Table des matières

1. Remerciements ...................................................................................................... 5
2. Présentation personnelle ........................................................................................ 6
3. Présentation de l’entreprise .................................................................................... 7
4. Contexte et motivation de la problématique ............................................................. 8
1. Introduction des enjeux de cybersécurité dans le monde d'aujourd'hui ....................... 8
2. Définition et fonctionnement des scanners de vulnérabilité ......................................... 9
3. Importance de l'interprétation correcte des résultats d’un scanner de vulnérabilités.. 9
4. Les limites des solutions intégrées de rapport ............................................................. 10
5. Environnement de Travail...................................................................................... 12
1. Télétravail ...................................................................................................................... 12
2. Méthodologie de travail ................................................................................................ 12
3. Infrastructure et ressources de l'entreprise ................................................................. 13
6. Missions Ponctuelles ............................................................................................. 15
7. Mission Principale : Présenter les résultats d'une solution d'évaluation des vulnérabilités
19
1. Point de départ .......................................................................................................... 19
Nessus : Présentation et Fonctionnement ....................................................................... 19
Z_Scan............................................................................................................................... 21
2. Restauration du projet Z_Scan .................................................................................. 27
3. Refonte graphique de l'interface de Z_vul_scan ....................................................... 35
Analyse de l’existant......................................................................................................... 35
Choix technologique ......................................................................................................... 37
Actions Réalisées .............................................................................................................. 38
4. Production de graphique avec Excel ......................................................................... 42
Remise en contexte .......................................................................................................... 42
Analyse de l’existant......................................................................................................... 42
Traiter les données de la Base de données vers Excel ..................................................... 44
Limitations : retour des données d'Excel à MongoDB ..................................................... 47
Pourquoi le script ne repose pas sur un modèle défini à l’avance .................................. 48
Utilisation combinée de xlsxwriter et openpyxl............................................................... 49
Indicateurs de performances clés à choisir ...................................................................... 50

3|Page
 5. Synthèse sur le projet Z_Scan .................................................................................... 57
6. Perspective et évolutions futures .............................................................................. 58
8. Conclusion ........................................................................................................... 59
9. Annexes............................................................................................................... 60
Introduction aux Annexes ................................................................................................ 60
Description des Annexes .................................................................................................. 60
10. Sitographie .......................................................................................................... 61
11. Fiche de Validation Entreprise................................................................................ 63

4|Page
 4. Contexte et motivation de la problématique

1. Introduction des enjeux de cybersécurité dans le monde

d'aujourd'hui

La cybersécurité est devenue un enjeu majeur dans le monde professionnel

d'aujourd'hui. Les organisations de toutes tailles et de tous secteurs dépendent de plus en
plus de systèmes informatiques pour leurs opérations quotidiennes et la gestion de leurs
données sensibles. Cette dépendance croissante aux technologies numériques a rendu les
entreprises plus vulnérables aux cyberattaques, qui peuvent causer des pertes financières
importantes, endommager la réputation et entraîner des violations de la vie privée des
clients et des employés.

Dans ce contexte, les entreprises doivent accorder une attention accrue à la protection
de leurs infrastructures et de leurs données, tout en restant conformes aux réglementations
en vigueur. Les responsables de la sécurité des systèmes d'information (RSSI) et les équipes
de Technologie de l'Information (IT) sont chargés de mettre en place des mesures de
sécurité efficaces pour prévenir et détecter les cybermenaces, tout en assurant la continuité
des opérations et la résilience face aux incidents.

Ces organisations peuvent également faire appel à des prestataires externes, tels que
Cyber Impact, pour effectuer des analyses de vulnérabilité et les aider à identifier et à
remédier aux faiblesses de leurs systèmes informatiques, réseaux et services, on parle alors
d’audit de cybersécurité externe.

Deux des étapes de cet audit consiste en la collecte de données concernant les hôtes,
systèmes, réseaux et applications de l'organisation cible puis en l’interprétation des résultats
en fonction des données recueillies.

Ces étapes peuvent être automatisé via un outil fréquemment utilisé lors d’audit de
cybersécurité : un scanner de vulnérabilité.

8|Page
 2. Définition et fonctionnement des scanners de vulnérabilité

Selon le National Institute of Standards and Technologyb, un scanner de vulnérabilité est

un outil (matériel et/ou logiciel) utilisé pour identifier les hôtes/attributs d'hôtes et les
vulnérabilités associées (CVE1, CWE2, et autres).

Il s'agit d'un logiciel qui scanne les actifs pour détecter les vulnérabilités connues et les
failles de sécurité qui pourraient être exploitées par des attaquants. Les résultats sont
ensuite analysés et présentés aux équipes de l’organisation pour qu'elles puissent prendre
des mesures pour corriger les problèmes détectés.

Le scanner de vulnérabilités réseau peut rechercher des ports ouverts, des services
vulnérables, des systèmes d'exploitation obsolètes ou mal configurés, des identifiants par
défaut, des certificats expirés et d'autres vulnérabilités potentielles.

Les résultats du scan de vulnérabilité réseau peuvent ensuite être utilisés pour identifier
les risques et prioriser les correctifs nécessaires pour renforcer la sécurité de l'entreprise.

3. Importance de l'interprétation correcte des résultats d’un

scanner de vulnérabilités

L'interprétation correcte des résultats issus des scanners de vulnérabilités est cruciale
pour plusieurs raisons :

Dans un premier temps, la priorisation des actions à mener à l’issue de l’audit : Les
rapports contiennent souvent un grand nombre de vulnérabilités identifiées, en particulier
dans un parc informatique d’entreprise qui peut contenir plusieurs milliers d’actifs. Il est
donc important de prioriser certaines mesures en fonction de leur criticité, de leur impact
potentiel et des ressources disponibles pour y remédier. Une interprétation adéquate des
résultats permet de concentrer les efforts sur les vulnérabilités les plus importantes et
d'optimiser l'utilisation des ressources.

Arrive ensuite la compréhension des risques : L'interprétation des résultats des scanners
de vulnérabilités permet également de mieux comprendre les risques encourus par
l'entreprise. Les rapports indiquant les vulnérabilités identifiées, leur impact business

1 : Common Vulnerabilities and Exposures, Vulnérabilités et expositions communes en français

2 : Common Weakness Enumeration, Énumération des faiblesses communes en français

9|Page
potentiel sur l'environnement informatique, et le niveau de risque associé, il est possible de
mieux comprendre les menaces potentielles auxquelles l'entreprise est exposée. Cela
permet également de mieux évaluer les risques, de prendre des mesures pour les réduire et
de mieux protéger l'infrastructure informatique de l'entreprise.

Toujours concernant l’interprétation des résultats, il me parait aussi essentiel de

rappeler que le risque est lié à la gravité d’une vulnérabilité mais également à la
vraisemblance de son exploitation. La vraisemblance est plus difficile à estimer de manière
automatique. Cela dépend de nombreux facteurs qui ne peuvent pas être facilement
quantifiés par un scanner, y compris le contexte spécifique de l'entreprise. Par exemple, une
entreprise qui stocke des données sensibles ou qui est une cible attractive pour les
cybercriminels pourrait être plus susceptible d'être attaquée que d'autres. De même,
certaines vulnérabilités pourraient être plus attrayantes pour les cybercriminels en fonction
de la facilité d'exploitation ou de la valeur des informations pouvant être obtenues.

En conclusion, l'interprétation correcte des résultats des scanners de vulnérabilités est

essentielle pour mieux comprendre les risques encourus par l'entreprise, prioriser les actions
à mener pour les corriger, et mieux communiquer à toutes les parties prenantes les
prochaines étapes à suivre pour améliorer la sécurité de l'entreprise.

4. Les limites des solutions intégrées de rapport

Plusieurs solutions de détection de vulnérabilité intègrent la génération automatique de

rapports de scan. Bien qu'utiles, ces derniers présentent plusieurs limites qui peuvent
entraver une interprétation correcte des résultats et l'exploitation des données pour le
business intelligence.

Dans un premier temps, on peut noter la technicité des rapports, les rapports intégrés
contiennent souvent des informations techniques complexes, qui peuvent être difficiles à
comprendre, particulièrement pour les non-spécialistes, rendant la communication des
résultats aux parties prenantes moins efficace.

On relèvera également un manque de personnalisation poussées, dans le cas de

Tenable Nessus (solution utilisée par Cyber Impact), les options de personnalisation de
rapport sont restreintes. Les rapports résumés peuvent omettre des informations
essentielles, telles que le port, le nom d'hôte ou les consignes pour corriger la vulnérabilité.
Les rapports détaillés, quant à eux, peuvent être trop verbeux, contenant plusieurs centaines
de pages pour une seule machine dans un réseau pouvant en contenir plusieurs milliers, la
prise de décision découlant de l’interprétation des résultats serait bien trop tardive.

10 | P a g e
 Il est cependant important d’indiquer que Tenable Nessus offre la possibilité
d'exporter des rapports dans d'autres formats plus adaptés au business intelligence, ces
formats peuvent être beaucoup moins lisibles, notamment pour les personnes non
techniques.

Il était donc nécessaire de développer une solution plus adaptée, afin de mieux exploiter
les résultats des scans de vulnérabilité. Cette solution pourrait inclure des outils de
visualisation de données, pour aider les parties prenantes à mieux comprendre les résultats
des scans. En outre, la solution devrait être conçue pour être plus conviviale, facilitant la
communication des résultats aux non-spécialistes de la sécurité informatique. En intégrant
ces fonctionnalités, les entreprises peuvent mieux tirer parti de leurs efforts de sécurité, en
réduisant la complexité et en améliorant leur efficacité à identifier et à corriger rapidement
les vulnérabilités critiques.

Extrait d’un rapport Nessus au format PDF concernant un réseau vulnérable avec 16 appareils réseaux actifs. 30
pages. Le rapport complet est disponible en tant que ressource externe à ce mémoire au format numérique.

Extrait du même rapport Nessus au format détaillé. 593 pages. Le rapport complet est disponible en tant
que ressource externe à ce mémoire au format numérique.

11 | P a g e
 5. Environnement de Travail

1. Télétravail

Mon stage a été effectué principalement en télétravail. Cela a constitué une expérience
enrichissante qui m'a permis de développer mon autonomie, ma discipline et ma capacité à
m'adapter à un environnement de travail numérique.

Bien qu'aucun horaire strict n'ait été imposé par l'entreprise, j'ai choisi d'établir un
planning de travail afin de maintenir des habitudes et assurer une productivité optimale.
Cela m'a aidé à séparer clairement le temps de travail et le temps personnel, ce qui est
crucial lorsqu'on travaille à domicile.

Malgré l'établissement d'un planning de travail régulier, j'ai également fait preuve de
flexibilité en fonction des exigences spécifiques de chaque tâche. Par exemple, si une
mission était proche de son achèvement, je prolongeais parfois ma journée de travail pour
l'achever, plutôt que de la reporter au lendemain. Cette flexibilité a été précieuse pour gérer
efficacement le flux de travail et atteindre les objectifs dans les délais.

Dans l'ensemble, mon expérience de télétravail pendant mon stage a été positive et
éducative. J'ai appris à gérer mon temps de manière efficace, à équilibrer les besoins du
travail avec ceux de ma vie personnelle et à être flexible en fonction des exigences de la
mission. J'ai aussi réalisé l'importance de la discipline personnelle et de la gestion du temps
dans le succès du travail à distance.

2. Méthodologie de travail

Le suivi de mon travail s'est principalement effectué au moyen de réunions

hebdomadaires avec mon tuteur de stage. Ces réunions étaient l'occasion de faire le point
sur l'évolution de ma mission principale, l'accomplissement des tâches ponctuelles
(détaillées ci-après) et l'identification et la résolution de problèmes éventuels. De plus, si des
difficultés apparaissaient pendant la réalisation des tâches, je les exprimais et les expliquais
durant ces réunions, ce qui permettait une rétroaction constructive et des ajustements en
temps réel.

J'ai bénéficié d'une grande autonomie quant à la réalisation de mes tâches, ce qui
incluait la priorisation des tâches ainsi que des méthodes à utiliser pour les accomplir. Cela

12 | P a g e
m'a permis de développer mes compétences en matière de prise de décisions et de gestion
du temps.

Néanmoins, il est important de noter que cette autonomie opérationnelle n'était pas
sans contraintes. En effet, certaines tâches nécessitaient le respect de certaines restrictions
techniques inhérentes au métier. Les choix technologiques effectués en amont par mon
tuteur pour ma mission principale conditionnaient mes méthodes de développement.
L’infrastructure réseau, système et les solutions logicielle déjà en place pour les missions
ponctuelles, déterminaient parfois la manière dont je devais mettre ne place de nouveaux
services.

