Objectif : Démontrer la capture de flux VoIP en hookant l'audioserver d'Android (plus précisément libaudioflinger.so) et en enregistrant les buffers PCM en liaison montante (micro) et liaison descendante (haut-parleur) lorsque le système est en mode communication.

Conception du projet et méthodologie

Architecture :

• Application de contrôle (Android)
  Interface avec 9 boutons pour gérer la configuration des politiques SELinux, l'injection du payload, le déplacement des données et la lecture audio.

• Payload (libaudiohook.so)
  Bibliothèque partagée C++ (compilée dans le projet de l'application) qui hooke les méthodes internes d'AudioFlinger à l'aide de Dobby et écrit les buffers PCM bruts dans un répertoire de session.

• Post-traitement
  Outil supplémentaire, tools/audioparser.py, convertit les fichiers bruts .ac (liaison descendante)/.bc (liaison montante) en WAV. Le gestionnaire de fichiers de l'application peut également convertir et lire ces fichiers dans l'application.

• Utilitaires de recherche
  Scripts Frida pour le traçage initial des fonctions et la découverte des offsets ; fichiers d'analyse pour les symboles/offsets et autres extraits.

Application de contrôle

Cette application Android fournit une interface graphique pour gérer l'enregistrement VoIP via l'audioserver. Elle s'intègre à un payload natif qui hooke la pile audio Android pour capturer l'audio du microphone et du haut-parleur des applications VoIP.

L'application sert de centre de contrôle : elle permet d'injecter les politiques SELinux requises, de démarrer/arrêter la surveillance, de gérer les données enregistrées et de lire les fichiers audio VoIP capturés.

Fonctionnalités

L'activité principale contient 9 boutons de contrôle :

1. Injecter les politiques
   Injecte les politiques SELinux requises pour que audioserver et cette application fonctionnent ensemble.

2. Démarrer la surveillance
   Injecte le payload de bibliothèque partagée dans audioserver, activant la capture audio VoIP en hookant RecordTrack et PlaybackTrack. Utilise AndKittyInjector pour l'injection de processus.

3. Arrêter la surveillance
   Redémarre le processus audioserver, arrêtant la surveillance et supprimant les hooks injectés.

4. Copier les données
   Copie l'audio PCM brut capturé depuis le répertoire temporaire /data/local/tmp/voip vers /sdcard/voip.

   • Nettoie le répertoire temporaire ensuite.

5. Afficher les journaux
   Affiche les journaux relatifs à l'injection, au hooking et à l'état de l'enregistrement.

6. Activer SELinux
   Rétablit le mode enforcing de SELinux.

7. Désactiver SELinux
   Passe SELinux en mode permissif. À utiliser lorsque les politiques injectées échouent.

8. Lire les audios
   Ouvre le gestionnaire de fichiers VoIP personnalisé (/sdcard/voip/) :

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

Payload de hooking

Cette bibliothèque partagée est injectée dans audioserver pour détecter AUDIO_MODE_IN_COMMUNICATION et capturer les flux audio VoIP directement depuis la pile audio Android pour un ensemble prédéfini de noms de packages.

Elle utilise le framework de hooking inline Dobby pour intercepter des méthodes critiques dans libaudioflinger.so.
Les flux audio liaison montante (microphone) et liaison descendante (haut-parleur) sont capturés et écrits dans des fichiers de session pour un traitement ultérieur.

Points de hooking

La bibliothèque installe des hooks sur les fonctions suivantes dans AudioFlinger et les classes associées :

Applications cibles

La bibliothèque filtre les flux en fonction du mappage UID → Package.

Applications actuellement surveillées :

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

Vous pouvez ajouter d'autres applications également dans audioserver_hook.cpp :

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

Sortie de fichiers

• Un répertoire de session est créé lors de l'injection dans audioserver sous : /data/local/tmp/voip/audioserver_session_<timestamp>/

• Les fichiers sont d'abord créés avec une extension .tmp, puis renommés à l'arrêt de la piste :

  • Liaison montante (micro) → <packageName>_<sampleRate>_<timestamp>.bc
  • Liaison descendante (haut-parleur) → <packageName>_<sampleRate>_<timestamp>.ac

• Exemple de session :

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

Offsets

Étant donné que la bibliothèque cible est strippée et que les méthodes ne sont pas exportées dans libaudioflinger.so, nous avons besoin des offsets exacts des méthodes et des autres composants associés pour hooker avec succès.

Nous pouvons extraire ces offsets à partir d'une analyse statique avec IDA-PRO ou d'une analyse dynamique avec Frida. Une fois les offsets connus, nous pouvons les remplacer dans le fichier d'en-tête offsets.h.

Offsets requis :

Méthodes :

1. AUDIOFLINGER_SETMODE_OFFSET
   • Méthode : android::AudioFlinger::setMode(audio_mode_t)
   • Nom manglé : _ZN7android12AudioFlinger7setModeE11audio_mode_t
2. RECORDTRACK_GETNEXTBUFFER_OFFSET
   • Méthode : android::AudioFlinger::RecordThread::RecordTrack::getNextBuffer(android::AudioBufferProvider::Buffer *)
   • Nom manglé : _ZN7android12AudioFlinger12RecordThread11RecordTrack13getNextBufferEPNS_19AudioBufferProvider6BufferE
3. TRACK_GETNEXTBUFFER_OFFSET
   • Méthode : android::AudioFlinger::PlaybackThread::Track::getNextBuffer(android::AudioBufferProvider::Buffer *)
   • Nom manglé : _ZN7android12AudioFlinger14PlaybackThread5Track13getNextBufferEPNS_19AudioBufferProvider6BufferE
4. TRACK_STOP_OFFSET
   • Méthode : android::AudioFlinger::PlaybackThread::Track::stop(void)
   • Nom manglé : _ZN7android12AudioFlinger14PlaybackThread5Track4stopEv

Autres offsets :

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

Ces offsets peuvent être obtenus par analyse statique.

• Bibliothèque - libaudioflinger.so
• Méthode - 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)

