source: filezilla/trunk/fuentes/src/putty/sshmd5.c @ 130

Last change on this file since 130 was 130, checked in by jrpelegrina, 4 years ago

First release to xenial

File size: 9.9 KB
Line 
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
22static 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
30static 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
118void MD5Init(struct MD5Context *s)
119{
120    MD5_Core_Init(&s->core);
121    s->blkused = 0;
122    s->lenhi = s->lenlo = 0;
123}
124
125void 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
168void 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
206void 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
224void *hmacmd5_make_context(void *cipher_ctx)
225{
226    return snewn(3, struct MD5Context);
227}
228
229void hmacmd5_free_context(void *handle)
230{
231    smemclr(handle, 3*sizeof(struct MD5Context));
232    sfree(handle);
233}
234
235void 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
257static void hmacmd5_key_16(void *handle, unsigned char *key)
258{
259    hmacmd5_key(handle, key, 16);
260}
261
262static void hmacmd5_start(void *handle)
263{
264    struct MD5Context *keys = (struct MD5Context *)handle;
265
266    keys[2] = keys[0];                /* structure copy */
267}
268
269static 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
275static 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
288static 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
295static 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
306void 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
312static 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
321static 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
327static 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
335const 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};
Note: See TracBrowser for help on using the repository browser.