Ces contraintes représentaient des défis stimulants et m'ont aidé à développer ma

capacité à naviguer efficacement dans un environnement technologique complexe.

Ma mission principale reposait en grande partie sur la compréhension des besoins du

client, qui était également mon tuteur de stage. Les réunions hebdomadaires étaient donc
cruciales pour clarifier ces besoins et réorienter le travail si nécessaire. Cela m'a permis
d'acquérir une précieuse expérience en matière d’attentes client.

Dans le cadre de ma mission, j'ai travaillé sur des projets de développement complexe
qui nécessitaient une gestion rigoureuse des versions. Pour ce faire, tous les
développements étaient versionnés sur un serveur local. De plus, lorsque j'effectuais des
missions d'administration système, je m'assurais de la sauvegarde des serveurs via des
snapshots après l'exécution des missions. Ces processus garantissaient la sécurité des
données et permettaient une traçabilité et une reproductibilité des travaux effectués.

Ces différentes pratiques ont permis un suivi régulier et efficace du travail, tout en
garantissant un haut niveau de qualité et de sécurité dans la réalisation de mes tâches.

3. Infrastructure et ressources de l'entreprise

L'infrastructure de Cyber Impact était entièrement virtualisée et sécurisée, permettant

ainsi un accès à distance simple et sûr. Cela a été particulièrement déterminant dans le
cadre de mon stage à distance, car j'avais besoin d'accéder à de nombreuses ressources et
de services.

Pour garantir un accès sécurisé à ces ressources, l'entreprise a mis en place un VPN
d’entreprise (Virtual Private Network, Réseau Privé Virtuel) pour garantir un accès sécurisé à
ses ressources.

13 | P a g e
 Les serveurs de l'entreprise étaient tous virtualisés grâce à un hyperviseur VMware
vSphere, basé sur l'infrastructure VMware ESXi. Cet hyperviseur était lui-même hébergé sur
un NAS (Network Attached Storage, Stockage en réseau), qui était protégé derrière un
firewall pour garantir la sécurité des données et des services.

L’entreprise possède aussi quelques services déployés sur cette infrastructure. On peut
notamment y trouver un annuaire Active Directory (AD), plusieurs serveurs web, un VPN, des
serveurs de stockage, ainsi que des machines dédiées au développement et aux tests. Ces
dernières m’ont été mise à disposition dans le cadre de mes missions.

Bien que Cyber Impact ne compte actuellement que deux employés, l'entreprise a décidé
de mettre en place un annuaire Active Directory, cela pourrait sembler superflu, cependant,
cette décision répond à un besoin pour des démonstrations pratiques. En effet, l'entreprise
envisage d'organiser des ateliers éducatifs pratiques pour les apprenants. L'AD jouera alors
un rôle crucial pour limiter les droits d'accès des apprenants à des aspects spécifiques du
système, assurant ainsi la sécurité des ressources sensibles de l'entreprise.

L'Active Directory est actuellement utilisée pour tester cet aspect de contrôle des droits
d'accès. Des environnements de test ont été mis en place, dans lesquels les droits d'accès
sont modifiés pour simuler les conditions réelles d'une session d'atelier. Ces tests
permettent de s'assurer que l'AD est correctement configuré et qu'il peut être déployé en
toute sécurité lors de la mise en place des ateliers.

En outre, même si Cyber Impact est actuellement une petite entreprise, l'AD offre des
avantages en matière de sécurité. Il centralise la gestion des droits d'accès, permettant ainsi
une surveillance efficace et une application rigoureuse des politiques de sécurité de
l'entreprise. Par exemple, l'AD peut être utilisé pour restreindre l'accès à certaines
ressources sensibles, même pour les employés de l'entreprise. Il facilite également la
traçabilité des actions des utilisateurs, un aspect clé de la gestion de la sécurité de
l'information.

Ainsi, malgré sa taille actuelle, Cyber Impact utilise l'Active Directory pour préparer son
expansion future et renforcer la sécurité de ses systèmes. Ce choix démontre une vision à
long terme et une compréhension claire de l'importance des bonnes pratiques en matière de
sécurité de l'information.

14 | P a g e
 6. Missions Ponctuelles

Un certain nombre de missions ponctuelles m’ont été confiés durant cette expérience
professionnelle. La plupart de ces missions s’avèrent être des tâches standards
d’administration système et réseaux, ce qui m’a permis de continuer à améliorer mes
compétences dans ces domaines.

Au-delà des savoirs-faires techniques, ces missions m’ont également enseigné à travailler
de manière rigoureuse et organisée, à savoir être à l’écoute des demandes et à respecter les
délais impartis pour les réalisations.

Au cours de mon stage, l'une de mes missions a été de mettre en place un serveur de
versionnage utilisant Git. Ce système ne m'était pas exclusivement destiné ; il servait
également à héberger les différentes versions des projets sur lesquels je travaillais. L'objectif
principal de cette mission était d'implémenter une infrastructure efficace pour le suivi des
modifications de code, afin de faciliter le travail collaboratif et la gestion des versions.

J'ai été en charge de la conception et de l'installation du serveur Git, ainsi que de la mise
en place de GitWeb, une interface web pour Git, afin d'améliorer la visibilité et la
compréhension des commits (action d'envoyer ses modifications locales vers le référentiel
central, dans le cadre de l’utilisation d’un logiciel de gestion de version) effectués.

Cependant, cette tâche n'a pas été sans défis. J'ai rencontré des difficultés pour faire
fonctionner correctement Git à travers le protocole HTTP. Les problèmes principaux étaient
liés à des erreurs de permission et d'authentification qui entravaient le bon fonctionnement
du système. Pour les surmonter, j'ai dû m'immerger dans la documentation de Git et dans
divers forums en ligne pour comprendre l'origine des problèmes et trouver une solution
appropriée. Cette recherche m'a permis d'ajuster la configuration du serveur et d'assurer le
bon fonctionnement de Git via HTTP.

Les résultats de cette mission ont été très positifs. Le serveur de versionnage a permis un
suivi efficace et ordonné des modifications du code, et l'utilisation de GitWeb a amélioré la
visibilité des commits pour tous les utilisateurs du serveur.

En rétrospective, la mise en place précoce de ce service a permis un suivi de code de ma

tâche principale de manière plus efficace, tout en permettant une gestion améliorée des
versions et un travail collaboratif optimal. Cette mission m'a également appris l'importance
d'une recherche approfondie pour résoudre des problèmes techniques et la nécessité de
travailler méthodiquement pour atteindre des objectifs clairs et précis.

15 | P a g e
 Suite à la mise en place du serveur de versionnage, une autre mission m'a été attribuée :
la création d'un schéma réseau et d'un plan d'adressage IP pour l'infrastructure actuelle,
ainsi que pour les nouvelles machines virtuelles que je générais progressivement. Cette
tâche a constitué un défi particulier en raison de la nature du stage, principalement effectué
en télétravail, et de l'absence d'accès physique aux machines.

En effet, devoir imaginer et comprendre l'infrastructure de machines distantes sans

pouvoir les voir ni les toucher a nécessité une approche réfléchie et méthodique. Une partie
importante de cette tâche a consisté en un « exercice de pensée » où je devais déduire la
configuration du réseau à partir de l'information limitée à laquelle j'avais accès.

Une fois mes hypothèses établies, je les vérifiais en consultant la configuration des
machines auxquelles j'avais accès. Pour les autres, j'ai dû recourir à des méthodes de
déduction indirectes et non standards pour estimer leur configuration et leur position dans
le réseau.

Ces déductions ont servi de base à la création du schéma réseau et du plan d'adressage
IP. Ainsi, le schéma réseau et le plan d'adressage IP que j'ai élaborés serviront donc à
informer ces apprenants de la topologie du réseau actuel. Cela leur permettra de
comprendre le fonctionnement de l'infrastructure et de mieux appréhender les défis liés à la
cybersécurité.

En effet, Cyber Impact a pour ambition de créer des environnements de test destinés à
l'apprentissage des étudiants. Dans le cadre de la diversification de son catalogue de
services, elle envisage à moyen/long terme de proposer des environnements pour mettre en
pratique des notions de cybersécurité, tels que l’administration de pare-feu ou la gestion des
risques et le renforcement de configuration.

Cette mission a non seulement renforcé mes compétences en réseau et en gestion

d'infrastructures virtuelles, mais elle m'a aussi appris à travailler de manière autonome et à
faire preuve de créativité face à des défis uniques. J'ai compris l'importance de la
documentation précise et à jour dans un environnement d'apprentissage, mais aussi la
valeur de la pensée déductive dans la résolution de problèmes techniques.

Après avoir réussi à créer le schéma réseau et le plan d'adressage IP, et toujours en
parallèle de ma mission principale exposée ci-après, une autre mission m'a été confiée,
toujours en matière de préparation au e-learning. Le but était d'installer Moodle sur une
nouvelle machine virtuelle, pour continuer de servir l'objectif éducatif de Cyber Impact.

16 | P a g e
 Pour rappel, Moodle est une plateforme d'apprentissage en ligne open source largement
utilisée dans l'éducation. Elle permet de créer des cours en ligne personnalisés, de gérer les
inscriptions des étudiants et de suivre leurs progrès.

La mise en place de Moodle a présenté plusieurs défis. Tout d'abord, j'ai constaté que la
documentation officielle de Moodle n'était pas à jour en ce qui concerne ses dépendances.
Bien qu'elle les indiquait, certaines dépendances mentionnées n'étaient plus à jour. Pour
résoudre ce problème, j'ai dû consulter les publications des développeurs pour trouver les
dépendances correctes et à jour. Cela a nécessité de la recherche et de la patience, mais n'a
pas représenté un obstacle majeur, car c’est une gêne relativement répandue en ce qui
concerne l’installation de ce genre de service.

Cependant, un autre défi s'est avéré plus difficile à surmonter. L'idée était que les élèves
puissent accéder aux modules d'apprentissage sur Moodle via des comptes, comptes qui
pourraient être créés par Active Directory, une fonctionnalité que Moodle sait gérer puisque
ce service sait interroger un annuaire LDAP3. Cependant, cela impliquait que la machine soit
jointe au domaine de l'entreprise. Pour des raisons encore inconnues, il n'a jamais été
possible de joindre le domaine avec cette machine (ou une autre), ce qui a constitué une
véritable frustration. Il est cependant à noter que qu’il existe d’autre machines linux sur le
domaine mais que des problèmes de synchronisation ont également été constaté.

Malgré ces défis, la mise en place de Moodle a été une expérience précieuse. Elle m'a
permis de développer mes compétences en administration de systèmes et de gérer des
problèmes inattendus. Elle m'a également rappelé l'importance de la persévérance et de la
recherche active de solutions lorsque la documentation officielle est insuffisante ou erronée.

La dernière tâche ponctuelle qui m'a été confiée au cours de mon stage était un projet
assez ambitieux de synchronisation de fichiers entre une machine Ubuntu et une machine
Windows. L'objectif était de créer un script, tant en PowerShell pour Windows qu'en Shell
pour Linux, pour synchroniser un certain type de fichiers - des fichiers Excel dans notre cas -
de manière bidirectionnelle, en se basant sur la date de modification du fichier. Pour rendre
le processus plus réactif et efficace, le script devait également inclure des événements
d'écoute qui déclencheraient la synchronisation dès qu'un fichier était modifié.

Malheureusement, très peu de ressources étaient disponibles pour servir de base de

travail à ce projet. De plus, bon nombre d'entre elles s'appuyaient sur des dépendances
comme rsync, ce qui n'était pas idéal pour notre cas d'utilisation.

3Lightweight Directory Access Protocol, un protocole permettant l'interrogation et la

modification des services d'annuaire

17 | P a g e
 J'ai décidé d'imposer une contrainte supplémentaire à moi-même : ne pas utiliser rsyncc
et utiliser un système de gestion d'événements. Cependant, après avoir exploré différentes
approches, il est devenu évident que la gestion d'événements de fichiers était une tâche
complexe. Nous avons donc finalement opté pour l'utilisation de rsync de manière
périodique avec Crond sur Linux et le planificateur de tâches sous Windows.

Même si je n'ai pas pu réaliser le projet tel que je l'avais initialement envisagé, cette
mission m'a appris à être flexible dans ma façon de résoudre les problèmes et à être réaliste
dans l'établissement de mes objectifs. J'ai également compris l'importance de la recherche
et de l'exploration des ressources disponibles, même si elles semblent insuffisantes ou non
idéales au premier abord.

Finalement, ce projet de synchronisation de fichiers a été une excellente occasion

