JStap
v1.1
Este repositório contém o código para o artigo ACSAC'19: "JStap: um pré-filtro estático para detecção de javascript maliciosa".
Observe que, em seu estado atual, o código é um POC e não uma API de produção totalmente pronta para produção.
O JSTAP é um sistema de detecção de javascript malicioso estático modular. Nosso detector é composto por dez módulos, incluindo cinco maneiras diferentes de abstrair o código (a saber, tokens, árvore de sintaxe abstrata (AST), gráfico de fluxo de controle (CFG), gráfico de dependência do programa considerando o fluxo de dados apenas (PDG-DFG) e PDG) e duas maneiras de extrair recursos (alavancagem N-Grams, ou identificadores). Com base na frequência desses padrões específicos, treinamos um classificador de floresta aleatório 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 análises AST, CFG, PDG-DFG e PDG, você deve gerar os PDGs dos arquivos considerados separadamente e antecipadamente. Depois disso, forneça a (s) pasta (s) contendo os PDGs como entrada para o aluno ou classificador (no caso de uma análise baseada em AST, por exemplo, usamos apenas as informações AST contidas no PDG). Pelo contrário, para a abordagem baseada em token, você deve fornecer diretamente a pasta que contém os arquivos JS como entrada para o aluno/classificador.
Para gerar os PDGs dos arquivos JS (.js) a partir da pasta Folder_name, inicie o seguinte comando shell a partir da pasta pdg_generation Localização:
$ python3 -c "from pdgs_generation import *; store_pdg_folder('FOLDER_NAME')"
Os PDGs correspondentes serão armazenados em pasta_name/análise/pdg.
Atualmente, estamos usando 2 CPUs para o processo de geração PDGS; Isso pode ser alterado modificando a variável num_workers de pdg_generation/utility_df.py.
Para construir um modelo a partir das pastas benignas e maliciosas, contendo arquivos JS (para a análise baseada em token) ou os PDGs (para as outras análises), use a opção-D Benigna maliciosa e adicione sua verdade correspondente à verdade com-L Benigna maliciosa.
Selecione os recursos que aparecem no conjunto de treinamento com o Chi2 em 2 conjuntos de dados independentes:-Valigno benigno-validado benigno com sua verdade correspondente à verdade-VL benigno malicioso.
Indique seu nível de análise com-LEVEL seguido por 'tokens', 'ast', 'cfg', 'pdg-dfg' ou 'pdg'.
Indique os recursos que a análise deve usar com -Rometas seguidas por 'ngrams', 'valor'. Você pode escolher onde armazenar os recursos selecionados pelo CHI2 com --analysis_path (JSTAP/análise padrão).
Você pode escolher o nome do modelo com -mn (padrão de ser 'modelo') e seu diretório com - -md (JStap/análise padrão).
$ python3 learner.py --d BENIGN/ MALICIOUS/ --l benign malicious --vd BENIGN-VALIDATE/ MALICIOUS-VALIDATE/ --vl benign malicious --level LEVEL --features FEATURES --mn FEATURES_LEVEL
O processo é semelhante para o processo de classificação.
Para classificar as amostras JS das pastas benigna2 e maliciosas2, use a opção -D benigna2 maliciosa2. Para carregar um modelo existente Recursos_level a ser usado para o processo de classificação, use a opção - -m características_level. Mantenha o mesmo nível de análise e recursos do treinamento do classificador:
$ python3 classifier.py --d BENIGN2/ MALICIOUS2/ --level LEVEL --features FEATURES --m FEATURES_LEVEL
Se você souber a verdade fundamental das amostras que classificar e gostaria de avaliar a precisão do seu classificador, use a opção - -l com a verdade correspondente da verdade:
$ python3 classifier.py --d BENIGN2 MALICIOUS2 --l benign malicious --level LEVEL --features FEATURES --m FEATURES_LEVEL
Atualmente, estamos usando 2 CPUs para os processos de aprendizado e classificação; Isso pode ser alterado modificando a variável num_workers de classificação/utility.py.
Para gerar as representações gráficas das AST (SAVE_PATH_AST), CFG (SAVE_PATH_CFG) e/ou PDG (SAVE_PATH_PDG) de um dado o arquivo JS Input_file, aproveitamos a biblioteca GraphViz.
Para instalar o GraphViz:
pip3 install graphviz
On MacOS: install brew and then brew install graphviz
On Linux: install graphviz
Inicie os seguintes comandos do Python3 da localização da pasta pdg_generation e indique o nome sob o qual armazenar os 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, o GraphViz pode causar um erro quando os gráficos estão se tornando muito grandes.
Para apenas exibir os gráficos sem armazená -los, use o valor 'nenhum'. Caso contrário e por padrão, o valor é falso.
Nota: Por padrão, o PDG correspondente não será armazenado. Para armazená -lo em uma pasta pdg_path existente, adicione o parâmetro store_pdgs='PDG_PATH' ao comando anterior.
Se você usar o JSTAP para pesquisa acadêmica, é altamente encorajado a citar o seguinte artigo:
@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 o sucesso da plataforma da web, os atacantes abusaram de sua principal linguagem de programação, a saber, JavaScript, para montar diferentes tipos de ataques às suas vítimas. Devido ao grande volume desses scripts maliciosos, os sistemas de detecção dependem de análises estáticas para processar rapidamente a grande maioria das amostras. Essas abordagens estáticas não são infalíveis e levam a classificações incorretas. Além disso, eles não têm informações semânticas para ir além das abordagens puramente sintáticas. Neste artigo, propomos o JSTAP, um sistema modular de detecção de JavaScript estático, que estende a capacidade de detecção dos pipelines lexicais e baseados em AST existentes, também alavancando as informações de controle e fluxo de dados. Nosso detector é composto por dez módulos, incluindo cinco maneiras diferentes de abstrair código, com diferentes níveis de contexto e informações semânticas e duas maneiras de extrair recursos. Com base na frequência desses padrões específicos, treinamos um classificador de floresta aleatório para cada módulo.
Na prática, o JStap supera os sistemas existentes, que reimpletamos e testamos em nosso conjunto de dados, totalizando mais de 270.000 amostras. Para melhorar a detecção, também combinamos as previsões de vários módulos. Uma primeira camada de votação unânime classifica 93% do nosso conjunto de dados com uma precisão de 99,73%, enquanto uma segunda camada-baseada em uma combinação de módulos alternativos-seleciona outros 6,5% do nosso conjunto de dados inicial com precisão acima de 99%. Dessa forma, o JSTAP pode ser usado como um pré-filtro preciso, o que significa que só precisaria encaminhar menos de 1% das amostras para análises adicionais. Para reprodutibilidade e implantabilidade direta de nossos módulos, disponibilizamos nosso sistema publicamente.
Este projeto está licenciado sob os termos da licença AGPL3 que você pode encontrar na LICENSE .
