DÉTECTION D INTRUSIONS ET ANALYSE PASSIVE DE RÉSEAUX

MATHIEU COUTURE DÉTECTION D INTRUSIONS ET ANALYSE PASSIVE DE RÉSEAUX Mémoire présenté à la Faculté des études supérieures de l Université Laval dans le cadre du programme de maîtrise en informatique pour l obtention du grade de Maître ès sciences DÉPARTEMENT D INFORMATIQUE ET DE GÉNIE LOGICIEL FACULTÉ DES SCIENCES ET DE GÉNIE UNIVERSITÉ LAVAL QUÉBEC juin 2005 c Mathieu Couture, 2005

Résumé Dans ce travail, nous proposons un nouveau langage dédié à la détection d intrusions. Il s agit d un langage purement déclaratif, basé sur une logique temporelle linéaire passée avec prédicats du premier ordre. Après avoir effectué une revue de treize langages de détection d intrusions existant déjà, nous donnons une liste de dix propriétés souhaitables pour un langage de détection d intrusions. Contrairement au langage que nous proposons, aucun des langages étudiés ne présente à la fois ces dix propriétés. En plus d être suffisamment expressif pour répondre aux besoins identifiés, il vient avec un algorithme de vérification qui s exécute en temps linéaire avec la quantité d information analysée et utilise une quantité bornée d espace mémoire. Ces deux propriétés permettent de protéger le système de détection d intrusions contre d éventuelles attaques d inondation.

Avant-propos Je désire d abord remercier ma mère, qui a su me donner le goût des études, ainsi que mon père, qui m a appris l importance de l intégrité et de la transparence. Je les remercie tous les deux pour le support et les encouragements qu ils m ont donné tout au long de mon cheminement, autant personnel qu académique. Je remercie aussi mon directeur de recherches, le professeur Béchir Ktari, pour avoir accepté de me diriger dans un domaine aussi stimulant, et pour la confiance qu il m a montrée tout au long de ces deux années de travail. J adresse aussi mes remerciements à Frédéric Massicotte, ami et collaborateur au Centre de Recherches sur les Communications, qui a su à plusieurs occasions me donner des critiques constructives sur mon travail. Je le remercie aussi pour son sens aigu du bien-être d autrui, qu il a su en partie me communiquer. Je tiens aussi à exprimer ma reconnaissance envers les professeurs Josée Desharnais et Mohamed Mejri qui ont accepté d évaluer ce mémoire. Je remercie le personnel administratif du département d informatique, et plus particulièrement Lynda Goulet, pour sa bonne humeur et les nombreux services qu elle m a rendus. Je remercie le Centre de Recherches sur les Communications, pour son support matériel et financier, le Gouvernement Français, pour m avoir accueilli et avoir financé en partie mes recherches, de même que les professeurs André-Luc Beylot, Marc Boyer et Jérôme Ermont, pour leur chaleureux accueil à l ENSEEIHT, à Toulouse. Je remercie le Ministère des Relations Internationales du Québec, pour avoir rendu possible cet échange avec l ENSEEIHT. Merci à Catherine et aux colocs du 22A, pour leur présence chaleureuse et les nombreuses soirées que nous avons passées ensemble. Merci à Alexandre Lacasse, pour son agréable compagnie au cours des deux voyages que nous avons faits en France, de même que pour ses commentaires encourageants et constructifs. Finalement, je remercie toutes celles et ceux de mes amies et amis qui m ont encouragé et supporté dans mes projets.

À ma mère, Nicole, avec qui tout a commencé. Imagination is more important than knowledge.

