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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
radiusniff.c
资源名称：radiusniff-0.2.tgz　[点击查看]
上传用户：quanlove
上传日期：2007-01-08
资源大小：17k
文件大小：24k
源码类别：

网络截获/分析

开发平台：

Unix_Linux

radiusniff.c：源码内容
  1. /*
  2.  
  3.  RADIUS traffic sNIFFer
  4.  Copyleft 2000 by FreeLSD <freelsd@freelsd.net>
  5.  
  6.  Some portion of code from snmpsniffer.c (c) by Nuno Leitao
  8.  NOTICE:
  9.  You may copy, distribute or modify this code, as long as you
  10.  keep this copyleft notice intact.
  12.  PS. dont try to run... ;)
  13.  
  14.  Greets to all ADM!@#$% and w00w00 ppl. 
  15.  
  16.  */
  19. #include <unistd.h>
  20. #include <sys/types.h>
  21. #include <sys/socket.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <signal.h>
  25. #include <stdio.h>
  26. #include <errno.h>
  27. #include <netinet/in_systm.h>
  28. #include <netinet/in.h>
  29. #include <netinet/ip.h>
  30. #include <netinet/udp.h>
  31. #include <netdb.h>
  32. #include <arpa/inet.h>
  34. #include <pcap.h>
  36. #include "md5.h"
  38. #define VERSION "0.2 (lame & dirty)"
  41. #ifdef NOT_HAVE_SNPRINTF
  42. #include <stdarg.h>
  43. #define snprintf int_snprintf
  44. int int_snprintf (char *buf, int len, char *fmt,...)
  45. {
  46.   va_list args;
  47.   int ret;
  49.   va_start (args, fmt);
  50.   ret = vsprintf (buf, fmt, args);
  51.   va_end (args);
  52.   return (ret);
  53. }
  54. #endif
  57. /* ------------------------------------------------------------------ */
  59. #ifdef LINUX
  60. #include <linux/if_ether.h>
  61. #define EthernetHeader  struct ethhdr
  62. #define IPHeader        struct iphdr
  63. #define UDPHeader       struct udphdr
  64. #define UDP_SrcPort(x) (x->source)
  65. #define UDP_DstPort(x) (x->dest)
  66. #define IP_SrcAddr(x)  (x->saddr)
  67. #define IP_DstAddr(x)  (x->daddr)
  68. #endif
  70. /* The default case is Solaris. */
  71. #ifndef EthernetHeader
  72. #include <net/if.h>
  73. #include <netinet/if_ether.h>
  74. #define EthernetHeader     struct ether_header
  75. #define IPHeader           struct ip
  76. #define UDPHeader          struct udphdr
  77. #define UDP_SrcPort(x) (x->uh_sport)
  78. #define UDP_DstPort(x) (x->uh_dport)
  79. #define IP_SrcAddr(x)  (x->ip_src)
  80. #define IP_DstAddr(x)  (x->ip_dst)
  81. #endif /* EthernetHeader */
  85. #define MAXBUFFER 65536
  87. #ifndef DICTIONARY_FILENAME
  88. #define DICTIONARY_FILENAME "dictionary"
  89. #endif
  91. #ifndef CLIENTS_FILENAME
  92. #define CLIENTS_FILENAME "clients"
  93. #endif
  96. #define RADIUS_ATTR_STR      1
  97. #define RADIUS_ATTR_INT      2
  98. #define RADIUS_ATTR_DATE     3
  99. #define RADIUS_ATTR_IPADDR   4
  100. #define RADIUS_ATTR_ABINARY  5         /* Ascend specific */
  102. typedef struct _DICT_VALUE {
  103.   int value;
  104.   char *name;
  105.   char *attrname;
  106.   void *next;
  107. } DICT_VALUE;
  110. typedef struct _DICT_ATTR {
  111.   int value;
  112.   int type;
  113.   char *name;
  114.   void *next;
  115. } DICT_ATTR;
  118. /* we ignore any greater */
  119. #define MAX_SECRET_STRING 253
  121. typedef struct _CLIENTS {
  122.   struct in_addr ipaddr;
  123.   char secret[MAX_SECRET_STRING];
  124.   void *next;
  125. } CLIENTS;
  128. /* radius attr packet for parsing process */
  129. typedef struct RAD_ATTR_PACKET {
  130.   int code;
  131.   int type;
  132.   int length;
  133.   char *buff;
  134.   int buff_length;
  135.   char *name;
  136.   void *next;
  137. } RAD_ATTR_PACKET;
  140. /* radius packet struct for parsing process */
  141. typedef struct RAD_PACKET {
  142.   time_t time;
  143.   struct sockaddr_in src;
  144.   struct sockaddr_in dst;
  145.   
  146.   unsigned char code;
  147.   unsigned char ident;
  148.   unsigned short length;
  149.   unsigned char auth[16];
  150.   char buff[4096];
  151.   unsigned int buff_length;
  152.   struct RAD_ATTR_PACKET *attr;              /* parsed attr's chain */
  153. } RAD_PACKET;
  156. /* ethernet packet */
  157. struct etherpacket {
  158.   EthernetHeader eth;
  159.   IPHeader ip;
  160.   UDPHeader udp;
  161.   char buff[MAXBUFFER];
  162. } eth_packet;
  165. /* The following are hooks to the positions in the struct.
  166.  */
  167. IPHeader *ip;
  168. UDPHeader *udp;
  170. /*-------------------------------------------------------------------------*/
  173. int quiet = 0;
  174. int account = 0;  /* only accounting info */
  175. int resolve = 0;  /* dont resolve hostnames as default */
  176. int verbose = 0;  /* silence as default */
  177. pcap_t *PCAP;     /* PCAP handler for interface */
  178. char *dict_filename = DICTIONARY_FILENAME;
  179. char *clients_filename = NULL;         /* individual clients secret */
  180. CLIENTS *secret_clients = NULL;
  181. char *secret_passwd = NULL;            /* global secret passwd */
  182. DICT_ATTR *dictionary_attr = NULL;
  183. DICT_VALUE *dictionary_value = NULL;
  186. char *ParseRadiusCode(unsigned int code)
  187. {
  188.   char *ret;
  189.   
  190.   switch (code) {
  191.   case 1:   ret = "Access-Request"; break;
  192.   case 2:   ret = "Access-Accept"; break;
  193.   case 3:   ret = "Access-Reject"; break;
  194.   case 4:   ret = "Accounting-Request"; break;
  195.   case 5:   ret = "Accounting-Response"; break;
  196.   case 11:  ret = "Access-Challenge"; break;
  197.   case 12:  ret = "Status-Server (experemental)"; break;
  198.   case 13:  ret = "Status=Client (experemental)"; break;
  199.   case 255: ret = "Reserved"; break;
  200.   default:
  201.     return NULL;
  202.   }
  203.   return ret;
  204. }
  207. char *ParseRadiusAuth(char *auth)
  208. {
  209.   static char ret[80];
  210.   int i;
  211.   for (i = 0; i < 16; i++) {
  212.     snprintf(ret+i*2, 80-i*2, "%02x", (unsigned int)*( unsigned char *)(auth+i));
  213.   }
  214.   return ret;
  215. }
  218. DICT_ATTR *GetAttrFromDict(int key)
  219. {
  220.   DICT_ATTR *attr = dictionary_attr;
  221.   
  222.   while (attr != NULL) {
  223.     if (attr->value == key) return attr;
  224.     attr = attr->next;
  225.   }
  226.   return NULL;
  227. }
  230. DICT_VALUE *GetValueFromDict(int attrkey, int key)
  231. {
  232.   DICT_VALUE *value = dictionary_value;
  233.   DICT_ATTR *attr;
  234.   char *str;
  235.   
  236.   if ((attr = GetAttrFromDict(attrkey)) == NULL) return NULL;
  237.   str = attr->name;
  239.   while (value != NULL) {
  240.     if (strlen(value->attrname) == strlen(str) &&
  241.         strncmp(value->attrname, str, strlen(str)) == 0 &&
  242.         value->value == key)
  243.       return value;
  244.     value = value->next;
  245.   }
  246.   return NULL;
  247. }
  249. char *GetHostSecret(struct in_addr *ipaddr)
  250. {
  252.   CLIENTS *cur = secret_clients;
  254.   while (cur != NULL) {
  255.     if (memcmp(ipaddr, &cur->ipaddr, sizeof(struct in_addr)) == 0)
  256.       return cur->secret;
  257.     cur = cur->next;
  258.   }
  259.   
  260.   /* if global secret passwd is setted, we use it as default
  261.    for nondefined hosts */
  262.   if (secret_passwd != NULL) return secret_passwd;
  263.   return NULL;
  264. }
  267. void OutHex(unsigned char *buff, unsigned int len)
  268. {
  269.   printf("(%d) ", len);
  270.   while (len-- != 0) {
  271.     printf("%02x", (unsigned int)*buff);
  272.     buff++;
  273.   }
  274. }
  276. void OutAscii(unsigned char *buff, unsigned int len)
  277. {
  278.   while (len-- != 0 && *buff != 0) {
  279.     printf("%c", (unsigned char)*buff);
  280.     buff++;
  281.   }
  282. }
  285. void FreeRadiusPacketStruct(RAD_PACKET *rad)
  286. {
  287.   int counter = 0;
  288.   RAD_ATTR_PACKET *pkt;
  290.   if (rad == NULL) return;
  291.   while ((pkt = rad->attr) != NULL) {
  292.     rad->attr = rad->attr->next;
  293.     counter++;
  294.     free(pkt);
  295.   }
  296. #ifdef DEBUG_MALLOC
  297.   fprintf(stderr, "free %d objectsn", counter);
  298. #endif
  299. }
  301. int OutRadiusPacket(RAD_PACKET *rad)
  302. {
  303.   struct tm *curr_time;
  304.   struct hostent *host;
  305.   char src_str[128], dst_str[128];
  306.   RAD_ATTR_PACKET *attr = rad->attr;
  307.   DICT_VALUE *value;
  308.   unsigned long val;
  309.   struct sockaddr_in addr;
  310.   char str[4096], *code_str;
  311.   int empty;
  313.   curr_time = localtime(&rad->time);
  315.   memset(src_str, 0, sizeof(src_str));
  316.   strncpy(src_str, (char *)inet_ntoa(rad->src.sin_addr), 127);
  318.   memset(dst_str, 0, sizeof(dst_str));
  319.   strncpy(dst_str, (char *)inet_ntoa(rad->dst.sin_addr), 127);
  321.   if (resolve) {
  322.     if ((host = gethostbyaddr((char *) &rad->src.sin_addr,
  323.                                sizeof(rad->src.sin_addr), AF_INET)))
  324.       strncpy(src_str, host->h_name, 127);
  325.     if ((host = gethostbyaddr((char *) &rad->dst.sin_addr,
  326.                                sizeof(rad->dst.sin_addr), AF_INET)))
  327.       strncpy(dst_str, host->h_name, 127);
  328.   }
  330.   
  331.   if (!account) {
  332.     /* out all packets */
  333.     printf("%.2d:%.2d:%.2d   ", 
  334.            curr_time->tm_hour, curr_time->tm_min, curr_time->tm_sec);
  335.     printf("%s:%u > %s:%un", src_str, ntohs(rad->src.sin_port),
  336.            dst_str, ntohs(rad->dst.sin_port));
  337.     code_str = ParseRadiusCode(rad->code);
  338.     if (code_str == NULL) {
  339.       printf("    code : Undefined (%0x02X)nn", rad->code);
  340.       return -1;
  341.     }
  342.     printf("    code : %sn", ParseRadiusCode(rad->code));
  343.     if (verbose) {
  344.       printf("    iden : 0x%02xn     len : 0x%03xn    auth : %sn",
  345.              rad->ident, rad->length, ParseRadiusAuth(rad->auth));
  346.     }
  347.     while (attr) {
  348.       printf("t%s = ", attr->name);
  349.       if (attr->buff_length <= 0) empty = 1; else empty = 0;
  350.       
  351.       switch (attr->type) {
  352.       case RADIUS_ATTR_DATE:
  353.         if (empty) break;
  354.         memcpy(&val, attr->buff, sizeof(long));
  355.         val = ntohl(val);
  356.         printf("%08Xh (date)n", val);
  357.         break;
  358.       case RADIUS_ATTR_INT:
  359.         if (empty) break;
  360.         memcpy(&val, attr->buff, sizeof(long));
  361.         val = ntohl(val);
  362.         if ((value = GetValueFromDict(attr->code, val)) == NULL) {
  363.           printf("%dn", val);
  364.         } else {
  365.           printf("%sn", value->name);
  366.         }
  367.         break;
  368.       case RADIUS_ATTR_IPADDR:
  369.         if (empty) break;
  370.         memcpy ((void *) &(addr.sin_addr), (void *)(attr->buff),
  371.                 sizeof(struct in_addr));
  372.         printf("%sn", inet_ntoa(addr.sin_addr));
  373.         break;
  374.       case RADIUS_ATTR_ABINARY:
  375.         if (empty) printf("""n");
  376.         else {
  377.           if ( attr->code == 2 && GetHostSecret(&rad->src.sin_addr) != NULL ) {
  378.              /* password */
  379.              char cr[1024];
  380.              char digest[32];
  381.              char *hostsecret = GetHostSecret(&rad->src.sin_addr);
  382.              int i;
  383.              memcpy(cr, hostsecret, strlen(hostsecret));
  384.              memcpy(cr + strlen(hostsecret), rad->auth, 16);
  385.              MD5Calc(digest, cr, strlen(hostsecret) + 16);
  386.              memset(cr, 0, sizeof(cr));
  387.              printf(""");
  388.              for ( i = 0; i < attr->buff_length; i++ ) 
  389.                attr->buff[i] ^= digest[i % 16];
  390.              OutAscii(attr->buff, attr->buff_length);
  391.              printf("" ");
  392.           }  
  393.           OutHex(attr->buff, attr->buff_length);
  394.           printf("n");
  395.         }
  396.         break;
  397.       case RADIUS_ATTR_STR:
  398.         if (empty) printf("""n");
  399.         else {
  400.           memcpy(str, (attr->buff), attr->buff_length);
  401.           str[attr->buff_length] = 0;
  402.           printf(""%s"n", str);
  403.         }
  404.         break;
  405.       default:
  406.         printf("<undefined type>n");
  407.         break;
  408.       }
  409.       attr = attr->next;
  410.     }
  411.   printf("n");
  412.   } else {
  413.     /* out only short accounting packets */
  414.     if (rad->code != 4 && rad->code != 5) return 0;
  415.     printf("%.2d:%.2d:%.2d  ", 
  416.            curr_time->tm_hour, curr_time->tm_min, curr_time->tm_sec);
  417.     printf("%s:%u > %s:%u ", src_str, ntohs(rad->src.sin_port),
  418.            dst_str, ntohs(rad->dst.sin_port));
  419.     if (rad->code == 4) printf("Req ");
  420.     else printf("Res ");
  421.     while (attr) {
  422.       printf("%s = ", attr->name);
  423.       if (attr->buff_length <= 0) empty = 1; else empty = 0;
  424.       
  425.       switch (attr->type) {
  426.       case RADIUS_ATTR_DATE:
  427.         if (empty) break;
  428.         memcpy(&val, attr->buff, sizeof(long));
  429.         val = ntohl(val);
  430.         printf("%08Xh (date)", val);
  431.         break;
  432.       case RADIUS_ATTR_INT:
  433.         if (empty) break;
  434.         memcpy(&val, attr->buff, sizeof(long));
  435.         val = ntohl(val);
  436.         if ((value = GetValueFromDict(attr->code, val)) == NULL) {
  437.           printf("%d", val);
  438.         } else {
  439.           printf("%s", value->name);
  440.         }
  441.         break;
  442.       case RADIUS_ATTR_IPADDR:
  443.         if (empty) break;
  444.         memcpy ((void *) &(addr.sin_addr), (void *)(attr->buff),
  445.                 sizeof(struct in_addr));
  446.         printf("%s", inet_ntoa(addr.sin_addr));
  447.         break;
  448.       case RADIUS_ATTR_ABINARY:
  449.         if (empty) printf("""");
  450.         else {
  451.           OutHex(attr->buff, attr->buff_length);
  452.         }
  453.         break;
  454.       case RADIUS_ATTR_STR:
  455.         if (empty) printf("""");
  456.         else {
  457.           memcpy(str, (attr->buff), attr->buff_length);
  458.           str[attr->buff_length] = 0;
  459.           printf(""%s"", str);
  460.         }
  461.         break;
  462.       default:
  463.         printf("<undefined type>");
  464.         break;
  465.       }
  466.       attr = attr->next;
  467.       if (attr) printf(", ");
  468.     }
  469.   printf("n");
  470.   }
  472.   return 0;
  473. }
  476. /* redefine type for some of non ascii attributes */
  477. int HookAttr(int code, int type)
  478. {
  479.   switch (code) {
  480.   case 2:          /* Password (out like md5) */
  481.   case 3:          /* Challenge-Response (CHAP Password) */
  482.   case 17:         /* Change-Password (only for Ascend)*/
  483.   case 19:         /* Callback-Number (no ascii) */
  484.   case 20:         /* Callback-Id (no ascii) */
  485.   case 24:         /* State (no ascii) */
  486.   case 25:         /* Class (no ascii) */
  487.   case 26:         /* Vendor_Specific */
  488.   case 214:        /* Ascend-Send-Secret */
  489.   case 215:        /* Ascend-Receive-Secret */
  490.     return RADIUS_ATTR_ABINARY;
  491.   }
  492.   return type;
  493. }
  496. int ParseRadiusAttr(RAD_PACKET *rad)
  497. {
  498.   DICT_ATTR *attr;
  499.   DICT_VALUE *value;
  500.   unsigned long val;
  501.   struct sockaddr_in addr;
  502.   RAD_ATTR_PACKET *rattr, *last = NULL;
  503.   int counter = 0;
  504.   unsigned char *buff = rad->buff;
  505.   int len = rad->buff_length;
  508.   if (len <= 0) return -1;
  509.   while (len > 0) {
  510.     rattr = malloc(sizeof(RAD_ATTR_PACKET));
  511.     if (rattr == NULL) {
  512.       fprintf(stderr, "ERROR: Out of memory (while parsing in progress)n");
  513.       return -1;
  514.     }
  515.     counter++;
  516.     rattr->code = (unsigned char)*buff;
  517.     rattr->length = (unsigned char)*(buff+1);
  518.     if ((attr = GetAttrFromDict(rattr->code)) == NULL) {
  519.       fprintf(stderr, "ERROR: Undefined attr (type:%02Xh, length:%d)n",
  520.               rattr->code, rattr->length);
  521.        return -1;
  522.     }
  523.     rattr->name = attr->name;
  524.     rattr->type = HookAttr(rattr->code, attr->type);
  525.     rattr->buff = buff+2;
  526.     rattr->buff_length = rattr->length-2; /* without code and len */
  527.     rattr->next = NULL;
  529.     if (last == NULL) rad->attr = rattr;
  530.     else last->next = rattr;
  531.     last = rattr;
  533.     /* continue for next attr */
  534.     len -= rattr->length;
  535.     buff += rattr->length;
  536.   }
  537.   if (len != 0) {
  538.     fprintf(stderr, "ERROR: wrong packet... non aligned internal structn");
  539.     return -1;
  540.   }
  541. #ifdef DEBUG_MALLOC
  542.   fprintf(stderr, "malloc %d objectsn", counter);
  543. #endif
  544.   return 0;
  545. }
  548. int CheckDoublePacket(RAD_PACKET *rad)
  549. {
  551.  return 0;  /* not implemented yet */
  552. }
  555. void FilterProc(char *user_data, struct pcap_pkthdr *p_header, const char *packet)
  556. {
  557.   unsigned int packet_size = p_header->caplen;
  558.   char *rad_pkt;
  559.   int rad_pkt_len;
  560.   RAD_PACKET RAD;   /* Parsed RADIUS packet struct */
  562.   memset(&RAD, 0, sizeof(RAD));
  563.   
  564.   /* get time incoming packet */
  565.   RAD.time = time(NULL);
  567.   if (packet_size > MAXBUFFER) return;   /* prevent overrun ;) */
  568.   memcpy(&eth_packet, packet, packet_size);
  569.   
  570.   /* fill sockaddr_in */
  571.   RAD.src.sin_family = AF_INET;
  572.   RAD.src.sin_port = UDP_SrcPort (udp);
  573.   memcpy ((void *) &(RAD.src.sin_addr), (void *) &(IP_SrcAddr (ip)),
  574.           sizeof (struct in_addr));
  576.   RAD.dst.sin_family = AF_INET;
  577.   RAD.dst.sin_port = UDP_DstPort (udp);
  578.   memcpy ((void *) &(RAD.dst.sin_addr), (void *) &(IP_DstAddr (ip)),
  579.           sizeof (struct in_addr));
  582.   rad_pkt = (char *)((eth_packet.buff)-2);
  583.   rad_pkt_len = packet_size-sizeof(eth_packet.ip)-sizeof(eth_packet.udp);
  585.   /* check size of received packet and according rfc drop wrong packets */
  586.   if (rad_pkt_len < 20 || rad_pkt_len > 4096) {
  587.     fprintf(stderr, "ERROR: %s:%u > %s:%u  - non RADIUS packet (bad UDP length: %d)n",
  588.             (char *) inet_ntoa(RAD.src.sin_addr), ntohs(RAD.src.sin_port),
  589.             (char *) inet_ntoa(RAD.dst.sin_addr), ntohs(RAD.dst.sin_port),
  590.            rad_pkt_len);
  591.     return;
  592.   }
  593.   
  594.   /* fill radius packet struct */
  595.   RAD.code = *(char *)rad_pkt;
  596.   RAD.ident = *(unsigned char *)(rad_pkt+1);
  597.   RAD.length = ntohs(*(unsigned short *)(rad_pkt+2));
  598.   memcpy(RAD.auth, (char *)(rad_pkt+4), 16);
  599.   RAD.buff_length = RAD.length - 20;     /* without code,ident,length,auth */
  600.   if (RAD.buff_length >= 0 && RAD.buff_length <= 4096 - 20 )
  601.     memcpy(RAD.buff, (char *)(rad_pkt+20), RAD.buff_length);
  602.   else {
  603.     fprintf(stderr, "ERROR: %s:%u > %s:%u  - non RADIUS packet (bad length in packet: %d)n",
  604.             (char *) inet_ntoa(RAD.src.sin_addr), ntohs(RAD.src.sin_port),
  605.             (char *) inet_ntoa(RAD.dst.sin_addr), ntohs(RAD.dst.sin_port),
  606.            RAD.buff_length);
  607.     return;
  608.   }
  611.   if (quiet && CheckDoublePacket(&RAD)) return;
  612.   if (ParseRadiusAttr(&RAD) == 0) OutRadiusPacket(&RAD);
  613.   FreeRadiusPacketStruct(&RAD);
  614.   
  615.   return;
  616. }
  619. void HookProto(void)
  620. {
  621.   ip = (IPHeader *) (((unsigned long) &eth_packet.ip) - 2);
  622.   udp = (UDPHeader *) (((unsigned long) &eth_packet.udp) - 2);
  623. }
  626. pcap_t *OpenPromisc(char *eth, int snaplen, int promisc, int to_ms)
  627. {
  628.   pcap_t *h;
  629.   char ebuf[PCAP_ERRBUF_SIZE];
  631.   h = pcap_open_live(eth, snaplen, promisc, to_ms, ebuf);
  632.   if( !h )
  633.     fprintf(stderr, "ERROR: Can't open interface %s.n%sn", eth, ebuf);
  634.   return h;
  635. }
  638. void ClosePromisc(void)
  639. {
  640.   pcap_close(PCAP);
  641. }
  644. #define MAX_FILTER_STR 4096
  646. int MakeFilter(pcap_t *h, char *eth, unsigned short pradius, unsigned short pradacct, char *filter)
  647. {
  648.   struct bpf_program bpf;
  649.   bpf_u_int32 net, mask;
  650.   char ebuf[PCAP_ERRBUF_SIZE];
  651.   char buf[MAX_FILTER_STR];
  653.   if (pcap_lookupnet(eth, &net, &mask, ebuf) == -1) {
  654.     fprintf(stderr, "ERROR: Can't lookup interface %sn%sn", eth, ebuf);
  655.     return -1;
  656.   }
  658.   snprintf(buf, MAX_FILTER_STR,
  659.            "(udp and (port %d or port %d) %s)",
  660.            ntohs(pradius), ntohs(pradacct), filter);
  662.   if (pcap_compile(h, &bpf, buf, 1, mask) == -1) {
  663.     fprintf(stderr, "ERROR: Can't compile BPF filter '%s'n", buf);
  664.     return -1;
  665.   }
  667.   if (pcap_setfilter(h, &bpf) == -1) {
  668.     fprintf(stderr, "ERROR: Can't set BPF filter '%s'n", buf);
  669.   }
  670.   
  671.   return 0;
  672. }
  675. void Terminate(int signal)
  676. {
  677.   ClosePromisc();
  678.   exit(0);
  679. }
  682. int LoadDictionary(char *fname)
  683. {
  684.   FILE *in;
  685.   char buff[1024];
  686.   int line = 0;
  687.   char attrstr[512], namestr[512], valuestr[512], typestr[512];
  688.   DICT_ATTR dicta, *attr;
  689.   DICT_VALUE dictv, *value;
  690.   
  691.   
  692.   if ((in = fopen(fname,"r")) == NULL) {
  693.     fprintf(stderr, "ERROR: Can't open dictionary file '%s'n", fname);
  694.     return -1;
  695.   }
  697.   while (fgets(buff, sizeof(buff), in) != NULL) {
  698.     line++;
  699.     if (*buff == 0 || *buff == '#' || *buff == 'n') continue;
  700.     if (strncmp(buff, "ATTRIBUTE", 9) == 0) {
  701.       if (sscanf(buff, "%s%s%s%s", attrstr, namestr, valuestr, typestr) != 4) {
  702.         fprintf(stderr, "ERROR: Can't understand ATTRIBUTE on line %dn", line);
  703.         return -1;
  704.       }
  705.       if (strlen(namestr) > 31) {
  706.         fprintf(stderr, "ERROR: Invalid name length on line %dn", line);
  707.         return -1;
  708.       }
  709.       if (!isdigit(*valuestr)) {
  710.         fprintf(stderr, "ERROR: Invalid value on line %dn", line);
  711.         return -1;
  712.       }
  713.       dicta.value = atoi(valuestr);
  715.       if (strcmp(typestr, "string") == 0) dicta.type = RADIUS_ATTR_STR;
  716.       else if (strcmp(typestr, "integer") == 0) dicta.type = RADIUS_ATTR_INT;
  717.       else if (strcmp(typestr, "ipaddr") == 0) dicta.type = RADIUS_ATTR_IPADDR;
  718.       else if (strcmp(typestr, "date") == 0) dicta.type = RADIUS_ATTR_DATE;
  719.       else if (strcmp(typestr, "abinary") == 0) dicta.type = RADIUS_ATTR_ABINARY;
  720.       else {
  721.         fprintf(stderr, "ERROR: Invalid type on line %dn", line);
  722.         return -1;
  723.       }
  724.       if ((dicta.name = malloc(strlen(namestr)+1)) == NULL) {
  725.         fprintf(stderr, "ERROR: Out of memn");
  726.         return -1;
  727.       }
  728.       strncpy(dicta.name, namestr, strlen(namestr)+1);
  729.       
  730.       /* insert new ATTR */
  731.       if ((attr = malloc(sizeof(DICT_ATTR))) == NULL) {
  732.         fprintf(stderr, "ERROR: Out of memn");
  733.         return -1;
  734.       }
  735.       memcpy(attr, &dicta, sizeof(DICT_ATTR));
  736.       attr->next = dictionary_attr;
  737.       dictionary_attr = attr;
  738. #ifdef DEBUG
  739.       fprintf(stderr,"attr: %sn", attr->name);
  740. #endif
  741.     }
  742.     else if (strncmp(buff, "VALUE", 5) == 0) {
  743.       if (sscanf(buff, "%s%s%s%s", typestr, attrstr, namestr, valuestr) != 4) {
  744.         fprintf(stderr, "ERROR: Can't understand VALUE on line %dn", line);
  745.         return -1;
  746.       }
  747.       if (strlen(attrstr) > 31) {
  748.         fprintf(stderr, "ERROR: Invalid attribute length on line %dn", line);
  749.         return -1;
  750.       }
  751.       if (strlen(namestr) > 31) {
  752.         fprintf(stderr, "ERROR: Invalid name length on line %dn", line);
  753.         return -1;
  754.       }
  755.       if (!isdigit(*valuestr)) {
  756.         fprintf(stderr, "ERROR: Invalid value on line %dn", line);
  757.         return -1;
  758.       }
  759.       dictv.value = atoi(valuestr);
  761.       if ((dictv.name = malloc(strlen(namestr)+1)) == NULL) {
  762.         fprintf(stderr, "ERROR: Out of memn");
  763.         return -1;
  764.       }
  765.       strncpy(dictv.name, namestr, strlen(namestr)+1);
  767.       if ((dictv.attrname = malloc(strlen(attrstr)+1)) == NULL) {
  768.         fprintf(stderr, "ERROR: Out of memn");
  769.         return -1;
  770.       }
  771.       strncpy(dictv.attrname, attrstr, strlen(attrstr)+1);
  773.       /* insert net VALUE */
  774.       if ((value = malloc(sizeof(DICT_VALUE))) == NULL) {
  775.         fprintf(stderr, "ERROR: Out of memn");
  776.         return -1;
  777.       }
  778.       memcpy(value, &dictv, sizeof(DICT_VALUE));
  779.       value->next = dictionary_value;
  780.       dictionary_value = value;
  781. #ifdef DEBUG
  782.       fprintf(stderr,"valu: %s (attr:%s)n", value->name, value->attrname);
  783. #endif
  784.     }
  785.   }
  786.   fclose(in);
  787.   return 0;
  788. }
  791. int LoadClients(char *fname)
  792. {
  793.   FILE *in = fopen(fname,"r");
  794.   char buff[1024];
  795.   CLIENTS host, *ins_host;
  796.   int line = 0;
  797.   char ip[128], sec[512];
  799.   if (in == NULL) {
  800.     fprintf(stderr, "ERROR: Can't open clients file '%s'n", fname);
  801.     return -1;
  802.   }
  804.   while (fgets(buff, sizeof(buff), in) != NULL) {
  805.     line++;
  806.     if (*buff == 0 || *buff == '#' || *buff == 'n') continue;
  807.     if (sscanf(buff, "%s%s", ip, sec) != 2) {
  808.       fprintf(stderr, "ERROR: Can't understand line %dn", line);
  809.       return -1;
  810.     }
  811.     
  812.     if (inet_aton(ip,&host.ipaddr) == 0) {
  813.       fprintf(stderr, "ERROR: Can't convert ip addr on line %dn", line);
  814.       return -1;
  815.     }
  817.     if (sizeof(host.secret) < strlen(sec)) {
  818.       fprintf(stderr, "ERROR: Too long secret on line %dn", line);
  819.       return -1;
  820.     }
  821.     memcpy(host.secret,sec,strlen(sec)+1);
  823.     /* insert new client secret password here */
  824.     if ((ins_host = malloc(sizeof(CLIENTS))) == NULL) {
  825.       fprintf(stderr, "ERROR: Out of memn");
  826.       return -1;
  827.     }
  828.     memcpy(ins_host, &host, sizeof(CLIENTS));
  829.     ins_host->next = secret_clients;
  830.     secret_clients = ins_host;
  831.   }
  833.   fclose(in);
  834.   return 0;
  835. }
  838. int main(int argc, char *argv[])
  839. {
  840.   char *filter = "";
  841.   char ebuf[PCAP_ERRBUF_SIZE];
  842.   char *eth = NULL;
  843.   int arg, error = 0;
  844.   struct servent *serv_ent;
  845.   unsigned short radius_port, radacct_port;
  847.   /*
  848.    fprintf(stderr, "eth_packet size: %dn", sizeof(eth_packet));
  849.    */
  851.   
  852.   while ((arg = getopt(argc, argv, "Vavri:f:d:c:qp:")) != -1) {
  853.     switch( arg ) {
  854.     case 'v':    /* be verbose */
  855.       verbose++;
  856.       break;
  857.     case 'i':    /* set interface name */
  858.       eth = strdup(optarg);
  859.       break;
  860.     case 'f':    /* pcap filter expression */
  861.       filter = strdup(optarg);
  862.       break;
  863.     case 'r':    /* resolve hostnames */
  864.       resolve++;
  865.       break;
  866.     case 'd':    /* set dictonary */
  867.       dict_filename = strdup(optarg);
  868.       break;
  869.     case 'c':    /* place where i can get secret passwords */
  870.       clients_filename = strdup(optarg);
  871.       break;
  872.     case 's':    /* there u can define default secret password */
  873.       secret_passwd = strdup(optarg);
  874.       break;
  875.     case 'q':    /* quiet output */
  876.       quiet++;
  877.       break;
  878.     case 'a':    /* output accounting info only */
  879.       account++;
  880.       break;
  881.     case 'V':
  882.       fprintf(stderr, "RADIUS sNIFFer by FreeLSD. Version %sn", VERSION);
  883.       fprintf(stderr, "http://www.freelsd.net/securityn");
  884.       exit(0);
  885.     default:
  886.       error++;
  887.       break;
  888.     }
  889.   }
  890.   
  891.   if (error) {
  892.     fprintf(stderr, "Usage: radiusniff [-vVrqa] [-i interface] [-f expression]n");
  893.     fprintf(stderr, "                  [-d dictionary ] [-c clients] [-s passwd]n");
  894.     exit(1);
  895.   }
  897.   if (!eth) {
  898.     if (!(eth = pcap_lookupdev(ebuf))) {
  899.       fprintf(stderr, "ERROR: Can't find device for sniffing.n%sn",ebuf);
  900.       exit(1);
  901.     }
  902.   }
  904.   if (access(dict_filename, R_OK) != 0) {
  905.     fprintf(stderr, "ERROR: Can't access to dictonary file '%s'n", dict_filename);
  906.     exit(1);
  907.   }
  908.   if (LoadDictionary(dict_filename) != 0) exit(1);
  910.   if (clients_filename) {
  911.     if (access(clients_filename, R_OK) != 0) {
  912.       fprintf(stderr, "ERROR: Can't access to clients file '%s', ignored...n", clients_filename);
  913.       clients_filename = NULL;
  914.     } else if (LoadClients(clients_filename) != 0) exit(1);
  915.   }
  916.   
  917.   HookProto();
  918.   signal(SIGINT, Terminate);
  919.   signal(SIGTERM, Terminate);
  920.   signal(SIGKILL, Terminate);
  921.   signal(SIGQUIT, Terminate);
  922.   
  923.   serv_ent = getservbyname("radius","udp");
  924.   serv_ent ? (radius_port = serv_ent->s_port) : (radius_port = htons(1645));
  925.   serv_ent = getservbyname("radacct","udp");
  926.   serv_ent ? (radacct_port = serv_ent->s_port) : (radacct_port = htons(1646));
  928.   if (!(PCAP = OpenPromisc(eth, 10000, 1, 0))) exit(1);
  929.   if (MakeFilter(PCAP, eth, radius_port, radacct_port, filter) != 0) exit(1);
  931.   /* Let's make STDOUT line buffered */
  932.   setlinebuf(stdout);
  934.   /* start main loop */
  935.   pcap_loop(PCAP, -1, (void *)FilterProc, NULL);
  936.   
  937.   ClosePromisc();
  938. }