diff --git a/src/mobile-pentesting/android-app-pentesting/react-native-application.md b/src/mobile-pentesting/android-app-pentesting/react-native-application.md index d0cc2103f..f954bec6b 100644 --- a/src/mobile-pentesting/android-app-pentesting/react-native-application.md +++ b/src/mobile-pentesting/android-app-pentesting/react-native-application.md @@ -1,15 +1,29 @@ -{{#include ../../banners/hacktricks-training.md}} - # Analisi dell'Applicazione React Native +{{#include ../../banners/hacktricks-training.md}} + Per confermare se l'applicazione è stata costruita sul framework React Native, segui questi passaggi: 1. Rinomina il file APK con un'estensione zip ed estrailo in una nuova cartella usando il comando `cp com.example.apk example-apk.zip` e `unzip -qq example-apk.zip -d ReactNative`. -2. Naviga nella nuova cartella ReactNative e individua la cartella assets. All'interno di questa cartella, dovresti trovare il file `index.android.bundle`, che contiene il JavaScript React in un formato minificato. +2. Naviga nella nuova cartella ReactNative e individua la cartella assets. All'interno di questa cartella, dovresti trovare il file `index.android.bundle`, che contiene il JavaScript React in formato minificato. 3. Usa il comando `find . -print | grep -i ".bundle$"` per cercare il file JavaScript. +Nota: Se ti viene fornito un Android App Bundle (.aab) invece di un APK, genera prima un APK universale e poi estrai il bundle: +```bash +# Get bundletool.jar and generate a universal APK set +java -jar bundletool.jar build-apks \ +--bundle=app-release.aab \ +--output=app.apks \ +--mode=universal \ +--overwrite + +# Extract the APK and then unzip it to find assets/index.android.bundle +unzip -p app.apks universal.apk > universal.apk +unzip -qq universal.apk -d ReactNative +ls ReactNative/assets/ +``` ## Codice Javascript Se controllando i contenuti di `index.android.bundle` trovi il codice JavaScript dell'applicazione (anche se minificato), puoi **analizzarlo per trovare informazioni sensibili e vulnerabilità**. @@ -18,7 +32,7 @@ Poiché il bundle contiene effettivamente tutto il codice JS dell'applicazione, ### Webpack -Per analizzare ulteriormente il codice JavaScript, puoi caricare il file su [https://spaceraccoon.github.io/webpack-exploder/](https://spaceraccoon.github.io/webpack-exploder/) o seguire questi passaggi: +Per analizzare ulteriormente il codice JavaScript, puoi caricare il file su [https://spaceraccoon.github.io/webpack-exploder/](https://spaceraccoon.github.io/webpack-exploder/) oppure seguire questi passaggi: 1. Crea un file chiamato `index.html` nella stessa directory con il seguente codice: ```html @@ -36,46 +50,146 @@ Per cercare credenziali sensibili e endpoint, segui questi passaggi: 1. Identifica parole chiave sensibili per analizzare il codice JavaScript. Le applicazioni React Native spesso utilizzano servizi di terze parti come Firebase, endpoint del servizio AWS S3, chiavi private, ecc. -2. In questo caso specifico, è stato osservato che l'applicazione utilizzava il servizio Dialogflow. Cerca un modello relativo alla sua configurazione. +2. In questo caso specifico, è stato osservato che l'applicazione stava utilizzando il servizio Dialogflow. Cerca un modello relativo alla sua configurazione. 3. È stato fortunato che credenziali sensibili hard-coded siano state trovate nel codice JavaScript durante il processo di ricognizione. -### Cambia il codice JS e ricostruisci +### Ricerca rapida di segreti/endpoint nei bundle -In questo caso cambiare il codice è facile. Devi solo rinominare l'app per utilizzare l'estensione `.zip` ed estrarla. Poi puoi **modificare il codice JS all'interno di questo bundle e ricostruire l'app**. Questo dovrebbe essere sufficiente per permetterti di **iniettare codice** nell'app per scopi di test. +Questi semplici greps spesso rivelano indicatori interessanti anche in JS minificato: +```bash +# Common backends and crash reporters +strings -n 6 index.android.bundle | grep -Ei "(api\.|graphql|/v1/|/v2/|socket|wss://|sentry\.io|bugsnag|appcenter|codepush|firebaseio\.com|amplify|aws)" -## Bytecode Hermes +# Firebase / Google keys (heuristics) +strings -n 6 index.android.bundle | grep -Ei "(AIza[0-9A-Za-z_-]{35}|AIzaSy[0-9A-Za-z_-]{33})" -Se il bundle contiene **bytecode Hermes**, **non potrai accedere al codice Javascript** dell'app (neanche alla versione minificata). +# AWS access key id heuristic +strings -n 6 index.android.bundle | grep -E "AKIA[0-9A-Z]{16}" -Puoi controllare se il bundle contiene bytecode Hermes eseguendo il seguente comando: +# Expo/CodePush deployment keys +strings -n 6 index.android.bundle | grep -Ei "(CodePush|codepush:\\/\\/|DeploymentKey)" + +# Sentry DSN +strings -n 6 index.android.bundle | grep -Ei "(Sentry\.init|dsn\s*:)" +``` +Se sospetti framework di aggiornamento Over-The-Air, cerca anche: +- Microsoft App Center / CodePush chiavi di distribuzione +- Configurazione Expo EAS Updates (`expo-updates`, `expo\.io`, certificati di firma) + +### Modifica il codice JS e ricompila + +In questo caso, modificare il codice è facile. Devi solo rinominare l'app per utilizzare l'estensione `.zip` ed estrarla. Poi puoi **modificare il codice JS all'interno di questo pacchetto e ricompilare l'app**. Questo dovrebbe essere sufficiente per permetterti di **iniettare codice** nell'app per scopi di test. + +## Bytecode Hermes + +Se il pacchetto contiene **bytecode Hermes**, **non sarai in grado di accedere al codice Javascript** dell'app (neanche alla versione minificata). + +Puoi controllare se il pacchetto contiene bytecode Hermes eseguendo il seguente comando: ```bash file index.android.bundle index.android.bundle: Hermes JavaScript bytecode, version 96 ``` -Tuttavia, puoi utilizzare gli strumenti **[hbctool](https://github.com/bongtrop/hbctool)**, **[hermes-dec](https://github.com/P1sec/hermes-dec)** o **[hermes_rs](https://github.com/Pilfer/hermes_rs)** per **disassemblare il bytecode** e anche per **decompilarlo in un codice JS pseudo**. Per fare ciò, ad esempio, questi comandi: +Tuttavia, puoi utilizzare gli strumenti **[hbctool](https://github.com/bongtrop/hbctool)**, fork aggiornati di hbctool che supportano versioni più recenti del bytecode, **[hasmer](https://github.com/lucasbaizer2/hasmer)**, **[hermes_rs](https://github.com/Pilfer/hermes_rs)** (libreria/API Rust), o **[hermes-dec](https://github.com/P1sec/hermes-dec)** per **disassemblare il bytecode** e anche per **decompilarlo in un codice pseudo JS**. Ad esempio: ```bash +# Disassemble and re-assemble with hbctool (works only for supported HBC versions) +hbctool disasm ./index.android.bundle ./hasm_out +# ...edit ./hasm_out/**/*.hasm (e.g., change comparisons, constants, feature flags)... +hbctool asm ./hasm_out ./index.android.bundle + +# Using hasmer (focus on disassembly; assembler/decompiler are WIP) +hasmer disasm ./index.android.bundle -o hasm_out + +# Using hermes-dec to produce pseudo-JS hbc-disassembler ./index.android.bundle /tmp/my_output_file.hasm -hbc-decompiler ./index.android.bundle /tmp/my_output_file.js +hbc-decompiler ./index.android.bundle /tmp/my_output_file.js ``` -### Modifica il codice e ricostruisci +Suggerimento: Il progetto open-source Hermes include anche strumenti per sviluppatori come `hbcdump` in specifiche versioni di Hermes. Se costruisci la versione corrispondente di Hermes utilizzata per produrre il bundle, `hbcdump` può estrarre funzioni, tabelle di stringhe e bytecode per un'analisi più approfondita. -Idealmente dovresti essere in grado di modificare il codice disassemblato (cambiando un confronto, un valore o qualsiasi cosa tu debba modificare) e poi **ricostruire il bytecode** e poi ricostruire l'app. +### Modifica il codice e ricostruisci (Hermes) -Lo strumento **[hbctool](https://github.com/bongtrop/hbctool)** supporta il disassemblaggio del bundle e la ricostruzione dopo che sono state apportate le modifiche, tuttavia **supporta solo versioni obsolete** del bytecode di Hermes. +Idealmente dovresti essere in grado di modificare il codice disassemblato (cambiando un confronto, un valore o qualsiasi cosa tu debba modificare) e poi **ricostruire il bytecode** e ricostruire l'app. -Lo strumento **[hermes-dec](https://github.com/P1sec/hermes-dec)** non supporta la ricostruzione del bytecode. +- L'originale **[hbctool](https://github.com/bongtrop/hbctool)** supporta il disassemblaggio del bundle e la ricostruzione dopo le modifiche, ma storicamente supportava solo versioni di bytecode più vecchie. I fork mantenuti dalla comunità estendono il supporto a versioni più recenti di Hermes (inclusi gli anni '80–96) e sono spesso l'opzione più pratica per patchare le app RN moderne. +- Lo strumento **[hermes-dec](https://github.com/P1sec/hermes-dec)** non supporta la ricostruzione del bytecode (solo decompilatore/disassemblatore), ma è molto utile per navigare nella logica e estrarre stringhe. +- Lo strumento **[hasmer](https://github.com/lucasbaizer2/hasmer)** mira a supportare sia il disassemblaggio che l'assemblaggio per più versioni di Hermes; l'assemblaggio è ancora in fase di sviluppo ma vale la pena provare su bytecode recenti. -Lo strumento **[hermes_rs](https://github.com/Pilfer/hermes_rs)** supporta la ricostruzione del bytecode, ma è in realtà una libreria e non uno strumento CLI. +Un flusso di lavoro minimale con assemblatori simili a hbctool: +```bash +# 1) Disassemble to HASM directories +hbctool disasm assets/index.android.bundle ./hasm + +# 2) Edit a guard or feature flag (example: force boolean true) +# In the relevant .hasm, replace a LoadConstUInt8 0 with 1 +# or change a conditional jump target to bypass a check. + +# 3) Reassemble into a new bundle +hbctool asm ./hasm assets/index.android.bundle + +# 4) Repack the APK and resign +zip -r ../patched.apk * +# Align/sign as usual (see Android signing section in HackTricks) +``` +Nota che il formato del bytecode di Hermes è versionato e l'assemblatore deve corrispondere esattamente al formato su disco. Se ricevi errori di formato, passa a un fork/alternativa aggiornato o ricostruisci gli strumenti Hermes corrispondenti. ## Analisi Dinamica -Potresti provare ad analizzare dinamicamente l'app utilizzando Frida per abilitare la modalità sviluppatore dell'app React e utilizzare **`react-native-debugger`** per collegarti ad essa. Tuttavia, per questo hai apparentemente bisogno del codice sorgente dell'app. Puoi trovare ulteriori informazioni su questo in [https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/](https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/). +Potresti provare ad analizzare dinamicamente l'app utilizzando Frida per abilitare la modalità sviluppatore dell'app React e utilizzare **`react-native-debugger`** per collegarti ad essa. Tuttavia, per questo hai apparentemente bisogno del codice sorgente dell'app. Puoi trovare ulteriori informazioni su [https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/](https://newsroom.bedefended.com/hooking-react-native-applications-with-frida/). +### Abilitare il Supporto Dev in release con Frida (avvertenze) + +Alcune app inviano accidentalmente classi che rendono il Supporto Dev attivabile. Se presente, puoi provare a forzare `getUseDeveloperSupport()` a restituire true: +```javascript +// frida -U -f com.target.app -l enable-dev.js +Java.perform(function(){ +try { +var Host = Java.use('com.facebook.react.ReactNativeHost'); +Host.getUseDeveloperSupport.implementation = function(){ +return true; // force dev support +}; +console.log('[+] Patched ReactNativeHost.getUseDeveloperSupport'); +} catch (e) { +console.log('[-] Could not patch: ' + e); +} +}); +``` +Warning: Nei build di rilascio costruiti correttamente, `DevSupportManagerImpl` e le classi correlate solo per il debug vengono rimosse e attivare questo flag può far crashare l'app o non avere alcun effetto. Quando funziona, puoi tipicamente esporre il menu di sviluppo e collegare debugger/ispettori. + +### Intercettazione della rete nelle app RN + +React Native Android si basa tipicamente su OkHttp sotto il cofano (tramite il modulo nativo `Networking`). Per intercettare/osservare il traffico su un dispositivo non rootato durante i test dinamici: +- Usa un proxy di sistema + fidati del CA dell'utente o utilizza altre tecniche generiche di bypass TLS Android. +- Suggerimento specifico per RN: se l'app include Flipper in rilascio per errore (strumenti di debug), il plugin di rete Flipper può esporre richieste/riposte. + +Per tecniche generiche di intercettazione Android e bypass di pinning, fai riferimento a: + +{{#ref}} +make-apk-accept-ca-certificate.md +{{#endref}} + +{{#ref}} +frida-tutorial/objection-tutorial.md +{{#endref}} + +## Problemi recenti nelle librerie RN popolari (cosa cercare) + +Quando si auditano i moduli di terze parti visibili nel bundle JS o nelle librerie native, controlla le vulnerabilità note e verifica le versioni in `package.json`/`yarn.lock`. + +- react-native-mmkv (Android): le versioni precedenti alla 2.11.0 registravano la chiave di crittografia opzionale nei log di Android. Se ADB/logcat è disponibile, i segreti potrebbero essere recuperati. Assicurati di avere >= 2.11.0. Indicatori: utilizzo di `react-native-mmkv`, dichiarazioni di log che menzionano l'inizializzazione di MMKV con crittografia. CVE-2024-21668. +- react-native-document-picker: le versioni < 9.1.1 erano vulnerabili a traversate di percorso su Android (selezione file), corretto in 9.1.1. Valida gli input e la versione della libreria. + +Controlli rapidi: +```bash +grep -R "react-native-mmkv" -n {index.android.bundle,*.map} 2>/dev/null || true +grep -R "react-native-document-picker" -n {index.android.bundle,*.map} 2>/dev/null || true +# If you also have the node_modules (rare on release): grep -R in package.json / yarn.lock +``` ## Riferimenti - [https://medium.com/bugbountywriteup/lets-know-how-i-have-explored-the-buried-secrets-in-react-native-application-6236728198f7](https://medium.com/bugbountywriteup/lets-know-how-i-have-explored-the-buried-secrets-in-react-native-application-6236728198f7) - [https://www.assetnote.io/resources/research/expanding-the-attack-surface-react-native-android-applications](https://www.assetnote.io/resources/research/expanding-the-attack-surface-react-native-android-applications) - [https://payatu.com/wp-content/uploads/2023/02/Mastering-React-Native-Application-Pentesting-A-Practical-Guide-2.pdf](https://payatu.com/wp-content/uploads/2023/02/Mastering-React-Native-Application-Pentesting-A-Practical-Guide-2.pdf) +- CVE-2024-21668: react-native-mmkv registra la chiave di crittografia dei log su Android, risolto in v2.11.0 (NVD): https://nvd.nist.gov/vuln/detail/CVE-2024-21668 +- hbctool (e fork) per assemblare/disassemblare Hermes: https://github.com/bongtrop/hbctool {{#include ../../banners/hacktricks-training.md}}