GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libcrypto/sha/sha_locl.h Lines: 7 7 100.0 %
Date: 2017-11-07 Branches: 0 0 0.0 %

Line Branch Exec Source
1
/* $OpenBSD: sha_locl.h,v 1.23 2016/12/23 23:22:25 patrick Exp $ */
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 <stdlib.h>
60
#include <string.h>
61
62
#include <openssl/opensslconf.h>
63
#include <openssl/sha.h>
64
65
#define DATA_ORDER_IS_BIG_ENDIAN
66
67
#define HASH_LONG               SHA_LONG
68
#define HASH_CTX                SHA_CTX
69
#define HASH_CBLOCK             SHA_CBLOCK
70
#define HASH_MAKE_STRING(c,s)   do {	\
71
	unsigned long ll;		\
72
	ll=(c)->h0; HOST_l2c(ll,(s));	\
73
	ll=(c)->h1; HOST_l2c(ll,(s));	\
74
	ll=(c)->h2; HOST_l2c(ll,(s));	\
75
	ll=(c)->h3; HOST_l2c(ll,(s));	\
76
	ll=(c)->h4; HOST_l2c(ll,(s));	\
77
	} while (0)
78
79
# define HASH_UPDATE             	SHA1_Update
80
# define HASH_TRANSFORM          	SHA1_Transform
81
# define HASH_FINAL              	SHA1_Final
82
# define HASH_INIT			SHA1_Init
83
# define HASH_BLOCK_DATA_ORDER   	sha1_block_data_order
84
# define Xupdate(a,ix,ia,ib,ic,id)	( (a)=(ia^ib^ic^id),	\
85
					  ix=(a)=ROTATE((a),1)	\
86
					)
87
88
__BEGIN_HIDDEN_DECLS
89
90
#ifndef SHA1_ASM
91
static
92
#endif
93
94
void sha1_block_data_order (SHA_CTX *c, const void *p,size_t num);
95
96
__END_HIDDEN_DECLS
97
98
#include "md32_common.h"
99
100
#define INIT_DATA_h0 0x67452301UL
101
#define INIT_DATA_h1 0xefcdab89UL
102
#define INIT_DATA_h2 0x98badcfeUL
103
#define INIT_DATA_h3 0x10325476UL
104
#define INIT_DATA_h4 0xc3d2e1f0UL
105
106
int SHA1_Init(SHA_CTX *c)
107
	{
108
185120
	memset (c,0,sizeof(*c));
109
92560
	c->h0=INIT_DATA_h0;
110
92560
	c->h1=INIT_DATA_h1;
111
92560
	c->h2=INIT_DATA_h2;
112
92560
	c->h3=INIT_DATA_h3;
113
92560
	c->h4=INIT_DATA_h4;
114
92560
	return 1;
115
	}
116
117
#define K_00_19	0x5a827999UL
118
#define K_20_39 0x6ed9eba1UL
119
#define K_40_59 0x8f1bbcdcUL
120
#define K_60_79 0xca62c1d6UL
121
122
/* As  pointed out by Wei Dai <weidai@eskimo.com>, F() below can be
123
 * simplified to the code in F_00_19.  Wei attributes these optimisations
124
 * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
125
 * #define F(x,y,z) (((x) & (y))  |  ((~(x)) & (z)))
126
 * I've just become aware of another tweak to be made, again from Wei Dai,
127
 * in F_40_59, (x&a)|(y&a) -> (x|y)&a
128
 */