Table des matières Résumé Avant-propos Table des matières Liste des tableaux Table des figures ii iii v viii x Introduction 1 1 Systèmes de détection d intrusions 5 1.1 Langages spécifiques au domaine...................... 7 1.1.1 Panoptis................................ 8 1.1.2 Snort.................................. 11 1.1.3 NeVO................................. 15 1.2 Langages impératifs.............................. 18 1.2.1 ASAX................................. 19 1.2.2 BRO.................................. 22 1.3 Systèmes de transitions............................ 25 1.3.1 STAT................................. 26 1.3.2 IDIOT................................. 30 1.3.3 BSML................................. 32 1.4 Systèmes experts............................... 35 1.4.1 P-BEST................................ 36 1.4.2 LAMBDA............................... 38 1.5 Logiques temporelles............................. 41 1.5.1 LogWeaver.............................. 42 1.5.2 Monid................................. 44 1.5.3 Chronicles............................... 46 1.6 Conclusion................................... 51

Table des matières vi 2 Logiques temporelles 55 2.1 Logiques temporelles............................. 58 2.1.1 Logique temporelle linéaire...................... 58 2.1.2 Logique temporelle linéaire passée.................. 60 2.1.3 Logique temporelle linéaire avec passé oubliable.......... 63 2.1.4 µ-calcul linéaire............................ 65 2.2 Logiques temporisées............................. 67 2.2.1 Logique temporelle temporisée.................... 67 2.2.2 Logique temporelle métrique..................... 70 2.2.3 TRIO................................. 71 2.3 Conclusion................................... 72 3 Détection d intrusions et analyse passive 74 3.1 Architecture du système........................... 76 3.2 Langage.................................... 77 3.3 Scénarios d attaques complexes....................... 78 3.4 Acquisition passive d information...................... 80 3.4.1 Ports TCP ouverts et sessions actives................ 80 3.4.2 Ports TCP fermés........................... 82 3.4.3 Sessions fermées et balayage FIN.................. 82 3.4.4 Vulnérabilités et systèmes d exploitation.............. 83 3.4.5 Adresses du routeur......................... 84 3.4.6 Inférence de nouvelles connaissances................ 85 3.5 Présentation formelle du langage...................... 86 3.5.1 Modèle................................. 86 3.5.2 Syntaxe................................ 87 3.5.3 Sémantique.............................. 89 3.5.4 Algorithme.............................. 90 3.6 Conclusion................................... 95 4 Logique d acquisition de connaissances 97 4.1 Un paradigme passé............................. 98 4.1.1 Modèle................................. 99 4.1.2 Syntaxe................................ 99 4.1.3 Sémantique.............................. 100 4.2 Unification................................... 102 4.2.1 Modèle................................. 103 4.2.2 Syntaxe................................ 103 4.2.3 Sémantique.............................. 106 4.3 Récursivité.................................. 112 4.3.1 Approximants............................. 112

Table des matières vii 4.3.2 Tableaux................................ 113 4.4 Algorithmes.................................. 114 4.4.1 Cas propositionnel.......................... 115 4.4.2 Cas du premier ordre......................... 118 4.5 Conclusion................................... 129 5 Travaux futurs 132 5.1 Satisfiabilité.................................. 132 5.2 Filtrage dynamique et sémantique de symptôme.............. 134 5.3 Synthèse de contrôleur............................ 136 Conclusion 142 Bibliographie 144

Liste des tableaux 1.1 Algorithme d apprentissage et de vérification de Panoptis......... 9 1.2 Syntaxe abstraite de RUSSEL......................... 20 1.3 Syntaxe des patrons dans BSML....................... 33 1.4 Syntaxe du calcul d événements utilisé dans LAMBDA........... 38 1.5 Syntaxe d un scénario d attaque LAMBDA................. 39 1.6 Syntaxe de la première logique de LogWeaver................ 42 1.7 Syntaxe des spécifications Eagle........................ 45 1.8 Prédicats de réification de Chronicles..................... 48 1.9 Dix propriétés souhaitables d un IDS..................... 52 1.10 Tableau récapitulatif des IDS......................... 53 2.1 Familles de logiques temporelles et leur modèle............... 57 2.2 Syntaxe de LTL................................ 58 2.3 Sémantique de LTL.............................. 59 2.4 Opérateurs définis de LTL........................... 59 2.5 Syntaxe de P-LTL............................... 60 2.6 Sémantique des opérateurs particuliers à P-LTL............... 61 2.7 Opérateurs définis de P-LTL......................... 61 2.8 Syntaxe de N-LTL............................... 63 2.9 Sémantique de l opérateur particulier à N-LTL............... 64 2.10 Syntaxe du µ-calcul linéaire.......................... 65 2.11 Sémantique de l opérateur particulier au µ-calcul linéaire.......... 65 2.12 Opérateurs définis du µ-calcul linéaire.................... 66 2.13 Syntaxe de T-LTL............................... 68 2.14 Sémantique des opérateurs particuliers à T-LTL............... 69 2.15 Un opérateur défini de T-LTL......................... 69 2.16 Syntaxe de MTL................................ 70 2.17 Sémantique des opérateurs particuliers à MTL................ 70 2.18 Syntaxe de TRIO................................ 71 2.19 Sémantique de l opérateur particulier à TRIO................ 71 2.20 Quelques opérateurs définis de TRIO..................... 72

