Annotation of embedaddon/freevrrpd/md5.c, revision 1.1.1.1
1.1 misho 1: /*
2: **********************************************************************
3: ** md5.c **
4: ** RSA Data Security, Inc. MD5 Message Digest Algorithm **
5: ** Created: 2/17/90 RLR **
6: ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version **
7: **********************************************************************
8: */
9:
10: /*
11: **********************************************************************
12: ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
13: ** **
14: ** License to copy and use this software is granted provided that **
15: ** it is identified as the "RSA Data Security, Inc. MD5 Message **
16: ** Digest Algorithm" in all material mentioning or referencing this **
17: ** software or this function. **
18: ** **
19: ** License is also granted to make and use derivative works **
20: ** provided that such works are identified as "derived from the RSA **
21: ** Data Security, Inc. MD5 Message Digest Algorithm" in all **
22: ** material mentioning or referencing the derived work. **
23: ** **
24: ** RSA Data Security, Inc. makes no representations concerning **
25: ** either the merchantability of this software or the suitability **
26: ** of this software for any particular purpose. It is provided "as **
27: ** is" without express or implied warranty of any kind. **
28: ** **
29: ** These notices must be retained in any copies of any part of this **
30: ** documentation and/or software. **
31: **********************************************************************
32: */
33:
34: /* -- include the following line if the md5.h header file is separate -- */
35: #include "md5.h"
36: #include <string.h>
37:
38: /* forward declaration */
39: static void Transform ();
40:
41: static unsigned char PADDING[64] = {
42: 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
43: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
44: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
45: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
46: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
47: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
48: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
49: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
50: };
51:
52: /* F, G and H are basic MD5 functions: selection, majority, parity */
53: #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
54: #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
55: #define H(x, y, z) ((x) ^ (y) ^ (z))
56: #define I(x, y, z) ((y) ^ ((x) | (~z)))
57:
58: /* ROTATE_LEFT rotates x left n bits */
59: #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
60:
61: /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
62: /* Rotation is separate from addition to prevent recomputation */
63: #define FF(a, b, c, d, x, s, ac) \
64: {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
65: (a) = ROTATE_LEFT ((a), (s)); \
66: (a) += (b); \
67: }
68: #define GG(a, b, c, d, x, s, ac) \
69: {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
70: (a) = ROTATE_LEFT ((a), (s)); \
71: (a) += (b); \
72: }
73: #define HH(a, b, c, d, x, s, ac) \
74: {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
75: (a) = ROTATE_LEFT ((a), (s)); \
76: (a) += (b); \
77: }
78: #define II(a, b, c, d, x, s, ac) \
79: {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
80: (a) = ROTATE_LEFT ((a), (s)); \
81: (a) += (b); \
82: }
83:
84: void MD5Init (mdContext)
85: MD5_CTX *mdContext;
86: {
87: mdContext->i[0] = mdContext->i[1] = (UINT4)0;
88:
89: /* Load magic initialization constants.
90: */
91: mdContext->buf[0] = (UINT4)0x67452301;
92: mdContext->buf[1] = (UINT4)0xefcdab89;
93: mdContext->buf[2] = (UINT4)0x98badcfe;
94: mdContext->buf[3] = (UINT4)0x10325476;
95: }
96:
97: void MD5Update (mdContext, inBuf, inLen)
98: MD5_CTX *mdContext;
99: unsigned char *inBuf;
100: unsigned int inLen;
101: {
102: UINT4 in[16];
103: int mdi;
104: unsigned int i, ii;
105:
106: /* compute number of bytes mod 64 */
107: mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
108:
109: /* update number of bits */
110: if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
111: mdContext->i[1]++;
112: mdContext->i[0] += ((UINT4)inLen << 3);
113: mdContext->i[1] += ((UINT4)inLen >> 29);
114:
115: while (inLen--) {
116: /* add new character to buffer, increment mdi */
117: mdContext->in[mdi++] = *inBuf++;
118:
119: /* transform if necessary */
120: if (mdi == 0x40) {
121: for (i = 0, ii = 0; i < 16; i++, ii += 4)
122: in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
123: (((UINT4)mdContext->in[ii+2]) << 16) |
124: (((UINT4)mdContext->in[ii+1]) << 8) |
125: ((UINT4)mdContext->in[ii]);
126: Transform (mdContext->buf, in);
127: mdi = 0;
128: }
129: }
130: }
131:
132: void MD5Final (md, mdContext)
133: unsigned char *md;
134: MD5_CTX *mdContext;
135: {
136: UINT4 in[16];
137: int mdi;
138: unsigned int i, ii;
139: unsigned int padLen;
140:
141: /* save number of bits */
142: in[14] = mdContext->i[0];
143: in[15] = mdContext->i[1];
144:
145: /* compute number of bytes mod 64 */
146: mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
147:
148: /* pad out to 56 mod 64 */
149: padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
150: MD5Update (mdContext, PADDING, padLen);
151:
152: /* append length in bits and transform */
153: for (i = 0, ii = 0; i < 14; i++, ii += 4)
154: in[i] = (((UINT4)mdContext->in[ii+3]) << 24) |
155: (((UINT4)mdContext->in[ii+2]) << 16) |
156: (((UINT4)mdContext->in[ii+1]) << 8) |
157: ((UINT4)mdContext->in[ii]);
158: Transform (mdContext->buf, in);
159:
160: /* store buffer in digest */
161: for (i = 0, ii = 0; i < 4; i++, ii += 4) {
162: mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
163: mdContext->digest[ii+1] =
164: (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
165: mdContext->digest[ii+2] =
166: (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
167: mdContext->digest[ii+3] =
168: (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
169: }
170: /* copy the resulting digest */
171: memcpy(md,mdContext->digest,sizeof(mdContext->digest));
172: }
173:
174: /* Basic MD5 step. Transform buf based on in.
175: */
176: static void Transform (buf, in)
177: UINT4 *buf;
178: UINT4 *in;
179: {
180: UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
181:
182: /* Round 1 */
183: #define S11 7
184: #define S12 12
185: #define S13 17
186: #define S14 22
187: /* FF ( a, b, c, d, in[ 0], S11, 3614090360); * 1 * */
188: FF ( a, b, c, d, in[ 0], S11, 0xD76AA478); /* 1 */
189: /* FF ( d, a, b, c, in[ 1], S12, 3905402710); * 2 * */
190: FF ( d, a, b, c, in[ 1], S12, 0xE8C7B756); /* 2 */
191: /* FF ( c, d, a, b, in[ 2], S13, 606105819); * 3 * */
192: FF ( c, d, a, b, in[ 2], S13, 0x242070DB); /* 3 */
193: /* FF ( b, c, d, a, in[ 3], S14, 3250441966); * 4 * */
194: FF ( b, c, d, a, in[ 3], S14, 0xC1BDCEEE); /* 4 */
195: /* FF ( a, b, c, d, in[ 4], S11, 4118548399); * 5 * */
196: FF ( a, b, c, d, in[ 4], S11, 0xF57C0FAF); /* 5 */
197: /* FF ( d, a, b, c, in[ 5], S12, 1200080426); * 6 * */
198: FF ( d, a, b, c, in[ 5], S12, 0x4787C62A); /* 6 */
199: /* FF ( c, d, a, b, in[ 6], S13, 2821735955); * 7 * */
200: FF ( c, d, a, b, in[ 6], S13, 0xA8304613); /* 7 */
201: /* FF ( b, c, d, a, in[ 7], S14, 4249261313); * 8 * */
202: FF ( b, c, d, a, in[ 7], S14, 0xFD469501); /* 8 */
203: /* FF ( a, b, c, d, in[ 8], S11, 1770035416); * 9 * */
204: FF ( a, b, c, d, in[ 8], S11, 0x698098D8); /* 9 */
205: /* FF ( d, a, b, c, in[ 9], S12, 2336552879); * 10 * */
206: FF ( d, a, b, c, in[ 9], S12, 0x8B44F7AF); /* 10 */
207: /* FF ( c, d, a, b, in[10], S13, 4294925233); * 11 * */
208: FF ( c, d, a, b, in[10], S13, 0xFFFF5BB1); /* 11 */
209: /* FF ( b, c, d, a, in[11], S14, 2304563134); * 12 * */
210: FF ( b, c, d, a, in[11], S14, 0x895CD7BE); /* 12 */
211: /* FF ( a, b, c, d, in[12], S11, 1804603682); * 13 * */
212: FF ( a, b, c, d, in[12], S11, 0x6B901122); /* 13 */
213: /* FF ( d, a, b, c, in[13], S12, 4254626195); * 14 * */
214: FF ( d, a, b, c, in[13], S12, 0xFD987193); /* 14 */
215: /* FF ( c, d, a, b, in[14], S13, 2792965006); * 15 * */
216: FF ( c, d, a, b, in[14], S13, 0xA679438E); /* 15 */
217: /* FF ( b, c, d, a, in[15], S14, 1236535329); * 16 * */
218: FF ( b, c, d, a, in[15], S14, 0x49B40821); /* 16 */
219:
220: /* Round 2 */
221: #define S21 5
222: #define S22 9
223: #define S23 14
224: #define S24 20
225: /* GG ( a, b, c, d, in[ 1], S21, 4129170786); * 17 * */
226: GG ( a, b, c, d, in[ 1], S21, 0xF61E2562); /* 17 */
227: /* GG ( d, a, b, c, in[ 6], S22, 3225465664); * 18 * */
228: GG ( d, a, b, c, in[ 6], S22, 0xC040B340); /* 18 */
229: /* GG ( c, d, a, b, in[11], S23, 643717713); * 19 * */
230: GG ( c, d, a, b, in[11], S23, 0x265E5A51); /* 19 */
231: /* GG ( b, c, d, a, in[ 0], S24, 3921069994); * 20 * */
232: GG ( b, c, d, a, in[ 0], S24, 0xE9B6C7AA); /* 20 */
233: /* GG ( a, b, c, d, in[ 5], S21, 3593408605); * 21 * */
234: GG ( a, b, c, d, in[ 5], S21, 0xD62F105D); /* 21 */
235: /* GG ( d, a, b, c, in[10], S22, 38016083); * 22 * */
236: GG ( d, a, b, c, in[10], S22, 0x2441453); /* 22 */
237: /* GG ( c, d, a, b, in[15], S23, 3634488961); * 23 * */
238: GG ( c, d, a, b, in[15], S23, 0xD8A1E681); /* 23 */
239: /* GG ( b, c, d, a, in[ 4], S24, 3889429448); * 24 * */
240: GG ( b, c, d, a, in[ 4], S24, 0xE7D3FBC8); /* 24 */
241: /* GG ( a, b, c, d, in[ 9], S21, 568446438); * 25 * */
242: GG ( a, b, c, d, in[ 9], S21, 0x21E1CDE6); /* 25 */
243: /* GG ( d, a, b, c, in[14], S22, 3275163606); * 26 * */
244: GG ( d, a, b, c, in[14], S22, 0xC33707D6); /* 26 */
245: /* GG ( c, d, a, b, in[ 3], S23, 4107603335); * 27 * */
246: GG ( c, d, a, b, in[ 3], S23, 0xF4D50D87); /* 27 */
247: /* GG ( b, c, d, a, in[ 8], S24, 1163531501); * 28 * */
248: GG ( b, c, d, a, in[ 8], S24, 0x455A14ED); /* 28 */
249: /* GG ( a, b, c, d, in[13], S21, 2850285829); * 29 * */
250: GG ( a, b, c, d, in[13], S21, 0xA9E3E905); /* 29 */
251: /* GG ( d, a, b, c, in[ 2], S22, 4243563512); * 30 * */
252: GG ( d, a, b, c, in[ 2], S22, 0xFCEFA3F8); /* 30 */
253: /* GG ( c, d, a, b, in[ 7], S23, 1735328473); * 31 * */
254: GG ( c, d, a, b, in[ 7], S23, 0x676F02D9); /* 31 */
255: /* GG ( b, c, d, a, in[12], S24, 2368359562); * 32 * */
256: GG ( b, c, d, a, in[12], S24, 0x8D2A4C8A); /* 32 */
257:
258: /* Round 3 */
259: #define S31 4
260: #define S32 11
261: #define S33 16
262: #define S34 23
263: /* HH ( a, b, c, d, in[ 5], S31, 4294588738); * 33 * */
264: HH ( a, b, c, d, in[ 5], S31, 0xFFFA3942); /* 33 */
265: /* HH ( d, a, b, c, in[ 8], S32, 2272392833); * 34 * */
266: HH ( d, a, b, c, in[ 8], S32, 0x8771F681); /* 34 */
267: /* HH ( c, d, a, b, in[11], S33, 1839030562); * 35 * */
268: HH ( c, d, a, b, in[11], S33, 0x6D9D6122); /* 35 */
269: /* HH ( b, c, d, a, in[14], S34, 4259657740); * 36 * */
270: HH ( b, c, d, a, in[14], S34, 0xFDE5380C); /* 36 */
271: /* HH ( a, b, c, d, in[ 1], S31, 2763975236); * 37 * */
272: HH ( a, b, c, d, in[ 1], S31, 0xA4BEEA44); /* 37 */
273: /* HH ( d, a, b, c, in[ 4], S32, 1272893353); * 38 * */
274: HH ( d, a, b, c, in[ 4], S32, 0x4BDECFA9); /* 38 */
275: /* HH ( c, d, a, b, in[ 7], S33, 4139469664); * 39 * */
276: HH ( c, d, a, b, in[ 7], S33, 0xF6BB4B60); /* 39 */
277: /* HH ( b, c, d, a, in[10], S34, 3200236656); * 40 * */
278: HH ( b, c, d, a, in[10], S34, 0xBEBFBC70); /* 40 */
279: /* HH ( a, b, c, d, in[13], S31, 681279174); * 41 * */
280: HH ( a, b, c, d, in[13], S31, 0x289B7EC6); /* 41 */
281: /* HH ( d, a, b, c, in[ 0], S32, 3936430074); * 42 * */
282: HH ( d, a, b, c, in[ 0], S32, 0xEAA127FA); /* 42 */
283: /* HH ( c, d, a, b, in[ 3], S33, 3572445317); * 43 * */
284: HH ( c, d, a, b, in[ 3], S33, 0xD4EF3085); /* 43 */
285: /* HH ( b, c, d, a, in[ 6], S34, 76029189); * 44 * */
286: HH ( b, c, d, a, in[ 6], S34, 0x4881D05); /* 44 */
287: /* HH ( a, b, c, d, in[ 9], S31, 3654602809); * 45 * */
288: HH ( a, b, c, d, in[ 9], S31, 0xD9D4D039); /* 45 */
289: /* HH ( d, a, b, c, in[12], S32, 3873151461); * 46 * */
290: HH ( d, a, b, c, in[12], S32, 0xE6DB99E5); /* 46 */
291: /* HH ( c, d, a, b, in[15], S33, 530742520); * 47 * */
292: HH ( c, d, a, b, in[15], S33, 0x1FA27CF8); /* 47 */
293: /* HH ( b, c, d, a, in[ 2], S34, 3299628645); * 48 * */
294: HH ( b, c, d, a, in[ 2], S34, 0xC4AC5665); /* 48 */
295:
296: /* Round 4 */
297: #define S41 6
298: #define S42 10
299: #define S43 15
300: #define S44 21
301: /* II ( a, b, c, d, in[ 0], S41, 4096336452); * 49 * */
302: II ( a, b, c, d, in[ 0], S41, 0xF4292244); /* 49 */
303: /* II ( d, a, b, c, in[ 7], S42, 1126891415); * 50 * */
304: II ( d, a, b, c, in[ 7], S42, 0x432AFF97); /* 50 */
305: /* II ( c, d, a, b, in[14], S43, 2878612391); * 51 * */
306: II ( c, d, a, b, in[14], S43, 0xAB9423A7); /* 51 */
307: /* II ( b, c, d, a, in[ 5], S44, 4237533241); * 52 * */
308: II ( b, c, d, a, in[ 5], S44, 0xFC93A039); /* 52 */
309: /* II ( a, b, c, d, in[12], S41, 1700485571); * 53 * */
310: II ( a, b, c, d, in[12], S41, 0x655B59C3); /* 53 */
311: /* II ( d, a, b, c, in[ 3], S42, 2399980690); * 54 * */
312: II ( d, a, b, c, in[ 3], S42, 0x8F0CCC92); /* 54 */
313: /* II ( c, d, a, b, in[10], S43, 4293915773); * 55 * */
314: II ( c, d, a, b, in[10], S43, 0xFFEFF47D); /* 55 */
315: /* II ( b, c, d, a, in[ 1], S44, 2240044497); * 56 * */
316: II ( b, c, d, a, in[ 1], S44, 0x85845DD1); /* 56 */
317: /* II ( a, b, c, d, in[ 8], S41, 1873313359); * 57 * */
318: II ( a, b, c, d, in[ 8], S41, 0x6FA87E4F); /* 57 */
319: /* II ( d, a, b, c, in[15], S42, 4264355552); * 58 * */
320: II ( d, a, b, c, in[15], S42, 0xFE2CE6E0); /* 58 */
321: /* II ( c, d, a, b, in[ 6], S43, 2734768916); * 59 * */
322: II ( c, d, a, b, in[ 6], S43, 0xA3014314); /* 59 */
323: /* II ( b, c, d, a, in[13], S44, 1309151649); * 60 * */
324: II ( b, c, d, a, in[13], S44, 0x4E0811A1); /* 60 */
325: /* II ( a, b, c, d, in[ 4], S41, 4149444226); * 61 * */
326: II ( a, b, c, d, in[ 4], S41, 0xF7537E82); /* 61 */
327: /* II ( d, a, b, c, in[11], S42, 3174756917); * 62 * */
328: II ( d, a, b, c, in[11], S42, 0xBD3AF235); /* 62 */
329: /* II ( c, d, a, b, in[ 2], S43, 718787259); * 63 * */
330: II ( c, d, a, b, in[ 2], S43, 0x2AD7D2BB); /* 63 */
331: /* II ( b, c, d, a, in[ 9], S44, 3951481745); * 64 * */
332: II ( b, c, d, a, in[ 9], S44, 0xEB86D391); /* 64 */
333:
334: buf[0] += a;
335: buf[1] += b;
336: buf[2] += c;
337: buf[3] += d;
338: }
339:
340: /*
341: **********************************************************************
342: ** End of md5.c **
343: ******************************* (cut) ********************************
344: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to md5.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / freevrrpd