开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 查看源码
dds.c
资源名称：ddos_scan.tar　[点击查看]
上传用户：zht1018
上传日期：2007-01-07
资源大小：29k
文件大小：13k
源码类别：

系统/网络安全

开发平台：

Unix_Linux

dds.c：源码内容
  1. /*
  2.  * dds $Revision: 1.6 $ - a distributed DoS tool scanner
  3.  * 
  4.  * Based on the gag scanner, written by David Dittrich, University
  5.  * of Washington, Marcus Ranum, Network Flight Recorder, with
  6.  * code contributed by others, and based on an idea stolen from
  7.  * George Weaver, Pennsylvania State University.
  8.  * 
  9.  * Dave Dittrich <dittrich@cac.washington.edu>
  10.  * Marcus Ranum <mjr@nfr.net>
  11.  * George Weaver <gmw@psu.edu>
  12.  * David Brumley <dbrumley@rtfm.stanford.edu>
  13.  */
  15. #if YOU_HAVE_NOT_READ_THIS_YET
  17. This software should only be used in compliance with all applicable laws and
  18. the policies and preferences of the owners of any networks, systems, or hosts
  19. scanned with the software
  21. The developers and licensors of the software provide the software on an "as
  22. is" basis, excluding all express or implied warranties, and will not be liable
  23. for any damages arising out of or relating to use of the software.
  25. THIS SOFTWARE IS MADE AVAILABLE "AS IS", AND THE UNIVERSITY OF WASHINGTON
  26. DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE,
  27. INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  28. FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL THE UNIVERSITY OF
  29. WASHINGTON BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  30. DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  31. ACTION OF CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING
  32. OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  
  34. #endif
  36. #define VERSION "$Revision: 1.6 $"
  38. #include <stdlib.h>
  39. #include <ctype.h>
  40. #include <signal.h>
  41. #include <stdio.h>
  42. #include <string.h>
  43. #include <unistd.h>
  44. #include <fcntl.h>
  45. #include <sys/types.h>
  46. #include <sys/time.h>
  47. #include <sys/wait.h>
  48. #include <sys/socket.h>
  49. #include <netinet/in.h>
  50. #include <netinet/in_systm.h>
  51. #include <netinet/ip.h>
  52. #include <netinet/udp.h>
  53. #include <netdb.h>
  54. #include <arpa/inet.h>
  55. #include <netinet/ip_icmp.h>
  57. #define BS 1024
  58. #define __FAVOR_BSD
  60. /* The two arrays below are for address range calculations.  They
  61.    should have been automatically generated, but
  62.    1) I am lazy.
  63.    2) There are a few special cases in them.
  65.    I will not scan more than a /16.  When we do scan a CIDR block, we
  66.    assume that it actually is a CIDR block, and do not scan the
  67.    network or broadcast address.
  69.    */
  71. static unsigned long MaskBits[] = {
  72.   0x00000000, /* /0 */
  73.   0x00000000, /* /1 */
  74.   0x00000000, /* /2 */
  75.   0x00000000, /* /3 */
  76.   0x00000000, /* /4 */
  77.   0x00000000, /* /5 */
  78.   0x00000000, /* /6 */
  79.   0x00000000, /* /7 */
  80.   0x00000000, /* /8 */
  81.   0x00000000, /* /9 */
  82.   0x00000000, /* /10 */
  83.   0x00000000, /* /11 */
  84.   0x00000000, /* /12 */
  85.   0x00000000, /* /13 */
  86.   0x00000000, /* /14 */
  87.   0x00000000, /* /15 */
  88.   0xffff0000, /* /16, Class B */
  89.   0xffff8000, /* /17, 128 * Class C */
  90.   0xffffc000, /* /18, 64 * Class C */
  91.   0xffffe000, /* /19, 32 * Class C */
  92.   0xfffff000, /* /20, 16 * Class C */
  93.   0xfffff800, /* /21, 8 * Class C */
  94.   0xfffffc00, /* /22, 4 * Class C */
  95.   0xfffffe00, /* /23, 2* Class C */
  96.   0xffffff00, /* /24, Class C */
  97.   0xffffff80, /* /25, 128 hosts */
  98.   0xffffffc0, /* /26, 64 hosts */
  99.   0xffffffe0, /* /27, 32 hosts */
  100.   0xfffffff0, /* /28, 16 hosts */
  101.   0xfffffff8, /* /29, 8 hosts */
  102.   0xfffffffc, /* /30, 4 hosts (PPP link) */
  103.   0xfffffffe, /* /31, invalid */
  104.   0xffffffff, /* /32, host */
  105. };
  107. static int NumHosts[] = {
  108.   0, 0, 0, 0,
  109.   0, 0, 0, 0,
  110.   0, 0, 0, 0,
  111.   0, 0, 0, 0, /* don't scan more than a /16 */
  112.   65534, /* These are all -2 so that we don't
  113.    scan the broadcast addr or the
  114.    network addr */
  115.   32766,
  116.   16382,
  117.   8190,
  118.   4094,
  119.   2046,
  120.   1022,
  121.   510,
  122.   254,
  123.   126,
  124.   62,
  125.   30,
  126.   14,
  127.   6,
  128.   2,
  129.   0,
  130.   1,
  131. };
  133. extern char *optarg;
  135. struct icmppkt_t {
  136. struct ip ipi;
  137. struct icmp icmpi;
  138. char buffer[BS];
  139. } icmppkt;
  141. struct udppkt_t {
  142. struct ip ipi;
  143. struct udphdr udpi;
  144. char buffer[BS];
  145. } udppkt;
  147. static unsigned short ip_sum(u_short *,int);
  148. static void listener();
  149. static int usage();
  151. static int vflg = 0; /* verbosity */
  152. static int dflg = 0; /* debugging */
  154. /* stacheldraht variables */
  155. static int stach_test = 668; /* sends test */
  156. static int stach_echo = 669; /* gets reply "sicken" */
  157. char stach_gagstr[] = "gesundheit!";
  158. char  stach_echostr[] = "sicken";
  160. /* trinoo variables */
  161. static short trinoo_dstport = 27444; /* handler listen port */
  162. static short trinoo_rctport = 31335; /* agent listen port */
  163. char  trinoo_scmd[] = "png";
  164. char  trinoo_spass[] = "l44adsl";
  165. char  trinoo_echostr[] = "PONG";
  167. /* TFN variables */
  168. u_short tfn_test = 789;
  169. u_short tfn_reply = 123;
  171. int 
  172. main(int argc, char **argv)
  173. {
  174. int             pid, host;
  175. char            target[128];
  176. unsigned long target_host;
  177. struct in_addr  target_ip;
  178. int mask;
  179. char * mask_ptr;
  180. int result;
  181. int isock, usock;
  182. char            buf[BS];
  183. struct icmp    *icmpi = (struct icmp *)buf;
  184. struct sockaddr_in
  185. isa,usa;
  186. int             i;
  187. char *jnk1;
  188. char *jnk2;
  189. int sleepytime = 500;
  190. int bigsleep = 30;
  191. int num_hosts;
  192. char scmd[BS], spass[BS], sbuf[BS];
  195. while((i = getopt(argc,argv,"ds:S:v")) != -1) {
  196. switch(i) {
  197. case 'd':
  198. dflg++;
  199. break;
  200. case 's':
  201. sleepytime = atoi(optarg);
  202. if(sleepytime <= 0) {
  203. fprintf(stderr,"WARNING: zero interping sleep time will probably overflow your system's transmit buffers and yield poor resultsn");
  204. sleepytime = 1;
  205. }
  206. break;
  207. case 'S':
  208. bigsleep = atoi(optarg);
  209. if(bigsleep <= 0) {
  210. fprintf(stderr,"WARNING: negative sleep value - staying with default of %dn", bigsleep);
  211. }
  212. break;
  213. case 'v':
  214. vflg++;
  215. break;
  216. default:
  217. exit(usage());
  218. }
  219. }
  221. if(optind >= argc || argc - optind > 1)
  222. exit(usage());
  224. mask_ptr = strchr(argv[optind], '/');
  226. /* if a CIDR block is passed in */
  227. if (mask_ptr) {
  228.   *mask_ptr = '';
  229.   mask_ptr ++;
  230.   
  231.   sscanf(mask_ptr, "%d", &mask);
  232.   
  233. } else {
  234.   printf("No mask passed, assuming host scan (/32)n");
  235.   mask = 32;
  236. }
  238.  
  239. result = inet_aton(argv[optind], &target_ip);
  241. if (result == 0) {
  242.   fprintf(stderr, "%s: Bad IP address: %sn", argv[0],
  243.   argv[optind]);
  244.   exit(-1);
  245. }
  247. if (mask < 16) {
  248.   fprintf(stderr, "Bad Network Admin!  Bad!  Do not scan more than a /16 at once!n");
  249.   exit(-1);
  250. }
  252. num_hosts = NumHosts[mask];
  254. if (num_hosts == 0) {
  255.   fprintf(stderr, "Cannot scan a /%d.  Exiting...n", mask);
  256.   exit(-1);
  257. }
  259. if(vflg) {
  260.   printf("Mask: %dn", mask);
  261.   printf("Target: %sn", inet_ntoa(target_ip));
  262.   printf("dds %s - scanning...nn", VERSION);
  263. }
  265. sprintf(sbuf,"%s %s",trinoo_scmd,trinoo_spass);
  267. target_host = ntohl(target_ip.s_addr);
  268. target_host &= MaskBits[mask];
  270. target_ip.s_addr = htonl(target_host);
  272. if((pid = fork()) < 0) {
  273. perror("cannot fork");
  274. exit(1);
  275. }
  277. /* child side listens for return packets */
  278. if (pid == 0)
  279. listener();
  281. sleep(1);
  282. /* let's see if we can open a raw ICMP socket */
  283. if((isock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) {
  284. perror("cannot open raw ICMP socket");
  285. exit(1);
  286. }
  288. /* main ping loop - COULD be expanded to whole Internet but... */
  289. /* but that would be _very_ bad.... */
  290. while (num_hosts) {
  291.   if (mask != 32) {
  292.     target_host ++;
  293.   }
  294.   target_ip.s_addr = htonl(target_host);
  296.   num_hosts--;
  298.   if(vflg)
  299.     printf("Probing address %sn", inet_ntoa(target_ip));
  300.   
  301. bzero(buf, sizeof(struct icmp) +
  302. sizeof(stach_gagstr));
  303. memcpy(buf + sizeof(struct icmp), stach_gagstr,
  304. sizeof(stach_gagstr));
  305. /* stacheldraht check */
  306. icmpi->icmp_type = 0;
  307. icmpi->icmp_hun.ih_idseq.icd_id =
  308. htons(stach_test);
  309. icmpi->icmp_cksum = ip_sum((u_short *)icmpi,
  310. sizeof(struct icmp) + sizeof(stach_gagstr));
  312. bzero((char *) &isa, sizeof(isa));
  313. isa.sin_family = AF_INET;
  314. isa.sin_addr.s_addr = target_ip.s_addr;
  316. if(dflg)
  317. fprintf(stderr,"Sending ICMP to: %sn",
  318. inet_ntoa(isa.sin_addr));
  320. i = sendto(isock,buf,
  321. sizeof(struct icmp)+sizeof(stach_gagstr),0,
  322. (struct sockaddr *)&isa, sizeof(isa));
  324. if (i < 0) {
  325. char ebuf[BS];
  326. sprintf(ebuf,"sendto: icmp %s",
  327. inet_ntoa(isa.sin_addr));
  328. perror(ebuf);
  329. break;
  330. }
  332. /* tfn check */
  333. bzero(buf, sizeof(struct icmp) + sizeof(stach_gagstr));
  335. if(dflg)
  336. fprintf(stderr,"Sending tfn ICMP to: %sn",
  337. inet_ntoa(isa.sin_addr));
  338. icmpi->icmp_type = ICMP_ECHOREPLY;
  339. icmpi->icmp_code= icmpi->icmp_seq = 0;
  340. icmpi->icmp_id = htons(tfn_test);
  341. icmpi->icmp_cksum = ip_sum((u_short *)icmpi, 
  342. sizeof(struct icmp));
  343. i = sendto(isock, buf, sizeof(struct icmp), 0, 
  344.    (struct sockaddr *)&isa, sizeof(isa));
  345. if(i != sizeof(struct icmp)){
  346. perror("Error sending full tfn packetn");
  347. break;
  348. }
  350. /* trinoo check */
  351. bzero((char *) &usa, sizeof(usa));
  352. usa.sin_family = AF_INET;
  353. usa.sin_addr.s_addr = target_ip.s_addr;
  354. usa.sin_port = htons(trinoo_dstport);
  356. if (dflg)
  357. fprintf(stderr,"Sending UDP to: %sn",
  358. inet_ntoa(usa.sin_addr));
  359. if ((usock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  360. perror("cannot open UDP socket");
  361. exit(1);
  362. }
  364. i = sendto(usock,sbuf,strlen(sbuf), 0,
  365. (struct sockaddr *)&usa,
  366. sizeof(usa));
  368. if (i < 0) {
  369. char ebuf[BS];
  370. sprintf(ebuf,"sendto: udp %s",
  371. inet_ntoa(usa.sin_addr));
  372. perror(ebuf);
  373. break;
  374. }
  375. close(usock);
  377. usleep(sleepytime);
  378. }
  379. (void)close(isock);
  382. /* wait for any late responses */
  383. if (dflg)
  384. fprintf(stderr,"Waiting %d seconds for late responses.n",
  385. bigsleep);
  386. sleep(bigsleep);
  388. /* shut listener. if this fails the listener exits on its own */
  389. (void)kill(pid, SIGHUP);
  390. exit(0);
  391. }
  394. static void listener()
  395. {
  396. int             isock, usock;
  397. int             i, len;
  398. fd_set          fdset;
  399. char buf[BS];
  400. char rcmd[BS], filler[BS], rpass[BS];
  401. struct timeval  timi;
  402. struct icmppkt_t
  403. ipacket;
  404. struct udppkt_t
  405. upacket;
  406. struct sockaddr_in
  407. sa, from;
  409. /* child becomes a listener process */
  411. if ((isock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) < 0) {
  412. perror("cannot open raw ICMP socket");
  413. exit(1);
  414. }
  415. if ((usock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  416. perror("cannot open raw UDP listen socket");
  417. exit(1);
  418. }
  420. bzero((char *) &sa, sizeof(sa));
  421. sa.sin_family = AF_INET;
  422. sa.sin_addr.s_addr = INADDR_ANY;
  423. sa.sin_port = htons(trinoo_rctport);
  425. if (bind(usock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
  426. perror("cannot bind to socket");
  427. exit(-1);
  428. }
  429.   
  430. while (1) {
  431. /* if parent has exitted, die */
  432. if(getppid() == 1)
  433. exit(0);
  435. FD_ZERO(&fdset);
  436. FD_SET(isock, &fdset);
  437. FD_SET(usock, &fdset);
  438. timi.tv_sec = 1;
  439. timi.tv_usec = 0;
  440. select(FD_SETSIZE, &fdset, NULL, NULL, &timi);
  441. usleep(100);
  442. if (FD_ISSET(isock, &fdset)) {
  443. /* read data from ICMP listen socket */
  444. memset((void *) &ipacket, 0, sizeof(struct icmppkt_t));
  445. i = read (isock, (char *) &ipacket, BS) -
  446. (sizeof (struct ip) + sizeof (struct icmp));
  447. sa.sin_addr.s_addr = ipacket.ipi.ip_src.s_addr;
  448. if(dflg)
  449. fprintf(stderr,"Listener got an ICMP packetn");
  451. /* stacheldraht check */
  452. if ((ipacket.icmpi.icmp_type == ICMP_ECHOREPLY) &&
  453.      (ntohs(ipacket.icmpi.icmp_hun.ih_idseq.icd_id)
  454. == stach_echo)) {
  455. if (strstr(ipacket.buffer, stach_echostr)) {
  456. printf("Received '%s' from %s",
  457. stach_echostr,
  458. inet_ntoa(sa.sin_addr));
  459. printf(" - probable stacheldraht agentn");
  460. }
  461. else {
  462. printf("Unexpected ICMP packet from %sn",
  463. inet_ntoa(sa.sin_addr));
  464. }
  465. }
  467. /* TFN Check */
  468. if ((ipacket.icmpi.icmp_type == ICMP_ECHOREPLY) &&
  469.    (ntohs(ipacket.icmpi.icmp_hun.ih_idseq.icd_id) == 
  470. tfn_reply)) {
  471. printf("Received TFN Reply from %s",
  472.   inet_ntoa(sa.sin_addr));
  473. printf(" - probable tfn agentn");
  474. }
  476. }
  478. if (FD_ISSET (usock, &fdset)) {
  479. /* read data from UDP listen socket */
  480. memset((void *) &upacket, 0, sizeof(struct udppkt_t));
  481. len = sizeof(from);
  482. #if 1
  483. if ((i = recvfrom(usock, buf, BS, 0,
  484. (struct sockaddr *) &from, &len)) < 0) {
  485. perror("recvfrom");
  486. continue;
  487. }
  488. #else
  489. i = read (usock, (char *) buf, BS) -
  490. (sizeof (struct ip) + sizeof (struct udphdr));
  491. #endif
  492. sa.sin_addr.s_addr = upacket.ipi.ip_src.s_addr;
  493. if(dflg)
  494. fprintf(stderr,
  495. "Listener got a UDP packet on port %sn",
  496. trinoo_rctport);
  498. /* trinoo check */
  499. if (strstr(buf,trinoo_echostr)) { 
  500. printf("Received '%s' from %s",
  501. trinoo_echostr,
  502. inet_ntoa(from.sin_addr));
  503. printf(" - probable trinoo agentn");
  504. }
  505. else {
  506. printf("Unexpected UDP packet received on port %d from %sn",
  507. trinoo_rctport, inet_ntoa(from.sin_addr));
  508. }
  509. }
  510. }
  511. }
  514. /* standard IP checksum */
  515. static unsigned short
  516. ip_sum(u_short *addr, int len)
  517. {
  518. register int    nleft = len;
  519. register u_short *w = addr;
  520. register int    sum = 0;
  521. u_short         answer = 0;
  523. while (nleft > 1) {
  524. sum += *w++;
  525. nleft -= 2;
  526. }
  527. if (nleft == 1) {
  528. *(u_char *) (&answer) = *(u_char *) w;
  529. sum += answer;
  530. }
  531. sum = (sum >> 16) + (sum & 0xffff);
  532. sum += (sum >> 16);
  533. answer = ~sum;
  534. return (answer);
  535. }
  539. static int
  540. usage()
  541. {
  542. fprintf(stderr,"usage: dds [options] <target>n");
  543. fprintf(stderr,"target is CIDR block to scan in form:n");
  544. fprintf(stderr,"tA.B.C.D/maskn");
  545. fprintf(stderr,"Options:n");
  546. fprintf(stderr,"t[-v] turns on verbosityn");
  547. fprintf(stderr,"t[-d] turns on debuggingn");
  548. fprintf(stderr,"t[-s] interpacket sleep in microsecondsn");
  549. fprintf(stderr,"t[-S] delay for late packetsn");
  551. return(1);
  552. }