![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dhcdrop.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcdrop / src|
Return to dhcdrop.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcdrop / src |
1.1 misho 1: /*
2: * Copyright (C) 2009 by Chebotarev Roman <roma@ultranet.ru>
3: *
4: * This program is free software; you can redistribute it and/or modify
5: * it under the terms of the GNU General Public License as published by
6: * the Free Software Foundation; either version 2 of the License.
7: *
8: * This program is distributed in the hope that it will be useful,
9: * but WITHOUT ANY WARRANTY; without even the implied warranty of
10: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11: * GNU General Public License for more details.
12: *
13: * You should have received a copy of the GNU General Public License
14: * along with this program; if not, write to the Free Software
15: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16: */
17:
18: #include "common_includes.h"
19: #include "net.h"
20: #include "dhcp.h"
21: #include "dhcdrop_types.h"
22: #include "net_functions.h"
23: #include "dhcp_functions.h"
24: #include "dhcdrop.h"
25:
26: const char usage_message[] = "Usage:\n"
27: "dhcpdrop [-h] [-D] [-t] [-y] [-r] [-b] [-a] [-A] [-f] [-R] [-q]\n"
28: "\t[-m <count>] [-c <count>] [-n <hostname>] [-N <clientname>]\n"
29: "\t[-p <port>] [-P <port>] [-w <secs>] [-T <timeout>]\n"
30: "\t[-M <max-hosts-scan>] [-l <MAC-address>] [-L <network>]\n"
31: "\t[-S <network/mask>] [-F <from-IP>] [-s <server-IP>]\n"
32: "\t[-C <"CHILDREN_TYPE" count (2 - 32)>] [<initial MAC address>]\n"
33: "\t-i <interface-name|interface-index>\n";
34:
35: const char keys[] = "\t-h - print this help message\n"
36: "\t-D - list of available network interfaces.\n"
37: "\t Format - index:name.\n"
38: "\t-t - test mode. Send DHCPDISCOVER and wait DHCPOFFER.\n"
39: "\t Exit with code 200 if DHCPOFFER is received.\n"
40: "\t Otherwise - exit with code 0.\n"
41: "\t-y - answer 'yes' to all questions.\n"
42: "\t-r - disable ethernet address randomize.\n"
43: "\t-b - use flag 'broadcast' in DHCP message\n"
44: "\t (default: don't use flag broadcast).\n"
45: "\t-a - always wait server('s) response\n"
46: "\t on default DHCP client port (68)\n"
47: "\t-A - always wait server('s) response\n"
48: "\t from default DHCP server port (67)\n"
49: "\t-f - flood mode. Generate DHCPDISCOVER flood.\n"
50: "\t-R - send DHCPRELEASE from source MAC address specified\n"
51: "\t by <initial MAC address> and IP address specified\n"
52: "\t by option -F to server specified by option -s.\n"
53: "\t-q - quiet mode.\n"
54: "\t-m count - maximum number of attempts\n"
55: "\t to receive answer from DHCP server.\n"
56: "\t-c count - maximum number of receiving addresses\n"
57: "\t from DHCP server (default: 255).\n"
58: "\t-n hostname - value of DHCP-option 'HostName'\n"
59: "\t (default: 'DHCP-dropper').\n"
60: "\t-N clientname - value of DHCP-option 'Vendor-Class'\n"
61: "\t (default: 'DHCP-dropper').\n"
62: "\t-p port - set client port value.\n"
63: "\t-P port - set server port value.\n"
64: "\t-w seconds - set timeout after which the process will be\n"
65: "\t restarted when using agressive mode (see option -L)\n"
66: "\t (default: 60 secs).\n"
67: "\t-T timeout - set timeout (of) waiting server response\n"
68: "\t in seconds (default: 3).\n"
69: "\t-M max-hosts-scan - maximum number of hosts scanned if\n"
70: "\t agressive mode (is used) (option -L).\n"
71: "\t-l MAC-address - ethernet address of DHCP server\n"
72: "\t which need(s) to (be) ignore(d). May be several servers.\n"
73: "\t Need option '-l' for each server.\n"
74: "\t-L network - specify legal network(s) on interfase. May be\n"
75: "\t several networks. If this parameter is set, dhcdrop\n"
76: "\t uses agressive mode: it scans address range assigned\n"
77: "\t by DHCP server for searching hosts with incorrect addresses,\n"
78: "\t sends DHCPRELEASE to server from every found host after\n"
79: "\t this it restarts process of receiving addreses.\n"
80: "\t-S network/mask - ARP-scan for network 'network' with network\n"
81: "\t mask 'mask' (CIDR notation). Source IP address for scanning\n"
82: "\t specified by option -F. If source IP is not set - using random\n"
83: "\t IP address from network address range.\n"
84: "\t-F from-IP - source IP for scanning network or sending\n"
85: "\t DHCPRELEASE (see option -S and -R).\n"
86: "\t-s server-IP - specify DHCP server IP address.\n"
87: "\t Used with option -R.\n"
88: "\t-C count - "
89: #ifdef _WIN32
90: "child thread"
91: #else
92: "children"
93: #endif
94: " number\n"
95: "\t (default: 0, minimal value: 2, maximum: 32).\n"
96: "\t Compatible only with flag '-f'.\n"
97: #ifdef _WIN32
98: "\t WARNING: not effectively under OS Windows.\n"
99: #endif
100: "\t-i interface - defines network interface, can be name or\n"
101: "\t index (cannot be 'any'). For listing available\n"
102: "\t interfaces use option -D.\n";
103:
104: const char ret_codes[] = "Program can exit with codes:\n"
105: "\t0 - Exit success. Illegal DHCP server not found.\n"
106: "\t10 - invalid user ID. You must be root for running programm.\n"
107: "\t20 - failed to set signal handler.\n"
108: "\t30 - configuration error. See usage.\n"
109: "\t40 - memory allocation error. Insufficient memory?\n"
110: "\t50 - error opening ethernet device.\n"
111: "\t51 - error listing devices.\n"
112: "\t60 - pcap filter overflow.\n"
113: "\t70 - pcap compile error.\n"
114: "\t80 - pcap set filter error.\n"
115: "\t90 - error sending packet.\n"
116: "\t100 - error getting packet.\n"
117: "\t110 - set non blocked mode error.\n"
118: "\t120 - invalid device.\n"
119: "\t200 - illegal DHCP server was found.\n";
120:
121: const char leases_warning[] = "\nWARNING: Failed to take away all the IP addresses assigned by DHCP server.\n"
122: "Perhaps DHCP server checks availability of IP addresses by sending ARP-request\n"
123: "before assigning them. Try to restart dhcpdrop later. If it doesn't help\n"
124: "try to disconnect problem hosts temporarily, then send manually DHCPRELEASE\n"
125: "from address of this hosts (use option -R) and restart dhcdrop.\n";
126:
127: const uint8_t broadcast_ether[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
128:
129: int main (int argc, char **argv)
130: {
131: struct config_params config; /* Parametrs from command line */
132:
133: srand(time(0));
134: atexit(cleanup);
135: set_timer_handler(timeout);
136: set_console_handler(int_sign);
137:
138: configure(argc, argv, &config);
139:
140: int ret = exec_action(&config);
141:
142: if(!config.quiet_mode && !config.test_mode)
143: printf("Finished.\n");
144:
145: return ret;
146: }
147:
148: int exec_action(const struct config_params * config)
149: {
150: int ret;
151:
152: #ifndef _WIN32
153: if(geteuid())
154: {
155: printf("Your EUID shoud be 0 (root) to run this program.\n"
156: "Currently your EUID is %u. Aborting.\n", geteuid());
157: return ERR_EUID;
158: }
159: #endif
160:
161: if(config->discover)
162: interfaces_discover(0);
163:
164: if(!config->test_mode && !config->quiet_mode)
165: printf("Using interface: '%s'\n", config->if_name);
166:
167: if(config->flood)
168: {
169: printf("Sending DHCPDISCOVER flood. Press Ctrl+C to abort...\n");
170: send_flood(config);
171: return EXIT_SUCCESS;
172: }
173:
174: /* Opening network device */
175: pcap_t * pcap_socket = get_device(config);
176:
177: if(config->scanned_network)
178: {
179: scan_subnet(pcap_socket, config->from_ip, config->source_mac, config->scanned_network, config->scan_netmask);
180: pcap_close(pcap_socket);
181: return EXIT_SUCCESS;
182: }
183:
184: if(config->send_dhcprelease)
185: {
186: printf("Send DHCPRELEASE from %s ", config->str_source_mac);
187: printf("client IP %s ", iptos(config->from_ip));
188: printf("to DHCP server %s\n", iptos(config->server_ip));
189: ret = send_dhcp_release(pcap_socket, config, config->source_mac,
190: config->server_ip, config->from_ip, rand());
191: pcap_close(pcap_socket);
192: return ret;
193: }
194:
195: struct dhcp_packet server_response;
196: uint16_t response_length;
197:
198: /* Searching DHCP server in the network */
199: struct dhcp_packet_net_header net_header;
200: ret = get_dhcp_server(config, pcap_socket, &net_header,
201: &server_response, &response_length);
202: if(!ret)
203: {
204: pcap_close(pcap_socket);
205: return EXIT_SUCCESS; /* Illegal DHCP server not found */
206: }
207:
208: if(ret != ILLEGAL_SERV_FOUND)
209: return ret; /* Error occured */
210:
211: if(config->test_mode) /* If test-mode - exit without dropping */
212: {
213: pcap_close(pcap_socket);
214: return ILLEGAL_SERV_FOUND;
215: }
216:
217: char str_srv_etheraddr[MAX_STR_MAC_LEN + 1];
218: bzero(str_srv_etheraddr, sizeof(str_srv_etheraddr));
219: etheraddr_bin_to_str(net_header.eth_head.ether_shost, str_srv_etheraddr);
220: /* Drop server with ethernet address in 'str_srv_etheraddr' */
221: int dropped = drop_dhcp_server(config, pcap_socket, str_srv_etheraddr);
222: if(config->quiet_mode)
223: printf("%d adresses received from DHCP server.\n", dropped);
224:
225: if(legal_nets_list(get_count, 0)) /* If set - use agressive mode */
226: {
227: if(!agressive_clean_leases(pcap_socket, config, &net_header,
228: &server_response, response_length))
229: {
230: if(hosts_list(get_count, 0, 0) > 1)
231: {
232: /* Ask user: "Restart dropping? [y/n]" */
233: char yN[2] = "n"; /* Default - don't restart */
234: (config->yes)? yN[0] = 'y' : (printf("Restart dropping? [y/n] "), scanf("%s", yN));
235: if((yN[0] == 'y') || (yN[0] == 'Y'))
236: {
237: printf("Restart dropping DHCP server after %d seconds timeout...\n", config->wait_before_restart);
238: sleep(config->wait_before_restart);
239: dropped = drop_dhcp_server(config, pcap_socket, str_srv_etheraddr);
240: if(config->quiet_mode)
241: printf("%d adresses received.\n", dropped);
242: if((dropped < (hosts_list(get_count, 0, NULL) - 1 + 1)) && /* -1 - itself DHCP server,
243: + 1 - start address */
244: !config->quiet_mode)
245: printf("%s\n", leases_warning);
246: }
247: }
248: }
249: }
250:
251: pcap_close(pcap_socket);
252:
253: return ILLEGAL_SERV_FOUND;
254: }
255:
256: void configure(const int argc, char **argv, struct config_params * params)
257: {
258: bzero(params, sizeof(struct config_params));
259: params->rand_mac_always = 1; /* Default - randomize source ethernet address */
260: params->max_attempts = MAX_ATTEMPTS; /* If == 0 - exit */
261: params->server_port = DEF_SERVER_PORT;
262: params->client_port = DEF_CLIENT_PORT;
263: params->max_hosts_scan = MAX_HOSTS_SCAN;
264: params->wait_before_restart = WAIT_BEFORE_RERUN;
265:
266: if(argc < 2)
267: usage(0);
268:
269: int i;
270: int ret;
271:
272: for(i = 1; i < argc; ++i)
273: {
274: /* t y r f b h m i c n N C l p P a A T D L M w S F R s*/
275: if(argv[i][0] == '-')
276: {
277: /*Parsing options without params*/
278: if(strlen(argv[i]) > 2)
279: usage(0);
280: switch(argv[i][1])
281: {
282: case 't':
283: params->test_mode = 1;
284: continue;
285: case 'y':
286: params->yes = 1;
287: continue;
288: case 'r':
289: params->rand_mac_always = 0;
290: continue;
291: case 'f':
292: params->flood = 1;
293: continue;
294: case 'b':
295: params->broadcast = 1;
296: continue;
297: case 'a':
298: params->always_wait_to_68 = 1;
299: continue;
300: case 'A':
301: params->always_wait_from_67 = 1;
302: continue;
303: case 'R':
304: params->send_dhcprelease = 1;
305: continue;
306: case 'q':
307: params->quiet_mode = 1;
308: continue;
309: case 'D':
310: params->discover = 1;
311: return;
312: case 'h':
313: usage(1);
314: break;
315: }
316: if(i + 1 >= argc)
317: usage(0);
318: if(argv[i + 1][0] == '-')
319: usage(0);
320:
321: /*Parsing options with params*/
322: switch(argv[i][1])
323: {
324: case 'm':
325: params->max_attempts = atoi(argv[i + 1]);
326: if(params->max_attempts < 1)
327: usage(0);
328: break;
329: case 'i':
330: params->if_name = argv[i + 1];
331: if(atoi(params->if_name) > 0)
332: {
333: params->if_name = interfaces_discover(atoi(params->if_name));
334: if(!params->if_name)
335: {
336: printf("Can't find device by index: '%s', use option '-D' for interface discover. Exit.\n",
337: argv[i + 1]);
338: exit(ERR_LISTING_DEV);
339: }
340: }
341: break;
342: case 'c':
343: params->max_address_count = atoi(argv[i + 1]);
344: if(params->max_address_count < 1)
345: usage(0);
346: break;
347: case 'n':
348: if(strlen(argv[i + 1]) > (sizeof(params->client_hostname) - 1))
349: {
350: printf("Client hostname too long.\n");
351: usage(0);
352: }
353: memcpy(params->client_hostname, argv[i + 1], strlen(argv[i + 1]));
354: break;
355: case 'N':
356: if(strlen(argv[i + 1]) > (sizeof(params->dhcp_client) - 1))
357: {
358: printf("DHCP client name too long.\n");
359: usage(0);
360: }
361: memcpy(params->dhcp_client, argv[i + 1], strlen(argv[i + 1]));
362: break;
363: case 'C':
364: params->children_count = atoi(argv[i + 1]);
365: if(params->children_count < 2 ||
366: params->children_count > MAX_CHILDREN)
367: usage(0);
368: break;
369: case 'p':
370: params->client_port = atoi(argv[i + 1]);
371: if(params->client_port < 1 || params->client_port > MAX_PORT_VALUE)
372: {
373: printf("Invalid DHCP client port value: '%s'\n", argv[i + 1]);
374: usage(0);
375: }
376: break;
377: case 'P':
378: params->server_port = atoi(argv[i + 1]);
379: if(params->server_port < 1 || params->server_port > MAX_PORT_VALUE)
380: {
381: printf("Invalid DHCP server port value: '%s'\n", argv[i + 1]);
382: usage(0);
383: }
384: break;
385: case 'l':
386: if(strlen(argv[i + 1]) > 17)
387: {
388: printf("Legal-server ethernet address too long.\n");
389: usage(0);
390: }
391: if(!ignor_servers_list(add, argv[i + 1]))
392: {
393: printf("Invalid legal-server ethernet address: '%s'\n", argv[i + 1]);
394: usage(0);
395: }
396: break;
397: case 'T':
398: params->timeout = atoi(argv[i + 1]);
399: if(params->timeout < 1)
400: {
401: printf("Invalid timeout value: '%s'\n", argv[i + 1]);
402: usage(0);
403: }
404: break;
405: case 'L':
406: {
407: if(strlen(argv[i + 1]) > MAX_IP4_ALEN) /* 3 = / + \d + d\. Sample: "/24" */
408: {
409: printf("Invalid legal network IP address: '%s'\n", argv[i + 1]);
410: usage(0);
411: }
412:
413: uint32_t net;
414: if( ( net = inet_addr(argv[i + 1])) == INADDR_NONE)
415: {
416: printf("Invalid legal network IP address: '%s'\n", argv[i + 1]);
417: usage(0);
418: }
419:
420: legal_nets_list(add, &net);
421:
422: break;
423: }
424: case 'M':
425: params->max_hosts_scan = atoi(argv[i + 1]);
426: if(params->max_hosts_scan < 4)
427: {
428: printf("Invalid maximum hosts scan value: %s. Minimum - 4.\n", argv[i + 1]);
429: usage(0);
430: }
431: break;
432: case 'w':
433: params->wait_before_restart = atoi(argv[i + 1]);
434: if(params->wait_before_restart < 1)
435: {
436: printf("Invalid 'wait before rerun' value: %s\n", argv[i + 1]);
437: usage(0);
438: }
439: break;
440: case 'S':
441: {
442: char network[MAX_IP4_ALEN + 3 + 1]; /* 3 - CIDR mask (/24 e.g.) 1 - \0 */
443: bzero(network, sizeof(network));
444:
445: if(strlen(argv[i + 1]) > (sizeof(network) - 1))
446: {
447: printf("Invalid network for scanning: %s - too long.\n", argv[i + 1]);
448: usage(0);
449: }
450:
451: strncpy(network, argv[i + 1], strlen(argv[i + 1]));
452:
453: char * mask = strrchr(network, '/');
454: if(!mask)
455: {
456: printf("Invalid network for scanning: %s - netmask not specified.\n", network);
457: usage(0);
458: }
459:
460: *mask = '\0'; /* Split network and netmask strings */
461: ++mask;
462:
463: if( (params->scanned_network = inet_addr(network)) == INADDR_NONE)
464: {
465: printf("Invalid network IP address for scanning: %s\n", network);
466: usage(0);
467: }
468:
469: params->scan_netmask = atoi(mask);
470: if( (params->scan_netmask < 0) || (params->scan_netmask > 30))
471: {
472: printf("Invalid netmask length: %s. Minimum - 0, maximum - 30.\n", mask);
473: usage(0);
474: }
475:
476: int bit_pos;
477: uint32_t netmask = 0;
478: for(bit_pos = 0; bit_pos < (32 - params->scan_netmask) ; ++bit_pos)
479: netmask |= 1 << bit_pos;
480: params->scan_netmask = htonl(~netmask);
481:
482: break;
483: }
484: case 'F':
485: {
486: if( (params->from_ip = inet_addr(argv[i + 1])) == INADDR_NONE)
487: {
488: printf("Invalid source IP address: %s\n", argv[i + 1]);
489: usage(0);
490: }
491: break;
492: }
493: case 's':
494: {
495: if( (params->server_ip = inet_addr(argv[i + 1])) == INADDR_NONE)
496: {
497: printf("Invalid server IP address: %s\n", argv[i + 1]);
498: usage(0);
499: }
500: break;
501: }
502: default:
503: usage(0);
504: break;
505: }
506: ++i;
507: }
508: else
509: {
510: if(strlen(argv[i]) > (sizeof(params->str_source_mac) - 1) )
511: {
512: printf("Length source MAC address too long. Exit.\n");
513: usage(0);
514: }
515: if(strlen(params->str_source_mac))
516: usage(0); /*Ethernet address already set*/
517: replace_semicolons(argv[i]);
518: strncat(params->str_source_mac, argv[i], MAX_STR_MAC_LEN);
519: }
520: }
521:
522: if(params->flood && params->test_mode)
523: {
524: printf("Error: option '-f' (flood) not compatible with option '-t' (test mode).\n");
525: usage(0);
526: }
527:
528: if(params->children_count && ! params->flood)
529: {
530: printf("Error: option '-C' (children count) compatible only with option '-f' (flood).\n");
531: usage(0);
532: }
533:
534: if(params->max_address_count > 255 && !params->rand_mac_always && !params->flood)
535: {
536: printf("Error: Option 'max address count' can't be greatest then 255 if you use option -r\n");
537: usage(0);
538: }
539:
540: if(!params->if_name)
541: usage(0);
542:
543: if(!strcmp("any", params->if_name))
544: {
545: printf("Can't drop DHCP server on 'any' device! Exit.\n");
546: exit(ERR_CONFIG);
547: }
548:
549: if( params->send_dhcprelease && (!params->server_ip ||
550: !params->from_ip || !strlen(params->str_source_mac)) )
551: {
552: printf("You must specify server IP address (use option -s), client IP address (use option -F)\n"
553: "\tand MAC address for sending DHCPRELEASE.\n");
554: usage(0);
555: }
556:
557: /* If not set initial MAC - set random value */
558: if(!strlen(params->str_source_mac))
559: rand_ether_addr(params->str_source_mac);
560: ret = etheraddr_str_to_bin(params->str_source_mac, params->source_mac);
561: if(!ret)
562: {
563: printf("Invalid parametrs in etheraddr_str_to_bin(). Aborting programm!");
564: abort();
565: }
566: if(ret < 0)
567: {
568: printf("Invalid source MAC address: '%s'\n", params->str_source_mac);
569: usage(0);
570: }
571:
572: if(! *params->client_hostname)
573: strncat(params->client_hostname, DEF_HOSTNAME, sizeof(params->client_hostname) - 1);
574: if(! *params->dhcp_client)
575: strncat(params->dhcp_client, DEF_DHCPCLIENT, sizeof(params->dhcp_client) - 1);
576: if( !params->max_address_count && !params->flood)
577: params->max_address_count = MAX_ADDR_COUNT;
578: if( !params->timeout)
579: params->timeout = DEF_TIMEOUT;
580: return;
581: }
582:
583: /*
584: If num == 0 - show all available interfaces and exit from programm.
585: Else - return name of interface by number 'num'
586: */
587: char * interfaces_discover(const int num)
588: {
589: if(!num)
590: printf("Available interfaces:\n");
591:
592: char errbuf[PCAP_ERRBUF_SIZE];
593: pcap_if_t *dev_list_start = 0, * dev_ptr = 0;
594: char * if_name = 0;
595: int32_t ret = pcap_findalldevs(&dev_list_start, errbuf);
596:
597: if(ret == -1)
598: {
599: printf("Error: %s\n", errbuf);
600: exit(ERR_LISTING_DEV);
601: }
602:
603: if(!dev_list_start)
604: {
605: printf("Error.\n");
606: exit(ERR_LISTING_DEV);
607: }
608:
609: int i = 1;
610: for(dev_ptr = dev_list_start; dev_ptr; dev_ptr = dev_ptr->next)
611: {
612: if(num)
613: {
614: if(!strcmp("any", dev_ptr->name))
615: continue;
616: if((i == num))
617: {
618: if_name = (char *) calloc(strlen(dev_ptr->name) + 1, sizeof(char));
619: if(!if_name)
620: {
621: printf("Can't allocate memory for interface '%s'. Quit.\n", dev_ptr->name);
622: exit(ERR_MEMORY);
623: }
624: strncpy(if_name, dev_ptr->name, strlen(dev_ptr->name));
625: pcap_freealldevs(dev_list_start);
626: return if_name;
627:
628: }
629: ++i;
630: }
631: else
632: {
633: if(strcmp("any", dev_ptr->name))
634: {
635: printf("%d:", i++);
636: ifprint(dev_ptr);
637: }
638: }
639: }
640:
641: pcap_freealldevs(dev_list_start);
642:
643: if(num) /* Suitable device not found */
644: return 0;
645:
646: exit(ERR_CONFIG);
647: }
648:
649: void send_flood(const struct config_params * params)
650: {
651: int i;
652: int ret_code;
653: struct flood_params par;
654: par.config = params;
655: #ifdef _WIN32
656: HANDLE threads[MAX_THREADS_COUNT]; /* Array of threads for DHCP senders */
657: DWORD th_id[MAX_THREADS_COUNT]; /* Array of threads identifiers */
658: par.flood_threads = threads;
659: par.threads_ids = th_id;
660: #endif
661:
662: if(params->children_count < 2)
663: {
664: if( (ret_code = start_flood((void*) &par) ) )
665: exit(ret_code);
666: return;
667: }
668: #ifdef _WIN32
669: printf("WARNING: multithread flood not effectively under OS Windows!\n");
670: #endif
671: printf("Create %d "CHILDREN_TYPE" for flood.\n", params->children_count);
672: for( i = 0; i < params->children_count; ++i)
673: new_child(&par, i);
674: printf("Waiting for all "CHILDREN_TYPE".\n");
675: wait_children(&par);
676: return;
677: }
678:
679: int get_dhcp_server(const struct config_params * config, /* Configuration parametrs. Can't be NULL */
680: pcap_t * pcap_socket, /* Pointer to pcap device. Can't be NULL */
681: struct dhcp_packet_net_header * net_header, /* Can't be NULL */
682: struct dhcp_packet * server_response, /* Function store DHCP response server here, */
683: /* can't be NULL */
684: uint16_t * response_length)
685: {
686: if(!pcap_socket || !server_response)
687: return ERR_ABNORMAL;
688:
689: char filter[PCAP_FILTER_LEN + 1]; /* filter for pcap_setfilter */
690: char str_ether_addr[MAX_STR_MAC_LEN + 1];
691:
692: bzero(filter, sizeof(filter));
693:
694: /* Create and set DHCP filter */
695: int ret;
696: if( (ret = make_serverdiscover_filter(filter, sizeof(filter) - 1, config, config->str_source_mac)) )
697: {
698: printf("Can't create DHCP filter.\n");
699: exit(ret);
700: }
701: /*printf("Filter: %s\n", filter);*/
702: if( (ret = set_pcap_filter(pcap_socket, filter)) )
703: {
704: printf("Can't set DHCP filter.\n");
705: exit(ret);
706: }
707:
708: int packet_len;
709:
710: int i;
711: uint32_t xid = rand();
712: for(i = 0; i < config->max_attempts; ++ i)
713: {
714: /* Sending DHCPDISCOVER */
715: if( (ret = send_dhcp_discover(pcap_socket, config, 0, xid)) )
716: return ret;
717: /* and waiting DHCPOFFER */
718: ret = get_dhcp_response(pcap_socket, config->timeout, DHCPOFFER, xid,
719: net_header, server_response, &packet_len);
720: if(!ret) /* DHCP server responded */
721: {
722: struct in_addr ip;
723: /* Trying to decode DHCP response */
724: if((ret = get_dhcp_option(server_response, packet_len,
725: DHO_DHCP_SERVER_IDENTIFIER, (void*)&ip.s_addr, sizeof(ip.s_addr))) < 1)
726: {
727: printf("Can't get DHCP server ID option!\n");
728: continue;
729: }
730:
731: if(ret < 0)
732: continue; /* Possible DoS */
733:
734: if(config->test_mode)
735: {
736: printf("DHCP SRV: %s ", inet_ntoa(ip));
737: ip.s_addr = net_header->ip_header.saddr;
738: printf("(IP-hdr: %s) SRV ether: ", inet_ntoa(ip));
739: print_ether(net_header->eth_head.ether_shost);
740: printf(", YIP: %s\n", inet_ntoa(server_response->yiaddr));
741: }
742: else
743: {
744: /* Convert server ethernet address to string */
745: bzero(str_ether_addr, sizeof(str_ether_addr));
746: etheraddr_bin_to_str(net_header->eth_head.ether_shost, str_ether_addr);
747: /* Print DHCP-info from packet */
748: printf("Got response from server %s ", inet_ntoa(ip));
749: ip.s_addr = net_header->ip_header.saddr;
750: printf("(IP-header %s), server ethernet address: ", inet_ntoa(ip));
751: print_ether(net_header->eth_head.ether_shost);
752: printf(", ");
753: uint32_t lease_time;
754: if(get_dhcp_option(server_response, packet_len, DHO_DHCP_LEASE_TIME,
755: (void*)&lease_time, sizeof(lease_time)) > 0)
756: printf("lease time: %.2gh (%us)\n", (float)ntohl(lease_time)/3600, ntohl(lease_time));
757:
758: decode_dhcp(server_response, packet_len);
759:
760: /* Ask user: "Drop him? [y/n]" */
761: char yN[2] = "n"; /* Default - don't drop */
762: (config->yes)? yN[0] = 'y' : (printf("Drop him? [y/n] "), scanf("%s", yN));
763: if((yN[0] != 'y') && (yN[0] != 'Y')) /* Don't drop this server */
764: {
765: /*Add DHCP server ethernet address in ignored list*/
766: ignor_servers_list(add, str_ether_addr);
767:
768: /* Reinit PCAP filter */
769: if( (ret = make_serverdiscover_filter(filter, sizeof(filter) - 1,
770: config, config->str_source_mac)) )
771: {
772: printf("Can't create DHCP filter.\n");
773: exit(ret);
774: }
775: /*printf("Filter: %s\n", filter);*/
776: if( (ret = set_pcap_filter(pcap_socket, filter)) )
777: {
778: printf("Can't set DHCP filter.\n");
779: exit(ret);
780: }
781:
782: /* Reinit DHCP server search loop */
783: i = -1;
784: if(!config->quiet_mode)
785: printf("Searching next server...\n");
786: continue;
787: }
788: *response_length = packet_len;
789: }
790: break;
791: }
792:
793: if(ret > 0)
794: exit(ret); /* Fatal error occured */
795:
796: if(!config->quiet_mode)
797: printf("Wait DHCPOFFER timeout. Resending DHCPDISCOVER.\n");
798: }
799:
800: if(ret < 0) /* DHCPDISCOVER timeout. Illegal server not found. */
801: return 0;
802:
803: return ILLEGAL_SERV_FOUND;
804: }
805:
806: int drop_dhcp_server(const struct config_params * config, pcap_t * pcap_socket,
807: const char * srv_etheraddr)
808: {
809: char filter[PCAP_FILTER_LEN + 1]; /* filter for pcap_setfilter */
810: uint8_t bin_src_etheraddr[ETH_ALEN];
811: char str_src_etheraddr[MAX_STR_MAC_LEN + 1];
812: struct dhcp_packet_net_header net_header;
813: struct dhcp_packet dhcp_resp;
814:
815: bzero(str_src_etheraddr, sizeof(str_src_etheraddr));
816:
817: strncat(str_src_etheraddr, config->str_source_mac, sizeof(str_src_etheraddr) - 1);
818: etheraddr_str_to_bin(str_src_etheraddr, bin_src_etheraddr);
819:
820: int ret;
821: int i;
822: int j;
823: int packet_len;
824: uint32_t xid;
825: int grab_ip_count = 0;
826:
827: /* Send DHCPDISCOVER(s) and wait response from DHCP server */
828: for(i = config->max_attempts; i > 0;)
829: {
830: bzero(filter, sizeof(filter));
831: /* Create and set filter for DHCP transaction */
832: if( (ret = make_serverdrop_filter(filter, sizeof(filter) - 1, config,
833: str_src_etheraddr, srv_etheraddr)) )
834: {
835: printf("Can't create pcap filter for dropping DHCP server! Exit.\n");
836: exit(ret);
837: }
838:
839: if( (ret = set_pcap_filter(pcap_socket, filter)) )
840: {
841: printf("Can't set DHCP filter.\n");
842: exit(ret);
843: }
844:
845: xid = rand();
846: /* Sending DHCPDISCOVER */
847: if( (ret = send_dhcp_discover(pcap_socket, config, bin_src_etheraddr, xid)) )
848: exit(ret);
849:
850: /* and waiting DHCPOFFER */
851: ret = get_dhcp_response(pcap_socket, config->timeout, DHCPOFFER, xid,
852: &net_header, &dhcp_resp, &packet_len);
853:
854: if(!ret) /* DHCP server responded */
855: {
856: uint32_t server_id;
857: if((ret = get_dhcp_option(&dhcp_resp, packet_len,
858: DHO_DHCP_SERVER_IDENTIFIER, (void*)&server_id, sizeof(server_id))) < 1)
859: {
860: printf("Can't get DHCP server ID option!\n");
861: continue;
862: }
863: if(ret < 0)
864: continue; /* Possible DoS */
865:
866: /* Trying to receive offered IP address */
867: for(j = 0; j < config->max_attempts; ++j)
868: {
869: /* Sendig DHCPREQUEST */
870: if( (ret = send_dhcp_request(pcap_socket, config, bin_src_etheraddr,
871: server_id, dhcp_resp.yiaddr.s_addr, xid)) )
872: exit(ret);
873:
874: /* and waiting DHCPACK */
875: ret = get_dhcp_response(pcap_socket, config->timeout, DHCPACK, xid,
876: &net_header, &dhcp_resp, &packet_len);
877: if(!ret) /* DHCP server responded */
878: {
879: ++grab_ip_count;
880: if(!config->quiet_mode)
881: {
882: printf("%d. ", grab_ip_count);
883: decode_dhcp(&dhcp_resp, packet_len);
884: }
885:
886: bzero(str_src_etheraddr, sizeof(str_src_etheraddr));
887:
888: if(config->rand_mac_always)
889: {
890: rand_ether_addr(str_src_etheraddr);
891: etheraddr_str_to_bin(str_src_etheraddr, bin_src_etheraddr);
892: }
893: else
894: {
895: ++bin_src_etheraddr[ETH_ALEN - 1];
896: etheraddr_bin_to_str(bin_src_etheraddr, str_src_etheraddr);
897: }
898:
899: i = config->max_attempts;
900: goto get_next_ip;
901: }
902:
903: if(ret > 0)
904: exit(ret); /* Fatal error occured */
905:
906: if(!config->quiet_mode)
907: printf("Wait DHCPACK timeout. Resending DHCPREQUEST.\n");
908: }
909: }
910:
911: if(ret > 0)
912: exit(ret); /* Fatal error occured */
913:
914: if(!config->quiet_mode)
915: printf("Wait DHCPOFFER timeout. Resending DHCPDISCOVER.\n");
916: --i;
917:
918: get_next_ip:;
919: if(grab_ip_count >= config->max_address_count)
920: break;
921: }
922: return grab_ip_count;
923: }
924:
925: int agressive_clean_leases(pcap_t * pcap_socket,
926: const struct config_params * config, struct dhcp_packet_net_header * srv_net_header,
927: const struct dhcp_packet * srv_resp, uint16_t resp_len)
928: {
929: if(!config->quiet_mode)
930: printf("Trying to use agressive mode.\n");
931:
932: uint32_t server_netmask;
933:
934: if(get_dhcp_option(srv_resp, resp_len, DHO_SUBNET_MASK, &server_netmask, sizeof(server_netmask)) < 1)
935: {
936: printf("Can't get netmask from DHCP packet.\n");
937: return -1;
938: }
939:
940: int lnets_count = legal_nets_list(get_count, 0);
941: uint32_t lnet, i;
942: for(i = 0; i < lnets_count; ++i)
943: {
944: lnet = legal_nets_list(by_index, &i);
945: if((srv_resp->yiaddr.s_addr & server_netmask) ==
946: (lnet & server_netmask))
947: {
948: printf("Can't use argessive mode because the network assigned "
949: "by DHCP server and the legal network are the same: %s/%d & ",
950: iptos(srv_resp->yiaddr.s_addr & server_netmask), to_cidr(server_netmask));
951: printf("%s/%d\n", iptos(lnet & server_netmask), to_cidr(server_netmask));
952: return -1;
953: }
954: }
955:
956:
957: /* Searching hosts in illegal network */
958:
959: uint32_t start_ip = ntohl(srv_resp->yiaddr.s_addr & server_netmask);
960:
961: if(!start_ip)
962: {
963: printf("Invalid IP address in DHCP server response: %s\n", inet_ntoa(srv_resp->yiaddr));
964: return -1;
965: }
966:
967: uint32_t end_ip = start_ip + (~ntohl(server_netmask));
968:
969: /* Check IP address range length */
970: if((end_ip - start_ip) > config->max_hosts_scan)
971: {
972: printf("Too long IP address scan range: %d. Maximum allowed scans: %d. "
973: "Use option -M for change this value.\n",
974: end_ip - start_ip, config->max_hosts_scan);
975: return -1;
976: }
977:
978: if(!config->quiet_mode)
979: {
980: printf("Starting ARP scanning network in range: %s - ", iptos(htonl(start_ip)));
981: printf("%s...\n", iptos(htonl(end_ip)));
982: }
983:
984: int ret = arp_scan(pcap_socket, start_ip, end_ip,
985: srv_resp->yiaddr.s_addr, srv_resp->chaddr);
986:
987: if(ret)
988: exit(ret);
989:
990: /* Now we have list of hosts with IP adresses assigned by illegal DHCP server */
991: int hosts_count = hosts_list(get_count, 0, NULL);
992: if(hosts_count < 2) /* Hosts with invalid IP addresses not found. 1 - itself DHCP server */
993: {
994: if(!config->quiet_mode)
995: printf("Hosts with invalid IP addresses not found.\n");
996: return 0;
997: }
998:
999: char ether_addr[MAX_STR_MAC_LEN + 1];
1000: bzero(ether_addr, sizeof(ether_addr));
1001: uint8_t bin_ethaddr[ETH_ALEN];
1002: uint32_t ip;
1003:
1004: printf("Illegal DHCP server perhaps assigned IP adresses to the following hosts:\n");
1005: for(i = 0; i < hosts_count; ++i)
1006: {
1007: ip = hosts_list(by_index, i, bin_ethaddr);
1008: etheraddr_bin_to_str(bin_ethaddr, ether_addr);
1009: printf("%d. Received ARP-reply from: %s (%s)%s", i + 1, ether_addr, iptos(ip),
1010: ((ip == srv_net_header->ip_header.saddr) &&
1011: !memcmp(srv_net_header->eth_head.ether_shost, bin_ethaddr, ETH_ALEN)
1012: )? " - itself DHCP server.\n" : "\n");
1013: }
1014:
1015: printf("Sending DHCPRELEASE for invalid clients:\n");
1016: for(i = 0; i < hosts_count; ++i)
1017: {
1018: ip = hosts_list(by_index, i, bin_ethaddr);
1019: if((ip == srv_net_header->ip_header.saddr) &&
1020: !memcmp(srv_net_header->eth_head.ether_shost, bin_ethaddr, ETH_ALEN))
1021: continue;
1022: etheraddr_bin_to_str(bin_ethaddr, ether_addr);
1023: printf("Send DHCPRELEASE for host %s (%s).\n", ether_addr, iptos(ip));
1024: if( (ret = send_dhcp_release(pcap_socket, config, bin_ethaddr,
1025: srv_net_header->ip_header.saddr, ip, rand())) )
1026: exit(ret);
1027: sleep(2);
1028: }
1029:
1030: return 0;
1031: }
1032:
1033: void scan_subnet(pcap_t * pcap_socket, uint32_t from_ip, const uint8_t * from_eth,
1034: const uint32_t network, const uint32_t netmask)
1035: {
1036: uint32_t start_ip = ntohl(network & netmask);
1037: uint32_t end_ip = start_ip + (~ntohl(netmask));
1038:
1039: printf("Starting ARP-scanning for subnet %s/%d.\n", iptos(htonl(start_ip & ntohl(netmask))),
1040: to_cidr(netmask));
1041:
1042: printf("IP address range %s - ", iptos(htonl(start_ip)));
1043: printf("%s.\n", iptos(htonl(end_ip)));
1044:
1045: if(!from_ip)
1046: {
1047: from_ip = htonl(start_ip + ((uint32_t) rand() % (end_ip - start_ip)));
1048: printf("WARNING: Source IP is not set (use option -F).\n"
1049: "Using random value for source IP address: %s\n", iptos(from_ip));
1050: }
1051:
1052: int ret = arp_scan(pcap_socket, start_ip, end_ip, from_ip, from_eth);
1053:
1054: /* Now we have list of hosts with IP adresses assigned by illegal DHCP server */
1055: int hosts_count = hosts_list(get_count, 0, NULL);
1056: char ether_addr[MAX_STR_MAC_LEN + 1];
1057: bzero(ether_addr, sizeof(ether_addr));
1058: uint8_t bin_ethaddr[ETH_ALEN];
1059: uint32_t ip;
1060: int i;
1061:
1062: for(i = 0; i < hosts_count; ++i)
1063: {
1064: ip = hosts_list(by_index, i, bin_ethaddr);
1065: etheraddr_bin_to_str(bin_ethaddr, ether_addr);
1066: printf("%d. Received ARP-reply from: %s (%s).\n", i + 1, ether_addr, iptos(ip));
1067: }
1068:
1069: if(ret)
1070: exit(ret);
1071: }
1072:
1073: int arp_scan(pcap_t * pcap_socket, const uint32_t start_range, const uint32_t end_range,
1074: uint32_t from_ip, const uint8_t * from_ether)
1075: {
1076: int ret;
1077:
1078: /* Set PCAP filter for receiving ARP packets for host 'from_ether'*/
1079: char str_from_ether[MAX_STR_MAC_LEN + 1];
1080: static char filter[PCAP_FILTER_LEN + 1];
1081:
1082: bzero(filter, sizeof(filter));
1083: bzero(str_from_ether, sizeof(str_from_ether));
1084:
1085: etheraddr_bin_to_str(from_ether, str_from_ether);
1086:
1087: if( (ret = make_arp_filter(filter, sizeof(filter) - 1, str_from_ether)) )
1088: {
1089: printf("Can't create ARP filter. Error code: %d.\n", ret);
1090: return ret;
1091: }
1092:
1093: if( (ret = set_pcap_filter(pcap_socket, filter)) )
1094: {
1095: printf("Can't set ARP filter.\n");
1096: return ret;
1097: }
1098:
1099: hosts_list(flush, 0, 0);
1100:
1101: /* Scanning network */
1102: int l;
1103: for(l = 0; l < 2; ++l)
1104: {
1105: uint32_t ip;
1106: for(ip = start_range; ip <= end_range; ++ip)
1107: {
1108: if( (ret = send_arpreq(pcap_socket, htonl(ip), from_ip, from_ether)) )
1109: {
1110: printf("Sending ARP packet error! Code: %d.\n", ret);
1111: return ret;
1112: }
1113:
1114: usleep(60);
1115:
1116: if( (ret = get_arpresps(pcap_socket, 0)) )
1117: {
1118: printf("Get ARP packet error! Code: %d.\n", ret);
1119: return ret;
1120: }
1121: }
1122: }
1123: /* Waiting for slow hosts */
1124: if( (ret = get_arpresps(pcap_socket, 2)) )
1125: {
1126: printf("Get ARP packet error! Code: %d.\n", ret);
1127: return ret;
1128: }
1129:
1130: return 0;
1131: }
1132:
1133: int get_arpresps(pcap_t * pcap_socket, int timeout)
1134: {
1135: uint8_t ether_packet[DHCP_MTU_MAX];
1136: struct arp_packet_net_header * arp_header;
1137:
1138: time_t timeout_time;
1139: int one_packet_timeout = timeout ? 1 : 0;
1140: if(timeout)
1141: timeout_time = time(0) + timeout;
1142:
1143: int ret;
1144: while(1)
1145: {
1146: if( (ret = get_packet(pcap_socket, ether_packet, one_packet_timeout)) < 0)
1147: return ERR_GETPACKET;
1148:
1149: if(ret)
1150: {
1151: arp_header = (struct arp_packet_net_header *) ether_packet;
1152: if(arp_header->arp_head.arp_oper == ARP_OP_RESP)
1153: {
1154: struct arp_data * arp_d = (struct arp_data *)
1155: (ether_packet + sizeof(struct arp_packet_net_header));
1156: hosts_list(add, arp_d->from_ip, arp_d->from_ether);
1157: }
1158: }
1159:
1160: if(!timeout)
1161: break;
1162:
1163: if(time(0) == timeout_time)
1164: break;
1165: }
1166:
1167: return 0;
1168: }
1169:
1170: int send_arpreq(pcap_t * pcap_socket, const uint32_t to_ip,
1171: const uint32_t from_ip, const uint8_t * from_ether)
1172: {
1173: static struct arp_data arp_d;
1174:
1175: memcpy(arp_d.from_ether, from_ether, ETH_ALEN);
1176: arp_d.from_ip = from_ip;
1177:
1178: memcpy(arp_d.to_ether, broadcast_ether, ETH_ALEN);
1179: arp_d.to_ip = to_ip;
1180:
1181: if(!send_packet(pcap_socket, arp_packet, (uint8_t *) &arp_d, sizeof(arp_d), 0, from_ether, 0))
1182: {
1183: pcap_close(pcap_socket);
1184: return ERR_SENDPACKET;
1185: }
1186: return 0;
1187: }
1188:
1189: #ifdef _WIN32
1190: BOOL WINAPI int_sign(DWORD signal)
1191: #else
1192: int int_sign(int32_t signal)
1193: #endif
1194: {
1195: if(signal == INTERRUPT_SIGNAL)
1196: {
1197: printf("Interrupted. Quit.\n");
1198: exit(EXIT_SUCCESS);
1199: }
1200: return 0;
1201: }
1202:
1203: #ifdef _WIN32
1204: unsigned __stdcall start_flood( void* arg )
1205: #else
1206: int start_flood( void* arg )
1207: #endif
1208: {
1209: flood_params_ptr par_ptr = (flood_params_ptr) arg;
1210: int j = 0, i;
1211: int ret;
1212:
1213: uint8_t src_ether[ETH_ALEN];
1214:
1215: int packets_count = par_ptr->config->max_address_count + ((par_ptr->config->max_address_count)? 0 : 1 );
1216:
1217: memcpy(src_ether, par_ptr->config->source_mac, sizeof(src_ether));
1218:
1219: pcap_t * pcap_socket = get_device(par_ptr->config);
1220:
1221: while( j < packets_count )
1222: { /* Sending DHCDISCOVER */
1223: if( (ret = send_dhcp_discover(pcap_socket, par_ptr->config, src_ether, 0)) )
1224: return ret;
1225:
1226: usleep(CAP_TIMEOUT);
1227:
1228: if(par_ptr->config->rand_mac_always) /* Randomize source ethernet address for next DHCPDISCOVER */
1229: {
1230: src_ether[0] = 0;
1231: for(i = 1; i < 6; ++i)
1232: src_ether[i] = rand();
1233: }
1234: if(par_ptr->config->max_address_count)
1235: ++j;
1236: }
1237: pcap_close(pcap_socket);
1238: return 0;
1239: }
1240:
1241:
1242: void new_child(const struct flood_params * p, const int child_num)
1243: {
1244: #ifdef _WIN32
1245: printf("Create thread #%d.\n", child_num + 1);
1246: p->flood_threads[child_num] = (HANDLE)_beginthreadex(NULL, 0, start_flood, (void*) p, 0,
1247: (uint32_t *) &p->threads_ids[child_num]);
1248:
1249: #else
1250: int pid;
1251: pid = fork();
1252: if(pid)
1253: printf("Create child #%d with pid %d.\n", child_num + 1, pid);
1254: else
1255: { /* Generate flood from child processes */
1256: exit(start_flood((void*) p));
1257: }
1258:
1259: #endif
1260: }
1261:
1262: void wait_children(const struct flood_params * p)
1263: {
1264: #ifdef _WIN32
1265: WaitForMultipleObjects(p->config->children_count, (HANDLE*) p->flood_threads, 1, INFINITE);
1266: #else
1267: int32_t pid;
1268: while( (pid = wait(0)) != -1)
1269: printf("Child with pid %d finished.\n", pid);
1270: #endif
1271: return;
1272: }
1273:
1274: int send_dhcp_discover(pcap_t * pcap_socket, const struct config_params * config,
1275: uint8_t * src_ether, const uint32_t xid)
1276: {
1277: /* Create DHCPDISCOVER */
1278: struct dhcp_packet dhcp_req;
1279:
1280: int dhcp_opt_len = make_dhcp_req(&dhcp_req, DHCPDISCOVER, src_ether ? src_ether : config->source_mac,
1281: 0, 0, xid, config);
1282: int snd_data_len = sizeof(struct dhcp_packet) - DHCP_OPTION_LEN + dhcp_opt_len;
1283: if(snd_data_len < BOOTP_MIN_LEN)
1284: snd_data_len = BOOTP_MIN_LEN;
1285:
1286: /* Send DHCPDISCOVER to DHCP server */
1287: if(!send_packet(pcap_socket, dhcp_packet, (uint8_t*) &dhcp_req,
1288: snd_data_len, config, src_ether ? src_ether : config->source_mac, 0))
1289: {
1290: printf("Can't send packet: %s\n", pcap_geterr(pcap_socket));
1291: pcap_close(pcap_socket);
1292: return ERR_SENDPACKET;
1293: }
1294:
1295: return 0;
1296: }
1297:
1298: int make_serverdiscover_filter(char * out_filter, const int max_filter_len,
1299: const struct config_params * config, const char * src_etheraddr)
1300: {
1301: if(!out_filter || !config)
1302: return ERR_ABNORMAL;
1303:
1304: /* Adding in pcap-filter all ignored servers */
1305: struct ignored_mac_node * ign_ptr = ignor_servers_list(get_top, 0);
1306:
1307: snprintf(out_filter, max_filter_len + 1,
1308: STR_SERVERDISCOVER_FILTER, src_etheraddr,
1309: (config->always_wait_from_67)? DEF_SERVER_PORT : config->server_port,
1310: (config->always_wait_to_68)? DEF_CLIENT_PORT : config->client_port
1311: );
1312:
1313: while(ign_ptr)
1314: {
1315: if(strlen(" and not ether src host ") +
1316: strlen(ign_ptr->mac_addr) +
1317: strlen(out_filter) > max_filter_len)
1318: {
1319: printf("Error! Filter owerflow.\n");
1320: return ERR_FILTER_OWERFLOW;
1321: }
1322:
1323: strncat(out_filter, " and not ether src host ", max_filter_len - strlen(out_filter));
1324: strncat(out_filter, ign_ptr->mac_addr, max_filter_len - strlen(out_filter));
1325: ign_ptr = ign_ptr->next;
1326: }
1327:
1328: return 0;
1329: }
1330:
1331: int make_arp_filter(char * out_filter, const int max_filter_len, const char * src_etheraddr)
1332: {
1333: if(!out_filter)
1334: return ERR_ABNORMAL;
1335:
1336: static const char arp_filter[] = "arp and ether dst ";
1337:
1338: if((strlen(arp_filter) + strlen(src_etheraddr)) > max_filter_len)
1339: return -1;
1340:
1341: strncpy(out_filter, arp_filter, max_filter_len);
1342: strncat(out_filter, src_etheraddr, max_filter_len - strlen(out_filter));
1343:
1344: return 0;
1345: }
1346:
1347: int make_serverdrop_filter(char * out_filter, const int max_filter_len,
1348: const struct config_params * config,
1349: const char * src_etheraddr, const char * server_ethaddr)
1350: {
1351: if(!out_filter || !config || !src_etheraddr || !server_ethaddr)
1352: return ERR_ABNORMAL;
1353:
1354: snprintf(out_filter, max_filter_len + 1, STR_SERVERDROP_FILTER, src_etheraddr,
1355: (config->always_wait_from_67)? DEF_SERVER_PORT : config->server_port,
1356: (config->always_wait_to_68)? DEF_CLIENT_PORT : config->client_port,
1357: server_ethaddr);
1358:
1359: return 0;
1360: }
1361:
1362:
1363: int set_pcap_filter(pcap_t * pcap_socket, char * filter_expression)
1364: {
1365: struct bpf_program fp;
1366: if(pcap_compile(pcap_socket, &fp, filter_expression, 1, 0) == -1)
1367: {
1368: printf("pcap_compile error: %s\nFilter expression is: '%s'\n",
1369: pcap_geterr(pcap_socket), filter_expression);
1370: pcap_close(pcap_socket);
1371: return ERR_PCAP_COMPILE;
1372: }
1373:
1374: if(pcap_setfilter(pcap_socket, &fp) == -1)
1375: {
1376: perror("pcap_setfilter");
1377: pcap_close(pcap_socket);
1378: return ERR_PCAP_SETFILTER;
1379: }
1380:
1381: pcap_freecode(&fp);
1382:
1383: return 0;
1384: }
1385:
1386: int send_dhcp_request(pcap_t * pcap_socket, const struct config_params * config,
1387: uint8_t * src_ether, /* Pseudo-client source ethernet address. Can't be NULL */
1388: const uint32_t server_ip_address, /* DHCP server IP address. Can't be NULL */
1389: const uint32_t req_ip_addr, /* Required client IP address. Can't be NULL */
1390: const int32_t xid
1391: )
1392: {
1393: if(!pcap_socket || !config || !src_ether || !server_ip_address || !req_ip_addr)
1394: return ERR_ABNORMAL;
1395:
1396: /* Create DHCPREQUEST */
1397: struct dhcp_packet dhcp_req;
1398:
1399: int dhcp_opt_len = make_dhcp_req(&dhcp_req, DHCPREQUEST, src_ether,
1400: server_ip_address, req_ip_addr, xid, config);
1401:
1402: int snd_data_len = sizeof(struct dhcp_packet) - DHCP_OPTION_LEN + dhcp_opt_len;
1403: if(snd_data_len < BOOTP_MIN_LEN)
1404: snd_data_len = BOOTP_MIN_LEN;
1405:
1406: /* Send DHCPREQUEST to DHCP server */
1407: if(!send_packet(pcap_socket, dhcp_packet, (uint8_t*) &dhcp_req,
1408: snd_data_len, config, src_ether ? src_ether : config->source_mac, 0))
1409: {
1410: printf("Can't send packet: %s\n", pcap_geterr(pcap_socket));
1411: pcap_close(pcap_socket);
1412: return ERR_SENDPACKET;
1413: }
1414:
1415: return 0;
1416: }
1417:
1418: int send_dhcp_release(pcap_t * pcap_socket, const struct config_params * config,
1419: const uint8_t * src_ether, /* Pseudo-client source ethernet address. Can't be NULL */
1420: const uint32_t server_ip_address, /* DHCP server IP address. Can't be NULL */
1421: const uint32_t cl_ip_addr, /* Released client IP address. Can't be NULL */
1422: const int32_t xid
1423: )
1424: {
1425: if(!pcap_socket || !config || !src_ether || !server_ip_address || !cl_ip_addr)
1426: return ERR_ABNORMAL;
1427:
1428: /* Create DHCPREQUEST */
1429: struct dhcp_packet dhcp_req;
1430:
1431: int dhcp_opt_len = make_dhcp_req(&dhcp_req, DHCPRELEASE, src_ether,
1432: server_ip_address, cl_ip_addr, xid, config);
1433:
1434: int snd_data_len = sizeof(struct dhcp_packet) - DHCP_OPTION_LEN + dhcp_opt_len;
1435: if(snd_data_len < BOOTP_MIN_LEN)
1436: snd_data_len = BOOTP_MIN_LEN;
1437:
1438: /* Send DHCPREQUEST to DHCP server */
1439: if(!send_packet(pcap_socket, dhcp_packet, (uint8_t*) &dhcp_req,
1440: snd_data_len, config, src_ether ? src_ether : config->source_mac, server_ip_address))
1441: {
1442: printf("Can't send packet: %s\n", pcap_geterr(pcap_socket));
1443: pcap_close(pcap_socket);
1444: return ERR_SENDPACKET;
1445: }
1446:
1447: return 0;
1448: }
1449:
1450: int get_dhcp_response(pcap_t * pcap_socket, const int timeout, const uint8_t resp_type,
1451: const uint32_t xid, struct dhcp_packet_net_header * net_header,
1452: struct dhcp_packet * response, int * dhcp_data_len)
1453: {
1454: uint8_t ether_packet[DHCP_MTU_MAX];
1455: struct dhcp_packet_net_header * dhcp_net_header;
1456: struct dhcp_packet *dhcp_resp;
1457: uint8_t dhcp_msg_type;
1458:
1459: const int max_errors = 10;
1460: int errors = 0;
1461:
1462: while(1)
1463: {
1464: if(errors == max_errors)
1465: break;
1466:
1467: int ret = get_packet(pcap_socket, ether_packet, timeout);
1468:
1469: if(ret < 0)
1470: return ERR_GETPACKET;
1471:
1472: if(!ret)
1473: return -1; /* Timeout - server not respond */
1474:
1475: /* Analysing packet */
1476: dhcp_net_header = (struct dhcp_packet_net_header *) ether_packet;
1477: dhcp_resp = (struct dhcp_packet *) (ether_packet + sizeof(struct dhcp_packet_net_header));
1478:
1479: *dhcp_data_len = ntohs(dhcp_net_header->udp_header.len)
1480: - sizeof(struct udphdr); /* UDP data length equal DHCP-packet length */
1481:
1482: if(*dhcp_data_len > DHCP_MAX_LEN)
1483: {
1484: printf("UDP data len too long (%u bytes)! Attempting DoS?\n", *dhcp_data_len);
1485: ++errors;
1486: continue;
1487: }
1488:
1489: if(
1490: (dhcp_resp->op != BOOTREPLY) ||
1491: (get_dhcp_option(dhcp_resp, *dhcp_data_len, DHO_DHCP_MESSAGE_TYPE,
1492: (void*)&dhcp_msg_type, sizeof(dhcp_msg_type)) < 1) ||
1493: (dhcp_msg_type != resp_type) ||
1494: (dhcp_resp->xid != xid)
1495: )
1496: {
1497: ++errors;
1498: continue;
1499: }
1500:
1501: memcpy(net_header, ether_packet, sizeof(struct dhcp_packet_net_header));
1502: memcpy(response, dhcp_resp, *dhcp_data_len);
1503: return 0;
1504: }
1505:
1506: return -1;
1507: }
1508:
1509:
1510: struct ignored_mac_node * ignor_servers_list(enum list_operations operation, char * ether_addr)
1511: {
1512: if(ether_addr)
1513: {
1514: replace_semicolons(ether_addr);
1515: int hex;
1516: if(sscanf(ether_addr, "%x:%x:%x:%x:%x:%x",
1517: &hex, &hex, &hex, &hex, &hex, &hex) < 6) /* Invalid format! */
1518: return 0;
1519: }
1520:
1521: static struct ignored_mac_node * ignored_list_top = 0;
1522:
1523: switch(operation)
1524: {
1525: case add:
1526: {
1527: if(!ether_addr || (strlen(ether_addr) < MIN_STR_MAC_LEN))
1528: return 0;
1529:
1530: struct ignored_mac_node * new_node =
1531: (struct ignored_mac_node *) malloc(sizeof(struct ignored_mac_node));
1532:
1533: if(! new_node)
1534: {
1535: printf("Can't allocate memory for legal DHCP server ethernet address! Exit.");
1536: exit(ERR_MEMORY);
1537: }
1538:
1539: bzero(new_node, sizeof(struct ignored_mac_node));
1540: strncpy(new_node->mac_addr, ether_addr, sizeof(new_node->mac_addr) - 1);
1541: new_node->next = ignored_list_top;
1542: ignored_list_top = new_node;
1543: return ignored_list_top;
1544: }
1545: break;
1546: case rem:
1547: {
1548: struct ignored_mac_node * node_ptr = ignored_list_top;
1549: while(node_ptr)
1550: {
1551: if(!strncmp(node_ptr->mac_addr, ether_addr, sizeof(node_ptr->mac_addr) - 1))
1552: {
1553: struct ignored_mac_node * removed = node_ptr;
1554: node_ptr = node_ptr->next;
1555: free(removed);
1556: return ignored_list_top;
1557: }
1558: else
1559: node_ptr = node_ptr->next;
1560: }
1561: }
1562: break;
1563: case get_top:
1564: return ignored_list_top;
1565: case search:
1566: {
1567: struct ignored_mac_node * node_ptr = ignored_list_top;
1568: while(node_ptr)
1569: if(!strncmp(node_ptr->mac_addr, ether_addr, sizeof(node_ptr->mac_addr) - 1))
1570: return ignored_list_top;
1571: else
1572: node_ptr = node_ptr->next;
1573: }
1574: break;
1575: case flush:
1576: {
1577: struct ignored_mac_node * next_node;
1578: while(ignored_list_top)
1579: {
1580: next_node = ignored_list_top->next;
1581: free(ignored_list_top);
1582: ignored_list_top = next_node;
1583: }
1584: return ignored_list_top;
1585: }
1586: break;
1587: default:
1588: break;
1589: }
1590: return 0;
1591: }
1592:
1593: uint32_t legal_nets_list(enum list_operations operation, const uint32_t * value)
1594: {
1595: static uint32_t * legal_nets = 0;
1596: static int count = 0;
1597: static int capacity = 0;
1598:
1599: switch(operation)
1600: {
1601: case get_count:
1602: return count;
1603: case add:
1604: if(!capacity)
1605: {
1606: capacity = 4;
1607: if( !(legal_nets = (uint32_t *) malloc(sizeof(uint32_t) * capacity)) )
1608: {
1609: printf("Can't allocate memory for legal networks! Exit.\n");
1610: exit(ERR_MEMORY);
1611: }
1612: }
1613:
1614: if(count == capacity)
1615: {
1616: capacity *= 2;
1617: if( !(legal_nets = (uint32_t*) realloc(legal_nets, capacity)))
1618: {
1619: printf("Can't reallocate memory for legal networks! Exit.\n");
1620: exit(ERR_MEMORY);
1621: }
1622: }
1623:
1624: legal_nets[count] = *value;
1625: ++count;
1626: break;
1627: case by_index:
1628: return legal_nets[*value];
1629: case flush:
1630: count = 0;
1631: capacity = 0;
1632: if(legal_nets)
1633: free(legal_nets);
1634: break;
1635: default:
1636: printf("Unknown operation on legal nets.\n");
1637: break;
1638: }
1639: return count;
1640: }
1641:
1642: int hosts_list(enum list_operations operation, uint32_t ip_addr, uint8_t * ether_addr)
1643: {
1644: struct invalid_host
1645: {
1646: uint8_t ether_addr[ETH_ALEN];
1647: uint32_t ip_addr;
1648: };
1649:
1650: static struct invalid_host * hosts_list = 0;
1651: static int count = 0;
1652: static int capacity = 0;
1653:
1654: switch(operation)
1655: {
1656: case get_count:
1657: return count;
1658: case add:
1659: {
1660: int i;
1661: for(i = 0; i < count; ++i)
1662: if(!memcmp(hosts_list[i].ether_addr, ether_addr, sizeof(hosts_list[i].ether_addr)) &&
1663: (hosts_list[i].ip_addr == ip_addr)) /* Dupe */
1664: return 0;
1665:
1666: if(!capacity)
1667: {
1668: capacity = 4;
1669: if(! (hosts_list = (struct invalid_host* ) malloc(sizeof(struct invalid_host) * capacity)) )
1670: {
1671: printf("Can't allocate memory for invalid hosts list! Exit.\n");
1672: exit(ERR_MEMORY);
1673: }
1674: }
1675:
1676: if(count == capacity)
1677: {
1678: capacity *= 2;
1679: if( !(hosts_list = (struct invalid_host *) realloc(hosts_list, sizeof(struct invalid_host) * capacity)))
1680: {
1681: printf("Can't reallocate memory for invalid hosts list! Exit.\n");
1682: exit(ERR_MEMORY);
1683: }
1684: }
1685:
1686: memcpy(hosts_list[count].ether_addr, ether_addr, sizeof(hosts_list[count].ether_addr));
1687: hosts_list[count].ip_addr = ip_addr;
1688: ++count;
1689: }
1690: break;
1691: case by_index:
1692: if( (ip_addr < 0) || (ip_addr > (count - 1)) )
1693: return -1;
1694:
1695: memcpy(ether_addr, hosts_list[ip_addr].ether_addr, sizeof(hosts_list[ip_addr].ether_addr));
1696: return hosts_list[ip_addr].ip_addr;
1697: case flush:
1698: capacity = 0;
1699: count = 0;
1700: if(hosts_list)
1701: free(hosts_list);
1702: break;
1703: default:
1704: printf("Unknown operations on invalid hostst list.\n");
1705: break;
1706: }
1707:
1708: return 0;
1709: }
1710:
1711: void cleanup(void)
1712: {
1713: ignor_servers_list(flush, 0);
1714: legal_nets_list(flush, 0);
1715: hosts_list(flush, 0, 0);
1716: }
1717:
1718:
1719: int decode_dhcp(const struct dhcp_packet * packet, const uint16_t packet_len)
1720: {
1721: uint8_t dhcp_msg_type;
1722: switch(packet->op)
1723: {
1724: case BOOTREQUEST: printf("Got BOOTREQUEST("); break;
1725: case BOOTREPLY: printf("Got BOOTREPLY ("); break;
1726: default: printf("Unknown message type: %u\n", packet->op); return 0;
1727: }
1728: if(get_dhcp_option(packet, packet_len, DHO_DHCP_MESSAGE_TYPE,
1729: (void*)&dhcp_msg_type, sizeof(dhcp_msg_type)) < 1)
1730: {
1731: printf("Error: Can't get DHCP message type.\n");
1732: return 0;
1733: }
1734:
1735: switch(dhcp_msg_type)
1736: {
1737: case DHCPDISCOVER: printf("DHCPDISCOVER) "); break;
1738: case DHCPOFFER: printf("DHCPOFFER) "); break;
1739: case DHCPREQUEST: printf("DHCPREQUEST) "); break;
1740: case DHCPDECLINE: printf("DHCPDECLINE) "); break;
1741: case DHCPACK: printf("DHCPACK) "); break;
1742: case DHCPNAK: printf("DHCPNAK) "); break;
1743: case DHCPRELEASE: printf("DHCPRELEASE) "); break;
1744: case DHCPINFORM: printf("DHCPINFORM) "); break;
1745: default: printf("Unknown DHCP message type: %u)\n", dhcp_msg_type);
1746: }
1747:
1748: if(packet->flags && htons(BOOTP_BROADCAST))
1749: printf("flags: BROADCAST ");
1750: printf("for client ether: ");
1751: print_ether(packet->chaddr);
1752:
1753: uint32_t netmask = 0;
1754: printf(" You IP: %s", inet_ntoa(packet->yiaddr));
1755: if(get_dhcp_option(packet, packet_len, DHO_SUBNET_MASK, (void*)&netmask, sizeof(netmask)) < 1)
1756: printf("\n");
1757: else
1758: printf("/%d\n", to_cidr(netmask));
1759:
1760: return dhcp_msg_type;
1761: }
1762:
1763: void usage(const char help)
1764: {
1765: (help)? printf("%s\n%s\n%s", usage_message, keys, ret_codes) : printf("%s", usage_message);
1766: printf("\n%s\n", COPYRIGHT HOMEPAGE);
1767: if(!help)
1768: printf("Use option -h for help. Exit.\n");
1769: exit(ERR_CONFIG);
1770: }
1771:
1772: /* Convert network mask to CIDR notation */
1773: uint32_t to_cidr(uint32_t mask)
1774: {
1775: mask = ntohl(mask);
1776: int i;
1777: for(i = 0; i < 33; ++i)
1778: if(mask & (1 << i))
1779: break;
1780: return (i == 33)? 0 : 32 - i;
1781: }
1782:
1783: /* Convert a numeric IP address to a string */
1784: char *iptos(const uint32_t in)
1785: {
1786: static char output[IPTOSBUFFERS][3*4 + 3 + 1];
1787: static short which;
1788: uint8_t *p;
1789:
1790: p = (uint8_t *)∈
1791: which = (which + 1 == IPTOSBUFFERS ? 0 : which + 1);
1792: snprintf(output[which], sizeof(output), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
1793: return output[which];
1794: }
1795:
1796: void ifprint(const pcap_if_t *dev)
1797: {
1798: pcap_addr_t *pcap_addr;
1799: /* Name */
1800: printf("%s", dev->name);
1801: /* Description */
1802: if (dev->description)
1803: printf("\n descr: %s", dev->description);
1804: /* IP addresses */
1805: for(pcap_addr = dev->addresses; pcap_addr; pcap_addr = pcap_addr->next)
1806: {
1807: if(!pcap_addr->addr)
1808: continue;
1809: switch(pcap_addr->addr->sa_family)
1810: {
1811: case AF_INET:
1812: if (pcap_addr->addr)
1813: printf("\n iaddr: %s", iptos(((struct sockaddr_in *)pcap_addr->addr)->sin_addr.s_addr));
1814: if (pcap_addr->netmask)
1815: printf("/%d ", to_cidr(((struct sockaddr_in *)pcap_addr->netmask)->sin_addr.s_addr));
1816: if (pcap_addr->broadaddr)
1817: printf(" bcast: %s",iptos(((struct sockaddr_in *)pcap_addr->broadaddr)->sin_addr.s_addr));
1818: if (pcap_addr->dstaddr)
1819: printf(" dst addr: %s",iptos(((struct sockaddr_in *)pcap_addr->dstaddr)->sin_addr.s_addr));
1820: break;
1821: case AF_INET6:
1822: break;
1823:
1824: default:
1825: break;
1826: }
1827: }
1828: printf("\n");
1829: }
1830:
1831: inline int etheraddr_bin_to_str(const uint8_t * bin_addr, char * str_addr)
1832: {
1833: if(!bin_addr || !str_addr)
1834: return 0;
1835: snprintf(str_addr, MAX_STR_MAC_LEN + 1, "%02x:%02x:%02x:%02x:%02x:%02x",
1836: bin_addr[0], bin_addr[1], bin_addr[2], bin_addr[3], bin_addr[4], bin_addr[5]);
1837: return 1;
1838: }
1839:
1840: int etheraddr_str_to_bin(const char * str_addr, uint8_t * bin_addr)
1841: {
1842: if(!str_addr || !bin_addr)
1843: return 0;
1844:
1845: static char ether_addr[MAX_STR_MAC_LEN + 1]; /* Non-const buffer for strtok */
1846: bzero(ether_addr, sizeof(ether_addr));
1847: strncpy(ether_addr, str_addr, sizeof(ether_addr) - 1);
1848:
1849: int i = 0;
1850: int byte;
1851: char * bytePtr = strtok(ether_addr, ":-");
1852: while(bytePtr)
1853: {
1854: if(i > 5)
1855: return -1; /* Ethernet address consist from 6 bytes! */
1856:
1857: if(strlen(bytePtr) > 2)
1858: return -1; /* Too long digit */
1859:
1860: if(sscanf(bytePtr, "%02x", &byte) < 1)
1861: return -1; /* Invalid HEX digit */
1862:
1863: bin_addr[i++] = (uint8_t) byte;
1864: bytePtr = strtok(NULL, ":-");
1865: }
1866: if(i < 6)
1867: return -1; ; /* Ethernet address consist from 6 bytes! */
1868: return 1;
1869: }
1870:
1871: inline void replace_semicolons(char * str_ether)
1872: {
1873: char * p = str_ether;
1874: while(*p)
1875: {
1876: if(*p == '-')
1877: *p = ':';
1878: ++p;
1879: }
1880: }
1881:
1882: inline void print_ether(const uint8_t * ether_addr)
1883: {
1884: int i;
1885: for(i = 0; i < ETH_ALEN; ++i)
1886: printf((i == (ETH_ALEN - 1) ) ? "%02X" :"%02X:", ether_addr[i]);
1887: }
1888:
1889: inline void rand_ether_addr(char * str_mac_addr) /* Minimal size of str_mac_addr must be STR_MAC_LEN (18) */
1890: {
1891: /* Fill first byte */
1892: strncat(str_mac_addr, "00:", 3);
1893: char * p = str_mac_addr + strlen(str_mac_addr);
1894: int i;
1895: for(i = 0; i < 5; ++i, p +=3) /* Randomize next 5 bytes */
1896: snprintf(p, 4, (i < 4)? ("%02X:") : "%02X", (int)(rand() & 0xFF));
1897: return;
1898: }