git.distorted.org.uk Git - u/mdw/putty/blob - 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 void MD5_Core_Init(MD5_Core_State *s) {
  23     s->h[0] = 0x67452301;
  24     s->h[1] = 0xefcdab89;
  25     s->h[2] = 0x98badcfe;
  26     s->h[3] = 0x10325476;
  27 }
  28
  29 void MD5_Block(MD5_Core_State *s, uint32 *block) {
  30     uint32 a,b,c,d;
  31
  32     a = s->h[0]; b = s->h[1]; c = s->h[2]; d = s->h[3];
  33
  34     subround(F, a, b, c, d, 0, 7, 0xd76aa478);
  35     subround(F, d, a, b, c, 1, 12, 0xe8c7b756);
  36     subround(F, c, d, a, b, 2, 17, 0x242070db);
  37     subround(F, b, c, d, a, 3, 22, 0xc1bdceee);
  38     subround(F, a, b, c, d, 4, 7, 0xf57c0faf);
  39     subround(F, d, a, b, c, 5, 12, 0x4787c62a);
  40     subround(F, c, d, a, b, 6, 17, 0xa8304613);
  41     subround(F, b, c, d, a, 7, 22, 0xfd469501);
  42     subround(F, a, b, c, d, 8, 7, 0x698098d8);
  43     subround(F, d, a, b, c, 9, 12, 0x8b44f7af);
  44     subround(F, c, d, a, b, 10, 17, 0xffff5bb1);
  45     subround(F, b, c, d, a, 11, 22, 0x895cd7be);
  46     subround(F, a, b, c, d, 12, 7, 0x6b901122);
  47     subround(F, d, a, b, c, 13, 12, 0xfd987193);
  48     subround(F, c, d, a, b, 14, 17, 0xa679438e);
  49     subround(F, b, c, d, a, 15, 22, 0x49b40821);
  50     subround(G, a, b, c, d, 1, 5, 0xf61e2562);
  51     subround(G, d, a, b, c, 6, 9, 0xc040b340);
  52     subround(G, c, d, a, b, 11, 14, 0x265e5a51);
  53     subround(G, b, c, d, a, 0, 20, 0xe9b6c7aa);
  54     subround(G, a, b, c, d, 5, 5, 0xd62f105d);
  55     subround(G, d, a, b, c, 10, 9, 0x02441453);
  56     subround(G, c, d, a, b, 15, 14, 0xd8a1e681);
  57     subround(G, b, c, d, a, 4, 20, 0xe7d3fbc8);
  58     subround(G, a, b, c, d, 9, 5, 0x21e1cde6);
  59     subround(G, d, a, b, c, 14, 9, 0xc33707d6);
  60     subround(G, c, d, a, b, 3, 14, 0xf4d50d87);
  61     subround(G, b, c, d, a, 8, 20, 0x455a14ed);
  62     subround(G, a, b, c, d, 13, 5, 0xa9e3e905);
  63     subround(G, d, a, b, c, 2, 9, 0xfcefa3f8);
  64     subround(G, c, d, a, b, 7, 14, 0x676f02d9);
  65     subround(G, b, c, d, a, 12, 20, 0x8d2a4c8a);
  66     subround(H, a, b, c, d, 5, 4, 0xfffa3942);
  67     subround(H, d, a, b, c, 8, 11, 0x8771f681);
  68     subround(H, c, d, a, b, 11, 16, 0x6d9d6122);
  69     subround(H, b, c, d, a, 14, 23, 0xfde5380c);
  70     subround(H, a, b, c, d, 1, 4, 0xa4beea44);
  71     subround(H, d, a, b, c, 4, 11, 0x4bdecfa9);
  72     subround(H, c, d, a, b, 7, 16, 0xf6bb4b60);
  73     subround(H, b, c, d, a, 10, 23, 0xbebfbc70);
  74     subround(H, a, b, c, d, 13, 4, 0x289b7ec6);
  75     subround(H, d, a, b, c, 0, 11, 0xeaa127fa);
  76     subround(H, c, d, a, b, 3, 16, 0xd4ef3085);
  77     subround(H, b, c, d, a, 6, 23, 0x04881d05);
  78     subround(H, a, b, c, d, 9, 4, 0xd9d4d039);
  79     subround(H, d, a, b, c, 12, 11, 0xe6db99e5);
  80     subround(H, c, d, a, b, 15, 16, 0x1fa27cf8);
  81     subround(H, b, c, d, a, 2, 23, 0xc4ac5665);
  82     subround(I, a, b, c, d, 0, 6, 0xf4292244);
  83     subround(I, d, a, b, c, 7, 10, 0x432aff97);
  84     subround(I, c, d, a, b, 14, 15, 0xab9423a7);
  85     subround(I, b, c, d, a, 5, 21, 0xfc93a039);
  86     subround(I, a, b, c, d, 12, 6, 0x655b59c3);
  87     subround(I, d, a, b, c, 3, 10, 0x8f0ccc92);
  88     subround(I, c, d, a, b, 10, 15, 0xffeff47d);
  89     subround(I, b, c, d, a, 1, 21, 0x85845dd1);
  90     subround(I, a, b, c, d, 8, 6, 0x6fa87e4f);
  91     subround(I, d, a, b, c, 15, 10, 0xfe2ce6e0);
  92     subround(I, c, d, a, b, 6, 15, 0xa3014314);
  93     subround(I, b, c, d, a, 13, 21, 0x4e0811a1);
  94     subround(I, a, b, c, d, 4, 6, 0xf7537e82);
  95     subround(I, d, a, b, c, 11, 10, 0xbd3af235);
  96     subround(I, c, d, a, b, 2, 15, 0x2ad7d2bb);
  97     subround(I, b, c, d, a, 9, 21, 0xeb86d391);
  98
  99     s->h[0] += a; s->h[1] += b; s->h[2] += c; s->h[3] += d;
 100 }
 101
 102 /* ----------------------------------------------------------------------
 103  * Outer MD5 algorithm: take an arbitrary length byte string,
 104  * convert it into 16-word blocks with the prescribed padding at
 105  * the end, and pass those blocks to the core MD5 algorithm.
 106  */
 107
 108 #define BLKSIZE 64
 109
 110 void MD5Init(struct MD5Context *s) {
 111     MD5_Core_Init(&s->core);
 112     s->blkused = 0;
 113     s->lenhi = s->lenlo = 0;
 114 }
 115
 116 void MD5Update(struct MD5Context *s, unsigned char const *p,
 117                unsigned len) {
 118     unsigned char *q = (unsigned char *)p;
 119     uint32 wordblock[16];
 120     uint32 lenw = len;
 121     int i;
 122
 123     /*
 124      * Update the length field.
 125      */
 126     s->lenlo += lenw;
 127     s->lenhi += (s->lenlo < lenw);
 128
 129     if (s->blkused+len < BLKSIZE) {
 130         /*
 131          * Trivial case: just add to the block.
 132          */
 133         memcpy(s->block + s->blkused, q, len);
 134         s->blkused += len;
 135     } else {
 136         /*
 137          * We must complete and process at least one block.
 138          */
 139         while (s->blkused + len >= BLKSIZE) {
 140             memcpy(s->block + s->blkused, q, BLKSIZE - s->blkused);
 141             q += BLKSIZE - s->blkused;
 142             len -= BLKSIZE - s->blkused;
 143             /* Now process the block. Gather bytes little-endian into words */
 144             for (i = 0; i < 16; i++) {
 145                 wordblock[i] =
 146                     ( ((uint32)s->block[i*4+3]) << 24 ) |
 147                     ( ((uint32)s->block[i*4+2]) << 16 ) |
 148                     ( ((uint32)s->block[i*4+1]) <<  8 ) |
 149                     ( ((uint32)s->block[i*4+0]) <<  0 );
 150             }
 151             MD5_Block(&s->core, wordblock);
 152             s->blkused = 0;
 153         }
 154         memcpy(s->block, q, len);
 155         s->blkused = len;
 156     }
 157 }
 158
 159 void MD5Final(unsigned char output[16], struct MD5Context *s) {
 160     int i;
 161     unsigned pad;
 162     unsigned char c[64];
 163     uint32 lenhi, lenlo;
 164
 165     if (s->blkused >= 56)
 166         pad = 56 + 64 - s->blkused;
 167     else
 168         pad = 56 - s->blkused;
 169
 170     lenhi = (s->lenhi << 3) | (s->lenlo >> (32-3));
 171     lenlo = (s->lenlo << 3);
 172
 173     memset(c, 0, pad);
 174     c[0] = 0x80;
 175     MD5Update(s, c, pad);
 176
 177     c[7] = (lenhi >> 24) & 0xFF;
 178     c[6] = (lenhi >> 16) & 0xFF;
 179     c[5] = (lenhi >>  8) & 0xFF;
 180     c[4] = (lenhi >>  0) & 0xFF;
 181     c[3] = (lenlo >> 24) & 0xFF;
 182     c[2] = (lenlo >> 16) & 0xFF;
 183     c[1] = (lenlo >>  8) & 0xFF;
 184     c[0] = (lenlo >>  0) & 0xFF;
 185
 186     MD5Update(s, c, 8);
 187
 188     for (i = 0; i < 4; i++) {
 189         output[4*i+3] = (s->core.h[i] >> 24) & 0xFF;
 190         output[4*i+2] = (s->core.h[i] >> 16) & 0xFF;
 191         output[4*i+1] = (s->core.h[i] >>  8) & 0xFF;
 192         output[4*i+0] = (s->core.h[i] >>  0) & 0xFF;
 193     }
 194 }
 195
 196 /* ----------------------------------------------------------------------
 197  * The above is the MD5 algorithm itself. Now we implement the
 198  * HMAC wrapper on it.
 199  */
 200
 201 static struct MD5Context md5_cs_mac_s1, md5_cs_mac_s2;
 202 static struct MD5Context md5_sc_mac_s1, md5_sc_mac_s2;
 203
 204 static void md5_key(struct MD5Context *s1, struct MD5Context *s2,
 205                     unsigned char *key, int len) {
 206     unsigned char foo[64];
 207     int i;
 208
 209     memset(foo, 0x36, 64);
 210     for (i = 0; i < len && i < 64; i++)
 211         foo[i] ^= key[i];
 212     MD5Init(s1);
 213     MD5Update(s1, foo, 64);
 214
 215     memset(foo, 0x5C, 64);
 216     for (i = 0; i < len && i < 64; i++)
 217         foo[i] ^= key[i];
 218     MD5Init(s2);
 219     MD5Update(s2, foo, 64);
 220
 221     memset(foo, 0, 64);                /* burn the evidence */
 222 }
 223
 224 static void md5_cskey(unsigned char *key) {
 225     md5_key(&md5_cs_mac_s1, &md5_cs_mac_s2, key, 16);
 226 }
 227
 228 static void md5_sckey(unsigned char *key) {
 229     md5_key(&md5_sc_mac_s1, &md5_sc_mac_s2, key, 16);
 230 }
 231
 232 static void md5_do_hmac(struct MD5Context *s1, struct MD5Context *s2,
 233                          unsigned char *blk, int len, unsigned long seq,
 234                          unsigned char *hmac) {
 235     struct MD5Context s;
 236     unsigned char intermediate[16];
 237
 238     intermediate[0] = (unsigned char)((seq >> 24) & 0xFF);
 239     intermediate[1] = (unsigned char)((seq >> 16) & 0xFF);
 240     intermediate[2] = (unsigned char)((seq >>  8) & 0xFF);
 241     intermediate[3] = (unsigned char)((seq      ) & 0xFF);
 242
 243     s = *s1;                           /* structure copy */
 244     MD5Update(&s, intermediate, 4);
 245     MD5Update(&s, blk, len);
 246     MD5Final(intermediate, &s);
 247     s = *s2;                           /* structure copy */
 248     MD5Update(&s, intermediate, 16);
 249     MD5Final(hmac, &s);
 250 }
 251
 252 static void md5_generate(unsigned char *blk, int len, unsigned long seq) {
 253     md5_do_hmac(&md5_cs_mac_s1, &md5_cs_mac_s2, blk, len, seq, blk+len);
 254 }
 255
 256 static int md5_verify(unsigned char *blk, int len, unsigned long seq) {
 257     unsigned char correct[16];
 258     md5_do_hmac(&md5_sc_mac_s1, &md5_sc_mac_s2, blk, len, seq, correct);
 259     return !memcmp(correct, blk+len, 16);
 260 }
 261
 262 struct ssh_mac ssh_md5 = {
 263     md5_cskey, md5_sckey,
 264     md5_generate,
 265     md5_verify,
 266     "hmac-md5",
 267     16
 268 };