d'appliquer et de développer mes compétences en « Scriptinge » et en administration de
systèmes. Cette tâche a été effectué en parallèle de ma mission principale, qui impliquera la
gestion de fichiers Excel.

18 | P a g e
 7. Mission Principale : Présenter les résultats d'une solution
d'évaluation des vulnérabilités

1. Point de départ

Il me parait essentiel de commencer cette partie en explicitant quel a été mon point de
départ et les ressources à ma disposition car cela conditionne beaucoup les tâches, les
raisonnements et les choix qui vont être décrit dans la suite de ce mémoire. Commençons
par le scanner Nessus, qui a motivé cette problématique

Nessus : Présentation et Fonctionnement

Nessus est un outil très réputé dans le domaine de la sécurité informatique, utilisé
pour la détection des vulnérabilités dans le cadre de tests d'intrusion ou d'audits de
sécurité. Développé par Tenable Network Security, Nessus offre une gamme exhaustive
de fonctions qui le distingue des autres outils similaires sur le marché.

Fonctionnant principalement comme un scanner de vulnérabilités, Nessus utilise une

base de données actualisée régulièrement qui comprend des informations sur des
milliers de vulnérabilités potentielles que l'on pourrait retrouver dans différents
systèmes et applications. L'outil effectue des scans approfondis pour détecter ces
vulnérabilités et fournit ensuite des rapports détaillés sur ses découvertes.

19 | P a g e
 Vue principale du scanner Nessus et des possibilités offertes par le produit

Il me parait important de rappeler que Nessus n'est pas simplement un outil de

découverte de services ; il est conçu pour aller bien au-delà en fournissant une analyse
détaillée des vulnérabilités. Alors qu'un scan de découverte de service pourrait
simplement identifier des services potentiellement vulnérables, Nessus effectue une
analyse plus approfondie pour identifier les vulnérabilités spécifiques qui pourraient être
exploitées.

Au sein de Cyber Impact, Nessus joue un rôle central dans le service d'analyse de
vulnérabilités que nous proposons. Ce service est conçu pour aider nos clients à
comprendre et à gérer les risques potentiels liés à la cybersécurité dans leurs systèmes
informatiques.

L'utilisation de Nessus nous permet de fournir des évaluations détaillées et précises

des vulnérabilités, aidant ainsi nos clients à identifier les faiblesses potentielles dans
leurs systèmes et à prendre des mesures proactives pour les corriger. C'est dans ce
contexte que la nécessité d'améliorer la présentation et la compréhension des rapports
de Nessus est apparue.

Face à la complexité des rapports générés par Nessus, notre objectif était d'optimiser
la communication des résultats à nos clients, en mettant en avant les informations les
plus pertinentes et en rendant les rapports plus accessibles et compréhensibles.

20 | P a g e
 En travaillant sur la version « Essentials » de Nessus, nous avons développé une
approche qui, bien que limitée en termes d'échelle, nous a permis de tester et
d'implémenter des solutions qui ont amélioré l'efficacité et la clarté des rapports de
Cyber Impact. Ce travail a renforcé la valeur du service que nous offrons à nos clients et a
contribué à notre objectif d'amélioration continue de la qualité de notre service.

Bien que Nessus soit un outil puissant pour l'analyse des vulnérabilités, l'un des défis
que nous avons rencontrés dans notre utilisation de l'outil concerne ses rapports. Les
rapports détaillés de Nessus peuvent être extrêmement longs et complexes, ce qui rend
difficile pour les utilisateurs de distinguer rapidement et facilement les informations les
plus pertinentes. À l'inverse, les rapports résumés sont souvent trop courts et peuvent
omettre des informations importantes.

Une des lacunes spécifiques que nous avons identifiées concerne l'absence
d'information sur le nombre de machines sur lesquelles un scan authentifié a été
effectué, d’autres lacunes seront traitées lors du développement. Cette information est
cruciale pour évaluer l'étendue de la couverture de notre analyse de vulnérabilités, ainsi
que pour identifier les domaines potentiels où des efforts supplémentaires pourraient
être nécessaires pour garantir l'authentification.

Lors de cette mission, nous avons cherché à trouver un équilibre entre le niveau de
détail et la lisibilité des rapports de Nessus. Nous avons travaillé à la création d'un
système qui compile les données les plus pertinentes des rapports détaillés de Nessus,
tout en présentant ces informations de manière claire et concise. L’objectif était de
fournir aux utilisateurs une vue d'ensemble précise et compréhensible des vulnérabilités
détectées, tout en mettant en évidence les informations clés qui peuvent être manquées
dans les rapports standard de Nessus.

Z_Scan

Dans le contexte de ma mission, un autre outil clé qui a joué un rôle central est
Z_vuln_scan, souvent abrégé en Z_Scan. Il s'agit d'un programme interne sans nom
commercial, conçu comme une application web.

Z_Scan est un outil ancien, conçu en Python 2.7. Python, comme on le sait, est un
langage de programmation hautement flexible et polyvalent, utilisé dans une multitude
de domaines, de la conception de sites web à l'analyse de données. Cependant, Python
2.7 est une version plus ancienne du langage (à l’heure où j’écris ces lignes la dernière
version de Python sortie et la 3.11 et la version 3.12 en est au stade de beta), qui a
officiellement cessé d'être supportée en 2020.

21 | P a g e
 D'après les informations disponibles dans le code lui-même, notamment les
commentaires laissés par les développeurs, le développement de Z_Scan aurait débuté
au minimum en 2009. Cela indique que le programme a une histoire assez longue, ce qui
explique en partie pourquoi il est basé sur des technologies plus anciennes comme
Python 2.7.

Les commentaires datés dans le code suggèrent un développement actif et continu

de l'outil entre 2009 et 2014. Cette période de cinq ans indique un investissement
significatif en termes de temps et de ressources dans la construction de Z_Scan. C'est
probablement pendant cette période que la majorité des fonctionnalités clés ont été
mises en place et que l'architecture globale de l'outil a été définie.

Toutefois, il est à noter que les traces les plus récentes du développement, avant
mon arrivée, datent de 2014. Cela pourrait signifier que le développement de Z_Scan a
ralenti passée cette date, une information qui sera confirmé par mon tuteur.

L'outil en lui-même a été construit en utilisant le frameworkg Pyramid. Pyramid est un

framework de développement web en Python, connu pour sa flexibilité et sa facilité
d'extension. Il est particulièrement adapté pour développer des applications web de
grande taille et complexe, ce qui laisse à penser que Z_Scan a été conçu dès le départ
pour être un outil robuste et capable de gérer une grande quantité de données.

Le moteur de templates utilisé dans Z_Scan est Chameleon. Ce moteur de templates

permet de générer du HTML dynamique à partir des données, ce qui est essentiel pour
une application web comme Z_Scan qui a besoin de présenter les données de manière
compréhensible pour l'utilisateur.

Pour le stockage des données, Z_Scan utilise une base de données MongoDB en
backend. MongoDB est une base de données NoSQL4 populaire qui peut gérer de grands
volumes de données et qui est connue pour sa flexibilité, sa scalabilité et ses
performances. Cela semble un choix tout à fait approprié en particulier si on doit gérer
des rapports à des milliers de machines. C’est ici que nous allons retrouver les données
clés des rapports de scanners de vulnérabilités qui serviront dans la suite de cette
mission.

Le but originel de Z_Scan était d'améliorer la présentation des rapports de projets

Nessus.

4Not Only Structured Query Language, désigne les différents types de bases de
données non relationnelles

22 | P a g e
 Capture d’écran de la page d’accueil avant refonte graphique

Il est important de souligner que cet outil a été conçu avant tout pour une utilisation
interne. Mon tuteur de stage est l'utilisateur principal de Z_Scan, exploitant ses
fonctionnalités pour faciliter la gestion des rapports Nessus. Néanmoins, l'utilisation de
Z_Scan ne se limite pas uniquement à cette perspective interne.

Un aspect intéressant de Z_Scan est son potentiel d'utilisation dans une interaction
client. Par exemple, Z_Scan peut être utilisé pour soutenir des démonstrations pour les
clients de Cyber Impact, mettant en évidence ses capacités de traitement et de présentation
des résultats Nessus. Cela pourrait être particulièrement utile lors de la présentation des
compétences et des services offerts par Cyber Impact en termes d'évaluation des
vulnérabilités.

Qui plus est, Z_Scan peut également servir de support précieux lors des retours
clients après un scan de leur infrastructure. Il peut aider à expliquer de manière plus claire et
compréhensible les résultats du scan, ce qui peut faciliter la compréhension par le client des
vulnérabilités identifiées et des mesures à prendre pour y remédier.

Les fonctionnalités proposées par Z_Scan présentent des améliorations notables par
rapport à celles intégrées dans Nessus, notamment en termes de flexibilité et de contrôle de
l'utilisateur sur la présentation des résultats du scan.

Tout d'abord, la manière dont Z_Scan gère le tri des résultats de scans est
particulièrement remarquable. Contrairement à Nessus, qui nécessite que l'utilisateur
détermine le mode de tri avant la génération du rapport et ne permet pas de modifier ce
choix par la suite, Z_Scan offre une flexibilité bien plus grande.

23 | P a g e
 Possibilités de tri offertes par Nessus lors de la génération de rapport d’un scan

Il permet en effet de passer d'une vue à une autre via un simple clic dans le menu.
Cela permet à l'utilisateur de passer facilement d'une classification par vulnérabilité à une
classification par actif réseau ou par découverte, sans avoir à générer plusieurs rapports et à
naviguer entre différents documents PDF. Cette capacité d'adapter rapidement la
présentation des résultats aux besoins du moment représente un gain de temps significatif
et améliore l'efficacité de l'analyse et facilite la prise de décision.

De plus, Z_Scan offre également une plus grande finesse dans le contrôle des détails
à afficher. Par exemple, l'outil permet d'afficher les détails de résolution d'une vulnérabilité
spécifique, au lieu de devoir afficher les détails pour toutes les vulnérabilités détectées,
comme c'est le cas avec Nessus. Cela facilite le focus sur une vulnérabilité particulière qui
pourrait nécessiter une attention immédiate ou une analyse plus approfondie.

24 | P a g e
Focus sur l’unique vulnérabilité de la signature SMB non requise, les autres vulnérabilités sont présentées de manière
plus succincte.

Cette fonctionnalité permet de simplifier le processus de résolution des vulnérabilités

en rendant les informations pertinentes plus accessibles et en évitant d'encombrer
l'interface avec des détails inutiles.

Z_Scan donne la possibilité d'exclure les faux positifs des rapports, ce qui permet
d'éliminer les alertes non pertinentes et de se concentrer sur les véritables vulnérabilités. De
plus, l'outil permet également d'indiquer la raison de l'exclusion de ces faux positifs,
ajoutant une couche supplémentaire de contexte et de clarté à l'analyse.

De plus, Z_Scan offre la possibilité d'ajouter des commentaires aux résultats, ce qui
permet d'apporter des précisions ou des observations spécifiques sur une vulnérabilité
donnée. C'est une fonctionnalité qui facilite grandement la collaboration et la
communication autour des résultats du scan.

L'une des fonctionnalités les plus significatives de Z_Scan est sa capacité à assurer le
suivi des corrections de vulnérabilités. Il permet de faire une séparation entre les mises à

25 | P a g e
jour (patchable) et les vulnérabilités non patchable, fournissant ainsi une vision claire et
actualisée de l'état de sécurité de l'infrastructure. Cette interactivité est un avantage majeur
par rapport à un rapport statique en PDF, qui ne peut pas être mis à jour pour refléter les
changements dans l'état des vulnérabilités.

En outre, l’application offre la possibilité d'afficher sur quelles machines un scan

authentifié a été effectué. Un scan authentifié, contrairement à un scan non authentifié, est
un scan qui est réalisé avec des identifiants valides sur le système cible. Cela permet
d'accéder à plus d'informations et de détecter davantage de vulnérabilités potentielles. Le
fait de pouvoir identifier les machines qui ont fait l'objet d'un scan authentifié aide à donner
un aperçu plus précis de la portée et de la profondeur de l'évaluation de la sécurité. Cette
notion de scan authentifié est importante et sera réemployée plus tard dans ce mémoire.

Ces fonctionnalités contribuent à faire de Z_Scan un outil efficace pour la gestion et

le suivi des évaluations de vulnérabilités, facilitant grandement le processus d'analyse et de
résolution des problèmes de sécurité.

Malgré ses nombreuses forces, Z_Scan présente aussi des faiblesses notables qui ont
une incidence sur son utilisation et son efficacité. L'une d'elles est son interface utilisateur,
qui a vieilli avec le temps. Si cette faiblesse peut sembler mineure lorsqu'elle est utilisée
exclusivement en interne, elle devient plus problématique lorsque l'outil est présenté à des
clients. En effet, une interface démodée peut donner une impression négative et rendre
l'outil moins attrayant, quelles que soient ses capacités fonctionnelles.

