TeseDoutoradoSantana Abntime Final Impressao-Assinado

MINISTÉRIO DA DEFESA
EXÉRCITO BRASILEIRO
DEPARTAMENTO DE CIÊNCIA E TECNOLOGIA
INSTITUTO MILITAR DE ENGENHARIA
PROGRAMA DE PÓS-GRADUAÇÃO EM ENGENHARIA DE DEFESA
RICARDO SANT’ANA
EXPLICABILIDADE EM ARQUITETURAS DE APRENDIZADO PROFUNDO

PARA ANÁLISE DE MALWARE
RIO DE JANEIRO
2020
RICARDO SANT’ANA
EXPLICABILIDADE EM ARQUITETURAS DE APRENDIZADO PROFUNDO

PARA ANÁLISE DE MALWARE
Tese apresentada ao Programa de Pós-graduação em Enge-

nharia de defesa do Instituto Militar de Engenharia, como
requisito parcial para a obtenção do título de Doutor em
Ciências em Engenharia de defesa.
Orientador(es): Julio Cesar Duarte, D.Sc..
Ronaldo Ribeiro Goldschmidt, D.Sc.
Rio de Janeiro
2020
©2020
INSTITUTO MILITAR DE ENGENHARIA
Praça General Tibúrcio, 80 – Praia Vermelha
Rio de Janeiro – RJ CEP: 22290-270
Este exemplar é de propriedade do Instituto Militar de Engenharia, que poderá incluí-lo em base
de dados, armazenar em computador, microfilmar ou adotar qualquer forma de arquivamento.
É permitida a menção, reprodução parcial ou integral e a transmissão entre bibliotecas deste
trabalho, sem modificação de seu texto, em qualquer meio que esteja ou venha a ser fixado,
para pesquisa acadêmica, comentários e citações, desde que sem finalidade comercial e que
seja feita a referência bibliográfica completa.
Os conceitos expressos neste trabalho são de responsabilidade do(s) autor(es) e do(s) orienta-
dor(es).
Sant’Ana, Ricardo.
Explicabilidade em Arquiteturas de Aprendizado Profundo para Análise de
Malware / Ricardo Sant’Ana. – Rio de Janeiro, 2020.
208 f.
Orientador(es): Julio Cesar Duarte e Ronaldo Ribeiro Goldschmidt.
Tese (doutorado) – Instituto Militar de Engenharia, Engenharia de defesa, 2020.
1. malware. aprendizado profundo. 2. explicabilidade. 3. análise de malware.

i. Duarte, Julio Cesar (orient.) ii. Goldschmidt, Ronaldo Ribeiro (orient.) iii.
Título
012304563789373

33
3 !
"#$#%&'#$#()%*%%+,'+-'%.%*#,/$0-'%*1%23+#.4(-#(5%'6%*#*#7#$%*+8($)6)1)+
96:6)%'*#4(-#(5%'6%;<+.+'#=16$6)+&%'<6%:&%'%%+>)#(23+*+)?)1:+*#@+1)+'#.
A6B(<6%$#.4(-#(5%'6%*#*#7#$%C
D'6#()%*+'E#$FGH1:6+A#$%'@1%')##I+(%:*+I6>#6'+J+:*$<5.6*)C
K&'+L%*+#.I6+*#H%(#6'+;MN*#*#O#.>'+*#PQPQ;&#:%$#-16()#>%(<%#R%.6(%*+'%G
,'+7CSTUVWXTSYZ[Y\T]TWX^_`aYXb0@Cc<C*+8940,'#$6*#()#
,'+7CdeWYTf[^V\geV\b[0@Cc<C*+894
,'+7ChVeWTi[\UVUXTi[\\[Y\VST^V0,5C@C*+894
,'+7CjVb`[e^hYU`[Y\Ti[\\[Y\V0@Cc<C*+894
,'+7CkXeV\XTl[m[\\VXVnYWoV0@Cc<C*+A4p4"
,'+7C][\VWXTlTUT\YUTq[rsT0@Cc<C*%tpIH
I6+*#H%(#6'+
PQPQ
Este trabalho é dedicado às crianças adultas que,
quando pequenas, sonharam em se tornar cientistas.
AGRADECIMENTOS
Inicialmente, gostaria de agradecer aos meus pais, principalmente pela educação e

valores que me foram ensinados. Também gostaria de agradecer ao meu irmão, que sempre
teve o papel de "irmão mais velho"e com quem sempre eu pude contar.
Agradeço também à minha esposa, Eliana, pela paciência e compreensão nestes 3
anos de curso. Foi confortante ter uma parceira com quem posso contar - inclusive para
ouvir sobre os aspectos técnicos do doutorado.
Agradeço aos meus orientadores, TC Duarte por todas orientações e paciência
durante o curso. As orientações foram fundamentais para eu saber que caminhava na
direção certa. Agradeço também ao professor Ronaldo que, em diversos momentos chave,
contribuiu para melhoria da tese.
Agradeço aos demais professores, funcionários e ao Chefe do PGED do Instituto
Militar de Engenharia, pelos ensinamentos e esclarecimentos.
Um agradecimento especial ao Chefe da Computação e amigo de turma TC Ander-
son que, por diversas vezes, empenhou-se em disponibilizar recursos e ambiente para o
desenvolvimento dos trabalhos relacionados à tese.
Por fim, agradeço ao Exército Brasileiro, pela oportunidade de realização do curso
de Doutorado.
“Você não é derrotado quando perde, mais sim quando você desiste.
(Vegeta, DBZ)
RESUMO
A utilização de aprendizado profundo em análise de malware vem crescendo ultimamente

com a disponibilidade, cada vez mais, de bases de dados de forma pública. No entanto,
mesmo com diversos trabalhos relacionados ao aprendizado profundo, o foco usualmente
é o de otimizar uma métrica de desempenho. Dessa forma, tal abordagem é incompleta
quando se deseja compreender o que leva um algoritmo de aprendizado profundo a produzir
uma determinada saída.
Com relação aos trabalhos de aplicação de aprendizado profundo na área de análise de

malware, algumas lacunas foram identificadas, tais como: poucas bases de dados publica-
mente disponíveis na forma de binário executável; pouca informação ou documentação
sobre os hiperparâmetros das arquiteturas utilizadas; falta de aprofundamento sobre a
correta rotulagem das amostras, problema este conhecido e pouco tratado; os resultados
de algoritmos de explicabilidade aplicados ao aprendizado profundo sofrem por causa
da distorção causada pelo redimensionamento das imagens de artefatos; falta de um
algoritmo que permita que a importância seja avaliada somente em uma região do artefato,
permitindo melhor aproveitamento do processamento.
O presente trabalho, então, busca, como diferencial, não somente definir arquiteturas,
baseadas em aprendizado profundo, claras e documentadas para análise de malware como
tratar as diversas lacunas encontradas e avaliar os resultados obtidos.
Assim, três propostas são apresentadas: um método para propor candidatos a verificação
de rótulo da base de dados de artefatos maliciosos; uma nova representação que atenue os
efeitos da distorção de representação e, finalmente, um algoritmo denominado Algoritmo
de Importância por Pixel que permite que o analista escolha apenas parte do artefato
malicioso para produzir resultados de explicabilidade.
O método de candidatos a verificação de rótulos obteve resultados de f1-score de 35,55%

para arquitetura Lenet-5 Normal e um f1-score de 46,95% para arquitetura VGG16
non_top. Como os resultados foram considerados abaixo do esperado, considerou-se que o
algoritmo atinge parcialmente ao objetivo proposto.
A nova representação foi avaliada considerando dois aspectos: o desempenho de arquitetura

de rede profunda e a capacidade de gerar assinaturas de forma automatizada. A representa-
ção proposta obtém resultado superior de desempenho quando comparada à representação
tradicional: 93,66% contra 92,51% para a arquitetura Lenet-5 Normal, 94,44% contra
94,27% para a arquitetura Resnet tiny, 94,58% contra 93,96% para a arquitetura VGG16
non_top e 94,18% contra 93,92% para a arquitetura VGG19 non_top. Para a geração de
assinaturas, a representação proposta obteve resultado superior de f1-score para, como
por exemplo, para arquitetura VGG16 non_top, as duas melhores assinaturas produzidas
com a representação proposta obtiveram f1-score de 55,55% e 44,39% contra 36,14% e
29,28% quando se utilizou a representação tradicional.
A aplicação do Algoritmo de Importância por Pixel em regiões do artefato onde a semântica

é mais simples de ser interpretada, como por exemplo a região do cabeçalho, produziu
resultados interessantes e inesperados: a informação da quantidade de APIs importadas
por um artefato foi utilizada para classificá-lo em uma determinada família.
Assim, os resultados experimentais da abordagem das propostas demonstram que as

lacunas identificadas foram parcialmente ou completamente resolvidas.
Palavras-chave: malware. aprendizado profundo. explicabilidade. análise de malware.

ABSTRACT
The use of deep learning in malware analysis has been increasing lately with the growing
availability of public datasets. However, even with several works related to deep learning,
the focus is usually on optimizing a performance metric. Thus, such an approach is
incomplete when we want to understand what drives a deep learning algorithm to produce
a given output.
Considering the researches which applies deep learning on malware analysis, some gaps were
identified, such as: just a few malware databases are public available as raw data (binaries);
there are almost none or few information or documentation about hyperparameters
values which were used in deep learning architectures; there is a lack of researches on
the correctness of the labels, which is a known problem; the results of the explanability
algorithms applied to deep learning suffer from the distortion caused by the images’ resizing;
the lack of an explcability algorithm that allows the evaluation of the importance in a
desired area which would allow a better use of the processing power.
This research, therefore, seeks not only to define malware analysis architectures, based
on deep larning, but also to treat the various gaps found while evaluating the obtained
results.
Thus, three proposals will be presented, they are: a method to yield candidates from a
malware database for label checking; a new image representation that mitigates the effects
of representation distortion and, finally, an algorithm, called Pixel Importance Algorithm
that allows the analyst to select a desired area for explicability results.
The method which yields candidates for label verification obtained f1-score of 35.55% for
Lenet-5 Normal architecture and a f1-score of 46.95% for VGG16 non _top architecture .
Since the results were considered below the expected, it was considered that the algorithm
partially achieves the proposed objective.
The new representation was evaluated considering two aspects: the classification per-
formance of deep neural network architectures and the ability to generate automatic
signatures. The proposed representation achieves superior performance when compared to
the traditional representation: 93,66% against 92,51% when considering Lenet-5 Normal
architecture, 94,44% against 94,27% when considering Resnet tiny architecture, 94,58%
against 93,96% when considering VGG16 non_top architecture and 94,18% against 93,92%
when considering VGG19 non_top architecture.
When considering signatures’ generation , the proposed representation obtained better

f1-score: for instance, when considering VGG16 non _top architecture , the two best
signatures produced using the proposed representation obtained f1-score equals to 55.55%
and 44.39% against 36.14% and 29.28% when proposed representation was used.
The application of the Algoritmo de Importância por Pixel in regions of the artifact
where the semantics are simpler to interpret, such as the header, produced interesting and
unexpected results: the information of the amount of APIs imported by an artifact was
used to classify it in a particular family.
So, the proposal experimental results show that the identified gaps have been partially or
completely solved.
Keywords: malware. deep learning. explicability. malware analysis.

LISTA DE ILUSTRAÇÕES
Figura 1 – Número de novas espécies de malware. Baseado em dados apresentados em AVtest(1). 24

Figura 2 – Evolução dos malware tradicionais. . . . . . . . . . . . . . . . . . . . . 25
Figura 3 – Taxa de Erro obtida no desafio anual do ImageNet((2)) . . . . . . . . . 28
Figura 4 – Relação entre Objetivo Geral, Específicos e lacunas . . . . . . . . . . . 33
Figura 5 – Estrutura do Texto da Tese . . . . . . . . . . . . . . . . . . . . . . . . 36
Figura 6 – Código Binário Original localizado à esquerda e código empacotado
localizado à direita. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Figura 7 – Código empacotado (a esquerda) sendo desempacotado e gerando o
binário da esquerda. Note que o binário gerado é diferente do original
da Fig 6. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Figura 8 – Etapas de Análise de Malware na forma de um Ciclo. . . . . . . . . . . 43
Figura 9 – Exemplo de uma função em Assembly que utiliza a API WriteFile. . . . 45
Figura 10 – Fases de um Projeto de Aprendizado de Máquina. . . . . . . . . . . . . 50
Figura 11 – Visão Geral Treinamento, Validação e Teste de um modelo de aprendi-
zado de máquina. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Figura 12 – Hierarquia do Aprendizado profundo frente a outros conceitos da área.
Fonte: Goodfellow et al.(3). . . . . . . . . . . . . . . . . . . . . . . . . 52
Figura 13 – Exemplo de uma arquitetura de camadas que transforma uma imagem
de entrada em uma saída (número 4). Fonte: (4). . . . . . . . . . . . . 53
Figura 14 – Exemplo da representações em cada camada. Fonte: (4). . . . . . . . . 53
Figura 15 – Rede Neural Completamente Conectada. Figura baseada em http://cs231n.github.io/convo
networks/. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Figura 16 – Função de ativação sigmóide (esquerda) e tanh (direita) . . . . . . . . 55
Figura 17 – Função de ativação ReLU. . . . . . . . . . . . . . . . . . . . . . . . . . 56
Figura 18 – Processo Geral do Aprendizado de Máquina e do Aprendizado Profundo 57
Figura 19 – Exemplo de Imagem de Entrada RGB (3 canais) com 4 pixeis de largura
e 4 pixeis de altura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Figura 20 – Exemplo de Operação de Convolução onde um filtro K (azul) de tama-
nho 3x3 é aplicado em uma região da imagem I de um único canal e
produzindo I ∗ K . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Figura 21 – Aplicação de 2 Filtros de tamanho 3x3x3 em uma imagem de tamanho
6x6x3. O resultado possui dimensão 4x4x2. . . . . . . . . . . . . . . . . 59
Figura 22 – Exemplo de aplicação de Padding de valor 1 em uma imagem de tamanho
4x4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Figura 23 – Exemplo de aplicação de Max Pooling (a) e Average Pooling onde o
filtro tem tamanho 2x2 e o stride é 2. . . . . . . . . . . . . . . . . . . . 60
Figura 24 – Exemplo da aplicação de Pooling com Average Pooling, Max Pooling e
Min Pooling em uma imagem. . . . . . . . . . . . . . . . . . . . . . . . 61
Figura 25 – Exemplo de achatamento realizado entre a camada de engenharia de
atributos e a camada de classificação. Figura baseada em Ng et al.(5). . 61
Figura 26 – Exemplo de uma arquitetura de uma rede neural convolucional. A
quantidade de filtros ilustrada na figura é apenas simbólica. Referência
(6). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Figura 27 – Exemplo de Dropout aplicado a uma rede neural completamente conectada 63
Figura 28 – Dropout aplicado durante predição de uma Rede neural completamente
conectada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Figura 29 – Exemplo Global Average Pooling. Fonte (7) . . . . . . . . . . . . . . . . 68
Figura 30 – Exemplo aprendizado por transferência onde o aprendizado das camadas
convolucionais de (a) é aproveitado na arquitetura (b). . . . . . . . . . 69
Figura 31 – Framework para detecção de malware. Adaptado de Han et al.(8). . . . 72
Figura 32 – Visão geral do formato PE. Fonte: (9). . . . . . . . . . . . . . . . . . . 74
Figura 33 – Exemplo de Extração de Atributos. . . . . . . . . . . . . . . . . . . . 76
Figura 34 – Extrato de código assembly. . . . . . . . . . . . . . . . . . . . . . . . . 77
Figura 35 – Processo de codificação de mnemônicos produzindo um vetor de mnemô-
nicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Figura 36 – Sequência de bytes para imagem. . . . . . . . . . . . . . . . . . . . . . 79
Figura 37 – Representação do artefato VirusShare_48da6cdcdd791cf9759339506d1f1442
em escala de cinza. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Figura 38 – Representação de Imagem de 4 artefatos maliciosos. 2 da classe Bifrose
e 2 da classe Vundo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Figura 39 – Exemplo de variação semântica em que o byte 64h possui diversas
semânticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Figura 40 – Histogramas para tamanhos de arquivo para classe Bifrose e para Classe
Cycbot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Figura 41 – Representação de Imagen de 32x32 de 4 artefatos maliciosos. 2 da classe
Bifrose e 2 da classe Vundo. . . . . . . . . . . . . . . . . . . . . . . . . 83
Figura 42 – Sumário de Atributos para FIFA 2018 Statistics utilizando o método de
(a) Importância de Atributos e (b) com o método Partial Dependence
Plot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Figura 43 – Visualização de Filtros da arquitetura baseada em redes convolucionais
VGG16 treinada para o Imagenet. . . . . . . . . . . . . . . . . . . . . . 88
Figura 44 – Visualização de mapas de atributos da camada block1_conv1 da arqui-
tetura VGG16. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Figura 45 – Visualização dos pontos de dados destacados para as detecções de
cachorro (b) e gato (c). . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Figura 46 – Exemplo da criação de um modelo substituto intrinsecamente interpre-
tável a partir de um modelo mais complexo. . . . . . . . . . . . . . . . 89
Figura 47 – Resumo dos tipos de explicabilidade apresentados nesta tese. . . . . . 90
Figura 48 – Troca entre explicabilidade (interpretability) acurácia (accuracy). . . . 91
Figura 49 – Exemplo de mapa de calor de uma amostra de malware para dois
modelos com mesma arquitetura. . . . . . . . . . . . . . . . . . . . . . 92
Figura 50 – Estimativa da importância do atributo k a partir dos erros de predição
da matriz X e da matriz com o atributo permutado Xk . . . . . . . . . 93
Figura 51 – Entrada de dados X, como a imagem de um cachorro OU um gato,
produzindo uma matriz de atributos F aprendidos. . . . . . . . . . . . 95
Figura 52 – Matriz FXtrain aprendidos de um modelo sofre redução de dimensionali-
dade permitindo a visualização espacial de cada classe. . . . . . . . . . 96
Figura 53 – Exemplo de Arquitetura GAP-CNN para classificação de artefato mali-
cioso. Baseado em (10). . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Figura 54 – Exemplo do Class Activation Map pra classificação de artefato malicioso.
Baseado em (10). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Figura 55 – Exemplo do Class Activation Map. Fonte (10). . . . . . . . . . . . . . . 98
Figura 56 – Exemplo do Gradiant-Weighted Class Activation Map. Fonte (11). . . . 99
Figura 57 – Número de publicações na área de aprendizado profundo para Science
Direct e IEEE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Figura 58 – Visão Geral do Escopo deste Trabalho . . . . . . . . . . . . . . . . . . 113
Figura 59 – Obtenção da matriz de atributos FXtrain de uma entrada Xtrain . . . . . 117
Figura 60 – Exemplo ilustrativo da Proposta P1 para Amostra 56. . . . . . . . . . 118
Figura 61 – Exemplo ilustrativo da Proposta P1 para Amostra 582. . . . . . . . . . 119
Figura 62 – Arquitetura Lenet − 5 Normal destacando a quantidade de camadas
convolucionais e quantidade de camadas completamente conectadas. . . 119
Figura 63 – Visão geral do processo de obtenção do mapa de calor por meio do
Grad-Cam para artefatos maliciosos. Em (1) tem-se o artefato sendo
representado como uma imagem de tamanho 256×299. Em (2) a imagem
é redimensionada para 224 × 224. Em (3) a amostra é aplicada a uma
RNC treinada produzindo um resultado (4). Além disso, por meio de um
algoritmo de explicabilidade é obtido o mapa de calor (5) de tamanho
224 × 224. Finalmente em (6) o mapa de calor é redimensionado para
256 × 299. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Figura 64 – Efeito da Distorção da Representação no resultado da explicabilidade.
Em (a) tem-se a imagem original de tamanho 299 × 256. Em (b) tem-se
a imagem redimensionada para o tamanho 224 × 224. Em (c) tem-se
o mapa de calor obtido, de tamanho 224 × 224. Finalmente em (d),
tem-se o mapa de calor redimensionado para o tamanho 299 × 256. . . 121
Figura 65 – A Figura apresenta o efeito da distorção em um artefato da família
Trojan:Win32/Koutodoor. . . . . . . . . . . . . . . . . . . . . . . . . . 122
método proposto. Em (a) tem-se a imagem original de tamanho 64×2626.
Em (b) tem-se a imagem redimensionada para o tamanho 224 × 224. Em
(c) tem-se o mapa de calor obtido, de tamanho 224 × 224. Finalmente
em (d), tem-se o mapa de calor redimensionado para o tamanho 64 × 2626.122
Figura 67 – A Figura ilustra uma visão geral do processo de obtenção da feature
importance em análise de malware. . . . . . . . . . . . . . . . . . . . . 123
Figura 68 – Visualização do mapa de importância para famílias (a) Vundo, (b)
Cycbot e (c) Zwangi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Figura 69 – Efeito da distorção de representação no método de Importância de
atributos por permutação para artefatos maliciosos da família Zwangi. 125
Figura 71 – Divisão de conjunto de dados VirusShareSant. . . . . . . . . . . . . . . 128
Figura 72 – Exemplo de sobreajuste para arquiteturas Normal e Small. . . . . . . . 130
Figura 73 – Arquiteturas VGG16 non-top, VGG19 non-top e Renet tiny sem sobre-
ajuste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Figura 74 – Valor f1-score em função do valor ω selecionado para o modelo Lenet−5
Normal para amostras com erro de predição. . . . . . . . . . . . . . . . 136
Figura 75 – Valor f1-score em função do valor ω selecionado para o modelo Lenet−5
Normal para amostras com acerto de predição. . . . . . . . . . . . . . 137
Figura 76 – Valor f1-score em função do valor ω selecionado para o modelo V GG16
non_top para amostras com erro de predição. . . . . . . . . . . . . . . 137
non_top para amostras com acerto de predição. . . . . . . . . . . . . . 138
Figura 78 – Amostra de Artefato da Família Trojan:Win32/Vundo. . . . . . . . . . 141
Figura 79 – Mapa de Calor para modelo Lenet-5 Normal. . . . . . . . . . . . . . . 142
Figura 80 – Mapa de Calor para modelo Resnet tiny. . . . . . . . . . . . . . . . . 142
Figura 81 – Mapa de Calor para modelo VGG16 non_top. . . . . . . . . . . . . . 143
Figura 84 – Mapa de Calor do modelo Lenet-5 Normal para... . . . . . . . . . . . . 145
Figura 88 – Mapa de Calor do modelo Lenet-5 Normal para ... . . . . . . . . . . . 149
Figura 89 – Mapa de Calor do modelo VGG16 non_top para ... . . . . . . . . . . . 151
Figura 90 –Mapa de Calor do modelo VGG16 non_top para ... . . . . . . . . . . . 152
Figura 93 –Regiões de calor geradas pelo Algoritmo de Importância por Pixel para
3 amostras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Figura 94 – Importância por Pixel para os primeiros 1024 bytes das amostras 40 e 6. 157
Figura 95 – Visão Geral ddo processo de criação da Base VirusShareSant. . . . . . 174
Figura 96 – Visão Geral da submissão de um artefato para o VirusTotal. . . . . . . 178
Figura 97 – Visão Geral do processo de definição da Base VirusShareSant . . . . . 179
Figura 98 – Arquitetura original da Lenet, de acordo com (6) . . . . . . . . . . . . 184
Figura 99 – Hiperparâmetros das 3 arquiteturas convolucionais, baseadas na Lenet-5,
utilizadas nesta tese: (a) normal, (b) small e (c) tiny. . . . . . . . . . . 185
Figura 100 – Visão Geral da VGG16. Fonte: https://www.kaggle.com/shivamb/cnn-
architectures-vgg-resnet-inception-tl/notebook . . . . . . . . . . . . . . 186
Figura 101 – Visão Detalhada da V GG16 com valores de hiperparâmetros. . . . . . 187
Figura 102 – Visão Detalhada da V GG19 com valores de hiperparâmetros. . . . . . 187
Figura 103 – Exemplo de um bloco residual. . . . . . . . . . . . . . . . . . . . . . . 188
Figura 104 – Renet com 34 camadas conforme He et al.(12). . . . . . . . . . . . . . 188
Figura 105 – Tipos de interpolação. Fonte: https://en.wikipedia.org/wiki/Bicubic_interpolation191
Figura 106 – Experimento de aplicação dos diversos tipos de interpolação. . . . . . . 192
Grad-Cam para artefatos maliciosos. . . . . . . . . . . . . . . . . . . . 193
Figura 111 – Visão geral do formato PE(9). . . . . . . . . . . . . . . . . . . . . . . . 207
Figura 112 – Visão geral do cabeçalho do formato PE(9). . . . . . . . . . . . . . . . 208
LISTA DE QUADROS
LISTA DE TABELAS
Tabela 1 – Taxonomia da Representação de Artefatos Maliciosos. . . . . . . . . . 30

Tabela 2 – Definição da largura da representação de imagem de um artefato mali-
cioso de acordo com Nataraj et al.(13). . . . . . . . . . . . . . . . . . . 79
Tabela 3 – Relações do Objetivo Específico S0. . . . . . . . . . . . . . . . . . . . . 101
Tabela 4 – Desempenho de Redes Convolucionais para Classificação de Malware . 104
Tabela 6 – Verificação da Correta Rotulagem de Redes Convolucionais para Classi-
ficação de Malware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Tabela 8 – Representação de Imagem de Artefatos Maliciosos . . . . . . . . . . . . 110
Tabela 10 – Explicabilidade em RNC para análise de artefatos maliciosos . . . . . . 111
Tabela 11 – Quantidades de amostras de malware por família para a base VirusSha-
reSant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Tabela 12 – Quantidades de amostras de malware para o conjunto de treinamento,
validação e teste. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Tabela 13 – Acurácia para os diversos modelos baseados na arquitetura Lenet-5. . . 129
Tabela 14 – Acurácia para os diversos modelos utilizando transferência de aprendizado.130
Tabela 15 – Acurácia para o conjunto de testes para os modelos Lenet-5 Normal,
Resnet tiny, V GG16 non-top e V GG19 non-top. . . . . . . . . . . . . 131
Tabela 16 – Comparação de Acurácia para representação convencional e a proposta. 139
Tabela 17 – Conjunto de Dados de Artefatos Maliciosos Publicamente Disponíveis. 175
Tabela 18 – Distribuição das amostras do conjunto de treinamento da base de dados
Microsoft Malware Classification Challenge (BIG 2015). . . . . . . . . 177
Tabela 19 – Resultado Parcial do VirusTotal para o Artefato ... . . . . . . . . . . . 180
Tabela 20 – 17 Famílias selecionadas de artefatos maliciosos. . . . . . . . . . . . . . 180
Tabela 21 – Quantidade de Amostras de Malware por família por pacote do VirusShare.181
Tabela 22 – Distribuição das quantidades de amostras de malware em cada uma
das famílias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Tabela 23 – Distribuição das quantidades de amostras de malware em cada uma
das famílias na base VirusShareSant . . . . . . . . . . . . . . . . . . . 183
Tabela 24 – Quantidade de parâmetros e tempo médio de treinamento por época de
cada arquitetura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Tabela 25 – Hiperparâmetros das Arquiteturas que utilizam Transferência por Inici-
alização. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Tabela 26 – Hiperparâmetros das Arquiteturas que utilizam Transferência por Atri-
butos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Tabela 27 – Hiperparâmetros das Arquiteturas que utilizam Transferência Parcial
de Atributos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Tabela 28 – Erro médio quadrático entre imagem original e imagem com interpolação.192
Tabela 29 – Quantidade de amostras de cada família com tamanho superior a
224 × 224 bytes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Tabela 30 – Desempenho das RNCs utilizando os algoritmos de interpolação Bilinear
e Biquintic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Tabela 31 – Comparação do algoritmo Bilinear e Biquintic para geração de assina-
turas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Tabela 32 – Porcentagem de Amostras com determinado tamanho de cabeçalho . . 199
Tabela 33 – Acurácia na arquitetura Lenet-5 Tiny para Cabeçalho. . . . . . . . . . 200
Tabela 34 – Acurácia na arquitetura VGG16 non_top para Código. . . . . . . . . . 200
Tabela 35 – Comparação entre o comitê de classificadores da tese e o comitê de
votação majoritária para tratar variação semântica. . . . . . . . . . . . 201
Tabela 36 – Quantidade de Amostras de Malware por família por pacote do VirusShare.205
Tabela 37 – Acurácia para o conjunto de testes e VSS Concept Drifting. . . . . . . 206
SUMÁRIO
1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.1 MOTIVAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.2 CARACTERIZAÇÃO DO PROBLEMA . . . . . . . . . . . . . . . . . . . . 29
1.3 OBJETIVO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.4 QUESTÕES DE PESQUISA . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.5 METODOLOGIA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1.6 JUSTIFICATIVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1.7 ESTRUTURA DO TEXTO . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2 ANÁLISE DE MALWARE . . . . . . . . . . . . . . . . . . . . . . . . 37
2.1 ANÁLISE DE MALWARE . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.1.1 MALWARE : DEFINIÇÕES E TAXONOMIA . . . . . . . . . . . . . . . . . . 37
2.1.2 FORMAS DE EVASÃO A ANÁLISE E DETECÇÃO . . . . . . . . . . . . . . 40
2.1.3 ANÁLISE DE MALWARE . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3 APRENDIZADO DE MÁQUINA . . . . . . . . . . . . . . . . . . . . 46
3.1 DEFINIÇÕES E CONCEITOS DE APRENDIZADO DE MÁQUINA . . . . . 46
3.2 TIPOS DE SISTEMAS DE APRENDIZADO DE MÁQUINA . . . . . . . . 47
3.2.1 APRENDIZADO SUPERVISIONADO E NÃO SUPERVISIONADO . . . . . . . 47
3.2.2 SISTEMAS DE APRENDIZADO ONLINE E EM LOTE . . . . . . . . . . . . 49
3.2.3 SISTEMAS DE APRENDIZADO BASEADO EM INSTÂNCIAS E BASEADO EM
MODELOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.3 FASES DE UM SISTEMA BASEADO EM APRENDIZADO DE MÁQUINA 50
3.4 APRENDIZADO PROFUNDO . . . . . . . . . . . . . . . . . . . . . . . . 51
3.4.1 REDES NEURAIS COMPLETAMENTE CONECTADAS . . . . . . . . . . . . 53
3.4.2 REDES NEURAIS CONVOLUCIONAIS . . . . . . . . . . . . . . . . . . . . . 56
3.4.3 DROPOUT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.4.4 NORMALIZAÇÃO EM LOTE . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.4.5 GLOBAL AVERAGE POOLING . . . . . . . . . . . . . . . . . . . . . . . . 66
3.4.6 APRENDIZADO POR TRANSFERÊNCIA . . . . . . . . . . . . . . . . . . . 68
4 ANÁLISE AUTOMATIZADA DE MALWARE . . . . . . . . . . . . 71

4.1 SOLUÇÕES DE ANÁLISE AUTOMATIZADA DE MALWARE . . . . . . . 71
4.2 ARQUIVO DO TIPO PEFILE . . . . . . . . . . . . . . . . . . . . . . . . 73
4.2.1 O ARQUIVO EXECUTÁVEL PARA WINDOWS ő . . . . . . . . . . . . . . . 73
4.3 REPRESENTAÇÃO DO ARQUIVO DO FORMATO PE . . . . . . . . . . . 75
4.3.1 VETORES DE ATRIBUTOS . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.3.2 VETORES DE MNEMÔNICOS DO CÓDIGO EXECUTÁVEL . . . . . . . . . . 76
4.3.3 IMAGEM DO DADO BRUTO . . . . . . . . . . . . . . . . . . . . . . . . . 79
5 EXPLICABILIDADE . . . . . . . . . . . . . . . . . . . . . . .
. . . . 84
5.1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . 84
5.2 DEFINIÇÕES E TAXONOMIA EM EXPLICABILIDADE . . . . . . . . . . 85
5.3 EXPLICABILIDADE EM APRENDIZADO PROFUNDO . . . . . . . . . . . 90
5.4 ALGORITMOS DE EXPLICABILIDADE . . . . . . . . . . . . . . .
. . . . 92
5.4.1 ALGORITMOS DE EXPLICABILIDADE AGNÓSTICOS . . . . . . . .
. . . . 92
5.4.1.1 IMPORTÂNCIA PELA PERMUTAÇÃO DE ATRIBUTOS . . . . . . . .
. . . . 92
5.4.2 ALGORITMOS DE EXPLICABILIDADE EM APRENDIZADO PROFUNDO . . . 95
5.4.2.1 VISUALIZAÇÃO DE ATRIBUTOS APRENDIDOS PARA REDES NEURAIS
CONVOLUCIONAIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.4.2.2 MAPAS DE ATIVAÇÃO DE CLASSE . . . . . . . . . . . . . . . . . . . . . . 96
5.4.2.3 MAPAS DE ATIVAÇÃO DE CLASSE POR GRADIENTE . . . . . . . . . . . . 98
6 TRABALHOS RELACIONADOS . . . . . . . . . . . . . . . . . . . . 100

6.1 DESEMPENHO DE REDES CONVOLUCIONAIS PARA ANÁLISE DE
MALWARE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.2 RE-ROTULAGEM DE BASE DE DADOS DE ARTEFATOS MALICIOSOS 105
6.3 REPRESENTAÇÃO DE IMAGEM DE ARTEFATO MALICIOSO . . . . . . 107
6.4 EXPLICABILIDADE EM APRENDIZADO PROFUNDO APLICADO À ANÁ-
LISE DE MALWARE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
7 PROPOSTA DE TRABALHO . . . .
. . . . . . . . . . . . . . . . . 113
7.1 MÉTODO . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . 113
7.2 PROPOSTAS . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . 115
7.2.1 ARQUITETURA RNC - PROPOSTA P0 . .
. . . . . . . . . . . . . . . . . . 115
7.2.2 RE-ROTULAGEM DE BASE DE DADOS - PROPOSTA P1 . . . . . . . . . . 116
7.2.2.1 DESCRIÇÃO DA PROPOSTA . . . . . . . . . . . . . . . . . . . . . . . . . 116
7.2.3 NOVA REPRESENTAÇÃO DO ARTEFATO MALICIOSO- PROPOSTA P2 . . . 118
7.2.3.1 DESCRIÇÃO DA PROPOSTA . . . . . . . . . . . . . . . . . . . . . . . . . 121
7.2.4 ALGORITMO DE IMPORTÂNCIA POR PIXEL - PROPOSTA P3 . . . . . . . 122
7.2.4.1 DESCRIÇÃO DO PROBLEMA . . . . . . . . . . . . . . . . . . . . . . . . . 124
7.2.4.2 SOLUÇÃO PROPOSTA: ALGORITMO DE IMPORTÂNCIA POR PIXEL . . . . 124
8 RESULTADOS DE DESEMPENHO . . . . . . . . . . . . . . . . . . 127

8.1 CONJUNTO DE DADOS . . . . . . . . . . . . . . . . . . . . . . . . . . 127
8.2 SELEÇÃO DE ARQUITETURAS DE APRENDIZADO PROFUNDO . . . . 128
8.2.1 ARQUITETURAS DE APRENDIZADO PROFUNDO BASEADAS NA LENET-5 128
8.2.2 ARQUITETURAS DE APRENDIZADO PROFUNDO COM TRANSFERÊNCIA
DE APRENDIZADO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.2.3 SELEÇÃO DE ARQUITETURAS . . . . . . . . . . . . . . . . . . . . . . . . 131
8.2.4 COMITÊ DE CLASSIFICADORES . . . . . . . . . . . . . . . . . . . . . . . 133
8.3 ANÁLISE DOS RESULTADOS OBTIDOS . . . . . . . . . . . . . . . . . . 134
8.4 CONCLUSÃO PARCIAL . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9 RESULTADOS DA RE-ROTULAGEM . . . . . . . . . . . . . . . . . 135

9.1 APLICAÇÃO DO ALGORITMO PROPOSTO . . . . . . . . . . . . . . . . 135
9.1.1 LENET-5 NORMAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9.1.2 VGG16 NON_TOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
9.2 CONCLUSÃO PRELIMINAR . . . . . . . . . . . . . . . . . . . . . . . . . 138
10 RESULTADOS DA NOVA REPRESENTAÇÃO . . . . . . . . . . . . 139

10.1 DESEMPENHO DAS ARQUITETURAS DE APRENDIZADO PROFUNDO 139
10.1.1 DESCRIÇÃO DOS EXPERIMENTOS . . . . . . . . . . . . . . . . . . . . . 139
10.1.2 ANÁLISE DOS RESULTADOS . . . . . . . . . . . . . . . . . . . . . . . . . 140
10.1.3 CONCLUSÃO PARCIAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
10.2 REGIÕES DE CALOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
10.2.1 DESCRIÇÃO DO EXPERIMENTO . . . . . . . . . . . . . . . . . . . . . . . 140
10.3 ASSINATURA AUTOMATIZADA . . . . . . . . . . . . . . . . . . . . . . 144
10.3.1 RESULTADOS DA CRIAÇÃO DE ASSINATURAS - LENET-5 NORMAL . . . . 145
10.3.1.1 ANÁLISE DOS RESULTADOS - LENET 5 NORMAL . . . . . . . . . . . . . . 150
10.3.1.2 CONCLUSÃO PARCIAL LENET-5 . . . . . . . . . . . . . . . . . . . . . . . 150
10.3.2 RESULTADOS DA CRIAÇÃO DE ASSINATURAS - VGG16 NON_TOP . . . . 151
10.3.2.1 ANÁLISE DOS RESULTADOS - VGG16 NON_TOP . . . . . . . . . . . . . . 154
10.3.2.2 CONCLUSÃO PARCIAL - VGG16 NON_TOP . . . . . . . . . . . . . . . . . 154
10.4 CONCLUSÃO PARCIAL . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
11 RESULTADOS DO ALGORITMO DE IMPORTÂNCIA POR PIXEL 156

11.1 OBTENÇÃO DA REGIÃO DE CALOR . . . . . . . . . . . . . . . . . . . . 156
11.2 UTILIZAÇÃO DO ALGORITMO DE IMPORTÂNCIA POR PIXEL . . . . . 157
12 CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
APÊNDICE A – BASE DE DADOS VIRUSSHARESANT . . . . . 174

A.1 BASES PUBLICAMENTE DISPONÍVEIS . . . . . . . . . . . . . . . . . . 174
A.2 BASE DE DADOS VIRUSSHARESANT . . . . . . . . . . . . . . . . . . . 177
A.2.1 SELEÇÃO INICIAL DAS FAMÍLIAS E CRITÉRIO DE ACEITAÇÃO . . . . . . . 179
A.2.2 VALIDAÇÃO DE COMPATIBILIDADE . . . . . . . . . . . . . . . . . . . . . 181
A.2.3 DEFINIÇÃO DAS FAMÍLIAS PARA A BASE VIRUSSHARESANT . . . . . . . 182
A.3 DISCUSSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
APÊNDICE B – ARQUITETURAS DE CNN UTILIZADAS . . . . 184

B.1 ARQUITETURAS CONVOLUCIONAIS BASEADAS NA LENET-5 . . . . . 184
B.2 ARQUITETURAS CONVOLUCIONAIS BASEADAS EM TRANSFERÊNCIA
DE APRENDIZADO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
B.2.1 TRANSFERÊNCIA POR INICIALIZAÇÃO . . . . . . . . . . . . . . . . . . . 188
B.2.2 TRANSFERÊNCIA DE ATRIBUTOS . . . . . . . . . . . . . . . . . . . . . . 189
B.2.3 TRANSFERÊNCIA PARCIAL DE ATRIBUTOS . . . . . . . . . . . . . . . . . 189
APÊNDICE C – EFEITOS DO RESIZE NA DISTORÇÃO DA RE-

PRESENTAÇÃO . . . . . . . . . . . . . . . . . . . 191
C.1 MOTIVAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
C.2 DESCRIÇÃO DO PROBLEMA . . . . . . . . . . . . . . . . . . . . . . . . 193
C.3 IMPACTO NO DESEMPENHO . . . . . . . . . . . . . . . . . . . . . . . 193
C.3.1 DESCRIÇÃO DO EXPERIMENTO DE DESEMPENHO . . . . . . . . . . . . 194
C.3.2 RESULTADOS DO EXPERIMENTO DE DESEMPENHO . . . . . . . . . . . . 194
C.4 IMPACTO NA EXPLICABILIDADE . . . . . . . . . . . . . . . . . . . . . 195
C.4.1 DESCRIÇÃO DO EXPERIMENTO . . . . . . . . . . . . . . . . . . . . . . . 195
C.4.2 RESULTADOS OBTIDOS . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
C.4.3 ANÁLISE DOS RESULTADOS . . . . . . . . . . . . . . . . . . . . . . . . . 197
APÊNDICE D – PROPOSTA PARA PROBLEMA DE VARIAÇÃO

SEMÂNTICA . . . . . . . . . . . . . . . . . . . . . 198
D.1 MOTIVAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
D.2 DESCRIÇÃO DAS ARQUITETURAS . . . . . . . . . . . . . . . . . . . . 198
D.2.1 ARQUITETURAS PARA SEÇÃO TIPO CABEÇALHO . . . . . . . . . . . . . 198
D.2.2 ARQUITETURAS PARA SEÇÃO TIPO CÓDIGO . . . . . . . . . . . . . . . . 199
D.2.3 ARQUITETURAS PARA SEÇÃO TIPO DADO . . . . . . . . . . . . . . . . . 199
D.3 RESULTADOS DE DESEMPENHO . . . . . . . . . . . . . . . . . . . . . 200
D.3.1 DESEMPENHO PARA A SEÇÃO TIPO CABEÇALHO . . . . . . . . . . . . . 200
D.3.2 DESEMPENHO PARA A SEÇÃO TIPO CÓDIGO . . . . . . . . . . . . . . . 200
D.3.3 DESEMPENHO PARA A SEÇÃO TIPO DADO . . . . . . . . . . . . . . . . 200
D.3.4 DESEMPENHO PARA VOTAÇÃO MAJORITÁRIA . . . . . . . . . . . . . . . 201
D.4 CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
APÊNDICE E – RUÍDO NO ALGORITMO DE IMPORTÂNCIA

DE PIXEL . . . . . . . . . . . . . . . . . . . . . . 203
E.1 UTILIZAÇÃO DO RUÍDO . . . . . . . . . . . . . . . . . . . . . . . . . . 203
APÊNDICE F – BASE DE DADOS PARA CONCEPT DRIFTING 205

F.1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
F.2 RESULTADOS DE DESEMPENHO . . . . . . . . . . . . . . . . . . . . . 206
F.3 CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
ANEXO A – FORMATO PE . . . . . . . . . . . . . . . . . . . . . . 207

24
1 INTRODUÇÃO
Nos dias atuais, presencia-se um aumento no aparecimento de amostras de malware

únicas e de variações de malware pré-existentes detectadas (14). Ainda, de acordo com
Kaspersky(14), de 2018 para 2019 houve um aumento de 13% na quantidade de detecções
de artefatos maliciosos em ambientes de negócio. De acordo com Kaspersky(15), o antivírus
da Kaspersky Labs detectou um total de 15 milhões objetos maliciosos únicos em 2017.
Além disso, 4% dos usuários de computadores foram afetados por, pelo menos, um tipo de
malware e 900 mil computadores de novos usuários foram alvos de encryptors.
Para a plataforma Windows, detectou-se um total de 52 mil novas amostras em
2016, um total de 56 mil novas amostras em 2017, um total de 67 mil novas amostras em
2018, um total de 89 mil novas amostras em 2019 e um total de 55 mil novas amostas em
2020, respectivamente1 . Ainda, em 2020, uma média de aproximadamente 9 mil artefatos
maliciosos novos por mês foram detectados(1). Para os próximos anos há de se observar
cenários similares. O aumento no número de novas espécies de malware ao longo dos
últimos anos está apresentado na Figura 1.
Figura 1 – Número de novas espécies de malware. Baseado em dados apresentados em AVtest(1).
Mesmo quando se consideram amostras em voga, como os ransomwares, o cenário

permanece similar: 96 mil variações de crypto-ransomware e 38 novas famílias foram
descobertas (16). Quando se examina a plataforma de execução do malware, 74,49% dos
malware são construídos para o sistema operacional Microsoft Windows, seguido por 10,75%
para navegadores e 2,77% para Android. Especificamente para a plataforma Microsoft
Windows, 62,51% dos malware são Trojans, 21,05% dos malware são vírus clássicos e
1
Até a data de 02 junho de 2020.
Capítulo 1. Introdução 25
6,62% dos malware são Worms, ou seja, em sua grande maioria, os artefatos maliciosos são
binários executáveis ou código injetado em binários executáveis (1). Portanto, os códigos
binários executáveis maliciosos para plataforma Microsoft Windows são os mais comuns
tipos de artefatos maliciosos.
Para obter um melhor panorama da situação atual, faz-se necessário avaliar a
evolução dos malware na última década. De acordo com Singh e Singh(17), comparando
malware tradicionais com os novos, observa-se que o malware novo é mais difícil de se
detectar. De fato, os malware tradicionais eram amplos, conhecidos, abertos e únicos e
evoluíram para malware direcionados, de dia zero, furtivos e persistentes, como mostra a
Figura 2.
Figura 2 – Evolução dos malware tradicionais.
Artefatos maliciosos amplos são projetados para infectar diversas máquinas, ao

contrário daqueles direcionados que são desenvolvidos focando em um usuário ou grupo
de usuários. Um malware conhecido utiliza técnicas e métodos já dominados enquanto
um malware desconhecido que utiliza vulnerabilidades não dominadas2 ou desconhecidas3 .
Artefatos maliciosos abertos não se preocupam em passar desapercebido no sistema
infectado, ao contrário de artefatos maliciosos furtivos. Finalmente, uma amostra maliciosa
tradicional, que é mais antiga, infectava a máquina e executava seu código malicioso uma
única vez causando o dano, ao passo que amostras mais recentes tendem a ser persistentes,
ou seja, instalam-se no sistema e tentam manter o código malicioso em execução. Pode-se,
portanto, concluir que as amostras de malware têm evoluído de forma a ser tornar uma
ameaça cada vez maior para sistemas de computação.
Outro aspecto interessante do cenário atual é a evolução da quantidade de variantes
de malware. De acordo com o AVTest(18), o número de artefatos maliciosos que surgiram
em 2018 é de mais de 850 mil amostras e o número total de novas amostras de malware
que surgiram em 2018 é maior que 135 mil, ou seja, a relação entre número de artefatos
maliciosos e números de artefatos maliciosos únicos é de, aproximadamente, 6:1. Isto sugere
que os desenvolvedores de artefatos maliciosos focam no desenvolvimento de variantes
de malware, realizando pequenas alterações ou empacotamentos em malware existentes
2
Vulnerabilidade não dominada é aquela em que não se conhece, publicamente, uma forma de explorá-la.
3
Também chamadas de vulnerabilidades zero day.
de forma a dificultar a sua detecção. Desta forma, desenvolver um método de detecção

automática de variantes de código malicioso é relevante em qualquer sistema de proteção
contra malware.
Atualmente, empresas e instituições, de diversos setores, incorporam recursos
tecnológicos aos seus processos e o cenário apresentado agrava-se quanto maior o uso da
tecnologia da informação. Por exemplo, com a crise recente do Coronavírus, empresas
menores, como startups ou trabalhadores independentes, não possuem infraestrutura de
tecnologia da informação sofisticada e, portanto, realizam o trabalho remoto por meio de
(home office) de forma insegura, criando um ambiente vulnerável, pois a infecção da rede
corporativa pode acontecer pelo canal de acesso remoto do computador pessoal. Assim, na
medida em que os sistemas de computador se tornam progressivamente interconectados,
a complexidade da segurança da informação aumenta e, com isso, cria-se um ambiente
propício para a disseminação de malware com diversos objetivos. Neste contexto, torna-se
importante o processo de análise de malware.
A análise de malware refere-se ao estudo de amostras maliciosas com o objetivo
de desenvolver um melhor entendimento sobre vários aspectos do artefato, conforme
um objetivo pré-definido. Os resultados de tal análise devem permitir, por exemplo, a
atualização de soluções de segurança de forma a acompanhar a evolução do malware ou
alimentar um sistema de Inteligência de Ameaças (Threat Intelligence). A Inteligência
de Ameaças é um conhecimento baseado em evidências, incluindo contexto, mecanismos,
indicadores e implicações sobre uma ameaça existente e emergente, que podem ser usados
para informar decisões relacionadas com a resposta à ameaça (19).
De forma a ajudar os analistas de malware a recuperar informações úteis de
uma quantidade tão grande de executáveis, é necessário realizar a detecção e a análise
de malware de forma automática e em grande escala. Para o desenvolvimento de tais
tecnologias automatizadas de defesa, que permitam o processamento de grandes quantidades
de malware e que superem a capacidade dos novos malware, a meta mais importante é
capturar aspectos amplos e genéricos das amostras de artefatos maliciosos. Assim, pode-se
generalizar as conclusões obtidas a partir da análise de malware coletados e realizar uma
analogia com as características dos novos artefatos.
A escolha de soluções que envolvam técnicas de aprendizado de máquina é natural
para o processo de extração de conhecimento dos artefatos maliciosos e a generalização
além das instâncias conhecidas. Um subconjunto das técnicas de aprendizado de máquina
que vem se destacando atualmente é o aprendizado profundo. Aprendizado profundo faz
parte de uma família de algoritmos de aprendizado de máquina baseadas em redes neurais
artificiais que utiliza aprendizado por representação. Apesar da crescente popularidade
das técnicas de aprendizado profundo ao definir o estado da arte em muitas áreas, esta
abordagem não foi amplamente explorada na análise de malware 4 .

Entretanto, mesmo com os atuais avanços em aprendizado profundo, uma caracte-
rística típica destes modelos de aprendizado profundo é a sua natureza de caixa-preta: os
sistemas de classificação conseguem obter altas taxas de acurácias, mas é difícil compreender
e entender o que os levou a produzir uma determinada saída.
A explicabilidade ou interpretabilidade em Inteligência Artificial busca apontar um
caminho para a solução deste tipo de problema. De acordo com Turek(20), a explicabilidade
em inteligência artificial visa
“produzir modelos mais explicáveis, mantendo um alto nível de desempenho

de aprendizagem (precisão de previsão); e permitir que usuários humanos
entendam, confiem de maneira adequada e gerenciem com eficácia a geração
emergente de parceiros artificialmente inteligentes”.
Adadi e Berrada(21) destacam quatro motivos que justificam a implementação da

explicabilidade:
• Justificar: sistemas explicáveis fornecem a informação requerida para justificar

resultados, particularmente, quando decisões não esperadas são feitas.
• Controlar: explicabilidade pode ser útil para prevenir que algo dê errado: de fato,
entender mais sobre o comportamento do sistema fornece maior visibilidade sobre
vulnerabilidades e falhas desconhecidas e ajuda a identificar e corrigir rapidamente
os erros em situações de baixa criticidade (como depuração).
• Melhorar: muitas vezes tem-se a necessidade de melhorar continuamente um sistema.

Se se conhece como o sistema produziu determinada saída, pode-se modificar o sistema
de forma que ele se torne mais eficiente ou eficaz para um determinado objetivo.
• Descobrir: se o sistema é capaz de realizar uma determinada tarefa de forma superior

aos humanos, implementar a explicabilidade possibilita que sejam descobertos novos
conhecimentos ainda não observados.
Desta forma, uma solução de aprendizado profundo que permita uma melhor
explicabilidade pode ser útil ao esclarecer as razões para uma determinada detecção ou
classificação, ao ajudar a prevenir que vulnerabilidades, até então desconhecidas na
arquitetura de aprendizado profundo, possam ser identificadas, ao permitir que sejam
realizadas melhorias na arquitetura de forma a melhorar seu desempenho e ao possibilitar
que novo conhecimento seja obtido a partir da interpretação das saídas da arquitetura.
4
Pode-se observar um crescente número de publicações na área de aprendizado profundo aplicado à
análise de malware a partir de 2016.
1.1 Motivação
Técnicas de Aprendizado Profundo são aplicadas, atualmente, nas diversas áreas de
conhecimento e, em muitos casos, tais técnicas são o estado da arte, ou seja, o nível mais
alto de desenvolvimento para uma determinada tarefa(3). Pode-se observar este avanço,
por exemplo, nos resultados obtidos, ano após ano, no desafio anual do Imagenet(2). Na
Figura 3 tem-se a taxa de erro obtida pelo campeão da competição no período de 2010 a
2017. A primeira grande melhora foi obtida por Krizhevsky, Sutskever e Hinton(22) em
2012, com uma redução da taxa de erro de 26,1% em 2011 para 16,4% em 2012, onde, pela
primeira vez, foi utilizada uma abordagem de aprendizado profundo conhecida como rede
neural convolucional. A partir de 2012, todas as arquiteturas vencedoras foram baseadas
em técnicas de aprendizado profundo. Finalmente, em He et al.(12), foi obtido um valor
de taxa de erro de 3,6% que é um patamar de qualidade superior ao obtido por um ser
humano. Em 2017 foram alcançados valores de taxa de erro 2,2% e 29 dos 38 competidores
obtiveram taxa de erro menor que 5%5 .
Figura 3 – Taxa de Erro obtida no desafio anual do ImageNet((2))
A utilização de aprendizado profundo em análise de artefatos maliciosos é bastante

recente e promissora. A ideia central do aprendizado profundo é que os objetos de análise
sejam gerados pela composição de fatores ou características de entrada, em vários níveis
hierárquicos (3). Neste sentido, as soluções de aprendizado profundo constroem uma
hierarquia de representações - da mais simples para a mais complexa, não havendo
necessidade de uma engenharia de atributos, como no caso de classificadores de aprendizado
5
Em 2017, os desenvolvedores do projeto ImageNet decidiram atuar em um novo e mais complexo desafio
que envolve a classificação de objetos 3D usando linguagem natural e, por isso, não há resultados
posteriores a 2017.
de máquina tradicionais. Ao mesmo tempo, ainda que obtenham altas taxas de acurácia,
as arquiteturas de aprendizado profundo não possuem, intrinsecamente, uma forma trivial
de se obter a causa e a cadeia de raciocínio de uma determinada predição.
Em grande parte dos trabalhos analisados que tratam da aplicação de aprendizado
profundo à análise de malware, não existe a intenção de se relacionar as características de
entrada utilizadas com os resultados obtidos. Para obter as razões de uma determinada
classificação ou detecção, por parte de um algoritmo de aprendizado profundo, pode-se
utilizar algoritmos de explicabilidade, ou seja, algoritmos capazes de fornecer informações
que ajudam a melhor compreender os resultados obtidos.
Como os custos para se desenvolver uma arquitetura para análise de malware
podem ser altos quando se busca uma grande precisão, parece importante um melhor
entendimento das relações entre características e arquitetura de aprendizado profundo
nos resultados obtidos. Além disso, ao compreender essas relações é possível obter um
avanço no conhecimento na análise de malware por meio da descoberta, por parte da
explicabilidade do algoritmo de aprendizado profundo, de aspectos anteriormente ocultos.
1.2 Caracterização do Problema

A quantidade de malware e suas variantes vem crescendo nos últimos anos e o
processo de análise manual de artefatos não é, obviamente, adequado para lidar com
esta tendência. Assim, soluções automatizadas de detecção e classificação de malware são
interessantes e soluções de aprendizado de máquina, mais especificamente de aprendizado
profundo, atendem a estas demandas (23, 24, 25, 26, 27, 28, 29, 30, 31, 30, 32, 33, 34).
No entanto, como existem poucas bases de dados de artefatos maliciosos disponibilizadas
publicamente para desenvolver pesquisa, estes trabalhos dão pouca ou nenhuma importância
para a verificação da correta rotulagem das amostras destas bases. Assim, a primeira
lacuna encontrada nestes trabalhos é que nenhum deles considerou possíveis erros na
correta rotulagem da base de dados de artefatos maliciosos, o que poderia levar
os algoritmos de aprendizado de máquina a pressupostos incorretos (Lacuna
L1).
Em qualquer sistema de detecção ou classificação que utilize aprendizado profundo
é importante definir a forma de entrada dos dados, ou seja, sua representação. Os tipos
de representação de um artefato malicioso, encontrados nos trabalhos que envolvem
análise de malware e que utilizam aprendizado profundo, podem ser classificados como: (a)
Imagem do Artefato: uma imagem de todo artefato a partir do executável é gerada, (b)
Mnemônicos: sequência de mnemônicos extraída a partir do código executável do artefato
e (c) Atributos: frutos de processamento por algoritmos definidos por um especialista na
área podendo ser estáticos ou dinâmicos. Em alguns trabalhos, pode-se encontrar mais de
uma forma de representação ou uma representação híbrida. A Tabela 1 apresenta trabalhos

que utilizam aprendizado profundo para análise de artefatos maliciosos, destacando o tipo
de representação e a plataforma utilizada.
Tabela 1 – Taxonomia da Representação de Artefatos Maliciosos.
Ano Referência Representação utilizada Plataforma

2014 Yuan et al.(23) Atributos Android
2015 Pascanu et al.(24) Atributos Android
2016 Yuan, Lu e Xue(25) Atributos Android
2016 Kolosnjaji et al.(35) Atributos Windows
2016 Su et al.(36) Atributos Android
2017 Choi et al.(26) Imagem do Artefato Windows
2017 Kabanga e Kim(37) Imagem do Artefato Windows
2017 Vinayakumar, Soman e Poornachandran(38) Atributos Estáticos Android
2017 Martinelli, Marulli e Mercaldo(39) Imagem de Atributos Android
2017 Kim(40) Imagem do Artefato Windows
2017 Nix e Zhang(27) Imagem do Artefato Windows
2017 Maniath et al.(41) Atributos Windows
2018 Raff et al.(28) Imagem do Artefato Android
2018 Ni, Qian e Zhang(42) Imagem de Atributos Windows
2018 Kalash et al.(29) Imagem do Artefato Windows
2018 Sun e Qian(43) Mnemônicos e Imagem de Atributos Windows
2018 HaddadPajouh et al.(44) Mnemônicos IoT/Linux
2018 Cakir e Dogdu(31) Mnemônicos Windows
2018 Sewak, Sahay e Rathore(45) Mnemônicos Windows
2018 Cui et al.(46) Imagem do Artefato Windows
2018 Krčál et al.(30) Imagem do Artefato Windows
2018 Masabo, Kaawaase e Sansa-Otim(47) Imagem de Atributos Windows
2018 Chen, Sultana e Sahita(48) Imagem de Atributo Windows
2018 Yan, Qi e Rao(49) Imagem do Artefato e Mnemônicos Windows
2018 Jung, Kim e Im(32) Imagem de Atributos Windows
2019 Akarsh et al.(33) Imagem do Artefato Windows
2019 He e Kim(50) Imagem do Artefato Android
2019 Pei, Yu e Tian(51) Atributos Android
2020 Naeem et al.(52) Imagem do Artefato Android
2020 Ren et al.(34) Imagem do Artefato Android
2020 Niu et al.(53) Mnemônicos Android
Nesta tese, decidiu-se por utilizar a representação por Imagem do Artefato por
dois motivos: (a) a imagem de um artefato representa todo o executável e, portanto, é
mais abrangente, quando comparada com a utilização dos seus mnemônicos que apenas
consideram o código executável do artefato malicioso e (b) permite que a engenharia de
atributos aprendida pelo algoritmo de aprendizado profundo, seja utilizada para alavancar
o conhecimento pelo analista de malware. Assim, como definiu-se que a representação do
artefato será feita por Imagem do Artefato, as arquiteturas propostas serão baseadas
em Redes Neurais Convolucionais por serem mais adequadas ao processamento de imagens.
Dos trabalhos analisados que utilizam a representação do artefato por imagem e
arquiteturas de Redes Neurais Convolucionais, poucos implementam alguma forma de
explicabilidade quando aplicados à análise de malware. No geral, eles se limitam em obter
os resultados da aplicação direta de um algoritmo de explicabilidade na arquitetura de
aprendizado profundo aplicada à anaĺise de malware. Ainda, Yakura et al.(54) e Krčál
et al.(30) sofrem da distorção de representação, ou seja, definida a arquitetura de rede
convolucional a ser utilizada, as imagens que alimentam a rede convolucional devem possuir
um único tamanho (tamanhos fixos), e, portanto, um redimensionamento é feito para o
treinamento da rede e, depois, desfeito para obter o resultado da explicabilidade, causando
uma distorção indesejada. Em Yakura et al.(54), Krčál et al.(30) e Raff et al.(28), os
autores obtém o resultado da explicabilidade a partir do processamento de todo artefato
malicioso, ainda que se deseje o resultado da explicabilidade apenas para uma seção do
artefato.
Assim, os trabalhos analisados que implementam explicabilidade em Redes Neurais
Convolucionais para análise de malware(28, 30, 54) apresentam as seguintes limitações:
• Malware de diferentes tamanhos são representados por imagens de tamanhos vari-

ados e, para alimentar uma arquitetura de aprendizado profundo definida6 , estas
imagens devem sofrer um redimensionamento para valores fixos de altura
e largura, desconsiderando que a maior correlação na representação por
imagem do artefato está no eixo horizontal (Lacuna L2);
• Os resultados da explicabilidade são obtidos a partir do processamento de toda

a imagem, não sendo possível predeterminar uma região a ser processada
do artefato para obter os resultados da explicabilidade (Lacuna L3).
Estas duas limitações citadas são específicas de soluções de aprendizado profundo

aplicadas à análise de malware e, como os algoritmos de explicabilidade existentes são
genéricos, não as consideram. Assim, a questão é em que grau uma adaptação em
um algoritmo de explicabilidade existente pode melhorar a interpretação dos
resultados de um algoritmo de aprendizado profundo aplicado à análise de
malware? Deve-se ainda considerar que os resultados de um algoritmo de explicabilidade
são interessantes somente se a arquitetura de aprendizado profundo possui um desempenho
adequado.
A abordagem utilizada nesta tese é a de aprofundar o conhecimento sobre repre-
sentação do artefato malicioso e algoritmos de explicabilidade e propor alternativas e
adaptações na forma de métodos ou algoritmos que solucionem as lacunas identificadas.
1.3 Objetivo
O objetivo geral desta tese é propor adaptações que, aplicadas a algorit-
mos de explicabilidade, permitam melhorar a identificação de relações entre
as características de entrada da rede com os resultados obtidos para uma de-
terminada tarefa na área de análise de malware, e solucionar ou mitigar os efeitos
6
Definida uma arquitetura de aprendizado profundo como uma rede neural convolucional, todas as
imagens de entrada devem possuir o mesmo tamanho.
negativos das lacunas identificadas. Ainda, a implementação de explicabilidade na ar-

quitetura de aprendizado profundo aplicada em análise de artefatos maliciosos não deve
diminuir o desempenho desta, ou seja, não deve comprometer o desempenho preditivo do
modelo.
Os objetivos específicos identificados são:
• Objetivo Específico S0: Definir uma arquitetura de Rede Neural Convolucional

com acurácia adequada para aplicação de algoritmos de explicabilidade;
• Objetivo Específico S1: Definir adaptações em algoritmos de explicabilidade de

forma a obter possíveis candidatos à retificação do rótulo e minimizar os efeitos da
Lacuna L1;
• Objetivo Específico S2: Definir representações que alinhem o resultado da expli-

cabilidade com a alta correlação horizontal da representação da imagem mitigando
os efeitos identificados na Lacuna L2;
• Objetivo Específico S3: Adaptar um algoritmo de explicabilidade de forma a

permitir o processamento da explicabilidade em regiões de interesse do artefato
apresentando uma alternativa que soluciona a Lacuna L3.
Assim, para atingir o objetivo geral é preciso atingir o objetivo S0 e S1 ou S2 ou S3.

Para atingir o objetivo S0 é preciso propor arquiteturas de Redes Neurais Convolucionais
que obtém resultado de acurácia adequada para aplicação de algoritmos de explicabilidade.
Para atingir o objetivo específico S1 é preciso solucionar a lacuna L1 e atingir o objetivo S0.
Para atingir o objetivo específico S2 é preciso mitigar ou minimizar os efeitos identificados
na Lacuna L2 e atingir o objetivo específico S0. Finalmente, para atingir o objetivo
específico S3 é preciso atingir o objetivo específico S0 e propor um método ou uma
adaptação que considere apenas uma região do artefato malicioso, solucionando a Lacuna
L3. A Figura 4 apresenta a relação entre o objetivo geral, os objetivos específicos e lacunas
identificadas.
O resultado da análise de malware por meio de um algoritmo de aprendizado
profundo depende da base de dados disponível. Para esta tese, foi gerada uma base de
dados para classificação em famílias de malware denominada VirusShareSant e que está
descrita no Apêndice A.
1.4 Questões de Pesquisa

Considerando a importância do uso de algoritmos de explicabilidade em aprendizado
profundo para análise de malware e as lacunas encontradas nos diversos trabalhos analisados,
as seguintes questões de pesquisa foram levantadas:
Figura 4 – Relação entre Objetivo Geral, Específicos e lacunas
• Questão de Pesquisa Q1: Pode-se obter amostras candidatas à reavaliação de

sua correta rotulagem a partir de um método de análise dos atributos aprendidos do
algoritmo de aprendizado de profundo? Esta questão de pesquisa está relacionada
com o objetivo específico S1.
• Questão de Pesquisa Q2: A definição de um novo redimensionamento da re-

presentação de imagem de um artefato malicioso que considere a maior correlação
horizontal entre os bytes pode trazer melhoras aos resultados de algoritmos de ex-
plicabilidade ? Esta questão de pesquisa está relacionada com o objetivo específico
S2.
• Questão de Pesquisa Q3: Pode-se adaptar um algoritmo de explicabilidade, de

forma a permitir que apenas uma região pré-selecionada do artefato malicioso seja
analisada ? Esta questão de pesquisa está relacionada com o objetivo específico S3.
Finalmente, para o desenvolvimento desta tese, alguns pressupostos foram conside-

rados:
• Com uma quantidade bastante extensa de amostras, qualquer algoritmo de aprendi-

zado de profundo é capaz de obter um resultado adequado.
• No aprendizado profundo, espera-se que a hierarquia de representações seja capaz de,

a partir da representação de entrada, obter o resultado desejado conforme objetivo
da análise de malware definido;
• A representação do malware é versátil o suficiente para que, com modificações, seja

possível realizar análises úteis a partir dos resultados de algoritmos de explicabilidade;
• A partir de um modelo treinado, existe uma relação entre os resultados de algoritmos

de explicabilidade e a representação de malware de onde é possível obter informação
útil sobre as razões para uma classificação ou detecção por parte do algoritmo de
aprendizado profundo.
1.5 Metodologia
Para obtenção do conhecimento necessário e para a validação do problema escolhido,
foi realizada uma pesquisa bibliográfica nos assuntos abordados por esta tese:
• Representação: focada principalmente na escolha de uma forma de representar o

artefato malicioso de maneira a permitir a interpretação após aplicação de algoritmos
de explicabilidade.
• Aprendizado de Profundo: especificamente para arquiteturas de Redes Neurais

Convolucionais;
• Análise de Malware: notadamente, aspectos da análise de malware para ambientes

automatizados que utilizam aprendizado de máquina;
• Explicabilidade: aspectos gerais de explicabilidade e foco em algoritmos agnósticos e

algoritmos específicos para redes neurais convolucionais;
A pesquisa foi conduzida de maneira experimental, procurando, assim, avaliar

e validar as abordagens propostas em relação às lacunas L1, L2 e L3 encontradas. O
desempenho da arquitetura de aprendizado profundo foi avaliada de forma quantitativa,
buscando acurácias que sejam adequadas para a utilização de algoritmos de explicabilidade.
A informação de entrada do algoritmo de aprendizado profundo é resultado da análise
estática do artefato malicioso para plataforma Windows ő , ou seja, sem a execução do
mesmo. Além disso, o objetivo do algoritmo de aprendizado profund, que é determinado
pela base selecionada, o é o de classificar o artefato malicioso em 9 famílias.
Para cada objetivo específico S1, S2 e S3 serão propostas soluções e métodos de
avaliação específicos de forma a demonstrar que a proposta resolve ou mitiga as Lacunas
L1, L2 e L3. A análise dos resultados da aplicação de explicabilidade para algoritmos
existentes e propostos nas soluções de análise de malware foi realizada de forma qualitativa.
1.6 Justificativa
O desenvolvimento de tecnologias de segurança duais, ou seja, com aplicações na
área militar e civil, é tema a Estratégia Nacional de Defesa7 . A Estratégia Nacional de
Defesa trata da reorganização e reorientação das Forças Armadas, da organização da Base
7
https://www.defesa.gov.br/arquivos/estado_e_defesa/END-PND_Optimized.pdf
Industrial de Defesa e da política de composição dos efetivos da Marinha, do Exército e

da Aeronáutica. Ela define, ainda, três setores estratégicos como essenciais para a defesa
nacional: o espacial, o cibernético e o nuclear. A Segurança Nacional, que é uma das ações
estratégicas do Setor Cibernético, visa
“contribuir com o aperfeiçoamento dos dispositivos e procedimentos de se-

gurança que reduzam a vulnerabilidade dos sistemas relacionados à Defesa
Nacional contra ataques cibernéticos.”
Os resultados deste trabalho podem contribuir para o aperfeiçoamento de soluções

de segurança e, ainda, apoiar o desenvolvimento de tecnologias nacionais. No Exército
Brasileiro, a aplicação desse conhecimento pode contribuir para a definição de uma
arquitetura específica para análise de artefatos maliciosos que esteja em sintonia com
as necessidades da área de segurança da informação. Ainda, por meio da análise dos
resultados obtidos, será possível responder a perguntas como: Quais características são
mais interessantes para detecção de variantes de malware ou quais algoritmos são mais
adequados para realizar a detecção de malware. As respostas a estas perguntas podem
dar, aos analistas de artefatos maliciosos, uma melhor percepção do potencial de ataque
de uma determinada amostra.
1.7 Estrutura do Texto

Esta tese está organizada da seguinte maneira: os capítulos 2, 3, 4 e 5 apresentam
referenciais teóricos relacionados ao tema desta tese: visão geral de análise de malware,
conceitos de aprendizado de máquina e aprendizado profundo, análise automatizada de
artefatos maliciosos, destacando o uso de soluções de aprendizado de máquina e conceitos
e definições de explicabilidade. O Capítulo 6 apresenta os trabalhos relacionados com as
propostas desta tese. No Capítulo 7 apresenta as propostas desta tese relacionando cada
proposta com sua respectiva Lacuna e com o objetivo geral. Nos Capítulos 8, 9, 10 e 11
são apresentados os resultados das propostas com suas respectivas análises e conclusões.
Finalmente, no Capítulo 12 é apresentado a conclusão, trabalhos futuros e contribuições.
A Figura 5 apresenta uma visão geral da estrutura do texto.
Figura 5 – Estrutura do Texto da Tese

37
2 ANÁLISE DE MALWARE
Esta primeira parte do referencial teórico envolve assuntos relacionados à área de

análise de malware e as principais referências utilizadas foram Skoudis e Zeltser(55) e
Sikorski e Honig(56).
2.1 Análise de Malware

A análise de artefatos maliciosos é o processo complexo que pode tanto estar focada
em detectar se um binário é malicioso ou não quanto em classificar o mesmo em famílias ou
variantes. Assim, embora exista uma grande diversidade de tipos de malware, as técnicas
usadas para analisar o malware são comuns e dependem apenas do objetivo de análise.
Um objetivo comum da análise de malware é determinar exatamente o que um
artefato pode fazer, como detectá-lo e como medir ou conter seus danos. Como cada
análise tem suas especificidades, o trabalho de um analista de malware é bastante custoso
e demorado.
Para ajudar os analistas de malware a recuperar informações úteis de uma quanti-
dade tão grande de executáveis, é necessário fazer a detecção e a análise de malware de
forma automática e em grande escala. Para o desenvolvimento de tais tecnologias automa-
tizadas de defesa, que permitam o processamento de grandes quantidades de malware, a
meta mais importante é capturar aspectos amplos das amostras de artefatos maliciosos.
Desta forma, pode-se generalizar as conclusões obtidas a partir da análise de malware já
coletadas e realizar uma analogia com as características dos novos artefatos.
Nas seções subsequentes, estão apresentados os principais conceitos e definições
de malware, bem como sua taxonomia. Ainda, estão apresentadas as etapas da análise
de malware realizadas por um analista de malware e, em seguida, os aspectos da análise
automatizada de malware.
2.1.1 Malware: Definições e Taxonomia

Existem diversas definições para malware. Segundo Moir(57), tem-se que malware
é qualquer software projetado para causar danos a um único computador, servidor ou
rede de computadores. Em Skoudis e Zeltser(55) tem-se que malware é um conjunto de
instruções que são executadas em um computador e fazem o seu sistema realizar uma
operação que um invasor deseja que ele faça. Finalmente, em Sikorski e Honig(56), tem-se
que malware é qualquer software que faça algo que prejudique o usuário, computador ou
rede.
Capítulo 2. Análise de Malware 38
As definições anteriores são adequadas considerando o contexto a que se propuseram.

No entanto, deve-se enfatizar algumas características típicas de artefatos maliciosos:
1. Um artefato malicioso pode ser um conjunto de instruções: um artefato malicioso

não precisa, necessariamente, ser um binário executável. Embora muitos códigos
maliciosos sejam implementados em executáveis binários, um artefato malicioso se
estende muito além disso, pois o código malicioso pode ser implementado em qualquer
linguagem de computador na forma de trechos de código. Por exemplo, um vírus de
macro é um vírus escrito em uma linguagem incorporada e desenvolvida para um
determinado aplicativo (comumente processadores de texto e aplicativos de planilha).
Assim, os vírus de macro podem ser incorporados em documentos e são executados
automaticamente quando o documento é aberto, ou seja, o vírus se aproveita de um
mecanismo diferenciado para a execução de suas instruções maliciosas.
2. Um artefato malicioso causa dano de forma proposital: um artefato malicioso causa

algum tipo de dano porque foi projetado para isso ou porque foi utilizado para causar
dano (ainda que de forma inconsciente pela vítima). Por exemplo: o WannaCry
ransomware cryptoworm é um artefato cujo propósito é causar à vítima perda ou fi-
nanceira ou de dados, cifrando os dados da máquina infectada e exigindo o pagamento
de resgate em troca da senha de decifração. O WannaCry ransomware cryptoworm
foi claramente projetado para causar dano. Um executável com a capacidade de
Ping of Death, que é o envio de um ping malformado ou mal-intencionado para um
computador, causa uma Negação de Serviço (Denial of Service). No entanto, existe
um uso legítimo para esta técnica: quando se deseja testar a capacidade de carga de
um servidor.
Do exposto, pode-se concluir que a tarefa de classificar um artefato como malicioso

está longe de ser trivial e, para facilitar sua categorização, os malware foram agrupados
em diversos tipos (56):
1. Backdoor: código malicioso que se instala no computador para permitir o acesso pelo
invasor. Backdoors geralmente permitem que o invasor se conecte ao computador
infectado com pouca ou nenhuma autenticação e execute comandos no sistema local;
2. Botnet: semelhante a um Backdoor ao permitir que o invasor acesse o sistema de

forma remota - no entanto, todos os computadores infectados com o mesmo Botnet
recebem as mesmas instruções de um único servidor de comando e controle;
3. Downloader: código malicioso cujo propósito é apenas o de baixar outro código

malicioso. Os Downloaders são geralmente instalados pelos atacantes quando eles
obtêm acesso a um sistema. O programa de download, por si só, não é malicioso: no
entanto, ao baixar e instalar códigos maliciosos adicionais, ele se torna uma ameaça;
4. Malware de Roubo de Informações: coletam informações do computador da vítima e,

geralmente, as envia ao invasor. Exemplos incluem sniffers e keyloggers;
5. Lançador (Launcher): usado para iniciar outros programas maliciosos. Geralmente,

os lançadores usam técnicas não tradicionais para iniciar outros programas maliciosos,
a fim de garantir sigilo ou maior acesso a um sistema;
6. Rootkit: código malicioso projetado para ocultar a existência de outro código. Os

Rootkits geralmente são combinados com outros malware, como um Backdoor, para
permitir acesso remoto ao invasor e dificultar a detecção do código pela vítima;
7. Worm ou Vírus: código malicioso que pode se copiar e infectar outros computadores
automaticamente, geralmente explorando uma vulnerabilidade do sistema, ou seja,
ele é capaz de se propagar sem interferência do usuário;
8. Trojan Horse: tipo de malware que se disfarça como um arquivo ou programa normal
para induzir os usuários a baixar e instalar malware. Ele pode conceder acesso remoto
a um computador infectado.
As soluções de antivírus classificam, ainda, os diversos tipos de malware em famílias

e cada solução de antivírus tem sua própria nomenclatura própria. O antivírus da Microsoft,
por exemplo, utiliza o seguinte esquema1 .
[T ipo :][P lataf orma/][F amília][.V ariante][!Suf ixos]
Backdoor : W in32/Caphaw.D!lnk
O Tipo descreve o que o malware faz e alguns exemplos de tipos são os Worms,
os Trojans e os Backdoors. A Plataforma representa o sistema operacional (Microsoft
Windows, Mac OS ou Android) no qual o malware foi projetado para funcionar. A
plataforma também é usada para representar linguagens de programação e formatos de
arquivo. A Família indica o agrupamento de malware com base em características comuns,
incluindo a atribuição aos mesmos autores. A Variante é usada de forma sequencial para
todas as versões distintas de uma família de malware. Uma variante “.B” teria sido criada
após a detecção da variante “.A”. Finalmente, os Sufixos fornecem detalhes adicionais
sobre o malware, incluindo como ele é usado como parte de uma ameaça multicomponente.
Por exemplo, um sufixo .worm indica que ele é o componente worm do malware.
1
https://docs.microsoft.com/en-us/windows/security/threat-protection/intelligence/malware-naming
2.1.2 Formas de Evasão a Análise e Detecção

Os autores de malware, cientes da possibilidade de análise e detecção de seus
artefatos, criam mecanismos para evadir ou dificultar a análise de malware ou sua detecção.
De acordo com Sikorski e Honig(56), tem-se basicamente 4 técnicas de anti-engenharia
reversa: anti-disassembly, anti-debugging, anti-emulação e packing.
O anti-disassembly utiliza a injeção de códigos ou dados especialmente criados de
forma a fazer com que o processo de desmontagem (disassembling) produza uma listagem
incorreta do programa. Os autores de malware usam técnicas anti-disassembly com o
objetivo de atrasar ou impedir a análise de código malicioso, pois, ao implementar essa
técnica, o nível de habilidade exigida pelo analista de malware passa a ser maior. Essa
técnica é implementada, comumente, utilizando uma ferramenta a parte e, geralmente,
após o processo de criação do malware.
Na listagem, 2.1, tem-se um extrato de código exemplificando uma técnica de
anti-disassembly. Pode-se observar que o jz da primeira instrução está fazendo um salto
para o hexadecimal 8B (endereço 401010 + 1) e não o E8 da linha seguinte. Ou seja, a
listagem que o programa disassembler fez é uma listagem equivocada, pois o primeiro hex
da segunda linha, de acordo com o disassembler, é o E8. O E8 foi incluído pelo atacante
para que o processo de desmontagem falhasse, num primeiro momento.
Listing 2.1 – Código assembly com técnica anti-disassembly

40100E : 74 01 j z short near_ptr loc_401010+1
401010: E8 8B 45 0C 8B c a l l near ptr 8B4C55A0h
401015: 48 dec eax
401016: 04 0F add a1 , 0 Fh
401018: BE 11 83 FA 70 mov esi , 70FA8111h
Na listagem 2.2 o hexadecimal E8 foi tratado manualmente pelo analista como

2
dado e, portanto, o processo de disassembly foi realizado a partir do hexadecimal 8B. A
partir do código tratado, é possível prosseguir com a análise.
Listing 2.2 – Código assembly corrigido com técnica anti-disassembly

40100E : 74 01 j z short loc_401011
401010: E8 db 0E8h
401011: 8B 45 0C mov eas , [ ebp+0Ch]
401014: 8B 48 04 mov ecx , [ eax + 4 ] ]
401017: 0F BE 11 movsx edx , byte ptr [ ecx ]
O anti-debugging é uma técnica de anti-análise usada pelo malware para reconhecer

quando se está sob o controle de um debugger. Nesse caso, o malware pode alterar sua
2
Configurado na ferramenta de desmontagem.
execução normal ou mesmo causar uma falha de forma a atrapalhar a análise. No caso do
malware ser um executável para Microsoft Windows, uma das formas mais simples de anti-
debbuging é fazer uma chamada a API IsDebuggerPresent. Outra forma de anti-debugging
são as verificações de tempo de execução de determinadas rotinas, o tempo de execução
das rotinas, quando estão sendo depurados, é muito superior ao tempo de execução sem o
debugger.
As técnicas anti-VM são técnicas implementadas por malware que tentam evadir
a detecção ou análise ao perceber que são executados em ambientes virtualizados. A
popularidade de técnicas anti-VM diminuiu bastante recentemente (56) devido ao aumento
no uso da virtualização em ambientes operacionais. Tradicionalmente, os autores de
malware usavam técnicas anti-VM pois partiam da hipótese de que se o malware estiver
sendo executado em uma máquina virtual ele estaria sendo analisado. No entanto, na
medida em que a utilização de virtualização aumenta, as técnicas anti-VM tendem a
ser menos comuns. Um exemplo típico de técnica anti-VM é a detecção de ferramentas
específicas instaladas no ambiente virtual, como o VMWare Tools 3 para VMWare.
Os programas de empacotamento, conhecidos como empacotadores (packers),
tornaram-se populares entre os autores de malware, porque ajudam a dificultar a de-
tecção do código malicioso do malware pelo software antivírus. A popularidade dos packers
é consequência de estarem, em sua grande maioria, disponíveis gratuitamente e exigirem
pouco conhecimento técnico para sua utilização. Em um malware empacotado, a análise
estática básica manual não é útil, pois o único código, em claro, disponível para a análise é o
código do empacotador, ou seja, para uma análise eficaz do malware compactado devemos,
inicialmente, descompactá-lo, o que torna o processo mais complicado e desafiador.
Figura 6 – Código Binário Original localizado à esquerda e código empacotado localizado

à direita.
A Figura 6 apresenta um exemplo de como funciona um empacotador. O código

original de um binário (a esquerda, em verde) é empacotado, gerando um código empacotado
(em rosa, a direita). Ao código final empacotado, é adicionado um código para desempacotar
o código empacotado (a direita, em amarelo). Assim, a versão final do artefato malicioso
3
https://kb.vmware.com/s/article/340
possui: um código desempacotador e o código original empacotado. As informações de

imports e exports do código original também são empacotadas.
Figura 7 – Código empacotado (a esquerda) sendo desempacotado e gerando o binário da

esquerda. Note que o binário gerado é diferente do original da Fig 6.
A Figura 7 apresenta o processo de desempacotamento do malware. Quando o

artefato é executado, o código desempacotador acessa os dados encontrados na seção de
código empacotado gerando o código original do malware (em verde, à direita), incluindo
os exports (em azul, à direita e acima) e imports (em azul, à direita, abaixo).
O código empacotador pode ser gerado a partir de diversas ferramentas como
Armadillo , o NSpack , o Eziris Intellilock e o AsProtect SKE. Deve-se observar, no entanto,
que estes empacotadores são usados de forma legítima ao ajudar a preservar os direitos
autorais e evitar/dificultar a engenharia reversa. Por exemplo, autores de jogos Massively
Multiplayer Online Role-Playing Game (MMORPG) querem evitar que um usuário faça
engenharia reversa do jogo e crie cheat codes 4 . Além disso, no passado, os empacotadores
foram bastante utilizados para gerar arquivos binários menores de forma a se adequar a
limitações de banda de internet existente à época.
Além das técnicas apresentadas de anti-engenharia reversa, alguns autores ainda
citam a técnica de ofuscação. De acordo com You e Yim(58), a característica marcante da
ofuscação é o uso de técnicas de criptografia para ocultar o código executável e dados, o que
torna a tarefa de análise bem mais complicada. A técnica de ofuscação consiste em cifrar o
código executável e, possivelmente, alguma seção de dados. A versão final do binário possui
uma seção de dados cifrados e um código para realizar a decifração, ou seja, o processo de
ofuscação/desofuscação é bem similar ao processo de empacotar/desempacotar. A grande
desvantagem dessa técnica é que as assinaturas de artefatos maliciosos podem ser criadas a
partir do código de decifração. Isso fez com que os autores de malware evoluíssem a técnica
de ofuscação e, com isso, surgiram os malware oligomórficos, polimórficos e metamórficos.
4
Alterações no código original que tragam benefícios para o jogador como, por exemplo, vida infinita.
O malware oligomórfico consegue fazer modificações na rotina de decifração.

Malware polimórficos utilizam diversas técnicas de ofuscação de forma combinada para, de
forma dinâmica, gerar código de decifração diferente a cada evolução. Finalmente, tem-se
os malware metamórficos, que são capazes de reescrever seus códigos polimórficos. Fazem
uma conversão do código polimórfico para uma representação temporária e, em seguida, o
reescrevem. Finalmente, o código é traduzido para linguagem de máquina gerando um
novo código final polimórfico diferente do anterior. Alguns malware polimórficos realizam
a mudança a cada 15-20 segundos. Portanto, pode-se observar uma crescente dificuldade
em se criar uma assinatura baseada no código de decifração para sua detecção.
2.1.3 Análise de Malware

De acordo com Sikorski e Honig(56), pode-se definir 4 etapas de análise de artefatos
maliciosos: Análise Estática Básica, Análise Dinâmica Básica, Análise Estática Avançada
e Análise Dinâmica Avançada. Ao contrário do que o nome sugere, as etapas não são
realizadas em sequência, mas em ciclos, onde as saídas produzidas pelas etapas anteriores
servem de entrada para a próxima etapa. A Figura 8 apresenta as 4 etapas de análise de
malware na forma de um ciclo. Do ponto de vista de nomenclatura, o processo de análise
de artefatos maliciosos como um todo também é chamado de engenharia reversa de código
malicioso.
Figura 8 – Etapas de Análise de Malware na forma de um Ciclo.
A análise estática básica é um processo de análise de um binário de malware sem

executar o código e, geralmente, é realizada para identificar cada componente do mesmo. Na
análise estática básica utilizam-se ferramentas simples, como uma ferramenta de cálculo de
hashes para identificar unicamente o malware, uma ferramente de antivírus para confirmar
se o mesmo possui assinatura conhecida ou a ferramenta strings para obter as sequências
de caracteres do binário. Além disso, exitem outras ferramentas mais elaboradas, como
as que calculam a entropia de cada seção de um executável para Windows ő (PEfile) para
descobrir se o mesmo está empacotado ou cifrado (59) e ferramentas que fornecem a lista
de APIs utilizadas pelo artefato (60). Algumas são capazes de fornecer, ainda, informações
a partir do cabeçalho do arquivo PEFile como data de compilação, lista de imports, lista
de exports, nome das seções e meta informações sobre os recursos do artefato.
A análise dinâmica básica envolve executar o artefato em ambiente controlado,
como uma Sandbox, utilizando, por exemplo, uma máquina virtual devidamente configurada.
A análise dinâmica básica realiza o monitoramento de malware durante a execução ou
realiza a análise do sistema após a execução do malware. Diferentemente da análise estática,
a análise dinâmica permite observar o comportamento real malware, além de ser uma
maneira eficiente de identificar algumas das funcionalidades do malware. No processo de
análise dinâmica básica, o analista tem um papel tipicamente ativo. Um exemplo do papel
do analista no processo de análise dinâmica básica está descrito a seguir:
1. Por meio de monitoramento, o analista percebe que o artefato tenta baixar um

executável da internet;
2. Como o malware está em ambiente controlado, não é possível realizar essa operação;
3. Para seguir a análise, o analista cria um sítio falso, com o mesmo domínio da
requisição e disponibiliza um executável falso para o malware;
4. A análise pode, portanto, prosseguir a partir do momento que o artefato realiza o

download do executável falso.
Diversas ferramentas estão disponíveis para auxiliar o analista durante a análise

dinâmica básica, tais como: Sysinternals Suite (61) e Remnux(62).
A análise estática avançada envolve o uso de um disassembler. A análise é
feita no código do assembly buscando encontrar uma estrutura ou o padrão da atividade
maliciosa. Como geralmente um malware possui muitas linhas de código assembly, a análise
consiste em, inicialmente, dividir o código em funções. Cada função é individualmente
analisada em busca do código responsável pelas atividades maliciosas. A Figura 9 apresenta
um trecho em assembly de uma função de um malware. Pode-se observar que essa função
recebe a quantidade de bytes que ela deve escrever e um endereço5 onde estarão localizados
esses bytes: a função chama a API WriteFile para escrever os bytes no endereço desejado.
Da análise destas informações, pode-se concluir que a função escreve os bytes em um
arquivo e, portanto, pode-se renomeá-la de loc_114C8 para Escreve_Bytes_Arquivo.
5
Esse endereço pode ser um ponteiro para um recurso do sistema operacional (como um arquivo).
Figura 9 – Exemplo de uma função em Assembly que utiliza a API WriteFile.
A análise estática avançada requer um conhecimento técnico avançado da plataforma

de execução do artefato, além de ser uma etapa bastante demorada e, tecnicamente, bem
mais complicada quando comparada à etapa de análise estática básica.
Finalmente, a análise dinâmica avançada envolve o uso de um Assembly De-
bugger que permite a execução de uma ou mais instruções do artefato analisado de forma
controlada. Com isso, o analista pode, por exemplo, executar instrução a instrução do
código assembly e verificar os valores dos registradores e pilha a cada passo. Apesar de ser
bastante lenta, essa fase permite um entendimento mais aprofundado, quando comparado
às outras etapas, do código assembly do artefato em análise. Exige, além dos conhecimentos
citado nas análises anteriores, conhecimentos específicos da ferramenta de debbuger e do
sistema operacional onde o malware é executado.
46
3 APRENDIZADO DE MÁQUINA
Nesta segunda parte do referencial teórico serão apresentados conceitos encontrados

relacionados ao Aprendizado de Máquina e Explicabilidade.As principais fontes utilizadas
foram Raschka(63), Géron(64) e Goodfellow et al.(3).
Para resolver um problema em um computador, desenvolve-se um algoritmo. Um
algoritmo é uma sequência de instruções que deve ser realizada para transformar a entrada
em saída. Por exemplo, em um algoritmo para classificação, a entrada para o algoritmo é
um conjunto de números e a saída do algoritmo uma determinada classe. Para a mesma
tarefa, pode haver vários algoritmos e a escolha por um deles não se limita apenas à lógica
do algoritmo, mas deve-se também considerar o tempo de execução e a quantidade de
consumo de memória (64).
Algumas tarefas, no entanto, não possuem um algoritmo claro para sua solução
(65). Um exemplo simples é a classificação de um e-mail como spam ou legítimocitege-
ron2019hands. Obviamente a entrada (o texto do e-mail) e a saída (spam ou não spam) do
algoritmo são conhecidos. Mas não é trivial como programar um algoritmo com todas as
regras que classificam um texto como spam ou não. Além disso, o que pode ser considerado
um spam para um usuário, para outro usuário pode ser um e-mail legítimo (64).
Pode-se compensar a falta de conhecimento sobre as regras do que é ou não spam
com uma grande quantidade de dados. Provedores do serviço de e-mail possuem uma
imensa quantidade de mensagens já classificados por seus usuários. Nesta abordagem,
para solucionar a tarefa, é necessário um programa que seja capaz de aprender o que é
spam ou não a partir desta base de dados existente. Em outras palavras, deseja-se que o
programa extraía automaticamente o algoritmo para essa tarefa. Deve-se, ainda, fornecer
ao programa uma medida do quão bem ele está aprendendo, ou seja, uma medida do erro.
Esta área de conhecimento, onde programas extraem conhecimento automaticamente para
uma determinada tarefa, denomina-se de aprendizado de máquina.
3.1 Definições e Conceitos de Aprendizado de Máquina

De acordo com Mitchell et al.(66), tem-se a seguinte definição de aprendizado de
máquina: Diz-se que um programa de computador aprende com a experiência E com
relação a alguma classe de tarefas T e medida de desempenho P, se seu desempenho em
tarefas em T, como medido por P, melhora com a experiência E. Já em Samuel(67), tem-se
que aprendizado de máquina é o “campo de estudo que dá aos computadores a capacidade
de aprender sem ser programado explicitamente”. Pode-se, portanto, dizer que a área de
Capítulo 3. Aprendizado de Máquina 47
aprendizado de máquina é o estudo de algoritmos ou modelos matemáticos que são capazes

de melhorar, progressivamente, seu desempenho em uma tarefa específica, a partir de um
conjunto de dados a eles fornecido.
3.2 Tipos de Sistemas de Aprendizado de Máquina

Existem diversos tipos de diferentes sistemas de aprendizado de máquina e é útil
classificá-los conforme alguns critérios (63):
1. Se os sistemas de aprendizado de máquina são ou não treinados com supervisão

humana (supervisionados, não supervisionados, semi-supervisionados e aprendizagem
por reforço);
2. Se os sistemas de aprendizado de máquina podem ou não aprender de forma incre-

mental no tempo (online versus aprendizado em lote);
3. Se os sistemas de aprendizado de máquina trabalham comparando novos pontos de

dados com pontos de dados conhecidos ou, em vez disso, detectam padrões nos dados
de treinamento e constroem um modelo preditivo (sistema baseado em instâncias
versus aprendizado baseado em modelos).
Esses critérios não são exclusivos pois pode-se combiná-los. Por exemplo, um filtro
de spam pode aprender de forma online, usando um modelo de rede neural e treinado a
partir exemplos de spam e e-mails legítimos. Esse é um exemplo de um sistema aprendizado
de máquina supervisionado, online e baseado em modelo.
3.2.1 Aprendizado supervisionado e não supervisionado

Os sistemas de aprendizado de máquina podem ser classificados de acordo com a
quantidade e o tipo de supervisão que recebem durante o treinamento. Existem quatro
categorias principais considerando a supervisão: aprendizado supervisionado, aprendizado
não supervisionado, aprendizado semi-supervisionado e aprendizado por reforço.
No aprendizado supervisionado, inclui-se os rótulos nos dados de treinamento que
são usados para alimentar o algoritmo de aprendizado de máquina. Um exemplo de uma
tarefa de aprendizado de máquina supervisionada é a classificação, como um filtro de spam:
ele é treinado com amostras de e-mails e suas respectivas classes (spam ou legítimo) e
deve aprender como classificar novos e-mails. Outra típica tarefa supervisionada é a de
predizer um valor alvo, como o preço de um imóvel dado um conjuntos de características
chamadas de preditores. Este tipo de tarefa é chamada regressão. Para treinar o sistema,
deve-se fornecer exemplos de imóveis, na forma dos valores dos seus respectivos atributos)
e seus rótulos (preço do imóvel). Com o modelo treinado é possível, a partir dos valores
dos atributos de um novo imóvel, predizer seu preço (63).
Alguns exemplos de algoritmos de aprendizado de máquina supervisionados são: K-
Nearest Neightbors (k-NN) (68), Regressão Linear (69), Regressão Logística (70), Máquinas
de Vetores de Suporte (Support Vector Machines - SVM) (71), Árvores de Decisão (72) e
Redes Neurais (73).
No aprendizado não supervisionado, os dados de treinamento não possuem rótulo:
o sistema tenta aprender sem valores alvo (sem rótulos). Como exemplos de aprendizado
não supervisionado tem-se os algoritmos de agrupamento (k-means (74), Hierarchical
Cluster Analysis (75), Expectation Maximization (76)) e os algoritmos para redução de
dimensionalidade e visualização (Principal Component Analysis - PCA (77), Kernel PCA
(78) e Locally-Linear Embedding - LLE (79)).
De acordo com Jain(80), o objetivo dos algoritmos de agrupamento de dados,
também conhecidos como algoritmos de clusterização, é descobrir o agrupamento natural
de um conjunto de padrões, pontos ou objetos. Por exemplo, a aplicação de algoritmos
de agrupamento em dados de visitantes de um blog pode produzir grupos de visitantes
que possuem interesses em comum. Assim, a partir dos agrupamentos encontrados pelo
algoritmo, pode-se direcionar postagens do blog para grupos específicos que possuam certos
interesses em comum.
No aprendizado semi-supervisionado, tem-se que parte dos dados com rótulos
(geralmente a minoria dos dados) e parte dos dados sem rótulos. A partir de um grande
número de imagens, onde a minoria é rotulada como 1 (possuem um gato) e 0 (não possuem
gato) e a maioria não é rotulada, o algoritmo de aprendizado semi-supervisionado utiliza
as imagens rotuladas para fazer inferências sobre as imagens não rotuladas e decidir sobre
a presença ou ausência de gatos.
Finalmente, no aprendizado por reforço, um agente pode observar o ambiente
- que segue regras pré-definidas - selecionar e executar ações e, como resultado, obter
recompensas ou penalidades. A partir dos resultados de recompensas ou penalidades, o
agente deve, aprender por si só qual a melhor estratégia - chamada política - para obter o
máximo de recompensas. Uma política define qual ação o agente deve escolher em uma
dada situação. Uma técnica bastante conhecida de aprendizado por reforço é o Q-learning
(81). O objetivo do Q-learning é aprender uma política, que diz a um agente qual ação
tomar sob quais circunstâncias - mas ele não requer um modelo do ambiente e pode lidar
com problemas que possuam transições e recompensas estocásticas, sem exigir adaptações.
Um exemplo recente de aprendizado por reforço é o projeto LCZero 1 - uma proposta
que utiliza aprendizado por reforço para desenvolver um programa que joga xadrez. O
1
http://lczero.org
ambiente é definido pelo tabuleiro, movimento das peças e regras do xadrez. Assim, com
base no nas recompensas e penalidades fruto do resultado de milhares de partidas que
o agente joga contra si mesmo, o agente define uma política para efetuar um lance em
dada uma posição. Atualmente, o programa LCZero está entre os melhores programas de
xadrez do mundo2 .
3.2.2 Sistemas de aprendizado online e em lote

Outro critério usado para classificar sistemas de aprendizado de máquina é se ele
pode ou não aprender de forma online a partir de um fluxo contínuo de dados de entrada.
Em sistemas de aprendizado de máquina online, o treinamento do sistema é realizado
de forma incremental, alimentando o mesmo com as novas instâncias sequencialmente -
de forma individual ou por pequenos grupos chamados de minibatches. Assim, o sistema
pode aprender com os novos dados em tempo real. Nestes tipos de sistemas deve-se definir
a taxa de aprendizado, ou seja, a taxa com que o sistema aprenderá a partir das novas
instâncias. Uma taxa de aprendizado alta fará com que o sistema aprenda muito com as
novas instâncias e esqueça rapidamente as amostras antigas. Uma taxa de aprendizado
baixa fará com que o sistema aprenda mais devagar com as amostras novas e mantenha o
aprendizado das amostras antigas (64).
Por outro lado, em sistemas de aprendizado de máquina em lote, o aprendizado deve
acontecer usando todo o dado disponível. Esse tipo de aprendizado de máquina geralmente
leva muito tempo para executar e requer maior poder computacional, quando comparado
com o aprendizado online. Primeiro o sistema é treinado e implantado em produção, onde
não mais ocorre aprendizado. O sistema apenas aplica o que já foi aprendido. Se o sistema
precisa aprender com novos dados, deve-se treinar uma nova versão a partir de todos os
dados (antigos e novos), parar o sistema em produção e substituir o sistema antigo pelo
novo.
3.2.3 Sistemas de aprendizado baseado em instâncias e baseado em modelos

Uma outra forma de categorizar sistemas de aprendizado de máquina é como a
generalização é realizada. Muitos dos sistemas de aprendizado de máquina estão relaci-
onados com tarefas de predição e isso significa que, dado um sistema treinado a partir
de um conjunto de treinamento, ele deve ser capaz de generalizar para instâncias nunca
vistas anteriormente. Ou seja, o verdadeiro propósito não é obter um bom desempenho
no treinamento - ainda que seja um objetivo a ser atingido - mas sim, obter um bom
desempenho nas novas instâncias.
2
https://ccrl.chessdom.com/ccrl/4040/. Acessado em 29/07/2020.
Em sistemas baseados em instâncias, uma nova instância é comparada com as

instâncias já existentes por meio de alguma medida de similaridade. Por exemplo, em um
sistema de detecção de spam, uma nova instância é comparada com instâncias de spam
conhecidas e instâncias de e-mails legítimos conhecidos. Se a nova instância tiver maior
similaridade com um spam ela será considerada um spam e se tiver maior similaridade
com um e-mail legítimo ela será considerada um e-mail legítimo (64). Assim, a forma de
generalizar utilizada é a de construir um modelo a partir do simples armazenamento das
instâncias conhecidas. A generalização de novas amostras será resultado da aplicação de
algum algoritmo de similaridade às novas instâncias.
Um exemplo de sistema de aprendizado de máquina baseado em modelo é o da
regressão linear (69). Uma linha reta modela as instâncias conhecidas e a predição para as
novas amostras é resultado da aplicação do modelo a estas novas amostras. Um exemplo
de um sistema de aprendizado de máquina baseado em instâncias é o k-NN (68).
3.3 Fases de um Sistema Baseado em Aprendizado de Máquina

Na Figura 10 são apresentadas as fases de uma solução de aprendizado de máquina
conforme descrito em Gron(82). Na primeira etapa, deve-se fazer uma análise dos dados de
forma a obter uma visão geral dos mesmo. Na segunda etapa, deve-se analisar a estrutura
dos dados com a finalidade de melhor compreendê-los. A terceira etapa, preparar os dados,
envolve: a limpeza de dados, o processo de lidar com atributos categóricos, o escalonamento
e outras transformações consideradas necessárias. Na quarta etapa, é preciso selecionar
e realizar o treinamento do modelo. Na quinta e última etapa, o modelo é ajustado e
retreinado até que obtenha resultado satisfatório.
Figura 10 – Fases de um Projeto de Aprendizado de Máquina.
Uma visão mais detalhada do processo de treinamento, validação e teste de um

modelo está apresentada na Figura 11. Inicialmente, um modelo é treinado a partir de
um conjunto de dados de treinamento e uma seleção de hiperparâmetros do modelo.
Um modelo intermediário de aprendizado de máquina e o resultado do modelo para o
conjunto de treinamento são obtidos. A este modelo intermediário de aprendizado de
máquina é aplicado o conjunto de dados de validação para a obtenção do resultado para
este conjunto. Se o resultado do modelo intermediário não estiver satisfatório, uma nova
seleção de hiperparâmetros é realizada e o processo é reiniciado. Se o resultado no conjunto
de validação atende às expectativas, então o modelo final de aprendizado de máquina é

treinado utilizando o conjunto de dados de treinamento e validação. A este modelo final
é aplicado o conjunto de testes e obtido um resultado. Este resultado é a estimativa do
resultado do modelo para um ambiente de produção.
Figura 11 – Visão Geral Treinamento, Validação e Teste de um modelo de aprendizado de

máquina.
3.4 Aprendizado Profundo

O Aprendizado Profundo é um subcampo específico do Aprendizado de Máquina
que cria uma nova abordagem baseada em representações a partir de dados brutos
enfatizando o aprendizado por meio de camadas sucessivas de representações cada vez
mais significativas (4). O aprendizado de representação é um conjunto de métodos que
permite que uma máquina seja alimentada com dados brutos e descubra, automaticamente,
as representações necessárias para detecção ou classificação (83). A Figura 12 apresenta
uma visão hierárquica do conceito de aprendizado profundo considerando outros conceitos
similares.
O termo deep de aprendizado profundo (deep learning) está relacionado com a
ideia de muitas camadas sucessivas de representações onde o número de camadas de um
modelo é chamado de profundidade do modelo. Como cada camada aprende representações
sucessivas mais significativas, aprendizado profundo ou deep learning pode ser chamado,
Figura 12 – Hierarquia do Aprendizado profundo frente a outros conceitos da área. Fonte:

Goodfellow et al.(3).
portanto, de aprendizado de representações hierárquicas. Uma outra abordagem bastante

comum, que utiliza apenas poucas camadas, é denominada arquitetura superficial (shallow).
As técnicas convencionais de aprendizado de máquina são limitadas em sua capaci-
dade de processar dados em sua forma bruta, como o valor de pixel de uma imagem. Em
outras palavras, algoritmos de aprendizado de máquina necessitam que se realize uma
engenharia de características (feature engineering), ou seja, é preciso que um especialista
na área de domínio defina quais características, extraídas do dado bruto, são interessantes
para determinada tarefa. O aprendizado profundo, por outro lado, permite que modelos
computacionais compostos de múltiplas camadas de processamento aprendam representa-
ções de dados brutos com múltiplos níveis de abstração de forma automática (83), ou seja,
são capazes de realizar a engenharia de características de forma automática.
Do ponto de vista arquitetural, as representações hierárquicas na forma de camadas,
baseadas em modelos de redes neurais, são empilhadas umas sobre as outras. Na Figura
13, tem-se um exemplo de uma arquitetura que transforma uma imagem de um dígito em
uma saída numérica(número 4). Apesar de usar apenas poucas camadas escondidas, ela
serve para ilustrar a hierarquia de representações ao longo das camadas.
Na Figura 14 está apresentado um exemplo das representações de cada camada.
A rede transforma a imagem digitalizada em representações cada vez mais diferentes da
imagem original e cada vez mais informativas sobre o resultado final. A representação final,
que é a representação da última camada, é a predição da rede - neste caso, o número 4.
Assim, arquiteturas de aprendizado profundo atuais envolvem dezenas ou até
centenas de camadas sucessivas de representações. Na competição ImageNet Large Scale
Visual Recognition Challenge, por exemplo, a solução vencedora em 2012, AlexNet (22),
possuía 5 camadas convolucionais e 3 camadas completamente conectadas; a solução
Figura 13 – Exemplo de uma arquitetura de camadas que transforma uma imagem de

entrada em uma saída (número 4). Fonte: (4).
Figura 14 – Exemplo da representações em cada camada. Fonte: (4).
vencedora em 2013, ZFnet (84) tinha a mesma quantidade de camadas da AlexNet. No

entanto, a solução vencedora em 2014, GoogleNet (85), possuía 22 camadas. Já em 2015, a
solução vencedora, ResNET (12), possuía 152 camadas.
3.4.1 Redes Neurais Completamente Conectadas

Redes Neurais Completamente Conectadas realizam a transformação de uma
entrada por meio de uma série de camadas ocultas, onde cada camada é composta de um
conjunto de neurônios e cada camada é totalmente conectada a todos os neurônios da
camada anterior. Na Figura 15 tem-se um exemplo de uma rede neural completamente
conectada com uma camada de entrada (input layer), duas camadas escondidas (hidden
layer) e uma camada de saída (output layer).
A saída da primeira camada escondida é dada por f (W.x + b), onde W é uma
matriz de pesos aprendidos, x é a entrada, b é o bias (não representado na figura) e f é
Figura 15 – Rede Neural Completamente Conectada. Figura baseada em

http://cs231n.github.io/convolutional-networks/.
uma função de ativação. A saída da primeira camada escondida faz papel de entrada para
a segunda camada escondida, e assim por diante.
Redes neurais completamente conectadas podem ser superficiais (shallow) ou
profundas (deep). Não há realmente um consenso sobre a definição de uma rede neural
superficial, mas considera-se uma rede neural com uma camada oculta é considerada uma
rede neural superficial, enquanto uma rede com muitas camadas ocultas e um grande
número de neurônios em cada camada é considerada profunda.
Redes Neurais não são um assunto novo. De fato, em 1943, Warren McCulloch e
Walter Pitts desenvolveram o modelo matemático de uma rede neural artificial usando
lógica de limiar (threshold logic) (86). Em 1958, Frank Rosenblatt criou o modelo Per-
ceptron que foi o primeiro a realizar tarefas de reconhecimento de padrões. Em 1959,
Widrow e Hoff desenvolveram o modelo chamado ADALINE - a primeira rede neural a ser
aplicada a problemas reais. Finalmente, em 1975, Paul Werbos desenvolveu o algoritmo de
backpropagation para resolver o problema do XOR no modelo Perceptron. Nos últimos
anos, diversos avanços ocorreram de forma a permitir que redes profundas pudessem ser
implementas. Um dos problemas resolvidos foi o da dissipação do gradiente, que está
relacionado com o uso de funções de ativação similares à sigmoide em redes neurais.
A função de ativação é uma função matemática localizada, em uma arquitetura
baseada em redes neurais, entre a entrada e a saída do neurônio. Pode ser tão simples
quanto uma função que liga ou desliga a saída do neurônio ou pode ser uma transformação
mais complexa. Funções de ativação típicas de modelos tradicionais de redes neurais são as
funções sigmóide e tanh (tangente hiperbólica). A Figura 16 apresenta a função sigmóide
e a função tanh.
Um problema com as funções sigmóide e tanh é que elas saturam, ou seja, valores
grandes de entrada x produzem valores de saída muito próximos de 1,0 e valores excessiva-
mente negativos produzem valores próximos de -1 para tanh ou 0 para sigmóide. De fato,
Figura 16 – Função de ativação sigmóide (esquerda) e tanh (direita)
em Goodfellow et al.(3),
“. . . Unidades sigmoidais saturam na maior parte de seu domínio - saturam

para um valor alto quando x é muito positivo, saturam para um valor baixo
quando x é muito negativo e só são fortemente sensíveis à sua entrada quando
x está próximo de 0.”
No aprendizado de máquina, usa-se a descida gradiente para atualizar os parâmetros

do modelo e a função a ser minimizada é a denominada função de custo. A descida do
gradiente é um algoritmo de otimização usado para minimizar algumas funções movendo-se
iterativamente na direção da descida mais íngreme, conforme definido pelo negativo do
gradiente. Para propagar esse erro por diversas camadas de uma rede neural se utiliza o
back-propagation (87).
O erro é retro propagado (backpropagation) pela rede para atualizar os pesos.
Quando se calcula um gradiente na zona de saturação das funções de ativação sigmodais,
obtém-se valores muito próximos de zero. E como a atualização dos pesos da rede é
proporcional ao gradiente, tem-se uma atualização pequena (ou quase nula) na zona
de saturação. Esse problema se agrava drasticamente a cada camada adicional: o valor
de atualização é o produto dos valores de atualização de cada camada, e, portanto, ele
fica cada vez mais próximo de zero quanto maior o número de camadas. E valores de
atualização zero ou próximo de zero, fazem com que os pesos não sejam atualizados,
deixando o aprendizado da rede estagnado. Este problema denomina-se dissipação de
gradiente (vanishing gradient) e, ele impede que redes profundas, efetivamente, aprendam.
A função ReLU - Rectified Linear Unit - e suas variações são funções de ativação
não lineares que resolvem exatamente este problema de dissipação de gradiente: para
valores x > 0 o gradiente é 1 para valores x < 0 o gradiente é zero. Como não há derivada
para x = 0, escolhemos, durante a implementação, o valor de gradiente 1 ou 0. De fato,
em Goodfellow et al.(3) pode-se encontrar:
“.. grande mudança algorítmica que melhorou bastante o desempenho das redes
feedforward foi a substituição de unidades sigmóides por unidades lineares
retificadas.”
Matematicamente, a ReLU pode ser definida como y = max(0, x) e é apresentada na

Figura 17.
Figura 17 – Função de ativação ReLU.
A utilização da função ReLU para resolver o problema de dissipação de gradiente em

redes profundas foi um dos avanços que ocorreu nesta área. As redes neurais completamente
conectadas utilizam, comumente, funções de ativação como a ReLu ou suas variações (88).
3.4.2 Redes Neurais Convolucionais

Redes neurais Convolucionais representam bem a capacidade de redes profundas
de realizar a engenharia de atributos de forma automática. A Figura 18, apresenta um
comparativo entre o processo geral de algoritmos de aprendizado de máquina e o processo
geral do aprendizado profundo. No caso do aprendizado de máquina, uma entrada -
representada na forma de um artefato malicioso - é apresentada ao sistema. Em seguida,
deve-se realizar a extração de características, pré-definidas por um especialista, a ser
utilizado pela etapa de classificação, ou seja, deve-se realizar a engenharia de atributos.
Assim, os atributos selecionados do artefato malicioso são extraídos e apresentados para a
camada de classificação que predirá a família do artefato malicioso (no exemplo, família
Vundo). No caso do aprendizado profundo, o mesmo artefato malicioso é apresentado à
arquitetura. Ao contrário do aprendizado de máquina convencional, a extração de atributos,
aprendida durante o treinamento pelo sistema, é realizada automaticamente (representado
em nós azuis), sem a intervenção de um especialista. Em um segundo momento, esses
atributos extraídos de forma automática são apresentados para a camada de classificação
(nós vermelhos) que, finalmente, realizam predição da família do artefato (Vundo).
Figura 18 – Processo Geral do Aprendizado de Máquina e do Aprendizado Profundo
As Redes Neurais Convolucionais (ConvNet) trabalham, portanto, de forma um

pouco diferente quando comparadas às Redes Completamente Conectadas: as camadas de
engenharia de atributos são organizadas em 3 dimensões: largura, altura e profundidade.
Além disso, os neurônios destas camadas não se conectam a todos os neurônios da camada
seguinte, mas apenas a uma pequena região desta. Após as camadas de engenharia de
atributos, tem-se a camada de rede neural completamente conectada que é adicionada
para realizar a classificação e produzir as predições. Em outras palavras, uma Rede Neural
Convolucional é um algoritmo de aprendizado profundo que pode captar uma entrada,
atribuir relevância (pesos e vieses que podem ser aprendidos) a vários aspectos/objetos da
imagem e ser capaz de classificá-los(3).
Uma arquitetura de rede neural convolucional é composta, comumente, por:
1. Entrada: geralmente uma imagem composta de canais.
2. Rede Neural Convolucional: uma ou mais camadas responsáveis pela engenharia

de atributos e compostas por:
a) Camada de Convolução: onde são aplicadas a operação de convolução, os Filtros

ou Kernels e a função de ativação (geralmente ReLu).
b) Camada de Pooling
3. Rede Neural Completamente Conectada: responsável pela classificação e pre-

dição dos resultados desejados.
A entrada de uma rede convolucional é uma matriz de tamanho definidos pela

quantidade de pixeis da largura e da altura e os canais. Caso a imagem seja colorida, os
canais são o RGB (red, green, blue). Cada ponto, da matriz de tamanho altura x largura,
tem um valor inteiro entre 0 e 255. A Figura 19 apresenta uma imagem com os 3 canais
RGB, largura de 4 unidades e altura de 4 unidades
Figura 19 – Exemplo de Imagem de Entrada RGB (3 canais) com 4 pixeis de largura e 4

pixeis de altura.
Na camada de convolução são aplicadas a operação de convolução da imagem

com os filtros, a função de ativação e operação de pooling. A Figura 20 apresenta um
exemplo de uma operação de convolução: o filtro ou kernel K de tamanho 3x3 (em azul)
é aplicado a uma região da imagem (em vermelho) e o produto é realizado ponto a
ponto e somado, resultando em um escalar (I ∗ K, em verde). Após ser aplicado a uma
região, o filtro é deslocado em uma unidade (stride=1) para direita e, após ser aplicado
na extremidade direita, o processo recomeça na extremidade esquerda, deslocando uma
unidade para baixo. O valor do stride para aplicação do filtro é um hiperparâmetro a
ser definido pelo projetista da arquitetura de redes convolucionais. Assim, a Figura 20
representa um filtro de tamanho 3x3 realizando a operação de convolução numa imagem
com um único canal de tamanho 7x7.
Figura 20 – Exemplo de Operação de Convolução onde um filtro K (azul) de tamanho

3x3 é aplicado em uma região da imagem I de um único canal e produzindo
I ∗K .
A operação de convolução funciona de maneira similar em imagem com mais de

um canal e ou quando é aplicado mais de um filtro. A Figura 21 apresenta, um exemplo
da aplicação de dois filtros de tamanho 3x3x3 em uma imagem com de largura 6, altura 6
e profundidade 3. O filtro sempre terá a mesma profundidade da imagem de entrada e, por
isso, alguns autores apresentam o tamanho do filtro apenas com largura e altura (3x3). O
resultado da aplicação de um dos filtros é uma imagem de tamanho 4x4 e profundidade 1.
Assim, o resultado da aplicação de cada filtro é concatenado de forma a produzir uma
saída de dimensão 4x4x2, onde 2 é o número de filtros.
Figura 21 – Aplicação de 2 Filtros de tamanho 3x3x3 em uma imagem de tamanho 6x6x3.

O resultado possui dimensão 4x4x2.
A aplicação da operação de convolução apresenta dois problemas: diminuição do

tamanho da saída e perda de informações nos cantos da imagem. Assim, antes de se
aplicar a operação de convolução a uma imagem, é possível realizar o padding da mesma.
O padding estende a área da qual uma rede neural convolucional processa uma imagem,
ao preencher o entorno desta com valores zero. Na Figura 22, tem-se um exemplo de um
padding de valor 1 sendo aplicado a uma imagem de dimensão 5x5. O objetivo do padding
é permitir mais espaço para a operação de convolução dos filtros.
Figura 22 – Exemplo de aplicação de Padding de valor 1 em uma imagem de tamanho

4x4.
Assim, ao atenuar ou evitar a diminuição do tamanho da saída de uma operação

de convolução, o padding permite o uso de uma quantidade maior de camadas. A escolha
do valor de padding depende da arquitetura e da complexidade das imagens de entrada.
Após uma camada de convolução é possível realizar a operação de pooling. A
operação de pooling é similar a operação de convolução com um filtro: no entanto, em
vez de se realizar operações de multiplicação e adição, deve-se apenas selecionar o maior
valor (Max Pooling), o valor médio (Average Pooling) ou o menor valor (Min Pooling).
A Figura 23 apresenta um filtro de tamanho 2x2 e um passo (stride) de 2. No primeiro
caso (a) tem-se um exemplo de Max Pooling e no segundo caso (b) tem-se um exemplo de
Average Pooling, ambos aplicados a uma imagem de tamanho 4x4.
Figura 23 – Exemplo de aplicação de Max Pooling (a) e Average Pooling onde o filtro tem
tamanho 2x2 e o stride é 2.
A Figura 24 apresenta uma imagem em tom de cinza com fundo branco (pixeis
com valores 255) e o resultado da aplicação de pooling utilizando o Average Pooling, o
Max Pooling e o Min Pooling. O método de Average Pooling suaviza a imagem e, portanto,
o resultado é uma imagem com menor nitidez. O Max Pooling seleciona os pixeis mais
brilhantes da imagem e o o resultado é a perda de características interessantes da imagem
original. A aplicação do Min Pooling resultou em um destaque das principais características
da imagem.
O resultado da aplicação de Max Pooling e Min Pooling seriam invertidos caso a
imagem fosse números brancos com fundo preto e, portanto, ambos funcionam como um
supressor de ruído(3), ou seja, eles descartam completamente a ativação ruidosa, mantendo
somente um único valor. Portanto, deve-se selecionar a técnica de pooling de acordo com a
imagem de entrada.
Além de filtrar a imagem de entrada, a técnica de pooling é utilizada para reduzir
o tamanho das representações e acelerar os cálculos durante o treinamento e predição da
rede. O resultado de uma camada de pooling é, portanto, um volume com largura e altura
menores que a representação de entrada. De fato, no exemplo da Figura 23, a redução é
de 75% da quantidade de informação.
Uma camada da etapa de engenharia de atributos de uma rede convolucional é
Figura 24 – Exemplo da aplicação de Pooling com Average Pooling, Max Pooling e Min
Pooling em uma imagem.
composta, normalmente, por uma camada de convolução e uma camada de pooling e, além
disso, a etapa de engenharia de atributos possui, comumente, diversas camadas. O resultado
da última camada da etapa de engenharia de atributos de uma rede convolucional, que é
um volume de tamanho L × A × P , onde L é a largura, A é a altura e P é a profundidade,
é achatada de forma a gerar um vetor de tamanho (L × A × P ) por 1. Esta operação é
denominada achatamento ou flatten. Este vetor é a entrada para a etapa de classificação
da rede neural convolucional, que nada mais é que uma rede completamente conectada.
Na Figura 25 tem-se um exemplo do processo de achatamento. A saída da última
camada de engenharia de atributos (camada convolucional) produz um resultado de
dimensão 3x3x3. O processo de achatamento transformará esse cubo em um vetor de 9x1.
Figura 25 – Exemplo de achatamento realizado entre a camada de engenharia de atributos

e a camada de classificação. Figura baseada em Ng et al.(5).
Na Figura 26, é apresentado um exemplo de uma arquitetura de uma rede convo-

lucional com duas camadas na etapa de engenharia de atributos e duas camadas na
etapa de classificação. A entrada para a rede convolucional é uma imagem de dimensão

28x28 com 3 canais.
A primeira camada da etapa de engenharia de atributos é composta por uma
camada de convolução com 20 filtros de tamanho 5x5x3 (stride 1) e uma camada de max
pooling com filtros de tamanho 2x2 e stride 2. A segunda camada da etapa de engenharia
de atributos é composta por uma camada de convolução com 50 filtros de tamanho 5x5
(stride 1) e uma camada de max pooling com filtros de tamanho 2x2 e stride 2. Em seguida,
o resultado da última camada da etapa de engenharia de atributos, que possui volume
4x4x50 é achatada, gerando um vetor de entrada para a etapa de classificação de tamanho
1x800.
Figura 26 – Exemplo de uma arquitetura de uma rede neural convolucional. A quantidade

de filtros ilustrada na figura é apenas simbólica. Referência (6).
A primeira camada da etapa de classificação da rede neural completamente

conectada é composta por 10 neurônios que estão completamente conectados com as
800 entradas. Assim, o resultado dessa arquitetura é um vetor de dimensão 10x1. Essa
arquitetura foi utilizada para predizer dígitos manuscritos em imagens de tamanho 28x28
e é conhecida como Lenet-5 (6).
3.4.3 Dropout
De acordo com Srivastava et al.(89), o Dropout é uma técnica para resolver o
problema de sobreajuste (overfitting). A ideia principal é descartar aleatoriamente conexões
de uma camada de uma rede neural durante o treinamento. O valor de Dropout d varia
entre 0 e 0,5 e um valor de Dropout de d = 0, 25 descarta um quarto de suas conexões
para uma determinada camada. Durante o treinamento, o Dropout ameniza o efeito da
coadaptação e do sobreajuste
A coadaptação acontece quando, em algum momento durante o treinamento,
algumas poucas conexões obtém maior capacidade preditiva que outras. Desta forma,
conforme a rede é treinada, estas conexões com maior capacidade preditiva sofrem maior
adaptação e as conexões com menor capacidade preditiva sofrem menor adaptação. A

partir de então, conforme ainda durante o treinamento, os ajustes de peso são realizados
de forma que as conexões fortes contribuam cada vez mais para a predição e as conexões
fracas contribuam cada vez menos para a predição, causando, portanto, um sobreajuste.
Métodos comuns de regularização como L1 e L2 não são capazes de resolver o problema
da coadaptação, pois eles se baseiam na capacidade preditiva do modelo como um todo,
ou seja, a regularização dos pesos é aplicada a todas conexões e não às conexões mais
fortes ou mais fracas(89, 90, 91).
A Figura 27 apresenta um exemplo da aplicação de Dropout em uma rede neural
completamente conectada, durante o treinamento. A esquerda da Figura tem-se uma
rede neural completamente conectada sem Dropout e a direita tem-se a aplicação de um
Dropout de 0,25 na mesma arquitetura, ou seja, um quarto das conexões são desabilitadas.
Normalmente, a escolha sobre quais conexões sofrerão Dropout é feita de forma aleatória a
cada amostra de treinamento(3).
Figura 27 – Exemplo de Dropout aplicado a uma rede neural completamente conectada
Durante o teste ou predição, não há Dropout de conexões e os valores de saída

dos neurônios são multiplicados por 1 − d. Na Figura 28 está apresentado quais seriam os
valores de saída da primeira conexão da primeira camada de uma rede completamente
conectada considerando d = 0, 25.
Intuitivamente, cada conexão de uma camada com Dropout tem d de probabilidade
de estar conectada durante um minibatch de treinamento e, desta forma, o neurônio que
desta conexão tem d de probabilidade de sofrer atualização dos pesos, atenuando os efeitos
da coadaptação e, portanto, do sobreajuste.
Utilizando a distribuição de probabilidade de Bernoulli para modelar o Dropout, é
possível provar que o efeito do Dropout para o valor esperado do gradiente (calculado para
a atualização dos pesos) é igual ao gradiente de uma rede regularizada. Isso significa que
aplicar o Dropout é equivalente a minimizar uma rede regularizada(91, 92, 89).
Figura 28 – Dropout aplicado durante predição de uma Rede neural completamente conec-
tada.
3.4.4 Normalização em Lote

A normalização em lote (Batch Normalization), proposto por Ioffe e Szegedy(93),
é um método usado para tornar as redes neurais artificiais mais estáveis por meio da
normalização dos valores da camada de entrada de cada camada escondida. Cada camada
de uma rede neural possui entradas com uma distribuição correspondente, que é afetada
durante o processo de treinamento pela aleatoriedade da inicialização de parâmetros e dos
dados de entrada. O efeito destas fontes de aleatoriedade na distribuição das entradas
para as camadas internas durante o treinamento é descrito como covariate shift. Assim, o
covariate shift refere-se à mudança na distribuição dos valores de entrada para um algoritmo
de aprendizagem e a razão para o covariate shift ser um problema é que o comportamento
do algoritmo de aprendizado de máquina pode mudar quando a distribuição da entrada
muda(3, 93).
Este é um problema que não é exclusivo do aprendizado profundo: se os conjuntos
de treinamento e teste vierem de fontes totalmente diferentes (por exemplo, imagens
de fontes diferentes como câmeras profissionais e smartphones), as distribuições seriam
diferentes.
Assim, a ideia básica por trás da normalização em lote é limitar os efeitos do
covariate shift ao normalizar as ativações de cada camada de forma a se obter uma
distribuição com média zero e variância um. Uma versão mais sofisticada da normalização
em lote permite o aprendizado de parâmetros γ e β que podem definir a média e variância
da camada para quaisquer valores. No Algoritmo 1 tem-se a descrição da normalização em
lote. Neste algoritmo, é uma constante adicionada à variância do lote para estabilidade
numérica(93).
Algorithm 1: Normalização em Lote
Result: yi = N Lγ,β (xi )
Input: Valores de x do lote Λ = x0 ,x1 ,...,xn ;
Parâmetros a serem aprendidos: γ,β;
Carregar Lote Λ ;
µΛ ← m1 m i=1 xi ;
P
1 Pm
σΛ ← m i=1 (xi − µΛ )2 ;
2
xi −µΛ
x̂i ← √ σ 2 +
;
yi ← γ × x̂i + β ≡ N Lγ,β (xi )
Com isso, o resultado da aplicação de normalização em lote em uma determinada

camada produzirá uma distribuição com média β e variância γ mais adequados para a
tarefa de classificação ou regressão.
Considere uma função de perda f (w) multivariável que será otimizada utilizando
o gradiente descendente, onde w são os pesos desta função. Para fins de simplificação,
considere a expansão de Taylor de segunda ordem da função f multivariável em torno dos
pesos(3):
f (w + δw) ≈ f (w) + g T δw + 12 (δw)T H(δw)
Onde g é o vetor gradiente de f (w) e H é a matriz Hessiana de f (w) dados por:
∂f (w)
 
 ∂w1 
 ∂f (w) 
g = ∇f (w) = f (w) = . 
d
 ∂w2 
 .. 
 
dw
 
∂f (w)
∂wN
∂ 2 f (w) ∂ 2 f (w)
 
∂w1 ∂w1
... ∂wN ∂w1
∂ 2 f (w) ∂ 2 f (w)
 
 
H = Hf (w) = d
g (w) = ∂w2 ∂w1 ∂wN ∂w2
 
dw f

.. .. 
. .
 
 
 
∂ 2 f (w) ∂ 2 f (w)
∂wN ∂w1
... ∂wN ∂wN
Considere, portanto, a expansão de Taylor em torno dos pesos atuais w0 :

f (w) ≈ f (w0 ) + (w − w0 )T g + 12 (w − w0 )T H(w − w0 )
No gradiente descendente, w − w0 = g onde é a taxa de aprendizado. Assim,
tem-se que:
f (w0 − g) ≈ f (w0 ) − g T g + 12 2 g T Hg
Quando a função f (w) é linear, o termo 12 2 g T Hg é zero, pois as derivadas parciais
de segunda ordem serão zero resultando em uma parcela nula. No caso de funções f (w)
não lineares, com o é o caso em aplicações de aprendizado profundo, a matriz Hessiana e o
gradiente de 12 2 g T Hg representam o efeito da curvatura da função f (w) no ponto w0 : se a

curvatura é pequena, o gradiente é quase constante e um valor de grande ainda resultaria
em diminuição de perda. No entanto, quando a curvatura é grande, o gradiente muda
rapidamente e valores altos de poderiam aumentar a perda. Neste caso, se o gradiente é
o autovetor de H com o maior autovalor, a parcela 12 2 g T Hg poderia resultar em valores
superiores ao de g T g. Assim, a única forma de garantir que g T g é maior que 12 2 g T Hg é
utilizando um valor de pequeno ou decrementando o valor de ao longo do aprendizado.
Assim, na normalização em lote, ao tornar a média e a variância das ativações de
cada camada independentes dos próprios valores, o valor absoluto do termo 12 2 g T Hg será
pequeno, permitindo que maiores taxas de aprendizado sejam usadas. Uma interpretação
similar pode ser utilizada se utilizarmos termos de ordens superiores a segunda ordem na
expansão de Taylor.
3.4.5 Global Average Pooling

Para classificação de imagens utilizando arquiteturas de redes convolucionais, é
comum que a arquitetura seja composta por um conjunto de camadas convolucionais
seguida por um conjunto de camadas completamente conectadas. e finalmente uma camada
de softmax Um exemplo deste tipo de modelo é a V GG16. A estrutura desta arquitetura
produzida pelo keras está apresentada na Listagem 3.4.5.
_________________________________________________________________
Layer ( t y p e ) Output Shape Param #
=================================================================
input_1 ( I n p u t L a y e r ) ( None , 2 2 4 , 2 2 4 , 3 ) 0
_________________________________________________________________
block1_conv1 ( Conv2D ) ( None , 2 2 4 , 2 2 4 , 6 4 ) 1792
_________________________________________________________________
block1_conv2 ( Conv2D ) ( None , 2 2 4 , 2 2 4 , 6 4 ) 36928
_________________________________________________________________
b l o c k 1 _ p o o l ( MaxPooling2D ) ( None , 1 1 2 , 1 1 2 , 6 4 ) 0
_________________________________________________________________
block2_conv1 ( Conv2D ) ( None , 1 1 2 , 1 1 2 , 1 2 8 ) 73856
_________________________________________________________________
block2_conv2 ( Conv2D ) ( None , 1 1 2 , 1 1 2 , 1 2 8 ) 147584
_________________________________________________________________
b l o c k 2 _ p o o l ( MaxPooling2D ) ( None , 5 6 , 5 6 , 1 2 8 ) 0
_________________________________________________________________
block3_conv1 ( Conv2D ) ( None , 5 6 , 5 6 , 2 5 6 ) 295168
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________

_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
_________________________________________________________________
b l o c k 5 _ p o o l ( MaxPooling2D ) ( None , 7 , 7 , 5 1 2 ) 0
_________________________________________________________________
f l a t t e n ( Flatten ) ( None , 2 5 0 8 8 ) 0
_________________________________________________________________
f c 1 ( Dense ) ( None , 4 0 9 6 ) 102764544
_________________________________________________________________
f c 2 ( Dense ) ( None , 4 0 9 6 ) 16781312
_________________________________________________________________
p r e d i c t i o n s ( Dense ) ( None , 1 0 0 0 ) 4097000
=================================================================
T o t a l params : 1 3 8 , 3 5 7 , 5 4 4
T r a i n a b l e params : 1 3 8 , 3 5 7 , 5 4 4
Non−t r a i n a b l e params : 0
Da Listagem, pode-se observar que dos 138.357.544 parâmetros, 123.642.856 são

das camadas completamente conectadas (f c1, f c2 e predictions). Juntas, as camadas
completamente conectadas respondem por 89% de todos os parâmetros treináveis. Particu-
larmente primeira camada completamente conectada é responsável por 74% de todos os
parâmetros treináveis. A quantidade de parâmetros da primeira camada completamente
conectada f c1 é calculada como a quantidade de parâmetros da camada f latten adicionado
de 1 e multiplicado por 4096, ou seja, (25088 + 1) × 4096. Ainda, camadas completa-
mente conectadas estão sujeitas a sobreajuste (overfitting), dificultando a generalização da
capacidade da rede geral(91).
Assim, arquiteturas como V GG16, que possuem alta concentração dos parâmetros
treináveis nas camadas completamente conectadas, correm um risco de sofrer sobreajuste.
Desta forma, em Lin, Chen e Yan(94), o autor propõe o uso de Global Average Pooling
(GAP) para minimizar o sobreajuste e reduzir o número total de parâmetros de um modelo.
Similar ao Max Pooling, camadas GAP servem para reduzir a dimensão espacial dos
tensores (saídas das camadas convolucionais, dada por altura, largura e profundidade). No
caso das camadas GAP, uma saída de h × l × p é reduzida para 1 × 1 × p, utilizando a
função média (average) nas p imagens de tamanho h × l.
Na Figura 29 está ilustrada a aplicação de uma camada de GAP a um tensor de
dimensão 6 × 6 × 3 produzindo um tensor de dimensão 1 × 1 × 3
Finalmente, para exemplificar, se uma camada GAP fosse aplicada na arquitetura
V GG após a camada block5_pool (antes da camada f latten) o tensor de saída de dimensão
7 × 7 × 512 resultaria em um tensor de dimensão 1 × 1 × 512 e, a camada f latten teria
Figura 29 – Exemplo Global Average Pooling. Fonte (7)
tamanho 512 (e não 25.088). Desta forma a primeira camada completamente conectada
teria (512 + 1) × 4096 = 2.101.248, ou seja, as camadas completamente conectadas
teriam 22.979.560: uma redução de mais de 80% na quantidade de parâmetros da camada
completamente conectada.
3.4.6 Aprendizado por Transferência

O aprendizado de transferência é um método de aprendizado de máquina em que
um modelo desenvolvido para uma tarefa é reutilizado, como ponto de partida, para
desenvolver um modelo para uma segunda tarefa. De acordo com Goodfellow et al.(3)
“O aprendizado por transferência e a adaptação do domínio se referem à

situação em que o que foi aprendido em um cenário . . . é explorado para
melhorar a generalização em outro cenário”.
Ainda, de acordo com Olivas(95),
“Aprendizado por transferência é a melhoria do aprendizado em uma nova

tarefa através da transferência de conhecimento de uma tarefa relacionada que
já foi aprendida.”
De qualquer forma, o aprendizado por transferência é eficaz apenas se os atributos

do modelo aprendidos na primeira tarefa forem genéricos o suficiente para serem aplicados
em outros problemas. Assim, no aprendizado de transferência, primeiro uma arquitetura
básica em um conjunto de dados para uma tarefa específica é treinado e, em seguida,
redireciona-se os atributos aprendidos, para uma segunda arquitetura de destino a ser
treinada em um conjunto de dados para uma outra tarefa.
Na Figura 30 tem-se um exemplo de aprendizado por transferência. A arquitetura

(a) foi treinada, por exemplo, com imagens para realizar a tarefa de classificação em
1000 diferentes categorias. A arquitetura (b) utiliza os pesos aprendidos das camadas
convolucionais de (a) e acrescenta uma arquitetura de rede completamente conectada para
classificação. Para a nova tarefa, por exemplo, de classificação de artefatos maliciosos
em 9 famílias, a arquitetura apresentada em (b) aproveita os atributos das camadas
convolucionais aprendidos durante o treinamento da arquitetura apresentada em (a) e,
portanto, somente os pesos da camada de classificação de (b) serão aprendidos na nova
tarefa.
Figura 30 – Exemplo aprendizado por transferência onde o aprendizado das camadas

convolucionais de (a) é aproveitado na arquitetura (b).
A literatura não define tipos de aprendizado por transferência e, especialmente para

arquiteturas neurais convolucionais, pode-se realizar o aprendizado por transferência de
diversas formas. De forma a ser mais preciso na utilização da transferência de aprendizado
definiu-se que a arquitetura original é onde se realiza o treinamento propriamente dito
e a arquitetura secundária é onde se realiza o aprendizado por transferência. Assim,
estabeleceu-se 3 tipos de aprendizado por transferência para redes convolucionais:
• Transferência por Inicialização: a arquitetura secundária inicializa todos os

pesos utilizando os pesos aprendidos na arquitetura original. Possivelmente, a última
camada de classificação da arquitetura secundária não é igual à da arquitetura
original e, portanto, seus pesos são inicializados de forma aleatória. Todos os pesos
da arquitetura secundária podem ser modificados durante o processo de
aprendizagem;
• Transferência de Atributos: a arquitetura secundária aproveita a arquitetura e

pesos da camada de engenharia de atributos da arquitetura original. A camada de
classificação da arquitetura secundária pode ser totalmente diferente da camada de
classificação da arquitetura original e, portanto, os pesos são inicializados de forma
aleatória. Os pesos da camada da arquitetura de engenharia de atributos
não são modificados no processo de aprendizagem;
• Transferência Parcial de Atributos: a arquitetura secundária aproveita a arqui-

tetura da camada de engenharia de atributos da arquitetura original, mas apenas
uma parte dos pesos é transferida e congelada na arquitetura secundária.
A camada de classificação da arquitetura secundária pode ser totalmente diferente da
camada de classificação da arquitetura original e, portanto, os pesos são inicializados
de forma aleatória;
71
4 ANÁLISE AUTOMATIZADA DE MALWARE
4.1 Soluções de Análise Automatizada de Malware

Soluções automatizadas de análise de malware, possuem problemas intrínsecos mais
desafiadores quando comparados com a análise manual de artefatos. De fato, por não
existir nenhum tipo de interferência humana, uma solução automatizada tem limitada
capacidade de transpor obstáculos impostos pelos artefatos maliciosos e tais obstáculos
podem ser encontrados tanto em soluções automatizadas que realizam análise dinâmica
quanto as de análise estática.
Para exemplificar, considere a análise do comportamento de um artefato malicioso
do tipo Downloader durante sua execução em um ambiente controlado. Um dos comporta-
mentos típicos a ser observado pelo analista é que o artefato tenta transferir um ou mais
arquivos de um servidor remoto para um computador local. Como o ambiente é controlado
(Sandbox), o artefato malicioso não consegue executar esta tarefa1 . Desta forma, a análise
estaria estagnada, pois o artefato não é possível reproduzir todos os comportamentos
maliciosos sem o arquivo remoto.
Para contornar este problema, o analista pode transferir o arquivo solicitado de
forma manual para um computador local e, em seguida, adicioná-lo em um sítio falso dentro
ambiente controlado e prosseguir com a análise. Uma solução automatizada de análise
dinâmica, entretanto, seria incapaz de prosseguir a análise e, portanto, somente produziria
resultados relacionados a execução do Downloader. Uma solução para esse problema seria
implementar um canal de comunicação com a internet monitorado - que é chamado de
dirty line - no ambiente controlado. Obviamente, as implicações de tal implementação
devem ser tratadas pela área de segurança operacional. De qualquer forma, este é um
exemplo em que uma solução automatizada não pode fazer a tarefa de intervenção humana.
Da mesma forma, uma solução automatizada de análise estática é incapaz de lidar
com artefatos maliciosos que implementam alguma ofuscação de código desconhecida. A
solução automatizada somente será capaz de analisar o código da rotina de ofuscação.
Um analista poderia, usando técnicas de análise dinâmica, executar o artefato passo
a passo até que o mesmo realizasse a desofuscação e, finalmente, obter o código da
rotina maliciosa principal do artefato. Rotinas conhecidas de ofuscação poderiam, no
entanto, ser identificadas durante um pré-processamento do artefato e tratadas pela
solução automatizada o que traz maior complexidade para a mesma.
1
Considera-se uma boa prática de segurança bloquear o acesso à Internet a partir do ambiente controlado
de análise.
Capítulo 4. Análise Automatizada de Malware 72
Assim, soluções automatizadas, que são implantadas em um ambiente operacional,

envolvem um conjunto complexo de processamentos e capacidades, cujas definições e
descrições estão além do escopo desta tese. Uma proposta interessante, baseada em
técnicas de criação de perfis, apresentada por Han et al.(8) apresenta uma visão geral de
soluções automatizadas. Apesar de ser um modelo baseado em aprendizado de máquina
tradicional, onde a entrada é um conjunto de atributos, ele serve para dar uma visão
geral de módulos de um sistema automatizado operacional. A grande vantagem de um
sistema que envolva mais de um perfil, ou seja, diversas técnicas de detecção, é que seu
desempenho global tende a aumentar e, ainda, a solução tem maior potencial de detecção
de ameaças novas(8).
A Figura 31 apresenta uma visão geral de um sistema de detecção de artefatos
maliciosos conforme apresentado em Han et al.(8) onde os possíveis resultados são malware
ou não malware.
Figura 31 – Framework para detecção de malware. Adaptado de Han et al.(8).
Este sistema de detecção de malware apresenta 3 perfis, categorizados conforme o

tipo da entrada de dado: perfil básico de estrutura, perfil de comportamento de baixo nível
e perfil de comportamento de alto nível. O perfil básico faz uma análise estática baseada
nos dados de cabeçalho do arquivo e obtém informações como o tamanho das seções. O
perfil de comportamento baixo nível obtém a ordem de chamadas de APIs obtidas a partir
da execução do artefato malicioso. Finalmente, o perfil de comportamento alto nível obtém
atributos a partir da troca de informações entre o artefato malicioso e sistemas de rede,
arquivos e registro do Windows ő .
Esta proposta de Han et al.(8) pode ser ampliada com a inclusão de outras
abordagens, tais como: utilização de mais de um classificador com um sistema de votação
e utilização de sistemas baseados em aprendizado profundo onde a engenharia de atributos
é automática. De qualquer forma, como as soluções automatizadas de análise de malware
se baseiam em algoritmos de aprendizado de máquina deve-se considerar a forma de
representação dos dados de entrada (malware).
4.2 Arquivo do tipo PEFILE

Um aspecto relevante, quando se utiliza algoritmos de aprendizado de máquina, é
a definição da forma de representação dos dados de entrada. É notório que, em qualquer
problema que envolva aprendizado de máquina, deseja-se que os dados de entrada possuam
informação suficiente para que a solução de aprendizado de máquina seja capaz de produzir
resultados satisfatórios, de acordo com um objetivo definido. No entanto, tão importante
quanto definir quais serão os dados de entrada, é definir qual a forma de representação
destes dados de entrada.
Como nesta tese artefatos maliciosos executáveis serão classificados em famílias
e uma amostra de malware é um executável para o sistema operacional Windows ő , para
definir uma representação do artefato malicioso é preciso, inicialmente, compreender o
formato de um arquivo executável de Windows ő .
4.2.1 O Arquivo Executável para Windows ő

O sistema operacional Windows ő utiliza o formato Portable Executable (PE) em
seus executáveis. O formato PE é um formato de arquivos para executáveis e para código
de objetos DLL usados em versões 32 bits e 64 bits do sistema operacional Windows ő .
Este padrão define uma estrutura de dados que encapsula as informações necessárias para
o loader do sistema operacional Windows ő possa carregar e gerenciar o código executável
encapsulado2 . Um executável no formato PE contém duas seções: a (Header) e a (Section).
Ambas as seções podem ser subdivididas em diversas outras seções. A Figura 32 apresenta
uma visão geral do formato PE3 .
O cabeçalho do executável contém meta informações de controle como a localização,
data de compilação, bibliotecas utilizadas, tamanho das subseções, informações de com-
patibilidade entre outros. As informações estão no formato de valores hexadecimais: por
exemplo, o Address Of Entry Point é o endereço base de onde se inicia o código executável;
o Relative Virtual Address (RVA) é a diferença entre o endereço base e o endereço quando o
executável é carregado em memória. Estas informações são úteis quando se deseja analisar
2
Referência: https://docs.microsoft.com/en-us/windows/win32/debug/pe-format.
3
Uma imagem de tamanho maior pode ser vista no Anexo A
Figura 32 – Visão geral do formato PE. Fonte: (9).
o executável: por exemplo, para calcular o endereço do início do código executável quando
carregado em memória, deve-se adicionar ao Address of Entry Point ao valor do RVA.
Além disso, o cabeçalho possui informações sobre quais objetos DLL são necessários
para a execução do arquivo sendo que, cada função de cada um desses objetos DLL é
carregada em um determinado endereço de memória que está localizada na Import Address
Table (IAT) que também está definida no cabeçalho.
A seção Section contém o conteúdo principal do arquivo, incluindo código, dados,
recursos e outros arquivos executáveis. Cada seção tem um cabeçalho e um corpo. Um
aplicativo típico pode, por convenção, possuir nove seções predefinidas: .text, .bss, .rdata,
.data, .rsrc, .edata, .idata, .pdata e .debug. Geralmente, aplicativos não possuem todas
essas seções e, ainda, autores de artefatos maliciosos costumam alterar o nome destas
seções para dificultar a análise.
Algumas seções são mais interessantes que outras quando se considera a tarefa de
análise de artefatos maliciosos, como as seções de código (.text), as seções de dados (.data,
.edata, .idata e .rdata) e a seção de recursos (.rsrc). A seção .rdata representa os dados de
leitura do executável como constantes e strings. A seção .rsrc é a seção de recursos, ou
seja, ícones, imagens que o aplicativo poderá utiliza. A seção .edata contém informação
sobre os nomes e endereços de funções exportadas, ou seja, funções que outros executáveis
podem utilizar. A seção .idata contém informações sobre funções importadas definidas na
IAT. A seção .data contém dados de leitura e escrita que serão utilizados pelo executável.
A seção .text contém o código assembly executável do arquivo.
Apesar de alguns malware redefinirem os nomes das seções, é possível identificá-las.
Por exemplo, para identificar a seção do código executável, pode-se buscar no cabeçalho
pela informação de entry point address e confirmar que a seção, neste endereço, é executável.
A partir de então, também é possível identificar as seções de dados de leitura (como .rdata)
pois é uma seção não executável e definida como apenas de leitura no cabeçalho.
4.3 Representação do Arquivo do formato PE

A partir de arquivos executáveis no formato PE, é possível representar o arte-
fato malicioso de diversas formas. As formas mais comumente utilizadas em trabalhos
acadêmicos que aplicam aprendizado profundo são:
• Vetores de Atributos
• Vetores de Mnemônicos do Código Executável
• Imagem do Dado Bruto
4.3.1 Vetores de Atributos

Diversos trabalhos utilizam vetores de atributos para a análise de artefatos mali-
ciosos. A representação do artefato malicioso por meio de vetores de atributos consiste
em realizar diversos processamentos do artefato malicioso de forma a extrair valores que
representam um aspecto do artefato. O conjunto de todos esses valores extraídos é o vetor
de atributos.
A Figura 33 apresenta um exemplo de um processo de extração de atributos. Neste
exemplo, tem-se 5 funções de processamento A,B,C,D e E que extraem 3, 1, 2, 1 e 3
atributos, respectivamente. O vetor com todos os 10 atributos é o vetor de atributos
extraídos do artefato malicioso. Um exemplo de uma função de processamento de extração
de atributos é a entropia por janela, ou seja, o cálculo da entropia em janelas do arquivo
no formato PE. A motivação para se utilizar a entropia é que, valores altos de entropia
significam que a informação contida na janela está cifrada o que é uma característica típica
de artefatos maliciosos(59).
Quando se utiliza vetores de atributos, a definição e escolha das funções de pro-
cessamento ficam a cargo de um especialista de domínio, ou seja, um especialista que
Figura 33 – Exemplo de Extração de Atributos.
define quais atributos são interessantes para uma determinada tarefa de classificação.
Em Anderson e Roth(96), os autores publicaram o EMBER: um conjunto de dados de
referência rotulado baseado em vetores de atributos para treinar modelos de aprendizado de
máquina para detectar, estaticamente, arquivos executáveis maliciosos para a plataforma
Windows ő . Este conjunto de dados inclui os atributos extraídos de mais de 1 milhão de
arquivos binários.
Ainda, também foi disponibilizado o código fonte das funções de processamento de
extração de atributos, permitindo a incorporação de novas amostras no conjunto de dados.
A grande vantagem desta abordagem é que é possível deixar público uma base de dados
de artefatos maliciosos na forma de atributos extraídos (ao invés do binário do artefato
malicioso propriamente) sem ferir qualquer legislação vigente relacionada a disseminação
de artefatos maliciosos 4 .
Além disso, em Anderson e Roth(96), é apresentada uma comparação de desem-
penho entre um modelo de árvore de decisão aprimorado com gradiente (Light Gradient
Boosting Model - LightGBM )e o modelo de aprendizado profundo MalConv proposto em
Raff et al.(28). Os resultados mostram que o modelo que utiliza atributos (LightGBM)
supera o modelo de aprendizado profundo MalConv.
4.3.2 Vetores de Mnemônicos do Código Executável

A utilização de vetores de mnemônicos consiste, basicamente, em extrair a sequência
de mnemônicos dos comandos em assembly da seção de código executável (comumente
4
De acordo com a legislação brasileira, no § 1º do art. 154-A do Código Penal, inserido pela Lei
12.737/12, a distribuição de artefatos maliciosos é proibida.
seção .text) do binário.

Aqui cabe uma ressalva: em muitos trabalhos (97, 44, 31, 49, 98, 43, 99), o termo op-
code é utilizado para se referenciar aos mnemônicos. No entanto, de acordo com Guide(100),
“Um opcode primário pode ter 1, 2 ou 3 bytes de comprimento. ... Campos

menores podem ser definidos dentro do opcode principal.”
Ou seja, opcode é a sequência de bytes em hexadecimal que codifica toda instrução

assembly. Desta forma, observando o extrato de código assembly da Figura 34, tem-se que
hexadecimal 51 é um opcode da instrução push ecx; da mesma forma, o hexadecimal 56 é
o opcode da instrução push esi; finalmente, a sequência hexadecimal [33 C0] é o opcode da
instrução assembly xor eax, eax.
Figura 34 – Extrato de código assembly.
Portanto, a sequência jnz, push, push, push, mov, call, mov é uma sequência de
mnemônicos e não uma sequência de opcodes. Nesta tese foi empregado o termo mnemônico.
A representação de um binário por meio de sequência de mnemônicos deve, ainda,
ser codificada para a forma numérica para servir como dado de entrada para um sistema de
aprendizado de máquina. Esta sequência de mnemônicos codificada é denominada vetor
de mnemônicos do código executável.
A Figura 35 apresenta o seguinte exemplo: em (1) o código executável do artefato
malicioso é desmontado (disassembled); em (2) uma sequência de mnemônicos é extraída
do código desmontado; finalmente, em (3) cada mnemônico é codificado para um vetor
numérico, gerando o vetor de mnemônicos. No exemplo da Figura, a codificação one-hot
encoder foi utilizada.
A codificação comumente utilizada é a one hot encoder. Em circuitos digitais, a
codificação one-hot consiste em gerar um grupo de bits entre os quais as combinações
legais de valores são apenas aquelas que contém um único bit um (1) e os demais zero (0)
(101). Essa definição pode ser usava para o entendimento da codificação one hot encoder
em aprendizado de máquina. Na codificação one-hot-encoder, a dimensão do vetor gerado
é igual à quantidade de mnemônicos únicos da sequência, onde cada código possui uma
Figura 35 – Processo de codificação de mnemônicos produzindo um vetor de mnemônicos.
posição igual a um (1) e as posições restante nulas (0). Ainda, o conjunto de vetores
mnemônicos agrupados é uma matriz esparsa.
O uso de matrizes esparsas como entrada de dados para algoritmos de aprendizado
de máquina gera diversos problemas computacionais por causa da grande desproporção
entre o número de uns e zeros dos dados de entrada. Diversas áreas de aprendizado de
máquina costumam lidar dados de entrada na forma de matrizes esparsas, dentre elas,
destacam-se as seguintes:
• Processamento de linguagem natural aplicada em documentos de texto;
• Sistemas de recomendação que utilizam a informação sobre a utilização de um

determinado produto de catálogo;
• Visão computacional que emprega imagens que possuem muitos pixels pretos.
Na área de análise de malware, uma solução interessante para o problema de vetores

codificados com one-hot-encoder com dimensão alta foi apresentada por Sun e Qian(43),
onde foi observado que, dos 735 mnemônicos únicos extraídos, 255 somam um total de
ocorrências de 99,98% do total e os 480 restantes representam apenas 0,02%. Assim, no
lugar de usar um vetor de dimensão 735 para codificar os mnemônicos com one-hot-encoder,
pode-se utilizar um vetor de dimensão 256, onde 255 codificações são utilizadas para os
mnemônicos mais frequentes e 1 codificação para os restantes. Dessa forma, a dimensão
final do vetor codificado diminuiu de 735 para 256, atenuando os efeitos da matriz esparsa.
4.3.3 Imagem do Dado Bruto

A ideia de se representar um artefato malicioso como uma imagem para, então,
extrair atributos e alimentar um sistema de aprendizado de máquina, pode ser vista em
Nataraj et al.(13). Neste trabalho, um determinado binário de um artefato malicioso é lido
como um vetor de números inteiros representados por 8 bits e, em seguida, organizado
em uma matriz de duas dimensões. Essa matriz pode ser visualizada como uma imagem
em escala de cinza onde cada ponto da matriz está no intervalo [0,255], sendo 0 um valor
para a cor preta e 255 para a cor branca. A Figura 36 apresenta um exemplo onde os
20 primeiros bytes foram extraídos de um artefato e disponibilizados na forma de uma
imagem de tons de cinza de tamanho 4 × 5. Observar que os bytes foram distribuídos
horizontalmente, linha após linha.
Figura 36 – Sequência de bytes para imagem.
O processo exemplificado na Figura 36 pode ser realizado em toda sequência de

bytes de um artefato malicioso. Para isso é preciso, somente definir um valor de largura (ou
altura) a ser utilizado. Em Nataraj et al.(13), são propostos valores de largura de acordo
com o tamanho do artefato. Estes valores estão apresentados na Tabela 2.
Tabela 2 – Definição da largura da representação de imagem de um artefato malicioso de

acordo com Nataraj et al.(13).
Faixa do Tamanho do Arquivo Largura da Imagem
<10 kB 32
10 kB – 30 kB 64
. 60 kB – 100 kB 256
100 kB – 200 kB kB 384
200 kB – 500 kB kB 512
500 kB – 1000 kB 1024
A Figura 37 apresenta um exemplo de uma representação do artefato malicioso

VirusShare_48da6cdcdd791cf9759339506d1f1442 em escala de cinza utilizando a Tabela 2
para determinar a largura e altura da imagem (a esquerda). A Figura da direita apresenta
o mesmo artefato destacando a região de código executável em azul, a região de dados em
vermelho e o cabeçalho em preto (as duas primeiras linhas do retângulo).
Figura 37 – Representação do artefato VirusShare_48da6cdcdd791cf9759339506d1f1442

em escala de cinza.
O valor da largura da altura é definida a partir do tamanho da largura e do arquivo.

Não foi encontrada nenhuma referência que validasse ou discutisse esses valores empíricos
encontrados pelo autor. Como o trabalho publicado pelo autor é de 2011, é possível que o
tamanho dos artefatos tenha evoluído para valores maiores, acarretando em uma revisão
nos valores constantes na Tabela 2.
Ainda em Nataraj et al.(13), o autor mostra que, diferentes famílias de artefatos
maliciosos, possuem diferentes texturas na representação de imagem. A Figura 38 apresenta
4 representações de artefatos maliciosos por meio de imagem, utilizando a Tabela 2, da base
de dados VirusShareSant(Apêndice A): duas amostras da classe Vundo e duas amostras
da classe Bifrose. Para esta representação utilizou-se uma escala colorida em vez de uma
escala preto e branco de forma a ressaltar a diferença de textura. Pode-se observar que
a textura das representações dos artefatos das duas amostras da classe Vundo e Bifrose
são similares entre si. Além disso, há diferença entre as texturas das representações de
artefatos maliciosos entre a classe Vundo e a classe Bifrose. Observações similares a estas
deram origem ao trabalho de Nataraj et al.(13).
Outro resultado apresentado por Nataraj et al.(13) foi a criação de uma base de
dados de artefatos maliciosos disponibilizada publicamente na forma de representação
de imagens denominada MalImg. Com isso, diversos trabalhos começaram a aplicar
aprendizado profundo a análise de artefatos maliciosos utilizando a textura da representação
por imagem(43, 29, 102, 37, 103, 104, 105, 106, 107, 108, 109, 110).
Um problema da utilização da textura da representação de imagem do artefato
Figura 38 – Representação de Imagem de 4 artefatos maliciosos. 2 da classe Bifrose e 2 da

classe Vundo.
malicioso é a variação semântica dos bytes nesta representação. A variação semântica

ocorre porque o mesmo valor hexadecimal possui diferentes significados dentro do artefato
malicioso e, ao representar um artefato malicioso como uma única imagem, a variação
semântica é ignorada.
Figura 39 – Exemplo de variação semântica em que o byte 64h possui diversas semânti-
cas.
Na Figura 39 tem-se um exemplo concreto da variação semântica para um artefato

malicioso: no caso (a) o byte 64h representa uma parte do opcode da instrução movf s :
[ecx − 0D880h], esp]; no caso (b) o byte 64h representa uma informação na seção de
dados .data do artefato; e em (c) o byte 64h representa parte do campo Base of Data do
cabeçalho5 . Mas para uma representação de imagem, em todos os casos, o 64h é um pixel
cinza e, portanto, não há nenhuma distinção semântica. Uma forma de tratar a variação
semântica, que vai além do escopo desta tese, é utilizar uma RNC para a representação de
imagem de cada tipo de seção, conforme apresentação no Apêndice D.
5
Essa informação foi obtida utilizando o software PEStudio 8.4.
Outro problema típico dessa abordagem é que algoritmos de aprendizado profundo

necessitam que as imagens de entrada tenham o mesmo tamanho. No entanto, o tamanho
de artefatos maliciosos varia bastante. A Figura 40 apresenta o histograma de tamanhos
de arquivos de 2000 amostras do conjunto de treinamento de dados da base de dados
VirusShareSant(Apêndice A) para as famílias Bifrose e Cycbot.
Figura 40 – Histogramas para tamanhos de arquivo para classe Bifrose e para Classe
Cycbot.
Pode-se observar que, a família Bifrose possui arquivos que, em sua maioria, são de
tamanho até 1500 kB, podendo chegar a 4000 kB. As amostras da família Cycbot possuem
tamanho em torno de 180 kB, podendo chegar a 450 kB. Assim, qualquer representação de
artefato malicioso na forma de imagem produzirá imagens com larguras e alturas distintas.
Uma solução que é comumente empregada em trabalhos acadêmicos para resolver
o problema de imagens de tamanhos distintos envolve realizar o redimensionamento
da largura e altura para valores pré-fixados, independente da largura ou altura original
da representação original. Uma forma típica, encontrada em trabalhos que utilizam a
representação por imagem de artefatos maliciosos como entrada para um algoritmo de
aprendizado profundo, é utilizar os mesmos valores para largura e altura. Um valor
comumente utilizado são 32x32 ou 64x64 ou 128x128.
A Figura 41 apresenta uma representação de imagem, com redimensionamento
para 32×32, para os mesmos 4 artefatos maliciosos apresentados na Figura 38. Pode-se
observar que a amostra 287 da família Bifrose parece ter textura diferente da amostra 273
da mesma família, ou seja, ao realizarmos o redimensionamento das imagens para valores
fixos, cria-se um novo problema que foi denominado, neste trabalho, de distorção da
representação.
Cabe ressaltar que até a presente data, em nenhum trabalho da área de análise de
malware pesquisado, encontrou-se uma discussão sobre a distorção da representação,
causada pelo redimensionamento de imagem. Finalmente, vale a pena lembrar que, apesar
de utilizarem imagens redimensionadas, as soluções que utilizam aprendizado profundo
Figura 41 – Representação de Imagen de 32x32 de 4 artefatos maliciosos. 2 da classe

Bifrose e 2 da classe Vundo.
obtém valores de acurácia bastante adequados.

84
5 EXPLICABILIDADE
5.1 Introdução
A explicabilidade em aprendizado de máquina é um assunto recente. O maior
interesse neste tópico de pesquisa é resultado direto da adoção de algoritmos de aprendizado
de máquina nas diversas áreas do conhecimento. Mas, por muito tempo, o desempenho
sempre foi a única preocupação ao se projetar sistemas de aprendizado de máquina: o
problema é que, conforme Doshi-Velez e Kim(111),
“... uma única métrica, como a precisão da classificação, é uma descrição

incompleta da maioria das tarefas do mundo real.”
Dessa forma, a necessidade por explicabilidade surge da falta de uma formalização

completa do problema, ou seja, em certos problemas ou tarefas, não é suficiente obter
apenas a predição (o quê) mas também como se chegou àquela predição, pois uma predição
correta resolve apenas parte do problema.
A respeito dos motivos que justificam a implementação da explicabilidade, Adadi e
Berrada(21) destacam quatro:
• Justificar: sistemas explicáveis fornecem a informação requerida para justificar resul-

tados, particularmente, quando decisões não esperadas são feitas.
• Controlar: explicabilidade pode ser útil para prevenir que algo dê errado: de fato,
entender mais sobre o comportamento do sistema fornece maior visibilidade sobre
vulnerabilidades e falhas desconhecidas e ajuda a identificar e corrigir rapidamente
os erros em situações de baixa criticidade (como depuração).
• Melhorar: muitas vezes tem-se a necessidade de melhorar continuamente um sistema.

Se se conhece como o sistema produziu determinada saída, pode-se modificar o
sistema de forma que ele se torne mais inteligente.
• Descobrir: se o sistema é capaz de realizar uma determinada tarefa de forma superior

aos humanos, implementar a explicabilidade possibilidade que outros aspectos ainda
não observados baseado no entendimento do processo de decisão do algoritmo sejam
aprendidos.
Em alguns casos, a necessidade por explicabilidade é mais evidente: por exemplo,

quando é preciso auditar o resultado de um sistema ou quando é preciso garantir a
Capítulo 5. Explicabilidade 85
sua aceitação social. Uma área crítica para a utilização de aprendizado de máquina é
a segurança da informação, pois qualquer falha do algoritmo pode acarretar situações
desastrosas, podendo variar desde uma simples parada do serviço até a exfiltração de
informações sensíveis.
Assim, na área de segurança da informação, o entendimento da cadeia de raciocínio
(chain of reasoning) - que são as informações detalhadas que levam a determinadas decisões,
recomendações ou predições feitas pelo algoritmo - é fundamental e a explicabilidade surge,
exatamente, para atender a este tipo de demanda.
5.2 Definições e Taxonomia em Explicabilidade

De acordo com Gunning(112), inteligência artificial explicável
“ visa produzir modelos mais explicáveis, mantendo um alto nível de desempe-

nho de aprendizagem (acurácia de predição); e permitir que usuários humanos
entendam, confiem adequadamente e gerenciem efetivamente a geração emer-
gente de parceiros artificialmente inteligentes.”
Em Barocas et al.(113) tem-se que o objetivo de permitir a explicabilidade apren-

dizado de máquina é
“garantir que decisões algorítmicas, bem como quaisquer dados que as condu-
zam, possam ser explicados aos usuários finais e outras partes interessadas em
termos não técnicos.”
Da análise destas duas definições, pode-se concluir que um aspecto importante

para a explicabilidade1 é que o usuário do sistema de aprendizado de máquina possa
compreender a razão para determinadas predições.
Os métodos para explicabilidade em aprendizado de máquina podem ser classificados
de acordo com vários critérios (114). Considerando quando o método de explicabilidade é
aplicado, temos:
• Pre-Model: são técnicas de explicabilidade aplicadas antes da seleção do modelo,

ou seja, são aplicadas aos dados e, portanto, estão bastante relacionadas com análise
exploratória de dados. Um bom entendimento dos dados pode ajudar a melhor sele-
cionar modelos de aprendizado de máquina e seus hiperparâmetros mais adequados .
Algumas técnicas utilizadas são Análise de Componentes Principais, t-Distribuited
Stochastic Neighboor Embeding e métodos de agrupamento (como K-means).
1
Também chamada de interpretabilidade - por falta de padronização, será utilizado o termo explicabili-
dade nesta tese.
• In-Model: refere-se aos modelos de aprendizado de máquina que possuem interpre-

tabilidade inerente, sendo intrinsecamente interpretável. Essa interpretabilidade no
modelo pode ser alcançada através da imposição de restrições no modelo, como espar-
sidade, monotonicidade, causalidade ou restrições provenientes do conhecimento do
domínio (115). A explicabilidade In-model também é denominada interpretabilidade
intrínseca ou transparência.
• Post-Model: refere-se à implementação da explicabilidade após a construção de um

modelo (post hoc). Obviamente, existem métodos post hoc que podem ser aplicados a
modelos intrinsecamente interpretáveis, uma vez que os métodos post hoc geralmente
são dissociados do modelo. Neste caso, esses métodos são bastante interessantes
para modelos do tipo caixa-preta, como a maioria das arquiteturas baseadas em
algoritmos de aprendizado profundo.
Considerando-se que os métodos de explicabilidade são exclusivas de uma determi-

nada classe de modelos ou não, temos:
• Específica do Modelo: São métodos/ferramentas específicas de um modelo ou

classe de modelos. A interpretação dos modelos intrinsecamente interpretáveis é
sempre específica do modelo.
• Agnóstica do Modelo ou Independente do Modelo: são métodos/ferramentas

que podem ser usados em qualquer modelo de aprendizado de máquina e são aplicadas
após o treinamento do modelo (post hoc). Esses métodos agnósticos geralmente
funcionam analisando pares de atributos de entrada e saídas. Esses métodos não
podem ter acesso a modelos internos, como pesos ou informações estruturais.
E finalmente, considerando o escopo da explicabilidade, temos:
• Explicabilidade Local: o método explica uma amostra individualmente. A ideia é

que, localmente, uma predição pode depender apenas linear ou monotonicamente de
alguns atributos, em vez de ter uma dependência complexa deles. Por exemplo, o
valor de uma casa pode depender não-linearmente de muitos atributos. Mas se você
estiver vendo apenas casas com mais de 200 metros quadrados, é possível que, para
esse subconjunto de dados, a previsão do modelo dependa linearmente do tamanho.
• Explicabilidade Global: O método explica o modelo como um todo, ou parte dele.

Para obter a explicabilidade global do modelo seria necessário o modelo treinado
e o conhecimento do algoritmo e dos dados. Esse nível de explicabilidade fornece
informações sobre como o modelo toma decisões, com base em uma visão holística
de seus atributos e de cada um dos componentes aprendidos, como pesos, outros
parâmetros e estruturas. A explicabilidade global é muito difícil de se alcançar na

prática sendo mais comum a implementação de explicabilidade de parte do modelo
(explicabilidade modular).
Outro critério interessante, e pouco abordado, para diferenciar métodos de explica-

bilidade é quando se considera o tipo de resultado produzido pelo método ou o tipo de
explicação que cada método produz(114) que podem ser Sumário de Atributos, Aspectos
Internos do Modelo, Pontos de Dados e Modelo substituto intrinsecamente interpretável.
O Sumário de Atributos é um método de explicabilidade que fornece estatísticas
resumidas para cada atributo. Esse resumo pode ser na forma de importância do atributo
(feature importance) ou na forma visual como em partial dependence plot. Na Figura 42,
para o conjunto de dados FIFA Statistics 2018 2 , foi utilizado um modelo Random Forest
treinado para predizer o Man of the Match (Sim/Não). A Figura apresenta em (a) um
exemplo do método de importância de atributos na forma tabular onde os principais
atributos são mostrados em ordem decrescente de importância de acordo com os pesos e
suas variâncias e, em (b), o método de Partial Plot Dependence é aplicado para o atributo
Goal Scored onde é possível observar que, para predizer o Man of the Match, o aumento
no número de gols contribui na sua predição até o limite de 1 gol. A partir desse valor,
aumentar o número de gols não aumenta a chance da predição.
Figura 42 – Sumário de Atributos para FIFA 2018 Statistics utilizando o método de (a)
Importância de Atributos e (b) com o método Partial Dependence Plot.
Os Aspectos Internos do Modelo são um tipo de explicabilidade típico de

modelos intrinsecamente interpretáveis. As saídas de alguns métodos são valores de
pesos internos do modelo, como no caso dos pesos para regressão linear. Os métodos de
explicabilidade que geram informações internas do modelo são, por definição, específicos
do modelo. Um exemplo de visualização de aspectos internos de modelo é a visualização
dos filtros (kernels) das diversas camadas de um modelo de aprendizado profundo com
2
https://www.kaggle.com/mathan/fifa-2018-match-statistics
redes convolucionais. A Figura 43 apresenta a visualização de (a) 9 filtros da camada

block2_conv1 e de (b) 9 filtros da camada block5_conv1 de uma arquitetura V GG16(116)
treinada para o Imagenet(117). Pode-se observar que, quanto mais interna a camada
convolucional (block5_conv1), mais complexas são as formas dos filtros.
Figura 43 – Visualização de Filtros da arquitetura baseada em redes convolucionais VGG16

treinada para o Imagenet.
Outra forma comum de visualizar os efeitos dos filtros de uma arquitetura de

aprendizado profundo em uma imagem é por meio de mapas de atributos (feature maps).
Mapas de Atributos são o resultado de ativação em um filtro quando uma determinada
imagem é utilizada como entrada de uma rede convolucional. Na Figura 44 tem-se em (a) a
imagem de entrada para a arquitetura VGG16 treinada para o Imagenet e, em seguida, em
(b), (c) e (d) temos, respectivamente três mapas de atributos dos três primeiros filtros da
camada block1_conv1. Pode-se dizer que o primeiro filtro (b) tentou capturar o contorno
do pássaro; o segundo filtro (c) tentou destacar alguns aspectos das asas do pássaro e,
finalmente, o terceiro filtro (d) tentou destacar alguma informação relacionada com o
limite entre o pássaro e o fundo da imagem. A camada block1_conv1 possui 64 filtros e
foram gerados mapas de atributos dos três primeiros filtros.
Figura 44 – Visualização de mapas de atributos da camada block1_conv1 da arquitetura

VGG16.
Os Pontos de Dados são métodos que destacam pontos (no vetor de entrada)
de forma a tornar um modelo explicável. Para ser útil, tais métodos de explicabilidade
requerem que os pontos de dados sejam significativos e possam ser interpretados. Por
exemplo, pode-se destacar os ponto de dados em uma imagem ou texto permitindo que se
possa identificar regiões mais importantes.
Na Figura 45 tem-se um exemplo de pontos destacados para detecção de cachorro e
gato para o modelo pré-treinado Mobilenet. Pode-se observar que os pontos destacados são
úteis para melhor compreender quais conjuntos de pixeis são relevantes para a detecção.
Figura 45 – Visualização dos pontos de dados destacados para as detecções de cachorro

(b) e gato (c).
Os Modelos Substitutos Intrinsecamente Interpretáveis servem para inter-

pretar modelos de caixa-preta fazendo uma aproximação (globalmente ou localmente) por
um modelo intrinsecamente interpretável. Assim, a interpretação do modelo substituto
fornecerá uma melhor percepção do modelo original.
Figura 46 – Exemplo da criação de um modelo substituto intrinsecamente interpretável a

partir de um modelo mais complexo.
A Figura 46 apresenta um exemplo da criação de um Modelo Substituto intrinse-

camente interpretável em que o modelo substituto é linear. Em (a) tem-se as fronteiras
do modelo definindo duas áreas de classificação, rosa e azul, utilizando 2 atributos. Para
se obter uma interpretação para o ponto vermelho em destaque, primeiro realiza-se a
aproximação do modelo global não linear utilizando um modelo que, em torno do ponto em
destaque, é linear (b). A partir de então, é possível usufruir da facilidade de interpretação
do modelo linear e tirar conclusões para explicar uma amostra de interesse. Neste exemplo,
foi utilizado o método Local Interpretable Model-agnostic Explanations (LIME)(118) para
obter a aproximação linear local.
Tais classificações estão relacionadas uma com as outras: a explicabilidade in-model
é intrinsecamente explicável, embora existam algumas técnicas específicas que são post hoc.
Da mesma forma, a explicabilidade post-model vem de métodos pos hoc pois os métodos
são aplicados após o treinamento do modelo e, portanto, a técnica de explicabilidade é
independente do modelo. Deve-se aqui ressaltar que esses tipos não são os únicos. Na
Figura 47, é apresentado um resumo dos tipos de explicabilidade.
Figura 47 – Resumo dos tipos de explicabilidade apresentados nesta tese.
5.3 Explicabilidade em Aprendizado Profundo

Algoritmos de aprendizado de profundo são capazes de superar os humanos em
diversas tarefas. No entanto, sua estrutura aninhada e não-linear os torna altamente não
transparentes, ou seja, não estão claros quais informações nos dados de entrada produzem
determinada predição. Portanto, esses modelos são normalmente considerados caixas pretas,
no sentido de que eles podem fazer boas predições, mas sua estrutura natural fornece
pouca ou nenhuma informação sobre como o modelo produziu determinada predição.
Existem dois aspectos que devem ser considerados quanto à explicabilidade em
modelos de aprendizado profundo: o compromisso (trade-off ) entre desempenho e
explicabilidade e a multiplicidade de bons modelos.
De fato, há uma troca entre o desempenho e explicabilidade obtido pelo algoritmo
e sua explicabilidade intrínseca, pois à medida que a complexidade do modelo de aprendi-
zado de máquina aumenta e um melhor desempenho é obtido, perde-se a capacidade de
interpretação do modelo.
Figura 48 – Troca entre explicabilidade (interpretability) acurácia (accuracy).

Fonte:Molnar(119).
De acordo com Guo et al.(120) e Morocho-Cayamcela, Lee e Lim(121), quanto

melhor a acurácia do modelo, menor a sua explicabilidade (ou interpretabilidade), con-
forme mostra a Figura 48. Da Figura, tem-se que modelos de aprendizado profundo, que
geralmente são os modelos com maior acurácia, são os menos interpretáveis.
Ainda, considerando os algoritmos de aprendizado profundo, um problema interes-
sante apresentado em Hall e Gill(122) é o da multiplicidade de bons modelos. Dada
a estrutura complexa dos modelos de aprendizado de máquina, para o mesmo conjunto
de variáveis de entrada e rótulos, algoritmos de aprendizado de máquina podem produzir
vários modelos precisos, adotando caminhos internos muito semelhantes, mas que não são,
necessariamente, iguais. Portanto, detalhes das explicações também podem ser diferentes
para cada uma dessas variações de modelos.
Este conceito é importante quando se deseja comparar dois modelos que utilizaram
o mesmo conjunto de treinamento obtiveram acurácias similares, pois é muito provável
que cada modelo tenha utilizado os dados de entrada de maneira diferente. Neste caso, se
aplicar algum algoritmo de explicabilidade em ambos os modelos, os resultados podem ser
completamente diferentes.
A Figura 49 apresenta um exemplo da multiplicidade de bons modelos. Para dois

modelos, que possuem a mesma arquitetura e que foram inicializados de forma diferente,
obtém-se a acurácia de 91,73% e 91,78% respectivamente para os modelos 1 e 2. A partir de
então, para uma amostra de malware, foi gerado o mapa de calor destacando a importância
de cada região para a correta classificação da amostra para ambos os modelos.
Figura 49 – Exemplo de mapa de calor de uma amostra de malware para dois modelos
com mesma arquitetura.
Pode-se observar, claramente, que os modelos utilizaram regiões diferentes da

mesma amostra para a tarefa de classificação em famílias.
5.4 Algoritmos de Explicabilidade

Nesta seção estão apresentados algoritmos de explicabilidade que podem ser apli-
cados a modelos de aprendizado profundo, divididos em duas categorias: os que são
model-agnostic, ou seja, independentes de modelo e os que são específicos de modelos de
aprendizado profundo.
5.4.1 Algoritmos de Explicabilidade Agnósticos

Nesta seção serão tratados de algoritmos de explicabilidade agnósticos, ou seja,
que são independente do modelo. A grande vantagem destes algoritmos é que podem ser
aplicados a qualquer modelo de aprendizado de máquina.
5.4.1.1 Importância pela Permutação de Atributos
É uma técnica post-model, agnóstica de modelo, de explicabilidade parcial e o

resultado produzido é na forma de pontos de dados. A medição da importância dos
atributos usando permutação foi introduzida por Breiman(123) que utilizou o algoritmo
Florestas Aleatórias (Random Forest). Para Breiman(123), as ferramentas de importância
de variáveis (Variable Importance - VI) descrevem o quanto a acurácia de um modelo
preditivo depende das informações de cada covariável (covariate 3 ). Por exemplo, em

florestas aleatórias, a VI é medida pela diminuição da acurácia de predição quando uma
covariável é permutada.
Com base nas ideias de Breiman(123), Fisher, Rudin e Dominici(124) propuseram
uma versão independente do modelo (model agnostic). Assim, de acordo com Fisher,
Rudin e Dominici(124), o conceito de Importância pela Permutação de Atributos é medida
calculando o erro de predição do modelo, erro, para uma entrada de dados X, considerando
que X possui n atributos (dimensão de cada entrada). Para cada atributo de X realiza-se
a permutação dos valores do atributo k, onde k está no intervalo [1, n], obtendo uma nova
entrada de dados Xk . Essa entrada Xk é fornecida ao modelo e um erro de predição, errok ,
é obtido. Um atributo k é considerado mais importante quanto maior for a razão entre o
erro de predição errok/erro.
Figura 50 – Estimativa da importância do atributo k a partir dos erros de predição da

matriz X e da matriz com o atributo permutado Xk .
A Figura 50 apresenta um exemplo de como a importância de um determinado

atributo é medido. Inicialmente, uma matriz de entrada X com m amostras e n atributos
é apresentada a um modelo treinado, obtendo ypred . A partir do ypred e da saída real
yreal , é possível calcular um erro de predição erro, por exemplo, utilizando o erro médio
quadrático. Usando a matriz X, realiza-se uma permutação do k atributo obtendo a matriz
Xk , de dimensão m por n. Essa matriz Xk é apresentada ao modelo treinado, obtendo
ypredk . A partir do ypredk e da saída real yreal , é possível calcular o erro de predição errok .
Finalmente, quanto maior a razão Rk =errok /erro, maior a importância do atributo k.
3
Termo utilizado pelo autor para definir atributos ou características. Comumente utilizado por pessoal
da área estatística.
Intuitivamente, ao permutar o atributo k e obter errok de valor similar a erro,

é natural concluir que o atributo k não colaborou para as predições, ou seja, não teve
importância. Da mesma forma, ao permutar o atributo k resultar em Rk =errok /erro é
grande, significa que o atributo k tem bastante importância. Na Figura 50, foi realizado
apenas uma única permutação de k, mas pode-se realizar diversas iterações e calcular a
média e variância de errok e, portanto, obter a média e variância de Rk .
No Algoritmo 2 é apresentado o método de Importância pela Permutação de
Atributo:
Algorithm 2: Algoritmo para Estimar Importância pela Permutação de Atributos
Data: Modelo treinado F , matriz de atributos X, rótulos de saída yreal , medida de
erro erro = L(y, F )
Result: Importância do atributo k
Estimar o erro do modelo treinado F , e=L(ypred , F(X));
for k ← 1 to n do
Gerar matriz Xk ao permutar o atributo k entre as m amostras de X;
Estimar o erro errok = L(ypredk , F(Xk ));
Calcular a importância do atributo k a partir da razão Rk =errok/erro;
end
Ordenar os atributos de forma descendente de Rk ;
Um aspecto interessante discutido em Molnar(119) é sobre a escolha do conjunto de

treinamento ou conjunto de testes para obter a importância dos atributos. Para obter uma
intuição sobre como responder esta pergunta, pode-se considerar o seguinte experimento:
um modelo treinado em um conjunto de dados que não tem relação alguma com os rótulos
de saída, ou seja, os rótulos são independentes do conjunto de treinamento. Ainda assim, o
modelo obtém um erro de predição no treinamento baixo, ou seja, o modelo está fazendo
sobreajuste (overfitting). Nestas condições, o erro de predição no conjunto de testes será
alto (quando comparado ao erro no conjunto de treinamento). Se o conjunto de treinamento
for utilizado para avaliar a importância pela permutação dos atributos, serão obtidos quais
atributos o modelo considerou importante para a predição. Se o conjunto de testes for
utilizado para avaliar a importância pela permutação dos atributos, serão obtidos quais
atributos, de fato, são importantes para a predição.
Assim, no caso do modelo com sobreajuste, é de se esperar que se encontre atributos
com valor Rk =errok /erro alto quando se o conjunto de treinamento é utilizado e valores
de Rk =errok /erro próximos de 1 quando se utiliza o conjunto de testes. Este experimento
mostra como é importante considerar o conjunto de dados a ser utilizado para avaliar a
importância do atributo para um determinado modelo(119).
5.4.2 Algoritmos de Explicabilidade em Aprendizado Profundo

5.4.2.1 Visualização de Atributos Aprendidos para Redes Neurais Convolucionais
Em arquiteturas de aprendizado profundo baseadas em redes neurais convoluci-

onais, pode-se considerar que a saída da última camada convolucional são os atributos
aprendidos de forma automatizada4 , para um determinado modelo treinado. A partir desta
consideração, pode-se analisar esses atributos aprendidos, utilizando processos de redução
de dimensionalidade e ter uma visualização de como os atributos aprendidos se localizam
espacialmente.
Figura 51 – Entrada de dados X, como a imagem de um cachorro OU um gato, produzindo

uma matriz de atributos F aprendidos.
Na Figura 51 tem-se um exemplo de como extrair os atributos aprendidos por um

modelo de rede neural convolucional treinada utilizando imagens de cachorros e gatos,
considerando que a rede neural convolucional foi treinada utilizando o conjunto de dados
Xtrain . Para se extrair os atributos aprendidos FXtrain deve-se alimentar a rede com o
mesmo conjunto de treinamento Xtrain e obter a saída da última camada convolucional da
arquitetura do modelo. Essa matriz de atributos FXtrain possui a mesma quantidade de
amostras m da matriz de entrada Xtrain . A dimensão de cada amostra, p, da matriz de
atributos é a dimensão da saída da última camada convolucional da arquitetura.
Em seguida, utilizando algoritmos de redução de dimensionalidade em FXtrain , é
possível visualizarmos a distribuição espacial dos atributos aprendidos por este modelo das
amostras utilizadas no treinamento. A Figura 52 apresenta um exemplo onde uma matriz de
atributos aprendidos de um determinado modelo FXtrain sofre redução de dimensionalidade
para 2 dimensões, permitindo a visualização espacial de cada amostra de cada classe (gato
ou cachorro).
4
Atributos estes aprendidos automaticamente e não definidos por um especialista da área.
Figura 52 – Matriz FXtrain aprendidos de um modelo sofre redução de dimensionalidade

permitindo a visualização espacial de cada classe.
5.4.2.2 Mapas de Ativação de Classe
Em Zhou et al.(10), os autores propuseram uma forma de localização de objeto em

arquiteturas que utilizam as camadas Global Average Pooling (GAP-CNN). A camada
GAP, nestas arquiteturas, podem fornecer informações sobre a localização do objeto
detectado e esta localização será apresentada na forma de mapa de calor (heatmap) ou
mapas de ativação de classe (class activation map). Assim, um mapa de ativação de classe
para uma determinada categoria indica as regiões discriminativas da imagem usadas pela
CNN para identificar essa categoria.
Uma característica das arquiteturas GAP-CNN é que após a última camada convo-
lucional (GAP), segue uma camada completamente conectada para realizar a classificação.
Assim, a estrutura geral de uma arquitetura GAP-CNN está apresentada na Figura:
Figura 53 – Exemplo de Arquitetura GAP-CNN para classificação de artefato malicioso.

Baseado em (10).
A Resnet50 é uma arquitetura do tipo GAP-CNN. A seguir, na Listagem 5.4.2.2,

está apresentada a parte final da descrição dela na implementação do keras.
_________________________________________________________________________________________
bn5c_branch2c ( B a t c h N o r m a l i z a t i ( None , 7 , 7 , 2 0 4 8 ) 8192 res5c_branch2c [ 0 ] [ 0 ]
_________________________________________________________________________________________
add_16 (Add) ( None , 7 , 7 , 2 0 4 8 ) 0 bn5c_branch2c [ 0 ] [ 0 ]
activation_46 [ 0 ] [ 0 ]
_________________________________________________________________________________________
activation_49 ( Activation ) ( None , 7 , 7 , 2 0 4 8 ) 0 add_16 [ 0 ] [ 0 ]
_________________________________________________________________________________________
avg_pool ( G l o b a l A v e r a g e P o o l i n g 2 ( None , 2 0 4 8 ) 0 activation_49 [ 0 ] [ 0 ]
_________________________________________________________________________________________
f c 1 0 0 0 ( Dense ) ( None , 1 0 0 0 ) 2049000 avg_pool [ 0 ] [ 0 ]
Pode-se observar que a última camada convolucional, activation_49, tem como

saída um tensor de dimensões 7 × 7 × 2048 e que, após uma camada de Global Average
Pooling, avgp ool, produz uma saída de dimensões 1 × 1 × 2048.
Inicialmente, selecionam-se todas as conexões entre a GAP e o neurônio que
produziu a classificação correta. O primeiro passo para calcular o CAM é aplicar a função
softmax aos pesos W1 , W2 , ...Wp obtendo os pesos W1s , Wss , ...W1sp . Isso faz com que a
soma dos pesos W1s , Wss , ...W1sp seja 1.
i)
sof tmax(W )i = Pexp(W
exp(Wj ))
j
A partir de então, o CAM é calculado multiplicando cada tensor da camada anterior

à camada GAP pelo peso do seu equivalente após a camada GAP. Considerando um tensor
com profundidade p, tem-se:
CAM = W1s × Imagem1 + W2s × Imagem2 + ... + Wps × Imagemp
Cada tensor da camada anterior à camada GAP possui um único peso Wk que
conecta a última camada de classificação. Finalmente, a imagem resultante CAM é
redimensionada para o tamanho da imagem original resultando em um mapa de calor. Por
exemplo, a camada anterior a GAP na Resnet50 é de tamanho 7 × 7 × 2048 e, portanto,
serão existem 2048 Imagens de tamanho 7 × 7. A Figura 54 apresenta o processo de cálculo
do CAM.
Figura 54 – Exemplo do Class Activation Map pra classificação de artefato malicioso.

Baseado em (10).
A Figura 55 apresenta um exemplo do cálculo do CAM para a classificação da

raça de um cachorro. Observe que cada Imagem da camada anterior à GAP produz um
mapa de calor. O resultado final pode ser então visto como a soma ponderada dos mapas
de calores individuais pelos seus respectivos pesos W1 , W2 , ...Wp . Novamente, no caso da
Resnet50, serão gerados 2048 mapas de calor de tamanho 7 × 7. Assim, o resultado da

soma ponderada será um mapa de calor de tamanho 7 × 7. Este mapa de calor deverá ser
redimensionado para o tamanho da imagem de entrada da Resnet50 que é 224 × 224.
Figura 55 – Exemplo do Class Activation Map. Fonte (10).
A grande limitação da aplicação do CAM é que ela é específica para redes neurais
convolucionais que sejam do tipo GAP-CNN.
5.4.2.3 Mapas de Ativação de Classe por Gradiente
A proposta do Grad-CAM (11) procura solucionar exatamente a lacuna do CAM

que necessita uma arquitetura GAP-CNN. No CAM, mapas de calor são gerados utilizando
a média ponderada das imagens da camada anterior à GAP (canais de saída da camada
anterior) usando os pesos da Rede Completamente Conectada que está ligada à saída para
predizer a classe.
Ao invés disso, para uma determinada Imagem de entrada que produz um resultado
de classificação, seleciona-se uma camada convolucional qualquer. Para esta camada
calcula-se o mapa de atributos desta camada de tamanho h × l × p de forma similar ao
CAM. No entanto, para calcular os pesos para realizar a soma ponderada, calcula-se o
gradiente da predição para a mesma camada convolucional selecionada. Estes gradientes
também são tensores de tamanho h × l × p e para torná-los pesos escalares aplica-se o
Global Average Pooling, produzindo A1 , A2 , ...Ap . Finalmente, também se aplica aos pesos
a função softmax produzindo A1s , A2s , ...Aps . A Figura 56 ilustra este processo. Finalmente,
calcula-se o mapa de calor da mesma forma que o CAM:
CAM = A1s × Imagem1 + A2s × Imagem2 + ... + Aps × Imagemp
É interessante observar que o cálculo do gradiente para uma determinada entrada
está implementado nas diversas soluções de aprendizado profundo, pois este cálculo é
necessário durante o treinamento da rede. Além disso, por depender apenas do gradiente,
Figura 56 – Exemplo do Gradiant-Weighted Class Activation Map. Fonte (11).
qualquer camada pode ser escolhida para gerar o mapa de calor. A escolha da camada
não é trivial, mas que, no caso mais geral, a última camada convolucional parece ser
adequada(11).
100
6 TRABALHOS RELACIONADOS
A aplicação de aprendizado profundo na área de análise de artefatos maliciosos

é recente e os principais motivos para este interesse são: (a) o crescimento no uso de
aprendizado profundo nas diversas áreas de conhecimento e (b) a disponibilização de bases
de dados de artefatos maliciosos de forma pública.
De acordo com VARGAS e Lourdes(125), nos últimos 10 anos, há um crescente
aumento no número de publicações na área de aprendizado profundo. A Figura 57 apresenta
essa evolução para as revistas Science Direct e IEEE, no período de janeiro de 2006 a
julho de 2017 (125), complementada com dados de 2018 e 2019.
Figura 57 – Número de publicações na área de aprendizado profundo para Science Direct

e IEEE.
Além disso, recentemente, algumas bases de dados de artefatos maliciosos rotuladas

começaram a ser disponibilizadas:
• Em 2011, fruto do trabalho de Nataraj et al.(13) foi disponibilizada uma base de

dados de artefatos maliciosos representados na forma de imagem1 . O algoritmo
utilizado pelo autor para extrair atributos foi o Generalized Search Tree (GiST).
No entanto, a utilização do GiST consome tempo e técnicas de processamento de
imagem mais poderosas foram propostas recentemente;
• Em 2015, a Microsoft disponibilizou, publicamente, uma base de artefatos maliciosos

para a competição Microsoft Malware Classification Challenge (BIG 2015) (126);
• Em 2018, Anderson e Roth(96) disponibilizaram uma base de dados de atributos

extraídos de artefatos maliciosos denominada EMBER;
• Ainda em 2018, Huang e Kao(108) disponibilizaram uma base de dados de artefatos

maliciosos para a plataforma Android de forma pública2 .
1
https://vision.ece.ucsb.edu/research/signal-processing-malware-analysis
2
http://r2d2.twman.org. Site indisponível em 01-03-2020.
Capítulo 6. Trabalhos Relacionados 101
Assim, fica claro que a disponibilização destes conjuntos de dados foi relevante
para o recente aumento de interesse na área de aprendizado profundo aplicado à análise
de malware.
6.1 Desempenho de Redes Convolucionais para Análise de Malware

Para atingir o objetivo S0, foi realizada uma pesquisa sobre a diversas arquiteturas
de Redes Neurais Convolucionais e foi avaliado o desempenho destas para a tarefa de
classificação em famílias de artefatos maliciosos. Os valores de desempenho pesquisados
serão analisados de forma a fornecer uma referência para uma proposta que atinja S0.
Cabe lembrar que o objetivo específico S0 não está diretamente relacionado com o objetivo
geral da tese, no entanto, é preciso alcançá-lo para que os objetivos específicos S1,S2 e S3
sejam atingidos. A Tabela 3 apresenta um quadro resumo com o objetivo geral e objetivo
específico S0.
Tabela 3 – Relações do Objetivo Específico S0.

.
Objetivo Geral Propor adaptações que, aplicadas a algoritmos de expli-
cabilidade, permitam melhorar a identificação de relações
entre as características de entrada da rede com os resul-
tados obtidos para uma determinada tarefa na área de
análise de malware
Objetivo Específico S0 Definir uma arquitetura de Rede Neural Convolucional
com acurácia adequada para aplicação de algoritmos de
explicabilidade
Lacuna Nos trabalhos analisados, não há a documentação ade-
quada dos hiperparâmetros utilizados nas diversas solu-
ções de redes neurais convolucionais aplicadas à análise de
malware.
Em Kabanga e Kim(37), uma representação por imagem de tamanho 128 × 128 de

artefatos da base de dados MalImg(13) são apresentados para uma rede neural convolucional
para a tarefa de classificação de artefatos em 25 famílias. O artigo não descreve aspectos
importantes da arquitetura da rede convolucional tais como: tamanho dos filtros, quantidade
de camadas, valor para o dropout e quantidade de neurônios das camadas completamente
conectadas, apenas apresentando uma visão geral da rede neural convolucional. A acurácia
obtida foi de 98%.
Em Rezende et al.(103), é utilizada a técnica de transfer learning para a arquitetura
ResNet-50 (12) para a tarefa de classificação de artefatos maliciosos em famílias. A base de
dados utilizada é a MalIMG(13) e possui 9.339 artefatos maliciosos divididos em 25 famílias.
A entrada de dados é uma representação na forma de imagem do artefato malicioso de
tamanho 224 × 224. Apenas a saída a última camada da Resnet-50 foi modificada: a
camada completamente conectada com 1000 neurônios passou a ter apenas 9 neurônios. A
acurácia obtida foi de 98,62%.
Em Ni, Qian e Zhang(42), os mnemônicos do código assembly do artefato malicioso
são extraídos e codificados, obtendo uma sequência de mnemônicos. Em seguida, um
algoritmo de hash de similaridade(127) é aplicado a esta sequência, originando uma
representação vetorial para cada artefato. O tamanho dessa representação pode variar,
dependendo do tamanho do algoritmo utilizado para codificar os mnemônicos, sendo que
valores comuns são 128 bits, 256 bits e 512 bits. Uma imagem é, então, gerada a partir de
uma ou mais representações vetoriais. Esta imagem é, em seguida, utilizada como entrada
para uma rede neural convolucional. Apenas os valores dos principais hiperparâmetros
da arquitetura geral da rede neural convolucional são apresentados, deixando de lados
valores como o valor do dropout e o número correto de camadas convolucionais. A base de
dados utilizada está disponibilizada em Microsoft Malware Classification Challenge (BIG
2015) (126) e possui 9 famílias de artefatos maliciosos. O resultado obtido é de 98,26% de
acurácia na classificação em famílias de malware.
Em Kalash et al.(29), a técnica de transfer learning foi aplicada a análise de
malware utilizando a rede VGG-19 (baseada na VGG-16 descrita em (116)). A entrada
de dados é uma representação, na forma de imagem de 224 × 224, do artefato malicioso.
As bases de dados utilizadas são públicas: (Microsoft Malware Classification Challenge
(BIG 2015) (126) que possui 9 famílias de artefatos maliciosos e MalIMG(13) que possui
25 famílias de artefatos maliciosos) para a tarefa de classificação de malware em famílias.
A acurácia obtida é de 97,52% para a base da Microsoft e de 99,97% para a base Malimg.
O autor não deixa claro quais camadas da VGG-19 foram usadas para transfer learning e
qual a configuração da camada de rede neural completamente conectada que foi utilizada
para classificação.
Em Yakura et al.(54), o autor transformou artefatos maliciosos da base de dados
VxHeavens 3 , que possui 542 famílias, em imagens para servir de entrada para uma rede
neural convolucional para a tarefa de classificação em famílias de malware. Os valores dos
hiperparâmetros da implementação da rede neural convolucional foram apresentados. Não
foi apresentada, entretanto, uma acurácia global da solução4 .
Em Cui et al.(128), uma rede neural convolucional foi utilizada para a tarefa de
classificar artefatos maliciosos em famílias, utilizando a base de dados MalImg(13) que
contém representação na forma de imagem de artefatos maliciosos para 25 famílias e
obtendo uma acurácia de 96,70%. Ainda, foi desenvolvida uma abordagem eficaz para
3
O sítio foi fechado pela polícia Ucraniana em 23 de março de 2012.
https://nakedsecurity.sophos.com/2012/03/28/vx-heavens-virus-writing-website-raided/
4
Os códigos fontes utilizados foram disponibilizados para o autor desta tese.
resolver o problema de desbalanceamento da quantidade de amostras por família. Com

relação a rede neural convolucional o artigo somente cita ser uma sequência de duas camadas
convolucionais, uma camada de MaxPooling e duas camadas de redes completamente
conectadas e que foi utilizada a função de ativação Rectified Linear Unit(ReLU).
Em Zhao et al.(129), o autor utilizou uma representação de imagem como entrada
para uma rede neural convolucional para a tarefa de classificação em 25 famílias de malware.
O autor realizou um particionamento da representação de imagem sempre que mudanças
altas no valor da entropia eram observadas. Regiões sem grandes mudanças de texturas (ou
entropia) são excluídas da imagem original. Os valores dos hiperparâmetros da rede neural
convolucional não foram apresentados. A solução apresentada é denominada MalDeep e o
resultado obtido foi de 92,5% de acurácia.
Em Gibert et al.(130), imagens de tamanho 256x256 que representam artefatos
maliciosos da base de dados MalImg (13) (25 famílias) e da base de dados Microsoft
Malware Classification Challenge (BIG 2015) (126)) (9 famílias) são utilizados para a
classificação de famílias de malware. O trabalho propôs duas arquiteturas de redes neurais:
uma para cada base de dados e apenas uma visão geral das arquiteturas é apresentada.
A acurácia obtida foi de 97.48% e 97.49% para as bases de dados BIG2015 e MalImg,
respectivamente.
Em Kadri, Nassar e Safa(131), o autor utilizou artefatos maliciosos para realizar
a tarefa de classificação de malware em famílias utilizando a base de dados Microsoft
Malware Classification Challenge (BIG 2015) (126) que possui 9 famílias. Como entrada de
dados foram utilizados os primeiros 1MB do artefato malicioso (dado bruto). A arquitetura
proposta é similar a apresentada em Raff et al.(28), mas com a saída modificada para
que produza uma saída de tamanho 9 em vez de apenas 1 (maligno ou benigno). O autor
utilizou transfer learning na forma de inicialização dos pesos de arquitetura com os pesos
originais da proposta de Raff et al.(28). A acurácia obtida foi de 96,98%.5
A Tabela 4 apresenta um quadro resumo dos trabalhos citados, destacando a
entrada utilizada, o classificador e a disponibilidade dos hiperparâmetros, o objetivo da
análise e quantidade de famílias, o conjunto de dados disponibilizados e ao resultado
obtido.
O principal motivo para realizar essa revisão bibliográfica é compreender o estado
da arte de trabalhos científicos que utilizam redes neurais convolucionais para a tarefa
de classificação de artefatos maliciosos e analisar o desempenho obtido. Da análise destes
trabalhos, pode-se concluir:
• Uma grande parte dos trabalhos não apresenta os valores dos hiperparâmetros da
arquitetura convolucional, o que dificulta a sua replicação;
5
Os códigos fontes utilizados foram disponibilizados para o autor desta tese.
Tabela 4 – Desempenho de Redes Convolucionais para Classificação de Malware
Trabalho Entrada Classificador Objetivo Conjunto de dados Resultadoa
Kabanga e Imagem 128 × 128. Rede neural convolucional. Classificação em 25 fa- Pública MalImg(13); Win- Acc. de 98%
Kim(37) Não apresenta valores dos mílias de malware. dows
hiperparâmetros
Rezende et 224 × 224 da representação do ar- Rede neural convolucional Classificação em 25 fa- Pública. MalIMG(13) ; Win- Acc. de 98,62%
al.(103) tefato malicioso. Resnet-50. Última camada mílias de Malware dows
modificada
Ni, Qian e Hash de similaridade da sequência Rede neural convolucional. Classificação em 9 famí- Pública. Microsoft Malware Acc. de 98,26%
Zhang(42) de mnemônicos codificada. Algumas informações não lias de Malware Classification Challenge (BIG
são apresentadas. 2015); Windows
Kalash et al.(29) Imagem 224 × 224 gerada a partir Rede neural convolucional Classificação em 9 e 25 Pública. Microsoft Malware Acc. de 97,52% e
dos dados brutos. VGG-19. famílias de malware (9 Classification Challenge (BIG 99,97%
classes) 2015) (126) e MalIMG(13) ;
Capítulo 6. Trabalhos Relacionados
Windows
Yakura et Imagem a partir do artefato mali- Rede neural convolucional. Classificação em famí- Descontinuada. VxHeavens. Acc. não apre-
al.(54) cioso. lia de malware (542 Aprox. 150.000 amostras de sentada
classes) 542 famílias; Windows
Cui et al.(128) Representação na forma de ima- Rede neural convolucional. Classificação em Famí- Pública, MalImg(13) ; Win- Acc. de 96,70%
gem do malware. Quase nenhuma informa- lia de Malware (24 clas- dows
ção sobre os hiperparâme- ses selecionadas)
tros da arquitetura.
Zhao et al.(129) Representação de imagem onde re- Rede neural convolucional. Classificação em 9 famí- Pública, Microsoft Malware Acc. de 92,5%
giões sem grandes mudanças de Alguns dos hiperparâme- lias de Malware Classification Challenge (BIG
textura são excluídas. tros da arquitetura não são 2015) (9 classes); Windows
apresentados.
Gibert et Imagem 256 × 256 gerada a partir Rede neural convolucional. Classificação em 9 e 25 Pública. Microsoft Malware Acc. de 97.48% e
al.(130) dos dados brutos. famílias de malware Classification Challenge (BIG 97.49%
2015) (9 famílias) (126) e
MalIMG(13) (25 famílias) ;
Windows
Kadri, Nassar e Primeiros 1MB dos dados brutos. Rede neural convolucional Classificação em 9 famí- Pública. Microsoft Malware Acc. de 97.48% e
Safa(131) proposta em Raff et al.(28) lias de malware Classification Challenge (BIG 97,98%.
2015) (126)) ; Windows
Proposta P0, Se- 224 × 224, Seção 8.2 Rede neural convolucional Classificação em 9 famí- Privadab ; Windows Acc. de 95,35%,
ção 7.2.1 e Seção com TODOS valores de hi- lias de malware. Seção 8.2.4
8.2 perparâmetros
a
104
O termo acurácia foi abreviado como Acc.

b
A ser disponibilizada publicamente
• As bases de dados públicas mais utilizadas são: Microsoft Malware Classification

Challenge (BIG 2015) (126) e MalIMG(13). Cabe ressaltar que, atualmente, a base
de dados MalIMG está indisponível6 ;
• A base de dados mais próxima da utilizada nesta tese é a base Microsoft Malware
Classification Challenge (BIG 2015) que possui 9 famílias de artefatos maliciosos.
A acurácia média dos trabalhos que utilizam a base de dados Microsoft Malware
Classification Challenge (BIG 2015) (42, 29, 129, 130, 131) é de 96,62%.
6.2 Re-Rotulagem de Base de Dados de Artefatos Maliciosos

Para atingir o objetivo S1, foi realizada inicialmente uma pesquisa sobre a utili-
zação de aprendizado profundo para a classificação de artefatos maliciosos em famílias
considerando se o trabalho realizava a verificação da correta rotulagem da base de dados.
O objetivo específico S1 tem relação com o objetivo geral: ao definir adaptações nos
algoritmos de explicabilidade de forma a propor candidatos à re-rotulagem, obtém-se um
melhor conhecimento sobre a relação entre entrada e saída da arquitetura, dando, inclusive,
oportunidade de avaliarmos a correta rotulagem baseado na saída da rede. A Tabela 5
apresenta um quadro resumo com o objetivo geral, objetivo específico S1 e a Lacuna L1.

.
análise de malware
Objetivo Específico S1 Definir adaptações em algoritmos de explicabilidade de
forma a obter possíveis candidatos à retificação do rótulo
e minimizar os efeitos da Lacuna L1
Lacuna L1 Possíveis erros na correta rotulagem da base de dados
de artefatos maliciosos que podem levar os algoritmos de
aprendizado de máquina a pressupostos incorretos.
Rotular um executável malicioso em uma família conhecida é importante em

diversas áreas de análise de malware, como na identificação de novas ameaças, filtrando
as amostras conhecidas. De qualquer forma, considerando a quantidade de amostras de
artefatos maliciosos, é inviável que essa rotulagem seja realizada de forma manual por um
analista. Diversos trabalhos utilizam técnicas de aprendizado profundo para classificar
6
Verificado em 3 de novembro de 2020.
artefatos maliciosos em famílias, mas nenhum dos trabalhos pesquisados considerou a

possibilidade de erros na rotulagem.
Em Kabanga e Kim(37), o autor realiza a classificação de artefatos maliciosos
utilizando a base MalImg(13) que é composta de 25 famílias. A acurácia na classificação
obtida foi de 98% e o autor considera que os rótulos da base de dados estão corretos.
Em Rezende et al.(103), o autor utiliza uma a base de dados MalIMG(13) para
classificar 9.339 artefatos maliciosos em 25 famílias. A acurácia obtida foi de 98,62% e os
rótulos das classes foram considerados corretos para fins de treinamento e estimativa de
erro.
Em Ni, Qian e Zhang(42), os mnemônicos do código assembly do artefato malicioso
são extraídos e representados na forma de imagem. Esta imagem alimenta um algoritmo
de aprendizado profundo. A base de dados utilizada é a Microsoft Malware Classification
Challenge (BIG 2015) (126) e possui 9 famílias de artefatos maliciosos. O resultado obtido
é de 98,26% de acurácia.
Em Kalash et al.(29), artefatos maliciosos são transformados em imagem e alimen-
tam um algoritmo de aprendizado profundo para a classificação em famílias. As bases
de dados utilizadas são: a (Microsoft Malware Classification Challenge (BIG 2015) (126)
que possui 9 famílias de artefatos maliciosos e a MalIMG(13) que possui 25 famílias de
artefatos maliciosos). A acurácia obtida é de 97,52% para a base da Microsoft e de 99,97%
para a base Malimg. O trabalho considera que os rótulos de ambas as bases de dados estão
corretos.
Yakura et al.(54) o autor utiliza a base de dados de artefatos maliciosos da base de
dados VxHeavens que possui 542 famílias. Os resultados foram apresentados na forma de
curvas ROC e os rótulos da base de dados foram considerados corretos pelo autor.
Em Cui et al.(128), o autor utiliza a base de dados MalImg(13) que contém
representação na forma de imagem de artefatos maliciosos para 25 famílias e obtendo
uma acurácia de 96,70%. Ainda, o autor considera que os rótulos da base de dados estão
corretos.
Em Gibert et al.(130), o autor utiliza a base de dados MalImg (13) que possui 25
famílias de malware e a base de dados Microsoft Malware Classification Challenge (BIG
2015) (126)) que possui 9 famílias de malware. A acurácia obtida é de 97.48% e 97.49%
para as bases de dados BIG2015 e MalImg, respectivamente. O autor considera que ambas
as bases estão corretamente rotuladas.
Kadri, Nassar e Safa(131) o autor utiliza a base de dados Microsoft Malware
Classification Challenge (BIG 2015) (126) que possui 9 famílias de malware. A entrada
de dados é composta pelos primeiros 1Mb do artefato malicioso. A acurácia obtida foi de
97,48% e o autor considera que os rótulos da base de dados estão corretos.
Em Zhao et al.(129) o autor utiliza uma base de dados de imagens de amostras

de malware contendo 25 famílias. Após um processamento da imagem, o autor obtém
um resultado de 92,5% de acurácia. O autor considera os rótulos da base de dados como
corretos.
A Tabela 6 apresenta um quadro resumo dos trabalhos pesquisados considerando
se erros de rotulagem no conjunto de dados ocorreram. Da análise desta Tabela pode-se
concluir que, apesar de terem obtido resultados de acurácia bastante satisfatórios, nenhum
dos trabalhos considerou problemas ou erros na rotulagem da base de dados. A Proposta
P1 (Seção 7.2.2) busca sanar este tipo de lacuna encontrada nos diversos trabalhos.
Tabela 6 – Verificação da Correta Rotulagem de Redes Convolucionais para Classificação

de Malware
.
Trabalho Conjunto de Dados Resultado Rotulagem
Kabanga e Kim(37) MalIMG(13) 98.02% Não
Rezende et al.(103) MalIMG(13) 98,62% Não
Ni, Qian e Zhang(42) BIG 2015 (126) 98,26% Não
Kalash et al.(29) BIG 2015 (126); MalIMG(13) 98,97%; 98,52% Não
Yakura et al.(54) VxHeavens – Não
Cui et al.(128) MalImg(13) 96,70% Não
Gibert et al.(130) BIG 2015 (126); MalIMG(13) 97,48%; 97,49% Não
Kadri, Nassar e Safa(131) BIG 2015 (126) 97,48% Não
Zhao et al.(129) MalIMG(13) 92,05% Não
Proposta P1 Privada. 95,37%, Seção 8.2.4 Sim
Cabe ressaltar que trabalhos pesquisados na área de aprendizado de máquina

(convencional) supervisionado(132, 133, 134) também possuem a Lacuna L1. Além disso,
alguns trabalhos na área de aprendizado de máquina não supervisionado(135, 136, 137, 138)
realizam agrupamento de artefatos de forma automática, mas dependem de uma rotulagem
manual para atribuir um nome de família conhecido a cada grupo produzido.
6.3 Representação de Imagem de Artefato Malicioso

Para atingir o objetivo S2, uma pesquisa bibliográfica foi realizada em trabalhos
que aplicam redes neurais convolucionais para análise de malware pois, nestes casos, o
artefato é representado na forma de uma imagem. O objetivo específico S2 tem relação com
o objetivo geral: ao definir adaptações na forma dos dados de entrada e considerar a maior
correlação horizontal da representação, algoritmos de explicabilidade podem produzir
resultados mais interessantes para determinar as relações entre a entrada e o resultado
produzido pela rede neural convolucional. A Tabela 7 apresenta um quadro resumo com o
objetivo geral, objetivo específico S2 e a Lacuna L2.

.
análise de malware
Objetivo Específico S2 Definir representações que alinhem o resultado da explica-
bilidade com a alta correção horizontal da representação
da imagem mitigando os efeitos de distorção apresentados
na Lacuna L2
Lacuna L2 Malware de diferentes tamanhos são representados por ima-
gens de tamanhos variados e, para alimentar uma solução
de aprendizado profundo, estas imagens devem sofrer um
redimensionamento para valores fixos de altura e largura,
desconsiderando que a maior correlação na representação
por imagem do artefato está no eixo horizontal.
Não considerar a maior correlação no eixo horizontal da representação de imagem

do artefato malicioso faz com que distorções ocorram tanto na representação de entrada do
algoritmo de aprendizado profundo quanto nos resultado de algoritmos de explicabilidade
conforme apresentado na Seção 4.3.3. A grande maioria dos trabalhos utiliza a representação
apresentada em Nataraj et al.(13) e simplesmente não trata do problema de distorção ao
redimensionar a imagem original para as dimensões fixas de entrada de uma rede neural
convolucional.
Em Kabanga e Kim(37), uma representação por imagem dos artefatos é realizada
de acordo com Nataraj et al.(13) e, em seguida, transformada para o tamanho 128 × 128.
A acurácia obtida foi de 98% e o autor não utiliza nenhuma técnica de explicabilidade
para interpretar os resultados obtidos.
Em Rezende et al.(103), o autor representa o artefato malicioso de acordo com
Nataraj et al.(13) para, em seguida, redimensioná-lo para o tamanho 224 × 224. A acurácia
alcançada foi de 98,62% e o autor não utiliza qualquer mecanismo de explicabilidade.
Em Kalash et al.(29), o autor utiliza uma representação do artefato de acordo
com Nataraj et al.(13) para, então, redimensionar para 224 × 224. A acurácia obtida é de
97,52% para a base da Microsoft e de 99,97% para a base Malimg. O autor não utiliza
qualquer mecanismo de explicabilidade para relacionar os resultados com as entradas.
Em Yakura et al.(54), o autor transformou artefatos maliciosos da base de dados
VxHeavens imagens de acordo com Nataraj et al.(13), para em seguida converter as imagens
para o tamanho 128 × 128. Os resultados obtidos foram apresentados na forma de curva
ROC e o autor utilizou um mecanismo de explicabilidade de atenção(139) para obter
regiões de maior interesse do artefato.

Em Cui et al.(128), é utilizada uma representação de artefatos maliciosos na
forma de imagem conforme proposto em Nataraj et al.(13). Em seguida, os artefatos
são convertidos para o tamanho 128 × 128 para servir de entrada para uma rede neural
convolucional. A acurácia obtida foi de 96,70% após a aplicação de uma técnica para
compensar o desbalanceamento na quantidade de artefatos por família. O autor não utilizou
nenhuma técnica de explicabilidade.
Em Zhao et al.(129), o autor utilizou uma representação de imagem como entrada
para uma rede neural convolucional conforme Nataraj et al.(13). Em seguida, as imagens
foram processadas de forma que regiões de mesma entropia fossem retiradas. O resultado
final foi convertido para o tamanho 224 × 224. O resultado alcançado foi de 92,5% de
acurácia e o autor não utilizou nenhum tipo de explicabilidade.
Em Gibert et al.(130), o autor representou os artefatos de acordo com Nataraj et
al.(13) para finalmente redimensioná-las para o tamanho 256 × 256. A acurácia obtida foi
de 97.48% para o banco de dados e 97.49% para as bases de dados BIG2015 e MalImg,
respectivamente. O autor não utilizou nenhum mecanismo de explicabilidade.
Em Kadri, Nassar e Safa(131), o autor utilizou como entrada de dados os primeiros
1MB do artefato malicioso (dado bruto). A arquitetura proposta é similar a apresentada
em Raff et al.(28), mas com a saída modificada para que produza uma saída de tamanho
9 em vez de apenas 1 (maligno ou benigno). A acurácia obtida foi de 97,48% e o autor
não utilizou nenhum mecanismo de explicabilidade.
Em Raff et al.(28) utilizaram primeiros 2 Mb de informação do artefato malicioso
(dado bruto) como entrada para uma rede neural convolucional para a tarefa de detecção
de malware. A acurácia obtida é de 95%, utilizando uma base de dados privada com
aproximadamente 500 mil amostras. O autor aplica um algoritmo de explicabilidade
denominado class activation map(CAM)(10) para identificar possíveis regiões de interesse.
Em Krčál et al.(30), o autor utilizou uma representação de imagem de acordo
com Nataraj et al.(13) e, em seguida, redimensionou a mesma para o tamanho 224 × 224.
Além disso, foram adicionados atributos extraídos do artefato malicioso. O resultado foi
uma acurácia de 96% quando utilizou somente a imagem e 97,1% quando utilizou tanto a
imagem quanto os atributos extraídos. O autor cita o uso do algoritmo de explicabilidade
Grad-Cam(11) e apresenta um único resultado.
A Tabela 8 apresenta um quadro resumo dos trabalhos relacionados com a presença
de distorção na representação do artefato de entrada para a rede neural convolucional e
relacionados com o uso de explicabilidade. A Proposta P2 (Seção 7.2.3) apresenta uma
nova representação de imagem do artefato malicioso de forma que a distorção causada
pelo redimensionamento da imagem ocorra majoritariamente na horizontal.
Tabela 8 – Representação de Imagem de Artefatos Maliciosos
Trabalho Representação Imagem Distorção Uso de Expli-

Entrada nos dois cabilidade
eixos
Kabanga e Kim(37) De acordo com (13) 128 × 128 Sim Não
Rezende et al.(103) De acordo com (13) 224 × 224 Sim Não
Kalash et al.(29) De acordo com (13) 224 × 224 Sim Não
Yakura et al.(54) De acordo com (13) 128 × 128 Sim Sim
Cui et al.(128) De acordo com (13) 128 × 128 Sim Não
Zhao et al.(129) De acordo com (13) 224 × 224 Sim Não
Gibert et al.(130) De acordo com (13) 224 × 224 Sim Não
Kadri, Nassar e 1 Mb dado bruto 1 Mb Não Não
Safa(131)
Raff et al.(28) 2 Mb dado bruto 1 Mb Não Sim
Krčál et al.(30) De acordo com (13) 224 × 224 Sim Sim
Proposta P2 Fixando altura 224 × 224 Horizontal Sim
6.4 Explicabilidade em Aprendizado Profundo aplicado à Análise

de Malware
Para atingir o objetivo S3, uma pesquisa bibliográfica foi realizada em trabalhos
que aplicam explicabilidade em redes neurais convolucionais para análise de malware
considerando a aplicação do algoritmo em toda extensão da imagem ou em apenas em
uma região de interesse. O objetivo S3 tem relação com o objetivo geral ao definir um
método para obter resultados da explicabilidade apenas em regiões de interesse - regiões
estas definidas por um especialista na área de análise de malware, ou seja, permite melhor
identificar as relações entre as características de entrada e saída para uma região de
interesse. A Tabela 9 apresenta um quadro resumo com o objetivo geral, objetivo específico
S3 e a Lacuna L3.
Poucos trabalhos foram encontrados que debatem ou implementam explicabilidade
em arquiteturas de aprendizado profundo aplicadas à Análise de Malware e, nestes, o
algoritmo de explicabilidade era utilizado na forma original, sempre considerando a imagem
de entrada como um todo.
Em Raff et al.(28), o autor apresentou uma arquitetura baseada em redes convolu-
cionais inovadora, onde a entrada de dados são os primeiros 2Mb do artefato malicioso.
Utilizando a técnica de class activation map (10) foi possível encontrar áreas, aprendidas
pelo algoritmo de aprendizado profundo, que produziam o aspecto maligno ou benigno do
artefato. A técnica foi utilizada para calcular as regiões de maior importância na imagem
de entrada como um todo.

.
análise de malware
Objetivo Específico S3 Adaptar um algoritmo de explicabilidade de forma a per-
mitir o processamento da explicabilidade em regiões de
interesse do artefato solucionando a Lacuna L3.
Lacuna L3 Os resultados da explicabilidade são obtidos a partir do
processamento de toda a imagem, não sendo possível pre-
determinar uma região a ser processada do artefato para
obter os resultados da explicabilidade.
Em Yakura et al.(54), o autor implementa um mecanismo simples de atenção(139)

para identificar as principais regiões de interesse do algoritmo de aprendizado profundo.
Em seguida, realiza uma análise manual das regiões destacadas pelo mecanismo de atenção
e apresenta os resultados. O mecanismo de atenção é treinado a partir do conjunto de
todas as imagens de entrada, não sendo possível treiná-lo somente com uma região de
interesse.
Em Krčál et al.(30), o autor utilizou o gradient-weighted class activation mapping
(11) para identificar as áreas consideradas mais importantes para o algoritmo de apren-
dizado profundo e apresentou apenas um resumo dos seus resultados. O algoritmo de
explicabilidade aplicado apresenta o resultado considerando a imagem como um todo.
A Tabela 10 apresenta um quadro resumo destes trabalhos considerando o uso
da explicabilidade e os resultados obtidos quando comparados a nossa proposta, desta-
cando uma descrição resumida da solução de aprendizado profundo utilizada, que tipo
de algoritmo de explicabilidade foi utilizado, se apresenta os resultados, se analisa o
desempenho do algoritmo de explicabilidade e se propõe alternativas as óbices do algoritmo
de explicabilidade utilizado.
Tabela 10 – Explicabilidade em RNC para análise de artefatos maliciosos
Trabalho Algoritmo de Explicabilidade Região de

Interesse
Raff et al.(28) Class Activation Map (10) Não
Yakura et al.(54) Mecanismo de Atenção(139) Não
Krčál et al.(30) Gradient-Weighted Class Activation Mapping (11) Não
Proposta P3 Importância por Pixel Sim
A conclusão que se pode tirar é que são poucos os trabalhos de aprendizado

profundo aplicados à análise de malware que implementaram algum tipo de explicabilidade.

Mais especificamente, Raff et al.; Krčál et al.(28, 30) utilizaram mecanismos específicos
das redes neurais convolucionais e Yakura et al.(54) implementou o mecanismo de atenção,
que é uma técnica típica de arquiteturas de aprendizado profundo. A proposta P3 (Seção
7.2.4) propõe um algoritmo de explicabilidade em que é possível calcular a importância
apenas de uma região de interesse da imagem.
113
7 PROPOSTA DE TRABALHO
Neste capitulo estão apresentadas as propostas desta tese e sua relação com os
objetivos específicos e lacunas encontradas além da forma de avaliação, quando for o caso.
7.1 Método
Na figura 58 tem-se uma visão geral do escopo que envolve esta tese. Os blocos (a),
(b), (c) e (d) representam uma visão geral de duas etapas do desenvolvimento de soluções
baseadas em aprendizado de máquina: a etapa de treinamento e validação para obtenção
de um modelo de aprendizado de máquina e a etapa de teste que tem como objetivo obter o
desempenho do modelo no conjunto de testes ou para estimar rótulos de amostras a partir
de um modelo treinado. Ainda, os algoritmos de explicabilidade, utilizados para atingir o
objetivo S1,S2 e S3, são amplos e envolvem as etapas de representação, do algoritmo de
aprendizado profundo e do resultado.
Figura 58 – Visão Geral do Escopo deste Trabalho
Em (a), tem-se o Dataset que será utilizado no desenvolvimento desta tese. A

escolha do conjunto de dados define o objetivo da análise de malware e, desta forma, a
base de dados foi desenvolvida para classificação em 9 famílias de malware com binários
executáveis para plataforma Microsoft Windows. Esta base está descrita de forma mais
completa no apêndice A.
Em (b), é apresentada a representação escolhida como entrada para o algoritmo
de aprendizado profundo. Escolheu-se a opção de se fornecer os dados brutos na forma
de imagem (Imagem do Artefato, conforme apresentado na Seção 1.2), aproveitando-se
Capítulo 7. Proposta de Trabalho 114
da possibilidade de que algoritmos de aprendizado conseguem criar uma hierarquia de

representações sem necessidade de uma engenhara de atributos.
Como o objetivo desta tese é propor adaptações que, aplicadas a algorit-
mos de explicabilidade, permitam melhorar a identificação de relações entre as
características de entrada da rede com os resultados obtidos para uma determi-
nada tarefa na área de análise de malware, escolheu-se não utilizar a representação
de vetores de atributos dos artefatos maliciosos descrita na Seção 4.3.1 pelos seguintes
motivos:
• Para um analista de malware, saber que determinado atributo é mais importante

que outro pode ser pouco elucidativo, pois, comumente, há pouca interpretabilidade
nos atributos;
• A capacidade do algoritmo de aprendizado profundo de produzir novo conhecimento

está limitada, pois a engenharia de atributos já foi realizada.
Como exemplo da falta de interpretabilidade em atributos comumente utilizados,

pode-se citar a frequência de um determinado mnemônico. Por exemplo, para classificar
um artefato malicioso na classe Vundo, obtém-se, de um algoritmo de explicabilidade, que
o atributo mais importante é o valor da contagem de ocorrências do mnemônico M OV .
Esta informação, provavelmente, será pouco esclarecedora para um analista, ainda que
seja eficiente para a tarefa de classificação.
Em (c) pode-se utilizar diversos algoritmos de aprendizado profundo que possuam
resultado aceitável para a tarefa de análise de malware escolhida. Para esta tese, foi utilizada
a arquitetura de rede neural convolucional por ser adequada e comumente utilizada para
classificar imagens(3).
Finalmente, em (d), tem-se o resultado da tarefa de classificação em um das 9
famílias em conformidade com a base de dados utilizada nesta tese.
As técnicas de explicabilidade, utilizadas nesta tese para atingir os objetivos
específicos S1, S2 e S3, envolvem os blocos (b), (c) e (d). É interessante destacar que o
resultado de acurácia da rede neural convolucional aplicada a tarefa de classificação de
amostras de malware em famílias e que atende ao objetivo S0, não deve ser prejudicado
pela implementação de soluções de explicabilidade.
Com a conclusão deste trabalho, as principais contribuições foram:
(i) Uma ou mais arquiteturas de redes neurais convolucionais que possuem acurácia de
forma a atender o objetivo específico S0;
(ii) Uma técnica, baseada em algoritmos de explicabilidade, que resulta em possíveis

candidatos a retificação do rótulo e uma forma de avaliação da técnica que permita
atender o objetivo específico S1;
(iii) Uma técnica para representar o artefato malicioso na forma de imagem e que permita
avaliar a vantagem desta representação ,considerando os resultados dos algoritmos
de explicabilidade, buscando atender ao objetivo específico S2;
(iv) Um algoritmo de explicabilidade, adaptado à soluções de aprendizado profundo

aplicadas à análise de malware, que permita que apenas uma região pré-determinada
para análise pode ser selecionada, atendendo, assim, ao objetivo específico S3.
Indiretamente, também se obteve as seguintes contribuições:
(i) Descrição completa de arquiteturas de redes neurais convolucionais para análise de

malware;
(ii) Uma solução de aprendizado profundo baseado em redes recorrentes onde a entrada
é a sequência de mnemônicos do artetfato;
(iii) Bases de dados de malware para pesquisa acadêmica.
Ainda, os algoritmos e métodos relacionados com explicabilidade apresentados

podem, facilmente, ser adicionados ao modelo apresentado em Han et al.(8).
7.2 Propostas
Nesta Seção estão apresentadas as 4 principais propostas desta tese: (a) Uma
solução baseada em redes neurais convolucionais (RNC) para classificação de artefatos
maliciosos - Proposta P0, (b) Um Algoritmo que resulta em candidatos à Re-Rotulagem
por meio do processamento de Atributos Aprendidos - Proposta P1, (c) Uma nova
representação do Artefato Malicioso - Proposta P2 e (d) Um algoritmo denominado
Importância por Pixel - Proposta P3.
7.2.1 Arquitetura RNC - Proposta P0

Fruto da pesquisa apresentada na Seção 6.1, decidiu-se selecionar algumas arquite-
turas de redes neurais convolucionais para a análise de artefatos maliciosos:
1. Pela análise dos resultados obtidos em Gibert et al.(130), decidiu-se por selecionar
variações da arquitetura Lenet-5 (6). Estas podem incluir técnicas como Dropout
(Seção 3.4.3) e Normalização em Lote (Seção 3.4.5). É importante destacar somente
em Gibert et al.(130) houve a descrição completa da arquitetura convolucional

existente;
2. Da análise dos resultados de Rezende et al.(103), decidiu-se por selecionar a ar-

quitetura ResNet(12) e utilizar a técnica de Transferência de Aprendizado (Seção
3.4.6);
3. Finalmente, da análise dos resultados de Kalash et al.(29), decidiu-se por selecionar

as arquiteturas V GG16(140) e V GG19(116) e utilizar a técnicas de Transferência
de Aprendizado (Seção 3.4.6).
Conforme resultado da pesquisa bibliográfica apresentada na Seção 6.1, a média

acurácia para a base de dados Microsoft Malware Classification Challenge (BIG 2015) é
de 96,62% e, portanto, deve ser utilizado como valor base de acurácia a ser obtido.
7.2.2 Re-Rotulagem de Base de Dados - Proposta P1

As Base de dados de artefatos maliciosos possuem, normalmente, diversos erros
nos rótulos e o principal motivo para isto é que a rotulagem destas bases é realizada
pelo resultado produzido por uma ou mais soluções de antivírus. No entanto, um sistema
de antivírus tem seu foco na identificação de um artefato malicioso e não na correta
classificação do mesmo como pertencente ou não a uma determinada família(141).
7.2.2.1 Descrição da Proposta
Em redes neurais convolucionais, é possível obter os atributos aprendidos a partir

de um modelo treinado. Estes atributos aprendidos são o resultado final da aplicação de
diversas camadas convolucionais, de funções não lineares (ReLU) e, possivelmente, de
outras técnicas como normalização em lote ou dropout. Ou seja, a saída da última camada
convolucional de uma rede neural convolucional representa o processo de engenharia de
atributos realizado pela rede neural convolucional(142, 143).
A Figura 59 ilustra o processo de extração dos atributos aprendidos de uma rede
convolucional. Cada amostra do conjunto de dados X é selecionada e fornecida a uma
rede neural convolucional treinada, que produz um resultado de classificação. Da camada
de achatamento, que fica entre as camadas convolucionais e as camadas completamente
conectadas, é possível extrair um vetor de atributos F de dimensão p. Assim, para as m
amostras do conjunto de dados X, obtém-se uma matriz de atributos m×p.
Para obter candidatos a re-rotulagem da base de dados, utiliza-se a matriz de
atributos do conjunto de treinamento. Inicialmente, define-se ω que é quantidade de
amostras mais próximas de uma amostra desejada. Em seguida, seleciona-se o conjunto de
amostras do conjunto de treinamento que foram preditas de forma equivocada Θ. Para
Figura 59 – Obtenção da matriz de atributos FXtrain de uma entrada Xtrain .
cada amostra θ deste conjunto Θ são escolhidas ω amostras σ que possuem a menor
distância euclidiana entre Fθ e Fσ e obtém-se o conjunto Σ = θ1 , θ2 , ..., θω . Em seguida,
obtém-se o rótulo real para θ, Rθ e o rótulo real de cada amostra de Σ, RΣ . Se Rθ não
pertencer a RΣ então θ é uma amostra candidata a verificação de rótulo.
Algorithm 3: Algoritmo Proposto: Candidatos a Re-rotulagem
Data: Modelo treinado M , matriz de atributos F com dimensão m×p do conjunto
de treinamento, rótulos de real Realm×1 e rótulo preditos P redm×1
Result: Conjunto de candidatos a Verificação de Rótulos Γ
Definir conjunto de amostras Θ onde Realmx1 6= P redmx1 ;
Definir ω como a quantidade de amostras mais próximas ;
for cada amostra θ de Θ do
Obter Fθ que é o vetor de atributos da amostra ;
Calcular as ω amostras da matriz F mais próximas de Fθ e obter o conjunto Σ ;
Obter os rótulos reais de Σ, RΣ e de θ, Rθ ;
if Rθ ∈/ RΣ then
Incluir θ em Γ ;
end
end
O algoritmo proposto empresta ideias de algoritmos amplamente conhecidos como

o k-means(74) e o k-Nearest Neighbors(144) adequando seus conceitos à proposta.
Para fins de ilustração, a Figura 60 apresenta a aplicação do algoritmo em que

1
ω = 6 e os atributos aprendidos por uma rede neural convolucional baseada na Lenet-5
foram projetados para duas dimensões. Deve-se ressaltar, no entanto, que o algoritmo
original é aplicado à dimensão de F dos atributos aprendidos e não em duas dimensões.
Na Figura, a amostra 56, marcada com um N, está sendo avaliada, . Selecionam-se as 6
amostras mais próximas da amostra 56. Os rótulos destas seis amostras mais próximas
são: Winwebsec e Hupigon. Como o rótulo real da amostra 56 (true label) é Bifrose e não
existe nenhuma amostra da família Bifrose entre as seis mais próximas, a amostra 56 é
candidata a verificação de rótulo.
Figura 60 – Exemplo ilustrativo da Proposta P1 para Amostra 56.
De forma similar, a Figura 61 apresenta a aplicação do algoritmo de re-rotulagem

para a Amostra 582 em que ω = 6. Selecionaram-se, portanto, as seis amostras mais
próximas da amostra 582, marcada com um N, e os rótulos encontrados foram: Hupigon,
Winwebsec, Bifrose e Cycbot. Como o rótulo real da amostra 582 é Cycbot, ela não é
candidata a verificação de rótulo.
A forma de avaliação desta proposta envolve o cálculo da métrica f1-score(65, 66)
e matriz de confusão(65, 66), considerando que uma saída 1 significa que deve existir uma
revisão do rótulo real da amostra e 0 significa não deve existir uma revisão do rótulo real
da amostra.
7.2.3 Nova representação do Artefato Malicioso- Proposta P2

Na Seção 4.3.3, estão apresentadas as lacunas encontradas em diversos trabalhos
que utilizam a representação de dado bruto na forma de imagem como entrada para
1
Qualquer outro valor de ω pode ser escolhido. O valor 6 foi escolhido apenas para exemplificar a
aplicação do método.
Figura 61 – Exemplo ilustrativo da Proposta P1 para Amostra 582.
um algoritmo de aprendizado profundo, sendo que a distorção da representação afeta,

diretamente, os resultados da explicabilidade.
Para fins de apresentação da proposta de nova representação, será utilizada uma
arquitetura de rede neural convolucional baseada na Lenet-5 denominada Lenet−5 Normal.
A Figura 62 apresenta uma visão geral da arquitetura Lenet − 5 Normal conforme descrita
na Seção B.1.
Figura 62 – Arquitetura Lenet − 5 Normal destacando a quantidade de camadas convolu-

cionais e quantidade de camadas completamente conectadas.
Utilizando a arquitetura Lenet − 5 Normal, artefatos maliciosos foram represen-

tados como imagem, utilizando a Tabela 2 proposta por Nataraj et al.(13). Em seguida,
redimensionou-se a imagem para 224 × 224. Conforme apresentado na Seção 8.2.1, a
acurácia do modelo é de 99,52% para o conjunto de treinamento e de 93,65% para o
conjunto de testes.
Uma visão geral do processo de classificação de amostras de artefatos maliciosos em
famílias utilizando a arquitetura descrita pode ser visto na Figura 107. Em (1), a amostra
Figura 63 – Visão geral do processo de obtenção do mapa de calor por meio do Grad-Cam
para artefatos maliciosos. Em (1) tem-se o artefato sendo representado como
uma imagem de tamanho 256 × 299. Em (2) a imagem é redimensionada para
224 × 224. Em (3) a amostra é aplicada a uma RNC treinada produzindo
um resultado (4). Além disso, por meio de um algoritmo de explicabilidade é
obtido o mapa de calor (5) de tamanho 224 × 224. Finalmente em (6) o mapa
de calor é redimensionado para 256 × 299.
de um artefato malicioso da família T rojan : W in32/V undo2 é representada na forma

de uma imagem de tamanho 256 × 299. Em seguida, em (2), redimensionou-se a imagem
para o tamanho 224 × 224. Em (3), utilizamos essa imagem de tamanho 224 × 224 como
entrada do modelo baseado na Lenet − 5 Normal, para classificar artefatos maliciosos em
9 famílias. Já em (4), tem-se o resultado da predição do modelo.
Finalmente, pode-se obter o mapa de calor ao aplicar um algoritmo de explicabili-
3
dade , em (5), um mapa de calor de tamanho 224 × 224 é obtido destacando a localização
de regiões que o modelo considerou relevante para realizar a classificação. Finalmente em
(6), realizou-se um redimensionamento do mapa de calor para o tamanho da representação
original do artefato malicioso.
Pode-se observar que, em dois momentos do processo, temos a distorção de repre-
sentação: de (1) para (2) e de (5) para (6). A Figura 64 apresenta as 4 imagens destacadas
e suas respectivas dimensões. Como a proporção entre largura e altura não se mantém de
(a) para (b) e de (c) para (d), fica clara a distorção da representação. Além disso, qualquer
dilatação no eixo vertical poderia ser indesejada, já que a correlação entre os bytes da
imagem é, prioritariamente, horizontal apenas (Ver Seção 4.3.3).
2
Artefato VirusShare_613c7d47cc5b836a591f9cda82cfbe00.
3
Utilizou-se o método intrínseco para redes convolucionais denominado GradCam. Ver Seção 5.4.2.3
Figura 64 – Efeito da Distorção da Representação no resultado da explicabilidade. Em (a)

tem-se a imagem original de tamanho 299 × 256. Em (b) tem-se a imagem
redimensionada para o tamanho 224 × 224. Em (c) tem-se o mapa de calor
obtido, de tamanho 224 × 224. Finalmente em (d), tem-se o mapa de calor
redimensionado para o tamanho 299 × 256.
Assim, idealmente, as regiões de mapa de calor na imagem final deveriam considerar

uma maior correlação de valores no eixo horizontal. Uma imagem de região de calor com
espalhamentos na forma de retas horizontais representaria melhor uma sequência de bytes
do artefato malicioso.
No entanto, ao utilizar a Tabela 2 proposta por Nataraj et al.(13), distorções
diferentes, tanto no eixo horizontal como no vertical, são observadas para artefatos da
mesma família.
7.2.3.1 Descrição da Proposta
Para resolver o problema, pode-se fixar o valor da altura de imagem para representar
todos artefatos maliciosos, variando somente a largura em função do tamanho do artefato.
Assim, a distorção, por causa do redimensionamento da imagem ocorrerá majoritariamente
na horizontal.
A Figura 65 apresenta um artefato da família Trojan:Win32/Koutodoor de tamanho
64 × 2626 sendo redimensionado para o tamanho de 224 × 224. Podemos observar que a
distorção na altura é de 2:1 e a distorção na largura é de 82:1 aproximadamente.
A Figura 66 apresenta uma visão geral do processo proposto, fixando o valor da
altura em 64. A diferença em relação ao método descrito na Seção 4.3.3 é que ambas as
representações do artefato malicioso em (1) e no mapa de calor obtido em (6) possuem
uma altura de 64.
Para avaliar esta proposta, dois aspectos foram considerados:
1. Desempenho: inicialmente, é preciso definir diversos valores de altura e verificar

como esta nova representação afeta o desempenho quando comparada ao método de
representação proposto em Nataraj et al.(13);
Figura 65 – A Figura apresenta o efeito da distorção em um artefato da família Tro-

jan:Win32/Koutodoor.
Figura 66 – Visão geral do processo de obtenção do mapa de calor por meio do método
proposto. Em (a) tem-se a imagem original de tamanho 64 × 2626. Em (b)
tem-se a imagem redimensionada para o tamanho 224 × 224. Em (c) tem-se o
mapa de calor obtido, de tamanho 224 × 224. Finalmente em (d), tem-se o
mapa de calor redimensionado para o tamanho 64 × 2626.
2. Capacidade de Gerar Assinaturas: o resultado da explicabilidade pode ser útil

para gerar assinaturas de forma automática. Dessa forma, o resultado da aplicação
da forma de representação proposta e o método proposto em Nataraj et al.(13) foram
comparados.
7.2.4 Algoritmo de Importância por Pixel - Proposta P3

Conforme já apresentado na Seção 5.4.1.1, o método de estimativa da importância
pela permutação de atributos é um método agnóstico que pode ser utilizado em modelos
de aprendizado profundo. A vantagem desta proposta é que é possível definir uma região
de interesse para análise e o custo computacional será proporcional à esta região.
Quando aplicados à tarefa de análise de malware, o algoritmo de estimativa da

importância pela permutação de atributos permite identificar mapas de importância para
todo conjunto de treinamento ou teste de amostras de malware. Assim, se for selecionado
um subconjunto de uma única família do conjunto de dados de treinamento ou teste, serão
obtidas as regiões de maior importância para toda uma família. Portanto, definiram-se os
seguintes passos:
1. Treinar um modelo a partir de imagens de artefatos redimensionadas para 32 × 32 e

obter um modelo treinado;
2. Separa-se todas as amostras da família selecionada f desejada e aplica-se o algoritmo

de importância de atributos por permutação (Seção 5.4.1.1 para esse conjunto;
3. Obtém-se um mapa de importância para toda da família f ;
A Figura 67 mostra, de forma similar ao apresentado na Seção 5.4.1.1, o processo

para obter o valor da importância Rk = errok /erro. Uma medida de erro comumente
utilizada, nesse caso, é a acurácia, que neste caso, é se a classe predita está certa ou errada.
Figura 67 – A Figura ilustra uma visão geral do processo de obtenção da feature importance
em análise de malware.
Na Figura 68, é apresentado um exemplo da aplicação desse processo em um

conjunto de treinamento da base de dados VirusShareSant, que é composta por 9 famílias.
Nessa Figura temos em (a), (b) e (c), os atributos mais importantes para a família Vundo,
Cycbot e Zwangi, respectivamente.
Pode-se observar que a região que se destacou para a família Vundo é uma região do
início do arquivo (esquerda e acima), região está onde estão, comumente, as informações do
Figura 68 – Visualização do mapa de importância para famílias (a) Vundo, (b) Cycbot e
(c) Zwangi.
cabeçalho de um arquivo do tipo PE file; para os artefatos da família Cycbot, tanto a região
de cabeçalho como a região inicial de código executável se destacaram; finalmente, para
artefatos da família Zwangi, duas regiões se destacaram: uma região inicial (cabeçalho) e
uma região no final (de dados).
7.2.4.1 Descrição do Problema
Considerando que artefatos são representados em imagens de tamanho diferente,

uma área retangular na imagem de importância será traduzida para regiões retangulares de
tamanhos distintos na imagem original. De fato, a mesma região de importância em uma
imagem de tamanho 32 × 32 leva a regiões diferentes de artefatos de tamanhos diferentes,
ainda que da mesma família. A Figura 69 apresenta um exemplo desse problema. Em
(a) e (c) temos duas amostras distintas de malware da família Zwangi que pertencem ao
conjunto de treinamento. Em (b) temos uma imagem de tamanho 32 × 32 com os atributos
importantes obtidos pela permutação das amostras da família Zwangi. Podemos observar
que a mesma região destacada em vermelho em (b) leva a regiões de tamanhos diferentes
em (a) e (c). Do ponto de vista semântico e para a análise de malware, é pouco provável
que toda a região destacada em (a) tenha a mesma função de toda a região destacada em
(b). Este fenômeno é causado pela distorção de representação.
Um resultado que indica os efeitos da distorção de representação, é que os valores
de média e variância da importância são da mesma ordem de grandeza, o que torna o valor
da média, em si, pouco significativo. Estas lacunas encontradas na aplicação do algoritmo
de importância por permutação de pixel, que permite que uma região seja selecionada
para análise, foi o fator motivador para o desenvolvimento da proposta.
7.2.4.2 Solução Proposta: Algoritmo de importância por pixel
O método de importância por permutação de atributos faz, para cada atributo dos
dados de entrada, uma permutação de valores entre as amostras e calcula um erro ek para
cada permutação. No caso de representação por imagem, o método é aplicado a cada pixel
da imagem de entrada (por exemplo, 32 × 32) do modelo de algoritmo de aprendizado
Figura 69 – Efeito da distorção de representação no método de Importância de atributos

por permutação para artefatos maliciosos da família Zwangi.
profundo já treinado. Neste método, a forma de perturbar um determinado atributo é por

meio da permutação de valores entre as amostras.
A proposta envolve a aplicação da pertubação na imagem original, ou seja, na
representação do artefato malicioso e, em seguida, realizar o redimensionamento da imagem.
A parte interessante desta abordagem é que ela permite que se estime, pontualmente na
imagem original, a importância de cada pixel. O problema é que não é possível realizar
a permutação em cada pixel, já que cada amostra de imagem tem tamanho diferente e
não há relação entre os pixeis de amostras diferentes. Portanto, no lugar de se usar a
permutação, utiliza-se ruído para realizar a pertubação4 . Uma justificativa para o uso do
ruído pode ser vista no Apêndice E.
A Figura 110 apresenta um resumo do processo proposto. Inicialmente, a amostra
original do artefato malicioso é redimensionada e submetida ao modelo treinado. A classe
do artefato é predita e um erro erro é calculado5 . Finalmente, realizamos uma pertubação
em um pixel da imagem original, redimensionamos a mesma e submetemos ao modelo
treinado. A classe é predita e um erro errok é calculado. A razão R = erro/errok é
calculada de forma similar ao método de importância por permutação de atributos. O
processo é repetido para diversos valores de pertubação. Denominamos essa proposta de
4
Considerando que o código hexadecimal varia de 0-255, temos 255 valores possíveis, pois o valor original
do pixel não deve ser utilizado.
5
Geralmente utilizamos a acurácia.
Figura 70 – A Figura ilustra uma visão geral do processo de obtenção da feature importance
em análise de malware.
“Importância por Pixel”. O algoritmo 4 apresenta esse processo:

Algorithm 4: Algoritmo Proposto: Importância por pixel
Data: Modelo treinado F , representação por imagem: Img que possui N pixeis,
rótulos de saída classereal , medida de erro e = L(classe, F )
Result: Mapa de Importância de Img
Estimar o erro de Img quando submetido ao modelo treinado F ,
erro=L(classepred , F(Img));
for n ← 1 to N do
Gerar p pertubações no pixel n, obtendo p imagens ;
Estimar o erro erro0k = L(classepredk , F(Img)), para cada imagem;
Calcular a média dos valores de erro0k e obter errok ; ;
Calcular a a razão Rk =errok /erro ;
end
Ordenar os pixeis de forma descendente de Rk ;
A métrica de medida do erro para esse algoritmo proposto pode ser definida para
cada caso. É interessante observar que o uso da métrica acurácia permite que diversas
variações em pixeis produzam um erro errok igual a erro, ou seja, nenhum resultado de
importância. Na implementação desenvolvida foi utilizada a distância euclidiana do vetor
classereal da amostra ao vetor classepred .
127
8 RESULTADOS DE DESEMPENHO
Neste Capítulo, estão apresentados os resultados das arquiteturas de aprendizado

profundo e suas respectivas acurácias com relação a classificação de malware de forma a
atender ao objetivo S0.
8.1 Conjunto de Dados

Para a realização desta tese, optou-se pelo desenvolvimento de uma base de dados
de artefatos maliciosos que contém 9 famílias. A descrição desta base dados, denominada
VirusShareSant, está apresentada no Apêndice A. A Tabela 11 apresenta as famílias e a
quantidade de amostras de cada família para a VirusShareSant.
Tabela 11 – Quantidades de amostras de malware por família para a base VirusShareSant
Classe Família Quantidade de Amostras

1 Backdoor:Win32/Bifrose 2291
2 Trojan:Win32/Vundo 6794
3 Backdoor:Win32/Cycbot 3622
4 BrowserModifier:Win32/Zwangi 920
5 Rogue:Win32/Winwebsec 4624
6 Trojan:Win32/Koutodoor 5605
7 Backdoor:Win32/Rbot 1170
8 Backdoor:Win32/Hupigon 1943
9 Trojan:Win32/Startpage 1648
A partir deste conjunto de dados, foram definidos o conjunto de treinamento,

conjunto de validação e conjunto de testes. O conjunto de teste representa 20% das
amostras da base de dados VirusShareSant, totalizando 5.724 amostras. Das restantes
80% das amostras (22.893 artefatos), 85% foram selecionadas para compor o conjunto
de treinamento, totalizando 19.459 amostras e 15% foram selecionadas para compor o
conjunto de validação, totalizando 3.434 amostras. A Figura 71 apresenta esta divisão.
A relação entre a quantidade de amostras por família no conjunto de treinamento,
validação e teste seguiu a mesma proporção apresentada na Tabela 11. Na Tabela 12 é
apresentada a quantidade de amostras por família para o conjunto de dados de treinamento,
validação e teste.
Tanto a forma de partição da base de dados VirusShareSantquanto as amostras de
cada subconjunto foram mantidas nos diversos experimentos e simulações de forma a ser
possível comparar o desempenho entre as diversas arquiteturas.
Capítulo 8. Resultados de Desempenho 128
Figura 71 – Divisão de conjunto de dados VirusShareSant.
Tabela 12 – Quantidades de amostras de malware para o conjunto de treinamento, valida-

ção e teste.
Classe Família Qtd. Trein. Qtd. Val. Qtd. Teste

1 Backdoor:Win32/Bifrose 1558 275 458
2 Trojan:Win32/Vundo 4620 815 1359
3 Backdoor:Win32/Cycbot 2463 435 724
4 BrowserModifier:Win32/Zwangi 626 110 184
5 Rogue:Win32/Winwebsec 3144 555 925
6 Trojan:Win32/Koutodoor 3811 673 1121
7 Backdoor:Win32/Rbot 796 140 234
8 Backdoor:Win32/Hupigon 1321 233 389
9 Trojan:Win32/Startpage 1120 198 330
Total 19.459 3.434 5.724
8.2 Seleção de Arquiteturas de Aprendizado Profundo

Conforme apresentado na Seção 6.1, poucos artigos apresentam os valores dos
hiperparâmetros utilizados para formar a arquitetura de Rede Neural Convolucional.
Assim, resolveu-se propor soluções baseadas em arquiteturas conhecidas.
8.2.1 Arquiteturas de Aprendizado Profundo baseadas na Lenet-5

Em um primeiro momento, foi utilizado um modelo similar ao Lenet-5 (6) para a
classificação de artefatos maliciosos em 9 famílias, com a diferença de que foi definida,
como função de ativação, a ReLu no lugar da Sigmoid e do uso de Max Pooling no lugar do
Average Pooling. O resultado de acurácia desta arquitetura para o conjunto de treinamento
foi de 92,57% e 87,45% para o conjunto de validação.
Com estes resultados iniciais, foram desenvolvidas outras arquiteturas baseadas na
Lenet-5 e descritas no Apêndice B, Seção B.1: Normal, Small e Tiny. A representação do
artefato malicioso foi feita de acordo com a Tabela 2 proposta por Nataraj et al.(13). Esta
representação foi redimensionada para valores de 32 × 32, 64 × 64, 128 × 128 e 224 × 224.
O treinamento foi realizado com 20 épocas, o que já foi suficiente para estabilizar a perda
dos diversos modelos. Os resultados estão apresentados na Tabela 241 .
Da Tabela 13, pode-se concluir que nenhuma das arquiteturas se destacou na
obtenção do melhor resultado: para uma entrada de tamanho 32 × 32 a melhor arquitetura
(acurácia no conjunto de validação) foi a Tiny; para uma entrada de 64 × 64 a melhor
arquitetura foi a Tiny; para uma entrada de 128 × 128 a melhor acurácia foi na arquitetura
Normal; e finalmente para a entrada de 224 × 224 a melhor acurácia foi para a arquitetura
Normal - que também foi o melhor resultado de acurácia.
Quando se considera o tamanho da entrada, quanto maior o valor da entrada,
melhor o modelo: a entrada de tamanho 224 × 224 obteve a melhor acurácia para as
diversas arquiteturas.
Tabela 13 – Acurácia para os diversos modelos baseados na arquitetura Lenet-5.

Arquitetura Tamanho da Acurácia no Acurácia na
Imagem de Entrada Treinamento Validação
Normal 32 × 32 97,79% 91,73%
Normal 64 × 64 99,06% 91,99%
Normal 128 × 128 99,18% 93,36%
Normal 224 × 224 99,52% 93,65%
Small 32 × 32 98,46% 91,47%
.
Small 64 × 64 99,45% 92,66&
Small 128 × 128 99,56% 91,85%
Small 224 × 224 99,73% 93,56%
Tiny 32 × 32 98,39% 91,88%
Tiny 64 × 64 99,48% 93,13%
Tiny 128 × 128 99,86% 93,33%
Tiny 224 × 224 99,78% 93,48%
Ainda, da Tabela 24, pode-se observar que há uma grande diferença entre a
acurácia no conjunto de treinamento e validação, ou seja, os modelos podem estar fazendo
sobreajuste (overfitting). A Figura 72 apresenta dois exemplos de possível sobreajuste
de acordo com a evolução dos modelos a cada época para o conjunto de treinamento e
validação para entrada do tamanho 224 × 224: em (a) é apresentada a acurácia para a
arquitetura Normal e em (b) é apresentada a acurácia obtida para a arquitetura Small.
Em (a) a diferença entre a acurácia de treinamento e a acurácia de validação é de quase
7% e em (b) esta diferença é de quase 6%.
Com intuito de melhorar os resultados no conjunto de validação, algumas alter-
nativas foram analisadas como o uso de Dropout para diminuir o sobreajuste ou o Batch
1
Idealmente, dever-se repetir o mesmo experimento diversas vezes e obter um valor médio e a variância
da acurácia.
Figura 72 – Exemplo de sobreajuste para arquiteturas Normal e Small.
Normalization para aumentar a estabilidade do modelo e, como efeito secundário, diminuir

o sobreajuste. No entanto, pouco resultado foi obtido com o uso destas técnicas para a dimi-
nuição do sobreajuste no conjunto de validação e, portanto, estes modelos permaneceram
inalterados.
8.2.2 Arquiteturas de Aprendizado Profundo com Transferência de Aprendi-

zado
De forma a obter uma variedade de arquiteturas de redes neurais convolucionais,
Escolheu-se utilizar arquiteturas consagradas e transferência de aprendizado conforme
descrito no Apêndice B, Seção B.2. A Tabela 14 apresenta o resultado de desempenho
para 8 arquiteturas que utilizaram transferência de aprendizado e que obtiveram acurácia
interessante.
Tabela 14 – Acurácia para os diversos modelos utilizando transferência de aprendizado.

Arquitetura Tipo de Acurácia no Acurácia na
Transferência Treinamento Validação
Resnet big por Inicialização 96,75% 92,57%
Resnet tiny por Inicialização 99,05% 94,93%
VGG16 big por Atributos 95,61% 87,91%
.
VGG16 non-top por Atributos 99,32% 95,22%
VGG19 big por Atributos 96,44% 88,64%
VGG19 non-top por Atributos 98,75% 94,76%
VGG16 block5_conv2 parcial de Atributos 93,26% 92,38%
VGG19 block5_conv1 parcial de Atributos 92,53% 91,86%
A primeira obervação que se pode fazer destes resultados é a diferença entre a

acurácia no conjunto de treinamento e a acurácia no conjunto de validação é pequena
quando comparada às arquiteturas baseadas na Lenet-5, o que sugere que quase não há
sobreajuste. Desta forma, os modelos que obtiveram as melhores acurácias no conjunto de
validação foram a VGG16 non-top, Resnet tiny e VGG19 non-top. A Figura 73 apresenta
as acurácias no conjunto de treinamento e validação para estas três arquiteturas em função
do número de épocas do treinamento.
Figura 73 – Arquiteturas VGG16 non-top, VGG19 non-top e Renet tiny sem sobreajuste.
8.2.3 Seleção de Arquiteturas

A partir dos resultados de acurácia obtidos, foram selecionadas 1 arquitetura
baseada na Lenet-5 e 3 arquiteturas que utilizaram transferência de aprendizado. Do
ponto de vista de treinamento da etapa de engenharia de atributos dos modelos (camadas
convolucionais), o modelo Lenet-5 Normal teve os seus pesos inicializados de forma aleatória,
a arquitetura Resnet tiny teve seus pesos inicializados com os valores aprendidos para o
conjunto de dados Imagenet(117) e os modelos V GG16 non-top e V GG19 non-top tiveram
seus pesos congelados com o valor que foi aprendido no conjunto de dados Imagenet(117).
A Tabela 16 apresenta o resultado da acurácia dos modelos selecionados para o
conjunto de testes.
Tabela 15 – Acurácia para o conjunto de testes para os modelos Lenet-5 Normal, Resnet
tiny, V GG16 non-top e V GG19 non-top.
Arquitetura Tamanho da Tipo de Acurácia no
Entrada Transferência Teste
Lenet-5 Normal 224 × 224 —- 92,51%
.
Resnet tiny 224 × 224 por Inicialização 94,27%
VGG16 non-top 224 × 224 por Atributos 93,96%
VGG19 non-top 224 × 224 por Atributos 93,92%
O desempenho da arquitetura Lenet-5 N ormal pode ser observado a partir da

matriz de confusão do conjunto de dados de teste (5.724 amostras). Observando a ma-
triz de confusão, na linha 1 e coluna 2, tem-se que 24 amostras são da classe Back-
door:Win32/Bifrose (primeira família) e que o algoritmo de aprendizado profundo classifi-
cou como Trojan:Win32/Vundo (segunda família).
 

348 24 5 4 9 5 19 22 22 
 6 1314 5 1 7 2 11 7 6 
 
 
 0 2 715 1 0 0 6 0 0
 

 
 2 2 1 171 3 0 0 0 5
 

 
 11 6 3 1 860 0 1 38 5
 

 
 0 6 0 1 0 1112 1 0 1
 

 
 8 4 5 0 5 0 194 16 2
 

 
 11 14 3 1 18 0 9 301 32
 

 
13 9 0 3 4 3 3 15 280
O desempenho da arquitetura Resnet tiny pode ser observado a partir da matriz
de confusão do conjunto de dados de teste (5.724 amostras). Observando a primeira
linha da matriz de confusão, na linha 1 e coluna 8, tem-se que 39 amostras são da classe
Backdoor:Win32/Bifrose (primeira família) e que o algoritmo de aprendizado profundo
classificou como Backdoor:Win32/Hupigon (oitava família).
 

376 11 0 0 12 1 5 39 14 
 11 1320 3 0 2 1 7 10 5 
 
 
 2 2 718 0 0 0 2 0 0
 

 
 5 1 0 167 1 2 1 3 4
 

 
 6 2 0 0 901 0 1 13 2 
 
 
 1 1 0 0 1 1114 1 0 3
 

 
 11 2 2 0 5 1 198 14 1 
 
 
 13 6 0 0 21 2 3 330 14
 

 
13 6 0 3 8 6 1 21 272
O desempenho da arquitetura V GG16 non-top pode ser observado a partir da
matriz de confusão do conjunto de dados de teste (5.724 amostras). Observando a primeira
coluna da matriz de confusão, na linha 8 e coluna 1, tem-se que 24 amostras são da classe
Backdoor:Win32/Hupigon (oitava família) e que o algoritmo de aprendizado profundo
classificou como Backdoor:Win32/Bifrose (primeira família).
 

390 7 0 2 21 0 6 26 6 
 14 1298 8 2 12 2 3 17 3 
 
 
 1 2 719 0 1 0 1 0 0
 

 
 6 2 0 165 4 0 0 3 4
 

 
 6 0 0 1 896 0 2 20 0
 

 
 0 1 0 0 2 1115 1 2 0
 

 
 13 3 0 1 3 0 202 8 4
 

 
 24 5 0 0 31 0 3 323 3
 

 
21 6 0 2 7 2 3 19 270
Finalmente, o desempenho da arquitetura V GG19 non-top pode ser observado a
partir da matriz de confusão do conjunto de dados de teste (5.724 amostras). Observando
a primeira linha da matriz de confusão, na linha 8 e coluna 2, tem-se que 9 amostras são
da classe Backdoor:Win32/Hupigon (oitava família) e que o algoritmo de aprendizado
profundo classificou como Backdoor:Win32/Cycbot.
 

399 17 0 3 6 1 5 14 13 
 13 1321 2 1 1 2 5 9 5 
 
 
 3 8 711 0 0 0 2 0 0
 

 
 6 1 0 170 1 0 0 1 5
 

 
 20 0 1 2 889 0 2 7 4
 

 
 6 2 0 1 0 1109 0 0 3
 

 
 19 5 0 0 0 0 202 6 2
 

 
 40 9 0 1 18 0 4 289 28
 

 
21 7 0 1 2 2 3 8 286
8.2.4 Comitê de Classificadores

A partir dos resultados dos 4 classificadores, resolveu-se criar um classificador
ÚNICO utilizando a técnica de comitê de votação majoritária. Ainda, caso exista empate,
o resultado será dado pela saída do classificador que obteve melhor resultado no conjunto
de validação. Assim, a ordem decrescente dos classificadores é: V GG16 non-top, Resnet
tiny, V GG19 non-top e Lenet-5 Normal. O resultado de acurácia, utilizando este comitê
de classificadores foi de 99,88% no conjunto de treinamento (24 amostras classificadas
de forma equivocada) e o resultado no conjunto de testes foi de 95,37%. No total, foram
cometidos 265 erros de 5.724 amostras de testes.
A matriz de confusão para este comitê de classificadores para o conjunto de testes
apresenta uma melhora na classificação das diversas amostras quando comparada às
matrizes de confusão de cada classificador de forma isolada.
 

413 8 0 0 9 0 4 18 6 
 14 1330 2 0 2 1 3 6 1 
 
 
 2 4 717 0 0 0 1 0 0
 

 
 7 0 0 173 2 0 0 1 1
 

 
 8 1 1 1 902 0 2 10 0
 

 
 2 2 0 0 0 1115 1 0 1
 

 
 16 2 0 0 3 0 206 7 0
 

 
 31 7 0 0 19 0 2 324 6
 

 
18 6 0 0 4 3 3 17 279
8.3 Análise dos Resultados Obtidos

As acurácias no conjunto de testes para os classificadores V GG16 non-top, Resnet
tiny, V GG19 non-top e Lenet-5 Normal foram de 93,96%, 94,27%, 93,92% e 92,51%,
respectivamente. A média destas acurácias é de 93,66% que está menor que a acurácia
média de 96,62%, obtida da média dos trabalhos analisados (42, 29, 129, 130, 131) que
utilizam a base de dados Microsoft Malware Classification Challenge (BIG 2015).
Para melhor comparar ambas as bases, a arquitetura Lenet − 5 Normal foi aplicada
as amostras da base de dados Microsoft Malware Classification Challenge (BIG 2015)
conforme apresentado em Gibert et al.(130). O resultado obtido foi de 97,45% o que
é muito próximo ao resultado alcançado em Gibert et al.(130) que é de 97,48%. Este
resultado sugere que a base de dados VirusShareSanté intrinsecamente mais complexa que
a base de dados Microsoft Malware Classification Challenge (BIG 2015) para o objetivo
de classificação em famílias. Assim, resolveu-se manter as configurações das arquiteturas
de redes neurais convolucionais selecionadas.
8.4 Conclusão Parcial

Os resultados de acurácia alcançados, individualmente, por cada uma das arquite-
turas V GG16 non-top, Resnet tiny, V GG19 non-top e Lenet-5 Normal alcançaram um
valor suficiente para que o objetivo S0 seja atingido. Ainda, o uso de um comitê de
votação majoritária fez com que a acurácia atingisse um valor de 95,37%, que é maior que
o valor de acurácia de cada classificador individualmente.
135
9 RESULTADOS DA RE-ROTULAGEM
Neste Capítulo, estão apresentados os resultados relacionados à Proposta P1 -

Re-Rotulagem de Base de Dados.
9.1 Aplicação do Algoritmo Proposto

Para verificar como o algoritmo proposto de re-rotulagem de amostras de malware
se comporta, duas arquiteturas de aprendizado profundo foram selecionadas: a Lenet − 5
Normal e a V GG16 non_top. Ambas as arquiteturas foram treinadas com o conjunto de
treinamento conforme apresentado na Seção 8.1. A representação da imagem do artefato
malicioso foi realizada de acordo com Nataraj et al.(13).
Em ambos os casos, foram selecionadas as amostras que o algoritmo de aprendizado
profundo classificou de forma equivocada durante o treinamento. Estas amostras foram
então submetidas ao algoritmo de re-rotulagem proposto para diversos valores de ω.
9.1.1 Lenet-5 Normal

Para a arquitetura Lenet − 5 Normal, 93 amostras do conjunto de treinamento
foram preditas de forma equivocada. Para cada uma das 93 amostras foi realizada uma
verificação manual para determinar se o rótulo da amostra estava correto ou incorreto.
Este conjunto de 93 dados sobre a correta rotulagem será denominado Π.
Deve-se lembrar que esta avaliação manual não é simples: em muitos casos uma
amostra de malware possui diversos comportamentos presentes em mais de uma família de
artefatos maliciosos, ou seja, nem sempre existe uma fronteira clara para determinar se
uma amostra pertence a uma ou outra família (141, 145). O algoritmo proposto foi, então,
aplicado às 93 amostras variando o valor de ω entre 2 e 9. Em cada caso, foi calculado o
valor do f1-score, ou seja, o quão bem o algoritmo se saiu considerando Π.
A Figura 74 apresenta o resultado do f1-score em função do valor ω (quantidade
de pontos mais próximos). Pode-se observar que um valor de ω igual a 4 parece ser mais
adequado. Neste caso, o valor do f1-score foi estimado em 35,55%.
A métrica f1-score busca-se um equilíbrio entre os falsos positivos e falsos negativos
de uma classificação. A matriz de confusão para ω = 4 está apresentada a seguir:
 

56 26
3 8
Isto significa que 3 amostras precisavam de uma avaliação de re-rotulagem, mas o
Capítulo 9. Resultados da Re-Rotulagem 136
Figura 74 – Valor f1-score em função do valor ω selecionado para o modelo Lenet − 5

Normal para amostras com erro de predição.
algoritmo apresentou que não haveria esta necessidade (falso negativo). Ainda, 26 amostras
não precisavam de re-rotulagem, mas o algoritmo apresentou que era necessário (falso
positivo). Finalmente, 56 amostras não precisavam de re-rotulagem e foram identificadas
de forma correta pelo algoritmo (verdadeiro negativo); e 8 amostras precisavam de re-
rotulagem e foram identificadas de forma correta pelo algoritmo (verdadeiro positivo).
Considerando o ponto de vista de um analista de malware que precisa realizar a
verificação manual da possível re-rotulagem de artefatos, das 93 amostras selecionadas, o
algoritmo que sugere que se faça re-rotulagem em 34 amostras. Destas, apenas 8 realmente
necessitam de re-rotulagem. Finalmente, do conjunto de 93 amostras, 3 amostras que
precisam ser re-rotuladas não foram identificadas pelo algoritmo.
Finalmente, para comprovar a intuição de que somente amostras com predições
equivocadas devem ser submetidas ao algoritmo, foram selecionadas, ao acaso, 93 amostras
preditas de forma correta. A Figura 75 apresenta os valores do f1-score em função da
quantidade de pontos mais próximos selecionados.
Pode-se observar que o melhor f1-score, 13,79%, obtido está bem abaixo do f1-score
obtido para amostras preditas de forma equivocada que é de 35,55%.
9.1.2 VGG16 non_top

O mesmo experimento anterior foi repetido para a arquitetura V GG16 non_top.
Esta arquitetura possui 132 amostras preditas de forma equivocada no conjunto de
treinamento. para conjunto de 132 amostras, foram avaliadas manualmente a correta
rotulagem. Este resultado final da avaliação manual será denominado Π.
O algoritmo proposto foi, então, aplicado às 132 amostras variando o valor de ω
entre 2 e 9. Em cada caso, foi calculado o valor do f1-score, ou seja, o quão bem o algoritmo
Figura 75 – Valor f1-score em função do valor ω selecionado para o modelo Lenet − 5

Normal para amostras com acerto de predição.
se saiu considerando o conjunto Π. A Figura 76 apresenta o valor de f1-score para valores

de ω entre 2 e 9. Pode-se observar que, assim como a Lenet − 5 Normal, o melhor valor de
f1-score foi obtido com ω = 4, 46,95%.

non_top para amostras com erro de predição.
A matriz de confusão para ω = 4 está apresentada a seguir:

 

44 30
31 27
Do ponto de vista de um analista de malware, o algoritmo sugere que 57 amostras
devem ser reavaliadas para re-rotulagem. Destas, 27 realmente devem ser re-rotuladas e 30
não devem. Além disso, o algoritmo deixa 31 amostras que precisam ser re-rotuladas fora
do conjunto.
Novamente, a fim de validar o algoritmo para amostras preditas de forma equivocada,
foram selecionadas 132 amostras preditas de forma correta pelo V GG16 non_top para a
aplicação do algoritmo. A Figura 77 apresenta os resultados.

non_top para amostras com acerto de predição.
Novamente, pode-se observar que o maior valor de f1-score obtido 23,07% para
ω = 2 é bastante inferior ao obtido para amostras preditas de forma equivocada, 46,95%.
9.2 Conclusão Preliminar

O algoritmo proposto é inovador no sentido de ser capaz de propor candidatos a
re-rotulagem baseando-se na saída de um modelo de aprendizado profundo pré-treinado.
No entanto, o algoritmo proposto ainda possui lacunas:
• O valor do f1-score ser menor que 50%1 , mesmo para amostras preditas de forma
equivocada pelo algoritmo de aprendizado de máquina;
• O algoritmo não é adequado às amostras preditas de forma correta pelo modelo de

aprendizado profundo;
De qualquer forma, por indicar um caminho a ser aprofundado para resolver ou

minimizar os efeitos da Lacuna L1, considerou-se que o algoritmo atinge o Objetivo S1
de forma parcial.
1
Estimou-se que, para um analista de malware, avaliar o rótulo manualmente de amostras seja trabalhoso.
Assim, considera-se adequado se o algoritmo obtiver um f1-score maior que 50%.
139
10 RESULTADOS DA NOVA REPRESENTAÇÃO
Nesta Seção será apresentado os resultados sobre a Nova representação de artefatos

maliciosos descrita na Seção 7.2.3. Inicialmente, serão apresentados os resultados de
desempenho quando se utiliza esta proposta de representação e, em seguida, a proposta
será avaliada com relação à capacidade de produzir assinaturas de forma automática.
10.1 Desempenho das Arquiteturas de Aprendizado Profundo

O objetivo desta seção é apresentar os resultados de acurácia comparando os
resultados obtidos na Seção 8.2, que aplica a representação conforme Nataraj et al.(13) e
a Nova Representação proposta.
10.1.1 Descrição dos Experimentos

Originalmente, foram realizadas simulações considerando os tamanhos fixos de
altura 32, 64, 128 e 224, e valores de imagem de entrada de 32 × 32, 64 × 64, 128 × 128 e
224×224, totalizando 16 experimentos para cada conjunto de hiperparâmetros selecionados.
Nesta Seção estão apresentados somente os resultados de acurácia para valores fixos 2241
e entrada de 224 × 224. O valor de entrada 224 × 224 foi o que obteve melhor resultado
para arquiteturas com representação baseada em Nataraj et al.(13) (Capítulo 8).
Tabela 16 – Comparação de Acurácia para representação convencional e a proposta.

.
Convencional (Nataraj et al.(13)) Proposta
Arquitetura Acurácia Acurácia Acurácia Acurácia Acurácia Acurácia
Treinamento Validação Teste Treinamento Validação Teste
Lenet-5 Normal 99,52% 93,65% 92,51% 99,84% 94,58% 93,66%
Resnet tiny 99,05% 94,93% 94,27% 99,09% 95,08% 94,44%
VGG16 non-top 99,32% 95,22% 93,96% 99,73% 95,81% 94,58%
VGG19 non-top 98,75% 94,76% 93,92% 99,01% 95,49% 94,18%
Da mesma forma como apresentado na Seção 8.2.4, foi criado e avaliado um comitê
com os 4 classificadores considerando a representação proposta. O resultado do comitê
para o conjunto de testes foi de 95,21%. No total, foram cometidos 274 erros de 5.724
amostras de teste. O resultado foi pouco inferior ao resultado do comitê com classificadores
considerando a representação tradicional dos artefatos maliciosos que errou 266 amostras).
1
O valor fixo de 224 não obteve o melhor resultado, mas foi escolhido a fim de padronizar o valor fixo
de entrada para as diversas arquiteturas.
Capítulo 10. Resultados da Nova representação 140
A matriz de confusão para o comitê de classificadores considerando a representação

proposta está apresentada a seguir:
 

418 16 2 0 6 1 4 6 5 
 12 1337 0 1 2 1 5 0 1
 

 
 2 5 716 0 0 0 1 0 0
 

 
 6 3 0 172 1 0 0 0 2
 

 
 7 2 0 1 910 0 1 3 1
 

 
 1 0 0 0 0 1118 2 0 0
 

 
 19 11 0 0 3 0 198 3 0
 

 
 30 16 0 1 16 3 2 320 1
 

 
29 18 0 1 5 2 5 9 261
10.1.2 Análise dos Resultados

Individualmente, os resultados de acurácia para o conjunto de treinamento, va-
lidação e teste da Nova Representação foi pouco superior para as arquiteturas V GG16
non_top, V GG19 non_top, Resnet tiny e Lenet − 5 Normal. A maior diferença ocorreu
no conjunto de testes para o modelo Lenet − 5 Normal: 1,1499% e a média da diferença
foi de 0,4691%.
Para o comitê de classificadores por votação majoritária, o método convencional
obteve uma acurácia de 95,37% e o método utilizando a Nova Representação obteve uma
acurácia ligeiramente inferior de 95,21%.
10.1.3 Conclusão Parcial

A conclusão parcial é que a representação proposta pouco afeta no desempenho
dos diversos classificadores, podendo, portanto, ser utilizada com o intuito de melhorar os
resultados da aplicação de algoritmos de explicabilidade.
10.2 Regiões de calor

O objetivo desta seção é apresentar os resultados da aplicação de algoritmos de
explicabilidade em arquiteturas de aprendizado profundo aplicadas à análise de malware
considerando a representação tradicional de artefatos (13) e a Nova Representação proposta.
10.2.1 Descrição do Experimento

Para validar os resultados da Nova Representação, foi utilizado o algoritmo de
explicabilidade Grad-CAM(11) para todas as 4 arquiteturas, considerando as arquiteturas
V GG16 non_top, V GG19 non_top, Resnet tiny e Lenet − 5 Normal selecionadas, utili-
zando tanto a representação tradicional (13) quanto a proposta. Uma amostra2 da família
Trojan:Win32/Vundo foi alimentada em cada uma das 8 arquiteturas e os resultados foram
obtidos. Na Figura 78 está ilustrada a imagem desta amostra (a) em tons de cinza, (b)
utilizando um mapa de cores para melhor visualização e (c) destacando as seções do
artefato onde amarelo é a seção de cabeçalho, azul é seção executável e vermelho seção de
dados. O artefato possui 1 seção de cabeçalho, 1 seção de código executável e 5 seções de
dados.
Figura 78 – Amostra de Artefato da Família Trojan:Win32/Vundo.
A Figura 79 apresenta o resultado da amostra para a arquitetura Lenet − 5 Normal

pré-treinada3 utilizando a representação tradicional e proposta. Pode-se observar que
o mapa de calor é composto por diversas regiões desconectadas. Como a arquitetura
Lenet − 5 Normal possui muitos filtros (quando comparada às outras arquiteturas), cada
filtro está identificando um padrão em específico. Ou seja, fica claro pelo mapa de calor
que, apesar da Lenet − 5 Normal conseguir uma alta acurácia, seria complicado obter
algum resultado interessante do modelo treinado do ponto de vista de explicabilidade, pois
um analista teria que analisar todas as pequenas regiões de importância individualmente.
A Figura 80 apresenta o resultado da aplicação do Grad-CAM na amostra para
arquitetura Resnet tiny pré-treinada, utilizando a representação tradicional e proposta. Ao
contrário da Lenet−5 Normal, o mapa de calor, em ambos os casos, é composto basicamente
de uma grande área conectada. Um ponto interessante é que, considerando que há apenas
a diferença de representação, ambas encontraram áreas de importância bem diferentes.
No caso da representação tradicional, há uma região de importância predominantemente
vertical na parte debaixo da figura. Como os bytes estão dispostos na horizontal, seria
complicado obter o significado desta área vertical. No caso da representação proposta, há
claramente uma área mais larga na horizontal de altura aproximadamente de 30.
A Figura 81 apresenta o resultado da aplicação do Grad-CAM na amostra para
arquitetura V GG16 non_top. O resultado desta arquitetura parece bem interessante para
2
VirusShare_613c7d47cc5b836a591f9cda82cfbe00.
3
Dois modelos foram treinados. Um com amostras utilizando a representação tradicional e outro com
amostras utilizando a representação proposta.
Figura 79 – Mapa de Calor para modelo Lenet-5 Normal.
Figura 80 – Mapa de Calor para modelo Resnet tiny.
esta amostra pois as regiões de importância estão, em ambos os casos, bem delimitadas
e as áreas são bem menores que no caso da Resnet tiny. Da mesma forma, no caso da
representação proposta, a região da parte de baixo do mapa de calor é mais alargada na
horizontal.
Finalmente, a Figura 82 apresenta o resultado da explicabilidade quando aplicado
à V GG19 non_top. O resultado desta arquitetura para a representação tradicional e
proposta são similares. Ambas produziram uma área de importância localizada no canto
inferior direito do mapa de calor. Deve-se se observar que todos os exemplos apresentados
são para a mesma amostra e os mapas de calor são bem distintos. A explicabilidade, neste
caso, é específica do modelo, ou seja, o mapa de calor destaca o que é importante para um
Figura 81 – Mapa de Calor para modelo VGG16 non_top.
determinado modelo.
Além da visualização do mapa de calor em si, é interessante analisar lado a lado o

mapa de calor e as seções do arquivo tipo PE File. A Figura 83 apresenta o mapa de calor
em ambas as representações para o modelo V GG16 non_top. Podemos observar que o
modelo com a representação tradicional destaca uma região de importância localizada na
seção de dados e o modelo com a representação proposta destaca uma região de código.
Assim, com base em informações de mapa de calor, um analista pode aprofundar sua
análise: por exemplo, se o destaque for para uma região de código, é possível realizar
a desmontagem desta região de código e verificar o que o algoritmo considerou mais
importante. O resultado desta análise produzir novos conhecimentos na área de análise de
artefatos maliciosos.

Em qualquer caso apresentado, a análise das regiões de importância por um
analista de malware pode trazer novos conhecimentos, pois o modelo pode ter considerado
importante uma área antes desconsiderada. Assim, qualquer modelo tem potencial de
produzir resultados de explicabilidade interessantes. No entanto, para fins de avaliação
da Nova Representação, não é simples definir um critério objetivo para apontar um
melhor modelo. Assim, resolveu-se avaliar a capacidade de gerar assinaturas de forma
automatizada, conforme apresentado na Seção 10.3.

Os resultados da explicabilidade aplicada a modelos de redes neurais convoluci-
onais são interessantes para área de análise de malware e tem potencial para fornecer
novas informações antes desconhecidas. No entanto, não foi possível criar um critério
objetivo de avaliação que aponte qual modelo fornece melhor explicabilidade em função
da representação utilizada: (a) tradicional ((13) ou (b) Proposta.
10.3 Assinatura Automatizada

Para realizar a comparação de mapas de calor entre a abordagem de representação
tradicional e proposta, definiu-se o seguinte:
1. Definir um conjunto de dados para avaliação;
2. Dado mapa de calor de uma determinada amostra, procurar a localização dos picos;
3. Para cada pico, selecionar uma quantidade de n de bytes em torno do pico. Esta
sequência de bytes de tamanho 2 × n;
4. Avaliar todas as amostras do conjunto de dados. Idealmente, a assinatura é interes-

sante se somente amostras da mesma família da amostra selecionada possuírem a
assinatura.
Assim, o conjunto de dados utilizados foi o conjunto de validação e amostras

ao acaso foram selecionadas e avaliadas. Do ponto de vista de custo computacional, é
importante destacar que o tempo médio para a busca por 10 assinaturas de tamanho de
8 bytes no conjunto de validação demora algo em torno de 1 hora em um computador
Intel i7, geração 7, 7GB de memória RAM DDR4, HD SSD, considerando que todos os
artefatos estão compactados no formato .gz .
10.3.1 Resultados da Criação de Assinaturas - Lenet-5 Normal

Nesta seção serão apresentados os resultados do uso da sequência de bytes no
desenvolvimento de assinaturas para a Lenet-5 Normal, utilizando a abordagem tradicional
e a proposta.
(A) Estudo de Caso 1: Amostra da família Trojan:Win32/Vundo A
amostra escolhida foi a amostra VirusShare_613c7d47cc5b836a591f9cda82cfbe00 da família
Trojan:Win32/Vundo. A Figura 84 apresenta o mapa de calor e seções do arquivo para (a)
representação tradicional e (b) representação proposta.
Figura 84 – Mapa de Calor do modelo Lenet-5 Normal para Virus-

Share_613c7d47cc5b836a591f9cda82cfbe00 .
Para abordagem tradicional, foi possível identificar 5 regiões principais. Escolhendo

uma sequência de 8 bytes em torno de seus máximos obtém-se:
• Assinatura 1: 0x40, 0x0, 0x0, 0x0, 0x0, 0xc7, 0x0, 0x0.
• Assinatura 2: 0x0, 0x0, 0x0, 0x0, 0xc7, 0x0, 0x0, 0x6e.
• Assinatura 3: 0x0, 0x51, 0x72, 0xff, 0xf1, 0x72, 0x0, 0x0.
• Assinatura 4: 0x51, 0x72, 0xff, 0xf1, 0x72, 0x0, 0x0, 0x0.
• Assinatura 5: 0x51, 0x72, 0xff, 0xf1, 0x72, 0x0, 0x0, 0x0.

 
2619 0
A matriz de confusão de cada uma das 5 assinaturas foi:  .
814 1
O resultado não é interessante: por um lado, 2619 amostras não deveriam ter as
assinaturas e não as tinha. No entanto, das 815 amostras da família Trojan:Win32/Vundo,
apenas 1 tinha as assinaturas. Em outras palavras, a assinatura somente servia para
identificar unicamente o artefato. O f1-score obtido foi de 0,87%.
Para a abordagem proposta, também foram selecionadas sequências de 8 bytes em
torno dos dezoito máximos identificados.
• Assinatura 1: 0xfd, 0xff, 0xff, 0xff, 0x15, 0xb8, 0x20, 0x1.
• Assinatura 2: 0xff, 0xff, 0xff, 0x15, 0xb8, 0x20, 0x1, 0x10.
• Assinatura 3: 0xff, 0xff, 0x15, 0xb8, 0x20, 0x1, 0x10, 0x8d.
• Assinatura 4: 0xff, 0x15, 0xb8, 0x20, 0x1, 0x10, 0x8d, 0x8d.
• Assinatura 5: 0x14, 0xe9, 0x9d, 0x1, 0x0, 0x0, 0x68, 0x4.
• Assinatura 6: 0xe9, 0x9d, 0x1, 0x0, 0x0, 0x68, 0x4, 0x1.
• Assinatura 7: 0x9d, 0x1, 0x0, 0x0, 0x68, 0x4, 0x1, 0x0.
• Assinatura 8: 0x1, 0x0, 0x0, 0x68, 0x4, 0x1, 0x0, 0x0.
• Assinatura 9: 0x0, 0x0, 0x68, 0x4, 0x1, 0x0, 0x0, 0xff.
• Assinatura 10: 0x0, 0x68, 0x4, 0x1, 0x0, 0x0, 0xff, 0xb5.
• Assinatura 11: 0x68, 0x4, 0x1, 0x0, 0x0, 0xff, 0xb5, 0xb4.
• Assinatura 12: 0x4, 0x1, 0x0, 0x0, 0xff, 0xb5, 0xb4, 0xfd.
• Assinatura 13: 0x1, 0x0, 0x0, 0xff, 0xb5, 0xb4, 0xfd, 0xff.
• Assinatura 14: 0x0, 0x0, 0xff, 0xb5, 0xb4, 0xfd, 0xff, 0xff.
• Assinatura 15: 0x0, 0xff, 0xb5, 0xb4, 0xfd, 0xff, 0xff, 0x8d.
• Assinatura 16: 0x5, 0x68, 0xbe, 0x1, 0x10, 0x3, 0xf, 0x84.
• Assinatura 17: 0x68, 0xbe, 0x1, 0x10, 0x3, 0xf, 0x84, 0x19.
• Assinatura 18: 0xbe, 0x1, 0x10, 0x3, 0xf, 0x84, 0x19, 0x1.
As assinaturas para a representação proposta não obteve resultado muito melhor

que a representação
  tradicional.
  Algumas
 das matrizes
 de confusão obtidas foram as
2616 3 2613 6 2619 0 2619 0 2214 405
seguintes  , , , , .
811 4 811 4 814 1 814 1 804 11
os respectivos f1-score foram: 0,97%, 0,96%, 0,24%, 0,24% e 1,78%.
(B) Estudo de Caso 2: Amostra da família Rogue:Win32/Winwebsec
A amostra escolhida foi a amostra VirusShare_b4d34b147c2e23c7a8edbf7ef739e345 da
família Rogue:Win32/Winwebsec. A Figura 85 apresenta o mapa de calor e seções do
arquivo para (a) representação tradicional e (b) representação proposta. O cabeçalho não
está aparecendo nas seções porque ele ocupa um espaço pequeno. Por exemplo, no caso da
representação proposta, ele ocupa apenas os primeiros 1024 bytes da primeira linha.

Share_b4d34b147c2e23c7a8edbf7ef739e345 .
Para abordagem tradicional, foi possível identificar 24 regiões principais e selecionou-

se uma sequência de 8 bytes emtorno de seus máximos. Para todas as 18 assinaturas a
2879 0
matriz de confusão foi  , ou seja, um f1-score de 0,35%.
554 1
Para abordagem proposta, foram identificadas 42 regiões de picos e selecionou-se
uma sequência de 8 bytes em torno dos máximos. Assim como naabordagem  tradicional,
2879 0
para todas as 42 assinaturas, a matriz de confusão obtida foi  , ou seja, um
554 1
f1-score de 0,35%.
(C) Estudo de Caso 3: Amostra da família Backdoor:Win32/Cycbot
A amostra escolhida foi a amostra VirusShare_59a9d67646c65d307743c17726f46e08 da
família Backdoor:Win32/Cycbot.
A Figura 86 apresenta o mapa de calor e seções do arquivo para (a) representação
tradicional e (b) representação proposta. O cabeçalho não está aparecendo mas ele ocupa
os primeiros 1024 bytes de ambas as imagens.
Para a abordagem proposta, foram encontradas 19 picos e, com isso, foram criadas

Share_59a9d67646c65d307743c17726f46e08.
19 assinaturas de tamanho 8 bytes em torno do pico. Nenhuma das assinaturas apresentou

uma
 matrizde confusão interessante. Todas apresentaram uma matriz de confusão similar
2999 0
a , o que dá um f1-score de 0.45%.
434 1
Para a abordagem proposta, foram encontradas 48 picos e, com isso, foram criadas
48 assinaturas de tamanho 8 bytes em torno do pico. A grande parte das assinaturas
apresentaram f1-score abaixo de 1%, o que inviabiliza seu uso.
No entanto, 6 assinaturas
  apresentaram
  um resultado
 interessante e suas matri-

2999 0 2999 0 2999 0 2999 0 2999 0
zes de confusão são:  ,  ,  ,  ,  ,
371 64 353 82 295 140 287 148 256 79
 
2999 0 
 , obtendo um f1-score de 25,65%, 31,72%, 48,69%, 50,77%, 30,73%, 24,59% ,
374 61
respectivamente. Estes resultados começam a ser interessantes quando se busca um sistema
de geração de assinaturas automatizado.
(D) Estudo de Caso 4: Amostra da família Backdoor:Win32/Cycbot A
amostra escolhida foi a amostra VirusShare_76a3dfc670acd2c3c85c00e49fb4c028 da família
Backdoor:Win32/Cycbot.
Para a abordagem tradicional, foram encontrados 21 picos. Assim, 21 assinaturas
 de
2999 0
8 bytes foram geradas e avaliadas. Todas apresentaram uma matriz de confusão  ,
434 1
com um f1-score de 0,45%.
Para a abordagem proposta, foram encontrados 11 picos e, portanto, foram
 geradas

2999 0
11 assinaturas de tamanho de 8 bytes. Dois resultados foram interessantes  ,
383 52

Share_76a3dfc670acd2c3c85c00e49fb4c028.
 
2999 0 
 , que resultam em f1-score de 21.35% e 15.67%.
398 37
(E) Estudo de Caso 5: Amostra da família Rogue:Win32/Winwebsec
A amostra escolhida foi a amostra VirusShare_4dd9514a635c463ade0531d09577dcb3 da
família Rogue:Win32/Winwebsec.

Share_4dd9514a635c463ade0531d09577dcb3.

 de
2879 0
554 1
o que dá um f1-score de 0,35%.
Para a abordagem proposta, foram encontrados 24 picos e geradas, portanto, 24
assinaturas de tamanho 8 bytes. Nenhuma das assinaturas produzidas obteve resultado
satisfatório. O f1-score destas 24 assinaturas variou entre 0,35% e 1,07%.
10.3.1.1 Análise dos Resultados - Lenet 5 Normal
Dos resultados apresentados a seguinte análise pode ser realizada:
• No Estudo de Caso 1 e Estudo de Caso 2, tanto a abordagem tradicional como a

abordagem proposta produziram assinaturas inviáveis. Possivelmente, o fato de o
mapa de calor da Lenet-5 Normal ser um conjunto de diversas áreas desconectadas
esteja prejudicando a geração de assinaturas;
• No Estudo de caso 3, a abordagem tradicional não conseguiu produzir nenhuma

assinatura viável. No caso da abordagem proposta, 6 assinaturas de 48 se destacaram
com f1-score 25,65%, 31,72%, 48,69%, 50,77%, 30,73% e 24,59%. O estudo de caso 4
obteve resultado similar ao estudo de caso 3;
• No estudo de caso 5, nem a abordagem tradicional e nem a abordagem proposta

produziram assinaturas viáveis;
• Não foram apresentados aqui os Estudos de Caso 6 e 7 pois, nestes casos, o mapa de
calor gerado para a abordagem tradicional era nulo4
10.3.1.2 Conclusão Parcial Lenet-5
Da análise dos resultados apresentados, pode-se concluir o que se segue:
• A arquitetura Lenet-5 Normal parece não ser uma boa arquitetura para a geração
de assinaturas de forma automatizada. Talvez, o principal motivo seja por causa do
sobreajuste que está acontecendo na arquitetura, pois as regiões de mapa de calor
são bem desconectadas;
• A abordagem proposta produziu resultados similares ou melhores que a abordagem

tradicional;
• Nesta avaliação decidiu-se por utilizar uma entrada de dados fixa no 224 × 224. No
entanto, algumas simulações foram realizadas com intuito de verificar a capacidade de
gerar assinaturas viáveis. O modelo com entrada 32 × 32 para abordagem tradicional
e proposta (fixando valor da altura na representação para 32) foram muito superiores.
Decidiu-se por manter os resultados aqui apresentados porque o foco é avaliar a
abordagem tradicional de representação e a abordagem proposta para geração de
assinaturas (e não avaliar a melhor arquitetura de rede neural convolucional).
4
Em pesquisa realizada, o motivo de serem produzidos mapas de calor nulos é uma instabilidade
computacional gerada pelo algoritmo Grad-CAM da implementação do pacote eli5. O problema não
foi resolvido.
10.3.2 Resultados da Criação de Assinaturas - VGG16 non_top

Nesta seção serão apresentados os resultados do uso da sequência de bytes no desen-
volvimento de assinaturas para a arquitetura V GG16 non_top, comparando a abordagem
tradicional com a abordagem proposta.
(A) Estudo de Caso 1: Amostra da família BrowserModifier:Win32/Zwangi
A amostra escolhida foi a amostra VirusShare_de98a354787f0e06758c1a03be23eb63 da
família BrowserModifier:Win32/Zwangi.
Figura 89 – Mapa de Calor do modelo VGG16 non_top para Virus-

Share_de98a354787f0e06758c1a03be23eb63.

 de
3236 0
191 7
ou seja, um f1-score de 6,82%.
Para a abordagem proposta, foram encontrados 19 picos e geradas, portanto, 19
assinaturas de
 tamanho 8 bytes. 
Duas matrizes de confusão foram obtidas nestas 19
1 3235 3222 14
assinaturas:  , , com f1-score de 10,90% e 17,46% respectivamente.
0 198 178 20
Este resultado foi pouco melhor que a abordagem tradicional, mas ainda é um resultado
baixo para uma assinatura.
(B) Estudo de Caso 2: Amostra da família Backdoor:Win32/Bifrose A
amostra escolhida foi a amostra VirusShare_65e1811671961c79af8f2da4f33eb51c da família

Backdoor:Win32/Bifrose.

Share_65e1811671961c79af8f2da4f33eb51c.
Para a abordagem tradicional, foram produzidos 169 picos. Assim, 169 assinaturas
de
 8 bytes 
foram
 geradas eavaliadas. As duas melhores matrizes de confusão obtidas foram
3140 19 2095 1064
 , , que possuem um f1-score de 6,57% e 15,81% respectivamente.
265 10 160 115
Para a abordagem proposta, foram encontrados 120 picos e geradas, portanto,
120 assinaturas de tamanho8 bytes. As
 duas
 melhores
 matrizes de confusão foram obti-
3149 10 1506 1653
das nestas 120 assinaturas:  , , com f1-score de 7,43% e 19,05%
264 11 72 203
respectivamente. Novamente, um resultado pouco melhor que a abordagem tradicional.
(C) Estudo de Caso 3: Amostra da família BrowserModifier:Win32/Zwangi
Para a abordagem tradicional, foram produzidos 23 picos. Assim, 23 assinaturas

3322 2
de 8 bytes foram geradas. As melhores matrizes de confusão obtidas foram  ,
66 44

 
3141 183
 , que possuem um f1-score de 56,41% e 35,85% respectivamente.
46 64
Para a abordagem proposta, foram encontrados 68 picos e geradas 68 assinaturas
de
 tamanho8 bytes. As melhores
 matrizes de confusão foram obtidas nestas 68 assinaturas:
3216 108 3052 272
 , , com f1-score de 45,39% e 44,39% respectivamente.
46 641 1 109
(D) Estudo de Caso 4: Amostra da família BrowserModifier:Win32/Zwangi
A amostra escolhida foi a amostra VirusShare_e70017930479d88b1747e3df6e99be25 da

Share_e70017930479d88b1747e3df6e99be25.
Para a abordagem tradicional, foram produzidos 218 picos no mapa de calor.

Assim, 218 assinaturas de 8 bytes foram produzidas. As melhores matrizes de confusão
   
3298 26 3195 129
obtidas foram  , , que possuem um f1-score de 36,14% e 29,28%
80 30 69 41
respectivamente.
Para a abordagem proposta, foram encontrados 39 picos e, portanto, foram pro-
duzidas 39 assinaturas de tamanho
 8 bytes.
  As melhores
 matrizes de confusão foram
3317 7  3324 0 
obtidas nestas 39 assinaturas:  , , com f1-score de 55,55% e 44,39%
65 45 74 36
respectivamente.
10.3.2.1 Análise dos Resultados - VGG16 non_top
Dos resultados apresentados a seguinte análise pode ser realizada:
• No Estudo de Caso 1 a representação proposta gerou assinaturas melhores que a

representação tradicional, ainda que o f1-score obtido fosse relativamente baixo;
• No Estudo de Caso 2 a representação proposta se saiu ligeiramente melhor que a

representação tradicional, ainda que a representação tradicional tenha sugerido 169
assinaturas contra as 120 assinaturas da representação proposta;
• No Estudo de Caso 3, novamente, a representação tradicional as duas melhores

assinaturas produziram resultado de f1-score 56,41% e 35,85%, enquanto que as
duas melhores assinaturas da representação proposta obtiveram 45,39% e 44,39%.
Considerou-se que houve um equilíbrio entre a abordagem tradicional e proposta;
• No Estudo de Caso 4, a representação proposta se saiu melhor que a abordagem

tradicional, ainda que a representação tradicional sugerisse 218 assinaturas contra
39 da representação proposta;
• Não foram apresentados aqui os Estudos de Caso 5, 6 e 7 pois, nestes casos, o

mapa de calor gerado ou para a representação tradicional, ou para a representação
proposta, ou para ambas, possivelmente por uma instabilidade computacional do
algoritmo do pacote eli5 utilizado5 .
10.3.2.2 Conclusão Parcial - VGG16 non_top
Da análise dos resultados apresentados, pode-se concluir o que se segue:
• A arquitetura VGG16 non_top produziu assinaturas melhores que o modelo Lenet-5

Normal;
• A abordagem proposta produziu resultados melhores que a abordagem tradicional

em quase todos os casos;
5
A documentação do eli5 se encontra em https://eli5.readthedocs.io/en/latest/autodocs/keras.html.
• Uma avaliação na capacidade de gerar assinaturas foi realizada e foi observado que as
arquiteturas com a entrada 32 × 32 para abordagem tradicional e proposta (fixando
valor da altura na representação para 32) para o modelo VGG16 non_top foi superior,
obtendo inclusive f1-score de 78% em alguns casos analisados. Decidiu-se por manter
os resultados aqui apresentados, pois o foco é avaliar a representação tradicional e a
representação proposta para geração de assinaturas6 .
10.4 Conclusão Parcial

No geral, o tanto para a Lenet-5 Normal quanto para o VGG16 non_top, a repre-
sentação proposta foi superior a representação tradicional na tarefa de gerar assinaturas
de forma automatizada. O modelo VGG16 non_top se saiu bem melhor que o modelo
Lenet-5 Normal nesta tarefa. Desta forma, conclui-se que, a Nova Representação pro-
posta tem potencial para gerar assinaturas, por meio de algoritmos de explicabilidade,
superior à representação tradicional. Assim, a representação proposta atinge o Objetivo
S2, ao fornecer uma representação que melhor se adéqua a tarefa de geração automática
de assinaturas. Além disso, experimentos mostraram que a escolha de uma função de
redimensionamento pode influenciar positivamente nos valores do f1-score das assinaturas
geradas. Os resultados destes experimentos estão apresentados no Apêndice C.
Para o objetivo de gerar assinaturas, além da representação proposta, deve-se
avaliar outras arquiteturas e outros tamanhos de entrada do modelo, pois estes podem
produzir melhores resultados.
6
Neste caso, não houve transferência de aprendizado, pois originalmente a arquitetura VGG16 tem
como entrada uma imagem 224 × 224 × 3.
156
11 RESULTADOS DO ALGORITMO DE IMPORTÂNCIA POR

PIXEL
Este capítulo apresenta os resultados da aplicação do algoritmo de Importância de

Pixel e demonstra um uso para o analista de malware.
11.1 Obtenção da Região de Calor

Para obter os resultados de regiões de calor ou mapas de importância utilizando
o algoritmo proposto “Importância por Pixel”, foram realizadas 10 pertubações para
cada pixel de amostras de artefatos escolhidas ao acaso. A métrica de erro utilizada foi a
distância euclidiana entre o vetor de saída de predição (de tamanho 9) e o rótulo real (de
tamanho 9). A arquitetura do modelo treinado neste experimento é baseada na Lenet-5
Normal, tendo a imagem de entrada tamanho 32 × 32. A Figura 93 apresenta o resultado
do mapa de importância para 3 amostras da classe BrowserModifier:Win32/Zwangi.
Figura 93 – Regiões de calor geradas pelo Algoritmo de Importância por Pixel para 3
amostras.
Para gerar estes mapas de importância, um limiar de 1,2 foi criado e somente os
pixeis com importância acima de um limiar foram apresentados.
Capítulo 11. Resultados do Algoritmo de Importância por Pixel 157

Um aspecto interessante que podemos observar em todos os mapas de importância é
que, além de ser possível definir quais pontos serão submetidos para avaliação do algoritmo,
os pixeis não sofrem efeito da distorção por representação. Um analista pode, por exemplo,
utilizar-se deste algoritmo para analisar apenas algumas regiões de interesse, como por
exemplo a região de código ou cabeçalho, onde a semântica dos bytes podem ser melhores
interpretadas pelo analista.

O método desenvolvido possui duas vantagens principais: permitir que se defina a
região de interesse e o fato de não sofrer de distorção de representação. O uso do algoritmo
ainda requer algumas definições: definir a quantidade de pertubações (ruído) por pixel,
definir a região de interesse e definir a métrica do erro a ser utilizada.
11.2 Utilização do Algoritmo de Importância por Pixel

Uma forma de avaliar os resultados da explicabilidade é analisar alguma região onde
a semântica é mais conhecida. Neste caso, escolheu-se a região do cabeçalho do arquivo
PE das amostras. Assim, 20 amostras da família Trojan:Win32/Vundo que possuíam
cabeçalho de tamanho 1025 foram escolhidas ao acaso. Para cada amostra foi calculado a
Importância por Pixel (IPP) dos primeiros 1024 bytes. Destas 20 amostras, 8 obtiveram
um gráfico de IPP muito próximo. A Figura 94 apresenta os gráficos IPP para as amostras
40 e 6 da classe Trojan:Win32/Vundo. Para aplicação do algoritmo de importância de
pixel foram realizadas 10 pertubações por pixel.
Figura 94 – Importância por Pixel para os primeiros 1024 bytes das amostras 40 e 6.
Na Figura 94, o eixo X representa os bytes de 0 a 1023 e o eixo Y representa o

valor de IPP calculado para cada byte.
Deve-se lembrar que o quando mais longe do valor 1, maior a importância do
pixel. Assim, pode-se identificar 4 regiões com IPP abaixo de 0.5: [122, 123, 124, 126],
[375, 376, 377, 378, 379], [630, 631, 632, 633, 634, 636, 637] e [890, 891, 892, 893, 894, 895] (re-
giões estas presentes não somente nas amostras apresentadas no gráfico, mas nas em todas
as 8 amostras). As informações acima de 375 são referências a informações específicas de
cada seção do PE File. No entanto, as informações localizadas entre 122-126 os valores
de ExportDirectory VA e ExportDirectory Size. Estes valores refletem a localização as
bibliotecas de funções importadas pelo executável, ou seja, para estas 8 amostras, o local e
tamanho dos endereços (ponteiros) das funções importadas pelo executável é mais impor-
tante para classificá-lo como Vundo. Esta análise simples foi realizada apenas para mostrar
a importância de se utilizar os resultados de explicabilidade de algoritmos de aprendizado
profundo. O Algoritmo de Importância por Pixel foi a ferramenta utilizada para extrair
as informações - mas a interpretação e o grau de importância dos valores produzidos
ainda dependem da análise humana. Neste caso, os valores de ExportDirectory VA e
ExportDirectory Size poderiam ser utilizados para compor um Indicador de Compromisso
(IOC - Indicator of Compromise).

O algoritmo de importância de pixel permitiu que parte de um artefato fosse
selecionado para a aplicação do algoritmo de explicabilidade fazendo com que o mesmo
tivesse um melhor aproveitamento de processamento. O uso do algoritmo de importância
de pixel foi demonstrado pela sua aplicação nos primeiros 1024 bytes de 20 arquivos
executáveis da família Trojan:Win32/Vundo, produzindo alguns resultados interessantes.

O Algoritmo de Importância por Pixel, assim como qualquer outro algoritmo,
fornece explicações sobre o que o modelo de aprendizado profundo considerou relevante
para determinada classificação. Isso, de forma alguma, deve ser considerado uma verdade:
modelos diferentes, aplicados ao mesmo problema podem produzir resultados bem diferentes
de explicabilidade1 . No entanto, é interessante avaliar e analisar o que levou o algoritmo
de aprendizado profundo a produzir determinada saída.
A parte interessante do Algoritmo de Importância por Pixel é que foi possível, de
forma bastante simples, escolher a região de interesse. A quantidade de pertubações deve
ser definida pelo usuário do algoritmo.
1
Ver sobre multiplicidade de bons modelos na Seção 5.3.
Outra vantagem do algoritmo de importância de pixel é que ele pode ser aplicado a
qualquer arquitetura de aprendizado profundo que tenha como entrada uma representação
de artefato malicioso na forma de imagem. Possíveis redimensionamentos da imagem (para
um valor fixo, como no caso das redes neurais convolucionais), e distorções na imagem
não afetam o resultado do algoritmo.
160
12 CONCLUSÃO
A quantidade de malware e suas variantes vem crescendo nos últimos anos e soluções
automatizadas de detecção e classificação de malware por meio de aprendizado profundo
são interessantes, pois atendem a essas demandas. No entanto, as soluções de aprendizado
profundo ainda são, tipicamente, caixas pretas, ou seja, apenas nos fornecem os resultados
de sua detecção ou classificação. Assim, nesta tese foi definido um objetivo geral e 4
objetivos específicos que solucionavam ou mitigavam os efeitos das 3 Lacunas encontradas
nos diversos trabalhos. Em todas as propostas, ou na implementação ou na forma de
avaliação, foram utilizadas técnicas de explicabilidade.
O primeiro passo para realizar esta tese foi criar uma base de dados de artefatos
maliciosos, denominada VirusShareSant. Em seguida, criou-se e documentou-se um con-
junto de arquiteturas de redes neurais convolucionais, atendendo o Objetivo Especifico
S0, que realizassem a classificação das amostras em 9 famílias com acurácia adequada.
Para atender o Objetivo Específico S1, foi proposta um método que utiliza como
base os atributos aprendidos de uma rede neural convolucional, para propor candidatos a
verificação de rotulagem das amostras. O método é inovador, no sentido de ser único a usar
uma representação de explicabilidade de uma rede neural convolucional. Os resultados
obtidos são interessantes, mas por proporcionarem um valor baixo de f1-score considerou-se
o resultado final satisfatório e, portanto, resolveu parcialmente a Lacuna L1 encontrada.
De qualquer forma, o método proposto apresenta um caminho a ser aprofundado em
trabalhos futuros como possível abordagem para resolver a Lacuna L1.
O Objetivo Específico S2 foi atendido propondo uma Nova Representação de
artefatos maliciosos na forma de imagem. A forma proposta valoriza a correlação horizontal
existente na disposição dos bytes na imagem. Este método mitiga os efeitos da distorção
de representação apresentado como Lacuna L2. Para avaliar esta representação proposta,
indicou-se uma forma de gerar assinaturas de forma automatizada utilizando o algoritmo
de explicabilidade Grad-CAM e foi mostrado que os resultados da Nova Representação são
superiores aos da representação tradicional. Ou seja, a nova representação trouxe melhoras
na aplicação do algoritmo de explicabilidade para a geração de assinaturas.
O Objetivo Específico S3 foi atendido ao se propor um método para avaliação
de apenas parte de uma região de imagem, além do método proposto ter ainda a vantagem
de ser agnóstico ao modelo. A vantagem de se utilizar um algoritmo onde uma região pode
ser definida pelo analista foi mostrada produzindo resultados satisfatórios. Portanto, foi
possível realizar uma adaptação em um método existente, o método de importância de
atributos por permutação, de forma a resolver a Lacuna L3.
Capítulo 12. Conclusão 161
Quanto às contribuições obtidas tem-se: Uma base de dados de artefatos maliciosos

para desenvolvimento de trabalhos acadêmicos na área de aprendizado de máquina aplicado
a análise de malware (Contribuição I); Um conjunto de arquiteturas documentadas que
podem servir de ponto de partida para o desenvolvimento de trabalhos relacionados
à aplicação de aprendizado profundo em análise de malware utilizando redes neurais
convolucionais (Contribuição II); Um método para produzir candidatos a verificação
de rótulos por meio de arquiteturas de redes neurais convolucionais que pode servir de
protótipo para o desenvolvimento e aprofundamento nesta área (Contribuição III); Uma
Nova Representação de artefatos que permite melhorar os resultados de algoritmos de
explicabilidade para a geração de assinaturas de forma automatizada (Contribuição IV);
Um método de explicabilidade, adaptado a partir de um método existente, que permite
que uma região de interesse da imagem seja avaliada de forma a obter a importância de
cada pixel (Contribuição V).
Com a realização desta tese, diversos aspectos foram levantados que podem servir
para aprofundamento em trabalhos futuros. A partir de metodologia aplicada para de-
senvolver a base de dados VirusShareSant, é possível criar outras bases, com as mesmas
famílias da VirusShareSant, mas distribuídas ao longo do tempo. Isso permitiria que um
estudo fosse realizado para avaliar o efeitos do concept drifting (146) no desempenho
de soluções de aprendizado de máquina e propor soluções que mitiguem seus efeitos. Não
foram encontrados trabalhos que abordem este tipo de problema na área de análise de
malware devido, principalmente, a falta de base de dados para estudo acadêmico. Um
exemplo de como produzir uma base de dados para concept drifting, utilizando como ponto
de partida o método utilizado para gerar a base VirusShareSant, está apresentado no
Apêndice F.
Além disso, outro trabalho futuro a ser desenvolvido seria o de realizar um estudo
para tratar do problema de variação semântica apresentado na Seção 4.3.3. Uma possível
solução seria utilizar, uma rede convolucional para cada tipo1 de seção dos executáveis.
Ainda, é possível implementar redes especializadas para uma determinada seção, como
uma rede neural recorrente Long Short Term Memory (LSTM) (147) para realizar a
classificação da seção de códigos e um algoritmo de Random Forest (123) para a seção de
cabeçalhos.
Outro ponto interessante é que a verificar a correta rotulagem de artefatos é funda-
mental para o desenvolvimento de base de dados de artefatos maliciosos e, recentemente,
uma proposta baseada em um sistema especialista foi desenvolvida com resultados bas-
tante interessantes (145, 141). A grande vantagem desta proposta2 é que os artefatos
são classificados conforme suas capacidades e não por famílias utilizando o resultado
1
Cabeçalho, Código ou Dados, por exemplo.
2
A ser apresentada em dezembro de 2020.
Capítulo 12. Conclusão 162
produzido por diversas soluções de antivírus (como VirusTotal). A desvantagem deste

trabalho é que ele depende da implementação de regras por um especialista na área. Um
aprofundamento pode ser realizado de forma a propor uma solução mista, baseada no
conhecimento especialista e na Proposta P1 apresentada nesta tese.
Com relação a representação do artefato malicioso na forma de imagem, em Ren et
al.(34), o autor apresenta uma solução interessante para representar o artefato malicioso ao
representá-lo como uma sequência de bytes de altura 1 e redimensioná-lo para um tamanho
fixo também de altura 1. Em seguida, aplicar uma arquitetura convolucional similar a
apresentada em Raff et al.(28) para realizar a classificação. Não foi intenção do autor
resolver ou mitigar o problema de distorção de representação mas, de qualquer forma,
a forma apresentada é interessante para avaliação e poderia ser tratada em trabalhos
futuros.
163
REFERÊNCIAS
1 AVTEST. Total Malware. 2020. 24 março 2020. Disponível em: <https://www.av-test.

org/en/statistics/malware/>.
2 DENG, J.; DONG, W.; SOCHER, R.; LI, L.-J.; LI, K.; FEI-FEI, L. Imagenet: A large-
scale hierarchical image database. In: IEEE. Computer Vision and Pattern Recognition,
2009. CVPR 2009. IEEE Conference on. [S.l.], 2009. p. 248–255.
3 GOODFELLOW, I.; BENGIO, Y.; COURVILLE, A.; BENGIO, Y. Deep learning. [S.l.]:
MIT press Cambridge, 2016. v. 1.
4 CHOLLET, F. Deep learning with python. [S.l.]: Manning Publications Co., 2017.
5 NG, W.; MINASNY, B.; MONTAZEROLGHAEM, M.; PADARIAN, J.; FERGUSON,

R.; BAILEY, S.; MCBRATNEY, A. B. Convolutional neural network for simultaneous
prediction of several soil properties using visible/near-infrared, mid-infrared, and their
combined spectra. Geoderma, Elsevier, v. 352, p. 251–267, 2019.
6 LECUN, Y.; BOTTOU, L.; BENGIO, Y.; HAFFNER, P. Gradient-based learning

applied to document recognition. Proceedings of the IEEE, IEEE, v. 86, n. 11, p. 2278–
2324, 1998.
7 COOK, A. Global Average Pooling Layers for Object Localization. 2020.

11 nov. de 2020. Disponível em: <https://alexisbcook.github.io/2017/
global-average-pooling-layers-for-object-localization/>.
8 HAN, W.; XUE, J.; WANG, Y.; LIU, Z.; KONG, Z. Malinsight: A systematic profiling
based malware detection framework. Journal of Network and Computer Applications,
Elsevier, v. 125, p. 236–250, 2019.
9 WIKIPEDIA. PEFile. 2020. 01 março 2020. Disponível em: <https://en.wikipedia.org/

wiki/Portable\_Executable.>
10 ZHOU, B.; KHOSLA, A.; LAPEDRIZA, A.; OLIVA, A.; TORRALBA, A. Learning
deep features for discriminative localization. In: Proceedings of the IEEE conference on
computer vision and pattern recognition. [S.l.: s.n.], 2016. p. 2921–2929.
11 SELVARAJU, R. R.; COGSWELL, M.; DAS, A.; VEDANTAM, R.; PARIKH, D.;
BATRA, D. Grad-cam: Visual explanations from deep networks via gradient-based loca-
lization. In: Proceedings of the IEEE international conference on computer vision. [S.l.:
s.n.], 2017. p. 618–626.
12 HE, K.; ZHANG, X.; REN, S.; SUN, J. Deep residual learning for image recognition.
In: Proceedings of the IEEE conference on computer vision and pattern recognition. [S.l.:
s.n.], 2016. p. 770–778.
13 NATARAJ, L.; KARTHIKEYAN, S.; JACOB, G.; MANJUNATH, B. Malware ima-

ges: visualization and automatic classification. In: Proceedings of the 8th international
symposium on visualization for cyber security. [S.l.: s.n.], 2011. p. 1–7.
Referências 164
14 KASPERSKY. 2020 State of Malware Report. 2020. 03 de março de 2020. Disponível

em: <https://resources.malwarebytes.com/files/2020/02/2020_State-of-Malware-Report.
pdf>.
15 KASPERSKY. Kaspersky Security Bulletin. Overall statistics for 2017. 2017. 28 de

março de 2018. Disponível em: <https://securelist.com/ksb-overall-statistics-2017/83453/
>.
16 KASPERSKY. Kaspersky Security Bulletin: REVIEW OF THE YEAR 2017. 2017. 04

de abril de 2018. Disponível em: <https://media.kasperskycontenthub.com/wp-content/
uploads/sites/43/2018/03/07164738/KSB_Review-of-2017_final_EN-1.pdf>.
17 SINGH, J.; SINGH, J. Challenges of malware analysis : Obfuscation techniques. In: .

[S.l.: s.n.], 2018.
18 AVTEST, T. Heightened threat scenario: all the facts in the AV-TEST Security Report
2018/2019. 2019. 4 de novembro 2019. Disponível em: <https://www.av-test.org/en/news/
heightened-threat-scenario-all-the-facts-in-the-av-test-security-report-2018-2019/>.
19 MCMILLAN, R. Definition: Threat Intelligence. 2013. 16 de maior de 2019. Disponível

em: <https://www.gartner.com/en/documents/2487216>.
20 TUREK, D. M. Explainable Artificial Intelligence (XAI). 2019. 20 de agosto de 2019.

Disponível em: <http://www.darpa.mil/program/explainable-artificial-intelligence>.
21 ADADI, A.; BERRADA, M. Peeking inside the black-box: A survey on explainable

artificial intelligence (xai). IEEE Access, IEEE, v. 6, p. 52138–52160, 2018.
22 KRIZHEVSKY, A.; SUTSKEVER, I.; HINTON, G. E. Imagenet classification with

deep convolutional neural networks. In: Advances in neural information processing systems.
[S.l.: s.n.], 2012. p. 1097–1105.
23 YUAN, Z.; LU, Y.; WANG, Z.; XUE, Y. Droid-sec: deep learning in android malware
detection. In: Proceedings of the 2014 ACM conference on SIGCOMM. [S.l.: s.n.], 2014. p.
371–372.
24 PASCANU, R.; STOKES, J. W.; SANOSSIAN, H.; MARINESCU, M.; THOMAS,

A. Malware classification with recurrent networks. In: IEEE. 2015 IEEE International
Conference on Acoustics, Speech and Signal Processing (ICASSP). [S.l.], 2015. p. 1916–1920.
25 YUAN, Z.; LU, Y.; XUE, Y. Droiddetector: android malware characterization and
detection using deep learning. Tsinghua Science and Technology, TUP, v. 21, n. 1, p.
114–123, 2016.
26 CHOI, S.; JANG, S.; KIM, Y.; KIM, J. Malware detection using malware image and
deep learning. In: IEEE. 2017 International Conference on Information and Communication
Technology Convergence (ICTC). [S.l.], 2017. p. 1193–1195.
27 NIX, R.; ZHANG, J. Classification of android apps and malware using deep neural
networks. In: IEEE. 2017 International joint conference on neural networks (IJCNN).
[S.l.], 2017. p. 1871–1878.
Referências 165
28 RAFF, E.; BARKER, J.; SYLVESTER, J.; BRANDON, R.; CATANZARO, B.;
NICHOLAS, C. K. Malware detection by eating a whole exe. In: Workshops at the
Thirty-Second AAAI Conference on Artificial Intelligence. [S.l.: s.n.], 2018.
29 KALASH, M.; ROCHAN, M.; MOHAMMED, N.; BRUCE, N. D.; WANG, Y.; IQBAL,
F. Malware classification with deep convolutional neural networks. In: IEEE. 2018 9th
IFIP International Conference on New Technologies, Mobility and Security (NTMS). [S.l.],
2018. p. 1–5.
30 KRČÁL, M.; ŠVEC, O.; BÁLEK, M.; JAŠEK, O. Deep convolutional malware classi-
fiers can learn from raw executables and labels only. 2018.
31 CAKIR, B.; DOGDU, E. Malware classification using deep learning methods. In:
Proceedings of the ACMSE 2018 Conference. [S.l.: s.n.], 2018. p. 1–5.
32 JUNG, B.; KIM, T.; IM, E. G. Malware classification using byte sequence information.
In: Proceedings of the 2018 Conference on Research in Adaptive and Convergent Systems.
[S.l.: s.n.], 2018. p. 143–148.
33 AKARSH, S.; POORNACHANDRAN, P.; MENON, V. K.; SOMAN, K. A detailed

investigation and analysis of deep learning architectures and visualization techniques for
malware family identification. In: Cybersecurity and Secure Information Systems. [S.l.]:
Springer, 2019. p. 241–286.
34 REN, Z.; WU, H.; NING, Q.; HUSSAIN, I.; CHEN, B. End-to-end malware detection
for android iot devices using deep learning. Ad Hoc Networks, Elsevier, v. 101, p. 102098,
2020.
35 KOLOSNJAJI, B.; ZARRAS, A.; WEBSTER, G.; ECKERT, C. Deep learning for clas-
sification of malware system call sequences. In: SPRINGER. Australasian Joint Conference
on Artificial Intelligence. [S.l.], 2016. p. 137–149.
36 SU, X.; ZHANG, D.; LI, W.; ZHAO, K. A deep learning approach to android malware
feature learning and detection. In: IEEE. 2016 IEEE Trustcom/BigDataSE/ISPA. [S.l.],
2016. p. 244–251.
37 KABANGA, E. K.; KIM, C. H. Malware images classification using convolutional

neural network. Journal of Computer and Communications, Scientific Research Publishing,
v. 6, n. 1, p. 153–158, 2017.
38 VINAYAKUMAR, R.; SOMAN, K.; POORNACHANDRAN, P. Deep android malware

detection and classification. In: IEEE. 2017 International conference on advances in
computing, communications and informatics (ICACCI). [S.l.], 2017. p. 1677–1683.
39 MARTINELLI, F.; MARULLI, F.; MERCALDO, F. Evaluating convolutional neural

network for effective mobile malware detection. Procedia Computer Science, Elsevier,
v. 112, p. 2372–2381, 2017.
40 KIM, H.-J. Image-based malware classification using convolutional neural network.

In: Advances in Computer Science and Ubiquitous Computing. [S.l.]: Springer, 2017. p.
1352–1357.
Referências 166
41 MANIATH, S.; ASHOK, A.; POORNACHANDRAN, P.; SUJADEVI, V.; SANKAR,

A. P.; JAN, S. Deep learning lstm based ransomware detection. In: IEEE. 2017 Recent
Developments in Control, Automation & Power Engineering (RDCAPE). [S.l.], 2017. p.
442–446.
42 NI, S.; QIAN, Q.; ZHANG, R. Malware identification using visualization images and
deep learning. Computers & Security, Elsevier, v. 77, p. 871–885, 2018.
43 SUN, G.; QIAN, Q. Deep learning and visualization for identifying malware families.
IEEE Transactions on Dependable and Secure Computing, IEEE, 2018.
44 HADDADPAJOUH, H.; DEHGHANTANHA, A.; KHAYAMI, R.; CHOO, K.-K. R.

A deep recurrent neural network based approach for internet of things malware threat
hunting. Future Generation Computer Systems, Elsevier, v. 85, p. 88–96, 2018.
45 SEWAK, M.; SAHAY, S. K.; RATHORE, H. An investigation of a deep learning

based malware detection system. In: Proceedings of the 13th International Conference on
Availability, Reliability and Security. [S.l.: s.n.], 2018. p. 1–5.
46 CUI, Z.; XUE, F.; CAI, X.; CAO, Y.; WANG, G.-g.; CHEN, J. Detection of malicious
code variants based on deep learning. IEEE Transactions on Industrial Informatics, IEEE,
v. 14, n. 7, p. 3187–3196, 2018.
47 MASABO, E.; KAAWAASE, K. S.; SANSA-OTIM, J. Big data: deep learning for
detecting malware. In: IEEE. 2018 IEEE/ACM Symposium on Software Engineering in
Africa (SEiA). [S.l.], 2018. p. 20–26.
48 CHEN, L.; SULTANA, S.; SAHITA, R. Henet: A deep learning approach on intel®
processor trace for effective exploit detection. In: IEEE. 2018 IEEE Security and Privacy
Workshops (SPW). [S.l.], 2018. p. 109–115.
49 YAN, J.; QI, Y.; RAO, Q. Detecting malware with an ensemble method based on deep
neural network. Security and Communication Networks, Hindawi, v. 2018, 2018.
50 HE, K.; KIM, D.-S. Malware detection with malware images using deep learning
techniques. In: IEEE. 2019 18th IEEE International Conference On Trust, Security And
Privacy In Computing And Communications/13th IEEE International Conference On Big
Data Science And Engineering (TrustCom/BigDataSE). [S.l.], 2019. p. 95–102.
51 PEI, X.; YU, L.; TIAN, S. Amalnet: A deep learning framework based on graph
convolutional networks for malware detection. Computers & Security, Elsevier, p. 101792,
2020.
52 NAEEM, H.; ULLAH, F.; NAEEM, M. R.; KHALID, S.; VASAN, D.; JABBAR, S.;
SAEED, S. Malware detection in industrial internet of things based on hybrid image
visualization and deep learning model. Ad Hoc Networks, Elsevier, p. 102154, 2020.
53 NIU, W.; CAO, R.; ZHANG, X.; DING, K.; ZHANG, K.; LI, T. Opcode-level function
call graph based android malware classification using deep learning. Sensors, Multidiscipli-
nary Digital Publishing Institute, v. 20, n. 13, p. 3645, 2020.
Referências 167
54 YAKURA, H.; SHINOZAKI, S.; NISHIMURA, R.; OYAMA, Y.; SAKUMA, J. Malware
analysis of imaged binary samples by convolutional neural network with attention me-
chanism. In: ACM. Proceedings of the Eighth ACM Conference on Data and Application
Security and Privacy. [S.l.], 2018. p. 127–134.
55 SKOUDIS, E.; ZELTSER, L. Malware: Fighting malicious code. [S.l.]: Prentice Hall
Professional, 2004.
56 SIKORSKI, M.; HONIG, A. Practical malware analysis: the hands-on guide to dissec-
ting malicious software. [S.l.]: no starch press, 2012.
57 MOIR, R. Defining Malware: FAQ. 2009. 27 de novembro de 2019. Disponí-

vel em: <https://docs.microsoft.com/en-us/previous-versions/tn-archive/dd632948(v=
technet.10)?redirectedfrom=MSDN>.
58 YOU, I.; YIM, K. Malware obfuscation techniques: A brief survey. In: IEEE. 2010
International conference on broadband, wireless computing, communication and applications.
[S.l.], 2010. p. 297–300.
59 LYDA, R.; HAMROCK, J. Using entropy analysis to find encrypted and packed
malware. IEEE Security & Privacy, IEEE, v. 5, n. 2, p. 40–45, 2007.
60 SAMI, A.; YADEGARI, B.; RAHIMI, H.; PEIRAVIAN, N.; HASHEMI, S.; HAMZE,
A. Malware detection based on mining api calls. In: ACM. Proceedings of the 2010 ACM
symposium on applied computing. [S.l.], 2010. p. 1020–1025.
61 RUSSINOVICH, M. Sysinternals suite. Microsoft TechNet, 2009.
62 ZELTSER, L. Remnux: A linux toolkit for reverse-engineering and analyzing malware.

2018.
63 RASCHKA, S. Python machine learning. [S.l.]: Packt Publishing Ltd, 2015.
64 GÉRON, A. Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow:

Concepts, Tools, and Techniques to Build Intelligent Systems. [S.l.]: O’Reilly Media, 2019.
65 ALPAYDIN, E. Introduction to machine learning. [S.l.]: MIT press, 2014.
66 MITCHELL, T. M. et al. Machine learning. 1997. Burr Ridge, IL: McGraw Hill, v. 45,
n. 37, p. 870–877, 1997.
67 SAMUEL, A. L. Some studies in machine learning using the game of checkers. IBM
Journal of research and development, IBM, v. 3, n. 3, p. 210–229, 1959.
68 COVER, T.; HART, P. Nearest neighbor pattern classification. IEEE transactions on

information theory, IEEE, v. 13, n. 1, p. 21–27, 1967.
69 MYERS, R. H.; MYERS, R. H. Classical and modern regression with applications.

[S.l.]: Duxbury press Belmont, CA, 1990. v. 2.
70 MENARD, S. W. Applied logistic regression analysis. [S.l.: s.n.], 1995.
71 SUYKENS, J. A.; VANDEWALLE, J. Least squares support vector machine classifiers.

Neural processing letters, Springer, v. 9, n. 3, p. 293–300, 1999.
Referências 168
72 SAFAVIAN, S. R.; LANDGREBE, D. A survey of decision tree classifier methodology.

IEEE transactions on systems, man, and cybernetics, IEEE, v. 21, n. 3, p. 660–674, 1991.
73 HAYKIN, S.; NETWORK, N. A comprehensive foundation. Neural networks, v. 2,

n. 2004, p. 41, 2004.
74 HARTIGAN, J. A.; WONG, M. A. Algorithm as 136: A k-means clustering algorithm.

Journal of the Royal Statistical Society. Series C (Applied Statistics), JSTOR, v. 28, n. 1,
p. 100–108, 1979.
75 WILKS, D. S. Cluster analysis. In: International geophysics. [S.l.]: Elsevier, 2011.

v. 100, p. 603–616.
76 MOON, T. K. The expectation-maximization algorithm. IEEE Signal processing

magazine, IEEE, v. 13, n. 6, p. 47–60, 1996.
77 WOLD, S.; ESBENSEN, K.; GELADI, P. Principal component analysis. Chemometrics

and intelligent laboratory systems, Elsevier, v. 2, n. 1-3, p. 37–52, 1987.
78 MIKA, S.; SCHÖLKOPF, B.; SMOLA, A. J.; MÜLLER, K.-R.; SCHOLZ, M.;
RÄTSCH, G. Kernel pca and de-noising in feature spaces. In: Advances in neural infor-
mation processing systems. [S.l.: s.n.], 1999. p. 536–542.
79 ROWEIS, S. T.; SAUL, L. K. Nonlinear dimensionality reduction by locally linear

embedding. science, American Association for the Advancement of Science, v. 290, n. 5500,
p. 2323–2326, 2000.
80 JAIN, A. K. Data clustering: 50 years beyond k-means. Pattern recognition letters,

Elsevier, v. 31, n. 8, p. 651–666, 2010.
81 WATKINS, C. J.; DAYAN, P. Q-learning. Machine learning, Springer, v. 8, n. 3-4, p.

279–292, 1992.
82 GRON, A. Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts,

Tools, and Techniques to Build Intelligent Systems. 1st. ed. [S.l.]: O’Reilly Media, Inc.,
2017. ISBN 1491962291, 9781491962299.
83 LECUN, Y.; BENGIO, Y.; HINTON, G. Deep learning. nature, Nature Publishing
Group, v. 521, n. 7553, p. 436, 2015.
84 ZEILER, M. D.; FERGUS, R. Visualizing and understanding convolutional networks.

In: SPRINGER. European conference on computer vision. [S.l.], 2014. p. 818–833.
85 SZEGEDY, C.; LIU, W.; JIA, Y.; SERMANET, P.; REED, S.; ANGUELOV, D.;
ERHAN, D.; VANHOUCKE, V.; RABINOVICH, A. Going deeper with convolutions. In:
Proceedings of the IEEE conference on computer vision and pattern recognition. [S.l.: s.n.],
2015. p. 1–9.
86 PERKEL, D. H. Logical neurons: the enigmatic legacy of warren mcculloch. Trends

in Neurosciences, Elsevier Current Trends, v. 11, n. 1, p. 9–12, 1988.
87 RUMELHART, D. E.; HINTON, G. E.; WILLIAMS, R. J. et al. Learning representa-

tions by back-propagating errors. Cognitive modeling, v. 5, n. 3, p. 1, 1988.
Referências 169
88 AGARAP, A. F. Deep learning using rectified linear units (relu). arXiv preprint
arXiv:1803.08375, 2018.
89 SRIVASTAVA, N.; HINTON, G.; KRIZHEVSKY, A.; SUTSKEVER, I.; SALAKHUT-
DINOV, R. Dropout: a simple way to prevent neural networks from overfitting. The journal
of machine learning research, JMLR. org, v. 15, n. 1, p. 1929–1958, 2014.
90 WAGER, S.; WANG, S.; LIANG, P. S. Dropout training as adaptive regularization.
In: Advances in neural information processing systems. [S.l.: s.n.], 2013. p. 351–359.
91 HINTON, G. E.; SRIVASTAVA, N.; KRIZHEVSKY, A.; SUTSKEVER, I.; SA-
LAKHUTDINOV, R. R. Improving neural networks by preventing co-adaptation of feature
detectors. arXiv preprint arXiv:1207.0580, 2012.
92 BALDI, P.; SADOWSKI, P. J. Understanding dropout. In: Advances in neural infor-
mation processing systems. [S.l.: s.n.], 2013. p. 2814–2822.
93 IOFFE, S.; SZEGEDY, C. Batch normalization: Accelerating deep network training
by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
94 LIN, M.; CHEN, Q.; YAN, S. Network in network. arXiv preprint arXiv:1312.4400,
2013.
95 OLIVAS, E. S. Handbook of Research on Machine Learning Applications and Trends:
Algorithms, Methods, and Techniques: Algorithms, Methods, and Techniques. [S.l.]: IGI
Global, 2009.
96 ANDERSON, H. S.; ROTH, P. Ember: an open dataset for training static pe malware
machine learning models. arXiv preprint arXiv:1804.04637, 2018.
97 ZHANG, J.; QIN, Z.; YIN, H.; OU, L.; HU, Y. Irmd: malware variant detection using
opcode image recognition. In: IEEE. 2016 IEEE 22nd International Conference on Parallel
and Distributed Systems (ICPADS). [S.l.], 2016. p. 1175–1180.
98 ELKHAWAS, A. I.; ABDELBAKI, N. Malware detection using opcode trigram se-
quence with svm. In: IEEE. 2018 26th International Conference on Software, Telecommu-
nications and Computer Networks (SoftCOM). [S.l.], 2018. p. 1–6.
99 SHALAGINOV, A.; BANIN, S.; DEHGHANTANHA, A.; FRANKE, K. Machine
learning aided static malware analysis: A survey and tutorial. In: Cyber Threat Intelligence.
[S.l.]: Springer, 2018. p. 7–45.
100 GUIDE, P. Intel® 64 and ia-32 architectures software developer’s manual. Volume
3B: System programming Guide, Part, v. 2, p. 5, 2011.
101 HARRIS, S.; HARRIS, D. Digital design and computer architecture: arm edition.
[S.l.]: Morgan Kaufmann, 2015.
102 YUE, S. Imbalanced malware images classification: a cnn based approach. arXiv
preprint arXiv:1708.08042, 2017.
103 REZENDE, E.; RUPPERT, G.; CARVALHO, T.; RAMOS, F.; GEUS, P. D. Malicious
software classification using transfer learning of resnet-50 deep neural network. In: IEEE.
2017 16th IEEE International Conference on Machine Learning and Applications (ICMLA).
[S.l.], 2017. p. 1011–1014.
Referências 170
104 YAJAMANAM, S.; SELVIN, V. R. S.; TROIA, F. D.; STAMP, M. Deep learning
versus gist descriptors for image-based malware classification. In: ICISSP. [S.l.: s.n.], 2018.
p. 553–561.
105 KEBEDE, T. M.; DJANEYE-BOUNDJOU, O.; NARAYANAN, B. N.; RALESCU,

A.; KAPP, D. Classification of malware programs using autoencoders based deep learning
architecture and its application to the microsoft malware classification challenge (big 2015)
dataset. In: IEEE. 2017 IEEE National Aerospace and Electronics Conference (NAECON).
[S.l.], 2017. p. 70–75.
106 LE, Q.; BOYDELL, O.; NAMEE, B. M.; SCANLON, M. Deep learning at the shallow
end: Malware classification for non-domain experts. Digital Investigation, Elsevier, v. 26,
p. S118–S126, 2018.
107 MENG, X.; SHAN, Z.; LIU, F.; ZHAO, B.; HAN, J.; WANG, H.; WANG, J. Mcsmgs:
malware classification model based on deep learning. In: IEEE. 2017 International Confe-
rence on Cyber-Enabled Distributed Computing and Knowledge Discovery (CyberC). [S.l.],
2017. p. 272–275.
108 HUANG, T. H.-D.; KAO, H.-Y. R2-d2: color-inspired convolutional neural network
(cnn)-based android malware detections. In: IEEE. 2018 IEEE International Conference
on Big Data (Big Data). [S.l.], 2018. p. 2633–2642.
109 SU, J.; VASCONCELLOS, V. D.; PRASAD, S.; DANIELE, S.; FENG, Y.; SAKURAI,
K. Lightweight classification of iot malware based on image recognition. In: IEEE. 2018
IEEE 42nd Annual Computer Software and Applications Conference (COMPSAC). [S.l.],
2018. v. 2, p. 664–669.
110 KUMAR, R.; XIAOSONG, Z.; KHAN, R. U.; AHAD, I.; KUMAR, J. Malicious
code detection based on image processing using deep learning. In: Proceedings of the 2018
International Conference on Computing and Artificial Intelligence. [S.l.: s.n.], 2018. p.
81–85.
111 DOSHI-VELEZ, F.; KIM, B. Towards a rigorous science of interpretable machine

learning. arXiv preprint arXiv:1702.08608, 2017.
112 GUNNING, D. Explainable Artificial Intelligence (XAI), DARPA. 2017.
113 BAROCAS, S.; FRIEDLER, S.; HARDT, M.; KROLL, J.; VENKA-
TASUBRAMANIAN, S.; WALLACH, H. The FAT-ML Workshop Series on Fairness,
Accountability, and Transparency in Machine Learning. [S.l.]: Accessed: Jun, 2018.
114 CARVALHO, D. V.; PEREIRA, E. M.; CARDOSO, J. S. Machine learning interpreta-

bility: A survey on methods and metrics. Electronics, Multidisciplinary Digital Publishing
Institute, v. 8, n. 8, p. 832, 2019.
115 RUDIN, C. Stop explaining black box machine learning models for high stakes
decisions and use interpretable models instead. Nature Machine Intelligence, Nature
Publishing Group, v. 1, n. 5, p. 206–215, 2019.
116 SIMONYAN, K.; ZISSERMAN, A. Very deep convolutional networks for large-scale
image recognition. arXiv preprint arXiv:1409.1556, 2014.
Referências 171
117 DENG, J.; DONG, W.; SOCHER, R.; LI, L.-J.; LI, K.; FEI-FEI, L. Imagenet: A
large-scale hierarchical image database. In: IEEE. 2009 IEEE conference on computer
vision and pattern recognition. [S.l.], 2009. p. 248–255.
118 RIBEIRO, M. T.; SINGH, S.; GUESTRIN, C. " why should i trust you?" explaining
the predictions of any classifier. In: Proceedings of the 22nd ACM SIGKDD international
conference on knowledge discovery and data mining. [S.l.: s.n.], 2016. p. 1135–1144.
119 MOLNAR, C. Interpretable machine learning. [S.l.]: Lulu. com, 2019.
120 GUO, M.; ZHANG, Q.; LIAO, X.; CHEN, Y. An interpretable machine learning
framework for modelling human decision behavior. arXiv preprint arXiv:1906.01233, 2019.
121 MOROCHO-CAYAMCELA, M. E.; LEE, H.; LIM, W. Machine learning for 5g/b5g
mobile and wireless communications: Potential, limitations, and future directions. IEEE
Access, IEEE, v. 7, p. 137184–137206, 2019.
122 HALL, P.; GILL, N. An Introduction to Machine Learning Interpretability-Dataiku

Version. [S.l.]: O’Reilly Media, Incorporated, 2018.
123 BREIMAN, L. Random forests. Machine learning, Springer, v. 45, n. 1, p. 5–32, 2001.
124 FISHER, A.; RUDIN, C.; DOMINICI, F. All models are wrong, but many are
useful: Learning a variable’s importance by studying an entire class of prediction models
simultaneously. Journal of Machine Learning Research, v. 20, n. 177, p. 1–81, 2019.
125 VARGAS, R.; LOURDES, R. Deep learning: previous and present applications.
Journal of Awareness, Rating Academy, v. 3, n. Special, p. 11, 2017.
126 KAGGLE. Microsoft Malware Winners’ Interview: 1st place, "NO to overfit-
ting!". 2015. 29 setembro de 2019. Disponível em: <http://blog.kaggle.com/2015/05/
26/microsoft-malware-winners-interview-1st-place-no-to-overfitting/>.
127 CHARIKAR, M. S. Similarity estimation techniques from rounding algorithms. In:

Proceedings of the thiry-fourth annual ACM symposium on Theory of computing. [S.l.: s.n.],
2002. p. 380–388.
128 CUI, Z.; DU, L.; WANG, P.; CAI, X.; ZHANG, W. Malicious code detection based
on cnns and multi-objective algorithm. Journal of Parallel and Distributed Computing,
Elsevier, v. 129, p. 50–58, 2019.
129 ZHAO, Y.; XU, C.; BO, B.; FENG, Y. Maldeep: A deep learning classification
framework against malware variants based on texture visualization. Security and Commu-
nication Networks, Hindawi, v. 2019, 2019.
130 GIBERT, D.; MATEU, C.; PLANES, J.; VICENS, R. Using convolutional neural
networks for classification of malware represented as images. Journal of Computer Virology
and Hacking Techniques, Springer, v. 15, n. 1, p. 15–28, 2019.
131 KADRI, M. A.; NASSAR, M.; SAFA, H. Transfer learning for malware multi-
classification. In: Proceedings of the 23rd International Database Applications & Engineering
Symposium. [S.l.: s.n.], 2019. p. 1–7.
Referências 172
132 DAHL, G. E.; STOKES, J. W.; DENG, L.; YU, D. Large-scale malware classifica-
tion using random projections and neural networks. In: IEEE. 2013 IEEE International
Conference on Acoustics, Speech and Signal Processing. [S.l.], 2013. p. 3422–3426.
133 RIECK, K.; HOLZ, T.; WILLEMS, C.; DÜSSEL, P.; LASKOV, P. Learning and
classification of malware behavior. In: SPRINGER. International Conference on Detection
of Intrusions and Malware, and Vulnerability Assessment. [S.l.], 2008. p. 108–125.
134 RIECK, K.; TRINIUS, P.; WILLEMS, C.; HOLZ, T. Automatic analysis of malware
behavior using machine learning. Journal of Computer Security, IOS Press, v. 19, n. 4, p.
639–668, 2011.
135 BAILEY, M.; OBERHEIDE, J.; ANDERSEN, J.; MAO, Z. M.; JAHANIAN, F.;
NAZARIO, J. Automated classification and analysis of internet malware. In: SPRINGER.
International Workshop on Recent Advances in Intrusion Detection. [S.l.], 2007. p. 178–197.
136 BAYER, U.; COMPARETTI, P. M.; HLAUSCHEK, C.; KRUEGEL, C.; KIRDA, E.
Scalable, behavior-based malware clustering. In: CITESEER. NDSS. [S.l.], 2009. v. 9, p.
8–11.
137 PERDISCI, R.; U, M. Vamo: towards a fully automated malware clustering validity
analysis. In: Proceedings of the 28th Annual Computer Security Applications Conference.
[S.l.: s.n.], 2012. p. 329–338.
138 RAFIQUE, M. Z.; CABALLERO, J. Firma: Malware clustering and network signature
generation with mixed network behaviors. In: SPRINGER. International Workshop on
Recent Advances in Intrusion Detection. [S.l.], 2013. p. 144–163.
139 VASWANI, A.; SHAZEER, N.; PARMAR, N.; USZKOREIT, J.; JONES, L.; GOMEZ,
A. N.; KAISER, Ł.; POLOSUKHIN, I. Attention is all you need. In: Advances in neural
information processing systems. [S.l.: s.n.], 2017. p. 5998–6008.
140 SIMONYAN, K.; ZISSERMAN, A. Very deep convolutional networks for large-scale
image recognition. CoRR, abs/1409.1556, 2014. Disponível em: <http://arxiv.org/abs/
1409.1556>.
141 SEBASTIÁN, M.; RIVERA, R.; KOTZIAS, P.; CABALLERO, J. Avclass: A tool
for massive malware labeling. In: SPRINGER. International Symposium on Research in
Attacks, Intrusions, and Defenses. [S.l.], 2016. p. 230–253.
142 ALBAWI, S.; MOHAMMED, T. A.; AL-ZAWI, S. Understanding of a convolutional
neural network. In: IEEE. 2017 International Conference on Engineering and Technology
(ICET). [S.l.], 2017. p. 1–6.
143 NAMATĒVS, I. Deep convolutional neural networks: Structure, feature extraction
and training. Information Technology and Management Science, Sciendo, v. 20, n. 1, p.
40–47, 2017.
144 KELLER, J. M.; GRAY, M. R.; GIVENS, J. A. A fuzzy k-nearest neighbor algorithm.
IEEE transactions on systems, man, and cybernetics, IEEE, n. 4, p. 580–585, 1985.
145 SEBASTIÁN, S.; CABALLERO, J. Avclass2: Massive malware tag extraction from
av labels. In: SPRINGER. Proceedings of the 36th Annual Computer Security Applications
Conference. [S.l.], 2020. p. –.
Referências 173
146 TSYMBAL, A. The problem of concept drift: definitions and related work. Computer
Science Department, Trinity College Dublin, Citeseer, v. 106, n. 2, p. 58, 2004.
147 HOCHREITER, S.; SCHMIDHUBER, J. Long short-term memory. Neural computa-

tion, MIT Press, v. 9, n. 8, p. 1735–1780, 1997.
148 RONEN, R.; RADU, M.; FEUERSTEIN, C.; YOM-TOV, E.; AHMADI, M. Microsoft
malware classification challenge. arXiv preprint arXiv:1802.10135, 2018.
149 CHIO, C.; FREEMAN, D. Machine Learning and Security: Protecting Systems with
Data and Algorithms. [S.l.]: " O’Reilly Media, Inc.", 2018.
150 KIRILLOV, I.; BECK, D.; CHASE, P.; MARTIN, R. Malware attribute enumeration
and characterization. The MITRE Corporation [online, accessed Nov. 6 , 2020], 2011.
151 DULAUNOY, A.; IKLODY, A.; MOKADDEM, S.; ROMMELFANGEN, S.; SERVILI,
D.; STUDER, C.; VINOT, R. MISP Standard, The collaborative intelligence standard
powering intelligence and information exchange, sharing and modeling. 2020. 6 nov. de
2020. Disponível em: <https://www.misp-standard.org/>.
152 KRIZHEVSKY, A.; HINTON, G. Convolutional deep belief networks on cifar-10.

Unpublished manuscript, v. 40, n. 7, p. 1–9, 2010.
153 STROBL, C.; BOULESTEIX, A.-L.; KNEIB, T.; AUGUSTIN, T.; ZEILEIS, A.
Conditional variable importance for random forests. BMC bioinformatics, Springer, v. 9,
n. 1, p. 307, 2008.
154 ALTMANN, A.; TOLOŞI, L.; SANDER, O.; LENGAUER, T. Permutation impor-
tance: a corrected feature importance measure. Bioinformatics, Oxford University Press,
v. 26, n. 10, p. 1340–1347, 2010.
155 HARDY, M. A.; BRYMAN, A. Handbook of data analysis. [S.l.]: Sage, 2009.
174
APÊNDICE A – BASE DE DADOS VIRUSSHARESANT
Este apêndice tem como objetivo apresentar o detalhamento técnico da base

VirusShareSant. Inicialmente, na Seção A.1 são apresentados os critérios de seleção para
base de dados considerando as bases publicamente disponíveis e , em seguida, é descrito
o processo de criação de uma nova base de dados denominada VirusShareSantque está
apresentada na Seção A.2. A Figura 95 apresenta um resumo do processo de definição da
Base de Dados utilizada nesta tese.
Figura 95 – Visão Geral ddo processo de criação da Base VirusShareSant.
A.1 Bases Publicamente Disponíveis

Para a seleção de uma base de dados de artefatos maliciosos deve-se considerar
diversos fatores: o objetivo de análise do artefato, a plataforma de execução dos
APÊNDICE A. Base de Dados VirusShareSant 175
artefatos maliciosos, a quantidade de amostras, se o binário do artefato está

disponível e a presença dos rótulos. A Tabela 17 apresenta um quadro resumido
considerando as principais bases de dados disponibilizadas publicamente1 .
Tabela 17 – Conjunto de Dados de Artefatos Maliciosos Publicamente Disponíveis.
Ano Referência Objetivo Plataforma Qtd Binário Rótulo

2011 Nataraj et al.(13) Classificação; 25 Famílias Microsoft Windows ő 9.342 Não Sim
2015 Ronen et al.(148) Classificação; 9 Famílias Microsoft Windows ő 21.741 Parcial Parcial
2018 Anderson e Detecção de Malware Microsoft Windows ő 1.1 mi Não Parcial
Roth(96)
2018 Huang e Kao(108) Classificação: 8 famílias Android 2 mi Não Sim
+ benigno. Detecção de
Malware
Em Nataraj et al.(13), o autor disponibilizou uma imagem redimensionada em

escala de cinza dos bytes do artefato. Todas as amostras desta base estão rotuladas. Em
Ronen et al.(148) o binário do artefato malicioso está apenas parcialmente disponível,
pois o cabeçalho do executável fora removido. Assim, apenas 10.868 amostras das 21.741
possuem rótulo. Em Anderson e Roth(96) apenas um conjunto de atributos extraídos dos
artefatos por meio de funções de processamento pré-definidas estão disponibilizados, ou seja,
o binário não foi disponibilizado. Tem-se um total de 900 mil amostras (300 mil maliciosas,
300 mil benignas e 300 mil sem rótulo) no conjunto de treinamento e 200 mil amostras
rotuladas (100 mil maliciosas e 100 mil benignas) no conjunto de testes. Finalmente,
em Huang e Kao(108), o autor disponibilizou o artefato na forma de representação de
imagem RGB do bytecode para Dalvik de cada aplicativo (apk), totalizando uma base com
mais de 2 milhões de amostras malignas e benignas rotuladas. Os rótulos também estão
disponibilizados para classificação em 8 famílias dos tipos Adware, SMS-Clicker, RiskTool
e Trojan.
Os critérios de seleção e suas respectivas justificativas para desenvolver esta tese
foram os seguintes:
1. O objetivo de análise do artefato: considerando a pouca quantidade de bases de

dados publicamente disponíveis, o objetivo da análise foi definido após a escolha da
base. No entanto, deve-se ressaltar que nenhum método ou algoritmo utilizado nesta
tese foi adaptado para um determinado objetivo em específico, ou seja, os métodos
aqui desenvolvidos poderão ser aproveitados em outros objetivos;
2. A plataforma de execução dos artefatos maliciosos: De acordo com AV-

Test(18), 51,08% dos artefatos maliciosos, detectados em 2018, são para plataforma
Microsoft Windows ő . Ainda, no primeiro trimestre de 2019, esse valor foi atualizado
para 74,49% dos artefatos maliciosos. Finalmente, para a plataforma Microsoft Win-
dows ő , 62,51% são Trojans, 21,05% são vírus clássicos e 6,62% são Worms, ou seja,
1
Tabela atualizada em dezembro de 2019.
em sua grande maioria, os artefatos maliciosos são binários executáveis ou código

injetado em binários executáveis (1). Desta forma, deu-se preferência para base de
dados de arquivos executáveis para a plataforma Microsoft Windows ő ;
3. A quantidade de amostras: considerando que o trabalho será desenvolvido utili-

zando algoritmos de aprendizado profundos, uma maior quantidade de amostras é, a
princípio, mais adequada(3)2 .
4. Disponibilidade do binário do artefato: a disponibilidade do artefato malicioso

foi considerada importante pois não limita a escolha da representação do binário para
o algoritmo de aprendizado profundo. Por exemplo, se o artefato estiver acessível
somente na forma de imagem redimensionada, não será possível, em princípio, extrair
os mnemônicos e operandos da seção de código do artefato;
5. Disponibilidade dos rótulos: É fundamental que a base de dados escolhida possua

rótulos, pois o trabalho de rotular bases de dados extensas pode demandar uma
quantidade de tempo não compatível com o tempo disponível para o desenvolvimento
desta tese.
Assim, considerando a Tabela 17, a base apresentada em Ronen et al.(148), deno-

minada Microsoft Malware Classification Challenge (BIG 2015), é a que melhor atende aos
critérios supracitados. Ainda, apesar de não disponibilizar o binário original dos artefatos,
pois estão disponibilizados os hexadecimais do binário sem o cabeçalho e o código assembly
da seção executável na forma de um arquivo texto.
A base Microsoft Malware Classification Challenge (BIG 2015) é composta de
arquivos de malware categorizados em nove famílias. Cada amostra deste conjunto de
dados é composta por dois arquivos: um arquivo binário sem cabeçalho que contém uma
representação hexadecimal do malware executável (extensão .byte) e um arquivo composto
pelo código desmontado do malware (entensão .asm)3 . O conjunto de dados contém um
conjunto rotulado para treinamento e um conjunto não rotulado para teste. O conjunto de
treinamento possui um total 10.868 amostras distribuídas em famílias conforme tabela 18.
Esse total de amostras rotuladas foi considerado, inicialmente, adequado para desenvolver
arquiteturas de aprendizado profundo para classificação em famílias.
A grande vantagem da base Microsoft Malware Classification Challenge (BIG 2015)
é que, por ser pública, permite a comparação de resultados obtidos com outros trabalhos.
No entanto, com o desenvolvimento da tese, ela não se mostrou mais adequada pelos
seguintes motivos:
2
Outros aspectos devem ser considerados, como a representatividade do conjunto de dados.
3
Desmontado utilizando a ferramenta proprietária IDA.
Tabela 18 – Distribuição das amostras do conjunto de treinamento da base de dados

Microsoft Malware Classification Challenge (BIG 2015).
Classe Família # Total

1 Ramnit 1541
2 Lollipop 2478
3 Kelihos_ver3 2942
4 Vundo 475
5 Simda 42
6 Tracur 751
7 Kelihos_ver1 398
8 Obfuscator.ACY 1228
9 Gatak 1013
• Impossibilidade de avaliar o impacto das informações do cabeçalho na classificação:

como estas informações foram removidas, não é possível avaliar o quanto elas são
importantes para um processo de classificação;
• Ausência do executável (PEFile) do artefato malicioso: algumas técnicas de extração

de informações de seções específicas do arquivo não puderam ser implementadas. Por
exemplo, sem o cabeçalho, não era possível saber o início e fim das diversas seções
do PEFILE;
• Impossibilidade de automatizar o processo de desmontagem: como o objetivo é

deixar o processo de classificação de malware em família automatizado. É preciso
que utilizar desmontadores públicos via API de programação. Além disso, é preciso
verificar a efetividade destes desmontadores em um ambiente de produção;
• Ausência dos rótulos para o subconjunto de testes: a ausência de rótulos faz com que,
na prática, sejam utilizadas apenas as 10.868 amostras do conjunto de treinamento.
Assim, decidiu-se por procurar uma alternativa para a base de dados Microsoft
Malware Classification Challenge (BIG 2015) que atendesse aos critérios apresentados.
A.2 Base de Dados VirusShareSant

Com o desenvolvimento de uma base de dados de artefatos maliciosos é preciso
de uma fonte de dados com uma grande quantidade de malware. Assim, realizou-se uma
pesquisa de fontes ou sítios que disponibilizassem artefatos maliciosos de forma pública ou
por meio de solicitação. Foram encontradas as seguintes fontes:
• Malwshare(http://www.malshare.com.) é uma base de dados de artefatos maliciosos

com mais de 3 milhões de amostras. Os principais aspectos que limitam a utilização
desta fonte é que ela não possui rótulos (apenas resultados do Yara) e somente é
possível acessar um total de 1.000 amostras por dia;
• VX Heavens Virus Dataset(http://vxheaven.org/): fonte de dados bastante popular

no meio acadêmico e que contém aproximadamente 270.000 amostras de artefatos
maliciosos rotulados em 40 famílias para plataforma Microsoft Windows ő . De acordo
com Chio e Freeman(149), as amostras não foram atualizadas nos últimos 12 anos.
Em 2012, o sítio foi fechado pela polícia ucraniana;
• VirusShare(http://virushare.com): é uma fonte de dados de malware com mais de 34

milhões de amostras de diversas plataformas. Os arquivos podem ser baixados via
torrent e estão organizados por pacotes numerados. Os pacotes de 0 a 148 possuem
131.072 amostras cada e os pacotes de 149 em diante possuem 65.536 amostras cada.
As amostras não são rotuladas.
Aparentemente, nenhum dos sítios acima apresentados atendem aos critérios de-
finidos, pois eles não fornecem rótulos dos artefatos. No entanto, por iniciativa de John
Seymour e do MLSec Project4 , iniciou-se a criação de rótulos para os artefatos do Vi-
rusShare utilizando uma API de comunicação com o VirusTotal(149). O VirusTotal é
um serviço online que realiza uma varredura nos artefatos submetidos utilizando diversas
soluções de antivírus. A comunicação com o VirusTotal pode ser realizada via Web ou
API e a resposta a uma solicitação via API é na forma de um arquivo json. A Figura 96
apresenta uma visão geral do processo de obtenção de amostras de vírus a partir de um
pacote do VirusShare e sua respectiva submissão para o Virus Total, conforme descrito no
sítio da MLSec.
Figura 96 – Visão Geral da submissão de um artefato para o VirusTotal.
Assim, o trabalho realizado pelo pessoal do MLSec Project foi o de automatizar o

processo de: (1) baixar os pacotes de artefatos maliciosos do sítio VirusShare, (2) submeter
cada artefato do pacote ao VirusTotal e (3) obter a resposta dos antivírus no formato json
e armazená-la. Dessa forma, utilizando a fonte de dados do VirusShare e os resultados
do trabalho de John Seymour e do MLSec Project, foi possível construir uma base de
4
http://www.mlsec.org/
dados denominada VirusShareSant que atendesse aos critérios definidos para esta tese.
No momento do desenvolvimento da base VirusShareSant, as amostras dos pacotes de
00000 a 00233 do VirusShare já foram submetidas para varredura pelo VirusTotal.
Decidida a fonte de artefatos maliciosos e a resposta json de cada amostra, pode-se
definir o processo para obtenção de uma base de malware. A Figura 97 apresenta uma
visão geral do processo de definição da base de dados utilizada nesta tese. Inicialmente,
foram selecionadas famílias de artefatos maliciosos candidatas da fonte de artefatos
maliciosos(pacotes do VirusShare) e um critério de aceitação foi aplicado a cada amostra.
Em seguida, para cada amostra de cada família selecionada, foi validada a compatibilidade
com o padrão PE FILE. Amostras não compatíveis foram descartadas. Finalmente, as
amostras das 9 famílias com maior quantidade de artefatos foram escolhidas.
Figura 97 – Visão Geral do processo de definição da Base VirusShareSant
A.2.1 Seleção Inicial das Famílias e Critério de Aceitação

Para a escolha de amostras de famílias de artefatos maliciosos, foram selecionados
sete pacotes do VirusShare: VirusShare_00015 (2012-10-20), VirusShare_00021 (2012-11-
20), VirusShare_00023 (2012-11-30), VirusShare_00024 (2012-12-06), VirusShare_00026
(2012-12-22), VirusShare_00047 (2013-03-25) e VirusShare_00094 (2013-09-08). Todos os
pacotes possuem 131.072 amostras de malware cada.
A partir de então, foi criado um conjunto de critérios de aceitação para seleção de
amostras e rotulamento:
• O artefato foi detectado pelo antivírus da Microsoft;
• O artefato foi detectado por, pelo menos, outros 10 antivírus;
• Pelo menos outras duas soluções de antivírus utilizam nomenclatura similar à

nomenclatura de família utilizada pelo antivírus da Microsoft Windows ő .
Os três critérios devem ser atendidos para que a amostra seja selecionada. Estes
critérios de aceitação foram criados com o objetivo realizar uma normalização de dos nomes
das famílias considerando a diversidade de nomenclatura entre as soluções de antivírus. Na
Tabela 19 tem-se o nome a amostra V irusShare_a1d06041214f 7df 6ddb61010153470dd,
para diversas soluções de antivírus obtidas a partir dos resultados do Virustotal de 27 de
abril de 2011.
Tabela 19 – Resultado Parcial do VirusTotal para o Artefato
V irusShare_a1d06041214f 7df 6ddb61010153470dd
Antivírus Nomenclatura
Microsoft Backdoor:Win32/Bifrose.AE
VIPRE Trojan.Win32.Agent.Betq
BitDefender Backdoor.Bifrose.ZXE
McAfee MultiDropper-SP
Symantec Backdoor.Bifrose
Panda Bck/Bifrost.gen
AVG Dropper.Generic3.BICI
TrendMicro-HouseCall null
Pode-se observar que, muito provavelmente, o artefato pertence a família Bifrose,

mas se considerarmos a resposta do antivírus VIPRE, ele pertence à família Betq e, ainda,
de acordo com o McAfee ele é um Dropper. É claro que soluções de antivírus diferentes
não possuem nome de famílias iguais.
Para a aplicação dos critérios, selecionou-se ao acaso 17 (dezessete) famílias de
artefatos dos tipos Trojan, Backdoor, Exploit, Worm e VirTool. Todas as amostras destas
famílias foram submetidas aos critérios de aceitação. A Tabela 20 apresenta a lista destas
17 famílias utilizando a nomenclatura de nomes do antivírus da Microsoft Windows ő .
Tabela 20 – 17 Famílias selecionadas de artefatos maliciosos.
Classe Família
1 Backdoor:Win32/Bifrose
2 Trojan:Win32/Vundo
3 Exploit:Win32/CplLnk.A
4 VirTool:Win32/Obfuscator
5 Worm:Win32/Citeary
6 Backdoor:Win32/Cycbot
7 BrowserModifier:Win32/Zwangi
8 Rogue:Win32/Winwebsec
9 Trojan:Win32/Koutodoor
10 PWS:Win32/OnLineGames
11 Backdoor:Win32/Ripin
12 Backdoor:Win32/Rbot
13 Backdoor:Win32/Hupigon
14 TrojanDownloader:Win32/Troxen
15 Worm:Win32/Hybris
16 TBrowserModifier:Win32/Istbar
17 Trojan:Win32/Startpage
A Tabela 21 apresenta a quantidade de amostras de malware de cada família encon-

trada em cada pacote do VirusShare que atenderam os critérios de aceitação, totalizando
48.013 amostras de malware.
Tabela 21 – Quantidade de Amostras de Malware por família por pacote do VirusShare.
Id Família 00015 00021 00023 00024 00026 00047 00094

1 Backdoor:Win32/Bifrose 264 255 294 276 270 528 430
2 Trojan:Win32/Vundo 262 1387 1034 577 983 1817 760
3 Exploit:Win32/CplLnk.A 108 215 182 107 164 0 8
4 VirTool:Win32/Obfuscator 117 286 272 147 220 255 217
5 Worm:Win32/Citeary 9 13 4 9 5 28 30
6 Backdoor:Win32/Cycbot 620 540 475 577 555 479 425
7 BrowserModifier:Win32/Zwangi 203 146 122 142 156 96 74
8 Rogue:Win32/Winwebsec 413 652 500 395 529 1401 738
9 Trojan:Win32/Koutodoor 931 1110 833 846 1248 378 259
10 TrojanDownloader:Win32/Troxen 58 12 16 36 23 13 12
11 PWS:Win32/OnLineGames 299 4283 2206 947 1888 2154 1461
12 Backdoor:Win32/Ripini 44 4 11 26 14 24 22
13 Backdoor:Win32/Rbot 256 118 182 265 157 121 75
14 Backdoor:Win32/Hupigon 198 170 181 185 199 666 406
15 Worm:Win32/Hybris 1421 103 0 654 371 0 0
16 BrowserModifier:Win32/Istbar 352 17 1 175 98 0 1
17 Trojan:Win32/Startpage 144 117 132 122 112 506 579
Total 5699 9428 6445 5486 6992 8466 5497
A.2.2 Validação de compatibilidade

Para finalizar, fora utilizada a biblioteca pefile do Python para verificar se os
artefatos eram executáveis compatíveis com o padrão PE FILE da Microsoft Windows ő .
A seguir, é apresentado um trecho do código que utilizado para verificar se o artefato é
executável válido. Basicamente, o código em Python tenta abrir o arquivo do tipo PE
FILE imprimindo uma mensagem de erro caso não seja possível.
try:
pe = pefile.PE(filename)
print("{:s}\t {:d}".format(name,checkSections(pe)))
except pefile.PEFormatError as e:
print("{:s}\t ERROR {:s}".format(name,e.value))
Assim, aplicando o código de validação de compatibilidade, das 48.013 das 17 famí-

lias, foram encontrados 4.320 artefatos incompatíveis. Alguns motivos foram descobertos
que explicam esta grande quantidade de arquivos incompatíveis com o formato PE File.
Um primeiro motivo para essa grande quantidade de incompatibilidades é que as
soluções de antivírus utilizam, comumente, assinatura para detectar um artefato como
malicioso (ou mesmo classificá-lo em uma família) e não verificam se o mesmo é um
executável válido. Para comprovar essa hipótese, selecionaram-se 20 das 4.320 amostras
que foram implantadas em ambiente controlado (Sandbox) e executadas. O resultado
foi que nenhuma das 20 amostras foram executadas com sucesso no sistema operacional
Microsoft Windows ő , ou seja, pode-se inferir que muitas destas 4.320 amostras, estão, de
alguma forma, corrompidas e não podem ser executadas. Assim, estas 4.320 amostras
foram descartadas, restando um total de 43.693 amostras de artefatos maliciosos.
Um segundo motivo é que os artefatos da família Exploit:Win32/CplLnk.A são

arquivos de atalho especialmente criados para explorar a vulnerabilidade de aplicativos
que exibem ícones de atalho: quando o aplicativo que exibe ícones de atalho tenta exibir a
pré-visualização do malware, o mesmo é executado. Portanto, nenhum artefato da família
Exploit:Win32/CplLnk.A é um executável válido (PE FILE válido). De forma similar,
todos artefatos da família Worm:Win32/Hybris são arquivos do tipo .scr (screensaver) e,
por não serem executáveis, também foram descartados.
Como resultado da exclusão dos 4.320 arquivos - arquivos corrompidos e artefatos
das famílias Exploit:Win32/CplLnk e Worm:Win32/Hybris - obteve-se uma base com 15
famílias. A Tabela 22 mostra a distribuição da quantidade de artefatos maliciosos em cada
uma destas famílias.
Tabela 22 – Distribuição das quantidades de amostras de malware em cada uma das

famílias

3 VirTool:Win32/Obfuscator 1443
4 Worm:Win32/Citeary 94
9 TrojanDownloader:Win32/Troxen 161
10 PWS:Win32/OnLineGames 13227
11 Backdoor:Win32/Ripini 145
14 BrowserModifier:Win32/Istbar 6
A.2.3 Definição das Famílias para a Base VirusShareSant

Para esta tese, evitou-se o uso de famílias de artefatos maliciosos que possuíssem pou-
cas amostras como é o caso das famílias BrowserModifier:Win32/Istbar e Worm:Win32/Citeary
da Tabela 22 e, desta forma, selecionou-se as 9 famílias que continham a maior quantidade
de amostras.
Na Tabela 23 tem-se a distribuição das amostras entre as 9 famílias com maior
quantidade de amostras. Essa base foi denominada VirusShareSant. Os arquivos binários e
um arquivo csv com o nome de cada binário e seu respectivo rótulo serão disponibilizados
publicamente.
Tabela 23 – Distribuição das quantidades de amostras de malware em cada uma das

famílias na base VirusShareSant
.
A.3 Discussão
Como diferentes antivírus caracterizam malware com diferentes abordagens, os
rótulos dos artefatos são inconsistentes entre as diversas soluções(135). A solução aqui
apresentada para realizar a rotulagem da base de dados VirusShareSantresume-se a aplicar
critérios de aceitação mínimos(Seção A.2.1) que, ao menos, consideram mais de uma solução
de antivírus. O resultado são rótulos considerados adequados para o desenvolvimento desta
tese.
No entanto, uma abordagem recente, denominadas AVClass(141) e AvClass2 (145),
propõem que um sistema especialista realize a tarefa de rotulagem de base de dados de
artefatos maliciosos de forma automática, utilizando o conhecimento pré-programado de um
especialista na área. A primeira versão, AvClass, obteve uma acurácia de agrupamento entre
93,9% e 62,3% dependendo do conjunto de dados utilizado e ela foi capaz de rotular 81%
das amostras de conjuntos de dados baseados na saída json quando o artefato é submetido
ao Virus Total. A segunda versão, AvClass2, caracteriza os artefatos maliciosos por meio
do uso de marcações (tags) baseado em padrões como Malware Attribute Enumeration and
Characterization (MAEC)(150) e Malware Information Sharing Platform (MISP)(151). O
resultado é uma ferramenta especialista capaz de rotular 98% de uma base de dados.
184
APÊNDICE B – ARQUITETURAS DE CNN UTILIZADAS
Neste apêndice estão apresentadas as principais arquiteturas de redes neurais

convolucionais utilizadas nesta tese. As Tabelas 4 apresenta um quadro resumo dos
trabalhos analisados que aplicam redes neurais convolucionais à análise de artefatos
maliciosos. Na grande maioria destes trabalhos, no entanto, não são apresentados os
valores de hiperparâmetros das arquiteturas de redes neurais convolucionais utilizadas.
Assim, desenvolveram-se, de forma independente, diversas arquiteturas.
Em todos as arquiteturas aqui apresentadas, para estimar o tempo médio por
época, realizou-se um treinamento com um conjunto de treinamento com 19.459 amostras
das 9 famílias de artefatos maliciosos da base de dados VirusShareSante cada artefato
foi representado na forma de imagem de acordo com a Tabela 2 proposta por (13). Para
avaliar o tempo médio por época, utilizou-se uma placa GPU Nvidia 1080 TI com 11Gb
de RAM.
B.1 Arquiteturas Convolucionais baseadas na Lenet-5

Em (6), os autores concluíram que as redes neurais convolucionais, superam outros
modelos para o reconhecimento de caracteres manuscritos e propuseram uma arquitetura
denominada Lenet(6). Apesar da tarefa de reconhecer caracteres manuscritos ser bas-
tante simples, quando comparadas com as tarefas atuais de aplicação de redes neurais
convolucionais, a Lenet foi utilizada como arquitetura de base para o desenvolvimento de
arquiteturas para classificação de artefatos maliciosos em famílias. A Figura 98 apresenta
os hiperparâmetros da arquitetura Lenet original.
Figura 98 – Arquitetura original da Lenet, de acordo com (6)

.
A partir desta arquitetura, foram definidas 3 arquiteturas que estão apresentadas

na Figura 99. Em (a), tem-se a arquitetura normal com 32 filtros na primeira camada
convolucional, 64 filtros na segunda camada convolucional e, finalmente, com 3 camadas
completamente conectadas na etapa de classificação com 512, 256 e 9 neurônios respectiva-
mente. Em (b), tem-se a arquitetura small com 32 filtros na primeira camada convolucional,
64 filtros na segunda camada convolucional, finalmente, com 2 camadas completamente
APÊNDICE B. Arquiteturas de CNN utilizadas 185
conectadas na etapa de classificação com 256 e 9 neurônios, respectivamente. Em (c),

tem-se a arquitetura tiny, com 16 filtros na primeira camada convolucional, 32 filtros na
segunda camada convolucional, finalmente, com 2 camadas completamente conectadas na
etapa de classificação com 256 e 9 neurônios, respectivamente.
Figura 99 – Hiperparâmetros das 3 arquiteturas convolucionais, baseadas na Lenet-5,

utilizadas nesta tese: (a) normal, (b) small e (c) tiny.
Além dos valores de hiperparâmetros da arquitetura de rede convolucional, é

preciso definir o tamanho da imagem de entrada. Em trabalhos que utilizam redes neurais
convolucionais(152, 140, 12) para classificação de imagens, valores comuns da imagem de
entrada é de 32 × 32 e 224 × 224 e, portanto, foram selecionados. Além destes valores
selecionou-se os valores de 64 × 64 e 128 × 128. Assim, estes 4 valores de tamanho de
imagem foram utilizados em cada uma das 3 arquiteturas definidas. Com isso, foi possível
calcular a quantidade de parâmetros de cada arquitetura e estimar o tempo médio de
treinamento por época. A Tabela 24 apresenta os resultados obtidos.
Pode-se observar que uma quantidade maior de parâmetros acarretou um menor
tempo por época no treinamento. Como o redimensionamento do artefato representado de
acordo com a Tabela 2 proposta por (13) acontece durante o treinamento, um redimensio-
namento para valores 32×32 é mais demorado quando comparado a um redimensionamento
para 224 × 224, o que pode justificar o menor tempo obtido quando a entrada é uma
imagem de tamanho 224 × 224.
B.2 Arquiteturas Convolucionais baseadas em Transferência de Apren-

dizado
Arquiteturas convolucionais existentes foram aproveitadas utilizando técnicas de
transferência de aprendizado conforme apresentado na Seção 3.4.6. As arquiteturas con-
Tabela 24 – Quantidade de parâmetros e tempo médio de treinamento por época de cada

arquitetura.
Arquitetura Tamanho da Quantidade de Tempo Médio
Imagem de Entrada Parâmetros por Época
Normal 32 × 32 2.250.121 617.20
Normal 64 × 64 8.541.577 333.38
Normal 128 × 128 33.707.401 242.13
Normal 224 × 224 102.913.417 222.17
Small 32 × 32 1.069.961 617.77
.
Small 64 × 64 4.215.689 333.86
Small 128 × 128 16.798.601 212.80
Small 224 × 224 51.401.609 208.17
Tiny 32 × 32 531.657 617.95
Tiny 64 × 64 2.104.521 367.69
Tiny 128 × 128 8.395.977 214.45
Tiny 224 × 224 25.697.481 192.29
volucionais existentes selecionadas para avaliação foram: V GG16(140), V GG19(116) e

ResNet(12). Estas arquiteturas foram escolhidas porque obtiveram resultados interessantes
no Imagenet(2) e porque são suportadas pelas placas GPUs disponibilizadas (GPU Nvidia
1080 TI com 11Gb de RAM e GPU Nvidia 1060 com 6GB de RAM).
Figura 100 – Visão Geral da VGG16. Fonte: https://www.kaggle.com/shivamb/cnn-

architectures-vgg-resnet-inception-tl/notebook
A Figura 100 apresenta uma visão geral da V GG16. Ela possui uma etapa de extra-
ção de atributos composta por 5 blocos seguido por uma etapa de classificação composta
por 3 camadas de redes completamente conectadas. A Figura 101 apresenta esta arquitetura
com mais informações sobre os hiperparâmetros. Em todas etapas convolucionais, os filtros
têm tamanho 3 × 3, strides igual a 1 e padding igual a same, ou seja, um valor de padding
de forma que o tamanho da largura e altura de saída seja igual ao da entrada. As camadas
de pooling realizam a operação de Max Pooling com filtros de tamanho 2 × 2 e strides

igual a 2. Ainda, na Figura, tem-se destacado a quantidade de filtros em cada camada
convolucional. Além disso, a um conjunto de camadas convolucionais e de Pooling da etapa
convolucional é chamada de blocos. As camadas de redes completamente conectadas (FC)
possuem, respectivamente, 4096, 4096 e 1000 neurônios.
Figura 101 – Visão Detalhada da V GG16 com valores de hiperparâmetros.
De forma similar ao descrito para a V GG16, a Figura 102 apresenta os hiperparâ-

metros da V GG19. A diferença entre a V GG16 e a V GG19 está na quantidade de etapas
convolucionais do bloco 4 e 5.
Figura 102 – Visão Detalhada da V GG19 com valores de hiperparâmetros.
Finalmente, a ResNet(12) é uma arquitetura baseada em blocos residuais. Em

arquiteturas normais, cada camada alimenta a camada seguinte. Em blocos residuais, uma
camada alimenta a camada seguinte e também camadas 2 ou 3 passos a frente. A Figura
103 apresenta um exemplo de uma etapa residual(12).
A saída da etapa residual é dada por H(x) = F (x) + x, ou seja, as camadas de
pesos irão, de fato, aprender o mapeamento residual F (x) = H(x) − x. Assim, mesmo que
aconteça um desaparecimento do gradiente (vanishing gradient) para as camadas de peso,
a entrada x (que é saída das camadas anteriores) sempre será propagada.
A Figura 104 apresenta um exemplo de uma arquitetura Resnet com 34 camadas
conforme apresentado em He et al.(12). A arquitetura Resnet utilizada nesta tese é baseada
em uma Resnet que possui 50 camadas.
Figura 103 – Exemplo de um bloco residual.
Figura 104 – Renet com 34 camadas conforme He et al.(12).
Assim, as arquiteturas V GG16, V GG19 e Resnet50 foram utilizadas nas 3 formas

de Transferência de aprendizado (por Inicialização, Parcial de Atributos e por Atributos)
e seu desempenho para a tarefa de classificação de artefatos maliciosos foi avaliado.
B.2.1 Transferência por Inicialização

Utilizando a técnica de transferência por inicialização, diversas modificações foram
testadas nas 3 arquiteturas e apenas a arquitetura Resnet obteve resultado interessante.
Uma característica desta arquitetura é que a etapa de classificação da Resnet50 possui
apenas uma única camada com 1000 neurônios. Para esta arquitetura, foram definidas
duas variações:
1. Resnet big: Foi mantida a arquitetura da etapa de extração de atributos (camada

convolucional) da Resnet50 e adicionou-se 6 camadas completamente conectadas
com 1024, 512, 256, 128, 64 e 9 neurônios respectivamente. Os pesos da extração
de atributos foram inicializados com os valores da Resnet50 original utilizada em
Imagenet(117).
2. Resnet tiny: Foi mantida arquitetura da etapa de extração de atributos (camada

convolucional) da Resnet50 e adicionou-se 1 camada completamente conectada com
9 neurônios. Os pesos da extração de atributos foram inicializados com os valores da
Resnet50 original utilizada no Imagenet(117).
A Tabela 25 apresenta um quadro resumo destas duas variações da arquitetura

Resnet50.
Tabela 25 – Hiperparâmetros das Arquiteturas que utilizam Transferência por Inicialização.

Arquitetura Tamanho da Qtd. de Parâm. Qtd. de Parâm. Tempo Médio
Entrada Treináveis Não treináveis por Época (s)
.
Resnet big 224x224 26,383,753 0 526,67
Resnet tiny 224x224 23,606,153 0 552,62
B.2.2 Transferência de Atributos

Utilizando a técnica de transferência por atributos, diversas arquiteturas e modifica-
ções foram testadas e apenas as arquiteturas baseadas na V GG16 e na V GG19 obtiveram
resultados interessantes. Para ambas as redes, os pesos foram aprendidos utilizando a base
de imagens do Imagenet(117). Para cada uma destas duas arquiteturas, foram definidas
duas variações:
1. big: Versão que inclui toda arquitetura original com todos os pesos congelados.
Adicionou-se 7 camadas completamente conectadas ao final com 1024, 1024, 512,
256, 128, 64 e 9 neurônios respectivamente.
2. non-top: Versão que inclui apenas a etapa de engenharia de atributos (camadas

convolucionais) com os pesos congelados. Adicionou-se 6 camadas completamente
conectadas com 1024, 1024, 512, 256, 128 e 9 neurônios respectivamente.
A Tabela 26 apresenta um quadro resumo com as 4 variações de arquiteturas.
B.2.3 Transferência Parcial de Atributos

Utilizando a transferência parcial de atributos, onde algumas camadas da etapa
de extração de atributos (camadas convolucionais) são mantidas congeladas e o restante
dos pesos são utilizados como inicialização. Os pesos da etapa convolucional das arqui-
teturas foram originados do que foi aprendido com a base de dados do Imagenet(117).
As arquiteturas que mostraram resultados interessantes foram a V GG16 e V GG19, mais
especificamente:
Tabela 26 – Hiperparâmetros das Arquiteturas que utilizam Transferência por Atributos.

.
VGG16 big 224x224 2,772,489 138,357,544 145,05
VGG16 non-top 224x224 27,430,921 14,714,688 168,92
VGG19 big 224x224 2,772,489 143,667,240 169,22
VGG19 non-top 224x224 27,430,921 20,024,384 193,48
1. VGG16 block5_conv2 : os pesos até bloco 5, segunda camada convolucional da

V GG16 são congelados. O restando dos pesos da etapa de extração de atributos são
utilizados para inicialização;
2. VGG19 block5_conv1 : os pesos até bloco 5, primeira camada convolucional da

V GG19 são congelados. O restando dos pesos da etapa de extração de atributos são
utilizados para inicialização.
A Tabela 27 apresenta um quadro resumo destas duas variações de arquiteturas.
Tabela 27 – Hiperparâmetros das Arquiteturas que utilizam Transferência Parcial de

Atributos.
.
VGG16 block5_conv2 224x224 32,150,537 9,995,072 188,72
VGG19 block5_conv1 224x224 36,083,209 10,585,152 308,30
191
APÊNDICE C – EFEITOS DO RESIZE NA DISTORÇÃO DA

REPRESENTAÇÃO
Este Apêndice trata de influência do resize na representação do artefato malicioso

na forma da imagem. De forma a padronizar o entendimento, o processo é chamado de
upsampling ou interpolação quando o resultado final de sua aplicação é uma imagem com
um maior número de pixeis quando comparada à imagem original. O termo processo de
downsampling foi utilizado quando a imagem final possui um número menor de pixeis
quando comparada à imagem original. Finalmente, o termo redimensionamento foi utilizado
quando, em um conjunto de dados, foi aplicado tanto downsampling quanto upsampling.
C.1 Motivação
Durante o redimensionamento da imagem original (representação do artefato
malicioso) para um tamanho fixo de entrada do algoritmo de aprendizado profundo.
Durante o processo de upsampling (interpolação) a função resize da biblioteca skimage
oferece diversas alternativas, de acordo com o valor da variável order passada como
parâmetro: 0 - Nearest-neighbor, 1 - Bilinear, 2 - Biquadratic, 3 - Bicubic, 4 - Biquartic e 5
- Biquintic. Por padrão, a função resize utiliza o método Bilinear.
A Figura 105 apresenta uma visão para 1 dimensão e 2 dimensões dos métodos
Nearest-neighbor, Bilineare Bicubic. O ponto a ser calculado está na cor preta.
Figura 105 – Tipos de interpolação. Fonte: https://en.wikipedia.org/wiki/Bicubic_interpolation
Desta forma, pode-se concluir que a variável order passada como parâmetro da
APÊNDICE C. Efeitos do Resize na distorção da Representação 192
função resize define a ordem do polinômio que realizará a interpolação. Assim, um

primeiro teste para avaliação das 6 possibilidades foi escolher uma figura, reduzi-la e, em
seguida, realizar a interpolação com cada uma destas possibilidades. O resultado final
está apresentado na Figura 106 apresenta os resultados deste experimento, utilizando uma
imagem de tamanho 512 × 512 da astronauta Eileen Collins1 .
Figura 106 – Experimento de aplicação dos diversos tipos de interpolação.
Para fins de realizar uma avaliação objetiva de cada método, calculou-se o erro
quadrático médio entre a imagem gerada pela interpolação e a imagem original. Os
resultados estão apresentados na Tabela 28. Uma melhor reconstrução da imagem original
é obtida quanto menor o erro quadrático médio.
Tabela 28 – Erro médio quadrático entre imagem original e imagem com interpolação.
Algoritmo Erro médio Quadrático
Nearest-neighbor 0.004949
Bilinear 0.004117
. Biquadratic 0.003380
Bicubic 0.003514
Biquartic 0.003297
Biquintic 0.003283
Este resultado inicial motivou a realizar simulações para comparar o desempenho

de redes neurais convolucionais aplicadas à análise de malware utilizando o algoritmo
Bilinear e Biquintic.
1
Disponibilizada publicamente em https://flic.kr/p/r9qvLn
C.2 Descrição do Problema

O problema de distorção de representação ocorre em dois momentos em um processo
de obtenção de mapa de calor de explicabilidade ilustrado na Figura 107. Primeiro momento
é quando redimensionamentos a representação original do artefato malicioso para um
tamanho fixo, ou seja, de (1) para (2). O segundo momento é quando redimensionamos o
mapa de calor obtido para o tamanho da imagem original, ou seja, de (5) para (6).
Figura 107 – Visão geral do processo de obtenção do mapa de calor por meio do Grad-Cam
para artefatos maliciosos.
Em ambos os casos, a escolha de um algoritmo de interpolação pode ser significativa.

O primeiro caso está relacionado com o desempenho da rede neural convolucional e o
segundo caso está relacionado com a obtenção do mapa de calor final.
C.3 Impacto no Desempenho

Para avaliar o impacto no desempenho do uso do algoritmo de interpolação em
redes neurais convolucionais aplicadas à análise de malware, calculou-se, inicialmente, a
quantidade de amostras de artefatos maliciosos com tamanho superior a 224 × 224 = 50.176
bytes. A Tabela 29 apresenta esta informação para cada família de artefatos maliciosos da
Base de Dados VirusShareSant. Pode-se observar que a grande maioria das amostras tem
tamanho superior a 224 × 224, ou seja, as amostras sofrem um downsampling (amostragem)
e não uma interpolação. Para a família Bifrose, por exemplo, apenas em 317 das 2.291
amostras serão aplicados o algoritmo de interpolação. Assim, espera-se que os algoritmos
Bilinear e Biquintic obtenham resultado similar de desempenho.
Tabela 29 – Quantidade de amostras de cada família com tamanho superior a 224 × 224
bytes.
Família do Artefato Qtd>224 × 224 Qtd Total Porcentagem
Backdoor:Win32/Bifrose 1.974 2.291 86,16%
Trojan:Win32/Vundo 6.413 6.794 94,39%
Backdoor:Win32/Cycbot 3.622 3.622 100,00%
BrowserModifier:Win32/Zwangi 669 920 72,72%
.
Rogue:Win32/Winwebsec 4.617 4.624 99,85%
Trojan:Win32/Koutodoor 4.055 5.605 72,35%
Backdoor:Win32/Rbot 1.077 1.170 92,05%
Backdoor:Win32/Hupigon 1.918 1.943 98,71%
Trojan:Win32/Startpage 1.357 1.648 82,34%
C.3.1 Descrição do Experimento de Desempenho

Com o objetivo de avaliar a influência do algoritmo de redimensionamento no
desempenho de uma rede neural convolucional aplicada a análise de malware, selecionou-se
a arquitetura VGG16 non-top apresentada no Apêndice B.2 com transferência de atributos
onde se utiliza a representação de artefato malicioso na forma de imagem conforme Nataraj
et al.(13). Para avaliar impacto do redimensionamento, foram selecionados dois algoritmos
de interpolação: Bilinear e Biquintic. A estimativa de desempenho é obtida calculando-se
a média do desempenho de 5 modelos treinados com cada algoritmo de interpolação para
o conjunto de validação da base de dados VirusShareSant.
C.3.2 Resultados do Experimento de Desempenho

Os resultados do experimento proposto estão apresentados na Tabela 30. Pode-se
observar que existe uma diferença miníma entre os experimentos. A soma das diferenças
de desempenho para os 5 experimentos é de apenas 0.12 a favor do Biquintic. Apesar disso,
resolveu-se utilizar o algoritmo de interpolação Biquintic nos diversos experimentos de
redimensionamento desta tese.
Tabela 30 – Desempenho das RNCs utilizando os algoritmos de interpolação Bilinear e

Biquintic
Repetição Bilinear Biquintic Diferença

Experimento 1 95.47% 95.67% -0.20
Experimento 2 95.76% 95.70% 0.06
Experimento 3 95.52% 95.61% -0.09
Experimento 4 95.78% 95.67% 0.12
Experimento 5 95.73% 95.49% 0.23
C.4 Impacto na Explicabilidade

É difícil avaliar a eficácia da utilização de um ou outro algoritmo de interpolação
(resize) durante o redimensionamento de um mapa de calor de explicabilidade para
o tamanho da imagem original, conforme apresentado na Figura 107 de (5) para (6).
Isso ocorre porque os critérios para avaliar explicabilidade são subjetivos. Desta forma,
utilizando o mesmo modelo treinado (independente de qual algoritmo de interpolação foi
utilizado de (1) para (2) da Figura 107), foram selecionados dois algoritmos de interpolação
para o redimensionamento do mapa de calor: Bilinear e Biquintic.
C.4.1 Descrição do Experimento

Assim, com o objetivo de avaliar a influência do algoritmo de interpolação nos
resultados da explicabilidade de uma rede neural convolucional, utilizou-se o mesmo modelo
VGG 16 non_top treinado, modificando-se apenas o algoritmo utilizado para redimensionar
o mapa de calor da explicabilidade. Para avaliar o resultado, utilizou-se a Capacidade
de Gerar Assinaturas descrita na Seção 7.2.3 para avaliar a influência dos algoritmos
Bilinear e Biquintic nos resultados da explicabilidade.
C.4.2 Resultados Obtidos

Para os resultados aqui apresentados, será utilizada a arquitetura VGG16 non_top,
a representação tradicional e proposta (ver Seção 7.2.3) e serão utilizadas as mesmas
amostras da Seção 10.3.2 para fins de comparação.
(A) Estudo de Caso 1: Amostra da família BrowserModifier:Win32/Zwangi
tradicional e (b) representação proposta. O cabeçalho ocupa os primeiros 1024 bytes de
ambas as imagens e, por questão de resolução, não está ilustrado. O redimensionamento
do mapa de calor foi realizado utilizando o algoritmo de Biquintic.
 de
3236 0
191 7
ou seja, um f1-score de 6,82%.
Para a abordagem proposta, foram encontrados 28 picos e geradas, portanto,
 28

3232 4
assinaturas de tamanho 8 bytes. As duas melhores matrizes de confusão:  ,
178 20

 
3214 22
 , com f1-score de 18,01% e 18,93% respectivamente. Este resultado é superior
175 23
ao obtido na abordagem tradicional.
(B) Estudo de Caso 4: Amostra da família BrowserModifier:Win32/Zwangi
A amostra escolhida foi a amostra VirusShare_e70017930479d88b1747e3df6e99be25 da
os primeiros 1024 bytes de ambas as imagens. O redimensionamento do mapa de calor foi
realizado utilizando o algoritmo de Biquintic.

Share_e70017930479d88b1747e3df6e99be25.
Para a abordagem tradicional, foram produzidos 277 picos no mapa de calor.

Assim, 218 assinaturas
 de 8bytes foram
 produzidas. As melhores matrizes de confusão
3256 68 3324 0 
obtidas foram  , , que possuem um f1-score de 41,07% e 49,31%
64 46 74 36
respectivamente.
Para a abordagem proposta, foram encontrados 43 picos e, portanto, foram pro-
duzidas 39 assinaturas de tamanho
 8 bytes.
  As melhores
 matrizes de confusão foram
3322 2  3324 0 
obtidas nestas 39 assinaturas:  , , com f1-score de 57,32% e 58,06%
65 45 65 45
respectivamente.
C.4.3 Análise dos Resultados

Os resultados aqui obtidos utilizando o algoritmo Biquintic podem ser comparados
com os resultados obtidos na Seção 10.3.2 que utiliza o algoritmo Bilinear. A Tabela 31
apresenta um quadro comparativo dos resultados.
Tabela 31 – Comparação do algoritmo Bilinear e Biquintic para geração de assinaturas.
Bilinear Biquintic
1 f1-score 2o f1-score
o
1 f1-score 2o f1-score
o
Estudo de Caso 1 - Tradicional 6,82% 6,82% 6,82% 6,82%

Estudo de Caso 1 - Proposta 17,46% 10,90% 18,93% 18,01%
Estudo de Caso 4 - Tradicional 36,14% 29,28% 49,31% 41,07%
Estudo de Caso 4 - Proposta 55,55% 44,39% 58,06% 57,32%
Estes resultados mostram que a utilização do algoritmo Biquintic traz melhoras

nas assinaturas geradas automaticamente.
198
APÊNDICE D – PROPOSTA PARA PROBLEMA DE

VARIAÇÃO SEMÂNTICA
Este Apêndice trata de uma proposta de solução para o problema de variação

semântica apresentado na Seção 4.3.3.
D.1 Motivação
Os bytes de um binário se encontram entre os valores 0 e 255. No entanto, conforme
a seção que um determinado valor se encontre, o seu significado é bastante distinto.
Como cada artefato da base de dados VirusShareSant é disponibilizado na íntegra, é
possível extrair os bytes de cada uma de suas seções A biblioteca do Python PEFile foi
utilizada para este fim. Assim, neste apêndice será proposta uma arquitetura de redes
neurais convolucionais para cada tipo de seção do binário executável: cabeçalho, executável
e dados. Ao final, uma votação majoritária selecionando-se a melhor combinação de
classificadores para cada tipo de seção, ou seja, 3 classificadores.
D.2 Descrição das Arquiteturas

Para esta proposta foram definidas arquiteturas para cada tipo de seção do artefato.
D.2.1 Arquiteturas para Seção Tipo Cabeçalho

Como o cabeçalho é, do ponto de vista semântico, o mais simples (quando comparado
à seção de código executável e à seção de dados), decidiu-se por analisar o tamanho do
cabeçalho. A Tabela 32 apresenta os resultados desta análise. Assim, dois experimentos
foram realizados: (1) com os primeiros 1024 bytes do cabeçalho, que pode ser representado
por uma imagem de tamanho 32 × 32 e (2) com os primeiros 4096 bytes do cabeçalho,
que pode ser representado por uma imagem de tamanho 64 × 64. Em ambos os casos,
completou-se com zeros caso o artefato não tivesse o tamanho definido no cabeçalho.
Cabeçalhos maiores que o tamanho definido eram descartados.
A arquitetura de rede neural convolucional utilizada é a Lenet-5 Tiny que possui
48.585 parâmetros quando a entrada é uma imagem de 32 × 32 e 146.889 parâmetros
quando a entrada é uma imagem de tamanho 64 × 64. Esta quantidade é bem inferior à
quantidade de parâmetros treináveis de arquiteturas utilizadas nesta tese conforme pode
ser observado na Tabela 24, Tabela 26 e Tabela 25.
APÊNDICE D. Proposta para problema de Variação Semântica 199
Tabela 32 – Porcentagem de Amostras com determinado tamanho de cabeçalho
Tamanho Porcentagem de Amostras

tamanho <= 256 0.87%
tamanho <= 512 2.70%
tamanho <=1024 64.10%
tamanho <=2048 66.76%
tamanho <=4096 99.84%
D.2.2 Arquiteturas para Seção Tipo Código

A seção de códigos tem uma semântica mais complexa, pois um byte pode fazer
parte do mnemônico ou do operando de uma instrução assembly. Além disso, o mesmo byte
pode ter significados diferentes dependendo dos bytes ao seu redor1 . Desta forma, para
tratar esta maior complexidade semântica, selecionou-se a arquitetura VGG16 non_top
com transferência de atributos conforme Seção B.2.2.
A entrada de dados para esta VGG16 non_top foi realizada de duas formas:
1. Os primeiros 99.856 bytes da seção de códigos eram selecionados. Caso necessário,

realiza-se um preenchimento com zeros até se obter o tamanho 99.856 e bytes
excedentes eram descartados. Uma imagem de tamanho 316 × 316 era gerada e
redimensionada para 224 × 224. Esta imagem de 224 × 224 era repetida para formar
uma imagem com 3 canais.
2. Os primeiros 150.528 bytes da seção de códigos foram selecionados. Se fosse o caso,

foi realizado um preenchimento com zeros até se obter o tamanho 150.528 e, caso
necessário, descarta-se os bytes excedentes. Uma imagem com 3 canais de tamanho
224 × 224 era gerada.
D.2.3 Arquiteturas para Seção Tipo Dado

A seção de dados é a que deve possuir maior quantidade de informação complexa
pois, ao contrário da seção de código que possui uma estrutura definida pela linguagem
Assembly, a seção de dados pode possuir informação de strings, de dados de programas, de
dados cifrados ou compactados, de imagens, entre outras. Assim, da mesma forma que
foi tratada a complexidade para a seção de código, também selecionou-se a arquitetura
VGG16 non_top com transferência de atributos conforme Seção B.2.2.
A entrada de dados para esta RNC foi realizada da seguinte forma: os primeiros
150.528 bytes da seção de dados foram selecionados. Caso necessário, realiza-se um preen-
1
Por exemplo, o hexadecimal 14 do opcode 8D 14 DF é traduzido para lea edx,[edi+ebp] enquanto que
no opcode 88 14 33 é traduzido para mov [ebx+esi],dl.
chimento com zeros até se obter o tamanho 150.528 e, caso necessário, descarta-se os bytes
excedentes. Uma imagem com 3 canais de tamanho 224 × 224 era gerada.
D.3 Resultados de Desempenho

D.3.1 Desempenho para a Seção Tipo Cabeçalho
Para a primeira arquitetura, Lenet-5 Tiny, utilizando 1024 bytes iniciais como
imagem de tamanho 32 × 32, foi obtida uma acurácia de 97.84% para o conjunto de
treinamento e 95.60% para o conjunto de validação. Para a segunda arquitetura, Lenet-5
Tiny, utilizando 4096 bytes do cabeçalho como imagem de tamanho 64×64,, foi obtida uma
acurácia de 97.68% para o conjunto de treinamento e 95.34% para o conjunto de validação.
Estes resultados, por si só, são surpreendentes quando comparados aos resultados da
Tabela 13 e Tabela 14. A Tabela 33 apresenta um quadro com estes valores de acurácia.
Tabela 33 – Acurácia na arquitetura Lenet-5 Tiny para Cabeçalho.

Arquitetura Tamanho da Acurácia no Acurácia na
Imagem de Entrada Treinamento Validação
.
Tiny 32 × 32 97.84% 95.60%
Tiny 64 × 64 97.68% 95.34%
D.3.2 Desempenho para a Seção Tipo Código

Os resultados para a seção de código utilizando a VGG16 non_top está apresentada
na Tabela 34.
Tabela 34 – Acurácia na arquitetura VGG16 non_top para Código.
.
Qtd. Bytes Tamanho da Imagem de Entrada Acurácia no Acurácia na
Treinamento Validação
99.856 316 × 316 −→ 224 × 224 −→ 224 × 224 × 3 97.61% 91.64%
150.528 224 × 224 × 3 97.71% 92.57%
Estas acurácias são inferiores aos resultados apresentados na Tabelas 13 e na Tabela

14. No entanto, deve-se considerar que se está utilizando somente informação da seção de
código do artefato malicioso.
D.3.3 Desempenho para a Seção Tipo Dado

A acurácia da arquitetura proposta para o conjunto de treinamento foi de 96.59%
e de 91.85% para o conjunto de validação. Estas acurácias são inferiores às acurácias das
arquiteturas da proposta P0 desta tese, mas deve-se considerar que somente estão sendo
utilizadas informações das seções de dados.
D.3.4 Desempenho para Votação Majoritária

Para votação majoritária selecionou-se a proposta com imagens de tamanho 32 × 32
para seção de cabeçalho, a proposta que utiliza 150.528 bytes de informação da seção de
código e transforma em imagem de dimensão 224 × 224 × 3 e a proposta da seção do tipo de
dados. A acurácia no conjunto de treinamento foi de 99.22%, no conjunto de validação foi
de 96.19% e, finalmente, no conjunto de testes foi de 95.55%. A quantidade de parâmetros
treináveis deste comitê é de 48.585 parâmetros para arquitetura da seção de cabeçalho,
6.456.841 parâmetros para arquitetura da seção de código e 6.456.841 parâmetros para a
arquitetura da seção de dados, totalizando 12.962.267 de parâmetros treináveis.
Na Seção 8.2.4, temos que o resultado para o comitê utilizado na tese foi de
99,88% no conjunto de treinamento e 95,37% no conjunto de testes, utilizando 102.913.417
parâmetros para a Lenet-5 Normal, 23.553.033 parâmetros para a Resnet tiny, 27.430.921
parâmetros para a VGG16 non-top e 27.430.921 parâmetros para a VGG19 non-top,
totalizando 181.328.292 parâmetros. A Tabela 35 apresenta um quadro resumo destes dois
comitês.
Tabela 35 – Comparação entre o comitê de classificadores da tese e o comitê de votação

majoritária para tratar variação semântica.
Arquitetura Quantidade de Acurácia no Acurácia no
Parâmetros Treinamento Teste
.
Comitê Classificadores Tese 181.328.292 99,88% 95,37%
Comitê Variabilidade Semântica 12.962.267 96.19% 95.55%
D.4 Conclusão
A conclusão que pode-se tirar do experimento anterior está apresentada a seguir:
1. A arquitetura para cabeçalho que utiliza apenas 1.024 bytes do binário obteve,
sozinha, um valor de acurácia superior a quase todas as outras arquiteturas isoladas.
Deve-se aprofundar neste tipo de abordagem quando o objetivo é desempenho;
2. O comitê de arquiteturas de por seção obteve melhor resultado no conjunto de testes

com aproximadamente 15 vezes menos a quantidade de parâmetros.
3. O comitê aqui proposto é bastante simples pois não explora a relação entre as
seções que possam existir. Uma outra alternativa é criar 3 arquiteturas SOMENTE
convolucionais onde a entrada de dados de cada uma são os bytes de cada tipo de
seção. Então, uma camada ÚNICA completamente realiza o processamento de cada
uma das saídas das camadas convolucionais (atributos aprendidos).
203
APÊNDICE E – RUÍDO NO ALGORITMO DE IMPORTÂNCIA

DE PIXEL
Na Seção 7.2.4.2 foi apresentada a proposta P3, Algoritmo de Importância por

Pixel. Neste Apêndice será discutido o uso do ruído no algoritmo proposto.
E.1 Utilização do Ruído

O Algoritmo de Importância por Pixel foi baseado no algoritmo de importância
por permutação de atributos proposto por Breiman(123). No algoritmo de permutação de
atributos a pertubação em um atributo é realizada pela permutação de valores entre diversas
amostras. No entanto, conforme apresentado na Seção 7.2.4.2, realizar a pertubação na
imagem redimensionada da representação do artefato não faz sentido, já que essa pertubação
pode não ter equivalente na imagem original. Assim, resolveu-se realizar a pertubação na
imagem original de representação do artefato, ou seja, antes do redimensionamento para
um valor fixo.
Inicialmente, alguns trabalhos sugerem a realização de permutação de atributos,
como pode ser visto em Breiman(123), Strobl et al.(153) e Altmann et al.(154), mas este
tipo de solução não pode ser aplicado nesta tese.
Uma das formas mais simples de obter a importância entre duas variáveis é por meio
da correlação entre elas. Por exemplo, uma uma correlação de ordem zero(155) simplesmente
se refere à correlação entre duas variáveis, a variável independente e dependente, sem
controlar a influência de quaisquer outras variáveis. Ainda que exista a influência de
outras variáveis, ao conduzir uma análise com mais de duas variáveis, pode ser interessante
conhecer as relações bivariáveis (de ordem zero)entre as variáveis independentes e a
dependente para obter uma melhor noção do que acontece quando se começa a controlar
outras variáveis.
Um exemplo de correlação de ordem zero é a Pearson Correlation(155). A formula
para o coeficiente de correlação de Pearson está apresentada a seguir:
Pn Pn Pn
n (xy)−( x)( y)
r = √ Pn 1 Pn 1 Pn 21 Pn ,
[n 1
x2 −( 1
x)2 ][n 1
y −( 1
y)2 ]
onde x e y são as variáveis aleatórias e n é a quantidade de amostras.

Quando um coeficiente de correlação é 1, isso significa que a cada aumento em uma
variável, há um aumento positivo em outra proporção fixa, por exemplo, a relação entre a
variável dependente do tamanho dos sapatos e a variável independente do comprimento
do pé. Quando um coeficiente de correlação é -1, isso significa que todo aumento positivo
APÊNDICE E. Ruído no Algoritmo de Importância de Pixel 204
em uma variável, há uma diminuição negativa em outra proporção fixa. A relação entre a
diminuição da quantidade de gás em um tanque de gás, e a velocidade do gás. Finalmente,
quando um coeficiente de correlação é 0 para cada aumento, significa que não há aumento
positivo ou negativo e as duas variáveis não estão relacionadas.
A Figura 110 apresenta um quadro geral da proposta. O sistema que produz o
erro_k é composto pela fase de redimensionamento e modelo treinado. Considerando um
cenário onde cada pixel k é independente dos pixels adjacentes, o que se deseja conhecer é
qual o valor do coeficiente de Pearson para as variáveis valor de um pixel k e erro_k. Ou
seja, há alguma relação entre o valor do pixel k e o erro_k.
Figura 110 – A Figura ilustra uma visão geral do processo de obtenção da feature impor-
tance em análise de malware.
Aplicando os conceitos do coeficiente de Pearson, pode-se concluir que se a variável

valor do pixel k for um ruído, então não deve existir nenhuma relação entre ela e o valor
do erro_k e, portanto, o valor do coeficiente é zero. Do ponto de vista de importância
de variável, o pixel k é pouco importante. Com isso, justifica-se a utilizando do ruído
para estimar a importância de uma variável em um cenário simplificado, onde o pixel k é
independente dos pixels adjacentes.
205
APÊNDICE F – BASE DE DADOS PARA CONCEPT

DRIFTING
Um aspecto interessante a ser avaliado quando se trata do problema de classificação

ou detecção de artefatos maliciosos é o concept drifting. Neste Apêndice é apresentado o
resultado da aplicação do método para gerar a base de dados VirusShareSant para gerar
uma base de dados para avaliação de modelos de aprendizado profundo considerando a
evolução do desenvolvimento de artefatos maliciosos (concept drifting).
F.1 Introdução
Os pacotes selecionados para desenvolver a base de dados VirusShareSant e suas
respectivas datas são: VirusShare_00015 (2012-10-20), VirusShare_00021 (2012-11-20),
VirusShare_00023 (2012-11-30), VirusShare_00024 (2012-12-06), VirusShare_00026 (2012-
12-22), VirusShare_00047 (2013-03-25) e VirusShare_00094 (2013-09-08). Ou seja, os
artefatos da base VirusShareSant contém amostras de 2012-10-20 a 2013-09-08.
Para avaliar o efeito do concept drifting, é preciso gerar uma base contendo amostras
das mesmas famílias que a base VirusShareSant e que seja mais recente. Assim, selecionou-
se os pacotes VirusShare_00095, VirusShare_00096, VirusShare_00097, VirusShare_00098
e VirusShare_00099. As datas de criação destes arquivos são, respectivamente, 2013-09-09,
2013-09-10, 2013-09-12, 2013-09-17 e 2013-09-18, ou seja, todos artefatos são de 2013.
A forma de rotular esta base foi a mesma utilizada para a base VirusShareSante está
descrita no Apêndice A. Assim, a Tabela 36 mostra um quadro resumo da base resultante
apresentando a quantidade de amostras por família e por pacote do VirusShare. O número
total de amostras desta nova base é de 19.090 amostras, ou seja, a mesma ordem de
grandeza do conjunto de treinamento da base VirusShareSant. A base resultante será
denominada VSS Concept Drifting.
Tabela 36 – Quantidade de Amostras de Malware por família por pacote do VirusShare.
Id Família 0095 00096 00097 00098 00099

1 Backdoor:Win32/Bifrose 442 494 602 373 386
2 Trojan:Win32/Vundo 767 960 1018 848 809
3 Backdoor:Win32/Cycbot 445 433 418 117 100
4 BrowserModifier:Win32/Zwangi 44 43 55 27 35
5 Rogue:Win32/Winwebsec 746 907 1043 859 822
6 Trojan:Win32/Koutodoor 285 367 392 274 238
7 Backdoor:Win32/Rbot 51 89 78 84 61
8 Backdoor:Win32/Hupigon 400 411 427 240 215
9 Trojan:Win32/Startpage 594 678 676 383 354
Total 3774 4382 4709 3205 3020
APÊNDICE F. Base de Dados para Concept Drifting 206
F.2 Resultados de Desempenho

Na Seção 8.2.3 tem-se os resultados dos modelos selecionados para o conjunto
de teste da base de dados VirusShareSant. Este modelos utilizam a representação de
artefato utilizando a Tabela proposta por Nataraj et al.(13). As amostras da base VSS
Concept Drifting foram aplicadas nestes modelos e os resultados de desempenho foram
comparados com os resultados do conjunto de testes da base VirusShareSant. A Tabela
37 apresenta estes resultados. Pode-se observar que houve uma redução no desempenho
em todas arquiteturas. Muito provavelmente, os artefatos produzidos em 2013 (da base
VSS Concept Drifting) foram modificados de forma a serem menos detectáveis ou suas
capacidades foram modificadas ou até mesmo ampliadas.
Tabela 37 – Acurácia para o conjunto de testes e VSS Concept Drifting.

Arquitetura Acurácia Conjunto de Teste Acurácia VSS Concept Drifting
Lenet-5 Normal 92,51% 89,14%
. Resnet tiny 94,27% 89,67%
VGG16 non-top 93,96% 88,94%
VGG19 non-top 93,92% 90,43%
F.3 Conclusão
Assim, a base VSS Concept Drifting pode servir como ponto de partida para
desenvolver arquiteturas ou soluções que considerem o efeito do concept drifting nos
artefatos maliciosos. A falta de base de dados pode ser o motivo pelo qual não foram
encontrados trabalhos que utilizam aprendizado de máquina em classificação ou detecção
de malware e que considerem o efeito do cncept drifting em artefatos maliciosos.
207
ANEXO A – FORMATO PE
Na Figura 111 tem-se a estrutura geral do formato Portable Executable e na Figura

112 tem-se um detalhamento do cabeçalho de um arquivo do tipo PE file.
Figura 111 – Visão geral do formato PE(9).

ANEXO A. Formato PE 208
Figura 112 – Visão geral do cabeçalho do formato PE(9).

TeseDoutoradoSantana Abntime Final Impressao-Assinado

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TeseDoutoradoSantana Abntime Final Impressao-Assinado

Enviado por

Direitos autorais:

Formatos disponíveis

MINISTÉRIO DA DEFESA

EXPLICABILIDADE EM ARQUITETURAS DE APRENDIZADO PROFUNDO

EXPLICABILIDADE EM ARQUITETURAS DE APRENDIZADO PROFUNDO

Tese apresentada ao Programa de Pós-graduação em Enge-

Orientador(es): Julio Cesar Duarte e Ronaldo Ribeiro Goldschmidt.

Tese (doutorado) – Instituto Militar de Engenharia, Engenharia de defesa, 2020.

1. malware. aprendizado profundo. 2. explicabilidade. 3. análise de malware.

Inicialmente, gostaria de agradecer aos meus pais, principalmente pela educação e

A utilização de aprendizado profundo em análise de malware vem crescendo ultimamente

Com relação aos trabalhos de aplicação de aprendizado profundo na área de análise de

O método de candidatos a verificação de rótulos obteve resultados de f1-score de 35,55%

A nova representação foi avaliada considerando dois aspectos: o desempenho de arquitetura

A aplicação do Algoritmo de Importância por Pixel em regiões do artefato onde a semântica

Assim, os resultados experimentais da abordagem das propostas demonstram que as

Palavras-chave: malware. aprendizado profundo. explicabilidade. análise de malware.

When considering signatures’ generation , the proposed representation obtained better

Keywords: malware. deep learning. explicability. malware analysis.

Figura 1 – Número de novas espécies de malware. Baseado em dados apresentados em AVtest(1). 24

Tabela 1 – Taxonomia da Representação de Artefatos Maliciosos. . . . . . . . . . 30

4 ANÁLISE AUTOMATIZADA DE MALWARE . . . . . . . . . . . . 71

6 TRABALHOS RELACIONADOS . . . . . . . . . . . . . . . . . . . . 100

8 RESULTADOS DE DESEMPENHO . . . . . . . . . . . . . . . . . . 127

9 RESULTADOS DA RE-ROTULAGEM . . . . . . . . . . . . . . . . . 135

10 RESULTADOS DA NOVA REPRESENTAÇÃO . . . . . . . . . . . . 139

11 RESULTADOS DO ALGORITMO DE IMPORTÂNCIA POR PIXEL 156

APÊNDICE A – BASE DE DADOS VIRUSSHARESANT . . . . . 174

APÊNDICE B – ARQUITETURAS DE CNN UTILIZADAS . . . . 184

APÊNDICE C – EFEITOS DO RESIZE NA DISTORÇÃO DA RE-

APÊNDICE D – PROPOSTA PARA PROBLEMA DE VARIAÇÃO

APÊNDICE E – RUÍDO NO ALGORITMO DE IMPORTÂNCIA

APÊNDICE F – BASE DE DADOS PARA CONCEPT DRIFTING 205

ANEXO A – FORMATO PE . . . . . . . . . . . . . . . . . . . . . . 207

Nos dias atuais, presencia-se um aumento no aparecimento de amostras de malware

Figura 1 – Número de novas espécies de malware. Baseado em dados apresentados em AVtest(1).

Mesmo quando se consideram amostras em voga, como os ransomwares, o cenário

Figura 2 – Evolução dos malware tradicionais.

Artefatos maliciosos amplos são projetados para infectar diversas máquinas, ao

de forma a dificultar a sua detecção. Desta forma, desenvolver um método de detecção

abordagem não foi amplamente explorada na análise de malware 4 .

“produzir modelos mais explicáveis, mantendo um alto nível de desempenho

Adadi e Berrada(21) destacam quatro motivos que justificam a implementação da

• Justificar: sistemas explicáveis fornecem a informação requerida para justificar

• Melhorar: muitas vezes tem-se a necessidade de melhorar continuamente um sistema.

• Descobrir: se o sistema é capaz de realizar uma determinada tarefa de forma superior

Figura 3 – Taxa de Erro obtida no desafio anual do ImageNet((2))

A utilização de aprendizado profundo em análise de artefatos maliciosos é bastante

1.2 Caracterização do Problema

uma forma de representação ou uma representação híbrida. A Tabela 1 apresenta trabalhos

Tabela 1 – Taxonomia da Representação de Artefatos Maliciosos.

Ano Referência Representação utilizada Plataforma

• Malware de diferentes tamanhos são representados por imagens de tamanhos vari-

• Os resultados da explicabilidade são obtidos a partir do processamento de toda

Estas duas limitações citadas são específicas de soluções de aprendizado profundo

negativos das lacunas identificadas. Ainda, a implementação de explicabilidade na ar-

• Objetivo Específico S0: Definir uma arquitetura de Rede Neural Convolucional

• Objetivo Específico S1: Definir adaptações em algoritmos de explicabilidade de

• Objetivo Específico S2: Definir representações que alinhem o resultado da expli-

• Objetivo Específico S3: Adaptar um algoritmo de explicabilidade de forma a

Assim, para atingir o objetivo geral é preciso atingir o objetivo S0 e S1 ou S2 ou S3.

1.4 Questões de Pesquisa

Figura 4 – Relação entre Objetivo Geral, Específicos e lacunas

• Questão de Pesquisa Q1: Pode-se obter amostras candidatas à reavaliação de

• Questão de Pesquisa Q2: A definição de um novo redimensionamento da re-