Detecção de malware usando Deep Learning

Detecção de malware usando redes neurais convolucionais em fast.ai

RIA KULSHRESTHA em Rumo à Ciência dos Dados Seguir Jul 1 · 6 min ler Foto de Markus Spiske em Unsplash

O que é Malware?

Malware refere-se ao despacho de criminosos de software mal-intencionado para infectar computadores individuais ou a rede de toda a organização. Ele explora as vulnerabilidades do sistema alvo, como um bug em um software legítimo (por exemplo, um navegador ou plug-in de aplicativo da Web) que pode ser seqüestrado.

Uma infiltração de malware pode ser desastrosa – as conseqüências incluem roubo de dados, extorsão ou paralisação de sistemas de rede.

Por que é importante detectar o Malware?

O malware é uma das ameaças de segurança mais graves da Internet atualmente. De fato, a maioria dos problemas da Internet, como e-mails de spam e ataques de negação de serviço, tem o malware como causa subjacente. Ou seja, os computadores que estão comprometidos com malwares geralmente estão em rede para formar botnets, e muitos ataques são lançados usando essas redes mal-intencionadas controladas por invasores.

A fim de lidar com o novo malware gerado, novas técnicas para detectá-los e evitar qualquer dano causado por eles.

Por que Aprendizado Profundo?

Hoje em dia, o aprendizado profundo dominou as várias tarefas de visão computacional. Não apenas essas técnicas de aprendizado profundo permitiram um rápido progresso nessa competição, mas até superaram o desempenho humano em muitas delas. Uma dessas tarefas é a classificação de imagem.

Ao contrário dos métodos mais tradicionais de técnicas de aprendizado de máquina, os classificadores de aprendizado profundo são treinados por meio do aprendizado de recursos, em vez de algoritmos específicos da tarefa. Isso significa que a máquina aprenderá padrões nas imagens apresentadas, em vez de exigir que o operador humano defina os padrões que a máquina deve procurar na imagem. Em resumo, ele pode extrair recursos automaticamente e classificar dados em várias classes.

As camadas iniciais aprendem como detectar recursos de baixo nível, como bordas, e as camadas subsequentes combinam recursos de camadas anteriores em uma representação mais holística e completa.

Podemos transformar um arquivo maligno / benigno em uma imagem em escala de cinza usando o método descrito posteriormente. Então, podemos aplicar essas técnicas de aprendizado profundo nas imagens geradas para classificá-las como malware ou benignas.

Como criar imagens de malware?

Para classificar imagens usando um modelo de aprendizagem profunda, precisaremos de imagens de arquivos benignos e de malware. Nós só faremos uma classificação binária (malware e classe benigna). A classificação multiclasses também pode ser feita usando essa técnica, com a ideia de que uma variante de arquivos de malware terá imagens diferentes das outras.

Quando tivermos nosso conjunto de dados pronto, converteremos cada arquivo em uma imagem de escala de cinza 256×256 (cada pixel tem um valor entre 0 e 255) seguindo as etapas abaixo para cada imagem:

 Passo 1: Leia 8 bits de cada vez no arquivo. 
Etapa 2: trate os 8 bits como um número binário e converta-os em seu inteiro correspondente.
Etapa 3: insira o número como o valor do pixel.

Um arquivo de tamanho máximo de 64 KB pode ajustar uma imagem de 256 x 256. Qualquer arquivo com tamanho maior que 64 KB, o conteúdo restante será descartado.
Por outro lado, se o tamanho de um arquivo for menor que 64 KB, a imagem restante será preenchida com 0s.

Como a detecção de malware é feita em tempo real, precisamos classificar uma imagem como benigna ou malware em segundos. Portanto, manter o processo de geração de imagem simples e curto nos ajudará a economizar tempo valioso.

Preparação do conjunto de dados

Este passo é extremamente simples. Uma vez geradas todas as imagens, separe-as em duas pastas – treino e validação. Cada uma dessas pastas conterá duas pastas, ou seja, Malware e Benign.
Armazene essas duas pastas em outra pasta chamada “dataset.tar” e compacte-a para gerar um arquivo .tar.

