Test d implémentations de protocoles cryptographiques Master 2 INFORMATIQUE option S2L

Test d implémentations de protocoles cryptographiques Master 2 INFORMATIQUE option S2L Thanh-Tuan BUI Emmanuel MAIROT Septembre 2011 - Janvier 2012 Encadrants : Frédéric DADEAU Pierre-Cyrille HEAM

Remerciements Nous tenons tout particulièrement à remercier nos responsables de projet Monsieur Frédéric Dadeau et Monsieur Pierre-Cyrille Heam, pour nous avoir suivis et aiguillés durant la réalisation du projet. Nous les remercions également pour les explications claires et les conseils donnés pour la réalisation de ce rapport. 1

Table des matières 1 Introduction 3 1.1 Contexte.................................. 3 1.2 Problématiques.............................. 3 1.3 Objectifs.................................. 4 1.4 Plan du rapport.............................. 5 2 Les protocoles cryptographiques 6 2.1 Notions générales............................. 6 2.2 Propriétés de sécurité........................... 7 2.3 Description du protocole NSPK..................... 9 3 Étude des techniques et des outils d attaque 11 3.1 Les logiciels d analyse du réseau informatique............. 11 3.1.1 Ettercap.............................. 11 3.1.2 Wireshark............................. 12 3.2 Les packet sniffers en ligne de commande................ 13 3.2.1 Aircrack-ng............................ 13 3.2.2 TCPDUMP............................ 14 3.2.3 WINDUMP............................ 15 3.2.4 NGREP.............................. 15 3.2.5 SNORT.............................. 15 3.2.6 NTOP............................... 15 3.2.7 TCPDUMP et la dissection de paquets............. 16 3.2.8 SCAPY.............................. 17 3.3 Bilan sur l étude............................. 19 4 Le protocole Needham Schroeder Public Key 20 4.1 Implémentation du protocole NSPK................... 20 4.2 Codage de l environnement pour le modèle d intrus de Dolev-Yao.. 21 4.3 L exécution des tests........................... 24 5 Conclusion 27 5.1 Bilan du projet.............................. 27 5.2 Bilan personnel.............................. 27 5.3 Perspectives................................ 28 2

Chapitre 1 Introduction 1.1 Contexte De nos jours, de plus en plus d entreprises permettent le partage de leurs informations avec des entreprises externes en utilisant Internet. Ce phénomène de partage est valable pour n importe quel domaine d activité. Cependant le fait de partager ces informations entraîne une menace pour l entreprise. En effet, le développement d Internet a également entrainé l augmentation de la criminalité informatique ce qui peut fortement nuire à une entreprise. La nécessité d assurer la confidentialité et l authenticité des messages échangés est de plus en plus importante. La cybercriminalité se définit en trois principaux types d infractions : Les infractions spécifiques aux technologies de l information et de la communication : les interceptions d informations, les infractions aux cartes bancaires... Les infractions liées aux technologies de l information et de la communication : l incitation au terrorisme, les atteintes aux personnes... Les infractions facilitées par les technologies de l information et de la communication : les escroqueries en ligne, la contrefaçon... Ce projet concerne plus particulièrement la première partie. Les attaques menées par ces cybercriminels utilisent des failles présentes dans le code d application développé. Pour éviter tout problème, il est primordial de vérifier et de valider la sûreté au niveau du code développé. Les protocoles cryptographiques permettent de protéger des informations sensibles. Cependant de nouvelles failles sont trouvées régulièrement, même sur des protocoles connus et développés depuis de longue date. Dans notre cas, des tests d implémentations seront mis en place. 1.2 Problématiques Ce projet se situe dans le cadre des travaux menés au sein du Laboratoire Informatique de l Université de Franche-Comté (LIFC) sur la génération de tests pour les protocoles cryptographiques. Durant les travaux de génération de tests, un procédé de type penetration testing a été mis au point dans lequel le testeur joue le rôle d un attaquant/intrus dans le système. La génération de tests se fait sur une approche de type Model Based Testing notée MBT. L idée générale du MBT est de se baser sur un modèle formel du système qui décrit son évolution à travers une vision abstraite de son 3

fonctionnement. Le test à partir de modèles permet de construire les cas de tests en simulant l exécution du système sur son modèle et produit l oracle du test c est-àdire le résultat attendu en le calculant sur le modèle. Un cas de test est une suite d appels d opérations du système. Une séquence est une suite de cas de tests. Pour générer des tests, il faut avoir un modèle abstrait qui correspond à un modèle fonctionnel mais détaillé et précis car il doit permettre de calculer les cas de tests et les résultats attendus. Le modèle établi doit être validé pour être sûr que son comportement représente bien celui attendu et vérifié en s assurant qu il doit établir et préserver certaines propriétés. Dans notre cas, les cas de tests sont calculés à partir d un modèle du protocole décrit dans un langage dédié nommé High-Level Protocol Specification Language (HLPSL). Une spécification HLPSL décrit des systèmes de transition qui représentent les différentes entités dans le protocole. Le langage HLPSL est basé sur la définition des rôles avec les rôles basiques qui vont représenter le comportement de chaque participant intervenant dans le protocole et les rôles de composition qui représentent les scénarios des rôles basiques avec l instanciation des différents rôles basiques pour modéliser l ensemble du protocole. Dans le cadre du test de pénétration, les cas de tests sont ainsi représentés sous la forme d une suite de messages que l intrus envoie et reçoit (ou intercepte) sur le réseau. Néanmoins, ces cas de tests restent au niveau abstrait et doivent donc être concrétisés pour être joués sur une implémentation réelle du protocole. Le but de notre travail est de concrétiser les tests en passant d un test abstrait à un test exécutable sur une implémentation d un protocole. Plutôt que de travailler sur l implémentation réelle du protocole, nous allons réaliser notre concrétisation de tests sur des algorithmes qui simulent des protocoles pour la simple raison que la capacité d effectuer des tests sur ces algorithmes sera plus aisée si nous connaissons le langage de développement utilisé. Le déroulement du travail a été découpé en plusieurs parties pour mener à bien ce projet. Ce découpage est présenté dans la prochaine partie. 1.3 Objectifs Pour jouer des attaques sur un réseau sans fil, il est nécessaire de se munir d outils d attaque. Ils vont nous permettre de concrétiser des attaques car des travaux ont été réalisés dans le but de générer des tests qui à ce jour restent au niveau abstrait. La première étape du projet sera de nous familiariser avec les échanges de données sur un réseau sans fil, c est pourquoi une étude sera menée pour voir quels sont les logiciels à utiliser pour récupérer les données sur le réseau et surtout comment les utiliser. L objectif étant de comprendre comment traiter les paquets (récupération, modification, envoi). Le deuxième objectif sera de rechercher des implémentations de protocole et d étudier leur capacité à être testées. Si elles le sont, alors nous devrons concrétiser des traces d attaque dans le but de montrer les failles dans ces implémentations. 4

