md5.c 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. /*
  2. * md5.c : MD5 Message Digest Algorithm
  3. *
  4. * $Source$
  5. * $Id$
  6. *
  7. */
  8. /* Original copyright message: */
  9. /*
  10. * This code implements the MD5 message-digest algorithm. To compute
  11. * the message digest of a chunk of bytes, declare an MD5Context
  12. * structure, pass it to MD5Init, call MD5Update as needed on
  13. * buffers full of bytes, and then call MD5Final, which will fill a
  14. * supplied 16-byte array with the digest.
  15. *
  16. * Equivalent code is available from RSA Data Security, Inc. This code
  17. * has been tested against that, and is equivalent, except that you
  18. * don't need to include two pages of legalese with every copy.
  19. */
  20. #include <config.h>
  21. #include <stdio.h>
  22. #include <string.h> /* for memcpy() */
  23. #include <rdf_config.h>
  24. #include <rdf_digest.h>
  25. #include <rdf_types.h>
  26. /* original code from header - function names have changed */
  27. struct MD5Context {
  28. u32 buf[4];
  29. u32 bits[2];
  30. unsigned char in[64];
  31. };
  32. static void MD5Init(struct MD5Context *context);
  33. static void MD5Update(struct MD5Context *context,
  34. unsigned char const *buf,
  35. unsigned len);
  36. static void MD5Final(unsigned char digest[16], struct MD5Context *context);
  37. static void MD5Transform (u32 buf[4], u32 const in[16]);
  38. /* original code from C file - GNU configurised */
  39. #ifndef WORDS_BIGENDIAN
  40. #define byteReverse(buf, len) /* Nothing */
  41. #else
  42. static void byteReverse(unsigned char *buf, unsigned longs);
  43. /* ASM ifdef removed */
  44. /*
  45. * Note: this code is harmless on little-endian machines.
  46. */
  47. static void byteReverse(unsigned char *buf, unsigned longs)
  48. {
  49. u32 t;
  50. do {
  51. t = (u32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
  52. ((unsigned) buf[1] << 8 | buf[0]);
  53. *(u32 *) buf = t;
  54. buf += 4;
  55. } while (--longs);
  56. }
  57. #endif /* WORDS_BIGENDIAN */
  58. /*
  59. * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
  60. * initialization constants.
  61. */
  62. static void MD5Init(struct MD5Context *ctx)
  63. {
  64. ctx->buf[0] = 0x67452301;
  65. ctx->buf[1] = 0xefcdab89;
  66. ctx->buf[2] = 0x98badcfe;
  67. ctx->buf[3] = 0x10325476;
  68. ctx->bits[0] = 0;
  69. ctx->bits[1] = 0;
  70. }
  71. /*
  72. * Update context to reflect the concatenation of another buffer full
  73. * of bytes.
  74. */
  75. static void MD5Update(struct MD5Context *ctx,
  76. unsigned char const *buf,
  77. unsigned len)
  78. {
  79. u32 t;
  80. /* Update bitcount */
  81. t = ctx->bits[0];
  82. if ((ctx->bits[0] = t + ((u32) len << 3)) < t)
  83. ctx->bits[1]++; /* Carry from low to high */
  84. ctx->bits[1] += len >> 29;
  85. t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
  86. /* Handle any leading odd-sized chunks */
  87. if (t) {
  88. unsigned char *p = (unsigned char *) ctx->in + t;
  89. t = 64 - t;
  90. if (len < t) {
  91. memcpy(p, buf, len);
  92. return;
  93. }
  94. memcpy(p, buf, t);
  95. byteReverse(ctx->in, 16);
  96. MD5Transform(ctx->buf, (u32 *) ctx->in);
  97. buf += t;
  98. len -= t;
  99. }
  100. /* Process data in 64-byte chunks */
  101. while (len >= 64) {
  102. memcpy(ctx->in, buf, 64);
  103. byteReverse(ctx->in, 16);
  104. MD5Transform(ctx->buf, (u32 *) ctx->in);
  105. buf += 64;
  106. len -= 64;
  107. }
  108. /* Handle any remaining bytes of data. */
  109. memcpy(ctx->in, buf, len);
  110. }
  111. /*
  112. * Final wrapup - pad to 64-byte boundary with the bit pattern
  113. * 1 0* (64-bit count of bits processed, MSB-first)
  114. */
  115. static void MD5Final(unsigned char *digest, struct MD5Context *ctx)
  116. {
  117. unsigned count;
  118. unsigned char *p;
  119. /* Compute number of bytes mod 64 */
  120. count = (ctx->bits[0] >> 3) & 0x3F;
  121. /* Set the first char of padding to 0x80. This is safe since there is
  122. always at least one byte free */
  123. p = ctx->in + count;
  124. *p++ = 0x80;
  125. /* Bytes of padding needed to make 64 bytes */
  126. count = 64 - 1 - count;
  127. /* Pad out to 56 mod 64 */
  128. if (count < 8) {
  129. /* Two lots of padding: Pad the first block to 64 bytes */
  130. memset(p, 0, count);
  131. byteReverse(ctx->in, 16);
  132. MD5Transform(ctx->buf, (u32 *) ctx->in);
  133. /* Now fill the next block with 56 bytes */
  134. memset(ctx->in, 0, 56);
  135. } else {
  136. /* Pad block to 56 bytes */
  137. memset(p, 0, count - 8);
  138. }
  139. byteReverse(ctx->in, 14);
  140. /* Append length in bits and transform */
  141. ((u32 *) ctx->in)[14] = ctx->bits[0];
  142. ((u32 *) ctx->in)[15] = ctx->bits[1];
  143. MD5Transform(ctx->buf, (u32 *) ctx->in);
  144. byteReverse((unsigned char *) ctx->buf, 4);
  145. memcpy(digest, ctx->buf, 16);
  146. memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
  147. }
  148. /* The four core functions - F1 is optimized somewhat */
  149. /* #define F1(x, y, z) (x & y | ~x & z) */
  150. #define F1(x, y, z) (z ^ (x & (y ^ z)))
  151. #define F2(x, y, z) F1(z, x, y)
  152. #define F3(x, y, z) (x ^ y ^ z)
  153. #define F4(x, y, z) (y ^ (x | ~z))
  154. /* This is the central step in the MD5 algorithm. */
  155. #define MD5STEP(f, w, x, y, z, data, s) \
  156. ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
  157. /*
  158. * The core of the MD5 algorithm, this alters an existing MD5 hash to
  159. * reflect the addition of 16 longwords of new data. MD5Update blocks
  160. * the data and converts bytes into longwords for this routine.
  161. */
  162. static void MD5Transform(u32 buf[4], u32 const in[16])
  163. {
  164. register u32 a, b, c, d;
  165. a = buf[0];
  166. b = buf[1];
  167. c = buf[2];
  168. d = buf[3];
  169. MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
  170. MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
  171. MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
  172. MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
  173. MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
  174. MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
  175. MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
  176. MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
  177. MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
  178. MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
  179. MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
  180. MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
  181. MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
  182. MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
  183. MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
  184. MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
  185. MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
  186. MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
  187. MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
  188. MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
  189. MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
  190. MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
  191. MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
  192. MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
  193. MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
  194. MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
  195. MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
  196. MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
  197. MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
  198. MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
  199. MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
  200. MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
  201. MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
  202. MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
  203. MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
  204. MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
  205. MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
  206. MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
  207. MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
  208. MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
  209. MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
  210. MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
  211. MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
  212. MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
  213. MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
  214. MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
  215. MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
  216. MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
  217. MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
  218. MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
  219. MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
  220. MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
  221. MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
  222. MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
  223. MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
  224. MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
  225. MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
  226. MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
  227. MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
  228. MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
  229. MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
  230. MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
  231. MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
  232. MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
  233. buf[0] += a;
  234. buf[1] += b;
  235. buf[2] += c;
  236. buf[3] += d;
  237. }
  238. /* my code from here */
  239. static unsigned char md5_digest[16];
  240. static void
  241. md5_final(struct MD5Context *c)
  242. {
  243. MD5Final(md5_digest, c);
  244. }
  245. static unsigned char *
  246. md5_get_digest(void *c)
  247. {
  248. return md5_digest;
  249. }
  250. static void
  251. md5_register_factory(rdf_digest_factory *factory)
  252. {
  253. factory->context_length = sizeof(struct MD5Context);
  254. factory->digest_length = 16;
  255. factory->init = (void (*)(void *))MD5Init;
  256. factory->update = (void (*)(void *, unsigned char*, size_t))MD5Update;
  257. factory->final = (void (*)(void *))md5_final;
  258. factory->get_digest = (unsigned char *(*)(void *))md5_get_digest;
  259. }
  260. void
  261. md5_constructor(void)
  262. {
  263. rdf_digest_register_factory("MD5", &md5_register_factory);
  264. }