EzDoum

찾기
처음으로 | 찾기 | 아카이브 | 글 올리기 | 링크 | 자료실 | 통계 | 연락처 | 자유게시판
이지도움 특집
전체보기
네트워크
TI OMAP35x
TI DaVinci
Analog Blackfin
RobotWar2005
임베디드!
캐쉬의 모든것
메모리 할당 알고리즘
CPU 파이프라이닝
자료구조(Tree)
금융

Login
이름

암호

기억하기


사용자 등록

현재 접속중인 등록 사용자는 0명, 익명 사용자는 6명 입니다.
전체 등록 사용자: 751명

마지막 답장
·libcurl + fuse 조합으로 되는게 많네. (1)
·Linux Ftrace에 관해 (3)
·Android MTP ( Media Transfer Protocol ) (1)
·Lighttpd에 인증을 digest 사용시 IE 오동작 문제? (1)
·Dtrace에 관해 (1)

최근글
·OpenSSL and multi-threads (0)
·ARM 환경에서 OpenCL 사용 (0)
·IoT용 WIFI 모듈 비교 ( MCU ) 클래스 (0)
·Glances - 리눅스 여러 가지 항목을 한 화면에서 모니터링 (0)
·plugin 방식의 로그 분석기 (0)

뜨거운 감자
·나는 인터렉티브한 환경에서 역어셈블 한다. (12)
·GNU REGEX (정규표현식) 프로그래밍 강좌 (7)
·SoCRobotWar 2005 - 신입생 기초 교육자료 (7)
·ASP.NET의 데이터 그리드와 사용자 컨트롤 (7)
·DHTML Editing Control (7)

가장 많이 읽은 글
·[Cache] 2-way Set-Associative 방식이란 무엇일까? (2)
·멀티쓰레드(Pthread) 프로그래밍
·Sorting Algorithm Animation (2)
·GNU REGEX (정규표현식) 프로그래밍 강좌 (7)
·SoCRobotWar 2005 - 신입생 기초 교육자료 (7)

http 프로토콜에서 사용하는 인증방법 두가지
글쓴이: EzDoum 글쓴날: 2007년 10월 16일 오후 08:49
보안



http 프로토콜에서 사용하는 인증 방법 두가지

basic은 암호화 없이 base64 인코딩해서 전송하기 때문에 패킷 캡쳐만 하면 다 보인다.
두번째는 digest 방법인데 md를 사용해 직접 패스워드가 전송 되는것은 아니지만, Man-in-the-middle attack 에 취약하다.

아래의 소스는 wget의 소스중에 basic과 digest구현 이다.

http://en.wikipedia.org/wiki/Basic_access_authentication
http://en.wikipedia.org/wiki/Digest_access_authentication

