Ziel: Demonstrieren der VoIP-Stream-Erfassung durch Hooking des Android-audioserver (insbesondere libaudioflinger.so) und Aufzeichnen der Uplink- (Mikrofon) und Downlink- (Lautsprecher) PCM-Puffer, wenn sich das System im Kommunikationsmodus befindet.

Projektdesign & Methodik

Architektur:

• Controller App (Android)
  UI mit 9 Schaltflächen zur Verwaltung der SELINUX-Richtlinieneinrichtung, Payload-Injektion, Datenübertragung und Wiedergabe.

• Payload (libaudiohook.so)
  C++-Shared-Library (als Teil des App-Projekts erstellt), die interne AudioFlinger-Methoden mit Dobby hookt und rohe PCM-Puffer in ein Sitzungsverzeichnis schreibt.

• Post-Processing
  Zusätzliches Tool, tools/audioparser.py konvertiert rohe .ac(Downlink)/.bc(Uplink)-Dateien in WAV. Der Dateimanager der App kann ebenfalls konvertieren und in der App abspielen.

• Research Utilities
  Frida-Skripte für anfängliches Funktionstracing & Offset-Ermittlung; Analysedateien für Symbol/Offset und andere Snippets.

Controller App

Diese Android-Anwendung bietet eine grafische Oberfläche zur Verwaltung der VoIP-Aufzeichnung über den audioserver. Sie integriert einen nativen Payload, der in den Android-Audiostack eingreift, um Mikrofon- und Lautsprecheraudio von VoIP-Anwendungen zu erfassen.

Die App dient als Kontrollzentrum, mit dem Sie erforderliche SELinux-Richtlinien injizieren, die Überwachung starten/stoppen, aufgezeichnete Daten verwalten und erfasste VoIP-Audiodateien abspielen können.

Funktionen

Die Hauptaktivität enthält 9 Steuerschaltflächen:

1. Inject Policies
   Injiziert die erforderlichen SELinux-Richtlinien, damit audioserver und diese App zusammenarbeiten können.

2. Start Monitoring
   Injiziert den Shared-Library-Payload in audioserver und ermöglicht so die VoIP-Audioerfassung durch Hooking von RecordTrack und PlaybackTrack. Verwendet AndKittyInjector für die Prozessinjektion.

3. Stop Monitoring
   Startet den audioserver-Prozess neu, stoppt die Überwachung und entfernt injizierte Hooks.

4. Copy Data
   Kopiert erfasstes rohes PCM-Audio aus dem temporären Verzeichnis /data/local/tmp/voip nach /sdcard/voip.

   • Räumt anschließend das temporäre Verzeichnis auf.

5. View Logs
   Zeigt Protokolle zu Injektion, Hooking und Aufzeichnungsstatus an.

6. Enable SELinux
   Stellt den SELinux-Enforcing-Modus wieder her.

7. Disable SELinux
   Setzt SELinux in den permissiven Modus. Verwenden, wenn injizierte Richtlinien fehlschlagen.

8. Play Audios
   Öffnet den benutzerdefinierten VoIP-Dateimanager (/sdcard/voip/):

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

Hooking-Payload

Diese Shared Library wird in audioserver injiziert, um AUDIO_MODE_IN_COMMUNICATION zu erkennen und VoIP-Audiostreams direkt aus dem Android-Audiostack für eine vordefinierte Menge von Paketnamen zu erfassen.

Sie verwendet das Dobby Inline-Hooking-Framework, um kritische Methoden in libaudioflinger.so abzufangen.
Sowohl Uplink- (Mikrofon) als auch Downlink- (Lautsprecher) Audiostreams werden erfasst und zur späteren Verarbeitung in Sitzungsdateien geschrieben.

Hooking-Punkte

Die Bibliothek installiert Hooks auf den folgenden Funktionen in AudioFlinger und zugehörigen Klassen:

Zielanwendungen

Die Bibliothek filtert Streams basierend auf der UID → Paket-Zuordnung.

Derzeit überwachte Apps:

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

Sie können andere Anwendungen auch in audioserver_hook.cpp hinzufügen:

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

Dateiausgabe

