View8

View8 è uno strumento di analisi statica progettato per decompilare oggetti bytecode V8 serializzati (file JSC) in codice leggibile ad alto livello. Per analizzare e disassemblare questi oggetti serializzati, View8 utilizza un binario V8 compilato e modificato. Di conseguenza, View8 produce un output testuale simile a JavaScript.

Requisiti

• Python 3.x
• Binario del disassembler. Versioni disponibili:
• Versione V8 9.4.146.24 (usata in Node V16.x)
• Versione V8 10.2.154.26 (usata in Node V18.x)
• Versione V8 11.3.244.8 (usata in Node V20.x)

Per le versioni compilate, visita la pagina delle release.

Utilizzo

Argomenti della riga di comando

• --inp, -i: Il nome del file di input.
• --out, -o: Percorso dell'output. A seconda delle opzioni selezionate, l'output può essere un singolo file o una struttura di directory.
• --input_format, -f: Specifica il formato di input. Le opzioni sono:
  • raw: l'input è un file JSC grezzo.
  • disassembled: il file di input è già disassemblato.
  • serialized: l'input è già decompilato e memorizzato in un formato serializzato. L'attuale formato serializzato è Python pickle; utilizzare solo input attendibili.
• --export_format, -e: Specifica i formati di esportazione. Le opzioni sono v8_opcode, translated, decompiled e serialized. È possibile combinare più opzioni. Predefinito: decompiled.
• --path, -p: Percorso del binario del disassembler. Richiesto se l'input è in formato grezzo e View8 non riesce a individuare automaticamente il disassembler corrispondente.
• --scope: Propaga gli argomenti di ambito. Predefinito: 1.
• --normalize: Sostituisce gli identificatori di funzione derivati dagli indirizzi con nomi deterministici basati sull'ordine di analisi.
• --normalize-map [CSV]: Durante l'uso di --normalize, scrive un file CSV che mappa ogni nome di funzione originale al suo nome normalizzato. Quando il percorso viene omesso, View8 deriva <output>.name_map.csv da --out, oppure da --inp quando non è impostato alcun percorso di output.
• --tree, -t: Divide l'output in una struttura ad albero invece di memorizzare tutte le funzioni in un unico file. Specifica la funzione che verrà utilizzata come radice dell'albero. Per iniziare dalla funzione principale predefinita, usa start.
• --split_mode: Modalità di divisione dell'albero. Le opzioni sono declarers, calls e references. Predefinito: declarers.
• --inline_depth, -d: Nelle modalità calls e references, include nel file principale dell'albero le funzioni raggiungibili dalla radice selezionata fino alla profondità N. La profondità 0 significa solo la radice selezionata; la profondità 1 include i chiamati/riferimenti diretti; la profondità 2 include i loro figli. Non utilizzato con declarers.
• --inline_branch_limit, -l: In modalità albero, incorpora nel file principale dell'albero i rami figlio completi con al massimo N funzioni quando i rami figlio sono inclusi da --inline_depth. I rami più grandi vengono salvati separatamente.
• --split_depth: Nelle modalità calls e references, limita la profondità di attraversamento dei rami di utilizzo esportati. Predefinito: 4.
• --include, -n: File contenente le funzioni da includere nell'output.
• --exclude, -x: File contenente le funzioni da escludere dall'output.
• --func: Visualizza una funzione selezionata.
• --show_all: Nella modalità di visualizzazione delle funzioni, mostra anche le righe contrassegnate come nascoste.
• --verbosity, -v: Livello di dettaglio. Intervallo accettato: 0 a 3.

Utilizzo di base

Per decompilare un file bytecode V8 ed esportare il codice decompilato:

python view8.py -i input_file -o output_file

Percorso del disassembler

Per impostazione predefinita, View8 rileva la versione del bytecode V8 del file di input utilizzando VersionDetector.exe e cerca automaticamente un binario del disassembler compatibile nella cartella Bin. Questo può essere modificato specificando un binario del disassembler diverso con l'opzione --path o -p:

python view8.py -i input_file -o output_file --path /percorso/del/disassembler

Elaborazione di file disassemblati

Per saltare il processo di disassemblaggio e fornire un file già disassemblato come input, usa l'opzione --input_format disassembled o -f disassembled:

python view8.py -i input_file -o output_file -f disassembled

Nomi di funzione deterministici e CSV di mappatura

Usa --normalize per sostituire i nomi di funzione derivati dagli indirizzi con identificatori deterministici. Per preservare la relazione tra i nomi originali e quelli normalizzati, aggiungi --normalize-map:

python view8.py \
  --input_format disassembled \
  --inp sample.jsc.disasm.txt \
  --normalize \
  --normalize-map \
  --out decompiled/sample.dec.txt \
  --export_format decompiled serialized

Questo scrive decompiled/sample.dec.name_map.csv con le seguenti colonne:

original_name,normalized_name
func_start_0x268514e9dcd9,func_start_0x100000000
func_rne_0x268514eb0779,func_rne_0x100000001

È possibile fornire anche un percorso CSV esplicito:

python view8.py \
  --input_format disassembled \
  --inp sample.jsc.disasm.txt \
  --normalize \
  --normalize-map mappings/sample.names.csv \
  --out decompiled/sample.dec.txt

Creazione ed elaborazione di file serializzati

A volte è utile decompilare il file in un formato serializzato che preservi gli oggetti e le strutture analizzati. Questo tipo di output può essere più facile da post-elaborare rispetto a un formato testuale, ad esempio durante un'ulteriore deoffuscazione. Per creare un output serializzato, usa il formato di esportazione serialized:

python view8.py -i input_file -o output_file -e serialized

Avviso di sicurezza: l'attuale formato serializzato è un file Python pickle (.pkl). L'unpickling di dati provenienti da fonti non attendibili può eseguire codice arbitrario. Carica solo file serializzati che hai generato tu stesso.

Per ricaricare un output serializzato ed esportarlo in un altro formato, usa --input_format serialized o -f serialized:

python view8.py -i input_file -o output_file -f serialized