# Tutorial do Objection
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
## **Introdução**
[](https://github.com/sensepost/objection)
**objection - Exploração de Dispositivos Móveis em Tempo de Execução**
`objection` é um conjunto de ferramentas de exploração de dispositivos móveis em tempo de execução, alimentado pelo [Frida](https://www.frida.re). Foi construído com o objetivo de ajudar a avaliar aplicativos móveis e sua postura de segurança sem a necessidade de um dispositivo móvel com jailbreak ou root.
**Observação:** Isso não é uma forma de contornar o jailbreak/root. Ao usar o `objection`, você ainda está limitado por todas as restrições impostas pelo sandbox aplicável que está enfrentando.
### Resumo
O **objetivo** do **objection** é permitir que o usuário chame as **principais ações que o Frida oferece**. **Caso contrário**, o usuário precisará criar um **único script para cada aplicativo** que ele deseja testar.
## Tutorial
Para este tutorial, vou usar o APK que você pode baixar aqui:
{% file src="../../../.gitbook/assets/app-release.zip" %}
Ou do seu [repositório original](https://github.com/asvid/FridaApp)(baixe app-release.apk)
### Instalação
```bash
pip3 install objection
```
### Conexão
Faça uma **conexão ADB regular** e **inicie** o servidor **frida** no dispositivo (e verifique se o frida está funcionando tanto no cliente quanto no servidor).
Se você estiver usando um dispositivo **root**, é necessário selecionar o aplicativo que deseja testar dentro da opção _**--gadget**_. Neste caso:
```bash
frida-ps -Uai
objection --gadget asvid.github.io.fridaapp explore
```
### Ações Básicas
Nem todos os comandos possíveis do Objection serão listados neste tutorial, apenas aqueles que considero mais úteis.
#### Ambiente
Algumas informações interessantes (como senhas ou caminhos) podem ser encontradas dentro do ambiente.
```bash
env
```
.png>)
#### Informações sobre o Frida
O Frida é uma poderosa ferramenta de manipulação e instrumentação de código aberto, que permite a análise e modificação dinâmica de aplicativos em execução. Ele suporta várias plataformas, incluindo Android, iOS, Windows, macOS e Linux.
O Frida é amplamente utilizado para testes de segurança de aplicativos móveis, pois permite que os testadores realizem análises profundas e interajam com o código do aplicativo em tempo real. Ele oferece recursos avançados, como a capacidade de injetar scripts JavaScript personalizados em aplicativos, monitorar chamadas de função, interceptar e modificar dados em trânsito e muito mais.
Neste tutorial, vamos nos concentrar no uso do Frida para testes de segurança de aplicativos Android. Vamos explorar o uso da ferramenta Objection, que é uma extensão do Frida, para automatizar várias tarefas comuns de teste de segurança em aplicativos Android.
```bash
frida
```
.png>)
#### Upload/Download
```bash
file download []
file upload []
```
#### Importar script frida
```javascript
const { spawn } = require('child_process');
const frida = require('frida');
async function run() {
const device = await frida.getUsbDevice();
const pid = await device.spawn(['com.example.app']);
const session = await device.attach(pid);
const script = await session.createScript(`
console.log('Hello, world!');
`);
await script.load();
await device.resume(pid);
}
run().catch(console.error);
```
#### Importar script frida
```javascript
const { spawn } = require('child_process');
const frida = require('frida');
async function run() {
const device = await frida.getUsbDevice();
const pid = await device.spawn(['com.example.app']);
const session = await device.attach(pid);
const script = await session.createScript(`
console.log('Olá, mundo!');
`);
await script.load();
await device.resume(pid);
}
run().catch(console.error);
```
```bash
import
```
#### SSLPinning
O SSLPinning é uma técnica de segurança utilizada em aplicativos Android para proteger a comunicação entre o aplicativo e o servidor. Ele impede que um atacante intercepte e leia o tráfego de rede, mesmo que ele consiga realizar um ataque de Man-in-the-Middle (MITM).
Quando um aplicativo utiliza o SSLPinning, ele verifica se o certificado do servidor corresponde ao certificado esperado. Isso garante que a conexão seja estabelecida apenas com servidores confiáveis, evitando assim a possibilidade de ataques de interceptação.
Durante um teste de penetração em um aplicativo Android, é importante verificar se o SSLPinning está implementado corretamente. Caso contrário, um atacante pode explorar essa falha para interceptar e ler o tráfego de rede sensível, como senhas e informações pessoais.
O Objection é uma ferramenta útil para testar a implementação do SSLPinning em aplicativos Android. Ele permite desativar temporariamente o SSLPinning, facilitando a análise do tráfego de rede e a identificação de possíveis vulnerabilidades.
Para desativar o SSLPinning usando o Objection, você pode executar o seguinte comando:
```
$ objection sslpinning disable
```
Após desativar o SSLPinning, você pode usar ferramentas como o Wireshark para capturar e analisar o tráfego de rede. Isso ajudará a identificar se o aplicativo está vulnerável a ataques de interceptação.
É importante ressaltar que o SSLPinning é uma medida de segurança importante e sua implementação correta é essencial para proteger a comunicação entre o aplicativo e o servidor. Portanto, é recomendado que os desenvolvedores realizem testes de penetração para identificar e corrigir possíveis falhas de segurança relacionadas ao SSLPinning.
```bash
android sslpinning disable #Attempts to disable SSL Pinning on Android devices.
```
#### Detecção de root
Root detection, or the ability to detect whether a device has been rooted, is an important aspect of mobile app security. Rooted devices can pose a higher risk for app security as they have elevated privileges and can potentially bypass security measures put in place by the app.
There are several techniques that can be used to detect root on an Android device. Some common methods include checking for the presence of known root files or directories, checking for the presence of root binaries, and checking for the presence of system files that are typically modified on rooted devices.
Root detection can be implemented in an Android app using various approaches. One common method is to use the SafetyNet API provided by Google Play Services. This API allows developers to check the device's integrity and verify if it has been tampered with, including checking for root access.
Another approach is to use third-party libraries or frameworks that provide root detection functionality. These libraries often have pre-built checks and can simplify the implementation process.
It's important to note that root detection is not foolproof and can be bypassed by sophisticated attackers. Therefore, it should be used as one layer of defense in a comprehensive security strategy.
#### Detecção de root
A detecção de root, ou a capacidade de detectar se um dispositivo foi rooteado, é um aspecto importante da segurança de aplicativos móveis. Dispositivos rooteados podem representar um risco maior para a segurança do aplicativo, pois possuem privilégios elevados e podem potencialmente contornar as medidas de segurança implementadas pelo aplicativo.
Existem várias técnicas que podem ser usadas para detectar o root em um dispositivo Android. Alguns métodos comuns incluem verificar a presença de arquivos ou diretórios de root conhecidos, verificar a presença de binários de root e verificar a presença de arquivos do sistema que são tipicamente modificados em dispositivos rooteados.
A detecção de root pode ser implementada em um aplicativo Android usando várias abordagens. Um método comum é usar a API SafetyNet fornecida pelo Google Play Services. Essa API permite que os desenvolvedores verifiquem a integridade do dispositivo e verifiquem se ele foi adulterado, incluindo a verificação de acesso root.
Outra abordagem é usar bibliotecas ou frameworks de terceiros que fornecem funcionalidade de detecção de root. Essas bibliotecas geralmente possuem verificações pré-construídas e podem simplificar o processo de implementação.
É importante observar que a detecção de root não é infalível e pode ser contornada por atacantes sofisticados. Portanto, ela deve ser usada como uma camada de defesa em uma estratégia abrangente de segurança.
```bash
android root disable #Attempts to disable root detection on Android devices.
android root simulate #Attempts to simulate a rooted Android environment.
```
#### Executar Comando
The `exec` command in objection allows you to execute shell commands directly on the target Android device. This can be useful for various purposes, such as exploring the device's file system, running scripts, or executing commands that require root privileges.
To use the `exec` command, you need to specify the command you want to execute as an argument. For example, to list the files in the current directory, you can use the following command:
```
objection> exec ls
```
You can also execute commands that require root privileges by using the `-r` flag. For example, to restart the device, you can use the following command:
```
objection> exec -r reboot
```
Keep in mind that executing commands with root privileges can be risky, as it can potentially cause damage to the device or compromise its security. Therefore, it is important to exercise caution and only execute commands that you fully understand and trust.
Additionally, you can use the `exec` command in combination with other objection commands to perform more advanced tasks. For example, you can use the `exec` command to execute a script that interacts with the target application using objection's Frida API.
Overall, the `exec` command in objection provides a convenient way to execute shell commands on the target Android device, allowing you to perform various tasks during the mobile penetration testing process.
```bash
android shell_exec whoami
```
#### Capturas de tela
```bash
android ui screenshot /tmp/screenshot
android ui FLAG_SECURE false #This may enable you to take screenshots using the hardware keys
```
### Análise estática tornada dinâmica
Em um aplicativo real, devemos conhecer todas as informações descobertas nesta parte antes de usar o objection graças à **análise estática**. De qualquer forma, desta forma, talvez você possa ver **algo novo**, já que aqui você terá apenas uma lista completa de classes, métodos e objetos exportados.
Isso também é útil se, de alguma forma, você estiver **incapaz de obter algum código-fonte legível** do aplicativo.
#### Listar atividades, receptores e serviços
```
android hooking list activities
```
.png>)
# Tutorial Objection
O Objection é uma ferramenta de teste de penetração móvel que permite a manipulação dinâmica de aplicativos Android. Ele fornece uma interface de linha de comando (CLI) para interagir com os aplicativos em execução no dispositivo Android, permitindo que você inspecione, modifique e até mesmo injete código no aplicativo.
## Instalação
Para começar, você precisa instalar o Objection no seu dispositivo Android. Siga as etapas abaixo:
1. Faça o download do Objection no [repositório oficial do GitHub](https://github.com/sensepost/objection).
2. Extraia o arquivo zip baixado.
3. Abra um terminal e navegue até o diretório onde você extraiu o Objection.
4. Execute o comando `pip install -r requirements.txt` para instalar as dependências necessárias.
5. Conecte seu dispositivo Android ao computador usando um cabo USB.
6. No terminal, execute o comando `adb devices` para verificar se o dispositivo está conectado corretamente.
7. Execute o comando `objection --gadget "com.example.app"` para iniciar o Objection e anexá-lo ao aplicativo de destino.
## Explorando o aplicativo
Agora que o Objection está instalado e conectado ao aplicativo de destino, você pode começar a explorar e manipular o aplicativo. Aqui estão alguns comandos úteis para começar:
- `android hooking list classes` - lista todas as classes carregadas pelo aplicativo.
- `android hooking search class ` - pesquisa uma classe específica no aplicativo.
- `android hooking list methods ` - lista todos os métodos de uma classe.
- `android hooking search method ` - pesquisa um método específico no aplicativo.
- `android hooking watch class ` - monitora todas as chamadas de método em uma classe.
- `android hooking watch method ` - monitora todas as chamadas de um método específico.
Esses comandos são apenas o começo. O Objection oferece uma ampla gama de recursos e funcionalidades para explorar e manipular aplicativos Android. Experimente diferentes comandos e veja o que você pode descobrir!
## Injeção de código
Uma das principais funcionalidades do Objection é a capacidade de injetar código em tempo de execução nos aplicativos Android. Isso permite que você modifique o comportamento do aplicativo e teste diferentes cenários.
Para injetar código em um aplicativo, você pode usar o seguinte comando:
```
android hooking watch class --dump-args
```
Isso irá monitorar todas as chamadas de método na classe especificada e exibir os argumentos passados para cada chamada. Você pode então modificar esses argumentos ou até mesmo substituir o código do método para alterar o comportamento do aplicativo.
## Conclusão
O Objection é uma ferramenta poderosa para testes de penetração em aplicativos Android. Com sua capacidade de manipular dinamicamente aplicativos em execução, você pode descobrir vulnerabilidades e explorá-las para obter acesso não autorizado ou realizar outras atividades maliciosas. No entanto, lembre-se sempre de usar essa ferramenta com responsabilidade e apenas em ambientes controlados e autorizados.
```
android hooking list services
android hooking list receivers
```
Frida lançará um erro se nenhum for encontrado
#### Obtendo a atividade atual
```
android hooking get current_activity
```
#### Pesquisar Classes
Vamos começar procurando por classes dentro do nosso aplicativo.
```
android hooking search classes asvid.github.io.fridaapp
```
.png>)
#### Métodos de busca de uma classe
Agora vamos extrair os métodos dentro da classe _MainActivity:_
```
android hooking search methods asvid.github.io.fridaapp MainActivity
```
 (1).png>)
