Herkeios

Système de détection des intrusions

Le Flooding


<< La couche de liaison de données Le SYN Flood >>


I°) Le flooding brute

Le ping-flood
   Cette attaque est la plus commune et la plus connue. Cette fois, on ne veut pas crasher l'ordinateur distant mais le saturer, de façon à ce qu'il ne puisse plus communiquer. Les attaques de flood TCP/IP essaient de simplement surcharger la bande passante sur le réseau de la machine concerner et ainsi l'isoler. En pratique, cette attaque consiste juste à envoyer beaucoup de requêtes PING à la victime, avec des paquets contenant beaucoup de données. Cette attaque n'a rien de spécialement intelligente car elle se résume à un combat entre bandes passantes, et que la meilleure gagne..

Les attaques amplifiées
   A ce stade, l'utilisation de TCP commence à devenir intéressante. Les attaques amplifiées sont juste une façon d'exploiter des floods, mais intelligemment. Nous avons parlé dans notre article sur l'adressage dans la couche liaison de données d'une adresse spéciale, la broadcast. Cette adresse donne la possibilité d'envoyer un paquet à toutes les machines connectées au réseau. Ainsi, si on envoie une requête PING à la broadcast, tous les systèmes connectés nous enverrons un paquet ICMP reply en retour. Comme se flooder soi-même n'est pas d'une immense utilité, il faut trouver un moyen de faire répondre tous ces systèmes à qui on l'entend, car cela représente un gros potentiel. La solution est simple : envoyer un paquet PING echo spoofé contenant l'adresse de la victime comme source et la broadcast comme destinataire. Ainsi, chaque système du réseau recevra un ping qu'ils croieront venir de la machine de la victime et y répondront. En envoyant beaucoup de paquets spoofés, la bande passante de la victime est prise d'assaut de manière exponentielle avec le nombre de systèmes connectés au réseau.
Une manière de se prémunir de ces attaques est d'interdir les pings sur la broadcast ou de ne les rerouter que vers le serveur principal, ce qui est couramment effectué dans les grands réseaux (universités, entreprises). Cette attaque s'appelle communément un smurf.

Implémentation du flood ICMP
   Il n'y a pas plus simple que la programmation de ce type de flood. Dans le programme suivant, on envoie des paquets ICMP de source vers dest (dans le cas d'une attaque amplifiée, source est la victime et dest la passerelle. On devine ici que argv[1] != 0 signifie une attaque amplifiée.
    #include "injection.h"
    #include "mac_manip.h"
    #include <signal.h>
    #include <printf.h>
    #include <time.h>

    #define device "eth0"

    static int attaque = 1;

    void fin_attaque(int signo) {
      attaque = 0;
    }


    static int ping_flood(char * argv[]) {
      [...]

      source[15] = dest[15] = '\0';

      signal(SIGINT, fin_attaque); //SIGINT Déclenche la fin de l'attaque

      printf((atoi(argv[1]) ? "Attaque Ping Flood Amplifiée\n" : "Attaque Ping Flood Simple\n"));
      printf("Début de l'attaque... (Ctrl + C pour arrêter)\n");

      //La fonction injection_icmp() est définie dans Networking/Injection/src/injection.c
      while (attaque) {

        //On injecte
        if (injection_icmp(device, source, dest, mac_source, (atoi(argv[1]) ? "\xff\xff\xff\xff\xff\xff" : NULL), 0, 0, ICMP_ECHO)) {
          printf("Injection ICMP echouée\n");
          break;
        }
      }

      [...]

      return 0;
    }



Le flood DDoS (Distributed Denial of Service)
   Comme nous l'avons fait remarquer pour l'attaque de type ping-flood, le flooding revient à un combat entre bandes passantes. L'idée du Déni de Service Distribué est simple et rejoint celle du smurf, à savoir, pourquoi faire le combat tout seul et pas à plusieurs ? Effectivement, plus il y a d'ordinateurs qui floodent une seule machine ou un seul réseau, plus ça devient facile de saturer sa bande passante, toute immense qu'elle puisse être. Les attaques de flood les plus remarquables de ces années suivent ce principe, on peut notamment nommer l'attaque des 13 root servers (les serveurs qui maintiennent l'Internet) en Février dernier (2007). Cette attaque avait été particulièrement simple : environ 5 000 machines ont submergé les root servers de requêtes DNS et UDP. Au moins 2 serveurs sont tombés dans cette nuit du 6 au 7 Février et au moins 3 autres ont étés saturés, ce qui s'est ressenti parfois par un très léger lag sur l'Internet. Vous nous direz que rassembler 5 000 machines n'est pas à la portée du premier venu. Et bien si. En fait, ces machines ne sont autres que des machines lambda, comme vous ou nous qui ont étés affectés par un virus, reproducteur, qui est resté silencieux sur tous ces postes jusqu'à ce que leur "maître" leur demande de passer à l'action. Tous les postes infectés étaient sous Windows et plus de 65% en Corée du Sud, ce qui laisse penser que là-bas se trouvait le chef-lieu de l'attaque. De plus, utiliser autant d'ordinateurs à la fois permet naturellement de rendre quasiment impossible le traçage de la source du flood.

Détection du flood de bande passante
   La détection de ce type de flood est aussi très simple, il suffit de savoir lorsque notre interface est saturée, ie : lorsque le nombre de paquets ICMP reçus chaque seconde dépasse une certaine limite. Vous l'aurez compris, la seule difficulté étant de déterminer correctement cette limite, celle-ci pouvant dépendre du réseau.
Voici comment nous l'implémentons :
    /* Au maximum, FLOOD_P packets transitant par l'interface toutes les secondes */
    #define FLOOD_P 300

    struct {
      time_t t[FLOOD_P];
      int i;
    } flood;

    inline void test_flood()
    {
      time_t t0 = time(0);
      if (flood.t[(++flood.i)%FLOOD_P] >= t0))
      {
    /*************************************/
        /* DETECTION FLOOD */
        printf("....\n*********FLOOD**********\n....\n");
        fflush(stdout);
    /*************************************/
      }
      flood.t[flood.i%FLOOD_P] = t0;
    }
Pour réaliser cette détection, nous créons un tableau statique contenant des variables de type time_t, c'est à dire permettant de stocker des temps (en secondes). La taille de ce tableau est notre limite décrite précedemment, ici nous la fixons à 300 paquets par seconde.

A chaque fois que nous recevons un paquet, nous enregistrons l'horaire à laquel il à été reçu dans notre tableau, en incrémentant d'un indice à chaque paquet. Comme nous bouclons sur les indices du tableau (grace au modulo), il suffit lorsque nous enregistrons l'horaire d'un paquet de vérifier que l'horaire du paquet recu précédemment à cette indice n'a pas été reçu à la même seconde. Sinon, cela signifie que nous avons recu autant de paquets que la taille de notre tableau en moins d'une seconde, puisque nous avons eu le temps de boucler et de le remplir complétement.

Ce typ de détection est à améliorer grâce à une liaison avec l'analyse statistique du réseau.



<< La couche de liaison de données Le SYN Flood >>
Site sur la sécurité informatique - Qu'est-ce qu'un IDS ? - L'équipe Herkeios