RAPPORT DE STAGE DE FIN D ETUDES. Sujet PDF

Institut de la Francophonie Ecole Nationale Supérieure des
pour l’Informatique Télécommunications
RAPPORT DE STAGE DE FIN D’ETUDES
Sujet
- Etude et analyse des attaques et des signatures d'attaques
- Etude bibliographique des parades au DoS et DDoS
- Etude des HoneyPots
- Intégration des HoneyPots dans une architecture globale de
protection
Etudiant : Responsables :
DOAN DUY Thieu Hoa, IFI Ahmed SERHROUCHNI
Paris, jenvier - juillet 2004

Sujet
Etude et analyse des attaques et des signatures d'attaques
Etude bibliographique des parades au DoS et DDoS
Etude des HoneyPot
Intégration des HoneyPot dans une architecture globale de protection
2
Table de matière
Introduction.................................................................................................... 5
Remerciements............................................................................................... 6
Partie 1 : Etude des attaques ........................................................................... 7
Déterminer des vulnérabilités.....................................................................................7
Le craquage par mot de passe ..................................................................................7
Le sniffing des mots de passe et des paquets .........................................................7
L'IP spoofing ................................................................................................................9
Les scanners..............................................................................................................10
Les chevaux de Troie................................................................................................10
Les vers ......................................................................................................................11
Les trappes ................................................................................................................11
Les bombes logiques ................................................................................................11
Le TCP-SYN flooding................................................................................................12
Le Flood .....................................................................................................................13
Le Spamming.............................................................................................................13
Les virus .....................................................................................................................13
L'ingénierie social ......................................................................................................14
Partie 2 : Etude bibliographique des parades au DoS et DDoS ..................... 15
DoS .............................................................................................................................15
Les attaques directes.................................................................................................15
Les attaques indirectes par rebond ............................................................................16
Les attaques indirectes par réponse...........................................................................16
Quelques parades de type DoS...............................................................................17
Ping de la mort .........................................................................................................17
TearDrop..................................................................................................................18
DDoS ..........................................................................................................................21
Mode opératoire .......................................................................................................22
Les outils .................................................................................................................22
1. TFN (Tribal Flood Network) ................................................................................23
2. TFN2K.................................................................................................................24
3. Trin00 ..................................................................................................................24
4. Stacheldraht .........................................................................................................26
Mesures de protection ..............................................................................................26
Partie 3 : Etude des HoneyPot ...................................................................... 29
Définition ....................................................................................................................29
Avantages ..................................................................................................................29
Inconvénients.............................................................................................................30
Les types d'honeypot ................................................................................................30
Honeyd: Low-interaction honeypot. .........................................................................31
Honeynet: High-interaction honeypot. ......................................................................32
3
Valeurs de Honeypot.................................................................................................33
Partie 4 : Intégration des HoneyPot dans une architecture globale de
protection ..................................................................................................... 35
Installer Honeyd.........................................................................................................35
Configuration Honeyd ...............................................................................................37
Configurer un réseau virtuel simple..........................................................................37
Configurer un réseau virtuel avec un routeur ............................................................38
Configurer un réseau virtuel relié aux machines réelles ............................................39
Configurer un réseau virtuel complexe .....................................................................40
Outils aide à créer fichier de configuration honeyd ...................................................41
Lancer Honeyd et analyser les données capturées...............................................42
Lancer......................................................................................................................43
Analyser les données capturées..............................................................................43
Annexes ....................................................................................................... 51
Références.................................................................................................... 55
4
Introduction
Ce document est un rapport du stage que j’ai effectué du 1er janvier 2004 au 30
juin 2004 dans le cadre de la scolarité 2003/2004 au Département Informatique et
Réseau, ce stage est placé sous la direction de Monsieur le Professeur Ahmed
Serhrouschni
L’objectif du projet était de :

- Etude et analyse des attaques et des signatures d’attaques
- Etude bibliographique des parades au DoS et DDoS
- Etude des HoneyPot
- Intégration des HoneyPot dans une architecture globale de protection
Ce stage s’inscrit dans le cadre de mon stage de fin d’étude pour valider mon
diplôme de DEA à l’Institut de la Francophonie pour l’Informatique au Vietnam.
Ce document présentera 4 parties principales correspondantes à l’objectif du

projet.
5
Remerciements
Je tien tout d’abord à remercier Monsieur le Professeur Ahmed Serhrouchni pour

m’avoir accueilli dans son projet et avoir encadré mon stage.
Je remercie tout particulièrement Adil Andalousie pour tous ses conseils sur la
signature électronique ainsi que le certificat électronique et le temps qu’il m’a
consacré.
Merci également à toutes les personnes dans mon bureau qui m’a donné un
environnement de travail très agréable.
6
Partie 1 : Etude des attaques
Déterminer des vulnérabilités