#### Listar métodos declarados de uma classe com seus parâmetros
Vamos descobrir quais parâmetros os métodos da classe precisam:
```
android hooking list class_methods asvid.github.io.fridaapp.MainActivity
```
.png>)
#### Listar classes
Você também pode listar todas as classes que foram carregadas dentro do aplicativo atual:
```
android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
```
Isso é muito útil se você quiser **interceptar o método de uma classe e só souber o nome da classe**. Você pode usar essa função para **procurar qual módulo possui a classe** e, em seguida, interceptar seu método.
### Interceptação sendo fácil
#### Interceptando (observando) um método
A partir do [código-fonte](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt) do aplicativo, sabemos que a **função** _**sum()**_ **da** _**MainActivity**_ está sendo executada **a cada segundo**. Vamos tentar **capturar todas as informações possíveis** toda vez que a função for chamada (argumentos, valor de retorno e rastreamento de volta):
```
android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --dump-args --dump-backtrace --dump-return
```
.png>)
#### Hookando (observando) uma classe inteira
Na verdade, eu acho todos os métodos da classe MainActivity realmente interessantes, vamos **hookar todos eles**. Tenha cuidado, isso pode **crashar** um aplicativo.
```
android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
```
Se você brincar com o aplicativo enquanto a classe estiver conectada, você verá quando **cada função é chamada**, seus **argumentos** e o valor de **retorno**.
.png>)
#### Alterando o valor de retorno booleano de uma função
A partir do código-fonte, você pode ver que a função _checkPin_ recebe uma _String_ como argumento e retorna um _booleano_. Vamos fazer a função **sempre retornar verdadeiro**:
.png>)
Agora, se você escrever qualquer coisa na caixa de texto para o código PIN, você verá que qualquer coisa é válida:
.png>)
### Instâncias de classe
Procure e imprima **instâncias ativas de uma classe Java específica**, especificada por um nome de classe totalmente qualificado. Out é o resultado de uma tentativa de obter um valor de string para uma objeção descoberta que normalmente **contém valores de propriedade para o objeto**.
```
android heap print_instances
```
.png>)
### Keystore/Intents
Você pode brincar com o keystore e intents usando:
```
android keystore list
android intents launch_activity
android intent launch_service
```
#### Despejo
O comando `memory dump` é usado para extrair o conteúdo da memória de um aplicativo Android em execução. Isso pode ser útil para analisar dados sensíveis armazenados na memória, como chaves de criptografia, tokens de autenticação ou informações confidenciais do usuário.
Para realizar um despejo de memória, você pode usar a ferramenta Objection. Primeiro, conecte-se ao dispositivo Android usando o Objection:
```
$ objection -g
```
Depois de se conectar com sucesso, você pode usar o comando `memory dump` para extrair a memória do aplicativo:
```
$ memory dump
```
O despejo de memória será salvo em um arquivo no formato HPROF. Você pode especificar o caminho e o nome do arquivo usando a opção `-o`:
```
$ memory dump -o /caminho/para/arquivo.hprof
```
Depois de concluir o despejo de memória, você pode analisar o arquivo HPROF usando ferramentas como o Android Studio ou o MAT (Memory Analyzer Tool) para identificar possíveis vazamentos de informações ou analisar o conteúdo da memória em busca de dados sensíveis.
É importante lembrar que o despejo de memória pode conter informações confidenciais e deve ser tratado com cuidado. Certifique-se de seguir as práticas recomendadas de segurança e conformidade ao lidar com dados sensíveis.
```bash
memory dump all #Dump all memory
memory dump from_base #Dump a part
```
#### Lista
```
memory list modules
```
.png>)
Na parte inferior da lista, você pode ver o frida:
.png>)
Vamos verificar o que o frida está exportando:
.png>)
#### Pesquisar/Escrever
Você também pode pesquisar e escrever na memória com o objection:
```
memory search "" (--string) (--offsets-only)
memory write "" "" (--string)
```
### SQLite
Vocês podem usar o comando `sqlite` para interagir com bancos de dados SQLite.
### Sair
```
exit
```
## O que falta no Objection
* Os métodos de hooking às vezes travam o aplicativo (isso também é por causa do Frida).
* Você não pode usar as instâncias das classes para chamar funções da instância. E você não pode criar novas instâncias de classes e usá-las para chamar funções.
* Não há um atalho (como o de sslpinnin) para hook todos os métodos de criptografia comuns usados pelo aplicativo para ver texto cifrado, texto simples, chaves, IVs e algoritmos usados.
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100.000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
* Você trabalha em uma **empresa de cibersegurança**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).