Então a estrutura final do diretório será ?
dataset.tar contém validação e trem. Validação terá pastas Malware e Benign. O trem terá pastas Malware e Benign.

Mova a pasta compactada no mesmo diretório que o notebook Jupyter que contém o código.

Implementando o modelo

** O modelo usado para este problema é criado seguindo a lição 1 do curso fast.ai (classificação Pet). **

Para ler o conjunto de dados do seu Google Drive, adicione as seguintes linhas de código

 ! pip instale o PyDrive # import os 
de pydrive.auth importar GoogleAuth
de pydrive.drive import GoogleDrive
da autenticação de importação do google.colab
de oauth2client.client import GoogleCredentials
auth.authenticate_user ()
gauth = GoogleAuth ()
gauth.credentials = GoogleCredentials.get_application_default ()
drive = GoogleDrive (gauth)

Depois de executar as últimas quatro linhas do código mencionado acima, o Google SDK solicitará que você insira um código de verificação. Ele mencionará um link, assim que você clicar nele, receberá o seu código de segurança.

 link = '1sL4I4xNh657AhrIOOwbr6TX58ahyC' (adicione o link aqui) 

Crie uma variável que contenha o link para o arquivo .tar contendo os dados armazenados em seu Google Drive.
Para obter a URL, abra o arquivo .tar na sua unidade e obtenha o link compartilhável para o arquivo. Você não precisa do URL inteiro apenas uma parte dele. Assim, por exemplo, se o seu link compartilhável é “https://drive.google.com/File/d/ 1sL4I4xNh657AhrIOOwbr6TX58ahyC / ver? Usp = Sharing”
você só precisa da parte que está em negrito.

Obtendo caminhos para os dados

 baixado = drive.CreateFile ({'id': link}) 
downloaded.GetContentFile ('dataset.tar')
import tarfile
tar = tarfile.open ("dataset.tar")
caminho = tar.extractall ('DS /')
tar.close ()
caminho = Path.cwd (). joinpath ("DS / conjunto de dados /")
path.ls ()
data = ImageDataBunch.from_folder (caminho, ds_tfms = get_transforms (), tamanho = 224) ## Para exibir dados em um lote
data.show_batch (linhas = 3, figsize = (7,6))
## Para saber o número de classes em um conjunto de dados
imprimir (data.c)
## Para saber os nomes das classes em um conjunto de dados
print (data.classes)

Criando o modelo

 learn = create_cnn (dados, model.resnet34, metrics = error_rate) ## Para conhecer a arquitetura do modelo 
learn.model
## Treinando o modelo
learn.fit_one_cycle (4)
learn.fit_one_cycle (10)

Aqui está uma captura de tela da saída que recebi depois de executar o código acima:

Saída para 4 e 10 épocas.

 interp = ClassificationInterpretation.from_learner (aprender) 
perdas, idxs = interp.top_losses ()
interp.plot_top_losses (9, figsize = (9,6))

As imagens com perdas máximas.

Como encontrar e definir uma boa taxa de aprendizado?

Até agora, não dissemos ao nosso modelo que taxa de aprendizado usar durante o treinamento do modelo, o que todos sabemos é um dos parâmetros mais importantes do hiper-parâmetro durante o treinamento.
Para encontrar uma boa taxa de aprendizado, faça o seguinte:

 learn.lr_find () 
learn.recorder.plot ()

Encontrar uma taxa de aprendizado ideal.

 learn.fit_one_cycle (5, max_lr = slice (1e-6,1e-4)) ## Salvando os pesos do modelo 
learn.save ('stage-1-malware-detection')

As perdas são muito menores em comparação com antes.

Nota: Toda vez que você chamar a função fit_one_cycle (), os pesos não serão reinicializados. Então, se você chamar a função uma após a outra, as épocas se somam, ou seja, se você chamar fit_one_cycle (5) seguido de fit_one_cycle (10), o modelo foi treinado por aproximadamente 15 épocas.

O código completo pode ser encontrado na minha conta do GitHub, que está vinculada aqui . Estes são apenas alguns trechos do código e apenas segui-los não dará um código viável.

Por favor, sinta-se à vontade para buscar sugestões / melhorias / discussões sobre o mesmo. : D