La mise en lumière de ces points me permet de faire le lien avec la problématique de

ce mémoire : "Comment présenter de façon claire les résultats d’une solution d’évaluation
des vulnérabilités ?". Un aspect essentiel de cette question est la présentation visuelle des
résultats. Il est prévu que Z_Scan présente des indicateurs sous forme de graphiques, mais le
développement de cette fonctionnalité a été interrompu. Il s'agit d'une opportunité
manquée, car les graphiques peuvent grandement faciliter la prise de décision, que ce soit
pour un client profane ou un professionnel cherchant à synthétiser rapidement les
informations clés.

Dans le domaine de l'informatique décisionnelle, on reconnaît l'importance des

visualisations de données pour simplifier la compréhension des informations complexes et
aider à identifier les tendances et les schémas. Les graphiques sont particulièrement utiles
pour les personnes non familiarisées avec la cybersécurité, car ils peuvent rendre les
résultats d'un scan de vulnérabilité plus accessibles et faciles à comprendre.

Il est donc crucial d'améliorer l'interface de Z_Scan et de développer des

fonctionnalités de visualisation pour répondre efficacement à la problématique. En prenant

26 | P a g e
en compte ces faiblesses et en travaillant à les surmonter, nous pouvons améliorer la clarté
et l'efficacité de la présentation des résultats de l'évaluation des vulnérabilités.

2. Restauration du projet Z_Scan

Comme dit précédemment, je suis parti d’une base de travail déjà existante et assez
conséquente. Et, toujours comme dit lors de mes premières impressions, le développement
est relativement ancien.

La restauration d'un projet logiciel après une interruption de plusieurs années est un
processus qui oblige à un certain nombre d’exigences et qui présente à la fois des défis
techniques et intellectuels. La première étape de ce processus et d’abord et avant tout de
comprendre et d'interpréter l'ensemble du code existant.

Il est important de souligner que comprendre un code existant est une tâche à part
entière, qui va bien au-delà de la maîtrise du langage de programmation utilisé. En effet,
même si j'ai une bonne affinité avec le langage Python, la compréhension du code de Z_Scan
a nécessité de saisir non seulement les détails techniques, mais aussi l'intention et la logique
derrière chaque fonctionnalité.

Cela a impliqué de comprendre la volonté des développeurs d'origine - en

l'occurrence, mon tuteur et son ancien mentor - des années après la fin du développement
initial. C'est une tâche difficile, car il est nécessaire de reconstruire le contexte dans lequel le
code a été écrit, de comprendre les problèmes qu'il était destiné à résoudre et de saisir la
logique sous-jacente aux choix de conception.

Il est à rappeler que le projet est entièrement tourné vers le domaine de la

cybersécurité, ce qui oblige à une compréhension - au minimum - partielle des enjeux liés au
domaine, ainsi que, par exemple, du vocabulaire spécifique qui a pu être employé en
commentaires. Cela permet aussi de comprendre certains choix qui ont été fait dans le
développement concernant la création de certaines fonctionnalités.

La restauration de Z_Scan a également mis en évidence l'existence d'une dette

technique significative. Le concept de dette technique décrit la situation dans laquelle un
choix de conception ou d'implémentation à court terme a des conséquences à long terme
qui compliquent la maintenance ou l'évolution du projet. Dans le cas de Z_Scan, cette dette
se manifeste de plusieurs manières.

Dans un premier temps, il y a de nombreux blocs de code commentés dans

l'application. Ces blocs de code peuvent être des restes d'anciennes fonctionnalités qui ont

27 | P a g e
été abandonnées, ou des tentatives de résolution de problèmes qui n'ont pas abouti. Quelle
que soit leur origine, ils ajoutent du bruit au code et peuvent rendre sa lecture et sa
compréhension plus difficiles.

Deuxièmement, le projet contient des scripts en plusieurs versions. Cela peut être le
signe d'un manque de contrôle des versions ou d'une mauvaise gestion des mises à jour du
code. Cela peut également rendre le code plus difficile à maintenir, car il n'est pas toujours
clair quelle version du script doit être utilisée, ni quelles sont les différences entre les
versions.

Troisièmement, il semble que le projet ne suit pas la structure standard d'un projet
Pyramid.

├───bin
│ ├───json2excel
│ │ └───handlers
│ └───python
├───gimp
│ └───2.0
│ ├───environ
│ ├───interpreters
│ ├───modules
│ ├───plug-ins
│ └───python
├───imgs
├───jquery
│ ├───css
│ ├───development-bundle
│ │ ├───demos
│ │ │ ├───accordion

. . . .
. . . .
. . . .
. . . .
. . . .

│ │ │ ├───tooltip
│ │ │ │ ├───ajax
│ │ │ │ └───images
│ │ │ └───widget
│ │ ├───docs
│ │ ├───external
│ │ ├───themes
│ │ │ ├───base
│ │ │ └───flick
│ │ └───ui
│ │ ├───i18n
│ │ └───minified

28 | P a g e
│ │ └───i18n
│ └───js
├───modules
│ └───templates
├───python
├───static
├───templates
└───webfonts
Structure du projet (tronqué), les cas de doublons de dossiers avérés ont été colorisés

Par exemple, il y a deux dossiers pour les templates, et les deux semblent
nécessaires. Cela peut rendre le code plus difficile à naviguer et à comprendre, surtout pour
quelqu'un qui s'attendrait à une structure de projet standard.

Structure par défaut d’un projet utilisant le framework Pyramid h

Tous ces facteurs contribuent à augmenter la complexité du code et à rendre sa

maintenance plus difficile. Cela souligne l'importance de bonnes pratiques de
développement, comme le respect des structures de projet standard, le contrôle des
versions et la suppression du code inutile ou obsolète.

Il est indéniable que la résolution de la dette technique de Z_Scan est une étape
significative pour la restauration et l'amélioration du logiciel. Cependant, il est important de

29 | P a g e
souligner que, compte tenu des contraintes de temps inhérentes à la nature de mon stage, il
a fallu faire des choix quant à l'orientation des efforts de développement.

Dans le contexte de ces contraintes, j'ai travaillé à réduire la dette technique du

projet autant que possible. Cependant, certains aspects, comme le cas du doublon de
dossiers de templates, n'ont pas pu être pleinement abordés. Le choix a été fait de
privilégier des améliorations plus visibles et directement liées à la problématique du
mémoire : la refonte graphique de l'interface utilisateur et la production de graphiques à
partir des données de scan.

Ces priorités ont été définies en tenant compte de l'impact potentiel sur la clarté de
la présentation des résultats d'évaluation des vulnérabilités.

Dans l’idéal, la réduction de la dette technique est un processus continu qui, devrait
être intégré dans le cycle de vie du développement logiciel. Alors que la phase de mon stage
se termine, j'espère que le travail que j'ai réalisé posera les bases pour des améliorations
futures de Z_Scan, y compris la résolution des problèmes techniques restants.

La restauration de Z_Scan a présenté d'autres défis importants, parmi lesquels la

corruption de certains fichiers et la nécessité de réinstaller les dépendances, certaines ayant
même disparu au fil des ans.

La corruption de fichiers a été une difficulté majeure, car elle a nécessité la recherche
de copies de certains scripts. Dans certains cas, ces copies pourraient ne pas avoir été mises
à jour aussi récemment que le reste du projet, ajoutant une autre couche de complexité à la
restauration du logiciel.

Quant aux dépendances, il a fallu naviguer dans un paysage de packages qui a

considérablement évolué depuis le développement initial de Z_Scan. Un exemple
particulièrement significatif est celui de "urllib2", un package Python qui a été séparé en
plusieurs packages avec l'arrivée de Python 3. Cela signifie que "urllib2" n'est plus disponible
sur le dépôt de packages standard de Pythoni, ce qui a nécessité la réinstallation de la
dépendance à partir de source tierce.

En effet, Z_Scan reste actuellement compatible uniquement avec Python 2.7. Cette
situation implique certaines difficultés, notamment le risque de sécurité associé à
l'utilisation de dépendances obsolètes et non mises à jour. Avec la fin du support officiel
pour Python 2 en janvier 2020, les problèmes de sécurité ne sont plus corrigés, ce qui peut
exposer le projet à des vulnérabilités potentielles.

30 | P a g e
 À titre personnel, j'aurais souhaité mettre à jour Z_Scan pour une version plus
récente de Python. Cependant, cette tâche aurait été une entreprise considérable. La
migration vers Python 3 aurait exigé non seulement la mise à jour du code de base, mais
aussi la recherche de dépendances équivalentes pour celles qui n'ont pas fait la transition
vers Python 3.

Dans certains cas, je pense même qu’il aurait été nécessaire de porter manuellement
certaines dépendances à une version plus moderne de Python, ce qui aurait nécessité un
temps considérable au vu du projet.

Il parait évident qu'un tel effort de modernisation aurait dépassé la portée de ce

stage. Ça en a même jamais été un objectif. Cependant, je pense que c'est un aspect
important à prendre en compte pour le futur développement de Z_Scan. Assurer la
compatibilité avec les versions actuelles de Python et de ses dépendances serait une étape
importante pour améliorer la sécurité, la fiabilité et la maintenabilité du logiciel.

Au-delà de cet avis personnel et du projet écrit en Python, abordons maintenant un

autre aspect crucial de la restauration du projet Z_Scan : la gestion de la base de données.
Comme mentionné précédemment, l’application est fortement dépendante des données
issues des rapports Nessus. Ces données sont essentielles pour alimenter le programme et
pour lui permettre d'accomplir sa mission principale : la présentation claire et efficace des
résultats d'évaluation des vulnérabilités.

La première étape de ce processus a été la mise en place d'un cluster MongoDB sur
deux machines. MongoDB est une base de données orientée documents, idéale pour gérer
des données structurées de manière flexible, comme c'est le cas avec les rapports Nessus. Le
fait d'avoir un cluster sur deux machines assure la résilience des données : si une machine
tombe en panne, l'autre peut continuer à servir les données, garantissant ainsi une
disponibilité continue du service.

Une fois ce cluster en place et après avoir établi un lien entre l’application et la base
de données, il était nécessaire d'obtenir un rapport Nessus concret pour alimenter la base
de données et donc d’alimenter Z_Scan. En effet, impossible de restaurer correctement un
projet autant lié à des données si la base de données qui l’alimente est vide. Pour cela, il
fallait des données probantes, c'est-à-dire des données représentatives de ce que Z_Scan
aurait à traiter dans un contexte réel.

En effet, il n'aurait pas été approprié d'utiliser les données des clients de Cyber
Impact en raison de leur caractère sensible et de ma position de stagiaire au sein de
l'entreprise.

31 | P a g e
 Afin de respecter les considérations de confidentialité et de sécurité des données, sur
une idée de mon tuteur, il fut décidé d'utiliser Metasploitable2, une distribution Linux
spécialement conçue pour être vulnérable. Metasploitable2 est un outil largement utilisé
dans le domaine de la cybersécurité pour l'apprentissage et la formation. Elle est
délibérément emplie de failles de sécurité pour permettre aux apprenants de tester leurs
compétences en matière de détection et d'exploitation des vulnérabilités.

Une autre solution aurait été d’utiliser scanme.nmap.org, un site est dédié au test
des capacités de Nmap, une suite de logiciels libres de scan de ports bien connue, et à
l'apprentissage de son utilisation. En effet, l'équipe de Nmap permet aux utilisateurs
d'effectuer des scans sur ce domaine pour leur permettre de pratiquer sans risquer de violer
la loi.

Une fois la distribution virtuelle en place sur un hyperviseur, j'ai pu lancer un scan
Nessus sur ce réseau où je savais qu’il y avait au moins un terminal réseau complètement
vulnérable de bien des façons, produisant ainsi un rapport riche en données. Ces datas, bien
que générées dans un environnement contrôlé, étaient représentatives de ce que Z_Scan
pourrait avoir à traiter dans un contexte réel.

Cette approche a permis de tester Z_Scan avec des données réalistes tout en
respectant les contraintes de confidentialité et de sécurité. Par ailleurs, elle a permis de
valider le fonctionnement de l'application avec des données récentes, un aspect essentiel de
la restauration du projet.

Il y a cependant une différence notable concernant le point précédent, en effet,

Nessus permet de faire des audits de conformité et plus des scans de vulnérabilités plus
classique, un aspect qui est géré par Z_Scan. Or cette option d’audit de conformité n’est pas
disponible avec la version « Essentials » de Nessus, il parait donc compliqué d’assurer la
bonne restauration de cette fonctionnalité même si la structure de base de Z_Scan a été
correctement configurée et validée.

