View8

View8 es una herramienta de análisis estático diseñada para descompilar objetos de bytecode V8 serializados (archivos JSC) en código legible de alto nivel. Para analizar y desensamblar estos objetos serializados, View8 utiliza un binario V8 compilado con parches. Como resultado, View8 produce una salida textual similar a JavaScript.

Requisitos

• Python 3.x
• Binario desensamblador. Versiones disponibles:
• Versión de V8 9.4.146.24 (usada en Node V16.x)
• Versión de V8 10.2.154.26 (usada en Node V18.x)
• Versión de V8 11.3.244.8 (usada en Node V20.x)

Para versiones compiladas, visita la página de lanzamientos.

Uso

Argumentos de línea de comandos

• --inp, -i: El nombre del archivo de entrada.
• --out, -o: Ruta de salida. Dependiendo de las opciones seleccionadas, la salida puede ser un único archivo o un árbol de directorios.
• --input_format, -f: Especifica el formato de entrada. Las opciones son:
  • raw: la entrada es un archivo JSC sin procesar.
  • disassembled: el archivo de entrada ya está desensamblado.
  • serialized: la entrada ya está descompilada y almacenada en un formato serializado. El formato serializado actual es pickle de Python; usa solo entradas de confianza.
• --export_format, -e: Especifica los formatos de exportación. Las opciones son v8_opcode, translated, decompiled y serialized. Se pueden combinar varias opciones. Valor predeterminado: decompiled.
• --path, -p: Ruta al binario desensamblador. Es necesario si la entrada está en formato raw y View8 no puede localizar automáticamente el desensamblador correspondiente.
• --scope: Propaga los argumentos de ámbito. Valor predeterminado: 1.
• --normalize: Reemplaza los identificadores de funciones derivados de direcciones con nombres deterministas basados en el orden de análisis.
• --normalize-map [CSV]: Al usar --normalize, escribe un CSV que mapea cada nombre de función original a su nombre normalizado. Cuando se omite la ruta, View8 deriva <output>.name_map.csv de --out, o de --inp cuando no se establece una ruta de salida.
• --tree, -t: Divide la salida en una estructura de árbol en lugar de almacenar todas las funciones en un solo archivo. Especifica la función que se usará como raíz del árbol. Para comenzar desde la función principal predeterminada, usa start.
• --split_mode: Modo de división del árbol. Las opciones son declarers, calls y references. Valor predeterminado: declarers.
• --inline_depth, -d: En los modos calls y references, incluye las funciones alcanzables desde la raíz del árbol seleccionada hasta la profundidad N en el archivo principal del árbol. La profundidad 0 significa solo la raíz seleccionada; la profundidad 1 incluye llamadas/referencias directas; la profundidad 2 incluye sus hijos. No se usa con declarers.
• --inline_branch_limit, -l: En modo árbol, incluye ramas hijas completas con un máximo de N funciones en el archivo principal del árbol cuando las ramas hijas están incluidas por --inline_depth. Las ramas más grandes se guardan por separado.
• --split_depth: En los modos calls y references, limita la profundidad de recorrido de las ramas de uso exportadas. Valor predeterminado: 4.
• --include, -n: Archivo que contiene las funciones a incluir en la salida.
• --exclude, -x: Archivo que contiene las funciones a excluir de la salida.
• --func: Muestra una función seleccionada.
• --show_all: En el modo de visualización de funciones, también muestra las líneas marcadas como ocultas.
• --verbosity, -v: Nivel de verbosidad. Rango aceptado: 0 a 3.

Uso básico

Para descompilar un archivo de bytecode V8 y exportar el código descompilado:

python view8.py -i input_file -o output_file

Ruta del desensamblador

De forma predeterminada, View8 detecta la versión del bytecode V8 del archivo de entrada usando VersionDetector.exe y busca automáticamente un binario desensamblador compatible en la carpeta Bin. Esto se puede cambiar especificando un binario desensamblador diferente con la opción --path o -p:

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

Procesamiento de archivos desensamblados

Para omitir el proceso de desensamblado y proporcionar un archivo ya desensamblado como entrada, usa la opción --input_format disassembled o -f disassembled:

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

Nombres de funciones deterministas y CSV de mapeo

Usa --normalize para reemplazar los nombres de funciones derivados de direcciones con identificadores deterministas. Para preservar la relación entre los nombres originales y normalizados, agrega --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

Esto escribe decompiled/sample.dec.name_map.csv con las siguientes columnas:

original_name,normalized_name
func_start_0x268514e9dcd9,func_start_0x100000000
func_rne_0x268514eb0779,func_rne_0x100000001

También se puede proporcionar una ruta CSV explícita:

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

Creación y procesamiento de archivos serializados

A veces es útil descompilar el archivo en un formato serializado que preserve los objetos y estructuras analizados. Este tipo de salida puede ser más fácil de procesar posteriormente que un formato de texto, por ejemplo durante una desofuscación adicional. Para crear una salida serializada, usa el formato de exportación serialized:

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

Advertencia de seguridad: el formato serializado actual es un archivo pickle de Python (.pkl). Deserializar datos de fuentes no confiables puede ejecutar código arbitrario. Solo carga archivos serializados que hayas generado tú mismo.

Para cargar una salida serializada y exportarla en otro formato, usa --input_format serialized o -f serialized:

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