1.4 Plan du rapport Pour bien positionner le sujet, nous verrons dans une première partie les notions se rapportant au domaine de la cryptographie (définitions...). En seconde partie, nous étudierons les techniques et les outils d attaques sur des canaux de communication non sécurisés (logiciels disponibles...). Nous allons également voir le développement effectué et les tests concrets effectués sur le protocole NSPK avec la description de celui-ci. Pour finir ce rapport un bilan sera effectué au niveau de l état d avancement du projet, suivi d un bilan personnel. 5

Chapitre 2 Les protocoles cryptographiques 2.1 Notions générales Avant de développer la partie technique de ce projet, il nous a semblé nécessaire de définir le sujet et plus principalement les notions se rapportant à la cryptographie. Depuis le début d Internet, le réseau Internet a énormément évolué et est devenu un outil majeur de communication mais qui présente des risques (liés à l activité des entreprises sur le Web). Cependant les transactions effectuées à travers le réseau peuvent être interceptées et posent des problèmes. Il est donc nécessaire de garantir la sécurité des informations, c est le rôle de la cryptographie. La cryptographie correspond aux méthodes ou techniques permettant de transmettre des données confidentielles à l aide de secrets ou de clés. Ces méthodes permettent d assurer l intégrité, l authenticité et la confidentialité des messages. Ces informations seront définies dans la suite de ce rapport. La cryptographie est utilisée depuis l antiquité. De nouvelles méthodes sont apparues ou évoluées (cryptographie asymétrique...) mais le principe est toujours semblable. Pour protéger un message, une transformation est appliquée pour faire en sorte que le message devienne incompréhensible : c est la phase de chiffrement. Ainsi à partir d un texte clair et après chiffrement, on obtient un texte chiffré ou cryptogramme. Le déchiffrement est l action permettant de transformer le texte chiffré en un texte en clair. Les transformations se font à l aide d algorithmes cryptographiques qui dépendent d un paramètre qui est la clef (clef de chiffrement ou de déchiffrement). Parmi ces algorithmes, il est possible de citer : les algorithmes de chiffrement faibles les algorithmes de cryptographie symétrique (à clef secrète) les algorithmes de cryptographie asymétrique (à clef publique et privée) Ces algorithmes seront vues en détails dans la partie 2.2. La cryptanalyse est la science qui consiste à tenter de déchiffrer un message chiffré sans connaître la clef utilisée. Le processus mis en place pour comprendre un message est appelé une attaque. Effectuer la cryptanalyse d un algorithme de chiffrement consiste à étudier sa sécurité en tentant de résoudre (casser) les fonctions cryptographiques qui le composent à l aide d attaques. La cryptologie est la science qui regroupe la cryptographie et la cryptanalyse (voir figure 2.1 pour les étapes de transformation). 6

Figure 2.1 Schéma représentant la cryptologie 2.2 Propriétés de sécurité Dans cette partie, nous verrons en détails les termes se rapportant aux propriétés de sécurité avec des exemples. Voici les différentes notions : Authentification : capacité à reconnaître de façon sûre l identité d une entité (être sûr que l expéditeur est bon). L entité peut être une personne, un ordinateur... Confidentialité : une information ne peut être connue que par les entités autorisées (exemple : compte bancaire, dossier médical...). Cette propriété est assurée par le chiffrement. C est une non divulgation de l information ou des ressources. Intégrité : assure qu une information ne peut être modifiée, sauf par des personnes qui en ont le droit. Le contrôle d accès permet de vérifier si un sujet demande l accès à une information qu il possède bien les droits nécessaires pour y accéder. Cela consiste à s assurer que les informations n ont pas été modifiées durant leurs échanges (présence de mécanismes d intégrité avec des mécanismes de prévention et de détection). Vérifier l intégrité consiste à déterminer si les données n ont pas été altérées durant une transaction avec un organisme bancaire par exemple. Le terme authenticité regroupe les notions d authentification et d intégrité. Pour résoudre des problèmes, il existe les fonctions de hachage et la signature numérique. Comme indiqué dans la partie précédente, le chiffrement se fait à l aide d algorithmes cryptographiques énoncés précédemment. Voici les détails de ces algorithmes : Les algorithmes de chiffrement faibles : Facilement cassables, ce sont les premiers algorithmes utilisés pour le chiffrement. Ces algorithmes servent notamment à remplacer des caractères par des autres. Voici quelques exemples d algorithmes de chiffrement faibles : Chiffre de César (décalage de lettres). Le chiffrement de César utilise une technique de substitution monoalphabétique simple par décalage des lettres du message de trois places vers la droite par rapport à l alphabet. Chiffre de Vigenère. Le chiffrement de Vigenère est quant à lui, basé sur le chiffrement de César, mais au lieu d utiliser une clé à une lettre, on utilise une clé plus longue. C est un chiffrement polyalphabétique car différentes occurrences de la même lettre peuvent être codées par des lettres différentes. 7