L'audit de conformité est une fonctionnalité importante pour toute entreprise qui a
besoin de respecter certaines normes de sécurité, comme ISO 27001, PCI DSS, HIPAA, etc.
C'est un outil précieux pour vérifier si l'entreprise respecte ces normes et pour identifier les
domaines où des améliorations peuvent être nécessaires.

32 | P a g e
 Liste des scans de conformités proposés par Nessus, tous ces scans demande une mise à jour
vers une offre payante

Nessus Professional, la version payante de Nessus, propose cette fonctionnalité

d'audit de conformité. Il offre des modèles prédéfinis pour un certain nombre de normes de
conformité différentes et peut automatiquement vérifier si votre système répond à ces
exigences.

En l'absence de cette fonctionnalité, il pourrait être plus difficile de vérifier si la

restauration de Z_Scan est complète et correcte. Sans la capacité d'exécuter des audits de
conformité, vous ne pourrez pas tester cette fonctionnalité dans Z_Scan.

La première étape essentielle de la restauration du projet a été la remise en marche

du script d'importation des données. Sans cela, toutes les autres fonctionnalités de Z_Scan
seraient restées inaccessibles, faute de données à traiter. Cet outil, qui se lance via la ligne
de commande, est conçu pour importer les rapports Nessus au format XML directement
dans la base de données MongoDB.

Heureusement, malgré les années qui se sont écoulées, la structure des rapports
exportés par Nessus n'a que très peu changé. Mis à part quelques ajustements mineurs, la
restauration du script d'importation des données n'a pas présenté de difficulté majeure.
Cette stabilité du format de sortie de Nessus a été un avantage certain pour la restauration
du projet.

33 | P a g e
 Il peut sembler surprenant que Z_Scan, une application web Pyramid, repose sur des
scripts à exécuter en ligne de commande, mais cela s'inscrit en réalité dans la logique du
projet. En effet, Z_Scan offre la possibilité de planifier des tâches à l'avance via un
planificateur ou de les exécuter directement via l'interface web, l’une de ces tâches est
FILLMONGODB, dont le nom est relativement explicite sur sa finalité.

Planificateur de tâche de l’application Z_vuln_scan

C'est d'ailleurs dans ce cadre que j'ai développé une nouvelle tâche destinée à
produire des graphiques à partir des données importées, en utilisant Excel. Mais j'aborderai
ce point dans la partie dédiée.

J’ai adopté une approche méthodique pour restaurer le projet Z_Scan. Conscient de
la complexité du projet et des multiples problèmes potentiels que je pourrais rencontrer, j'ai
opté pour une approche systématique, traitant chaque route une à une. Dans le contexte du
framework Pyramid, une route représente un chemin d'accès spécifique dans l'application.

Chaque route a été analysée et testée individuellement. À chaque fois qu'une erreur
survenait, j'analysais et corrigeais le problème avant de passer à la route suivante. Cette
approche m'a permis de garantir la stabilité de chaque partie de l'application avant de
passer à la suivante.

34 | P a g e
 La plupart des erreurs rencontrées étaient liées à des changements dans les
dépendances ou à la structure hiérarchique des dossiers du projet. Le temps et l'attention
que j'ai accordés à ces problèmes ont été essentiels pour assurer le succès de la restauration
du projet.

Cette approche m'a non seulement permis de restaurer avec succès le projet Z_Scan,
mais elle m'a aussi donné une compréhension approfondie de l'architecture du projet et de
ses dépendances, ce qui me serait particulièrement utile pour la suite des missions en lien
avec ce projet de développement.

3. Refonte graphique de l'interface de Z_vul_scan

Suite à l'analyse de l'existant, il est apparu clairement que l'interface utilisateur de

Z_Scan avait besoin d'être repensée et améliorée. Il convient déjà de répertorier les
principales faiblesses détectées ainsi que des propositions d'amélioration, toujours dans la
perspective de présenter de manière claire et accessible les résultats d'une solution
d'évaluation des vulnérabilités.

Analyse de l’existant

Une faiblesse notable de l'interface de Z_Scan est la densité d'information. Les

utilisateurs sont confrontés à une grande quantité d'informations en un seul coup d'œil, ce
qui peut être accablant et rendre difficile la localisation d'informations spécifiques. Il parait
essentiel d’aérer la présentation de ces résultats.

De plus, toutes les informations sont présentées de la même manière, qu'elles soient
cruciales ou secondaires, c’est ce qu’on appelle la hiérarchisation visuelle des informations,
ce qui peut prêter à confusion pour l'utilisateur, surtout s'il est novice dans le domaine de la
cybersécurité. Par exemple, la présentation des vulnérabilités pourrait être mieux
hiérarchisée, en donnant plus de visibilité aux vulnérabilités les plus critiques, par le biais, de
couleurs ou d'icônes. Il est à noter que cette hiérarchisation n’est pas complètement
inexistante, mais relativement peu marquée, ce qui est contre-productif. De la même façon
et en lien de ce qui vient d’être dit, le manque de délimitation claire entre deux
vulnérabilités provoque la aussi des difficultés de lecture des informations :

35 | P a g e
 Manque de délimitation des vulnérabilités d’un même terminal réseau, phénomène particulièrement visible en ce qui
concerne les solutions à apporter pour boucher une vulnérabilité.

Une troisième faiblesse de l'interface de Z_Scan réside dans son manque de

cohérence globale. En effet, la présentation des informations varie grandement d'une page à
l'autre, rendant l'interface moins intuitive qu'elle ne pourrait l'être. Afin d'améliorer cette
cohérence, il serait judicieux d'adopter des modèles de conception cohérents et des palettes
de couleurs uniformes à travers toutes les pages de l'application.

Bien que la présentation de résultats d'évaluation de vulnérabilités sous forme de

listes ou de tableaux soit fonctionnelle et visuelle, elle manque de vivacité et de lisibilité,
notamment pour un public non spécialiste. Les graphiques sont un moyen efficace de
présenter des données complexes de manière simple et intuitive.

Le manque de graphiques dans Z_Scan (un aspect prévu à l’origine du

développement est mis à l’arrêt en même temps que le reste du projet) est donc un aspect à
prendre en considération pour améliorer la clarté et l'efficacité de la présentation des
résultats. Cependant, il est important de noter que ce point est abordé de manière
spécifique dans une autre partie du mémoire, dans le cadre de la production de graphiques
sous Excel.

36 | P a g e
 L'utilisation d'icônes est un moyen efficace de guider l'utilisateur et de faciliter la
navigation. Cependant, dans le cas de Z_Scan, les icônes utilisées ne semblent pas toujours
intuitives ou cohérentes. Par exemple, une même icône peut apparaître plusieurs fois sur
une même page pour une utilisation différente, ce qui peut être source de confusion. De
plus, certaines icônes ne correspondent pas à l'action réelle réalisée en cliquant sur elles.
Cette incohérence est un obstacle à l'efficacité et à l'intuitivité de l'interface, et doit donc
être adressée lors de la refonte.

Malgré les faiblesses citées, il me parait nécessaire d’en replacer certaines dans le
contexte du développement initiale du projet, Z_Scan a été développé à une époque où les
pratiques et attentes en matière de conception d'interfaces étaient différentes. De plus, la
quantité d'informations que les utilisateurs sont prêts et capables de traiter a également
évolué.

Aujourd'hui, l'importance de l'expérience utilisateur (UX) est reconnue et privilégiée

dans la conception de tout produit numérique. Les utilisateurs apprécient les interfaces
claires et simplifiées qui leur permettent de comprendre facilement les informations
présentées et de naviguer intuitivement.

Cela dit, il est important de souligner que l'interface de Z_Scan a été conçue à une
époque où cette densité d'information était bien plus la norme. À l'époque, les interfaces
graphiques étaient souvent chargées d'informations et d'options pour donner à l'utilisateur
le contrôle total sur les fonctionnalités du logiciel. Cependant, avec l'évolution de la
technologie et des attentes des utilisateurs, cette approche est devenue obsolète.

C'est donc dans ce contexte que nous devons envisager la refonte de l'interface de
Z_Scan. L'objectif sera de réduire la densité d'information par écran pour se rapprocher des
standards visuels actuels, tout en conservant la richesse des fonctionnalités de l'outil.
L'objectif est de rendre l'outil plus accessible et compréhensible pour une plus large gamme
d'utilisateurs, y compris ceux qui ne sont pas nécessairement experts en cybersécurité. Cette
démarche s'inscrit parfaitement dans le cadre de notre problématique, qui est de présenter
de façon claire les résultats d'une solution d'évaluation des vulnérabilités.

Choix technologique

Face aux faiblesses identifiées lors de l'analyse de l'interface graphique de Z_Scan, le

choix d'un framework CSS5 approprié était essentiel pour assurer une cohérence visuelle

5
Cascading Style Sheets, feuille de style en cascade et français

37 | P a g e
globale. J'ai opté pour Bulma CSS, un framework CSS basé sur Flexboxj. Ce choix repose sur
plusieurs facteurs clés.

Premièrement, Bulma est hautement personnalisable et modulaire, ce qui permet

une grande flexibilité lors de la conception. Cela a permis de s'adapter précisément aux
besoins spécifiques de l'interface utilisateur de Z_Scan, tout en assurant une cohérence
visuelle sur l'ensemble du projet.

Deuxièmement, Bulma est connu pour sa simplicité et sa facilité d'utilisation. Cela a

permis de gagner du temps lors de la phase de développement et d'accélérer le processus de
refonte.

De plus, Bulma est responsive, cela veut dire que Bulma optimise votre site internet
en fonction de la taille du support sur lequel il est affiché. Il est tout à fait possible, qu’à
terme, Z_Scan puisse être consulter sur divers appareils.

Enfin, Bulma a une communauté active qui offre un soutien constant et de

nombreuses ressources, ce qui est un avantage précieux en termes de résolution de
problèmes et de recherche de solutions innovantes.

Concernant la gestion des icônes, la librairie Font Awesome a été choisie pour sa
grande variété d'icônes disponibles, sa reconnaissance dans le domaine du web et le fait
qu’il puisse être utilisé de façon homogène avec Bulma. Cette librairie est largement utilisée,
et de nombreux utilisateurs sont déjà familiers avec ses icônes, ce qui renforce l'intuitivité de
l'interface.

En somme, le choix de Bulma CSS et Font Awesome s'est avéré judicieux pour
adresser les problèmes identifiés dans l'interface de Z_Scan, contribuant ainsi à la clarté et à
la lisibilité des résultats de l'évaluation des vulnérabilités.

Actions Réalisées

Suite à l'analyse de l'interface actuelle et à la sélection des outils technologiques, j'ai

entrepris une série d'actions concrètes pour améliorer la présentation des résultats de
l'évaluation des vulnérabilités dans l'interface de Z_Scan.

38 | P a g e
 Premièrement, j'ai introduit un nouveau schéma de couleurs plus contrasté pour
améliorer la hiérarchisation visuelle de l'information. Cela a permis de mettre en avant les
informations les plus importantes et de faciliter leur repérage par l'utilisateur.

Vue globale des différents patchs avant refonte graphique

Vue globale des différents patchs après refonte graphique

39 | P a g e
 Deuxièmement, j'ai cherché à épurer et espacer les éléments de l'interface afin de
réduire la densité d'information. L'interface originale avait tendance à surcharger l'utilisateur
avec un grand nombre d'informations présentées simultanément. En introduisant un design
plus minimaliste et en espaçant plus largement les éléments, j'ai pu rendre l'interface plus
lisible et moins intimidante pour l'utilisateur.

Capture d’écran globale d’une des pages les plus chargée en information, le classement des patchs par terminal réseau, avant refonte graphique

40 | P a g e
Capture d’écran globale d’une des pages les plus chargée en information, le classement des patchs par terminal réseau, après refonte graphique

Troisièmement, j'ai entrepris de revoir l'utilisation des icônes dans l'interface. J'ai
remplacé les icônes peu intuitives ou incohérentes par des icônes Font Awesome plus
appropriées, en accord avec l'action réalisée. Cela a permis d'améliorer la cohérence globale
de l'interface et de la rendre plus intuitive pour l'utilisateur.

