md5.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374
  1. /* $USAGI: md5.c,v 1.2 2000/11/02 11:59:24 yoshfuji Exp $ */
  2. /* $KAME: md5.c,v 1.2 2000/05/27 07:07:48 jinmei Exp $ */
  3. /* $Id: md5.c,v 1.6 2006/01/17 23:39:04 vincent Exp $ */
  4. /*
  5. * Copyright (C) 2004 6WIND
  6. * <Vincent.Jardin@6WIND.com>
  7. * All rights reserved.
  8. *
  9. * This MD5 code is Big endian and Little Endian compatible.
  10. */
  11. /*
  12. * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  13. * All rights reserved.
  14. *
  15. * Redistribution and use in source and binary forms, with or without
  16. * modification, are permitted provided that the following conditions
  17. * are met:
  18. * 1. Redistributions of source code must retain the above copyright
  19. * notice, this list of conditions and the following disclaimer.
  20. * 2. Redistributions in binary form must reproduce the above copyright
  21. * notice, this list of conditions and the following disclaimer in the
  22. * documentation and/or other materials provided with the distribution.
  23. * 3. Neither the name of the project nor the names of its contributors
  24. * may be used to endorse or promote products derived from this software
  25. * without specific prior written permission.
  26. *
  27. * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  28. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30. * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  31. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37. * SUCH DAMAGE.
  38. */
  39. #include <zebra.h>
  40. #include "md5.h"
  41. #define SHIFT(X, s) (((X) << (s)) | ((X) >> (32 - (s))))
  42. #define F(X, Y, Z) (((X) & (Y)) | ((~X) & (Z)))
  43. #define G(X, Y, Z) (((X) & (Z)) | ((Y) & (~Z)))
  44. #define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
  45. #define I(X, Y, Z) ((Y) ^ ((X) | (~Z)))
  46. #define ROUND1(a, b, c, d, k, s, i) { \
  47. (a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
  48. (a) = SHIFT((a), (s)); \
  49. (a) = (b) + (a); \
  50. }
  51. #define ROUND2(a, b, c, d, k, s, i) { \
  52. (a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
  53. (a) = SHIFT((a), (s)); \
  54. (a) = (b) + (a); \
  55. }
  56. #define ROUND3(a, b, c, d, k, s, i) { \
  57. (a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
  58. (a) = SHIFT((a), (s)); \
  59. (a) = (b) + (a); \
  60. }
  61. #define ROUND4(a, b, c, d, k, s, i) { \
  62. (a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
  63. (a) = SHIFT((a), (s)); \
  64. (a) = (b) + (a); \
  65. }
  66. #define Sa 7
  67. #define Sb 12
  68. #define Sc 17
  69. #define Sd 22
  70. #define Se 5
  71. #define Sf 9
  72. #define Sg 14
  73. #define Sh 20
  74. #define Si 4
  75. #define Sj 11
  76. #define Sk 16
  77. #define Sl 23
  78. #define Sm 6
  79. #define Sn 10
  80. #define So 15
  81. #define Sp 21
  82. #define MD5_A0 0x67452301
  83. #define MD5_B0 0xefcdab89
  84. #define MD5_C0 0x98badcfe
  85. #define MD5_D0 0x10325476
  86. /* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */
  87. static const uint32_t T[65] = {
  88. 0,
  89. 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
  90. 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
  91. 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
  92. 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
  93. 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
  94. 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
  95. 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
  96. 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
  97. 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
  98. 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
  99. 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
  100. 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
  101. 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
  102. 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
  103. 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
  104. 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
  105. };
  106. static const uint8_t md5_paddat[MD5_BUFLEN] = {
  107. 0x80, 0, 0, 0, 0, 0, 0, 0,
  108. 0, 0, 0, 0, 0, 0, 0, 0,
  109. 0, 0, 0, 0, 0, 0, 0, 0,
  110. 0, 0, 0, 0, 0, 0, 0, 0,
  111. 0, 0, 0, 0, 0, 0, 0, 0,
  112. 0, 0, 0, 0, 0, 0, 0, 0,
  113. 0, 0, 0, 0, 0, 0, 0, 0,
  114. 0, 0, 0, 0, 0, 0, 0, 0,
  115. };
  116. static void md5_calc (const uint8_t *, md5_ctxt *);
  117. void md5_init(md5_ctxt *ctxt)
  118. {
  119. ctxt->md5_n = 0;
  120. ctxt->md5_i = 0;
  121. ctxt->md5_sta = MD5_A0;
  122. ctxt->md5_stb = MD5_B0;
  123. ctxt->md5_stc = MD5_C0;
  124. ctxt->md5_std = MD5_D0;
  125. memset (ctxt->md5_buf, 0, sizeof(ctxt->md5_buf));
  126. }
  127. void md5_loop(md5_ctxt *ctxt, const void *vinput, uint len)
  128. {
  129. uint gap, i;
  130. const uint8_t *input = vinput;
  131. ctxt->md5_n += len * 8; /* byte to bit */
  132. gap = MD5_BUFLEN - ctxt->md5_i;
  133. if (len >= gap) {
  134. memcpy (ctxt->md5_buf + ctxt->md5_i, input, gap);
  135. md5_calc(ctxt->md5_buf, ctxt);
  136. for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
  137. md5_calc((input + i), ctxt);
  138. }
  139. ctxt->md5_i = len - i;
  140. memcpy (ctxt->md5_buf, (input + i), ctxt->md5_i);
  141. } else {
  142. memcpy (ctxt->md5_buf + ctxt->md5_i, input, len);
  143. ctxt->md5_i += len;
  144. }
  145. }
  146. void md5_pad(md5_ctxt *ctxt)
  147. {
  148. uint gap;
  149. /* Don't count up padding. Keep md5_n. */
  150. gap = MD5_BUFLEN - ctxt->md5_i;
  151. if (gap > 8) {
  152. memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat,
  153. gap - sizeof(ctxt->md5_n));
  154. } else {
  155. /* including gap == 8 */
  156. memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat, gap);
  157. md5_calc (ctxt->md5_buf, ctxt);
  158. memcpy (ctxt->md5_buf, md5_paddat + gap,
  159. MD5_BUFLEN - sizeof(ctxt->md5_n));
  160. }
  161. /* 8 byte word */
  162. if (BYTE_ORDER == LITTLE_ENDIAN)
  163. memcpy (&ctxt->md5_buf[56], &ctxt->md5_n8[0], 8);
  164. else
  165. {
  166. ctxt->md5_buf[56] = ctxt->md5_n8[7];
  167. ctxt->md5_buf[57] = ctxt->md5_n8[6];
  168. ctxt->md5_buf[58] = ctxt->md5_n8[5];
  169. ctxt->md5_buf[59] = ctxt->md5_n8[4];
  170. ctxt->md5_buf[60] = ctxt->md5_n8[3];
  171. ctxt->md5_buf[61] = ctxt->md5_n8[2];
  172. ctxt->md5_buf[62] = ctxt->md5_n8[1];
  173. ctxt->md5_buf[63] = ctxt->md5_n8[0];
  174. }
  175. md5_calc(ctxt->md5_buf, ctxt);
  176. }
  177. void md5_result(uint8_t *digest, md5_ctxt *ctxt)
  178. {
  179. /* 4 byte words */
  180. if (BYTE_ORDER == LITTLE_ENDIAN)
  181. memcpy (digest, &ctxt->md5_st8[0], 16);
  182. else if (BYTE_ORDER == BIG_ENDIAN)
  183. {
  184. digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
  185. digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
  186. digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
  187. digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
  188. digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
  189. digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
  190. digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
  191. digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
  192. }
  193. }
  194. static void md5_calc(const uint8_t *b64, md5_ctxt * ctxt)
  195. {
  196. uint32_t A = ctxt->md5_sta;
  197. uint32_t B = ctxt->md5_stb;
  198. uint32_t C = ctxt->md5_stc;
  199. uint32_t D = ctxt->md5_std;
  200. #if (BYTE_ORDER == LITTLE_ENDIAN)
  201. const uint32_t *X = (const uint32_t *)b64;
  202. #elif (BYTE_ORDER == BIG_ENDIAN)
  203. uint32_t X[16];
  204. if (BYTE_ORDER == BIG_ENDIAN)
  205. {
  206. /* 4 byte words */
  207. /* what a brute force but fast! */
  208. uint8_t *y = (uint8_t *)X;
  209. y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
  210. y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
  211. y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
  212. y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
  213. y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
  214. y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
  215. y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
  216. y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
  217. y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
  218. y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
  219. y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
  220. y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
  221. y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
  222. y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
  223. y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
  224. y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
  225. }
  226. #endif
  227. ROUND1(A, B, C, D, 0, Sa, 1); ROUND1(D, A, B, C, 1, Sb, 2);
  228. ROUND1(C, D, A, B, 2, Sc, 3); ROUND1(B, C, D, A, 3, Sd, 4);
  229. ROUND1(A, B, C, D, 4, Sa, 5); ROUND1(D, A, B, C, 5, Sb, 6);
  230. ROUND1(C, D, A, B, 6, Sc, 7); ROUND1(B, C, D, A, 7, Sd, 8);
  231. ROUND1(A, B, C, D, 8, Sa, 9); ROUND1(D, A, B, C, 9, Sb, 10);
  232. ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
  233. ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
  234. ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
  235. ROUND2(A, B, C, D, 1, Se, 17); ROUND2(D, A, B, C, 6, Sf, 18);
  236. ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A, 0, Sh, 20);
  237. ROUND2(A, B, C, D, 5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
  238. ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A, 4, Sh, 24);
  239. ROUND2(A, B, C, D, 9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
  240. ROUND2(C, D, A, B, 3, Sg, 27); ROUND2(B, C, D, A, 8, Sh, 28);
  241. ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C, 2, Sf, 30);
  242. ROUND2(C, D, A, B, 7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);
  243. ROUND3(A, B, C, D, 5, Si, 33); ROUND3(D, A, B, C, 8, Sj, 34);
  244. ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
  245. ROUND3(A, B, C, D, 1, Si, 37); ROUND3(D, A, B, C, 4, Sj, 38);
  246. ROUND3(C, D, A, B, 7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
  247. ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C, 0, Sj, 42);
  248. ROUND3(C, D, A, B, 3, Sk, 43); ROUND3(B, C, D, A, 6, Sl, 44);
  249. ROUND3(A, B, C, D, 9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
  250. ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A, 2, Sl, 48);
  251. ROUND4(A, B, C, D, 0, Sm, 49); ROUND4(D, A, B, C, 7, Sn, 50);
  252. ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A, 5, Sp, 52);
  253. ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C, 3, Sn, 54);
  254. ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A, 1, Sp, 56);
  255. ROUND4(A, B, C, D, 8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58);
  256. ROUND4(C, D, A, B, 6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60);
  257. ROUND4(A, B, C, D, 4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62);
  258. ROUND4(C, D, A, B, 2, So, 63); ROUND4(B, C, D, A, 9, Sp, 64);
  259. ctxt->md5_sta += A;
  260. ctxt->md5_stb += B;
  261. ctxt->md5_stc += C;
  262. ctxt->md5_std += D;
  263. }
  264. /* From RFC 2104 */
  265. void
  266. hmac_md5(text, text_len, key, key_len, digest)
  267. unsigned char* text; /* pointer to data stream */
  268. int text_len; /* length of data stream */
  269. unsigned char* key; /* pointer to authentication key */
  270. int key_len; /* length of authentication key */
  271. uint8_t * digest; /* caller digest to be filled in */
  272. {
  273. MD5_CTX context;
  274. unsigned char k_ipad[65]; /* inner padding -
  275. * key XORd with ipad
  276. */
  277. unsigned char k_opad[65]; /* outer padding -
  278. * key XORd with opad
  279. */
  280. unsigned char tk[16];
  281. int i;
  282. /* if key is longer than 64 bytes reset it to key=MD5(key) */
  283. if (key_len > 64) {
  284. MD5_CTX tctx;
  285. MD5Init(&tctx);
  286. MD5Update(&tctx, key, key_len);
  287. MD5Final(tk, &tctx);
  288. key = tk;
  289. key_len = 16;
  290. }
  291. /*
  292. * the HMAC_MD5 transform looks like:
  293. *
  294. * MD5(K XOR opad, MD5(K XOR ipad, text))
  295. *
  296. * where K is an n byte key
  297. * ipad is the byte 0x36 repeated 64 times
  298. * opad is the byte 0x5c repeated 64 times
  299. * and text is the data being protected
  300. */
  301. /* start out by storing key in pads */
  302. bzero( k_ipad, sizeof k_ipad);
  303. bzero( k_opad, sizeof k_opad);
  304. bcopy( key, k_ipad, key_len);
  305. bcopy( key, k_opad, key_len);
  306. /* XOR key with ipad and opad values */
  307. for (i=0; i<64; i++) {
  308. k_ipad[i] ^= 0x36;
  309. k_opad[i] ^= 0x5c;
  310. }
  311. /*
  312. * perform inner MD5
  313. */
  314. MD5Init(&context); /* init context for 1st
  315. * pass */
  316. MD5Update(&context, k_ipad, 64); /* start with inner pad */
  317. MD5Update(&context, text, text_len); /* then text of datagram */
  318. MD5Final(digest, &context); /* finish up 1st pass */
  319. /*
  320. * perform outer MD5
  321. */
  322. MD5Init(&context); /* init context for 2nd
  323. * pass */
  324. MD5Update(&context, k_opad, 64); /* start with outer pad */
  325. MD5Update(&context, digest, 16); /* then results of 1st
  326. * hash */
  327. MD5Final(digest, &context); /* finish up 2nd pass */
  328. }