Cette opération consiste à déterminer le système d'exploitation, les services
ouverts ainsi que leur version afin de pouvoir déterminer les éventuelles failles et
les exploiter.
Un des outils les populaire et les plus puissant est « nmap »'. Il permet entre
autres le half-scan (sans établir de connexion)
nmap -sS IP_du_serveur
ou encore, le fingerprinting (détection d'OS)
nmap -sS -O IP_du_serveur
Il y a des autres outils qui nous aident à déterminer les vulnérabilités dans un
système. Par exemple, sous Windows, l’outils SuperScan est connu et souvent
utilisé par l’attaquant. Dans la dernière partie, je l’utilise pour collectionner les
informations sur les machines virtuelles.
Après avoir obtenu les informations nécessaires sur les OS ou services ouvertes,
l’attaquant va chercher les vulnérabilités et les méthodes d’attaque
correspondantes
Le craquage par mot de passe
La manière la plus classique par laquelle un hacker va essayer d'obtenir un mot

de passe est l'attaque avec un dictionnaire. Dans ce genre d'attaque, le hacker
utilise un dictionnaire de mots et de noms propres, et il les essaie un à un pour
vérifier si le mot de passe est valide. Ces attaques se font avec des programmes
qui peuvent deviner des milliers de mots de passe à la seconde, même quand
ceux-ci sont ``hachés''. Ce procédé est d'autant plus facile qu'il lui permet de tester
des variations sur les mots : mots écrits à l'envers, majuscules et minuscules,
ajout de chiffres à la fin du mot.
Le sniffing des mots de passe et des paquets

Si un hacker ne peut pas deviner un mot de passe, il a d'autres outils pour
l'obtenir. Une façon qui est devenue assez populaire est le sniffing. La plupart des
réseaux utilisent la technologie de broadcast (comme Ethernet). En pratique, tous
les ordinateurs sauf le destinataire du message vont s'apercevoir que le message
7
ne leur est pas destiné et vont donc l'ignorer. Mais par contre, beaucoup
d'ordinateurs peuvent être programmés pour regarder chaque message qui
traverse le réseau (mode promiscuité). Il existe des programmes qui utilisent ce
procédé et qui capturent tous les messages qui circulent sur le réseau en repérant
les mots de passe. Si quelqu'un se connecte à un ordinateur à travers un réseau
en utilisant les protocoles insécurités (telnet, rlogin, ftp...), alors cette personne
risque de perdre son mot de passe. C'est pourquoi il existe une menace sérieuse
pour les personnes qui se connectent sur des ordinateurs distants, où les mots de
passe apparaissent en clair dans la trame. Les programmes de sniffing les plus
connus sont Esniff et TCPDump. Mais un sniffer peut tout aussi bien être
bénéfique à l'administrateur réseau, puisqu'il permettrait de déceler avant les
Hackers les failles de sécurité de son réseau. Ethereal v0.8.12 sous Linux permet
de journaliser les événements définis par l'administrateur. Il est en outre
compatible avec les journaux de LOG des routeurs Cisco (Cisco Secure IDS iplog
files).
Ethereal est téléchargeable à l'adresse suivante : http://www.ethereal.com/
Voici ci-dessous une liste d'autres sniffers disponibles dans le commerce

Nom Adresse Description
ATM Sniffer Network http://www.networkassociates.com Décode plus de 250 protocoles
Analyzer
Shomiti Systems http://www.shomiti.com Supporte le standard Ethernet et
Century LAN Analyzer fonctionne sous Windows 95/98 et NT
PacketView de Klos ftp.klos.com/demo/pvdemo.zip Ce sniffer est basé sur DOS, idéal pour
Technologies les environnements Ethernet
Network Probe 8000 http://www.netcommcorp.com Fait une analyse d'environ 13
protocoles dont TCP/IP, Microsoft,
NFS, Novell
LANWatch http://www.guesswork.com Marche sous DOS, Windows 9x et NT
EtherPeek http://www.aggroup.com Pour Windows et plates-formes
Macintosh
Ethload http://www.computercraft.com/nopro Sniffer qui permet de surveiller les
gs/ethld104.zip sessions rlogin et telnet
Linux sniffer Sniffer de mots de passe uniquement,
en langage C
La meilleure défense contre l'attaque de sniffers est l'utilisation d'un protocole de

chiffrement comme SSL (Secure Socket Layer).
8
L'IP spoofing
L'adresse IP d'un ordinateur est l'adresse qui est utilisée pour reconnaître un
ordinateur sur internet. Un des principaux problèmes est qu'en utilisant le routage
source d'IP, l'ordinateur du hacker peut se faire passer pour un ordinateur connu.
Le routage source d'IP est une option qui peut être utilisée pour spécifier une route
directe à une destination et renvoyer le chemin de retour à l'expéditeur. La route
peut inclure l'utilisation d'autres routeurs ou de serveurs qui n'auraient
normalement pas été utilisés pour faire suivre les paquets à la destination finale.
Voici un exemple qui montre comment ceci peut être utilisé de façon à ce que
l'ordinateur de l'intrus apparaisse comme étant l'ordinateur certifié par le serveur :
• L'agresseur change l'adresse IP de son ordinateur pour faire croire qu'il est
un client certifié par le serveur,
• Il va ensuite construire une route source jusqu'au serveur qui spécifiera le
chemin de retour direct que les paquets IP devront prendre pour aller au
serveur et qu'ils devront prendre pour retourner à l'ordinateur de l'agresseur
en utilisant le client certifié comme dernière étape dans la route vers le
serveur,
• L’agresseur envoie une requête client au serveur en utilisant la route
source,
• Le serveur accepte la requête du client comme si elle provenait directement
du client certifié et retourne une réponse au client,
• Le client, utilisant la route source, faire suivre le paquet à l'ordinateur de
l'agresseur.
Beaucoup de machines Unix acceptent les paquets de route source et les

redirigent comme la route source l'indique. Beaucoup de routeurs acceptent
également les paquets de route source bien que certains d'entre eux puissent être
configurés pour bloquer ces paquets. Le routeur, pour des raisons de sécurité, ne
devra pas accepter le routage source. Une autre manière encore plus simple pour
spoofer un client est d'attendre que le système client ait éteint sa machine et de se
faire passer ensuite pour ce dernier. Les entreprises utilisent souvent des PC et le
protocole TCP/IP et NFS pour se connecter à des serveurs Unix et obtenir un
accès aux répertoires et aux fichiers du serveur. Comme NFS utilise uniquement
les adresses IP pour authentifier les clients, un intrus pourrait configurer un PC
avec le même nom et la même adresse IP qu'un autre ordinateur, et alors essayer
de lancer des connexions au serveur Unix comme s'il était le vrai client. Ceci est
très simple à réaliser et ressemblerait à une attaque de l'intérieur. Le routeur devra
9
donc refuser les connexions d'une machine ayant la même adresse IP qu'une
machine interne, mais se trouvant à l'extérieur du réseau local. Les e-mails sont
particulièrement sujets au spoofing car ils sont faciles à réaliser. Les courriers
électroniques sans l'ajout d'une signature électronique ne peuvent pas être
d'origine fiable. Il est facile par Telnet de se connecter directement au port SMTP
du système (port 25). Le serveur recevant ces commandes fait confiance à cette
personne si elle s'identifie. D'où le fait que le courrier électronique peut lui aussi
être spoofé facilement en entrant une adresse d'expéditeur différente de l'adresse
réelle. On peut donc sans aucun privilège falsifier ou spoofer le courrier
électronique. D'autres services comme le DNS peuvent aussi être spoofés mais
avec toutefois plus de difficultés que le courrier électronique. Ces services
représentent une crainte qui mérite d'être considérée quand on les utilise. Le
routeur pare-feu devra tenir régulièrement à jour ses fichiers LOG afin de contrôler
toute tentative de piratage. De plus, ces fichiers LOG devront être sécurisés pour
éviter toute modification malveillante.
Les scanners
Un scanner est un programme qui permet de savoir quels ports sont ouverts sur
une machine donnée. Les Hackers utilisent les scanners pour savoir comment ils
vont procéder pour attaquer une machine. Leur utilisation n'est heureusement pas
seulement malsaine, car les scanners peuvent aussi permettre de prévenir une
attaque. Le plus connu des scanners réseau est WS_Ping ProPack, que l'on peut
trouver sur http://www.ipswitch.com/french/wsping.html Les fichiers LOG générés
par les scanners ne doivent pas être modifiables par un pirate.
Les chevaux de Troie
Un cheval de Troie est un programme qui se cache lui-même dans un autre

programme apparemment au-dessus de tout soupçon. Quand la victime
(l'utilisateur normal) lance ce programme, elle lance par là même le cheval de
Troie caché. Actuellement, les chevaux de Troie les plus utilisés sont : Back
Orifice 2000, Backdoor, Netbus, Subseven, Socket de Troie. La méthode la plus
efficace pour se protéger de ces programmes néfastes est d'utiliser un bon
antivirus comme Norton 2000 ou Network Associates. Des programmes
spécifiques permettent également de scruter toute tentative de connexion sur les
ports scrutés. Lockdown 2000 est le plus connu d'entre eux : une fois une tentative
de connexion détectée, il fait un traceroute sur l'IP qui a tenté la connexion. La
version 4 possède en bibliothèque 488 signatures de ``Troyans''. La machine
Linux devra être équipée d'un antivirus permettant de repérer non seulement les
10
virus, mais également les chevaux de Troie.
Les vers
Un ver est un programme capable de se propager et de s'auto-reproduire sans
l'utilisation d'un programme quelconque ni d'une action par une personne. Sur
chaque ordinateur où il agit, le ver crée une nouvelle liste de machines distantes
cibles. En parallèle, le ver :
- essaie de trouver les mots de passe des comptes utilisateurs,
- essaie d'entrer dans chaque machine cible en se faisant passer pour un
utilisateur de la machine « attaquante »' (après avoir craqué le mot de passe
utilisateur), et en utilisant un ancien bug dans le protocole finger, qui permet
de savoir quels sont les usagers connectés sur une machine distante ou sur
quelle machine est connecté un utilisateur donné. Les attaques de vers sont
toutefois très rares parce que les serveurs sur l’Internet sont de plus en plus
performants (Windows NT Server ou Apache), mais c'est toujours une
méthode utilisée par les hackers quand un nouveau bug est découvert dans
un système d'exploitation. Les vers permettent aux agresseurs d'attaquer un
maximum de sites en peu de temps. Le routeur pare-feu ne doit pas s'attarder
à filtrer les vers: c'est la qualité du système d'exploitation qui doit permettre
d'enrayer toute attaque de vers.
Les trappes
Une trappe est un point d'entrée dans un système informatique qui passe au-
dessus des mesures de sécurité normales. C'est généralement un programme
caché ou un composant électronique rendant le système de protection inefficace.
De plus, la trappe est souvent activée par un événement ou une action normale
(exemple : trappe dans les premières versions de Internet Explorer 5).
Pareillement au type d'attaque précédent, les trappes sont des programmes qui ne
peuvent pas être détectés au niveau IP, mais au niveau application (signature).
C'est donc le rôle de l'antivirus et du système d'exploitation de détruire les trappes.
Les bombes logiques

Ce sont des dispositifs programmés dont le déclenchement s'effectue à un
moment déterminé en exploitant la date du système, le lancement d'une
commande, ou n'importe quel appel au système. Les bombes logiques doivent
être repérées au niveau applicatif, par un antivirus performant.
11
Le TCP-SYN flooding
Quand un client essaie d'établir une connexion TCP sur un serveur, le client et le
serveur échangent une séquence de messages. Cette connexion technique
s'applique à toutes les connexions TCP/IP (Telnet, web, e-mails...). Le système
client commence par envoyer un message SYN (pour synchronisation) au serveur.
Le serveur renvoie alors un accusé de réception du SYN : SYN-ACK au client. Le
client finit alors par établir la connexion en répondant par un ACK. La connexion
(au niveau 4 du modèle OSI) entre le client et le serveur est donc ouverte et le
service d'échange de données peut s'exécuter. La faille vient du fait qu'au moment
où le serveur a renvoyé un accusé de réception du SYN (SYN- ACK), le serveur
mais n'a pas encore reçu le ACK du client. C'est alors une connexion dite semi-
ouverte. Le serveur construit dans sa mémoire système une structure de données
décrivant toutes les connexions courantes. Cette structure de données est de taille
finie, ce qui veut dire qu'il peut se créer un dépassement de capacité (overflow) en
créant intentionnellement trop de connexions partiellement ouvertes. Le fait de
créer ces semi-connexions sans se faire repérer est facilement réalisable avec l'IP
spoofing. L'ordinateur de l'agresseur envoie des messages SYN au serveur
victime; ceux-ci paraissent provenir d'un ordinateur bien défini mais font référence
à un système client qui n'est pas capable de répondre au message SYN-ACK. Ce
qui veut dire que le message ACK final ne sera jamais envoyé au serveur victime.
Ces semi-connexions dans la structure de données du serveur victime vont
éventuellement créer un débordement dans cette structure et le serveur sera
incapable d'accepter d'autres connexions tant que la table ne sera pas vidée.
Normalement, il y a un système de time-out associé à chaque connexion ouverte,
donc les semi-connexions devraient expirer et le serveur victime récupérer de la
place libre dans sa mémoire pour d'autres connexions. Toutefois, le système
agresseur peut simplement continuer à envoyer des paquets dont l'IP est spoofée
plus vite que le serveur victime puisse expirer les semi-connexions. Dans la
plupart des cas, la victime d'une telle attaque aura des difficultés à accepter toute
nouvelle connexion. Dans ces cas, l'attaque n'affectera pas les connexions déjà
existantes ou la capacité à créer des connexions de l'intérieur vers l'extérieur. Par
contre, dans certains cas, le serveur aura épuisé toutes ses ressources mémoires,
et pourra ``planter'' et donc être rendu inopérant. La localisation de l'attaque est
très souvent obscure parce que les adresses IP des paquets SYN envoyés sont
rarement plausibles. Quand le paquet arrive au serveur victime, il n'y a aucun
moyen de déterminer sa véritable source. Comme l’Internet fait suivre les paquets
sur une adresse de destination, le seul moyen de valider la source d'un paquet est
12
d'utiliser le filtrage. Avec la technologie actuelle du protocole IP, il est impossible
d'éliminer tous les paquets spoofés. Mais il existe quelques solutions pour réduire
le nombre de paquets spoofés et sortant du réseau. Le routeur devra limiter les
entrées à l'interface externe, en n'accordant pas le droit d'entrée à un paquet qui a
une adresse source du réseau interne. Il peut aussi être bon de filtrer les paquets
sortants qui ont une adresse source différente du réseau interne afin de prévenir
une attaque d'IP spoofing provenant du réseau interne. La combinaison de ces
deux types de filtrage doit empêcher les agresseurs extérieurs d'envoyer des
paquets prétendant provenir du réseau interne. Cela doit également empêcher les
paquets provenant du réseau interne de prétendre venir de l'extérieur du réseau.
L'IP spoofing et le SYN-flooding sont actuellement les deux principaux problèmes
de la sécurité sur Internet.
Le Flood
Le Flood consiste à envoyer très rapidement de gros paquets d'informations à la
machine routeur (à condition d'avoir un PING très court, comme c'est le cas pour
un RLE), ce qui risque de faire ``planter'' la machine (``Ping Of Death'' : message
ICMP de 64 ko qui faisait planter Windows). Une solution consiste à avoir une
bonne gestion de la fenêtre d'anticipation TCP, et d'envoyer autant que faire se
peut des messages ICMP de réduction de fenêtre.
Le Spamming
Le Spamming consiste à envoyer plusieurs milliers de messages identiques à une
boîte aux lettres pour la faire saturer. En effet, les mails ne sont pas directs, ainsi
lorsque le courrier sera relevé, celui-ci mettra beaucoup trop de temps et la boîte
aux lettres sera alors inutilisable. Le routeur pare-feu pourra cependant détecter
les tentatives de Spamming, en sniffant les paquets IP arrivants, et en remarquant
une trop grande fréquence dans la réception d'un même message (taille du
paquet, adresses source et destination identiques).
Les virus
Les constructeurs de pare-feu tendent maintenant à fournir avec leurs produits
une solution antivirus complète, qui permet de filtrer les attaques logicielles
comme les chevaux de Troie, les vers, les trappes et les bombes logiques. Les
éléments actifs du réseau sont désormais de véritables remparts contre une
pléthore d'attaques, qu'elles soient au niveau réseau ou au niveau applicatif. Cela
rend la tâche des administrateurs réseau plus simple, car toutes les fonctions de
sécurité sont fédérées sur un seul et même équipement, plus robuste et
13
entièrement administrable. Les éléments composant le réseau ne sont pas les
seuls remparts aux attaques. Le système d'exploitation garantit un niveau de
sécurité supplémentaire vis-à-vis des attaques de type virus, nuke ou trappes.
C'est pourquoi nous nous intéressons maintenant à l'aspect sécurité de Linux.
L'ingénierie social
L'ingénierie sociale n'est pas vraiment une attaque informatique. C'est plutôt une
méthode pour obtenir des informations sur un système ou des mots de passe.
C'est une approche psychologique en utilisant des acteurs humaines disposants
des informations pertinentes sur le système cible à attaquer. Pour obtenir le but, il
y a 5 méthodes:
- Internet: Se faire passer pour un acteur de l'entreprise (un utilisateur ou un
administrateur)
- Contact: Permet de cibler la personne et obtenir des informations dans son
contexte (rendez-vous pour un motif quelconque) ou hors de son contexte
(au restaurant d'entreprise ou en face au bureau).
- Téléphone: Préparer d'une identité, d'un rôle ou d'un but exprimé. Utilise
des canaux indirects (par exemple la téléphoniste ou un département
quelconque)
- Fax: Copier l'en-tête d'un fournisseur ou d'un client pour obtenir une
information
- Lettre: Même approche pour le fax mais au lieu de copier l'en-tête, on utilise
une adresse fictive.
Contre mesure
- Formation des acteurs à tous les niveaux
- Délimiter exactement le périmètre des informations confidentielles,
sensibles, internes et publiques.
- Tenter de placer les indicateurs pour assurer l'identité des personnes
désirant des informations sensibles
- Les documents ou communications qui ne sont pas clairement identifiés,
doivent être transmises à un acteur responsable pour leur traitement.
- Clause de confidentialité dans les contrats.
14
Partie 2 : Etude bibliographique des parades au DoS et
DDoS
DoS
Les techniques d'attaque : Les attaquants utilisent plusieurs techniques
d'attaques. Ces attaques peuvent être regroupées en trois familles différentes :
- Les attaques directes.
- Les attaques indirectes par rebond.
- Les attaques indirectes par réponses.
Nous allons voir en détail ces trois familles.
Les attaques directes

C'est la plus simple des attaques. Le hacker attaque directement sa victime à
partir de son ordinateur. La plupart des "script kiddies" utilise cette technique. En
effet, les programmes de hack qu'ils utilisent ne sont que faiblement paramétrable,
et un grand nombre de ces logiciels envoient directement les paquets à la victime.
Si vous vous faites attaqués de la sorte, il y a de grandes chances pour que vous
puissiez remonter à l'origine de l'attaque, identifiant par la même occasion
l'identité de l'attaquant.
Depuis quelques ans, on n’utilise jamais cette technique car il n’est pas efficace
quand on utilise une machine normale pour attaquer un serveur très performant.
15
Les attaques indirectes par rebond
Cette attaque est très prisée des hackers. En effet, le rebond a deux avantages :
- Masquer l'identité (l'adresse IP) du hacker.
- Eventuellement, utiliser les ressources de l'ordinateur intermédiaire car il est
plus puissant (CPU, bande passante...) pour attaquer.
Le principe en lui même, est simple: Les paquets d'attaque sont envoyés à
l'ordinateur intermédiaire, qui répercute l'attaque vers la victime. D'où le terme de
rebond.
L'attaque FTP Bounce fait partie de cette famille d'attaque.