• Ein Sitzungsverzeichnis wird bei der Injektion in audioserver unter folgendem Pfad erstellt: /data/local/tmp/voip/audioserver_session_<timestamp>/

• Dateien werden zunächst mit einer .tmp-Erweiterung erstellt und beim Stoppen des Tracks umbenannt:

  • Uplink (Mikrofon) → <packageName>_<sampleRate>_<timestamp>.bc
  • Downlink (Lautsprecher) → <packageName>_<sampleRate>_<timestamp>.ac

• Beispielsitzung:

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

Offsets

Da die Ziellibrary gestrippt ist und Methoden in libaudioflinger.so nicht exportiert werden, benötigen wir exakte Offsets der Methoden und anderer zugehöriger Komponenten für erfolgreiches Hooking.

Wir können diese Offsets aus der statischen Analyse mit IDA-PRO oder aus der dynamischen Analyse mit Frida extrahieren. Sobald die Offsets bekannt sind, können wir sie in der Headerdatei offsets.h ersetzen.

Erforderliche Offsets:

Methoden:

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

Andere Offsets:

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

Diese können aus der statischen Analyse ermittelt werden.

• Bibliothek - libaudioflinger.so
• Methode - 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)

Hinweise

• Nur der IN_COMMUNICATION-Modus wird erfasst. Normales Audio (Musik, Klingelton usw.) wird ignoriert.
• Eine spezielle Behandlung für Telegram und Signal erzwingt korrekte Abtastraten (Telegram: 48000 Hz, Signal: 8000 Hz), um andere unnötige Audios wie Klingel- und Verbindungstrennungsgeräusche zu ignorieren.
• PCM wird roh gespeichert; die Controller-App konvertiert PCM später für die Wiedergabe in WAV.

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

Identifizierung der Zielfunktionen

Verwendeter Prozess:

1. Dynamisches Tracing - Frida:
   • Frida verwendet, um alle Funktionsaufrufe während eines VoIP-Anrufs zu verfolgen
   • Alle Funktionen gefiltert, die für die Verarbeitung von Audiopuffern verantwortlich sind.
   • Anschließend Frida-Skripte erstellt, um Audiopuffer zu erfassen und zu verarbeiten.
2. AOSP-Review & Klassen-Zuordnung
   • AudioFlinger verwaltet Wiedergabe/Erfassung über PlaybackThread & RecordThread.
   • Pro Client wird Audio durch PlaybackThread::Track (Downlink) und RecordThread::RecordTrack (Uplink) repräsentiert.
3. Filtern auf app-spezifische Streams
   • UID→Paket-Zuordnung verwendet, um auf Ziel-Apps zu beschränken.
4. Stabilität und Offsets
   • Der finale native Payload löst Adressen über Basis + hartcodierte Offsets auf (gespeichert in app/src/main/cpp/include/offsets.h), um gestrippte Symbole zu überstehen.

Erkennung von MODE_IN_COMMUNICATION

Wir hooken AudioFlinger::setMode(int mode) und pflegen einen globalen Zustand:

• Bei jedem Aufruf protokollieren wir die Modusänderung und aktualisieren g_currentAudioMode.
• Hooks (sowohl im Mikrofon- als auch im Lautsprecher-Hook) prüfen g_currentAudioMode == AUDIO_MODE_IN_COMMUNICATION.
• Dadurch wird sichergestellt, dass wir Puffer nur bei aktiver VoIP-Sitzung ausgeben und Musik/Klingeltöne/Gerätewiedergabe/Mikrofonaufnahmen usw. vermeiden.

Erstellen & Ausführen des PoC

Projektstruktur

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

Voraussetzungen

• Android Studio + NDK
• Gerooteter Emulator (z. B. rootAVD) oder ein Testgerät, das dir gehört (z. B. Magisk)
• Test-VoIP-Apps installiert (dieselben, die du besitzt/verwaltest)
• Python für audioparser.py

Erstellen der App (die auch den Payload erstellt)

1. Öffne app/ in Android Studio.
2. Stelle sicher, dass das NDK installiert ist (SDK Manager → SDK Tools → NDK).
3. Erstelle die Debug-Variante. Die Gradle/CMake-Konfiguration kompiliert den nativen Payload (libaudiohook.so) als Teil des Projekts.