ROT13. Le ROT13 est un cas particulier du chiffrement de César, un algorithme de chiffrement de texte. Il s agit d un décalage de 13 caractères de chaque lettre du texte à chiffrer. Tous ces algorithmes ont été vus et codés dans le cadre du module de Sécurité en Licence 3. Les algorithmes de cryptographie symétrique (à clef secrète) : Le principe de l algorithme repose sur une même clé pour chiffrer et déchiffrer le message. La clé doit être par conséquent transmise de façon sûre. La clé de chiffrement doit être par conséquent la même que celle de déchiffrement. Les algorithmes de cryptographie symétrique (à clef secrète) les plus connues sont Data Encryption Standard (DES), Advanced Encryption Standard (AES) et Triple DES (3DES). DES est le cryptosystème à clef secrète le plus utilisé actuellement. Il sert à chiffrer les transactions bancaires, les codes PIN des cartes bancaires... Avant de commencer à échanger des informations, les interlocuteurs doivent partager une clé confidentielle. Les algorithmes de cryptographie asymétrique (à clef publique et privée) : Il se base sur le principe de deux clés. La première, la clé publique, permet de faire le chiffrement et la deuxième, la clé privée permet le déchiffrement. La clé publique est accessible par tous. Avec les algorithmes de cryptographie asymétrique, les clefs de chiffrement et de déchiffrement sont différentes et il est impossible de déduire l une à partir de l autre. Parmi ces algorithmes de cryptographie asymétrique (à clef publique et privée) on peut citer : Rivest Shamir Adleman (RSA) Digital Signature Algorithm (DSA)... RSA est actuellement le standard de chiffrement à clé publique. Il permet de résoudre le problème de l authentification et celui de distribution des clés. Ce type d algorithme est beaucoup plus lent que les algorithmes de cryptographie symétrique. Ils sont, par conséquent, plus utilisés pour chiffrer des clés de sessions secrètes que directement des données. Par exemple, il est 100 fois plus lent que DES. La cryptographie asymétrique est également utilisée pour assurer l authenticité d un message : Anonymat : c est la non identification de l identité. Disponibilité : c est l aptitude à utiliser l information ou les ressources. Non-répudiation : c est assurer que l auteur d un envoi ne peut ensuite nier l avoir effectué. On distingue la non-répudiation d origine qui est le refus de reconnaître avoir envoyé quelque chose et la non-répudiation de réception qui est le refus de reconnaître d avoir reçu quelque chose. Fraîcheur : pendant une session de protocoles, une donnée est fraîche si on peut garantir qu elle a été émise pour la session courante par un des acteurs. En résumé, dans un cryptosystème à clés secrètes, la clé utilisée est la même pour le processus de codage et de décodage alors que dans un cryptosystème à clés publiques, les clés existent par paires avec une clé publique pour le chiffrement et une clé secrète pour le déchiffrement. Les propriétés associées aux protocoles sont 8

les propriétés définies ci-dessus, c est à dire les notions de secret, d authentification d une entité, de fraîcheur, d accord non répudiable, d équité et d anonymat. Après avoir défini tous ces termes, il nous semble nécessaire de définir ce qu est un protocole cryptographique et où ils sont utilisés. Un protocole cryptographique est un ensemble de règles d échange entre les points d un réseau, basé sur les cryptosystèmes qui permettent de sécuriser les communications dans un environnement hostile. Ce cryptosystème désigne l ensemble des algorithmes cryptographiques (une partie des ces algorithmes vus précédemment) et de tous les textes en clairs, textes chiffrés et clés possibles. Les protocoles cryptographiques sont utilisés dans le cadre de communication secrète (SSH,...), d authentification d agents (login,...), de signature de contrats électroniques, de paiement bancaire en ligne... Un exemple de protocole cryptographie connu est le protocole Diffie-Hellman qui permet à deux agents A et B de générer un secret partagé sans avoir des informations l un sur l autre. Ce protocole inventé par Diffie et Hellman en 1976 est basé sur la cryptologie à clef publique car il fait intervenir des valeurs publiques et des valeurs privées. Ce protocole est vulnérable à l attaque active dite attaque de l intercepteur. Pour contourner cette attaque, il est nécessaire d authentifier les valeurs publiques utilisées pour générer le secret partagé. Ce protocole se nomme Diffie-Hellman authentifié. Un autre exemple de protocole cryptographique est le protocole de Needham- Shröder considéré comme sûr pendant de nombreuses années avant que Lowe montre une attaque. L importance des protocoles cryptographiques est devenue considérable et les failles sont de plus en plus redoutées. Ce protocole et les failles qui lui sont associées vont être décrites dans la partie suivante. 2.3 Description du protocole NSPK Ce protocole utilise un système à clé publique. Imaginons qu Alice veut communiquer avec Bob de manière sécurisée. Elle connaît la clé publique de Bob et réciproquement. Il faut qu Alice soit sûre de communiquer avec Bob. Ils vont donc chacun mettre au point une information secrète partagée (le nonce 1 ) qui va leur servir à créer à la fin une clé appelée clé de session pour chiffrer et donc protéger leur message. Le schéma suivant permet d avoir une meilleure visualisation du procédé d échange des messages : A : Alice ; B : Bob N A, N B les nonces d Alice et Bob K A, K B les clés publiques d Alice et Bob A B : {N A,A}K B Dans un premier temps, Alice génère son nonce qui va servir pour la communication avec Bob. Alice envoie un message à Bob contenant son nonce et son identité en le chiffrant avec la clé publique de Bob. Bob reçoit le message (sans savoir d où ce message provient). Pour avoir cette information, il déchiffre le message avec sa clé privée et obtient l identité d Alice et le nonce d Alice. 1. Number used once 9

B A : {N A,N B }K A Bob va à son tour communiquer avec Alice. Pour indiquer à Alice qu il est bien Bob, il va retourner le nonce d Alice qu il a reçu ainsi que le nonce qu il aura généré. Ce message est chiffré avec la clé publique d Alice. Alice reçoit le message de Bob et le déchiffre avec sa clé privée. Alice est donc à présent sûre de communiquer avec Bob. Il ne reste plus qu à convaincre Bob qu elle est bien Alice. A B : {N B }K B Le dernier message qu Alice envoie à Bob est le nonce de Bob chiffré avec la clef publique de Bob. Bob reçoit alors le message d Alice et le déchiffre avec sa clé privée. Il reconnait son nonce que seule Alice a pu déduire du message précédent. Bob est donc sûr de communiquer avec Alice. La communication entre les deux personnes peut commencer. Toutefois il a été vu que cette attaque est vulnérable aux attaques dites man-inthe-middle. L attaque man-in-the-middle est une attaque qui consiste à intercepter et à faire véhiculer les messages provenant d autres utilisateurs de telle sorte qu aucune partie ne s en rende compte. Si un individu Igor joue le rôle de l intrus alors il va jouer une attaque appelée l attaque de Lowe. Si Alice veut communiquer avec Igor alors son attaque se déroule comme suit : A : Alice ; B : Bob ; I : Igor N A, N B, N I les nonces d Alice, de Bob et d Igor K A, K B, K I les clés publiques d Alice, Bob et Igor Le terme X(Y) signifie que l intrus ou la donnée X joue le rôle de l agent ou la donnée Y. A I : {N A,A}K I I(A) B : {N A,A}K B B I(A) : {N A,N B }K A I A : {N A,N B (N I )}K A A I : {N B (N I )}K I I(A) B : {N B }K B En bleu on peut voir qu Alice a bien reçu les informations qu elle attendait et en rouge, Bob a lui aussi bien reçu les informations qu il attendait mais en croyant converser avec Alice alors qu il communique avec Igor. Pour donc éviter toute intrusion, le protocole NSPK a subi un changement au message que Bob envoie : {N A,N B }K A. Le but étant de rajouter l identité de Bob dans ce message pour qu il devienne {N A,N B,B}K A. Ce protocole version corrigé nous a servi pour nos tests comme nous le verrons dans le chapitre 4. Dans le prochain chapitre, nous allons voir les techniques et outils utilisés pour ce projet. 10

