Objetivo: Demonstrar a captura de fluxo VoIP ao hookear o audioserver do Android (especificamente libaudioflinger.so) e gravar buffers PCM de uplink (microfone) e downlink (alto-falante) quando o sistema está em modo comunicação.

Design do Projeto e Metodologia

Arquitetura:

• App Controlador (Android)
  Interface com 9 botões para gerenciar a configuração da política SELINUX, injeção de payload, movimentação de dados e reprodução.

• Payload (libaudiohook.so)
  Biblioteca compartilhada em C++ (compilada como parte do projeto do app) que hookeia métodos internos de AudioFlinger usando Dobby e grava buffers PCM brutos em um diretório de sessão.

• Pós-processamento
  Ferramenta adicional, tools/audioparser.py converte arquivos brutos .ac (Downlink)/.bc (Uplink) para WAV. O gerenciador de arquivos do app também pode converter e reproduzir no próprio aplicativo.

• Utilitários de Pesquisa
  Scripts Frida para rastreamento inicial de funções e descoberta de offsets; arquivos de análise para símbolos/offsets e outros trechos.

App Controlador

Este aplicativo Android fornece uma interface gráfica para gerenciar a gravação de VoIP através do audioserver. Ele se integra a um payload nativo que hookeia a pilha de áudio do Android para capturar áudio do microfone e do alto-falante de aplicativos VoIP.

O aplicativo serve como um centro de controle, permitindo injetar as políticas SELinux necessárias, iniciar/parar o monitoramento, gerenciar os dados gravados e reproduzir arquivos de áudio VoIP capturados.

Recursos

A atividade principal contém 9 botões de controle:

1. Injetar Políticas
   Injeta as políticas SELinux necessárias para que audioserver e este aplicativo funcionem juntos.

2. Iniciar Monitoramento
   Injeta o payload da biblioteca compartilhada no audioserver, habilitando a captura de áudio VoIP ao hookear RecordTrack e PlaybackTrack. Usa AndKittyInjector para injeção de processo.

3. Parar Monitoramento
   Reinicia o processo audioserver, interrompendo o monitoramento e removendo os hooks injetados.

4. Copiar Dados
   Copia o áudio PCM bruto capturado do diretório temporário /data/local/tmp/voip para /sdcard/voip.

   • Limpa o diretório temporário em seguida.

5. Ver Logs
   Exibe logs relacionados à injeção, hooking e status da gravação.

6. Habilitar SELinux
   Restaura o modo enforcing do SELinux.

7. Desabilitar SELinux
   Define o SELinux para o modo permissivo. Use quando as políticas injetadas falharem.

8. Reproduzir Áudios
   Abre o Gerenciador de Arquivos VoIP personalizado (/sdcard/voip/):

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

Payload de Hooking

Esta biblioteca compartilhada é injetada no audioserver para detectar AUDIO_MODE_IN_COMMUNICATION e capturar fluxos de áudio VoIP diretamente da pilha de áudio do Android para um conjunto predefinido de nomes de pacotes.

Ela usa o framework de hooking inline Dobby para interceptar métodos críticos dentro de libaudioflinger.so.
Os fluxos de áudio de uplink (microfone) e downlink (alto-falante) são capturados e gravados em arquivos de sessão para processamento posterior.

Pontos de Hook

A biblioteca instala hooks nas seguintes funções dentro de AudioFlinger e classes relacionadas:

Aplicativos Alvo

A biblioteca filtra fluxos com base no mapeamento UID → Pacote.

Aplicativos atualmente monitorados:

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

Você também pode adicionar outros aplicativos dentro de audioserver_hook.cpp:

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

Saída de Arquivos

• Um diretório de sessão é criado no momento da injeção no audioserver em: /data/local/tmp/voip/audioserver_session_<timestamp>/

• Os arquivos são criados primeiro com a extensão .tmp e depois renomeados na parada do track:

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

• Exemplo de sessão:

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

Offsets

Como a biblioteca alvo é stripped (sem símbolos) e os métodos não são exportados em libaudioflinger.so, precisamos de offsets exatos dos métodos e de outros componentes relacionados para um hooking bem-sucedido.

Podemos extrair esses offsets a partir de análise estática usando IDA-PRO ou de análise dinâmica usando frida. Uma vez que os offsets são conhecidos, podemos substituí-los dentro do arquivo de cabeçalho offsets.h.

Offsets Necessários:

Métodos:

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

Outros Offsets:

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

Eles podem ser obtidos por análise estática.

• Biblioteca - 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

• Apenas o modo IN_COMMUNICATION é capturado. Áudio normal (música, toque, etc.) é ignorado.
• O tratamento especial para Telegram e Signal aplica as taxas de amostragem corretas (Telegram: 48000 Hz, Signal: 8000 Hz) para ignorar outros áudios desnecessários, como toque de chamada e sons de desconexão de chamada.
• O PCM é armazenado bruto; o aplicativo controlador converte PCM → WAV posteriormente para reprodução.

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

Identificação das Funções Alvo

Processo utilizado:

1. Rastreamento dinâmico - Frida:
   • Usou Frida para rastrear todas as chamadas de função durante uma chamada VoIP.
   • Filtrou todas as funções responsáveis pelo tratamento de buffers de áudio.
   • Depois criou scripts Frida para capturar e manipular os buffers de áudio.
