1 – Le concept de l’attaque

Le but est la saturation du processeur de la cible en lui demandant d’effectuer des calculs de checksum. L’attaque peut être émise à partir d’un poste ou plusieurs simultanément. Dans le premier cas, vous aurez très souvent vous-même besoin d’un bon processeur afin de surpasser celui de la cible, excepté, si vous utilisez des checksums pré calculés. Dans le second cas, vous émettez alors l’attaque à partir de N postes et disposant ainsi d’une puissance processeur supérieur à votre cible, d’une bande passante supérieur et des points d’accès non concentrés et donc plus difficile à stopper.

2 – Le fonctionnement de l’attaque

2.1 – Schéma

Le fonctionnement est de générer une trame IP sans application spécifique afin d’obliger la cible à calculer le checksum de l’entête IP afin de valider la conformité.

2.2 – Calcul du Checksum IP

Voici le schéma de l’entête IP avec ce fameux Checksum basé sur 2 octets :

La cible devra calculer le checksum pour chaque trame reçue sollicitant implicitement son processeur. Le calcul effectué par la cible est le suivant :

unsigned short calcul_du_checksum(bool liberation, unsigned short *data, int taille)
     {
     unsigned long checksum=0;
     // ********************************************************
     // Complément à 1 de la somme des complément à 1 sur 16 bits
     // ********************************************************
     while(taille>1)
         {
         if (liberation==TRUE)
             liberation_du_jeton(); // Rend la main à la fenêtre principale
         checksum=checksum+*data++;
         taille=taille-sizeof(unsigned short);
         }
 
     if(taille)
         checksum=checksum+*(unsigned char*)data;
 
     checksum=(checksum>>16)+(checksum&0xffff);
     checksum=checksum+(checksum>>16);
 
     return (unsigned short)(~checksum);
     }

L’avantage de cette méthode est d’être portable sur toutes piles IP, même si aucun port n’est en écoute.

2.3 – Calcul du Checksum TCP

Le fonctionnement est de générer une trame TCP afin d’obliger la cible à calculer le checksum de l’entête IP et TCP afin de valider la conformité. Voici le schéma de l’entête TCP avec le Checksum basé sur 2 octets :

La cible devra calculer le checksum de l’entête IP puis celui de l’entête TCP pour chaque trame reçue sollicitant implicitement son processeur. Le calcul effectué par la cible pour le Checksum TCP est le suivant :

struct pseudo_entete
     {
     unsigned long ip_source; // Adresse ip source
     unsigned long ip_destination; // Adresse ip destination
     char mbz; // Champs à 0
     char type; // Type de protocole (6->TCP et 17->UDP)
     unsigned short length; // htons( Taille de l'entete Pseudo + Entete TCP ou UDP + Data )
     };
 
 unsigned short calcul_du_checksum_tcp(bool liberation, unsigned long ip_source_tampon, unsigned long ip_destination_tampon, struct tcp tcp_tampon, char data_tampon[65535])
     {
     struct pseudo_entete pseudo_tcp;
     char tampon[65535];
     unsigned short checksum;
 
     // ********************************************************
     // Initialisation du checksum
     // ********************************************************
     tcp_tampon.checksum=0; // Doit être à 0 pour le calcul
 
     // ********************************************************
     // Le calcul du Checksum TCP (Idem à UDP)
     // ********************************************************
     // Le calcul passe par une pseudo entete TCP + l'entete TCP + les Data
     pseudo_tcp.ip_source=ip_source_tampon;
     pseudo_tcp.ip_destination=ip_destination_tampon;
     pseudo_tcp.mbz=0;
     pseudo_tcp.type=IPPROTO_TCP;
     pseudo_tcp.length=htons((unsigned short)(sizeof(struct tcp)+strlen(data_tampon)));
     memcpy(tampon,&pseudo_tcp,sizeof(pseudo_tcp));
     memcpy(tampon+sizeof(pseudo_tcp),&tcp_tampon,sizeof(struct tcp));
     memcpy(tampon+sizeof(pseudo_tcp)+sizeof(struct tcp),data_tampon,strlen(data_tampon));
     checksum=calcul_du_checksum(liberation,(unsigned short*)tampon,sizeof(pseudo_tcp)+sizeof(struct tcp)+strlen(data_tampon));
 
     return(checksum);
     }

