Le langage dot

Il s'agit du langage permettant de simplement décrire les graphes que vous souhaitez réaliser.

Par exemple, le code dot suivant :

digraph G {
        node1 [label="Foo",color="red"];
        node2 [label="Bar",color="green"];

        node1 -> node2;
}

Produit, grâce a la commande dot -Tpng graph.dot > graph.png le graphe suivant :

Le langage dot est relativement structuré : les attributs des noeuds comme ceux des liens sont placés devant leur déclaration.

Afin de simplifier la création du code dot, nous utiliserons la classe Python GvGen [10]. De cette façon, il est aisé de réaliser des graphes complexes : il ne suffit que de déclarer les différents objets et de poser leur relations.

Par exemple, si nous souhaitons créer un graphe avec une légende, le code dot devient compliqué parce que par défaut, graphviz ne sait pas gérer ce cas. Il faut en effet supprimer la flèche, tout en imposant une direction au graphe afin que le texte s'affiche à droite de l'élément que nous voulons mettre en légende, puis supprimer le lien et éviter de d'entourer le texte de description.

Voici le code GvGen permettant de générer un graph simple avec une légende :

#!/usr/bin/python
import gvgen

# Création d'un nouveau graphe avec une légende
graph = gvgen.GvGen("Legend")

# Création des items "foo" et "bar"
a = graph.newItem("foo")
b = graph.newItem("bar")

# Lier "foo" avec "bar"
graph.newLink(a,b)

# Création et application des styles
graph.styleAppend("foostyle","color","red")
graph.styleAppend("foostyle","shape","rectangle")
graph.styleApply("foostyle", a)

graph.styleAppend("barstyle","color","blue")
graph.styleAppend("barstyle","style","filled")
graph.styleApply("barstyle", b)

# Création d'une zone de légende
graph.legendAppend("foostyle", "Foo item")
graph.legendAppend("barstyle", "This is the bar item")

# Création du code dot
graph.dot()

Le code précédent va générer le code dot suivant :

digraph G {
compound=true;rankdir=LR;

    subgraph cluster1 {

      label="Legend";
      node7 [shape="plaintext",label="This is the bar item"];
      node6 [color="blue",style="filled",label=""];
      node5 [shape="plaintext",label="Foo item"];
      node4 [color="red",shape="rectangle",label=""];

    }

node2 [color="red",shape="rectangle",label="foo"];
node3 [color="blue",style="filled",label="bar"];

node6->node7 [style="invis",dir="none"];
node4->node5 [style="invis",dir="none"];
node2->node3;
}

On remarque de le code python avec GvGen nous permet d'automatiser la création du langage dot, mais aussi de rendre sa création plus simple à l'aide de fonctions n'existant pas dans graphviz, comme les définitions de styles.

Ce code dot permet de créer l'image suivante :

Si vous souhaitez voir un excellent exemple d'application utilisant GvGen, vous pouvez vous tourner vers Graphdep [11], un outil d'affichage de dépendances entre fonctions dans du code C, C++ ou python.

Intégration à Prelude

Prelude, comme vu au début de l'article, permet de récupérer grâce au système de polling toutes les alertes que les différentes analyseur ont pu lui envoyer.

Grâce aux bindings faciles, nous pouvons récupérer tous les objets IDMEF souhaités pour les passer à GvGen. Le but étant d'arriver au graphe 2D permettant de visualiser des attaques.

Nous allons récupérer les cibles afin de regrouper les attaques avec des jeux de couleurs représentant la gravité de chacune des attaques.

C'est en récupérant une branche spécifique de Prelude que nous allons pouvoir développer facilement l'affichage des attaques en langage dot.

Intégration à Rtgraph3d

Rtgraph3d [6] à été développé par Philippe Biondi dans le bus d'offrir une application équivalente à graphviz, mais en 3D et en temps réel.

DBus est utilisé pour pouvoir se connecter et interagir avec l'application en envoyant une simple chaine de texte.

Sachant que nous avons déjà réussi à générer le code dot, il serait fâcheux de reprendre tout le travail. Il est donc plus simple de modifier le code de rtgraph3d afin d'y ajouter l'import graphviz.

Pour se faire, nous allons utiliser pydot, qui permet de lire le code dot et de le transformer en objets Python. L'algorithme utilisé sera le suivant :