Liste des tableaux ix 3.1 Syntaxe du langage de signatures....................... 77 3.2 Syntaxe..................................... 88 3.3 Sémantique................................... 89 3.4 Syntaxe du sous-ensemble associé au langage de signatures......... 90 3.5 Algorithme de vérification........................... 92 4.1 Syntaxe pour le cas propositionnel...................... 99 4.2 Sémantique pour le cas propositionnel.................... 100 4.3 Syntaxe pour le cas du premier ordre..................... 103 4.4 Sémantique opérationnelle pour le cas du premier ordre.......... 106 4.5 Approximants................................. 113 4.6 Approximants avec intervalles......................... 114 4.7 Algorithme de vérification pour le cas propositionel............. 116 4.8 Algorithme de vérification pour le cas du premier ordre........... 120 4.9 Sémantique dénotationnelle pour le cas du premier ordre.......... 121 5.1 Système de preuves à base de tableaux.................... 134 5.2 Sémantique de symptôme........................... 135 5.3 Syntaxe de l algèbre des automates...................... 137 5.4 Sémantique de l algèbre des automates.................... 137 5.5 Algorithme de synthèse de contrôleur..................... 139

Table des figures 1.1 Exemple de fichier de configuration de Panoptis............... 8 1.2 Exemple de fichier de planification de tâches de Panoptis.......... 9 1.3 Exemple de fichier de sortie de Panoptis................... 9 1.4 Structure de Snort............................... 12 1.5 Exemple de signature Snort.......................... 13 1.6 Exemple d utilisation du module de réaction................. 14 1.7 Exemple d utilisation du module flowbits................... 14 1.8 Exemple de signature NeVO.......................... 17 1.9 Détection d une pénétration externe dans ASAX.............. 21 1.10 Structure de Bro................................ 22 1.11 Exemple de script Bro............................. 23 1.12 Session à demi ouverte dans NetSTAT.................... 28 1.13 Session à demi ouverte dans l outil STATed................. 29 1.14 Modélisation d un réseau avec NetSTAT................... 29 1.15 Session TCP dans IDIOT........................... 31 1.16 Attaque TCP SYN-Flood dans BSML.................... 34 1.17 Exemple de règle d inférence dans P-BEST................. 37 1.18 Modélisation du scénario d accès illégal à un fichier avec LAMBDA.... 40 1.19 Exemple de spécification Eagle........................ 45 1.20 Exemple de chronique............................. 48 2.1 Exemples de programmes........................... 60 3.1 Architecture du système développée (à droite), et celle de Snort (à gauche). 76 3.2 Balayage SYN................................. 79 3.3 Poignée de main TCP............................. 81 3.4 Ports TCP fermés............................... 81 3.5 Fermeture d une session TCP......................... 81 3.6 Détection d un système d exploitation FreeBSD 3.0 à 4.3.......... 83 3.7 Règle Snort numéro 343............................ 84 3.8 Réduction des faux-positifs à l aide de la détection de vulnérabilités.... 84 3.9 Adresses du routeur.............................. 85

