JStap
v1.1
Este repositorio contiene el código para el documento ACSAC'19: "Jstap: un prefiltro estático para la detección maliciosa de JavaScript".
Tenga en cuenta que en su estado actual, el código es un POC y no una API lista completa lista para la producción.
JSTAP es un sistema de detección de JavaScript malicioso estático modular. Nuestro detector está compuesto por diez módulos, incluidas cinco formas diferentes de resumir el código (a saber, los tokens, el árbol de sintaxis abstracta (AST), el gráfico de flujo de control (CFG), el gráfico de dependencia del programa considerando solo el flujo de datos (PDG-DFG) y PDG), y dos formas de extraer características (aprovechando los N-N-Mamas, o valores identificadores). Basado en la frecuencia de estos patrones específicos, entrenamos un clasificador de bosque aleatorio para cada módulo.
install python3 version 3.6.7
install python3-pip # (tested with 9.0.1)
pip3 install -r requirements.txt # (tested versions indicated in requirements.txt)
install nodejs # (tested with 8.10.0)
install npm # (tested with 3.5.2)
cd pdg_generation
npm install escodegen # (tested with 1.9.1)
cd ../classification
npm install esprima # (tested with 4.0.1)
cd ..
Para los análisis AST, CFG, PDG-DFG y PDG, debe generar los PDG de los archivos considerados por separado y de antemano. Después de eso, proporcione la (s) carpeta (s) que contiene los PDG como entrada al alumno o clasificador (en el caso de un análisis basado en AST, por ejemplo, solo usamos la información AST contenida en el PDG). Por el contrario, el enfoque basado en token, debe dar directamente la carpeta que contiene los archivos JS como entrada al alumno/clasificador.
Para generar los PDG de los archivos JS (.js) desde la carpeta de carpeta_name, inicie el siguiente comando shell desde la ubicación de la carpeta pdg_generation :
$ python3 -c "from pdgs_generation import *; store_pdg_folder('FOLDER_NAME')"
Los PDG correspondientes se almacenarán en carpeta_name/análisis/PDG.
Actualmente, estamos utilizando 2 CPU para el proceso de generación PDGS; Esto se puede cambiar modificando las variables num_workers de pdg_generation/utility_df.py.
Para construir un modelo a partir de las carpetas benignas y maliciosas, que contiene archivos JS (para el análisis basado en token) o los PDG (para los otros análisis), use la opción--D Benigna maliciosa y agregue su verdad terrestre correspondiente con--l benigno malicioso.
Seleccione las características que aparecen en el conjunto de capacitación con Chi2 en 2 conjuntos de datos independientes: --vd Benign-Validate-Validato-Validato con su verdad terrestre-VL Benign Benign Malicious.
Indique su nivel de análisis con-nivel seguido de 'tokens', 'AST', 'CFG', 'PDG-DFG' o 'PDG'.
Indique las características que el análisis debe usar con -características seguidas de 'ngrams', 'valor'. Puede elegir dónde almacenar las características seleccionadas por Chi2 con --analysis_path (JSTAP/Análisis predeterminado).
Puede elegir el nombre del modelo con --mn (siendo predeterminado 'modelo') y su directorio con --md (JSPA/Análisis predeterminado).
$ python3 learner.py --d BENIGN/ MALICIOUS/ --l benign malicious --vd BENIGN-VALIDATE/ MALICIOUS-VALIDATE/ --vl benign malicious --level LEVEL --features FEATURES --mn FEATURES_LEVEL
El proceso es similar para el proceso de clasificación.
Para clasificar las muestras de JS de las carpetas Benign2 y Malicious2, use la opción - -D benign2 maliciosa2. Para cargar un modelo existente características_level que se utilizarán para el proceso de clasificación, use la opción --m características_level. Mantenga el mismo nivel de análisis y características que para la capacitación del clasificador:
$ python3 classifier.py --d BENIGN2/ MALICIOUS2/ --level LEVEL --features FEATURES --m FEATURES_LEVEL
Si conoce la verdad terrestre de las muestras que clasifica y desea evaluar la precisión de su clasificador, use la opción -L con la verdad terrestre correspondiente:
$ python3 classifier.py --d BENIGN2 MALICIOUS2 --l benign malicious --level LEVEL --features FEATURES --m FEATURES_LEVEL
Actualmente, estamos utilizando 2 CPU para los procesos de aprendizaje y clasificación; Esto se puede cambiar modificando las variables num_workers de classification/utility.py.
Para generar las representaciones gráficas de AST (Save_Path_ast), CFG (Save_Path_CFG) y/o PDG (Save_Path_PDG) de un archivo JS dado input_file, aprovechamos la biblioteca GraphViz.
Para instalar GraphViz:
pip3 install graphviz
On MacOS: install brew and then brew install graphviz
On Linux: install graphviz
Inicie los siguientes comandos Python3 desde la ubicación de la carpeta pdg_generation e indique el nombre debajo del cual almacenar los gráficos:
>>> from pdgs_generation import *
>>> pdg = get_data_flow('INPUT_FILE', benchmarks=dict(), save_path_ast='ast', save_path_cfg='cfg', save_path_pdg='pdg')
Cuidado, GraphViz puede lanzar un error cuando los gráficos se están volviendo demasiado grandes.
Para mostrar simplemente los gráficos sin almacenarlos, use el valor 'Ninguno'. De lo contrario y por valor predeterminado, el valor es falso.
Nota: Por defecto, el PDG correspondiente no se almacenará. Para almacenarlo en una carpeta PDG_PATH existente, agregue el parámetro store_pdgs='PDG_PATH' al comando anterior.
Si usa JSTAP para la investigación académica, se le recomienda encarecidamente citar el siguiente documento:
@inproceedings{fass2019jstap,
author="Fass, Aurore and Backes, Michael and Stock, Ben",
title="{textsc{JStap}: A Static Pre-Filter for Malicious JavaScript Detection}",
booktitle="Proceedings of the Annual Computer Security Applications Conference~(ACSAC)",
year="2019"
}
Dado el éxito de la plataforma web, los atacantes han abusado de su lenguaje de programación principal, a saber, JavaScript, para montar diferentes tipos de ataques contra sus víctimas. Debido al gran volumen de tales scripts maliciosos, los sistemas de detección se basan en análisis estáticos para procesar rápidamente la gran mayoría de las muestras. Sin embargo, estos enfoques estáticos no son infalibles y conducen a clasificaciones erróneas. Además, carecen de información semántica para ir más allá de los enfoques puramente sintácticos. En este documento, proponemos JSTAP, un sistema de detección de JavaScript estático modular, que extiende la capacidad de detección de las tuberías léxicas y basadas en AST existentes al aprovechar también la información de control e flujo de datos. Nuestro detector está compuesto por diez módulos, incluidas cinco formas diferentes de abstraer código, con diferentes niveles de contexto e información semántica, y dos formas de extraer características. Basado en la frecuencia de estos patrones específicos, entrenamos un clasificador de bosque aleatorio para cada módulo.
En la práctica, JSTAP supera a los sistemas existentes, que reimplemimos y probamos en nuestro conjunto de datos por un total de más de 270,000 muestras. Para mejorar la detección, también combinamos las predicciones de varios módulos. Una primera capa de votación unánime clasifica el 93% de nuestro conjunto de datos con una precisión del 99.73%, mientras que una segunda capa en una combinación de módulos alternativos marcó otro 6.5% de nuestro conjunto de datos inicial con una precisión superior al 99%. De esta manera, JSTAP se puede usar como un prefiltro preciso, lo que significa que solo necesitaría reenviar menos del 1% de las muestras a análisis adicionales. Para la reproducibilidad y la implementación directa de nuestros módulos, hacemos que nuestro sistema esté disponible públicamente.
Este proyecto tiene licencia bajo los términos de la licencia AGPL3 que puede encontrar en LICENSE .