L’utilisation du checksum TCP permet d’obtenir de meilleur résultat, car implicitement, il est combiné au checksum IP.

2.4 – Calcul du Checksum UDP

Le fonctionnement est identique à la méthode TCP, pour cela, il faut générer une trame UDP afin d’obliger la cible à calculer le checksum de l’entête IP et UDP afin de valider la conformité. Voici le schéma de l’entête UDP avec le Checksum basé sur 2 octets :

La cible devra calculer le checksum de l’entête IP puis celui de l’entête UDP pour chaque trame reçue sollicitant implicitement son processeur. Le calcul effectué par la cible pour le Checksum UDP est le suivant :

struct pseudo_entete
     {
     unsigned long ip_source; // Adresse ip source
     unsigned long ip_destination; // Adresse ip destination
     char mbz; // Champs à 0
     char type; // Type de protocole (6->TCP et 17->UDP)
     unsigned short length; // htons( Taille de l'entete Pseudo + Entete TCP ou UDP + Data )
     };
 
 unsigned short calcul_du_checksum_udp(bool liberation, unsigned long ip_source_tampon, unsigned long ip_destination_tampon, struct udp udp_tampon, char data_tampon[65535])
     {
     struct pseudo_entete pseudo_udp;
     char tampon[65535];
     unsigned short checksum;
 
     // ********************************************************
     // Initialisation du checksum
     // ********************************************************
     udp_tampon.checksum=0; // Doit être à 0 pour le calcul
 
     // ********************************************************
     // Le calcul du Checksum UDP (Idem à TCP)
     // ********************************************************
     // Le calcul passe par une pseudo entete UDP + l'entete UDP + les Data
     pseudo_udp.ip_source=ip_source_tampon;
     pseudo_udp.ip_destination=ip_destination_tampon;
     pseudo_udp.mbz=0;
     pseudo_udp.type=IPPROTO_UDP;
     pseudo_udp.length=htons((unsigned short)(sizeof(struct udp)+(unsigned short)strlen(data_tampon)));
     memcpy(tampon,&pseudo_udp,sizeof(pseudo_udp));
     memcpy(tampon+sizeof(pseudo_udp),&udp_tampon,sizeof(struct udp));
     memcpy(tampon+sizeof(pseudo_udp)+sizeof(struct udp),data_tampon,strlen(data_tampon));
     checksum=calcul_du_checksum(liberation,(unsigned short*)tampon,sizeof(pseudo_udp)+sizeof(struct udp)+strlen(data_tampon));
  
     return(checksum);
     }

3 – Les conseils et astuces

• L’astuce de l’émetteur est d’envoyer des trames préconstruites afin de ne pas calculer soit même le checksum gagnant ainsi un temps considérable.
• L’utilisation de smurf augmentera fortement le nombre de checksum à calculer.
• Le choix de la taille des données est important. Si les trames sont grandes, du style 65535 octets, alors le calcul du checksum sera plus long et sollicitera plus de processeur.

4 – Les outils

• FrameIP est un générateur de trames IP. Il vous permettra de personnaliser les champs des différentes entêtes réseaux. Vous aurez la possibilité grâce à cet outils de pré calculer les checksum.
• PingIcmp permet d’effectuer des Ping Icmp sans interruption.

5 – La conclusion

La puissance de calcul est tel maintenant, que même la combinaison Checksum IP et TCP n’écroulera pas les récents processeurs. Cependant, destiné à des petits chipset tel que des boîtiers d’impression, des routeurs de particulier et autres, la gêne occasionnée peut être conséquente.

6 – Les vidéos

7 – Suivi du document

Création et suivi de la documentation par _SebF

8 – Discussion autour de l’attaque par saturation du processeur

Vous pouvez poser toutes vos questions, faire part de vos remarques et partager vos expériences à propos de l’attaque par saturation du processeur. Pour cela, n’hésitez pas à laisser un commentaire ci-dessous :