Evolution des icônes utilisées concernant une vulnérabilité, dans l’ordre, classer la vulnérabilité en « patchée,
l’ajouter à un groupe, ajouter un commentaire, exclure la vulnérabilité (pour une autre raison qu’un patch et signalé
comme faux-positif

41 | P a g e
 En évaluant l'interface de Z_Scan, un aspect s'est avéré efficace et a été conservé : la
présentation des données sous forme de tableau. Ce choix initial avait été fait par deux
professionnels de la cybersécurité, une expertise qui a orienté leur décision vers une
présentation structurée et pertinente des données.

Les tableaux permettent une visualisation claire et ordonnée des informations. Ils
facilitent le tri et le filtrage des données selon différents critères pertinents, tels que la
criticité d'une vulnérabilité ou la classification par appareil. Cette présentation soutient la
mission de Z_Scan qui est de fournir une évaluation claire et compréhensible des
vulnérabilités.

Malgré la refonte graphique, cette méthode de présentation des données a donc été
préservée. Le travail effectué s'est concentré principalement sur l'amélioration des éléments
visuels, en augmentant la lisibilité et l'intuitivité de l'interface, tout en maintenant la
structure effective existante pour la présentation des données.

Cette approche illustre l'importance d'une analyse approfondie de l'interface

utilisateur avant d'entreprendre une refonte. Il est crucial de comprendre non seulement ce
qui doit être amélioré, mais aussi ce qui fonctionne déjà bien et doit être préservé. Ce
principe a guidé la refonte de l'interface utilisateur de Z_Scan, visant à améliorer
l'expérience utilisateur tout en conservant les éléments efficaces de la conception originale.

4. Production de graphique avec Excel

Remise en contexte

En cybersécurité, l'analyse précise des résultats issus de scans de vulnérabilités est

cruciale pour établir des plans d'action efficaces. Face à l'immensité des données obtenues,
il est nécessaire de les présenter de manière lisible et concise. La solution Z_Scan, bien que
performante, nécessitait un outil supplémentaire pour optimiser la visualisation des données
et extraire des statistiques lisibles dans format plus convivial. C'est dans ce contexte que
s'inscrit la dernière partie de mon projet chez Cyber Impact : la création d'un outil de
visualisation de données basé sur Excel.

Analyse de l’existant

Avant mon implication dans le projet Z_Scan, une tentative de visualisation des
données de vulnérabilités avait été entreprise en utilisant GNUplot, un outil connu pour sa
flexibilité et sa capacité à générer des graphiques à partir de données scientifiques.

42 | P a g e
Cependant, l'intégration de GNUplot au sein du framework Pyramid s'est avérée
problématique, notamment sur la production d’image à partir des données. De nombreuses
difficultés ont été rencontrées, ce qui a conduit à une impasse technique. De plus, GNUplot,
bien que puissant, souffrait de certaines limitations, notamment en termes de
personnalisation visuelle.

GNUplot est un programme en ligne de commande qui génère des graphiques 2D et

3D à partir de données qui peuvent être lues à partir d'un fichier texte, générées par un
autre programme, ou entrées manuellement. GNUplot est capable de générer une grande
variété de types de graphiques et peut sortir les graphiques dans de nombreux formats, y
compris PNG, PostScript et PDF.

À titre personnel, j'ai une appréciation favorable de la combinaison

dataframe/pandas, matplotlib et GNUplot pour le traitement et la visualisation de données.
Cette approche technique est largement reconnue et utilisée dans le domaine du traitement
des données et dans le milieu scientifique. Cependant, la maîtrise de ces trois bibliothèques
Python peut être considérée comme une compétence spécialisée, rendant le
développement et la maintenance plus difficile pour un non-spécialiste.

Pour rappel : Pandas est une bibliothèque logicielle écrite pour le langage de
programmation Python qui fournit des structures de données et des fonctions d'analyse de
données de haute performance et faciles à utiliser. Elle est basée sur la notion de
"Dataframe", qui est essentiellement une table de données bidimensionnelle où chaque
colonne peut contenir des données d'un certain type (numérique, string, etc.).

Matplotlib est une bibliothèque de traçage 2D en Python qui produit des figures de
qualité dans une variété de formats et de milieux interactifs. Matplotlib peut être utilisée
dans des scripts Python, le terminal Python et IPythonk, des applications web, et divers outils
d'interface utilisateur graphique (GUI) en Python.

Dans le contexte du projet Z_Scan, il était essentiel de choisir une solution qui serait
non seulement puissante et flexible, mais aussi accessible pour une variété d'utilisateurs, y
compris ceux qui n'ont pas d'expertise approfondie en programmation ou en manipulation
de données. En tenant compte de ces facteurs, ainsi que de l'impasse technique rencontrée
avec GNUplot, la décision a été prise de passer à une solution plus courante et familière :
Excel. Ce choix a été guidé par la volonté d'offrir une solution de visualisation de données
qui serait à la fois facile à utiliser et à maintenir.

43 | P a g e
 Traiter les données de la Base de données vers Excel

Pour le transfert des données entre la base MongoDB et Excel, j'ai développé un
script Python. Ce script peut être exécuté à partir du gestionnaire de tâches de Z_Scan décrit
plus haut, et a été conçu pour être indépendant du système d'exploitation sur lequel Z_Scan
est déployé. Actuellement, Z_Scan est déployé sur une distribution Ubuntu, bien qu'il soit
possible de le faire fonctionner sur d'autres systèmes tels que Windows.

Le transfert des données s'effectue par l'intermédiaire des bibliothèques Python

openpyxl et xlsxwriter, qui permettent de lire, écrire et modifier des fichiers Excel
directement. Ce choix évite le recours à un pilote ODBC (Open Database Connectivity), qui
est un standard permettant de connecter une application à une base de données. En effet,
l'utilisation d'un pilote ODBC pour MongoDB aurait introduit une dépendance
supplémentaire non disponible sur Linux, et aurait nécessité d'avoir Excel installé sur la
même machine que le gestionnaire de base de données, ce qui n'est pas souhaitable dans
notre contexte.

En utilisant openpyxl et xlsxwriter, le script Python extrait les données de la base

MongoDB, puis les structure et les écrit dans un fichier Excel, tout cela de manière
automatisée. Cette approche permet une plus grande flexibilité et évite les erreurs
manuelles potentielles lors du transfert des données. De plus, le fichier Excel généré peut
être utilisé dans différents contextes et sur différentes plateformes, augmentant ainsi la
portabilité des données.

Lors de la création du script d'extraction des données, j'ai donc utilisé deux
bibliothèques Python spécifiques : openpyxl et xlsxwriter. Openpyxl est une bibliothèque
Python utilisée pour lire/écrire des fichiers Excel xlsx/xlsm/xltx/xltm. Elle offre une interface
très complète et intuitive pour la gestion des données Excel. D'autre part, xlsxwriter est une
bibliothèque Python qui peut être utilisée pour écrire des fichiers texte, des nombres, des
formules et des hyperliens dans des fichiers Excel 2010 xlsx en utilisant plusieurs types de
formatage.
L'une des difficultés rencontrées lors de l'écriture du script a été la désérialisationl et
l’aplatissementm des données. Les données stockées dans MongoDB sont sous forme de
documents JSON6, qui peuvent contenir des structures de données complexes, y compris des
listes et des dictionnaires imbriqués. Pour les rendre exploitables dans Excel, une étape de
désérialisation était nécessaire. Cela implique la conversion des structures de données JSON
de MongoDB en structures de données Python, puis la restructuration de ces données pour
qu'elles puissent être écrites dans un fichier Excel. Le défi ici était de rendre le code

6JavaScript Object Notation, un format de données textuel dérivé de la notation des

objets du langage JavaScript

44 | P a g e
universel et hautement tolérant, pour pouvoir gérer tous les types de données possibles, y
compris ceux qui pourraient apparaître dans la version payante de Nessus.

Extrait d’une donnée JSON dans la base de données MongoDB de Z_Scan, des dictionnaires sont imbriqués dans une liste

Gestion des structures imbriquées dans Python, Obligeant à de nombreuses boucles imbriquées

45 | P a g e
 Une fois les données de la base MongoDB correctement récupérées et aplaties, j'ai
fait le choix d'utiliser un DataFrame pour simplifier l'exportation vers Excel. Un DataFrame,
provenant de la bibliothèque Pandas, est une structure de données bidimensionnelle, c'est-
à-dire une table, où chaque colonne peut contenir des données d'un type différent
(nombres, chaines de caractères, etc.). Les DataFrame sont particulièrement adaptés pour le
traitement de grandes quantités de données et pour l'exportation de ces données dans
divers formats, dont Excel.

Toutefois, j'ai été conscient des difficultés que peuvent présenter les DataFrame pour
les personnes non familières avec la bibliothèque Pandas. C'est pourquoi j'ai veillé à ce que
leur utilisation reste sommaire et transparente pour les autres développeurs du projet. Le
DataFrame est uniquement utilisé dans le script d'exportation, comme une étape
intermédiaire avant la création du fichier Excel. Ainsi, les autres parties du projet, y compris
le script de récupération et d'aplatissage des données, n'ont pas besoin de gérer des
DataFrame, ce qui facilite la maintenance et l'évolutivité du projet.

La conception et le développement du script ont donc nécessité une compréhension

approfondie non seulement des données et de leur structure, mais aussi des spécificités des
bibliothèques Python utilisées et de la manière dont les données peuvent être écrites dans
un fichier Excel. Malgré la complexité de la tâche, la flexibilité offerte par Python et les
bibliothèques choisies a permis de surmonter ces défis et de créer un script robuste et
universel capable d'extraire et de structurer les données pour une utilisation ultérieure dans
Excel.

Pour améliorer l'utilisabilité du fichier Excel généré, il a été demandé par mon tuteur
que les données puissent être triées selon n'importe quel critère. C'est une fonctionnalité
très appréciée dans l'analyse de données car elle permet d'organiser et de filtrer les
informations rapidement en fonction des besoins spécifiques de l'utilisateur. Pour mettre en
œuvre cette demande, j'ai utilisé la fonctionnalité d'AutoFiltre d'Excel.

46 | P a g e
 La méthode AutoFiltre a été ajoutée à chaque en-tête de chaque feuille Excel
produite par le script. Ainsi, les utilisateurs peuvent facilement trier et filtrer les informations
contenues dans les feuilles en fonction de leurs besoins. Par exemple, ils peuvent choisir de
voir uniquement les vulnérabilités d'une certaine criticité, ou de filtrer les données pour
n'afficher que les informations concernant un appareil spécifique. Cette fonctionnalité a
grandement amélioré la maniabilité du fichier Excel et a permis une analyse plus précise et
flexible des données.

Extrait du fichier de sortie Excel après exécution du script, l’ensemble des données sont triable par colonne, ici par port

Limitations : retour des données d'Excel à MongoDB

J'ai initialement envisagé d'implémenter une fonctionnalité permettant de renvoyer

les données modifiées dans Excel vers la base de données MongoDB. Le processus aurait en
théorie été le miroir de l'exportation : prendre les données aplaties d'Excel, reconstruire la
structure originelle de MongoDB et réinjecter les données dans la base si le fichier avait été
modifié. Cependant, ce processus s'est avéré plus complexe en pratique en raison de
l'aplatissement des données.

47 | P a g e
 En effet, l'aplatissement des données, bien que nécessaire pour leur exploitation
dans Excel, provoque une perte d'information concernant la structure originelle des
données. Il est certes possible de reconstruire cette structure, mais cela suppose de
connaître à l'avance les données pour lesquelles il faut réaugmenter la dimensionnalité. Cela
irait à l'encontre du principe de tolérance à la variété des données que j'ai cherché à
instaurer pour ce script. De plus, cela poserait problème pour la fonctionnalité de
conformité, dont la structure m'est inconnue.

Face à ces contraintes et ces incertitudes, il a été décidé de ne pas renvoyer les
données modifiées dans Excel vers MongoDB. Cette décision a été prise en accord avec les
principes de maintenabilité et de tolérance aux variétés de données que j'ai cherché à
instaurer pour ce script. Cependant, cela reste une limitation que j'ai identifiée et qui
pourrait faire l'objet de développements futurs pour améliorer encore l'outil.

Pourquoi le script ne repose pas sur un modèle défini à l’avance

L'une des principales raisons pour lesquelles Excel a été choisi comme outil d'analyse
des données est sa capacité à générer facilement des graphiques à partir des données.
Cependant, la construction de ces graphiques n'a pas été sans défis.

Un choix délibéré a été fait pour éviter l'utilisation d'un modèle Excel préconstruit
pour générer ces graphiques. Bien qu'il existe une multitude de modèles disponibles qui
peuvent faciliter la création de graphiques, ceux-ci présentent certains inconvénients. En
particulier, ils sont souvent très spécifiques et rigides, ce qui signifie qu'ils peuvent être très
peu tolérants aux erreurs ou aux changements dans les données.

Dans le contexte de ce projet, les rapports Nessus peuvent changer au fil du temps,
avec de nouvelles vulnérabilités découvertes et des modifications apportées à la façon dont
elles sont signalées. Si nous avions choisi d'utiliser un modèle préconstruit, chaque fois qu'un
changement de ce type se produirait, nous devrions probablement mettre à jour ou ajuster
le modèle pour s'adapter à ces changements. Cela entraînerait une maintenance
supplémentaire qui n'est pas souhaitable. (Sans compter qu’un modèle personnalisé est
difficile à créer si la fonctionnalité d’audit de conformité ne peut pas être prise en compte.)