Pour chaque lien :
    Pour chaque noeud du lien :
        Si c'est la source :
            label_source = attribut label du noeud
            couleur_source = attribut color du noeud
        Si c'est la destination :
            label_dest = attribut label du noeud
            couleur_dest = attribut color du noeud

    Si nous n'avons aucun label pour les sources :
        Attribuer le nom du lien pour le noeud

    Création du noeud source nommé et avec la couleur normalisée
    Création du noeud destination nommé et avec la couleur normalisée

    Si la couleur est mise en paramètre, mettre à jour les noeuds

Et en appliquant le patch suivant, on peut maintenant utiliser la fonction d'import dot dans rtgraph3d :

--- rtg_cli.py.orig     2008-01-10 19:20:30.000000000 +0100
+++ rtg_cli.py  2008-01-10 19:19:47.000000000 +0100
@@ -94,6 +154,35 @@
         for n1,n2 in zip(e[:-1],e[1:]):
             self.rtg.new_edge(n1,{},n2,{})

+    def do_dot(self, args):
+        graph = pydot.graph_from_dot_file(args)
+        for edge in graph.get_edge_list():
+               edge_src = "\"" + edge.get_source() + "\""
+               edge_dst = "\"" + edge.get_destination() + "\""
+               for node in graph.get_node_list():
+                       if node.name == edge_src:
+                               src_label = node.get_label()
+                               src_color = node.get_color()
+                       if node.name == edge_dst:
+                               dst_label = node.get_label()
+                               dst_color = node.get_color()
+
+               if not src_label:
+                       src_label = edge.get_source()
+
+               if not dst_label:
+                       dst_label = edge.get_destination()
+
+
+               edge_args = src_label + " " + dst_label
+               self.do_edge(edge_args)
+               if src_color:
+                       src_color_s = src_label + " color=" + color_normalize(src_color)
+                       self.do_update(src_color_s)
+               if dst_color:
+                       dst_color_s = dst_label + " color=" + color_normalize(dst_color)
+                       self.do_update(dst_color_s)
+
     def do_glow(self, args):
         for n in args.split():
             self.rtg.glow(n)

Pour la normalisation des couleurs, nous utilisons la fonction color_normalize qui est disponible à l'adresse suivante: http://www.wallinfire.net/files/color_calc.py

Maintenant que nous avons tout ce code, il ne nous reste plus qu'à faire le code Prelude qui fait le lien entre :

• Une attaque que nous produisons volontairement : un scan de ports, un utilisateur qui se trompe de mot de passe, etc..
• Une sonde Prelude qui détecte cette attaque
• Notre code qui récupère les objets que le collecteur reçoit des sondes
• Graphviz, que nous utilisons avec GvGen pour générer du code dot
• RtGraph3d que nous utilisons avec le patch mis plus haut pour avoir une vue en 3D des attaques

Voici le code que nous allons utiliser pour produire le graphe. Il est montré ici par morceaux, mais il est disponible en libre téléchargement à l'adresse : http://svn.prelude-ids.org/libprelude/branches/libprelude-easy-bindings/bindings/tools/idmef-path-gvgen.py

Tout d'abord, on crée le client avec ce code :

import PreludeEasy

client = PreludeEasy.Client("PreludeGvGen")
client.Init()

client.PoolInit("192.168.33.215", 1)

Le nom de notre client est "PreludeGvGen", cela veut dire qu'il faut l'enregistrer avec les capacités IDMEF de lecture sur le collecteur. On le fait en tapant sur la machine qui sera utilisée pour lancer l'application de cette façon :

~# prelude-admin register "PreludeGvGen" "idmef:r" 192.168.33.215 --uid 1000 --gid 1000

Puis, sur le collecteur :

~# prelude-admin registration-server prelude-manager

Une fois la sonde enregistrée pour l'utilisateur ayant le numéro 1000, on peut l'utiliser en tant que simple utilisateur.

La fonction de lecture d'objets IDMEF est initialisée à l'aide de la fonction PoolInit.

Maintenant, nous pouvons faire une boucle infinie pour la lecture de chaque objet IDMEF que le collecteur verra :

while 1:
       idmef = client.ReadIDMEF(1)
       if idmef:
              handle_alert(idmef)

C'est la fonction ReadIDMEF permet de lire un message IDMEF que le collecteur de Prelude lui aura envoyé.

