summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/md5/md5_dgst.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/md5/md5_dgst.c')
-rw-r--r--src/lib/libcrypto/md5/md5_dgst.c398
1 files changed, 139 insertions, 259 deletions
diff --git a/src/lib/libcrypto/md5/md5_dgst.c b/src/lib/libcrypto/md5/md5_dgst.c
index 43b3498d92..c38a3f021e 100644
--- a/src/lib/libcrypto/md5/md5_dgst.c
+++ b/src/lib/libcrypto/md5/md5_dgst.c
@@ -58,8 +58,9 @@
58 58
59#include <stdio.h> 59#include <stdio.h>
60#include "md5_locl.h" 60#include "md5_locl.h"
61#include <openssl/opensslv.h>
61 62
62char *MD5_version="MD5 part of SSLeay 0.9.0b 29-Jun-1998"; 63const char *MD5_version="MD5" OPENSSL_VERSION_PTEXT;
63 64
64/* Implemented from RFC1321 The MD5 Message-Digest Algorithm 65/* Implemented from RFC1321 The MD5 Message-Digest Algorithm
65 */ 66 */
@@ -69,24 +70,7 @@ char *MD5_version="MD5 part of SSLeay 0.9.0b 29-Jun-1998";
69#define INIT_DATA_C (unsigned long)0x98badcfeL 70#define INIT_DATA_C (unsigned long)0x98badcfeL
70#define INIT_DATA_D (unsigned long)0x10325476L 71#define INIT_DATA_D (unsigned long)0x10325476L
71 72
72#ifndef NOPROTO 73int MD5_Init(MD5_CTX *c)
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
88void MD5_Init(c)
89MD5_CTX *c;
90 { 74 {
91 c->A=INIT_DATA_A; 75 c->A=INIT_DATA_A;
92 c->B=INIT_DATA_B; 76 c->B=INIT_DATA_B;
@@ -95,192 +79,35 @@ MD5_CTX *c;
95 c->Nl=0; 79 c->Nl=0;
96 c->Nh=0; 80 c->Nh=0;
97 c->num=0; 81 c->num=0;
82 return 1;
98 } 83 }
99 84
100void MD5_Update(c, data, len) 85#ifndef md5_block_host_order
101MD5_CTX *c; 86void md5_block_host_order (MD5_CTX *c, const void *data, int num)
102register unsigned char *data;
103unsigned 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
233void MD5_Transform(c,b)
234MD5_CTX *c;
235unsigned 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
272static void md5_block(c, X, num)
273MD5_CTX *c;
274register ULONG *X;
275int num;
276 { 87 {
277 register ULONG A,B,C,D; 88 const MD5_LONG *X=data;
89 register unsigned long A,B,C,D;
90 /*
91 * In case you wonder why A-D are declared as long and not
92 * as MD5_LONG. Doing so results in slight performance
93 * boost on LP64 architectures. The catch is we don't
94 * really care if 32 MSBs of a 64-bit register get polluted
95 * with eventual overflows as we *save* only 32 LSBs in
96 * *either* case. Now declaring 'em long excuses the compiler
97 * from keeping 32 MSBs zeroed resulting in 13% performance
98 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
99 * Well, to be honest it should say that this *prevents*
100 * performance degradation.
101 *
102 * <appro@fy.chalmers.se>
103 */
278 104
279 A=c->A; 105 A=c->A;
280 B=c->B; 106 B=c->B;
281 C=c->C; 107 C=c->C;
282 D=c->D; 108 D=c->D;
283 for (;;) 109
110 for (;num--;X+=HASH_LBLOCK)
284 { 111 {
285 /* Round 0 */ 112 /* Round 0 */
286 R0(A,B,C,D,X[ 0], 7,0xd76aa478L); 113 R0(A,B,C,D,X[ 0], 7,0xd76aa478L);
@@ -351,80 +178,133 @@ int num;
351 R3(C,D,A,B,X[ 2],15,0x2ad7d2bbL); 178 R3(C,D,A,B,X[ 2],15,0x2ad7d2bbL);
352 R3(B,C,D,A,X[ 9],21,0xeb86d391L); 179 R3(B,C,D,A,X[ 9],21,0xeb86d391L);
353 180
354 A+=c->A&0xffffffffL; 181 A = c->A += A;
355 B+=c->B&0xffffffffL; 182 B = c->B += B;
356 c->A=A; 183 C = c->C += C;
357 c->B=B; 184 D = c->D += D;
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 } 185 }
366 } 186 }
367#endif 187#endif
368 188
369void MD5_Final(md, c) 189#ifndef md5_block_data_order
370unsigned char *md; 190#ifdef X
371MD5_CTX *c; 191#undef X
192#endif
193void md5_block_data_order (MD5_CTX *c, const void *data_, int num)
372 { 194 {
373 register int i,j; 195 const unsigned char *data=data_;
374 register ULONG l; 196 register unsigned long A,B,C,D,l;
375 register ULONG *p; 197 /*
376 static unsigned char end[4]={0x80,0x00,0x00,0x00}; 198 * In case you wonder why A-D are declared as long and not
377 unsigned char *cp=end; 199 * as MD5_LONG. Doing so results in slight performance
200 * boost on LP64 architectures. The catch is we don't
201 * really care if 32 MSBs of a 64-bit register get polluted
202 * with eventual overflows as we *save* only 32 LSBs in
203 * *either* case. Now declaring 'em long excuses the compiler
204 * from keeping 32 MSBs zeroed resulting in 13% performance
205 * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
206 * Well, to be honest it should say that this *prevents*
207 * performance degradation.
208 *
209 * <appro@fy.chalmers.se>
210 */
211#ifndef MD32_XARRAY
212 /* See comment in crypto/sha/sha_locl.h for details. */
213 unsigned long XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
214 XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
215# define X(i) XX##i
216#else
217 MD5_LONG XX[MD5_LBLOCK];
218# define X(i) XX[i]
219#endif
378 220
379 /* c->num should definitly have room for at least one more byte. */ 221 A=c->A;
380 p=c->data; 222 B=c->B;
381 j=c->num; 223 C=c->C;
382 i=j>>2; 224 D=c->D;
383 225
384 /* purify often complains about the following line as an 226 for (;num--;)
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 { 227 {
403 for (; i<MD5_LBLOCK; i++) 228 HOST_c2l(data,l); X( 0)=l; HOST_c2l(data,l); X( 1)=l;
404 p[i]=0; 229 /* Round 0 */
405 md5_block(c,p,64); 230 R0(A,B,C,D,X( 0), 7,0xd76aa478L); HOST_c2l(data,l); X( 2)=l;
406 i=0; 231 R0(D,A,B,C,X( 1),12,0xe8c7b756L); HOST_c2l(data,l); X( 3)=l;
407 } 232 R0(C,D,A,B,X( 2),17,0x242070dbL); HOST_c2l(data,l); X( 4)=l;
408 for (; i<(MD5_LBLOCK-2); i++) 233 R0(B,C,D,A,X( 3),22,0xc1bdceeeL); HOST_c2l(data,l); X( 5)=l;
409 p[i]=0; 234 R0(A,B,C,D,X( 4), 7,0xf57c0fafL); HOST_c2l(data,l); X( 6)=l;
410 p[MD5_LBLOCK-2]=c->Nl; 235 R0(D,A,B,C,X( 5),12,0x4787c62aL); HOST_c2l(data,l); X( 7)=l;
411 p[MD5_LBLOCK-1]=c->Nh; 236 R0(C,D,A,B,X( 6),17,0xa8304613L); HOST_c2l(data,l); X( 8)=l;
412 md5_block(c,p,64); 237 R0(B,C,D,A,X( 7),22,0xfd469501L); HOST_c2l(data,l); X( 9)=l;
413 cp=md; 238 R0(A,B,C,D,X( 8), 7,0x698098d8L); HOST_c2l(data,l); X(10)=l;
414 l=c->A; l2c(l,cp); 239 R0(D,A,B,C,X( 9),12,0x8b44f7afL); HOST_c2l(data,l); X(11)=l;
415 l=c->B; l2c(l,cp); 240 R0(C,D,A,B,X(10),17,0xffff5bb1L); HOST_c2l(data,l); X(12)=l;
416 l=c->C; l2c(l,cp); 241 R0(B,C,D,A,X(11),22,0x895cd7beL); HOST_c2l(data,l); X(13)=l;
417 l=c->D; l2c(l,cp); 242 R0(A,B,C,D,X(12), 7,0x6b901122L); HOST_c2l(data,l); X(14)=l;
243 R0(D,A,B,C,X(13),12,0xfd987193L); HOST_c2l(data,l); X(15)=l;
244 R0(C,D,A,B,X(14),17,0xa679438eL);
245 R0(B,C,D,A,X(15),22,0x49b40821L);
246 /* Round 1 */
247 R1(A,B,C,D,X( 1), 5,0xf61e2562L);
248 R1(D,A,B,C,X( 6), 9,0xc040b340L);
249 R1(C,D,A,B,X(11),14,0x265e5a51L);
250 R1(B,C,D,A,X( 0),20,0xe9b6c7aaL);
251 R1(A,B,C,D,X( 5), 5,0xd62f105dL);
252 R1(D,A,B,C,X(10), 9,0x02441453L);
253 R1(C,D,A,B,X(15),14,0xd8a1e681L);
254 R1(B,C,D,A,X( 4),20,0xe7d3fbc8L);
255 R1(A,B,C,D,X( 9), 5,0x21e1cde6L);
256 R1(D,A,B,C,X(14), 9,0xc33707d6L);
257 R1(C,D,A,B,X( 3),14,0xf4d50d87L);
258 R1(B,C,D,A,X( 8),20,0x455a14edL);
259 R1(A,B,C,D,X(13), 5,0xa9e3e905L);
260 R1(D,A,B,C,X( 2), 9,0xfcefa3f8L);
261 R1(C,D,A,B,X( 7),14,0x676f02d9L);
262 R1(B,C,D,A,X(12),20,0x8d2a4c8aL);
263 /* Round 2 */
264 R2(A,B,C,D,X( 5), 4,0xfffa3942L);
265 R2(D,A,B,C,X( 8),11,0x8771f681L);
266 R2(C,D,A,B,X(11),16,0x6d9d6122L);
267 R2(B,C,D,A,X(14),23,0xfde5380cL);
268 R2(A,B,C,D,X( 1), 4,0xa4beea44L);
269 R2(D,A,B,C,X( 4),11,0x4bdecfa9L);
270 R2(C,D,A,B,X( 7),16,0xf6bb4b60L);
271 R2(B,C,D,A,X(10),23,0xbebfbc70L);
272 R2(A,B,C,D,X(13), 4,0x289b7ec6L);
273 R2(D,A,B,C,X( 0),11,0xeaa127faL);
274 R2(C,D,A,B,X( 3),16,0xd4ef3085L);
275 R2(B,C,D,A,X( 6),23,0x04881d05L);
276 R2(A,B,C,D,X( 9), 4,0xd9d4d039L);
277 R2(D,A,B,C,X(12),11,0xe6db99e5L);
278 R2(C,D,A,B,X(15),16,0x1fa27cf8L);
279 R2(B,C,D,A,X( 2),23,0xc4ac5665L);
280 /* Round 3 */
281 R3(A,B,C,D,X( 0), 6,0xf4292244L);
282 R3(D,A,B,C,X( 7),10,0x432aff97L);
283 R3(C,D,A,B,X(14),15,0xab9423a7L);
284 R3(B,C,D,A,X( 5),21,0xfc93a039L);
285 R3(A,B,C,D,X(12), 6,0x655b59c3L);
286 R3(D,A,B,C,X( 3),10,0x8f0ccc92L);
287 R3(C,D,A,B,X(10),15,0xffeff47dL);
288 R3(B,C,D,A,X( 1),21,0x85845dd1L);
289 R3(A,B,C,D,X( 8), 6,0x6fa87e4fL);
290 R3(D,A,B,C,X(15),10,0xfe2ce6e0L);
291 R3(C,D,A,B,X( 6),15,0xa3014314L);
292 R3(B,C,D,A,X(13),21,0x4e0811a1L);
293 R3(A,B,C,D,X( 4), 6,0xf7537e82L);
294 R3(D,A,B,C,X(11),10,0xbd3af235L);
295 R3(C,D,A,B,X( 2),15,0x2ad7d2bbL);
296 R3(B,C,D,A,X( 9),21,0xeb86d391L);
418 297
419 /* clear stuff, md5_block may be leaving some stuff on the stack 298 A = c->A += A;
420 * but I'm not worried :-) */ 299 B = c->B += B;
421 c->num=0; 300 C = c->C += C;
422/* memset((char *)&c,0,sizeof(c));*/ 301 D = c->D += D;
302 }
423 } 303 }
304#endif
424 305
425#ifdef undef 306#ifdef undef
426int printit(l) 307int printit(unsigned long *l)
427unsigned long *l;
428 { 308 {
429 int i,ii; 309 int i,ii;
430 310
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-12-09 00:44:34 +0000