Si vous êtes victime de ce genre d'attaque, il n'est pas facile de remonter à la
source. Au plus simple, vous remontrez à l'ordinateur intermédiaire.
Les attaques indirectes par réponse

Cette attaque est un dérivé de l'attaque par rebond. Elle offre les mêmes
avantages, du point de vue du hacker. Mais au lieu d'envoyer une attaque à
l'ordinateur intermédiaire pour qu'il la répercute, l'attaquant va lui envoyer une
requête. Et c'est cette réponse à la requête qui va être envoyée à l'ordinateur
victime.
16
Là aussi, il n'est pas aisé de remonter à la source...
Quelques parades de type DoS
Ping de la mort
Un ping a normalement une longueur maximale de 65535 ((216) - 1) octets,
incluant une entête de 20 octets. Un ping of death c'est un ping qui a une
longueur de données supérieure à la taille maximale. Lors de sont envoi, le ping of
death est fragmenté en paquets plus petits. L'ordinateur victime qui reçoit ces
paquets doit alors les reconstruirent. Certains systèmes ne gèrent pas cette
fragmentation, et se bloquent, ou crashent complètement.
En principe, pour déborder une machine on ne peut que l'envoyer des paquets
avec la taille supérieure à 64 Koctets. La commande suivante va nous montrer
comment les créer:
ping -f -s 65550 xxx.xxx.xxx.xxx

où xxx.xxx.xxx.xxx est l'adresse de la victime.
L'idée est de les fragmenter en des paquets dont la taille est inférieure à 64
Koctets grâce à la technique de fragment des paquets.
17
Le problème se passe quand la machine cible essaie de défragmenter les paquets
reçus. Le paquet final ayant la taille supérieure à 64 Koctets va bloquer la victime.
Supposons que l'on a deux fragments suivants:
Fragment 1 Fragment 2
MF=1 Offset=0 MF=0 Offset=65000
Taille=65000 Taille=1000
Donnée Donnée
Quand on les rassemble, la taille du nouveau fragment est

65000 + 1000 = 66000
Cette valeur est supérieure à 64Ko, on ne peut pas la mettre dans un registre à
taille 16bits. Si on le fait, cela causera un problème.
Prouver
On va voir ce problème dans le système d'exploitation Minix version 2.0.2. Le

code suivant est extrait dans le fichier ip_read.c de la fonction merge_frags()
second_datasize=second_offset+second_datasize-(first_offset+first_datasize);
cut_second= bf_cut(second, second_hdr_size + first_offset+first_datasize-
second_offset, second_datasize);
....
first_datasize += second_datasize;
first_hdr->ih_length= htons(first_hdr_size + first_datasize);
second_datasize = 65000 + 1000 – (0 + 65000) = 1000

first_datasize = 65000 + 1000 = 66000
first_hdr->ih_length = htons(first_hdr_size + 66000);
=> Erreur
Le variable first_hdr->ih_length est défini comme un variable à 16 bits
correspond à une valeur 65535 bits.
TearDrop
Teardrop est une attaque (principalement contre les machines sous Microsoft
18
Windows NT) qui repose sur des fragments superposés.
On va voir le code suivant (extrait dans la fonction ip_glue() du fichier
ip_fragment.c du noyau 2.0.23 de la ligne 361):
/* Copy the data portions of all fragments into the new buffer. */
fp = qp->fragments;
while(fp != NULL) {
if (count+fp->len > skb->len) { // (i)
NETDEBUG(printk("Invalid fragment list: Fragment over size.\n"));
ip_free(qp);
frag_kfree_skb(skb,FREE_WRITE);
ip_statistics.IpReasmFails++;
return NULL;
}
memcpy((ptr + fp->offset), fp->ptr, fp->len); // (ii)
count += fp->len;
fp = fp->next;
}
Qu'est ce qu'il se passe si la taille d'un fragment est inférieur à 0 (fp->len < 0).
Quand on loue une partie de mémoire avec un nombre négatif, cela devient un
très grand nombre positif. Cela dépense de la mémoire de la victime, l'ordinateur
peut être soit bloqué soit redémarré.
Prouver
Les figures suivant montrent comment on peut créer un fragment ayant la taille
négative (fp->len < 0)
Fragment 1 Fragment 2
MF=1 Offset=0 MF=0 Offset=500
Taille=1000 Taille=400
Donnée Donnée
Supposons que l'on reçoit 2 fragments ci-dessus et on est en train de traiter le

fragment 2.
Le variable 'end' est déjà calculé dans la ligne 474 par l'instruction:
end = offset + ntohs(iph->tot_len) – ihl;
= 500 + 400 – ihl
19
= 900 - ihl
Selon les codes à partir de ligne 508 dans le fichier ip_frament.c (Linux-2.0.23)
if (prev != NULL && offset < prev->end)
{
i = prev->end - offset;
offset += i; /* ptr into datagram */
ptr += i; /* ptr into fragment data */
}
On a i = 1000 – 500 = 500

offset = 500 + 500 = 1000
On passe end et nouvel offset dans la fonction ip_frag_create. On voie
maintenant la partie principale dans cette fonction (dans le fichier ip_fragment.c à
partir de la ligne 93 (fonction ip_frag_create) – Linux 2.0.23)
/* Fill in the structure. */
fp->offset = offset;
fp->end = end;
fp->len = end – offset;
Donc, fp->len = 900 – ihl – 1000 = –100 – ihl < 0
De la version 2.1.89 à 2.2.3 du noyau, on a changé le code pour contre cette

