![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rmd160.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / crypto|
Return to rmd160.c CVS log | Up to [truecrypt] / truecrypt / crypto |
1.1.1.6 root 1: // RIPEMD-160 written and placed in the public domain by Wei Dai
2:
1.1 root 3: /*
1.1.1.6 root 4: * This code implements the MD4 message-digest algorithm.
5: * The algorithm is due to Ron Rivest. This code was
6: * written by Colin Plumb in 1993, no copyright is claimed.
7: * This code is in the public domain; do with it what you wish.
1.1 root 8: */
9:
1.1.1.3 root 10: /* Adapted by TrueCrypt Foundation */
11:
1.1 root 12: #include <memory.h>
1.1.1.6 root 13: #include "Common/Tcdefs.h"
14: #include "Common/Endian.h"
15: #include "Rmd160.h"
1.1 root 16:
1.1.1.6 root 17: #define F(x, y, z) (x ^ y ^ z)
18: #define G(x, y, z) (z ^ (x & (y^z)))
19: #define H(x, y, z) (z ^ (x | ~y))
20: #define I(x, y, z) (y ^ (z & (x^y)))
21: #define J(x, y, z) (x ^ (y | ~z))
22:
23: #define PUT_64BIT_LE(cp, value) do { \
24: (cp)[7] = (byte) ((value) >> 56); \
25: (cp)[6] = (byte) ((value) >> 48); \
26: (cp)[5] = (byte) ((value) >> 40); \
27: (cp)[4] = (byte) ((value) >> 32); \
28: (cp)[3] = (byte) ((value) >> 24); \
29: (cp)[2] = (byte) ((value) >> 16); \
30: (cp)[1] = (byte) ((value) >> 8); \
31: (cp)[0] = (byte) (value); } while (0)
32:
33: #define PUT_32BIT_LE(cp, value) do { \
34: (cp)[3] = (byte) ((value) >> 24); \
35: (cp)[2] = (byte) ((value) >> 16); \
36: (cp)[1] = (byte) ((value) >> 8); \
37: (cp)[0] = (byte) (value); } while (0)
1.1 root 38:
1.1.1.3 root 39: #ifndef TC_MINIMIZE_CODE_SIZE
40:
1.1.1.6 root 41: static byte PADDING[64] = {
1.1 root 42: 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
43: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
44: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
45: };
46:
1.1.1.3 root 47: #else
48:
1.1.1.6 root 49: static byte PADDING[64];
1.1.1.3 root 50:
1.1.1.6 root 51: #endif
1.1.1.3 root 52:
1.1.1.6 root 53: void RMD160Init (RMD160_CTX *ctx)
1.1 root 54: {
55: ctx->count = 0;
1.1.1.6 root 56: ctx->state[0] = 0x67452301;
57: ctx->state[1] = 0xefcdab89;
58: ctx->state[2] = 0x98badcfe;
59: ctx->state[3] = 0x10325476;
60: ctx->state[4] = 0xc3d2e1f0;
1.1.1.3 root 61: PADDING[0] = 0x80;
1.1 root 62: }
63:
1.1.1.6 root 64: /*
65: * Update context to reflect the concatenation of another buffer full
66: * of bytes.
67: */
68: void RMD160Update (RMD160_CTX *ctx, const unsigned char *input, unsigned __int32 len)
1.1 root 69: {
1.1.1.6 root 70: size_t have, need;
71:
72: /* Check how many bytes we already have and how many more we need. */
73: have = (size_t)((ctx->count >> 3) & (RIPEMD160_BLOCK_LENGTH - 1));
74: need = RIPEMD160_BLOCK_LENGTH - have;
1.1 root 75:
1.1.1.6 root 76: /* Update bitcount */
77: ctx->count +=
78: #ifndef TC_NO_COMPILER_INT64
79: (uint64)
80: #endif
81: len << 3;
1.1 root 82:
83: if (len >= need) {
1.1.1.6 root 84: if (have != 0) {
85: memcpy (ctx->buffer + have, input, need);
86: RMD160Transform ((uint32 *) ctx->state, (const uint32 *) ctx->buffer);
87: input += need;
88: len -= need;
1.1 root 89: have = 0;
90: }
1.1.1.6 root 91:
92: /* Process data in RIPEMD160_BLOCK_LENGTH-byte chunks. */
93: while (len >= RIPEMD160_BLOCK_LENGTH) {
94: RMD160Transform ((uint32 *) ctx->state, (const uint32 *) input);
95: input += RIPEMD160_BLOCK_LENGTH;
96: len -= RIPEMD160_BLOCK_LENGTH;
1.1 root 97: }
98: }
1.1.1.6 root 99:
100: /* Handle any remaining bytes of data. */
101: if (len != 0)
102: memcpy (ctx->buffer + have, input, (size_t) len);
1.1 root 103: }
104:
1.1.1.6 root 105: /*
106: * Pad pad to 64-byte boundary with the bit pattern
107: * 1 0* (64-bit count of bits processed, MSB-first)
108: */
109: static void RMD160Pad(RMD160_CTX *ctx)
1.1 root 110: {
1.1.1.6 root 111: byte count[8];
112: size_t padlen;
113:
114: /* Convert count to 8 bytes in little endian order. */
1.1 root 115:
1.1.1.3 root 116: #ifndef TC_NO_COMPILER_INT64
1.1.1.6 root 117: PUT_64BIT_LE(count, ctx->count);
1.1.1.3 root 118: #else
1.1.1.6 root 119: *(unsigned __int32 *) (count + 4) = 0;
120: PUT_32BIT_LE(count, ctx->count);
1.1.1.3 root 121: #endif
1.1.1.6 root 122:
123: /* Pad out to 56 mod 64. */
124: padlen = RIPEMD160_BLOCK_LENGTH -
125: (size_t)((ctx->count >> 3) & (RIPEMD160_BLOCK_LENGTH - 1));
1.1 root 126: if (padlen < 1 + 8)
1.1.1.6 root 127: padlen += RIPEMD160_BLOCK_LENGTH;
128: RMD160Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */
129: RMD160Update(ctx, count, 8);
130: }
1.1 root 131:
1.1.1.6 root 132: /*
133: * Final wrapup--call RMD160Pad, fill in digest and zero out ctx.
134: */
135: void RMD160Final(unsigned char *digest, RMD160_CTX *ctx)
136: {
137: int i;
1.1 root 138:
1.1.1.6 root 139: RMD160Pad(ctx);
140: if (digest) {
141: for (i = 0; i < 5; i++)
142: PUT_32BIT_LE(digest + i * 4, ctx->state[i]);
143: memset (ctx, 0, sizeof(*ctx));
144: }
1.1 root 145: }
146:
1.1.1.6 root 147:
1.1.1.3 root 148: #ifndef TC_MINIMIZE_CODE_SIZE
149:
1.1.1.6 root 150: #define word32 unsigned __int32
151:
152: #define k0 0
153: #define k1 0x5a827999UL
154: #define k2 0x6ed9eba1UL
155: #define k3 0x8f1bbcdcUL
156: #define k4 0xa953fd4eUL
157: #define k5 0x50a28be6UL
158: #define k6 0x5c4dd124UL
159: #define k7 0x6d703ef3UL
160: #define k8 0x7a6d76e9UL
161: #define k9 0
162:
163: static word32 rotlFixed (word32 x, unsigned int y)
1.1 root 164: {
1.1.1.6 root 165: return (word32)((x<<y) | (x>>(sizeof(word32)*8-y)));
166: }
1.1 root 167:
1.1.1.6 root 168: #define Subround(f, a, b, c, d, e, x, s, k) \
169: a += f(b, c, d) + x + k;\
170: a = rotlFixed((word32)a, s) + e;\
171: c = rotlFixed((word32)c, 10U)
172:
173: void RMD160Transform (unsigned __int32 *digest, const unsigned __int32 *data)
174: {
1.1 root 175: #if BYTE_ORDER == LITTLE_ENDIAN
1.1.1.6 root 176: const word32 *X = data;
1.1 root 177: #else
1.1.1.6 root 178: word32 X[16];
1.1 root 179: int i;
180: #endif
181:
1.1.1.6 root 182: word32 a1, b1, c1, d1, e1, a2, b2, c2, d2, e2;
183: a1 = a2 = digest[0];
184: b1 = b2 = digest[1];
185: c1 = c2 = digest[2];
186: d1 = d2 = digest[3];
187: e1 = e2 = digest[4];
1.1 root 188:
1.1.1.6 root 189: #if BYTE_ORDER == BIG_ENDIAN
190: for (i = 0; i < 16; i++)
191: {
192: X[i] = LE32 (data[i]);
193: }
194: #endif
1.1 root 195:
1.1.1.6 root 196: Subround(F, a1, b1, c1, d1, e1, X[ 0], 11, k0);
197: Subround(F, e1, a1, b1, c1, d1, X[ 1], 14, k0);
198: Subround(F, d1, e1, a1, b1, c1, X[ 2], 15, k0);
199: Subround(F, c1, d1, e1, a1, b1, X[ 3], 12, k0);
200: Subround(F, b1, c1, d1, e1, a1, X[ 4], 5, k0);
201: Subround(F, a1, b1, c1, d1, e1, X[ 5], 8, k0);
202: Subround(F, e1, a1, b1, c1, d1, X[ 6], 7, k0);
203: Subround(F, d1, e1, a1, b1, c1, X[ 7], 9, k0);
204: Subround(F, c1, d1, e1, a1, b1, X[ 8], 11, k0);
205: Subround(F, b1, c1, d1, e1, a1, X[ 9], 13, k0);
206: Subround(F, a1, b1, c1, d1, e1, X[10], 14, k0);
207: Subround(F, e1, a1, b1, c1, d1, X[11], 15, k0);
208: Subround(F, d1, e1, a1, b1, c1, X[12], 6, k0);
209: Subround(F, c1, d1, e1, a1, b1, X[13], 7, k0);
210: Subround(F, b1, c1, d1, e1, a1, X[14], 9, k0);
211: Subround(F, a1, b1, c1, d1, e1, X[15], 8, k0);
212:
213: Subround(G, e1, a1, b1, c1, d1, X[ 7], 7, k1);
214: Subround(G, d1, e1, a1, b1, c1, X[ 4], 6, k1);
215: Subround(G, c1, d1, e1, a1, b1, X[13], 8, k1);
216: Subround(G, b1, c1, d1, e1, a1, X[ 1], 13, k1);
217: Subround(G, a1, b1, c1, d1, e1, X[10], 11, k1);
218: Subround(G, e1, a1, b1, c1, d1, X[ 6], 9, k1);
219: Subround(G, d1, e1, a1, b1, c1, X[15], 7, k1);
220: Subround(G, c1, d1, e1, a1, b1, X[ 3], 15, k1);
221: Subround(G, b1, c1, d1, e1, a1, X[12], 7, k1);
222: Subround(G, a1, b1, c1, d1, e1, X[ 0], 12, k1);
223: Subround(G, e1, a1, b1, c1, d1, X[ 9], 15, k1);
224: Subround(G, d1, e1, a1, b1, c1, X[ 5], 9, k1);
225: Subround(G, c1, d1, e1, a1, b1, X[ 2], 11, k1);
226: Subround(G, b1, c1, d1, e1, a1, X[14], 7, k1);
227: Subround(G, a1, b1, c1, d1, e1, X[11], 13, k1);
228: Subround(G, e1, a1, b1, c1, d1, X[ 8], 12, k1);
229:
230: Subround(H, d1, e1, a1, b1, c1, X[ 3], 11, k2);
231: Subround(H, c1, d1, e1, a1, b1, X[10], 13, k2);
232: Subround(H, b1, c1, d1, e1, a1, X[14], 6, k2);
233: Subround(H, a1, b1, c1, d1, e1, X[ 4], 7, k2);
234: Subround(H, e1, a1, b1, c1, d1, X[ 9], 14, k2);
235: Subround(H, d1, e1, a1, b1, c1, X[15], 9, k2);
236: Subround(H, c1, d1, e1, a1, b1, X[ 8], 13, k2);
237: Subround(H, b1, c1, d1, e1, a1, X[ 1], 15, k2);
238: Subround(H, a1, b1, c1, d1, e1, X[ 2], 14, k2);
239: Subround(H, e1, a1, b1, c1, d1, X[ 7], 8, k2);
240: Subround(H, d1, e1, a1, b1, c1, X[ 0], 13, k2);
241: Subround(H, c1, d1, e1, a1, b1, X[ 6], 6, k2);
242: Subround(H, b1, c1, d1, e1, a1, X[13], 5, k2);
243: Subround(H, a1, b1, c1, d1, e1, X[11], 12, k2);
244: Subround(H, e1, a1, b1, c1, d1, X[ 5], 7, k2);
245: Subround(H, d1, e1, a1, b1, c1, X[12], 5, k2);
246:
247: Subround(I, c1, d1, e1, a1, b1, X[ 1], 11, k3);
248: Subround(I, b1, c1, d1, e1, a1, X[ 9], 12, k3);
249: Subround(I, a1, b1, c1, d1, e1, X[11], 14, k3);
250: Subround(I, e1, a1, b1, c1, d1, X[10], 15, k3);
251: Subround(I, d1, e1, a1, b1, c1, X[ 0], 14, k3);
252: Subround(I, c1, d1, e1, a1, b1, X[ 8], 15, k3);
253: Subround(I, b1, c1, d1, e1, a1, X[12], 9, k3);
254: Subround(I, a1, b1, c1, d1, e1, X[ 4], 8, k3);
255: Subround(I, e1, a1, b1, c1, d1, X[13], 9, k3);
256: Subround(I, d1, e1, a1, b1, c1, X[ 3], 14, k3);
257: Subround(I, c1, d1, e1, a1, b1, X[ 7], 5, k3);
258: Subround(I, b1, c1, d1, e1, a1, X[15], 6, k3);
259: Subround(I, a1, b1, c1, d1, e1, X[14], 8, k3);
260: Subround(I, e1, a1, b1, c1, d1, X[ 5], 6, k3);
261: Subround(I, d1, e1, a1, b1, c1, X[ 6], 5, k3);
262: Subround(I, c1, d1, e1, a1, b1, X[ 2], 12, k3);
263:
264: Subround(J, b1, c1, d1, e1, a1, X[ 4], 9, k4);
265: Subround(J, a1, b1, c1, d1, e1, X[ 0], 15, k4);
266: Subround(J, e1, a1, b1, c1, d1, X[ 5], 5, k4);
267: Subround(J, d1, e1, a1, b1, c1, X[ 9], 11, k4);
268: Subround(J, c1, d1, e1, a1, b1, X[ 7], 6, k4);
269: Subround(J, b1, c1, d1, e1, a1, X[12], 8, k4);
270: Subround(J, a1, b1, c1, d1, e1, X[ 2], 13, k4);
271: Subround(J, e1, a1, b1, c1, d1, X[10], 12, k4);
272: Subround(J, d1, e1, a1, b1, c1, X[14], 5, k4);
273: Subround(J, c1, d1, e1, a1, b1, X[ 1], 12, k4);
274: Subround(J, b1, c1, d1, e1, a1, X[ 3], 13, k4);
275: Subround(J, a1, b1, c1, d1, e1, X[ 8], 14, k4);
276: Subround(J, e1, a1, b1, c1, d1, X[11], 11, k4);
277: Subround(J, d1, e1, a1, b1, c1, X[ 6], 8, k4);
278: Subround(J, c1, d1, e1, a1, b1, X[15], 5, k4);
279: Subround(J, b1, c1, d1, e1, a1, X[13], 6, k4);
280:
281: Subround(J, a2, b2, c2, d2, e2, X[ 5], 8, k5);
282: Subround(J, e2, a2, b2, c2, d2, X[14], 9, k5);
283: Subround(J, d2, e2, a2, b2, c2, X[ 7], 9, k5);
284: Subround(J, c2, d2, e2, a2, b2, X[ 0], 11, k5);
285: Subround(J, b2, c2, d2, e2, a2, X[ 9], 13, k5);
286: Subround(J, a2, b2, c2, d2, e2, X[ 2], 15, k5);
287: Subround(J, e2, a2, b2, c2, d2, X[11], 15, k5);
288: Subround(J, d2, e2, a2, b2, c2, X[ 4], 5, k5);
289: Subround(J, c2, d2, e2, a2, b2, X[13], 7, k5);
290: Subround(J, b2, c2, d2, e2, a2, X[ 6], 7, k5);
291: Subround(J, a2, b2, c2, d2, e2, X[15], 8, k5);
292: Subround(J, e2, a2, b2, c2, d2, X[ 8], 11, k5);
293: Subround(J, d2, e2, a2, b2, c2, X[ 1], 14, k5);
294: Subround(J, c2, d2, e2, a2, b2, X[10], 14, k5);
295: Subround(J, b2, c2, d2, e2, a2, X[ 3], 12, k5);
296: Subround(J, a2, b2, c2, d2, e2, X[12], 6, k5);
297:
298: Subround(I, e2, a2, b2, c2, d2, X[ 6], 9, k6);
299: Subround(I, d2, e2, a2, b2, c2, X[11], 13, k6);
300: Subround(I, c2, d2, e2, a2, b2, X[ 3], 15, k6);
301: Subround(I, b2, c2, d2, e2, a2, X[ 7], 7, k6);
302: Subround(I, a2, b2, c2, d2, e2, X[ 0], 12, k6);
303: Subround(I, e2, a2, b2, c2, d2, X[13], 8, k6);
304: Subround(I, d2, e2, a2, b2, c2, X[ 5], 9, k6);
305: Subround(I, c2, d2, e2, a2, b2, X[10], 11, k6);
306: Subround(I, b2, c2, d2, e2, a2, X[14], 7, k6);
307: Subround(I, a2, b2, c2, d2, e2, X[15], 7, k6);
308: Subround(I, e2, a2, b2, c2, d2, X[ 8], 12, k6);
309: Subround(I, d2, e2, a2, b2, c2, X[12], 7, k6);
310: Subround(I, c2, d2, e2, a2, b2, X[ 4], 6, k6);
311: Subround(I, b2, c2, d2, e2, a2, X[ 9], 15, k6);
312: Subround(I, a2, b2, c2, d2, e2, X[ 1], 13, k6);
313: Subround(I, e2, a2, b2, c2, d2, X[ 2], 11, k6);
314:
315: Subround(H, d2, e2, a2, b2, c2, X[15], 9, k7);
316: Subround(H, c2, d2, e2, a2, b2, X[ 5], 7, k7);
317: Subround(H, b2, c2, d2, e2, a2, X[ 1], 15, k7);
318: Subround(H, a2, b2, c2, d2, e2, X[ 3], 11, k7);
319: Subround(H, e2, a2, b2, c2, d2, X[ 7], 8, k7);
320: Subround(H, d2, e2, a2, b2, c2, X[14], 6, k7);
321: Subround(H, c2, d2, e2, a2, b2, X[ 6], 6, k7);
322: Subround(H, b2, c2, d2, e2, a2, X[ 9], 14, k7);
323: Subround(H, a2, b2, c2, d2, e2, X[11], 12, k7);
324: Subround(H, e2, a2, b2, c2, d2, X[ 8], 13, k7);
325: Subround(H, d2, e2, a2, b2, c2, X[12], 5, k7);
326: Subround(H, c2, d2, e2, a2, b2, X[ 2], 14, k7);
327: Subround(H, b2, c2, d2, e2, a2, X[10], 13, k7);
328: Subround(H, a2, b2, c2, d2, e2, X[ 0], 13, k7);
329: Subround(H, e2, a2, b2, c2, d2, X[ 4], 7, k7);
330: Subround(H, d2, e2, a2, b2, c2, X[13], 5, k7);
331:
332: Subround(G, c2, d2, e2, a2, b2, X[ 8], 15, k8);
333: Subround(G, b2, c2, d2, e2, a2, X[ 6], 5, k8);
334: Subround(G, a2, b2, c2, d2, e2, X[ 4], 8, k8);
335: Subround(G, e2, a2, b2, c2, d2, X[ 1], 11, k8);
336: Subround(G, d2, e2, a2, b2, c2, X[ 3], 14, k8);
337: Subround(G, c2, d2, e2, a2, b2, X[11], 14, k8);
338: Subround(G, b2, c2, d2, e2, a2, X[15], 6, k8);
339: Subround(G, a2, b2, c2, d2, e2, X[ 0], 14, k8);
340: Subround(G, e2, a2, b2, c2, d2, X[ 5], 6, k8);
341: Subround(G, d2, e2, a2, b2, c2, X[12], 9, k8);
342: Subround(G, c2, d2, e2, a2, b2, X[ 2], 12, k8);
343: Subround(G, b2, c2, d2, e2, a2, X[13], 9, k8);
344: Subround(G, a2, b2, c2, d2, e2, X[ 9], 12, k8);
345: Subround(G, e2, a2, b2, c2, d2, X[ 7], 5, k8);
346: Subround(G, d2, e2, a2, b2, c2, X[10], 15, k8);
347: Subround(G, c2, d2, e2, a2, b2, X[14], 8, k8);
348:
349: Subround(F, b2, c2, d2, e2, a2, X[12], 8, k9);
350: Subround(F, a2, b2, c2, d2, e2, X[15], 5, k9);
351: Subround(F, e2, a2, b2, c2, d2, X[10], 12, k9);
352: Subround(F, d2, e2, a2, b2, c2, X[ 4], 9, k9);
353: Subround(F, c2, d2, e2, a2, b2, X[ 1], 12, k9);
354: Subround(F, b2, c2, d2, e2, a2, X[ 5], 5, k9);
355: Subround(F, a2, b2, c2, d2, e2, X[ 8], 14, k9);
356: Subround(F, e2, a2, b2, c2, d2, X[ 7], 6, k9);
357: Subround(F, d2, e2, a2, b2, c2, X[ 6], 8, k9);
358: Subround(F, c2, d2, e2, a2, b2, X[ 2], 13, k9);
359: Subround(F, b2, c2, d2, e2, a2, X[13], 6, k9);
360: Subround(F, a2, b2, c2, d2, e2, X[14], 5, k9);
361: Subround(F, e2, a2, b2, c2, d2, X[ 0], 15, k9);
362: Subround(F, d2, e2, a2, b2, c2, X[ 3], 13, k9);
363: Subround(F, c2, d2, e2, a2, b2, X[ 9], 11, k9);
364: Subround(F, b2, c2, d2, e2, a2, X[11], 11, k9);
365:
366: c1 = digest[1] + c1 + d2;
367: digest[1] = digest[2] + d1 + e2;
368: digest[2] = digest[3] + e1 + a2;
369: digest[3] = digest[4] + a1 + b2;
370: digest[4] = digest[0] + b1 + c2;
371: digest[0] = c1;
1.1 root 372: }
1.1.1.3 root 373:
374: #else // TC_MINIMIZE_CODE_SIZE
375:
376: /*
377: Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
378:
1.1.1.7 ! root 379: Governed by the TrueCrypt License 2.7 the full text of which is contained
1.1.1.3 root 380: in the file License.txt included in TrueCrypt binary and source code
381: distribution packages.
382: */
383:
1.1.1.4 root 384: #pragma optimize ("tl", on)
385:
1.1.1.3 root 386: typedef unsigned __int32 uint32;
387: typedef unsigned __int8 byte;
388:
1.1.1.6 root 389: #include <stdlib.h>
390: #pragma intrinsic (_lrotl)
391:
1.1.1.3 root 392: static const byte OrderTab[] = {
393: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
394: 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
395: 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
396: 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
397: 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13,
398: 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
399: 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
400: 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
401: 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
402: 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
403: };
404:
405: static const byte RolTab[] = {
406: 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
407: 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
408: 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
409: 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
410: 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6,
411: 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
412: 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
413: 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
414: 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
415: 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
416: };
417:
418: static const uint32 KTab[] = {
419: 0x00000000UL,
420: 0x5A827999UL,
421: 0x6ED9EBA1UL,
422: 0x8F1BBCDCUL,
423: 0xA953FD4EUL,
424: 0x50A28BE6UL,
425: 0x5C4DD124UL,
426: 0x6D703EF3UL,
427: 0x7A6D76E9UL,
428: 0x00000000UL
429: };
430:
431:
1.1.1.6 root 432: void RMD160Transform (unsigned __int32 *state, const unsigned __int32 *data)
1.1.1.3 root 433: {
434: uint32 a, b, c, d, e;
435: uint32 a2, b2, c2, d2, e2;
436: byte pos;
437: uint32 tmp;
438:
439: a = state[0];
440: b = state[1];
441: c = state[2];
442: d = state[3];
443: e = state[4];
444:
445: for (pos = 0; pos < 160; ++pos)
446: {
447: tmp = a + data[OrderTab[pos]] + KTab[pos >> 4];
448:
449: switch (pos >> 4)
450: {
1.1.1.6 root 451: case 0: case 9: tmp += F (b, c, d); break;
452: case 1: case 8: tmp += G (b, c, d); break;
453: case 2: case 7: tmp += H (b, c, d); break;
454: case 3: case 6: tmp += I (b, c, d); break;
455: case 4: case 5: tmp += J (b, c, d); break;
1.1.1.3 root 456: }
457:
1.1.1.6 root 458: tmp = _lrotl (tmp, RolTab[pos]) + e;
1.1.1.3 root 459: a = e;
460: e = d;
1.1.1.6 root 461: d = _lrotl (c, 10);
1.1.1.3 root 462: c = b;
463: b = tmp;
464:
465: if (pos == 79)
466: {
467: a2 = a;
468: b2 = b;
469: c2 = c;
470: d2 = d;
471: e2 = e;
472:
473: a = state[0];
474: b = state[1];
475: c = state[2];
476: d = state[3];
477: e = state[4];
478: }
479: }
480:
481: tmp = state[1] + c2 + d;
482: state[1] = state[2] + d2 + e;
483: state[2] = state[3] + e2 + a;
484: state[3] = state[4] + a2 + b;
485: state[4] = state[0] + b2 + c;
486: state[0] = tmp;
487: }
488:
489: #endif // TC_MINIMIZE_CODE_SIZE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.