rfc2617에도 구현 예제가 있음
http://tools.ietf.org/html/rfc2617

  1. /* Authorization support:
  2.  
  3.    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
  4.  
  5.    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
  6.    consisting of answering to the server's challenge with the proper
  7.    MD5 digests.
  8. */
  9.  
  10. /* Create the authentication header contents for the `Basic' scheme.
  11.    This is done by encoding the string "USER:PASS" to base64 and
  12.    prepending the string "Basic " in front of it.  */
  13.  
  14. static char *
  15. basic_authentication_encode (const char *user, const char *passwd)
  16. {
  17.   char *t1, *t2;
  18.   int len1 = strlen (user) + 1 + strlen (passwd);
  19.  
  20.   t1 = (char *)alloca (len1 + 1);
  21.   sprintf (t1, "%s:%s", user, passwd);
  22.  
  23.   t2 = (char *)alloca (BASE64_LENGTH (len1) + 1);
  24.   base64_encode (t1, len1, t2);
  25.  
  26.   return concat_strings ("Basic ", t2, (char *) 0);
  27. }
  28.  
  29. #define SKIP_WS(x) do {    \
  30.   while (ISSPACE (*(x)))                        \
  31.     ++(x);                              \
  32. } while (0)
  33.  
  34. #ifdef ENABLE_DIGEST
  35. /* Parse HTTP `WWW-Authenticate:' header.  AU points to the beginning
  36.    of a field in such a header.  If the field is the one specified by
  37.    ATTR_NAME ("realm", "opaque", and "nonce" are used by the current
  38.    digest authorization code), extract its value in the (char*)
  39.    variable pointed by RET.  Returns negative on a malformed header,
  40.    or number of bytes that have been parsed by this call.  */
  41. static int
  42. extract_header_attr (const char *au, const char *attr_name, char **ret)
  43. {
  44.   const char *ep;
  45.   const char *cp = au;
  46.  
  47.   if (strncmp (cp, attr_name, strlen (attr_name)) == 0)
  48.     {
  49.       cp += strlen (attr_name);
  50.       if (!*cp)
  51.         return -1;
  52.       SKIP_WS (cp);
  53.       if (*cp != '=')
  54.         return -1;
  55.       if (!*++cp)
  56.         return -1;
  57.       SKIP_WS (cp);
  58.       if (*cp != '\"')
  59.         return -1;
  60.       if (!*++cp)
  61.         return -1;
  62.       for (ep = cp; *ep && *ep != '\"'; ep++)
  63.         ;
  64.       if (!*ep)
  65.         return -1;
  66.       xfree_null (*ret);
  67.       *ret = strdupdelim (cp, ep);
  68.       return ep - au + 1;
  69.     }
  70.   else
  71.     return 0;
  72. }
  73.  
  74. /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
  75.    an array of 16 bytes containing the hash keys, and BUF should be a
  76.    buffer of 33 writable characters (32 for hex digits plus one for
  77.    zero termination).  */
  78. static void
  79. dump_hash (unsigned char *buf, const unsigned char *hash)
  80. {
  81.   int i;
  82.  
  83.   for (i = 0; i < MD5_HASHLEN; i++, hash++)
  84.     {
  85.       *buf++ = XNUM_TO_digit (*hash >> 4);
  86.       *buf++ = XNUM_TO_digit (*hash & 0xf);
  87.     }
  88.   *buf = '\0';
  89. }
  90.  
  91. /* Take the line apart to find the challenge, and compose a digest
  92.    authorization header.  See RFC2069 section 2.1.2.  */
  93. static char *
  94. digest_authentication_encode (const char *au, const char *user,
  95.                               const char *passwd, const char *method,
  96.                               const char *path)
  97. {
  98.   static char *realm, *opaque, *nonce;
  99.   static struct {
  100.     const char *name;
  101.     char **variable;
  102.   } options[] = {
  103.     { "realm", &realm },
  104.     { "opaque", &opaque },
  105.     { "nonce", &nonce }
  106.   };
  107.   char *res;
  108.  
  109.   realm = opaque = nonce = NULL;
  110.  
  111.   au += 6;                  /* skip over `Digest' */
  112.   while (*au)
  113.     {
  114.       int i;
  115.  
  116.       SKIP_WS (au);
  117.       for (i = 0; i < countof (options); i++)
  118.         {
  119.           int skip = extract_header_attr (au, options[i].name,
  120.                                           options[i].variable);
  121.           if (skip < 0)
  122.             {
  123.               xfree_null (realm);
  124.               xfree_null (opaque);
  125.               xfree_null (nonce);
  126.               return NULL;
  127.             }
  128.           else if (skip)
  129.             {
  130.               au += skip;
  131.               break;
  132.             }
  133.         }
  134.       if (i == countof (options))
  135.         {
  136.           while (*au && *au != '=')
  137.             au++;
  138.           if (*au && *++au)
  139.             {
  140.               SKIP_WS (au);
  141.               if (*au == '\"')
  142.                 {
  143.                   au++;
  144.                   while (*au && *au != '\"')
  145.                     au++;
  146.                   if (*au)
  147.                     au++;
  148.                 }
  149.             }
  150.         }
  151.       while (*au && *au != ',')
  152.         au++;
  153.       if (*au)
  154.         au++;
  155.     }
  156.   if (!realm || !nonce || !user || !passwd || !path || !method)
  157.     {
  158.       xfree_null (realm);
  159.       xfree_null (opaque);
  160.       xfree_null (nonce);
  161.       return NULL;
  162.     }
  163.  
  164.   /* Calculate the digest value.  */
  165.   {
  166.     ALLOCA_MD5_CONTEXT (ctx);
  167.     unsigned char hash[MD5_HASHLEN];
  168.     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
  169.     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
  170.  
  171.     /* A1BUF = H(user ":" realm ":" password) */
  172.     gen_md5_init (ctx);
  173.     gen_md5_update ((unsigned char *)user, strlen (user), ctx);
  174.     gen_md5_update ((unsigned char *)":", 1, ctx);
  175.     gen_md5_update ((unsigned char *)realm, strlen (realm), ctx);
  176.     gen_md5_update ((unsigned char *)":", 1, ctx);
  177.     gen_md5_update ((unsigned char *)passwd, strlen (passwd), ctx);
  178.     gen_md5_finish (ctx, hash);
  179.     dump_hash (a1buf, hash);
  180.  
  181.     /* A2BUF = H(method ":" path) */
  182.     gen_md5_init (ctx);
  183.     gen_md5_update ((unsigned char *)method, strlen (method), ctx);
  184.     gen_md5_update ((unsigned char *)":", 1, ctx);
  185.     gen_md5_update ((unsigned char *)path, strlen (path), ctx);
  186.     gen_md5_finish (ctx, hash);
  187.     dump_hash (a2buf, hash);
  188.  
  189.     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
  190.     gen_md5_init (ctx);
  191.     gen_md5_update (a1buf, MD5_HASHLEN * 2, ctx);
  192.     gen_md5_update ((unsigned char *)":", 1, ctx);
  193.     gen_md5_update ((unsigned char *)nonce, strlen (nonce), ctx);
  194.     gen_md5_update ((unsigned char *)":", 1, ctx);
  195.     gen_md5_update (a2buf, MD5_HASHLEN * 2, ctx);
  196.     gen_md5_finish (ctx, hash);
  197.     dump_hash (response_digest, hash);
  198.  
  199.     res = (char*) xmalloc (strlen (user)
  200.                            + strlen (user)
  201.                            + strlen (realm)
  202.                            + strlen (nonce)
  203.                            + strlen (path)
  204.                            + 2 * MD5_HASHLEN /*strlen (response_digest)*/
  205.                            + (opaque ? strlen (opaque) : 0)
  206.                            + 128);
  207.     sprintf (res, "Digest \
  208. username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
  209.              user, realm, nonce, path, response_digest);
  210.     if (opaque)
  211.       {
  212.         char *p = res + strlen (res);
  213.         strcat (p, ", opaque=\"");
  214.         strcat (p, opaque);
  215.         strcat (p, "\"");
  216.       }
  217.   }
  218.   return res;
  219. }
  220. #endif /* ENABLE_DIGEST */
  221.  


