Obiettivo: Dimostrare la cattura di flussi VoIP effettuando l'hook dell'audioserver di Android (in particolare libaudioflinger.so) e registrando i buffer PCM in uplink (microfono) e downlink (altoparlante) quando il sistema è in modalità comunicazione.

Progettazione e Metodologia

Architettura:

• App di Controllo (Android)
  Interfaccia con 9 pulsanti per gestire la configurazione delle policy SELinux, l'iniezione del payload, lo spostamento dei dati e la riproduzione.

• Payload (libaudiohook.so)
  Libreria condivisa C++ (compilata come parte del progetto dell'app) che aggancia i metodi interni di AudioFlinger usando Dobby e scrive i buffer PCM grezzi in una directory di sessione.

• Post-Elaborazione
  Strumento aggiuntivo, tools/audioparser.py, converte i file grezzi .ac(Downlink)/.bc(Uplink) in WAV. Il file manager dell'app può anche convertire e riprodurre in-app.

• Utility di Ricerca
  Script Frida per il tracciamento iniziale delle funzioni e la scoperta degli offset; file di analisi per simboli/offset e altri frammenti.

App di Controllo

Questa applicazione Android fornisce un'interfaccia grafica per gestire la registrazione VoIP tramite l'audioserver. Si integra con un payload nativo che si aggancia allo stack audio di Android per catturare l'audio del microfono e dell'altoparlante dalle applicazioni VoIP.

L'app funge da centro di controllo, consentendo di iniettare le policy SELinux richieste, avviare/fermare il monitoraggio, gestire i dati registrati e riprodurre i file audio VoIP catturati.

Funzionalità

L'attività principale contiene 9 pulsanti di controllo:

1. Inietta Policy
   Inietta le policy SELinux necessarie affinché audioserver e questa app funzionino insieme.

2. Avvia Monitoraggio
   Inietta il payload della libreria condivisa in audioserver, abilitando la cattura dell'audio VoIP tramite hook di RecordTrack e PlaybackTrack. Usa AndKittyInjector per l'iniezione di processo.

3. Ferma Monitoraggio
   Riavvia il processo audioserver, fermando il monitoraggio e rimuovendo gli hook iniettati.

4. Copia Dati
   Copia l'audio PCM grezzo catturato dalla directory temporanea /data/local/tmp/voip a /sdcard/voip.

   • Pulisce la directory temporanea dopo l'operazione.

5. Visualizza Log
   Mostra i log relativi all'iniezione, all'hook e allo stato della registrazione.

6. Abilita SELinux
   Ripristina la modalità enforcing di SELinux.

7. Disabilita SELinux
   Imposta SELinux in modalità permissive. Usalo quando le policy iniettate falliscono.

8. Riproduci Audio
   Apre il File Manager VoIP personalizzato (/sdcard/voip/):

+----------------------+    
|                      |    
|   App MainActivity   |    
|                      |    
|                      |    
|(9 Control Buttons UI)|    
|                      |    
|                      |    
+----------+-----------+    
           |                
           |                
           |                
+----------v-----------+    
|                      |    
|       JNI Layer      |    
|                      |    
| Selinux, Process Inje|    
| ction,               |    
|                      |    
|                      |    
+----------------------+    

Payload di Hook

Questa libreria condivisa viene iniettata in audioserver per rilevare AUDIO_MODE_IN_COMMUNICATION e catturare i flussi audio VoIP direttamente dallo stack audio di Android per un set predefinito di nomi pacchetto.

Usa il framework di hooking inline Dobby per intercettare metodi critici all'interno di libaudioflinger.so.
Entrambi i flussi audio uplink (microfono) e downlink (altoparlante) vengono catturati e scritti in file di sessione per l'elaborazione successiva.

Punti di Hook

La libreria installa hook sulle seguenti funzioni all'interno di AudioFlinger e classi correlate:

Applicazioni Target

La libreria filtra i flussi in base al mapping UID → Pacchetto.

App attualmente monitorate:

• com.whatsapp
• com.whatsapp.w4b (WhatsApp Business)
• org.thoughtcrime.securesms (Signal)
• org.telegram.messenger
• org.telegram.messenger.web

Puoi aggiungere altre applicazioni anche all'interno di audioserver_hook.cpp:

static const char* kTargetPackages[] = {  
    "com.whatsapp",  
    "com.whatsapp.w4b",  
    "org.thoughtcrime.securesms",  
    "org.telegram.messenger",  
    "org.telegram.messenger.web"  
};

Output dei File

• Una directory di sessione viene creata all'iniezione in audioserver in: /data/local/tmp/voip/audioserver_session_<timestamp>/

• I file vengono prima creati con estensione .tmp, poi rinominati all'arresto della traccia:

  • Uplink (mic) → <packageName>_<sampleRate>_<timestamp>.bc
  • Downlink (speaker) → <packageName>_<sampleRate>_<timestamp>.ac

• Esempio di sessione:

	/data/local/tmp/voip/audioserver_session_1725389200/
	├── com.whatsapp_48000_1725389201_123456.ac
	├── com.whatsapp_48000_1725389201_123789.bc
	

Offset

Poiché la libreria target è strippata e i metodi non sono esportati in libaudioflinger.so, abbiamo bisogno di offset esatti dei metodi e di altri componenti correlati per un hooking efficace.

Possiamo estrarre questi offset tramite analisi statica con IDA-PRO o analisi dinamica con Frida.
Una volta noti gli offset, possiamo sostituirli all'interno del file header offsets.h.

Offset Richiesti:

Metodi:

1. AUDIOFLINGER_SETMODE_OFFSET
   • Metodo: android::AudioFlinger::setMode(audio_mode_t)
   • Nome mangled: _ZN7android12AudioFlinger7setModeE11audio_mode_t
2. RECORDTRACK_GETNEXTBUFFER_OFFSET
   • Metodo: android::AudioFlinger::RecordThread::RecordTrack::getNextBuffer(android::AudioBufferProvider::Buffer *)
   • Nome mangled: _ZN7android12AudioFlinger12RecordThread11RecordTrack13getNextBufferEPNS_19AudioBufferProvider6BufferE
3. TRACK_GETNEXTBUFFER_OFFSET
   • Metodo: android::AudioFlinger::PlaybackThread::Track::getNextBuffer(android::AudioBufferProvider::Buffer *)
   • Nome mangled: _ZN7android12AudioFlinger14PlaybackThread5Track13getNextBufferEPNS_19AudioBufferProvider6BufferE
4. TRACK_STOP_OFFSET
   • Metodo: android::AudioFlinger::PlaybackThread::Track::stop(void)
   • Nome mangled: _ZN7android12AudioFlinger14PlaybackThread5Track4stopEv

Altri Offset:

1. SAMPLERATE_OFFSET
2. UID_OFFSET
3. ISOUT_OFFSET
4. FORMAT_OFFSET
5. CHANNELMASK_OFFSET
6. ATTR_OFFSET

Questi possono essere ottenuti tramite analisi statica.

• Libreria - libaudioflinger.so
• Metodo - android::AudioFlinger::ThreadBase::TrackBase::TrackBase

TrackBase::TrackBase(
        IAfThreadBase *thread,
            const sp<Client>& client,
            const audio_attributes_t& attr,
            uint32_t sampleRate,
            audio_format_t format,
            audio_channel_mask_t channelMask,
            size_t frameCount,
            void *buffer,
            size_t bufferSize,
            audio_session_t sessionId,
            pid_t creatorPid,
            uid_t clientUid,
            bool isOut,
            const alloc_type alloc,
            track_type type,
            audio_port_handle_t portId,
            std::string metricsId)

Note

Viene catturata solo la modalità IN_COMMUNICATION. L'audio normale (musica, suoneria, ecc.) viene ignorato.

La gestione speciale per Telegram e Signal impone frequenze di campionamento corrette (Telegram: 48000 Hz, Signal: 8000 Hz) per ignorare altri audio non necessari come squilli del telefono e suoni di disconnessione.

Il PCM viene salvato grezzo; l'app di controllo converte successivamente PCM → WAV per la riproduzione.

 ┌─────────────────────────────┐
 │        VoIP Apps            │
 │  (WhatsApp / Signal / TG)   │
 └───────────────┬─────────────┘
                 │ Audio in/out
                 ▼
 ┌─────────────────────────────┐
 │       audioserver           │
 │  (libaudioflinger.so)       │
 └───────┬─────────┬───────────┘
         │         │
   uplink│         │downlink
 (mic)   │         │(speaker)
         ▼         ▼
 ┌───────────-──┐   ┌────────────-─┐
 │ RecordTrack  │   │  Track       │
 │ getNextBuffer│   │ getNextBuffer│
 └───────┬────-─┘   └───────┬────-─┘
         │                 │
   ┌─────▼─────┐     ┌─────▼─────┐
   │ hook_...  │     │ hook_...  │
   │ (uplink)  │     │ (downlink)│
   └─────┬─────┘     └─────┬─────┘
         │                 │
         └──────┬───┬──────┘
                │   │
                ▼   ▼
     ┌───────────────────────────┐
     │  /data/local/tmp/voip/    │
     │  audioserver_session_*    │
     │   - *.bc  (uplink)        │
     │   - *.ac  (downlink)      │
     └───────────────────────────┘

Identificazione delle Funzioni Target

Processo utilizzato:

1. Tracciamento dinamico - Frida:
   • Utilizzato Frida per tracciare tutte le chiamate di funzione durante una chiamata VoIP
   • Filtrate tutte le funzioni responsabili della gestione dei buffer audio.
   • Quindi creati script Frida per catturare e gestire i buffer audio.
2. Revisione AOSP e mappatura delle classi
   • AudioFlinger gestisce riproduzione/cattura tramite PlaybackThread e RecordThread.
   • L'audio per client è rappresentato da PlaybackThread::Track (downlink) e RecordThread::RecordTrack (uplink).
3. Filtraggio dei flussi specifici per app
   • Utilizzato il mapping UID→pacchetto per limitare alle app target.
4. Stabilità e offset
   • Il payload nativo finale risolve gli indirizzi tramite base + offset hardcoded (conservati in app/src/main/cpp/include/offsets.h) per sopravvivere ai simboli strippati.

Rilevare MODE_IN_COMMUNICATION

Facciamo l'hook di AudioFlinger::setMode(int mode) e manteniamo uno stato globale:

• A ogni chiamata, registriamo il cambio di modalità e aggiorniamo g_currentAudioMode.
• Gli hook (sia nell'hook del microfono che in quello dell'altoparlante) controllano che g_currentAudioMode == AUDIO_MODE_IN_COMMUNICATION.
• Questo garantisce di scaricare i buffer solo mentre una sessione VoIP è attiva, evitando musica/suonerie/riproduzione del dispositivo/registrazioni del microfono, ecc.

Compilazione ed Esecuzione della PoC

Struttura del Progetto

.
├── Android_App/ 
|   ├── app/                           # Android Studio project (App + Payload)
|	│   ├── src/
|	│   │   ├── main/
|	│   │   │   ├── java/              # Controller App Java/Kotlin sources
|	│   │   │   ├── cpp/               # Payload source (built with the app)
|	│   │   │   │   └── include/
|	│   │   │   │       └── offsets.h  # Function offsets for tested builds
├── tools/
│   ├── audioparser.py             # Converts .ac/.bc raw files → WAV
│   ├── frida/                     # Frida scripts for initial hook discovery
│   │   ├── host_audioserver.py
│   │   ├── agent_audioserver.js
├── app-release.apk                 # Signed release apk
└── README.md                       # Root README (design, build, run instructions)

Prerequisiti

• Android Studio + NDK
• Emulatore rooted (es. rootAVD) o dispositivo di test di tua proprietà (es. Magisk)
• App VoIP di test installate (le stesse che possiedi/amministri)
• Python per audioparser.py

Compilare l'App (che compila anche il payload)

1. Apri app/ in Android Studio.
2. Assicurati che NDK sia installato (SDK Manager → SDK Tools → NDK).
3. Compila la variante Debug. La configurazione Gradle/CMake compilerà il payload nativo (libaudiohook.so) come parte del progetto.

Installazione sul Dispositivo di Test

adb install -r app/build/outputs/apk/debug/app-debug.apk oppure installa l'app-release.apk fornita: adb install -r app-release.apk

Se separi gli artefatti, puoi anche inviare la libreria condivisa per il test: adb push app/src/main/jniLibs/arm64-v8a/libaudiohook.so /data/local/tmp/

Eseguire la PoC (Emulatore/Dispositivo di Proprietà)

1. Avvia l'App di Controllo -> concedi i permessi root quando richiesto.
2. Tocca "Inietta Policy"
   Prepara le regole SELinux richieste per l'interazione tra l'app e audioserver nel tuo ambiente di test.
3. Tocca “Avvia Monitoraggio”
   L'app usa AndKittyInjector per iniettare il payload in audioserver.
4. Effettua una chiamata VoIP di test (es. con il tuo account WhatsApp/Signal/Telegram).
5. Tocca “Ferma Monitoraggio”
   Riavvia audioserver.
6. Tocca “Copia Dati”
   Sposta i file di sessione da /data/local/tmp/voip/… a /sdcard/voip/ (e pulisce la directory temporanea).
7. Riproduzione
   • In-app: “Riproduci Audio” converte PCM -> WAV e riproduce.
   • Oppure offline:
     root@kitploit:~

      adb pull /sdcard/voip/
     python3 tools/audioparser.py voip/
     

Pulsanti aggiuntivi:

• “Visualizza Log”: Visualizza lo stato di iniettore/hook.
• “Abilita SELinux” / “Disabilita SELinux”: Attiva/disattiva enforcing/permissive nel tuo laboratorio se le policy sono troppo restrittive.
• “Elimina Dati”: Cancella sia /data/local/tmp/voip/ che /sdcard/voip/.

Versioni e Dispositivi Testati

• Emulatore: AVD API 34 (x86_64) - Android 14 - rooted con rootAVD
• Dispositivo: Samsung Galaxy S22 (ARM64) - Android 14 - Build S901EXXSCEYB1 - rooted con Magisk

App Testate

• Whatsapp
• Whatsapp Business
• Signal
• Telegram

Sfide Notevoli e Soluzioni

1. Simboli strippati
   • Problema: I simboli non possono essere individuati direttamente tramite dlsym.
   • Soluzione: Usare gli offset dall'analisi statica.
2. Simboli/Offset Differenti tra Build
   • Problema: I simboli strippati variano tra build; dlsym diretto potrebbe fallire.
   • Soluzione: Usare base + offset hardcoded per le build testate (offsets.h), validati con dump dei simboli di Frida e IDA-PRO.
3. Precisione del Rilevamento della Modalità
   • Problema: Registrare al di fuori delle sessioni VoIP produce dati rumorosi.
   • Soluzione: Gli hook catturano su AudioFlinger::setMode(IN_COMMUNICATION); registrare le transizioni; memorizzare un flag di modalità globale.
4. SELinux
   • Problema: La scrittura nelle directory temporanee e l'IPC con audioserver possono essere bloccati.
   • Soluzione: Fornire un passaggio Inietta Policy per aggiungere le regole necessarie; esporre gli interruttori Abilita/Disabilita SELinux per il debug in ambienti di test.
5. Ciclo di Vita dei File e Rinomina
   • Problema: Evitare output parziali/corrotti all'arresto del thread.
   • Soluzione: Scrivere prima in .tmp; su stop() rinominare in (downlink) o (uplink).

Riferimenti (Open-Source e Documentazione)

• Dobby (Framework di Inline Hooking) - https://www.github.com/jmpews/Dobby
• AndKittyInjector (iniettore di processi Android) - https://github.com/MJx0/AndKittyInjector
• AOSP
  • frameworks/av/services/audioflinger (AudioFlinger, PlaybackThread, RecordThread)
  • system/media/audio (formati audio, attributi, maschere di canale)