rovellipaolo/ninjadroidEngenharia Reversa Ninja em pacotes APK do Android
NinjaDroid é uma ferramenta simples para engenharia reversa de pacotes Android APK.
Publicado em: 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)
## Visão Geral
O NinjaDroid utiliza o [AXMLParser](https://github.com/appknox/pyaxmlparser) juntamente com uma série de scripts Python baseados em `aapt`, `keytool`, `string` e outros para extrair diversas informações de um pacote APK, tais como:
- Lista de arquivos do APK: nome do arquivo, tamanho, MD5, SHA-1, SHA-256 e SHA-512
- Informações do `AndroidManifest.xml`: nome do aplicativo, nome do pacote, versão, sdks, permissões, atividades, serviços, broadcast-receivers, ...
- Informações do certificado digital `CERT.RSA/DSA`: número de série, validade, impressão digital, emissor e proprietário
- Lista de URLs, comandos de shell e outras strings genéricas codificadas nos arquivos `classes.dex`
Além disso, o NinjaDroid usa [apktool](https://github.com/iBotPeaches/Apktool) e [dex2jar](https://github.com/pxb1988/dex2jar) para extrair e armazenar:
- arquivo de relatório JSON, que contém todas as informações extraídas do APK
- arquivo `AndroidManifest.xml` (graças ao `apktool`)
- arquivo de certificado digital `CERT.RSA/DSA`
- arquivos `classes.dex`
- arquivo _.jar_ traduzido (graças ao `dex2jar`)
- arquivos smali desmontados (graças ao `apktool`)
- pastas `assets/` e `res/` juntamente com seu conteúdo (graças ao `apktool`)
## Compilação
O primeiro passo é clonar o repositório do NinjaDroid ou baixar seu código-fonte.```shell
$ git clone https://github.com/rovellipaolo/NinjaDroid
$ cd NinjaDroid
NinjaDroid tem várias formas de ser executado: nativamente no seu ambiente local, em Docker, como Flatpak (experimental) e como Snap (experimental).
Para executar o NinjaDroid na sua máquina local, precisa de instalar Python 3.5 ou superior, Java 8 ou superior e binutils.
Opcionalmente, se tiver o Android SDK instalado localmente, pode usar a versão do SDK do aapt em vez da incluída. Para tal, precisa de alterar a localização do aapt em ninjadroid/aapt/Aapt.py (i.e. __AAPT_EXEC_PATH = "ninjadroid/aapt/aapt").
Basta executar os seguintes comandos, que instalarão todas as dependências Python (garantindo que aapt, apktool e dex2jar têm permissões executáveis) e adicionarão um link simbólico ninjadroid para /usr/local/bin/.```shell
$ make build-linux
$ make install
$ ninjadroid --help
#### MacOS
Apenas execute os seguintes comandos, que instalarão todas as dependências Python necessárias (certificando-se de que `aapt`, `apktool` e `dex2jar` tenham permissões de execução) e adicionarão um link simbólico `ninjadroid` para `/usr/local/bin/`.```shell
$ make build-macos
$ make install
$ ninjadroid --help
Para executar o NinjaDroid no Docker, você precisa ter o Docker instalado.
Para construir a imagem Docker, execute os seguintes comandos:```shell
$ make build-docker
$ docker run --name ninjadroid ninjadroid:latest ninjadroid --help
Note que você precisa vincular o diretório que contém o pacote APK de destino à imagem 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 o mesmo se aplica também ao diretório de saída ao usar a opção -e/--extract, ao qual você também precisa conceder permissões:```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 executar o NinjaDroid como um Flatpak, você precisa do `Flatpak` e do `flatpak-builder` instalados.
Basta executar os seguintes comandos, que instalarão todas as dependências do Flatpak necessárias:```shell
$ make build-flatpak
$ flatpak-builder --run flatpak/build flatpak/com.github.rovellipaolo.NinjaDroid.yaml ninjadroid --help
NOTA: A opção -e/--extract não funciona corretamente no momento (veja: https://github.com/rovellipaolo/NinjaDroid/issues/21).
Para executar o NinjaDroid como um Snap, você precisa ter Snap e snapcraft instalados.
Basta executar os seguintes comandos, que instalarão todas as dependências Snap necessárias:```shell
$ make build-snap
$ make install-snap
$ ninjadroid --help
**NOTE:** A opção `-e`/`--extract` não funciona corretamente quando o snap é instalado sem usar a opção `--devmode` (veja: https://github.com/rovellipaolo/NinjaDroid/issues/20).
## Teste
Depois de configurado (veja a seção _"Instalação"_), você também pode executar os testes e o checkstyle da seguinte forma.
### Nativo
Para executá-los em sua máquina local, execute os seguintes comandos:```shell
$ make test
$ make regression
$ make checkstyle
Você também pode executar os testes com cobertura utilizando o seguinte comando:```shell $ make test-coverage
E/ou configure o checkstyle para ser executado automaticamente a cada git commit ao executar o seguinte comando:```
$ make install-githooks
Para executá-los no Docker, execute os seguintes comandos:```shell $ make test-docker $ make regression-docker $ make checkstyle-docker
### Flatpak
Para executar os testes de regressão no Flatpak, execute o seguinte comando:```shell
$ make regression-flatpak
Para executar os testes de regressão no Snap, execute o seguinte comando:```shell $ make regression-snap
## Uso
Os seguintes são exemplos de execução do NinjaDroid contra o pacote APK de exemplo.