HideNoSeek
v1.0
Este repositório contém a maior parte do código do nosso artigo do CCS'19: "Hidenoseek: camuflando javascript malicioso em benignos", a saber::
Observe que, em seu estado atual, o código é um POC e não uma API de produção totalmente pronta para produção.
Hidenoseek é um ataque de camuflagem novo e genérico, que altera as construções de amostras de JavaScript maliciosas para reproduzir exatamente uma sintaxe benigna existente. Para esse fim, aprimoramos estaticamente as árvores de sintaxe abstrata (ASTs) de entradas JavaScript válidas com informações de controle e fluxo de dados. Referimos a estrutura de dados resultante como Gráfico de Dependência do Programa (PDG). Em particular, Hidenoseek procura subáfas isomórficas entre os arquivos maliciosos e os benignos. Especificamente, ele substitui sub-sujos benignos por seus equivalentes maliciosos (mesma estrutura sintática) e ajusta as dependências de dados benignas-sem alterar o AST-para que a semântica maliciosa seja mantida.
Por razões éticas, decidimos publicar nem o código completo de nosso módulo de seleção de clone nem nosso módulo de substituição de clone. Portanto, esta versão Hidenoseek pode ser usada para detectar clones sintáticos, mas não para reescrevê -los.
install python3 # (tested with 3.6.7)
install nodejs # (tested with 8.10.0)
install npm # (tested with 3.5.2)
cd src
npm install escodegen # (tested with 1.9.1)
cd ..
Hidenoseek trabalha diretamente no nível do PDG. Para detectar clones entre 2 pastas JavaScript, você deve gerar os PDGs com antecedência (cf. PDGS Generation) e fornecer como entrada para a função src/samples_generation.replace_ast_df_folder .
Para detectar clones entre 2 amostras de JavaScript, você deve fornecer os caminhos dos arquivos diretamente como entrada para a função src/samples_generation.replace_ast .
Para gerar os PDGs dos arquivos JS a partir da pasta Folder_name, inicie o seguinte comando Shell a partir da pasta src Local:
$ python3 -c "from pdgs_generation import store_pdg_folder; store_pdg_folder('FOLDER_NAME')"
Os PDGs correspondentes serão armazenados em pasta_name/pdg.
Para gerar o PDG de um dado o arquivo JS input_file, inicie os seguintes comandos Python3 no local da pasta src :
>>> from pdgs_generation import get_data_flow
>>> pdg = get_data_flow('INPUT_FILE', benchmarks=dict())
Por padrão, o PDG correspondente não será armazenado. Para armazená -lo em uma pasta pdg_path existente, ligue para:
>>> from pdgs_generation import get_data_flow
>>> pdg = get_data_flow('INPUT_FILE', benchmarks=dict(), store_pdgs='PDG_PATH')
Observe que, para esta versão HideNoseek, adicionamos um tempo limite de 60 segundos para o processo de geração PDG (cf. linha 83 de src/pdgs_generation.py ).
Para encontrar clones entre os PDGs benignos da pasta Folder_benign_pdgs e os maliciosos da pasta_malicious_pdgs, inicie o seguinte comando python3 a partir da pasta src Localização:
$ python3 -c "from samples_generation import replace_ast_df_folder; replace_ast_df_folder('FOLDER_BENIGN_PDGS', 'FOLDER_MALICIOUS_PDGS')"
Para cada PDG malicioso, uma pasta PDG_NAME-análise será criada em Folder_Malicious_pdgs. Para cada PDG benigno analisado, ele conterá um arquivo json (formato de nome: benign_malicious.json), que resume os principais achados, como nós idênticos, a proporção de nós idênticos, tokens diferentes, diferentes benchmarks ...
Além disso, exibimos em Stdout o código benigno e malicioso dos clones relatados. Isso pode ser desativado, por exemplo, para multiprocessamento, comentando a chamada print_clones Linha 153 de src/samples_generation.py .
Para encontrar clones entre um arquivo js benigno benigna_js e um malicioso malicioso_js, inicie os seguintes comandos Python3 do local da pasta src :
>>> from samples_generation import replace_ast
>>> replace_ast('BENIGN_JS', 'MALICIOUS_JS')
As saídas, em termos de arquivo JSON e no STDOUT, são como anteriormente.
As funções src/pdgs_generation.store_pdg_folder e src/samples_generation.replace_ast_df_folder são totalmente paralelizadas. Nos dois casos, atualmente estamos usando 1 CPU, mas você pode alterá -lo modificando os Num_workers variáveis do src/utility_df.py . Se você usar mais de 1 CPU, comentará a chamada print_clones Line 153 de src/samples_generation.py .
O example/Benign-example contém example.js example/Malicious-seed/seed.js
Para detectar clones entre esses 2 arquivos, inicie os seguintes comandos Python3 do local da pasta src :
>>> from samples_generation import replace_ast
>>> replace_ast('../example/Benign-example/example.js', '../example/Malicious-seed/seed.js')
Você obterá a seguinte saída no stdout:
INFO:Successfully selected 2 clones in XXXs
==============
[<node.Node object at XXX>, <node.Node object at XXX>]
obj.setAttribute('type', 'application/x-shockwave-flash');
obj = document.createElement('object');
[<node.Node object at XXX>, <node.Node object at XXX>]
wscript.run('cmd.exe /c "<malicious powershell>;"', '0');
wscript = WScript.CreateObject('WScript.Shell');
--
[<node.Node object at XXX>, <node.Node object at XXX>]
obj.setAttribute('tabindex', '-1');
obj = document.createElement('object');
[<node.Node object at XXX>, <node.Node object at XXX>]
wscript.run('cmd.exe /c "<malicious powershell>;"', '0');
wscript = WScript.CreateObject('WScript.Shell');
--
==============
INFO:Could find 100.0% of the malicious nodes in the benign AST
Nossa ferramenta encontrou 2 clones (cada vez composta por 2 declarações). Isso significa que toda a semente maliciosa pode ser reescrita de duas maneiras diferentes no exemplo benigno.
Além disso, foi criado o example/Malicious-seed/seed-analysis/example_seed.json , contendo informações adicionais do clone, foi criado.
Se você usa o Hidenoseek para pesquisas acadêmicas, é altamente encorajado a citar o seguinte artigo:
@inproceedings{fass2019hidenoseek,
author="Fass, Aurore and Backes, Michael and Stock, Ben",
title="{textsc{HideNoSeek}: Camouflaging Malicious JavaScript in Benign ASTs}",
booktitle="ACM CCS",
year="2019"
}
No campo de malware, os sistemas baseados em aprendizado se tornaram populares para detectar novas variantes maliciosas. No entanto, os atacantes com conhecimento específico e interno de um sistema de destino podem produzir amostras de entrada que são classificadas incorretamente. Na prática, a suposição de fortes atacantes não é realista, pois implica acesso a informações privilegiadas. Em vez disso, propomos Hidenoseek, um novo e genérico ataque de camuflagem, que evita toda a classe de detectores com base em recursos sintáticos, sem precisar de informações sobre o sistema que ele está tentando fugir. Nosso ataque consiste em alterar as construções de amostras de JavaScript maliciosas para reproduzir uma sintaxe benigna.
Para esse fim, reescrevemos automaticamente as árvores de sintaxe abstrata (ASTs) de entradas de javascript maliciosas nos benignos existentes. Em particular, Hidenoseek usa sementes maliciosas e procura subgrafos isomórficos entre as sementes e os scripts benignos tradicionais. Especificamente, ele substitui sub-sufos benignos por seus equivalentes maliciosos (mesma estrutura sintática) e ajusta as dependências de dados benignas-sem alterar a AST-, para que a semântica maliciosa seja mantida. Na prática, aproveitamos 23 sementes maliciosas para gerar 91.020 scripts maliciosos, o que reproduzem perfeitamente o ASTS das 10.000 páginas da Web do Alexa. Além disso, podemos produzir em média 14 amostras maliciosas diferentes com o mesmo AST que cada Alexa Top 10.
No geral, um classificador treinado padrão possui 99,98% de falsos negativos com entradas Hidenoseek, enquanto um classificador treinado em tais amostras tem mais de 88,74% de falsos positivos, tornando os detectores estáticos alvo não confiáveis.
Este projeto está licenciado nos termos da licença AGPL3, que você pode encontrar na LICENSE .
