rovellipaolo/ninjadroidIngeniería inversa ninja en paquetes APK de Android
NinjaDroid es una herramienta simple para la ingeniería inversa de paquetes APK de Android.
Publicado en: 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)
## Resumen
NinjaDroid utiliza [AXMLParser](https://github.com/appknox/pyaxmlparser) junto con una serie de scripts de Python basados en `aapt`, `keytool`, `string` y similares para extraer una serie de información de un paquete APK dado, como:
- Lista de archivos del APK: nombre del archivo, tamaño, MD5, SHA-1, SHA-256 y SHA-512
- Información de `AndroidManifest.xml`: nombre de la app, nombre del paquete, versión, sdks, permisos, actividades, servicios, broadcast-receivers, ...
- Información del certificado digital `CERT.RSA/DSA`: número de serie, validez, huella digital, emisor y propietario
- Lista de URLs, comandos de shell y otras cadenas genéricas codificadas en los archivos `classes.dex`
Además, NinjaDroid utiliza [apktool](https://github.com/iBotPeaches/Apktool) y [dex2jar](https://github.com/pxb1988/dex2jar) para extraer y almacenar:
- Archivo de informe JSON, que contiene toda la información extraída del APK
- Archivo `AndroidManifest.xml` (gracias a `apktool`)
- Archivo de certificado digital `CERT.RSA/DSA`
- Archivos `classes.dex`
- Archivo _.jar_ traducido (gracias a `dex2jar`)
- Archivos smali desensamblados (gracias a `apktool`)
- Carpetas `assets/` y `res/` junto con su contenido (gracias a `apktool`)
## Construcción
El primer paso es clonar el repositorio de NinjaDroid, o descargar su código fuente.```shell
$ git clone https://github.com/rovellipaolo/NinjaDroid
$ cd NinjaDroid
NinjaDroid tiene varias formas de ejecutarse: de forma nativa en su entorno local, en Docker, como Flatpak (experimental) y como Snap (experimental).
Para ejecutar NinjaDroid en su máquina local, necesita instalar Python 3.5 o superior, Java 8 o superior y binutils.
Opcionalmente, si tiene el SDK de Android instalado localmente, puede usar la versión del SDK de aapt en lugar de la incluida. Para hacerlo, necesita cambiar la ubicación de aapt en ninjadroid/aapt/Aapt.py (es decir, __AAPT_EXEC_PATH = "ninjadroid/aapt/aapt").
Simplemente ejecute los siguientes comandos, que instalarán todas las dependencias de Python (asegurándose de que aapt, apktool y dex2jar tengan permisos de ejecución) y agregarán un enlace simbólico ninjadroid a /usr/local/bin/.```shell
$ make build-linux
$ make install
$ ninjadroid --help
#### MacOS
Simplemente ejecute los siguientes comandos, que instalarán todas las dependencias de Python necesarias (asegurándose de que `aapt`, `apktool` y `dex2jar` tengan permisos de ejecución) y agregarán un enlace simbólico `ninjadroid` a `/usr/local/bin/`.```shell
$ make build-macos
$ make install
$ ninjadroid --help
Para ejecutar NinjaDroid en Docker, necesitas tener Docker instalado.
Para construir la imagen Docker, ejecuta los siguientes comandos:```shell
$ make build-docker
$ docker run --name ninjadroid ninjadroid:latest ninjadroid --help
Ten en cuenta que debes vincular el directorio que contiene el paquete APK de destino a la imagen de 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
Y lo mismo se aplica también al directorio de salida cuando se utiliza la opción -e/--extract, al que también debe otorgar permisos:```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 (experimental)
Para ejecutar NinjaDroid como Flatpak, necesitas tener instalados `Flatpak` y `flatpak-builder`.
Simplemente ejecuta los siguientes comandos, que instalarán todas las dependencias Flatpak necesarias:```shell
$ make build-flatpak
$ flatpak-builder --run flatpak/build flatpak/com.github.rovellipaolo.NinjaDroid.yaml ninjadroid --help
NOTA: La opción -e/--extract no funciona correctamente actualmente (ver: https://github.com/rovellipaolo/NinjaDroid/issues/21).
Para ejecutar NinjaDroid como un Snap, necesitas Snap y snapcraft instalados.
Simplemente ejecuta los siguientes comandos, los cuales instalarán todas las dependencias Snap necesarias:```shell
$ make build-snap
$ make install-snap
$ ninjadroid --help
**NOTA:** La opción `-e`/`--extract` no funciona correctamente cuando el snap está instalado sin usar la opción `--devmode` (consulte: https://github.com/rovellipaolo/NinjaDroid/issues/20).
## Prueba
Una vez que lo hayas configurado (consulta la sección _"Instalación"_), también puedes ejecutar las pruebas y la verificación de estilo de la siguiente manera.
### Nativo
Para ejecutarlas en tu máquina local, lanza los siguientes comandos:```shell
$ make test
$ make regression
$ make checkstyle
También puedes ejecutar las pruebas con cobertura lanzando el siguiente comando:```shell $ make test-coverage
Y/o configurar checkstyle para que se ejecute automáticamente en cada commit de git lanzando el siguiente comando:```
$ make install-githooks
Para ejecutarlos en Docker, ejecuta los siguientes comandos:```shell $ make test-docker $ make regression-docker $ make checkstyle-docker
### Flatpak
Para ejecutar las pruebas de regresión en Flatpak, lanza el siguiente comando:```shell
$ make regression-flatpak
Para ejecutar las pruebas de regresión en Snap, lanza el siguiente comando:```shell $ make regression-snap
## Uso
Los siguientes son ejemplos de ejecución de NinjaDroid contra el paquete APK de muestra.