Translated ['', 'src/mobile-pentesting/android-app-pentesting/avd-androi

src/mobile-pentesting/android-app-pentesting/README.md

@@ -1,10 +1,10 @@
-# Applicazioni Android Pentesting
+# Pentesting di Applicazioni Android
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Nozioni di base sulle Applicazioni Android
+## Fondamenti delle Applicazioni Android
 
-È altamente consigliato iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza Android e i componenti più pericolosi in un'applicazione Android**:
+It's highly recommended to start reading this page to know about the **most important parts related to Android security and the most dangerous components in an Android application**:
 
 
 {{#ref}}
@@ -13,14 +13,14 @@ android-applications-basics.md
 
 ## ADB (Android Debug Bridge)
 
-Questo è lo strumento principale che serve per connettersi a un dispositivo Android (emulato o fisico).\
-**ADB** permette di controllare i dispositivi sia tramite **USB** sia tramite **Network** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, l'**installazione** e la **disinstallazione** di app, l'**esecuzione** di comandi shell, il **backup** dei dati, la **lettura** dei log, tra le altre funzioni.
+Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo android (emulato o fisico).\
+**ADB** permette di controllare i dispositivi sia via **USB** che via **rete** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** dei dati, **lettura** dei log, tra le altre funzioni.
 
 Dai un'occhiata alla seguente lista di [**ADB Commands**](adb-commands.md) per imparare come usare adb.
 
 ## Smali
 
-A volte è interessante **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (ad esempio password ben offuscate o flag). In questo caso può essere utile decompilare l'apk, modificare il codice e ricompilarlo.\
+A volte è interessante **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (forse password ben offuscate o flag). In tal caso, può essere utile decompilare l'apk, modificare il codice e ricompilarlo.\
 [**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Questo può essere molto utile come **alternativa per diversi test durante l'analisi dinamica** che verranno presentati. Quindi, **tieni sempre presente questa possibilità**.
 
 ## Altri trucchi interessanti
@@ -30,7 +30,7 @@ A volte è interessante **modificare il codice dell'applicazione** per accedere
 - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
 - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md)
 - **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
-- Estrai APK dal dispositivo:
+- Estrarre l'APK dal dispositivo:
 ```bash
 adb shell pm list packages
 com.android.insecurebankv2
@@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 
 adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 ```
-- Unisci tutti i splits e gli apks base con [APKEditor](https://github.com/REAndroid/APKEditor):
+- Unisci tutti gli splits e i base apks con [APKEditor](https://github.com/REAndroid/APKEditor):
 ```bash
 mkdir splits
 adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
@@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
 # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
 java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 ```
-## Casi di studio e Vulnerabilità
+## Casi di studio & Vulnerabilità
 
 
 {{#ref}}
@@ -68,34 +68,34 @@ Per favore, [**leggi qui per trovare informazioni sui diversi decompiler disponi
 
 ### Ricerca di informazioni interessanti
 
-Solo dando un'occhiata alle **strings** dell'APK puoi cercare **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche code execution **backdoors** o authentication backdoors (hardcoded admin credentials nell'app).
+Bastano poche osservazioni delle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi elemento interessante... cerca anche eventuali **backdoor** di esecuzione di codice o backdoor di autenticazione (credenziali admin hardcoded nell'app).
 
 **Firebase**
 
-Presta particolare attenzione alle **Firebase URLs** e verifica se sono configurate in modo errato. [Maggiori informazioni su cos'è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Presta particolare attenzione agli **URL di Firebase** e verifica se è configurato male. [Maggiori informazioni su cos'è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
 ### Comprensione di base dell'applicazione - Manifest.xml, strings.xml
 
-L'**esame dei file _Manifest.xml_ e _strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza. Questi file possono essere ottenuti usando decompiler o rinominando l'estensione dell'APK in .zip e poi decomprimendolo.
+L'**esame del _Manifest.xml_ e dei file **_strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessi usando decompiler o rinominando l'estensione dell'APK in .zip e poi estraendolo.
 
-**Vulnerabilità** identificate dal **Manifest.xml** includono:
+Le **vulnerabilità** identificate dal **Manifest.xml** includono:
 
-- **Applicazioni debuggabili**: Le applicazioni impostate come debuggabili (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamento. Per capire come sfruttare applicazioni debuggabili, consulta un tutorial su come individuare e sfruttare applicazioni debuggabili su un dispositivo.
-- **Impostazioni di backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati via adb, specialmente quando il debug USB è abilitato.
-- **Network Security**: Le configurazioni personalizzate di network security (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pinning e impostazioni del traffico HTTP. Un esempio è consentire traffico HTTP per domini specifici.
-- **Attività e servizi esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere sfruttati. Un'ulteriore analisi durante i test dinamici può rivelare come sfruttare questi componenti.
-- **Content Providers e FileProviders**: Content provider esposti potrebbero permettere accesso non autorizzato o modifica dei dati. Anche la configurazione dei FileProvider dovrebbe essere esaminata attentamente.
-- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati, prestando particolare attenzione a come gli URL scheme sono gestiti riguardo alle vulnerabilità di input.
-- **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, sottolineando l'importanza di non supportare versioni Android obsolete e vulnerabili per ragioni di sicurezza.
+- **Debuggable Applications**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per capire meglio come sfruttare applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un dispositivo.
+- **Backup Settings**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando usb debugging è abilitato.
+- **Network Security**: Configurazioni di network security personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pins e impostazioni per il traffico HTTP. Un esempio è permettere traffico HTTP per domini specifici.
+- **Exported Activities and Services**: Identificare attività e servizi esportati nel manifest può mettere in evidenza componenti che potrebbero essere abusati. Un'analisi più approfondita durante i test dinamici può rivelare come sfruttare questi componenti.
+- **Content Providers and FileProviders**: I content provider esposti potrebbero consentire accesso o modifica non autorizzata dei dati. Anche la configurazione dei FileProvider dovrebbe essere scrupolosamente esaminata.
+- **Broadcast Receivers and URL Schemes**: Questi componenti potrebbero essere sfruttati per attacchi, prestando particolare attenzione a come gli schemi URL sono gestiti per possibili vulnerabilità di input.
+- **SDK Versions**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, sottolineando l'importanza di non supportare versioni Android obsolete e vulnerabili per ragioni di sicurezza.
 
-Dal file **strings.xml**, possono essere scoperte informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, sottolineando la necessità di una revisione accurata di queste risorse.
+Dal file **strings.xml**, possono emergere informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, evidenziando la necessità di una revisione attenta di queste risorse.
 
 ### Tapjacking
 
-**Tapjacking** è un attacco in cui una **applicazione malevola** 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 indurre l'utente a interagire con essa, mentre l'interazione viene inoltrata all'app vittima.\
-Di fatto, è **accecare l'utente impedendogli di rendersi conto che sta effettivamente eseguendo azioni sull'app vittima**.
+**Tapjacking** è un attacco dove una **malicious** **application** 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 inoltra l'interazione all'app vittima.\
+Di fatto, sta **accecando l'utente sul fatto che sta veramente eseguendo azioni sull'app vittima**.
 
-Find more information in:
+Trova più informazioni in:
 
 
 {{#ref}}
@@ -104,110 +104,110 @@ tapjacking.md
 
 ### Task Hijacking
 
-Un'attività con il `launchMode` impostato su `singleTask` senza alcun `taskAffinity` definito è vulnerabile al task Hijacking. Questo significa che un'applicazione può essere installata e, se avviata prima della vera applicazione, potrebbe dirottare il task della vera applicazione (così l'utente interagirà con l'app malevola pensando di usare quella reale).
+Un'**activity** con il **`launchMode`** impostato a **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al Task Hijacking. Questo significa che un'**application** può essere installata e, se lanciata prima della vera applicazione, potrebbe **hijackare il task dell'app reale** (quindi l'utente interagirà con la **malicious application pensando di usare quella reale**).
 
-More info in:
+Maggiori informazioni in:
 
 
 {{#ref}}
 android-task-hijacking.md
 {{#endref}}
 
-### Archiviazione dei dati insicura
+### Archiviazione dati insicura
 
 **Internal Storage**
 
-In Android, i file **memorizzati** nella **internal storage** sono progettati per essere accessibili esclusivamente dall'**app** che li ha creati. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **permettere** che i file siano **condivisi** tra diverse applicazioni. Queste modalità **non limitano l'accesso** a questi file da altre applicazioni, comprese quelle potenzialmente malevole.
+In Android, i file **memorizzati** in **internal** storage sono **progettati** per essere accessibili esclusivamente dall'**app** che li ha **creati**. Questa misura di sicurezza è **forzata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** che i file siano **condivisi** tra diverse applicazioni. Queste modalità **non limitano però l'accesso** a tali file da parte di altre applicazioni, incluse potenzialmente quelle maligne.
 
 1. **Analisi statica:**
-- **Verifica** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **attentamente esaminato**. Queste modalità **possono potenzialmente esporre** file ad **accessi non intenzionati o non autorizzati**.
+- **Verifica** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **accuratamente controllato**. Queste modalità **possono potenzialmente esporre** i file a **accessi non intenzionati o non autorizzati**.
 2. **Analisi dinamica:**
-- **Controlla** i **permessi** impostati sui file creati dall'app. In particolare, **verifica** se alcuni file sono impostati come leggibili o scrivibili da tutti. Questo può rappresentare un rischio significativo per la sicurezza, poiché permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intenzione, di **leggere o modificare** tali file.
+- **Controlla** i **permessi** impostati sui file creati dall'app. In particolare, **verifica** se alcuni file sono **impostati come leggibili o scrivibili da tutti**. Questo può rappresentare un rischio di sicurezza significativo, poiché permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intenzione, di **leggere o modificare** questi file.
 
 **External Storage**
 
-Quando si lavora con file su **external storage**, come SD Card, devono essere prese alcune precauzioni:
+Quando si trattano file su **external storage**, come le SD Card, vanno prese alcune precauzioni:
 
 1. **Accessibilità**:
-- I file su external storage sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
-2. **Problemi di sicurezza**:
+- I file su external storage sono **leggibili e scrivibili globalmente**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file.
+2. **Preoccupazioni di sicurezza**:
 - Data la facilità di accesso, è sconsigliato **memorizzare informazioni sensibili** su external storage.
 - L'external storage può essere rimosso o accessibile da qualsiasi applicazione, rendendolo meno sicuro.
-3. **Gestione dei dati dall'external storage**:
-- Esegui sempre **validazione degli input** sui dati recuperati dall'external storage. Questo è cruciale perché i dati provengono da una fonte non fidata.
-- È fortemente sconsigliato memorizzare eseguibili o file di classi su external storage per il caricamento dinamico.
-- Se la tua applicazione deve recuperare file eseguibili dall'external storage, assicurati che questi file siano **firmati e verificati criptograficamente** prima del caricamento dinamico. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione.
+3. **Gestione dei dati provenienti da external storage**:
+- Esegui sempre la **validazione dell'input** sui dati recuperati da external storage. Questo è cruciale perché i dati provengono da una fonte non attendibile.
+- È fortemente sconsigliato memorizzare eseguibili o class files su external storage per il caricamento dinamico.
+- Se la tua applicazione deve comunque recuperare file eseguibili da external storage, assicurati che tali file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità di sicurezza della tua applicazione.
 
-External storage può essere **acceduto** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
+External storage può essere **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
 
 > [!TIP]
-> A partire da Android 4.4 (**API 17**), la SD card ha una struttura di directory che limita l'accesso di un'app alla directory specifica per quell'app. Questo impedisce a un'applicazione malevola di ottenere accesso in lettura o scrittura ai file di un'altra app.
+> A partire da Android 4.4 (**API 17**), la SD card ha una struttura di directory che **limita l'accesso di un'app alla directory specificamente destinata a quell'app**. Questo previene che applicazioni maligne ottengano accesso in lettura o scrittura ai file di un'altra app.
 
 **Dati sensibili memorizzati in chiaro**
 
-- **Shared preferences**: Android permette a ogni applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e talvolta è possibile trovare informazioni sensibili in chiaro in quella cartella.
-- **Databases**: Android permette a ogni applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e talvolta è possibile trovare informazioni sensibili in chiaro in quella cartella.
+- **Shared preferences**: Android permette a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
+- **Databases**: Android permette a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
 
-### TLS rotto
+### Broken TLS
 
 **Accept All Certificates**
 
-Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, l'hostname non corrisponde, con righe di codice come la seguente:
+Per qualche motivo a volte gli sviluppatori accettano tutti i certificati anche se, per esempio, l'hostname non corrisponde, con righe di codice come le seguenti:
 ```java
 SSLSocketFactory sf = new cc(trustStore);
 sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
 ```
-Un buon modo per testare questo è provare a catturare il traffico usando un proxy come Burp senza autorizzare la Burp CA sul dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
+Un buon modo per testare questo è provare a catturare il traffico usando un proxy come Burp senza autorizzare Burp CA all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
 
-### Crittografia difettosa
+### Crittografia compromessa
 
-**Processi di gestione delle chiavi insufficienti**
+**Processi di gestione delle chiavi inadeguati**
 
-Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/predictable nel codice. Questo non dovrebbe essere fatto, perché del reversing potrebbe permettere agli attaccanti di estrarre le informazioni riservate.
+Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/predictable nel codice. Questo non dovrebbe essere fatto, poiché del reversing potrebbe permettere agli attackers di estrarre le informazioni riservate.
 
 **Uso di algoritmi insicuri e/o deprecati**
 
-Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per eseguire authorisation **checks**, **store** o **send** data. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se **hashes** sono usati per memorizzare le password per esempio, dovrebbero essere usati hash resistenti al brute-force con salt.
+Gli sviluppatori non dovrebbero usare **deprecated algorithms** per eseguire controlli di autorizzazione, per **store** o **send** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se vengono usati **hashes** per salvare le password, ad esempio, dovrebbero essere impiegati hashes resistenti al brute-force con salt.
 
 ### Altri controlli
 
-- È raccomandato di **obfuscate the APK** per rendere più difficile il lavoro di reverse engineering agli attaccanti.
-- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri controlli per verificare se il mobile è **rooted** e agire di conseguenza.
-- Se l'app è sensibile (come le app bancarie), dovrebbe verificare se viene usato un **emulator**.
-- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguirla** per verificare se è stata modificata.
+- È consigliato **obfuscate the APK** per rendere più difficile il lavoro di reverse engineer agli attackers.
+- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri controlli per verificare se il dispositivo è **rooted** e agire di conseguenza.
+- Se l'app è sensibile (come le app bancarie), dovrebbe verificare se è in uso un **emulator**.
+- Se l'app è sensibile (come le app bancarie), dovrebbe **check it's own integrity before executing** per verificare se è stata modificata.
 - Usa [**APKiD**](https://github.com/rednaga/APKiD) per verificare quale compiler/packer/obfuscator è stato usato per buildare l'APK
 
-### Applicazione React Native
+### React Native Application
 
-Leggi la pagina seguente per imparare come accedere facilmente al codice javascript delle applicazioni React:
+Leggi la pagina seguente per imparare come accedere facilmente al javascript delle applicazioni React:
 
 
 {{#ref}}
 react-native-application.md
 {{#endref}}
 
-### Applicazioni Xamarin
+### Xamarin Applications
 
-Leggi la pagina seguente per imparare come accedere facilmente al codice C# di applicazioni Xamarin:
+Leggi la pagina seguente per imparare come accedere facilmente al codice C# di un'applicazione xamarin:
 
 
 {{#ref}}
 ../xamarin-apps.md
 {{#endref}}
 
-### Applicazioni Superpacked
+### Superpacked Applications
 
-Secondo questo [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprima questo tipo di app... e di un metodo più veloce che consiste nell'**eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
+Secondo questo [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un singolo file. Il blog parla della possibilità di creare un'app che decomprima questo tipo di applicazioni... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
 
-### Analisi statica automatizzata del codice
+### Automated Static Code Analysis
 
-Lo strumento [**mariana-trench**](https://github.com/facebook/mariana-trench) è in grado di trovare **vulnerabilities** scansionando il **code** dell'applicazione. Questo tool contiene una serie di **known sources** (che indicano allo strumento i **places** dove l'**input** è **controlled by the user**), **sinks** (che indicano allo strumento **dangerous** **places** dove un input malevolo potrebbe causare danni) e **rules**. Queste regole indicano la **combinazione** di **sources-sinks** che segnala una vulnerabilità.
+Lo strumento [**mariana-trench**](https://github.com/facebook/mariana-trench) è in grado di trovare **vulnerabilities** scansionando il **code** dell'applicazione. Questo strumento contiene una serie di **known sources** (che indicano allo strumento i **places** dove l'**input** è **controlled by the user**), **sinks** (che indicano al tool i **dangerous** **places** dove l'input malevolo potrebbe causare danni) e **rules**. Queste regole indicano la **combination** di **sources-sinks** che segnala una vulnerabilità.
 
-Con queste informazioni, **mariana-trench analizzerà il codice e troverà possibili vulnerabilities su di esso**.
+Con questa conoscenza, **mariana-trench will review the code and find possible vulnerabilities on it**.
 
 ### Secrets leaked
 
-Un'applicazione può contenere segreti (API keys, passwords, hidden urls, subdomains...) al suo interno che potresti riuscire a scoprire. Puoi usare uno strumento come [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
+Un'applicazione può contenere secrets (API keys, password, hidden urls, subdomains...) al suo interno che potresti essere in grado di scoprire. Potresti usare uno strumento come [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
 
 ### Bypass Biometric Authentication
 
@@ -218,12 +218,12 @@ bypass-biometric-authentication-android.md
 
 ### Altre funzioni interessanti
 
-- **Esecuzione di codice**: `Runtime.exec(), ProcessBuilder(), native code:system()`
-- **Invio di SMS**: `sendTextMessage, sendMultipartTestMessage`
-- **Funzioni native** dichiarate come `native`: `public native, System.loadLibrary, System.load`
-- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md)
+- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
+- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
+- **Native functions** dichiarate come `native`: `public native, System.loadLibrary, System.load`
+- [Leggi questo per imparare **how to reverse native functions**](reversing-native-libraries.md)
 
-### **Altri trucchi**
+### **Other tricks**
 
 
 {{#ref}}
@@ -234,13 +234,13 @@ content-protocol.md
 
 ---
 
-## Analisi Dinamica
+## Dynamic Analysis
 
-> Prima di tutto, hai bisogno di un ambiente dove puoi installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer e Frida principalmente). Pertanto, è fortemente raccomandato un dispositivo rooted (emulato o meno).
+> Prima di tutto, ti serve un ambiente dove poter installare l'applicazione e tutta la configurazione (Burp CA cert, Drozer e Frida principalmente). Pertanto, un dispositivo rooted (emulato o no) è fortemente raccomandato.
 
-### Analisi dinamica online
+### Online Dynamic analysis
 
-Puoi creare un **account gratuito** su: [https://appetize.io/](https://appetize.io/). Questa piattaforma ti permette di **upload** e **execute** APKs, quindi è utile per vedere come si comporta un apk.
+Puoi creare un **free account** su: [https://appetize.io/](https://appetize.io). Questa piattaforma ti permette di **upload** e **execute** APK, quindi è utile per vedere come si comporta un apk.
 
 Puoi anche **vedere i log della tua applicazione** sul web e connetterti tramite **adb**.
 
@@ -248,11 +248,11 @@ Puoi anche **vedere i log della tua applicazione** sul web e connetterti tramite
 
 Grazie alla connessione ADB puoi usare **Drozer** e **Frida** all'interno degli emulatori.
 
-### Analisi dinamica locale
+### Local Dynamic Analysis
 
-#### Usare un emulatore
+#### Using an emulator
 
-- [**Android Studio**](https://developer.android.com/studio) (Puoi creare **x86** e **arm** devices, e secondo [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** senza bisogno di un emulatore arm lento).
+- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**le ultime versioni x86** supportano librerie **ARM** senza bisogno di un lento emulatore arm).
 - Impara a configurarlo in questa pagina:
 
 
@@ -260,122 +260,130 @@ Grazie alla connessione ADB puoi usare **Drozer** e **Frida** all'interno degli
 avd-android-virtual-device.md
 {{#endref}}
 
-- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Personal Edition, devi creare un account. _Si raccomanda di **download** la versione **WITH** _**VirtualBox** per evitare errori potenziali._)
-- [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer).
+- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, è necessario creare un account. _È raccomandato **download** la versione **WITH** _**VirtualBox** per evitare potenziali errori._)
+- [**Nox**](https://es.bignox.com) (Free, ma non supporta Frida o Drozer).
 
 > [!TIP]
-> Quando crei un nuovo emulatore su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile.
+> Quando crei un nuovo emulator su qualunque piattaforma ricorda che quanto più grande è lo schermo, tanto più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile.
 
-Per **install google services** (come AppStore) in Genymotion devi cliccare sul pulsante evidenziato in rosso nell'immagine seguente:
+Per **installare google services** (come AppStore) in Genymotion devi cliccare sul pulsante segnato in rosso nell'immagine seguente:
 
 ![](<../../images/image (277).png>)
 
-Inoltre, nota che nella **configurazione della Android VM in Genymotion** puoi selezionare la **Bridge Network mode** (questo sarà utile se ti connetterai alla Android VM da una VM diversa con gli strumenti).
+Inoltre, nota che nella **configurazione della VM Android in Genymotion** puoi selezionare la modalità **Bridge Network** (questo sarà utile se ti connetterai alla VM Android da una VM diversa con gli strumenti).
 
-#### Usare un dispositivo fisico
+#### Use a physical device
 
-Devi attivare le opzioni di **debugging** e sarebbe utile se riuscissi a **rootarlo**:
+Devi attivare le opzioni di **debugging** e sarebbe utile poterlo **root**:
 
 1. **Settings**.
-2. (Da Android 8.0) Seleziona **System**.
+2. (FromAndroid 8.0) Seleziona **System**.
 3. Seleziona **About phone**.
 4. Premi **Build number** 7 volte.
 5. Torna indietro e troverai le **Developer options**.
 
-> Una volta installata l'applicazione, la prima cosa da fare è provarla e indagare cosa fa, come funziona e familiarizzare con essa.\
-> Suggerisco di **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, così potremo **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito.
+> Una volta installata l'applicazione, la prima cosa che dovresti fare è provarla e investigare cosa fa, come funziona e prendere confidenza con essa.\
+> Suggerisco di **effettuare questa analisi dinamica iniziale usando MobSF dynamic analysis + pidcat**, così saremo in grado di **imparare come l'applicazione funziona** mentre MobSF **captures** molti dati **interessanti** che puoi rivedere più tardi.
+
+Magisk/Zygisk quick notes (raccomandato su dispositivi Pixel)
+- Patchare boot.img con l'app Magisk e flashare via fastboot per ottenere root systemless
+- Abilitare Zygisk + DenyList per nascondere il root; considera LSPosed/Shamiko quando è necessario un hiding più robusto
+- Conservare il boot.img originale per recuperare dopo gli OTA; ripatchare dopo ogni OTA
+- Per il mirroring dello schermo, usa scrcpy sull'host
+
+
 
 ### Unintended Data Leakage
 
 **Logging**
 
-Gli sviluppatori dovrebbero fare attenzione a esporre informazioni di **debugging** pubblicamente, poiché possono portare a leak di dati sensibili. Gli strumenti [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` sono raccomandati per monitorare i log dell'applicazione per identificare e proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità.
+Gli sviluppatori devono essere cauti nell'esporre informazioni di **debugging** pubblicamente, poiché ciò può portare a leak di dati sensibili. Gli strumenti [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` sono raccomandati per monitorare i log delle applicazioni e identificare/proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità.
 
 > [!WARNING]
-> Nota che da **versioni successive ad Android 4.0**, **le applicazioni possono accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\
-> Comunque, è sempre raccomandato di **non loggare informazioni sensibili**.
+> Nota che da **versioni successive a Android 4.0**, **le applicazioni possono accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\
+> Comunque, è sempre consigliato **non loggare informazioni sensibili**.
 
 **Copy/Paste Buffer Caching**
 
-Il framework **clipboard-based** di Android abilita la funzionalità copia-incolla nelle app, ma rappresenta un rischio poiché **altre applicazioni** possono **accedere** agli appunti, potenzialmente esponendo dati sensibili. È fondamentale **disabilitare le funzioni di copia/incolla** per sezioni sensibili dell'applicazione, come i dettagli della carta di credito, per prevenire leak di dati.
+Il framework basato sulla **clipboard** di Android abilita la funzionalità copy-paste nelle app, ma rappresenta un rischio in quanto **altre applicazioni** possono **accedere** alla clipboard, esponendo potenzialmente dati sensibili. È cruciale **disabilitare copy/paste** nelle sezioni sensibili di un'applicazione, come i dati della carta di credito, per prevenire leak.
 
 **Crash Logs**
 
-Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di loggare nei crash, e se i log devono essere trasmessi in rete, assicurati che siano inviati tramite un canale SSL per sicurezza.
+Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attackers, specialmente quando l'app non può essere reverse-engineerata. Per mitigare questo rischio, evitare di loggare sui crash e, se i log devono essere trasmessi in rete, assicurarsi che vengano inviati tramite un canale SSL per sicurezza.
 
 Come pentester, **cerca di dare un'occhiata a questi log**.
 
 **Analytics Data Sent To 3rd Parties**
 
-Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente causare leak di dati sensibili a causa di una cattiva implementazione da parte degli sviluppatori. Per identificare potenziali leak di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se informazioni sensibili vengono inviate a servizi di terze parti.
+Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente causare **leak di dati sensibili** a causa di un'implementazione scorretta degli sviluppatori. Per identificare potenziali leak di dati, è consigliabile **intercettare il traffico dell'applicazione** e verificare se informazioni sensibili vengono inviate a servizi di terze parti.
 
 ### SQLite DBs
 
-La maggior parte delle applicazioni userà **database SQLite interni** per salvare informazioni. Durante il pentest dai un'occhiata ai **databases** creati, ai nomi delle **tabelle** e **colonne** e a tutti i **dati** salvati perché potresti trovare **informazioni sensibili** (che costituirebbero una vulnerabilità).\
-I database dovrebbero essere localizzati in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases`
+La maggior parte delle applicazioni utilizzerà **database SQLite interni** per salvare informazioni. Durante il pentest controlla i **databases** creati, i nomi delle **tables** e delle **columns** e tutti i **data** salvati perché potresti trovare informazioni sensibili (che costituirebbero una vulnerabilità).\
+I database dovrebbero trovarsi in /data/data/the.package.name/databases come /data/data/com.mwr.example.sieve/databases
 
-Se il database salva informazioni confidenziali ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**.
+Se il database salva informazioni confidenziali ed è **encrypted** ma puoi **find** la **password** all'interno dell'applicazione è comunque una **vulnerability**.
 
-Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema <table_name>`
+Enumera le tabelle usando `.tables` ed enumera le colonne delle tabelle con `.schema <table_name>`
 
 ### Drozer (Exploit Activities, Content Providers and Services)
 
-Dalla [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** ti permette di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'applicazione installata può fare**, come fare uso del meccanismo di Inter-Process Communication (IPC) di Android e interagire con il sistema operativo sottostante.\
-Drozer è uno strumento utile per **exploit exported activities, exported services and Content Providers** come imparerai nelle sezioni seguenti.
+Dai [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permette di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'app installata può fare**, come utilizzare il meccanismo IPC di Android e interagire con il sistema operativo sottostante. .\
+Drozer è uno strumento utile per **exploitare exported activities, exported services e Content Providers** come imparerai nelle sezioni seguenti.
 
-### Sfruttare le exported Activities
+### Exploiting exported Activities
 
 [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
-Ricorda inoltre che il codice di un'activity inizia nel metodo **`onCreate`**.
+Ricorda inoltre che il codice di un'attività inizia nel metodo **`onCreate`**.
 
 **Authorisation bypass**
 
-Quando un'Activity è exported puoi invocarne la schermata da un'app esterna. Pertanto, se un'activity con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **autenticazione** per **accedervi.**
+Quando un'Activity è exported puoi invocare la sua schermata da un'app esterna. Pertanto, se un'activity con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **authentication** per accedervi.
 
 [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
 
-Puoi anche avviare un'activity exported tramite adb:
+Puoi anche avviare un'activity exported da adb:
 
 - PackageName is com.example.demo
 - Exported ActivityName is com.example.test.MainActivity
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
-**NOTA**: MobSF rileverà come malevolo l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'activity, ma a causa di [questo](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su versioni vecchie (API versions < 21).
+**NOTE**: MobSF rileverà come dannoso l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'activity, ma a causa di [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su vecchie versioni (API versions < 21).
 
 > [!TIP]
-> Nota che un bypass di autorizzazione non è sempre una vulnerabilità; dipende da come funziona il bypass e quali informazioni vengono esposte.
+> Nota che un authorisation bypass non è sempre una vulnerabilità: dipende da come il bypass funziona e quali informazioni vengono esposte.
 
-**Perdita di informazioni sensibili**
+**Sensitive information leakage**
 
-**Le Activity possono anche restituire risultati**. Se riesci a trovare un'activity esportata e non protetta che chiama il metodo **`setResult`** e **restituisce informazioni sensibili**, c'è una perdita di informazioni sensibili.
+**Activities can also return results**. Se riesci a trovare un'activity esportata e non protetta che invoca il metodo **`setResult`** e **restituisce informazioni sensibili**, si verifica una sensitive information leakage.
 
 #### Tapjacking
 
-Se il Tapjacking non è prevenuto, potresti abusare dell'activity esportata per far eseguire all'utente **azioni inaspettate**. Per maggiori informazioni su [**cos'è Tapjacking segui il link**](#tapjacking).
+Se il Tapjacking non è prevenuto, potresti abusare dell'activity esportata per far eseguire all'**user azioni inaspettate**. Per maggiori informazioni su [**cos'è Tapjacking segui il link**](#tapjacking).
 
 ### Exploiting Content Providers - Accessing and manipulating sensitive information
 
-[**Leggi questo se vuoi rinfrescare cos'è un Content Provider.**](android-applications-basics.md#content-provider)\
-I Content Provider sono fondamentalmente usati per **condividere dati**. Se un'app ha content provider disponibili potresti essere in grado di **estrarre dati sensibili** da essi. È anche interessante testare possibili **SQL injections** e **Path Traversals** poiché potrebbero essere vulnerabili.
+[**Leggi questo se vuoi rinfrescare cosa sia un Content Provider.**](android-applications-basics.md#content-provider)\
+I Content providers sono fondamentalmente usati per **condividere dati**. Se un'app ha content providers disponibili potresti essere in grado di **estrarre dati sensibili** da essi. È inoltre interessante testare possibili **SQL injections** e **Path Traversals**, poiché potrebbero essere vulnerabili.
 
 [**Scopri come sfruttare i Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers)
 
 ### **Exploiting Services**
 
-[**Leggi questo se vuoi rinfrescare cos'è un Service.**](android-applications-basics.md#services)\
+[**Leggi questo se vuoi rinfrescare cosa sia un Service.**](android-applications-basics.md#services)\
 Ricorda che le azioni di un Service iniziano nel metodo `onStartCommand`.
 
-Un Service è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione espone dei service dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\
+Un Service è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione esporta dei Service dovresti **controllare** il **codice** per capire cosa fa e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassing le misure di autenticazione...\
 [**Scopri come sfruttare i Service con Drozer.**](drozer-tutorial/index.html#services)
 
 ### **Exploiting Broadcast Receivers**
 
-[**Leggi questo se vuoi rinfrescare cos'è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
+[**Leggi questo se vuoi rinfrescare cosa sia un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
 Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`.
 
-Un Broadcast Receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\
-[**Scopri come sfruttare i Broadcast Receiver con Drozer.**](#exploiting-broadcast-receivers)
+Un Broadcast Receiver rimarrà in attesa di un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\
+[**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)
 
 ### **Exploiting Schemes / Deep links**
 
@@ -399,50 +407,50 @@ Per trovare il **codice che verrà eseguito nell'App**, vai all'activity chiamat
 
 **Informazioni sensibili**
 
-Ogni volta che trovi un deep link verifica che **non stia ricevendo dati sensibili (come passwords) tramite parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonate the deep link and steal that data!**
+Ogni volta che trovi un deep link verifica che **non stia ricevendo dati sensibili (come password) tramite i parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonare il deep link e rubare quei dati!**
 
-**Parameters in path**
+**Parametri nel path**
 
-Devi anche verificare se un deep link sta usando un parametro all'interno del path dell'URL come: `https://api.example.com/v1/users/{username}` , in tal caso puoi forzare un path traversal accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
-Nota che se trovi gli endpoint corretti all'interno dell'applicazione potresti essere in grado di causare un **Open Redirect** (se parte del path è usata come domain name), **account takeover** (se puoi modificare i dettagli degli utenti senza token CSRF e l'endpoint vuln usa il metodo corretto) e qualsiasi altra vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
+Devi anche verificare se un deep link sta usando un parametro dentro il path dell'URL come: `https://api.example.com/v1/users/{username}` , in tal caso puoi forzare un path traversal accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
+Nota che se trovi gli endpoint corretti dentro l'applicazione potresti essere in grado di causare un **Open Redirect** (se parte del path è usata come nome di dominio), **account takeover** (se puoi modificare i dettagli degli utenti senza token CSRF e l'endpoint vulnerabile usa il metodo corretto) e qualsiasi altra vuln. Maggiori [info su questo qui](http://dphoeniixx.com/2020/12/13-2/).
 
-**More examples**
+**Altri esempi**
 
-Un [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
+Un [interessante bug bounty report](https://hackerone.com/reports/855618) sui link (_/.well-known/assetlinks.json_).
 
-### Transport Layer Inspection and Verification Failures
+### Ispezione del livello di trasporto e fallimenti di verifica
 
-- **Certificates are not always inspected properly** by Android applications. È comune che queste applicazioni ignorino gli avvisi e accettino certificati self-signed o, in alcuni casi, tornino a utilizzare connessioni HTTP.
-- **Negotiations during the SSL/TLS handshake are sometimes weak**, impiegando cipher suites non sicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), permettendo agli attaccanti di decrittare i dati.
-- **Leakage of private information** è un rischio quando le applicazioni si autenticano usando canali sicuri ma poi comunicano su canali non sicuri per altre transazioni. Questo approccio non protegge i dati sensibili, come session cookies o dettagli utente, dall'intercettazione da parte di entità malintenzionate.
+- **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni ignorino gli avvisi e accettino certificati self-signed o, in alcuni casi, tornino a usare connessioni HTTP.
+- **Le negoziazioni durante l'handshake SSL/TLS sono a volte deboli**, impiegando cipher suite insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), permettendo agli attaccanti di decriptare i dati.
+- **Perdita di informazioni private** è un rischio quando le applicazioni si autenticano usando canali sicuri ma poi comunicano su canali non sicuri per altre transazioni. Questo approccio non protegge i dati sensibili, come cookie di sessione o dettagli utente, dall'intercettazione da parte di entità malevole.
 
-#### Certificate Verification
+#### Verifica del certificato
 
-Ci concentreremo sulla **certificate verification**. L'integrità del certificato del server deve essere verificata per aumentare la sicurezza. Questo è cruciale perché configurazioni TLS insicure e la trasmissione di dati sensibili su canali non cifrati possono rappresentare rischi significativi. Per passaggi dettagliati su come verificare i certificati server e risolvere le vulnerabilità, [**questa risorsa**](https://manifestsecurity.com/android-application-security-part-10/) fornisce una guida completa.
+Ci concentreremo sulla **verifica del certificato**. L'integrità del certificato del server deve essere verificata per migliorare la sicurezza. Questo è cruciale perché configurazioni TLS insicure e la trasmissione di dati sensibili su canali non cifrati possono comportare rischi significativi. Per passaggi dettagliati sulla verifica dei certificati server e la risoluzione delle vulnerabilità, [**questa risorsa**](https://manifestsecurity.com/android-application-security-part-10/) fornisce linee guida complete.
 
 #### SSL Pinning
 
-SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certificato del server rispetto a una copia nota memorizzata all'interno dell'app stessa. Questo metodo è essenziale per prevenire attacchi MITM. Implementare SSL Pinning è fortemente raccomandato per applicazioni che gestiscono informazioni sensibili.
+Lo **SSL Pinning** è una misura di sicurezza in cui l'applicazione verifica il certificato del server rispetto a una copia nota memorizzata all'interno dell'app stessa. Questo metodo è essenziale per prevenire attacchi MITM. Implementare SSL Pinning è fortemente raccomandato per applicazioni che gestiscono informazioni sensibili.
 
-#### Traffic Inspection
+#### Ispezione del traffico
 
-Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida su come installare un certificato CA personalizzato, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Per ispezionare il traffico HTTP è necessario **installare il certificato dello strumento proxy** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida sull'installazione di un certificato CA custom, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
-Le applicazioni che targettizzano **API Level 24 and above** richiedono modifiche al Network Security Config per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare il Network Security Config, [**consulta questo tutorial**](make-apk-accept-ca-certificate.md).
+Le applicazioni targettizzate per **API Level 24 and above** richiedono modifiche alla Network Security Config per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare la Network Security Config, [**consulta questo tutorial**](make-apk-accept-ca-certificate.md).
 
-Se viene usato **Flutter** devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché aggiungere semplicemente il certificato nello store non funzionerà poiché Flutter ha la propria lista di CA valide.
+Se viene usato **Flutter** devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, semplicemente aggiungendo il certificato nello store non funzionerà dato che Flutter ha la sua propria lista di CA valide.
 
-#### Static detection of SSL/TLS pinning
+#### Rilevamento statico dello SSL/TLS pinning
 
-Prima di tentare bypass runtime, mappa rapidamente dove il pinning è applicato nell'APK. La scoperta statica ti aiuta a pianificare hook/patch e a concentrarti sui corretti code paths.
+Prima di tentare bypass a runtime, mappa rapidamente dove il pinning è applicato nell'APK. La scoperta statica ti aiuta a pianificare hook/patch e a concentrarti sui percorsi di codice corretti.
 
 Tool: SSLPinDetect
-- Utility open-source di static-analysis che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati di implementazioni di pinning SSL/TLS.
-- Riporta il file path esatto, il numero di linea e uno snippet di codice per ogni match.
-- Copre framework comuni e code path custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, e pin nel Network Security Config XML.
+- Utilità open-source di static-analysis che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati per implementazioni di SSL/TLS pinning.
+- Riporta il percorso file esatto, il numero di riga e un estratto di codice per ogni corrispondenza.
+- Copre framework comuni e percorsi di codice custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init con custom TrustManagers/KeyManagers, e pin in Network Security Config XML.
 
-Installazione
-- Prerequisiti: Python >= 3.8, Java on PATH, apktool
+Install
+- Prereqs: Python >= 3.8, Java on PATH, apktool
 ```bash
 git clone https://github.com/aancw/SSLPinDetect
 cd SSLPinDetect
@@ -456,8 +464,8 @@ python sslpindetect.py -f app.apk -a apktool.jar
 # Verbose (timings + per-match path:line + snippet)
 python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
 ```
-Esempio di regole di pattern (JSON)
-Usa o estendi le signatures per rilevare stili di pinning proprietari/custom. Puoi caricare il tuo JSON e eseguire scan su larga scala.
+Esempi di regole di pattern (JSON)
+Usa o estendi le signatures per rilevare stili di pinning proprietari/custom. Puoi caricare il tuo JSON ed effettuare scan su larga scala.
 ```json
 {
 "OkHttp Certificate Pinning": [
@@ -471,43 +479,43 @@ Usa o estendi le signatures per rilevare stili di pinning proprietari/custom. Pu
 ]
 }
 ```
-Note e consigli
-- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives.
+Note e suggerimenti
+- Scansione veloce di app di grandi dimensioni tramite multi-threading e memory-mapped I/O; regex precompilate riducono overhead/falsi positivi.
 - Pattern collection: https://github.com/aancw/smali-sslpin-patterns
-- Typical detection targets to triage next:
-- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
-- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
-- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
-- Declarative pins in res/xml network security config and manifest references
-- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing.
+- Obiettivi tipici di rilevamento da valutare successivamente:
+- OkHttp: uso di CertificatePinner, setCertificatePinner, riferimenti ai package okhttp3/okhttp
+- TrustManagers personalizzati: javax.net.ssl.X509TrustManager, override di checkServerTrusted
+- Contesti SSL personalizzati: SSLContext.getInstance + SSLContext.init con manager personalizzati
+- Pin dichiarativi in res/xml network security config e riferimenti nel manifest
+- Usa le posizioni corrispondenti per pianificare Frida hooks, patch statiche, o revisioni di config prima dei test dinamici.
 
 
 
-#### Bypass SSL Pinning
+#### Bypassare SSL Pinning
 
-Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili diversi metodi per questo scopo:
+Quando SSL Pinning è implementato, diventa necessario bypassarlo per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo:
 
-- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
-- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
-- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
-- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below)
-- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
+- Modifica automaticamente l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il principale vantaggio di questa opzione è che non servirà root per bypassare lo SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare la nuova, e questo non funziona sempre.
+- Puoi usare **Frida** (discusso sotto) per bypassare questa protezione. Qui c'è una guida per usare Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
+- Puoi anche provare a bypassare automaticamente SSL Pinning usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
+- Puoi anche provare a bypassare automaticamente SSL Pinning usando **MobSF dynamic analysis** (spiegato sotto)
+- Se pensi che ci sia traffico che non stai catturando puoi provare a **inoltrare il traffico a burp usando iptables**. Leggi questo blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
 
-#### Looking for Common Web Vulnerabilities
+#### Ricerca di vulnerabilità web comuni
 
-È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate sull'identificazione e la mitigazione di queste vulnerabilità sono oltre lo scopo di questo sommario ma sono ampiamente trattate altrove.
+È importante cercare anche le comuni vulnerabilità web all'interno dell'applicazione. Informazioni dettagliate sull'identificazione e la mitigazione di queste vulnerabilità sono oltre lo scopo di questo riassunto ma sono trattate estensivamente altrove.
 
 ### Frida
 
-[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, analisti di reverse engineering e ricercatori di sicurezza.\
-**Puoi accedere all'applicazione in esecuzione e hook methods on run time to change the behaviour, change values, extract values, run different code...**\
-Se vuoi fare pentest di applicazioni Android devi sapere come usare Frida.
+[Frida](https://www.frida.re) è un toolkit di instrumentazione dinamica per sviluppatori, reverse-engineer e ricercatori di sicurezza.\
+**Puoi accedere all'applicazione in esecuzione e hookare metodi a runtime per cambiare il comportamento, modificare valori, estrarre valori, eseguire codice diverso...**\
+Se vuoi fare pentesting su applicazioni Android devi sapere come usare Frida.
 
-- Impara come usare Frida: [**Frida tutorial**](frida-tutorial/index.html)
-- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
-- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
-- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
-- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
+- Impara a usare Frida: [**Frida tutorial**](frida-tutorial/index.html)
+- Alcune "GUI" per le azioni con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- Ojection è ottimo per automatizzare l'uso di Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
+- Puoi trovare alcuni script Awesome Frida qui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
+- Prova a bypassare meccanismi anti-debugging / anti-frida caricando Frida come indicato in [https://erfur.github.io/blog/dev/code-injection-without-ptrace] (tool [linjector](https://github.com/erfur/linjector-rs))
 
 #### Anti-instrumentation & SSL pinning bypass workflow
 
@@ -517,9 +525,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md
 
 ### **Dump della memoria - Fridump**
 
-Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemonics.
+Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe contenere, come password o mnemonic.
 
-Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi eseguire il dump della memoria dell'app con:
+Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi dumpare la memoria dell'app con:
 ```bash
 # With PID
 python3 fridump3.py -u <PID>
@@ -528,120 +536,120 @@ python3 fridump3.py -u <PID>
 frida-ps -Uai
 python3 fridump3.py -u "<Name>"
 ```
-Questo eseguirà il dump della memoria nella cartella ./dump, e lì puoi usare grep con qualcosa del tipo:
+Questo scaricherà la memoria nella cartella ./dump, e lì puoi usare grep con qualcosa del tipo:
 ```bash
 strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
 ```
 ### **Dati sensibili nel Keystore**
 
-In Android il Keystore è il posto migliore per memorizzare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentest dovrebbero verificarne la presenza in quanto un utente root o qualcuno con accesso fisico al dispositivo potrebbe essere in grado di rubare questi dati.
+Su Android il Keystore è il posto migliore per memorizzare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentests dovrebbero verificarne la presenza come root user oppure qualcuno con accesso fisico al dispositivo potrebbe essere in grado di rubare questi dati.
 
-Anche se un'app memorizza dati nel keystore, i dati dovrebbero essere crittografati.
+Anche se un'app memorizzasse dati nel Keystore, i dati dovrebbero essere cifrati.
 
-Per accedere ai dati all'interno del keystore puoi usare questo script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
+Per accedere ai dati all'interno del Keystore puoi usare questo Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
 ```bash
 frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
 ```
 ### **Fingerprint/Biometrics Bypass**
 
-Usando il seguente script Frida potrebbe essere possibile **bypass fingerprint authentication** che le applicazioni Android potrebbero eseguire per **proteggere alcune aree sensibili:**
+Utilizzando il seguente script Frida potrebbe essere possibile eseguire un **bypass fingerprint authentication** che le applicazioni Android potrebbero adottare per **proteggere alcune aree sensibili:**
 ```bash
 frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
 ```
 ### **Immagini di sfondo**
 
-Quando metti un'applicazione in background, Android memorizza una **istantanea dell'applicazione** così quando viene riportata in primo piano inizia a caricare l'immagine prima dell'app in modo che sembri che l'app sia stata caricata più velocemente.
+Quando mandi un'applicazione in background, Android salva una **istantanea dell'applicazione** così quando viene ripristinata in primo piano inizia a caricare l'immagine prima dell'app, dando l'impressione che l'app si sia caricata più velocemente.
 
-Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare queste informazioni** (nota che è necessario avere i permessi di root per accedervi).
+Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare quelle informazioni** (nota: è necessario il root per accedervi).
 
 Le istantanee sono solitamente memorizzate in: **`/data/system_ce/0/snapshots`**
 
-Android fornisce un modo per **impedire la cattura dello screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, impedendone l'apparizione negli screenshot o la visualizzazione su display non sicuri.
+Android fornisce un modo per **impedire la cattura dello screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, impedendone la comparsa negli screenshot o la visualizzazione su display non sicuri.
 ```bash
 getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
 ### **Android Application Analyzer**
 
-Questo strumento può aiutarti a gestire diversi tool durante l'analisi dinamica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+This tool could help you managing different tools during the dynamic analysis: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Intent Injection
 
-Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky.
+Gli sviluppatori spesso creano proxy components come activities, services, e broadcast receivers che gestiscono questi Intents e li passano a metodi come `startActivity(...)` o `sendBroadcast(...)`, il che può essere rischioso.
 
-Il pericolo consiste nel permettere a malintenzionati di attivare componenti dell'app non-exported o accedere a content provider sensibili deviando questi Intent. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` e poi li esegue, potenzialmente portando a iniezioni di Intent malevoli.
+Il pericolo sta nel permettere ad un attacker di triggerare componenti dell'app non-exported o accedere a content providers sensibili deviando questi Intents. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` e poi li esegue, potenzialmente portando a malicious Intent injections.
 
 ### Essential Takeaways
 
-- **Intent Injection** è simile al problema Open Redirect del web.
-- Gli exploit comportano il passaggio di oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure.
-- Può esporre componenti non-exported e content provider a malintenzionati.
-- La conversione da URL a `Intent` di `WebView` può facilitare azioni non intenzionali.
+- **Intent Injection** is similar to web's Open Redirect issue.
+- Exploits involve passing `Intent` objects as extras, which can be redirected to execute unsafe operations.
+- It can expose non-exported components and content providers to attackers.
+- `WebView`’s URL to `Intent` conversion can facilitate unintended actions.
 
-### Iniezioni lato client Android e altri
+### Android Client Side Injections and others
 
-Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi prestare particolare attenzione a queste vulnerabilità in un'app Android:
+Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere particolarmente attento a queste vulnerabilità in un'app Android:
 
-- **SQL Injection:** Quando si gestiscono query dinamiche o Content-Providers assicurati di usare query parametrizzate.
-- **JavaScript Injection (XSS):** Verifica che il supporto a JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato di default). [More info here](webview-attacks.md#javascript-enabled).
-- **Local File Inclusion:** I WebView dovrebbero avere l'accesso al file system disabilitato (abilitato di default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
-- **Eternal cookies**: In diversi casi quando l'app Android termina la sessione il cookie non viene revocato o può essere persino salvato su disco
+- **SQL Injection:** When dealing with dynamic queries or Content-Providers ensure you are using parameterized queries.
+- **JavaScript Injection (XSS):** Verify that JavaScript and Plugin support is disabled for any WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled).
+- **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
+- **Eternal cookies**: In several cases when the Android application finish the session the cookie isn't revoked or it could be even saved to disk
 - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
 
-## Analisi automatica
+## Automatic Analysis
 
 ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
 
-**Analisi statica**
+**Static analysis**
 
 ![](<../../images/image (866).png>)
 
-**Valutazione delle vulnerabilità dell'applicazione** usando una gradevole interfaccia web. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
+**Vulnerability assessment of the application** using a nice web-based frontend. You can also perform dynamic analysis (but you need to prepare the environment).
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf
 docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
 ```
 Nota che MobSF può analizzare **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Le applicazioni Windows devono essere analizzate da un MobSF installato su un host Windows_).\
-Inoltre, se crei un file **ZIP** con il codice sorgente di un'app **Android** o **IOS** (vai nella cartella root dell'applicazione, seleziona tutto e crea un ZIPfile), sarà in grado di analizzarlo.
+Inoltre, se crei un file **ZIP** con il codice sorgente di un'app **Android** o un'app **IOS** (vai alla cartella root dell'applicazione, seleziona tutto e crea un file ZIP), sarà in grado di analizzarlo anche.
 
-MobSF permette anche di fare il **diff/Compare** delle analisi e di integrare **VirusTotal** (dovrai impostare la tua API key in _MobSF/settings.py_ e abilitarla: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` a `False`, allora l'**hash** sarà **upload** invece del file.
+MobSF permette anche di fare il **diff/Compare** delle analisi e di integrare **VirusTotal** (dovrai impostare la tua API key in _MobSF/settings.py_ e abilitarla: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` su `False`, in tal caso verrà caricato l'**hash** invece del file.
 
-### Analisi dinamica assistita con MobSF
+### Assisted Dynamic analysis with MobSF
 
-**MobSF** può essere molto utile anche per la **dynamic analysis** su **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **start first a VM in genymotion** e **then MobSF.**_\
-Il **MobSF dynamic analyser** può:
+**MobSF** può essere molto utile anche per l'analisi dinamica su **Android**, ma in questo caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: devi **avviare prima una VM in genymotion** e **poi MobSF.**_\  
+L'analizzatore dinamico di **MobSF** può:
 
-- **Dump application data** (URLs, logs, clipboard, screenshots fatte da te, screenshots fatte da "**Exported Activity Tester**", email, SQLite databases, XML files, e altri file creati). Tutto questo viene fatto automaticamente eccetto gli screenshot: per gli screenshot devi premere quando vuoi catturarne uno oppure devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
-- Catturare il **HTTPS traffic**
-- Usare **Frida** per ottenere informazioni a runtime
+- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Tutto questo viene fatto automaticamente eccetto per gli screenshot: devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere gli screenshot di tutte le attività esportate.
+- Capture **HTTPS traffic**
+- Use **Frida** to obtain **runtime** **information**
 
-Dalle **versioni di Android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per catturare il traffico. Catturerà solo il traffico dell'applicazione testata.
+Dalle versioni Android > 5, avvierà automaticamente Frida e imposterà il proxy globale per catturare il traffico. Catturerà solo il traffico dell'applicazione testata.
 
 **Frida**
 
-Di default userà anche alcuni Frida Scripts per **bypass SSL pinning**, **root detection** e **debugger detection** e per **monitor interesting APIs**.\
-MobSF può anche **invoke exported activities**, catturare **screenshots** di esse e **save**le per il report.
+Di default, utilizzerà anche alcuni Frida Scripts per bypassare SSL pinning, root detection e debugger detection e per monitorare API interessanti.\
+MobSF può anche invocare exported activities, catturare screenshot di esse e salvarli per il report.
 
-Per **start** il testing dinamico premi il bottone verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocation ai metodi hooked, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
-MobSF permette anche di caricare i tuoi **Frida scripts** (per inviare i risultati dei tuoi Frida scripts a MobSF usa la funzione `send()`). Ha anche **several pre-written scripts** che puoi caricare (puoi aggiungerne altri in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **select them**, premere "**Load**" e premere "**Start Instrumentation**" (potrai vedere i log di quegli script dentro "**Frida Live Logs**").
+Per **avviare** il testing dinamico premi il bottone verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocazioni ai metodi hooked, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
+MobSF permette anche di caricare i tuoi **Frida scripts** (per inviare i risultati dei tuoi Frida scripts a MobSF usa la funzione `send()`). Ha anche **diversi script pre-scritti** che puoi caricare (puoi aggiungerne altri in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selezionarli**, premere "**Load**" e poi "**Start Instrumentation**" (potrai vedere i log di quegli script dentro "**Frida Live Logs**").
 
 ![](<../../images/image (419).png>)
 
 Inoltre, hai alcune funzionalità ausiliarie di Frida:
 
-- **Enumerate Loaded Classes**: Stamperà tutte le classi caricate
-- **Capture Strings**: Stamperà tutte le stringhe catturate mentre usi l'applicazione (molto noisy)
+- **Enumerate Loaded Classes**: Mostrerà tutte le classi caricate
+- **Capture Strings**: Mostrerà tutte le stringhe catturate mentre usi l'applicazione (molto rumoroso)
 - **Capture String Comparisons**: Può essere molto utile. Mostrerà le 2 stringhe confrontate e se il risultato è True o False.
-- **Enumerate Class Methods**: Inserisci il nome della classe (come "java.io.File") e stamperà tutti i metodi della classe.
+- **Enumerate Class Methods**: Inserisci il nome della classe (come "java.io.File") e mostrerà tutti i metodi della classe.
 - **Search Class Pattern**: Cerca classi per pattern
-- **Trace Class Methods**: **Trace** un'intera classe (vedi input e output di tutti i metodi della classe). Ricorda che di default MobSF traccia diversi metodi interessanti delle Android Api.
+- **Trace Class Methods**: Traccia un'intera classe (vedi input e output di tutti i metodi della classe). Ricorda che di default MobSF traccia diversi metodi interessanti delle Android API.
 
-Una volta selezionato il modulo ausiliario che vuoi usare devi premere "**Start Intrumentation**" e vedrai tutti gli output in "**Frida Live Logs**".
+Una volta selezionato il modulo ausiliario che vuoi utilizzare devi premere "**Start Intrumentation**" e vedrai tutti gli output in "**Frida Live Logs**".
 
 **Shell**
 
-MobSF offre anche una shell con alcuni comandi **adb**, **MobSF commands**, e comuni **shell** **commands** in fondo alla pagina di dynamic analysis. Alcuni comandi interessanti:
+MobSF fornisce anche una shell con alcuni comandi **adb**, comandi MobSF, e comandi di shell comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti:
 ```bash
 help
 shell ls
@@ -652,13 +660,13 @@ receivers
 ```
 **Strumenti HTTP**
 
-Quando il traffico http viene catturato puoi vedere una vista brutta del traffico catturato sul pulsante "**HTTP(S) Traffic**" in basso oppure una vista più pulita nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\
-Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la request_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
+Quando il traffico http viene catturato puoi vedere una visualizzazione brutta del traffico catturato nel pulsante "**HTTP(S) Traffic**" oppure una visualizzazione migliore nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\
+Per fare ciò, _avvia Burp -->_ _disabilita Intercept --> in MobSB HTTPTools seleziona la richiesta_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
-Una volta terminata l'analisi dinamica con MobSF puoi premere su "**Start Web API Fuzzer**" per **fuzz http requests** e cercare vulnerabilità.
+Una volta terminata la dynamic analysis con MobSF puoi premere "**Start Web API Fuzzer**" per **fuzz http requests** e cercare vulnerabilità.
 
 > [!TIP]
-> Dopo aver eseguito un'analisi dinamica con MobSF le impostazioni del proxy potrebbero essere mal configurate e potresti non riuscire a correggerle dall'interfaccia. Puoi correggere le impostazioni del proxy eseguendo:
+> Dopo aver eseguito una dynamic analysis con MobSF le impostazioni del proxy potrebbero essere mal configurate e potresti non riuscire a correggerle dalla GUI. Puoi ripristinare le impostazioni del proxy eseguendo:
 >
 > ```
 > adb shell settings put global http_proxy :0
@@ -666,18 +674,18 @@ Una volta terminata l'analisi dinamica con MobSF puoi premere su "**Start Web AP
 
 ### Assisted Dynamic Analysis with Inspeckage
 
-Puoi ottenere lo strumento da [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
-Questo tool utilizza alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**.
+You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
+Questo strumento utilizza alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui una **dynamic analysis**.
 
 ### [Yaazhini](https://www.vegabird.com/yaazhini/)
 
-Questo è un **ottimo strumento per eseguire analisi statica con una GUI**
+This is a **great tool to perform static analysis with a GUI**
 
 ![](<../../images/image (741).png>)
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Questo tool è progettato per cercare diverse **vulnerabilità delle applicazioni Android legate alla security**, sia nel **source code** sia negli **APKs** confezionati. Lo strumento è inoltre **in grado di creare un APK deployable "Proof-of-Concept"** e **ADB commands**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario effettuare il root del dispositivo di test.
+This tool is designed to look for several **security related Android application vulnerabilities**, either in **source code** or **packaged APKs**. The tool is also **capable of creating a "Proof-of-Concept" deployable APK** and **ADB commands**, to exploit some of the found vulnerabilities (Exposed activities, intents, tapjacking...). As with Drozer, there is no need to root the test device.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -686,10 +694,10 @@ qark --java path/to/specific/java/file.java
 ```
 ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
 
-- Mostra tutti i file estratti per un facile riferimento
-- Decompila automaticamente gli APK in formato Java e Smali
-- Analizza AndroidManifest.xml per vulnerabilità comuni e comportamento
-- Analisi statica del codice sorgente per vulnerabilità comuni e comportamento
+- Mostra tutti i file estratti per riferimento rapido
+- Decompila automaticamente file APK in formato Java e Smali
+- Analizza AndroidManifest.xml per vulnerabilità e comportamenti comuni
+- Analisi statica del codice sorgente per vulnerabilità e comportamenti comuni
 - Informazioni sul dispositivo
 - e altro
 ```bash
@@ -697,11 +705,11 @@ reverse-apk relative/path/to/APP.apk
 ```
 ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
 
-SUPER è un'applicazione da riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevarle.
+SUPER è un'applicazione da riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare queste vulnerabilità.
 
 Tutte le regole sono raccolte in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui ha bisogno.
 
-Scarica gli ultimi binari dalla [download page](https://superanalyzer.rocks/download.html)
+Scarica i binari più recenti dalla [download page](https://superanalyzer.rocks/download.html)
 ```
 super-analyzer {apk_file}
 ```
@@ -709,17 +717,17 @@ super-analyzer {apk_file}
 
 ![](<../../images/image (297).png>)
 
-StaCoAn è uno strumento **multipiattaforma** che aiuta sviluppatori, bugbounty hunters e ethical hackers nello svolgimento di [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobile.
+StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, bugbounty hunters e ethical hackers nello svolgere [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili.
 
-Il concetto è che trascini e rilasci il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e questo genererà per te un report visuale e portatile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata.
+Il concetto è che trascini e rilasci il file della tua applicazione mobile (un file .apk o .ipa) nell'applicazione StaCoAn e otterrai un report visuale e portatile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata.
 
-Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases):
+Download[ latest release](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ./stacoan
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-AndroBugs Framework è un sistema di analisi delle vulnerabilità per Android che aiuta sviluppatori o hacker a trovare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\
+AndroBugs Framework è un sistema di analisi delle vulnerabilità per Android che aiuta gli sviluppatori o gli hackers a trovare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -727,11 +735,11 @@ androbugs.exe -f [APK file]
 ```
 ### [Androwarn](https://github.com/maaaaz/androwarn)
 
-**Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente su potenziali comportamenti dannosi sviluppati da un'applicazione Android.
+**Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvertire l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android.
 
-La rilevazione viene eseguita tramite **static analysis** del Dalvik bytecode dell'applicazione, rappresentato come **Smali**, usando la libreria [`androguard`](https://github.com/androguard/androguard).
+La rilevazione viene effettuata tramite la **static analysis** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard).
 
-Questo strumento individua i **comportamenti comuni delle applicazioni "maligne"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
+Questo strumento cerca i **comportamenti comuni delle applicazioni "malevoli"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
 ```
 python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 ```
@@ -739,42 +747,42 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 ![](<../../images/image (595).png>)
 
-**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. È uno strumento che mette insieme strumenti comunemente usati per il reverse engineering e l'analisi delle mobile application, per assistere nel testing delle mobile application contro le minacce per la sicurezza mobile identificate da OWASP. Il suo obiettivo è rendere questo compito più facile e accessibile agli sviluppatori di mobile application e ai professionisti della sicurezza.
+**MARA** è un framework di **M**obile **A**pplication **R**everse engineering and **A**nalysis. È uno strumento che mette insieme tool comunemente usati per il reverse engineering e l'analisi di applicazioni mobile, per aiutare nel testing delle applicazioni contro le minacce di sicurezza mobile OWASP. L'obiettivo è rendere questo compito più semplice e accessibile agli sviluppatori di applicazioni mobile e ai professionisti della sicurezza.
 
 È in grado di:
 
-- Estrarre codice Java e Smali usando diversi strumenti
+- Estrarre codice Java e Smali usando diversi tool
 - Analizzare APK usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
-- Estrarre informazioni private dall'APK usando regexp.
+- Estrarre informazioni private dall'APK usando regexps.
 - Analizzare il Manifest.
 - Analizzare i domini trovati usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) e [whatweb](https://github.com/urbanadventurer/WhatWeb)
-- Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
+- Deobfuscare APK tramite [apk-deguard.com](http://www.apk-deguard.com)
 
 ### Koodous
 
 Utile per rilevare malware: [https://koodous.com/](https://koodous.com/)
 
-## Obfuscating/Deobfuscating code
+## Offuscare/Deoffuscare il codice
 
-Nota che a seconda del servizio e della configurazione che usi per offuscare il codice, i segreti potrebbero o meno risultare offuscati.
+Nota che, a seconda del servizio e della configurazione usata per offuscare il codice, i segreti possono risultare offuscati oppure no.
 
 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
 
-Da [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca codice Java. È in grado di ottimizzare il bytecode oltre a rilevare e rimuovere istruzioni non utilizzate. ProGuard è software libero distribuito sotto la GNU General Public License, versione 2.
+Da [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca codice Java. È capace di ottimizzare il bytecode così come di rilevare e rimuovere istruzioni inutilizzate. ProGuard è software libero distribuito sotto la GNU General Public License, versione 2.
 
-ProGuard è distribuito come parte dell'Android SDK e viene eseguito durante la build dell'applicazione in modalità release.
+ProGuard è distribuito come parte dell'Android SDK e viene eseguito quando si builda l'applicazione in modalità release.
 
 ### [DexGuard](https://www.guardsquare.com/dexguard)
 
-Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
+Trovi una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
-(Dalla guida) L'ultima volta che abbiamo controllato, la modalità di funzionamento di Dexguard era:
+(Dalla guida) L'ultima volta che abbiamo verificato, la modalità di funzionamento di Dexguard era:
 
 - caricare una risorsa come InputStream;
-- passare il risultato a una classe che eredita da FilterInputStream per decrittarlo;
-- fare alcune inutili operazioni di obfuscation per far perdere qualche minuto al reverser;
+- passare il risultato a una classe che eredita da FilterInputStream per decrittarla;
+- fare qualche obfuscation inutile per far perdere tempo a un reverser;
 - passare il risultato decrittato a un ZipInputStream per ottenere un file DEX;
-- infine caricare il DEX risultante come risorsa usando il metodo `loadDex`.
+- infine caricare il DEX risultante come Resource usando il metodo `loadDex`.
 
 ### [DeGuard](http://apk-deguard.com)
 
@@ -784,39 +792,40 @@ Puoi caricare un APK offuscato sulla loro piattaforma.
 
 ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
 
-Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Usa l'API pubblica Gemini di Google.
+Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza in app android e deoffuscare il codice di app android. Usa l'API pubblica Google Gemini.
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
-È un deobfuscator Android generico. Simplify esegue virtualmente un'app per comprenderne il comportamento e poi cerca di ottimizzare il codice in modo che si comporti identicamente ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generica, quindi non importa quale tipo specifico di offuscamento sia stato usato.
+È un deobfuscator android generico. Simplify **esegue praticamente un'app** per capirne il comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più comprensibile per un umano. Ogni tipo di ottimizzazione è semplice e generica, quindi non importa quale specifico tipo di offuscamento sia stato usato.
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 
-APKiD ti dà informazioni su **come è stato creato un APK**. Identifica molti **compilatori**, **packers**, **obfuscators**, e altre cose strane. È lo [_PEiD_] per Android.
+APKiD ti dà informazioni su **come è stato creato un APK**. Identifica molti **compilers**, **packers**, **obfuscators**, e altre cose strane. È lo [_PEiD_](https://www.aldeid.com/wiki/PEiD) per Android.
 
-### Manual
+### Manuale
 
-[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
+[Leggi questo tutorial per imparare alcuni trucchi su **come reverse custom obfuscation**](manual-deobfuscation.md)
 
 ## Labs
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate che include una raccolta dei più recenti framework, tutorial e lab da diversi esperti e ricercatori per reverse engineering e analisi di malware.
+AndroL4b è una virtual machine per sicurezza Android basata su ubuntu-mate che include una raccolta degli ultimi framework, tutorial e lab di diversi security geeks e ricercatori per reverse engineering e malware analysis.
 
-## References
+## Riferimenti
 
 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
-- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È un'ottima lista di risorse
-- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido Android
+- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È una grande lista di risorse
+- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido su Android
 - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
 - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
 - [SSLPinDetect: Advanced SSL Pinning Detection for Android Security Analysis](https://petruknisme.medium.com/sslpindetect-advanced-ssl-pinning-detection-for-android-security-analysis-1390e9eca097)
 - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect)
 - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns)
+- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
 
-## Yet to try
+## Da provare
 
 - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
 - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md

@@ -2,46 +2,63 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-This page provides a practical workflow to regain dynamic analysis against Android apps that detect/root‑block instrumentation or enforce TLS pinning. It focuses on fast triage, common detections, and copy‑pasteable hooks/tactics to bypass them without repacking when possible.
+Questa pagina fornisce un workflow pratico per recuperare l'analisi dinamica contro app Android che rilevano/bloccano l'instrumentation su device rootati o che applicano TLS pinning. Si concentra su triage rapido, rilevamenti comuni e hook/tattiche copiabili e incollabili per bypassarli evitando il repacking quando possibile.
 
-## Superficie di rilevamento (cosa verificano le app)
+## Detection Surface (what apps check)
 
-- Controlli di root: binario su, percorsi Magisk, valori getprop, pacchetti root comuni
-- Controlli Frida/debugger (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scansione di /proc, classpath, librerie caricate
-- Anti‑debug nativo: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
-- Controlli di init precoce: Application.onCreate() o hook di avvio del processo che causano crash se è presente instrumentation
-- TLS pinning: TrustManager/HostnameVerifier personalizzati, OkHttp CertificatePinner, Conscrypt pinning, pin nativi
+- Root checks: su binary, Magisk paths, getprop values, common root packages
+- Frida/debugger checks (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scanning /proc, classpath, loaded libs
+- Native anti‑debug: ptrace(), syscalls, anti‑attach, breakpoints, inline hooks
+- Early init checks: Application.onCreate() or process start hooks that crash if instrumentation is present
+- TLS pinning: custom TrustManager/HostnameVerifier, OkHttp CertificatePinner, Conscrypt pinning, native pins
 
 ## Step 1 — Quick win: hide root with Magisk DenyList
 
-- Abilita Zygisk in Magisk
-- Abilita DenyList, aggiungi il pacchetto target
-- Riavvia e riprova
+- Enable Zygisk in Magisk
+- Enable DenyList, add the target package
+- Reboot and retest
 
-Molte app cercano solo indicatori ovvi (su/percorsi Magisk/getprop). DenyList spesso neutralizza controlli ingenui.
+Molte app cercano solo indicatori ovvi (su/Magisk paths/getprop). DenyList spesso neutralizza controlli naivi.
 
 References:
 - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
 
 ## Step 2 — 30‑second Frida Codeshare tests
 
-Prova script drop‑in comuni prima di approfondire:
+Prova script "drop‑in" comuni prima di approfondire:
 
 - anti-root-bypass.js
 - anti-frida-detection.js
 - hide_frida_gum.js
 
-Esempio:
+Example:
 ```bash
 frida -U -f com.example.app -l anti-frida-detection.js
 ```
-Questi tipicamente sostituiscono (stub) i check Java per root/debug, le scansioni process/service e le chiamate native ptrace(). Utili su app poco protette; hardened targets potrebbero richiedere hook su misura.
+Questi tipicamente stub Java root/debug checks, process/service scans, e native ptrace(). Utili su app poco protette; hardened targets potrebbero richiedere tailored hooks.
 
 - Codeshare: https://codeshare.frida.re/
 
-## Step 3 — Bypass init-time detectors collegandosi più tardi
+## Automatizza con Medusa (Frida framework)
 
-Molte rilevazioni vengono eseguite solo durante process spawn/onCreate(). Spawn‑time injection (-f) o gadgets vengono intercettati; collegarsi dopo il caricamento della UI può aggirare questi controlli.
+Medusa offre oltre 90 moduli pronti all'uso per SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception e altro.
+```bash
+git clone https://github.com/Ch0pin/medusa
+cd medusa
+pip install -r requirements.txt
+python medusa.py
+
+# Example interactive workflow
+show categories
+use http_communications/multiple_unpinner
+use root_detection/universal_root_detection_bypass
+run com.target.app
+```
+Suggerimento: Medusa è ottimo per ottenere risultati rapidi prima di scrivere custom hooks. Puoi anche cherry-pick modules e combinarli con i tuoi scripts.
+
+## Passo 3 — Bypass init-time detectors by attaching late
+
+Molte rilevazioni vengono eseguite solo durante il process spawn/onCreate(). Spawn‑time injection (-f) o gadgets vengono intercettati; attaching dopo il caricamento della UI può invece passare.
 ```bash
 # Launch the app normally (launcher/adb), wait for UI, then attach
 frida -U -n com.example.app
@@ -50,12 +67,12 @@ aobjection --gadget com.example.app explore  # if using gadget
 ```
 Se questo funziona, mantieni la sessione stabile e procedi a mappare e verificare gli stub.
 
-## Step 4 — Map detection logic via Jadx and string hunting
+## Fase 4 — Mappare la logica di rilevamento tramite Jadx e ricerca di stringhe
 
-Parole chiave per il triage statico in Jadx:
+Parole chiave per triage statico in Jadx:
 - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
 
-Pattern Java tipici:
+Tipici pattern Java:
 ```java
 public boolean isFridaDetected() {
 return getRunningServices().contains("frida");
@@ -68,9 +85,9 @@ API comuni da esaminare/hook:
 - java.lang.Runtime.exec / ProcessBuilder (probing commands)
 - android.os.SystemProperties.get (root/emulator heuristics)
 
-## Passo 5 — Stub del runtime con Frida (Java)
+## Passo 5 — Runtime stubbing con Frida (Java)
 
-Sovrascrivi i controlli personalizzati per restituire valori sicuri senza repacking:
+Sovrascrivi guardie custom per restituire valori sicuri senza repacking:
 ```js
 Java.perform(() => {
 const Checks = Java.use('com.example.security.Checks');
@@ -85,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager');
 AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
 });
 ```
-Triaging dei crash precoci? Dump classes poco prima che si arresti per individuare probabili detection namespaces:
+Triaging early crashes? Dump classes poco prima che si chiuda per individuare i probabili detection namespaces:
 ```js
 Java.perform(() => {
 Java.enumerateLoadedClasses({
@@ -94,7 +111,17 @@ onComplete: () => console.log('Done')
 });
 });
 ```
-Registra e neutralizza i metodi sospetti per confermare il flusso di esecuzione:
+```
+// Quick root detection stub example (adapt to target package/class names)
+Java.perform(() => {
+try {
+const RootChecker = Java.use('com.target.security.RootCheck');
+RootChecker.isDeviceRooted.implementation = function () { return false; };
+} catch (e) {}
+});
+```
+
+Log e neutralizza metodi sospetti per confermare il flusso di esecuzione:
 ```js
 Java.perform(() => {
 const Det = Java.use('com.example.security.DetectionManager');
@@ -104,24 +131,64 @@ return false;
 };
 });
 ```
-## Step 6 — Seguire la traccia JNI/native quando i Java hooks falliscono
+## Bypass emulator/VM detection (Java stubs)
 
-Traccia i punti di ingresso JNI per individuare i loader nativi e l'inizializzazione della rilevazione:
+Euristiche comuni: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE contenenti generic/goldfish/ranchu/sdk; artefatti QEMU come /dev/qemu_pipe, /dev/socket/qemud; MAC predefinito 02:00:00:00:00:00; NAT 10.0.2.x; assenza di telefonia/sensori.
+
+Spoof rapido dei campi Build:
+```js
+Java.perform(function(){
+var Build = Java.use('android.os.Build');
+Build.MODEL.value = 'Pixel 7 Pro';
+Build.MANUFACTURER.value = 'Google';
+Build.BRAND.value = 'google';
+Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
+});
+```
+Completa con stub per i controlli di esistenza dei file e per gli identificatori (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) in modo da restituire valori realistici.
+
+## SSL pinning bypass quick hook (Java)
+
+Neutralizza i TrustManagers personalizzati e forza SSL contexts permissivi:
+```js
+Java.perform(function(){
+var X509TrustManager = Java.use('javax.net.ssl.X509TrustManager');
+var SSLContext = Java.use('javax.net.ssl.SSLContext');
+
+// No-op validations
+X509TrustManager.checkClientTrusted.implementation = function(){ };
+X509TrustManager.checkServerTrusted.implementation = function(){ };
+
+// Force permissive TrustManagers
+var TrustManagers = [ X509TrustManager.$new() ];
+var SSLContextInit = SSLContext.init.overload('[Ljavax.net.ssl.KeyManager;','[Ljavax.net.ssl.TrustManager;','java.security.SecureRandom');
+SSLContextInit.implementation = function(km, tm, sr){
+return SSLContextInit.call(this, km, TrustManagers, sr);
+};
+});
+```
+Note
+- Estendere per OkHttp: hook okhttp3.CertificatePinner e HostnameVerifier se necessario, oppure utilizzare uno script universale di unpinning da CodeShare.
+- Esempio di esecuzione: `frida -U -f com.target.app -l ssl-bypass.js --no-pause`
+
+## Fase 6 — Seguire la traccia JNI/native quando i Java hooks falliscono
+
+Traccia i punti di ingresso JNI per localizzare native loaders e detection init:
 ```bash
 frida-trace -n com.example.app -i "JNI_OnLoad"
 ```
-Rapido triage nativo dei file .so inclusi:
+Triage nativo rapido dei file .so inclusi:
 ```bash
 # List exported symbols & JNI
 nm -D libfoo.so | head
 objdump -T libfoo.so | grep Java_
 strings -n 6 libfoo.so | egrep -i 'frida|ptrace|gum|magisk|su|root'
 ```
-Reversing interattivo/nativo:
+Interattivo/nativo reversing:
 - Ghidra: https://ghidra-sre.org/
 - r2frida: https://github.com/nowsecure/r2frida
 
-Esempio: neutralizzare ptrace per eludere un semplice anti‑debug in libc:
+Esempio: neuter ptrace per eludere un semplice anti‑debug in libc:
 ```js
 const ptrace = Module.findExportByName(null, 'ptrace');
 if (ptrace) {
@@ -137,26 +204,28 @@ reversing-native-libraries.md
 
 ## Passo 7 — Objection patching (embed gadget / strip basics)
 
-Quando preferisci il repacking ai runtime hooks, prova:
+Se preferisci il repacking ai runtime hooks, prova:
 ```bash
 objection patchapk --source app.apk
 ```
 Note:
 - Richiede apktool; assicurati di avere una versione aggiornata seguendo la guida ufficiale per evitare problemi di build: https://apktool.org/docs/install
-- Gadget injection permette l'instrumentation senza root ma può comunque essere rilevata da controlli init‑time più stringenti.
+- Gadget injection permette instrumentation senza root, ma può comunque essere rilevato da controlli init‑time più stringenti.
+
+Opzionalmente, aggiungi moduli LSPosed e Shamiko per un nascondimento del root più efficace negli ambienti Zygisk, e cura la DenyList per coprire i processi figli.
 
 Riferimenti:
 - Objection: https://github.com/sensepost/objection
 
-## Passo 8 — Fallback: Patch TLS pinning per la visibilità del traffico di rete
+## Passo 8 — Fallback: Patch TLS pinning per la visibilità della rete
 
-Se l'instrumentation è bloccata, puoi comunque ispezionare il traffico rimuovendo staticamente il pinning:
+Se l'instrumentation è bloccata, puoi comunque ispezionare il traffico rimuovendo staticamente il TLS pinning:
 ```bash
 apk-mitm app.apk
 # Then install the patched APK and proxy via Burp/mitmproxy
 ```
 - Strumento: https://github.com/shroudedcode/apk-mitm
-- Per i trucchi CA‑trust nella configurazione di rete (e il trust delle CA utente su Android 7+), vedi:
+- Per i trucchi relativi a CA‑trust nella configurazione di rete (e al user CA trust di Android 7+), vedi:
 
 {{#ref}}
 make-apk-accept-ca-certificate.md
@@ -166,7 +235,7 @@ make-apk-accept-ca-certificate.md
 install-burp-certificate.md
 {{#endref}}
 
-## Prontuario rapido dei comandi
+## Elenco rapido dei comandi utili
 ```bash
 # List processes and attach
 frida-ps -Uai
@@ -184,14 +253,14 @@ objection --gadget com.example.app explore
 # Static TLS pinning removal
 apk-mitm app.apk
 ```
-## Suggerimenti e avvertenze
+## Suggerimenti & avvertenze
 
-- Preferisci attaching late piuttosto che spawning quando le app crashano all'avvio
-- Alcune detections si rieseguono nei flussi critici (es., payment, auth) — mantieni i hooks attivi durante la navigazione
-- Combina statico e dinamico: string hunt in Jadx per selezionare le classi; poi applica hook ai metodi per verificare a runtime
-- Le app hardenate possono usare packers e native TLS pinning — prevedi di dover eseguire reverse engineering sul codice nativo
+- Privilegia attaching late rispetto allo spawning quando le app crashano all'avvio
+- Alcune detections si re‑run nei flussi critici (es. payment, auth) — tieni i hooks attivi durante la navigazione
+- Mix static e dynamic: string hunt in Jadx per accorciare la lista delle classi; poi hook methods per verificare a runtime
+- Le app hardened possono usare packers e native TLS pinning — aspettati di dover reverse il codice nativo
 
-## Riferimenti
+## References
 
 - [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
 - [Frida Codeshare](https://codeshare.frida.re/)
@@ -202,5 +271,7 @@ apk-mitm app.apk
 - [r2frida](https://github.com/nowsecure/r2frida)
 - [Apktool install guide](https://apktool.org/docs/install)
 - [Magisk](https://github.com/topjohnwu/Magisk)
+- [Medusa (Android Frida framework)](https://github.com/Ch0pin/medusa)
+- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
 
 {{#include ../../banners/hacktricks-training.md}}

src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md

@@ -6,29 +6,29 @@ Grazie mille a [**@offsecjay**](https://twitter.com/offsecjay) per il suo aiuto
 
 ## Cos'è
 
-Android Studio consente di **eseguire macchine virtuali di Android che puoi utilizzare per testare APK**. Per utilizzarle avrai bisogno di:
+Android Studio permette di **eseguire macchine virtuali Android che puoi usare per testare APKs**. Per usarle avrai bisogno di:
 
-- Gli **strumenti SDK di Android** - [Scarica qui](https://developer.android.com/studio/releases/sdk-tools).
-- Oppure **Android Studio** (con strumenti SDK di Android) - [Scarica qui](https://developer.android.com/studio).
+- Gli **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools).
+- Oppure **Android Studio** (con Android SDK tools) - [Download here](https://developer.android.com/studio).
 
-In Windows (nel mio caso) **dopo aver installato Android Studio** avevo gli **strumenti SDK installati in**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
+Su Windows (nel mio caso) **dopo aver installato Android Studio** avevo gli **SDK Tools installati in**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
 
-In mac puoi **scaricare gli strumenti SDK** e averli nel PATH eseguendo:
+Su mac puoi **scaricare gli SDK tools** e averli nel PATH eseguendo:
 ```bash
 brew tap homebrew/cask
 brew install --cask android-sdk
 ```
-O da **Android Studio GUI** come indicato in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) che li installerà in `~/Library/Android/sdk/cmdline-tools/latest/bin/` e `~/Library/Android/sdk/platform-tools/` e `~/Library/Android/sdk/emulator/`
+Oppure da **Android Studio GUI** come indicato in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) che li installerà in `~/Library/Android/sdk/cmdline-tools/latest/bin/` e `~/Library/Android/sdk/platform-tools/` e `~/Library/Android/sdk/emulator/`
 
-Per i problemi di Java:
+Per i problemi Java:
 ```java
 export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
 ```
 ## GUI
 
-### Preparare la Macchina Virtuale
+### Prepare Virtual Machine
 
-Se hai installato Android Studio, puoi semplicemente aprire la vista principale del progetto e accedere a: _**Strumenti**_ --> _**AVD Manager.**_
+If you installed Android Studio, you can just open the main project view and access: _**Tools**_ --> _**AVD Manager.**_
 
 <div align="center" data-full-width="false">
 
@@ -36,38 +36,38 @@ Se hai installato Android Studio, puoi semplicemente aprire la vista principale
 
 </div>
 
-Poi, clicca su _**Crea Dispositivo Virtuale**_
+Then, click on _**Create Virtual Device**_
 
 <figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
 
-_**seleziona** il telefono che vuoi usare_ e clicca su _**Avanti.**_
+_**seleziona** il telefono che vuoi usare_ e fai clic su _**Next.**_
 
 > [!WARNING]
-> Se hai bisogno di un telefono con il Play Store installato, seleziona uno con l'icona del Play Store!
+> If you need a phone with Play Store installed select one with the Play Store icon on it!
 >
 > <img src="../../images/image (1144).png" alt="" data-size="original">
 
-Nella vista attuale sarai in grado di **selezionare e scaricare l'immagine Android** che il telefono eseguirà:
+Nella vista corrente potrai **selezionare e scaricare l'immagine Android** che il telefono eseguirà:
 
 <figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Quindi, selezionala e se non è scaricata clicca sul simbolo _**Scarica**_ accanto al nome (**ora aspetta fino a quando l'immagine è scaricata).**\
-Una volta che l'immagine è scaricata, seleziona semplicemente **`Avanti`** e **`Fine`**.
+Quindi, selezionala e se non è scaricata fai clic sul simbolo _**Download**_ accanto al nome (**adesso aspetta fino al completamento del download dell'immagine).**\
+Una volta scaricata l'immagine, seleziona semplicemente **`Next`** e **`Finish`**.
 
-La macchina virtuale sarà creata. Ora **ogni volta che accedi all'AVD manager sarà presente**.
+La virtual machine verrà creata. Ora **ogni volta che accederai all'AVD manager sarà presente**.
 
-### Eseguire la Macchina Virtuale
+### Run Virtual Machine
 
-Per **eseguirla** basta premere il _**Pulsante di Avvio**_.
+In order to **run** it just press the _**Start button**_.
 
 ![](<../../images/image (518).png>)
 
-## Strumento da Riga di Comando
+## Command Line tool
 
 > [!WARNING]
-> Per macOS puoi trovare lo strumento `avdmanager` in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` e l'`emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` se li hai installati.
+> For macOS you can find the `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` if you have them installed.
 
-Prima di tutto devi **decidere quale telefono vuoi usare**, per vedere l'elenco dei telefoni possibili esegui:
+First of all you need to **decide which phone you want to use**, in order to see the list of possible phones execute:
 ```
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
 
@@ -95,16 +95,16 @@ Name: Nexus 10
 OEM : Google
 [...]
 ```
-Una volta deciso il nome del dispositivo che vuoi utilizzare, devi **decidere quale immagine Android vuoi eseguire su questo dispositivo.**\
-Puoi elencare tutte le opzioni utilizzando `sdkmanager`:
+Una volta deciso il nome del dispositivo che vuoi usare, devi **decidere quale immagine Android vuoi eseguire su questo dispositivo.**\
+Puoi elencare tutte le opzioni usando `sdkmanager`:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
 ```
-E **scarica** quello (o tutti) che vuoi usare con:
+E **download** quello (o tutti quelli) che vuoi usare con:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
 ```
-Una volta scaricato l'immagine Android che desideri utilizzare, puoi **elencare tutte le immagini Android scaricate** con:
+Una volta scaricata l'immagine Android che vuoi usare puoi **elencare tutte le immagini Android scaricate** con:
 ```
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list target
 ----------
@@ -120,11 +120,11 @@ Type: Platform
 API level: 29
 Revision: 4
 ```
-In questo momento hai deciso il dispositivo che vuoi utilizzare e hai scaricato l'immagine Android, quindi **puoi creare la macchina virtuale utilizzando**:
+A questo punto hai deciso il dispositivo che vuoi utilizzare e hai scaricato l'immagine Android, quindi **puoi creare la macchina virtuale usando**:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
 ```
-Nell'ultimo comando **ho creato una VM chiamata** "_AVD9_" utilizzando il **dispositivo** "_Nexus 5X_" e l'**immagine Android** "_system-images;android-28;google_apis;x86_64_".\
+Nel comando precedente **ho creato una VM chiamata** "_AVD9_" usando il **dispositivo** "_Nexus 5X_" e l'**immagine Android** "_system-images;android-28;google_apis;x86_64_".\
 Ora puoi **elencare le macchine virtuali** che hai creato con:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
@@ -140,7 +140,7 @@ Name: Pixel_2_API_27
 Path: C:\Users\cpolo\.android\avd\Pixel_2_API_27_1.avd
 Error: Google pixel_2 no longer exists as a device
 ```
-### Esegui Macchina Virtuale
+### Eseguire la macchina virtuale
 
 > [!WARNING]
 > Per macOS puoi trovare lo strumento `avdmanager` in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` e l'`emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` se li hai installati.
@@ -151,64 +151,120 @@ C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds
 AVD9
 Pixel_2_API_27
 ```
-Puoi semplicemente **eseguire qualsiasi macchina virtuale creata** utilizzando:
+Puoi semplicemente **avviare qualsiasi macchina virtuale creata** usando:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
 ```
-O utilizzando opzioni più avanzate, puoi eseguire una macchina virtuale come:
+Oppure, usando opzioni più avanzate, puoi eseguire una macchina virtuale come:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
 ```
-### Opzioni della riga di comando
+### Opzioni da riga di comando
 
-Tuttavia ci sono **molte opzioni utili della riga di comando** che puoi utilizzare per avviare una macchina virtuale. Di seguito puoi trovare alcune opzioni interessanti ma puoi [**trovare un elenco completo qui**](https://developer.android.com/studio/run/emulator-commandline)
+Tuttavia ci sono **molte diverse opzioni utili da riga di comando** che puoi usare per avviare una macchina virtuale. Qui sotto puoi trovare alcune opzioni interessanti ma puoi [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline)
 
 **Avvio**
 
-- `-snapshot name` : Avvia snapshot VM
+- `-snapshot name` : Avvia uno snapshot della VM
 - `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Elenca tutti gli snapshot registrati
 
 **Rete**
 
-- `-dns-server 192.0.2.0, 192.0.2.255` : Consente di indicare separati da virgola i server DNS per la VM.
-- **`-http-proxy 192.168.1.12:8080`** : Consente di indicare un proxy HTTP da utilizzare (molto utile per catturare il traffico usando Burp)
-- Se le impostazioni del proxy non funzionano per qualche motivo, prova a configurarle internamente o utilizzando un'applicazione come "Super Proxy" o "ProxyDroid".
+- `-dns-server 192.0.2.0, 192.0.2.255` : Permette di indicare, separati da virgola, i server DNS per la VM.
+- **`-http-proxy 192.168.1.12:8080`** : Permette di indicare un proxy HTTP da usare (molto utile per catturare il traffico usando Burp)
+- Se le impostazioni del proxy non funzionano per qualche motivo, prova a configurarle internamente o usando un'applicazione come "Super Proxy" o "ProxyDroid".
 - `-netdelay 200` : Imposta l'emulazione della latenza di rete in millisecondi.
-- `-port 5556` : Imposta il numero di porta TCP utilizzato per la console e adb.
-- `-ports 5556,5559` : Imposta le porte TCP utilizzate per la console e adb.
+- `-port 5556` : Imposta il numero di porta TCP usato per la console e adb.
+- `-ports 5556,5559` : Imposta le porte TCP usate per la console e adb.
 - **`-tcpdump /path/dumpfile.cap`** : Cattura tutto il traffico in un file
 
 **Sistema**
 
-- `-selinux {disabled|permissive}` : Imposta il modulo di sicurezza Security-Enhanced Linux su modalità disabilitata o permissiva su un sistema operativo Linux.
+- `-selinux {disabled|permissive}` : Imposta il modulo di sicurezza Security-Enhanced Linux in modalità disabled o permissive su un sistema operativo Linux.
 - `-timezone Europe/Paris` : Imposta il fuso orario per il dispositivo virtuale
-- `-screen {touch(default)|multi-touch|o-touch}` : Imposta la modalità dello schermo touch emulato.
-- **`-writable-system`** : Usa questa opzione per avere un'immagine di sistema scrivibile durante la tua sessione di emulazione. Dovrai anche eseguire `adb root; adb remount`. Questo è molto utile per installare un nuovo certificato nel sistema.
+- `-screen {touch(default)|multi-touch|o-touch}` : Imposta la modalità del touch screen emulato.
+- **`-writable-system`** : Usa questa opzione per avere un'immagine di sistema scrivibile durante la sessione di emulazione. Dovrai inoltre eseguire `adb root; adb remount`. Questo è molto utile per installare un nuovo certificato nel sistema.
 
-## Rooting di un dispositivo Play Store
+## Configurazione CLI Linux (SDK/AVD quickstart)
 
-Se hai scaricato un dispositivo con Play Store non sarai in grado di ottenere root direttamente, e riceverai questo messaggio di errore
+Gli strumenti CLI ufficiali rendono facile creare emulatori veloci e debugabili senza Android Studio.
+```bash
+# Directory layout
+mkdir -p ~/Android/cmdline-tools/latest
+
+# Download commandline tools (Linux)
+wget https://dl.google.com/android/repository/commandlinetools-linux-13114758_latest.zip -O /tmp/cmdline-tools.zip
+unzip /tmp/cmdline-tools.zip -d ~/Android/cmdline-tools/latest
+rm /tmp/cmdline-tools.zip
+
+# Env vars (add to ~/.bashrc or ~/.zshrc)
+export ANDROID_HOME=$HOME/Android
+export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH
+
+# Install core SDK components
+sdkmanager --install "platform-tools" "emulator"
+
+# Install a debuggable x86_64 system image (Android 11 / API 30)
+sdkmanager --install "system-images;android-30;google_apis;x86_64"
+
+# Create an AVD and run it with a writable /system & snapshot name
+avdmanager create avd -n PixelRootX86 -k "system-images;android-30;google_apis;x86_64" -d "pixel"
+emulator -avd PixelRootX86 -writable-system -snapshot PixelRootX86_snap
+
+# Verify root (debuggable images allow `adb root`)
+adb root
+adb shell whoami  # expect: root
+```
+Note
+- Varianti di system image: google_apis (debuggable, permette adb root), google_apis_playstore (non rootable), aosp/default (leggera).
+- Tipi di build: userdebug spesso permette `adb root` su immagini con capacità di debug. Le immagini Play Store sono build di produzione e bloccano il root.
+- Su host x86_64, l'emulazione full-system ARM64 non è supportata da API 28+. Per Android 11+ usa le immagini Google APIs/Play che includono la traduzione per-app ARM-to-x86 per eseguire molte app ARM-only rapidamente.
+
+### Snapshots dalla CLI
+```bash
+# Save a clean snapshot from the running emulator
+adb -s emulator-5554 emu avd snapshot save my_clean_setup
+
+# Boot from a named snapshot (if it exists)
+emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup
+```
+## Traduzione binaria ARM→x86 (Android 11+)
+
+Le immagini Google APIs e Play Store su Android 11+ possono tradurre i binari ARM delle app per processo mantenendo il resto del sistema nativo x86/x86_64. Questo è spesso abbastanza veloce per testare molte app che girano solo su ARM su desktop.
+
+> Consiglio: Preferisci le immagini Google APIs x86/x86_64 durante i pentests. Le immagini Play sono comode ma bloccano `adb root`; usale solo quando richiedi specificamente i Play services e accetti la mancanza di root.
+
+## Rooting a Play Store device
+
+Se hai scaricato un dispositivo con Play Store non potrai ottenere root direttamente e otterrai questo messaggio di errore
 ```
 $ adb root
 adbd cannot run as root in production builds
 ```
-Usando [rootAVD](https://github.com/newbit1/rootAVD) con [Magisk](https://github.com/topjohnwu/Magisk) sono riuscito a fare il root (segui ad esempio [**questo video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **o** [**questo**](https://www.youtube.com/watch?v=qQicUW0svB8)).
+Using [rootAVD](https://github.com/newbit1/rootAVD) with [Magisk](https://github.com/topjohnwu/Magisk) sono riuscito ad ottenere il root (segui ad esempio [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **o** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)).
 
-## Installa il Certificato Burp
+## Installare il certificato di Burp
+
+Consulta la pagina seguente per imparare come installare un certificato CA personalizzato:
 
-Controlla la seguente pagina per imparare come installare un certificato CA personalizzato:
 
 {{#ref}}
 install-burp-certificate.md
 {{#endref}}
 
-## Opzioni AVD Interessanti
+## Opzioni utili per AVD
 
-### Fai uno Snapshot
+### Creare uno snapshot
 
-Puoi **usare l'interfaccia grafica** per fare uno snapshot della VM in qualsiasi momento:
+Puoi **usare la GUI** per creare uno snapshot della VM in qualsiasi momento:
 
 ![](<../../images/image (234).png>)
 
+## Riferimenti
+
+- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
+- [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline)
+- [Run ARM apps on the Android Emulator (x86 translation)](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)
+
 {{#include ../../banners/hacktricks-training.md}}

src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md

@@ -1,4 +1,4 @@
-# Frida Tutorial
+# Tutorial di Frida
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -10,32 +10,85 @@ Installa **frida tools**:
 pip install frida-tools
 pip install frida
 ```
-**Scarica e installa** nel android il **frida server** ([Scarica l'ultima versione](https://github.com/frida/frida/releases)).\
-Comando per riavviare adb in modalità root, connettersi ad esso, caricare frida-server, dare permessi di esecuzione e eseguirlo in background:
+**Scarica e installa** su android il **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
+One-liner per riavviare adb in modalità root, connettersi ad esso, caricare frida-server, assegnare i permessi di esecuzione e avviarlo in background:
 ```bash
 adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
 ```
-**Controlla** se sta **funzionando**:
+**Verifica** se **funziona**:
 ```bash
 frida-ps -U #List packages and processes
 frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
 ```
-## Tutorial
+## Frida server vs. Gadget (root vs. no-root)
+
+Due modi comuni per strumentare le app Android con Frida:
+
+- Frida server (rooted devices): Caricare e avviare un daemon nativo che consente di collegarsi a qualsiasi processo.
+- Frida Gadget (no root): Includere Frida come libreria condivisa all'interno dell'APK e caricarla automaticamente nel processo di destinazione.
+
+Frida server (rooted)
+```bash
+# Download the matching frida-server binary for your device's arch
+# https://github.com/frida/frida/releases
+adb root
+adb push frida-server-<ver>-android-<arch> /data/local/tmp/frida-server
+adb shell chmod 755 /data/local/tmp/frida-server
+adb shell /data/local/tmp/frida-server &    # run at boot via init/magisk if desired
+
+# From host, list processes and attach
+frida-ps -Uai
+frida -U -n com.example.app
+```
+Frida Gadget (no-root)
+
+1) Estrai l'APK, aggiungi il gadget .so e la configurazione:
+- Posiziona libfrida-gadget.so in lib/<abi>/ (es., lib/arm64-v8a/)
+- Crea assets/frida-gadget.config con le impostazioni di caricamento degli script
+
+Esempio frida-gadget.config
+```json
+{
+"interaction": { "type": "script", "path": "/sdcard/ssl-bypass.js" },
+"runtime": { "logFile": "/sdcard/frida-gadget.log" }
+}
+```
+2) Riferisci/carica il gadget in modo che venga inizializzato presto:
+- Più semplice: aggiungi un piccolo stub Java con System.loadLibrary("frida-gadget") in Application.onCreate(), oppure usa il caricamento delle librerie native già presente.
+
+3) Ricompila e firma l'APK, poi installalo:
+```bash
+apktool d app.apk -o app_m
+# ... add gadget .so and config ...
+apktool b app_m -o app_gadget.apk
+uber-apk-signer -a app_gadget.apk -o out_signed
+adb install -r out_signed/app_gadget-aligned-debugSigned.apk
+```
+4) Collegarsi dall'host al processo gadget:
+```bash
+frida-ps -Uai
+frida -U -n com.example.app
+```
+Note
+- Gadget viene rilevato da alcune protezioni; mantieni nomi/percorsi stealthy e caricalo tardi/condizionatamente se necessario.
+- Su app hardened, prediligi test su device rooted con server + late attach, oppure combina con Magisk/Zygisk hiding.
+
+## Tutorials
 
 ### [Tutorial 1](frida-tutorial-1.md)
 
 **Da**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
 **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
-**Codice sorgente**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
+**Codice Sorgente**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
 
 **Segui il [link per leggerlo](frida-tutorial-1.md).**
 
 ### [Tutorial 2](frida-tutorial-2.md)
 
-**Da**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parti 2, 3 & 4)\
-**APK e codice sorgente**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
+**Da**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parts 2, 3 & 4)\
+**APKs e codice sorgente**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
 
-**Segui il [link per leggerlo.](frida-tutorial-2.md)**
+**Segui il[ link per leggerlo.](frida-tutorial-2.md)**
 
 ### [Tutorial 3](owaspuncrackable-1.md)
 
@@ -44,11 +97,11 @@ frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
 
 **Segui il [link per leggerlo](owaspuncrackable-1.md).**
 
-**Puoi trovare altri fantastici script Frida qui:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
+**Puoi trovare altri Awesome Frida scripts qui:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
 
-## Esempi rapidi
+## Esempi Rapidi
 
-### Chiamare Frida dalla riga di comando
+### Chiamare Frida da riga di comando
 ```bash
 frida-ps -U
 
@@ -61,7 +114,7 @@ frida -U --no-pause -l disableRoot.js -f owasp.mstg.uncrackable1
 #frozen so that the instrumentation can occur, and the automatically
 #continue execution with our modified code.
 ```
-### Script Python di Base
+### Script Python di base
 ```python
 import frida, sys
 
@@ -72,9 +125,9 @@ print('[ * ] Running Frida Demo application')
 script.load()
 sys.stdin.read()
 ```
-### Hooking functions without parameters
+### Hooking funzioni senza parametri
 
-Collegare la funzione `a()` della classe `sg.vantagepoint.a.c`
+Hook la funzione `a()` della classe `sg.vantagepoint.a.c`
 ```javascript
 Java.perform(function () {
 ;  rootcheck1.a.overload().implementation = function() {
@@ -84,14 +137,14 @@ return false;
 };
 });
 ```
-Collegare java `exit()`
+Hook java `exit()`
 ```javascript
 var sysexit = Java.use("java.lang.System")
 sysexit.exit.overload("int").implementation = function (var_0) {
 send("java.lang.System.exit(I)V  // We avoid exiting the application  :)")
 }
 ```
-Collegare MainActivity `.onStart()` e `.onCreate()`
+Hook MainActivity `.onStart()` & `.onCreate()`
 ```javascript
 var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity")
 mainactivity.onStart.overload().implementation = function () {
@@ -105,7 +158,7 @@ send("MainActivity.onCreate() HIT!!!")
 var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
 }
 ```
-Collegare android `.onCreate()`
+Hook android `.onCreate()`
 ```javascript
 var activity = Java.use("android.app.Activity")
 activity.onCreate.overload("android.os.Bundle").implementation = function (
@@ -115,9 +168,9 @@ send("Activity HIT!!!")
 var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
 }
 ```
-### Hooking functions with parameters and retrieving the value
+### Hooking di funzioni con parametri e recupero del valore
 
-Hooking una funzione di decrittazione. Stampa l'input, chiama la funzione originale per decrittare l'input e infine, stampa i dati in chiaro:
+Hooking di una funzione di decriptazione. Stampa l'input, chiama la funzione originale per decriptare l'input e infine stampa i dati in chiaro:
 ```javascript
 function getString(data) {
 var ret = ""
@@ -142,9 +195,9 @@ send("Decrypted flag: " + flag)
 return ret //[B
 }
 ```
-### Hooking functions and calling them with our input
+### Hooking functions e chiamarle con il nostro input
 
-Collegare una funzione che riceve una stringa e chiamarla con un'altra stringa (da [qui](https://11x256.github.io/Frida-hooking-android-part-2/))
+Hook a function che riceve una string e chiamala con un'altra string (da [here](https://11x256.github.io/Frida-hooking-android-part-2/))
 ```javascript
 var string_class = Java.use("java.lang.String") // get a JS wrapper for java's String class
 
@@ -159,7 +212,7 @@ return ret
 ```
 ### Ottenere un oggetto già creato di una classe
 
-Se vuoi estrarre un attributo di un oggetto creato, puoi usare questo.
+Se vuoi estrarre qualche attributo di un oggetto già creato puoi usare questo.
 
 In questo esempio vedrai come ottenere l'oggetto della classe my_activity e come chiamare la funzione .secret() che stamperà un attributo privato dell'oggetto:
 ```javascript
@@ -175,7 +228,13 @@ onComplete: function () {},
 ## Altri tutorial su Frida
 
 - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
-- [Parte 1 della serie di blog sull'uso avanzato di Frida: Librerie di crittografia IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
+- [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
 
 
+## Riferimenti
+
+- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
+- [Frida Gadget documentation](https://frida.re/docs/gadget/)
+- [Frida releases (server binaries)](https://github.com/frida/frida/releases)
+
 {{#include ../../../banners/hacktricks-training.md}}

src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md

@@ -1,20 +1,32 @@
-# Installa Certificato Burp
+# Installare il certificato di Burp
 
 {{#include ../../banners/hacktricks-training.md}}
 
 
-## Su una Macchina Virtuale
+## Proxy a livello di sistema tramite ADB
 
-Prima di tutto, devi scaricare il certificato Der da Burp. Puoi farlo in _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
+Configura un proxy HTTP globale in modo che tutte le app instradino il traffico attraverso il tuo interceptor (Burp/mitmproxy):
+```bash
+# Set proxy (device/emulator must reach your host IP)
+adb shell settings put global http_proxy 192.168.1.2:8080
+
+# Clear proxy
+adb shell settings put global http_proxy :0
+```
+Tip: In Burp, imposta il listener su 0.0.0.0 in modo che i dispositivi sulla LAN possano connettersi (Proxy -> Options -> Proxy Listeners).
+
+## Su una macchina virtuale
+
+Per prima cosa devi scaricare il certificato Der da Burp. Puoi farlo in _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
 
 ![](<../../images/image (367).png>)
 
-**Esporta il certificato in formato Der** e **trasformiamolo** in una forma che **Android** sarà in grado di **comprendere.** Nota che **per configurare il certificato burp sulla macchina Android in AVD** devi **eseguire** questa macchina **con** l'opzione **`-writable-system`**.\
-Ad esempio, puoi eseguirlo così:
+**Esporta il certificato nel formato Der** e trasformiamolo in una forma che **Android** possa **capire.** Nota che **per configurare il certificato di Burp sulla macchina Android in AVD** è necessario **eseguire** questa macchina **con** l'opzione **`-writable-system`**.\
+Per esempio puoi eseguirla così:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
 ```
-Poi, per **configurare il certificato di burp fare**:
+Quindi, per **configurare il certificato di burps**, esegui:
 ```bash
 openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem
 CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0"
@@ -25,39 +37,43 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc
 adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges
 adb reboot #Now, reboot the machine
 ```
-Una volta che la **macchina ha terminato il riavvio**, il certificato burp sarà in uso!
+Una volta che la **macchina ha finito di riavviarsi** il certificato Burp sarà in uso!
 
-## Utilizzando Magisc
+## Usare Magisc
 
-Se hai **rootato il tuo dispositivo con Magisc** (forse un emulatore), e non puoi **seguire** i **passi** precedenti per installare il certificato Burp perché il **filesystem è in sola lettura** e non puoi rimontarlo in scrittura, c'è un altro modo.
+Se hai **effettuato il root del dispositivo con Magisc** (magari un emulator), e **non puoi seguire** i precedenti **passaggi** per installare il certificato Burp perché il **file system è di sola lettura** e non puoi rimontarlo in scrittura, c'è un'altra via.
 
 Spiegato in [**questo video**](https://www.youtube.com/watch?v=qQicUW0svB8) devi:
 
-1. **Installare un certificato CA**: Basta **trascinare e rilasciare** il certificato Burp DER **cambiando l'estensione** in `.crt` nel mobile in modo che sia memorizzato nella cartella Download e andare su `Installa un certificato` -> `Certificato CA`
+1. **Installa un certificato CA**: Basta **trascina e rilascia** il certificato DER Burp cambiando l'estensione in `.crt` sul dispositivo in modo che venga memorizzato nella cartella Downloads e vai su `Install a certificate` -> `CA certificate`
 
 <figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
 
-- Controlla che il certificato sia stato memorizzato correttamente andando su `Credenziali attendibili` -> `UTENTE`
+- Verifica che il certificato sia stato memorizzato correttamente andando su `Trusted credentials` -> `USER`
 
 <figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
 
-2. **Rendere fidato di sistema**: Scarica il modulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un file .zip), **trascinalo e rilascialo** nel telefono, vai all'app **Magics** nel telefono nella sezione **`Moduli`**, clicca su **`Installa da memoria`**, seleziona il modulo `.zip` e una volta installato **riavvia** il telefono:
+2. **Rendilo attendibile a livello di sistema**: Scarica il modulo Magisc [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (un file .zip), **trascina e rilascia** il file nel telefono, vai alla **Magics app** sul telefono nella sezione **`Modules`**, clicca su **`Install from storage`**, seleziona il modulo `.zip` e una volta installato **riavvia** il telefono:
 
 <figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
 
-- Dopo il riavvio, vai su `Credenziali attendibili` -> `SISTEMA` e controlla che il certificato Postswigger sia presente
+- Dopo il riavvio, vai su `Trusted credentials` -> `SYSTEM` e verifica che il certificato Postswigger sia presente
 
 <figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
 
-## Post Android 14
+### Scopri come creare un modulo Magisc
 
-Nell'ultima versione di Android 14, è stato osservato un cambiamento significativo nella gestione dei certificati dell'Autorità di Certificazione (CA) fidati di sistema. In precedenza, questi certificati erano ospitati in **`/system/etc/security/cacerts/`**, accessibili e modificabili dagli utenti con privilegi di root, il che consentiva un'applicazione immediata in tutto il sistema. Tuttavia, con Android 14, la posizione di archiviazione è stata spostata in **`/apex/com.android.conscrypt/cacerts`**, una directory all'interno del percorso **`/apex`**, che è di natura immutabile.
+Vedi [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
 
-I tentativi di rimontare il **percorso APEX cacerts** come scrivibile incontrano un fallimento, poiché il sistema non consente tali operazioni. Anche i tentativi di smontare o sovrapporre la directory con un file system temporaneo (tmpfs) non eludono l'immutabilità; le applicazioni continuano ad accedere ai dati del certificato originale indipendentemente dalle modifiche a livello di file system. Questa resilienza è dovuta al fatto che il mount **`/apex`** è configurato con propagazione PRIVATA, garantendo che eventuali modifiche all'interno della directory **`/apex`** non influenzino altri processi.
+## Dopo Android 14
 
-L'inizializzazione di Android coinvolge il processo `init`, che, all'avvio del sistema operativo, avvia anche il processo Zygote. Questo processo è responsabile dell'avvio dei processi delle applicazioni con un nuovo namespace di mount che include un mount privato di **`/apex`**, isolando così le modifiche a questa directory da altri processi.
+Nell'ultima release di Android 14 è stata osservata una modifica significativa nella gestione dei certificati delle Certificate Authority (CA) attendibili dal sistema. In precedenza, questi certificati risiedevano in **`/system/etc/security/cacerts/`**, accessibili e modificabili dagli utenti con privilegi di root, il che ne permetteva l'applicazione immediata a livello di sistema. Tuttavia, con Android 14, la posizione di archiviazione è stata spostata in **`/apex/com.android.conscrypt/cacerts`**, una directory all'interno del percorso **`/apex`**, che è immutabile per natura.
 
-Tuttavia, esiste una soluzione per coloro che necessitano di modificare i certificati CA fidati di sistema all'interno della directory **`/apex`**. Questo comporta il rimontaggio manuale di **`/apex`** per rimuovere la propagazione PRIVATA, rendendolo quindi scrivibile. Il processo include la copia dei contenuti di **`/apex/com.android.conscrypt`** in un'altra posizione, lo smontaggio della directory **`/apex/com.android.conscrypt`** per eliminare il vincolo di sola lettura e poi il ripristino dei contenuti nella loro posizione originale all'interno di **`/apex`**. Questo approccio richiede un'azione rapida per evitare crash di sistema. Per garantire l'applicazione di queste modifiche a livello di sistema, si consiglia di riavviare il `system_server`, che riavvia effettivamente tutte le applicazioni e riporta il sistema a uno stato coerente.
+I tentativi di rimontare il percorso APEX cacerts come scrivibile falliscono, poiché il sistema non consente tali operazioni. Anche i tentativi di smontare o sovrapporre la directory con un file system temporaneo (tmpfs) non aggirano l'immutabilità; le applicazioni continuano ad accedere ai dati originali dei certificati indipendentemente dalle modifiche a livello di file system. Questa resilienza è dovuta al fatto che il mount di **`/apex`** è configurato con PRIVATE propagation, garantendo che qualsiasi modifica all'interno della directory **`/apex`** non influisca sugli altri processi.
+
+L'inizializzazione di Android coinvolge il processo `init` che, all'avvio del sistema operativo, avvia anche il processo Zygote. Questo processo è responsabile del lancio dei processi delle applicazioni con un nuovo mount namespace che include un mount privato di **`/apex`**, isolando così le modifiche a questa directory dagli altri processi.
+
+Tuttavia, esiste una soluzione alternativa per chi ha bisogno di modificare i certificati CA attendibili a livello di sistema nella directory **`/apex`**. Questa prevede il rimontaggio manuale di **`/apex`** per rimuovere la PRIVATE propagation, rendendolo così scrivibile. Il processo include la copia del contenuto di **`/apex/com.android.conscrypt`** in un'altra posizione, lo smontaggio della directory **`/apex/com.android.conscrypt`** per eliminare il vincolo di sola lettura e poi il ripristino dei contenuti nella loro posizione originale all'interno di **`/apex`**. Questo approccio richiede azione rapida per evitare crash di sistema. Per assicurare l'applicazione delle modifiche a livello di sistema, si raccomanda di riavviare `system_server`, che effettivamente riavvia tutte le applicazioni e riporta il sistema in uno stato consistente.
 ```bash
 # Create a separate temp directory, to hold the current certificates
 # Otherwise, when we add the mount we can't read the current certs anymore.
@@ -117,26 +133,26 @@ echo "System certificate injected"
 ```
 ### Bind-mounting through NSEnter
 
-1. **Impostazione di una Directory Scrivibile**: Inizialmente, viene stabilita una directory scrivibile montando un `tmpfs` sulla directory dei certificati di sistema non-APEX esistente. Questo viene realizzato con il seguente comando:
+1. **Impostazione di una directory scrivibile**: Inizialmente, viene creata una directory scrivibile montando un `tmpfs` sopra l'esistente directory dei certificati di sistema non-APEX. Questo viene ottenuto con il seguente comando:
 ```bash
 mount -t tmpfs tmpfs /system/etc/security/cacerts
 ```
-2. **Preparazione dei certificati CA**: Dopo aver impostato la directory scrivibile, i certificati CA che si intendono utilizzare devono essere copiati in questa directory. Questo potrebbe comportare la copia dei certificati predefiniti da `/apex/com.android.conscrypt/cacerts/`. È essenziale regolare le autorizzazioni e le etichette SELinux di questi certificati di conseguenza.  
-3. **Montaggio Bind per Zygote**: Utilizzando `nsenter`, si entra nello spazio dei nomi di montaggio di Zygote. Zygote, essendo il processo responsabile dell'avvio delle applicazioni Android, richiede questo passaggio per garantire che tutte le applicazioni avviate d'ora in poi utilizzino i nuovi certificati CA configurati. Il comando utilizzato è:
+2. **Preparazione dei certificati CA**: Dopo aver impostato la directory scrivibile, i certificati CA che si intende utilizzare devono essere copiati in questa directory. Questo può comportare la copia dei certificati di default da `/apex/com.android.conscrypt/cacerts/`. È essenziale regolare di conseguenza i permessi e le etichette SELinux di questi certificati.
+3. **Montaggio bind per Zygote**: Utilizzando `nsenter`, si entra nel namespace di mount di Zygote. Zygote, essendo il processo responsabile dell'avvio delle applicazioni Android, richiede questo passaggio per assicurare che tutte le applicazioni avviate d'ora in poi utilizzino i certificati CA appena configurati. Il comando usato è:
 ```bash
 nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
 ```
-Questo garantisce che ogni nuova app avviata aderisca alla configurazione aggiornata dei certificati CA.
+Questo garantisce che ogni nuova app avviata aderirà alla configurazione aggiornata dei certificati CA.
 
-4. **Applicare le modifiche alle app in esecuzione**: Per applicare le modifiche alle applicazioni già in esecuzione, `nsenter` viene nuovamente utilizzato per entrare nel namespace di ciascuna app individualmente e eseguire un montaggio bind simile. Il comando necessario è:
+4. **Applicare le modifiche alle app in esecuzione**: Per applicare le modifiche alle applicazioni già in esecuzione, `nsenter` viene nuovamente usato per entrare nel namespace di ciascuna app individualmente e eseguire un bind mount simile. Il comando necessario è:
 ```bash
 nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
 ```
-5. **Approccio Alternativo - Riavvio Morbido**: Un metodo alternativo prevede di eseguire il bind mount sul processo `init` (PID 1) seguito da un riavvio morbido del sistema operativo con i comandi `stop && start`. Questo approccio propagherebbe le modifiche attraverso tutti i namespace, evitando la necessità di affrontare individualmente ogni app in esecuzione. Tuttavia, questo metodo è generalmente meno preferito a causa dell'inconveniente del riavvio.
+5. **Alternative Approach - Soft Reboot**: Un metodo alternativo consiste nell'eseguire il bind mount sul processo `init` (PID 1) seguito da un soft reboot del sistema operativo con i comandi `stop && start`. Questo approccio propagherebbe le modifiche attraverso tutti i namespaces, evitando la necessità di indirizzare singolarmente ogni app in esecuzione. Tuttavia, questo metodo è generalmente meno preferito a causa dell'inconveniente del reboot.
 
 ## Riferimenti
 
-- [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
-
+- [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
+- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
 
 {{#include ../../banners/hacktricks-training.md}}