---
# System prepended metadata

title: Projet analyse de malwares

---

# Projet analyse de malwares

## Détection de malware par techniques de *Machine Learning*

> Victorien Blanchard, Lucas Gasté
>
> Vendredi 5 Juin 2020
>
> ENSIBS, CYBER2

# Introduction

Le but de ce TP est d'implémenter une technique de détection statique de programmes malveillants (*malwares*). Cette détection est dite statique dans le sens ou les binaires assujettis ne seront pas exécutées contrairement à une analyse dynamique où les sujets sont exécutés afin d'observer leur comportement au sein de leur environnement.  
Bien que ces deux techniques puissent être combinées afin de parvenir à de meilleurs résultats, ce ne sera pas l'objet de ce TP.
Une autre particularité de cette technique de détection est qu'elle possède une phase d'apprentissage permettant à l'algorithme de trouver des primitives lui permettant de discerner les programmes bénins des malveillants. Ainsi nous aurons à notre disposition un set de programmes catégorisés selon leur intention, permettant à l'algorithme d'avoir une référence. Nous aborderons premièrement dans ce rapport les caractéristiques des binaires exploitées pour effectuer l'analyse. S'en suivront les explications de la méthode de détection choisie ainsi que son implémentation en langage C. Pour finir une critique de cet algorithme ainsi que de ces résultats sera établie.

# 1. Données d'analyses

## 1.1 Format Portable Executable (PE)

Le format *Portable Executable* est le format des programmes exécutables sous Windows, il décrit comment les données, une fois compilées, sont stockées en son sein et comment elles seront *mappées* en mémoire lors de l'exécution. Parmi ces informations se trouve la localisation de toutes les sections de l'exécutable. Les sections sont créés par le compilateur lors de la compilation et contiennent différents types d'information en fonction de celles-ci.

Nous pouvons visualiser les différentes informations du *header* d'un fichier PE à l'aide de l'outil *Kaitai Struct Visualizer*