Table des figures xi 3.10 Inférence de nouvelles connaissances..................... 85 3.11 Exemple de trace................................ 87 3.12 Formule représentant une poignée de main TCP............... 88 3.13 Spécification associée au scénario d une poignée de main TCP....... 91 3.14 Exemple de trace d exécution de l algorithme................ 93 4.1 Attaque dans le contexte d une session TCP active............. 99 4.2 Exemple de trace pour le cas propositionnel................. 101 4.3 Exemple de relations de satisfaction pour le cas propositionnel....... 101 4.4 Exemple de trace du premier ordre...................... 102 4.5 Suivi des sessions TCP............................. 105 4.6 Exemple de relations de satisfaction pour le cas du premier ordre..... 107 4.7 Utilisation des approximants......................... 113 4.8 Utilisation des approximants avec intervalles................. 114 4.9 Balayage de ports TCP............................ 115 5.1 Exemples de contradictions.......................... 133 5.2 Exemple de conflit............................... 136 5.3 Automate TCP................................. 138 5.4 Contrôleur pour l automate TCP relativement à (rst [synack, ack]).. 138 5.5 Contrôleur universel pour (rst [synack, ack])............... 140

Introduction Contexte La détection d intrusions est un problème inhérent à la nature abstraite d un réseau informatique. Il est plutôt rare que l on puisse dire, par un simple coup d oeil aux équipements informatiques, que ceux-ci ont été ou sont présentement utilisés d une façon non-souhaitable. Pour le savoir, il faut étudier attentivement des quantités la plupart du temps astronomiques de fichiers d audit et faire preuve d une patience et d une capacité d analyse hors du commun. Afin de nous alléger cette tâche ardue, les informaticiens se sont mis à développer des outils logiciels automatisant une partie du travail. Ils les ont appelés systèmes de détection d intrusions. Les systèmes de détection d intrusions sont généralement classés en deux catégories : les détecteurs d anomalies et les systèmes à base de scénarios. Les détecteurs d anomalies fonctionnent généralement en deux phases : une phase d apprentissage et une phase de détection. Au cours de la phase d apprentissage, le système apprend à reconnaître ce qu est un comportement normal, et au cours de la phase de détection, il identifie les comportements anormaux. Les systèmes pour lesquels la phase d apprentissage continue après le début de la phase de reconnaissance sont dits adaptatifs. L objectif des systèmes adaptatifs est de tenir compte de la nature changeante des réseaux informatiques. Les systèmes à base de scénarios n ont pas de phase d apprentissage. Ils viennent avec une base de scénarios d attaque prédéfinis qu ils doivent reconnaître. L avantage des détecteurs d anomalies est donc de pouvoir détecter des scénarios d attaque insoupçonnés, au risque de générer des faux-positifs (fausses alarmes), alors que celui des systèmes à base de scénarios est de générer moins de faux-positifs, au risque de laisser passer des attaques encore inconnues. Dans ce cas, on parle de faux-négatifs. Le présent travail s intéresse surtout aux systèmes à base de scénarios. Une autre façon de classer les systèmes de détection d intrusions est selon le niveau auquel ils interviennent : hôte ou réseau. Au niveau hôte, les fichiers d audit analysés