De plus, l'utilisation d'un modèle spécifique au projet augmente également le risque

qu'un problème avec le modèle entraîne des problèmes avec l'ensemble du projet. En
choisissant de construire les graphiques de manière programmée, nous avons plus de
contrôle sur leur création et nous pouvons nous assurer qu'ils s'adaptent aux données
disponibles.

48 | P a g e
 Utilisation combinée de xlsxwriter et openpyxl

Lors de la construction de graphiques Excel dans ce projet, vous l’aurez peut-être

noté, deux bibliothèques Python ont été utilisées en parallèle : xlsxwriter et openpyxl. Bien
que cela puisse sembler contre-intuitif d'utiliser deux bibliothèques similaires, c'est en fait le
résultat de limitations distinctes de chaque bibliothèque.

Xlsxwriter est une bibliothèque Python qui permet de créer des fichiers Excel .xlsx en
écriture seule. Elle offre un contrôle précis sur l'aspect final du document Excel et permet
l'intégration de scripts VBA compilés, utiles pour la mise en place de macros automatisées.
Cependant, cette bibliothèque ne permet pas la lecture ou la modification de fichiers Excel
existants. Il est donc impossible d’obtenir des champs calculés pour faire un graphique (un
aspect qui sera traité ci-après).

De son côté, openpyxl est une bibliothèque Python qui permet de lire, écrire et
modifier des fichiers Excel .xlsx. Elle a été utilisée dans ce projet pour sa capacité à
manipuler des documents Excel existants, notamment pour la mise en forme des données.
Toutefois, cette bibliothèque a une limitation majeure : elle ne supporte pas l'utilisation de
macros.

De manière générale, aucune des deux bibliothèques ne gère réellement les macros
(l’une permet d’ajouter une version compilée, mais cela s’arrête là, celles-ci sont pourtant
nécessaires pour obtenir de l’interactivité avec les graphiques, pour changer le filtre sur des
données du graphique par exemple).

Par conséquent, l'utilisation combinée de ces deux bibliothèques a permis de tirer

parti de leurs forces respectives tout en contournant partiellement leurs limitations.
Xlsxwriter a été utilisé pour générer le squelette du document Excel et intégrer les macros
nécessaires, puis openpyxl a été utilisé pour peupler le document avec les données et
effectuer la mise en forme nécessaire.

Un élément important dans la réalisation de ce projet a été l'utilisation de macros

VBA (Visual Basic for Applications). Contrairement à une maquette préétablie, un code VBA
bien écrit peut s'adapter aux variations dans la structure ou le contenu des données, offrant
ainsi une certaine tolérance aux erreurs.

La création des macros a été effectuée directement dans Excel, en utilisant le mode
développeur de Visual Basic. Une fois les macros VBA créées et compilées, elles ont été
extraites du fichier Excel en exploitant le fait qu'un fichier Excel est en réalité un fichier
compressé au format zip. La macro compilée a ensuite été intégrée dans le document Excel
généré par le script Python en utilisant la bibliothèque xlsxwriter.

49 | P a g e
 Il est important de souligner qu'il n'y a pas d'autre moyen que de préparer les macros
VBA à l'avance. Cependant, contrairement à une maquette figée, un code VBA bien écrit
offre une flexibilité et une tolérance aux variations dans les données.

Code VBA pour mettre à jour le graphique si le filtre change, l’évènement est lié à la case du filtre, filtre qui n’existe
pas si les données nécessaires au graphique n’existent pas, la tolérance des erreurs peut donc être jugé acceptable

En parallèle à ces macros qui offrent une interactivité au document, Python a

continué d'être utilisé pour créer de nouvelles feuilles avec des champs calculés. C'est cette
fonctionnalité qui a permis la production de graphiques, sujet que nous aborderons dans la
section suivante.
Indicateurs de performances clés à choisir

Lors de l'élaboration de l'outil Excel, une étape clé a été la sélection des données à
mettre en avant sous forme de graphiques. En effet, la visualisation des données joue un
rôle crucial dans l'analyse des rapports de vulnérabilité, en facilitant la compréhension et
l'interprétation des données.

Le choix des données à représenter graphiquement s'est inspiré des tentatives

précédentes de création de graphiques présentes dans le code fourni. Bien que ce code
n'était pas fonctionnel, il a été conçu par des professionnels ayant une connaissance

50 | P a g e
approfondie des indicateurs de performance clés (abrégé KPI, pour Key Performance
Indicators) pertinents dans le domaine de la cybersécurité.

Un indicateur de performance clé est une mesure quantifiable utilisée pour évaluer le
succès d'une organisation, d'un employé, etc., dans la réalisation des objectifs. Dans notre
contexte, les KPI peuvent inclure des mesures telles que le nombre total, le nombre de
vulnérabilités par niveau de gravité, le taux de scan identifié etc.

En m'inspirant des KPI identifiés dans les tentatives précédentes de création de

graphiques, j'ai pu sélectionner les données les plus pertinentes à mettre en avant sous
forme de graphiques. La compréhension des tentatives de création de graphique
précédentes oblige à une bonne compréhension des intentions de mes prédécesseurs.

L’un des avantages majeurs d'utiliser Excel pour créer des graphiques est sa capacité
à produire des visualisations interactives. Cette interactivité est possible grâce à l'utilisation
de macros VBA (Visual Basic for Applications), qui sont des ensembles d'instructions
permettant de manipuler les fonctionnalités d'Excel.

Ainsi, l'ajout de cette interactivité a été une priorité dans le développement des
graphiques pour le projet Z_Scan. En plus d'améliorer l'expérience utilisateur, ces
fonctionnalités interactives permettent une analyse plus approfondie des données, car elles
offrent aux utilisateurs la possibilité d'explorer les données de manière dynamique et
personnalisée. Ce qui est une bonne approche pour tenter de répondre à la problématique
de ce mémoire.

La création de graphiques dynamiques dans Excel requiert une approche différente

de celle utilisée pour générer des images statiques avec GNUplot. Cela implique
généralement la refonte de nombreuses fonctions existantes et l'écriture de nouvelles pour
gérer les spécificités d'Excel.

L'une des spécificités d'Excel est la capacité à créer des champs calculés, soit
directement via des formules Excel, soit via des scripts Python lorsque les formules Excel ne
sont pas suffisantes. Les champs calculés sont des valeurs dérivées de données existantes,
généralement utilisées pour effectuer des analyses plus complexes ou pour produire des
résumés de données. Par exemple, un champ calculé peut représenter le pourcentage de
vulnérabilités critiques par rapport au nombre total de vulnérabilités, ou le nombre de
vulnérabilités par appareil.

51 | P a g e
 Dans la toute première tentative de produire un graphique simple, de sorte à prendre
parfaitement en main les bibliothèques utilisés pour cette tâche, j’ai tenté de produire le
taux d’appareil sur lesquels nous avions effectué un scan identifié, une donnée importante
déjà évoqué lors de ce mémoire car un scan authentifié permet de détecter des
vulnérabilités qui ne serait pas visible depuis un simple scan extérieur. Un pourcentage trop
bas dans le cadre d’un audit d’une infrastructure d’entreprise pourrait motiver à un scan
plus complet avec de nouveaux identifiants pour les actifs :

Tout premier graphique produit, un simple taux de scan authentifié.

52 | P a g e
 Code correspondant à la création du graphique sur le taux de scan identifié.

Dans certains cas, il peut être nécessaire de créer de nouvelles feuilles dans le
classeur Excel pour stocker ces champs calculés. Cela peut être utile pour organiser les
données et faciliter leur manipulation. De plus, ces nouvelles feuilles peuvent également
servir de base pour la création de graphiques dynamiques, en utilisant les champs calculés
comme source de données.

L'objectif ici est d'exploiter les fonctionnalités avancées d'Excel pour présenter les
données de manière plus intuitive et significative, tout en offrant aux utilisateurs la flexibilité
d'explorer et d'interagir avec les données à leur guise.

Excel a la capacité de fournir des fonctionnalités interactives, tels que les filtres de
données ou les validations de données (Data Validation). Ces dernières sont des outils
intégrés à Excel qui permettent de contrôler le type de données ou les valeurs qui peuvent
être entrées dans une cellule.

Dans le cadre de ce projet, les validations de données ont été utilisées pour créer des
menus déroulants. Ces menus déroulants sont liés à des cellules spécifiques dont les
résultats sont calculés, ce qui permet de sélectionner dynamiquement la ligne de données à
utiliser pour produire un graphique.

53 | P a g e
 Par exemple, un menu déroulant pourrait être utilisé pour choisir un critère
spécifique (ci-après l’adresse IP d’un appareil) à partir duquel un graphique serait généré.
Cette approche facilite l'analyse des données et permet une interaction plus directe et plus
flexible avec les données.

Comptage des vulnérabilités par gravité, filtré par adresse IP

Les validations de données ont été mises en place après la création des cellules
calculées pour assurer une interaction fluide et une fonctionnalité correcte. L'utilisation
conjointe des validations de données et des cellules calculées a permis de maximiser les
fonctionnalités d'Excel, rendant le rapport final plus intuitif et facile à utiliser pour les
professionnels de la cybersécurité.

L’instauration des menu déroulant servant de filtre est également un moyen de

contourner une limitation d’Excel le nombre de données que l’on peut mettre dans un
graphique. En effet, une série de données pour un graphique est limité à 255, ce qui limite
les possibilités de graphique à produire. Atteindre 255 adresses IP scannées grâce à Nessus
sur un réseau d’entreprise est très probable. Au-delà même de cette limitation, la lisibilité
d’un graphique avec autant d’information est purement inconcevable.

54 | P a g e
 Erreur obtenue en cas de trop nombreuse données
sélectionnées pour un graphique

Ces validations de données sont, en parallèle, lié à une macro qui gère les
évènements, en cas de modification de la valeur de la cellule, le graphique se met à jour
avec la nouvelle valeur saisie dans la cellule. Une manière de fonctionner très proche de ce
qui serait réalisé en JavaScript/HTML sur une page web.

La gestion des données dans un environnement non relationnel comme MongoDB

présente ses propres défis, particulièrement lorsqu'il est nécessaire d'établir des liens entre
différentes entités de données. Un des défis majeurs que j'ai rencontrés pendant le
développement de ce script était le fait d'établir une forme de relation entre plusieurs tables
ayant un champ commun.

MongoDB est une base de données NoSQL puissante avec plusieurs avantages, mais
contrairement à une base de données relationnelle SQL, elle n'a pas de schéma relationnel
inhérent. Cette particularité a ajouté une couche de complexité à la tâche de produire des
graphiques qui nécessitent le croisement de plusieurs tables. En fait, dans un contexte où les
liaisons entre les tables ne sont pas directement supportées par le système de gestion de la
base de données, j'ai dû trouver une solution alternative pour créer ces relations.

Voici un extrait de code qui illustre la solution que j'ai mise en œuvre pour relever ce
défi :

55 | P a g e
 Extrait de code permettant la création des cellules calculés du graphique plus haut

Dans ce code, j'ai créé deux dictionnaires pour gérer les relations entre les données
de vulnérabilités (vuln_dict, le dictionnaire des vulnérabilités) et les données de scans
(ip_dict, le dictionnaire des adresses IP). Le dictionnaire vuln_dict a été créé avec l'ID comme
clé et le score CVSS3 comme valeur, tandis que ip_dict utilise l'adresse IP comme clé et
stocke une liste de scores CVSS3 comme valeur.

Le tableau final a été produit en comptant le nombre de scores CVSS3 dans chaque
catégorie pour chaque adresse IP. Malgré la flexibilité de MongoDB, cette approche a
nécessité une manipulation de données en mémoire avec Python, qui peut être gourmande
en ressources pour de grands ensembles de données.

En somme, malgré les défis rencontrés, cette expérience a renforcé ma capacité à

travailler avec des bases de données NoSQL et à créer des solutions efficaces pour gérer des
données de manière ingénieuse.

56 | P a g e
 5. Synthèse sur le projet Z_Scan

