README

trueseeing è uno scanner di vulnerabilità veloce, accurato e resiliente per app iOS/Android. Operiamo a livello di Dalvik VM per Android – cioè non ci interessa se l'app target è offuscata o meno.

Capacità

Attualmente possiamo:

• Scansionare automaticamente l'app per vulnerabilità, producendo report in formato HTML/JSON/testo (vedi sotto)
• Manipolare l'app per un'analisi più semplice: ad es. abilitazione del debug bit, abilitazione del backup completo, disabilitazione del TLS pinning, manipolazione del livello API target, iniezione di frida-gadget, ecc.
• Esaminare l'app per informazioni generali
• Copiare dati dentro/fuori dall'app tramite interfaccia di debug
• Cercare determinate chiamate/const/sput/iput
• Dedurre costanti/typesets per gli argomenti di op
• Scansionare chiamate API/private per codici nativi (NB: è necessario ts2-disasm-ghidra)
• Scansionare app iOS per vulnerabilità di base (NB: è necessario ts2-disasm-ghidra)
• Allega script frida
• Fornisce sessione interattiva frida
• Tracciamento chiamate
• ecc.

Installazione

Container

NOTA:

• A partire dalla 2.1.9, siamo su ghcr.io. (Docker Hub è un po' deprecato)
• Richiede adbd nell'host per controllare i dispositivi.

Forniamo container così puoi usarli subito come segue; ora questa è anche la via raccomandata, e l'unico modo se sei su Windows, per eseguire:

$ docker run --rm -v $(pwd):/out -v ts2:/cache ghcr.io/alterakey/trueseeing

Se vuoi eseguire senza stato, ometti il montaggio del volume su /cache (non consigliato per l'uso quotidiano; vedi anche #254):

$ docker run --rm -v $(pwd):/out ghcr.io/alterakey/trueseeing

Installazione con uv

In alternativa, puoi installare il nostro pacchetto con uv come segue. In particolare la forma di installazione uv tool install potrebbe essere utile per le estensioni (vedi sotto), poiché concede loro la massima libertà. Ricorda solo che hai bisogno di un JRE e Android SDK (opzionalmente; per armeggiare con i dispositivi):

$ uvx trueseeing

$ uv tool install trueseeing
$ trueseeing

Installazione con pip (deprecato)

Ovviamente puoi sempre usare il buon vecchio pip se necessario:

$ pip install trueseeing

Utilizzo

Modalità interattiva

Puoi scansionare/analizzare/patchare/ecc. le app in modo interattivo – rendendola la scelta ideale per l'analisi manuale:

$ trueseeing target.apk
[+] trueseeing x.y.z
ts[target.apk]> ?
...
ts[target.apk]> i                      # show generic information
...
ts[target.apk]> pf AndroidManifest.xml # show manifest file
...
ts[target.apk]> a                      # analyze resources too
...
ts[target.apk]> /s something           # search text
...
ts[target.apk]> as                     # scan
...
[+] done, found 6403 issues (174.94 sec.)
ts[target.apk]> gh report.html

Modalità batch

Accettiamo un comando inline (-c) o file script (-i) da eseguire prima di darti il prompt, così come uscire subito invece di chiedere prompt (-q; non richiediamo un tty in questa modalità!).

Puoi usare le funzionalità per eseguire una scansione batch, come segue ad es. per scaricare i risultati direttamente su stderr:

$ trueseeing -eqc 'as' target.apk

Per generare un file di report in formato HTML:

$ trueseeing -eqc 'as;gh report.html' target.apk

Per generare un file di report in formato JSON:

$ trueseeing -eqc 'as;gj report.json' target.apk

Per ottenere il report generato su stdout, ometti il nome del file dal comando g* finale:

$ trueseeing -eqc 'as;gh' target.apk > report.html
$ trueseeing -eqc 'as;gj' target.apk > report.json

Modalità di scansione non interattiva (deprecata)

Tradizionalmente, puoi scansionare app con la seguente riga di comando per ottenere i risultati elencati su stderr:

$ trueseeing --scan target.apk

Per generare un report in formato HTML:

$ trueseeing --scan --scan-output report.html target.apk
$ trueseeing --scan --scan-report=html --scan-output report.html target.apk

Per generare un report in formato JSON:

$ trueseeing --scan --scan-report=json --scan-output report.json target.apk

Per ottenere il report generato su stdout, specifica '-' come nome file:

$ trueseeing --scan --scan-output - target.apk > report.html
$ trueseeing --scan --scan-report=html --scan-output - target.apk > report.html
$ trueseeing --scan --scan-report=json --scan-output - target.apk > report.json

Utilizzi Avanzati

Estensioni

Puoi scrivere i tuoi comandi e firme come estensioni. Le estensioni sono posizionate sotto /ext (container) o ~/.trueseeing2/extensions/ (uv/pip). In alternativa puoi distribuire le tue estensioni come wheel. Forniamo informazioni sui tipi in modo da poter non solo eseguire il type-check delle tue estensioni con zuban ma anche ottenere un buon supporto dagli IDE. Vedi la sezione dettagli per i dettagli.

Compilazione

Puoi compilarlo come segue:

$ docker build -t trueseeing https://github.com/alterakey/trueseeing.git#main

Per compilare wheel puoi farlo con flit, come segue:

$ flit build

Per hackerarlo, devi creare un ambiente di build appropriato. Con uv puoi semplicemente fare:

$ git clone https://github.com/alterakey/trueseeing.git wc
$ uv sync --locked --dev
$ (... hack ...)
$ uv run trueseeing ...                                    # to run
$ uv run zuban check trueseeing && uv run ruff trueseeing  # to validate
Success: no issues found in XX source files
$ uv run flit build                                        # to build (wheel)
$ docker build -t trueseeing .                             # to build (container)

Con pip, per crearne uno, prima imposta un venv, installa flit e le toolchain di validazione (zuban e ruff) lì dentro, e fai sì che flit tiri le dipendenze. In breve, fai qualcosa del genere:

$ git clone https://github.com/alterakey/trueseeing.git wc
$ python3 -m venv wc/.venv
$ source wc/.venv/bin/activate
(.venv) $ pip install flit zuban ruff
(.venv) $ flit install --deps=develop -s
(.venv) $ (... hack ...)
(.venv) $ trueseeing ...                                   # to run
(.venv) $ zuban check trueseeing && ruff check trueseeing  # to validate
Success: no issues found in XX source files
(.venv) $ flit build                                       # to build (wheel)
(.venv) $ docker build -t trueseeing .                     # to build (container)

Dettagli

Classi di vulnerabilità

Attualmente possiamo rilevare le seguenti classi di vulnerabilità, in gran parte quelle coperte da OWASP Mobile Top 10 - 2016:

• Improper Platform Usage (M1)

  • Debuggabile
  • Pubblicazione involontaria di Activity, Service, ContentProvider, BroadcastReceiver

• Insecure Data (M2)

  • Backupabile (cioè suscettibile all'attacco di backup)
  • Permessi file insicuri
  • Registrazione

• Insecure Communications (M3)

  • Mancanza di pinning (cioè suscettibile all'attacco di intercettazione TLS)
  • Uso di HTTP in chiaro
  • WebView manipolabili

• Insufficient Cryptography (M5)