From 457d1aeb9e938e16a39d3f2f8d444e3cb8ca3de4 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 21 Aug 2025 04:10:17 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/android-anti-i --- src/SUMMARY.md | 1 + .../android-app-pentesting/README.md | 92 ++++---- ...-instrumentation-and-ssl-pinning-bypass.md | 203 ++++++++++++++++++ 3 files changed, 253 insertions(+), 43 deletions(-) create mode 100644 src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 432bf44fc..e7e49e187 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -326,6 +326,7 @@ - [Android APK Checklist](mobile-pentesting/android-checklist.md) - [Android Applications Pentesting](mobile-pentesting/android-app-pentesting/README.md) - [Accessibility Services Abuse](mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md) + - [Android Anti Instrumentation And Ssl Pinning Bypass](mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md) - [Android Applications Basics](mobile-pentesting/android-app-pentesting/android-applications-basics.md) - [Android Task Hijacking](mobile-pentesting/android-app-pentesting/android-task-hijacking.md) - [ADB Commands](mobile-pentesting/android-app-pentesting/adb-commands.md) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index a100f0002..3eb4bb66d 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -## Nozioni di base sulle Applicazioni Android +## Nozioni di Base sulle Applicazioni Android È altamente consigliato iniziare a leggere questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**: @@ -12,8 +12,8 @@ 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 tramite **rete** da un computer. Questa utility abilita 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. +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 tramite **Rete** da un computer. Questa utility abilita 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. @@ -25,8 +25,8 @@ A volte è interessante **modificare il codice dell'applicazione** per accedere ## Altri trucchi interessanti - [Spoofing della 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) -- [Sfruttamento di meccanismi di aggiornamento in-app insicuri](insecure-in-app-update-rce.md) +- [Shizuku Privileged API (accesso privilegiato non root basato su ADB)](shizuku-privileged-api.md) +- [Sfruttare meccanismi di aggiornamento in-app insicuri](insecure-in-app-update-rce.md) - [Abuso dei Servizi di Accessibilità (Android RAT)](accessibility-services-abuse.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: @@ -65,11 +65,11 @@ Per favore, [**leggi qui per trovare informazioni sui diversi decompilatori disp ### Looking for interesting Info -Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche per **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app). +Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app). **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 verifica se è configurato male. [Maggiori informazioni su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Basic understanding of the application - Manifest.xml, strings.xml @@ -78,14 +78,14 @@ L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può ri **Vulnerabilità** identificate dal **Manifest.xml** includono: - **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare le applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable 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 tramite adb, specialmente quando il debug USB è abilitato. +- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che gestiscono informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato. - **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 le vulnerabilità di input. +- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere scrutinata. +- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per sfruttamenti, prestando particolare attenzione a come vengono gestiti gli schemi URL 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. +Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi personalizzati e altre note degli sviluppatori possono essere scoperte, sottolineando la necessità di una revisione attenta di queste risorse. ### Tapjacking @@ -100,7 +100,7 @@ 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. 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**). Maggiori informazioni in: @@ -115,33 +115,33 @@ android-task-hijacking.md 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. **Static Analysis:** -- **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**. +- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**. 2. **Dynamic Analysis:** -- **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 **autorizzazioni** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **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. **External Storage** 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 su memoria esterna sono **globalmente leggibili e scrivibili**. Ciò 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. +- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** su memoria esterna. - La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura. 3. **Gestione dei Dati dalla Memoria Esterna**: - Esegui sempre **validazione dell'input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile. -- Memorizzare eseguibili o file di classe sulla memoria esterna per il caricamento dinamico è fortemente sconsigliato. +- Memorizzare eseguibili o file di classe su memoria esterna per il caricamento dinamico è fortemente sconsigliato. - Se la tua applicazione deve recuperare file eseguibili dalla memoria esterna, assicurati che questi file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione. 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 malevola 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 dannosa di ottenere accesso in lettura o scrittura ai file di un'altra app. -**Sensitive data stored in clear-text** +**Dati sensibili memorizzati in chiaro** - **Shared preferences**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data//shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella. -- **Databases**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data//databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella. +- **Database**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data//databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella. ### Broken TLS @@ -162,14 +162,14 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa **Utilizzo di algoritmi insicuri e/o deprecati** -Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale. +Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se si utilizzano **hash** per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale. ### 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 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 @@ -190,7 +190,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 @@ -243,14 +243,14 @@ 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 necessitare 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 x86** versioni **supportano le librerie ARM** senza necessità 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] @@ -260,7 +260,7 @@ Per **installare i servizi Google** (come AppStore) in Genymotion devi cliccare ![](<../../images/image (277).png>) -Inoltre, nota che nella **configurazione della VM Android in Genymotion** puoi selezionare **Modalità rete Bridge** (questo sarà utile se ti connetterai alla VM Android da una VM diversa con gli strumenti). +Inoltre, nota che nella **configurazione della VM Android in Genymotion** puoi selezionare **Modalità di rete Bridge** (questo sarà utile se ti connetterai alla VM Android da una VM diversa con gli strumenti). #### Usa un dispositivo fisico @@ -273,7 +273,7 @@ Devi attivare le **opzioni di debug** e sarebbe utile se potessi **rootarlo**: 5. Torna indietro e troverai le **Opzioni sviluppatore**. > Una volta installata l'applicazione, la prima cosa che dovresti fare è provarla e indagare su cosa fa, come funziona e familiarizzare con essa.\ -> Ti suggerisco di **eseguire questa analisi dinamica iniziale utilizzando l'analisi dinamica di MobSF + pidcat**, così saremo in grado di **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati interessanti** che puoi rivedere in seguito. +> Ti suggerisco di **eseguire questa analisi dinamica iniziale utilizzando l'analisi dinamica di MobSF + pidcat**, in modo da poter **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati interessanti** che puoi rivedere in seguito. ### Perdita di dati non intenzionale @@ -306,7 +306,7 @@ I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come ` Se il database sta salvando informazioni riservate ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**. -Enumera le tabelle utilizzando `.tables` e enumera le colonne delle tabelle eseguendo `.schema `. +Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema `. ### Drozer (Attività di sfruttamento, Content Providers e Servizi) @@ -320,7 +320,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) @@ -342,7 +342,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity #### Tapjacking -Se il tapjacking non viene 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 viene 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 @@ -403,7 +403,7 @@ Un [interessante rapporto di bug bounty](https://hackerone.com/reports/855618) s ### Ispezione e verifiche del livello di trasporto - **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni trascurino gli avvisi e accettino certificati autofirmati o, in alcuni casi, tornino a utilizzare connessioni HTTP. -- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati. +- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittografare i dati. - **La perdita di informazioni private** è un rischio quando le applicazioni si autenticano utilizzando canali sicuri ma poi comunicano tramite canali non sicuri per altre transazioni. Questo approccio non riesce a proteggere i dati sensibili, come i cookie di sessione o i dettagli degli utenti, dall'intercettazione da parte di entità malevole. #### Verifica del certificato @@ -418,15 +418,15 @@ SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certifi Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (ad es., Burp). Senza installare questo certificato, il traffico crittografato potrebbe non essere visibile attraverso il proxy. Per una guida sull'installazione di un certificato CA personalizzato, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è fondamentale per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**fai riferimento a questo tutorial**](make-apk-accept-ca-certificate.md). +Le applicazioni destinate a **API Level 24 e superiori** richiedono modifiche alla Configurazione della Sicurezza di Rete per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico crittografato. Per istruzioni su come modificare la Configurazione della Sicurezza di Rete, [**fai riferimento a questo tutorial**](make-apk-accept-ca-certificate.md). -Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, aggiungere semplicemente il certificato nel negozio non funzionerà poiché Flutter ha la propria lista di CAs validi. +Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, aggiungere semplicemente il certificato nel negozio non funzionerà poiché Flutter ha la propria lista di CA valide. #### Bypassare SSL Pinning Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo: -- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare l'SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre. +- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre. - Potresti usare **Frida** (discusso di seguito) per bypassare questa protezione. Qui hai 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 **l'analisi dinamica di MobSF** (spiegato di seguito) @@ -448,6 +448,12 @@ Se vuoi fare pentesting su applicazioni Android, devi sapere come usare Frida. - Puoi trovare alcuni fantastici script 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](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) +#### Flusso di lavoro per il bypass di anti-strumentazione e SSL pinning + +{{#ref}} +android-anti-instrumentation-and-ssl-pinning-bypass.md +{{#endref}} + ### **Dump della memoria - Fridump** Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemonici. @@ -477,7 +483,7 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Utilizzando il seguente script Frida potrebbe essere possibile **bypassare l'autenticazione tramite impronta digitale** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:** +Utilizzando il seguente script Frida, potrebbe essere possibile **bypassare l'autenticazione tramite impronta digitale** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` @@ -515,8 +521,8 @@ Il pericolo risiede nel consentire agli attaccanti di attivare componenti dell'a Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere particolarmente attento a queste vulnerabilità in un'applicazione Android: - **Iniezione SQL:** Quando gestisci query dinamiche o Content-Providers assicurati di utilizzare query parametrizzate. -- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Maggiori informazioni qui](webview-attacks.md#javascript-enabled). -- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Maggiori informazioni qui](webview-attacks.md#javascript-enabled). +- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled). +- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled). - **Cookie Eterni**: In diversi casi, quando l'applicazione android termina la sessione, il cookie non viene revocato o potrebbe essere persino salvato su disco. - [**Flag Sicuro** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) @@ -591,7 +597,7 @@ Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools selezi Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità. > [!TIP] -> Dopo aver eseguito un'analisi dinamica con MobSF, le impostazioni del proxy potrebbero essere mal configurate e non sarai in grado di correggerle dalla GUI. Puoi correggere le impostazioni del proxy eseguendo: +> Dopo aver eseguito un'analisi dinamica con MobSF, le impostazioni del proxy potrebbero essere configurate in modo errato e non sarai in grado di correggerle dalla GUI. Puoi correggere le impostazioni del proxy eseguendo: > > ``` > adb shell settings put global http_proxy :0 @@ -604,7 +610,7 @@ Questo strumento utilizzerà alcuni **Hooks** per farti sapere **cosa sta succed ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Questo è un **ottimo strumento per eseguire analisi statiche con un'interfaccia grafica** +Questo è un **ottimo strumento per eseguire analisi statiche con una GUI** ![](<../../images/image (741).png>) @@ -644,7 +650,7 @@ super-analyzer {apk_file} StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, cacciatori di bug e hacker etici a eseguire [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili. -Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le liste di parole per ottenere un'esperienza personalizzata. +Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le wordlist per ottenere un'esperienza personalizzata. Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -662,7 +668,7 @@ 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**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard). +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). 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... ``` @@ -715,7 +721,7 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg Puoi caricare un APK offuscato sulla loro piattaforma. -### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app +### [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. @@ -729,7 +735,7 @@ APKiD ti fornisce informazioni su **come è stato creato un APK**. Identifica mo ### Manuale -[Leggi questo tutorial per imparare alcuni trucchi su **come fare il reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md) +[Leggi questo tutorial per imparare alcuni trucchi su **come fare reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md) ## Laboratori diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md new file mode 100644 index 000000000..7e8044bb7 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md @@ -0,0 +1,203 @@ +# Android Anti-Instrumentation & SSL Pinning Bypass (Frida/Objection) + +{{#include ../../banners/hacktricks-training.md}} + +Questa pagina fornisce un flusso di lavoro pratico per ripristinare l'analisi dinamica contro le app Android che rilevano/bloccano l'instrumentation o applicano il TLS pinning. Si concentra su una rapida valutazione, rilevamenti comuni e hook/tattiche copiabili per bypassarli senza ripackaging quando possibile. + +## Superficie di Rilevamento (cosa controllano le app) + +- Controlli di root: binario su, percorsi Magisk, valori getprop, pacchetti root comuni +- Controlli Frida/debugger (Java): Debug.isDebuggerConnected(), ActivityManager.getRunningAppProcesses(), getRunningServices(), scansione /proc, classpath, librerie caricate +- Anti-debug nativo: ptrace(), syscalls, anti-attach, breakpoints, inline hooks +- Controlli di early init: Application.onCreate() o hook di avvio processo che si bloccano se l'instrumentation è presente +- TLS pinning: TrustManager/HostnameVerifier personalizzati, OkHttp CertificatePinner, pinning Conscrypt, pin nativi + +## Passo 1 — Vittoria rapida: nascondere il root con Magisk DenyList + +- Abilitare Zygisk in Magisk +- Abilitare DenyList, aggiungere il pacchetto target +- Riavviare e ritestare + +Molte app cercano solo indicatori ovvi (percorsi su/Magisk/getprop). DenyList spesso neutralizza controlli naivi. + +Riferimenti: +- Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk + +## Passo 2 — Test di Frida Codeshare in 30 secondi + +Prova script comuni drop-in prima di approfondire: + +- anti-root-bypass.js +- anti-frida-detection.js +- hide_frida_gum.js + +Esempio: +```bash +frida -U -f com.example.app -l anti-frida-detection.js +``` +Questi tipicamente stub controlli Java root/debug, scansione di processi/servizi e ptrace() nativo. Utile su app leggermente protette; obiettivi rinforzati potrebbero necessitare di hook personalizzati. + +- Codeshare: https://codeshare.frida.re/ + +## Step 3 — Bypass dei rilevatori di init-time attaccando in ritardo + +Molte rilevazioni vengono eseguite solo durante la creazione del processo/onCreate(). L'iniezione al momento della creazione (-f) o gadget vengono catturati; attaccarsi dopo il caricamento dell'interfaccia utente può sfuggire. +```bash +# Launch the app normally (launcher/adb), wait for UI, then attach +frida -U -n com.example.app +# Or with Objection to attach to running process +aobjection --gadget com.example.app explore # if using gadget +``` +Se questo funziona, mantieni la sessione stabile e procedi a mappare e controllare gli stub. + +## Passo 4 — Mappa la logica di rilevamento tramite Jadx e ricerca di stringhe + +Parole chiave di triage statico in Jadx: +- "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger" + +Modelli Java tipici: +```java +public boolean isFridaDetected() { +return getRunningServices().contains("frida"); +} +``` +API comuni da rivedere/agganciare: +- android.os.Debug.isDebuggerConnected +- android.app.ActivityManager.getRunningAppProcesses / getRunningServices +- java.lang.System.loadLibrary / System.load (native bridge) +- java.lang.Runtime.exec / ProcessBuilder (probing commands) +- android.os.SystemProperties.get (root/emulator heuristics) + +## Passo 5 — Stubbing a runtime con Frida (Java) + +Sovrascrivi le guardie personalizzate per restituire valori sicuri senza ripackaging: +```js +Java.perform(() => { +const Checks = Java.use('com.example.security.Checks'); +Checks.isFridaDetected.implementation = function () { return false; }; + +// Neutralize debugger checks +const Debug = Java.use('android.os.Debug'); +Debug.isDebuggerConnected.implementation = function () { return false; }; + +// Example: kill ActivityManager scans +const AM = Java.use('android.app.ActivityManager'); +AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); }; +}); +``` +Triaging early crashes? Dumpa le classi poco prima che si blocchi per individuare i namespace di rilevamento probabili: +```js +Java.perform(() => { +Java.enumerateLoadedClasses({ +onMatch: n => console.log(n), +onComplete: () => console.log('Done') +}); +}); +``` +Registra e neutralizza i metodi sospetti per confermare il flusso di esecuzione: +```js +Java.perform(() => { +const Det = Java.use('com.example.security.DetectionManager'); +Det.checkFrida.implementation = function () { +console.log('checkFrida() called'); +return false; +}; +}); +``` +## Step 6 — Segui il percorso JNI/nativo quando i hook Java falliscono + +Traccia i punti di ingresso JNI per localizzare i caricamenti nativi e l'inizializzazione della rilevazione: +```bash +frida-trace -n com.example.app -i "JNI_OnLoad" +``` +Valutazione rapida nativa 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' +``` +Interactive/native reversing: +- Ghidra: https://ghidra-sre.org/ +- r2frida: https://github.com/nowsecure/r2frida + +Esempio: neuter ptrace per sconfiggere un semplice anti‑debug in libc: +```js +const ptrace = Module.findExportByName(null, 'ptrace'); +if (ptrace) { +Interceptor.replace(ptrace, new NativeCallback(function () { +return -1; // pretend failure +}, 'int', ['int', 'int', 'pointer', 'pointer'])); +} +``` +Vedi anche: {{#ref}} +reversing-native-libraries.md +{{#endref}} + +## Passo 7 — Patching con Objection (embed gadget / strip basics) + +Quando preferisci il repacking ai runtime hooks, prova: +```bash +objection patchapk --source app.apk +``` +Note: +- Richiede apktool; assicurati di avere una versione attuale dalla guida ufficiale per evitare problemi di build: https://apktool.org/docs/install +- L'iniezione di gadget consente l'istrumentazione senza root ma può comunque essere rilevata da controlli più severi all'avvio. + +Riferimenti: +- Objection: https://github.com/sensepost/objection + +## Passo 8 — Fallback: Patch TLS pinning per la visibilità della rete + +Se l'istrumentazione è bloccata, puoi comunque ispezionare il traffico rimuovendo il pinning in modo statico: +```bash +apk-mitm app.apk +# Then install the patched APK and proxy via Burp/mitmproxy +``` +- Strumento: https://github.com/shroudedcode/apk-mitm +- Per trucchi di configurazione della rete CA‑trust (e fiducia CA utente Android 7+), vedere: +{{#ref}} +make-apk-accept-ca-certificate.md +{{#endref}} +{{#ref}} +install-burp-certificate.md +{{#endref}} + +## Comandi utili cheat‑sheet +```bash +# List processes and attach +frida-ps -Uai +frida -U -n com.example.app + +# Spawn with a script (may trigger detectors) +frida -U -f com.example.app -l anti-frida-detection.js + +# Trace native init +frida-trace -n com.example.app -i "JNI_OnLoad" + +# Objection runtime +objection --gadget com.example.app explore + +# Static TLS pinning removal +apk-mitm app.apk +``` +## Suggerimenti e avvertenze + +- Preferisci allegare tardi piuttosto che generare nuovi processi quando le app si bloccano all'avvio +- Alcune rilevazioni vengono rieseguite in flussi critici (ad es., pagamento, autenticazione) — mantieni gli hook attivi durante la navigazione +- Mescola statico e dinamico: cerca stringhe in Jadx per selezionare classi; poi aggancia i metodi per verificare a runtime +- Le app rinforzate possono utilizzare packer e pinning TLS nativo — aspettati di fare reverse del codice nativo + +## Riferimenti + +- [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/) +- [Frida Codeshare](https://codeshare.frida.re/) +- [Objection](https://github.com/sensepost/objection) +- [apk-mitm](https://github.com/shroudedcode/apk-mitm) +- [Jadx](https://github.com/skylot/jadx) +- [Ghidra](https://ghidra-sre.org/) +- [r2frida](https://github.com/nowsecure/r2frida) +- [Apktool install guide](https://apktool.org/docs/install) +- [Magisk](https://github.com/topjohnwu/Magisk) + +{{#include ../../banners/hacktricks-training.md}}