vulnérabilité. Mais le problème est encore continué. Voir le code suivant (extrait
dans la fonction ip_glue() du fichier ip_fragment.c du noyau 2.2.3 de la ligne 357):
fp = qp->fragments;
count = qp->ihlen;
while(fp) {
if ((fp->len < 0) || ((count + fp->len) > skb->len))
goto out_invalid;
memcpy((ptr + fp->offset), fp->ptr, fp->len);
if (count == qp->ihlen) {
skb->dst = dst_clone(fp->skb->dst);
skb->dev = fp->skb->dev;
}
count += fp->len;
fp = fp->next;
}
Le problème dans ce code est si on a un fragment dans la liste des fragments qp-
>fragments ayant la taille 0 et il est le premier fragment dans la liste. Pour la
20
première fois de la boucle, count est nécessaire égal à qp->ihlen, la fonction
dst_clone(..) est donc lancée. Mais si fp->len = 0, count += fp->len ne change pas.
A la prochaine boucle, le variable count est encore égal à qp->len. La fonction
dst_clone() augmente un usage de count à un élément dans le routing cache.
Notre fragment de taille 0 causera cet élément dans le cache devenir être
abandonné. Le noyau ne peut pas le libéré. Parce que le noyau pense qu'il est
encore utilisé. D'autre part, l'appel à louer une nouvelle entrée dans le routing
cache ne teste pas si le hashtable qui contient la cache soit en état saturé. Si cela
se passe, le noyau va faire une collection des déchets. Si le nombre des entrées
dans le cache, après la collection, est encore supérieur au seuil alors la fonction
dst_alloc() sera échouée. Donc, si on génère un nombre assez grand des entrées
abandonnées dans le routing cache (4096 dans le noyau 2.2.3) dans notre
mauvaise liste des fragments, alors tous les appels à la fonction dst_alloc() sera
échoués.
Les étapes suivantes vont nous montrer comment créer tel liste:
- Envoyer un fragment à offset 0 avec la taille X (taille du fragment) et le flag
IP_MF est vrai (More Fragment). Cela crée une liste.
- Envoyer un fragment à offset 0 avec la taille d'entête IP est égale à la taille
totale IP et le flag IP_MF est vrai. Ce fragment va être traité comme il est
venu avant celui du premier car il a un offset égal à l'offset du fragment
existant. Jusqu'à maintenant, il n'y a pas d'overlap car sa valeur 'end' est
égale à l'offset du prochain fragment.
- Envoyer 3ème fragment à offset X avec IP_MF est faux. Cela signifie que
l'on termine ici.
=> On obtient 3 fragments avec les tailles: 0, X, End-X
DDoS
Le "Distributed denial-of-service" ou déni de service distribué est un type d'attaque
très évolué visant à faire planter ou à rendre muette une machine en la
submergeant de trafic inutile (voir fiche DoS). Plusieurs machines à la fois sont à
l'origine de cette attaque (c'est une attaque distribuée) qui vise à anéantir des
serveurs, des sous réseaux, etc. D'autre part, elle reste très difficile à contrer ou à
éviter. C'est pour cela que cette attaque représente une menace que beaucoup
craignent.
21
Mode opératoire
Les DDoS se sont démocratisées depuis quelques ans. En effet dans les premiers
temps, cette attaque restait assez compliquée et nécessitait de bonnes
connaissances de la part des attaquants; mais ceux-ci ont alors développé des
outils pour organiser et mettre en place l'attaque. Ainsi le processus de recherche
des hôtes secondaires (ou zombies) a été automatisé. On cherche en général des
failles courantes (buffer overflows sur wu-ftpd, les RPCs...) sur un grand nombre
de machines sur Internet et l'attaquant finit par se rendre maître (accès
administrateur) de centaines voir de milliers de machines non protégées. Il installe
ensuite les clients pour l'attaque secondaire et essaye également d'effacer ses
traces (corruption des fichiers logs, installation de rootkits). Une fois le réseau en
place, il n'y a plus qu'à donner l'ordre pour inonder la victime finale de paquets
inutiles.
Il est intéressant de noter que les victimes dans ce type d'attaques ne sont pas
que celles qui subissent le déni de service; tous les hôtes secondaires sont
également des machines compromises jusqu'au plus haut niveau (accès root),
tout comme l'hôte maître.
La menace provient du fait que les outils automatisant le processus ont été très
largement diffusés sur Internet. Il n'y a plus besoin d'avoir des connaissances
pointues pour la mettre en place, il suffit de "cliquer" sur le bouton.
Les outils
Pour mieux comprendre le phénomène, il parait impossible de ne pas étudier les
outils les plus importants dans ce domaine, qui doivent leur notoriété à des
célèbres attaques ayant visé des grands sites sur le net.
Un réseau typique se compose donc d'un maître (point central) et de nombreux

