summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/ripemd/rmd_dgst.c
diff options
context:
space:
mode:
authorryker <>1998-10-05 20:13:14 +0000
committerryker <>1998-10-05 20:13:14 +0000
commitaeeae06a79815dc190061534d47236cec09f9e32 (patch)
tree851692b9c2f9c04f077666855641900f19fdb217 /src/lib/libcrypto/ripemd/rmd_dgst.c
parenta4f79641824cbf9f60ca9d1168d1fcc46717a82a (diff)
downloadopenbsd-aeeae06a79815dc190061534d47236cec09f9e32.tar.gz
openbsd-aeeae06a79815dc190061534d47236cec09f9e32.tar.bz2
openbsd-aeeae06a79815dc190061534d47236cec09f9e32.zip
Import of SSLeay-0.9.0b with RSA and IDEA stubbed + OpenBSD build
functionality for shared libs. Note that routines such as sslv2_init and friends that use RSA will not work due to lack of RSA in this library. Needs documentation and help from ports for easy upgrade to full functionality where legally possible.
Diffstat (limited to 'src/lib/libcrypto/ripemd/rmd_dgst.c')
-rw-r--r--src/lib/libcrypto/ripemd/rmd_dgst.c535
1 files changed, 535 insertions, 0 deletions
diff --git a/src/lib/libcrypto/ripemd/rmd_dgst.c b/src/lib/libcrypto/ripemd/rmd_dgst.c
new file mode 100644
index 0000000000..210de1977d
--- /dev/null
+++ b/src/lib/libcrypto/ripemd/rmd_dgst.c
@@ -0,0 +1,535 @@
1/* crypto/ripemd/rmd_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 "rmd_locl.h"
61
62char *RMD160_version="RIPEMD160 part of SSLeay 0.9.0b 29-Jun-1998";
63
64#ifndef NOPROTO
65# ifdef RMD160_ASM
66 void ripemd160_block_x86(RIPEMD160_CTX *c, unsigned long *p,int num);
67# define ripemd160_block ripemd160_block_x86
68# else
69 void ripemd160_block(RIPEMD160_CTX *c, unsigned long *p,int num);
70# endif
71#else
72# ifdef RMD160_ASM
73 void ripemd160_block_x86();
74# define ripemd160_block ripemd160_block_x86
75# else
76 static void ripemd160_block();
77# endif
78#endif
79
80void RIPEMD160_Init(c)
81RIPEMD160_CTX *c;
82 {
83 c->A=RIPEMD160_A;
84 c->B=RIPEMD160_B;
85 c->C=RIPEMD160_C;
86 c->D=RIPEMD160_D;
87 c->E=RIPEMD160_E;
88 c->Nl=0;
89 c->Nh=0;
90 c->num=0;
91 }
92
93void RIPEMD160_Update(c, data, len)
94RIPEMD160_CTX *c;
95register unsigned char *data;
96unsigned long len;
97 {
98 register ULONG *p;
99 int sw,sc;
100 ULONG l;
101
102 if (len == 0) return;
103
104 l=(c->Nl+(len<<3))&0xffffffffL;
105 if (l < c->Nl) /* overflow */
106 c->Nh++;
107 c->Nh+=(len>>29);
108 c->Nl=l;
109
110 if (c->num != 0)
111 {
112 p=c->data;
113 sw=c->num>>2;
114 sc=c->num&0x03;
115
116 if ((c->num+len) >= RIPEMD160_CBLOCK)
117 {
118 l= p[sw];
119 p_c2l(data,l,sc);
120 p[sw++]=l;
121 for (; sw<RIPEMD160_LBLOCK; sw++)
122 {
123 c2l(data,l);
124 p[sw]=l;
125 }
126 len-=(RIPEMD160_CBLOCK-c->num);
127
128 ripemd160_block(c,p,64);
129 c->num=0;
130 /* drop through and do the rest */
131 }
132 else
133 {
134 int ew,ec;
135
136 c->num+=(int)len;
137 if ((sc+len) < 4) /* ugly, add char's to a word */
138 {
139 l= p[sw];
140 p_c2l_p(data,l,sc,len);
141 p[sw]=l;
142 }
143 else
144 {
145 ew=(c->num>>2);
146 ec=(c->num&0x03);
147 l= p[sw];
148 p_c2l(data,l,sc);
149 p[sw++]=l;
150 for (; sw < ew; sw++)
151 { c2l(data,l); p[sw]=l; }
152 if (ec)
153 {
154 c2l_p(data,l,ec);
155 p[sw]=l;
156 }
157 }
158 return;
159 }
160 }
161 /* we now can process the input data in blocks of RIPEMD160_CBLOCK
162 * chars and save the leftovers to c->data. */
163#ifdef L_ENDIAN
164 if ((((unsigned long)data)%sizeof(ULONG)) == 0)
165 {
166 sw=(int)len/RIPEMD160_CBLOCK;
167 if (sw > 0)
168 {
169 sw*=RIPEMD160_CBLOCK;
170 ripemd160_block(c,(ULONG *)data,sw);
171 data+=sw;
172 len-=sw;
173 }
174 }
175#endif
176 p=c->data;
177 while (len >= RIPEMD160_CBLOCK)
178 {
179#if defined(L_ENDIAN) || defined(B_ENDIAN)
180 if (p != (unsigned long *)data)
181 memcpy(p,data,RIPEMD160_CBLOCK);
182 data+=RIPEMD160_CBLOCK;
183#ifdef B_ENDIAN
184 for (sw=(RIPEMD160_LBLOCK/4); sw; sw--)
185 {
186 Endian_Reverse32(p[0]);
187 Endian_Reverse32(p[1]);
188 Endian_Reverse32(p[2]);
189 Endian_Reverse32(p[3]);
190 p+=4;
191 }
192#endif
193#else
194 for (sw=(RIPEMD160_LBLOCK/4); sw; sw--)
195 {
196 c2l(data,l); *(p++)=l;
197 c2l(data,l); *(p++)=l;
198 c2l(data,l); *(p++)=l;
199 c2l(data,l); *(p++)=l;
200 }
201#endif
202 p=c->data;
203 ripemd160_block(c,p,64);
204 len-=RIPEMD160_CBLOCK;
205 }
206 sc=(int)len;
207 c->num=sc;
208 if (sc)
209 {
210 sw=sc>>2; /* words to copy */
211#ifdef L_ENDIAN
212 p[sw]=0;
213 memcpy(p,data,sc);
214#else
215 sc&=0x03;
216 for ( ; sw; sw--)
217 { c2l(data,l); *(p++)=l; }
218 c2l_p(data,l,sc);
219 *p=l;
220#endif
221 }
222 }
223
224void RIPEMD160_Transform(c,b)
225RIPEMD160_CTX *c;
226unsigned char *b;
227 {
228 ULONG p[16];
229#if !defined(L_ENDIAN)
230 ULONG *q;
231 int i;
232#endif
233
234#if defined(B_ENDIAN) || defined(L_ENDIAN)
235 memcpy(p,b,64);
236#ifdef B_ENDIAN
237 q=p;
238 for (i=(RIPEMD160_LBLOCK/4); i; i--)
239 {
240 Endian_Reverse32(q[0]);
241 Endian_Reverse32(q[1]);
242 Endian_Reverse32(q[2]);
243 Endian_Reverse32(q[3]);
244 q+=4;
245 }
246#endif
247#else
248 q=p;
249 for (i=(RIPEMD160_LBLOCK/4); i; i--)
250 {
251 ULONG l;
252 c2l(b,l); *(q++)=l;
253 c2l(b,l); *(q++)=l;
254 c2l(b,l); *(q++)=l;
255 c2l(b,l); *(q++)=l;
256 }
257#endif
258 ripemd160_block(c,p,64);
259 }
260
261#ifndef RMD160_ASM
262
263void ripemd160_block(ctx, X, num)
264RIPEMD160_CTX *ctx;
265register ULONG *X;
266int num;
267 {
268 register ULONG A,B,C,D,E;
269 ULONG a,b,c,d,e;
270
271 for (;;)
272 {
273 A=ctx->A; B=ctx->B; C=ctx->C; D=ctx->D; E=ctx->E;
274
275 RIP1(A,B,C,D,E,WL00,SL00);
276 RIP1(E,A,B,C,D,WL01,SL01);
277 RIP1(D,E,A,B,C,WL02,SL02);
278 RIP1(C,D,E,A,B,WL03,SL03);
279 RIP1(B,C,D,E,A,WL04,SL04);
280 RIP1(A,B,C,D,E,WL05,SL05);
281 RIP1(E,A,B,C,D,WL06,SL06);
282 RIP1(D,E,A,B,C,WL07,SL07);
283 RIP1(C,D,E,A,B,WL08,SL08);
284 RIP1(B,C,D,E,A,WL09,SL09);
285 RIP1(A,B,C,D,E,WL10,SL10);
286 RIP1(E,A,B,C,D,WL11,SL11);
287 RIP1(D,E,A,B,C,WL12,SL12);
288 RIP1(C,D,E,A,B,WL13,SL13);
289 RIP1(B,C,D,E,A,WL14,SL14);
290 RIP1(A,B,C,D,E,WL15,SL15);
291
292 RIP2(E,A,B,C,D,WL16,SL16,KL1);
293 RIP2(D,E,A,B,C,WL17,SL17,KL1);
294 RIP2(C,D,E,A,B,WL18,SL18,KL1);
295 RIP2(B,C,D,E,A,WL19,SL19,KL1);
296 RIP2(A,B,C,D,E,WL20,SL20,KL1);
297 RIP2(E,A,B,C,D,WL21,SL21,KL1);
298 RIP2(D,E,A,B,C,WL22,SL22,KL1);
299 RIP2(C,D,E,A,B,WL23,SL23,KL1);
300 RIP2(B,C,D,E,A,WL24,SL24,KL1);
301 RIP2(A,B,C,D,E,WL25,SL25,KL1);
302 RIP2(E,A,B,C,D,WL26,SL26,KL1);
303 RIP2(D,E,A,B,C,WL27,SL27,KL1);
304 RIP2(C,D,E,A,B,WL28,SL28,KL1);
305 RIP2(B,C,D,E,A,WL29,SL29,KL1);
306 RIP2(A,B,C,D,E,WL30,SL30,KL1);
307 RIP2(E,A,B,C,D,WL31,SL31,KL1);
308
309 RIP3(D,E,A,B,C,WL32,SL32,KL2);
310 RIP3(C,D,E,A,B,WL33,SL33,KL2);
311 RIP3(B,C,D,E,A,WL34,SL34,KL2);
312 RIP3(A,B,C,D,E,WL35,SL35,KL2);
313 RIP3(E,A,B,C,D,WL36,SL36,KL2);
314 RIP3(D,E,A,B,C,WL37,SL37,KL2);
315 RIP3(C,D,E,A,B,WL38,SL38,KL2);
316 RIP3(B,C,D,E,A,WL39,SL39,KL2);
317 RIP3(A,B,C,D,E,WL40,SL40,KL2);
318 RIP3(E,A,B,C,D,WL41,SL41,KL2);
319 RIP3(D,E,A,B,C,WL42,SL42,KL2);
320 RIP3(C,D,E,A,B,WL43,SL43,KL2);
321 RIP3(B,C,D,E,A,WL44,SL44,KL2);
322 RIP3(A,B,C,D,E,WL45,SL45,KL2);
323 RIP3(E,A,B,C,D,WL46,SL46,KL2);
324 RIP3(D,E,A,B,C,WL47,SL47,KL2);
325
326 RIP4(C,D,E,A,B,WL48,SL48,KL3);
327 RIP4(B,C,D,E,A,WL49,SL49,KL3);
328 RIP4(A,B,C,D,E,WL50,SL50,KL3);
329 RIP4(E,A,B,C,D,WL51,SL51,KL3);
330 RIP4(D,E,A,B,C,WL52,SL52,KL3);
331 RIP4(C,D,E,A,B,WL53,SL53,KL3);
332 RIP4(B,C,D,E,A,WL54,SL54,KL3);
333 RIP4(A,B,C,D,E,WL55,SL55,KL3);
334 RIP4(E,A,B,C,D,WL56,SL56,KL3);
335 RIP4(D,E,A,B,C,WL57,SL57,KL3);
336 RIP4(C,D,E,A,B,WL58,SL58,KL3);
337 RIP4(B,C,D,E,A,WL59,SL59,KL3);
338 RIP4(A,B,C,D,E,WL60,SL60,KL3);
339 RIP4(E,A,B,C,D,WL61,SL61,KL3);
340 RIP4(D,E,A,B,C,WL62,SL62,KL3);
341 RIP4(C,D,E,A,B,WL63,SL63,KL3);
342
343 RIP5(B,C,D,E,A,WL64,SL64,KL4);
344 RIP5(A,B,C,D,E,WL65,SL65,KL4);
345 RIP5(E,A,B,C,D,WL66,SL66,KL4);
346 RIP5(D,E,A,B,C,WL67,SL67,KL4);
347 RIP5(C,D,E,A,B,WL68,SL68,KL4);
348 RIP5(B,C,D,E,A,WL69,SL69,KL4);
349 RIP5(A,B,C,D,E,WL70,SL70,KL4);
350 RIP5(E,A,B,C,D,WL71,SL71,KL4);
351 RIP5(D,E,A,B,C,WL72,SL72,KL4);
352 RIP5(C,D,E,A,B,WL73,SL73,KL4);
353 RIP5(B,C,D,E,A,WL74,SL74,KL4);
354 RIP5(A,B,C,D,E,WL75,SL75,KL4);
355 RIP5(E,A,B,C,D,WL76,SL76,KL4);
356 RIP5(D,E,A,B,C,WL77,SL77,KL4);
357 RIP5(C,D,E,A,B,WL78,SL78,KL4);
358 RIP5(B,C,D,E,A,WL79,SL79,KL4);
359
360 a=A; b=B; c=C; d=D; e=E;
361 /* Do other half */
362 A=ctx->A; B=ctx->B; C=ctx->C; D=ctx->D; E=ctx->E;
363
364 RIP5(A,B,C,D,E,WR00,SR00,KR0);
365 RIP5(E,A,B,C,D,WR01,SR01,KR0);
366 RIP5(D,E,A,B,C,WR02,SR02,KR0);
367 RIP5(C,D,E,A,B,WR03,SR03,KR0);
368 RIP5(B,C,D,E,A,WR04,SR04,KR0);
369 RIP5(A,B,C,D,E,WR05,SR05,KR0);
370 RIP5(E,A,B,C,D,WR06,SR06,KR0);
371 RIP5(D,E,A,B,C,WR07,SR07,KR0);
372 RIP5(C,D,E,A,B,WR08,SR08,KR0);
373 RIP5(B,C,D,E,A,WR09,SR09,KR0);
374 RIP5(A,B,C,D,E,WR10,SR10,KR0);
375 RIP5(E,A,B,C,D,WR11,SR11,KR0);
376 RIP5(D,E,A,B,C,WR12,SR12,KR0);
377 RIP5(C,D,E,A,B,WR13,SR13,KR0);
378 RIP5(B,C,D,E,A,WR14,SR14,KR0);
379 RIP5(A,B,C,D,E,WR15,SR15,KR0);
380
381 RIP4(E,A,B,C,D,WR16,SR16,KR1);
382 RIP4(D,E,A,B,C,WR17,SR17,KR1);
383 RIP4(C,D,E,A,B,WR18,SR18,KR1);
384 RIP4(B,C,D,E,A,WR19,SR19,KR1);
385 RIP4(A,B,C,D,E,WR20,SR20,KR1);
386 RIP4(E,A,B,C,D,WR21,SR21,KR1);
387 RIP4(D,E,A,B,C,WR22,SR22,KR1);
388 RIP4(C,D,E,A,B,WR23,SR23,KR1);
389 RIP4(B,C,D,E,A,WR24,SR24,KR1);
390 RIP4(A,B,C,D,E,WR25,SR25,KR1);
391 RIP4(E,A,B,C,D,WR26,SR26,KR1);
392 RIP4(D,E,A,B,C,WR27,SR27,KR1);
393 RIP4(C,D,E,A,B,WR28,SR28,KR1);
394 RIP4(B,C,D,E,A,WR29,SR29,KR1);
395 RIP4(A,B,C,D,E,WR30,SR30,KR1);
396 RIP4(E,A,B,C,D,WR31,SR31,KR1);
397
398 RIP3(D,E,A,B,C,WR32,SR32,KR2);
399 RIP3(C,D,E,A,B,WR33,SR33,KR2);
400 RIP3(B,C,D,E,A,WR34,SR34,KR2);
401 RIP3(A,B,C,D,E,WR35,SR35,KR2);
402 RIP3(E,A,B,C,D,WR36,SR36,KR2);
403 RIP3(D,E,A,B,C,WR37,SR37,KR2);
404 RIP3(C,D,E,A,B,WR38,SR38,KR2);
405 RIP3(B,C,D,E,A,WR39,SR39,KR2);
406 RIP3(A,B,C,D,E,WR40,SR40,KR2);
407 RIP3(E,A,B,C,D,WR41,SR41,KR2);
408 RIP3(D,E,A,B,C,WR42,SR42,KR2);
409 RIP3(C,D,E,A,B,WR43,SR43,KR2);
410 RIP3(B,C,D,E,A,WR44,SR44,KR2);
411 RIP3(A,B,C,D,E,WR45,SR45,KR2);
412 RIP3(E,A,B,C,D,WR46,SR46,KR2);
413 RIP3(D,E,A,B,C,WR47,SR47,KR2);
414
415 RIP2(C,D,E,A,B,WR48,SR48,KR3);
416 RIP2(B,C,D,E,A,WR49,SR49,KR3);
417 RIP2(A,B,C,D,E,WR50,SR50,KR3);
418 RIP2(E,A,B,C,D,WR51,SR51,KR3);
419 RIP2(D,E,A,B,C,WR52,SR52,KR3);
420 RIP2(C,D,E,A,B,WR53,SR53,KR3);
421 RIP2(B,C,D,E,A,WR54,SR54,KR3);
422 RIP2(A,B,C,D,E,WR55,SR55,KR3);
423 RIP2(E,A,B,C,D,WR56,SR56,KR3);
424 RIP2(D,E,A,B,C,WR57,SR57,KR3);
425 RIP2(C,D,E,A,B,WR58,SR58,KR3);
426 RIP2(B,C,D,E,A,WR59,SR59,KR3);
427 RIP2(A,B,C,D,E,WR60,SR60,KR3);
428 RIP2(E,A,B,C,D,WR61,SR61,KR3);
429 RIP2(D,E,A,B,C,WR62,SR62,KR3);
430 RIP2(C,D,E,A,B,WR63,SR63,KR3);
431
432 RIP1(B,C,D,E,A,WR64,SR64);
433 RIP1(A,B,C,D,E,WR65,SR65);
434 RIP1(E,A,B,C,D,WR66,SR66);
435 RIP1(D,E,A,B,C,WR67,SR67);
436 RIP1(C,D,E,A,B,WR68,SR68);
437 RIP1(B,C,D,E,A,WR69,SR69);
438 RIP1(A,B,C,D,E,WR70,SR70);
439 RIP1(E,A,B,C,D,WR71,SR71);
440 RIP1(D,E,A,B,C,WR72,SR72);
441 RIP1(C,D,E,A,B,WR73,SR73);
442 RIP1(B,C,D,E,A,WR74,SR74);
443 RIP1(A,B,C,D,E,WR75,SR75);
444 RIP1(E,A,B,C,D,WR76,SR76);
445 RIP1(D,E,A,B,C,WR77,SR77);
446 RIP1(C,D,E,A,B,WR78,SR78);
447 RIP1(B,C,D,E,A,WR79,SR79);
448
449 D =ctx->B+c+D;
450 ctx->B=ctx->C+d+E;
451 ctx->C=ctx->D+e+A;
452 ctx->D=ctx->E+a+B;
453 ctx->E=ctx->A+b+C;
454 ctx->A=D;
455
456 X+=16;
457 num-=64;
458 if (num <= 0) break;
459 }
460 }
461#endif
462
463void RIPEMD160_Final(md, c)
464unsigned char *md;
465RIPEMD160_CTX *c;
466 {
467 register int i,j;
468 register ULONG l;
469 register ULONG *p;
470 static unsigned char end[4]={0x80,0x00,0x00,0x00};
471 unsigned char *cp=end;
472
473 /* c->num should definitly have room for at least one more byte. */
474 p=c->data;
475 j=c->num;
476 i=j>>2;
477
478 /* purify often complains about the following line as an
479 * Uninitialized Memory Read. While this can be true, the
480 * following p_c2l macro will reset l when that case is true.
481 * This is because j&0x03 contains the number of 'valid' bytes
482 * already in p[i]. If and only if j&0x03 == 0, the UMR will
483 * occur but this is also the only time p_c2l will do
484 * l= *(cp++) instead of l|= *(cp++)
485 * Many thanks to Alex Tang <altitude@cic.net> for pickup this
486 * 'potential bug' */
487#ifdef PURIFY
488 if ((j&0x03) == 0) p[i]=0;
489#endif
490 l=p[i];
491 p_c2l(cp,l,j&0x03);
492 p[i]=l;
493 i++;
494 /* i is the next 'undefined word' */
495 if (c->num >= RIPEMD160_LAST_BLOCK)
496 {
497 for (; i<RIPEMD160_LBLOCK; i++)
498 p[i]=0;
499 ripemd160_block(c,p,64);
500 i=0;
501 }
502 for (; i<(RIPEMD160_LBLOCK-2); i++)
503 p[i]=0;
504 p[RIPEMD160_LBLOCK-2]=c->Nl;
505 p[RIPEMD160_LBLOCK-1]=c->Nh;
506 ripemd160_block(c,p,64);
507 cp=md;
508 l=c->A; l2c(l,cp);
509 l=c->B; l2c(l,cp);
510 l=c->C; l2c(l,cp);
511 l=c->D; l2c(l,cp);
512 l=c->E; l2c(l,cp);
513
514 /* clear stuff, ripemd160_block may be leaving some stuff on the stack
515 * but I'm not worried :-) */
516 c->num=0;
517/* memset((char *)&c,0,sizeof(c));*/
518 }
519
520#ifdef undef
521int printit(l)
522unsigned long *l;
523 {
524 int i,ii;
525
526 for (i=0; i<2; i++)
527 {
528 for (ii=0; ii<8; ii++)
529 {
530 fprintf(stderr,"%08lx ",l[i*8+ii]);
531 }
532 fprintf(stderr,"\n");
533 }
534 }
535#endif
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-20 04:18:58 +0000