rovellipaolo/ninjadroidNinja Reverse Engineering sur les paquets APK Android
NinjaDroid est un outil simple pour l'ingénierie inverse des paquets APK Android.
Publié sur : https://snapcraft.io/ninjadroid```shell $ snap install ninjadroid --channel=beta
[](https://github.com/rovellipaolo/NinjaDroid/actions)
[](https://coveralls.io/github/rovellipaolo/NinjaDroid)
[](https://www.gnu.org/licenses/gpl-3.0)
[](https://snapcraft.io/ninjadroid)
## Aperçu
NinjaDroid utilise [AXMLParser](https://github.com/appknox/pyaxmlparser) conjointement avec une série de scripts Python basés sur `aapt`, `keytool`, `string` et autres pour extraire une série d'informations d'un package APK donné, telles que :
- Liste des fichiers de l'APK : nom du fichier, taille, MD5, SHA-1, SHA-256 et SHA-512
- Informations `AndroidManifest.xml` : nom de l'application, nom du package, version, SDK, permissions, activités, services, broadcast-receivers, ...
- Informations du certificat numérique `CERT.RSA/DSA` : numéro de série, validité, empreinte, émetteur et propriétaire
- Liste d'URLs, de commandes shell et d'autres chaînes de caractères génériques codées en dur dans les fichiers `classes.dex`
De plus, NinjaDroid utilise [apktool](https://github.com/iBotPeaches/Apktool) et [dex2jar](https://github.com/pxb1988/dex2jar) pour extraire et stocker :
- Fichier de rapport JSON, qui contient toutes les informations extraites de l'APK
- Fichier `AndroidManifest.xml` (grâce à `apktool`)
- Fichier de certificat numérique `CERT.RSA/DSA`
- Fichiers `classes.dex`
- Fichier _.jar_ traduit (grâce à `dex2jar`)
- Fichiers smali désassemblés (grâce à `apktool`)
- Dossiers `assets/` et `res/` avec leur contenu (grâce à `apktool`)
## Compilation
La première étape consiste à cloner le dépôt NinjaDroid, ou à télécharger son code source.```shell
$ git clone https://github.com/rovellipaolo/NinjaDroid
$ cd NinjaDroid
NinjaDroid peut être exécuté de plusieurs façons : nativement dans votre environnement local, dans Docker, en tant que Flatpak (expérimental) et en tant que Snap (expérimental).
Pour exécuter NinjaDroid sur votre machine locale, vous devez installer Python 3.5 ou supérieur, Java 8 ou supérieur et binutils.
Optionnellement, si vous avez le SDK Android installé localement, vous pouvez utiliser la version SDK de aapt au lieu de celle incluse. Pour ce faire, vous devez modifier l'emplacement de aapt dans ninjadroid/aapt/Aapt.py (c'est-à-dire __AAPT_EXEC_PATH = "ninjadroid/aapt/aapt").
Lancez simplement les commandes suivantes, qui installeront toutes les dépendances Python (en s'assurant que aapt, apktool et dex2jar ont les permissions d'exécution) et ajouteront un lien symbolique ninjadroid vers /usr/local/bin/.```shell
$ make build-linux
$ make install
$ ninjadroid --help
#### MacOS
Lancez simplement les commandes suivantes, qui installeront toutes les dépendances Python nécessaires (en s'assurant que `aapt`, `apktool` et `dex2jar` ont les permissions d'exécution) et ajouteront un lien symbolique `ninjadroid` vers `/usr/local/bin/`.```shell
$ make build-macos
$ make install
$ ninjadroid --help
Pour exécuter NinjaDroid dans Docker, vous avez besoin que Docker soit installé.
Pour construire l'image Docker, lancez les commandes suivantes :```shell
$ make build-docker
$ docker run --name ninjadroid ninjadroid:latest ninjadroid --help
Notez que vous devez lier le répertoire contenant le package APK cible à l'image Docker :```shell
$ mkdir apks
$ cp /path/to/your/package.apk apks/package.apk
$ docker run --name ninjadroid -it --rm -v $(pwd)/apks:/apks ninjadroid:latest ninjadroid /apks/package.apk -aj
Et il en va de même pour le répertoire de sortie lors de l'utilisation de l'option -e/--extract, auquel vous devez également accorder des permissions :```shell
$ mkdir output
$ chmod 777
$ docker run --name ninjadroid --rm -v $(pwd)/apks:/apks -v $(pwd)/output:/output ninjadroid:latest ninjadroid /apks/package.apk -ae /output
### Flatpak (expérimental)
Pour exécuter NinjaDroid en tant que Flatpak, vous devez avoir `Flatpak` et `flatpak-builder` installés.
Lancez simplement les commandes suivantes, qui installeront toutes les dépendances Flatpak nécessaires :```shell
$ make build-flatpak
$ flatpak-builder --run flatpak/build flatpak/com.github.rovellipaolo.NinjaDroid.yaml ninjadroid --help
NOTE : L'option -e/--extract ne fonctionne pas correctement actuellement (voir : https://github.com/rovellipaolo/NinjaDroid/issues/21).
Pour exécuter NinjaDroid en tant que Snap, vous avez besoin de Snap et snapcraft installés.
Lancez simplement les commandes suivantes, qui installeront toutes les dépendances Snap nécessaires :```shell
$ make build-snap
$ make install-snap
$ ninjadroid --help
**REMARQUE:** L'option `-e`/`--extract` ne fonctionne pas correctement lorsque le snap est installé sans utiliser l'option `--devmode` (voir: https://github.com/rovellipaolo/NinjaDroid/issues/20).
## Test
Une fois que vous l'avez configuré (voir la section _"Installation"_), vous pouvez également exécuter les tests et checkstyle comme suit.
### Natif
Pour les exécuter sur votre machine locale, lancez les commandes suivantes :```shell
$ make test
$ make regression
$ make checkstyle
Vous pouvez également exécuter les tests avec couverture en lançant la commande suivante :```shell $ make test-coverage
Et/ou configurez checkstyle pour s'exécuter automatiquement à chaque commit git en lançant la commande suivante :```
$ make install-githooks
Pour les exécuter dans Docker, lancez les commandes suivantes :```shell $ make test-docker $ make regression-docker $ make checkstyle-docker
### Flatpak
Pour exécuter les tests de régression dans Flatpak, lancez la commande suivante :```shell
$ make regression-flatpak
Pour exécuter les tests de régression dans Snap, lancez la commande suivante :```shell $ make regression-snap
## Utilisation