Chapitre 3 Étude des techniques et des outils d attaque Dans le cadre de cette étude, nous allons voir les différentes techniques et les différents outils d attaque pour effectuer des tests sur des canaux de communication non sécurisés, le réseau Wifi dans notre cas. Nous allons voir les logiciels capables d intercepter les paquets transitant à travers le réseau ainsi que les logiciels capables de les interpréter. Un paquet a une adresse de destination qui peut être unicast (vers un seul périphérique), multicast (groupe de périphériques) voire broadcast dans le cas d une diffusion à l ensemble des personnes connectées. Quand le Wifi est activé, il est possible de voir les réseaux disponibles à proximité de l ordinateur. Cela est dû au fait que l access point envoie régulièrement des paquets. Pour capturer des paquets qui transitent dans l air sans être associé à un réseau Wifi, il est nécessaire de passer l interface de la carte Wifi en mode monitor pour accepter tous les paquets que le récepteur capte sans tenir compte de la destination. Dans le cadre de notre étude pour effectuer des tests, une carte AWUS036H a été utilisée. Cette carte permet l injection et le sniffing de paquets. L injection de paquets sert à stimuler le réseau en envoyant et en recevant de paquets. Le sniffing consiste à récupérer ce qui transite sur le réseau. Pour rejouer une attaque sur un réseau, nous avons dans un premier temps, essayé de s attaquer aux réseaux sans fil. Pour ce faire, nous avons cherché des outils qui permettent de récupérer les paquets transmis, de manipuler et décoder ces paquets et d envoyer des paquets. Toutes ces actions doivent être faites de manière souple et rapide. 3.1 Les logiciels d analyse du réseau informatique Après avoir défini les objectifs de l étude, voici les outils d attaque testés. 3.1.1 Ettercap Ettercap est un logiciel libre d analyse du réseau informatique. Il est capable d intercepter le trafic sur un segment réseau et de réaliser des attaques dites de l homme du milieu (man-in-the-middle) contre un certain nombre de protocoles de communication usuels tels que HTTP, FTP et certains protocoles chiffrés. Ettercap est également doté de plugins facilitant la recherche de mots de passe. Ce logiciel possède des fonctions intéressantes comme l injection de requêtes sur le réseau à 11

envoyer au client pour faire en sorte que la connexion soit toujours active ou à envoyer au serveur. Il est possible d utiliser ce logiciel sous mode graphique ou sous mode texte simple. Ettercap est multiplateforme mais difficile d utilisation sous Windows 7, Vista. Il fonctionne sous Windows, Linux, Mac OS X, Solaris ainsi que sous FreeBSD. Plusieurs types d attaques sont possibles. Site officiel : http ://ettercap.sourceforge.net/ Liens utilisés pour effectuer des tests : http ://www.crack-wifi.com/tutoriel-rogue-ap-les-dangers-des-hotspots-wifi.php Ettercap permet d intercepter le trafic du réseau mais le traitement des données n est pas aisé et l envoi de paquets est impossible. 3.1.2 Wireshark Wireshark (anciennement nommé Ethereal) est un logiciel libre d analyse de protocole utilisé dans le dépannage et l analyse de réseaux informatiques, le développement de protocoles, mais aussi le piratage. Wireshark est très facile d utilisation (grâce à son interface graphique) et possède un très grand nombre de fonctionnalités ce qui en fait un logiciel très complet. Wireshark est multiplateforme, il fonctionne sous Windows, Mac OS X, Linux, Solaris, ainsi que sous FreeBSD. Page de téléchargement : http ://www.wireshark.org/download.html Ce logiciel permet la capture de paquets de données circulant sur le réseau de manière totalement transparente. Il utilise WinPcap, Airpcap et Libpcap, compléments de ce logiciel pour la capture et le filtrage des informations. WinPcap est un logiciel de filtrage intégré dans de nombreuses applications. Il permet d accéder aux couches réseaux à bas niveau du système, d en obtenir les statistiques ou de capturer à distance et de transmettre les paquets. Grâce à sa librairie et ses contrôleurs, les développeurs ont pu développer des programmes de surveillance réseau, de détection d intrusions, d analyse de protocoles ou de trafic, et bien d autres encore. Attention, WinPcap n est pas un logiciel. C est une API utilisable avec d autres applications. Airpcap a pour but d aider le logiciel Wireshark à collecter des données de façon efficace. Libpcap est une bibliothèque d outils permettant de faire la capture des paquets qui circulent sur le réseau. Wireshark permet : de capturer les paquets directement depuis son interface réseau d obtenir des statistiques d importer/exporter des paquets capturés depuis/vers d autres programmes... Le logiciel Wireshark est le plus complet des logiciels gratuits. En effet il dispose de plusieurs menus : pour le filtrage, pour la liste des paquets capturés, les détails sur 12

