Translated ['src/mobile-pentesting/android-app-pentesting/react-native-a

This commit is contained in:
Translator 2025-08-21 04:16:17 +00:00
parent 457d1aeb9e
commit 7507e3d3f3

View File

@ -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 '8096) 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}}