Obfuscapk

[!IMPORTANT] Questo progetto è archiviato e non più mantenuto.

Alcune delle domande più comuni trovano risposta in FAQ e troubleshooting.

Uno strumento di offuscamento black-box per app Android.

Obfuscapk è uno strumento Python modulare per offuscare app Android senza bisogno del loro codice sorgente, poiché apktool viene utilizzato per decompilare il file apk originale e per costruire una nuova applicazione, dopo aver applicato alcune tecniche di offuscamento sul codice smali decompilato, sulle risorse e sul manifest. L'app offuscata mantiene la stessa funzionalità dell'originale, ma le differenze sotto il cofano talvolta rendono la nuova applicazione molto diversa dall'originale (ad esempio, per i software antivirus basati su firma).

🆕 Supporto per Android App Bundle 🆕

Obfuscapk sta aggiungendo il supporto per gli Android App Bundle (file aab) utilizzando BundleDecompiler (vedi #121). Per utilizzare questa nuova funzionalità, scarica l'ultima versione di BundleDecompiler disponibile da qui, salvala come BundleDecompiler.jar in una directory inclusa in PATH (ad esempio, in Ubuntu, /usr/local/bin o /usr/bin) e assicurati che abbia il flag eseguibile impostato.

[!IMPORTANT] BundleDecompiler non funziona ancora su Windows, quindi l'offuscamento degli app bundle non è supportato da Obfuscapk sulla piattaforma Windows. Inoltre, il supporto per gli app bundle è ancora in fase di sviluppo iniziale, quindi se incontri problemi o desideri aiutarci a migliorare, consulta contribuire.

❱ Pubblicazione

Maggiori dettagli su Obfuscapk sono disponibili nell'articolo "Obfuscapk: An open-source black-box obfuscation tool for Android apps". Puoi citare l'articolo come segue:```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" }

## ❱ Demo

![Demo](https://assets.kitploit.com/production/public/readmes/3132/632e285a29e53c28a5549c70012673a2761ca3ca4fd7eac3ad89be3d6a9a2a21.gif)

## ❱ Architettura

![Architecture](https://assets.kitploit.com/production/public/readmes/3132/da41bec35f1c09df38ad201aa1e74f0b1426dba0201162a70b4d5376b3da654e.png)

Obfuscapk è progettato per essere modulare e facile da estendere, quindi è costruito usando un [sistema a plugin](https://github.com/tibonihoo/yapsy). Di conseguenza, ogni offuscatore è un plugin che eredita da una [classe base astratta](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/obfuscator_category.py) e deve implementare il metodo `obfuscate`. Quando lo strumento inizia a elaborare un nuovo file di applicazione Android, crea un [oggetto di offuscamento](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/obfuscation.py) per memorizzare tutte le informazioni necessarie (ad esempio, la posizione del codice `smali` decompilato) e lo stato interno delle operazioni (ad esempio, l'elenco degli offuscatori già utilizzati). Poi l'oggetto di offuscamento viene passato, come parametro al metodo `obfuscate`, a tutti i plugin/offuscatori attivi (in sequenza) per essere elaborato e modificato. L'elenco e l'ordine dei plugin attivi sono specificati tramite [opzioni da riga di comando](#-usage).

Lo strumento è facilmente estensibile con nuovi offuscatori: è sufficiente aggiungere il codice sorgente che implementa la tecnica di offuscamento e i metadati del plugin (un file `<obfuscator-name>.obfuscator`) nella directory [`src/obfuscapk/obfuscators`](https://github.com/ClaudiuGeorgiu/Obfuscapk/tree/master/src/obfuscapk/obfuscators) (prendi come esempio iniziale un offuscatore semplice come [`Nop`](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/obfuscators/nop/nop.py)). Lo strumento rileverà automaticamente il nuovo plugin, quindi non è necessaria alcuna ulteriore configurazione (il nuovo plugin verrà trattato come tutti gli altri plugin inclusi nello strumento).

## ❱ Installazione

Ci sono due modi per ottenere una copia funzionante di Obfuscapk sul tuo computer: o [usando Docker](#docker-image) o [usando direttamente il codice sorgente](#from-source) in un ambiente `Python 3`. In entrambi i casi, la prima cosa da fare è ottenere una copia locale di questo repository, quindi apri un terminale nella directory dove vuoi salvare il progetto e clona il repository:```Shell
$ git clone https://github.com/ClaudiuGeorgiu/Obfuscapk.git

Immagine Docker

Prerequisiti

Questo è il metodo consigliato per installare Obfuscapk, poiché l'unico requisito è avere una versione recente di Docker installata:```Shell $ docker --version Docker version 20.10.21, build baeda1f

#### Immagine ufficiale su Docker Hub

L'[immagine Docker ufficiale di Obfuscapk](https://hub.docker.com/r/claudiugeorgiu/obfuscapk)
è disponibile su Docker Hub (creata automaticamente da questo repository):```Shell
$ # Download the Docker image.
$ docker pull claudiugeorgiu/obfuscapk
$ # Give it a shorter name.
$ docker tag claudiugeorgiu/obfuscapk obfuscapk

Installazione

Se hai scaricato l'immagine ufficiale da Docker Hub, sei pronto per usare lo strumento, quindi passa alle istruzioni per l'uso, altrimenti esegui il seguente comando nella directory Obfuscapk/src/ creata in precedenza (la cartella che contiene il Dockerfile) per costruire l'immagine 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 .

Quando l'immagine Docker è pronta, esegui un rapido test per verificare che tutto sia stato installato correttamente:```Shell
$ docker run --rm -it obfuscapk --help
usage: python3 -m obfuscapk.cli [-h] -o OBFUSCATOR [-w DIR] [-d OUT_APK_OR_AAB]
...

Obfuscapk è ora pronto per essere utilizzato, consulta le istruzioni d'uso per maggiori informazioni.

Da sorgente

Prerequisiti

Assicurati di avere una versione recente di apktool, apksigner e zipalign installati e disponibili dalla riga di comando:```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
...

Per supportare l'offuscamento degli app bundle hai anche bisogno di BundleDecompiler, quindi scarica l'ultima versione disponibile da qui, salvala come BundleDecompiler.jar in una directory inclusa in PATH (ad esempio, in Ubuntu, /usr/local/bin o /usr/bin) e assicurati che abbia il flag eseguibile impostato.

Per utilizzare BundleDecompiler e apktool hai anche bisogno di una versione recente di Java. zipalign e apksigner sono inclusi nell'Android SDK. La posizione degli eseguibili può essere specificata anche attraverso le seguenti variabili d'ambiente: APKTOOL_PATH, BUNDLE_DECOMPILER_PATH, APKSIGNER_PATH e ZIPALIGN_PATH (ad esempio, in Ubuntu, esegui export APKTOOL_PATH=/custom/location/apktool prima di eseguire Obfuscapk nello stesso terminale).

Oltre agli strumenti sopra menzionati, l'unico requisito di questo progetto è un'installazione funzionante di Python 3 (almeno 3.7) (insieme al suo gestore di pacchetti pip).

Installazione

Esegui i seguenti comandi nella directory principale del progetto (Obfuscapk/) per installare le dipendenze necessarie:```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

Dopo che i requisiti sono stati installati, effettua un rapido test per verificare che tutto funzioni correttamente:```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 è ora pronto per essere utilizzato, consulta le istruzioni per l'uso per maggiori informazioni.

❱ Utilizzo

Da ora in poi, Obfuscapk sarà considerato come un eseguibile disponibile come obfuscapk, quindi è necessario adattare i comandi in base a come hai installato lo strumento:

• Immagine Docker: una directory locale contenente l'applicazione da offuscare deve essere montata su /workdir nel contenitore (ad esempio, la directory corrente "${PWD}"), quindi il comando:

  root@kitploit:~

  $ obfuscapk [params...]
  

  diventa:

  root@kitploit:~

  $ docker run --rm -it -u $(id -u):$(id -g) -v "${PWD}":"/workdir" obfuscapk [params...]
  

• Dal sorgente: ogni istruzione deve essere eseguita dalla directory Obfuscapk/src/ (oppure aggiungendo la directory Obfuscapk/src/ alla variabile d'ambiente PYTHONPATH) e il comando:

  root@kitploit:~

  $ obfuscapk [params...]
  

  diventa:

  root@kitploit:~

  $ python3 -m obfuscapk.cli [params...]
  

Iniziamo dando un'occhiata al messaggio di aiuto:```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>

Ci sono due parametri obbligatori: `<APK_OR_BUNDLE_FILE>`, il percorso (relativo o assoluto) al file apk o app bundle da offuscare e l'elenco dei nomi delle tecniche di offuscamento da applicare (specificato con un'opzione `-o` che può essere usata più volte, ad es. `-o Rebuild -o NewAlignment -o NewSignature`). Gli altri argomenti opzionali sono i seguenti:

