rovellipaolo/ninjadroidNinja Reverse Engineering su pacchetti APK Android
NinjaDroid è un semplice strumento per il reverse engineering di pacchetti APK Android.
Pubblicato su: 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)
## Panoramica
NinjaDroid utilizza [AXMLParser](https://github.com/appknox/pyaxmlparser) insieme a una serie di script Python basati su `aapt`, `keytool`, `string` e simili per estrarre una serie di informazioni da un dato pacchetto APK, come ad esempio:
- Elenco dei file dell'APK: nome file, dimensione, MD5, SHA-1, SHA-256 e SHA-512
- Informazioni da `AndroidManifest.xml`: nome app, nome pacchetto, versione, SDK, permessi, attività, servizi, broadcast-receiver, ...
- Informazioni del certificato digitale `CERT.RSA/DSA`: numero di serie, validità, impronta digitale, emittente e proprietario
- Elenco di URL, comandi shell e altre stringhe generiche hard-coded nei file `classes.dex`
Inoltre, NinjaDroid utilizza [apktool](https://github.com/iBotPeaches/Apktool) e [dex2jar](https://github.com/pxb1988/dex2jar) per estrarre e conservare:
- File di report JSON, che contiene tutte le informazioni estratte dall'APK
- File `AndroidManifest.xml` (grazie a `apktool`)
- File del certificato digitale `CERT.RSA/DSA`
- File `classes.dex`
- File _.jar_ tradotto (grazie a `dex2jar`)
- File smali disassemblati (grazie a `apktool`)
- Cartelle `assets/` e `res/` insieme al loro contenuto (grazie a `apktool`)
## Build
Il primo passo è clonare il repository di NinjaDroid, o scaricare il suo codice sorgente.```shell
$ git clone https://github.com/rovellipaolo/NinjaDroid
$ cd NinjaDroid
NinjaDroid può essere eseguito in diversi modi: nativamente nel tuo ambiente locale, in Docker, come Flatpak (sperimentale) e come Snap (sperimentale).
Per eseguire NinjaDroid sulla tua macchina locale, devi installare Python 3.5 o superiore, Java 8 o superiore e binutils.
Opzionalmente, se hai l'Android SDK installato localmente, puoi usare la versione SDK di aapt invece di quella inclusa. Per fare ciò, devi modificare il percorso di aapt in ninjadroid/aapt/Aapt.py (cioè __AAPT_EXEC_PATH = "ninjadroid/aapt/aapt").
Basta lanciare i seguenti comandi, che installeranno tutte le dipendenze Python (assicurandoti che aapt, apktool e dex2jar abbiano i permessi di esecuzione) e aggiungeranno un collegamento simbolico ninjadroid a /usr/local/bin/.```shell
$ make build-linux
$ make install
$ ninjadroid --help
#### MacOS
Basta lanciare i seguenti comandi, che installeranno tutte le dipendenze Python necessarie (assicurandosi che `aapt`, `apktool` e `dex2jar` abbiano i permessi di esecuzione) e aggiungeranno un symlink `ninjadroid` in `/usr/local/bin/`.```shell
$ make build-macos
$ make install
$ ninjadroid --help
Per eseguire NinjaDroid in Docker, è necessario avere Docker installato.
Per creare l'immagine Docker, esegui i seguenti comandi:```shell
$ make build-docker
$ docker run --name ninjadroid ninjadroid:latest ninjadroid --help
Nota che devi montare la directory contenente il pacchetto APK target all'immagine 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
E lo stesso vale anche per la directory di output quando si utilizza l'opzione -e/--extract, alla quale è necessario concedere anche i permessi:```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 (sperimentale)
Per eseguire NinjaDroid come Flatpak, è necessario avere installati `Flatpak` e `flatpak-builder`.
Basta lanciare i seguenti comandi, che installeranno tutte le dipendenze Flatpak necessarie:```shell
$ make build-flatpak
$ flatpak-builder --run flatpak/build flatpak/com.github.rovellipaolo.NinjaDroid.yaml ninjadroid --help
NOTA: L'opzione -e/--extract non funziona correttamente al momento (vedi: https://github.com/rovellipaolo/NinjaDroid/issues/21).
Per eseguire NinjaDroid come Snap, è necessario avere Snap e snapcraft installati. Basta lanciare i seguenti comandi, che installeranno tutte le dipendenze Snap necessarie:```shell
$ make build-snap
$ make install-snap
$ ninjadroid --help
**NOTA:** L'opzione `-e`/`--extract` non funziona correttamente quando lo snap è installato senza usare l'opzione `--devmode` (vedi: https://github.com/rovellipaolo/NinjaDroid/issues/20).
## Test
Una volta configurato (vedi la sezione _"Installazione"_), puoi anche eseguire i test e il checkstyle come segue.
### Nativo
Per eseguirli sulla tua macchina locale, lancia i seguenti comandi:```shell
$ make test
$ make regression
$ make checkstyle
Puoi anche eseguire i test con copertura lanciando il seguente comando:```shell $ make test-coverage
E/o configurare il checkstyle per eseguire automaticamente a ogni commit git lanciando il seguente comando:```
$ make install-githooks
Per eseguirli in Docker, esegui i seguenti comandi:```shell $ make test-docker $ make regression-docker $ make checkstyle-docker
### Flatpak
Per eseguire i test di regressione su Flatpak, esegui il seguente comando:```shell
$ make regression-flatpak
Per eseguire i test di regressione in Snap, esegui il seguente comando:```shell $ make regression-snap
## Utilizzo
Di seguito sono riportati alcuni esempi di esecuzione di NinjaDroid sul pacchetto APK di esempio.