hôtes distants, encore appelés démons. Pendant le déroulement de l'attaque, le
hacker se connecte au maître qui envoie alors un ordre à toutes les hôtes distants
(via UDP, TCP ou ICMP). Ces communications peuvent également dans certains
cas être chiffrées. Ensuite, les hôtes distants vont attaquer la cible finale suivant la
technique choisie par l'attaquant. Ils vont par exemple se mettre à envoyer un
maximum de paquets UDP sur des ports spécifiés de la machine cible. Cette
masse de paquets va submerger la cible qui ne pourra plus répondre à aucune
autre requête (d'où le terme de déni de service). D'autres attaques existent, tel
que l'ICMP flood, le SYN flood (TCP), les attaques de type smurf, les attaques
22
dites furtives, les attaques de déni de service dites agressives (dont le but est bel
et bien de faire crasher complètement la cible), ou encore des attaques de type
"stream attack" (TCP ACK sur des ports au hasard)...
Certains outils se sont même inspirés des chevaux de Troie qui installent de petits
serveurs IRC permettant au hacker de les commander via cette interface.
1. TFN (Tribal Flood Network)

C'est le premier outil d'attaque de type Déni de Service qui ai obtenue une large
visibilité. Il utilise une architecture à deux couches. Un client qui contrôle des
agents/démons. Ces agents réalisent l'attaque distribuée sur la victime/cible et
avec le type d'attaque désiré par le client. Les agents TFN fonctionnent comme
des services réseaux cachés sur les machines piratées, capables de recevoir les
commandes du client noyées parmi le flux courant des communications du
réseau. Les adresses du client et des agents sont falsifiées dans tous les
communications et les attaques.
Architecture du TFN
Client
Agent Agent Agent
Victime
- Protocole de la communication entre Client/Agent : ICMP

- L’attaque sur les protocoles : IP / TCP / UDP / ICMP
Le TFN client est exécuté à travers la commande ligne pour envoyer des
commandes aux TFN Agents. Un client communique avec les agents en utilisant
des paquets ICMP echo-reply avec 16 bits binaires de valeur intégrée dans le
champs ID et quelques arguments ont été intégrées dans la partie de donnée du
paquet. Les valeurs binaires, qui sont définable
23
L’Utilisation
2. TFN2K
C'est la version évoluée de TFN, au début sur une architecture à deux couches
(trois couches désormais), mais avec l'ajout de chiffrement BlowFish de ces
communications entre le client et ses agents, qui le rend plus dur à détecter.
L'architecture du TFN2K est ressemble à celle du TFN.
- Communication entre master et agent sont TCP, UDP, ICMP ou aléatoire
entre les trois.
- Méthode d'attaque sont TCP/SYN, UDP, ICMP/PING ou broadcast PING
(smurf) paquet flood
- L'en-tête du paquet entre master et agent est aléatoire sauf ICMP
- TFN2K est silence, cad il ne fait pas de ACK de la commande il reçois. Le

client renvoie chaque commande 20 fois pour s'assurer que le deamon
recevra au moins une fois.
- Toutes les commandes sont chiffrées en utilisant l'algorithme CAST-256
(RFC 2612). Le clé est définie au moment de compilation et utilisé comme
mot de passe pout lancer tfn2k client
- Toutes les données chiffrées sont Base 64 encoded avant de l'envoie
3. Trin00
Trin00 s'appuie lui sur une architecture à trois couches avec un client/intrus, qui
envoie des commandes (y compris les cibles à attaquer) à des servers
masters/handlers qui se chargent chacun dans sous réseau d'agents/démons.
Cette couche intermédiaire rend plus difficile à identifier l'origine de l'attaque.
Cependant, Trin00 réussi moins bien à dissimuler ses communications au sein du
trafic réseau. Il ne cherche pas l'origine de l'attaque et la victime peut détecter les
agents. Trin00 n'utilise qu'une seule forme d'attaque DoS (UDP), contrairement à
TFN.
24
Architecture du Trin00
Instruder
Master Master Master
Deamon Deamon Deamon Deamon
Victime
- L’attaquant communique avec les masters par le protocole TCP sur la

destination porte 27665
- Les masters communiquent avec les deamons par le protocole UDP sur la
destination porte 27444
- Un deamon réponds aux masters par le protocole UDP sur la destination
porte 31335
- Les deamons attaquent « flood » la victime en utilisant le protocole UDP
avec une destination porte aléatoire
Quand un trinoo deamon est lancé, il annonce son présence par envoyer un
paquet UDP qui contient la chaîne « *HELLO* » aux trinoo masters avec les
adresses IP déjà programmés. Quand à lui, il va recevoir des paquets UDP
répondu qui contient une chaîne « PONG ».
Toutes les communications aux masters sur la porte 27665/UDP ont besoin un
mot de passe qui est été stocké dans la librairie du deamon sous forme chiffrée.
Toutes les communications avec les deamons sur la porte 27444/UDP ont besoin
que le paquet UDP contient la chaîne « l44 » (ici, c’est la minuscule du L) .
25
4. Stacheldraht
Stacheldraht est un mélange de TFN et Trin00, dissimulant l'origine des
communications et utilisant une variété des attaques de TFN et se basant sur une
architecture à trois couches de Trin00. Il utilise de meilleurs techniques que « ses
parents »
Architecture de Stacheldraht
Client Client
Handler Handler Handler
Agent Agent Agent Agent
Victime
Mesures de protection
Il n'est pas évident de se prémunir contre ces attaques par déni de service, car la
mise en place du réseau offensif par l'attaquant repose sur le fait que beaucoup
de machines sont peu ou pas sécurisée et présentent des failles. Ces failles sont
tellement nombreuses et d'autre part il existe tellement de machines vulnérables
sur Internet qu'il devient impossible d'empêcher de telles attaques.
Ainsi, si un outil de DDoS est détecté sur un système, cela signifie sûrement que il
a été installé sur de nombreux autres systèmes sans être décelé. D'autre part, la
présence de cet outil signifie également que le système a été intégralement
compromis, qu'il présente sûrement des backdoors et qu'on y a peut-être installé
un rootkit (type Adore). Il est donc urgent et nécessaire de retirer complètement
cette machine du réseau et de l'inspecter pour éventuellement la réinstaller.
Pour détecter un tel outil, on pourra chercher des noms évocateurs parmi les
26
processus système s'il n'y a pas de rootkit installé et si l'attaquant à laissé un nom
par défaut. Ces noms peuvent être regroupés dans la liste suivante (non
exhaustive):
Trinoo maître: master
Broadcast: ns
TFN client: tfn

Démon: td
Stacheldraht Handler: mserv

Agent: td
Shaft Handler: shaftmaster

Agent: shaftnode
mstream Handler: master

Agent: server
Trinity Agent: /usr/lib/idle.so
Portshell: /var/spool/uucp/uucico
Alt. Portshell: /var/spool/uucp/fsflush
Il peut être également fort utile de connaître les outils (au nombre de 4,
principalement) utilisés par les hackers. Des analyses sont disponibles pour 3
d'entres eux :
- http://staff.washington.edu/dittrich/misc/trinoo.analysis
- http://staff.washington.edu/dittrich/misc/tfn.analysis
- http://staff.washington.edu/dittrich/misc/stacheldraht.analysis
Il existe également un compte-rendu de congrès scientifique sur le sujet qui

apporte beaucoup d'idées pour se défendre et récupérer après de tels incidents :
http://www.cert.org/reports/dsit_workshop.pdf
Le Pushback : une contre-mesure en développement
Face aux menaces grandissantes provoquées par ce type d'attaques, les

scientifiques se penchent de plus en plus sur des techniques capables de les
contrer; une des plus récentes est la technique du Pushback. Nous ne rentrerons
27
pas dans les détails ici, tous les papiers étant disponibles sur le site ACC and
Pushback.
Très brièvement, cette technique a pour but d'identifier les attaques de DoS et
surtout de DDoS grâce à des heuristiques, de les contrer en remontant à leur
source, enfin de maintenir et de protéger le bon trafic qui souffre également la
plupart du temps des congestions engendrées par de telles attaques.
Cette méthode utilise un contrôle de congestion basé sur des agrégats, un
agrégat étant défini comme un sous-ensemble du trafic présentant une propriété
identifiable.
Exemples de propriétés :
- Paquets TCP SYN
- Paquets à destination de X
- Paquets IP dont les checksums sont incorrects
Le but est d'identifier les agrégats responsables de la congestion et de les éliminer

pour rétablir un trafic normal. Une fois la signature (c'est-à-dire la propriété
identifiante, le trait caractéristique de l'attaque) établie, le flux est comparée en
temps réel dans le routeur le plus proche de la cible du DDoS. Ce routeur
commence à rejeter (drop) les paquets correspondants à la signature et envoie
également un message d'alerte aux routeurs en amont sur les brins d'où lui
parvient le trafic incriminé. Ce message d'alerte contient entre autres choses la
signature qui va permettre à ces routeurs d'éliminer à leur tour les paquets
correspondants à l'attaque. Et ces routeurs vont également envoyer des
messages d'alerte aux routeurs situés en amont.
Cette technique récursive a pour avantage de pouvoir remonter jusqu'aux sources

de l'attaque; elle permet également de décongestionner le coeur même du réseau,
ce qui était impossible avec les techniques centrées sur la protection pure de la
cible. Enfin, même si une partie du trafic légitime est tout de même perdue, les
résultats finaux sont plutôt positifs.
28
Partie 3 : Etude des HoneyPot
Définition
Honeypot est un système des ressources informatiques dont valeur est calculée
sur l'utilisation malicieuse ou illicite de ces ressources.
C'est une définition générale qui couvre tous les manifestations différences des
honeypots. On va discuter dans cet article les exemples différences de honeypot
et leurs valeurs à la sécurité. Leurs valeurs sont basées sur les interactions entre
eux et les attaquants (y compris le virus, les spams). En principe, un honeypot a
une ressource dont il n'y a pas d'activités autorisées. Donc, il n'a pas de valeur de
production. Théoriquement, un honeypot n'a pas normalement de trafic parce qu'il
n'a pas d'activité légitime. Cela veut dire que, chaque interaction avec un
honeypot signifie un malicieux ou une mauvaise activité. Une connexion
quelconque qui essaie via un honeypot est considéré comme probe, attaque ou
compromise. Grâce à sa simplicité, il a énormément des avantages et des
inconvénients.
Avantages
Honeypots est une conception très simple qui leur donne des puissantes
- Petite ensemble de données mais haut valeur: Honeypot collecte un petit
nombre de l'informations. Au lieu de logging un Go par jour, il peut log
environ un Mo de donnée par jour. Au lieu de générer 10 milles alertes par
jour, il ne peut générer que 10. Mais il faut souligner que le honeypot ne
capture que des mauvaises activités. Chaque interaction avec un honeypot
signifie un inautorisé ou une activité dangereuse. Alors, l'honeypot réduit le
bruit par collecter une petite donnée, mais l'information est très valable, qui
ne concerne qu'à l'attaquant. Cela signifie qu'il est plus facile (et moins
chère) à analyser les données collectées pour dériver la valeur à partir de
ces données.
- Nouveaux outils et tactiques: Honeypot est élaboré pour capturer tous les
choses qui le sont envoyés. Y compris les outils et les tactiques que l'on ne
voit pas encore à l'avant.
- Ressource minimale: Un honeypot a besoin une ressource minimale pour
capturer les mauvaise activités. Un ancien Pentium ordinateur avec 128Mo
de mémoire peut facilement contrôler la classe B du réseau.
- Chiffrement ou IPv6: Différence à presque tous les technologies de
29
sécurité (comme IDS système), l'honeypot travail bien dans
l'environnement Ipv6 ou avec des données chiffrées. N'importe quelles
données (instruction ou command) qu'un attaquant l'envoie, il détectera,
capturera et l'analysera.
- Simplicité: En fin, l'honeypot est simple, il n'y a pas d'algorithme à
développer et il est facile à configurer.
Inconvénients
Comme tous les technologies, l'honeypot a aussi des faibles. Parce qu'il ne
remplace aucune technologie courante, mais il travail avec les technologies
existantes.
- Vue limité: l'honeypot ne peut détecter et capturer qu'aux activités
interactives directement avec lui. L'honeypot ne capturera pas des
attaques contre les autres systèmes.
- Risque: Toutes les technologies de la sécurité ont des risques. Le pare-feu
a risque d'être pénétré, le chiffrement a risque d'être démoli. Le IDS a le
risque de se tromper. L'honeypot a aussi des risques. Il a un risque d'être
pris la relève par un attaquant et d'être utilisé à faire du mal aux autres
systèmes. Les risques sont variés selon chaque type d'honeypot.
Les types d'honeypot

Il y a deux catégories d'honeypot: low-interaction et high-interaction honeypots.
Ces deux catégories nous donneront des connaissances sur quel type d'honeypot
qu’avec qui on a une interaction, sa faiblesse et sa force. L'interaction définie le
niveau d'activité que un honeypot permet au attaquant. Low-interaction honeypot a
un nombre d'interaction limité, ils travaillent normalement par simuler des services
et des systèmes d'exploitation. Les activités des attaquants sont limitées au
niveau de la simulation par l'honeypot. Par exemple, Une service simulée FTP
entendu sur le porte 21 peut simuler l'ouverture d'une session FTP ou il est
également supporter quelques autres commands FTP. L'avantage d'un low-
interaction est la simplicité. L'honeypot a tendance à déployer et maintenir
facilement avec un risque minimal. Normalement, il a besoin d'installer des
logiciels, de sélectionner des services ou de système d'exploitation que l'on veut
simuler et surveiller. L'approche de 'plus and play' fait facile à le déployer pour
presque tous les organisations. En plus, les services simulés atténuent les risques
par s'occuper toutes les activités des attaquants, l'attaquant n'accès jamais au
système d'exploitation principal pour lui faire du mal. L'inconvénient principal de
low-interaction honeypot est que les informations qu'il a loggé sont limitées, et
30
normalement sur les activités connues. Donc, il est plus facile pour un attaquant
pour détecter un low-interaction honeypot qu'à un high-interaction. Bien qu'un low-
interaction honeypot soit bien configuré, un attaquant qualifié peut détecter sa
présence. Les exemples d'honeypot sont: Spector, Honeyd et KFSensor.
High-interaction honeypot est différent. Il est des solutions complexes parce qu'il a
besoin les réelles applications et le système d'exploitation réel. Aucun n’est
simulé, on donne aux attaquants des choses réels. Si on veut un Linux honeypot
qui lance le serveur FTP, on construit un Linux système réel qui lance un serveur
FTP. Il y a deux majeurs avantages de cette solution. Premier, on peut capturer
extensivement des informations. En donnant aux attaquants un système réel à
communiquer avec, on peut apprendre tous ses comportements. Deuxième
avantage est qu’un haute-interaction honeypot ne fait pas d'attention sur comment
un attaquant se comportera. Au lieu de cela, il propose un ouvert environnement
qui capture tous les activités. Cela permet la solution high-interaction à apprendre
tous les comportements que nous ne espérons pas. Cependant, cela augmente
aussi des risques car l'attaquant peut utiliser ce système réel à attaquer le non-
honeypot système. En générale, un high-interaction honeypot peut faire ce qu'un
low-interaction honeypot fait et en plus. Mais, il est plus complexe à déployer et
maintenir. Les exemples sont: Symatec Decoy Server, Honeynet.
Pour mieux comprendre comment fonctionnent les deux types ci-dessus, on va

commencer par le low-interaction honeypot Honeyd.
Honeyd: Low-interaction honeypot.

Honeyd est un low-interaction honeypot développé par Niels Provos. Honeyd est
Open Source et conçu pour le système Unix. Honeyd travaille pour surveiller les
espaces IP qui n'est pas encore utilisé. N'importe quand qu'il trouve une
connexion qui essaie au IP inutilisé, il accepte cette connexion et commence à
communiquer avec l'attaquant en imitant comme victime. Par défaut, Honeyd
détecte et log n'importe quelle connexion vers les ports TCP et UDP. En plus, on
peut configurer les services simulés pour contrôler les ports spécifiques comme un
FTP serveur simulé contrôle le port 21. Quand un attaquant connecte à la service
simulée, honeyd non seulement détecte et log les activités, mais il capture aussi
les interactions de l'attaquant avec la service simulée. Dans le cas de FTP
serveur, on peut potentiellement capturer le compte que l'attaquant a utilisé, les
commandes. Dans quelque cas, on peut savoir ce qu'il cherche et sa identité.
Tous cela dépend du niveau de la simulation par l'honeypot. La plupart des
31
services fonctionnent par la même façon. Il espère un type de comportement
spécifique et puis, il est programmé pour réagir par la façon prédéterminée. La
limitation est si l'attaquant fait quelque choses que la simulation n'espère pas, elle
ne sait pas comment faire, comment répondre dans ce cas là. La plupart de low-
interaction honeypots, y compris Honeyd, génère simplement un message
d'erreur.
Quelque honeypots, comme Honeyd, peuvent non seulement simuler des

services, mais simuler des systèmes d'exploitation actuels. D'autre part, Honeyd
peut apparaître comme Cisco routeur, WinXP webserver ou Linux DNS serveur. Il
y a certains avantages quand on simule des systèmes d'exploitation différents.
D'abord, l'honeypot peut être mieux mélangé dans le réseau existant s'il a la
même apparence et comportement du produit système. En suite, on peut choisir
les attaquants spécifiques en proposant les systèmes et services ce qui sont ses
objectifs ou en proposant ceux qui que l'on veut étudier. Il y a deux éléments reliés
au système d'exploitation simulé. Le premier concerne au service simulé. Quand
un attaquant connecte au service simulé, ce service a un comportement et
s'apparaît comme sous système d'exploitation spécifique. Par exemple, si on a un
service simulé d'un webserver et on veut notre honeypot apparaît comme
Window2000 serveur, on peut simuler son comportement à la façon d'un IIS
webserver. Pour Linux, on peut le simuler à la façon d'un Apache webserver. La
plupart des honeypots simulent le système d'exploitation selon cette manière.
Quelque honeypots sophistiqués les simulent profondément (comme honeyd). Ils
simulent non seulement au niveau service mais aussi au niveau du pile IP. Si
quelqu'un utilise la méthode « active fingerprinting » pour déterminer le type de
système d'exploitation de notre honeypot, la plupart des honeypots répondent
avec la pile IP dont le système d'exploitation où ils sont installés. Honeyd
fonctionne de façon différente, honeyd dupe la réponse non seulement sur les
services mais la pile IP du système d'exploitation. Le niveau de simulation et de
sophistication dépense de technologie d'honeypot que l'on a utilisé.
Honeynet: High-interaction honeypot.

Honeynet est un example de high-interaction honeypot. Honeynet n'est pas un
produit, il n'est pas de solution logiciel que l'on installe sur un ordinateur. Au lieu
de cela, honeynet est une architecture, un entité du réseau des ordinateurs
construits pour être attaqué. L'idée est de proposer une architecture qui crée un
réseau contrôlé à au niveau où tous les activités sont contrôlées et capturées.
Dans le réseau on met des ordinateurs intentionnels, ce sont les ordinateurs réels
32
qui lancent des applications réels. L'attaquant trouve, attaque, et entre dans les
systèmes proposés. Quand ils fonts cela, ils ne prennent pas de conscience d'être
dans Honeynet. Tous ses activités, de la session SSH encrypté vers email et
téléchargement des fichiers, sont capturées sans aucune connaissance. Cela s'est
fait par insérer des modules dans le noyau du système victime qui capture tous les
actions des attaquants. En même temps, l'honeynet contrôle les activités des
attaquants. Il le fait en utilisant parcerelle Honeywall. Cette parcerelle permet le
trafic entré vers le système victime, mais contrôler le trafic sortie en utilisant la
technologie de prédiction des instructions. Cela donnera aux attaquants une
flexibilité dans l'interaction avec le système victime, mais les interdire de faire mal
au non-honeynet système
L'exemple du déploiement de honeynet est dans la figure suivante:
Valeurs de Honeypot
Maintenant, on a compris deux catégories générales d'honeypot. On peut mettre
au point sur ses valeurs. On sait déjà qu'il y a deux catégories générales,
honeypot peut être utilisé pour la recherche ou bien comme un produit. Quand il
est utilisé pour le but productif, il protège l'organisation. Y compris la prédiction, la
détection, ou aider l'organisation à répondre à une attaque. D'autre part, pour le
but de la recherche, il est utilisé pour collectionner des informations. Ces
informations ont des valeurs différentes selon les organisations. L'une a envie
33
d'étudier la tendance dans les activités des attaquants tendit que l'autre intéresse
sur la prédiction ou alerter par avance... En générale, low-interaction honeypot est
utilisé souvent pour le but productif tendit que high-interaction est utilisé souvent
pour la recherche. Mais, les deux buts peuvent être changer l'un pour l'autre.
Honetpot aide à prévenir par certaines façons. Premièrement, il contre les

attaques automatiques comme vers ou auto-rooter. Ces attaques basent sur les
outils qui scannent les entités du réseau de façon aléatoire pour chercher les
vulnérabilités du système. Si une des vulnérabilités est trouvée, les outils
automatiques attaqueront le système et obtenir le droit d'accès au système.
Deuxièmes, l'honeypot peut aider à contrer ces attaques par retarder le scan,
même si l'arrêter. En appelant honetpot adhésif, il gène tous les adresses IP pas
encore utilisés. Quand un « probed » comme scan activité, les honetpots auront
une action réciproque avec et faire les retarder. Ils les font en utilisant une variété
de cuses, comme Window taille zéro... Honetpots peuvent protéger votre
organisation des attaquants humains. La conception est la déception et la
dissuasion. L'idée est de refuser un attaquant. Faire dépenser ses temps à
communiquer avec les honetpots. Pendant ce temps là, votre organisation détecte
les activités de l'attaquant et a assez de temps à répondre ou arrêter cet
attaquant. Si l'attaquant sait que votre organisation utilise l'honeypot, mais il ne
sait pas quels systèmes sont les honeypots et quels systèmes sont les machines
légitimes. Il a des risques d'être dans le système d'honeypot et il décide donc de
ne pas attaquer votre organisation. L'honeypot dissuade l'attaquant. Un exemple
est Deception Toolkit, un low-interaction honetpot.
34
Partie 4 : Intégration des HoneyPot dans une architecture
globale de protection
Comme dans la troisième partie, on a distingué entre deux types de honeypot: l'un
est low-interaction honeypot et l'autre high-interaction honeypot. Chacun a des
caractéristiques propres. Pour les intégrer dans une structure globale de
protection, il faut donc faire attention sur les différences entre deux types. Alors,
dans cette partie, on va voir comment intégrer (installer les logiciels nécessaires)
honeypot: Honeyd pour low-interaction honeypot.
Honeyd est une type de honeypot qui permet de déployer les machines virtuelles
sur un réseau (en utilisant les adresses IP laissées libres) et ainsi permet de
détecter les actions frauduleuses sur le réseau. Le but est aussi bien de détecter
des attaques connues que de découvrir les nouvelles attaques en observant les
comportements des attaquants.
Honeyd fonctionne sous Unix, Solaris et BSD dérivés. Il est aussi porté sous
Windows par Roger A. Grimes (roger@banneretcs.com). C'est un daemon qui
crée des hosts virtuels sur le réseau utilisant les adresses IP non attribué sur le
réseau. Grâce à des templates, les hosts peut être configuré pour qu'ils paraissent
fonctionner sous certains systèmes d'exploitation. Plus précisément, Honeyd doit
être utilisé en collaboration avec soit l'outil Arpd soit proxy arp. Arpd permet de
gérer les adresses IP non distribuées et il redirige les attaques vers Honeyd.
Quand à lui, honeyd gère les échanges de données avec les attaquants pour
simuler les services, requête ICMP... Sans arpd ou proxy arp, honeyd ne peut pas
travailler.
Les librairies nécessaires pour compiler honeyd: libpcap, libdnet, et libevent
Installer Honeyd
Supposez que les packages nécessaires sont téléchargés:
- libpcap-0.8.1.tar.gz
- libevent-0.7c.tar.gz
- libdnet-1.7.tar.gz
- honeyd-0.8.tar.gz
Et ils sont mis dans le même répertoire.
35
- Installation de libevent:
# tar xzf libevent-1.7.tar.gz
# cd libevent-1.7
# ./configure
# make
# make install
- Installation de libpcap:
# tar xzf libpcap-0.8.1.tar.gz
# cd libpcap-0.8.1
# ./configure
# make
# make install
- Installation de libdnet:
# tar xzf libdnet-1.7.tar.gz
# cd libdnet-1.7
# ./configure
# make
# make install
- Installation de honeyd:
# tar xzf honeyd-0.8.tar.gz
# cd honeyd-0.8
# ./configure
# make
# make install
Attention :
- Pour installer tous les packages ci-dessus, il est besoins beaucoup de
librairies différentes. Si votre système ne les a pas, vous devez les installer
d’abord : Byson, aycc, python…
- Dans le cas de honeyd, s’il n’y pas de python dans votre système, vous
pouvez utiliser le paramètre –without-python dans la ligne ./configure
pour ne pas utiliser python comme un compileur des commandes par
défaut.
- Si vous avez encore des difficultés concernant à l’installation ou à
l’utilisation honeyd, vous pouvez télécharger la version pré compilée de
honeyd. Il vous reste à configurer le honeyd. Voir la partie suivante.
36
Configuration Honeyd
Dans cette partie, je ne concentre pas sur comment utiliser les commandes pour
élaborer un fichier de configuration.
Si vous voulez savoir en détail, veuillez accéder au lien :

http://www.citi.umich.edu/u/provos/honeyd/honeyd-man.pdf
(Disponible jusqu’au 19/05/2004).
Je ne concentre que sur les architectures du réseau simulées par Honeyd. Le

fichier de configuration va être inclus dans la commande pour honeyd comme un
paramètre suivie l’option –f.
Par exemple : ./honeyd –f honeyd.conf
Honeyd va lire le contenu de fichier configuration et puis générer tous les

composants nécessaires selon les commandes corresponde à chaque ligne.
Les fichiers concernant à honeyd

- Nmap.fingerprints : Stocker tous les personnalités corresponde aux noms
définis. Les personnalités peut être utilisées dans le fichier configuration
pour modifier le comportement d’un pile TCP simulé.
- Nmap.assoc : Compris les styles empreints pour xprobe.
- Xprobe2.conf : Déterminer comment honeyd faire une réaction aux utiles
ICMP empreintes.
Configurer un réseau virtuel simple

Supposons que l’on veut créer deux machines Windows sur un réseau virtuel avec
les adresses IP sont : 192.168.160.3 et 192.168.160.4. Le nom de fichier de
configuration est honey.conf.simple
Son contenu est :
create Windows #Créer un template

set Windows personality « Microsoft Windows XP#Choix le système d’exploitation
SP1 » et ses empreintes dans la base
37
de données
add Windows tcp port 80 « sh scripts/web.sh » #Comportement du port 80
(serveur de web simulé)
add Windows tcp port 139 open
add Windows udp port 137 open
set Windows default tcp action reset
set Windows default udp action reset
ère
bind 192.168.160.3 Windows #Créer 1 machine windows
bind 192.168.160.4 Windows #Créer 2ème machine windows
Le but de template est de créer une configuration globale pour toutes les
machines ayant le même comportement. Au lieu de configurer 10 machines
Windows XP, on ne crée qu’une seule template pour tous. En utilisant la
commande bind, on relie facilement 10 adresses IP vers cette template pour
obtenir 10 machines.
Dans la configuration ci-dessus, on ajoute 4 ports ouvertes : deux pour le

protocole tcp et deux pour celui de udp. Et on met l’action par défaut pour les
protocoles est « reset ».
La figure suivante illustre le réseau virtuel simple
Machine virtuelle
192.168.160.3/24
Machine virtuelle
192.168.160.4/24
Machine host
192.168.160.1/24
Configurer un réseau virtuel avec un routeur

Le but de cette configuration est de créer un réseau ayant sous d’autre sous
réseau. Les deux sont reliés par un routeur. Dans cette configuration, on va
ajouter deux machines Windows avec les adresses IP : 192.168.161.11 et
192.168.161.12 derrière le routeur ayant l’adresse IP 192.168.160.100.
38
set Windows personality « Microsoft Windows XP #Choix le système d’exploitation
SP1 » et ses empreintes dans la base
de données
ère
ème
create Router #Créer un routeur CISCO

set Router Personality « Cisco IOS 11.3 – #Choisir le type de routeur
12.0(11) »
set Router default tcp action reset
set Router UID 32767 GID 32767
add Router tcp port 23 « perl scripts/router- #Comportement du routeur
telnet.pl »
bind 192.168.160.100 Router #L’adresse du routeur
route entry 192.168.160.100 network #Réseau accéder par routeur
192.168.160.0/16
route 192.168.160.100 link 192.168.161.0/16 #Réseau accéder par routeur
bind 192.168.161.11 Windows #Créer 3ère machine windows

Bind 192.168.161.12 Windows #Créer 4ère machine windows
La figure suivante illustre le réseau virtuel avec routeur
Le fichier de configuration est honeyd.conf.router
Configurer un réseau virtuel relié aux machines réelles

Dans cette architecture, j’utilise celle précédente et ajoute une machine réelle
ayant l’adresse IP 192.168.160.2/24 en ajoutant une seule ligne dans le fichier de
39
configuration :
bind 192.168.160.2 to ethernet
Dans notre cas, l’ethernet est vmnet1 car j’utilise vmware.
Le fichier de configuration est honeyd.conf.reel
Configurer un réseau virtuel complexe

Dans cette configuration, je vais utiliser les empreints différents pour créer les
machines Windows ainsi que machines Linux. Il y a un routeur dans le réseau et
une machine réelle Windows. Cette configuration va être utilisée pour tester. Le
nom du fichier configuration est honeyd.conf.compl

set Windows personality « Microsoft Windows XP #Empreints
SP1 »
ère
ème

set Windows personality « Microsoft Windows XP #Empreints
SP1 »
bind 192.168.160.5 Windows #Créer 1ère machine Linux

bind 192.168.160.6 Windows #Créer 2ème machine Linux
40
create Router #Créer un routeur CISCO
set Router Personality « Cisco IOS 11.3 – #Choisir le type de routeur
12.0(11) »
set Router UID 32767 GID 32767
add Router tcp port 23 « perl scripts/router- #Comportement du routeur
telnet.pl »
bind 192.168.160.100 Router #L’adresse du routeur
route entry 192.168.160.100 network #Réseau accéder par routeur

192.168.160.0/16
route 192.168.160.100 link 192.168.161.0/16 #Réseau accéder par routeur
ère
ère
Outils aide à créer fichier de configuration honeyd
C’est un petit outil qui permet de créer facilement un fichier de configuration dans
5 minutes grâce à l’interface graphique. Il est développé dans un environnement
de KDevelop et QT sous Mandrake 9.2 pendant le stage. Il distingue de trois
catégories principales : Template, bind et route. Ainsi que les commandes : add,
set … Il fournie aussi des fonctions externes comme ouvrir les fichier de
configuration, sauvegarder une configuration sous un fichier, arranger les lignes
dans la configuration…
C’est la version 1 donc il y a encore des restrictions. Mais dans la version

suivante, je les corrigerai.
41
L’image suivant illustre l’interface principale de cet outil.
Lancer Honeyd et analyser les données capturées
Condition préalable:
- La machine host est une machine Linux Redhat 9.0 avec l’adresse IP :
192.168.160.1 dans laquelle on installe arpd et honeyd.
- Une autre machine, appelant machine de teste fonctionne sous Windows
98 sous forme d’une machine virtuelle Vmware avec l’adresse IP
192.168.160.2. Dans laquelle, on installe le logiciel Superscan pour
analyser le réseau virtuel et faire un scan sur les portes de la machine
virtuelle créée par honeyd.
42
Attention:
- Arpd va détruire le système DHCP dans le même réseau. C’est pourquoi je
choix le réseau 192.168.x.x pour simuler le réseau virtuel.
- La machine hôte ne peut pas ping vers les machines virtuelles à cause de
la technique de la commande Ping. Pour la commande Ping, elle envoie
des requêtes ICMP sur le réseau. Toutes les machines sur le même
réseau recevraient ces requêtes sauf elle. Donc, aprd sur le hôte ne reçoit
aucune requête ICMP. C’est la raison pour laquelle les machines virtuelles
ne répondent pas le hôte.
Lancer
# arpd 192.168.160.2-192.168.160.6 192.168.160.100 192.168.161.11-
192.168.161.12
# ./honeyd –f honeyd.conf.compl –a nmap.assoc –p nmap.prints –x xprobe2 –0
p0.os –l /var/log/honeyd.log 192.168.160.2-192.168.160.6 192.168.160.100
192.168.161.11-192.168.161.12
Analyser les données capturées
D’abord il faut faire une petite attaque vers notre réseau virtuel pour obtenir des
données. Le scénario est:
- Lancer la commande Ping
- Utiliser le navigateur de Web
- Lancer la commande Ftp
- Lancer la commande Telnet
- Lancer le logiciel SuperScan
Les adresses IP utilisées dans le scénario sont dans la table suivante
Machine Description Services
192.168.160.1 Machine host – réelle

192.168.160.2 Machine teste – réelle (machine VMWare)
192.168.160.3 Machine virtuelle – Windows Web
192.168.160.4 Machine virtuelle – Windows Web
192.168.160.5 Machine virtuelle – Linux Suse 7.0 Syslogd, web, ftp...

192.168.160.6 Machine virtuelle – Linux Suse 7.0 Syslogd, web, ftp...
43
Machine Description Services
192.168.160.100 Routeur Telnet
Maintenant, on va voir les données capturées et les analyser.

Premièrement, les empreintes de la commande Ping
Quand on lance la commande Ping de 192.168.160.2 (machine ou on teste) vers

la machine 192.168.160.3, arpd sur la machine host (192.168.160.1) recevra une
question « Qui a l'adresse IP 192.168.160.3 ». Il va répondre: Machine
192.168.160.3 se situe sur l'adresse 00:50:56:c0:00:01.
arpd[6304]: arpd_send: who-has 192.168.160.3 tell 192.168.160.1

arpd[6304]: arpd_send: who-has 192.168.160.3 tell 192.168.160.1
arpd[6304]: arp reply 192.168.160.3 is-at 00:50:56:c0:00:01
Dès maintenant, arpd rédige la gestion du IP 192.168.160.3 à honeyd. Quand à

honeyd, il va répondre à la commande Ping
honeyd[9200]: Sending ICMP Echo Reply: 192.168.160.3 -> 192.168.160.2

Les messages ci-dessus sont les messages dans le mode debug, mais les
messages importants se trouvent dans le fichier honeyd.log sont:
2004-05-20-21:33:47.0992 honeyd log started ------

2004-05-20-21:34:17.0037 icmp(1) - 192.168.160.2 192.168.160.3: 8(0): 60
2004-05-20-21:34:18.0081 icmp(1) - 192.168.160.2 192.168.160.3: 8(0): 60
2004-05-20-21:34:19.0118 icmp(1) - 192.168.160.2 192.168.160.3: 8(0): 60
On peut trouver la date (et l'heurs), protocole (icmp), IP source et IP destination...

L'image suivante va nous montrer en détail:
44
Deuxièmement, on va tester si le port 80 est fonctionne ou non pour les machines
simulées
Honeyd a déjà noté toutes les connexions vers la machine 192.168.160.5 (On
peut la considérer comme le serveur de Web car sur cette machine honeyd simule
un service de Web)
2004-05-20-21:34:56.0695 tcp(6) S 192.168.160.2 2556 192.168.160.5 80

[Windows XP SP1]
2004-05-20-21:34:56.0773 tcp(6) S 192.168.160.2 2557 192.168.160.5 80
[Windows XP SP1]
2004-05-20-21:35:01.0739 tcp(6) S 192.168.160.2 2558 192.168.160.5 80
[Windows XP SP1]
2004-05-20-21:35:03.0078 tcp(6) S 192.168.160.2 2559 192.168.160.5 80
[Windows XP SP1]
2004-05-20-21:35:11.0735 tcp(6) E 192.168.160.2 2557 192.168.160.5 80: 247
657
2004-05-20-21:35:12.0503 tcp(6) E 192.168.160.2 2556 192.168.160.5 80: 248
658
2004-05-20-21:35:17.0414 tcp(6) E 192.168.160.2 2558 192.168.160.5 80: 251
661
2004-05-20-21:35:18.0344 tcp(6) E 192.168.160.2 2559 192.168.160.5 80: 249
45
659
Quatre premières lignes nous montrent qu'il y a quatre requêtes de 192.168.160.2

au 192.168.160.5 sur le port 80 avec l’état « Start »
Après une période de temps, la machine 192.168.160.2 ferme les connexions, on
reçoit donc quatre messages dans le fichier log (indiquer par l’état « End »)
Les images suivantes illustrent deux fenêtres du navigateur de Web dont les
résultats simulés
46
Troisièmement: Maintenant on va essayer avec la commande « ftp »
2004-05-20-21:36:00.0834 tcp(6) S 192.168.160.2 2560 192.168.160.6 21

[Windows XP SP1]
La machine cible a l'adresse 192.168.160.6. Le message ci-dessus est extrait

dans le fichier honeyd.log et l'image suivante montre ce que l'on a fait avec la
commande « ftp »
47
Quatrièmement: Maintenant c'est la commande « telnet »
Le message suivant est extrait dans le fichier honeyd.log qui montre l'empreinte
de la commande « telnet »
2004-05-20-22:12:36.0278 tcp(6) S 192.168.160.2 3031 192.168.160.100 23

[Windows XP SP1]
La machine cible a l'adresse 192.168.160.100. C'est le routeur virtuel ou on simule

le service « telnet ».
Les messages suivants sont les messages en mode « debug » du honeyd.
honeyd[9816]: Connection request: tcp (192.168.160.2:3029 -

192.168.160.100:23)
honeyd[9816]: Connection established: tcp (192.168.160.2:3029 -
192.168.160.100:23) <-> /usr/bin/perl scripts/routers/cisco/router-telnet.pl
48
La machine 192.168.160.2 envoie une requête au routeur (192.168.160.100) sur
le port 23 pour demander d'établir une connexion. Après avoir établie une
connexion, l'attaquant va être tomber sur le service simulé: router-telnet.pl.
L'image suivante montre ce que l'on a fait avec la commande « telnet »
En fin: On va lancer un scan sur la machine 192.168.160.5 pour trouver toutes les
informations nécessaires: Les services, les ports ouverts, quel système
d'exploitation utilisé.
49
Grâce au superscan, on peut trouver le système d'exploitation sur la machine
192.168.160.5. Plus détaillé, la version du noyau sur cette machine est 2.4.7 (0).
On voit également les services FTP, SSH, Telnet, SMTP, IMCP HTTP... Les
attaquants qui n'ont pas d'expérience se sont trompés facilement que la machine
192.168.160.5 est une machine réelle.
50
Annexes
Les fragments techniques

(Utilise tous les textes fournis sur l’internet)
1. Tiny fragments
D'après la RFC (Request For Comment) 791 (IP), tous les noeuds Internet
(routeurs) doivent pouvoir transmettre des paquets d'une taille de 68 octets sans
les fragmenter d'avantage. En effet, la taille minimale de l'en-tête d'un paquet IP
est de 20 octets sans options. Lorsqu'elles sont présentes, la taille maximale de
l'en-tête est de 60 octets. Le champ IHL (Internet Header Length) contient la
longueur de l'en-tête en mots de 32 bits. Ce champ occupant 4 bits, le nombre de
valeurs possibles vaut de 2^4 - 1 = 15 (il ne peut pas prendre la valeur 0000). La
taille maximale de l'en-tête est donc bien 15*4 = 60 octets. Enfin, le champ
Fragment Offset qui indique le décalage du premier octet du fragment par rapport
au datagramme complet est mesuré en blocs de 8 octets. Un fragment de
données occupe donc au moins 8 octets. Nous arrivons bien à un total de 68
octets.
L'attaque consiste à fragmenter sur deux paquets IP une demande de connexion

TCP. Le premier paquet IP de 68 octets ne contient comme données que les 8
premiers octets de l'en-tête TCP (ports source et destination ainsi que le numéro
de séquence). Les données du second paquet IP renferment alors la demande de
connexion TCP (flag SYN à 1 et flag ACK à 0).
Or, les filtres IP appliquent la même règle de filtrage à tous les fragments d'un
paquet. Le filtrage du premier fragment (Fragment Offset égal à 0) déterminant
cette règle elle s'applique donc aux autres (Fragment Offset égal à 1) sans aucune
autre forme de vérification. Ainsi, lors de la défragmentation au niveau IP de la
machine cible, le paquet de demande de connexion est reconstitué et passé à la
couche TCP.
La connexion s'établit alors malgré le filtre IP.
Les figures 1 et 2 montrent les deux fragments et la figure 3 le paquet

défragmenté au niveau de la machine cible :
51
Fig.1: Fragment 1
Fig.2: Fragment 2
Fig.3: Paquet défragmenté
52
2. Fragment overlapping
Toujours d'après la RFC 791 (IP), si deux fragments IP se superposent, le

deuxième écrase le premier. L'attaque consiste à forger deux fragments d'un
paquet IP. Le filtre IP accepte le premier de 68 octets (voir Tiny Fragments) car il
ne contient aucune demande de connexion TCP (flag SYN = 0 et flag ACK = 0).
Cette règle d'acceptation s'applique, là encore, aux autres fragments du paquet.
Le deuxième (avec un Fragment Offset égale à 1) contenant les véritables
données de connexion est alors accepté par le filtre IP. Ainsi, lors de la
défragmentation les données du deuxième fragment écrasent celles du premier à
partir de la fin du 8ème octet (car le fragment offset est égal à 1). Le paquet
rassemblé constitue donc une demande de connexion valide pour la machine
cible. La connexion s'établit malgré le filtre IP.
Les figures 4 et 5 montrent les deux fragments et la figure 6 le paquet

défragmenté au niveau de la machine cible :
Fig.4: Fragment 1
53
Fig.5: Fragment 2
Fig.6: Paquet défragmenté
54
Références
http://www.xphys.tuwien.ac.at/ mike/security/network-security.html
http://staff.washington.edu/dittrich/misc/stacheldraht.analysis
http://staff.washington.edu/dittrich/misc/trinoo.analysis
http://staff.washington.edu/dittrich/misc/tfn.analysis
http://staff.washington.edu/dittrich/misc/trinoo.analysis
http://staff.washington.edu/dittrich/misc/tfn.analysis
http://staff.washington.edu/dittrich/misc/stacheldraht.analysis
http://www.cert.org/advisories/CA-2000-01.html
http://www.cert.org/advisories/CA-99-17-denial-of-service-tools.html
http://www.cert.org/advisories/CA-98-13-tcp-denial-of-service.html
http://www.cert.org/incident_notes/IN-99-07.html
http://www.sans.org/y2k/solaris.htm
http://www.tracking-hackers.com/papers/honeypots.html
http://www.honeypots.net/
http://www.rit.edu/~arl7969/whitepapers/alamb-4-2004.html
http://www.rit.edu/~arl7969/whitepapers/manuzis-2-22-2003.html
http://www.rit.edu/~arl7969/whitepapers/manuzis-7-5-2002-1.html
http://www.rit.edu/~arl7969/whitepapers/mcooper-4-2002.html
http://www.rit.edu/~arl7969/whitepapers/sholcroft-4.1-2002.html
http://www.rit.edu/~arl7969/whitepapers/sholcroft-4-2002.html
http://project.honeynet.org/papers/virtual/
http://project.honeynet.org/papers/index.html
http://project.honeynet.org/
http://www.honeynet.org/papers/
http://www.linuxsecurity.com/feature_stories/feature_story-100.html
http://www.packetfu.org/hnd.html
http://www.epmhs.gr/honeynet/
55

RAPPORT DE STAGE DE FIN D ETUDES. Sujet PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

RAPPORT DE STAGE DE FIN D ETUDES. Sujet PDF

Transféré par

Droits d'auteur :

Formats disponibles

Institut de la Francophonie Ecole Nationale Supérieure des

pour l’Informatique Télécommunications

RAPPORT DE STAGE DE FIN D’ETUDES

Paris, jenvier - juillet 2004

Etude bibliographique des parades au DoS et DDoS

Etude des HoneyPot

Intégration des HoneyPot dans une architecture globale de protection

L’objectif du projet était de :

Ce document présentera 4 parties principales correspondantes à l’objectif du

Je tien tout d’abord à remercier Monsieur le Professeur Ahmed Serhrouchni pour

Déterminer des vulnérabilités

Le craquage par mot de passe

La manière la plus classique par laquelle un hacker va essayer d'obtenir un mot

Le sniffing des mots de passe et des paquets

Voici ci-dessous une liste d'autres sniffers disponibles dans le commerce

La meilleure défense contre l'attaque de sniffers est l'utilisation d'un protocole de

Beaucoup de machines Unix acceptent les paquets de route source et les

Les chevaux de Troie

Un cheval de Troie est un programme qui se cache lui-même dans un autre

Les bombes logiques

Nous allons voir en détail ces trois familles.

Les attaques directes

L'attaque FTP Bounce fait partie de cette famille d'attaque.

Les attaques indirectes par réponse

Quelques parades de type DoS

ping -f -s 65550 xxx.xxx.xxx.xxx

MF=1 Offset=0 MF=0 Offset=65000

Quand on les rassemble, la taille du nouveau fragment est

On va voir ce problème dans le système d'exploitation Minix version 2.0.2. Le

second_datasize = 65000 + 1000 – (0 + 65000) = 1000

MF=1 Offset=0 MF=0 Offset=500

Supposons que l'on reçoit 2 fragments ci-dessus et on est en train de traiter le

On a i = 1000 – 500 = 500

De la version 2.1.89 à 2.2.3 du noyau, on a changé le code pour contre cette

Un réseau typique se compose donc d'un maître (point central) et de nombreux

1. TFN (Tribal Flood Network)

Agent Agent Agent

- Protocole de la communication entre Client/Agent : ICMP

- TFN2K est silence, cad il ne fait pas de ACK de la commande il reçois. Le

- Toutes les données chiffrées sont Base 64 encoded avant de l'envoie

Master Master Master

Deamon Deamon Deamon Deamon

- L’attaquant communique avec les masters par le protocole TCP sur la

Handler Handler Handler

Agent Agent Agent Agent

TFN client: tfn

Stacheldraht Handler: mserv

Shaft Handler: shaftmaster

mstream Handler: master

Trinity Agent: /usr/lib/idle.so

Il existe également un compte-rendu de congrès scientifique sur le sujet qui

Le Pushback : une contre-mesure en développement

Face aux menaces grandissantes provoquées par ce type d'attaques, les

Le but est d'identifier les agrégats responsables de la congestion et de les éliminer

Cette technique récursive a pour avantage de pouvoir remonter jusqu'aux sources

Les types d'honeypot

Pour mieux comprendre comment fonctionnent les deux types ci-dessus, on va

Honeyd: Low-interaction honeypot.

Quelque honeypots, comme Honeyd, peuvent non seulement simuler des

Honeynet: High-interaction honeypot.

L'exemple du déploiement de honeynet est dans la figure suivante:

Honetpot aide à prévenir par certaines façons. Premièrement, il contre les

Les librairies nécessaires pour compiler honeyd: libpcap, libdnet, et libevent