129
#define	F_00_19(b,c,d)	((((c) ^ (d)) & (b)) ^ (d))
130
#define	F_20_39(b,c,d)	((b) ^ (c) ^ (d))
131
#define F_40_59(b,c,d)	(((b) & (c)) | (((b)|(c)) & (d)))
132
#define	F_60_79(b,c,d)	F_20_39(b,c,d)
133
134
#ifndef OPENSSL_SMALL_FOOTPRINT
135
136
#define BODY_00_15(i,a,b,c,d,e,f,xi) \
137
	(f)=xi+(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
138
	(b)=ROTATE((b),30);
139
140
#define BODY_16_19(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
141
	Xupdate(f,xi,xa,xb,xc,xd); \
142
	(f)+=(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
143
	(b)=ROTATE((b),30);
144
145
#define BODY_20_31(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
146
	Xupdate(f,xi,xa,xb,xc,xd); \
147
	(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
148
	(b)=ROTATE((b),30);
149
150
#define BODY_32_39(i,a,b,c,d,e,f,xa,xb,xc,xd) \
151
	Xupdate(f,xa,xa,xb,xc,xd); \
152
	(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
153
	(b)=ROTATE((b),30);
154
155
#define BODY_40_59(i,a,b,c,d,e,f,xa,xb,xc,xd) \
156
	Xupdate(f,xa,xa,xb,xc,xd); \
157
	(f)+=(e)+K_40_59+ROTATE((a),5)+F_40_59((b),(c),(d)); \
158
	(b)=ROTATE((b),30);
159
160
#define BODY_60_79(i,a,b,c,d,e,f,xa,xb,xc,xd) \
161
	Xupdate(f,xa,xa,xb,xc,xd); \
162
	(f)=xa+(e)+K_60_79+ROTATE((a),5)+F_60_79((b),(c),(d)); \
163
	(b)=ROTATE((b),30);
164
165
#ifdef X
166
#undef X
167
#endif
168
#ifndef MD32_XARRAY
169
  /*
170
   * Originally X was an array. As it's automatic it's natural
171
   * to expect RISC compiler to accommodate at least part of it in
172
   * the register bank, isn't it? Unfortunately not all compilers
173
   * "find" this expectation reasonable:-( On order to make such
174
   * compilers generate better code I replace X[] with a bunch of
175
   * X0, X1, etc. See the function body below...
176
   *					<appro@fy.chalmers.se>
177
   */
178
# define X(i)	XX##i
179
#else
180
  /*
181
   * However! Some compilers (most notably HP C) get overwhelmed by
182
   * that many local variables so that we have to have the way to
183
   * fall down to the original behavior.
184
   */
185
# define X(i)	XX[i]
186
#endif
187
188
#if !defined(SHA1_ASM)
189
#include <machine/endian.h>
190
static void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, size_t num)
191
	{
192
	const unsigned char *data=p;
193
	unsigned MD32_REG_T A,B,C,D,E,T,l;
194
#ifndef MD32_XARRAY
195
	unsigned MD32_REG_T	XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
196
				XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
197
#else
198
	SHA_LONG	XX[16];
199
#endif
200
201
	A=c->h0;
202
	B=c->h1;
203
	C=c->h2;
204
	D=c->h3;
205
	E=c->h4;
206
207
	for (;;)
208
			{
209
210
	if (BYTE_ORDER != LITTLE_ENDIAN &&
211
	    sizeof(SHA_LONG)==4 && ((size_t)p%4)==0)
212
		{
213
		const SHA_LONG *W=(const SHA_LONG *)data;
214
215
		X( 0) = W[0];				X( 1) = W[ 1];
216
		BODY_00_15( 0,A,B,C,D,E,T,X( 0));	X( 2) = W[ 2];
217
		BODY_00_15( 1,T,A,B,C,D,E,X( 1));	X( 3) = W[ 3];
218
		BODY_00_15( 2,E,T,A,B,C,D,X( 2));	X( 4) = W[ 4];
219
		BODY_00_15( 3,D,E,T,A,B,C,X( 3));	X( 5) = W[ 5];
220
		BODY_00_15( 4,C,D,E,T,A,B,X( 4));	X( 6) = W[ 6];
221
		BODY_00_15( 5,B,C,D,E,T,A,X( 5));	X( 7) = W[ 7];
222
		BODY_00_15( 6,A,B,C,D,E,T,X( 6));	X( 8) = W[ 8];
223
		BODY_00_15( 7,T,A,B,C,D,E,X( 7));	X( 9) = W[ 9];
224
		BODY_00_15( 8,E,T,A,B,C,D,X( 8));	X(10) = W[10];
225
		BODY_00_15( 9,D,E,T,A,B,C,X( 9));	X(11) = W[11];
226
		BODY_00_15(10,C,D,E,T,A,B,X(10));	X(12) = W[12];
227
		BODY_00_15(11,B,C,D,E,T,A,X(11));	X(13) = W[13];
228
		BODY_00_15(12,A,B,C,D,E,T,X(12));	X(14) = W[14];
229
		BODY_00_15(13,T,A,B,C,D,E,X(13));	X(15) = W[15];
230
		BODY_00_15(14,E,T,A,B,C,D,X(14));
231
		BODY_00_15(15,D,E,T,A,B,C,X(15));
232
233
		data += SHA_CBLOCK;
234
		}
235
	else
236
		{
237
		HOST_c2l(data,l); X( 0)=l;		HOST_c2l(data,l); X( 1)=l;
238
		BODY_00_15( 0,A,B,C,D,E,T,X( 0));	HOST_c2l(data,l); X( 2)=l;
239
		BODY_00_15( 1,T,A,B,C,D,E,X( 1));	HOST_c2l(data,l); X( 3)=l;
240
		BODY_00_15( 2,E,T,A,B,C,D,X( 2));	HOST_c2l(data,l); X( 4)=l;
241
		BODY_00_15( 3,D,E,T,A,B,C,X( 3));	HOST_c2l(data,l); X( 5)=l;
242
		BODY_00_15( 4,C,D,E,T,A,B,X( 4));	HOST_c2l(data,l); X( 6)=l;
243
		BODY_00_15( 5,B,C,D,E,T,A,X( 5));	HOST_c2l(data,l); X( 7)=l;
244
		BODY_00_15( 6,A,B,C,D,E,T,X( 6));	HOST_c2l(data,l); X( 8)=l;
245
		BODY_00_15( 7,T,A,B,C,D,E,X( 7));	HOST_c2l(data,l); X( 9)=l;
246
		BODY_00_15( 8,E,T,A,B,C,D,X( 8));	HOST_c2l(data,l); X(10)=l;
247
		BODY_00_15( 9,D,E,T,A,B,C,X( 9));	HOST_c2l(data,l); X(11)=l;
248
		BODY_00_15(10,C,D,E,T,A,B,X(10));	HOST_c2l(data,l); X(12)=l;
249
		BODY_00_15(11,B,C,D,E,T,A,X(11));	HOST_c2l(data,l); X(13)=l;
250
		BODY_00_15(12,A,B,C,D,E,T,X(12));	HOST_c2l(data,l); X(14)=l;
251
		BODY_00_15(13,T,A,B,C,D,E,X(13));	HOST_c2l(data,l); X(15)=l;
252
		BODY_00_15(14,E,T,A,B,C,D,X(14));
253
		BODY_00_15(15,D,E,T,A,B,C,X(15));
254
		}
255
256
	BODY_16_19(16,C,D,E,T,A,B,X( 0),X( 0),X( 2),X( 8),X(13));
257
	BODY_16_19(17,B,C,D,E,T,A,X( 1),X( 1),X( 3),X( 9),X(14));
258
	BODY_16_19(18,A,B,C,D,E,T,X( 2),X( 2),X( 4),X(10),X(15));
259
	BODY_16_19(19,T,A,B,C,D,E,X( 3),X( 3),X( 5),X(11),X( 0));
260
261
	BODY_20_31(20,E,T,A,B,C,D,X( 4),X( 4),X( 6),X(12),X( 1));
262
	BODY_20_31(21,D,E,T,A,B,C,X( 5),X( 5),X( 7),X(13),X( 2));
263
	BODY_20_31(22,C,D,E,T,A,B,X( 6),X( 6),X( 8),X(14),X( 3));
264
	BODY_20_31(23,B,C,D,E,T,A,X( 7),X( 7),X( 9),X(15),X( 4));
265
	BODY_20_31(24,A,B,C,D,E,T,X( 8),X( 8),X(10),X( 0),X( 5));
266
	BODY_20_31(25,T,A,B,C,D,E,X( 9),X( 9),X(11),X( 1),X( 6));
267
	BODY_20_31(26,E,T,A,B,C,D,X(10),X(10),X(12),X( 2),X( 7));
268
	BODY_20_31(27,D,E,T,A,B,C,X(11),X(11),X(13),X( 3),X( 8));
269
	BODY_20_31(28,C,D,E,T,A,B,X(12),X(12),X(14),X( 4),X( 9));
270
	BODY_20_31(29,B,C,D,E,T,A,X(13),X(13),X(15),X( 5),X(10));
271
	BODY_20_31(30,A,B,C,D,E,T,X(14),X(14),X( 0),X( 6),X(11));
272
	BODY_20_31(31,T,A,B,C,D,E,X(15),X(15),X( 1),X( 7),X(12));
273
274
	BODY_32_39(32,E,T,A,B,C,D,X( 0),X( 2),X( 8),X(13));
275
	BODY_32_39(33,D,E,T,A,B,C,X( 1),X( 3),X( 9),X(14));
276
	BODY_32_39(34,C,D,E,T,A,B,X( 2),X( 4),X(10),X(15));
277
	BODY_32_39(35,B,C,D,E,T,A,X( 3),X( 5),X(11),X( 0));
278
	BODY_32_39(36,A,B,C,D,E,T,X( 4),X( 6),X(12),X( 1));
279
	BODY_32_39(37,T,A,B,C,D,E,X( 5),X( 7),X(13),X( 2));
280
	BODY_32_39(38,E,T,A,B,C,D,X( 6),X( 8),X(14),X( 3));
281
	BODY_32_39(39,D,E,T,A,B,C,X( 7),X( 9),X(15),X( 4));
282
283
	BODY_40_59(40,C,D,E,T,A,B,X( 8),X(10),X( 0),X( 5));
284
	BODY_40_59(41,B,C,D,E,T,A,X( 9),X(11),X( 1),X( 6));
285
	BODY_40_59(42,A,B,C,D,E,T,X(10),X(12),X( 2),X( 7));
286
	BODY_40_59(43,T,A,B,C,D,E,X(11),X(13),X( 3),X( 8));
287
	BODY_40_59(44,E,T,A,B,C,D,X(12),X(14),X( 4),X( 9));
288
	BODY_40_59(45,D,E,T,A,B,C,X(13),X(15),X( 5),X(10));
289
	BODY_40_59(46,C,D,E,T,A,B,X(14),X( 0),X( 6),X(11));
290
	BODY_40_59(47,B,C,D,E,T,A,X(15),X( 1),X( 7),X(12));
291
	BODY_40_59(48,A,B,C,D,E,T,X( 0),X( 2),X( 8),X(13));
292
	BODY_40_59(49,T,A,B,C,D,E,X( 1),X( 3),X( 9),X(14));
293
	BODY_40_59(50,E,T,A,B,C,D,X( 2),X( 4),X(10),X(15));
294
	BODY_40_59(51,D,E,T,A,B,C,X( 3),X( 5),X(11),X( 0));
295
	BODY_40_59(52,C,D,E,T,A,B,X( 4),X( 6),X(12),X( 1));
296
	BODY_40_59(53,B,C,D,E,T,A,X( 5),X( 7),X(13),X( 2));
297
	BODY_40_59(54,A,B,C,D,E,T,X( 6),X( 8),X(14),X( 3));
298
	BODY_40_59(55,T,A,B,C,D,E,X( 7),X( 9),X(15),X( 4));
299
	BODY_40_59(56,E,T,A,B,C,D,X( 8),X(10),X( 0),X( 5));
300
	BODY_40_59(57,D,E,T,A,B,C,X( 9),X(11),X( 1),X( 6));
301
	BODY_40_59(58,C,D,E,T,A,B,X(10),X(12),X( 2),X( 7));
302
	BODY_40_59(59,B,C,D,E,T,A,X(11),X(13),X( 3),X( 8));
303
304
	BODY_60_79(60,A,B,C,D,E,T,X(12),X(14),X( 4),X( 9));
305
	BODY_60_79(61,T,A,B,C,D,E,X(13),X(15),X( 5),X(10));
306
	BODY_60_79(62,E,T,A,B,C,D,X(14),X( 0),X( 6),X(11));
307
	BODY_60_79(63,D,E,T,A,B,C,X(15),X( 1),X( 7),X(12));
308
	BODY_60_79(64,C,D,E,T,A,B,X( 0),X( 2),X( 8),X(13));
309
	BODY_60_79(65,B,C,D,E,T,A,X( 1),X( 3),X( 9),X(14));
310
	BODY_60_79(66,A,B,C,D,E,T,X( 2),X( 4),X(10),X(15));
311
	BODY_60_79(67,T,A,B,C,D,E,X( 3),X( 5),X(11),X( 0));
312
	BODY_60_79(68,E,T,A,B,C,D,X( 4),X( 6),X(12),X( 1));
313
	BODY_60_79(69,D,E,T,A,B,C,X( 5),X( 7),X(13),X( 2));
314
	BODY_60_79(70,C,D,E,T,A,B,X( 6),X( 8),X(14),X( 3));
315
	BODY_60_79(71,B,C,D,E,T,A,X( 7),X( 9),X(15),X( 4));
316
	BODY_60_79(72,A,B,C,D,E,T,X( 8),X(10),X( 0),X( 5));
317
	BODY_60_79(73,T,A,B,C,D,E,X( 9),X(11),X( 1),X( 6));
318
	BODY_60_79(74,E,T,A,B,C,D,X(10),X(12),X( 2),X( 7));
319
	BODY_60_79(75,D,E,T,A,B,C,X(11),X(13),X( 3),X( 8));
320
	BODY_60_79(76,C,D,E,T,A,B,X(12),X(14),X( 4),X( 9));
321
	BODY_60_79(77,B,C,D,E,T,A,X(13),X(15),X( 5),X(10));
322
	BODY_60_79(78,A,B,C,D,E,T,X(14),X( 0),X( 6),X(11));
323
	BODY_60_79(79,T,A,B,C,D,E,X(15),X( 1),X( 7),X(12));
324
325
	c->h0=(c->h0+E)&0xffffffffL;
326
	c->h1=(c->h1+T)&0xffffffffL;
327
	c->h2=(c->h2+A)&0xffffffffL;
328
	c->h3=(c->h3+B)&0xffffffffL;
329
	c->h4=(c->h4+C)&0xffffffffL;
330
331
	if (--num == 0) break;
332
333
	A=c->h0;
334
	B=c->h1;
335
	C=c->h2;
336
	D=c->h3;
337
	E=c->h4;
338
339
			}
340
	}
341
#endif
342
343
#else	/* OPENSSL_SMALL_FOOTPRINT */
344
345
#define BODY_00_15(xi)		 do {	\
346
	T=E+K_00_19+F_00_19(B,C,D);	\
347
	E=D, D=C, C=ROTATE(B,30), B=A;	\
348
	A=ROTATE(A,5)+T+xi;	    } while(0)
349
350
#define BODY_16_19(xa,xb,xc,xd)	 do {	\
351
	Xupdate(T,xa,xa,xb,xc,xd);	\
352
	T+=E+K_00_19+F_00_19(B,C,D);	\
353
	E=D, D=C, C=ROTATE(B,30), B=A;	\
354
	A=ROTATE(A,5)+T;	    } while(0)
355
356
#define BODY_20_39(xa,xb,xc,xd)	 do {	\
357
	Xupdate(T,xa,xa,xb,xc,xd);	\
358
	T+=E+K_20_39+F_20_39(B,C,D);	\
359
	E=D, D=C, C=ROTATE(B,30), B=A;	\
360
	A=ROTATE(A,5)+T;	    } while(0)