Installation auf dem Testziel

adb install -r app/build/outputs/apk/debug/app-debug.apk oder installiere die bereitgestellte app-release.apk: adb install -r app-release.apk

Wenn du Artefakte trennst, kannst du die Shared Library auch zu Testzwecken übertragen: adb push app/src/main/jniLibs/arm64-v8a/libaudiohook.so /data/local/tmp/

Ausführen des PoC (Emulator/eigenes Gerät)

1. Starte die Controller-App -> Root-Zugriff gewähren, wenn dazu aufgefordert.
2. Tippe auf „Inject Policies“
   Bereitet die SELinux-Regeln vor, die für die Interaktion zwischen App und audioserver in deiner Testumgebung erforderlich sind.
3. Tippe auf „Start Monitoring“
   Die App verwendet AndKittyInjector, um den Payload in audioserver zu injizieren.
4. Führe einen Test-VoIP-Anruf durch (z. B. mit deinem eigenen WhatsApp/Signal/Telegram-Konto).
5. Tippe auf „Stop Monitoring“
   Startet audioserver neu.
6. Tippe auf „Copy Data“
   Verschiebt Sitzungsdateien von /data/local/tmp/voip/… nach /sdcard/voip/ (und leert das temporäre Verzeichnis).
7. Wiedergabe
   • In der App: „Play Audios“ konvertiert PCM -> WAV und spielt ab.
   • Oder offline:
     root@kitploit:~

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

Zusätzliche Schaltflächen:

• „View Logs“: Injektor-/Hook-Status anzeigen.
• „Enable SELinux“ / „Disable SELinux“: Enforcing/Permissive in deinem Labor umschalten, wenn Richtlinien zu streng sind.
• „Delete Data“: /data/local/tmp/voip/ und /sdcard/voip/ leeren.

Getestete Versionen & Geräte

• Emulator: AVD API 34 (x86_64) - Android 14 - gerootet mit rootAVD
• Gerät: Samsung Galaxy S22 (ARM64) - Android 14 - Build S901EXXSCEYB1 - gerootet mit Magisk

Getestete Apps

• Whatsapp
• Whatsapp Business
• Signal
• Telegram

Bemerkenswerte Herausforderungen & Lösungen

1. Gestrippte Symbole
   • Problem: Symbole können nicht direkt über dlsym gefunden werden.
   • Lösung: Offsets aus der statischen Analyse verwenden.
2. Unterschiedliche Symbole/Offsets zwischen Builds
   • Problem: Gestrippte Symbole variieren je nach Build; direktes dlsym kann fehlschlagen.
   • Lösung: Basis + hartcodierte Offsets für getestete Builds verwenden (offsets.h), validiert mit Frida-Symbol-Dumps und IDA-PRO.
3. Genauigkeit der Moduserkennung
   • Problem: Aufzeichnung außerhalb von VoIP-Sitzungen erzeugt verrauschte Daten.
   • Lösung: Hooks erfassen AudioFlinger::setMode(IN_COMMUNICATION); Übergänge protokollieren; ein globales Modus-Flag speichern.
4. SELinux
   • Problem: Das Schreiben in temporäre Verzeichnisse & IPC mit audioserver kann blockiert werden.
   • Lösung: Einen Schritt Inject Policies bereitstellen, um notwendige Regeln hinzuzufügen; Enable/Disable SELinux-Umschalter für das Debugging in Testumgebungen bereitstellen.
5. Dateilebenszyklus & Umbenennung
   • Problem: Vermeidung unvollständiger/beschädigter Ausgaben beim Stoppen des Threads.
   • Lösung: Zuerst in .tmp schreiben; bei stop() in (Downlink) oder (Uplink) umbenennen.

Referenzen (Open-Source & Dokumentation)

• Dobby (Inline Hooking Framework) - https://www.github.com/jmpews/Dobby
• AndKittyInjector (Android process injector) - https://github.com/MJx0/AndKittyInjector
• AOSP
  • frameworks/av/services/audioflinger (AudioFlinger, PlaybackThread, RecordThread)
  • system/media/audio (audio formats, attributes, channel masks)