les paquets sélectionnés et le contenu du paquet. Il supporte les formats de fichiers de capture les plus courants. Les liens que nous avons utilisés pour effectuer des tests : http ://blog.nicolargo.com/2011/05/capturer-et-analyser-un-trafic-reseau-avec-wireshark.html http ://blog.nicolargo.com/2007/07/tutoriel-wireshark-ex-ethereal.html Ce logiciel est très facile d utilisation grâce à son interface graphique très intuitive mais dans le cadre du projet, la présence d une interface graphique n est pas des plus aisées pour un traitement rapide des données. 3.2 Les packet sniffers en ligne de commande Le point commun des packet sniffers présentés ci-dessous sont le fait qu ils fonctionnent tous en ligne de commande. Ils permettent d obtenir le détail du trafic visible depuis une interface réseau. Les nombreuses informations qu il faut trier conduisent à utiliser le filtre BPF. Le filtre BPF (Berkeley Packet Filter) est un langage permettant de filtrer les paquets échangés sur un réseau. Ce langage est utilisé entre autres par des logiciels spécialisés dans l analyse d échanges réseau (exemples : ngrep, tcpdump, snort, ntop) et sert à sélectionner des données transitant sur un réseau selon des critères précis, par exemple : l heure d arrivée du paquet sur l interface réseau. le type de protocole réseau utilisé (IP, ARP, IGMP, GRE,...) qui envoie les paquets, quelle est l adresse du réseau source, ainsi que son port. qui reçoit les paquets, quelle est l adresse du réseau destination, ainsi que son port. 3.2.1 Aircrack-ng Aircrack-ng est une suite regroupant plusieurs outils différents. Il est possible de l utiliser sous Windows, Linux et Mac OS. Avant de s appeler Aircrack-ng, la suite se nommait Aircrack. Aircrack a été conçue pour surveiller son propre réseau (outil de surveillance réseau). Cette suite est gratuite (open-source). La suite contient plusieurs outils dont : airmon-ng : permet d activer/désactiver le mode moniteur d une carte WIFI. Dans ce mode, la carte WIFI, se place en observateur du réseau. Il est nécessaire de préciser que de nombreuses cartes WIFI ne supportent pas le mode monitor voire l injection. Commande pour activer le mode moniteur : airmon-ng start nominterface airodump-ng qui permet la capture de paquets. Cet outil scanne les réseaux et conserve les paquets. Il permet de capturer les paquets transitant dans les frames 802.11. Avant de lancer cet outil, il est nécessaire de mettre sa carte wifi en mode écoute. Syntaxe de base pour lancer airodump : airodump-ng <options> <interface> 13

aireplay-ng pour générer du trafic et ainsi capturer plus de paquets. Commande : aireplay-ng -0 -e NOM_DE_L_AP -a MAC_DE_L_AP -b MAC_DE_L_AP -c MAC_DE_LA_STATION aircrack-ng qui permet de retrouver une clé WEP ou WPA-PSK à partir des paquets récupérés grâce à airodump-ng (si on a un nombre suffisant de paquets bien sûr!). Commande : aircrack-ng nom-du-fichier-de-capture D autres outils existent également pour faciliter le décryptage des paquets (airdecap-ng... ) mais les outils présentés précédemment sont les outils les plus utilisés. La plupart des tests ont été effectués sous Linux (Ubuntu 11.10) pour plus de facilité et avoir moins de souci pour activer le mode monitor de la carte Wifi (il est impossible de faire l injection de paquets sous Windows). Ces outils sont également présents dans la distribution GNU/Linux Backtrack qui est complète au niveau de l analyse réseau et de tests d intrusion (la version actuelle est la version 5.0 R1). La suite Aircrack-ng regroupe de nombreux outils faciles d utilisation mais la création de paquets est impossible. 3.2.2 TCPDUMP Contrairement aux logiciels vus précédemment, celui-là n est pas multiplateforme, tcpdump est un outil UNIX permettant de collecter des données de réseau, de déchiffrer les bits et d afficher la sortie d une manière semi-cohérente. C est un peu l équivalent de Wireshark en ligne de commandes. Il permet d avoir une analyse en direct du réseau ou d enregistrer la capture dans un fichier afin de l analyser pour plus tard. L écriture de filtres est également possible afin de sélectionner les paquets à capturer/analyser et ainsi éviter de capturer l ensemble des paquets circulant sur le réseau. Le logiciel sera vu en détails dans la partie suivante. Pour d amples informations et pour se procurer le logiciel : TCPDUMP 4.1.1 / 1.1.1 pour LINUX : Site officiel : http ://www.tcpdump.org/ Tutoriel : http ://blog.nicolargo.com/2007/02/tutorial-tcpdump.html Lien application : http ://www.tcpdump.org/release/tcpdump-4.1.1.tar.gz La ligne de commande permet également de lancer son installation : sudo apt-get install tcpdump Cet outil a été testé en profondeur dans la suite du rapport. Un bilan sera alors effectué à ce moment-là. 14

3.2.3 WINDUMP Windump est l équivalent de tcpdump sur Windows. Avant toute installation de windump, il est nécessaire d installer WinPcap en premier : http ://www.winpcap.org/install/bin/winpcap 4 1 2.exe Pour d amples informations et pour se procurer le logiciel : WINDUMP 3.9.5 : Site application : http ://www.winpcap.org/windump/install/ Lien application : http ://www.winpcap.org/windump/install/bin/windump 3 9 5/WinDump.exe Comme nous avions testé les autres outils sous Linux, nous avons privilégié l utilisation de TCPDUMP. 3.2.4 NGREP Ngrep est un outil de surveillance de paquets réseau qui permet entre autres de récupérer facilement les mots de passe en connexion TCP. Il permet de filtrer très facilement du trafic grâce à l intégration des fonctionnalités de grep et des filtres BPF. NGREP n est pas facile d utilisation pour le traitement des paquets et a donc été mis de côté. 3.2.5 SNORT Snort est un système de détection d intrusion libre pour le réseau (ou NIDS) publié sous licence GNU GPL. Snort est capable d effectuer en temps réel des analyses de trafic. Il peut également être utilisé pour détecter une grande variété d attaques. Snort n étant pas facile à prendre en main, nous n avons pas poursuivi nos recherches sur ce système. 3.2.6 NTOP NTop pour Network TOP est un outil de supervision de réseau. Cet outil permet de capturer et d analyser les trames d une interface donnée. Il est ainsi possible de récupérer de nombreuses informations concernant les caractéristiques du trafic. Cette application est disponible sous Unix et sous Windows. Cet outil ne permet que la capture et l analyse de trames mais pas la modification ou création de paquets. 15

3.2.7 TCPDUMP et la dissection de paquets Finalement, TCDUMP étant le plus en adéquation avec notre projet pour récupérer les paquets, notamment grâce aux nombreux filtres qu il possède, nous allons le voir plus en détails dans cette partie. Nous allons donc aborder la notion de dissection des paquets pour mieux comprendre le découpage des paquets. On commence par la récupération des paquets, parmi les nombreux filtres offerts par TCPDUMP on retiendra ceux-ci : Affichage standard : tcpdump Interfaces réseaux disponibles pour la capture : tcpdump -D Capture du trafic d une interface particulière : tcpdump -i eth0 Affichage des adresses numériques : tcpdump -n Capture du trafic UDP : tcpdump udp Envoi du résultat dans un fichier (au lieu d un affichage direct à l écran) : tcpdump -w capture.log Arrêt de la capture après 10 paquets tcpdump -c 10 Traduit la charge utile de caractères hexadécimaux en caractères ASCII tcpdump -X Cet outil nous permet par exemple de connaître l entête de certains protocoles dont IP. Figure 3.1 Datagramme IP La figure 3.1 montre la structure du datagramme IP comportant : Version (4 bits) : indique le numéro de version pour le datagramme IP (4 ou 6). IHL (4bits) : Header Length, taille de l entête avec les options. Type of Service : champs type de service pour IP. 16

