JStap
v1.1
Ce référentiel contient le code du papier ACSAC'19: "JSTAP: un pré-filtre statique pour la détection de JavaScript malveillante".
Veuillez noter que dans son état actuel, le code est un POC et non une API à part entière pour la production.
JSTAP est un système de détection de JavaScript malveillant statique statique statique. Notre détecteur est composé de dix modules, dont cinq façons différentes de résumer le code (à savoir les jetons, l'arborescence de syntaxe abstraite (AST), le graphique de flux de contrôle (CFG), le graphique de dépendance du programme en tenant compte du flux de données (PDG-DFG) et PDG), et deux façons d'extraire les caractéristiques (levier N-grammes ou les valeurs d'identifiant). Sur la base de la fréquence de ces modèles spécifiques, nous formons un classificateur de forêt aléatoire pour chaque module.
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 ..
Pour les analyses AST, CFG, PDG-DFG et PDG, vous devez générer les PDG des fichiers considérés séparément et au préalable. Après cela, donnez au (s) dossier (s) contenant les PDG en entrée à l'apprenant ou au classificateur (dans le cas d'une analyse basée sur l'AST, par exemple, nous utilisons uniquement les informations AST contenues dans le PDG). Au contraire de l'approche basée sur les jetons, vous devez donner directement le dossier contenant les fichiers JS en entrée à l'apprenant / classificateur.
Pour générer les PDG des fichiers JS (.js) à partir du dossier Folder_name, lancez la commande shell suivante à partir de l'emplacement du dossier pdg_generation :
$ python3 -c "from pdgs_generation import *; store_pdg_folder('FOLDER_NAME')"
Les PDG correspondants seront stockés dans Folder_name / Analysis / PDG.
Actuellement, nous utilisons 2 CPU pour le processus de génération PDGS; Cela peut être modifié en modifiant la variable num_workers de pdg_generation / utility_df.py.
Pour construire un modèle à partir des dossiers bénins et malveillants, contenant des fichiers JS (pour l'analyse basée sur les jetons) ou les PDG (pour les autres analyses), utilisez l'option - d bienveillant malveillant et ajoutez leur vérité fondamentale correspondante avec - l malveillant bénin.
Sélectionnez les fonctionnalités apparaissant dans l'ensemble de formation avec CHI2 sur 2 ensembles de données indépendants: - Vd-valider malveillant-validate avec leur Vérité du sol correspondante - Vl malveillant bénin.
Indiquez votre niveau d'analyse avec - level suivi de «jetons», «AST», «CFG», «PDG-DFG» ou «PDG».
Indiquez les fonctionnalités avec lesquelles l'analyse doit utiliser - les fonctionnalités suivies de l'un ou l'autre «ngrams», «valeur». Vous pouvez choisir où stocker les fonctionnalités sélectionnées par CHI2 avec --analysis_path (par défaut JSTAP / Analyse).
Vous pouvez choisir le nom du modèle avec --mn (par défaut étant «modèle») et son répertoire avec --MD (par défaut JSTAP / Analysis).
$ python3 learner.py --d BENIGN/ MALICIOUS/ --l benign malicious --vd BENIGN-VALIDATE/ MALICIOUS-VALIDATE/ --vl benign malicious --level LEVEL --features FEATURES --mn FEATURES_LEVEL
Le processus est similaire pour le processus de classification.
Pour classer les échantillons JS à partir des dossiers BenigN2 et Malicious2, utilisez l'option --d Benign2 Malicious2. Pour charger un modèle existant de fonctionnalités_level à utiliser pour le processus de classification, utilisez l'option - m feondat_level. Gardez le même niveau d'analyse et les mêmes fonctionnalités que pour la formation du classificateur:
$ python3 classifier.py --d BENIGN2/ MALICIOUS2/ --level LEVEL --features FEATURES --m FEATURES_LEVEL
Si vous connaissez la vérité sur le terrain des échantillons que vous classez et souhaitez évaluer la précision de votre classificateur, utilisez l'option --L avec la vérité au sol correspondante:
$ python3 classifier.py --d BENIGN2 MALICIOUS2 --l benign malicious --level LEVEL --features FEATURES --m FEATURES_LEVEL
Actuellement, nous utilisons 2 CPU pour les processus d'apprentissage et de classification; Cela peut être modifié en modifiant la variable num_workers de Classification / Utility.py.
Pour générer les représentations graphiques de l'AST (Save_Path_ast), CFG (SAVE_PATH_CFG) et / ou PDG (SAVE_PATH_PDG) d'un fichier JS Input_file JS, nous levons la bibliothèque Graphviz.
Pour installer Graphviz:
pip3 install graphviz
On MacOS: install brew and then brew install graphviz
On Linux: install graphviz
Lancez les commandes Python3 suivantes à partir de l'emplacement du dossier pdg_generation et indiquez le nom sous lequel stocker le (s) graphique:
>>> from pdgs_generation import *
>>> pdg = get_data_flow('INPUT_FILE', benchmarks=dict(), save_path_ast='ast', save_path_cfg='cfg', save_path_pdg='pdg')
Méfiez-vous, Graphviz peut lancer une erreur lorsque les graphiques deviennent trop gros.
Pour afficher simplement les graphiques sans les stocker, utilisez la valeur «Aucun». Sinon et par défaut, la valeur est fausse.
Remarque: par défaut, le PDG correspondant ne sera pas stocké. Pour le stocker dans un dossier PDG_PATH existant, ajoutez le paramètre store_pdgs='PDG_PATH' à la commande précédente.
Si vous utilisez JSTAP pour la recherche universitaire, vous êtes fortement encouragé à citer l'article suivant:
@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"
}
Compte tenu du succès de la plate-forme Web, les attaquants ont abusé de son principal langage de programmation, à savoir JavaScript, pour monter différents types d'attaques contre leurs victimes. En raison du grand volume de ces scripts malveillants, les systèmes de détection reposent sur des analyses statiques pour traiter rapidement la grande majorité des échantillons. Ces approches statiques ne sont cependant pas infaillibles et conduisent à des classifications erronées. De plus, ils manquent d'informations sémantiques pour aller au-delà des approches purement syntaxiques. Dans cet article, nous proposons JSTAP, un système de détection JavaScript statique modulaire, qui étend la capacité de détection des pipelines lexicaux et AST existants en tirant également parti des informations de contrôle et de flux de données. Notre détecteur est composé de dix modules, dont cinq façons différentes de résumé le code, avec des niveaux de contexte différents et des informations sémantiques, et deux façons d'extraire les caractéristiques. Sur la base de la fréquence de ces modèles spécifiques, nous formons un classificateur de forêt aléatoire pour chaque module.
Dans la pratique, JSTAP surpasse les systèmes existants, que nous avons réimplémentés et testés sur notre ensemble de données totalisant plus de 270 000 échantillons. Pour améliorer la détection, nous combinons également les prédictions de plusieurs modules. Une première couche de vote unanime classe 93% de notre ensemble de données avec une précision de 99,73%, tandis qu'une deuxième couche - sur une combinaison de modules alternatives - élabore 6,5% de notre ensemble de données initial avec une précision de plus de 99%. De cette façon, JSTAP peut être utilisé comme un préfiltre précis, ce qui signifie qu'il ne devrait pas transmettre moins de 1% des échantillons à des analyses supplémentaires. Pour la reproductibilité et la déploiement direct de nos modules, nous mettons notre système accessible au public.
Ce projet est concédé sous licence de la licence AGPL3 que vous pouvez trouver dans LICENSE .