Remarques

• Seul le mode IN_COMMUNICATION est capturé. L'audio normal (musique, sonnerie, etc.) est ignoré.
• Une gestion spéciale pour Telegram et Signal impose les taux d'échantillonnage corrects (Telegram : 48000 Hz, Signal : 8000 Hz) afin d'ignorer d'autres audios inutiles comme la sonnerie et les sons de fin d'appel.
• Le PCM est stocké brut ; l'application de contrôle convertit ensuite le PCM → WAV pour la lecture.

 ┌─────────────────────────────┐
 │        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)      │
     └───────────────────────────┘

Identification des fonctions cibles

Processus utilisé :

1. Traçage dynamique - Frida :
   • Utilisation de Frida pour tracer tous les appels de fonction pendant un appel VoIP.
   • Filtrage de toutes les fonctions responsables de la gestion des buffers audio.
   • Création ensuite de scripts Frida pour capturer et gérer les buffers audio.
2. Revue AOSP et mappage des classes
   • AudioFlinger gère la lecture/capture via PlaybackThread et RecordThread.
   • L'audio par client est représenté par PlaybackThread::Track (liaison descendante) et RecordThread::RecordTrack (liaison montante).
3. Filtrage des flux spécifiques aux applications
   • Utilisation du mappage UID→package pour restreindre aux applications cibles.
4. Stabilité et offsets
   • Le payload natif final résout les adresses via base + offsets codés en dur (conservés dans app/src/main/cpp/include/offsets.h) pour survivre aux symboles strippés.

Détection de MODE_IN_COMMUNICATION

Nous hookons AudioFlinger::setMode(int mode) et maintenons un état global :

• À chaque appel, nous journalisons le changement de mode et mettons à jour g_currentAudioMode.
• Les hooks (dans les hooks micro et haut-parleur) vérifient g_currentAudioMode == AUDIO_MODE_IN_COMMUNICATION.
• Cela garantit que nous ne dumpons les buffers que pendant une session VoIP active, évitant la musique, les sonneries, la lecture de l'appareil, les enregistrements du micro, etc.

Compilation et exécution de la POC

Structure du projet

.
├── 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)

Prérequis