Total lenght : taille des données du datagramme (16 bits). identification : identifiant de datagramme, utilisé pour la fragmentation. Flags (3 bits) : drapeaux binaires pour la fragmentation (dont bits DF et MF). Fragment Offset : offset du datagramme courant dans le datagramme fragmenté. Time to live : nombre de sauts maximum sur la route. Protocol : protocole contenu dans les données IP. Header checksum : somme de contrôle effectuée sur l entête. Source address : Adresse IP source. Destination address : Adresse IP destination. Cependant, aucune recherche nous a permis de trouver que TCPDUMP pouvait modifier les paquets qui transitaient sur le réseau. TCPDUMP est donc bien défini comme un logiciel permettant uniquement de visualiser en temps réel le trafic réseau avec (ou sans) le contenu des paquets. Toutes les recherches renvoient vers l utilisation de SCAPY que nous verrons dans la prochaine section. 3.2.8 SCAPY Description SCAPY est un logiciel libre de manipulation de paquets réseau, écrit en Python par Philippe Biondi. Le logiciel est en mesure d intercepter le trafic sur un segment réseau, de générer des paquets dans un nombre important de protocoles. Cet utilitaire permet de manipuler, forger, décoder, émettre, recevoir les paquets d une multitude de protocoles (ARP, DHCP, DNS, ICMP, IP... ). Certes, il décode mais n interprète pas car selon son concepteur, il est en mesure de remplacer les logiciels tcpdump, ethereal... Il permet également d exécuter des tâches spécifiques que la plupart des autres outils ne sont pas capables de traiter, comme envoyer des trames invalides, injecter ses propres trames 802.11. De plus, SCAPY permet d établir les paquets que l on souhaite : l empilement des couches réseaux des plus basses aux plus élevées. Il propose un Domain Specific Language (DSL) permettant une rapide et puissante description pour tous types de paquet. L utilisateur est en mesure de décrire un paquet ou un ensemble de paquets pour les différentes couches. Les champs de chaque couche ont des valeurs utiles par défaut. En langage C, il faut environ une soixantaine de lignes pour décrire un paquet. L un des avantages majeurs de SCAPY est le fait que ces paquets à envoyer peuvent être décrits en une seule ligne, en ajoutant une seconde ligne pour afficher le résultat. Ce logiciel nous a également permis d apprendre les notions principales du langage Python pour effectuer des tests sur le réseau. Utilisation Pour son utilisation, on retrouve ces commandes : création d une session pour y revenir plus tard : sudo scapy -s sessiontest liste les protocoles supportés par Scapy ls() obtenir des détails sur send 17

help(send) détail d un protocole ls(nomprotocole) Capture de données, écoute sur l ensemble du trafic équivalent au protocole de transport UDP et cela, pour la machine dont l adresse IP est 192.168.0.2 avec un maximum de 30 paquets collectés (count). : sniff(filter="udp and host 192.168.0.2",count=30) Résultats relatifs à la capture en affectant les enregistrements à la variable cap via la variable. cap=_ Pour voir les enregistrements : cap.nsummary() cap[0] : info sur le paquet 0 Affichage direct dans la console : sniff(iface="wlan1", prn= lambda x : x.summary(), count=30) Il est également possible de faire des traceroutes. On envoie le paquet et on accepte de ne recevoir qu un seul paquet en réponse avec la commande sr1(). Exemple : sr1(ip(dst= 192.168.0.1 )/ICMP()) Envoi de plusieurs paquets : srloop(ip(dst= 192.168.0.1 )/ICMP()) Si adresse non existante : Erreur Après avoir testé de nombreux outils, Scapy est sans conteste le logiciel le plus pratique à prendre en main et le plus abouti. En effet il permet entre-autres de forger, de sniffer et d envoyer des paquets. Il est également multiplateforme. Le seul bémol est le manque d informations sur cet outil. 3.3 Bilan sur l étude Après avoir testé les principaux outils d attaque, nous sommes en mesure d effectuer un bilan. Dans le cadre de tests sur un vrai réseau, le logiciel le plus abouti est Scapy. En effet pour pouvoir mener à bien des tests, il est nécessaire de récupérer les paquets transitant sur le réseau, de traiter le contenu et de les réinsérer dans le réseau. Le traitement des paquets avec des logiciels ayant une interface graphique (comme Wireshark) n est pas efficace et rapide. Concernant les outils d attaques en ligne de commande, notre choix s est dans un premier temps porté sur TCPDUMP qui semblait le plus adapté dans le cadre du projet. En effet, TCPDUMP possède de nombreux filtres qui permettent de sélectionner les paquets qui nous intéressent avec précision. Après avoir étudié en détails son fonctionnement, nous avons découvert 18

que TCPDUMP ne permettait pas d établir ses propres paquets et surtout émettre les paquets. L outil Scapy, quant à lui, nous a semblé le logiciel le plus en adéquation avec notre sujet car il permet de recevoir, de créer, de manipuler et d envoyer des paquets réseau. Le fait d avoir eu de nombreux problèmes au niveau du proxy à l université (ping impossible en Wifi) et quelques manques d informations précises sur l outil SCAPY ne nous a pas permis de l utiliser pour la suite du projet. Pour résoudre ce problème, nous avons décidé de passer à un autre mode de fonctionnement qui permet sur un réseau filaire de mettre en place une infrastructure de test de protocoles pour des attaques de type man-in-the-middle. Nous allons voir cette infrastructure de tests dans la partie suivante. 19

