maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-methodologies-and-resources/basic-forensic-meth

Browse Source
This commit is contained in:
Translator 2025-09-04 02:39:33 +00:00
parent be5822a500
commit 9a642be01b
3 changed files with 194 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
View File

@ -14,15 +14,15 @@
- [Intezer](https://analyze.intezer.com)
- [Any.Run](https://any.run/)
## Ferramentas de Antivírus e Detecção Offline
## Ferramentas Offline de Antivírus e Detecção
### Yara
#### Instalar
#### Instalação
```bash
sudo apt-get install -y yara
```
#### Prepare regras
#### Preparar regras
Use este script para baixar e mesclar todas as regras yara de malware do github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Crie o diretório _**rules**_ e execute-o. Isso criará um arquivo chamado _**malware_rules.yar**_ que contém todas as regras yara para malware.
@ -31,25 +31,25 @@ wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763c
mkdir rules
python malware_yara_rules.py
```
#### Escanear
#### Varredura
```bash
yara -w malware_rules.yar image #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder
```
#### YaraGen: Verifique se há malware e crie regras
#### YaraGen: Verificar malware e criar regras
Você pode usar a ferramenta [**YaraGen**](https://github.com/Neo23x0/yarGen) para gerar regras yara a partir de um binário. Confira estes tutoriais: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
Você pode usar a ferramenta [**YaraGen**](https://github.com/Neo23x0/yarGen) para gerar yara rules a partir de um binário. Confira estes tutoriais: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
```bash
python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m ../../mals/
```
### ClamAV
#### Instalar
#### Instalação
```
sudo apt-get install -y clamav
```
#### Escanear
#### Scan
```bash
sudo freshclam #Update rules
clamscan filepath #Scan 1 file
@ -57,25 +57,25 @@ clamscan folderpath #Scan the whole folder
```
### [Capa](https://github.com/mandiant/capa)
**Capa** detecta **capacidades** potencialmente maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como táticas do Att\&ck ou capacidades suspeitas, como:
**Capa** detecta **capacidades** potencialmente maliciosas em executáveis: PE, ELF, .NET. Assim, encontrará coisas como Att\&ck tactics, ou capacidades suspeitas como:
- verificar erro de OutputDebugString
- verificar erro em OutputDebugString
- executar como um serviço
- criar processo
Obtenha no [**repositório do Github**](https://github.com/mandiant/capa).
Obtenha-o no [**Github repo**](https://github.com/mandiant/capa).
### IOCs
IOC significa Indicador de Compromisso. Um IOC é um conjunto de **condições que identificam** algum software potencialmente indesejado ou **malware** confirmado. As Blue Teams usam esse tipo de definição para **procurar por esse tipo de arquivos maliciosos** em seus **sistemas** e **redes**.\
Compartilhar essas definições é muito útil, pois quando o malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá-lo para identificar o malware mais rapidamente.
IOC significa Indicador de Comprometimento. Um IOC é um conjunto de **condições que identificam** algum software potencialmente indesejado ou confirmado **malware**. Blue Teams usam esse tipo de definição para **procurar por esse tipo de arquivos maliciosos** em seus **sistemas** e **redes**.\
Compartilhar essas definições é muito útil, pois quando um malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá-lo para identificar o malware mais rapidamente.
Uma ferramenta para criar ou modificar IOCs é [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
Você pode usar ferramentas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **procurar por IOCs definidos em um dispositivo**.
Você pode usar ferramentas como [**Redline**](https://www.fireeye.com/services/freeware/redline.html) para **procurar IOCs definidos em um dispositivo**.
### Loki
[**Loki**](https://github.com/Neo23x0/Loki) é um scanner para Indicadores Simples de Compromisso.\
[**Loki**](https://github.com/Neo23x0/Loki) é um scanner para Indicadores Simples de Comprometimento.\
A detecção é baseada em quatro métodos de detecção:
```
1. File Name IOC
@ -92,7 +92,7 @@ Compares process connection endpoints with C2 IOCs (new since version v.10)
```
### Linux Malware Detect
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, que é projetado em torno das ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele usa dados de ameaças de sistemas de detecção de intrusões na borda da rede para extrair malware que está sendo ativamente utilizado em ataques e gera assinaturas para detecção. Além disso, os dados de ameaças também são derivados de envios de usuários com o recurso de checkout do LMD e recursos da comunidade de malware.
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, projetado para as ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele usa dados de ameaça de sistemas de detecção de intrusão de borda de rede para extrair malware que está sendo usado ativamente em ataques e gerar assinaturas para detecção. Além disso, os dados de ameaça também são derivados de submissões de usuários com o recurso checkout do LMD e de recursos da comunidade de malware.
### rkhunter
@ -102,31 +102,31 @@ sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--sk
```
### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) é uma ferramenta que tentará encontrar strings ofuscadas dentro de executáveis usando diferentes técnicas.
[**FLOSS**](https://github.com/mandiant/flare-floss) é uma ferramenta que tenta encontrar strings ofuscadas dentro de executáveis usando diferentes técnicas.
### PEpper
[PEpper](https://github.com/Th3Hurrican3/PEpper) verifica algumas informações básicas dentro do executável (dados binários, entropia, URLs e IPs, algumas regras yara).
[PEpper ](https://github.com/Th3Hurrican3/PEpper) verifica alguns elementos básicos dentro do executável (binary data, entropy, URLs and IPs, algumas regras yara).
### PEstudio
[PEstudio](https://www.winitor.com/download) é uma ferramenta que permite obter informações de executáveis do Windows, como imports, exports, cabeçalhos, mas também verificará o virus total e encontrará técnicas potenciais do Att\&ck.
[PEstudio](https://www.winitor.com/download) é uma ferramenta que permite obter informações de executáveis Windows como imports, exports, headers, mas também verifica o VirusTotal e encontra potenciais técnicas do Att\&ck.
### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) é uma ferramenta para detectar se um arquivo está **criptografado** e também encontrar **empacotadores**.
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) é uma ferramenta para detectar se um arquivo está **criptografado** e também encontrar **packers**.
### NeoPI
[**NeoPI**](https://github.com/CiscoCXSecurity/NeoPI) é um script em Python que utiliza uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** dentro de arquivos de texto/script. O objetivo pretendido do NeoPI é ajudar na **detecção de código de web shell oculto**.
[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is um script Python que usa uma variedade de **métodos estatísticos** para detectar conteúdo **ofuscado** e **criptografado** dentro de arquivos de texto/script. O propósito do NeoPI é auxiliar na **detecção de código de web shell oculto**.
### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar **código ofuscado**/**suspeito**, bem como arquivos que utilizam funções **PHP** frequentemente usadas em **malwares**/webshells.
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) faz o seu melhor para detectar código **ofuscado**/**suspeito** assim como arquivos que usam funções **PHP** frequentemente usadas em **malwares**/webshells.
### Apple Binary Signatures
Ao verificar alguma **amostra de malware**, você deve sempre **verificar a assinatura** do binário, pois o **desenvolvedor** que a assinou pode já estar **relacionado** com **malware.**
Ao analisar alguma **amostra de malware** você deve sempre **verificar a assinatura** do binário, pois o **desenvolvedor** que a assinou pode já estar **relacionado** com **malware.**
```bash
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -139,27 +139,39 @@ spctl --assess --verbose /Applications/Safari.app
```
## Técnicas de Detecção
### Empilhamento de Arquivos
### File Stacking
Se você sabe que alguma pasta contendo os **arquivos** de um servidor web foi **atualizada pela última vez em uma data específica**. **Verifique** a **data** em que todos os **arquivos** no **servidor web foram criados e modificados** e se alguma data é **suspeita**, verifique esse arquivo.
Se você sabe que alguma pasta contendo os **files** de um **web server** foi **atualizada por último em uma determinada data**, **verifique** a **data** em que todos os **files** no **web server** foram criados e modificados e se alguma data for **suspeita**, cheque esse file.
### Linhas de Base
### Baselines
Se os arquivos de uma pasta **não deveriam ter sido modificados**, você pode calcular o **hash** dos **arquivos originais** da pasta e **compará-los** com os **atuais**. Qualquer modificação será **suspeita**.
Se os **files** de uma pasta **não deveriam ter sido modificados**, você pode calcular o **hash** dos **original files** da pasta e **compará-los** com os atuais. Qualquer coisa modificada será **suspeita**.
### Análise Estatística
### Statistical Analysis
Quando as informações são salvas em logs, você pode **verificar estatísticas como quantas vezes cada arquivo de um servidor web foi acessado, pois um shell web pode ser um dos mais**.
Quando a informação é salva em logs você pode **verificar estatísticas, como quantas vezes cada file de um web server foi acessado, já que um web shell pode ser um dos mais**.
---
## Deobfuscação de Fluxo de Controle Dinâmico (Despachantes JMP/CALL RAX)
### Android in-app native telemetry (no root)
Famílias modernas de malware abusam fortemente da ofuscação do Grafo de Fluxo de Controle (CFG): em vez de um salto/chamada direto, eles computam o destino em tempo de execução e executam um `jmp rax` ou `call rax`. Um pequeno *despachante* (tipicamente nove instruções) define o alvo final dependendo das flags `ZF`/`CF` da CPU, quebrando completamente a recuperação estática do CFG.
On Android, você pode instrumentar código nativo dentro do processo do app alvo pré-carregando uma pequena biblioteca logger antes que outras libs JNI inicializem. Isso dá visibilidade precoce do comportamento nativo sem hooks a nível de sistema ou root. Uma abordagem popular é SoTap: coloque libsotap.so para a ABI correta dentro do APK e injete uma chamada System.loadLibrary("sotap") cedo (por exemplo, em um inicializador estático ou Application.onCreate), então colete logs de caminhos internos/externos ou use Logcat como fallback.
A técnica – demonstrada pelo carregador SLOW#TEMPEST – pode ser derrotada com um fluxo de trabalho em três etapas que depende apenas do IDAPython e do emulador de CPU Unicorn.
See the Android native reversing page for setup details and log paths:
### 1. Localizar cada salto / chamada indireta
{{#ref}}
../../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
{{#endref}}
---
## Desobfuscando Control-Flow Dinâmico (JMP/CALL RAX Dispatchers)
Famílias modernas de malware abusam fortemente da obfuscação do Control-Flow Graph (CFG): em vez de um jump/call direto elas calculam o destino em tempo de execução e executam um `jmp rax` ou `call rax`. Um pequeno *dispatcher* (tipicamente nove instruções) define o alvo final dependendo das flags da CPU `ZF`/`CF`, quebrando completamente a recuperação estática do CFG.
A técnica – demonstrada pelo loader SLOW#TEMPEST – pode ser derrotada com um fluxo de trabalho em três passos que depende apenas de IDAPython e do emulador de CPU Unicorn.
### 1. Localize cada jump/call indireto
```python
import idautils, idc
@ -168,7 +180,7 @@ mnem = idc.print_insn_mnem(ea)
if mnem in ("jmp", "call") and idc.print_operand(ea, 0) == "rax":
print(f"[+] Dispatcher found @ {ea:X}")
```
### 2. Extraia o byte-code do despachante
### 2. Extrair o byte-code do dispatcher
```python
import idc
@ -199,9 +211,9 @@ mu.reg_write(UC_X86_REG_RAX, 0)
mu.emu_start(BASE, BASE+len(code))
return mu.reg_read(UC_X86_REG_RAX)
```
Execute `run(code,0,0)` e `run(code,1,1)` para obter os alvos dos ramos *falso* e *verdadeiro*.
Execute `run(code,0,0)` e `run(code,1,1)` para obter os alvos de branch *false* e *true*.
### 4. Repare um salto / chamada direta
### 4. Aplicar patch para um jump / call direto
```python
import struct, ida_bytes
@ -215,22 +227,23 @@ Após aplicar o patch, force o IDA a reanalisar a função para que o CFG comple
import ida_auto, idaapi
idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
```
### 5. Rotule chamadas de API indiretas
### 5. Rotular chamadas de API indiretas
Uma vez que o verdadeiro destino de cada `call rax` é conhecido, você pode informar ao IDA qual é, para que os tipos de parâmetros e nomes de variáveis sejam recuperados automaticamente:
Uma vez que o destino real de cada `call rax` seja conhecido, você pode informar o IDA sobre ele para que os tipos de parâmetros & nomes de variáveis sejam recuperados automaticamente:
```python
idc.set_callee_name(call_ea, resolved_addr, 0) # IDA 8.3+
```
### Benefícios práticos
* Restaura o CFG real → a descompilação passa de *10* linhas para milhares.
* Permite referência cruzada de strings & xrefs, tornando a reconstrução de comportamento trivial.
* Scripts são reutilizáveis: basta colocá-los em qualquer loader protegido pelo mesmo truque.
* Restaura o CFG real → a decompilação passa de *10* linhas para milhares.
* Permite string-cross-reference & xrefs, tornando a reconstrução do comportamento trivial.
* Scripts são reutilizáveis: coloque-os em qualquer loader protegido pelo mesmo truque.
---
## Referências
- [Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques](https://unit42.paloaltonetworks.com/slow-tempest-malware-obfuscation/)
- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}}

109
src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
View File

@ -2,34 +2,37 @@
{{#include ../../banners/hacktricks-training.md}}
**Para mais informações, consulte:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
Aplicativos Android podem usar bibliotecas nativas, tipicamente escritas em C ou C++, para tarefas críticas de desempenho. Criadores de malware também abusam dessas bibliotecas porque objetos compartilhados ELF ainda são mais difíceis de descompilar do que byte-code DEX/OAT. Esta página foca em fluxos de trabalho *práticos* e melhorias de ferramentas *recentes* (2023-2025) que facilitam a reversão de arquivos `.so` do Android.
**Para mais informações consulte:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
Apps Android podem usar bibliotecas nativas, tipicamente escritas em C ou C++, para tarefas críticas de desempenho. Criadores de malware também abusam dessas bibliotecas porque ELF shared objects ainda são mais difíceis de decompilar do que byte-code DEX/OAT.
Esta página foca em fluxos de trabalho *práticos* e em melhorias recentes de tooling (2023-2025) que tornam a reversão de arquivos `.so` do Android mais fácil.
---
### Fluxo de trabalho rápido de triagem para um `libfoo.so` recém-extraído
### Fluxo rápido de triagem para um `libfoo.so` recém-extraído
1. **Extraia a biblioteca**
1. **Extrair a biblioteca**
```bash
# De um aplicativo instalado
# From an installed application
adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
# Ou do APK (zip)
# Or from the APK (zip)
unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
```
2. **Identifique a arquitetura e proteções**
2. **Identificar arquitetura e proteções**
```bash
file libfoo.so # arm64 ou arm32 / x86
file libfoo.so # arm64 or arm32 / x86
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc.
checksec --file libfoo.so # (peda/pwntools)
```
3. **Liste símbolos exportados e ligações JNI**
3. **Listar símbolos exportados e bindings JNI**
```bash
readelf -s libfoo.so | grep ' Java_' # JNI dinâmico
strings libfoo.so | grep -i "RegisterNatives" -n # JNI registrado estaticamente
readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI
strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI
```
4. **Carregue em um descompilador** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper ou Cutter/Rizin) e execute a análise automática. Versões mais novas do Ghidra introduziram um descompilador AArch64 que reconhece stubs PAC/BTI e tags MTE, melhorando significativamente a análise de bibliotecas construídas com o NDK do Android 14.
5. **Decida entre reversão estática e dinâmica:** código ofuscado ou removido frequentemente precisa de *instrumentação* (Frida, ptrace/gdbserver, LLDB).
4. **Carregar em um decompilador** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) e executar a análise automática.
Versões mais recentes do Ghidra introduziram um decompilador AArch64 que reconhece stubs PAC/BTI e tags MTE, melhorando bastante a análise de bibliotecas compiladas com o Android 14 NDK.
5. **Decida entre reversing estático vs dinâmico:** código stripped ou ofuscado frequentemente precisa de *instrumentation* (Frida, ptrace/gdbserver, LLDB).
---
@ -37,11 +40,11 @@ strings libfoo.so | grep -i "RegisterNatives" -n # JNI registrado estaticame
A série 16 do Frida trouxe várias melhorias específicas para Android que ajudam quando o alvo usa otimizações modernas do Clang/LLD:
* `thumb-relocator` agora pode *hookear pequenas funções ARM/Thumb* geradas pelo alinhamento agressivo do LLD (`--icf=all`).
* Enumerar e reatribuir *slots de importação ELF* funciona no Android, permitindo patching `dlopen()`/`dlsym()` por módulo quando hooks inline são rejeitados.
* O hooking Java foi corrigido para o novo **ponto de entrada rápido ART** usado quando aplicativos são compilados com `--enable-optimizations` no Android 14.
* `thumb-relocator` agora pode *hook tiny ARM/Thumb functions* geradas pelo alinhamento agressivo do LLD (`--icf=all`).
* Enumeração e rebinding de *ELF import slots* funciona no Android, permitindo patching por módulo com `dlopen()`/`dlsym()` quando inline hooks são rejeitados.
* Java hooking foi corrigido para o novo **ART quick-entrypoint** usado quando apps são compilados com `--enable-optimizations` no Android 14.
Exemplo: enumerando todas as funções registradas através de `RegisterNatives` e despejando seus endereços em tempo de execução:
Exemplo: enumerar todas as funções registradas via `RegisterNatives` e despejar seus endereços em tempo de execução:
```javascript
Java.perform(function () {
var Runtime = Java.use('java.lang.Runtime');
@ -58,38 +61,76 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
});
});
```
Frida funcionará imediatamente em dispositivos habilitados para PAC/BTI (Pixel 8/Android 14+) desde que você use frida-server 16.2 ou posterior – versões anteriores falharam em localizar o preenchimento para hooks inline. citeturn5search2turn5search0
Frida will work out of the box on PAC/BTI-enabled devices (Pixel 8/Android 14+) as long as you use frida-server 16.2 or later – earlier versions failed to locate padding for inline hooks.
### Telemetria JNI local ao processo via .so pré-carregado (SoTap)
Quando instrumentação completa é exagerada ou bloqueada, você ainda pode obter visibilidade em nível nativo pré-carregando um pequeno logger dentro do processo alvo. SoTap é uma biblioteca nativa Android leve (.so) que registra o comportamento em tempo de execução de outras bibliotecas JNI (.so) dentro do mesmo processo do app (não requer root).
Propriedades principais:
- Inicializa cedo e observa interações JNI/nativas dentro do processo que a carrega.
- Persiste logs usando múltiplos caminhos graváveis com fallback elegante para Logcat quando o armazenamento é restrito.
- Personalizável no código-fonte: edite sotap.c para estender/ajustar o que é registrado e reconstrua por ABI.
Configuração (reempacotar o APK):
1) Coloque a build para a ABI correta dentro do APK para que o loader consiga resolver libsotap.so:
- lib/arm64-v8a/libsotap.so (for arm64)
- lib/armeabi-v7a/libsotap.so (for arm32)
2) Assegure que SoTap seja carregado antes de outras libs JNI. Injete uma chamada cedo (por exemplo, no inicializador estático de uma subclasse de Application ou onCreate) para que o logger seja inicializado primeiro. Exemplo de snippet Smali:
```smali
const-string v0, "sotap"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
```
3) Reconstrua/assine/instale, execute o app e então colete os logs.
Caminhos de log (verificados na ordem):
```
/data/user/0/%s/files/sotap.log
/data/data/%s/files/sotap.log
/sdcard/Android/data/%s/files/sotap.log
/sdcard/Download/sotap-%s.log
# If all fail: fallback to Logcat only
```
Notes and troubleshooting:
- Alinhamento da ABI é obrigatório. Uma incompatibilidade causará um UnsatisfiedLinkError e o logger não será carregado.
- Restrições de armazenamento são comuns em Android modernos; se gravações de arquivo falharem, SoTap ainda emitirá via Logcat.
- Comportamento/verbosidade devem ser customizados; reconstrua a partir do código-fonte após editar sotap.c.
Esta abordagem é útil para triagem de malware e depuração JNI quando observar fluxos de chamadas nativas desde o início do processo é crítico, mas hooks root/system-wide não estão disponíveis.
---
### Vulnerabilidades recentes que valem a pena investigar em APKs
### Recent vulnerabilities worth hunting for in APKs
| Ano | CVE | Biblioteca afetada | Notas |
| Year | CVE | Affected library | Notes |
|------|-----|------------------|-------|
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Buffer overflow na heap acessível a partir de código nativo que decodifica imagens WebP. Vários aplicativos Android incluem versões vulneráveis. Quando você vê um `libwebp.so` dentro de um APK, verifique sua versão e tente exploração ou correção.| citeturn2search0|
|2024|Múltiplos|Série OpenSSL 3.x|Vários problemas de segurança de memória e oracle de preenchimento. Muitos pacotes Flutter & ReactNative incluem seu próprio `libcrypto.so`.|
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Overflow de buffer no heap alcançável a partir de código nativo que decodifica imagens WebP. Vários apps Android empacotam versões vulneráveis. Quando você encontrar um `libwebp.so` dentro de um APK, verifique sua versão e tente exploração ou patching.| |
|2024|Multiple|OpenSSL 3.x series|Várias questões de segurança de memória e padding-oracle. Muitos bundles Flutter & ReactNative incluem seu próprio `libcrypto.so`.|
Quando você encontrar arquivos `.so` *de terceiros* dentro de um APK, sempre verifique seu hash contra avisos upstream. SCA (Análise de Composição de Software) é incomum em dispositivos móveis, então builds vulneráveis desatualizados são comuns.
Quando você spotar arquivos `.so` *de terceiros* dentro de um APK, sempre verifique o hash contra advisories upstream. SCA (Software Composition Analysis) é incomum em mobile, então builds desatualizados e vulneráveis são comuns.
---
### Tendências de Anti-Reversão & Hardening (Android 13-15)
### Anti-Reversing & Hardening trends (Android 13-15)
* **Autenticação de Ponteiros (PAC) & Identificação de Alvo de Ramificação (BTI):** O Android 14 habilita PAC/BTI em bibliotecas do sistema em silício ARMv8.3+ suportado. Descompiladores agora exibem pseudo-instruções relacionadas ao PAC; para análise dinâmica, o Frida injeta trampolinas *após* remover o PAC, mas suas trampolinas personalizadas devem chamar `pacda`/`autibsp` quando necessário.
* **MTE & Alocador endurecido Scudo:** a marcação de memória é opcional, mas muitos aplicativos cientes do Play-Integrity são construídos com `-fsanitize=memtag`; use `setprop arm64.memtag.dump 1` mais `adb shell am start ...` para capturar falhas de tag.
* **Ofuscador LLVM (predicados opacos, achatamento de fluxo de controle):** empacotadores comerciais (por exemplo, Bangcle, SecNeo) protegem cada vez mais o código *nativo*, não apenas Java; espere fluxo de controle falso e blobs de string criptografados em `.rodata`.
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 habilita PAC/BTI em bibliotecas do sistema em silício ARMv8.3+ suportado. Decompilers agora exibem pseudo-instruções relacionadas a PAC; para análise dinâmica o Frida injeta trampolines *after* stripping PAC, mas seus trampolines customizados devem chamar `pacda`/`autibsp` quando necessário.
* **MTE & Scudo hardened allocator:** memory-tagging é opt-in, mas muitos apps com Play-Integrity são compilados com `-fsanitize=memtag`; use `setprop arm64.memtag.dump 1` plus `adb shell am start ...` para capturar tag faults.
* **LLVM Obfuscator (opaque predicates, control-flow flattening):** packers comerciais (e.g., Bangcle, SecNeo) protegem cada vez mais o código *nativo*, não só Java; espere control-flow falso e blobs de strings criptografadas em `.rodata`.
---
### Recursos
### Resources
- **Aprendendo Assembly ARM:** [Azeria Labs – Fundamentos de Assembly ARM](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **Documentação JNI & NDK:** [Especificação JNI da Oracle](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Dicas JNI para Android](https://developer.android.com/training/articles/perf-jni) · [Guias NDK](https://developer.android.com/ndk/guides/)
- **Depurando Bibliotecas Nativas:** [Depure Bibliotecas Nativas do Android Usando JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
- **Aprendendo ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **Documentação JNI & NDK:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/)
- **Depuração de bibliotecas nativas:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
### Referências
### References
- Registro de alterações do Frida 16.x (hooking Android, realocação de função pequena) – [frida.re/news](https://frida.re/news/) citeturn5search0
- Aviso da NVD para overflow `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) citeturn2search0
- Changelog do Frida 16.x (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
- Aviso NVD para `libwebp` overflow CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863)
- SoTap: Logger leve in-app de comportamento JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
- Releases do SoTap – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases)
- Como trabalhar com SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13)
{{#include ../../banners/hacktricks-training.md}}

95
src/mobile-pentesting/android-app-pentesting/smali-changes.md
View File

@ -1,12 +1,13 @@
# Smali - Decompilação/\[Modificação]/Compilação
# Smali - Decompilando/[Modificando]/Compilando
{{#include ../../banners/hacktricks-training.md}}
Às vezes, é interessante modificar o código do aplicativo para acessar informações ocultas para você (talvez senhas ou flags bem ofuscadas). Então, pode ser interessante decompilar o apk, modificar o código e recompilá-lo.
**Referência de Opcodes:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
Às vezes é interessante modificar o código da aplicação para acessar informações ocultas para você (talvez senhas bem ofuscadas ou flags). Então, pode ser interessante decompilar o apk, modificar o código e recompilá-lo.
## Modo Rápido
**Referência de opcodes:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
## Maneira Rápida
Usando **Visual Studio Code** e a extensão [APKLab](https://github.com/APKLab/APKLab), você pode **decompilar automaticamente**, modificar, **recompilar**, assinar e instalar o aplicativo sem executar nenhum comando.
@ -14,43 +15,43 @@ Outro **script** que facilita muito essa tarefa é [**https://github.com/ax/apk.
## Decompilar o APK
Usando APKTool, você pode acessar o **código smali e recursos**:
Usando APKTool você pode acessar o **smali code and resources**:
```bash
apktool d APP.apk
```
Se o **apktool** der algum erro, tente [instalar a **versão mais recente**](https://ibotpeaches.github.io/Apktool/install/)
Se **apktool** lhe der algum erro, tente[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/)
Alguns **arquivos interessantes que você deve olhar são**:
Alguns **arquivos interessantes que você deve verificar são**:
- _res/values/strings.xml_ (e todos os xmls dentro de res/values/\*)
- _res/values/strings.xml_ (e todos os xmls dentro de res/values/*)
- _AndroidManifest.xml_
- Qualquer arquivo com extensão _.sqlite_ ou _.db_
Se o `apktool` tiver **problemas ao decodificar a aplicação**, dê uma olhada em [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) ou tente usar o argumento **`-r`** (Não decodificar recursos). Então, se o problema estava em um recurso e não no código-fonte, você não terá o problema (você também não decompilará os recursos).
Se `apktool` tiver **problemas ao decodificar a aplicação** consulte [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) ou tente usar o argumento **`-r`** (Não decodificar recursos). Então, se o problema estava em um recurso e não no código-fonte, você não terá o problema (você também não decompilará os recursos).
## Mudar código smali
## Alterar código smali
Você pode **mudar** **instruções**, mudar o **valor** de algumas variáveis ou **adicionar** novas instruções. Eu mudo o código Smali usando [**VS Code**](https://code.visualstudio.com), você então instala a **extensão smalise** e o editor lhe dirá se alguma **instrução está incorreta**.\
Você pode **alterar** **instruções**, alterar o **valor** de algumas variáveis ou **adicionar** novas instruções. Eu altero o código Smali usando [**VS Code**](https://code.visualstudio.com), em seguida instalo a **smalise extension** e o editor dirá se alguma **instrução estiver incorreta**.\
Alguns **exemplos** podem ser encontrados aqui:
- [Exemplos de mudanças Smali](smali-changes.md)
- [Smali changes examples](smali-changes.md)
- [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md)
Ou você pode [**ver abaixo algumas mudanças Smali explicadas**](smali-changes.md#modifying-smali).
Ou você pode [**check below some Smali changes explained**](smali-changes.md#modifying-smali).
## Recompilar o APK
## Recompile the APK
Após modificar o código, você pode **recompilar** o código usando:
Após modificar o código você pode **recompilar** o código usando:
```bash
apktool b . #In the folder generated when you decompiled the application
```
Ele **compilará** o novo APK **dentro** da pasta _**dist**_.
Ele vai **compile** o novo APK **inside** a pasta _**dist**_.
Se o **apktool** gerar um **erro**, tente[ instalar a **versão mais recente**](https://ibotpeaches.github.io/Apktool/install/)
Se o **apktool** lançar um **erro**, tente[ instalar a **última versão**](https://ibotpeaches.github.io/Apktool/install/)
### **Assine o novo APK**
### **Assinar o novo APK**
Então, você precisa **gerar uma chave** (você será solicitado a fornecer uma senha e algumas informações que pode preencher aleatoriamente):
Então, você precisa **gerar uma chave** (será solicitado uma senha e algumas informações que você pode preencher aleatoriamente):
```bash
keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias <your-alias>
```
@ -60,14 +61,14 @@ jarsigner -keystore key.jks path/to/dist/* <your-alias>
```
### Otimizar nova aplicação
**zipalign** é uma ferramenta de alinhamento de arquivos que fornece otimizações importantes para arquivos de aplicação Android (APK). [More information here](https://developer.android.com/studio/command-line/zipalign).
**zipalign** é uma ferramenta de alinhamento de arquivos que otimiza arquivos de aplicações Android (APK). [More information here](https://developer.android.com/studio/command-line/zipalign).
```bash
zipalign [-f] [-v] <alignment> infile.apk outfile.apk
zipalign -v 4 infile.apk
```
### **Assine o novo APK (novamente?)**
### **Assinar o novo APK (de novo?)**
Se você **preferir** usar [**apksigner**](https://developer.android.com/studio/command-line/) em vez de jarsigner, **você deve assinar o apk** após aplicar **a otimização com** zipalign. MAS NOTE QUE VOCÊ SÓ PRECISA **ASSINAR A APLICAÇÃO UMA VEZ** COM jarsigner (antes do zipalign) OU COM aspsigner (depois do zipalign).
Se você **prefere** usar [**apksigner**](https://developer.android.com/studio/command-line/) em vez de jarsigner, **você deve assinar o apk** depois de aplicar **a otimização com** zipaling. MAS NOTE QUE VOCÊ SÓ PRECISA **ASSINAR A APLICAÇÃO UMA VEZ** COM jarsigner (antes do zipalign) OU COM aspsigner (após zipaling).
```bash
apksigner sign --ks key.jks ./dist/mycompiled.apk
```
@ -89,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
return-void
.end method
```
O conjunto de instruções Smali está disponível [aqui](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions).
The Smali instruction set is available [aqui](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions).
### Mudanças Leves
### Alterações leves
### Modificar valores iniciais de uma variável dentro de uma função
Algumas variáveis são definidas no início da função usando o opcode _const_, você pode modificar seus valores ou pode definir novos:
Algumas variáveis são definidas no início da função usando o opcode _const_, você pode modificar seus valores, ou pode definir novas:
```bash
#Number
const v9, 0xf4240
@ -128,7 +129,7 @@ goto :goto_6 #Always go to: :goto_6
```
### Mudanças Maiores
### Registro
### Logging
```bash
#Log win: <number>
iget v5, p0, Lcom/google/ctf/shallweplayagame/GameActivity;->o:I #Get this.o inside v5
@ -139,17 +140,17 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin
```
Recomendações:
- Se você for usar variáveis declaradas dentro da função (declaradas v0,v1,v2...) coloque essas linhas entre o _.local \<número>_ e as declarações das variáveis (_const v0, 0x1_)
- Se você quiser colocar o código de logging no meio do código de uma função:
- Se você for usar variáveis declaradas dentro da função (declaradas v0,v1,v2...) coloque essas linhas entre _.local <number>_ e as declarações das variáveis (_const v0, 0x1_)
- Se quiser colocar o código de logging no meio do código de uma função:
- Adicione 2 ao número de variáveis declaradas: Ex: de _.locals 10_ para _.locals 12_
- As novas variáveis devem ser os próximos números das variáveis já declaradas (neste exemplo devem ser _v10_ e _v11_, lembre-se que começa em v0).
- Altere o código da função de logging e use _v10_ e _v11_ em vez de _v5_ e _v1_.
### Toasting
### Exibindo Toast
Lembre-se de adicionar 3 ao número de _.locals_ no início da função.
Este código está preparado para ser inserido no **meio de uma função** (**mude** o número das **variáveis** conforme necessário). Ele irá pegar o **valor de this.o**, **transformá-lo** em **String** e então **fazer** um **toast** com seu valor.
Este código está preparado para ser inserido no **meio de uma função** (**altere** o número das **variáveis** conforme necessário). Ele irá pegar o **valor de this.o**, **transformá-lo** em **String** e então **fazer** um **toast** com seu valor.
```bash
const/4 v10, 0x1
const/4 v11, 0x1
@ -161,4 +162,38 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/
move-result-object v12
invoke-virtual {v12}, Landroid/widget/Toast;->show()V
```
### Carregando uma Biblioteca Nativa na Inicialização (System.loadLibrary)
Às vezes você precisa pré-carregar uma biblioteca nativa para que ela seja inicializada antes de outras JNI libs (por exemplo, para habilitar process-local telemetry/logging). Você pode injetar uma chamada para System.loadLibrary() em um inicializador estático ou no início de Application.onCreate(). Exemplo smali para um inicializador estático de classe (<clinit>):
```smali
.class public Lcom/example/App;
.super Landroid/app/Application;
.method static constructor <clinit>()V
.registers 1
const-string v0, "sotap" # library name without lib...so prefix
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
return-void
.end method
```
Alternativamente, coloque as mesmas duas instruções no início do seu Application.onCreate() para garantir que a biblioteca seja carregada o mais cedo possível:
```smali
.method public onCreate()V
.locals 1
const-string v0, "sotap"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
invoke-super {p0}, Landroid/app/Application;->onCreate()V
return-void
.end method
```
Notas:
- Certifique-se de que a variante ABI correta da biblioteca exista em lib/<abi>/ (por exemplo, arm64-v8a/armeabi-v7a) para evitar UnsatisfiedLinkError.
- Carregar muito cedo (class static initializer) garante que o native logger possa observar a atividade JNI subsequente.
## Referências
- SoTap: registrador leve in-app de comportamento JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}}