[분류: 보안 인쇄용 페이지 본문 email로 보내기 ]

<  잘 정리된 network 관련 컨텐츠 | glib을 사용한 Easy I/O with IO Channels  >

답장 쓰기
글을 올리시려면 로그인 (사용자 등록) 하셔야 합니다.

검색
Google

분류
·공지 (6)
·인터넷 (87)
·하드웨어 (260)
·C/C++ (65)
·어셈블리 (7)
·리눅스 (136)
·리눅스 커널 (67)
·윈도우즈 (25)
·데이터베이스 (20)
·보안 (16)
·.NET (25)
·그래픽 (13)
·책소개 (42)
·호기심 천국 (80)
·잡담 (111)
·사랑 (3)

전체 본문수: 963
전체 답장수: 525


분류 : 보안
최근글
최근글
가장 많이 읽은 글
·ReverseEngineering - 종합선물세트 (2)
뜨거운 감자
·ReverseEngineering - 종합선물세트 (2)

EzDoum투표
이지도움 어때요?
이게 뭐야. 다시 안올란다. --;
아이 좋아라~ +_+;
관심없다.
먼가는 있는거 같은데 뭐하는 곳이지?
기타 (자유게시판에 글로 남겨 주세요)
[ 결과 | 투표 ]

랜덤 링크
http://kldp.net


 Home ^ BACK TO TOP ^ EzDoum - 도움이 필요하세요~??
 Powered by KorWeblog 1.5.8 Copyleft © 2001 EzDoum, 관리자: EzDoum