Introduction 2 sont des fichiers systèmes : utilisation du processeur, du système de fichiers, du réseau, traces d exécution de programmes, etc., alors qu au niveau réseau, les fichiers d audit utilisés sont des traces de trafic. Une trace de trafic est une copie de tout le trafic ayant circulé à un endroit donné d un réseau informatique. Il s agit en fin de compte d un cas particulier de fichier d audit, et c est pourquoi certains systèmes de détection présentent une approche générale permettant de regrouper les deux cas de cette classification. Plusieurs paradigmes, auxquels nous reviendrons, ont été proposés pour les langages de signatures des systèmes de détection d intrusions à base de scénarios. Parmi ceux-ci, se trouvent ceux basés sur des logiques temporelles. Les logiques temporelles, en méthodes formelles, ont été utilisées pour s attaquer à trois catégories de problèmes : Vérification Étant donné un programme, décider, avant même de l exécuter, si toutes ses exécutions respecteront une propriété donnée. Synthèse Étant donnée une propriété, générer un programme tel que toutes ses exécutions respectent cette propriété. Validation Étant donnée une exécution d un programme, décider si cette exécution respecte une propriété donnée. Le présent travail s inscrit donc dans un contexte de validation. Dans notre cas, le programme à valider sera le réseau, et son exécution sera matérialisée par les différents fichiers d audit mis à notre disposition. Bien que nous nous intéressions particulièrement aux traces de trafic, la méthode que nous proposons s adapte aussi bien aux autres fichiers d audit. Il convient de noter, avant d aller plus loin, que la détection d intrusions a ceci de particulier que les exécutions auxquelles on s intéresse sont de longueur infinie. Les méthodes proposées pour des exécutions finies de programmes ne sauraient donc s appliquer ici. Objectifs et méthodologie Nous nous sommes donné comme mandat de développer un langage de détection d intrusions qui soit basé sur un paradigme purement déclaratif. Pour ce faire, nous avons d abord dû effectuer une revue des langages de détection d intrusions existant déjà. Bien que plusieurs d entre eux aient la prétention d être déclaratifs, il s est avéré que le bien fondé de cette affirmation était dans la plupart des cas discutable. Ceux étant le plus près de répondre à ce critère étant ceux basés sur un paradigme de logique temporelle, nous avons privilégié cette voie pour la poursuite de nos travaux.

Introduction 3 Nous avons donc dû nous familiariser avec les logiques temporelles, et voir comment celles-ci pouvaient être utilisées pour répondre à nos besoins. Un de ces besoins était d acquérir passivement de l information sur un réseau informatique, de façon à faire une détection d intrusions plus accrue. En effet, un reproche ayant souvent été fait aux systèmes de détection d intrusions est de ne pas tenir compte du contexte avant de signaler des alarmes. Cette sauvegarde du contexte ne saurait cependant être faite sans un coût additionnel, le pire cas, tout à fait déraisonnable, constituant la sauvegarde complète de la trace de trafic. Au mieux, on ne sauvegarde que l information nécessaire, pas un bit de plus. La capacité à traiter un fichier d audit enregistrement par enregistrement sans revenir en arrière est ce que nous appellerons traitement en ligne. Les trois objectifs principaux de notre travail sont donc : 1. Paradigme déclaratif, 2. acquisition passive d information, 3. et traitement en ligne. Nous proposons deux approches pour s attaquer à ces problèmes. La première est une approche hybride où la séparation entre l information acquise et les scénarios à reconnaître est claire, tant au niveau du langage que du logiciel développé, et la seconde approche permet d uniformiser l acquisition d information et la définition de scénarios à reconnaître. Dans le premier cas, le langage utilisé pour décrire les scénarios est basé sur une logique temporelle avec opérateurs futurs, et dans le second cas, il est basé sur une logique temporelle avec opérateurs passés. Organisation La première partie de ce mémoire est une revue de littérature en deux volets. Au chapitre 1, nous dressons un état de l art détaillé des langages de signatures utilisés par treize systèmes de détection d intrusions. Nous proposons une taxonomie divisant ces langages en cinq catégories, selon les paradigmes utilisés. À la fin de ce chapitre, nous dressons une liste de dix propriétés identifiées comme souhaitables pour un langage de détection d intrusions. Au chapitre 2, nous présentons les logiques temporelles ayant le plus influencé notre travail. La seconde partie de ce mémoire présente le travail effectué. Au chapitre 3, nous décrivons un outil d acquisition passive d information et de détection d intrusions que nous avons développé. Cet outil utilise un langage de signatures qui permet de com-