Le parcours que j'ai entrepris avec le projet Z_Scan a été un voyage stimulant, rempli
de défis techniques et de nouvelles compétences acquises. L'objectif principal était de
restaurer, d'améliorer et de fournir une présentation améliorée des résultats d'une solution
d'évaluation des vulnérabilités. Ce périple a commencé par une exploration approfondie de
l’existant avec Z_Scan, et l’apprentissage de l’utilisation d’un scanner de vulnérabilités :
Nessus, tout cela suivie par une restauration du projet Z_Scan.

J'ai d'abord dû comprendre les complexités de Nessus et Z_Scan, deux systèmes

puissants qui se combinent pour fournir une évaluation détaillée des vulnérabilités du
réseau. Z_Scan, un projet mis en suspens, a nécessité une attention particulière pour
remettre le système en fonctionnement. La restauration du projet a impliqué une série de
tâches complexes allant de l’erreur de programmation à la réduction de la dette technique.

Après la restauration réussie de Z_Scan, j'ai entrepris de repenser l'interface

graphique de Z_vul_scan. Cette tâche a nécessité une analyse minutieuse de l'existant, un
choix technologique réfléchi et plusieurs actions précises pour réaliser la refonte graphique.
J'ai dû m'appuyer sur mes compétences en développement et design pour améliorer
l'esthétique et l'ergonomie de l'interface, ce qui a abouti à une application plus conviviale et
visuellement agréable.

Ensuite, l'accent a été mis sur la production de graphiques avec Excel. Ce travail a
commencé par la prise en compte du contexte, la réalisation d'une analyse de l'existant et le
traitement des données de la base de données vers Excel. J'ai dû surmonter plusieurs défis,
notamment les limitations inhérentes à la rétroaction des données d'Excel à MongoDB, la
nécessité d'une grande tolérance aux erreurs et les contraintes liées à l'utilisation combinée
de xlsxwriter et openpyxl.

Le choix des indicateurs de performances clés à représenter sous forme de

graphiques a été déterminé par une analyse méditée des données disponibles, ce qui a
permis de fournir des informations précieuses pour la prise de décisions.

Tout au long de cette mission, j'ai dû faire preuve de flexibilité et d'ingéniosité pour
surmonter les difficultés techniques et les limites des outils existants. J'ai acquis une
compréhension approfondie des systèmes d'évaluation des vulnérabilités et de la manière
dont ils peuvent être utilisés pour renforcer la sécurité d'un réseau. De plus, j'ai pu constater
l'importance d'une présentation visuelle efficace des données pour aider les responsables à
prendre des décisions éclairées.

En conclusion, malgré les défis, ce voyage a été une opportunité précieuse

d'apprendre et de grandir en tant que développeur. Les compétences et l'expérience
acquises tout au long de ce projet seront inestimables pour mes futurs engagements dans le
domaine de la cybersécurité.

57 | P a g e
 6. Perspective et évolutions futures

L'achèvement de la mission autour de Z_Scan marque le commencement d'une

nouvelle phase pour le projet. Z_Scan et les graphiques Excel produits sont prévus pour être
mis à la disposition des différents clients de Cyber Impact de manière gratuite, avec un
modèle de facturation axé sur le besoin d'expertise.

Dans ce contexte, un défi majeur à relever est d'assurer l'accessibilité et la réactivité

de Z_Scan sur divers appareils. La nature changeante et dynamique de l'environnement
numérique exige que les outils de cybersécurité soient flexibles et compatibles avec une
variété de dispositifs pour assurer une protection optimale. Par conséquent, des efforts
continus seront nécessaires pour assurer que Z_Scan reste à jour et pertinent pour nos
utilisateurs.

Une autre perspective d'évolution intéressante est la spatialisation des terminaux

réseau sur un plan de sol généré par l'apprentissage automatique, notamment via
l'utilisation d'IA génératrices d'images comme Stable Diffusion. Cette fonctionnalité pourrait
potentiellement offrir une visualisation intuitive de la répartition des vulnérabilités sur le
réseau, facilitant ainsi l'identification et la résolution des problèmes de sécurité.

En outre, un autre aspect à considérer pour l'avenir est l'intégration plus approfondie
de l'IA, comme avec le modèle de langage ChatGPT. Mon utilisation de ChatGPT durant cette
mission a été sporadique, d’où le fait qu’il ne soit évoqué que maintenant, servant
principalement à résumer le fonctionnement de certaines fonctions ou à automatiser
l'écriture de parties répétitives du code. Cependant, je vois un potentiel énorme dans
l'adoption de ces outils d'IA pour augmenter la productivité et accélérer le développement.

Cependant, il convient de noter que, malgré les avantages potentiels de l'IA, son utilisation
ne peut pas remplacer une vérification humaine rigoureuse. Les outils d'IA, bien qu'efficaces
pour automatiser certaines tâches, sont encore loin de pouvoir garantir un travail sans
erreurs. Par conséquent, leur utilisation doit être complétée par un contrôle humain pour
assurer la qualité et l'exactitude du travail. Il paraît néanmoins évident que ce jugement
devra être révisé dans quelques années pour quelque chose plus nuancé sur ce point.

En résumé, l'avenir de Z_Scan promet d'être passionnant, avec de nombreuses opportunités

pour l'innovation et l'amélioration. Avec un engagement continu envers le développement
et l'adaptation aux besoins changeants des utilisateurs, je suis confiant que Z_Scan
continuera à fournir une évaluation précise et utile des vulnérabilités pour aider les clients
de Cyber Impact à protéger leurs réseaux.

58 | P a g e
 8. Conclusion

Au terme de ce stage, je peux affirmer que l'expérience acquise est d'une valeur
inestimable. A travers les différentes missions qui m'ont été confiées, j'ai eu l'opportunité
d'explorer un large éventail de disciplines informatiques, ce qui a contribué à enrichir ma
compréhension du domaine et à affiner mes compétences techniques.

La gestion de l'administration système et la virtualisation ont été une étape clé de

mon apprentissage, en me donnant l'occasion de créer des machines avec vSphere et de
mettre en place des services en fonction des besoins de Cyber Impact. J'ai également été
immergé dans le monde des réseaux, la création de schémas réseaux et de cartographies IP
m'ayant permis d'acquérir une compréhension solide de ces aspects techniques.

La base de données NoSQL avec MongoDB m'a apporté une nouvelle perspective sur
la gestion des données. La refonte graphique de Z_Scan, couplée à la création et la
restauration de certaines fonctionnalités en Python, a été une plongée enrichissante dans le
développement front-end et back-end.

Le travail avec Nessus, ainsi que l'apport de mon tuteur, ont été essentiels pour
élargir ma compréhension de la cybersécurité. La création de graphiques liés à ce domaine
m'a fourni des outils précieux pour le Business Intelligence et l'informatique décisionnelle.

De plus, l'ensemble de ces missions m'a permis de développer mes compétences en

gestion de projet informatique. J'ai appris à gérer des projets de différentes envergures, à
coordonner des équipes et à prendre des décisions stratégiques pour atteindre les objectifs
définis.

En conclusion, ce stage a été une véritable chance d'explorer autant de domaines en

si peu de temps. Bien plus qu'un simple apprentissage, il m'a fourni les clés pour utiliser les
connaissances acquises dans ma future vie professionnelle. L'expérience acquise pendant ce
stage a solidement ancré mes compétences et m'a préparé à relever les défis futurs dans le
domaine de l'informatique. Avec cette expérience, je suis confiant de pouvoir apporter une
contribution significative à n'importe quelle équipe et de continuer à apprendre et à grandir
en tant que professionnel de l'informatique.

59 | P a g e
 9. Annexes

Introduction aux Annexes

Dans le cadre de ce mémoire, plusieurs annexes ont été créées pour fournir une
compréhension plus profonde et plus détaillée des travaux de recherche menés. En raison
de la taille substantielle de certaines de ces annexes, il n'a pas été possible de les inclure
dans la version imprimée de ce mémoire. Cependant, pour garantir un accès complet à
toutes les informations pertinentes, ces annexes ont été incluses sous forme numérique
dans le dossier qui accompagne ce document.

Description des Annexes

Annexe A : Fichier de rapport au format Nessus, un fichier texte balisé, visualisable

avec un éditeur de texte (un éditeur de texte avec coloration syntaxique est vivement
conseillé), cette annexe sert à montrer à quoi peuvent ressembler les données « brutes »
fournie par la solution d’évaluation de vulnérabilité avant tout traitement

Annexe B : Rapport produit par Nessus (format résumé) au format PDF, ce document
sert à montrer le manque d’informations présentent dans celui-ci

Annexe C : Rapport produit par Nessus (format détaillé) au format PDF, sert à
montrer la verbosité du rapport (593 pages)

Pour accéder à ces annexes, veuillez insérer la clé USB dans un ordinateur compatible
et naviguer jusqu'au dossier correspondant à l'annexe que vous souhaitez consulter. Chaque
fichier d’annexe sera nommé « annexe » suivi de la lettre associée.

Il est important de noter que certaines annexes peuvent nécessiter un logiciel spécifique
pour être visualisées correctement. Par exemple, le code source peut nécessiter un éditeur
de texte ou un environnement de développement intégré (IDE), et les données de test
peuvent nécessiter un logiciel de gestion de bases de données.

Je vous remercie de votre compréhension concernant cette manière de procéder, qui

permet de présenter de manière plus complète et détaillée les éléments de ce travail.

60 | P a g e
 10. Sitographie

a : L’annuaire Active Directory (AD) est un élément critique permettant la gestion

centralisée de l’ensemble des permissions sur les différents domaines qui composent un
système d’information (SI) Microsoft. L’obtention de privilèges élevés sur l’AD entraîne par
conséquent une prise de contrôle instantanée et complète de tout le SI.
https://www.ssi.gouv.fr/actualite/le-service-active-directory-security-ads-accompagner-la-
securisation-des-annuaires-active-directory-des-acteurs-critiques/

b : Source : https://csrc.nist.gov/glossary/term/vulnerability_scanner

c : rsync est un utilitaire open source qui permet de transférer rapidement des fichiers de
manière incrémentielle : https://rsync.samba.org/

d: Cron est un programme pour exécuter automatiquement des scripts, des commandes
ou des logiciels à une date et une heure spécifiée précise, ou selon un cycle défini à
l’avance : https://doc.ubuntu-fr.org/cron

e : Fait de scripter : utilisation de scripts. Utiliser un Langage de programmation qui

permet de manipuler les fonctionnalités d’un système informatique.
https://fr.wiktionary.org/wiki/scripting, https://fr.wiktionary.org/wiki/langage_de_script

f : Un point d'extrémité est tout dispositif qui se connecte à un réseau informatique. […],
un ordinateur connecté à un réseau est l'un des points d'arrivée d'un échange de données
continu.

Parmi les exemples quotidiens de points d'extrémité figurent les ordinateurs de bureau,
les smartphones, les tablettes, les ordinateurs portables et les dispositifs de l'Internet des
objets (IoT). https://www.cloudflare.com/fr-fr/learning/security/glossary/what-is-endpoint/
g : Une structure en couches indiquant quels types de programmes peuvent ou doivent
être construits et comment ils doivent être reliés entre eux.
https://csrc.nist.gov/glossary/term/framework

h: Source de la structure :
https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/project.html#the-project-
structure

i : Le module urllib2 a été divisé en plusieurs modules dans Python 3, nommés

urllib.request et urllib.error. Source : https://docs.python.org/2/library/urllib2.html

61 | P a g e
 j : Le module des boîtes flexibles, aussi appelé « flexbox », a été conçu comme un modèle
de disposition unidimensionnel et comme une méthode permettant de distribuer l'espace
entre des objets d'une interface ainsi que de les aligner. Source :
https://developer.mozilla.org/fr/docs/Web/CSS/CSS_flexible_box_layout/Basic_concepts_of
_flexbox

k : IPython fournit une riche boîte à outils pour vous aider à tirer le meilleur parti de
l'utilisation interactive de Python. Ses principaux composants sont les suivants :

- un puissant shell Python interactif

- Un noyau Jupyter pour travailler avec du code Python dans des carnets Jupyter
et d'autres interfaces interactives.

Source : https://pypi.org/project/ipython/

l : processus par lequel un format de niveau inférieur (par exemple, qui a été transféré sur
un réseau ou stocké dans un magasin de données) est traduit en un objet lisible ou une autre
structure de données. Source :
https://developer.mozilla.org/fr/docs/Glossary/Deserialization

m : permet de créer un nouveau tableau contenant les éléments des sous-tableaux du

tableau passé en argument, qui sont concaténés récursivement pour atteindre une
profondeur donnée.
https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/flat
(fait référence à une fonction javascript dans la source, mais valable dans le principe pour
tout traitement similaire de données)

62 | P a g e
11. Fiche de Validation Entreprise

63 | P a g e