View8

View8 est un outil d'analyse statique conçu pour décompiler des objets bytecode V8 sérialisés (fichiers JSC) en code lisible de haut niveau. Pour analyser et désassembler ces objets sérialisés, View8 utilise un binaire V8 compilé patché. En conséquence, View8 produit une sortie textuelle similaire à JavaScript.

Prérequis

• Python 3.x
• Binaire de désassemblage. Versions disponibles :
• Version V8 9.4.146.24 (Utilisée dans Node V16.x)
• Version V8 10.2.154.26 (Utilisée dans Node V18.x)
• Version V8 11.3.244.8 (Utilisée dans Node V20.x)

Pour les versions compilées, consultez la page des versions.

Utilisation

Arguments de ligne de commande

• --inp, -i : Le nom du fichier d'entrée.
• --out, -o : Chemin vers la sortie. Selon les options sélectionnées, la sortie peut être un fichier unique ou une arborescence de répertoires.
• --input_format, -f : Spécifie le format d'entrée. Les options sont :
  • raw : l'entrée est un fichier JSC brut.
  • disassembled : le fichier d'entrée est déjà désassemblé.
  • serialized : l'entrée est déjà décompilée et stockée dans un format sérialisé. Le format sérialisé actuel est le pickle Python ; utilisez uniquement des entrées de confiance.
• --export_format, -e : Spécifie le ou les formats d'exportation. Les options sont v8_opcode, translated, decompiled et serialized. Plusieurs options peuvent être combinées. Défaut : decompiled.
• --path, -p : Chemin vers le binaire de désassemblage. Requis si l'entrée est au format brut et que View8 ne peut pas localiser automatiquement le désassembleur correspondant.
• --scope : Propager les arguments de portée. Défaut : 1.
• --normalize : Remplacer les identifiants de fonctions dérivés des adresses par des noms déterministes basés sur l'ordre d'analyse.
• --normalize-map [CSV] : Lors de l'utilisation de --normalize, écrire un fichier CSV mappant chaque nom de fonction original à son nom normalisé. Lorsque le chemin est omis, View8 dérive <output>.name_map.csv de --out, ou de --inp lorsqu'aucun chemin de sortie n'est défini.
• --tree, -t : Diviser la sortie en une structure arborescente plutôt que de stocker toutes les fonctions dans un seul fichier. Spécifiez la fonction qui sera utilisée comme racine de l'arbre. Pour démarrer depuis la fonction principale par défaut, utilisez start.
• --split_mode : Mode de division de l'arbre. Les options sont declarers, calls et references. Défaut : declarers.
• --inline_depth, -d : Dans les modes calls et references, inclure les fonctions accessibles depuis la racine de l'arbre sélectionnée jusqu'à la profondeur N dans le fichier principal de l'arbre. La profondeur 0 signifie uniquement la racine sélectionnée ; la profondeur 1 inclut les appelés/références directs ; la profondeur 2 inclut leurs enfants. Non utilisé avec declarers.
• --inline_branch_limit, -l : En mode arbre, intégrer les branches enfants complètes contenant au plus N fonctions dans le fichier principal de l'arbre lorsque les branches enfants sont incluses par --inline_depth. Les branches plus grandes sont enregistrées séparément.
• --split_depth : Dans les modes calls et references, limiter la profondeur de parcours des branches d'utilisation exportées. Défaut : 4.
• --include, -n : Fichier contenant les fonctions à inclure dans la sortie.
• --exclude, -x : Fichier contenant les fonctions à exclure de la sortie.
• --func : Afficher une fonction sélectionnée.
• --show_all : En mode d'affichage de fonction, afficher également les lignes marquées comme cachées.
• --verbosity, -v : Niveau de verbosité. Plage acceptée : 0 à 3.

Utilisation de base

Pour décompiler un fichier bytecode V8 et exporter le code décompilé :

python view8.py -i input_file -o output_file

Chemin du désassembleur

Par défaut, View8 détecte la version du bytecode V8 du fichier d'entrée à l'aide de VersionDetector.exe et recherche automatiquement un binaire de désassemblage compatible dans le dossier Bin. Cela peut être modifié en spécifiant un binaire de désassemblage différent avec l'option --path ou -p :

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

Traitement des fichiers désassemblés

Pour ignorer le processus de désassemblage et fournir un fichier déjà désassemblé comme entrée, utilisez l'option --input_format disassembled ou -f disassembled :

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

Noms de fonctions déterministes et CSV de mappage

Utilisez --normalize pour remplacer les noms de fonctions dérivés des adresses par des identifiants déterministes. Pour préserver la relation entre les noms originaux et normalisés, ajoutez --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

Cela écrit decompiled/sample.dec.name_map.csv avec les colonnes suivantes :

original_name,normalized_name
func_start_0x268514e9dcd9,func_start_0x100000000
func_rne_0x268514eb0779,func_rne_0x100000001

Un chemin CSV explicite peut également être fourni :

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

Création et traitement de fichiers sérialisés

Il est parfois utile de décompiler le fichier dans un format sérialisé qui préserve les objets et structures analysés. Ce type de sortie peut être plus facile à post-traiter qu'un format texte, par exemple lors d'une désobfuscation ultérieure. Pour créer une sortie sérialisée, utilisez le format d'exportation serialized :

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

Avertissement de sécurité : le format sérialisé actuel est un fichier pickle Python (.pkl). Désérialiser des données provenant de sources non fiables peut exécuter du code arbitraire. Ne chargez que des fichiers sérialisés que vous avez générés vous-même.

Pour recharger une sortie sérialisée et l'exporter dans un autre format, utilisez --input_format serialized ou -f serialized :

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