2. Revisão do AOSP e mapeamento de classes
   • AudioFlinger gerencia reprodução/captura via PlaybackThread & RecordThread.
   • O áudio por cliente é representado por PlaybackThread::Track (downlink) e RecordThread::RecordTrack (uplink).
3. Filtragem para fluxos específicos do aplicativo
   • Usou o mapeamento UID→pacote para restringir aos aplicativos alvo.
4. Estabilidade e offsets
   • O payload nativo final resolve endereços via base + offsets fixos (hardcoded) (mantidos em app/src/main/cpp/include/offsets.h) para sobreviver a símbolos removidos (stripped).

Detectando MODE_IN_COMMUNICATION

Nós hookeamos AudioFlinger::setMode(int mode) e mantemos um estado global:

• A cada chamada, registramos a mudança de modo e atualizamos g_currentAudioMode.
• Os hooks (tanto nos hooks de microfone quanto nos de alto-falante) verificam g_currentAudioMode == AUDIO_MODE_IN_COMMUNICATION.
• Isso garante que só despejamos buffers enquanto uma sessão VoIP está ativa, evitando música/tonalidades/reprodução do dispositivo/gravações de microfone etc.

Compilando e Executando o PoC

Estrutura do Projeto

.
├── 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é-requisitos

• Android Studio + NDK
• Emulador com root (ex.: rootAVD) ou dispositivo de teste que você possui (ex.: Magisk)
• Aplicativos VoIP de teste instalados (os mesmos que você possui/administra)
• Python para audioparser.py

Compilar o Aplicativo (que também compila o payload)

1. Abra app/ no Android Studio.
2. Certifique-se de que o NDK está instalado (SDK Manager → SDK Tools → NDK).
3. Compile a variante Debug. A configuração Gradle/CMake compilará o payload nativo (libaudiohook.so) como parte do projeto.

Instalação no Alvo de Teste

adb install -r app/build/outputs/apk/debug/app-debug.apk ou instale o app-release.apk fornecido: adb install -r app-release.apk

Se você separar os artefatos, também pode enviar a biblioteca compartilhada para teste: adb push app/src/main/jniLibs/arm64-v8a/libaudiohook.so /data/local/tmp/

Executar o PoC (Emulador/Dispositivo Próprio)

1. Abra o Aplicativo Controlador e conceda root quando solicitado.
2. Toque em "Injetar Políticas"
   Prepara as regras SELinux necessárias para a interação entre o aplicativo e o audioserver em seu ambiente de teste.
3. Toque em "Iniciar Monitoramento"
   O aplicativo usa AndKittyInjector para injetar o payload no audioserver.
4. Faça uma chamada VoIP de teste (ex.: sua própria conta WhatsApp/Signal/Telegram).
5. Toque em "Parar Monitoramento"
   Reinicia o audioserver.
6. Toque em "Copiar Dados"
   Move os arquivos de sessão de /data/local/tmp/voip/… -> /sdcard/voip/ (e limpa o diretório temporário).
7. Reprodução
   • No aplicativo: "Reproduzir Áudios" converte PCM -> WAV e reproduz.
   • Ou offline:
     root@kitploit:~

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

Botões adicionais:

• "Ver Logs": Veja o status do injetor/hook.
• "Habilitar SELinux" / "Desabilitar SELinux": Alterne entre enforcing/permissivo em seu laboratório se as políticas forem muito restritivas.
• "Excluir Dados": Limpe /data/local/tmp/voip/ e /sdcard/voip/.

Versões e Dispositivos Testados

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

Aplicativos Testados

• Whatsapp
• Whatsapp Business
• Signal
• Telegram

Desafios Notáveis e Soluções

1. Símbolos removidos (stripped)
   • Problema: Os símbolos não podem ser localizados diretamente via dlsym.
   • Solução: Usar offsets de análise estática.
2. Símbolos/Offsets Diferentes entre Builds
   • Problema: Símbolos removidos variam por build; dlsym direto pode falhar.
   • Solução: Usar base + offsets fixos (hardcoded) para builds testadas (offsets.h), validados com dumps de símbolos do Frida e IDA-PRO.
3. Precisão da Detecção de Modo
   • Problema: Gravar fora de sessões VoIP gera dados ruidosos.
   • Solução: Os hooks capturam em AudioFlinger::setMode(IN_COMMUNICATION); registram transições; armazenam uma flag global de modo.
4. SELinux
   • Problema: A escrita em diretórios temporários e a IPC com audioserver podem ser bloqueadas.
   • Solução: Fornecer uma etapa Injetar Políticas para adicionar as regras necessárias; expor os botões Habilitar/Desabilitar SELinux para depuração em ambientes de teste.
5. Ciclo de Vida e Renomeação de Arquivos
   • Problema: Evitar saídas parciais/corrompidas na parada da thread.
   • Solução: Gravar em .tmp primeiro; no stop(), renomear para (downlink) ou (uplink).

Referências (Open-Source e Documentação)

• Dobby (Framework de Hooking Inline) - https://www.github.com/jmpews/Dobby
• AndKittyInjector (injetor de processos Android) - https://github.com/MJx0/AndKittyInjector
• AOSP
  • frameworks/av/services/audioflinger (AudioFlinger, PlaybackThread, RecordThread)
  • system/media/audio (formatos de áudio, atributos, máscaras de canais)