]>
Commit | Line | Data |
---|---|---|
58964a49 RE |
1 | /* crypto/md5/md5_dgst.c */ |
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | |
3 | * All rights reserved. | |
4 | * | |
5 | * This package is an SSL implementation written | |
6 | * by Eric Young (eay@cryptsoft.com). | |
7 | * The implementation was written so as to conform with Netscapes SSL. | |
8 | * | |
9 | * This library is free for commercial and non-commercial use as long as | |
10 | * the following conditions are aheared to. The following conditions | |
11 | * apply to all code found in this distribution, be it the RC4, RSA, | |
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | |
13 | * included with this distribution is covered by the same copyright terms | |
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | |
15 | * | |
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | |
17 | * the code are not to be removed. | |
18 | * If this package is used in a product, Eric Young should be given attribution | |
19 | * as the author of the parts of the library used. | |
20 | * This can be in the form of a textual message at program startup or | |
21 | * in documentation (online or textual) provided with the package. | |
22 | * | |
23 | * Redistribution and use in source and binary forms, with or without | |
24 | * modification, are permitted provided that the following conditions | |
25 | * are met: | |
26 | * 1. Redistributions of source code must retain the copyright | |
27 | * notice, this list of conditions and the following disclaimer. | |
28 | * 2. Redistributions in binary form must reproduce the above copyright | |
29 | * notice, this list of conditions and the following disclaimer in the | |
30 | * documentation and/or other materials provided with the distribution. | |
31 | * 3. All advertising materials mentioning features or use of this software | |
32 | * must display the following acknowledgement: | |
33 | * "This product includes cryptographic software written by | |
34 | * Eric Young (eay@cryptsoft.com)" | |
35 | * The word 'cryptographic' can be left out if the rouines from the library | |
36 | * being used are not cryptographic related :-). | |
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | |
38 | * the apps directory (application code) you must include an acknowledgement: | |
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |
40 | * | |
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | |
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
51 | * SUCH DAMAGE. | |
52 | * | |
53 | * The licence and distribution terms for any publically available version or | |
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | |
55 | * copied and put under another distribution licence | |
56 | * [including the GNU Public Licence.] | |
57 | */ | |
58 | ||
59 | #include <stdio.h> | |
60 | #include "md5_locl.h" | |
61 | ||
dfeab068 | 62 | char *MD5_version="MD5 part of SSLeay 0.9.1a 06-Jul-1998"; |
58964a49 RE |
63 | |
64 | /* Implemented from RFC1321 The MD5 Message-Digest Algorithm | |
65 | */ | |
66 | ||
67 | #define INIT_DATA_A (unsigned long)0x67452301L | |
68 | #define INIT_DATA_B (unsigned long)0xefcdab89L | |
69 | #define INIT_DATA_C (unsigned long)0x98badcfeL | |
70 | #define INIT_DATA_D (unsigned long)0x10325476L | |
71 | ||
72 | #ifndef NOPROTO | |
73 | # ifdef MD5_ASM | |
74 | void md5_block_x86(MD5_CTX *c, unsigned long *p,int num); | |
75 | # define md5_block md5_block_x86 | |
76 | # else | |
77 | static void md5_block(MD5_CTX *c, unsigned long *p,int num); | |
78 | # endif | |
79 | #else | |
80 | # ifdef MD5_ASM | |
81 | void md5_block_x86(); | |
82 | # define md5_block md5_block_x86 | |
83 | # else | |
84 | static void md5_block(); | |
85 | # endif | |
86 | #endif | |
87 | ||
88 | void MD5_Init(c) | |
89 | MD5_CTX *c; | |
90 | { | |
91 | c->A=INIT_DATA_A; | |
92 | c->B=INIT_DATA_B; | |
93 | c->C=INIT_DATA_C; | |
94 | c->D=INIT_DATA_D; | |
95 | c->Nl=0; | |
96 | c->Nh=0; | |
97 | c->num=0; | |
98 | } | |
99 | ||
100 | void MD5_Update(c, data, len) | |
101 | MD5_CTX *c; | |
102 | register unsigned char *data; | |
103 | unsigned long len; | |
104 | { | |
105 | register ULONG *p; | |
106 | int sw,sc; | |
107 | ULONG l; | |
108 | ||
109 | if (len == 0) return; | |
110 | ||
111 | l=(c->Nl+(len<<3))&0xffffffffL; | |
112 | /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to | |
113 | * Wei Dai <weidai@eskimo.com> for pointing it out. */ | |
114 | if (l < c->Nl) /* overflow */ | |
115 | c->Nh++; | |
116 | c->Nh+=(len>>29); | |
117 | c->Nl=l; | |
118 | ||
119 | if (c->num != 0) | |
120 | { | |
121 | p=c->data; | |
122 | sw=c->num>>2; | |
123 | sc=c->num&0x03; | |
124 | ||
125 | if ((c->num+len) >= MD5_CBLOCK) | |
126 | { | |
127 | l= p[sw]; | |
128 | p_c2l(data,l,sc); | |
129 | p[sw++]=l; | |
130 | for (; sw<MD5_LBLOCK; sw++) | |
131 | { | |
132 | c2l(data,l); | |
133 | p[sw]=l; | |
134 | } | |
135 | len-=(MD5_CBLOCK-c->num); | |
136 | ||
137 | md5_block(c,p,64); | |
138 | c->num=0; | |
139 | /* drop through and do the rest */ | |
140 | } | |
141 | else | |
142 | { | |
143 | int ew,ec; | |
144 | ||
145 | c->num+=(int)len; | |
146 | if ((sc+len) < 4) /* ugly, add char's to a word */ | |
147 | { | |
148 | l= p[sw]; | |
149 | p_c2l_p(data,l,sc,len); | |
150 | p[sw]=l; | |
151 | } | |
152 | else | |
153 | { | |
154 | ew=(c->num>>2); | |
155 | ec=(c->num&0x03); | |
156 | l= p[sw]; | |
157 | p_c2l(data,l,sc); | |
158 | p[sw++]=l; | |
159 | for (; sw < ew; sw++) | |
160 | { c2l(data,l); p[sw]=l; } | |
161 | if (ec) | |
162 | { | |
163 | c2l_p(data,l,ec); | |
164 | p[sw]=l; | |
165 | } | |
166 | } | |
167 | return; | |
168 | } | |
169 | } | |
170 | /* we now can process the input data in blocks of MD5_CBLOCK | |
171 | * chars and save the leftovers to c->data. */ | |
172 | #ifdef L_ENDIAN | |
173 | if ((((unsigned long)data)%sizeof(ULONG)) == 0) | |
174 | { | |
175 | sw=(int)len/MD5_CBLOCK; | |
176 | if (sw > 0) | |
177 | { | |
178 | sw*=MD5_CBLOCK; | |
179 | md5_block(c,(ULONG *)data,sw); | |
180 | data+=sw; | |
181 | len-=sw; | |
182 | } | |
183 | } | |
184 | #endif | |
185 | p=c->data; | |
186 | while (len >= MD5_CBLOCK) | |
187 | { | |
188 | #if defined(L_ENDIAN) || defined(B_ENDIAN) | |
189 | if (p != (unsigned long *)data) | |
190 | memcpy(p,data,MD5_CBLOCK); | |
191 | data+=MD5_CBLOCK; | |
192 | #ifdef B_ENDIAN | |
193 | for (sw=(MD5_LBLOCK/4); sw; sw--) | |
194 | { | |
195 | Endian_Reverse32(p[0]); | |
196 | Endian_Reverse32(p[1]); | |
197 | Endian_Reverse32(p[2]); | |
198 | Endian_Reverse32(p[3]); | |
199 | p+=4; | |
200 | } | |
201 | #endif | |
202 | #else | |
203 | for (sw=(MD5_LBLOCK/4); sw; sw--) | |
204 | { | |
205 | c2l(data,l); *(p++)=l; | |
206 | c2l(data,l); *(p++)=l; | |
207 | c2l(data,l); *(p++)=l; | |
208 | c2l(data,l); *(p++)=l; | |
209 | } | |
210 | #endif | |
211 | p=c->data; | |
212 | md5_block(c,p,64); | |
213 | len-=MD5_CBLOCK; | |
214 | } | |
215 | sc=(int)len; | |
216 | c->num=sc; | |
217 | if (sc) | |
218 | { | |
219 | sw=sc>>2; /* words to copy */ | |
220 | #ifdef L_ENDIAN | |
221 | p[sw]=0; | |
222 | memcpy(p,data,sc); | |
223 | #else | |
224 | sc&=0x03; | |
225 | for ( ; sw; sw--) | |
226 | { c2l(data,l); *(p++)=l; } | |
227 | c2l_p(data,l,sc); | |
228 | *p=l; | |
229 | #endif | |
230 | } | |
231 | } | |
232 | ||
233 | void MD5_Transform(c,b) | |
234 | MD5_CTX *c; | |
235 | unsigned char *b; | |
236 | { | |
237 | ULONG p[16]; | |
238 | #if !defined(L_ENDIAN) | |
239 | ULONG *q; | |
240 | int i; | |
241 | #endif | |
242 | ||
243 | #if defined(B_ENDIAN) || defined(L_ENDIAN) | |
244 | memcpy(p,b,64); | |
245 | #ifdef B_ENDIAN | |
246 | q=p; | |
247 | for (i=(MD5_LBLOCK/4); i; i--) | |
248 | { | |
249 | Endian_Reverse32(q[0]); | |
250 | Endian_Reverse32(q[1]); | |
251 | Endian_Reverse32(q[2]); | |
252 | Endian_Reverse32(q[3]); | |
253 | q+=4; | |
254 | } | |
255 | #endif | |
256 | #else | |
257 | q=p; | |
258 | for (i=(MD5_LBLOCK/4); i; i--) | |
259 | { | |
260 | ULONG l; | |
261 | c2l(b,l); *(q++)=l; | |
262 | c2l(b,l); *(q++)=l; | |
263 | c2l(b,l); *(q++)=l; | |
264 | c2l(b,l); *(q++)=l; | |
265 | } | |
266 | #endif | |
267 | md5_block(c,p,64); | |
268 | } | |
269 | ||
270 | #ifndef MD5_ASM | |
271 | ||
272 | static void md5_block(c, X, num) | |
273 | MD5_CTX *c; | |
274 | register ULONG *X; | |
275 | int num; | |
276 | { | |
277 | register ULONG A,B,C,D; | |
278 | ||
279 | A=c->A; | |
280 | B=c->B; | |
281 | C=c->C; | |
282 | D=c->D; | |
283 | for (;;) | |
284 | { | |
285 | /* Round 0 */ | |
286 | R0(A,B,C,D,X[ 0], 7,0xd76aa478L); | |
287 | R0(D,A,B,C,X[ 1],12,0xe8c7b756L); | |
288 | R0(C,D,A,B,X[ 2],17,0x242070dbL); | |
289 | R0(B,C,D,A,X[ 3],22,0xc1bdceeeL); | |
290 | R0(A,B,C,D,X[ 4], 7,0xf57c0fafL); | |
291 | R0(D,A,B,C,X[ 5],12,0x4787c62aL); | |
292 | R0(C,D,A,B,X[ 6],17,0xa8304613L); | |
293 | R0(B,C,D,A,X[ 7],22,0xfd469501L); | |
294 | R0(A,B,C,D,X[ 8], 7,0x698098d8L); | |
295 | R0(D,A,B,C,X[ 9],12,0x8b44f7afL); | |
296 | R0(C,D,A,B,X[10],17,0xffff5bb1L); | |
297 | R0(B,C,D,A,X[11],22,0x895cd7beL); | |
298 | R0(A,B,C,D,X[12], 7,0x6b901122L); | |
299 | R0(D,A,B,C,X[13],12,0xfd987193L); | |
300 | R0(C,D,A,B,X[14],17,0xa679438eL); | |
301 | R0(B,C,D,A,X[15],22,0x49b40821L); | |
302 | /* Round 1 */ | |
303 | R1(A,B,C,D,X[ 1], 5,0xf61e2562L); | |
304 | R1(D,A,B,C,X[ 6], 9,0xc040b340L); | |
305 | R1(C,D,A,B,X[11],14,0x265e5a51L); | |
306 | R1(B,C,D,A,X[ 0],20,0xe9b6c7aaL); | |
307 | R1(A,B,C,D,X[ 5], 5,0xd62f105dL); | |
308 | R1(D,A,B,C,X[10], 9,0x02441453L); | |
309 | R1(C,D,A,B,X[15],14,0xd8a1e681L); | |
310 | R1(B,C,D,A,X[ 4],20,0xe7d3fbc8L); | |
311 | R1(A,B,C,D,X[ 9], 5,0x21e1cde6L); | |
312 | R1(D,A,B,C,X[14], 9,0xc33707d6L); | |
313 | R1(C,D,A,B,X[ 3],14,0xf4d50d87L); | |
314 | R1(B,C,D,A,X[ 8],20,0x455a14edL); | |
315 | R1(A,B,C,D,X[13], 5,0xa9e3e905L); | |
316 | R1(D,A,B,C,X[ 2], 9,0xfcefa3f8L); | |
317 | R1(C,D,A,B,X[ 7],14,0x676f02d9L); | |
318 | R1(B,C,D,A,X[12],20,0x8d2a4c8aL); | |
319 | /* Round 2 */ | |
320 | R2(A,B,C,D,X[ 5], 4,0xfffa3942L); | |
321 | R2(D,A,B,C,X[ 8],11,0x8771f681L); | |
322 | R2(C,D,A,B,X[11],16,0x6d9d6122L); | |
323 | R2(B,C,D,A,X[14],23,0xfde5380cL); | |
324 | R2(A,B,C,D,X[ 1], 4,0xa4beea44L); | |
325 | R2(D,A,B,C,X[ 4],11,0x4bdecfa9L); | |
326 | R2(C,D,A,B,X[ 7],16,0xf6bb4b60L); | |
327 | R2(B,C,D,A,X[10],23,0xbebfbc70L); | |
328 | R2(A,B,C,D,X[13], 4,0x289b7ec6L); | |
329 | R2(D,A,B,C,X[ 0],11,0xeaa127faL); | |
330 | R2(C,D,A,B,X[ 3],16,0xd4ef3085L); | |
331 | R2(B,C,D,A,X[ 6],23,0x04881d05L); | |
332 | R2(A,B,C,D,X[ 9], 4,0xd9d4d039L); | |
333 | R2(D,A,B,C,X[12],11,0xe6db99e5L); | |
334 | R2(C,D,A,B,X[15],16,0x1fa27cf8L); | |
335 | R2(B,C,D,A,X[ 2],23,0xc4ac5665L); | |
336 | /* Round 3 */ | |
337 | R3(A,B,C,D,X[ 0], 6,0xf4292244L); | |
338 | R3(D,A,B,C,X[ 7],10,0x432aff97L); | |
339 | R3(C,D,A,B,X[14],15,0xab9423a7L); | |
340 | R3(B,C,D,A,X[ 5],21,0xfc93a039L); | |
341 | R3(A,B,C,D,X[12], 6,0x655b59c3L); | |
342 | R3(D,A,B,C,X[ 3],10,0x8f0ccc92L); | |
343 | R3(C,D,A,B,X[10],15,0xffeff47dL); | |
344 | R3(B,C,D,A,X[ 1],21,0x85845dd1L); | |
345 | R3(A,B,C,D,X[ 8], 6,0x6fa87e4fL); | |
346 | R3(D,A,B,C,X[15],10,0xfe2ce6e0L); | |
347 | R3(C,D,A,B,X[ 6],15,0xa3014314L); | |
348 | R3(B,C,D,A,X[13],21,0x4e0811a1L); | |
349 | R3(A,B,C,D,X[ 4], 6,0xf7537e82L); | |
350 | R3(D,A,B,C,X[11],10,0xbd3af235L); | |
351 | R3(C,D,A,B,X[ 2],15,0x2ad7d2bbL); | |
352 | R3(B,C,D,A,X[ 9],21,0xeb86d391L); | |
353 | ||
354 | A+=c->A&0xffffffffL; | |
355 | B+=c->B&0xffffffffL; | |
356 | c->A=A; | |
357 | c->B=B; | |
358 | C+=c->C&0xffffffffL; | |
359 | D+=c->D&0xffffffffL; | |
360 | c->C=C; | |
361 | c->D=D; | |
362 | X+=16; | |
363 | num-=64; | |
364 | if (num <= 0) break; | |
365 | } | |
366 | } | |
367 | #endif | |
368 | ||
369 | void MD5_Final(md, c) | |
370 | unsigned char *md; | |
371 | MD5_CTX *c; | |
372 | { | |
373 | register int i,j; | |
374 | register ULONG l; | |
375 | register ULONG *p; | |
376 | static unsigned char end[4]={0x80,0x00,0x00,0x00}; | |
377 | unsigned char *cp=end; | |
378 | ||
379 | /* c->num should definitly have room for at least one more byte. */ | |
380 | p=c->data; | |
381 | j=c->num; | |
382 | i=j>>2; | |
383 | ||
384 | /* purify often complains about the following line as an | |
385 | * Uninitialized Memory Read. While this can be true, the | |
386 | * following p_c2l macro will reset l when that case is true. | |
387 | * This is because j&0x03 contains the number of 'valid' bytes | |
388 | * already in p[i]. If and only if j&0x03 == 0, the UMR will | |
389 | * occur but this is also the only time p_c2l will do | |
390 | * l= *(cp++) instead of l|= *(cp++) | |
391 | * Many thanks to Alex Tang <altitude@cic.net> for pickup this | |
392 | * 'potential bug' */ | |
393 | #ifdef PURIFY | |
394 | if ((j&0x03) == 0) p[i]=0; | |
395 | #endif | |
396 | l=p[i]; | |
397 | p_c2l(cp,l,j&0x03); | |
398 | p[i]=l; | |
399 | i++; | |
400 | /* i is the next 'undefined word' */ | |
401 | if (c->num >= MD5_LAST_BLOCK) | |
402 | { | |
403 | for (; i<MD5_LBLOCK; i++) | |
404 | p[i]=0; | |
405 | md5_block(c,p,64); | |
406 | i=0; | |
407 | } | |
408 | for (; i<(MD5_LBLOCK-2); i++) | |
409 | p[i]=0; | |
410 | p[MD5_LBLOCK-2]=c->Nl; | |
411 | p[MD5_LBLOCK-1]=c->Nh; | |
412 | md5_block(c,p,64); | |
413 | cp=md; | |
414 | l=c->A; l2c(l,cp); | |
415 | l=c->B; l2c(l,cp); | |
416 | l=c->C; l2c(l,cp); | |
417 | l=c->D; l2c(l,cp); | |
418 | ||
419 | /* clear stuff, md5_block may be leaving some stuff on the stack | |
420 | * but I'm not worried :-) */ | |
421 | c->num=0; | |
422 | /* memset((char *)&c,0,sizeof(c));*/ | |
423 | } | |
424 | ||
425 | #ifdef undef | |
426 | int printit(l) | |
427 | unsigned long *l; | |
428 | { | |
429 | int i,ii; | |
430 | ||
431 | for (i=0; i<2; i++) | |
432 | { | |
433 | for (ii=0; ii<8; ii++) | |
434 | { | |
435 | fprintf(stderr,"%08lx ",l[i*8+ii]); | |
436 | } | |
437 | fprintf(stderr,"\n"); | |
438 | } | |
439 | } | |
440 | #endif |