Observation et analyse du trafic r�seau by JOUNES92

VIEWS: 25 PAGES: 21

									                                                                         Travaux pratique en Sécurité Informatique


                              TP N°1 : Observation et analyse du trafic réseau

Objectifs
            Expérimenter et analyser de façon pratique la communication et les services de bases dans un réseau local
par l’utilisation d’outils logiciels.

Outils d’observation et d’analyse
            Deux outils de type « sniffer » seront utilisés pour réaliser l’observation et l’analyse du trafic. Le premier
s’appelle Tcpdump. Il permet la capture et l’analyse en temps réel d’un trafic réseau donné. Il est très rudimentaire,
puisque exploitable en mode commande, et exigera de votre part d’avantage de réflexion pour l’interprétation des
résultats obtenus.
        Le deuxième s’appelle Wireshark. Il est plus convivial car utilisable en mode graphique avec un affichage plus
lisible. Wireshark est un excellent outil de capture et d’analyse de protocole de niveau applicatif.
        Ces deux outils permettent d’établir des filtres de capture de paquets de manière assez fine. Pour la réalisation
de ce TP, vous disposez de la plateforme suivante émulée par PC (VirtualBox).




                         192.168.10.11/24
                                                                                        192.168.10.2/24
                                                        Hub
                                                                                                          Serveur
           Client                                                                                          (Linux)
          (Linux)


                                                                                     192.168.10.12/24
                            192.168.10.10/24




                                          Client
                                                                                          Intrus
                                        (Windows)




        Cette plateforme est constituée d’un Serveur Linux (login : administrateur, password : nimda) et d’un Client
(Linux ou Window) qui servent à la génération d’un trafic TCP/IP et d’un troisième poste Linux (intrus) qui sert à la
capture et à l’analyse de ce trafic.
            Dans les sections suivantes, vous devez répondre aux différentes questions posées, en justifiant chacune
des réponses. Pour chaque question avec expérience, vous devez fournir :
                1.   une description de l'expérience
                2.   la ligne de commande
                3.   la sortie écran
                4.   et, éventuellement une analyse de cette sortie d’écran
                5.   Pour les questions sans expérience aucun canevas n’est imposé.




                                                              1
                                                                         Travaux pratique en Sécurité Informatique

Visualisation du trafic avec TCPdump
               1.   Sur le poste Intrus, ouvrir une fenêtre shell puis lancer la commande « tcpdump ip »
               2.   Sur le poste Client linux (lClient), exécuter la commande « ping –c 1 server »
               3.   Arrêter tcpdump en tapant CTRL-C puis décrire la sortie d’écran obtenue
               4.   Reprendre les étapes précédentes avec chacune des commandes tcpdump suivantes :
               5.   tcpdump icmp and src host lClient
               6.   tcpdump icmp and dst host server
               7.   tcpdump ‘icmp[0]=8’

Analyse de l'entête Ethernet
          1.    Effacer le cache ARP du poste Client en utilisant la commande « arp –d ip_adress »
          2.    A l’aide de tcpdump, afficher en format hexadécimal (option –xx), les trames Ethernet relatives aux
                requêtes ARP et ICMP échangées entre le poste Client et le poste Serveur
                Indication : la commande Ping utilise le protocole ARP pour obtenir l’adresse physique (Ethernet) de
                la machine distante puis utilise le protocole ICMP pour la joindre.
          3.    En rappelant brièvement la signification des champs qui composent une trame Ethernet, donner des
                exemples de valeurs que peut prendre le champ Type
          4.    A l’aide de la commande Unix ifconfig et la commande Windows ipconfig /all, relever les adresses
                physiques du client et du serveur
          5.    Identifier dans les trames Ethernet des paquets ARP, les adresses physiques source et destination.
                Que remarquez-vous ? expliquez
          6.    Déterminer la valeur du champ Type dans l’entête Ethernet des paquets ARP et ICMP échangés entre
                le serveur et le client
          7.    Par quel protocole les paquets ARP et ICMP sont-ils est immédiatement encapsulé ? Situez ces deux
                protocoles dans l'architecture TCP/IP

Analyse de l'entête TCP/IP
          1.    Depuis le poste Client, effectuer une connexion Telnet au Poste Serveur (login «client» mot de passe
                «client»)
          2.    A l’aide de tcpdump, capturer puis visualiser les trames appartenant au service Telnet
          3.    Identifier dans ces trames, l’entête IP et l’entête du protocole encapsulé dans IP, ensuite déterminer
                la longueur de ces deux entêtes puis Identifier où commence la charge utile
          4.    Localiser dans ces trames, l’emplacement des adresses IP et des ports source et destination puis
                indiquer leur valeur
          5.    Quel est le numéro de séquence du segment TCP SYN utilisé pour initier la connexion TCP entre le
                client et le serveur ? Qu’est qui permet d’identifier le segment comme étant de type SYN ?
          6.    Quel est le numéro de séquence du segment SYN/ACK envoyé par le serveur en réponse au SYN du
                client? Quelle est la valeur du champ ACK dans ce segment ?
          7.    Faire un schéma de ces échanges en notant à chaque fois la valeur du champ flags



Analyse de l'entête UDP
          1.    Indiquer un protocole de niveau applicatif qui s’appuie sur le protocole UDP



                                                            2
                                                                          Travaux pratique en Sécurité Informatique

            2.   Lancer à partir du le poste Client une commande qui emploie ce protocole applicatif
            3.   Déterminer à l’aide de tcpdump, le numéro de port utilisé par l’hôte destinataire pour contacter en
                 retour le client ? Comment l’hôte destinataire apprend-il ce numéro de port ?
            4.   Retrouvez et expliquez le schéma d’encapsulation du protocole UDP

Visualisation du trafic avec Wireshark
           Dans cette dernière partie, nous allons utiliser l’analyseur de protocole Wireshark pour analyser un
protocole applicatif.
       Au lancement de Wireshark, une interface utilisateur apparaître à l’écran. Il suffit alors de cliquer sur l’élément
Start dans le menu Capture pour démarrer la capture. Il faudra, éventuellement, choisir l’interface de capture en
cliquant dans le même menu sur l’élément Interfaces.
        Lorsque la capture est arrêtée, Wireshark affiche dans sa partie supérieure, ligne par ligne, la liste des trames
capturées. Lorsqu’une ligne est sélectionnée, son contenu, niveau par niveau (ou protocole par protocole), en
commençant par les couches basses (Par exemple, Ethernet II, Internet Protocol, etc.) est affiché dans la partie
centrale. Chaque niveau peut être déplié afin de visualiser le détail du protocole correspondant