Chapitre 4 Le protocole Needham Schroeder Public Key La dernière partie de notre projet consiste à concrétiser la génération de test sur les suites de messages qu un intrus envoie et reçoit (ou intercepte) sur le réseau. La phase recherche d implémentation de protocole ainsi que l étude de leur testabilité nous ont amenés à nous focaliser sur le protocole Needham Schroeder Public Key, également connu par son acronyme NSPK. Faute de ne pas avoir trouvé d autres implémentations d autres protocoles, celui-là fera donc l objet de notre étude. De plus il a été considéré comme sûr pendant de nombreuses années avant que Lowe montre une attaque qui sera expliquée plus en détails dans cette partie. 4.1 Implémentation du protocole NSPK Suite à nos recherches, une première implémentation du protocole NSPK en JAVA est récupérable à cette adresse : http ://fluffymachappy.com/nspk.shtml Parmi les fichiers sources, on y trouve : Server.java qui permet de créer la socket serveur en attente de connexion d un client pour ensuite exécuter les méthodes contenues dans la classe Server- Thread.java ServerThread.java qui sert à coder les envois et réceptions de message de Bob et à générer les nonces et les clés publiques et privées d Alice et Bob Client.java qui va se connecter au socket serveur de Server.java et sert à coder les envois et réceptions de message d Alice et à générer les nonces et les clés publiques et privées d Alice et Bob Data.java les données qui seront contenues dans les messages envoyés et reçus par le client et le serveur. Ces données sont caractérisées par le type de données (String, byte[], BigInteger ou encore int), la taille des données et les données brutes en elles-mêmes. Pour comprendre les tests réalisés dans la prochaine partie, il est nécessaire de savoir la façon dont les informations avaient été codées. Nous avons gardé l implémentation telle qu elle l était : les messages envoyés entre les participants sont une liste Array- List de Data. Pour le chiffrement et le déchiffrement, une méthode de la classe Data permet grâce à un paramètre de type Cipher de chiffrer ou déchiffrer la liste. Suivant la clé voulue, la création d une variable de type Cipher se fait avec un paramètre 20

de type PublicKey ou PrivateKey. Ce sont ces deux objets qui nous permettent de créer les clés publiques et privées d Alice et Bob. Concernant les données, un nonce est typé en BigInteger et l identité est une chaîne de caractères. Par exemple, la création de l identité d Alice se fait de la manière suivante : Data A = new Data("Alice"); Par le biais du constructeur, les attributs de la classe Data vont prendre automatiquement les valeurs suivantes : A.typeData = 0 A.lengthData = 5 A.currentData = Alice Le premier travail fourni concerne le refactoring, à chaque envoi de messages, on crée une méthode et on attribue un numéro d étape suivant le schéma suivant : A : Alice ; B : Bob ETAPE 1 : A B : {N A,A}K B ETAPE 2 : B A : {N A,N B,B}K A ETAPE 3 : A B : {N B }K B Le schéma précédent montre uniquement les envois de messages. Or dans notre implémentation en JAVA, il est important de rajouter une étape qui permette à la personne qui reçoit le message, de le déchiffrer et de réaliser ses tests sur les données. On étend donc le schéma précédent au schéma suivant : A : Alice ; B : Bob ETAPE 1.1 : A B : {N A,A}K B ETAPE 1.2 : B reçoit et déchiffre {N A,A}K B ETAPE 2.1 : B A : {N A,N B,B}K A ETAPE 2.2 : A reçoit et déchiffre {N A,N B,B}K A ETAPE 3.1 : A B : {N B }K B ETAPE 3.2 : B reçoit et déchiffre {N B }K B 4.2 Codage de l environnement pour le modèle d intrus de Dolev-Yao Avant de jouer des attaques il a été nécessaire de coder un intrus. Nous avons donc inséré dans ce modèle un troisième participant : Igor qui va être l intrus de Dolev-Yao. On code Igor pour qu il ait un rôle passif, il ne fait qu écouter les messages. En effet, il est capable d intercepter, mémoriser et envoyer les messages sous n importe quelle fausse identité. Ainsi, dans ce modèle, toutes les communications entre les acteurs sont transmises sans modification par un environnement hostile, représenté par l intrus : 21

A : Alice ; B : Bob ; I : Igor N A, N B, N I les nonces d Alice, de Bob et d Igor K A, K B, K I les clés publiques d Alice, Bob et Igor Le terme X(Y) signifie que l intrus ou la donnée X joue le rôle de l agent ou la donnée Y. ETAPE 1.1 : A I(B) : {N A,A}K B ETAPE 1.1.1 : I reçoit {N A,A}K B ETAPE 1.1.2 : I(A) B : {N A,A}K B ETAPE 1.2 : B déchiffre {N A,A}K B avec sa clé privée ETAPE 2.1 : B I(A) : {N A,N B,B}K A ETAPE 2.1.1 : I reçoit {N A,N B,B}K A ETAPE 2.1.2 : I(B) A : {N A,N B,B}K A ETAPE 2.2 : A déchiffre {N A,N B,B}K A avec sa clé privée ETAPE 3.1 : A I(B) : {N B }K B ETAPE 3.1.1 : I reçoit {N B }K B ETAPE 3.1.2 : I(A) B : {N B }K B ETAPE 3.2 : B déchiffre {N B }K B avec sa clé privée Le protocole NSPK réalisé est la version du protocole corrigé, celle abordée dans la partie 2.3 du rapport. Pour rappel, la modification est l ajout de l identité de Bob dans le message contenu dans l étape 2.1. La communication se fait donc entre Alice, Bob et Igor n est qu un intrus qui sait qu Alice veut communiquer avec Bob, il ne connaît donc aucune clé publique. Igor ne fait que transiter les messages (étapes en rouge), le résultat montre ainsi qu Alice et Bob reçoivent bien les messages attendus alors qu Igor a les messages mais chiffrés. Pour l exécution du programme, à chaque message reçu ou envoyé, on affiche à l écran les messages de la manière suivante : ETAPE X.X : Type de donnees : Longueur des donnees : Donnees : 22

Figure 4.1 Exécution d Alice Figure 4.2 Exécution de Bob Figure 4.3 Exécution d Igor Dans la figure 4.1, Alice démarre le protocole en envoyant dans l étape 1.1 son nonce et son identité. La figure 4.3 montre l interception du message par Igor. L étape 1.1.1 est la lecture du message reçu qu il ne peut pas déchiffrer et l étape 1.1.2 est le message qu il envoie (le même qu il a reçu). Nous ne nous attarderons pas plus sur les actions d Igor car tout au long du protocole Igor intercepte et renvoie le message reçu de la même manière. On voit ensuite dans la figure 4.2 lors de l étape 1.2 l affichage du message déchiffré par Bob et qu il obtient bien les mêmes données que celles qu Alice a envoyé. L étape 2.1 consiste à renvoyer le nonce N A d Alice, de rajouter son nonce N B et son identité. Tant qu Igor ne modifie aucun message, l exécution du programme montre que les étapes s enchaînent correctement. 23

