Objetivo: Demostrar la captura de flujos VoIP enganchando el audioserver de Android (específicamente libaudioflinger.so) y grabando los buffers PCM de subida (micrófono) y bajada (altavoz) cuando el sistema está en modo communication.

Diseño del Proyecto y Metodología

Arquitectura:

• App de Control (Android)
  Interfaz con 9 botones para gestionar la configuración de políticas SELINUX, la inyección del payload, el movimiento de datos y la reproducción.

• Payload (libaudiohook.so)
  Librería compartida en C++ (compilada como parte del proyecto de la app) que engancha métodos internos de AudioFlinger usando Dobby y escribe buffers PCM crudos en un directorio de sesión.

• Post-Procesamiento
  Herramienta adicional, tools/audioparser.py, convierte archivos crudos .ac(Downlink)/.bc(Uplink) a WAV. El administrador de archivos de la app también puede convertir y reproducir dentro de la aplicación.

• Utilidades de Investigación
  Scripts de Frida para el trazado inicial de funciones y el descubrimiento de offsets; archivos de análisis para símbolos/offsets y otros fragmentos.

App de Control

Esta aplicación Android proporciona una interfaz gráfica para gestionar la grabación VoIP a través del audioserver. Se integra con un payload nativo que se engancha en la pila de audio de Android para capturar el audio del micrófono y del altavoz de las aplicaciones VoIP.

La app actúa como un centro de control, permitiéndote inyectar las políticas SELinux requeridas, iniciar/detener la monitorización, gestionar los datos grabados y reproducir los archivos de audio VoIP capturados.

Características

La actividad principal contiene 9 botones de control:

1. Inyectar Políticas
   Inyecta las políticas SELinux necesarias para que audioserver y esta app funcionen juntos.

2. Iniciar Monitorización
   Inyecta el payload de la librería compartida en audioserver, habilitando la captura de audio VoIP mediante el enganche de RecordTrack y PlaybackTrack. Utiliza AndKittyInjector para la inyección de procesos.

3. Detener Monitorización
   Reinicia el proceso audioserver, deteniendo la monitorización y eliminando los hooks inyectados.

4. Copiar Datos
   Copia el audio PCM crudo capturado del directorio temporal /data/local/tmp/voip a /sdcard/voip.

   • Limpia el directorio temporal después.

5. Ver Logs
   Muestra los registros relacionados con la inyección, el enganche y el estado de la grabación.

6. Activar SELinux
   Restaura el modo enforcing de SELinux.

7. Desactivar SELinux
   Establece SELinux en modo permisivo. Úsalo si las políticas inyectadas fallan.

8. Reproducir Audios
   Abre el Administrador de Archivos VoIP personalizado (/sdcard/voip/):

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

Payload de Enganche

Esta librería compartida se inyecta en audioserver para detectar AUDIO_MODE_IN_COMMUNICATION y capturar los flujos de audio VoIP directamente de la pila de audio de Android para un conjunto predefinido de nombres de paquete.

Utiliza el framework de enganche inline Dobby para interceptar métodos críticos dentro de libaudioflinger.so.
Tanto los flujos de audio uplink (micrófono) como downlink (altavoz) se capturan y escriben en archivos de sesión para su posterior procesamiento.

Puntos de Enganche

La librería instala hooks en las siguientes funciones dentro de AudioFlinger y clases relacionadas:

Aplicaciones Objetivo

La librería filtra los flujos basándose en el mapeo UID → Paquete.

Aplicaciones actualmente monitorizadas:

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

También puedes añadir otras aplicaciones dentro de audioserver_hook.cpp:

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

Salida de Archivos

• Se crea un directorio de sesión al inyectar en audioserver bajo: /data/local/tmp/voip/audioserver_session_<timestamp>/

• Los archivos se crean primero con la extensión .tmp y luego se renombran al detener el track:

  • Uplink (micrófono) → <packageName>_<sampleRate>_<timestamp>.bc
  • Downlink (altavoz) → <packageName>_<sampleRate>_<timestamp>.ac

• Ejemplo de sesión:

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

Offsets

Dado que la librería objetivo está stripped y los métodos no están exportados en libaudioflinger.so, necesitamos los offsets exactos de los métodos y otros componentes relacionados para un enganche exitoso.

Podemos extraer esos offsets mediante análisis estático con IDA-PRO o mediante análisis dinámico con frida. Una vez que se conocen los offsets, podemos reemplazarlos dentro del archivo de cabecera offsets.h.

Offsets Requeridos:

Métodos:

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

Otros Offsets:

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

Estos pueden obtenerse mediante análisis estático.

• Librería - libaudioflinger.so
• Método - 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)

Notas

• Solo se captura el modo IN_COMMUNICATION. El audio normal (música, tonos de llamada, etc.) se ignora.
• El manejo especial para Telegram y Signal aplica las frecuencias de muestreo correctas (Telegram: 48000 Hz, Signal: 8000 Hz) para ignorar otros audios innecesarios como el tono de llamada y los sonidos de fin de llamada.
• El PCM se almacena crudo; la app de control convierte posteriormente PCM → WAV para la reproducción.

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

Identificación de Funciones Objetivo

Proceso utilizado:

1. Trazado dinámico - Frida:
   • Se usó Frida para trazar todas las llamadas a funciones durante una llamada VoIP.
   • Se filtraron todas las funciones responsables del manejo de buffers de audio.
   • Luego se crearon scripts de Frida para capturar y manejar los buffers de audio.