Introduction 4 biner et d effectuer les deux tâches dans un paradigme uniforme. Au chapitre 4, nous présentons un autre langage, développé en vue de combler les lacunes identifiées avec le premier. Entre autres, ce langage a la propriété d être purement déclaratif. Pour chacun de ces deux langages, nous présentons les algorithmes de vérification à utiliser et donnons les preuves de complétude et de cohérence. La troisième partie constitue la conclusion. Au chapitre 5, nous donnons quelques idées pour la continuation des travaux de recherche effectués dans le cadre de cette maîtrise. Nous dressons un bilan des travaux effectués au dernier chapitre.

Chapitre 1 Systèmes de détection d intrusions Un système de détection d intrusions (ou IDS pour Intrusion Detection System) est une composante logicielle responsable d identifier une utilisation non-désirable d une ressource informatique. On peut classer les IDS selon plusieurs critères. Les critères les plus généralement rencontrés sont le type de sonde (réseau ou hôte) et le type d algorithme (statistique ou à base de signatures). Les systèmes basés sur des méthodes statistiques, aussi appelés détecteurs d anomalies, présentent l avantage de pouvoir découvrir des attaques encore non-répertoriées. Ils fonctionnent généralement en deux phases : une phase d apprentissage et une phase de détection proprement dite. Pendant la phase d apprentissage, le système dresse un profil de ce qui sera par la suite considéré comme un comportement normal. La phase de reconnaissance, quand à elle, consistera à détecter des déviations du comportement normal. Normalement, la phase d apprentissage continue pendant la phase de reconnaissance. Cette stratégie permet de faire face à la nature changeante du comportement des utilisateurs et ainsi de s adapter au changement. L hypothèse derrière cette façon de faire est que le comportement normal d un utilisateur change de façon graduelle et qu une utilisation non-désirée du réseau entraînera un changement brusque dans le comportement. Cette hypothèse entraîne à la fois des faux-positifs (fausse alarme) et des faux-négatifs (attaque non-détectée). Les faux positifs surviennent lorsque les utilisateurs changent leur comportement de façon brusque, par exemple en installant un nouveau logiciel. Les faux négatifs, quand à eux, surviennent lorsqu un utilisateur malveillant au courant de la stratégie de détection change son comportement petit à petit de façon à exploiter la capacité d adaptation du système. Les IDS fonctionnant à base de signatures, quand à eux, engendrent moins de fauxpositifs car on leur spécifie exactement ce qu ils doivent détecter. Cependant, comme

Chapitre 1. Systèmes de détection d intrusions 6 on doit constamment tenir à jour leur base de signatures, le risque de faux-négatifs est plus élevé. Le modèle de système de détection d intrusions à base de signatures le plus simple que nous puissions imaginer est celui généralement utilisé dans le domaine des anti-virus : celui du patron de bits. L hypothèse menant à cette méthode de travail est qu un comportement non-désirable peut être détecté à partir d un petit nombre de bits physiquement situés à proximité les uns des autres. Dans le cas des anti-virus, il s agit généralement des premiers bits du fichier, alors que dans les IDS réseaux tels que Snort [1], il peut s agir de quelques bits bien ciblés d un seul paquet. Bien que naïve en apparence, la stratégie du patron de bits a mené jusqu à date à de très bons résultats, et ce pour deux raisons : premièrement, la complexité algorithmique liée à la vérification des signatures est des plus avantageuses (constante en mémoire et linéaire en temps) ; deuxièmement, la simplicité du langage de signature encourage la communauté d utilisateurs à participer à l enrichissement de la base de données de signatures. Les IDS fonctionnant à base de patrons de bits comportent cependant des faiblesses au niveau de l expressivité des signatures qui peuvent mener autant à des faux-positifs qu à des faux-négatifs. C est pourquoi la communauté scientifique persiste à mettre tant d efforts dans le développement d IDS pouvant détecter des patrons d événements séparés dans le temps. Les signatures de ces systèmes permettent de prendre en compte le contexte avant de signaler une alarme. Par exemple, dans le cas d un IDS réseau, ils permettent de spécifier que pour être valide, une attaque doit survenir dans le contexte d une session active. Différents modèles théoriques ont été utilisés dans le cadre du développement de ces systèmes, et nous allons consacrer le reste de ce chapitre à leur étude. Dans [2], Cédric Michel et Ludovic Mé proposent une taxonomie des langages utilisés en détection d intrusions divisant ceux-ci en six catégories : langages d événements, d exploits, de rapports, de détection, de corrélation et de rapports. Dans ce chapitre, nous nous attaquons au cas particulier des langages de détection, que nous subdivisons en cinq catégories. Nous commencerons notre étude dans la section 1.1 par les langages les plus simples : les langages spécifiques au domaine. Ces langages ont l avantage de présenter une grande simplicité, mais offrent souvent une faible expressivité et peu de souplesse. Par la suite, dans la section 1.2, nous jetterons un oeil aux langages impératifs ayant été développés spécialement pour la détection d intrusions. Ce sont ceux qui se rapprochent le plus des langages de programmation habituels. Ils présentent l avantage d offrir des primitives associées au traitement d événements et des systèmes de types appropriés à la détection d intrusions. Les signatures développées avec ces langages sont cependant souvent difficiles à maintenir. Les langages basés sur les systèmes de transition, que nous traiterons