4.3 L exécution des tests L exécution des tests s effectuent sur l attaque de Lowe que l on a vu dans la partie 2.3. Nous nous proposons d étendre l environnement du modèle de Dolev-Yao de telle sorte à simuler l attaque de Lowe. Supposons qu Alice veut initier une session avec Igor, Igor en profite pour jouer l attaque sur Bob, les étapes correspondantes sont : A : Alice ; B : Bob ; I : Igor N A, N B, N I les nonces d Alice, de Bob et d Igor K A, K B, K I les clés publiques d Alice, Bob et Igor Le terme X(Y) signifie que l intrus ou la donnée X joue le rôle de l agent ou la donnée Y. ETAPE 1.1 : A I : {N A,A}K I Alice envoie donc un message à Igor contenant son nonce et son identité chiffré avec la clé publique K I de Igor. ETAPE 1.1.1 : I reçoit et déchiffre {N A,A}K I ETAPE 1.1.2 : I(A) B : {N A,A}K B Au lieu de répondre à Alice, Igor déchiffre le message avec sa clé privée et chiffre le message avec la clé publique K B de Bob pour l envoyer à Bob. ETAPE 1.2 : B reçoit et déchiffre {N A,A}K B ETAPE 2.1 : B I(A) : {N A,N B,B}K A Bob réceptionne le message et pense qu Alice veut initier une session avec lui, alors il suit le protocole en renvoyant le nonce d Alice N A, son nonce N B et son identité B, le tout chiffré avec la clé publique N A d Alice. ETAPE 2.1.1 : I reçoit {N A,N B,B}K A ETAPE 2.1.2 : I A : {N A,N B (N I ),B}K A Ce message est chiffré avec K A, or Igor ne possède pas la clé privée d Alice, malgré l interception du message il ne pourra rien en faire donc envoie une copie conforme de ce message à Alice. ETAPE 2.2 : A : {N A,N B (N I ),I} ETAPE 3.1 : A I : {N B (N I )}K I Alice confond donc N B avec N I, suit le protocole en renvoyant N B à Igor (puisqu Alice est authentifié avec Igor). ETAPE 3.1.1 : I reçoit et déchiffre {N B }K I ETAPE 3.1.2 : I(A) B : {N B }K B Igor reçoit N B chiffré avec K I alors il peut déchiffrer le message sans problème et déduire N B. Pour que le protocole finit correctement, Igor envoie N B chiffré avec K B à Bob. ETAPE 3.2 : B : {N B }K B Au final, Alice s est authentifiée avec Igor, Igor connaît le nonce N B sans que Bob ne le sache car Bob croit avoir initié une session avec Alice. 24

Igor est un participant de la session avec Alice vu qu elle démarre une session avec lui. Il sait donc comment former un message alors il n y a aucun test sur la structure des messages. Le seul test que l on a mis en place est celui qui permet de mettre en valeur l intrusion d Igor et a lieu lors de l étape 2.2 quand Alice reçoit {N A,N B,I}. Ce message n a pas pu être édité par Igor car il a été chiffré avec la clé publique K A. Nous allons donc jouer nos tests sur ce message, particulièrement avec la donnée I. Si le protocole s était correctement déroulé, Alice devrait découvrir que la valeur I est égale à l identité d Igor or c est l identité de Bob qu elle va trouver. Les figures 4.4 et 4.5 montrent l exécution du programme d Alice selon les tests qu Alice fait ou non. Figure 4.4 Test sur les données Figure 4.5 Aucun test sur les données Dans la figure 4.4, Alice vérifie la donnée I de {N A,N B,I}. Elle découvre que la valeur attendue n est pas Igor mais Bob, elle ne continue plus l acheminement des messages. On voit dans la figure 4.5 que le protocole finit bien si la vérification de l identité n est pas faite. Ce test montre avec évidence que l attaque de Lowe a une faille dans le cas où Alice fait un test sur l identité d Igor. Dans le cas contraire, le protocole se déroule normalement jusqu à la fin. Pour une visualisation du test dans le code, la figure 4.6 montre comment l étape 2.2 est codée avec la vérification sur l identité d Igor. 25

Figure 4.6 Tests d Alice sur les donnéees 26

Chapitre 5 Conclusion 5.1 Bilan du projet La première étape consistait à faire un travail de recherche sur les techniques et outils d attaques sur des canaux de communication non sécurisés. Nous avons mené à bien cette partie en testant chaque outil trouvé en faisant un bilan de notre avancement à chaque réunion. L étude de nombreux outils nous a ainsi permis de trouver le logiciel qui était le plus en adéquation avec notre projet. Comme nous l avons vu précédemment, pour des raisons techniques nous avons mis de côté Scapy pour passer à la partie de développement de ce projet en mettant en place une infrastructure de tests en local. Alors que des cas de tests ont été calculés à partir d un modèle du protocole décrit dans un langage dédié nommé HLPSL, ils restaient au niveau abstrait. Malgré un long moment passé à la recherche d implémentation de protocoles, la seule qui était exploitable était une implémentation du NSPK initialement développée en JAVA. Nous avons donc réussi à concrétiser quelques tests sur celle-ci. L attaque réalisée est l attaque de Lowe, dans laquelle les échanges sont représentés sous la forme de suite de messages entre deux participants Alice et Bob, et l interception de ces messages par un intrus Igor. Les cas de tests se jouent directement dans le code de l un des participants (Alice dans notre cas), nous avons ainsi pu jouer avec les vérifications sur les données pour influencer sur le déroulement du protocole. 5.2 Bilan personnel Concernant le travail en binôme, même si nous avions déjà effectué un projet en Master 1 ensemble, ce projet nous a permis de développer nos capacités d écoute et d organisation. En effet, nous nous sommes partagés les tâches à effectuer (surtout sur le travail de recherche), pour pouvoir avancer plus vite et pour ne pas développer la même partie. Nous nous sommes rencontrés à différents moments du projet pour pouvoir d une part, mettre en commun les sources et d autre part, effectuer des tests en commun. Ce projet nous a également permis de travailler sur un sujet assez peu développé dans le cadre de la formation et d avoir une dernière vision de la gestion de projet en groupe avant de partir en stage en entreprise. Ce sujet nous a permis de mieux assimiler les notions vues en Licence 3 dans le cadre du module Sécurité et cette mise en pratique avec une phase de recherche suivie de développement est un vrai plus pour notre emploi futur. Quant au développement, 27