Raven Core  3.0.0
P2P Digital Currency
ripemd160.cpp
Go to the documentation of this file.
1 // Copyright (c) 2014 The Bitcoin Core developers
2 // Copyright (c) 2017-2019 The Raven Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 
6 #include "crypto/ripemd160.h"
7 
8 #include "crypto/common.h"
9 
10 #include <string.h>
11 
12 // Internal implementation code.
13 namespace
14 {
16 namespace ripemd160
17 {
18 uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
19 uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); }
20 uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; }
21 uint32_t inline f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~z); }
22 uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); }
23 
25 void inline Initialize(uint32_t* s)
26 {
27  s[0] = 0x67452301ul;
28  s[1] = 0xEFCDAB89ul;
29  s[2] = 0x98BADCFEul;
30  s[3] = 0x10325476ul;
31  s[4] = 0xC3D2E1F0ul;
32 }
33 
34 uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); }
35 
36 void inline Round(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t f, uint32_t x, uint32_t k, int r)
37 {
38  a = rol(a + f + x + k, r) + e;
39  c = rol(c, 10);
40 }
41 
42 void inline R11(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }
43 void inline R21(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, c, d), x, 0x5A827999ul, r); }
44 void inline R31(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, c, d), x, 0x6ED9EBA1ul, r); }
45 void inline R41(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, c, d), x, 0x8F1BBCDCul, r); }
46 void inline R51(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, c, d), x, 0xA953FD4Eul, r); }
47 
48 void inline R12(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f5(b, c, d), x, 0x50A28BE6ul, r); }
49 void inline R22(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f4(b, c, d), x, 0x5C4DD124ul, r); }
50 void inline R32(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f3(b, c, d), x, 0x6D703EF3ul, r); }
51 void inline R42(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f2(b, c, d), x, 0x7A6D76E9ul, r); }
52 void inline R52(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }
53 
55 void Transform(uint32_t* s, const unsigned char* chunk)
56 {
57  uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
58  uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
59  uint32_t w0 = ReadLE32(chunk + 0), w1 = ReadLE32(chunk + 4), w2 = ReadLE32(chunk + 8), w3 = ReadLE32(chunk + 12);
60  uint32_t w4 = ReadLE32(chunk + 16), w5 = ReadLE32(chunk + 20), w6 = ReadLE32(chunk + 24), w7 = ReadLE32(chunk + 28);
61  uint32_t w8 = ReadLE32(chunk + 32), w9 = ReadLE32(chunk + 36), w10 = ReadLE32(chunk + 40), w11 = ReadLE32(chunk + 44);
62  uint32_t w12 = ReadLE32(chunk + 48), w13 = ReadLE32(chunk + 52), w14 = ReadLE32(chunk + 56), w15 = ReadLE32(chunk + 60);
63 
64  R11(a1, b1, c1, d1, e1, w0, 11);
65  R12(a2, b2, c2, d2, e2, w5, 8);
66  R11(e1, a1, b1, c1, d1, w1, 14);
67  R12(e2, a2, b2, c2, d2, w14, 9);
68  R11(d1, e1, a1, b1, c1, w2, 15);
69  R12(d2, e2, a2, b2, c2, w7, 9);
70  R11(c1, d1, e1, a1, b1, w3, 12);
71  R12(c2, d2, e2, a2, b2, w0, 11);
72  R11(b1, c1, d1, e1, a1, w4, 5);
73  R12(b2, c2, d2, e2, a2, w9, 13);
74  R11(a1, b1, c1, d1, e1, w5, 8);
75  R12(a2, b2, c2, d2, e2, w2, 15);
76  R11(e1, a1, b1, c1, d1, w6, 7);
77  R12(e2, a2, b2, c2, d2, w11, 15);
78  R11(d1, e1, a1, b1, c1, w7, 9);
79  R12(d2, e2, a2, b2, c2, w4, 5);
80  R11(c1, d1, e1, a1, b1, w8, 11);
81  R12(c2, d2, e2, a2, b2, w13, 7);
82  R11(b1, c1, d1, e1, a1, w9, 13);
83  R12(b2, c2, d2, e2, a2, w6, 7);
84  R11(a1, b1, c1, d1, e1, w10, 14);
85  R12(a2, b2, c2, d2, e2, w15, 8);
86  R11(e1, a1, b1, c1, d1, w11, 15);
87  R12(e2, a2, b2, c2, d2, w8, 11);
88  R11(d1, e1, a1, b1, c1, w12, 6);
89  R12(d2, e2, a2, b2, c2, w1, 14);
90  R11(c1, d1, e1, a1, b1, w13, 7);
91  R12(c2, d2, e2, a2, b2, w10, 14);
92  R11(b1, c1, d1, e1, a1, w14, 9);
93  R12(b2, c2, d2, e2, a2, w3, 12);
94  R11(a1, b1, c1, d1, e1, w15, 8);
95  R12(a2, b2, c2, d2, e2, w12, 6);
96 
97  R21(e1, a1, b1, c1, d1, w7, 7);
98  R22(e2, a2, b2, c2, d2, w6, 9);
99  R21(d1, e1, a1, b1, c1, w4, 6);
100  R22(d2, e2, a2, b2, c2, w11, 13);
101  R21(c1, d1, e1, a1, b1, w13, 8);
102  R22(c2, d2, e2, a2, b2, w3, 15);
103  R21(b1, c1, d1, e1, a1, w1, 13);
104  R22(b2, c2, d2, e2, a2, w7, 7);
105  R21(a1, b1, c1, d1, e1, w10, 11);
106  R22(a2, b2, c2, d2, e2, w0, 12);
107  R21(e1, a1, b1, c1, d1, w6, 9);
108  R22(e2, a2, b2, c2, d2, w13, 8);
109  R21(d1, e1, a1, b1, c1, w15, 7);
110  R22(d2, e2, a2, b2, c2, w5, 9);
111  R21(c1, d1, e1, a1, b1, w3, 15);
112  R22(c2, d2, e2, a2, b2, w10, 11);
113  R21(b1, c1, d1, e1, a1, w12, 7);
114  R22(b2, c2, d2, e2, a2, w14, 7);
115  R21(a1, b1, c1, d1, e1, w0, 12);
116  R22(a2, b2, c2, d2, e2, w15, 7);
117  R21(e1, a1, b1, c1, d1, w9, 15);
118  R22(e2, a2, b2, c2, d2, w8, 12);
119  R21(d1, e1, a1, b1, c1, w5, 9);
120  R22(d2, e2, a2, b2, c2, w12, 7);
121  R21(c1, d1, e1, a1, b1, w2, 11);
122  R22(c2, d2, e2, a2, b2, w4, 6);
123  R21(b1, c1, d1, e1, a1, w14, 7);
124  R22(b2, c2, d2, e2, a2, w9, 15);
125  R21(a1, b1, c1, d1, e1, w11, 13);
126  R22(a2, b2, c2, d2, e2, w1, 13);
127  R21(e1, a1, b1, c1, d1, w8, 12);
128  R22(e2, a2, b2, c2, d2, w2, 11);
129 
130  R31(d1, e1, a1, b1, c1, w3, 11);
131  R32(d2, e2, a2, b2, c2, w15, 9);
132  R31(c1, d1, e1, a1, b1, w10, 13);
133  R32(c2, d2, e2, a2, b2, w5, 7);
134  R31(b1, c1, d1, e1, a1, w14, 6);
135  R32(b2, c2, d2, e2, a2, w1, 15);
136  R31(a1, b1, c1, d1, e1, w4, 7);
137  R32(a2, b2, c2, d2, e2, w3, 11);
138  R31(e1, a1, b1, c1, d1, w9, 14);
139  R32(e2, a2, b2, c2, d2, w7, 8);
140  R31(d1, e1, a1, b1, c1, w15, 9);
141  R32(d2, e2, a2, b2, c2, w14, 6);
142  R31(c1, d1, e1, a1, b1, w8, 13);
143  R32(c2, d2, e2, a2, b2, w6, 6);
144  R31(b1, c1, d1, e1, a1, w1, 15);
145  R32(b2, c2, d2, e2, a2, w9, 14);
146  R31(a1, b1, c1, d1, e1, w2, 14);
147  R32(a2, b2, c2, d2, e2, w11, 12);
148  R31(e1, a1, b1, c1, d1, w7, 8);
149  R32(e2, a2, b2, c2, d2, w8, 13);
150  R31(d1, e1, a1, b1, c1, w0, 13);
151  R32(d2, e2, a2, b2, c2, w12, 5);
152  R31(c1, d1, e1, a1, b1, w6, 6);
153  R32(c2, d2, e2, a2, b2, w2, 14);
154  R31(b1, c1, d1, e1, a1, w13, 5);
155  R32(b2, c2, d2, e2, a2, w10, 13);
156  R31(a1, b1, c1, d1, e1, w11, 12);
157  R32(a2, b2, c2, d2, e2, w0, 13);
158  R31(e1, a1, b1, c1, d1, w5, 7);
159  R32(e2, a2, b2, c2, d2, w4, 7);
160  R31(d1, e1, a1, b1, c1, w12, 5);
161  R32(d2, e2, a2, b2, c2, w13, 5);
162 
163  R41(c1, d1, e1, a1, b1, w1, 11);
164  R42(c2, d2, e2, a2, b2, w8, 15);
165  R41(b1, c1, d1, e1, a1, w9, 12);
166  R42(b2, c2, d2, e2, a2, w6, 5);
167  R41(a1, b1, c1, d1, e1, w11, 14);
168  R42(a2, b2, c2, d2, e2, w4, 8);
169  R41(e1, a1, b1, c1, d1, w10, 15);
170  R42(e2, a2, b2, c2, d2, w1, 11);
171  R41(d1, e1, a1, b1, c1, w0, 14);
172  R42(d2, e2, a2, b2, c2, w3, 14);
173  R41(c1, d1, e1, a1, b1, w8, 15);
174  R42(c2, d2, e2, a2, b2, w11, 14);
175  R41(b1, c1, d1, e1, a1, w12, 9);
176  R42(b2, c2, d2, e2, a2, w15, 6);
177  R41(a1, b1, c1, d1, e1, w4, 8);
178  R42(a2, b2, c2, d2, e2, w0, 14);
179  R41(e1, a1, b1, c1, d1, w13, 9);
180  R42(e2, a2, b2, c2, d2, w5, 6);
181  R41(d1, e1, a1, b1, c1, w3, 14);
182  R42(d2, e2, a2, b2, c2, w12, 9);
183  R41(c1, d1, e1, a1, b1, w7, 5);
184  R42(c2, d2, e2, a2, b2, w2, 12);
185  R41(b1, c1, d1, e1, a1, w15, 6);
186  R42(b2, c2, d2, e2, a2, w13, 9);
187  R41(a1, b1, c1, d1, e1, w14, 8);
188  R42(a2, b2, c2, d2, e2, w9, 12);
189  R41(e1, a1, b1, c1, d1, w5, 6);
190  R42(e2, a2, b2, c2, d2, w7, 5);
191  R41(d1, e1, a1, b1, c1, w6, 5);
192  R42(d2, e2, a2, b2, c2, w10, 15);
193  R41(c1, d1, e1, a1, b1, w2, 12);
194  R42(c2, d2, e2, a2, b2, w14, 8);
195 
196  R51(b1, c1, d1, e1, a1, w4, 9);
197  R52(b2, c2, d2, e2, a2, w12, 8);
198  R51(a1, b1, c1, d1, e1, w0, 15);
199  R52(a2, b2, c2, d2, e2, w15, 5);
200  R51(e1, a1, b1, c1, d1, w5, 5);
201  R52(e2, a2, b2, c2, d2, w10, 12);
202  R51(d1, e1, a1, b1, c1, w9, 11);
203  R52(d2, e2, a2, b2, c2, w4, 9);
204  R51(c1, d1, e1, a1, b1, w7, 6);
205  R52(c2, d2, e2, a2, b2, w1, 12);
206  R51(b1, c1, d1, e1, a1, w12, 8);
207  R52(b2, c2, d2, e2, a2, w5, 5);
208  R51(a1, b1, c1, d1, e1, w2, 13);
209  R52(a2, b2, c2, d2, e2, w8, 14);
210  R51(e1, a1, b1, c1, d1, w10, 12);
211  R52(e2, a2, b2, c2, d2, w7, 6);
212  R51(d1, e1, a1, b1, c1, w14, 5);
213  R52(d2, e2, a2, b2, c2, w6, 8);
214  R51(c1, d1, e1, a1, b1, w1, 12);
215  R52(c2, d2, e2, a2, b2, w2, 13);
216  R51(b1, c1, d1, e1, a1, w3, 13);
217  R52(b2, c2, d2, e2, a2, w13, 6);
218  R51(a1, b1, c1, d1, e1, w8, 14);
219  R52(a2, b2, c2, d2, e2, w14, 5);
220  R51(e1, a1, b1, c1, d1, w11, 11);
221  R52(e2, a2, b2, c2, d2, w0, 15);
222  R51(d1, e1, a1, b1, c1, w6, 8);
223  R52(d2, e2, a2, b2, c2, w3, 13);
224  R51(c1, d1, e1, a1, b1, w15, 5);
225  R52(c2, d2, e2, a2, b2, w9, 11);
226  R51(b1, c1, d1, e1, a1, w13, 6);
227  R52(b2, c2, d2, e2, a2, w11, 11);
228 
229  uint32_t t = s[0];
230  s[0] = s[1] + c1 + d2;
231  s[1] = s[2] + d1 + e2;
232  s[2] = s[3] + e1 + a2;
233  s[3] = s[4] + a1 + b2;
234  s[4] = t + b1 + c2;
235 }
236 
237 } // namespace ripemd160
238 
239 } // namespace
240 
242 
243 CRIPEMD160::CRIPEMD160() : bytes(0)
244 {
245  ripemd160::Initialize(s);
246 }
247 
248 CRIPEMD160& CRIPEMD160::Write(const unsigned char* data, size_t len)
249 {
250  const unsigned char* end = data + len;
251  size_t bufsize = bytes % 64;
252  if (bufsize && bufsize + len >= 64) {
253  // Fill the buffer, and process it.
254  memcpy(buf + bufsize, data, 64 - bufsize);
255  bytes += 64 - bufsize;
256  data += 64 - bufsize;
257  ripemd160::Transform(s, buf);
258  bufsize = 0;
259  }
260  while (end >= data + 64) {
261  // Process full chunks directly from the source.
262  ripemd160::Transform(s, data);
263  bytes += 64;
264  data += 64;
265  }
266  if (end > data) {
267  // Fill the buffer with what remains.
268  memcpy(buf + bufsize, data, end - data);
269  bytes += end - data;
270  }
271  return *this;
272 }
273 
274 void CRIPEMD160::Finalize(unsigned char hash[OUTPUT_SIZE])
275 {
276  static const unsigned char pad[64] = {0x80};
277  unsigned char sizedesc[8];
278  WriteLE64(sizedesc, bytes << 3);
279  Write(pad, 1 + ((119 - (bytes % 64)) % 64));
280  Write(sizedesc, 8);
281  WriteLE32(hash, s[0]);
282  WriteLE32(hash + 4, s[1]);
283  WriteLE32(hash + 8, s[2]);
284  WriteLE32(hash + 12, s[3]);
285  WriteLE32(hash + 16, s[4]);
286 }
287 
288 CRIPEMD160& CRIPEMD160::Reset()
289 {
290  bytes = 0;
291  ripemd160::Initialize(s);
292  return *this;
293 }
Round
#define Round(a, b, c, d, e, f, g, h, k, w)
Definition: hash_impl.h:23
CRIPEMD160::bytes
uint64_t bytes
Definition: ripemd160.h:18
CRIPEMD160::buf
unsigned char buf[64]
Definition: ripemd160.h:17
CRIPEMD160::OUTPUT_SIZE
static const size_t OUTPUT_SIZE
Definition: ripemd160.h:21
CRIPEMD160::Reset
CRIPEMD160 & Reset()
Definition: ripemd160.cpp:288
CRIPEMD160::s
uint32_t s[5]
Definition: ripemd160.h:16
CRIPEMD160::Write
CRIPEMD160 & Write(const unsigned char *data, size_t len)
Definition: ripemd160.cpp:248
memcpy
void * memcpy(void *a, const void *b, size_t c)
Definition: glibc_compat.cpp:19
CRIPEMD160::Finalize
void Finalize(unsigned char hash[OUTPUT_SIZE])
Definition: ripemd160.cpp:274
CRIPEMD160
A hasher class for RIPEMD-160.
Definition: ripemd160.h:13
ripemd160
Internal RIPEMD-160 implementation.
Definition: ripemd160.cpp:16
Generated on Mon Jul 29 2019 02:32:17 for Raven Core by   doxygen 1.8.13