Chapitre 1. Systèmes de détection d intrusions 7 dans la section 1.3, ont été mis au point afin de pouvoir spécifier d une façon déclarative les scénarios d attaques. Ces langages comportent cependant une partie impérative dont l objectif est souvent d emmagasiner une partie du contexte. Les systèmes experts, dont nous parlerons dans la section 1.4, sont spécialisés dans l accumulation et, surtout, l inférence d information concernant le contexte. Afin d éviter les problèmes de mémoire, cette information doit cependant être gérée explicitement, et le niveau d abstraction désiré n est pas toujours atteint. Les systèmes basés sur des logiques temporelles, dont nous parlerons finalement dans la section 1.5, sont ceux qui se rapprochent le plus de systèmes à base de signatures purement déclaratives. 1.1 Langages spécifiques au domaine Un langage spécifique au domaine, tel que défini dans [3], est un langage de programmation spécialement conçu pour capturer la sémantique propre à un domaine d application particulier. Des exemples de langages spécifiques au domaine sont HTML et SQL, respectivement conçus pour l édition d hypertextes et la consultation de bases de données. Dans le présent chapitre, chacun des systèmes de détection d intrusions que nous présentons vient avec son propre langage permettant de le configurer et/ou de spécifier des signatures particulières d attaque. Ces langages, spécialement conçus pour la détection d intrusions ou pour la surveillance de systèmes en général, tombent donc tous dans la catégorie des langages spécifiques au domaine. Cependant, dans la plupart des cas, ces langages sont conçus avec un certain souci d abstraction permettant des les utiliser pour différents types de fichiers d audit. Par exemple, le langage STATL peut être utilisé autant pour une détection d intrusions au niveau hôte (dans le cas de WinSTAT et USTAT), qu au niveau réseau (dans le cas de NetSTAT). Les trois systèmes que nous présentons dans cette section se distinguent de par le fait que les langages qu ils utilisent sont liés d encore plus près au type de détection particulier qu ils permettent d effectuer. Ils ne sont pas définis sur une sémantique abstraite de fichiers d audit, mais sur des sémantiques très concrètes reliées aux fichiers d audits de processus (dans le cas de Panoptis), au filtrage de paquets (dans le cas de Snort), et à l identification passive de failles de sécurité (dans le cas de NeVO). Nous présentons dès maintenant ces trois systèmes.

