home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / w00w00 / misc / dnslog.c next >
Encoding:
C/C++ Source or Header  |  1998-08-13  |  11.5 KB  |  600 lines
  1. #include <errno.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <stdarg.h>
  5. #include <strings.h>
  6. #include <sys/types.h>
  7. #include <sys/fcntl.h>
  8. #include <sys/socket.h>
  9. #include <netinet/in.h>
  10.  
  11.  
  12. #define DC_A     1
  13. #define DC_NS    2
  14. #define DC_CNAME 5
  15. #define DC_SOA   6
  16. #define DC_WKS   11
  17. #define DC_PTR   12
  18. #define DC_HINFO 13
  19. #define DC_MINFO 14
  20. #define DC_MX    15
  21. #define DC_TXT   16
  22.  
  23. #define ERROR      -1
  24. #define MAXBUFSIZE 64*1024
  25.  
  26. typedef struct {
  27.   unsigned short id;
  28.  
  29.   unsigned char  rd:1;           /* recursion desired                      */
  30.   unsigned char  tc:1;           /* truncated message                      */
  31.   unsigned char  aa:1;           /* authoritive answer                     */
  32.   unsigned char  opcode:4;       /* purpose of message                     */
  33.   unsigned char  qr:1;           /* response flag                          */
  34.  
  35.   unsigned char  rcode:4;        /* response code                          */
  36.   unsigned char  unused:2;       /* unused bits                            */
  37.   unsigned char  pr:1;           /* primary server required (non standard) */
  38.   unsigned char  ra:1;           /* recursion available                    */
  39.  
  40.   unsigned short qdcount;
  41.   unsigned short ancount;
  42.   unsigned short nscount;
  43.   unsigned short arcount;
  44. } dnsheaderrec;
  45.  
  46. typedef struct {
  47.   char buf[256];
  48.   char label[256];
  49.  
  50.   unsigned long  ttl;
  51.   unsigned short type;
  52.   unsigned short class;
  53.   unsigned short buflen;
  54.   unsigned short labellen;
  55. } dnsrrrec;
  56.  
  57. typedef struct {
  58.   dnsheaderrec h;
  59.  
  60.   dnsrrrec qd[20];
  61.   dnsrrrec an[20];
  62.   dnsrrrec ns[20];
  63.   dnsrrrec ar[20];
  64.  
  65. } dnsrec;
  66.  
  67. char *dnssprintflabel(char *s, char *buf, char *p);
  68. char *dnsaddlabel(char *p, char *label);
  69. void  dnstxt2rr(dnsrrrec *rr, char *b);
  70. void  dnsbuildpacket(dnsrec *dns, short qdcount, short ancount, 
  71.              short nscount, short arcount, ...);
  72. char *dnsaddbuf(char *p, void *buf, short len);
  73. int   dnsmakerawpacket(dnsrec *dns, char *buf);
  74. char *ip_to_arpa(char *ip);
  75. char *arparize(char *ip);
  76. char *get_token(char **src, char *token_sep);
  77.  
  78. char *dnssprintflabel(char *s, char *buf, char *p)
  79. {
  80.   unsigned short i,len;
  81.   char *b = NULL;
  82.  
  83.   len = (unsigned short) *(p++);
  84.  
  85.   while (len) {
  86.     while (len >= 0xC0) {
  87.       if (!b) b = p + 1;
  88.  
  89.       p   = buf + (ntohs(*((unsigned short *)(p-1))) & ~0xC000);
  90.       len = (unsigned short) *(p++);
  91.     }
  92.  
  93.     for (i = 0; i< len; i++) *(s++)=*(p++);
  94.  
  95.     *(s++)='.';
  96.  
  97.     len = (unsigned short) *(p++);
  98.   }
  99.  
  100.   *(s++) = 0;
  101.  
  102.   if (b)
  103.     return(b);
  104.  
  105.   return(p);
  106. }
  107.  
  108. char *dnsaddlabel(char *p, char *label)
  109. {
  110.   char *p1;
  111.  
  112.   while ((*label) && (label)) {
  113.     if ((*label == '.') && (!*(label+1)))
  114.       break;
  115.  
  116.     p1 = strchr(label,'.');
  117.  
  118.     if (!p1)
  119.       p1 = strchr(label,0);
  120.  
  121.     *(p++) = p1 - label;
  122.     memcpy(p, label, p1 - label);
  123.     p += p1 - label;
  124.  
  125.     label = p1;
  126.  
  127.     if (*p1)
  128.       label++;
  129.   }
  130.   *(p++)=0;
  131.  
  132.   return(p);
  133. }
  134.  
  135. #define DEFAULTTTL 60*10
  136.  
  137. void dnstxt2rr(dnsrrrec *rr, char *b)
  138. {
  139.   char *tok[20], *p;
  140.   unsigned short numt=0, i;
  141.   static char *buf=NULL;
  142.  
  143.   if (!buf) {
  144.     if ((buf = malloc(1024)) == NULL) {
  145.       perror("malloc");
  146.       exit(ERROR);
  147.     }
  148.   }
  149.  
  150.   strncpy(buf, b, sizeof(buf)); 
  151.  
  152.   p = strtok(buf," \t");
  153.  
  154.   do {
  155.     tok[numt++] = p;
  156.   } while (p = strtok(NULL," \t"));
  157.  
  158.   p = dnsaddlabel(rr->label,tok[0]);
  159.   rr->labellen = p-rr->label;
  160.  
  161.   i = 1;
  162.  
  163.   if (isdigit(*p)) rr->ttl=htonl(atol(tok[i++]));
  164.   else rr->ttl=htonl(DEFAULTTTL);
  165.  
  166.   if (strcmp(tok[i], "IN") == 0) i++;
  167.  
  168.   rr->class = htons(1);
  169.  
  170.   if (strcmp(tok[i], "A") == 0) {
  171.     i++;
  172.  
  173.     rr->type = htons(DC_A);
  174.  
  175.     if (i < numt) {
  176.        inet_aton(tok[i], rr->buf);
  177.        rr->buflen = 4;
  178.     } else
  179.        rr->buflen = 0;
  180.  
  181.     return;
  182.   }
  183.  
  184.   if (strcmp(tok[i], "CNAME") == 0) {
  185.     i++;
  186.  
  187.     rr->type = htons(DC_CNAME);
  188.  
  189.     if (i < numt) {
  190.       p = dnsaddlabel(rr->buf, tok[i]);
  191.       rr->buflen = p-rr->buf;
  192.     } else
  193.       rr->buflen=0;
  194.  
  195.     return;
  196.   }
  197.  
  198.   if (strcmp(tok[i], "NS") == 0) {
  199.     i++;
  200.  
  201.     rr->type=htons(DC_NS);
  202.  
  203.     if (i < numt) {
  204.       p = dnsaddlabel(rr->buf,tok[i]);
  205.       rr->buflen = p-rr->buf;
  206.     } else
  207.       rr->buflen = 0;
  208.     return;
  209.   }
  210.  
  211.   if (strcmp(tok[i], "PTR") == 0) {
  212.     i++;
  213.  
  214.     rr->type = htons(DC_PTR);
  215.  
  216.     if (i < numt) {
  217.       p = dnsaddlabel(rr->buf,tok[i]);
  218.       rr->buflen = p-rr->buf;
  219.     } else
  220.       rr->buflen=0;
  221.  
  222.     return;
  223.   }
  224.  
  225.   if (strcmp(tok[i], "MX") == 0) {
  226.     i++;
  227.     rr->type = htons(DC_MX);
  228.  
  229.     if (i < numt) {
  230.       p = rr->buf;
  231.  
  232.       *((unsigned short *)p) = htons(atoi(tok[i++])); 
  233.  
  234.       p += 2;
  235.       p = dnsaddlabel(p, tok[i]);
  236.  
  237.       rr->buflen = p-rr->buf;
  238.     } else
  239.       rr->buflen = 0;
  240.  
  241.     return;
  242.   }
  243. }
  244.  
  245. void dnsbuildpacket(dnsrec *dns, short qdcount, short ancount, short nscount, short arcount, ...)
  246. {
  247.   int i;
  248.   va_list va;
  249.  
  250.   dns->h.qdcount = htons(qdcount);
  251.   dns->h.ancount = htons(ancount);
  252.   dns->h.nscount = htons(nscount);
  253.   dns->h.arcount = htons(arcount);
  254.   dns->h.rcode   = 0;
  255.  
  256.   va_start(va, arcount);
  257.  
  258.   for (i=0; i < qdcount; i++)
  259.     dnstxt2rr(&dns->qd[i], va_arg(va, char *));
  260.  
  261.   for (i=0; i < ancount; i++)
  262.     dnstxt2rr(&dns->an[i],va_arg(va, char *));
  263.  
  264.   for (i=0; i < nscount; i++)
  265.     dnstxt2rr(&dns->ns[i], va_arg(va, char *));
  266.  
  267.   for (i=0; i < arcount; i++)
  268.     dnstxt2rr(&dns->ar[i], va_arg(va, char *));
  269.  
  270.  
  271.   va_end(va);
  272. }
  273.  
  274. char *dnsaddbuf(char *p, void *buf, short len)
  275. {
  276.   memcpy(p,buf,len);
  277.   return(p+len);
  278. }
  279.  
  280. int dnsmakerawpacket(dnsrec *dns, char *buf)
  281. {
  282.   int i;
  283.   char *p;
  284.   unsigned short len;
  285.  
  286.   memcpy(buf, &dns->h, sizeof(dnsheaderrec));
  287.  
  288.   p = buf+sizeof(dnsheaderrec);
  289.  
  290.   /********** Query ***********/
  291.   for (i=0; i < ntohs(dns->h.qdcount); i++) {
  292.     p = dnsaddbuf(p, dns->qd[i].label,  dns->qd[i].labellen);
  293.     p = dnsaddbuf(p, &dns->qd[i].type,  2);
  294.     p = dnsaddbuf(p, &dns->qd[i].class, 2);
  295.   }
  296.  
  297.   /********** Answer ***********/
  298.   for (i=0; i < ntohs(dns->h.ancount); i++) {
  299.     p   = dnsaddbuf(p,  dns->an[i].label, dns->an[i].labellen);
  300.     p   = dnsaddbuf(p, &dns->an[i].type,  2);
  301.     p   = dnsaddbuf(p, &dns->an[i].class, 2);
  302.     p   = dnsaddbuf(p, &dns->an[i].ttl,   4);
  303.  
  304.     len = htons(dns->an[i].buflen);
  305.  
  306.     p   = dnsaddbuf(p, &len, 2);
  307.     p   = dnsaddbuf(p, dns->an[i].buf, dns->an[i].buflen);
  308.   }
  309.  
  310.   /********** Nameservers ************/
  311.   for (i=0; i < ntohs(dns->h.nscount); i++) {
  312.     p  = dnsaddbuf(p, dns->ns[i].label,  dns->ns[i].labellen);
  313.     p  = dnsaddbuf(p, &dns->ns[i].type,  2);
  314.     p  = dnsaddbuf(p, &dns->ns[i].class, 2);
  315.     p  = dnsaddbuf(p, &dns->ns[i].ttl,   4);
  316.  
  317.     len = htons(dns->ns[i].buflen);
  318.     p   = dnsaddbuf(p,&len,2);
  319.     p   = dnsaddbuf(p,dns->ns[i].buf,dns->ns[i].buflen);
  320.   }
  321.  
  322.   /********** Additional ************/
  323.   for (i=0; i < ntohs(dns->h.arcount); i++) {
  324.      p   = dnsaddbuf(p,dns->ar[i].label,  dns->ar[i].labellen);
  325.      p   = dnsaddbuf(p,&dns->ar[i].type,  2);
  326.      p   = dnsaddbuf(p,&dns->ar[i].class, 2);
  327.      p   = dnsaddbuf(p,&dns->ar[i].ttl,   4);
  328.  
  329.      len = htons(dns->ar[i].buflen);
  330.  
  331.      p  = dnsaddbuf(p, &len, 2);
  332.      p  = dnsaddbuf(p, dns->ar[i].buf, dns->ar[i].buflen);
  333.   }
  334.  
  335.   return(p-buf);
  336. }
  337.  
  338.  
  339. char *get_token(src, token_sep)
  340. char **src;
  341. char *token_sep;
  342. {
  343.   char    *tok;
  344.  
  345.   if (!(src && *src && **src))
  346.     return NULL;
  347.  
  348.   while(**src && strchr(token_sep, **src)) (*src)++;
  349.  
  350.   if(**src)
  351.     tok = *src;
  352.   else
  353.     return NULL;
  354.  
  355.   *src = strpbrk(*src, token_sep);
  356.  
  357.   if (*src) {
  358.     **src = '\0';
  359.     (*src)++;
  360.     while(**src && strchr(token_sep, **src)) (*src)++;
  361.   } else
  362.     *src = "";
  363.  
  364.   return tok;
  365. }
  366.  
  367. char *ip_to_arpa(char *ip)
  368. {
  369.   char *arpablock, *bit_a, *bit_b, *bit_c;
  370.   char *oomf;
  371.  
  372.   arpablock = NULL;
  373.   arpablock = (char *)malloc(64);
  374.   oomf = (char *)malloc(64);
  375.  
  376.   strncpy(oomf, ip, sizeof(oomf));
  377.  
  378.   bit_a = get_token(&oomf, ".");
  379.   bit_b = get_token(&oomf, ".");
  380.   bit_c = get_token(&oomf, ".");
  381.     
  382.   sprintf(arpablock, "%s.%s.%s.in-addr.arpa", bit_c, bit_b, bit_a);
  383.  
  384.   return arpablock;
  385.  
  386. }
  387.  
  388. char *arparize(char *ip)
  389. {
  390.   char *arpa, *bit_a, *bit_b, *bit_c, *bit_d;
  391.   char *oomf;
  392.  
  393.   arpa = NULL;
  394.   arpa = (char *)malloc(64);
  395.   oomf = (char *)malloc(64);
  396.  
  397.   strncpy(oomf, ip, sizeof(oomf));
  398.  
  399.   bit_a = get_token(&oomf, ".");
  400.   bit_b = get_token(&oomf, ".");
  401.   bit_c = get_token(&oomf, ".");
  402.   bit_d = oomf;
  403.     
  404.   sprintf(arpa, "%s.%s.%s.%s.in-addr.arpa", bit_d, bit_c, bit_b, bit_a);
  405.  
  406.   return arpa;
  407.  
  408. }
  409.  
  410.  
  411. char* printrr(char* rrptr,char* packet,char qd)
  412. {
  413.   char *p, *p2;
  414.   char buf[MAXBUFSIZE];
  415.  
  416.   unsigned long ttl;
  417.   unsigned short type, class, len;
  418.  
  419.   p    = dnssprintflabel(buf, packet+28, rrptr);
  420.   type = ntohs(*(unsigned short*)p);
  421.  
  422.   p += 2;
  423.   class = ntohs(*(unsigned short*)p);
  424.   p += 2;
  425.   
  426.   printf("%s ", buf);
  427.  
  428.   switch (class) {
  429.     case 1:
  430.            printf("IN ");
  431.            break;
  432.   
  433.                     
  434.     default:
  435.            printf("%i? ",class);
  436.   }
  437.  
  438.   switch (type) {
  439.     case DC_A:
  440.                 printf("A ");
  441.                 break;
  442.     case DC_CNAME:
  443.                 printf("CNAME ");
  444.             break;
  445.     case DC_NS:
  446.                 printf("NS ");
  447.             break;
  448.     case DC_PTR:
  449.                 printf("PTR ");
  450.             break;
  451.     case DC_MX:
  452.                 printf("MX ");
  453.             break;    
  454.               
  455.     default:
  456.                 printf("%i? ", type);
  457.   }
  458.  
  459.   if (qd) return p;
  460.   
  461.   ttl = ntohl(*(unsigned long *)p);
  462.   p  += 4;
  463.  
  464.   len = ntohs(*(unsigned short *)p);
  465.   p += 2;
  466.   
  467.   switch (type) {
  468.   
  469.     case DC_A:
  470.              if (len != 4) {
  471.                 printf("(length error) ");
  472.                 break;
  473.              }
  474.  
  475.              printf("%s ", (char *)inet_ntoa(*(struct in_addr*)p));
  476.              break;
  477.            
  478.     case DC_PTR:
  479.     case DC_NS:
  480.     case DC_CNAME:
  481.             p2 = dnssprintflabel(buf, packet+28, p);
  482.  
  483.             if (p2 != (p+len)) 
  484.                    printf("(length error) ");
  485.  
  486.             printf("%s ", buf);       
  487.  
  488.             break;
  489.     
  490.     
  491.     default:
  492.                 printf("?? ");
  493.   }
  494.  
  495.   printf("(ttl=%lu)\n", ttl);
  496.   
  497.   
  498.   return (p+len);
  499.  
  500. }
  501.  
  502.  
  503.  
  504.  
  505. void main(int argc, char **argv)
  506. {
  507.   char buf[MAXBUFSIZE];
  508.   char packet[MAXBUFSIZE];
  509.  
  510.   int rr;
  511.   int fd;
  512.   int fromlen; 
  513.   int numread; 
  514.   int raw_udp;
  515.   int nbpaket, maxpaket = 9999;
  516.  
  517.   char *rrptr; 
  518.   char fname[256];
  519.  
  520.   dnsrec *dns;
  521.  
  522.   struct sockaddr_in from;
  523.   unsigned short qdnb, annb, nsnb, arnb, id;
  524.  
  525.   printf("w00w00!\n");
  526.     
  527.   dns = (dnsrec *)(packet+20+8);
  528.  
  529.   if (argc > 2) maxpaket = atoi(argv[1]);
  530.  
  531.   if ((raw_udp = socket(AF_INET, SOCK_RAW, IPPROTO_UDP)) < 0) {
  532.      perror("socket");
  533.      exit(ERROR);
  534.   }
  535.  
  536.  
  537.   nbpaket = 0;
  538.   while (nbpaket < maxpaket) {
  539.  
  540.     fromlen=sizeof(from);
  541.  
  542.     if ((numread = recvfrom(raw_udp, packet, MAXBUFSIZE, 0, (struct sockaddr *)&from, &fromlen)) < 0) {
  543.       perror("recvfrom");
  544.       continue;
  545.     }
  546.  
  547.     nbpaket++;
  548.     
  549.     id = ntohs(dns->h.id);
  550.     
  551.     strncpy(fname, (char*)inet_ntoa(from.sin_addr), sizeof(fname));
  552.     printf("%i bytes received from %s\n", numread,fname);
  553.  
  554.     
  555.     if (dns->h.qr) sprintf(buf, "response.%s.%i", fname, id);
  556.     else sprintf(buf, "question.%s.%i", fname, id);
  557.  
  558.     if ((fd = open(buf, O_WRONLY | O_CREAT | O_APPEND)) == ERROR) {
  559.     perror("open");
  560.     exit(ERROR);
  561.     }
  562.  
  563.     if ((write(fd,packet,numread)) == ERROR) {
  564.     perror("write");
  565.         close(fd);
  566.     exit(ERROR);
  567.     }
  568.  
  569.     close(fd);
  570.     
  571.     qdnb = ntohs(dns->h.qdcount);
  572.     annb = ntohs(dns->h.ancount);
  573.     nsnb = ntohs(dns->h.nscount);
  574.     arnb = ntohs(dns->h.arcount);
  575.     
  576.     printf("ID=%i, response=%i\n", id, dns->h.qr);
  577.     printf("%i questions, %i answers, %i authoritatives, %i infos\n",
  578.             qdnb, annb, nsnb, arnb);
  579.  
  580.     rrptr = (char*)(&(dns->qd[rr]));
  581.  
  582.     for (rr = 0; rr < qdnb; rr++) {
  583.       rrptr = printrr(rrptr, packet, 1);
  584.       printf("\n");
  585.     }
  586.  
  587.     for (rr=0; rr < annb; rr++)
  588.       rrptr = printrr(rrptr, packet, 0);
  589.  
  590.     for (rr=0; rr < nsnb; rr++) 
  591.       rrptr = printrr(rrptr, packet, 0);
  592.  
  593.     for (rr=0; rr < arnb; rr++)
  594.       rrptr = printrr(rrptr, packet, 0);
  595.     
  596.     printf("\n");  
  597.    
  598.   }
  599. }
  600.