hash-md5.c

   1 #include <endian.h>
   2 #include <stdint.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "hash-md5.h"
   7
   8 static inline uint32_t rol32(const uint32_t x, const unsigned int n)
   9 {
  10         return (x << n) | (x >> (32 - n));
  11 }
  12
  13 static inline uint32_t F(const uint32_t X, const uint32_t Y, const uint32_t Z)
  14 {
  15         return (X & Y) | (~X & Z);
  16 }
  17
  18 static inline uint32_t G(const uint32_t X, const uint32_t Y, const uint32_t Z)
  19 {
  20         return (X & Z) | (Y & ~Z);
  21 }
  22
  23 static inline uint32_t H(const uint32_t X, const uint32_t Y, const uint32_t Z)
  24 {
  25         return X ^ Y ^ Z;
  26 }
  27
  28 static inline uint32_t I(const uint32_t X, const uint32_t Y, const uint32_t Z)
  29 {
  30         return Y ^ (X | ~Z);
  31 }
  32
  33 struct md5_context {
  34         uint32_t A, B, C, D;
  35         uint64_t len;   /* in bits */
  36         uint8_t m[64];
  37         unsigned int m_len;
  38 };
  39
  40 #define MD5(a, b, c, d, F, k, s, Ti)    \
  41         a = b + rol32(a + F(b, c, d) + X[k] + Ti, s)
  42
  43 static void __md5_update(void *_ctx, const uint8_t *m)
  44 {
  45         struct md5_context *ctx = _ctx;
  46         uint32_t A, B, C, D;
  47         uint32_t X[16];
  48         int i;
  49
  50         A = ctx->A;
  51         B = ctx->B;
  52         C = ctx->C;
  53         D = ctx->D;
  54         for (i = 0; i < 16; i++)
  55                 X[i] = le32toh(*(uint32_t *)(m + i * sizeof(uint32_t)));
  56
  57         MD5(A, B, C, D, F,  0,  7, 0xd76aa478);
  58         MD5(D, A, B, C, F,  1, 12, 0xe8c7b756);
  59         MD5(C, D, A, B, F,  2, 17, 0x242070db);
  60         MD5(B, C, D, A, F,  3, 22, 0xc1bdceee);
  61         MD5(A, B, C, D, F,  4,  7, 0xf57c0faf);
  62         MD5(D, A, B, C, F,  5, 12, 0x4787c62a);
  63         MD5(C, D, A, B, F,  6, 17, 0xa8304613);
  64         MD5(B, C, D, A, F,  7, 22, 0xfd469501);
  65         MD5(A, B, C, D, F,  8,  7, 0x698098d8);
  66         MD5(D, A, B, C, F,  9, 12, 0x8b44f7af);
  67         MD5(C, D, A, B, F, 10, 17, 0xffff5bb1);
  68         MD5(B, C, D, A, F, 11, 22, 0x895cd7be);
  69         MD5(A, B, C, D, F, 12,  7, 0x6b901122);
  70         MD5(D, A, B, C, F, 13, 12, 0xfd987193);
  71         MD5(C, D, A, B, F, 14, 17, 0xa679438e);
  72         MD5(B, C, D, A, F, 15, 22, 0x49b40821);
  73
  74         MD5(A, B, C, D, G,  1,  5, 0xf61e2562);
  75         MD5(D, A, B, C, G,  6,  9, 0xc040b340);
  76         MD5(C, D, A, B, G, 11, 14, 0x265e5a51);
  77         MD5(B, C, D, A, G,  0, 20, 0xe9b6c7aa);
  78         MD5(A, B, C, D, G,  5,  5, 0xd62f105d);
  79         MD5(D, A, B, C, G, 10,  9, 0x02441453);
  80         MD5(C, D, A, B, G, 15, 14, 0xd8a1e681);
  81         MD5(B, C, D, A, G,  4, 20, 0xe7d3fbc8);
  82         MD5(A, B, C, D, G,  9,  5, 0x21e1cde6);
  83         MD5(D, A, B, C, G, 14,  9, 0xc33707d6);
  84         MD5(C, D, A, B, G,  3, 14, 0xf4d50d87);
  85         MD5(B, C, D, A, G,  8, 20, 0x455a14ed);
  86         MD5(A, B, C, D, G, 13,  5, 0xa9e3e905);
  87         MD5(D, A, B, C, G,  2,  9, 0xfcefa3f8);
  88         MD5(C, D, A, B, G,  7, 14, 0x676f02d9);
  89         MD5(B, C, D, A, G, 12, 20, 0x8d2a4c8a);
  90
  91         MD5(A, B, C, D, H,  5,  4, 0xfffa3942);
  92         MD5(D, A, B, C, H,  8, 11, 0x8771f681);
  93         MD5(C, D, A, B, H, 11, 16, 0x6d9d6122);
  94         MD5(B, C, D, A, H, 14, 23, 0xfde5380c);
  95         MD5(A, B, C, D, H,  1,  4, 0xa4beea44);
  96         MD5(D, A, B, C, H,  4, 11, 0x4bdecfa9);
  97         MD5(C, D, A, B, H,  7, 16, 0xf6bb4b60);
  98         MD5(B, C, D, A, H, 10, 23, 0xbebfbc70);
  99         MD5(A, B, C, D, H, 13,  4, 0x289b7ec6);
 100         MD5(D, A, B, C, H,  0, 11, 0xeaa127fa);
 101         MD5(C, D, A, B, H,  3, 16, 0xd4ef3085);
 102         MD5(B, C, D, A, H,  6, 23, 0x04881d05);
 103         MD5(A, B, C, D, H,  9,  4, 0xd9d4d039);
 104         MD5(D, A, B, C, H, 12, 11, 0xe6db99e5);
 105         MD5(C, D, A, B, H, 15, 16, 0x1fa27cf8);
 106         MD5(B, C, D, A, H,  2, 23, 0xc4ac5665);
 107
 108         MD5(A, B, C, D, I,  0,  6, 0xf4292244);
 109         MD5(D, A, B, C, I,  7, 10, 0x432aff97);
 110         MD5(C, D, A, B, I, 14, 15, 0xab9423a7);
 111         MD5(B, C, D, A, I,  5, 21, 0xfc93a039);
 112         MD5(A, B, C, D, I, 12,  6, 0x655b59c3);
 113         MD5(D, A, B, C, I,  3, 10, 0x8f0ccc92);
 114         MD5(C, D, A, B, I, 10, 15, 0xffeff47d);
 115         MD5(B, C, D, A, I,  1, 21, 0x85845dd1);
 116         MD5(A, B, C, D, I,  8,  6, 0x6fa87e4f);
 117         MD5(D, A, B, C, I, 15, 10, 0xfe2ce6e0);
 118         MD5(C, D, A, B, I,  6, 15, 0xa3014314);
 119         MD5(B, C, D, A, I, 13, 21, 0x4e0811a1);
 120         MD5(A, B, C, D, I,  4,  6, 0xf7537e82);
 121         MD5(D, A, B, C, I, 11, 10, 0xbd3af235);
 122         MD5(C, D, A, B, I,  2, 15, 0x2ad7d2bb);
 123         MD5(B, C, D, A, I,  9, 21, 0xeb86d391);
 124
 125         ctx->A += A;
 126         ctx->B += B;
 127         ctx->C += C;
 128         ctx->D += D;
 129 }
 130
 131 void md5_update(void *_ctx, const uint8_t *m)
 132 {
 133         struct md5_context *ctx = _ctx;
 134
 135         __md5_update(ctx, m);
 136         ctx->len += 512;
 137 }
 138
 139 void _md5_update(void *_ctx, const uint8_t *m, unsigned int len)
 140 {
 141         struct md5_context *ctx = _ctx;
 142
 143         while (len > 0) {
 144                 ctx->m[ctx->m_len] = *m;
 145                 ctx->m_len++;
 146                 m++;
 147                 len--;
 148                 ctx->len += 8;
 149
 150                 if (ctx->m_len == 64) {
 151                         __md5_update(ctx, ctx->m);
 152                         ctx->m_len = 0;
 153                 }
 154         }
 155 }
 156
 157 void *md5_init_context(void)
 158 {
 159         struct md5_context *ctx;
 160
 161         ctx = malloc(sizeof(struct md5_context));
 162         if (!ctx)
 163                 return NULL;
 164
 165         ctx->A = 0x67452301;
 166         ctx->B = 0xefcdab89;
 167         ctx->C = 0x98badcfe;
 168         ctx->D = 0x10325476;
 169         ctx->len = 0;
 170
 171         memset(ctx->m, 0, 64);
 172         ctx->m_len = 0;
 173
 174         return ctx;
 175 }
 176
 177 void md5_fini_context(void *_ctx)
 178 {
 179         struct md5_context *ctx = _ctx;
 180
 181         memset(ctx, 0, sizeof(struct md5_context));
 182         free(ctx);
 183 }
 184
 185 void md5_fini(void *_ctx)
 186 {
 187         struct md5_context *ctx = _ctx;
 188
 189         ctx->m[ctx->m_len] = 0x80;
 190         ctx->m_len++;
 191         if (ctx->m_len <= 64 - 8) {
 192                 while (ctx->m_len <= 64 - 8) {
 193                         ctx->m[ctx->m_len] = 0;
 194                         ctx->m_len++;
 195                 }
 196         } else {
 197                 while (ctx->m_len < 64) {
 198                         ctx->m[ctx->m_len] = 0;
 199                         ctx->m_len++;
 200                 }
 201                 __md5_update(ctx, ctx->m);
 202                 memset(ctx->m, 0, 64 - 8);
 203         }
 204         *(uint64_t *)&ctx->m[64 - 8] = htole64(ctx->len);
 205         __md5_update(ctx, ctx->m);
 206 }
 207
 208 void md5_digest(void *_ctx, uint8_t *digest)
 209 {
 210         struct md5_context *ctx = _ctx;
 211
 212         *(uint32_t *)&digest[0] = htole32(ctx->A);
 213         *(uint32_t *)&digest[4] = htole32(ctx->B);
 214         *(uint32_t *)&digest[8] = htole32(ctx->C);
 215         *(uint32_t *)&digest[12] = htole32(ctx->D);
 216 }