Analisi dell'Applicazione React Native

Reading time: 10 minutes

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 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:

# 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à.

Poiché il bundle contiene effettivamente tutto il codice JS dell'applicazione, è possibile dividerlo in diversi file (potenzialmente facilitando il suo reverse engineering) utilizzando lo strumento react-native-decompiler.

Webpack

Per analizzare ulteriormente il codice JavaScript, puoi caricare il file su https://spaceraccoon.github.io/webpack-exploder/ oppure seguire questi passaggi:

1. Crea un file chiamato index.html nella stessa directory con il seguente codice:

<script src="./index.android.bundle"></script>

2. Apri il file index.html in Google Chrome.

3. Apri la Developer Toolbar premendo Command+Option+J per OS X o Control+Shift+J per Windows.

4. Clicca su "Sources" nella Developer Toolbar. Dovresti vedere un file JavaScript suddiviso in cartelle e file, che compongono il bundle principale.

Se trovi un file chiamato index.android.bundle.map, potrai analizzare il codice sorgente in un formato non minificato. I file di mappatura contengono mappature sorgente, che ti permettono di mappare identificatori minificati.

Per cercare credenziali sensibili ed 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 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.

Ricerca rapida di segreti/endpoint nei bundle

Questi semplici greps spesso rivelano indicatori interessanti anche in JS minificato:

# 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)"

# Firebase / Google keys (heuristics)
strings -n 6 index.android.bundle | grep -Ei "(AIza[0-9A-Za-z_-]{35}|AIzaSy[0-9A-Za-z_-]{33})"

# AWS access key id heuristic
strings -n 6 index.android.bundle | grep -E "AKIA[0-9A-Z]{16}"

# 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 / chiavi di distribuzione CodePush
• 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 bundle e ricompilare l'app. Questo dovrebbe essere sufficiente per permetterti di iniettare codice nell'app per scopi di test.

Bytecode Hermes

Se il bundle contiene bytecode Hermes, non sarai in grado di accedere al codice Javascript dell'app (neanche alla versione minificata).

Puoi controllare se il bundle contiene bytecode Hermes eseguendo il seguente comando:

file index.android.bundle
index.android.bundle: Hermes JavaScript bytecode, version 96

Tuttavia, puoi utilizzare gli strumenti hbctool, fork aggiornati di hbctool che supportano versioni più recenti del bytecode, hasmer, hermes_rs (libreria/API Rust), o hermes-dec per disassemblare il bytecode e anche per decompilarlo in un codice pseudo JS. Ad esempio:

# 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

Tip: 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.

Modifica il codice e ricostruisci (Hermes)

Idealmente dovresti essere in grado di modificare il codice disassemblato (cambiando un confronto, o un valore o qualsiasi cosa tu debba modificare) e poi ricostruire il bytecode e ricostruire l'app.

• Il hbctool originale 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 app moderne di RN.
• Lo strumento hermes-dec non supporta la ricostruzione del bytecode (solo decompilatore/disassemblatore), ma è molto utile per navigare nella logica e estrarre stringhe.
• Lo strumento 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.

Un flusso di lavoro minimale con assemblatori simili a hbctool:

# 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 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:

// 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:

Make APK Accept CA Certificate

Objection Tutorial

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), risolto nella 9.1.1. Valida gli input e la versione della libreria.

Controlli rapidi:

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://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
• 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