* `-w DIR` viene utilizzato per impostare la directory di lavoro dove salvare i file intermedi (generati da `apktool`). Se non specificato, viene creata una directory denominata `obfuscation_working_dir` nella stessa directory dell'applicazione di input. Questo può essere utile per scopi di debug, ma se non necessario può essere impostato su una directory temporanea (ad es. `-w /tmp/`).

* `-d OUT_APK_OR_AAB` viene utilizzato per impostare il percorso del file di destinazione: il file apk generato dal processo di offuscamento (ad es. `-d /home/user/Desktop/obfuscated.apk` o `-d /home/user/Desktop/obfuscated.aab`). Se non specificato, il file offuscato finale verrà salvato all'interno della directory di lavoro. Nota: i file esistenti verranno sovrascritti senza alcun avviso.

* `-i` è un flag per ignorare le librerie di terze parti note durante il processo di offuscamento, per utilizzare meno risorse, aumentare le prestazioni e ridurre il rischio di errori. La [lista delle librerie](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/resources/libs_to_ignore.txt) da ignorare è adattata dal progetto [LiteRadar](https://github.com/pkumza/LiteRadar).

* `-p` è un flag per mostrare le barre di avanzamento durante le operazioni di offuscamento. Quando si utilizza lo strumento in operazioni batch/build automatici è comodo avere le barre di avanzamento disabilitate, altrimenti questo flag dovrebbe essere abilitato per vedere l'avanzamento dell'offuscamento.

* `-k VT_API_KEY` è necessario solo quando si utilizza l'offuscatore `VirusTotal`, per impostare la chiave API da utilizzare durante la comunicazione con Virus Total.

* `--keystore-file KEYSTORE_FILE`, `--keystore-password KEYSTORE_PASSWORD`, `--key-alias KEY_ALIAS` e `--key-password KEY_PASSWORD` possono essere utilizzati per specificare un keystore personalizzato (necessario per la firma dell'apk). Se si utilizza `--keystore-file`, devono essere specificati anche `--keystore-password` e `--key-alias`, mentre `--key-password` è necessario solo se la chiave scelta ha una password diversa da quella del keystore. Per impostazione predefinita (quando `--keystore-file` non è specificato), viene utilizzato un [keystore incluso con Obfuscapk](https://github.com/ClaudiuGeorgiu/Obfuscapk/blob/master/src/obfuscapk/resources/obfuscation_keystore.jks) per le operazioni di firma.

* `--ignore-packages-file IGNORE_PACKAGES_FILE` è un percorso verso un file che contiene i nomi dei pacchetti da ignorare. Tutte le classi all'interno di questi pacchetti non verranno offuscate quando questa opzione viene utilizzata. Il file dovrebbe avere un nome di pacchetto per riga come mostrato nell'esempio seguente:
    ```
    com.mycompany.dontobfuscate
    com.mycompany.ignore
    ...
    ```
* `--use-aapt2` è un flag per utilizzare l'opzione aapt2 quando si ricostruisce un'app con `apktool`.

Consideriamo ora un semplice esempio funzionante per vedere come funziona Obfuscapk:```Shell
$ # original.apk is a valid Android apk file.
$ obfuscapk -o RandomManifest -o Rebuild -o NewAlignment -o NewSignature original.apk

Quando si esegue il comando sopra, ecco cosa succede dietro le quinte:

• poiché non è stata specificata una directory di lavoro, viene creata una nuova directory di lavoro (obfuscation_working_dir) nella stessa posizione di original.apk (questo può essere utile per ispezionare i file smali/manifest/risorse in caso di errori)

• vengono eseguiti alcuni controlli per assicurarsi che tutti i file/eseguibili necessari siano disponibili e pronti per essere utilizzati

• inizia il vero processo di offuscamento: gli offuscatori specificati vengono eseguiti (in ordine) uno dopo l'altro finché non rimane più alcun offuscatore o fino a quando non si verifica un errore

  • quando si esegue il primo offuscatore, original.apk viene decompilato con apktool e i risultati vengono salvati nella directory di lavoro

  • poiché il primo offuscatore è RandomManifest, le voci nel manifest Android decompilato vengono riordinate casualmente (senza rompere le strutture xml)

  • l'offuscatore Rebuild si limita a ricostruire l'applicazione (ora con il manifest modificato) usando apktool, e poiché non è stato specificato alcun file di output, il file apk risultante viene salvato nella directory di lavoro creata in precedenza

Come visto nell'esempio precedente, gli offuscatori Rebuild, NewAlignment e NewSignature sono sempre necessari per completare un'operazione di offuscamento, per costruire l'apk offuscato finale. Non sono tecniche di offuscamento reali, ma sono necessari nel processo di costruzione, quindi sono inclusi nell'elenco degli offuscatori per mantenere l'architettura generale modulare.

Non funziona come previsto? Vedi FAQ e risoluzione dei problemi.

❱ Offuscatori

Gli offuscatori inclusi in Obfuscapk possono essere suddivisi in diverse categorie, a seconda delle operazioni che eseguono:

• Banali: come suggerisce il nome, questa categoria include operazioni semplici (che non modificano molto l'applicazione originale), come firmare il file apk con una nuova firma.

• Rinomina: operazioni che cambiano i nomi degli identificatori utilizzati (classi, campi, metodi).

• Crittografia: impacchettamento di codice/risorse crittografate e decrittografia durante l'esecuzione dell'app. Quando Obfuscapk viene avviato, genera automaticamente una chiave segreta casuale (32 caratteri, utilizzando lettere ASCII e cifre) che verrà utilizzata per la crittografia.

• Codice: tutte le operazioni che comportano la modifica del codice sorgente decompilato.

• Risorse: operazioni sui file di risorse (come la modifica del manifest).

• Altro

Gli offuscatori attualmente inclusi in Obfuscapk sono presentati brevemente di seguito (in ordine alfabetico). Fare riferimento al codice sorgente del progetto per maggiori dettagli.

[!SUGGERIMENTO] Non tutti gli offuscatori elencati di seguito corrispondono a tecniche di offuscamento reali (ad es., Rebuild, NewAlignment, NewSignature e VirusTotal), ma sono implementati come offuscatori per mantenere l'architettura modulare e facile da estendere con nuove funzionalità.

❱ Licenza

Sei libero di utilizzare questo codice secondo i termini della MIT License.

❱ Crediti

Questo software è stato sviluppato per scopi di ricerca presso il Computer Security Lab (CSecLab), ospitato presso DIBRIS, Università di Genova.

❱ Team

• Simone Aonzo - Research Assistant (Assistente di Ricerca)
• Gabriel Claudiu Georgiu - Core Developer (Sviluppatore Principale)
• Luca Verderame - Postdoctoral Researcher (Ricercatore Postdottorato)
• Alessio Merlo - Faculty Member (Membro del Corpo Docente)