md5.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367
  1. /*
  2. * This code implements the MD5 message-digest algorithm.
  3. * The algorithm is due to Ron Rivest. This code was
  4. * written by Colin Plumb in 1993, no copyright is claimed.
  5. * This code is in the public domain; do with it what you wish.
  6. *
  7. * Equivalent code is available from RSA Data Security, Inc.
  8. * This code has been tested against that, and is equivalent,
  9. * except that you don't need to include two pages of legalese
  10. * with every copy.
  11. *
  12. * To compute the message digest of a chunk of bytes, declare an
  13. * MD5Context structure, pass it to MD5Init, call MD5Update as
  14. * needed on buffers full of bytes, and then call MD5Final, which
  15. * will fill a supplied 16-byte array with the digest.
  16. */
  17. /* This code slightly modified to fit into Samba by
  18. abartlet@samba.org Jun 2001
  19. and to fit the cifs vfs by
  20. Steve French sfrench@us.ibm.com */
  21. #include <linux/string.h>
  22. #include "md5.h"
  23. static void MD5Transform(__u32 buf[4], __u32 const in[16]);
  24. /*
  25. * Note: this code is harmless on little-endian machines.
  26. */
  27. static void
  28. byteReverse(unsigned char *buf, unsigned longs)
  29. {
  30. __u32 t;
  31. do {
  32. t = (__u32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
  33. ((unsigned) buf[1] << 8 | buf[0]);
  34. *(__u32 *) buf = t;
  35. buf += 4;
  36. } while (--longs);
  37. }
  38. /*
  39. * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
  40. * initialization constants.
  41. */
  42. void
  43. MD5Init(struct MD5Context *ctx)
  44. {
  45. ctx->buf[0] = 0x67452301;
  46. ctx->buf[1] = 0xefcdab89;
  47. ctx->buf[2] = 0x98badcfe;
  48. ctx->buf[3] = 0x10325476;
  49. ctx->bits[0] = 0;
  50. ctx->bits[1] = 0;
  51. }
  52. /*
  53. * Update context to reflect the concatenation of another buffer full
  54. * of bytes.
  55. */
  56. void
  57. MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
  58. {
  59. register __u32 t;
  60. /* Update bitcount */
  61. t = ctx->bits[0];
  62. if ((ctx->bits[0] = t + ((__u32) len << 3)) < t)
  63. ctx->bits[1]++; /* Carry from low to high */
  64. ctx->bits[1] += len >> 29;
  65. t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
  66. /* Handle any leading odd-sized chunks */
  67. if (t) {
  68. unsigned char *p = (unsigned char *) ctx->in + t;
  69. t = 64 - t;
  70. if (len < t) {
  71. memmove(p, buf, len);
  72. return;
  73. }
  74. memmove(p, buf, t);
  75. byteReverse(ctx->in, 16);
  76. MD5Transform(ctx->buf, (__u32 *) ctx->in);
  77. buf += t;
  78. len -= t;
  79. }
  80. /* Process data in 64-byte chunks */
  81. while (len >= 64) {
  82. memmove(ctx->in, buf, 64);
  83. byteReverse(ctx->in, 16);
  84. MD5Transform(ctx->buf, (__u32 *) ctx->in);
  85. buf += 64;
  86. len -= 64;
  87. }
  88. /* Handle any remaining bytes of data. */
  89. memmove(ctx->in, buf, len);
  90. }
  91. /*
  92. * Final wrapup - pad to 64-byte boundary with the bit pattern
  93. * 1 0* (64-bit count of bits processed, MSB-first)
  94. */
  95. void
  96. MD5Final(unsigned char digest[16], struct MD5Context *ctx)
  97. {
  98. unsigned int count;
  99. unsigned char *p;
  100. /* Compute number of bytes mod 64 */
  101. count = (ctx->bits[0] >> 3) & 0x3F;
  102. /* Set the first char of padding to 0x80. This is safe since there is
  103. always at least one byte free */
  104. p = ctx->in + count;
  105. *p++ = 0x80;
  106. /* Bytes of padding needed to make 64 bytes */
  107. count = 64 - 1 - count;
  108. /* Pad out to 56 mod 64 */
  109. if (count < 8) {
  110. /* Two lots of padding: Pad the first block to 64 bytes */
  111. memset(p, 0, count);
  112. byteReverse(ctx->in, 16);
  113. MD5Transform(ctx->buf, (__u32 *) ctx->in);
  114. /* Now fill the next block with 56 bytes */
  115. memset(ctx->in, 0, 56);
  116. } else {
  117. /* Pad block to 56 bytes */
  118. memset(p, 0, count - 8);
  119. }
  120. byteReverse(ctx->in, 14);
  121. /* Append length in bits and transform */
  122. ((__u32 *) ctx->in)[14] = ctx->bits[0];
  123. ((__u32 *) ctx->in)[15] = ctx->bits[1];
  124. MD5Transform(ctx->buf, (__u32 *) ctx->in);
  125. byteReverse((unsigned char *) ctx->buf, 4);
  126. memmove(digest, ctx->buf, 16);
  127. memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
  128. }
  129. /* The four core functions - F1 is optimized somewhat */
  130. /* #define F1(x, y, z) (x & y | ~x & z) */
  131. #define F1(x, y, z) (z ^ (x & (y ^ z)))
  132. #define F2(x, y, z) F1(z, x, y)
  133. #define F3(x, y, z) (x ^ y ^ z)
  134. #define F4(x, y, z) (y ^ (x | ~z))
  135. /* This is the central step in the MD5 algorithm. */
  136. #define MD5STEP(f, w, x, y, z, data, s) \
  137. ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
  138. /*
  139. * The core of the MD5 algorithm, this alters an existing MD5 hash to
  140. * reflect the addition of 16 longwords of new data. MD5Update blocks
  141. * the data and converts bytes into longwords for this routine.
  142. */
  143. static void
  144. MD5Transform(__u32 buf[4], __u32 const in[16])
  145. {
  146. register __u32 a, b, c, d;
  147. a = buf[0];
  148. b = buf[1];
  149. c = buf[2];
  150. d = buf[3];
  151. MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
  152. MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
  153. MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
  154. MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
  155. MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
  156. MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
  157. MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
  158. MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
  159. MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
  160. MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
  161. MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
  162. MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
  163. MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
  164. MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
  165. MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
  166. MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
  167. MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
  168. MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
  169. MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
  170. MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
  171. MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
  172. MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
  173. MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
  174. MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
  175. MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
  176. MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
  177. MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
  178. MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
  179. MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
  180. MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
  181. MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
  182. MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
  183. MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
  184. MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
  185. MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
  186. MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
  187. MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
  188. MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
  189. MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
  190. MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
  191. MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
  192. MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
  193. MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
  194. MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
  195. MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
  196. MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
  197. MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
  198. MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
  199. MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
  200. MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
  201. MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
  202. MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
  203. MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
  204. MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
  205. MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
  206. MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
  207. MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
  208. MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
  209. MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
  210. MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
  211. MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
  212. MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
  213. MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
  214. MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
  215. buf[0] += a;
  216. buf[1] += b;
  217. buf[2] += c;
  218. buf[3] += d;
  219. }
  220. #if 0 /* currently unused */
  221. /***********************************************************************
  222. the rfc 2104 version of hmac_md5 initialisation.
  223. ***********************************************************************/
  224. static void
  225. hmac_md5_init_rfc2104(unsigned char *key, int key_len,
  226. struct HMACMD5Context *ctx)
  227. {
  228. int i;
  229. /* if key is longer than 64 bytes reset it to key=MD5(key) */
  230. if (key_len > 64) {
  231. unsigned char tk[16];
  232. struct MD5Context tctx;
  233. MD5Init(&tctx);
  234. MD5Update(&tctx, key, key_len);
  235. MD5Final(tk, &tctx);
  236. key = tk;
  237. key_len = 16;
  238. }
  239. /* start out by storing key in pads */
  240. memset(ctx->k_ipad, 0, sizeof (ctx->k_ipad));
  241. memset(ctx->k_opad, 0, sizeof (ctx->k_opad));
  242. memcpy(ctx->k_ipad, key, key_len);
  243. memcpy(ctx->k_opad, key, key_len);
  244. /* XOR key with ipad and opad values */
  245. for (i = 0; i < 64; i++) {
  246. ctx->k_ipad[i] ^= 0x36;
  247. ctx->k_opad[i] ^= 0x5c;
  248. }
  249. MD5Init(&ctx->ctx);
  250. MD5Update(&ctx->ctx, ctx->k_ipad, 64);
  251. }
  252. #endif
  253. /***********************************************************************
  254. the microsoft version of hmac_md5 initialisation.
  255. ***********************************************************************/
  256. void
  257. hmac_md5_init_limK_to_64(const unsigned char *key, int key_len,
  258. struct HMACMD5Context *ctx)
  259. {
  260. int i;
  261. /* if key is longer than 64 bytes truncate it */
  262. if (key_len > 64) {
  263. key_len = 64;
  264. }
  265. /* start out by storing key in pads */
  266. memset(ctx->k_ipad, 0, sizeof (ctx->k_ipad));
  267. memset(ctx->k_opad, 0, sizeof (ctx->k_opad));
  268. memcpy(ctx->k_ipad, key, key_len);
  269. memcpy(ctx->k_opad, key, key_len);
  270. /* XOR key with ipad and opad values */
  271. for (i = 0; i < 64; i++) {
  272. ctx->k_ipad[i] ^= 0x36;
  273. ctx->k_opad[i] ^= 0x5c;
  274. }
  275. MD5Init(&ctx->ctx);
  276. MD5Update(&ctx->ctx, ctx->k_ipad, 64);
  277. }
  278. /***********************************************************************
  279. update hmac_md5 "inner" buffer
  280. ***********************************************************************/
  281. void
  282. hmac_md5_update(const unsigned char *text, int text_len,
  283. struct HMACMD5Context *ctx)
  284. {
  285. MD5Update(&ctx->ctx, text, text_len); /* then text of datagram */
  286. }
  287. /***********************************************************************
  288. finish off hmac_md5 "inner" buffer and generate outer one.
  289. ***********************************************************************/
  290. void
  291. hmac_md5_final(unsigned char *digest, struct HMACMD5Context *ctx)
  292. {
  293. struct MD5Context ctx_o;
  294. MD5Final(digest, &ctx->ctx);
  295. MD5Init(&ctx_o);
  296. MD5Update(&ctx_o, ctx->k_opad, 64);
  297. MD5Update(&ctx_o, digest, 16);
  298. MD5Final(digest, &ctx_o);
  299. }
  300. /***********************************************************
  301. single function to calculate an HMAC MD5 digest from data.
  302. use the microsoft hmacmd5 init method because the key is 16 bytes.
  303. ************************************************************/
  304. #if 0 /* currently unused */
  305. static void
  306. hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
  307. unsigned char *digest)
  308. {
  309. struct HMACMD5Context ctx;
  310. hmac_md5_init_limK_to_64(key, 16, &ctx);
  311. if (data_len != 0) {
  312. hmac_md5_update(data, data_len, &ctx);
  313. }
  314. hmac_md5_final(digest, &ctx);
  315. }
  316. #endif