Annotation of embedaddon/bird2/lib/md5.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD Library -- MD5 Hash Function and HMAC-MD5 Function
3: *
4: * (c) 2015 CZ.NIC z.s.p.o.
5: *
6: * The code was written by Colin Plumb in 1993, no copyright is claimed.
7: *
8: * Adapted for BIRD by Martin Mares <mj@ucw.cz>
9: *
10: * Can be freely distributed and used under the terms of the GNU GPL.
11: */
12:
13: #include "lib/md5.h"
14:
15: #ifdef CPU_LITTLE_ENDIAN
16: #define byteReverse(buf, len) /* Nothing */
17: #else
18: void byteReverse(byte *buf, uint longs);
19:
20: /*
21: * Note: this code is harmless on little-endian machines.
22: */
23: void byteReverse(byte *buf, uint longs)
24: {
25: u32 t;
26: do {
27: t = (u32) ((uint) buf[3] << 8 | buf[2]) << 16 |
28: ((uint) buf[1] << 8 | buf[0]);
29: *(u32 *) buf = t;
30: buf += 4;
31: } while (--longs);
32: }
33: #endif
34:
35: static void md5_transform(u32 buf[4], u32 const in[16]);
36:
37: /*
38: * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
39: * initialization constants.
40: */
41: void
42: md5_init(struct hash_context *CTX)
43: {
44: struct md5_context *ctx = (void *) CTX;
45:
46: ctx->buf[0] = 0x67452301;
47: ctx->buf[1] = 0xefcdab89;
48: ctx->buf[2] = 0x98badcfe;
49: ctx->buf[3] = 0x10325476;
50:
51: ctx->bits[0] = 0;
52: ctx->bits[1] = 0;
53: }
54:
55: /*
56: * Update context to reflect the concatenation of another buffer full
57: * of bytes.
58: */
59: void
60: md5_update(struct hash_context *CTX, const byte *buf, uint len)
61: {
62: struct md5_context *ctx = (void *) CTX;
63: u32 t;
64:
65: /* Update bitcount */
66:
67: t = ctx->bits[0];
68: if ((ctx->bits[0] = t + ((u32) len << 3)) < t)
69: ctx->bits[1]++; /* Carry from low to high */
70: ctx->bits[1] += len >> 29;
71:
72: t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
73:
74: /* Handle any leading odd-sized chunks */
75: if (t)
76: {
77: byte *p = (byte *) ctx->in + t;
78:
79: t = 64 - t;
80: if (len < t)
81: {
82: memcpy(p, buf, len);
83: return;
84: }
85: memcpy(p, buf, t);
86: byteReverse(ctx->in, 16);
87: md5_transform(ctx->buf, (u32 *) ctx->in);
88: buf += t;
89: len -= t;
90: }
91:
92: /* Process data in 64-byte chunks */
93: while (len >= 64)
94: {
95: memcpy(ctx->in, buf, 64);
96: byteReverse(ctx->in, 16);
97: md5_transform(ctx->buf, (u32 *) ctx->in);
98: buf += 64;
99: len -= 64;
100: }
101:
102: /* Handle any remaining bytes of data. */
103: memcpy(ctx->in, buf, len);
104: }
105:
106: /*
107: * Final wrapup - pad to 64-byte boundary with the bit pattern
108: * 1 0* (64-bit count of bits processed, MSB-first)
109: */
110: byte *
111: md5_final(struct hash_context *CTX)
112: {
113: struct md5_context *ctx = (void *) CTX;
114: uint count;
115: byte *p;
116:
117: /* Compute number of bytes mod 64 */
118: count = (ctx->bits[0] >> 3) & 0x3F;
119:
120: /* Set the first char of padding to 0x80. This is safe since there is
121: always at least one byte free */
122: p = ctx->in + count;
123: *p++ = 0x80;
124:
125: /* Bytes of padding needed to make 64 bytes */
126: count = 64 - 1 - count;
127:
128: /* Pad out to 56 mod 64 */
129: if (count < 8)
130: {
131: /* Two lots of padding: Pad the first block to 64 bytes */
132: memset(p, 0, count);
133: byteReverse(ctx->in, 16);
134: md5_transform(ctx->buf, (u32 *) ctx->in);
135:
136: /* Now fill the next block with 56 bytes */
137: memset(ctx->in, 0, 56);
138: }
139: else
140: {
141: /* Pad block to 56 bytes */
142: memset(p, 0, count - 8);
143: }
144: byteReverse(ctx->in, 14);
145:
146: /* Append length in bits and transform */
147: ((u32 *) ctx->in)[14] = ctx->bits[0];
148: ((u32 *) ctx->in)[15] = ctx->bits[1];
149:
150: md5_transform(ctx->buf, (u32 *) ctx->in);
151: byteReverse((byte *) ctx->buf, 4);
152:
153: return (byte*) ctx->buf;
154: }
155:
156: /* The four core functions - F1 is optimized somewhat */
157:
158: /* #define F1(x, y, z) (x & y | ~x & z) */
159: #define F1(x, y, z) (z ^ (x & (y ^ z)))
160: #define F2(x, y, z) F1(z, x, y)
161: #define F3(x, y, z) (x ^ y ^ z)
162: #define F4(x, y, z) (y ^ (x | ~z))
163:
164: /* This is the central step in the MD5 algorithm. */
165: #define MD5STEP(f, w, x, y, z, data, s) \
166: ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
167:
168: /*
169: * The core of the MD5 algorithm, this alters an existing MD5 hash to
170: * reflect the addition of 16 longwords of new data. MD5Update blocks
171: * the data and converts bytes into longwords for this routine.
172: */
173: void
174: md5_transform(u32 buf[4], u32 const in[16])
175: {
176: register u32 a, b, c, d;
177:
178: a = buf[0];
179: b = buf[1];
180: c = buf[2];
181: d = buf[3];
182:
183: MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
184: MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
185: MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
186: MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
187: MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
188: MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
189: MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
190: MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
191: MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
192: MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
193: MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
194: MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
195: MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
196: MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
197: MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
198: MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
199:
200: MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
201: MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
202: MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
203: MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
204: MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
205: MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
206: MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
207: MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
208: MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
209: MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
210: MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
211: MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
212: MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
213: MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
214: MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
215: MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
216:
217: MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
218: MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
219: MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
220: MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
221: MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
222: MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
223: MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
224: MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
225: MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
226: MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
227: MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
228: MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
229: MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
230: MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
231: MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
232: MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
233:
234: MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
235: MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
236: MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
237: MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
238: MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
239: MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
240: MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
241: MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
242: MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
243: MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
244: MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
245: MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
246: MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
247: MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
248: MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
249: MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
250:
251: buf[0] += a;
252: buf[1] += b;
253: buf[2] += c;
254: buf[3] += d;
255: }
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 / bird2 / lib