sshmd5.c

   1 #include "ssh.h"
   2
   3 /*
   4  * MD5 implementation for PuTTY. Written directly from the spec by
   5  * Simon Tatham.
   6  */
   7
   8 /* ----------------------------------------------------------------------
   9  * Core MD5 algorithm: processes 16-word blocks into a message digest.
  10  */
  11
  12 #define F(x,y,z) ( ((x) & (y)) | ((~(x)) & (z)) )
  13 #define G(x,y,z) ( ((x) & (z)) | ((~(z)) & (y)) )
  14 #define H(x,y,z) ( (x) ^ (y) ^ (z) )
  15 #define I(x,y,z) ( (y) ^ ( (x) | ~(z) ) )
  16
  17 #define rol(x,y) ( ((x) << (y)) | (((uint32)x) >> (32-y)) )
  18
  19 #define subround(f,w,x,y,z,k,s,ti) \
  20        w = x + rol(w + f(x,y,z) + block[k] + ti, s)
  21
  22 static void MD5_Core_Init(MD5_Core_State * s)
  23 {
  24     s->h[0] = 0x67452301;
  25     s->h[1] = 0xefcdab89;
  26     s->h[2] = 0x98badcfe;
  27     s->h[3] = 0x10325476;
  28 }
  29
  30 static void MD5_Block(MD5_Core_State * s, uint32 * block)
  31 {
  32     uint32 a, b, c, d;
  33
  34     a = s->h[0];
  35     b = s->h[1];
  36     c = s->h[2];
  37     d = s->h[3];
  38
  39     subround(F, a, b, c, d, 0, 7, 0xd76aa478);
  40     subround(F, d, a, b, c, 1, 12, 0xe8c7b756);
  41     subround(F, c, d, a, b, 2, 17, 0x242070db);
  42     subround(F, b, c, d, a, 3, 22, 0xc1bdceee);
  43     subround(F, a, b, c, d, 4, 7, 0xf57c0faf);
  44     subround(F, d, a, b, c, 5, 12, 0x4787c62a);
  45     subround(F, c, d, a, b, 6, 17, 0xa8304613);
  46     subround(F, b, c, d, a, 7, 22, 0xfd469501);
  47     subround(F, a, b, c, d, 8, 7, 0x698098d8);
  48     subround(F, d, a, b, c, 9, 12, 0x8b44f7af);
  49     subround(F, c, d, a, b, 10, 17, 0xffff5bb1);
  50     subround(F, b, c, d, a, 11, 22, 0x895cd7be);
  51     subround(F, a, b, c, d, 12, 7, 0x6b901122);
  52     subround(F, d, a, b, c, 13, 12, 0xfd987193);
  53     subround(F, c, d, a, b, 14, 17, 0xa679438e);
  54     subround(F, b, c, d, a, 15, 22, 0x49b40821);
  55     subround(G, a, b, c, d, 1, 5, 0xf61e2562);
  56     subround(G, d, a, b, c, 6, 9, 0xc040b340);
  57     subround(G, c, d, a, b, 11, 14, 0x265e5a51);
  58     subround(G, b, c, d, a, 0, 20, 0xe9b6c7aa);
  59     subround(G, a, b, c, d, 5, 5, 0xd62f105d);
  60     subround(G, d, a, b, c, 10, 9, 0x02441453);
  61     subround(G, c, d, a, b, 15, 14, 0xd8a1e681);
  62     subround(G, b, c, d, a, 4, 20, 0xe7d3fbc8);
  63     subround(G, a, b, c, d, 9, 5, 0x21e1cde6);
  64     subround(G, d, a, b, c, 14, 9, 0xc33707d6);
  65     subround(G, c, d, a, b, 3, 14, 0xf4d50d87);
  66     subround(G, b, c, d, a, 8, 20, 0x455a14ed);
  67     subround(G, a, b, c, d, 13, 5, 0xa9e3e905);
  68     subround(G, d, a, b, c, 2, 9, 0xfcefa3f8);
  69     subround(G, c, d, a, b, 7, 14, 0x676f02d9);
  70     subround(G, b, c, d, a, 12, 20, 0x8d2a4c8a);
  71     subround(H, a, b, c, d, 5, 4, 0xfffa3942);
  72     subround(H, d, a, b, c, 8, 11, 0x8771f681);
  73     subround(H, c, d, a, b, 11, 16, 0x6d9d6122);
  74     subround(H, b, c, d, a, 14, 23, 0xfde5380c);
  75     subround(H, a, b, c, d, 1, 4, 0xa4beea44);
  76     subround(H, d, a, b, c, 4, 11, 0x4bdecfa9);
  77     subround(H, c, d, a, b, 7, 16, 0xf6bb4b60);
  78     subround(H, b, c, d, a, 10, 23, 0xbebfbc70);
  79     subround(H, a, b, c, d, 13, 4, 0x289b7ec6);
  80     subround(H, d, a, b, c, 0, 11, 0xeaa127fa);
  81     subround(H, c, d, a, b, 3, 16, 0xd4ef3085);
  82     subround(H, b, c, d, a, 6, 23, 0x04881d05);
  83     subround(H, a, b, c, d, 9, 4, 0xd9d4d039);
  84     subround(H, d, a, b, c, 12, 11, 0xe6db99e5);
  85     subround(H, c, d, a, b, 15, 16, 0x1fa27cf8);
  86     subround(H, b, c, d, a, 2, 23, 0xc4ac5665);
  87     subround(I, a, b, c, d, 0, 6, 0xf4292244);
  88     subround(I, d, a, b, c, 7, 10, 0x432aff97);
  89     subround(I, c, d, a, b, 14, 15, 0xab9423a7);
  90     subround(I, b, c, d, a, 5, 21, 0xfc93a039);
  91     subround(I, a, b, c, d, 12, 6, 0x655b59c3);
  92     subround(I, d, a, b, c, 3, 10, 0x8f0ccc92);
  93     subround(I, c, d, a, b, 10, 15, 0xffeff47d);
  94     subround(I, b, c, d, a, 1, 21, 0x85845dd1);
  95     subround(I, a, b, c, d, 8, 6, 0x6fa87e4f);
  96     subround(I, d, a, b, c, 15, 10, 0xfe2ce6e0);
  97     subround(I, c, d, a, b, 6, 15, 0xa3014314);
  98     subround(I, b, c, d, a, 13, 21, 0x4e0811a1);
  99     subround(I, a, b, c, d, 4, 6, 0xf7537e82);
 100     subround(I, d, a, b, c, 11, 10, 0xbd3af235);
 101     subround(I, c, d, a, b, 2, 15, 0x2ad7d2bb);
 102     subround(I, b, c, d, a, 9, 21, 0xeb86d391);
 103
 104     s->h[0] += a;
 105     s->h[1] += b;
 106     s->h[2] += c;
 107     s->h[3] += d;
 108 }
 109
 110 /* ----------------------------------------------------------------------
 111  * Outer MD5 algorithm: take an arbitrary length byte string,
 112  * convert it into 16-word blocks with the prescribed padding at
 113  * the end, and pass those blocks to the core MD5 algorithm.
 114  */
 115
 116 #define BLKSIZE 64
 117
 118 void MD5Init(struct MD5Context *s)
 119 {
 120     MD5_Core_Init(&s->core);
 121     s->blkused = 0;
 122     s->lenhi = s->lenlo = 0;
 123 }
 124
 125 void MD5Update(struct MD5Context *s, unsigned char const *p, unsigned len)
 126 {
 127     unsigned char *q = (unsigned char *) p;
 128     uint32 wordblock[16];
 129     uint32 lenw = len;
 130     int i;
 131
 132     /*
 133      * Update the length field.
 134      */
 135     s->lenlo += lenw;
 136     s->lenhi += (s->lenlo < lenw);
 137
 138     if (s->blkused + len < BLKSIZE) {
 139         /*
 140          * Trivial case: just add to the block.
 141          */
 142         memcpy(s->block + s->blkused, q, len);
 143         s->blkused += len;
 144     } else {
 145         /*
 146          * We must complete and process at least one block.
 147          */
 148         while (s->blkused + len >= BLKSIZE) {
 149             memcpy(s->block + s->blkused, q, BLKSIZE - s->blkused);
 150             q += BLKSIZE - s->blkused;
 151             len -= BLKSIZE - s->blkused;
 152             /* Now process the block. Gather bytes little-endian into words */
 153             for (i = 0; i < 16; i++) {
 154                 wordblock[i] =
 155                     (((uint32) s->block[i * 4 + 3]) << 24) |
 156                     (((uint32) s->block[i * 4 + 2]) << 16) |
 157                     (((uint32) s->block[i * 4 + 1]) << 8) |
 158                     (((uint32) s->block[i * 4 + 0]) << 0);
 159             }
 160             MD5_Block(&s->core, wordblock);
 161             s->blkused = 0;
 162         }
 163         memcpy(s->block, q, len);
 164         s->blkused = len;
 165     }
 166 }
 167
 168 void MD5Final(unsigned char output[16], struct MD5Context *s)
 169 {
 170     int i;
 171     unsigned pad;
 172     unsigned char c[64];
 173     uint32 lenhi, lenlo;
 174
 175     if (s->blkused >= 56)
 176         pad = 56 + 64 - s->blkused;
 177     else
 178         pad = 56 - s->blkused;
 179
 180     lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3));
 181     lenlo = (s->lenlo << 3);
 182
 183     memset(c, 0, pad);
 184     c[0] = 0x80;
 185     MD5Update(s, c, pad);
 186
 187     c[7] = (lenhi >> 24) & 0xFF;
 188     c[6] = (lenhi >> 16) & 0xFF;
 189     c[5] = (lenhi >> 8) & 0xFF;
 190     c[4] = (lenhi >> 0) & 0xFF;
 191     c[3] = (lenlo >> 24) & 0xFF;
 192     c[2] = (lenlo >> 16) & 0xFF;
 193     c[1] = (lenlo >> 8) & 0xFF;
 194     c[0] = (lenlo >> 0) & 0xFF;
 195
 196     MD5Update(s, c, 8);
 197
 198     for (i = 0; i < 4; i++) {
 199         output[4 * i + 3] = (s->core.h[i] >> 24) & 0xFF;
 200         output[4 * i + 2] = (s->core.h[i] >> 16) & 0xFF;
 201         output[4 * i + 1] = (s->core.h[i] >> 8) & 0xFF;
 202         output[4 * i + 0] = (s->core.h[i] >> 0) & 0xFF;
 203     }
 204 }
 205
 206 void MD5Simple(void const *p, unsigned len, unsigned char output[16])
 207 {
 208     struct MD5Context s;
 209
 210     MD5Init(&s);
 211     MD5Update(&s, (unsigned char const *)p, len);
 212     MD5Final(output, &s);
 213     smemclr(&s, sizeof(s));
 214 }
 215
 216 /* ----------------------------------------------------------------------
 217  * The above is the MD5 algorithm itself. Now we implement the
 218  * HMAC wrapper on it.
 219  *
 220  * Some of these functions are exported directly, because they are
 221  * useful elsewhere (SOCKS5 CHAP authentication uses HMAC-MD5).
 222  */
 223
 224 void *hmacmd5_make_context(void *cipher_ctx)
 225 {
 226     return snewn(3, struct MD5Context);
 227 }
 228
 229 void hmacmd5_free_context(void *handle)
 230 {
 231     smemclr(handle, 3*sizeof(struct MD5Context));
 232     sfree(handle);
 233 }
 234
 235 void hmacmd5_key(void *handle, void const *keyv, int len)
 236 {
 237     struct MD5Context *keys = (struct MD5Context *)handle;
 238     unsigned char foo[64];
 239     unsigned char const *key = (unsigned char const *)keyv;
 240     int i;
 241
 242     memset(foo, 0x36, 64);
 243     for (i = 0; i < len && i < 64; i++)
 244         foo[i] ^= key[i];
 245     MD5Init(&keys[0]);
 246     MD5Update(&keys[0], foo, 64);
 247
 248     memset(foo, 0x5C, 64);
 249     for (i = 0; i < len && i < 64; i++)
 250         foo[i] ^= key[i];
 251     MD5Init(&keys[1]);
 252     MD5Update(&keys[1], foo, 64);
 253
 254     smemclr(foo, 64);                  /* burn the evidence */
 255 }
 256
 257 static void hmacmd5_key_16(void *handle, unsigned char *key)
 258 {
 259     hmacmd5_key(handle, key, 16);
 260 }
 261
 262 static void hmacmd5_start(void *handle)
 263 {
 264     struct MD5Context *keys = (struct MD5Context *)handle;
 265
 266     keys[2] = keys[0];                /* structure copy */
 267 }
 268
 269 static void hmacmd5_bytes(void *handle, unsigned char const *blk, int len)
 270 {
 271     struct MD5Context *keys = (struct MD5Context *)handle;
 272     MD5Update(&keys[2], blk, len);
 273 }
 274
 275 static void hmacmd5_genresult(void *handle, unsigned char *hmac)
 276 {
 277     struct MD5Context *keys = (struct MD5Context *)handle;
 278     struct MD5Context s;
 279     unsigned char intermediate[16];
 280
 281     s = keys[2];                       /* structure copy */
 282     MD5Final(intermediate, &s);
 283     s = keys[1];                       /* structure copy */
 284     MD5Update(&s, intermediate, 16);
 285     MD5Final(hmac, &s);
 286 }
 287
 288 static int hmacmd5_verresult(void *handle, unsigned char const *hmac)
 289 {
 290     unsigned char correct[16];
 291     hmacmd5_genresult(handle, correct);
 292     return smemeq(correct, hmac, 16);
 293 }
 294
 295 static void hmacmd5_do_hmac_internal(void *handle,
 296                                      unsigned char const *blk, int len,
 297                                      unsigned char const *blk2, int len2,
 298                                      unsigned char *hmac)
 299 {
 300     hmacmd5_start(handle);
 301     hmacmd5_bytes(handle, blk, len);
 302     if (blk2) hmacmd5_bytes(handle, blk2, len2);
 303     hmacmd5_genresult(handle, hmac);
 304 }
 305
 306 void hmacmd5_do_hmac(void *handle, unsigned char const *blk, int len,
 307                      unsigned char *hmac)
 308 {
 309     hmacmd5_do_hmac_internal(handle, blk, len, NULL, 0, hmac);
 310 }
 311
 312 static void hmacmd5_do_hmac_ssh(void *handle, unsigned char const *blk, int len,
 313                                 unsigned long seq, unsigned char *hmac)
 314 {
 315     unsigned char seqbuf[16];
 316
 317     PUT_32BIT_MSB_FIRST(seqbuf, seq);
 318     hmacmd5_do_hmac_internal(handle, seqbuf, 4, blk, len, hmac);
 319 }
 320
 321 static void hmacmd5_generate(void *handle, unsigned char *blk, int len,
 322                              unsigned long seq)
 323 {
 324     hmacmd5_do_hmac_ssh(handle, blk, len, seq, blk + len);
 325 }
 326
 327 static int hmacmd5_verify(void *handle, unsigned char *blk, int len,
 328                           unsigned long seq)
 329 {
 330     unsigned char correct[16];
 331     hmacmd5_do_hmac_ssh(handle, blk, len, seq, correct);
 332     return smemeq(correct, blk + len, 16);
 333 }
 334
 335 const struct ssh_mac ssh_hmac_md5 = {
 336     hmacmd5_make_context, hmacmd5_free_context, hmacmd5_key_16,
 337     hmacmd5_generate, hmacmd5_verify,
 338     hmacmd5_start, hmacmd5_bytes, hmacmd5_genresult, hmacmd5_verresult,
 339     "hmac-md5", "hmac-md5-etm@openssh.com",
 340     16, 16,
 341     "HMAC-MD5"
 342 };