claudiugeorgiu/obfuscapkUn outil d'obfuscation automatique pour applications Android fonctionnant en mode boîte noire, prenant en charge des fonctionnalités d'obfuscation avancées et doté d'une architecture modulaire facilement extensible avec de nouvelles techniques
[!IMPORTANT] Ce projet est archivé et n'est plus maintenu.
Certaines des questions les plus courantes trouvent leurs réponses dans FAQ et dépannage.
Un outil d'obfuscation boîte noire pour les applications Android.
Obfuscapk est un outil Python modulaire pour obfusquer des applications Android sans avoir besoin de leur code source, car apktool est utilisé pour décompiler le fichier apk original et construire une nouvelle application, après avoir appliqué certaines techniques d'obfuscation sur le code smali décompilé, les ressources et le manifeste. L'application obfusquée conserve les mêmes fonctionnalités que l'originale, mais les différences sous le capot rendent parfois la nouvelle application très différente de l'originale (par exemple, pour les logiciels antivirus basés sur les signatures).
Obfuscapk ajoute la prise en charge des Android App Bundles (fichiers aab) en utilisant BundleDecompiler (voir #121). Pour utiliser cette nouvelle fonctionnalité, téléchargez la dernière version de BundleDecompiler disponible ici, enregistrez-la sous BundleDecompiler.jar dans un répertoire inclus dans PATH (par exemple, sous Ubuntu, /usr/local/bin ou /usr/bin) et assurez-vous que le drapeau exécutable est défini.
[!IMPORTANT] BundleDecompiler ne fonctionne pas encore sous Windows, donc l'obfuscation des App Bundles n'est pas prise en charge par Obfuscapk sur la plateforme Windows. De plus, la prise en charge des App Bundles est encore en développement précoce, donc si vous rencontrez des problèmes ou si vous souhaitez nous aider à améliorer, veuillez consulter contribuer.
Plus de détails sur Obfuscapk peuvent être trouvés dans l'article "Obfuscapk: An open-source black-box obfuscation tool for Android apps". Vous pouvez citer l'article comme suit :```BibTeX @article{aonzo2020obfuscapk, title = "Obfuscapk: An open-source black-box obfuscation tool for Android apps", journal = "SoftwareX", volume = "11", pages = "100403", year = "2020", issn = "2352-7110", doi = "https://doi.org/10.1016/j.softx.2020.100403", url = "https://www.sciencedirect.com/science/article/pii/S2352711019302791", author = "Simone Aonzo and Gabriel Claudiu Georgiu and Luca Verderame and Alessio Merlo", keywords = "Android, Obfuscation, Program analysis" }
## ❱ Démo
## ❱ Architecture
Obfuscapk est conçu pour être modulaire et facile à étendre, il est donc construit en utilisant un
[système de plugins](https://github.com/tibonihoo/yapsy). Par conséquent, chaque obfuscateur est
un plugin qui hérite d'une
[classe de base](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/obfuscator_category.py)
abstraite et doit implémenter la méthode `obfuscate`. Lorsque l'outil commence à traiter un nouveau
fichier d'application Android, il crée un
[objet d'obfuscation](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/obfuscation.py)
pour stocker toutes les informations nécessaires (par exemple, l'emplacement du code `smali` décompilé)
et l'état interne des opérations (par exemple, la liste des obfuscateurs déjà utilisés).
Ensuite, l'objet d'obfuscation est passé, en tant que paramètre à la méthode `obfuscate`, à tous
les plugins/obfuscateurs actifs (en séquence) pour être traités et modifiés. La liste et
l'ordre des plugins actifs sont spécifiés via les [options de ligne de commande](#-usage).
L'outil est facilement extensible avec de nouveaux obfuscateurs : il suffit d'ajouter le code source
implémentant la technique d'obfuscation et les métadonnées du plugin (un
fichier `<obfuscator-name>.obfuscator`) dans le répertoire
[`src/obfuscapk/obfuscators`](https://github.com/ClaudiuGeorgiu/Obfuscapk/tree/master/src/obfuscapk/obfuscators)
(prenez un obfuscateur existant simple comme
[`Nop`](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/obfuscators/nop/nop.py)
comme exemple de départ). L'outil détectera automatiquement le nouveau plugin, donc aucune
configuration supplémentaire n'est nécessaire (le nouveau plugin sera traité comme tous les autres
plugins fournis avec l'outil).
## ❱ Installation
Il existe deux façons d'obtenir une copie fonctionnelle d'Obfuscapk sur votre propre ordinateur : soit
en [utilisant Docker](#docker-image), soit en [utilisant directement le code source](#from-source)
dans un environnement `Python 3`. Dans les deux cas, la première chose à faire est d'obtenir une copie
locale de ce dépôt, alors ouvrez un terminal dans le répertoire où vous souhaitez enregistrer
le projet et clonez le dépôt :```Shell
$ git clone https://github.com/ClaudiuGeorgiu/Obfuscapk.git
C'est la méthode recommandée pour installer Obfuscapk, car la seule condition est d'avoir une version récente de Docker installée :```Shell $ docker --version Docker version 20.10.21, build baeda1f
#### Image officielle Docker Hub
L'[image officielle Docker Obfuscapk](https://hub.docker.com/r/claudiugeorgiu/obfuscapk) est disponible sur Docker Hub (construite automatiquement à partir de ce dépôt) :```Shell
$ # Download the Docker image.
$ docker pull claudiugeorgiu/obfuscapk
$ # Give it a shorter name.
$ docker tag claudiugeorgiu/obfuscapk obfuscapk
Si vous avez téléchargé l'image officielle depuis Docker Hub, vous êtes prêt à utiliser l'outil, alors
consultez les instructions d'utilisation, sinon exécutez la commande
suivante dans le répertoire précédemment créé Obfuscapk/src/ (le dossier contenant le
Dockerfile) pour construire l'image Docker :```Shell
$ # Make sure to run the command in Obfuscapk/src/ directory.
$ # It will take some time to download and install all the dependencies.
$ docker build -t obfuscapk .
Lorsque l'image Docker est prête, effectuez un test rapide pour vérifier que tout a été installé correctement :```Shell
$ docker run --rm -it obfuscapk --help
usage: python3 -m obfuscapk.cli [-h] -o OBFUSCATOR [-w DIR] [-d OUT_APK_OR_AAB]
...
Obfuscapk est maintenant prêt à être utilisé, voir les instructions d'utilisation pour plus d'informations.
Assurez-vous d'avoir une version récente de
apktool,
apksigner
et zipalign installée
et disponible depuis la ligne de commande :```Shell
$ apktool
Apktool v2.9.0 - a tool for reengineering Android apk files
...
```Shell
$ apksigner
Usage: apksigner <command> [options]
apksigner --version
apksigner --help
...
$ zipalign
Zip alignment utility
Copyright (C) 2009 The Android Open Source Project
...
Pour prendre en charge l'obfuscation des app bundles, vous avez également besoin de BundleDecompiler, alors téléchargez la dernière version disponible depuis ici, enregistrez-la sous BundleDecompiler.jar dans un répertoire inclus dans PATH (par exemple, sous Ubuntu, /usr/local/bin ou /usr/bin) et assurez-vous que le bit exécutable est défini.
Pour utiliser BundleDecompiler et apktool, vous avez également besoin d'une version récente de Java.
zipalign et apksigner sont inclus dans le SDK Android. L'emplacement des exécutables peut également être spécifié via les variables d'environnement suivantes :
APKTOOL_PATH, BUNDLE_DECOMPILER_PATH, APKSIGNER_PATH et ZIPALIGN_PATH (par exemple,
sous Ubuntu, exécutez export APKTOOL_PATH=/custom/location/apktool avant d'exécuter Obfuscapk
dans le même terminal).
En dehors des outils ci-dessus, la seule exigence de ce projet est une installation fonctionnelle de Python 3 (au moins 3.7) (accompagnée de son gestionnaire de paquets pip).
Exécutez les commandes suivantes dans le répertoire principal du projet (Obfuscapk/) pour installer les dépendances nécessaires :```Shell
$ # Make sure to run the commands in Obfuscapk/ directory.
$ # The usage of a virtual environment is highly recommended. $ python3 -m venv venv $ source venv/bin/activate
$ # Install Obfuscapk's requirements. $ python3 -m pip install -r src/requirements.txt
Une fois les dépendances installées, effectuez un test rapide pour vérifier que tout fonctionne correctement :```Shell
$ cd src/
$ # The following command has to be executed always from Obfuscapk/src/ directory
$ # or by adding Obfuscapk/src/ directory to PYTHONPATH environment variable.
$ python3 -m obfuscapk.cli --help
usage: python3 -m obfuscapk.cli [-h] -o OBFUSCATOR [-w DIR] [-d OUT_APK_OR_AAB]
...
Obfuscapk est maintenant prêt à être utilisé, consultez les instructions d'utilisation pour plus d'informations.
À partir de maintenant, Obfuscapk sera considéré comme un exécutable disponible sous le nom obfuscapk, vous devez donc adapter les commandes selon la façon dont vous avez installé l'outil :
Image Docker : un répertoire local contenant l'application à obscurcir doit être monté dans /workdir dans le conteneur (par exemple, le répertoire courant "${PWD}"), donc la commande :
$ obfuscapk [params...]
devient :
$ docker run --rm -it -u $(id -u):$(id -g) -v "${PWD}":"/workdir" obfuscapk [params...]
Depuis les sources : chaque instruction doit être exécutée depuis le répertoire Obfuscapk/src/ (ou en ajoutant le répertoire Obfuscapk/src/ à la variable d'environnement PYTHONPATH) et la commande :
$ obfuscapk [params...]
devient :
$ python3 -m obfuscapk.cli [params...]
Commençons par consulter le message d'aide :```Shell $ obfuscapk --help obfuscapk [-h] -o OBFUSCATOR [-w DIR] [-d OUT_APK_OR_AAB] [-i] [-p] [-k VT_API_KEY] [--keystore-file KEYSTORE_FILE] [--keystore-password KEYSTORE_PASSWORD] [--key-alias KEY_ALIAS] [--key-password KEY_PASSWORD] [--use-aapt2] <APK_OR_BUNDLE_FILE>
Il y a deux paramètres obligatoires : `<APK_OR_BUNDLE_FILE>`, le chemin (relatif ou absolu) vers le fichier apk ou app bundle à obscurcir, et la liste des noms des techniques d'obscurcissement à appliquer (spécifiée avec une option `-o` pouvant être utilisée plusieurs fois, par exemple, `-o Rebuild -o NewAlignment -o NewSignature`). Les autres arguments optionnels sont les suivants :
* `-w DIR` est utilisé pour définir le répertoire de travail où enregistrer les fichiers intermédiaires (générés par `apktool`). S'il n'est pas spécifié, un répertoire nommé `obfuscation_working_dir` est créé dans le même répertoire que l'application d'entrée. Cela peut être utile à des fins de débogage, mais si ce n'est pas nécessaire, il peut être défini sur un répertoire temporaire (par exemple, `-w /tmp/`).
* `-d OUT_APK_OR_AAB` est utilisé pour définir le chemin du fichier de destination : le fichier apk généré par le processus d'obscurcissement (par exemple, `-d /home/user/Desktop/obfuscated.apk` ou `-d /home/user/Desktop/obfuscated.aab`). S'il n'est pas spécifié, le fichier obscurci final sera enregistré dans le répertoire de travail. Remarque : les fichiers existants seront écrasés sans aucun avertissement.
* `-i` est un indicateur pour ignorer les bibliothèques tierces connues pendant le processus d'obscurcissement, afin d'utiliser moins de ressources, d'augmenter les performances et de réduire le risque d'erreurs. La
[liste des bibliothèques](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/resources/libs_to_ignore.txt)
à ignorer est adaptée du projet [LiteRadar](https://github.com/pkumza/LiteRadar).
* `-p` est un indicateur pour afficher les barres de progression pendant les opérations d'obscurcissement. Lors de l'utilisation de l'outil dans des opérations par lots/constructions automatiques, il est pratique d'avoir les barres de progression désactivées, sinon cet indicateur doit être activé pour voir la progression de l'obscurcissement.
* `-k VT_API_KEY` n'est nécessaire que lors de l'utilisation de l'obscurcisseur `VirusTotal`, pour définir la clé API à utiliser lors de la communication avec Virus Total.
* `--keystore-file KEYSTORE_FILE`, `--keystore-password KEYSTORE_PASSWORD`,
`--key-alias KEY_ALIAS` et `--key-password KEY_PASSWORD` peuvent être utilisés pour spécifier un keystore personnalisé (nécessaire pour la signature de l'apk). Si `--keystore-file` est utilisé, `--keystore-password` et `--key-alias` doivent également être spécifiés, tandis que `--key-password` n'est nécessaire que si la clé choisie a un mot de passe différent de celui du keystore. Par défaut (lorsque `--keystore-file` n'est pas spécifié), un
[keystore inclus avec Obfuscapk](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/resources/obfuscation_keystore.jks)
est utilisé pour les opérations de signature.
* `--ignore-packages-file IGNORE_PACKAGES_FILE` est un chemin vers un fichier qui contient les noms de paquets à ignorer. Toutes les classes à l'intérieur de ces paquets ne seront pas obscurcies lorsque cette option est utilisée. Le fichier doit avoir un nom de paquet par ligne comme indiqué dans l'exemple ci-dessous :
```
com.mycompany.dontobfuscate
com.mycompany.ignore
...
```
* `--use-aapt2` est un indicateur pour utiliser l'option aapt2 lors de la reconstruction d'une application avec `apktool`.
Considérons maintenant un exemple de travail simple pour voir comment Obfuscapk fonctionne :```Shell
$ # original.apk is a valid Android apk file.
$ obfuscapk -o RandomManifest -o Rebuild -o NewAlignment -o NewSignature original.apk
Lors de l'exécution de la commande ci-dessus, voici ce qui se passe en arrière-plan :
comme aucun répertoire de travail n'a été spécifié, un nouveau répertoire de travail
(obfuscation_working_dir) est créé au même emplacement que original.apk (cela peut
être utile pour inspecter les fichiers smali/manifeste/ressources en cas d'erreur)
certaines vérifications sont effectuées pour s'assurer que tous les fichiers/exécutables nécessaires sont disponibles et prêts à être utilisés
le processus d'obfuscation proprement dit commence : les obfuscateurs spécifiés sont exécutés (dans l'ordre) un par un jusqu'à ce qu'il n'y ait plus d'obfuscateur ou jusqu'à ce qu'une erreur soit rencontrée
lors de l'exécution du premier obfuscateur, original.apk est décompilé avec
apktool et les résultats sont stockés dans le répertoire de travail
comme le premier obfuscateur est RandomManifest, les entrées du manifeste
Android décompilé sont réorganisées aléatoirement (sans casser les structures xml)
L'obfuscateur Rebuild reconstruit simplement l'application (maintenant avec le
manifeste modifié) en utilisant apktool, et comme aucun fichier de sortie n'a été
spécifié, le fichier apk résultant est sauvegardé dans le répertoire de travail créé
précédemment
Comme vu dans l'exemple précédent, les obfuscateurs Rebuild, NewAlignment et
NewSignature sont toujours nécessaires pour terminer une opération d'obfuscation, afin
de construire l'apk obfusqué final. Ce ne sont pas de véritables techniques d'obfuscation,
mais ils sont nécessaires dans le processus de construction, donc ils sont inclus dans la
liste des obfuscateurs pour garder l'architecture globale modulaire.
Pas de résultat attendu ? Voir la FAQ et le dépannage.
Les obfuscateurs inclus dans Obfuscapk peuvent être divisés en différentes catégories, selon les opérations qu'ils effectuent :
Trivial : comme son nom l'indique, cette catégorie inclut des opérations simples (qui ne modifient pas beaucoup l'application originale), comme signer le fichier apk avec une nouvelle signature.
Renommage : opérations qui changent les noms des identifiants utilisés (classes, champs, méthodes).
Chiffrement : empaquetage de code/ressources chiffrés et déchiffrement lors de l'exécution de l'application. Lorsque Obfuscapk démarre, il génère automatiquement une clé secrète aléatoire (32 caractères, utilisant lettres et chiffres ASCII) qui sera utilisée pour le chiffrement.
Code : toutes les opérations qui impliquent la modification du code source décompilé.
Ressources : opérations sur les fichiers de ressources (comme la modification du manifeste).
Autre
Les obfuscateurs actuellement fournis avec Obfuscapk sont brièvement présentés ci-dessous (par ordre alphabétique). Veuillez vous référer au code source du projet pour plus de détails.
[!TIP] Tous les obfuscateurs ci-dessous ne correspondent pas à de véritables techniques d'obfuscation (par ex.,
Rebuild,NewAlignment,NewSignatureetVirusTotal), mais ils sont implémentés comme obfuscateurs pour garder l'architecture modulaire et facile à étendre avec de nouvelles fonctionnalités.
Utilise la réflexion pour invoquer des API dangereuses du framework Android. Pour déterminer si une méthode appartient au framework Android, Obfuscapk se réfère au mapping découvert par Backes et al.
📄 Code source d'AdvancedReflection
Insère du code indésirable. Dans ce cas, le code indésirable est composé de calculs arithmétiques et d'une instruction de branchement dépendant du résultat de ces calculs, conçus de sorte que la branche ne soit jamais prise.
📄 Code source d'ArithmeticBranch
Chiffre les fichiers d'actifs.
📄 Code source d'AssetEncryption
Cette technique modifie le graphe de flot de contrôle sans impacter la sémantique du code : elle ajoute de nouvelles méthodes qui invoquent les originales. Par exemple, une invocation de la méthode m1 sera substituée par une nouvelle méthode wrapper m2, qui, lorsqu'elle est invoquée, appelle la méthode originale m1.
📄 Code source de CallIndirection
Change le nom du package et renomme les classes (même dans le fichier manifeste).
📄 Code source de ClassRename
Chiffre les chaînes constantes dans le code.
📄 Code source de ConstStringEncryption
Supprime les informations de débogage.
📄 Code source de DebugRemoval
Renomme les champs.
📄 Code source de FieldRename
Étant donné une méthode, elle insère une instruction
gotopointant vers la fin de la méthode et une autregotopointant vers l'instruction après la premièregoto; elle modifie le graphe de flot de contrôle en ajoutant deux nouveaux nœuds.
📄 Code source de Goto
Chiffre les bibliothèques natives.
📄 Code source de LibEncryption
Elle exploite la fonctionnalité de surcharge du langage Java pour assigner le même nom à différentes méthodes mais avec des arguments différents. Étant donné une méthode déjà existante, cette technique crée une nouvelle méthode vide avec le même nom et les mêmes arguments, mais ajoute également de nouveaux arguments aléatoires. Ensuite, le corps de la nouvelle méthode est rempli d'instructions arithmétiques aléatoires.
📄 Code source de MethodOverload
Renomme les méthodes.
📄 Code source de MethodRename
Realigne l'application.
📄 Code source de NewAlignment
Re-signe l'application avec une nouvelle signature personnalisée.
📄 Code source de NewSignature
Insère du code indésirable. Nop, abréviation de no-operation, est une instruction dédiée qui ne fait rien. Cette technique insère simplement des instructions
nopaléatoires dans chaque implémentation de méthode.
📄 Code source de Nop
Réorganise aléatoirement les entrées dans le fichier manifeste.
📄 Code source de RandomManifest
Reconstruit l'application.
📄 Code source de Rebuild
Cette technique analyse le code existant à la recherche d'invocations de méthodes de l'application, ignorant les appels au framework Android (voir
AdvancedReflection). Si elle trouve une instruction avec une invocation de méthode appropriée (c'est-à-dire pas de constructeurs, visibilité publique, suffisamment de registres libres, etc.), cette invocation est redirigée vers une méthode personnalisée qui invoquera la méthode originale en utilisant les API de réflexion.
📄 Code source de Reflection
Cette technique consiste à changer l'ordre des blocs de base dans le code. Lorsqu'une instruction de branchement est trouvée, la condition est inversée (par exemple, branche si inférieur à devient branche si supérieur ou égal à) et les blocs de base cibles sont réorganisés en conséquence. De plus, elle réorganise aléatoirement le code en abusant des instructions
goto.
📄 Code source de Reorder
Chiffre les chaînes dans les ressources (uniquement celles appelées dans le code).
📄 Code source de ResStringEncryption
Envoie l'application originale et obfusquée à Virus Total. Vous devez fournir la clé API VT (voir l'option
-k).
📄 Code source de VirusTotal
Vous êtes libre d'utiliser ce code sous la licence MIT.
Ce logiciel a été développé à des fins de recherche au Computer Security Lab (CSecLab), hébergé au DIBRIS, Université de Gênes.
L'obfuscateur NewAlignment utilise l'outil zipalign pour aligner le fichier
apk résultant
L'obfuscateur NewSignature signe le fichier apk nouvellement créé avec un
certificat personnalisé contenu dans un
keystore fourni avec Obfuscapk
(bien qu'un keystore différent puisse être spécifié avec le paramètre --keystore-file)
lorsque tous les obfuscateurs ont été exécutés sans erreur, le fichier apk obfusqué
résultant peut être trouvé dans obfuscation_working_dir/original_obfuscated.apk, signé,
aligné et prêt à être installé sur un appareil/émulateur