Analyse du protocole FTP
            1.   Lancer la capture Wireshark sur le poste Intrus
            2.   Etablir depuis le poste client une connexion FTP au poste serveur puis télécharger le fichier «
                 readme.txt » en utilisant la commande FTP « get ». Une fois le téléchargement terminé, fermer la
                 connexion FTP avec la commande « quit »
            3.   Arrêter la capture wireshark puis limiter l’affichage aux seules trames transportant des messages ftp (port
                 20 et 21). Décrivez les trames capturées
            4.   Le protocole FTP est immédiatement encapsulé par un autre protocole. Dites lequel ?
            5.   A partir des trames affichées, faire un schéma des différents échanges effectués entre les deux hôtes.
                 On remarque que ftp utilise des connexions du protocole de niveau inférieur pour deux usages
                 différents. Lesquels ?
            6.   Afficher les flux de caractères ASCII véhiculés par le trafic FTP en cliquant sur l’élément follow TCP
                 stream dans le menu Analyse
            7.   Quel problème de sécurité remarquez-vous en observant ce flux ? Proposez une solution pour
                 résoudre ce problème.




                                                             3
                                                                           Travaux pratique en Sécurité Informatique


                              TP N°2 : Attaques et techniques utilisées


Objectifs
             Comprendre comment se prépare une attaque réseau puis tester et analyser certaines techniques
d’attaques. La connaissance de ces techniques est primordiale pour l’élaboration de mesures de protection et de
détection.

Phase Identification
             Dans une première phase, l’attaquant commence par identifier les noms de domaines enregistrés par la
cible en utilisant les registres publics des noms de domaines whois. Il s’agit d’un annuaire mondial qui permet d’avoir
des informations détaillées sur un domaine cible, plus particulièrement les adresses IP des serveurs principaux
appartenant à ce domaine.
       Vous       pouvez   interroger   les    registres     whois   sur   le   Net     en   utilisant   l’URL   suivante :
http://www.raynette.fr/services/whois. La sortie d’écran suivante concerne le nom de domaine enst.fr

        Informations sur le domaine 'enst.fr'
        Adresse IP de 'www.enst.fr' :                                  137.194.2.39
        Serveurs DNS :                                                 infres.enst.fr
                                                                       phoenix.uneec.eurocontrol.fr
                                                                       enst.enst.fr
                                                                       minos.enst.fr
         Serveur(s) mail :                                             smtp2.enst.fr

       Pour connaître l’ensemble des adresses IP allouées à la cible, il suffit ensuite de réaliser un script qui effectue
une résolution inverse à base d’adresses IP en utilisant la commande Unix host.

        host 137.194.2.4
              4.2.194.137.in-addr.arpa domain name pointer sagserv.enst.fr.

        host 137.194.3.4
              4.3.194.137.in-addr.arpa domain name pointer cal-ppp4.ppp.enst.fr.

        host 137.194.4.4
              Host 4.4.194.137.in-addr.arpa not found
        …
             8.   A l’aide de la commande nslookup, trouver depuis le poste Intrus l’adresse réseau attribuée au poste
                  server (nslookup server server).

Phase Reconnaissance
             Une fois l’adresse réseau du domaine cible identifié, des attaques de type « scan » sont employées afin
d’obtenir des informations sur les hôtes actifs de ce réseau.

             Nmap est un scanneur qui utilise des paquets IP bruts (raw packets) pour déterminer quels sont les hôtes