Nous définissons comme fonction de callback handle_alert, qui est définie comme ce qui suit :

def handle_alert(idmef):

        source = idmef.Get("alert.source(0).node.address(0).address")
        if not sourceslist.has_key(source):
                sourceitem = graph.newItem(source)
                sourceslist[source] = sourceitem
        target = idmef.Get("alert.target(0).node.address(0).address")
        if not targetslist.has_key(target):
                targetitem = graph.newItem(target)
                targetslist[target] = targetitem
        alert  = idmef.Get("alert.classification.text")
        alert = alert.replace(' ','_')
        if not alertslist.has_key(alert):
                alertitem = graph.newItem(alert)
                alertslist[alert] = alertitem

                severity = idmef.Get("alert.assessment.impact.severity")
                if severity:
                        if severity == "high":
                                graph.propertyAppend(alertslist[alert],"color","red")
                                graph.propertyAppend(alertslist[alert],"style","filled")
                        if severity == "medium":
                                graph.propertyAppend(alertslist[alert],"color","orange")
                                graph.propertyAppend(alertslist[alert],"style","filled")
                        if severity == "low":
                                graph.propertyAppend(alertslist[alert],"color","green")
                                graph.propertyAppend(alertslist[alert],"style","filled")
                        if severity == "info":
                                graph.propertyAppend(alertslist[alert],"color","blue")
                                graph.propertyAppend(alertslist[alert],"style","filled")


        graph.newLink(sourceslist[source],alertslist[alert])
        graph.newLink(alertslist[alert],targetslist[target])

Il s'agit tout simplement de la fonction principale, qui gère la récupération de la source, destination ainsi que le nom de l'alerte pour utiliser les fonctions de GvGen pour produire le graphe en langage dot.

Nous allons utiliser un signal de terminaison pour produire le graphe. Par exemple un simple kill ou Ctrl-C permettra de l'afficher :

def sighandler(sig, frame):
        graph.dot()
        sys.exit(0)

signal.signal(signal.SIGTERM, sighandler)
signal.signal(signal.SIGINT, sighandler)

Maintenant nous pouvons lancer notre programme :

$ ./idmef-path-gvgen.py

Puis nous appuyons sur Ctrl+C, et nous voyons :

digraph G {
compound=true;
   node1 [label="192.168.33.180"];
   node2 [label="127.0.0.1"];
   node3 [color="orange",style="filled",label="User_login_failed"];
   node4 [label="192.168.33.215"];
   node5 [color="green",style="filled",label="(portscan)_TCP_Portscan"];
   node6 [label="10.8.0.46"];
   node7 [color="orange",style="filled",label="Server_recognition"];
   node8 [label="192.168.33.139"];
   node9 [color="orange",style="filled",label="User_login_failed_with_an_invalid_user"];
node1->node3;
node1->node5;
node3->node2;
node5->node4;
node6->node7;
node7->node2;
node8->node9;
node8->node3;
node9->node2;
}

Ce qui nous donne, à l'aide d'un dot -Tpng gvgen-2d.dot > gvgen-2d.png :

Le graphe se lit en regardant les noeuds en haut, qui sont les sources. Nous avons donc été attaqués par trois sources différentes. Au milieu, ce sont les attaques, avec un jeu de couleur en fonction de la gravité. Puis, en bas nous avons les cibles. Il y en a deux : 127.0.0.1 et 192.168.33.215.

192.168.33.215 est l'adresse IP réseau de la machine et 127.0.0.1 aussi, mais il s'agit de l'adresse IP locale. Si l'on voit cette adresse IP, c'est simplement parce que cela correspond à la cible vue par Prelude LML lors de l'analyse de log. Cette adresse peut bien sur se configurer.

Maintenant, grâce au patch sur RTgraph3d, nous allons pouvoir visualiser en 3D ces mêmes évènements grâce à l'import dot.

Nous lançons donc la fenêtre OpenGL de rtgraph3d :

$ ./rtgraph3d.py &

Puis son programme client :

$ ./rtg_cli.py

Nous pouvons taper notre commande "dot", qui correspond à l'import dot de notre graphe :

RTG> dot gvgen-2d.png

Ce qui nous donne l'image suivante :

[10]	http://software.inl.fr/wiki/GvGen

[11]	http://haypo.hachoir.org/trac/wiki/graphdep