361
362
#define BODY_40_59(xa,xb,xc,xd)	 do {	\
363
	Xupdate(T,xa,xa,xb,xc,xd);	\
364
	T+=E+K_40_59+F_40_59(B,C,D);	\
365
	E=D, D=C, C=ROTATE(B,30), B=A;	\
366
	A=ROTATE(A,5)+T;	    } while(0)
367
368
#define BODY_60_79(xa,xb,xc,xd)	 do {	\
369
	Xupdate(T,xa,xa,xb,xc,xd);	\
370
	T=E+K_60_79+F_60_79(B,C,D);	\
371
	E=D, D=C, C=ROTATE(B,30), B=A;	\
372
	A=ROTATE(A,5)+T+xa;	    } while(0)
373
374
#if !defined(SHA1_ASM)
375
static void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, size_t num)
376
	{
377
	const unsigned char *data=p;
378
	unsigned MD32_REG_T A,B,C,D,E,T,l;
379
	int i;
380
	SHA_LONG	X[16];
381
382
	A=c->h0;
383
	B=c->h1;
384
	C=c->h2;
385
	D=c->h3;
386
	E=c->h4;
387
388
	for (;;)
389
		{
390
	for (i=0;i<16;i++)
391
	{ HOST_c2l(data,l); X[i]=l; BODY_00_15(X[i]); }
392
	for (i=0;i<4;i++)
393
	{ BODY_16_19(X[i],       X[i+2],      X[i+8],     X[(i+13)&15]); }
394
	for (;i<24;i++)
395
	{ BODY_20_39(X[i&15],    X[(i+2)&15], X[(i+8)&15],X[(i+13)&15]); }
396
	for (i=0;i<20;i++)
397
	{ BODY_40_59(X[(i+8)&15],X[(i+10)&15],X[i&15],    X[(i+5)&15]);  }
398
	for (i=4;i<24;i++)
399
	{ BODY_60_79(X[(i+8)&15],X[(i+10)&15],X[i&15],    X[(i+5)&15]);  }
400
401
	c->h0=(c->h0+A)&0xffffffffL;
402
	c->h1=(c->h1+B)&0xffffffffL;
403
	c->h2=(c->h2+C)&0xffffffffL;
404
	c->h3=(c->h3+D)&0xffffffffL;
405
	c->h4=(c->h4+E)&0xffffffffL;
406
407
	if (--num == 0) break;
408
409
	A=c->h0;
410
	B=c->h1;
411
	C=c->h2;
412
	D=c->h3;
413
	E=c->h4;
414
415
		}
416
	}
417
#endif
418
419
#endif