actifs sur le réseau, quels services (y compris le nom de l'application et la version) ces hôtes offrent et quels
systèmes d'exploitation (et leurs versions) ils utilisent.

             1.   En exécutant nmap (option –sP et option –sS) sur le poste Intrus, retrouver les machines actives du


                                                              4
                                                                        Travaux pratique en Sécurité Informatique

               réseau
          2.   Détecter les ports réseaux ouverts (de 1 à 5000) et les services actifs sur chaque hôte du réseau
               (option -p 1-5000)
          3.   En utilisant TCPdump ou wireshark, décrire brièvement la technique utilisée par nmap pour obtenir
               ces informations
          4.   En utilisant nmap (option –O), déterminer le système d’exploitation utilisé par chaque hôte actif du
               réseau

               Attention : Le scan d'un hôte est considéré juridiquement comme une attaque réseau. Sauf s’il est
               accompli sur un hôte dont l'auteur est lui même l'administrateur.
      Durant cette phase, la topologie du réseau cible peut être établie en utilisant la commande Unix traceroute
(tracert sous windows). Cette commande fournit la liste de tous les systèmes intermédiaires (routeurs) entre la
machine où la commande traceroute est exécutée et la machine cible.
          5.   Déterminez le nombre de routeurs franchis le poste Intrus jusqu’à aux hôtes précédemment identifiés.
               Essayer maintenant de schématiser la topologie du réseau auquel ils appartiennent

Phase Exploitation

Couche liaison : ARP poisoning
          1.   Choisir deux hôtes parmi ceux identifiés dans la phase précédente puis relever leur adresse IP et
               adresse physique. Faite la même chose avec le poste Intrus
                                                      Adresse IP                   Adresse physique
           Hôte 1
           Hôte 2
           Poste Intrus

          2.   En exécutant la commande ARP (ajouter l’option –a sous Windows) sur les deux hôtes choisis, relever
               le contenu de leur cache ARP

                          Hôte 1 : Cache ARP
                                    Adresse IP                     Adresse physique


                          Hôte 2 : Cache ARP
                                    Adresse IP                     Adresse physique


          3.   En utilisant le générateur de paquets ettercap -G (voir l'annexe II) sur la machine Intrus, réaliser une
               attaque « arp poisoning » contre les deux hôtes
          4.   Réexécuter la commande ARP sur les deux hôtes précédents. Comparer le contenu courant du cache
               ARP avec celui relever précédemment. Que remarquez-vous ? Quelles sont les conséquences d’un tel
               changement ? Expliquez.
          5.   Sur l’un des hôtes attaqués, lancer la capture Tcpdump (ou wireshark) pendant quelques secondes. En
               observant la sortie Tcpdump, indiquer de quel type de trames il s’agit essentiellement, puis en
               examinant les différents champs du protocole encapsulé dans ces trames, dites à quoi elles servent.
          6.   Expliquer maintenant la technique utilisée par l’attaque ARP poisoning. Quelle vulnérabilité exploite


                                                          5
                                                                              Travaux pratique en Sécurité Informatique

                    cette attaque ?

Attaque par débordement de tampon



Objectifs
               Comprendre le principe du débordement de tampon, appelée communément « buffer overflow », qui
touche la majorité des systèmes d’exploitation et apprendre de quelle manière il est exploité pour mener une attaque
contre le système.

       Important : Il est fortement recommandé de lire soigneusement le document de Aleph one intitulé Smashing
stack for fun and profite (traduction en français) avant la séance de travaux pratiques.

Outils utilisés
               gdb (GNU DeBugger) est un débogueur Unix pour les programmes compilés par gcc. Il sera utiliser pour
examiner un programme pendant son exécution. Ci-dessus les commandes à connaître (Pour plus de détailles tapez
gdb -help).

       -       « gdb programme » : Ouverture du programme dans le débogueur;
       -       « run argument » : exécution du programme avec argument ;
       -       « disassemble @debut @fin » : affichage des instructions en langage assembleur situées entre les
               adresses @debut et @fin.
               ddd est une interface graphique pour le débogueur gdb (Pour plus de détailles tapez man ddd)

               Enfin, hexedit est un éditeur hexadécimal Unix. Il sera utilisé pour visualiser, éditer et modifier des fichiers
binaires. Ci-dessus les commandes à connaître (Pour plus de détailles, consultez le manuel d’utilisation de hexedit).

       -       « hexedit Fichier » : Ouverture du fichier ;
       -       « F2 » : Enregistrement du fichier ;
       -       « Ctrl-C » : Fermeture l’éditeur hexedit.

Principe du débordement de tampon
               Soit le programme vulnerable.c suivant:


           #include <string.h>
           void vulnerable (char *argument) {
                       char buffer[6] ;
                       strcpy(buffer, argument) ;
           }
           int main (int argc, char **argv) {
                       if(argc>1) vulnerable(argv[1]) ;
                       return(0);
           }

       1.         Editer ce programme puis compiler le avec l’option –g pour inclure dans le fichier exécutable les
  informations nécessaires pour le débogage

       2.         Désactiver la fonction exec-shield du noyau en exécutant la commande                           « echo 0 >
  /proc/sys/karnel/exec-shield ». La nécessité d’un tel changement dans la configuration du noyau sera expliquée


                                                                6
                                                                                Travaux pratique en Sécurité Informatique

  plus tard

       3.          Exécuter le programme test avec les arguments suivants :
                  test AAAAAA
                  test AAAAAAAAAA
                  test AAAAAAAAAAAAAA
       4.          Décrivez le comportement de ce programme lors de la variation de la taille de son argument

       Vous aller maintenant utiliser le débogueur GDB pour examiner le comportement de ce programme durant
  son exécution.

                         5.   Lancer le programme gdb en tapant « gdb vulnerable»

       6.          A l’aide de la commande « run », lancer à partir de gdb l’exécution du programme test avec comme
  argument « AAAAAABBBBCCCC »

       7.          Afficher le contenu des deux registre ebp et eip en utilisant la commande « Info reg ebp eip». Que
  remarquez-vous ?

       Indication : le code ASCII du caractère « A » est 0x41, celui de « B » est 0x42 et celui de « C » est 0x43.

       8.          A présent, Expliquer à quoi est dû le changement de comportement du programme test.
       Indication : Pensez à schématiser la structure de la pile avant et après l’exécution de la fonction strcpy().

Principe de l’attaque basée sur le débordement de tampon
            Soit le programme vulnerable.c suivant :
       #include <stdio.h>
       #include <unistd.h>
       void lireMessage() {
                  char buffer[12];
                  puts("Quel est ton Message ?");
                  gets(buffer);
       }
       void attaque() {
                  printf("Attaque reussie!\n");
       }
       int main() {
                  lireMessage();
                  puts("Message bien reçu.");
                  return(0);
       }

                    Remarque : Ne vous souciez pas de l’apparition de la fonction attaque() dans le code du programme.
                    Elle sera exploitée plus tard.
              1.    Editer puis compiler ce programme.
                    Remarque : Lors de la compilation le message d’avertissement suivant sera affiché:
                        ” /tmp/xxxxxxx.o : In function `lireMessage’: /…/vulnerable.c:7 : AVERTISSEMENT : the `gets’ function is
                        dangerous and should not be used. ”
                    Ce message fait référence au fait que la fonction gets() ne dispose d’aucun moyen pour connaître la



                                                                  7
                                                                          Travaux pratique en Sécurité Informatique

              taille de la variable qui lui est fournie. Ainsi, s’il arrive que la valeur entrée soit très longue, il est
              possible que l’écriture se fasse au delà des emplacements réservées à cette variable provoquant ainsi
              un débordement de tampon. C’est justement cette erreur qui sera exploitée pour réaliser l’attaque.

         2.   Exécuter le programme obtenu puis entrer le message « hello ». Vérifier que son comportement
              correspond au code décrit précédemment.

Recherche d’informations
         1.   Lancer le débogage du programme vulnerable à partir du logiciel ddd en tapant « ddd vulnerable »

         2.   Depuis l’interface graphique de ddd, visualiser la fenêtre « code machine » en cliquant sur l’élément
              « Machine Code Windows » dans le menu « View ». désormais, l’interface ddd se subdivise en trois
              parties :
                         La fenêtre source qui contient le code source C du programme vulnerable.
                         La fenêtre code machine qui contient le code assembleur de la fonction main(). Il est possible
                          de remplacer main() par une autre fonction, en double cliquant simplement sur le nom de
                          cette dernière dans la fenêtre source.
                         La fenêtre console qui fournie l’interface avec la ligne de commande du débogueur GDB ;
                          C’est à travers cette fenêtre que les échanges avec gdb seront réalisés.

              L’interface ddd dispose aussi d’une boite à outils (avec le bouton « run » au sommet) qui fournit des
              boutons raccourcis pour les commandes gdb les plus utilisées.

         3.   Exécuter le programme vulnerable en cliquant sur le bouton « run » de la boite à outils. Une fenêtre
              d’exécution s’affiche alors pour vous demander d’introduire le message. Une fois le message introduit, le
              programme termine son exécution. Déplacer la fenêtre d’exécution sur le côté sans la fermée.

         4.   Ajouter un point d’arrêt ou « breakpoint » pour suspendre momentanément l’exécution du programme
              juste après l’affichage de la chaîne de caractère « quel est ton message? ». Pour cela, il suffit de faire
              un click droit devant de la ligne « gets(buffer); », puis de sélectionner l’élément « set breakpoint »
              dans le menu contextuel qui s’affiche. Un signe Stop apparaît pour indiquer l’emplacement du point
              d’arrêt.

         5. En utilisant le bouton « run » de la boite à outils, réexécuter à nouveau le programme. L’exécution du
              programme sera suspendue lorsqu’elle atteint le point d’arrêt. Une flèche verte est affichée dans la
              fenêtre source et une autre dans la fenêtre code machine désignant ainsi l’endroit où l’exécution du
              programme a été suspendue.

         6.   Afficher le contenu du tableau buffer et des 12 octets qui lui succèdent dans la mémoire (24 octets au
              total). A cet effet, cliquer sur l’élément « memory…> dans le menu « Data ». Une fois la fenêtre
              « Examine memory » affichée, introduire la valeur 24 dans le champs « examine », ensuite
              positionner le liste déroulante sur la valeur hex et enfin introduire la chaîne de caractère buffer dans
              le champ « from ». Valider en cliquant sur le bouton « display ». Une fenêtre de données s’affichera
              alors au dessus de la fenêtre du code source. Cette fenêtre contient une table de 3 lignes, chaque
              ligne débute par une adresse mémoire suivie par les valeurs en format hexadécimal de 8 cases
              mémoires successives. L’ensemble de ces valeurs correspond aux 24 octets dont l’affichage a été



                                                             8
                                                                          Travaux pratique en Sécurité Informatique

                 demandé.

            7.   Exécuter uniquement l’instruction « gets(buffers); » en cliquant sur le bouton « next » de la boite à
                 outils. Le programme se mettra alors en attente de l’entrée d’une chaîne de caractères.

            8.   Taper « hello » suivie de la touche entrée dans la fenêtre d’exécution. Observer la présence dans la
                 zone mémoire affichée à l’étape 6 des valeurs successives « 0x68 » « 0x65 » « 0x6c » « 0x6c »
                 « 0x6f » qui correspondent respectivement aux codes ascII « h », « e », « l », « l », et « o ». Ce qui
                 signifie que la fonction gets() a placé la chaîne de caractère « hello » dans le tableau buffer.

            9.   En examinant la fenêtre code machine de la fonction main(), relever l’adresse de l’instruction qui suit
                 immédiatement la fonction lireMessage().

            10. Chercher où se situe cette adresse dans la zone mémoire affichée à l’étape 6 ; vous devez la
                 retrouvée puisqu’elle est enregistrée par l’instruction call lireMessage de la fonction main().

            11. Remarque : l’adresse mémoire recherchée apparaît en ordre inverse. Ceci est du au faite que les
                 processeurs INTEL choisissent de sauvegarder les nombres longs en commençant par l’octet de poids
                 faible.

            12. Déterminer enfin la distance en bytes depuis la fin du tableau buffer jusqu’à cette adresse de retour.


Altération du flux d’exécution
           Vous avez certainement remarqué que le programme vulnerable n’appelle jamais la fonction attaque().
Nous allons maintenant exploiter le problème relatif à l’instruction gets() (signalé par le compilateur gcc) pour faire
déborder la pile et remplacer l’adresse de retour de la fonction lireMessage() par l’adresse de la première instruction
de la fonction attaque().
       Il est évident que l’entrée du programme vulnerable doit être une chaîne binaire particulière lue depuis un
fichier puisqu’elle ne peut être introduite depuis le clavier.
            1.   Relever l’adresse de début de la fonction attaque().

            2.   Créer un fichier vide altererExecution puis éditer le avec l’éditeur hexedit ; Introduire les      valeurs
                 hexadécimales qui permettent de faire déborder la pile et de modifier l’adresse de retour pour quelle
                 pointe vers la fonction attaque().

                 Remarque : l’instruction gets() continue la lecture jusqu’à ce qu’elle rencontre le code ascII 0x0A
                 correspondant à un retour au début de ligne (newline).

            3.   Vérifier que la fonction attaque() opère correctement. En tapant dans le shell la commande
                 « ./vulnerable < altererExecution », le programme doit afficher le message « Attaque reussie! ».

            4.   Remarque : Si vous souhaitez utiliser le débogueur pour analyser le comportement du programme,
                 ouvrez le dans le débogueur, puis lancez son exécution en tapant la commande « run <
                 altererExecution ».


Construction du code d’attaque
           Maintenant que nous savons comment modifier le flux d'exécution d’un programme vulnérable au
débordement de tampon, nous allons lui demander d’exécuter un code d’attaque qui nous offre un shell.


                                                                 9
                                                                          Travaux pratique en Sécurité Informatique

      Ci-dessous à droite figure le code source C du programme qui permet d’obtenir un shell. En face de lui figure
une séquence de valeurs hexadécimales qui représentent sa traduction en codes machines, connue sous le nom de
shellcode.


        #include <stdio.h>                                  0xeb 0x1f 0x5e 0x89 0x76 0x08 0x31 0xc0 0x88
        void main() {                                       0x46 0x07 0x89 0x46 0x0c 0x89 0xf3 0x8d 0x4e
          char *name[2];                                    0x08 0x8d 0x56 0x0c 0xb0 0x0b 0xcd 0x80 0x31
          name[0] = "/bin/sh";                              0xdb 0x89 0xd8 0x40 0xcd 0x80 0xe8 0xdc 0xff 0xff
          name[1] = NULL;                                   0xff 0x2f 0x62 0x69 0x6e 0x2f 0x73 0x68
          execve(name[0], name, NULL);
        }

      Précision : Le shellcode ci-dessus correspond uniquement à un système Linux basé sur un processeur Intel :
      Les détails des appels systèmes tel que exceve(), changent d'un OS à un autre, et d'un CPU à un autre.
      Reportez-vous au document de Aleph one cité au début de ce document pour savoir comment est réalisée la
      traduction ci-dessus.

             1.   En exécutant le programme shellcode.c suivant, vérifier que le shellcode fonctionne correctement.
                  Dites à quoi servent les instructions en gras.

   char shellCode[] =
                     "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\x89\xf3"
                     "\x8d\x4e\x08\x8d\x56\x0c\xb0\x0b\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
                     "\x80\xe8\xdc\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68";
        void execShell() {
          int *ret;
          ret = (int *)&ret + 2;
          (*ret) = (int)shellCode;
        }
        void main() {
          execShell();
          return(0);
        }




Injection et exécution du code d’attaque
      Pour des raisons de simplicité, nous avons choisi dans l’exemple précédant d’implémenter le code d’attaque
(représenté par la fonction attaque()) directement dans le programme vulnerable. Cependant une telle disposition n’a
rien de réaliste c’est pourquoi nous voulons maintenant que notre code d’attaque, à savoir le shellcode, soit injecté
dans l’espace d’adressage du programme vulnerable durant son exécution. L’idée consiste alors à placer le code
d’attaque dans l’espace mémoire réservée à la variable buffer dans la pile puis d’utiliser la technique de
débordement de tampon pour remplacer l’adresse de retour par l’adresse de la première instruction du code
d’attaque.
             1.   Ouvrer le fichier vulnerable.c, puis augmenter la taille du tableau buffer à 50 octets pour qu’il puisse
                  contenir le shellcode, ensuite recompiler le.

             2.   A l’aide de l’éditeur hexedit, écrire dans un fichier nommé codeAttaque, le shellcode ainsi que la



                                                             10
                                                                        Travaux pratique en Sécurité Informatique

                nouvelle l’adresse de retour qui pointe vers ce code (voir figure). Utiliser ddd pour retrouver la valeur
                de l’adresse de retour.

                Indication : Le contenu du fichier codeAttaque sera injecté directement dans la pile du programme
                vulnerable grâce à la fonction gets().

           3.   Vérifier à l’aide du débuggeur que l’injection du shellcode opère correctement. A cet effet, placer dans
                des endroits appropriés, des points d’arrêts, puis lancer l’exécution du programme en tapant la
                commande « run < codeAttaque » dans la console, puis observer les changements opérés sur le
                contenu de la pile du programme.

           4.   Après avoir lancer plusieurs fois le programme depuis le débogueur, observer la localisation de la
                variable buffer dans la mémoire. Que remarquez-vous ? quel problème cela pose-il ?

           5.   Pour résoudre ce problème, placer un point d’arrêt devant l’instruction gets(), lancer l’exécution du
                programme, ensuite relever l’adresse de début de la variable buffer puis modifier le fichier d’entrée
                codeAttaque avant de continuer l’exécution du programme.

           6.   Que constatez-vous lors de l’exécution de l’instruction de retour « ret » de la fonction lireMessage() ?
                Expliquez ce qui va se produire.


Mécanisme de protection
          Actuellement la plupart des systèmes offrent une protection contre l’exploitation du débordement de
tampon. Cette protection peut être configurée via le fichier du noyau « exec-shell ».
           1.   Utiliser la commande « echo 1 > /proc/sys/karnel/exec-shield » pour remettre la valeur de ce fichier à
                1. Réexécuter le programme shellcode précédent. Que se passe-t-il cette fois ci ?

           2.   Expliquer brièvement la technique de protection utilisée.




                                                           11
                                                                             Travaux pratique en Sécurité Informatique

                                           TP N°3 : Filtrage de paquets

Objectifs
            Utiliser et maîtriser le filtrage de paquets via Iptables. Assurer la protection d’un système des accès non
autorisés en créant des nouvelles règles de filtrage.

Description de l’outil
            Le noyau Linux comporte des systèmes de filtrage IP. Plusieurs systèmes se sont succédés au fil du temps:
ipfwadm, ipchains et iptables. Pour ce TP, nous utiliserons le dernier en date : iptables, appelé aussi netfilter.
       Netfilter/Iptables est un pare-feu Linux libre qui assure la mise en place, la maintenance et l’inspection des
règles de filtrage.

       Pour la réalisation de ce TP, vous disposez de la plateforme suivante émulée par PC (virtualbox).




                           192.168.10.11                                                   192.168.10.2


                                                                                                          Serveur
              lClient

       Cette plateforme est constituée d’un serveur sur lequel est installé un pare-feu, et d’un poste de travail qui
servira pour tester les différentes règles de filtrage implémentées dans le pare-feu.

Les chaînes et les règles de filtrage
            Les règles de filtrage sont organisées en chaînes. Chaque chaîne est une succession de règles. Il y a trois
chaînes prédéfinies dans la table de filtrage :
                  La chaîne d’entrée (input) : Elle filtre les paquets IP destinés à des processus de la machine elle-
                même ;
                  La chaîne de transfert (forward) : Elle filtre les paquets IP destinés à une autre machine ;
                  La chaîne de sortie (output) : Elle filtre les paquets émis par les processus de la machine elle-même.
       A chaque fois qu’un paquet arrive au pare-feu, il est orienté selon certains paramètres vers la chaîne
concernée (voir schéma suivant).


                                            Décision         Chaîne de
                  Paquets reçus               de                                      Paquets émis
                                                              transfert
                                            routage




                                           Chaîne                              Chaîne de
                                           d’entrée                              sortie


                                                           Processus local




                                                              12
                                                                               Travaux pratique en Sécurité Informatique

        Initialement, ces chaînes sont vides. Il est possible alors de définir des règles de filtrage pour chaque chaîne
qui permettent de prendre une décision face à tout paquet qui la traverse. Chaque règle est un ensemble de
conditions, qui lorsqu’elles sont vérifiées, vont aboutir à une décision pour le paquet traité. Les décisions principales
sont:
          -             ACCEPT: le paquet est autorisé à traverser la chaîne
          -             DROP: le paquet est jeté
          -             REJECT: le paquet est jeté et sa source est prévenue par un paquet ICMP
          -             LOG : Le paquet est journalisé
        Les règles sont examinées séquentiellement. La première règle dont les conditions correspondent au paquet
traité, est appliquée.
        La manipulation des chaînes et des règles de filtrage s’effectue à travers la commande iptables. Voici les
options de cette commande qui vous seront utiles lors des prochaines manipulations (Pour plus de détails, consultez
le manuel d’utilisation d’iptables) :
              -L : affiche la liste des règles d’une ou de toutes les chaînes existantes
              -F               : efface toutes les règles d'une chaîne existante
              -D               : efface une règle particulière d’une chaîne
              -N               : crée une nouvelle chaîne
              -X               : supprime une chaîne vide
              -P               : attribue la politique par défaut (ACCEPT ou DROP) à une chaîne
              -A               : ajoute une nouvelle règle à la fin d'une chaîne
              -I               : insère une nouvelle règle à une position donnée dans une chaîne

Politique de filtrage par défaut
        Pour chaque chaîne, il est possible de choisir entre deux politiques de filtrage :
                    DROP : Tout ce qui n'est pas explicitement autorisé est interdit. Les règles de filtrage de la chaîne
                    consistent alors à laisser passer ce qui est autorisé.
                    ACCEPT : Tout ce qui n'est pas explicitement interdit est autorisé. Les règles de filtrage de la chaîne
                    consistent alors à bloquer ce qui est interdit.
               1.    Lancer la commande iptables -L puis observer la sortie d’écran

               2.    Quelle est la politique adoptée par chacune des chaînes prédéfinies ?


Exploitation des règles de filtrage
               1.    Créer sur le poste pare-feu un répertoire nommé « firewall »

               2.    Copier dans ce répertoire le fichier regles-filtrage.tar.gz puis décompacter le avec la commande « tar
                     xvzf regles-filtrage.tar.gz ». Vous devez obtenir les quatre fichiers scripts suivants : deny-all, accept-
                     all, block-ip et unblock-ip

               3.    Rendre ces fichiers exécutables (droits d’accès chmod 700 file)

               4.    Exécuter le script deny-all en tapant « ./deny-all ». Essayer maintenant de faire un ping vers localhost
                     et 192.168.10.11. Que constatez-vous ? Décrivez les commandes utilisées par ce script

               5.    Editer le script deny-all puis décommenter les lignes suivantes :



                                                                  13
                                                                         Travaux pratique en Sécurité Informatique


                    #INTERFACE_LOOPBACK=lo

                    #iptables -A OUTPUT –o $INTERFACE_LOOPBACK –j ACCEPT
                    #iptables -A INPUT –i $INTERFACE_LOOPBACK –j ACCEPT


           6.   Exécuter le script obtenu puis ressayer à nouveau les deux commandes Ping précédentes. Que
                constatez-vous cette fois ci ? Expliquez

           7.   Afficher les informations concernant les paquets examinés par le pare-feu en utilisant la commande
                « iptables –L -v». Commenter la sortie d’écran

           8.   Exécuter le script accept-all en tapant « ./accept-all » puis essayer de faire un ping vers localhost et
                192.168.10.254. Que constatez-vous ? Décrivez les commandes utilisées par ce script

           9.   Exécuter le script block-ip en tapant « ./block-ip 192.168.10.11 ». Essayer maintenant de faire un ping
                vers localhost et 192.168.10.11. Que constatez-vous ? Décrivez les commandes utilisées par ce script

           10. Exécuter le script unblock-ip en tapant « ./unblock-ip 192.168.10.11 » puis essayer de faire un ping
                vers localhost et 192.168.10.11. Que constatez-vous ? Décrivez les commandes utilisées par ce script


Création de nouvelles règles de filtrage
          Dans cette partie, il vous est demandé de créer des nouvelles règles de filtrage permettant d’assurer des
exigences de sécurité particulières. Pour chaque règle, vous devez :
               commencer par effacer toutes les règles existantes dans les chaînes de la table de filtrage puis
                s'assurer qu'aucune règle n'est appliquée. Ensuite, vous devez choisir puis appliquer à chaque chaîne
                une politique de filtrage par défaut.
               inclure dans le rapport, une description détaillée de toutes les règles de filtrage demandées, ainsi que
                la description du test réalisé sur chacune d’elles, à savoir la sortie d’écran des commandes utilisées
                pour le test et/ou la capture d’écran d'un sniffer (wireshark par exemple)
        Voici les exigences de sécurité que doit assurer le pare-feu :

           1.   Interdire un paquet s’il ne provient pas de localhost

           2.   Interdire le protocole ICMP à destination de localhost

           3.   Interdire tout paquet à destination du port Telnet

           4.   Interdire tout paquet sortant par eth0 et dont le numéro du port destination est inférieur à 1024

           5.   Interdire toute tentative d’initialisation de connexion TCP provenant de eth0

           6.   Interdire toute réponse à un Ping

           7.   Interdire tout paquet entrant par eth0 et dont l’adresse physique n’est pas celle du poste de travail
                Remarque : Attention, vous ne pouvez utiliser le filtrage par adresse physique que sur la chaîne INPUT

           8.   Interdire les paquets provenant du sous-réseau local 192.168.10.0/24 sauf ceux en provenance du
                poste de travail.

                Remarque : Vous devez utiliser, dans ce cas, deux règles de filtrage.
                Appliquer ces règles puis essayer d’établir depuis le poste de travail, une connexion FTP vers le pare-


                                                           14
                                                                          Travaux pratique en Sécurité Informatique

                  feu. Inversez l’ordre de ces deux règles puis réessayez l’opération. Que remarquez-vous ? Quelle
                  conclusion pouvez-vous en tirer ?

             9.   Écrire une règle qui laisse passer 5 tentatives de connexion TCP avec une fréquence de 2 tentatives
                  par minute

             10. Créer une nouvelle chaîne qui journalise puis rejette tout paquet qui la traverse. Les paquets
                  journalisés doivent être précédés par le préfixe [FIREWALL DROP]. Renvoyer ensuite sur cette nouvelle
                  chaîne tout paquet entrant qui demande l’établissement d’une nouvelle connexion

             Vous avez certainement remarqué que pour toutes les règles de filtrage créées précédemment, la décision
de laisser passer ou de bloquer un paquet est prise uniquement sur la base des informations contenues dans le
paquet lui-même. On parle dans ce cas de filtrage sans état (stateless). Netfilter/Iptables met en oeuvre un
mécanisme de suivi de connexions (option --state) lui permettant d’assurer également un filtrage avec état
(statefull). Dans ce cas, la décision de laisser passer ou de bloquer un paquet prend également en compte les
paquets traités ultérieurement par le pare-feu.
             Les connexions suivies par le pare-feu peuvent être dans l'un des états suivants:
         -          NEW: le paquet est le premier d'une connexion (ex: paquet TCP SYN)
         -          ESTABLISHED: le paquet fait partie d'une connexion déjà établie
         -          RELATED: le paquet est en rapport avec une autre connexion déjà établie
         -          INVALID: paquet non identifié
             11. Positionnez la politique de filtrage par défaut à DROP pour les trois chaînes prédéfinies

             12. Autoriser tout paquet sortant appartenant à une connexion déjà établie ou en rapport avec une
                  connexion déjà établie

             13. Interdire tout paquet sortant relatif à une connexion de type INVALID

             14. Autoriser tout paquet créant une nouvelle connexion en entrée à destination du port 80

             15. Utiliser le navigateur web du poste de travail pour accéder à l’adresse URL « http://server/ ». Que
                  constatez-vous ?

             16. A présent, essayer l’adresse URL suivante « http://192.168.10.2/site ». Que constatez-vous cette fois
                  ci ? Un problème se pose. Dites lequel ?

             17. Que doit-on faire pour le résoudre ?


Analyse d’un script de filtrage
             Soit les commandes iptables suivantes. Elles forment ensemble un script permettant de mettre en place
une protection minimaliste d’un pare-feu.

                      iptables -F INPUT
                      iptables -F OUTPUT
                      iptables -F FORWARD



                      iptables -P INPUT DROP
                      iptables -P FORWARD DROP



                                                             15
                                                       Travaux pratique en Sécurité Informatique

iptables -P OUTPUT DROP



iptables -N log-and-drop
iptables -A log-and-drop -j LOG --log-prefix "drop "
iptables -A log-and-drop -j DROP



iptables -A FORWARD -p tcp --tcp-flags ALL ALL -j log-and-drop
iptables -A FORWARD -p tcp --tcp-flags ALL NONE -j log-and-drop



iptables -A FORWARD -i eth+   -s 224.0.0.0/4 -j log-and-drop
iptables -A FORWARD -i eth+   -s 192.168.0.0/16 -j log-and-drop
iptables -A FORWARD -i eth+   -s 172.16.0.0/12 -j log-and-drop
iptables -A FORWARD -i eth+   -s 10.0.0.0/8 -j log-and-drop



iptables -A FORWARD -m state --state INVALID -j log-and-drop
iptables -A FORWARD -m state --state RELATED,ESTABLISHED -j ACCEPT



EXT_IFACE="eth0"
DMZ_IFACE="eth1"
iptables -N ext-dmz
iptables -N dmz-ext
DMZ_ADDR=192.168.10.0/24
iptables -A FORWARD -s $DMZ_ADDR -i $DMZ_IFACE -o $EXT_IFACE -j dmz-ext
iptables -A FORWARD -o $DMZ_IFACE -j ext-dmz
iptables -A FORWARD -j log-and-drop



iptables -N icmp-accept
iptables -A icmp-accept -p icmp --icmp-type destination-unreachable -j ACCEPT
iptables -A icmp-accept -p icmp --icmp-type source-quench -j ACCEPT
iptables -A icmp-accept -p icmp --icmp-type time-exceeded -j ACCEPT
iptables -A icmp-accept -p icmp --icmp-type echo-request -j ACCEPT
iptables -A icmp-accept -p icmp --icmp-type echo-reply -j ACCEPT
iptables -A icmp-accept -j log-and-drop



iptables -A ext-dmz -p tcp --dport smtp -j ACCEPT
iptables -A ext-dmz -p udp --dport domain -j ACCEPT
iptables -A ext-dmz -p tcp --dport domain -j ACCEPT
iptables -A ext-dmz -p tcp --dport www -j ACCEPT
iptables -A ext-dmz -p tcp --dport https -j ACCEPT
iptables -A ext-dmz -p tcp --dport ssh -j ACCEPT
iptables -A ext-dmz -p icmp -j icmp-accept
iptables -A ext-dmz -j log-and-drop



iptables -A dmz-ext -p tcp --dport smtp -j ACCEPT
iptables -A dmz-ext -p tcp --sport smtp -j ACCEPT


                                       16
                                                               Travaux pratique en Sécurité Informatique

         iptables -A dmz-ext -p udp --dport domain -j ACCEPT
         iptables -A dmz-ext -p tcp --dport domain -j ACCEPT
         iptables -A dmz-ext -p tcp --dport www -j ACCEPT
         iptables -A dmz-ext -p tcp --dport https -j ACCEPT
         iptables -A dmz-ext -p tcp --dport telnet -j ACCEPT
         iptables -A dmz-ext -p icmp -j icmp-accept
         iptables -A dmz-ext -j log-and-drop



         iptables -N ext-frw
         iptables -N dmz-frw

         iptables -A INPUT -i $EXT_IFACE -j ext-frw
         iptables -A INPUT -i $DMZ_IFACE -j dmz-frw



         iptables -A ext-frw   -p icmp -j icmp-accept
         iptables -A ext-frw   -p tcp --dport ssh -j ACCEPT
         iptables -A ext-frw   -p tcp --sport ssh -j ACCEPT
         iptables -A ext-frw   -j log-and-drop



         iptables -A dmz-frw -p icmp -j icmp-accept
         iptables -A dmz-frw -j ACCEPT


1.   Expliquer pour chaque partie de ce script, les règles utilisées et leur rôle

2.   Réaliser pour chaque partie les tests qui permettent d’en vérifier le bon fonctionnement. Inclure dans
     le rapport la sortie et/ou les captures d’écran des différentes commandes utilisées lors des tests

3.   d’après ce script, où se situe exactement le pare-feu dans l’architecture réseau ? donnez une
     description générale (toujours selon ce script) de la protection qu’il permet d’assurer




                                                  17
                                                                          Travaux pratique en Sécurité Informatique

                                        TP N°4 : Web Sécurisé avec SSL


Objectif
       Développer une sécurité concernant l'authentification d'un serveur Web et la confidentialité de ses échanges
avec les clients en utilisant le protocole SSL.

Description du protocole SSL
           L’accès aux pages web se fait à l'aide du protocole http. Malheureusement, il n’y a aucune garantie de
confidentialité lorsque les accès empruntent un réseau public tel que Internet ; Il est relativement simple à un pirate
d'intercepter les requêtes du client (code de carte bleue par exemple) et les réponses faites par le serveur. En outre,
il n’y a aucune certitude que le site en cours de consultation est celui que l’on croit être.
       Le protocole SSL peut remédier à ces inconvénients en encapsulant et en chiffrant le trafic http. Ainsi, il sera
quasiment impossible à un pirate qui intercepterait des accès à des pages chargées via le protocole https de
décrypter cet échange, et donc de récupérer des informations confidentielles. En outre, https permet de s'assurer que
le serveur auquel on accède est bien celui que l'on croit être.
       Pour la réalisation de ce TP, vous disposer de la plateforme suivante émulée par PC (VMware).




                            192.168.10.11                                               129.168.10.2



                                                                                                       Serveur Web
             Client                                                                                    avec Apache
      avec navigateur web


           Cette plateforme est constituée d’un poste sur lequel est installé un serveur Web de type Apache et d’un
poste client possédant un navigateur web. Ce dernier va servir à tester l’accès aux pages Web exposées par le
serveur Apache.

Démarrage et configuration du serveur Web
           Le fichier de configuration du serveur Apache est /etc/apache2.conf
            1.   Le serveur apache est lancé par défaut.
                 Remarque : Pour que le serveur apache relit son fichier de configuration, vous devez le redémarrer
                 après chaque modification avec la commande « service apache2 relaod ou stop + start».

            2.   Depuis le poste client, tester la connexion au serveur apache en essayant d’afficher son état dans le
                 navigateur web

            3.   Saisir sur une console les lignes suivantes. Une fois la saisie terminée, taper sur CTRL-D

       cat > /var/www/login.html
        <html>
        <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
        <html><head><title>voic le document</title></head><body>
        <form       name="form1"            action="verif.php"><big><big>Authentification        par      mot        de



                                                             18
                                                                           Travaux pratique en Sécurité Informatique

       passe:</big></big><br>
        <br>
        <big>Nom</big>&nbsp; &nbsp;&nbsp;&nbsp;&nbsp; <input name="pseudo" type="text">
       <br><big>Prénom</big>&nbsp; <input name="pass" type="password"><br>
        <br>
       <input value="Valider" name="b_valider" type="submit">
       </form>
       </body></html>
                 Cette opération ajoute sous la nouvelle racine, une page html, login.html, titrée « Authentification par
                 mot de passe ».
            4.   Pour avoir une réponse au login, rajouter les fichier suivant : verif.php.

     cat > /var/www/verif.php
       <?php
       echo 'Bonjour : ' , $_GET['pseudo'] , '<br>';
       echo 'votre mot de passe est :' , $_GET['pass'] ;
       ?>


            5.   Tester l'accès à cette page via l’URL http://server/login.html tout en suivant avec Wireshark le flux TCP
                 engendré
                 Remarque : pensez à effacer le cache du navigateur Web du poste client pour que la lecture se fasse
                 à partir du serveur Web.

            6.   Analyser les requêtes et les réponses http échangées entre le client et le serveur apache. Que
                 constatez-vous ?


Sécurisation par mot de passe
         On souhaite maintenant restreindre l'accès à la page login.html à un ensemble particulier d'utilisateurs.
            1.   Préciser dans le fichier de configuration d’apache via la section Directory :

                 −    le type d'authentification demandé avec la directive AuthType. Vous lui affecterez la valeur Basic
                      ;

                 −    le texte d'invite à afficher au moyen de la directive AuthName, à laquelle vous affecterez une
                      chaîne de caractères entre guillemets ("Acces restrient") ;

                 −    le chemin d'accès au fichier contenant les mots de passe (AuthUserFile).

                 −    les personnes qui ont accès à la sous-arborescence au moyen de la directive Require (Plusieurs
                      valeurs sont possibles pour cette directive) Utiliser la directive user suivi d'une liste de noms
                      d'utilisateurs séparés par des espaces.

            2.   Utiliser l’utilitaire htpasswd fourni par Apache pour créer le fichier des mots de passe. Par exemple, la
                 commande suivante crée un nouveau fichier de mots de passe, nommé fichierPassword qui contient
                 l'utilisateur client.




                                                             19
                                                                        Travaux pratique en Sécurité Informatique


        htpasswd -c fichierPassword client

           3.   Suivre la suite de requêtes/réponses entre le client et le serveur apache avec wireshark lors de l’accès
                à la page Web http://server/login.html. Utiliser un couple utilisateur/mot de passe autorisé pour
                l’authentification. Analyser les trames capturées et retrouver la portion qui contient le mot de passe.
                Cette dernière est codée en Base64 (pour plus de détailles sur le codage en base64, consultez le
                page http://fr.wikipedia.org/wiki/Base64).

           4.   Conclusion ?


Sécurisation par certificat X.509
          On souhaite maintenant établir une connexion sécurisée avec le serveur Web via le protocole SSL. Pour
cela, vous devez créer une clé privée et un certificat pour le serveur Web. Par souci de simplification, nous allons nous
contenter dans cette partie d'un certificat auto-signé.
           1.   Vérifier que les deux packages openssl est pré-installé sur le serveur.

           2.   Créer un certificat auto-signé en lançant les commandes suivantes :

      openssl genrsa –des3 –out serveur.key 1024 ;
      openssl req -new -x509 -days 365 -key serveur.key -out serveur.crt

           3.   Expliquez les étapes précédentes et les arguments utilisés

           4.   Retirer le mot de passe qui protége la clé privée engendrée

           5.   Modifiez maintenant le fichier de configuration d'apache pour :

                −    Attendre les connexions sécurisées sur le port 3443 en utilisant les directives Listen et
                     VirtualHost ; (voir le fichier /etc/apache2/ports.conf)

                −    Activer SSL et indiquer les algorithmes cryptographiques utilisés ;

                    * Copier le fichier /etc/apache2/sites-availables/default dans /etc/apache2/sites-
                availables/ssl

                    * Modéfier la prmière ligne comme suit : <VirtualHost *:3443>

                    * Rajoutez les lignes suivantes :
                      SSLEngine On
                       SSLCertificateFile /etc/apache2/serveur.crt
                       SSLCertificateKeyFile /etc/apache2/serveur.key
                       DocumentRoot /var/www
                       DirectoryIndex login.htm

           6.   Activer le site ssl :

                       sudo a2ensite ssl

                       service apache2 reload

           7.   Testez la connexion à votre serveur avec la commande suivante :



                                                             20
                                                                           Travaux pratique en Sécurité Informatique

      openssl s_client -connect localhost:3443 -state

           8.    Accéder maintenant à la page login.html avec l’URL https://server:3443/login.html depuis le poste
                 client et vérifier avec wireshark que vous n'avez plus accès au mot de passe


Utilisation d’une autorité de certification
          On souhaite maintenant introduire une autorité de certification qui va signer la clé publique du serveur
Apache.
          1.     Créer un répertoire, nommé CA, dans lequel vont être placées les clés engendrées par openssl
          2.     Editer le fichier de configuration /etc/ssl/openssl.cnf en y modifiant l’entrée
               « dir = /home/administrateur/ca » de façon qu’elle pointe vers le répertoire qui vient d’être crée
          3.     Générer la paire de clés de la CA en utilisant la commande suivante :
          openssl req -new -x509 -days 365 -newkey rsa:1024 -keyout cakey.pem -out cacert.pem
          4.     Déplacer le fichier cakey.pem contenant la clé privée de la CA dans le répertoire /CA/private
préalablement crée. Protéger ce fichier en lui attribuant les privilèges root (droits d’accès 600)
          5.     Créer une requête de signature de certificat ou CSR (Certificate Signing Request) relative à chaque
hôte en utilisant la commande suivante :
          openssl req -new -days 365 -newkey rsa:1024 -keyout serveur.key -out serveurreq.pem
          6.     Avant de signer la CSR, il faut d’abord créer les deux fichiers index.txt et serial. Le premier sera utilisé
pour contenir les logs des certificats signés et le second indique le prochain numéro de série X.509 disponible.
Initialiser le contenu du fichier serial à 1 avec la commande « echo 01 > serial »
          7.     Il faut ensuite créer le répertoire /CA/newcerts dans lequel sera déposée une copie de chaque
certificat signée par la CA
          Remarque : Les noms des fichiers et des répertoires crées précédemment, ainsi que leur emplacement,
peuvent être personnalisés via le fichier de configuration /etc/ssl/openssl.cnf
          8.     A présent, signer chaque CSR en utilisant la commande suivante :
          openssl ca -in serveurreq.pem -out serveur.crt
          9.     Retirer le mot de passe qui protégé la clé privée de chaque hôte à l’aide de la commande :
          openssl rsa -in serveur.crt -out serveur.crt
          10. Placer dans le répertoire /etc/apache2 du serveur les fichiers serveur.key et serveur.crt.
          11. Dans le cas où vous voudriez que le certificat de la CA puisse être installé dans le navigateur Internet
Explorer, il vous faudra créer une version DER de ce certificat comme suit :
          openssl x509 -in ca.crt -out ca.der -outform DER
           12. Installer maintenant sur votre navigateur, le certificat de la CA que vous venez de créer
           13. Testez à nouveau l'accès à la page Web login.html depuis le poste Client. Que constatez-vous cette
                 fois ci ? Expliquez




                                                             21

								
To top