SECURITE RESEAU HACKING DECRYPTAGE ENTREPRISE ATTAQUE

ArpFlood.exe
par Sébastien FONTAINE (_SebF)

1 - Définition de l'exécutable
2 - Screen shot
3 - Download
4 - Suivi du développement
        4.1 - Problème restant
        4.2 - RoadMap
        4.3 - Suivi du projet
5 - Code source
        5.1 - ArpFlood.cpp

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.

Posez vos questions, remarques, demande d'évolution et retour d'expérience sur le Forum dédié aux outils

2 - Screen shot

SECURITE RESEAU HACKING DECRYPTAGE ENTREPRISE ATTAQUE

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

2006.12.07

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

2006.11.02

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);
            }



mot clé : saturation flooding executable windows arp arpflood reseau authentification attaques vpn win32 freeware intrusion exe software poisoning flood rarp man in the middle console programme utilitaire securite download dos free shareware outil tool

Copyright © 2011-2015 authsecu.com. Tous droits réservés. Les marques et marques commerciales mentionnées appartiennent à leurs propriétaires respectifs. L'utilisation de ce site Web sécurité implique l'acceptation des conditions d'utilisation et du règlement sur le respect de la vie privée de Sécurité. IP VPN LAN Téléphonie entreprise Expert de votre Infrastructure Serinya Operateur Telecom