• Android Studio + NDK
• Émulateur rooté (par exemple, rootAVD) ou appareil de test vous appartenant (par exemple, Magisk)
• Applications VoIP de test installées (celles que vous possédez/administrez)
• Python pour audioparser.py

Compiler l'application (qui compile également le payload)

1. Ouvrez app/ dans Android Studio.
2. Assurez-vous que le NDK est installé (SDK Manager → SDK Tools → NDK).
3. Compilez la variante Debug. La configuration Gradle/CMake compilera le payload natif (libaudiohook.so) dans le cadre du projet.

Installation sur la cible de test

adb install -r app/build/outputs/apk/debug/app-debug.apk ou installez app-release.apk fourni : adb install -r app-release.apk

Si vous séparez les artefacts, vous pouvez également pousser la bibliothèque partagée pour test : adb push app/src/main/jniLibs/arm64-v8a/libaudiohook.so /data/local/tmp/

Exécuter la POC (émulateur/appareil possédé)

1. Lancez l'application de contrôle -> accordez le root lorsque vous y êtes invité.
2. Touchez « Inject Policies »
   Prépare les règles SELinux requises pour l'interaction entre l'application et audioserver dans votre environnement de test.
3. Touchez « Start Monitoring »
   L'application utilise AndKittyInjector pour injecter le payload dans audioserver.
4. Passez un appel VoIP de test (par exemple, avec votre propre compte WhatsApp/Signal/Telegram).
5. Touchez « Stop Monitoring »
   Redémarre audioserver.
6. Touchez « Copy Data »
   Déplace les fichiers de session de /data/local/tmp/voip/… vers /sdcard/voip/ (et vide le répertoire temporaire).
7. Lecture
   • Dans l'application : « Play Audios » convertit le PCM → WAV et le lit.
   • Ou hors ligne :
     root@kitploit:~

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

Boutons supplémentaires :

• « View Logs » : voir l'état de l'injecteur/hook.
• « Enable SELinux » / « Disable SELinux » : basculer entre enforcing/permissif dans votre lab si les politiques sont trop strictes.
• « Delete Data » : efface à la fois /data/local/tmp/voip/ et /sdcard/voip/.

Versions et appareils testés

• Émulateur : AVD API 34 (x86_64) - Android 14 - rooté avec rootAVD
• Appareil : Samsung Galaxy S22 (ARM64) - Android 14 - Build S901EXXSCEYB1 - rooté avec Magisk

Applications testées

• Whatsapp
• Whatsapp Business
• Signal
• Telegram

Défis notables et solutions

1. Symboles strippés
   • Problème : Les symboles ne peuvent pas être localisés directement via dlsym.
   • Correctif : Utiliser les offsets issus de l'analyse statique.
2. Symboles/offsets différents selon les builds
   • Problème : Les symboles strippés varient selon le build ; dlsym direct peut échouer.
   • Correctif : Utiliser base + offsets codés en dur pour les builds testés (offsets.h), validés avec les dumps de symboles Frida et IDA-PRO.
3. Précision de la détection du mode
   • Problème : L'enregistrement en dehors des sessions VoIP produit des données bruitées.
   • Correctif : Les hooks capturent sur AudioFlinger::setMode(IN_COMMUNICATION) ; journaliser les transitions ; stocker un indicateur de mode global.
4. SELinux
   • Problème : L'écriture dans les répertoires temporaires et l'IPC avec audioserver peuvent être bloqués.
   • Correctif : Prévoir une étape Inject Policies pour ajouter les règles nécessaires ; exposer les bascules Enable/Disable SELinux pour le débogage dans les environnements de test.
5. Cycle de vie des fichiers et renommage
   • Problème : Éviter les sorties partielles/corrompues à l'arrêt du thread.
   • Correctif : Écrire d'abord dans .tmp ; lors du , renommer en (liaison descendante) ou (liaison montante).

Références (open-source et documentation)

• Dobby (framework de hooking inline) - https://www.github.com/jmpews/Dobby
• AndKittyInjector (injecteur de processus Android) - https://github.com/MJx0/AndKittyInjector
• AOSP
  • frameworks/av/services/audioflinger (AudioFlinger, PlaybackThread, RecordThread)
  • system/media/audio (formats audio, attributs, masques de canaux)