Botan  1.10.9
has160.cpp
Go to the documentation of this file.
1 /*
2 * HAS-160
3 * (C) 1999-2007 Jack Lloyd
4 *
5 * Distributed under the terms of the Botan license
6 */
7 
8 #include <botan/has160.h>
9 #include <botan/loadstor.h>
10 #include <botan/rotate.h>
11 
12 namespace Botan {
13 
14 namespace HAS_160_F {
15 
16 /*
17 * HAS-160 F1 Function
18 */
19 inline void F1(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
20  u32bit msg, u32bit rot)
21  {
22  E += rotate_left(A, rot) + (D ^ (B & (C ^ D))) + msg;
23  B = rotate_left(B, 10);
24  }
25 
26 /*
27 * HAS-160 F2 Function
28 */
29 inline void F2(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
30  u32bit msg, u32bit rot)
31  {
32  E += rotate_left(A, rot) + (B ^ C ^ D) + msg + 0x5A827999;
33  B = rotate_left(B, 17);
34  }
35 
36 /*
37 * HAS-160 F3 Function
38 */
39 inline void F3(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
40  u32bit msg, u32bit rot)
41  {
42  E += rotate_left(A, rot) + (C ^ (B | ~D)) + msg + 0x6ED9EBA1;
43  B = rotate_left(B, 25);
44  }
45 
46 /*
47 * HAS-160 F4 Function
48 */
49 inline void F4(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
50  u32bit msg, u32bit rot)
51  {
52  E += rotate_left(A, rot) + (B ^ C ^ D) + msg + 0x8F1BBCDC;
53  B = rotate_left(B, 30);
54  }
55 
56 }
57 
58 /*
59 * HAS-160 Compression Function
60 */
61 void HAS_160::compress_n(const byte input[], size_t blocks)
62  {
63  using namespace HAS_160_F;
64 
65  u32bit A = digest[0], B = digest[1], C = digest[2],
66  D = digest[3], E = digest[4];
67 
68  for(size_t i = 0; i != blocks; ++i)
69  {
70  load_le(&X[0], input, 16);
71 
72  X[16] = X[ 0] ^ X[ 1] ^ X[ 2] ^ X[ 3];
73  X[17] = X[ 4] ^ X[ 5] ^ X[ 6] ^ X[ 7];
74  X[18] = X[ 8] ^ X[ 9] ^ X[10] ^ X[11];
75  X[19] = X[12] ^ X[13] ^ X[14] ^ X[15];
76  F1(A,B,C,D,E,X[18], 5); F1(E,A,B,C,D,X[ 0],11);
77  F1(D,E,A,B,C,X[ 1], 7); F1(C,D,E,A,B,X[ 2],15);
78  F1(B,C,D,E,A,X[ 3], 6); F1(A,B,C,D,E,X[19],13);
79  F1(E,A,B,C,D,X[ 4], 8); F1(D,E,A,B,C,X[ 5],14);
80  F1(C,D,E,A,B,X[ 6], 7); F1(B,C,D,E,A,X[ 7],12);
81  F1(A,B,C,D,E,X[16], 9); F1(E,A,B,C,D,X[ 8],11);
82  F1(D,E,A,B,C,X[ 9], 8); F1(C,D,E,A,B,X[10],15);
83  F1(B,C,D,E,A,X[11], 6); F1(A,B,C,D,E,X[17],12);
84  F1(E,A,B,C,D,X[12], 9); F1(D,E,A,B,C,X[13],14);
85  F1(C,D,E,A,B,X[14], 5); F1(B,C,D,E,A,X[15],13);
86 
87  X[16] = X[ 3] ^ X[ 6] ^ X[ 9] ^ X[12];
88  X[17] = X[ 2] ^ X[ 5] ^ X[ 8] ^ X[15];
89  X[18] = X[ 1] ^ X[ 4] ^ X[11] ^ X[14];
90  X[19] = X[ 0] ^ X[ 7] ^ X[10] ^ X[13];
91  F2(A,B,C,D,E,X[18], 5); F2(E,A,B,C,D,X[ 3],11);
92  F2(D,E,A,B,C,X[ 6], 7); F2(C,D,E,A,B,X[ 9],15);
93  F2(B,C,D,E,A,X[12], 6); F2(A,B,C,D,E,X[19],13);
94  F2(E,A,B,C,D,X[15], 8); F2(D,E,A,B,C,X[ 2],14);
95  F2(C,D,E,A,B,X[ 5], 7); F2(B,C,D,E,A,X[ 8],12);
96  F2(A,B,C,D,E,X[16], 9); F2(E,A,B,C,D,X[11],11);
97  F2(D,E,A,B,C,X[14], 8); F2(C,D,E,A,B,X[ 1],15);
98  F2(B,C,D,E,A,X[ 4], 6); F2(A,B,C,D,E,X[17],12);
99  F2(E,A,B,C,D,X[ 7], 9); F2(D,E,A,B,C,X[10],14);
100  F2(C,D,E,A,B,X[13], 5); F2(B,C,D,E,A,X[ 0],13);
101 
102  X[16] = X[ 5] ^ X[ 7] ^ X[12] ^ X[14];
103  X[17] = X[ 0] ^ X[ 2] ^ X[ 9] ^ X[11];
104  X[18] = X[ 4] ^ X[ 6] ^ X[13] ^ X[15];
105  X[19] = X[ 1] ^ X[ 3] ^ X[ 8] ^ X[10];
106  F3(A,B,C,D,E,X[18], 5); F3(E,A,B,C,D,X[12],11);
107  F3(D,E,A,B,C,X[ 5], 7); F3(C,D,E,A,B,X[14],15);
108  F3(B,C,D,E,A,X[ 7], 6); F3(A,B,C,D,E,X[19],13);
109  F3(E,A,B,C,D,X[ 0], 8); F3(D,E,A,B,C,X[ 9],14);
110  F3(C,D,E,A,B,X[ 2], 7); F3(B,C,D,E,A,X[11],12);
111  F3(A,B,C,D,E,X[16], 9); F3(E,A,B,C,D,X[ 4],11);
112  F3(D,E,A,B,C,X[13], 8); F3(C,D,E,A,B,X[ 6],15);
113  F3(B,C,D,E,A,X[15], 6); F3(A,B,C,D,E,X[17],12);
114  F3(E,A,B,C,D,X[ 8], 9); F3(D,E,A,B,C,X[ 1],14);
115  F3(C,D,E,A,B,X[10], 5); F3(B,C,D,E,A,X[ 3],13);
116 
117  X[16] = X[ 2] ^ X[ 7] ^ X[ 8] ^ X[13];
118  X[17] = X[ 3] ^ X[ 4] ^ X[ 9] ^ X[14];
119  X[18] = X[ 0] ^ X[ 5] ^ X[10] ^ X[15];
120  X[19] = X[ 1] ^ X[ 6] ^ X[11] ^ X[12];
121  F4(A,B,C,D,E,X[18], 5); F4(E,A,B,C,D,X[ 7],11);
122  F4(D,E,A,B,C,X[ 2], 7); F4(C,D,E,A,B,X[13],15);
123  F4(B,C,D,E,A,X[ 8], 6); F4(A,B,C,D,E,X[19],13);
124  F4(E,A,B,C,D,X[ 3], 8); F4(D,E,A,B,C,X[14],14);
125  F4(C,D,E,A,B,X[ 9], 7); F4(B,C,D,E,A,X[ 4],12);
126  F4(A,B,C,D,E,X[16], 9); F4(E,A,B,C,D,X[15],11);
127  F4(D,E,A,B,C,X[10], 8); F4(C,D,E,A,B,X[ 5],15);
128  F4(B,C,D,E,A,X[ 0], 6); F4(A,B,C,D,E,X[17],12);
129  F4(E,A,B,C,D,X[11], 9); F4(D,E,A,B,C,X[ 6],14);
130  F4(C,D,E,A,B,X[ 1], 5); F4(B,C,D,E,A,X[12],13);
131 
132  A = (digest[0] += A);
133  B = (digest[1] += B);
134  C = (digest[2] += C);
135  D = (digest[3] += D);
136  E = (digest[4] += E);
137 
138  input += hash_block_size();
139  }
140  }
141 
142 /*
143 * Copy out the digest
144 */
145 void HAS_160::copy_out(byte output[])
146  {
147  for(size_t i = 0; i != output_length(); i += 4)
148  store_le(digest[i/4], output + i);
149  }
150 
151 /*
152 * Clear memory of sensitive data
153 */
155  {
157  zeroise(X);
158  digest[0] = 0x67452301;
159  digest[1] = 0xEFCDAB89;
160  digest[2] = 0x98BADCFE;
161  digest[3] = 0x10325476;
162  digest[4] = 0xC3D2E1F0;
163  }
164 
165 }
T load_le(const byte in[], size_t off)
Definition: loadstor.h:116
size_t hash_block_size() const
Definition: mdx_hash.h:32
void store_le(u16bit in, byte out[2])
Definition: loadstor.h:427
T rotate_left(T input, size_t rot)
Definition: rotate.h:21
unsigned char byte
Definition: types.h:22
void clear()
Definition: has160.cpp:154
void F2(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
Definition: has160.cpp:29
void F3(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
Definition: has160.cpp:39
size_t output_length() const
Definition: has160.h:23
void F4(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
Definition: has160.cpp:49
void F1(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
Definition: has160.cpp:19
void zeroise(MemoryRegion< T > &vec)
Definition: secmem.h:415
unsigned int u32bit
Definition: types.h:32