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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
www_funcs.c
资源名称：nessus-libraries_2.2.10.orig.tar.gz　[点击查看]
上传用户：tjescc
上传日期：2021-02-23
资源大小：419k
文件大小：16k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

www_funcs.c：源码内容
  1. /* Copyright (C) 1998 - 2003 Renaud Deraison
  2.  * Portions (C)  2002 - 2003 Michel Arboi
  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 version 2,
  6.  * as published by the Free Software Foundation
  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  16.  *
  17.  */
  19. #define EXPORTING
  20. #include <includes.h>
  23. /*
  24.  * This function implements "whisker like" IDS evasion tactics plus a couple
  25.  * of other methods.
  26.  * Read http://www.wiretrip.net/rfp/pages/whitepapers/whiskerids.html
  27.  *
  28.  * Note: RFP is not responsible for the bugs here. I (Michel Arboi) wrote it!
  29.  *
  30.  * 2002-02-26: added Pavel kankovsky's "absolute URI"
  31.  * 2002-03-06: added "CGI.pm parameters" by Noam Rathaus from securiteam.com
  32.  * Partial support: we should changed & to ; in the "posted" data.
  33.  * 2002-05-29: added "protocol string". See Alla Bezroutchko's message on 
  34.  * VULN-DEV (Date: 15 Feb 2002; From: <alla@scanit.be>;
  35.  * Subject: Possible IDS-evasion technique
  36.  * Message-ID: <3C6D434B.4377034A@scanit.be>)
  37.  */
  39. /* TBD
  40.  * Pollute Apache logs with this:
  42. To make a request and to make it seem like it came from NO IP ADDRESS at
  43. all, the request should be made as this :
  45. GET / HTTP/1.0 rrn
  47. In this case APACHE will print in the log file the carriage return
  48. character. So when we try to tail the access_log file it will be shown in
  49. the screen as :
  51. " 414 3461.251 - - [24/Oct/2001:18:58:18 +0100] "GET / HTTP/1.0
  53. A normal line would be :
  55. 127.0.0.1 - - [24/Oct/2001:19:00:32 +0100] "GET / HTTP/1.0" 200 164
  57. The normal line output will help us to understand that what happens is cat
  58. made a carriage return after the HTTP/1.0 and printed the rest of the log
  59. over the Ip Address field.
  60. We can also make it look like the request came from another Ip address, and
  61. this is preferable because like this the SysAdmin will see no apparent
  62. strange behaviour in the logfile. Just be carefull with the timestamp !!
  63. So the request should be :
  65. GET / HTTP/1.0 r10.0.0.1 - - [24/Oct/2001:19:00:32 +0100] "GET /
  66. HTTP/1.0rn
  68. And the logfile will appear like this :
  70. 10.0.0.1 - - [24/Oct/2001:19:00:32 +0100] "GET / HTTP/1.0" 200 164
  72. This is a perfect log entry and nobody can suspect on it :-)
  74. */
  76. char *
  77. build_encode_URL(data, method, path, name, httpver)
  78.  struct arglist * data;
  79.  char *method, *path, *name, *httpver;
  80. {
  81.   int i, l = 0, n_slash = 0, n_backslash = 0, start_with_slash = 0;
  82.   char *ret, *ret2;
  83.   /* NIDS evasion options */
  84.   char *s, *s2;
  85.   int double_slash, reverse_traversal, self_ref_dir;
  86.   int prem_req_end, param_hiding, cgipm_param;
  87.   int dos_win_syntax, null_method, tab_sep, http09;
  88.   char *abs_URI_type, *abs_URI_host;
  89.   char sep_c;
  90. #define URL_CODE_NONE 0
  91. #define URL_CODE_HEX 1
  92. #define URL_CODE_UTF16 2
  93. #define URL_CODE_UTF16MS 3
  94. #define URL_CODE_UTF8BAD 4
  95.   int url_encoding;
  96.   char gizmo[32];
  97.   struct kb_item ** kb = plug_get_kb(data);
  99.   /* 
  100.    * basically, we need to store the path, a slash, and the name 
  101.    * Encoding will expand this
  102.    * We'll add the method in front of all this and the HTTP version 
  103.    * at the end when all is done. That's not optimized, but that's simpler
  104.    */
  105.   l = path !=  NULL ? strlen(path) : 0;
  106.   l += strlen(name) + (path != NULL);
  108.   ret = emalloc(l+ 1);
  109.   if (path == NULL)
  110.     strcpy(ret, name);
  111.   else
  112.     sprintf(ret, "%s/%s", path, name);
  114. #ifdef URL_DEBUG
  115.   fprintf(stderr, "Request => %sn", ret);
  116. #endif
  118.   for (s = ret; *s != ''; s ++)
  119.     if (*s == '/')
  120.       n_slash ++;
  121.     else if (*s == '\')
  122.       n_backslash ++;
  124.   start_with_slash = (*ret == '/');
  126.   s = kb_item_get_str(kb, "NIDS/HTTP/CGIpm_param");
  127.   cgipm_param = (s != NULL && strcmp(s, "yes") == 0);
  128.   if (cgipm_param)
  129.     {
  130. #ifdef URL_DEBUG
  131.       i = 0;
  132. #endif
  133.       for (s = ret; *s != '' && *s != '?'; s ++)
  134. ;
  135.       if (*s == '?')
  136. for (; *s != ''; s ++)
  137.   if (*s == '&')
  138.     {
  139.       *s = ';';
  140. #ifdef URL_DEBUG
  141.       i ++;
  142. #endif
  143.     }
  144. #ifdef URL_DEBUG
  145.       if (i > 0)
  146. fprintf(stderr, "Request =  %sn", ret);
  147. #endif
  148.     }
  150.   s = kb_item_get_str(kb, "NIDS/HTTP/self_ref_dir");
  151.   self_ref_dir = (s != NULL && strcmp(s, "yes") == 0);
  152.   if (self_ref_dir)
  153.     {
  154.       l += 2 * n_slash;
  155.       ret2 = emalloc(l + 1);
  156.       for (s = ret, s2 = ret2; *s != '' && *s != '?'; s ++)
  157. if (*s != '/')
  158.   *s2++ = *s;
  159. else
  160.   {
  161.     strcpy(s2, "/./");
  162.     s2 += 3;
  163.   }
  164.       while (*s != '')
  165. *s2++ = *s++;
  166.       *s2 = '';
  167.       efree(&ret);
  168.       ret = ret2;
  169.       n_slash *= 2;
  170. #ifdef URL_DEBUG
  171.       fprintf(stderr, "Request =  %sn", ret);
  172. #endif
  173.     }
  175.   s = kb_item_get_str(kb, "NIDS/HTTP/reverse_traversal");
  176.   reverse_traversal = (s == NULL ? 0 : atoi(s));
  178.   if (reverse_traversal > 0)
  179.     {
  180.       l += (reverse_traversal + 4)  * n_slash;
  181.       ret2 = emalloc(l + 1);
  183.       for (s = ret, s2 = ret2; *s != '' && *s != '?'; s ++)
  184. if (*s != '/')
  185.   *s2++ = *s;
  186. else
  187.   {
  188.     *s2++ = '/';
  189.     for (i = reverse_traversal; i > 0; i --) 
  190.       *s2++ = lrand48() % 26 + 'a';
  191.     strcpy(s2, "/../");
  192.     s2 += 4;
  193.   }
  194.       while (*s != '')
  195. *s2++ = *s++;
  196.       *s2 = '';
  197.       efree(&ret);
  198.       ret = ret2;
  199.       n_slash *= 3;
  200. #ifdef URL_DEBUG
  201.       fprintf(stderr, "Request =  %sn", ret);
  202. #endif
  203.     }
  205.   s = kb_item_get_str(kb, "NIDS/HTTP/premature_request_ending");
  206.   prem_req_end = (s != NULL && strcmp(s, "yes") == 0);
  207.   if (prem_req_end)
  208.     {
  209.       l += 36;
  210.       ret2 = emalloc(l + 1);
  211.       n_slash += 4;
  212.       
  213.       s = gizmo;
  214.       *s++ = lrand48() % 26 + 'A';
  215.       for (i = 1; i < 8; i ++)
  216. *s++ = lrand48() % 26 + 'a';
  217.       *s++ = '';
  218.       sprintf(ret2, "/%%20HTTP/1.0%%0d%%0a%s:%%20/../..%s", gizmo, ret);
  219.       efree(&ret);
  220.       ret = ret2;
  221. #ifdef URL_DEBUG
  222.       fprintf(stderr, "Request =  %sn", ret);
  223. #endif
  224.     }
  225.   
  226.   s = kb_item_get_str(kb, "NIDS/HTTP/param_hiding");
  227.   param_hiding = (s != NULL && strcmp(s, "yes") == 0);
  228.   if (param_hiding)
  229.     {
  230.       l += 25;
  231.       ret2 = emalloc(l + 1);
  232.       n_slash += 2;
  233.       
  234.       s = gizmo;
  235.       for (i = 0; i < 8; i ++)
  236. *s++ = lrand48() % 26 + 'a';
  237.       *s++ = '';
  238.       sprintf(ret2, "/index.htm%%3f%s=/..%s", gizmo, ret);
  239.       efree(&ret);
  240.       ret = ret2;
  241. #ifdef URL_DEBUG
  242.       fprintf(stderr, "Request =  %sn", ret);
  243. #endif
  244.     }
  246.   s = kb_item_get_str(kb, "NIDS/HTTP/double_slash");
  247.   double_slash = (s != NULL && strcmp(s, "yes") == 0);
  248.   if (double_slash)
  249.     {
  250.       l += n_slash;
  251.       
  252.       ret2 = emalloc(l + 1);
  253.       for (s = ret, s2 = ret2; *s != '' && *s != '?'; s ++)
  254. if (*s != '/')
  255.   *s2++ = *s;
  256. else
  257.   {
  258.     *s2++ = '/';
  259.     *s2++ = '/';
  260.   }
  261.       while (*s != '')
  262. *s2++ = *s++;
  263.       *s2 = '';
  264.       efree(&ret);
  265.       ret = ret2;
  266.       n_slash *= 2;
  267. #ifdef URL_DEBUG
  268.       fprintf(stderr, "Request =  %sn", ret);
  269. #endif
  270.     }
  272.   s = kb_item_get_str(kb, "NIDS/HTTP/dos_win_syntax");
  273.   dos_win_syntax = (s != NULL && strcmp(s, "yes") == 0);
  274.   if (dos_win_syntax)
  275.     {
  276.       for (s = ret + 1; *s != '' && *s != '?'; s ++)
  277. if (*s == '/')
  278.   {
  279.     *s = '\';
  280.     n_backslash ++;
  281.   }
  282. #ifdef URL_DEBUG
  283.       fprintf(stderr, "Request =  %sn", ret);
  284. #endif
  285.     }
  287.   s = kb_item_get_str(kb, "NIDS/HTTP/URL_encoding");
  288.   url_encoding = URL_CODE_NONE;
  289.   if (s != NULL)
  290.   {
  291.     if (strcmp(s, "Hex") == 0)
  292.       url_encoding = URL_CODE_HEX;
  293.     else if (strcmp(s, "UTF-16 (double byte)") == 0)
  294.       url_encoding = URL_CODE_UTF16;
  295.     else if (strcmp(s, "UTF-16 (MS %u)") == 0)
  296.       url_encoding = URL_CODE_UTF16MS;
  297.     else if (strcmp(s, "Incorrect UTF-8") == 0)
  298.       url_encoding = URL_CODE_UTF8BAD;
  299.   }
  300.   
  301.   
  302.   switch (url_encoding)
  303.     {
  304.     case URL_CODE_UTF16:
  305.     case URL_CODE_UTF16MS:
  306.     case URL_CODE_UTF8BAD:
  307.       /* Let's try first without encoding [back]slashes */
  308.       l = (l - n_slash - n_backslash) * 6 + n_slash + n_backslash;
  309.       break;
  310.     case URL_CODE_HEX:
  311.       /* We do not encode slashes, as this does not work against Apache, 
  312.        * at least apache-1.3.22-2 from redhat */
  313.       l = (l - n_slash) * 3 + n_slash;
  314.       break;
  315.     }
  317.   if (url_encoding != URL_CODE_NONE)
  318.     {  
  319.       ret2 = emalloc(l + 1);
  321.       for (s = ret, s2 = ret2; *s != ''; s ++)
  322. if (*s == '/' ||
  323.     ((url_encoding == URL_CODE_UTF8BAD ||
  324.       url_encoding == URL_CODE_UTF16 ||
  325.       url_encoding == URL_CODE_UTF16MS) && *s == '\'))
  326.   *s2++ = *s;
  327. else if (s[0] == '%' && isxdigit(s[1]) && isxdigit(s[2]))
  328.   {
  329.     /* Already % encoded. Do not change it! */
  330.     *s2++ = *s++;
  331.     *s2++ = *s++;
  332.     *s2++ = *s;
  333.   }
  334. else if (s[0] == '%' && tolower(s[1]) == 'u' &&
  335.  isxdigit(s[2]) && isxdigit(s[3]) &&
  336.  isxdigit(s[4]) && isxdigit(s[5]) )
  337.   {
  338.     /* Already %u encoded. Do not change it! */
  339.     *s2++ = *s++;
  340.     *s2++ = *s++;
  341.     *s2++ = *s++;
  342.     *s2++ = *s++;
  343.     *s2++ = *s;
  344.   }   
  345. else if (url_encoding == URL_CODE_UTF16MS)
  346.   {
  347.     sprintf(s2, "%%u00%02x", *(unsigned char*)s); 
  348.     /* The argument MUST be "unsigned char" */
  349.     s2 += 6;
  350.   }
  351. else if (url_encoding == URL_CODE_UTF16)
  352.   {
  353.     sprintf(s2, "%%00%%%02x", *(unsigned char*)s); 
  354.     /* The argument MUST be "unsigned char" */
  355.     s2 += 6;
  356.   }
  357. else if (url_encoding == URL_CODE_UTF8BAD)
  358.   {
  359.     unsigned char c = *(unsigned char*)s;
  360.     sprintf(s2, "%%%02x%%%02x",
  361.     0xC0 | (c >> 6), 0x80 | (c & 0x3F)); 
  362.     s2 += 6;
  363.     /* Note: we could also use the raw unencoded characters */
  364.   }
  365. else
  366.   {
  367.     sprintf(s2, "%%%02x", *(unsigned char*)s); 
  368.     /* The argument MUST be "unsigned char", so that it stays between
  369.      * 0 and 255. Otherwise, we might get something like %FFFFFF42 */
  370.     s2 += 3;
  371.     if (*s == '\')
  372.       n_backslash --;
  373.   }
  374.       *s2 = '';
  375.       efree(&ret);
  376.       ret = ret2;
  377. #ifdef URL_DEBUG
  378.       fprintf(stderr, "Request =  %sn", ret);
  379. #endif
  380.     }
  382.   abs_URI_type = kb_item_get_str(kb, "NIDS/HTTP/absolute_URI/type");
  383.   if (start_with_slash && 
  384.       abs_URI_type != NULL && strcmp(abs_URI_type, "none") != 0)
  385.     {
  386. #ifndef MAXHOSTNAMELEN
  387. # define MAXHOSTNAMELEN 64
  388. #endif
  389.       char h[MAXHOSTNAMELEN];
  391.       abs_URI_host = kb_item_get_str(kb, "NIDS/HTTP/absolute_URI/host");
  392.       h[0] = '';
  393.       if (abs_URI_host != NULL)
  394.       {
  395. if (strcmp(abs_URI_host, "host name") == 0)
  396.   {
  397.     if ((s = (char*)plug_get_hostname(data)) != NULL)
  398.       strncpy(h, s, sizeof(h));
  399.     h[sizeof(h)-1] = '';
  400.   }
  401. else if (strcmp(abs_URI_host, "host IP") == 0)
  402.   {
  403.     struct in_addr * ptr;
  404.     if ((ptr = plug_get_host_ip(data)) != NULL)
  405.     {
  406.       char * asc = inet_ntoa(*ptr);
  407.       strncpy(h, asc, sizeof(h));
  408.     }
  409.     h[sizeof(h)-1] = '';
  410.   }
  411. else if (strcmp(abs_URI_host, "random name") == 0)
  412.   {
  413.     for (s2 = h, i = 0; i < 16; i ++)
  414.       *s2++ = lrand48() % 26 + 'a';
  415.     *s2++ = '';
  416.   }
  417. else if (strcmp(abs_URI_host, "random IP") == 0)
  418.   sprintf(h, "%d.%d.%d.%d", rand() % 256, rand() % 256, rand() % 256, rand() % 256);
  419. #if 0
  420. else
  421.   fprintf(stderr, "Unhandled value %sn", abs_URI_host);
  422. #endif
  423.      }
  424.  
  425.       l += strlen(h) + strlen(abs_URI_type) + 3;
  426.       n_slash += 2;
  427.       ret2 = emalloc(l + 1);
  429.       sprintf(ret2, "%s://%s%s", abs_URI_type, h, ret);
  430.       efree(&ret);
  431.       ret = ret2;
  432. #ifdef URL_DEBUG
  433.       fprintf(stderr, "Request =  %sn", ret);
  434. #endif
  435.     }
  438.   s = kb_item_get_str(kb, "NIDS/HTTP/null_method");
  439.   null_method = (s != NULL && strcmp(s, "yes") == 0);
  440.   if (null_method)
  441.     {
  442.       l += 3;
  443.       ret2 = emalloc(l + 1);
  444.       strcpy(ret2, "%00");
  445.       strcpy(ret2+3, ret);
  446.       efree(&ret);
  447.       ret = ret2;
  448.     }
  450.   l += strlen(method) + 1;
  452.   s = kb_item_get_str(kb, "NIDS/HTTP/http09");
  453.   http09 = (s != NULL && strcmp(s, "yes") == 0);
  454.   if (! http09)
  455.     {
  456.       s = kb_item_get_str(kb, "NIDS/HTTP/protocol_string");
  457.       if (s != NULL && *s != '')
  458. {
  459.   httpver = s;
  460. #if 0
  461.   fprintf(stderr, "NIDS/HTTP/protocol_string = %sn", s);
  462. #endif
  463. }
  464.       l += strlen(httpver) + 1;
  465.     }
  468.   s = kb_item_get_str(kb, "NIDS/HTTP/tab_separator");
  469.   tab_sep = (s != NULL && strcmp(s, "yes") == 0);
  470.   sep_c = (tab_sep ? 't' : ' ');
  472.   ret2 = emalloc(l + 1);
  473.   if (http09)
  474.     sprintf(ret2, "%s%c%s", method, sep_c, ret);
  475.   else
  476.     sprintf(ret2, "%s%c%s%c%s", method, sep_c, ret, sep_c, httpver);
  477.   efree(&ret);
  478.   ret = ret2;
  480. #ifdef URL_DEBUG
  481.       fprintf(stderr, "Request <= %sn", ret);
  482. #endif
  483.   return ret;
  484. }
  486. static char *
  487. http11_get_head(port, data, path, name, method)
  488.  struct arglist * data;
  489.  int port;
  490.  char *  path;
  491.  char *  name;
  492.  char *  method;
  493. {
  494.  char * hostname = (char*)plug_get_hostname(data);
  495.  char * url = build_encode_URL(data, method, path, name, "HTTP/1.1"); 
  496.  char * ret;
  497.  char * auth_string, tmp[32];
  498.  struct kb_item ** kb = plug_get_kb(data);
  500.  snprintf(tmp, sizeof(tmp), "/tmp/http/auth/%d", port);
  501.  auth_string = kb_item_get_str(kb, tmp);
  502.  if (auth_string == NULL)
  503.    auth_string = kb_item_get_str(kb, "http/auth");
  505.  ret = emalloc(strlen(hostname) + strlen(url) + (auth_string ? strlen(auth_string):0) + 1024);
  506.  sprintf(ret, "%srn
  507. Connection: Closern
  508. Host: %srn
  509. Pragma: no-cachern
  510. User-Agent: Mozilla/4.75 [en] (X11, U; Nessus)rn
  511. Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*rn
  512. Accept-Language: enrn
  513. Accept-Charset: iso-8859-1,*,utf-8rn%s%srn",
  514. url,
  515. hostname,
  516. auth_string ? auth_string:"",
  517. auth_string ? "rn":"");
  518.  efree(&url);
  519.  return ret;
  520. }
  522. static char *
  523. http11_get(port, data, path, name)
  524.  struct arglist * data;
  525.  int port;
  526.  char *  path;
  527.  char *  name;
  528. {
  529.   return http11_get_head(port, data, path, name, "GET");
  530. }
  532. static char *
  533. http11_head(port, data, path, name)
  534.  struct arglist * data;
  535.  int port;
  536.  char *  path;
  537.  char *  name;
  538. {
  539.   return http11_get_head(port, data, path, name, "HEAD");
  540. }
  542. /* ******** */
  544. static char *
  545. http10_get_head(port, data, path, name, method)
  546.  struct arglist * data;
  547.  int port;
  548.  char *  path;
  549.  char *  name;
  550.  char *  method;
  551. {
  552.  char * url = build_encode_URL(data, method, path, name, "HTTP/1.0"); 
  553.  char * ret;
  554.  char * auth_string, tmp[32];
  555.  struct kb_item ** kb = plug_get_kb(data);
  557.  snprintf(tmp, sizeof(tmp), "/tmp/http/auth/%d", port);
  558.  auth_string = kb_item_get_str(kb, tmp);
  559.  if (auth_string == NULL)
  560.    auth_string = kb_item_get_str(kb, "http/auth");
  561.  
  562.  ret = emalloc(strlen(url) + 1024 + (auth_string ? strlen(auth_string) : 0));
  563.  
  564.  sprintf(ret, "%srn%srn%s",
  565. url,
  566. auth_string?auth_string:"",
  567. auth_string?"rn":"");
  568.  efree(&url);
  569.  return ret;
  570. }
  572. static char *
  573. http10_get(port, data, path, name)
  574.  struct arglist * data;
  575.  int port;
  576.  char *  path;
  577.  char *  name;
  578. {
  579.   return http10_get_head(port, data, path, name, "GET");
  580. }
  582. static char *
  583. http10_head(port, data, path, name)
  584.  struct arglist * data;
  585.  int port;
  586.  char *  path;
  587.  char *  name;
  588. {
  589.   return http10_get_head(port, data, path, name, "HEAD");
  590. }
  592. /* ******** */
  594. static char *
  595. http_get(port, data, ver, path, name)
  596.  int port;
  597.  struct arglist * data;
  598.  int ver;
  599.  char *  path;
  600.  char *  name;
  601. {
  602.  if(ver == 10)
  603.   return http10_get(port, data, path, name);
  604.  else
  605.   return http11_get(port, data, path, name);
  606. }
  608. static char *
  609. http_head(port, data, ver, path, name)
  610.  struct arglist * data;
  611.  int port;
  612.  int ver;
  613.  char *  path;
  614.  char *  name;
  615. {
  616.  if(ver == 11)
  617.   return http11_head(port, data, path, name);
  618.  else
  619.   return http10_head(port, data, path, name);
  620. }
  622. static int 
  623. httpver(data, port)
  624.  struct arglist * data;
  625.  int port;
  626. {
  627.  char req[255];
  628.  int value;
  629.  bzero(req, sizeof(req));
  630.  snprintf(req, sizeof(req), "http/%d", port);
  631.  value = kb_item_get_int(plug_get_kb(data), req);
  632.  if ( value <= 0 )
  633.     return 11;
  634.  else
  635.     return value;
  636. }