mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-01 00:49:40 +00:00
356 lines
20 KiB
Markdown
356 lines
20 KiB
Markdown
# Tutoriel Objection
|
|
|
|
<details>
|
|
|
|
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
|
|
|
* Travaillez-vous dans une **entreprise de cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
|
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">
|
|
|
|
**Astuce de bug bounty** : **inscrivez-vous** sur **Intigriti**, une plateforme premium de **bug bounty créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
|
|
|
{% embed url="https://go.intigriti.com/hacktricks" %}
|
|
|
|
## **Introduction**
|
|
|
|
[](https://github.com/sensepost/objection)
|
|
|
|
**objection - Exploration mobile en temps d'exécution**
|
|
|
|
`objection` est une boîte à outils d'exploration mobile en temps d'exécution, alimentée par [Frida](https://www.frida.re). Elle a été conçue dans le but d'aider à évaluer les applications mobiles et leur posture de sécurité sans avoir besoin d'un appareil mobile jailbreaké ou rooté.
|
|
|
|
**Note :** Il ne s'agit pas d'une forme de contournement de jailbreak / root. En utilisant `objection`, vous êtes toujours limité par toutes les restrictions imposées par le sandbox applicable auquel vous êtes confronté.
|
|
|
|
### Résumé
|
|
|
|
L'**objectif** d'**objection** est de permettre à l'utilisateur d'appeler les **principales actions offertes par Frida**. **Sinon**, l'utilisateur devra créer un **script unique pour chaque application** qu'il souhaite tester.
|
|
|
|
## Tutoriel
|
|
|
|
Pour ce tutoriel, je vais utiliser l'APK que vous pouvez télécharger ici :
|
|
|
|
{% file src="../../../.gitbook/assets/app-release.zip" %}
|
|
|
|
Ou depuis son [dépôt d'origine](https://github.com/asvid/FridaApp)(téléchargez app-release.apk)
|
|
|
|
### Installation
|
|
```bash
|
|
pip3 install objection
|
|
```
|
|
### Connexion
|
|
|
|
Établissez une **connexion ADB classique** et **démarrez** le serveur **frida** sur l'appareil (et vérifiez que frida fonctionne à la fois sur le client et sur le serveur).
|
|
|
|
Si vous utilisez un **appareil rooté**, il est nécessaire de sélectionner l'application que vous souhaitez tester dans l'option _**--gadget**_. Dans ce cas :
|
|
```bash
|
|
frida-ps -Uai
|
|
objection --gadget asvid.github.io.fridaapp explore
|
|
```
|
|
### Actions de base
|
|
|
|
Toutes les commandes possibles d'Objection ne seront pas répertoriées dans ce tutoriel, seulement celles que j'ai trouvées les plus utiles.
|
|
|
|
#### Environnement
|
|
|
|
Certaines informations intéressantes (comme les mots de passe ou les chemins d'accès) peuvent être trouvées dans l'environnement.
|
|
```bash
|
|
env
|
|
```
|
|
.png>)
|
|
|
|
#### Informations sur Frida
|
|
```bash
|
|
frida
|
|
```
|
|
.png>)
|
|
|
|
#### Téléchargement/Téléversement
|
|
```bash
|
|
file download <remote path> [<local path>]
|
|
file upload <local path> [<remote path>]
|
|
```
|
|
#### Importer le script frida
|
|
|
|
```javascript
|
|
const { spawn } = require('child_process');
|
|
const frida = require('frida');
|
|
|
|
async function main() {
|
|
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);
|
|
}
|
|
|
|
main().catch(console.error);
|
|
```
|
|
|
|
#### Importer le script frida
|
|
|
|
```javascript
|
|
const { spawn } = require('child_process');
|
|
const frida = require('frida');
|
|
|
|
async function main() {
|
|
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('Bonjour, le monde !');
|
|
`);
|
|
await script.load();
|
|
await device.resume(pid);
|
|
}
|
|
|
|
main().catch(console.error);
|
|
```
|
|
```bash
|
|
import <local path frida-script>
|
|
```
|
|
#### SSLPinning
|
|
|
|
Le SSL pinning (épinglage SSL) est une technique utilisée pour renforcer la sécurité des connexions SSL/TLS dans une application mobile. Il consiste à vérifier l'empreinte digitale (ou le certificat) du serveur distant auquel l'application se connecte, afin de s'assurer qu'il s'agit bien du serveur attendu.
|
|
|
|
Dans le contexte du piratage d'applications Android, le SSL pinning peut poser un défi lors de l'analyse de trafic réseau à l'aide d'outils tels que Frida et Objection. Lorsque le SSL pinning est activé, l'application vérifie si le certificat du serveur correspond à celui attendu. Si ce n'est pas le cas, l'application peut refuser la connexion ou afficher un avertissement à l'utilisateur.
|
|
|
|
Pour contourner le SSL pinning lors du piratage d'une application Android, nous pouvons utiliser des techniques telles que l'injection de code avec Frida. En modifiant le comportement de l'application, nous pouvons désactiver ou contourner la vérification du certificat SSL, permettant ainsi d'analyser le trafic réseau à l'aide d'outils tels que Burp Suite ou Wireshark.
|
|
|
|
Il est important de noter que le contournement du SSL pinning est une pratique controversée et peut être considérée comme une violation de la sécurité de l'application. Il est donc essentiel de l'utiliser uniquement à des fins de test de sécurité légitimes et avec l'autorisation appropriée.
|
|
```bash
|
|
android sslpinning disable #Attempts to disable SSL Pinning on Android devices.
|
|
```
|
|
#### Détection de root
|
|
|
|
La détection de root est une technique couramment utilisée pour vérifier si un appareil Android est enraciné (rooté). L'enracinement d'un appareil Android permet à l'utilisateur d'obtenir un accès privilégié et un contrôle total sur le système d'exploitation. Cependant, cela peut également présenter des risques de sécurité, car les applications malveillantes peuvent exploiter les privilèges de root pour accéder à des fonctionnalités sensibles ou effectuer des actions indésirables.
|
|
|
|
Les développeurs d'applications peuvent implémenter des mécanismes de détection de root pour empêcher l'exécution de leur application sur des appareils enracinés. Ces mécanismes peuvent inclure la vérification de la présence de fichiers système spécifiques, la recherche de signatures de superutilisateurs ou l'utilisation d'APIs de détection de root.
|
|
|
|
Lors de l'évaluation de la sécurité d'une application Android, il est important de tester si elle peut être exécutée sur des appareils enracinés. Cela peut être fait en utilisant des outils tels que Objection, qui permettent de contourner les mécanismes de détection de root et de tester la résistance de l'application à ce type d'attaque.
|
|
|
|
Objection est un outil de pentesting mobile qui utilise Frida, un framework d'instrumentation dynamique, pour contourner les mécanismes de sécurité des applications Android. Il permet aux testeurs de sécurité d'interagir avec l'application en temps réel, d'analyser son comportement et de modifier son exécution.
|
|
|
|
Pour contourner la détection de root avec Objection, vous pouvez utiliser la commande `android root disable`. Cela désactive les mécanismes de détection de root de l'application, ce qui permet de l'exécuter sur des appareils enracinés. Cependant, il est important de noter que cela peut également exposer l'application à des risques de sécurité supplémentaires, car elle ne sera plus protégée contre les actions malveillantes potentielles des applications enracinées.
|
|
|
|
Il est recommandé de tester l'application sur des appareils enracinés uniquement dans un environnement contrôlé et sécurisé, tel qu'un environnement de test ou un sandbox. Cela permet de minimiser les risques de sécurité et de s'assurer que l'application fonctionne correctement sur des appareils enracinés sans compromettre la sécurité des utilisateurs finaux.
|
|
```bash
|
|
android root disable #Attempts to disable root detection on Android devices.
|
|
android root simulate #Attempts to simulate a rooted Android environment.
|
|
```
|
|
#### Exécuter une commande
|
|
|
|
The `exec` command in Objection allows you to execute shell commands on the target Android device. This can be useful for performing various actions during a mobile penetration test.
|
|
|
|
To use the `exec` command, you need to have a Frida session established with the target application. Once you have a session, you can run shell commands by using the following syntax:
|
|
|
|
```
|
|
objection> exec <command>
|
|
```
|
|
|
|
Replace `<command>` with the shell command you want to execute. For example, if you want to list the files in the current directory, you can use the `ls` command:
|
|
|
|
```
|
|
objection> exec ls
|
|
```
|
|
|
|
The output of the command will be displayed in the Objection console. You can also redirect the output to a file by using the `>` operator. For example, to save the output of the `ls` command to a file named `files.txt`, you can use the following command:
|
|
|
|
```
|
|
objection> exec ls > files.txt
|
|
```
|
|
|
|
Keep in mind that the `exec` command runs the shell command on the target device, so be cautious when executing commands that may have unintended consequences.
|
|
```bash
|
|
android shell_exec whoami
|
|
```
|
|
#### Captures d'écran
|
|
```bash
|
|
android ui screenshot /tmp/screenshot
|
|
android ui FLAG_SECURE false #This may enable you to take screenshots using the hardware keys
|
|
```
|
|
### Analyse statique rendue dynamique
|
|
|
|
Dans une application réelle, nous devrions connaître toutes les informations découvertes dans cette partie avant d'utiliser objection grâce à l'**analyse statique**. Quoi qu'il en soit, de cette manière, vous pouvez peut-être voir **quelque chose de nouveau**, car vous aurez uniquement une liste complète des classes, des méthodes et des objets exportés.
|
|
|
|
Cela est également utile si, d'une manière ou d'une autre, vous êtes **incapable d'obtenir du code source lisible** de l'application.
|
|
|
|
#### Liste des activités, des récepteurs et des services
|
|
```
|
|
android hooking list activities
|
|
```
|
|
.png>)
|
|
```
|
|
android hooking list services
|
|
android hooking list receivers
|
|
```
|
|
Frida affichera une erreur si aucune activité n'est trouvée.
|
|
|
|
#### Obtenir l'activité en cours
|
|
```
|
|
android hooking get current_activity
|
|
```
|
|
#### Recherche de classes
|
|
|
|
Commençons par rechercher les classes dans notre application.
|
|
```
|
|
android hooking search classes asvid.github.io.fridaapp
|
|
```
|
|
.png>)
|
|
|
|
#### Recherche des méthodes d'une classe
|
|
|
|
Maintenant, extrayons les méthodes à l'intérieur de la classe _MainActivity:_
|
|
```
|
|
android hooking search methods asvid.github.io.fridaapp MainActivity
|
|
```
|
|
 (1).png>)
|
|
|
|
#### Liste des méthodes déclarées d'une classe avec leurs paramètres
|
|
|
|
Voyons quels paramètres les méthodes de la classe nécessitent :
|
|
```
|
|
android hooking list class_methods asvid.github.io.fridaapp.MainActivity
|
|
```
|
|
.png>)
|
|
|
|
#### Liste des classes
|
|
|
|
Vous pouvez également répertorier toutes les classes qui ont été chargées dans l'application actuelle :
|
|
```
|
|
android hooking list classes #List all loaded classes, As the target application gets usedmore, this command will return more classes.
|
|
```
|
|
Ceci est très utile si vous souhaitez **accrocher la méthode d'une classe et que vous ne connaissez que le nom de la classe**. Vous pouvez utiliser cette fonction pour **rechercher le module qui possède la classe** puis accrocher sa méthode.
|
|
|
|
### Accrocher étant facile
|
|
|
|
#### Accrocher (surveiller) une méthode
|
|
|
|
À partir du [code source](https://github.com/asvid/FridaApp/blob/master/app/src/main/java/asvid/github/io/fridaapp/MainActivity.kt) de l'application, nous savons que la **fonction** _**sum()**_ **de** _**MainActivity**_ est exécutée **toutes les secondes**. Essayons de **dumper toutes les informations possibles** à chaque fois que la fonction est appelée (arguments, valeur de retour et backtrace) :
|
|
```
|
|
android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --dump-args --dump-backtrace --dump-return
|
|
```
|
|
.png>)
|
|
|
|
#### Accrocher (surveiller) une classe entière
|
|
|
|
En fait, je trouve tous les méthodes de la classe MainActivity vraiment intéressantes, accrochons-les toutes. Soyez prudent, cela pourrait provoquer un **plantage** de l'application.
|
|
```
|
|
android hooking watch class asvid.github.io.fridaapp.MainActivity --dump-args --dump-return
|
|
```
|
|
Si vous jouez avec l'application pendant que la classe est accrochée, vous verrez quand **chaque fonction est appelée**, ses **arguments** et la valeur de **retour**.
|
|
|
|
.png>)
|
|
|
|
#### Changer la valeur de retour booléenne d'une fonction
|
|
|
|
À partir du code source, vous pouvez voir que la fonction _checkPin_ reçoit une _String_ en argument et renvoie un _boolean_. Faisons en sorte que la fonction **renvoie toujours true** :
|
|
|
|
.png>)
|
|
|
|
Maintenant, si vous écrivez quelque chose dans la zone de texte pour le code PIN, vous verrez que tout est valide :
|
|
|
|
.png>)
|
|
|
|
### Instances de classe
|
|
|
|
Recherchez et affichez les **instances en direct d'une classe Java spécifique**, spécifiée par un nom de classe entièrement qualifié. Out est le résultat d'une tentative d'obtenir une valeur de chaîne pour une objection découverte qui contiendrait généralement **les valeurs des propriétés de l'objet**.
|
|
```
|
|
android heap print_instances <class>
|
|
```
|
|
.png>)
|
|
|
|
### Keystore/Intents
|
|
|
|
Vous pouvez jouer avec le keystore et les intents en utilisant:
|
|
```
|
|
android keystore list
|
|
android intents launch_activity
|
|
android intent launch_service
|
|
```
|
|
#### Dump
|
|
|
|
La fonction `dump` de Frida permet de créer une copie de la mémoire d'une application Android. Cela peut être utile pour analyser le contenu de la mémoire, y compris les variables, les objets et les données sensibles.
|
|
|
|
Pour utiliser la fonction `dump`, vous devez d'abord vous connecter à l'application cible à l'aide de Frida. Une fois connecté, vous pouvez exécuter la commande `dump()` pour créer une copie de la mémoire.
|
|
|
|
Voici un exemple d'utilisation de la fonction `dump` :
|
|
|
|
```javascript
|
|
Java.perform(function () {
|
|
var targetClass = Java.use('com.example.app.MainActivity');
|
|
var targetInstance = targetClass.$new();
|
|
|
|
// Appeler la fonction dump pour créer une copie de la mémoire
|
|
targetInstance.dump();
|
|
});
|
|
```
|
|
|
|
Lorsque vous exécutez cette commande, Frida créera un fichier de dump contenant la mémoire de l'application. Vous pouvez ensuite analyser ce fichier pour rechercher des informations sensibles ou des vulnérabilités potentielles.
|
|
|
|
Il est important de noter que l'utilisation de la fonction `dump` peut être considérée comme intrusive et peut violer la vie privée de l'utilisateur de l'application. Par conséquent, il est essentiel de respecter les lois et les réglementations en vigueur lors de l'utilisation de cette fonctionnalité.
|
|
```bash
|
|
memory dump all <local destination> #Dump all memory
|
|
memory dump from_base <base_address> <size_to_dump> <local_destination> #Dump a part
|
|
```
|
|
#### Liste
|
|
```
|
|
memory list modules
|
|
```
|
|
.png>)
|
|
|
|
En bas de la liste, vous pouvez voir frida :
|
|
|
|
.png>)
|
|
|
|
Voyons ce que frida exporte :
|
|
|
|
.png>)
|
|
|
|
#### Recherche/Écriture
|
|
|
|
Vous pouvez également rechercher et écrire dans la mémoire avec objection :
|
|
```
|
|
memory search "<pattern eg: 41 41 41 ?? 41>" (--string) (--offsets-only)
|
|
memory write "<address>" "<pattern eg: 41 41 41 41>" (--string)
|
|
```
|
|
### SQLite
|
|
|
|
Vous pouvez utiliser la commande `sqlite` pour interagir avec les bases de données SQLite.
|
|
|
|
### Sortie
|
|
```
|
|
exit
|
|
```
|
|
## Ce qui manque dans Objection
|
|
|
|
* Les méthodes de hooking font parfois planter l'application (cela est également dû à Frida).
|
|
* Vous ne pouvez pas utiliser les instances des classes pour appeler les fonctions de l'instance. Et vous ne pouvez pas créer de nouvelles instances de classes et les utiliser pour appeler des fonctions.
|
|
* Il n'y a pas de raccourci (comme celui pour sslpinnin) pour hooker toutes les méthodes de chiffrement couramment utilisées par l'application afin de voir le texte chiffré, le texte en clair, les clés, les IV et les algorithmes utilisés.
|
|
|
|
<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">
|
|
|
|
**Astuce pour les chasseurs de bugs** : **inscrivez-vous** sur **Intigriti**, une plateforme premium de **chasse aux bugs créée par des hackers, pour des hackers** ! Rejoignez-nous sur [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) dès aujourd'hui et commencez à gagner des primes allant jusqu'à **100 000 $** !
|
|
|
|
{% embed url="https://go.intigriti.com/hacktricks" %}
|
|
|
|
<details>
|
|
|
|
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
|
|
|
* Vous travaillez dans une **entreprise de cybersécurité** ? Vous souhaitez voir votre **entreprise annoncée dans HackTricks** ? ou souhaitez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
|
|
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Partagez vos astuces de piratage en soumettant des PR au** [**repo hacktricks**](https://github.com/carlospolop/hacktricks) **et au** [**repo hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|