1 : /*
2 : * This code implements the MD5 message-digest algorithm.
3 : * The algorithm is due to Ron Rivest. This code was
4 : * written by Colin Plumb in 1993, no copyright is claimed.
5 : * This code is in the public domain; do with it what you wish.
6 : *
7 : * Equivalent code is available from RSA Data Security, Inc.
8 : * This code has been tested against that, and is equivalent,
9 : * except that you don't need to include two pages of legalese
10 : * with every copy.
11 : *
12 : * To compute the message digest of a chunk of bytes, declare an
13 : * MD5Context structure, pass it to MD5Init, call MD5Update as
14 : * needed on buffers full of bytes, and then call MD5Final, which
15 : * will fill a supplied 16-byte array with the digest.
16 : */
17 :
18 : /* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
19 : not require an integer type which is exactly 32 bits. This work
20 : draws on the changes for the same purpose by Tatu Ylonen
21 : <ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
22 : that code, there is no copyright issue. I hereby disclaim
23 : copyright in any changes I have made; this code remains in the
24 : public domain. */
25 :
26 : /* Note regarding cvs_* namespace: this avoids potential conflicts
27 : with libraries such as some versions of Kerberos. No particular
28 : need to worry about whether the system supplies an MD5 library, as
29 : this file is only about 3k of object code. */
30 :
31 : #ifdef HAVE_CONFIG_H
32 : #include "config.h"
33 : #endif
34 :
35 : #include <string.h> /* for memcpy() and memset() */
36 :
37 : #include "md5.h"
38 :
39 : /* Little-endian byte-swapping routines. Note that these do not
40 : depend on the size of datatypes such as cvs_uint32, nor do they require
41 : us to detect the endianness of the machine we are running on. It
42 : is possible they should be macros for speed, but I would be
43 : surprised if they were a performance bottleneck for MD5. */
44 :
45 64 : static cvs_uint32 getu32(const unsigned char *addr)
46 : {
47 128 : return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
48 128 : | addr[1]) << 8 | addr[0];
49 : }
50 :
51 : static void
52 12 : putu32 (
53 : cvs_uint32 data,
54 : unsigned char *addr)
55 : {
56 12 : addr[0] = (unsigned char)data;
57 12 : addr[1] = (unsigned char)(data >> 8);
58 12 : addr[2] = (unsigned char)(data >> 16);
59 12 : addr[3] = (unsigned char)(data >> 24);
60 12 : }
61 :
62 : /*
63 : * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
64 : * initialization constants.
65 : */
66 : void
67 2 : cvs_MD5Init (
68 : struct cvs_MD5Context *ctx)
69 : {
70 2 : ctx->buf[0] = 0x67452301;
71 2 : ctx->buf[1] = 0xefcdab89;
72 2 : ctx->buf[2] = 0x98badcfe;
73 2 : ctx->buf[3] = 0x10325476;
74 :
75 2 : ctx->bits[0] = 0;
76 2 : ctx->bits[1] = 0;
77 2 : }
78 :
79 : /*
80 : * Update context to reflect the concatenation of another buffer full
81 : * of bytes.
82 : */
83 : void
84 2 : cvs_MD5Update (
85 : struct cvs_MD5Context *ctx,
86 : unsigned char const *buf,
87 : unsigned len)
88 : {
89 : cvs_uint32 t;
90 :
91 : /* Update bitcount */
92 :
93 2 : t = ctx->bits[0];
94 2 : if ((ctx->bits[0] = (t + ((cvs_uint32)len << 3)) & 0xffffffff) < t)
95 0 : ctx->bits[1]++; /* Carry from low to high */
96 2 : ctx->bits[1] += len >> 29;
97 :
98 2 : t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
99 :
100 : /* Handle any leading odd-sized chunks */
101 :
102 2 : if ( t ) {
103 0 : unsigned char *p = ctx->in + t;
104 :
105 0 : t = 64-t;
106 0 : if (len < t) {
107 0 : memcpy(p, buf, len);
108 0 : return;
109 : }
110 0 : memcpy(p, buf, t);
111 0 : cvs_MD5Transform (ctx->buf, ctx->in);
112 0 : buf += t;
113 0 : len -= t;
114 : }
115 :
116 : /* Process data in 64-byte chunks */
117 :
118 4 : while (len >= 64) {
119 0 : memcpy(ctx->in, buf, 64);
120 0 : cvs_MD5Transform (ctx->buf, ctx->in);
121 0 : buf += 64;
122 0 : len -= 64;
123 : }
124 :
125 : /* Handle any remaining bytes of data. */
126 :
127 2 : memcpy(ctx->in, buf, len);
128 : }
129 :
130 : /*
131 : * Final wrapup - pad to 64-byte boundary with the bit pattern
132 : * 1 0* (64-bit count of bits processed, MSB-first)
133 : */
134 : void
135 2 : cvs_MD5Final (
136 : unsigned char digest[16],
137 : struct cvs_MD5Context *ctx)
138 : {
139 : unsigned count;
140 : unsigned char *p;
141 :
142 : /* Compute number of bytes mod 64 */
143 2 : count = (ctx->bits[0] >> 3) & 0x3F;
144 :
145 : /* Set the first char of padding to 0x80. This is safe since there is
146 : always at least one byte free */
147 2 : p = ctx->in + count;
148 2 : *p++ = 0x80;
149 :
150 : /* Bytes of padding needed to make 64 bytes */
151 2 : count = 64 - 1 - count;
152 :
153 : /* Pad out to 56 mod 64 */
154 2 : if (count < 8) {
155 : /* Two lots of padding: Pad the first block to 64 bytes */
156 2 : memset(p, 0, count);
157 2 : cvs_MD5Transform (ctx->buf, ctx->in);
158 :
159 : /* Now fill the next block with 56 bytes */
160 2 : memset(ctx->in, 0, 56);
161 : } else {
162 : /* Pad block to 56 bytes */
163 0 : memset(p, 0, count-8);
164 : }
165 :
166 : /* Append length in bits and transform */
167 2 : putu32(ctx->bits[0], ctx->in + 56);
168 2 : putu32(ctx->bits[1], ctx->in + 60);
169 :
170 2 : cvs_MD5Transform (ctx->buf, ctx->in);
171 2 : putu32(ctx->buf[0], digest);
172 2 : putu32(ctx->buf[1], digest + 4);
173 2 : putu32(ctx->buf[2], digest + 8);
174 2 : putu32(ctx->buf[3], digest + 12);
175 2 : memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
176 2 : }
177 :
178 : #ifndef ASM_MD5
179 :
180 : /* The four core functions - F1 is optimized somewhat */
181 :
182 : /* #define F1(x, y, z) (x & y | ~x & z) */
183 : #define F1(x, y, z) (z ^ (x & (y ^ z)))
184 : #define F2(x, y, z) F1(z, x, y)
185 : #define F3(x, y, z) (x ^ y ^ z)
186 : #define F4(x, y, z) (y ^ (x | ~z))
187 :
188 : /* This is the central step in the MD5 algorithm. */
189 : #define MD5STEP(f, w, x, y, z, data, s) \
190 : ( w += f(x, y, z) + data, w &= 0xffffffff, w = w<<s | w>>(32-s), w += x )
191 :
192 : /*
193 : * The core of the MD5 algorithm, this alters an existing MD5 hash to
194 : * reflect the addition of 16 longwords of new data. MD5Update blocks
195 : * the data and converts bytes into longwords for this routine.
196 : */
197 : void
198 4 : cvs_MD5Transform (
199 : cvs_uint32 buf[4],
200 : const unsigned char inraw[64])
201 : {
202 : register cvs_uint32 a, b, c, d;
203 : cvs_uint32 in[16];
204 : int i;
205 :
206 68 : for (i = 0; i < 16; ++i)
207 64 : in[i] = getu32 (inraw + 4 * i);
208 :
209 4 : a = buf[0];
210 4 : b = buf[1];
211 4 : c = buf[2];
212 4 : d = buf[3];
213 :
214 4 : MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);
215 4 : MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
216 4 : MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
217 4 : MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
218 4 : MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);
219 4 : MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
220 4 : MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
221 4 : MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
222 4 : MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);
223 4 : MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
224 4 : MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
225 4 : MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
226 4 : MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);
227 4 : MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
228 4 : MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
229 4 : MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
230 :
231 4 : MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);
232 4 : MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);
233 4 : MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
234 4 : MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
235 4 : MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);
236 4 : MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);
237 4 : MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
238 4 : MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
239 4 : MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);
240 4 : MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);
241 4 : MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
242 4 : MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
243 4 : MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);
244 4 : MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);
245 4 : MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
246 4 : MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
247 :
248 4 : MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);
249 4 : MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
250 4 : MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
251 4 : MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
252 4 : MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);
253 4 : MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
254 4 : MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
255 4 : MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
256 4 : MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);
257 4 : MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
258 4 : MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
259 4 : MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
260 4 : MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);
261 4 : MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
262 4 : MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
263 4 : MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
264 :
265 4 : MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);
266 4 : MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
267 4 : MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
268 4 : MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
269 4 : MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);
270 4 : MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
271 4 : MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
272 4 : MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
273 4 : MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);
274 4 : MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
275 4 : MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
276 4 : MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
277 4 : MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);
278 4 : MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
279 4 : MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
280 4 : MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
281 :
282 4 : buf[0] += a;
283 4 : buf[1] += b;
284 4 : buf[2] += c;
285 4 : buf[3] += d;
286 4 : }
287 : #endif
|