2. Revisión de AOSP y mapeo de clases
   • AudioFlinger gestiona la reproducción/captura mediante PlaybackThread y RecordThread.
   • El audio por cliente está representado por PlaybackThread::Track (downlink) y RecordThread::RecordTrack (uplink).
3. Filtrado de flujos específicos de la app
   • Se usó el mapeo UID→paquete para restringir a las aplicaciones objetivo.
4. Estabilidad y offsets
   • El payload nativo final resuelve direcciones mediante base + offsets hardcodeados (mantenidos en app/src/main/cpp/include/offsets.h) para sobrevivir a los símbolos stripped.

Detección de MODE_IN_COMMUNICATION

Enganchamos AudioFlinger::setMode(int mode) y mantenemos un estado global:

• En cada llamada, registramos el cambio de modo y actualizamos g_currentAudioMode.
• Los hooks (tanto en los de micrófono como en los de altavoz) comprueban que g_currentAudioMode == AUDIO_MODE_IN_COMMUNICATION.
• Esto garantiza que solo volcamos buffers mientras hay una sesión VoIP activa, evitando música, tonos de llamada, reproducción del dispositivo, grabaciones de micrófono, etc.

Compilación y Ejecución del PoC

Estructura del Proyecto

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

Requisitos Previos

• Android Studio + NDK
• Emulador rooteado (por ejemplo, rootAVD) o dispositivo de prueba que poseas (por ejemplo, Magisk)
• Apps VoIP de prueba instaladas (las mismas que poseas/administres)
• Python para audioparser.py

Compilar la App (que también compila el payload)

1. Abre app/ en Android Studio.
2. Asegúrate de que el NDK esté instalado (SDK Manager → SDK Tools → NDK).
3. Compila la variante Debug. La configuración de Gradle/CMake compilará el payload nativo (libaudiohook.so) como parte del proyecto.

Instalar en el Dispositivo de Prueba

adb install -r app/build/outputs/apk/debug/app-debug.apk o instala el app-release.apk proporcionado: adb install -r app-release.apk

Si separas los artefactos, también puedes enviar la librería compartida para probarla: adb push app/src/main/jniLibs/arm64-v8a/libaudiohook.so /data/local/tmp/

Ejecutar el PoC (Emulador/Dispositivo Propio)

1. Abre la App de Control -> concede root cuando se solicite.
2. Toca "Inyectar Políticas"
   Prepara las reglas SELinux necesarias para la interacción entre la app y audioserver en tu entorno de prueba.
3. Toca "Iniciar Monitorización"
   La app usa AndKittyInjector para inyectar el payload en audioserver.
4. Realiza una llamada VoIP de prueba (por ejemplo, con tu propia cuenta de WhatsApp/Signal/Telegram).
5. Toca "Detener Monitorización"
   Reinicia audioserver.
6. Toca "Copiar Datos"
   Mueve los archivos de sesión de /data/local/tmp/voip/… a /sdcard/voip/ (y limpia el directorio temporal).
7. Reproducción
   • En la app: "Reproducir Audios" convierte PCM -> WAV y reproduce.
   • O sin conexión:
     root@kitploit:~

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

Botones adicionales:

• "Ver Logs": Consulta el estado del inyector/hooks.
• "Activar SELinux" / "Desactivar SELinux": Alterna entre enforcing/permisivo en tu laboratorio si las políticas son demasiado estrictas.
• "Eliminar Datos": Limpia tanto /data/local/tmp/voip/ como /sdcard/voip/.

Versiones y Dispositivos Probados

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

Apps Probadas

• Whatsapp
• Whatsapp Business
• Signal
• Telegram

Desafíos Notables y Soluciones

1. Símbolos stripped
   • Problema: Los símbolos no se pueden localizar directamente mediante dlsym.
   • Solución: Usar offsets obtenidos mediante análisis estático.
2. Distintos Símbolos/Offsets Entre Builds
   • Problema: Los símbolos stripped varían según el build; dlsym directo puede fallar.
   • Solución: Usar base + offsets hardcodeados para los builds probados (offsets.h), validados con volcados de símbolos de Frida e IDA-PRO.
3. Precisión en la Detección del Modo
   • Problema: Grabar fuera de sesiones VoIP genera datos con ruido.
   • Solución: Los hooks capturan en AudioFlinger::setMode(IN_COMMUNICATION); se registran las transiciones; se almacena un indicador global de modo.
4. SELinux
   • Problema: La escritura en directorios temporales y la IPC con audioserver pueden estar bloqueadas.
   • Solución: Proporcionar un paso de Inyectar Políticas para añadir las reglas necesarias; exponer los interruptores de Activar/Desactivar SELinux para depurar en entornos de prueba.
5. Ciclo de Vida y Renombrado de Archivos
   • Problema: Evitar salidas parciales o corruptas al detener el thread.
   • Solución: Escribir primero con .tmp; en renombrar a (downlink) o (uplink).

Referencias (Open-Source y Documentación)

• Dobby (Framework de enganche inline) - https://www.github.com/jmpews/Dobby
• AndKittyInjector (inyector de procesos de Android) - https://github.com/MJx0/AndKittyInjector
• AOSP
  • frameworks/av/services/audioflinger (AudioFlinger, PlaybackThread, RecordThread)
  • system/media/audio (formatos de audio, atributos, máscaras de canal)