![](https://i.imgur.com/Kibyx32.png)

Sur le schéma ci-dessus, l'import table.




### 1.1.1 .text

La section `.text` contient les instructions du programmes, c'est cette section (en cas général) qui va définir le comportement du programme. Quelles fonctions va-t-il appeler, quelles ressources va-t-il accéder etc. Si on souhaite être capable de comprendre le but, le fonctionnement d'un programme, il faut analyser cette section. C'est de cette section que nous extrairons les "ngrams", qui ne sont rien d'autre que des morceaux de la section `.text`. 
Le nombre de ngrams étant important, nous devrons procéder à un tri qui permettra de ne garder et d'étudier uniquement les ngrams les plus pertinants.
A noter que les instructions d'un programme peuvent ne pas se trouver dans la section `.text` dans le cas où le créateur voudrais cacher des informations, ou si le programme est packé.

### 1.1.2 IAT

L'IAT, ou *Import Address Table* est une table d'adressage situé dans le header d'un `PE`. Cette table est composée de pointeurs de fonctions vers les fonctions importées de DLL. Ces pointeurs permettent au programme de résoudre l'adresse des fonctions importées de DLL pendant l'execution. 
Chaque import est représenté par un ordinal, qui correspond à son numéro et qui n'a aucune garanti d'être "fixe" d'une version à l'autre d'une DLL, du nom de la fonction, et de son adresse.

![](https://i.imgur.com/srGGU6x.png)

Nous allons utiliser les imports comme un des vecteurs de détection pour notre algorithme, en listant tous les imports d'un binaire.

## 1.2 Extraction des attributs

Pour l'extraction de l'IAT, nous avons simplement utilisé l'outil `pefile` qui permet de récupérer l'IAT très facilement.

Pour ce qui est des ngrams, le même outil permet de récupérer les octets de la section .text, et donc de récupérer les ngrams.

La partie la plus importante est de filtrer toutes ces informations qui prennent beaucoup de place en mémoire et sur le disque.

Le but principal de cette étape préliminaire est de constituer un set de référence, qui permettra par la suite de créer des signatures pour chaque binaire.

Pour ce faire, il nous faut filtrer toutes les informations extraites des benignwares et malwares d'apprentissage, afin d'en garder les parties les plus pertinantes.

Dans un premier temps, on peut filtrer les imports en supprimant les similarités entre nos deux sets malware et benignware. On définit une similarité avec un "treshold" (un pourcentage) qui nous permet d'exclure les imports similaires à un treshold près. En clair, si notre treshold est de 15%, on exclus toutes les fonctions qui apparaissent entre les deux jeux de donnés avec une fréquence identique à 15% près.

Pour ce qui est des ngrams, on calcule le gain d'information (IG) de chacun d'entre eux, et on garde les `n` ngrams présentants le plus gros gain d'information, `n` étant définit par défaut à 500.

Ces deux filtres nous permettent de générer deux signatures de référence : une pour les malwares et une pour les benignwares.

## 1.3 Génération du modèle d'entrainement

Nous allons désormais générer deux signatures pour chaque binaire d'Apprentissage qu'il soit bénin ou malware. La notion de signature correspond au nombre de similarités entre la référence générée au préalable et le binaire courant. 

Pour chacune des deux catégories nous avons généré un fichier de référence comportant la liste des fonctions importées depuis les DLL référencées ainsi qu'une liste d'un certains nombre de *n-grams*. Pour stocker les signatures de chaque binaire nous allons créer deux variables de type `mpz_t` dont nous allons activer des bits ou non en fonction de si une similarité est détectée avec le fichier de référence.

### Exemple

Imaginons que le fichier de référence *benigwares* contienne l'ensemble des fonctions suivantes :

```
ksuser.dll:KsCreatePin
ntdll.dll:DbgPrint
ntdll.dll:RtlAssert
advapi32.dll:RegCloseKey
advapi32.dll:RegOpenKeyExW
advapi32.dll:RegQueryValueExW
kernel32.dll:CloseHandle
kernel32.dll:CreateEventW
```

Si le binaire dont on souhaite faire la signature pour les exports exportent les fonctions :

```
ntdll.dll:DbgPrint
kernel32.dll:CloseHandle
```

Alors sa signature sera la suivante : `01000010`. Le procédé est identique pour la signature des *n-grams* ainsi que pour la catégorie *malware*.

### Code 

Nous devons donc créer 4 sets de signatures : `b1`, `m1` signatures des exports pour respectivement la catégorie *benigware* et malware ainsi que `b2` et `m2` signatures des *n-grams* dans le même ordre.

```C
// E1 exports
set *set_b1 = Set_init(nb_benignware);	// benins exports
set *set_m1 = Set_init(nb_malware);		// malwares exports
// E2 ngram
set *set_b2 = Set_init(nb_benignware);	// benins ngram
set *set_m2 = Set_init(nb_malware);		// malwares ngram

dir_beningware->clear(dir_beningware);
dir_malware->clear(dir_malware);
// are only generated with the `Apprentissage` category
generate_training_sets(set_b1->s, set_b2->s, BENIGNWARE_DIR, reference_benignware);
generate_training_sets(set_m1->s, set_m2->s, MALWARE_DIR, reference_malware);
```

Nous avons également mis en place une fonctionnalité de stockage sur disques des signatures afin de les générer une seule fois et simplement de les charger en mémoire lors de leur utilisation.

```C
if (access(filename_sig, F_OK) != -1) {
  load_signature(filename_sig, sig_exports, sig_5grams);
} else {
  get_signature_exports(full_path, ref, sig_exports);
  get_signature_5grams(full_path, ref, sig_5grams);
  save_signature(filename_sig, sig_exports, sig_5grams);
}
```

L'algorithme est très simple, pour chaque binaire nous parcourons chaque ligne du fichier de référence de sa catégorie. Si une similarité est trouvée alors la fonction `mpz_setbit` met à 1 le bit associé. Dans le cas contraire le bit est laissé à 0.

Ces 4 ensembles constituent notre modèle d’entraînement.

## 1.4 Génération du jeu de tests

Nous allons à présent générer notre jeu de test. La méthode est identique à celle de la génération du modèle d’entraînement, à la différence que cette fois ci nous prenons des binaires du jeu de Test.

```C
unsigned long	nb_test_samples = nb_test_samples_malware + nb_test_samples_benignware;
set				*set_T_exp = Set_init(nb_test_samples);
set				*set_T_grams = Set_init(nb_test_samples);

set *set_T_exp_m = Set_init(nb_test_samples_malware);	// exports malwares test
set *set_T_grams_m = Set_init(nb_test_samples_malware);	// ngram malwares test

generate_training_sets(set_T_exp_m->s, set_T_grams_m->s, MALWARE_TEST_DIR, reference_malware);

set *set_T_exp_b = Set_init(nb_test_samples_benignware);	// exports benins test
set *set_T_grams_b = Set_init(nb_test_samples_benignware);	// ngram benins test

generate_training_sets(set_T_exp_b->s, set_T_grams_b->s, BENIGNWARE_TEST_DIR, reference_malware);

int j = 0;
puts("Now merging sets to create the Test set (merging T_m & T_b)\n");

for (int i = 0; i < nb_test_samples_benignware; i++, j++) {
  mpz_set(set_T_exp->s[j], set_T_exp_b->s[i]);
  mpz_set(set_T_grams->s[j], set_T_grams_b->s[i]);
}

for (int i = 0; i < nb_test_samples_malware; i++, j++) {
  mpz_set(set_T_exp->s[j], set_T_exp_m->s[i]);
  mpz_set(set_T_grams->s[j], set_T_grams_m->s[i]);
}
```

Le set contenant les signatures pour chaque binaire de Test, nommé T, est désormait prêt pour la phase de détection.

# 2. Algorithme de détection

La méthode de détection utilisée est celle des K plus proches voisins ou *KNN*. Elle consiste à sélectionner les K échantillons du set d'apprentissage les plus proche de l'entrée que nous sommes entrain d'analyser.

Dans notre contexte cela revient à trouver les signatures provenant du set d'Apprentissage aillant le plus de similarité avec le binaire `y` issue de l’ensemble T dont on souhaite déterminer la catégorie.

Nos échantillons sont dans notre contexte les signatures générées sous forme de grand entier. Ainsi, calculer la similarité revient à faire l'opération `&` logique sur les deux signatures. Grâce aux propriétés de l'opération *and*, les similarités sont symbolisées par des bits à `1`. Plus leur nombre est grand, plus la similarité est grande.

```c
void get_similarity(mpz_t y, mpz_t training_sig, mpz_t *similarity) {
    mpz_t and_res, bit_count;
    mpz_init(and_res);
    mpz_init(bit_count);

    // making and between the test binary signature and our Apprentissage set
    mpz_and(and_res, y, training_sig);

    // getting the amount of `1` in the and result
    mpz_set_ui(*similarity, mpz_popcount(and_res));

    mpz_clears(and_res, bit_count, NULL);
}
```

Nous pouvons désormais calculer l'indice de similarité entre le binaire `y` et chaque binaire du set de training. Chaque indice sera stocké dans une structure qui contiendra également une valeur indiquant si cet indice de similarité a été fait avec un binaire catégorisé comme bénin ou malveillant.

```C
void generate_similarity(mpz_t y, set *benin_set, set *malware_set, similarity_set* sim_set) {
    int i = 0;
    // getting similarity with all benin from T set
    for(; i < benin_set->size; i++ ) {
        get_similarity(y, benin_set->s[i], sim_set->sim_val[i].value);
        sim_set->sim_val[i].type = BENIN;
    }
    // getting similarity with all malware from T set
    for(int j = 0; i < sim_set->size; i++, j++ ) {
        get_similarity(y, malware_set->s[j], sim_set->sim_val[i].value);
        sim_set->sim_val[i].type = MALWARE;
    }
}
```

Les différents indices de similarité sont ainsi stockés dans un tableau de structure comportant leur valeur et provenance. Cependant, ils ne sont pas triés par ordre décroissant. Nous souhaitons obtenir les K indices de similarité les plus importants, et nous devons donc trier le tableau par ordre décroissant afin d'extraire les K premières valeurs.

Ce tri est fait à l'aide de la fonction `do_sorting(similarity_set *set);` qui est un simple appel à la méthode `       void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));` permettant d'implémenter un *callback* définissant quelles valeurs de la structure comparer pour trier le tableau.

Une fois le tableau ordonné, nous allons mettre un en place un vote pondéré pour faire l'attribution du label pour ce binaire `y`.

Notre vote pondéré est simplement l'addition des N valeurs issues des K valeurs en fonction de leur label.

## exemple

Si les `K = 5` premières valeurs sont :

```
24:MALWARE
24:MALWARE
19:BENIN
16:BENIN
16:BENIN
```

Alors nous avons comme résultat :

```
BENIN:51
MALWARE:48
```

Ainsi le binaire `y` se verra appliquer le label `BENIN`.

Le processus de détection doit être fait pour les signatures issues de l'ensemble E1 ainsi que E2. Le résultat du vote pondéré donnera potentiellement un label différent pour chacun des ensembles car se sont des attributs différents qui sont analysés. 

Il se peut également que le vote pondéré donne une valeur nulle, dans ce cas le label du binaire n'est pas défini.

# 3. Critique finale

## 3.1 Analyse des résultats

Le set T est composé de 55 binaires dont 28 bénins et 27 malwares. 
Avec un niveau de threshold de 15% ainsi que 500 ngrams nous obntenons les résultats suivants :

`K=5`

```
+-------------------------------------------+--------------------------------------------+
| E1                                        |  E2                                        |
+----------------------------------------------------------------------------------------+
| 27 malwares detected as malware           | 1 malwares detected as malware             |
| 0 malwares detected as benin              | 26 malwares detected as benin              |
| 0 malwares uncategorized                  | 0 malwares uncategorized                   |
|                                           |                                            |
| 10 benin detected as benin                | 16 benin detected as benin                 |
| 16 benin detected as malware              | 0 benin detected as malware                |
| 2 benin detected as uncategorized         | 12 benin detected as uncategorized         |
+-------------------------------------------+--------------------------------------------+
```

`K=9`

```
+-------------------------------------------+--------------------------------------------+
| E1                                        |  E2                                        |
+----------------------------------------------------------------------------------------+
| 27 malwares detected as malware           | 1 malwares detected as malware             |
| 0 malwares detected as benin              | 26 malwares detected as benin              |
| 0 malwares uncategorized                  | 0 malwares uncategorized                   |
|                                           |                                            |
| 10 benins detected as benin               | 16 benins detected as benin                |
| 16 benins detected as malware             | 0 benins detected as malware               |
| 2 benins detected as uncategorized        | 12 benins detected as uncategorized        |
+-------------------------------------------+--------------------------------------------+

```


Malheureusement nos tentatives de construction de courbes ROC on été des échecs totals. Aucune valeur n'étant significative qu'elles proviennent de la détection faite grâce aux signatures des exports ou des 5ngrams.

Le temps investit dans ce TP est déjà suffisamment conséquent (plus du double des heures allouées chacun) ainsi que le manque de résultat probant ne nous permet pas de continuer.