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 typedef struct {
  23     uint32 h[4];
  24 } MD5_Core_State;
  25
  26 void MD5_Core_Init(MD5_Core_State *s) {
  27     s->h[0] = 0x67452301;
  28     s->h[1] = 0xefcdab89;
  29     s->h[2] = 0x98badcfe;
  30     s->h[3] = 0x10325476;
  31 }
  32
  33 void MD5_Block(MD5_Core_State *s, uint32 *block) {
  34     uint32 a,b,c,d;
  35
  36     a = s->h[0]; b = s->h[1]; c = s->h[2]; d = s->h[3];
  37
  38     subround(F, a, b, c, d, 0, 7, 0xd76aa478);
  39     subround(F, d, a, b, c, 1, 12, 0xe8c7b756);
  40     subround(F, c, d, a, b, 2, 17, 0x242070db);
  41     subround(F, b, c, d, a, 3, 22, 0xc1bdceee);
  42     subround(F, a, b, c, d, 4, 7, 0xf57c0faf);
  43     subround(F, d, a, b, c, 5, 12, 0x4787c62a);
  44     subround(F, c, d, a, b, 6, 17, 0xa8304613);
  45     subround(F, b, c, d, a, 7, 22, 0xfd469501);
  46     subround(F, a, b, c, d, 8, 7, 0x698098d8);
  47     subround(F, d, a, b, c, 9, 12, 0x8b44f7af);
  48     subround(F, c, d, a, b, 10, 17, 0xffff5bb1);
  49     subround(F, b, c, d, a, 11, 22, 0x895cd7be);
  50     subround(F, a, b, c, d, 12, 7, 0x6b901122);
  51     subround(F, d, a, b, c, 13, 12, 0xfd987193);
  52     subround(F, c, d, a, b, 14, 17, 0xa679438e);
  53     subround(F, b, c, d, a, 15, 22, 0x49b40821);
  54     subround(G, a, b, c, d, 1, 5, 0xf61e2562);
  55     subround(G, d, a, b, c, 6, 9, 0xc040b340);
  56     subround(G, c, d, a, b, 11, 14, 0x265e5a51);
  57     subround(G, b, c, d, a, 0, 20, 0xe9b6c7aa);
  58     subround(G, a, b, c, d, 5, 5, 0xd62f105d);
  59     subround(G, d, a, b, c, 10, 9, 0x02441453);
  60     subround(G, c, d, a, b, 15, 14, 0xd8a1e681);
  61     subround(G, b, c, d, a, 4, 20, 0xe7d3fbc8);
  62     subround(G, a, b, c, d, 9, 5, 0x21e1cde6);
  63     subround(G, d, a, b, c, 14, 9, 0xc33707d6);
  64     subround(G, c, d, a, b, 3, 14, 0xf4d50d87);
  65     subround(G, b, c, d, a, 8, 20, 0x455a14ed);
  66     subround(G, a, b, c, d, 13, 5, 0xa9e3e905);
  67     subround(G, d, a, b, c, 2, 9, 0xfcefa3f8);
  68     subround(G, c, d, a, b, 7, 14, 0x676f02d9);
  69     subround(G, b, c, d, a, 12, 20, 0x8d2a4c8a);
  70     subround(H, a, b, c, d, 5, 4, 0xfffa3942);
  71     subround(H, d, a, b, c, 8, 11, 0x8771f681);
  72     subround(H, c, d, a, b, 11, 16, 0x6d9d6122);
  73     subround(H, b, c, d, a, 14, 23, 0xfde5380c);
  74     subround(H, a, b, c, d, 1, 4, 0xa4beea44);
  75     subround(H, d, a, b, c, 4, 11, 0x4bdecfa9);
  76     subround(H, c, d, a, b, 7, 16, 0xf6bb4b60);
  77     subround(H, b, c, d, a, 10, 23, 0xbebfbc70);
  78     subround(H, a, b, c, d, 13, 4, 0x289b7ec6);
  79     subround(H, d, a, b, c, 0, 11, 0xeaa127fa);
  80     subround(H, c, d, a, b, 3, 16, 0xd4ef3085);
  81     subround(H, b, c, d, a, 6, 23, 0x04881d05);
  82     subround(H, a, b, c, d, 9, 4, 0xd9d4d039);
  83     subround(H, d, a, b, c, 12, 11, 0xe6db99e5);
  84     subround(H, c, d, a, b, 15, 16, 0x1fa27cf8);
  85     subround(H, b, c, d, a, 2, 23, 0xc4ac5665);
  86     subround(I, a, b, c, d, 0, 6, 0xf4292244);
  87     subround(I, d, a, b, c, 7, 10, 0x432aff97);
  88     subround(I, c, d, a, b, 14, 15, 0xab9423a7);
  89     subround(I, b, c, d, a, 5, 21, 0xfc93a039);
  90     subround(I, a, b, c, d, 12, 6, 0x655b59c3);
  91     subround(I, d, a, b, c, 3, 10, 0x8f0ccc92);
  92     subround(I, c, d, a, b, 10, 15, 0xffeff47d);
  93     subround(I, b, c, d, a, 1, 21, 0x85845dd1);
  94     subround(I, a, b, c, d, 8, 6, 0x6fa87e4f);
  95     subround(I, d, a, b, c, 15, 10, 0xfe2ce6e0);
  96     subround(I, c, d, a, b, 6, 15, 0xa3014314);
  97     subround(I, b, c, d, a, 13, 21, 0x4e0811a1);
  98     subround(I, a, b, c, d, 4, 6, 0xf7537e82);
  99     subround(I, d, a, b, c, 11, 10, 0xbd3af235);
 100     subround(I, c, d, a, b, 2, 15, 0x2ad7d2bb);
 101     subround(I, b, c, d, a, 9, 21, 0xeb86d391);
 102
 103     s->h[0] += a; s->h[1] += b; s->h[2] += c; s->h[3] += d;
 104 }
 105
 106 /* ----------------------------------------------------------------------
 107  * Outer MD5 algorithm: take an arbitrary length byte string,
 108  * convert it into 16-word blocks with the prescribed padding at
 109  * the end, and pass those blocks to the core MD5 algorithm.
 110  */
 111
 112 #define BLKSIZE 64
 113
 114 void MD5Init(struct MD5Context *s) {
 115     MD5_Core_Init(&s->core);
 116     s->blkused = 0;
 117     s->lenhi = s->lenlo = 0;
 118 }
 119
 120 void MD5Update(struct MD5Context *s, unsigned char const *p,
 121                unsigned len) {
 122     unsigned char *q = (unsigned char *)p;
 123     uint32 wordblock[16];
 124     uint32 lenw = len;
 125     int i;
 126
 127     /*
 128      * Update the length field.
 129      */
 130     s->lenlo += lenw;
 131     s->lenhi += (s->lenlo < lenw);
 132
 133     if (s->blkused+len < BLKSIZE) {
 134         /*
 135          * Trivial case: just add to the block.
 136          */
 137         memcpy(s->block + s->blkused, q, len);
 138         s->blkused += len;
 139     } else {
 140         /*
 141          * We must complete and process at least one block.
 142          */
 143         while (s->blkused + len >= BLKSIZE) {
 144             memcpy(s->block + s->blkused, q, BLKSIZE - s->blkused);
 145             q += BLKSIZE - s->blkused;
 146             len -= BLKSIZE - s->blkused;
 147             /* Now process the block. Gather bytes little-endian into words */
 148             for (i = 0; i < 16; i++) {
 149                 wordblock[i] =
 150                     ( ((uint32)s->block[i*4+3]) << 24 ) |
 151                     ( ((uint32)s->block[i*4+2]) << 16 ) |
 152                     ( ((uint32)s->block[i*4+1]) <<  8 ) |
 153                     ( ((uint32)s->block[i*4+0]) <<  0 );
 154             }
 155             MD5_Block(&s->core, wordblock);
 156             s->blkused = 0;
 157         }
 158         memcpy(s->block, q, len);
 159         s->blkused = len;
 160     }
 161 }
 162
 163 void MD5Final(unsigned char output[16], struct MD5Context *s) {
 164     int i;
 165     int pad;
 166     unsigned char c[64];
 167     uint32 lenhi, lenlo;
 168
 169     if (s->blkused >= 56)
 170         pad = 56 + 64 - s->blkused;
 171     else
 172         pad = 56 - s->blkused;
 173
 174     lenhi = (s->lenhi << 3) | (s->lenlo >> (32-3));
 175     lenlo = (s->lenlo << 3);
 176
 177     memset(c, 0, pad);
 178     c[0] = 0x80;
 179     MD5_Bytes(s, &c, pad);
 180
 181     c[7] = (lenhi >> 24) & 0xFF;
 182     c[6] = (lenhi >> 16) & 0xFF;
 183     c[5] = (lenhi >>  8) & 0xFF;
 184     c[4] = (lenhi >>  0) & 0xFF;
 185     c[3] = (lenlo >> 24) & 0xFF;
 186     c[2] = (lenlo >> 16) & 0xFF;
 187     c[1] = (lenlo >>  8) & 0xFF;
 188     c[0] = (lenlo >>  0) & 0xFF;
 189
 190     MD5_Bytes(s, &c, 8);
 191
 192     for (i = 0; i < 4; i++) {
 193         output[4*i+3] = (s->core.h[i] >> 24) & 0xFF;
 194         output[4*i+2] = (s->core.h[i] >> 16) & 0xFF;
 195         output[4*i+1] = (s->core.h[i] >>  8) & 0xFF;
 196         output[4*i+0] = (s->core.h[i] >>  0) & 0xFF;
 197     }
 198 }