Chapitre 1. Systèmes de détection d intrusions 8 # # Configuration file for host pooh # # $ Id : poo.dsl 1.6 2000/05/30 12 :26 :58 dds Exp $ # HZ = 100 # "Floating point" value divisor bigend = FALSE # Set to TRUE for big endian (e.g. Sun), FALSE for # little endian (e.g. VAX, Intel x86) map = TRUE # Set to TRUE to map uid/tty numbers to names EPSILON = 150 # New maxima difference threshold (%) report = TRUE # Set to TRUE to report new/updated entries unlink = FALSE # Set to TRUE to start fresh # Reporting procedure output = /usr/bin/tee /dev/console /bin/mail root # Databases and parameters to check dbcheck(tty, minbmin, maxbmin, maxio, maxcount) # Terminals dbcheck(comm, ALL) # Commands dbcheck(uid, ALL) # Users dbcheck(uidtty, maxcount) # Users on a terminal dbcheck(uidcomm, minbmin, maxbmin, maxutime, # Users of a command maxstime, maxmem, maxrw, maxcount, maxasu) # Map users and terminals into groups usermap(caduser, john, marry, jill) usermap(admin, root, bin, uucp, mail, news) termmap(room202, tty31, tty32, tty33, tty34, tty35) termmap(ptys, ttyp01, ttyp02, ttyp03, ttyp04, ttyp05, ttyp06) 1.1.1 Panoptis Fig. 1.1 Exemple de fichier de configuration de Panoptis. Panoptis [3] se distingue des autres systèmes de détection d intrusions présentés dans ce chapitre par le fait qu il s agit du seul système basé sur une détection d anomalies que nous avons choisi de présenter. Comme nos travaux se situent plutôt dans le cadre de reconnaissance de scénarios, nous avons mis le focus sur ces types de systèmes, mais nous avons tout de même jugé utile, par souci de complétude, d inclure au moins un détecteur d anomalies. Comme nous l avons déjà dit, Panoptis est configurable à l aide d un langage spécifique au domaine. Ce domaine est celui des processus d un système Unix, et Panoptis prend donc en entrée des fichiers d audits de processus. Les auteurs affirment que le langage a quand même été conçu de façon assez générale pour pouvoir fonctionner sur n importe quel système fournissant des fichiers d audits de processus, dont Windows NT. Panoptis maintient des tables contenant les profils d activités pour différents utilisateurs, terminaux, processus, ou groupages et/ou couplage de ces entités. Par exemple, il peut maintenir une table concernant l utilisation d un processus donné, pour trois utilisateurs spécifiques utilisant un même terminal. Les informations maintenues pour

Chapitre 1. Systèmes de détection d intrusions 9 # # Panoptis crontab file for host pooh # # The format of this file is : # Hour Minute Day-of-month Month Day-of-week Command * 5,25,45 * * * panoptis pooh-quick.cfg pooh.20min 20m 8-18 05 * * * panoptis pooh-hour.cfg pooh.workhour 1h 19-7 05 * * * panoptis pooh-hour.cfg pooh.late 1h 4 50 * * 1-5 panoptis pooh-day.cfg pooh.workday 24h 4 50 * * 6,0 panoptis pooh-day.cfg pooh.weekend 24h 2 20 * * 0 panoptis pooh-full.cfg pooh.weekly 7d /usr/adm/pacct? /usr/adm/pacct Fig. 1.2 Exemple de fichier de planification de tâches de Panoptis. read and parse the the domain-specific language configuration while there are records in the specified accounting file read and decode an accounting record synthesise the derived quantities substitute the name of entities belonging to a group with the group name for every database table specified look for an database entry matching the key of the record retrieved if a matching entry is found compare it with the entry read if the accounting record value exceeds the amount stored in the database produce a new maximum value alert and update the database else (if no matching entry is found) produce a new value alert and update the database Tab. 1.1 Algorithme d apprentissage et de vérification de Panoptis. Database Users*Commands, key [dds/gcc] : New entry. Command : gcc Terminal : ttyp0 User : dds Executed from : 2001-01-13 01 :29 :32 to : 2001-01-13 01 :29 :33 (1.36 seconds) Database Users*Commands, key [root/ls] : New maximum average character input/output (204.8 / 64 ; 220%) Command : ls Terminal : ttyp1 User : root Executed from : 2001-01-13 01 :32 :13 to : 2001-01-13 01 :32 :13 (0.41 seconds) Fig. 1.3 Exemple de fichier de sortie de Panoptis.