Gav Wood
10 years ago
11 changed files with 1075 additions and 130 deletions
@ -0,0 +1,440 @@ |
|||||
|
/*
|
||||
|
This file is part of cpp-ethereum. |
||||
|
|
||||
|
cpp-ethereum is free software: you can redistribute it and/or modify |
||||
|
it under the terms of the GNU General Public License as published by |
||||
|
the Free Software Foundation, either version 3 of the License, or |
||||
|
(at your option) any later version. |
||||
|
|
||||
|
cpp-ethereum is distributed in the hope that it will be useful, |
||||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
|
GNU General Public License for more details. |
||||
|
|
||||
|
You should have received a copy of the GNU General Public License |
||||
|
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
*/ |
||||
|
/** @file Hash.cpp
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
*/ |
||||
|
|
||||
|
#include "Hash.h" |
||||
|
#include <cstdio> |
||||
|
#include <cstdlib> |
||||
|
#include <cstring> |
||||
|
#include "picosha2.h" |
||||
|
using namespace std; |
||||
|
using namespace dev; |
||||
|
|
||||
|
namespace dev |
||||
|
{ |
||||
|
|
||||
|
h256 sha256(bytesConstRef _input) |
||||
|
{ |
||||
|
h256 ret; |
||||
|
picosha2::hash256(_input.begin(), _input.end(), ret.data(), ret.data() + 32); |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
namespace rmd160 |
||||
|
{ |
||||
|
|
||||
|
/********************************************************************\
|
||||
|
* |
||||
|
* FILE: rmd160.h |
||||
|
* FILE: rmd160.c |
||||
|
* |
||||
|
* CONTENTS: Header file for a sample C-implementation of the |
||||
|
* RIPEMD-160 hash-function. |
||||
|
* TARGET: any computer with an ANSI C compiler |
||||
|
* |
||||
|
* AUTHOR: Antoon Bosselaers, ESAT-COSIC |
||||
|
* DATE: 1 March 1996 |
||||
|
* VERSION: 1.0 |
||||
|
* |
||||
|
* Copyright (c) Katholieke Universiteit Leuven |
||||
|
* 1996, All Rights Reserved |
||||
|
* |
||||
|
\********************************************************************/ |
||||
|
|
||||
|
// Adapted into "header-only" format by Gav Wood.
|
||||
|
|
||||
|
/* macro definitions */ |
||||
|
|
||||
|
#define RMDsize 160 |
||||
|
|
||||
|
/* collect four bytes into one word: */ |
||||
|
#define BYTES_TO_DWORD(strptr) \ |
||||
|
(((uint32_t) *((strptr)+3) << 24) | \ |
||||
|
((uint32_t) *((strptr)+2) << 16) | \ |
||||
|
((uint32_t) *((strptr)+1) << 8) | \ |
||||
|
((uint32_t) *(strptr))) |
||||
|
|
||||
|
/* ROL(x, n) cyclically rotates x over n bits to the left */ |
||||
|
/* x must be of an unsigned 32 bits type and 0 <= n < 32. */ |
||||
|
#define ROL(x, n) (((x) << (n)) | ((x) >> (32-(n)))) |
||||
|
|
||||
|
/* the five basic functions F(), G() and H() */ |
||||
|
#define F(x, y, z) ((x) ^ (y) ^ (z)) |
||||
|
#define G(x, y, z) (((x) & (y)) | (~(x) & (z))) |
||||
|
#define H(x, y, z) (((x) | ~(y)) ^ (z)) |
||||
|
#define I(x, y, z) (((x) & (z)) | ((y) & ~(z))) |
||||
|
#define J(x, y, z) ((x) ^ ((y) | ~(z))) |
||||
|
|
||||
|
/* the ten basic operations FF() through III() */ |
||||
|
#define FF(a, b, c, d, e, x, s) {\ |
||||
|
(a) += F((b), (c), (d)) + (x);\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define GG(a, b, c, d, e, x, s) {\ |
||||
|
(a) += G((b), (c), (d)) + (x) + 0x5a827999UL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define HH(a, b, c, d, e, x, s) {\ |
||||
|
(a) += H((b), (c), (d)) + (x) + 0x6ed9eba1UL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define II(a, b, c, d, e, x, s) {\ |
||||
|
(a) += I((b), (c), (d)) + (x) + 0x8f1bbcdcUL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define JJ(a, b, c, d, e, x, s) {\ |
||||
|
(a) += J((b), (c), (d)) + (x) + 0xa953fd4eUL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define FFF(a, b, c, d, e, x, s) {\ |
||||
|
(a) += F((b), (c), (d)) + (x);\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define GGG(a, b, c, d, e, x, s) {\ |
||||
|
(a) += G((b), (c), (d)) + (x) + 0x7a6d76e9UL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define HHH(a, b, c, d, e, x, s) {\ |
||||
|
(a) += H((b), (c), (d)) + (x) + 0x6d703ef3UL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define III(a, b, c, d, e, x, s) {\ |
||||
|
(a) += I((b), (c), (d)) + (x) + 0x5c4dd124UL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
#define JJJ(a, b, c, d, e, x, s) {\ |
||||
|
(a) += J((b), (c), (d)) + (x) + 0x50a28be6UL;\ |
||||
|
(a) = ROL((a), (s)) + (e);\ |
||||
|
(c) = ROL((c), 10);\ |
||||
|
} |
||||
|
|
||||
|
void MDinit(uint32_t *MDbuf) |
||||
|
{ |
||||
|
MDbuf[0] = 0x67452301UL; |
||||
|
MDbuf[1] = 0xefcdab89UL; |
||||
|
MDbuf[2] = 0x98badcfeUL; |
||||
|
MDbuf[3] = 0x10325476UL; |
||||
|
MDbuf[4] = 0xc3d2e1f0UL; |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
/********************************************************************/ |
||||
|
|
||||
|
void MDcompress(uint32_t *MDbuf, uint32_t *X) |
||||
|
{ |
||||
|
uint32_t aa = MDbuf[0], bb = MDbuf[1], cc = MDbuf[2], |
||||
|
dd = MDbuf[3], ee = MDbuf[4]; |
||||
|
uint32_t aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2], |
||||
|
ddd = MDbuf[3], eee = MDbuf[4]; |
||||
|
|
||||
|
/* round 1 */ |
||||
|
FF(aa, bb, cc, dd, ee, X[ 0], 11); |
||||
|
FF(ee, aa, bb, cc, dd, X[ 1], 14); |
||||
|
FF(dd, ee, aa, bb, cc, X[ 2], 15); |
||||
|
FF(cc, dd, ee, aa, bb, X[ 3], 12); |
||||
|
FF(bb, cc, dd, ee, aa, X[ 4], 5); |
||||
|
FF(aa, bb, cc, dd, ee, X[ 5], 8); |
||||
|
FF(ee, aa, bb, cc, dd, X[ 6], 7); |
||||
|
FF(dd, ee, aa, bb, cc, X[ 7], 9); |
||||
|
FF(cc, dd, ee, aa, bb, X[ 8], 11); |
||||
|
FF(bb, cc, dd, ee, aa, X[ 9], 13); |
||||
|
FF(aa, bb, cc, dd, ee, X[10], 14); |
||||
|
FF(ee, aa, bb, cc, dd, X[11], 15); |
||||
|
FF(dd, ee, aa, bb, cc, X[12], 6); |
||||
|
FF(cc, dd, ee, aa, bb, X[13], 7); |
||||
|
FF(bb, cc, dd, ee, aa, X[14], 9); |
||||
|
FF(aa, bb, cc, dd, ee, X[15], 8); |
||||
|
|
||||
|
/* round 2 */ |
||||
|
GG(ee, aa, bb, cc, dd, X[ 7], 7); |
||||
|
GG(dd, ee, aa, bb, cc, X[ 4], 6); |
||||
|
GG(cc, dd, ee, aa, bb, X[13], 8); |
||||
|
GG(bb, cc, dd, ee, aa, X[ 1], 13); |
||||
|
GG(aa, bb, cc, dd, ee, X[10], 11); |
||||
|
GG(ee, aa, bb, cc, dd, X[ 6], 9); |
||||
|
GG(dd, ee, aa, bb, cc, X[15], 7); |
||||
|
GG(cc, dd, ee, aa, bb, X[ 3], 15); |
||||
|
GG(bb, cc, dd, ee, aa, X[12], 7); |
||||
|
GG(aa, bb, cc, dd, ee, X[ 0], 12); |
||||
|
GG(ee, aa, bb, cc, dd, X[ 9], 15); |
||||
|
GG(dd, ee, aa, bb, cc, X[ 5], 9); |
||||
|
GG(cc, dd, ee, aa, bb, X[ 2], 11); |
||||
|
GG(bb, cc, dd, ee, aa, X[14], 7); |
||||
|
GG(aa, bb, cc, dd, ee, X[11], 13); |
||||
|
GG(ee, aa, bb, cc, dd, X[ 8], 12); |
||||
|
|
||||
|
/* round 3 */ |
||||
|
HH(dd, ee, aa, bb, cc, X[ 3], 11); |
||||
|
HH(cc, dd, ee, aa, bb, X[10], 13); |
||||
|
HH(bb, cc, dd, ee, aa, X[14], 6); |
||||
|
HH(aa, bb, cc, dd, ee, X[ 4], 7); |
||||
|
HH(ee, aa, bb, cc, dd, X[ 9], 14); |
||||
|
HH(dd, ee, aa, bb, cc, X[15], 9); |
||||
|
HH(cc, dd, ee, aa, bb, X[ 8], 13); |
||||
|
HH(bb, cc, dd, ee, aa, X[ 1], 15); |
||||
|
HH(aa, bb, cc, dd, ee, X[ 2], 14); |
||||
|
HH(ee, aa, bb, cc, dd, X[ 7], 8); |
||||
|
HH(dd, ee, aa, bb, cc, X[ 0], 13); |
||||
|
HH(cc, dd, ee, aa, bb, X[ 6], 6); |
||||
|
HH(bb, cc, dd, ee, aa, X[13], 5); |
||||
|
HH(aa, bb, cc, dd, ee, X[11], 12); |
||||
|
HH(ee, aa, bb, cc, dd, X[ 5], 7); |
||||
|
HH(dd, ee, aa, bb, cc, X[12], 5); |
||||
|
|
||||
|
/* round 4 */ |
||||
|
II(cc, dd, ee, aa, bb, X[ 1], 11); |
||||
|
II(bb, cc, dd, ee, aa, X[ 9], 12); |
||||
|
II(aa, bb, cc, dd, ee, X[11], 14); |
||||
|
II(ee, aa, bb, cc, dd, X[10], 15); |
||||
|
II(dd, ee, aa, bb, cc, X[ 0], 14); |
||||
|
II(cc, dd, ee, aa, bb, X[ 8], 15); |
||||
|
II(bb, cc, dd, ee, aa, X[12], 9); |
||||
|
II(aa, bb, cc, dd, ee, X[ 4], 8); |
||||
|
II(ee, aa, bb, cc, dd, X[13], 9); |
||||
|
II(dd, ee, aa, bb, cc, X[ 3], 14); |
||||
|
II(cc, dd, ee, aa, bb, X[ 7], 5); |
||||
|
II(bb, cc, dd, ee, aa, X[15], 6); |
||||
|
II(aa, bb, cc, dd, ee, X[14], 8); |
||||
|
II(ee, aa, bb, cc, dd, X[ 5], 6); |
||||
|
II(dd, ee, aa, bb, cc, X[ 6], 5); |
||||
|
II(cc, dd, ee, aa, bb, X[ 2], 12); |
||||
|
|
||||
|
/* round 5 */ |
||||
|
JJ(bb, cc, dd, ee, aa, X[ 4], 9); |
||||
|
JJ(aa, bb, cc, dd, ee, X[ 0], 15); |
||||
|
JJ(ee, aa, bb, cc, dd, X[ 5], 5); |
||||
|
JJ(dd, ee, aa, bb, cc, X[ 9], 11); |
||||
|
JJ(cc, dd, ee, aa, bb, X[ 7], 6); |
||||
|
JJ(bb, cc, dd, ee, aa, X[12], 8); |
||||
|
JJ(aa, bb, cc, dd, ee, X[ 2], 13); |
||||
|
JJ(ee, aa, bb, cc, dd, X[10], 12); |
||||
|
JJ(dd, ee, aa, bb, cc, X[14], 5); |
||||
|
JJ(cc, dd, ee, aa, bb, X[ 1], 12); |
||||
|
JJ(bb, cc, dd, ee, aa, X[ 3], 13); |
||||
|
JJ(aa, bb, cc, dd, ee, X[ 8], 14); |
||||
|
JJ(ee, aa, bb, cc, dd, X[11], 11); |
||||
|
JJ(dd, ee, aa, bb, cc, X[ 6], 8); |
||||
|
JJ(cc, dd, ee, aa, bb, X[15], 5); |
||||
|
JJ(bb, cc, dd, ee, aa, X[13], 6); |
||||
|
|
||||
|
/* parallel round 1 */ |
||||
|
JJJ(aaa, bbb, ccc, ddd, eee, X[ 5], 8); |
||||
|
JJJ(eee, aaa, bbb, ccc, ddd, X[14], 9); |
||||
|
JJJ(ddd, eee, aaa, bbb, ccc, X[ 7], 9); |
||||
|
JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11); |
||||
|
JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13); |
||||
|
JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15); |
||||
|
JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15); |
||||
|
JJJ(ddd, eee, aaa, bbb, ccc, X[ 4], 5); |
||||
|
JJJ(ccc, ddd, eee, aaa, bbb, X[13], 7); |
||||
|
JJJ(bbb, ccc, ddd, eee, aaa, X[ 6], 7); |
||||
|
JJJ(aaa, bbb, ccc, ddd, eee, X[15], 8); |
||||
|
JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11); |
||||
|
JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14); |
||||
|
JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14); |
||||
|
JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12); |
||||
|
JJJ(aaa, bbb, ccc, ddd, eee, X[12], 6); |
||||
|
|
||||
|
/* parallel round 2 */ |
||||
|
III(eee, aaa, bbb, ccc, ddd, X[ 6], 9); |
||||
|
III(ddd, eee, aaa, bbb, ccc, X[11], 13); |
||||
|
III(ccc, ddd, eee, aaa, bbb, X[ 3], 15); |
||||
|
III(bbb, ccc, ddd, eee, aaa, X[ 7], 7); |
||||
|
III(aaa, bbb, ccc, ddd, eee, X[ 0], 12); |
||||
|
III(eee, aaa, bbb, ccc, ddd, X[13], 8); |
||||
|
III(ddd, eee, aaa, bbb, ccc, X[ 5], 9); |
||||
|
III(ccc, ddd, eee, aaa, bbb, X[10], 11); |
||||
|
III(bbb, ccc, ddd, eee, aaa, X[14], 7); |
||||
|
III(aaa, bbb, ccc, ddd, eee, X[15], 7); |
||||
|
III(eee, aaa, bbb, ccc, ddd, X[ 8], 12); |
||||
|
III(ddd, eee, aaa, bbb, ccc, X[12], 7); |
||||
|
III(ccc, ddd, eee, aaa, bbb, X[ 4], 6); |
||||
|
III(bbb, ccc, ddd, eee, aaa, X[ 9], 15); |
||||
|
III(aaa, bbb, ccc, ddd, eee, X[ 1], 13); |
||||
|
III(eee, aaa, bbb, ccc, ddd, X[ 2], 11); |
||||
|
|
||||
|
/* parallel round 3 */ |
||||
|
HHH(ddd, eee, aaa, bbb, ccc, X[15], 9); |
||||
|
HHH(ccc, ddd, eee, aaa, bbb, X[ 5], 7); |
||||
|
HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15); |
||||
|
HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11); |
||||
|
HHH(eee, aaa, bbb, ccc, ddd, X[ 7], 8); |
||||
|
HHH(ddd, eee, aaa, bbb, ccc, X[14], 6); |
||||
|
HHH(ccc, ddd, eee, aaa, bbb, X[ 6], 6); |
||||
|
HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14); |
||||
|
HHH(aaa, bbb, ccc, ddd, eee, X[11], 12); |
||||
|
HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13); |
||||
|
HHH(ddd, eee, aaa, bbb, ccc, X[12], 5); |
||||
|
HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14); |
||||
|
HHH(bbb, ccc, ddd, eee, aaa, X[10], 13); |
||||
|
HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13); |
||||
|
HHH(eee, aaa, bbb, ccc, ddd, X[ 4], 7); |
||||
|
HHH(ddd, eee, aaa, bbb, ccc, X[13], 5); |
||||
|
|
||||
|
/* parallel round 4 */ |
||||
|
GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15); |
||||
|
GGG(bbb, ccc, ddd, eee, aaa, X[ 6], 5); |
||||
|
GGG(aaa, bbb, ccc, ddd, eee, X[ 4], 8); |
||||
|
GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11); |
||||
|
GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14); |
||||
|
GGG(ccc, ddd, eee, aaa, bbb, X[11], 14); |
||||
|
GGG(bbb, ccc, ddd, eee, aaa, X[15], 6); |
||||
|
GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14); |
||||
|
GGG(eee, aaa, bbb, ccc, ddd, X[ 5], 6); |
||||
|
GGG(ddd, eee, aaa, bbb, ccc, X[12], 9); |
||||
|
GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12); |
||||
|
GGG(bbb, ccc, ddd, eee, aaa, X[13], 9); |
||||
|
GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12); |
||||
|
GGG(eee, aaa, bbb, ccc, ddd, X[ 7], 5); |
||||
|
GGG(ddd, eee, aaa, bbb, ccc, X[10], 15); |
||||
|
GGG(ccc, ddd, eee, aaa, bbb, X[14], 8); |
||||
|
|
||||
|
/* parallel round 5 */ |
||||
|
FFF(bbb, ccc, ddd, eee, aaa, X[12] , 8); |
||||
|
FFF(aaa, bbb, ccc, ddd, eee, X[15] , 5); |
||||
|
FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12); |
||||
|
FFF(ddd, eee, aaa, bbb, ccc, X[ 4] , 9); |
||||
|
FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12); |
||||
|
FFF(bbb, ccc, ddd, eee, aaa, X[ 5] , 5); |
||||
|
FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14); |
||||
|
FFF(eee, aaa, bbb, ccc, ddd, X[ 7] , 6); |
||||
|
FFF(ddd, eee, aaa, bbb, ccc, X[ 6] , 8); |
||||
|
FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13); |
||||
|
FFF(bbb, ccc, ddd, eee, aaa, X[13] , 6); |
||||
|
FFF(aaa, bbb, ccc, ddd, eee, X[14] , 5); |
||||
|
FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15); |
||||
|
FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13); |
||||
|
FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11); |
||||
|
FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11); |
||||
|
|
||||
|
/* combine results */ |
||||
|
ddd += cc + MDbuf[1]; /* final result for MDbuf[0] */ |
||||
|
MDbuf[1] = MDbuf[2] + dd + eee; |
||||
|
MDbuf[2] = MDbuf[3] + ee + aaa; |
||||
|
MDbuf[3] = MDbuf[4] + aa + bbb; |
||||
|
MDbuf[4] = MDbuf[0] + bb + ccc; |
||||
|
MDbuf[0] = ddd; |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
void MDfinish(uint32_t *MDbuf, byte const *strptr, uint32_t lswlen, uint32_t mswlen) |
||||
|
{ |
||||
|
unsigned int i; /* counter */ |
||||
|
uint32_t X[16]; /* message words */ |
||||
|
|
||||
|
memset(X, 0, 16*sizeof(uint32_t)); |
||||
|
|
||||
|
/* put bytes from strptr into X */ |
||||
|
for (i=0; i<(lswlen&63); i++) { |
||||
|
/* byte i goes into word X[i div 4] at pos. 8*(i mod 4) */ |
||||
|
X[i>>2] ^= (uint32_t) *strptr++ << (8 * (i&3)); |
||||
|
} |
||||
|
|
||||
|
/* append the bit m_n == 1 */ |
||||
|
X[(lswlen>>2)&15] ^= (uint32_t)1 << (8*(lswlen&3) + 7); |
||||
|
|
||||
|
if ((lswlen & 63) > 55) { |
||||
|
/* length goes to next block */ |
||||
|
MDcompress(MDbuf, X); |
||||
|
memset(X, 0, 16*sizeof(uint32_t)); |
||||
|
} |
||||
|
|
||||
|
/* append length in bits*/ |
||||
|
X[14] = lswlen << 3; |
||||
|
X[15] = (lswlen >> 29) | (mswlen << 3); |
||||
|
MDcompress(MDbuf, X); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
#undef ROL |
||||
|
#undef F |
||||
|
#undef G |
||||
|
#undef H |
||||
|
#undef I |
||||
|
#undef J |
||||
|
#undef FF |
||||
|
#undef GG |
||||
|
#undef HH |
||||
|
#undef II |
||||
|
#undef JJ |
||||
|
#undef FFF |
||||
|
#undef GGG |
||||
|
#undef HHH |
||||
|
#undef III |
||||
|
#undef JJJ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/*
|
||||
|
* @returns RMD(_input) |
||||
|
*/ |
||||
|
h160 ripemd160(bytesConstRef _input) |
||||
|
{ |
||||
|
h160 hashcode; |
||||
|
uint32_t buffer[RMDsize / 32]; // contains (A, B, C, D(, E))
|
||||
|
uint32_t current[16]; // current 16-word chunk
|
||||
|
|
||||
|
// initialize
|
||||
|
rmd160::MDinit(buffer); |
||||
|
byte const* message = _input.data(); |
||||
|
uint32_t remaining = _input.size(); // # of bytes not yet processed
|
||||
|
|
||||
|
// process message in 16x 4-byte chunks
|
||||
|
for (; remaining >= 64; remaining -= 64) |
||||
|
{ |
||||
|
for (unsigned i = 0; i < 16; i++) |
||||
|
{ |
||||
|
current[i] = BYTES_TO_DWORD(message); |
||||
|
message += 4; |
||||
|
} |
||||
|
rmd160::MDcompress(buffer, current); |
||||
|
} |
||||
|
// length mod 64 bytes left
|
||||
|
|
||||
|
// finish:
|
||||
|
rmd160::MDfinish(buffer, message, _input.size(), 0); |
||||
|
|
||||
|
for (unsigned i = 0; i < RMDsize / 8; i += 4) |
||||
|
{ |
||||
|
hashcode[i] = buffer[i >> 2]; // implicit cast to byte
|
||||
|
hashcode[i + 1] = (buffer[i >> 2] >> 8); //extracts the 8 least
|
||||
|
hashcode[i + 2] = (buffer[i >> 2] >> 16); // significant bits.
|
||||
|
hashcode[i + 3] = (buffer[i >> 2] >> 24); |
||||
|
} |
||||
|
|
||||
|
return hashcode; |
||||
|
} |
||||
|
|
||||
|
#undef BYTES_TO_DWORD |
||||
|
#undef RMDsize |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,38 @@ |
|||||
|
/*
|
||||
|
This file is part of cpp-ethereum. |
||||
|
|
||||
|
cpp-ethereum is free software: you can redistribute it and/or modify |
||||
|
it under the terms of the GNU General Public License as published by |
||||
|
the Free Software Foundation, either version 3 of the License, or |
||||
|
(at your option) any later version. |
||||
|
|
||||
|
cpp-ethereum is distributed in the hope that it will be useful, |
||||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
|
GNU General Public License for more details. |
||||
|
|
||||
|
You should have received a copy of the GNU General Public License |
||||
|
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
*/ |
||||
|
/** @file Hash.h
|
||||
|
* @author Gav Wood <i@gavwood.com> |
||||
|
* @date 2014 |
||||
|
* |
||||
|
* The FixedHash fixed-size "hash" container type. |
||||
|
*/ |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include <string> |
||||
|
#include <libdevcore/FixedHash.h> |
||||
|
#include <libdevcore/vector_ref.h> |
||||
|
#include "SHA3.h" |
||||
|
|
||||
|
namespace dev |
||||
|
{ |
||||
|
|
||||
|
h256 sha256(bytesConstRef _input); |
||||
|
|
||||
|
h160 ripemd160(bytesConstRef _input); |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,360 @@ |
|||||
|
/*
|
||||
|
The MIT License (MIT) |
||||
|
|
||||
|
Copyright (C) 2014 okdshin |
||||
|
|
||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
|
of this software and associated documentation files (the "Software"), to deal |
||||
|
in the Software without restriction, including without limitation the rights |
||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
|
copies of the Software, and to permit persons to whom the Software is |
||||
|
furnished to do so, subject to the following conditions: |
||||
|
|
||||
|
The above copyright notice and this permission notice shall be included in |
||||
|
all copies or substantial portions of the Software. |
||||
|
|
||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
|
THE SOFTWARE. |
||||
|
*/ |
||||
|
#ifndef PICOSHA2_H |
||||
|
#define PICOSHA2_H |
||||
|
//picosha2:20140213
|
||||
|
#include <cstdint> |
||||
|
#include <iostream> |
||||
|
#include <vector> |
||||
|
#include <iterator> |
||||
|
#include <cassert> |
||||
|
#include <sstream> |
||||
|
#include <algorithm> |
||||
|
|
||||
|
namespace picosha2 |
||||
|
{ |
||||
|
|
||||
|
namespace detail |
||||
|
{ |
||||
|
|
||||
|
inline uint8_t mask_8bit(uint8_t x){ |
||||
|
return x&0xff; |
||||
|
} |
||||
|
|
||||
|
inline uint32_t mask_32bit(uint32_t x){ |
||||
|
return x&0xffffffff; |
||||
|
} |
||||
|
|
||||
|
static const uint32_t add_constant[64] = { |
||||
|
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, |
||||
|
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, |
||||
|
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, |
||||
|
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, |
||||
|
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, |
||||
|
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, |
||||
|
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, |
||||
|
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, |
||||
|
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, |
||||
|
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, |
||||
|
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, |
||||
|
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, |
||||
|
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, |
||||
|
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, |
||||
|
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, |
||||
|
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 |
||||
|
}; |
||||
|
|
||||
|
static const uint32_t initial_message_digest[8] = { |
||||
|
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, |
||||
|
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 |
||||
|
}; |
||||
|
|
||||
|
inline uint32_t ch(uint32_t x, uint32_t y, uint32_t z){ |
||||
|
return (x&y)^((~x)&z); |
||||
|
} |
||||
|
|
||||
|
inline uint32_t maj(uint32_t x, uint32_t y, uint32_t z){ |
||||
|
return (x&y)^(x&z)^(y&z); |
||||
|
} |
||||
|
|
||||
|
inline uint32_t rotr(uint32_t x, std::size_t n){ |
||||
|
assert(n < 32); |
||||
|
return mask_32bit((x>>n)|(x<<(32-n))); |
||||
|
} |
||||
|
|
||||
|
inline uint32_t bsig0(uint32_t x){ |
||||
|
return rotr(x, 2)^rotr(x, 13)^rotr(x, 22); |
||||
|
} |
||||
|
|
||||
|
inline uint32_t bsig1(uint32_t x){ |
||||
|
return rotr(x, 6)^rotr(x, 11)^rotr(x, 25); |
||||
|
} |
||||
|
|
||||
|
inline uint32_t shr(uint32_t x, std::size_t n){ |
||||
|
assert(n < 32); |
||||
|
return x >> n; |
||||
|
} |
||||
|
|
||||
|
inline uint32_t ssig0(uint32_t x){ |
||||
|
return rotr(x, 7)^rotr(x, 18)^shr(x, 3); |
||||
|
} |
||||
|
|
||||
|
inline uint32_t ssig1(uint32_t x){ |
||||
|
return rotr(x, 17)^rotr(x, 19)^shr(x, 10); |
||||
|
} |
||||
|
|
||||
|
template<typename RaIter1, typename RaIter2> |
||||
|
void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last){ |
||||
|
(void)last; // FIXME: check this is valid
|
||||
|
uint32_t w[64]; |
||||
|
std::fill(w, w+64, 0); |
||||
|
for(std::size_t i = 0; i < 16; ++i){ |
||||
|
w[i] = (static_cast<uint32_t>(mask_8bit(*(first+i*4)))<<24) |
||||
|
|(static_cast<uint32_t>(mask_8bit(*(first+i*4+1)))<<16) |
||||
|
|(static_cast<uint32_t>(mask_8bit(*(first+i*4+2)))<<8) |
||||
|
|(static_cast<uint32_t>(mask_8bit(*(first+i*4+3)))); |
||||
|
} |
||||
|
for(std::size_t i = 16; i < 64; ++i){ |
||||
|
w[i] = mask_32bit(ssig1(w[i-2])+w[i-7]+ssig0(w[i-15])+w[i-16]); |
||||
|
} |
||||
|
|
||||
|
uint32_t a = *message_digest; |
||||
|
uint32_t b = *(message_digest+1); |
||||
|
uint32_t c = *(message_digest+2); |
||||
|
uint32_t d = *(message_digest+3); |
||||
|
uint32_t e = *(message_digest+4); |
||||
|
uint32_t f = *(message_digest+5); |
||||
|
uint32_t g = *(message_digest+6); |
||||
|
uint32_t h = *(message_digest+7); |
||||
|
|
||||
|
for(std::size_t i = 0; i < 64; ++i){ |
||||
|
uint32_t temp1 = h+bsig1(e)+ch(e,f,g)+add_constant[i]+w[i]; |
||||
|
uint32_t temp2 = bsig0(a)+maj(a,b,c); |
||||
|
h = g; |
||||
|
g = f; |
||||
|
f = e; |
||||
|
e = mask_32bit(d+temp1); |
||||
|
d = c; |
||||
|
c = b; |
||||
|
b = a; |
||||
|
a = mask_32bit(temp1+temp2); |
||||
|
} |
||||
|
*message_digest += a; |
||||
|
*(message_digest+1) += b; |
||||
|
*(message_digest+2) += c; |
||||
|
*(message_digest+3) += d; |
||||
|
*(message_digest+4) += e; |
||||
|
*(message_digest+5) += f; |
||||
|
*(message_digest+6) += g; |
||||
|
*(message_digest+7) += h; |
||||
|
for(std::size_t i = 0; i < 8; ++i){ |
||||
|
*(message_digest+i) = mask_32bit(*(message_digest+i)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
}//namespace detail
|
||||
|
|
||||
|
template<typename InIter> |
||||
|
void output_hex(InIter first, InIter last, std::ostream& os){ |
||||
|
os.setf(std::ios::hex, std::ios::basefield); |
||||
|
while(first != last){ |
||||
|
os.width(2); |
||||
|
os.fill('0'); |
||||
|
os << static_cast<unsigned int>(*first); |
||||
|
++first; |
||||
|
} |
||||
|
os.setf(std::ios::dec, std::ios::basefield); |
||||
|
} |
||||
|
|
||||
|
template<typename InIter> |
||||
|
void bytes_to_hex_string(InIter first, InIter last, std::string& hex_str){ |
||||
|
std::ostringstream oss; |
||||
|
output_hex(first, last, oss); |
||||
|
hex_str.assign(oss.str()); |
||||
|
} |
||||
|
|
||||
|
template<typename InContainer> |
||||
|
void bytes_to_hex_string(const InContainer& bytes, std::string& hex_str){ |
||||
|
bytes_to_hex_string(bytes.begin(), bytes.end(), hex_str); |
||||
|
} |
||||
|
|
||||
|
template<typename InIter> |
||||
|
std::string bytes_to_hex_string(InIter first, InIter last){ |
||||
|
std::string hex_str; |
||||
|
bytes_to_hex_string(first, last, hex_str); |
||||
|
return hex_str; |
||||
|
} |
||||
|
|
||||
|
template<typename InContainer> |
||||
|
std::string bytes_to_hex_string(const InContainer& bytes){ |
||||
|
std::string hex_str; |
||||
|
bytes_to_hex_string(bytes, hex_str); |
||||
|
return hex_str; |
||||
|
} |
||||
|
|
||||
|
class hash256_one_by_one { |
||||
|
public: |
||||
|
hash256_one_by_one(){ |
||||
|
init(); |
||||
|
} |
||||
|
|
||||
|
void init(){ |
||||
|
buffer_.clear(); |
||||
|
std::fill(data_length_digits_, data_length_digits_+4, 0); |
||||
|
std::copy(detail::initial_message_digest, detail::initial_message_digest+8, h_); |
||||
|
} |
||||
|
|
||||
|
template<typename RaIter> |
||||
|
void process(RaIter first, RaIter last){ |
||||
|
add_to_data_length(std::distance(first, last)); |
||||
|
std::copy(first, last, std::back_inserter(buffer_)); |
||||
|
std::size_t i = 0; |
||||
|
for(;i+64 <= buffer_.size(); i+=64){ |
||||
|
detail::hash256_block(h_, buffer_.begin()+i, buffer_.begin()+i+64); |
||||
|
} |
||||
|
buffer_.erase(buffer_.begin(), buffer_.begin()+i); |
||||
|
} |
||||
|
|
||||
|
void finish(){ |
||||
|
uint8_t temp[64]; |
||||
|
std::fill(temp, temp+64, 0); |
||||
|
std::size_t remains = buffer_.size(); |
||||
|
std::copy(buffer_.begin(), buffer_.end(), temp); |
||||
|
temp[remains] = 0x80; |
||||
|
|
||||
|
if(remains > 55){ |
||||
|
std::fill(temp+remains+1, temp+64, 0); |
||||
|
detail::hash256_block(h_, temp, temp+64); |
||||
|
std::fill(temp, temp+64-4, 0); |
||||
|
} |
||||
|
else { |
||||
|
std::fill(temp+remains+1, temp+64-4, 0); |
||||
|
} |
||||
|
|
||||
|
write_data_bit_length(&(temp[56])); |
||||
|
detail::hash256_block(h_, temp, temp+64); |
||||
|
} |
||||
|
|
||||
|
template<typename OutIter> |
||||
|
void get_hash_bytes(OutIter first, OutIter last)const{ |
||||
|
for(const uint32_t* iter = h_; iter != h_+8; ++iter){ |
||||
|
for(std::size_t i = 0; i < 4 && first != last; ++i){ |
||||
|
*(first++) = detail::mask_8bit(static_cast<uint8_t>((*iter >> (24-8*i)))); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
void add_to_data_length(uint32_t n) { |
||||
|
uint32_t carry = 0; |
||||
|
data_length_digits_[0] += n; |
||||
|
for(std::size_t i = 0; i < 4; ++i) { |
||||
|
data_length_digits_[i] += carry; |
||||
|
if(data_length_digits_[i] >= 65536u) { |
||||
|
data_length_digits_[i] -= 65536u; |
||||
|
carry = 1; |
||||
|
} |
||||
|
else { |
||||
|
break; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
void write_data_bit_length(uint8_t* begin) { |
||||
|
uint32_t data_bit_length_digits[4]; |
||||
|
std::copy( |
||||
|
data_length_digits_, data_length_digits_+4, |
||||
|
data_bit_length_digits |
||||
|
); |
||||
|
|
||||
|
// convert byte length to bit length (multiply 8 or shift 3 times left)
|
||||
|
uint32_t carry = 0; |
||||
|
for(std::size_t i = 0; i < 4; ++i) { |
||||
|
uint32_t before_val = data_bit_length_digits[i]; |
||||
|
data_bit_length_digits[i] <<= 3; |
||||
|
data_bit_length_digits[i] |= carry; |
||||
|
data_bit_length_digits[i] &= 65535u; |
||||
|
carry = (before_val >> (16-3)) & 65535u; |
||||
|
} |
||||
|
|
||||
|
// write data_bit_length
|
||||
|
for(int i = 3; i >= 0; --i) { |
||||
|
(*begin++) = static_cast<uint8_t>(data_bit_length_digits[i] >> 8); |
||||
|
(*begin++) = static_cast<uint8_t>(data_bit_length_digits[i]); |
||||
|
} |
||||
|
} |
||||
|
std::vector<uint8_t> buffer_; |
||||
|
uint32_t data_length_digits_[4]; //as 64bit integer (16bit x 4 integer)
|
||||
|
uint32_t h_[8]; |
||||
|
}; |
||||
|
|
||||
|
inline void get_hash_hex_string(const hash256_one_by_one& hasher, std::string& hex_str){ |
||||
|
uint8_t hash[32]; |
||||
|
hasher.get_hash_bytes(hash, hash+32); |
||||
|
return bytes_to_hex_string(hash, hash+32, hex_str); |
||||
|
} |
||||
|
|
||||
|
inline std::string get_hash_hex_string(const hash256_one_by_one& hasher){ |
||||
|
std::string hex_str; |
||||
|
get_hash_hex_string(hasher, hex_str); |
||||
|
return hex_str; |
||||
|
} |
||||
|
|
||||
|
template<typename RaIter, typename OutIter> |
||||
|
void hash256(RaIter first, RaIter last, OutIter first2, OutIter last2){ |
||||
|
hash256_one_by_one hasher; |
||||
|
//hasher.init();
|
||||
|
hasher.process(first, last); |
||||
|
hasher.finish(); |
||||
|
hasher.get_hash_bytes(first2, last2); |
||||
|
} |
||||
|
|
||||
|
template<typename RaIter, typename OutContainer> |
||||
|
void hash256(RaIter first, RaIter last, OutContainer& dst){ |
||||
|
hash256(first, last, dst.begin(), dst.end()); |
||||
|
} |
||||
|
|
||||
|
template<typename RaContainer, typename OutIter> |
||||
|
void hash256(const RaContainer& src, OutIter first, OutIter last){ |
||||
|
hash256(src.begin(), src.end(), first, last); |
||||
|
} |
||||
|
|
||||
|
template<typename RaContainer, typename OutContainer> |
||||
|
void hash256(const RaContainer& src, OutContainer& dst){ |
||||
|
hash256(src.begin(), src.end(), dst.begin(), dst.end()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
template<typename RaIter> |
||||
|
void hash256_hex_string(RaIter first, RaIter last, std::string& hex_str){ |
||||
|
uint8_t hashed[32]; |
||||
|
hash256(first, last, hashed, hashed+32); |
||||
|
std::ostringstream oss; |
||||
|
output_hex(hashed, hashed+32, oss); |
||||
|
hex_str.assign(oss.str()); |
||||
|
} |
||||
|
|
||||
|
template<typename RaIter> |
||||
|
std::string hash256_hex_string(RaIter first, RaIter last){ |
||||
|
std::string hex_str; |
||||
|
hash256_hex_string(first, last, hex_str); |
||||
|
return hex_str; |
||||
|
} |
||||
|
|
||||
|
inline void hash256_hex_string(const std::string& src, std::string& hex_str){ |
||||
|
hash256_hex_string(src.begin(), src.end(), hex_str); |
||||
|
} |
||||
|
|
||||
|
template<typename RaContainer> |
||||
|
void hash256_hex_string(const RaContainer& src, std::string& hex_str){ |
||||
|
hash256_hex_string(src.begin(), src.end(), hex_str); |
||||
|
} |
||||
|
|
||||
|
template<typename RaContainer> |
||||
|
std::string hash256_hex_string(const RaContainer& src){ |
||||
|
return hash256_hex_string(src.begin(), src.end()); |
||||
|
} |
||||
|
|
||||
|
}//namespace picosha2
|
||||
|
|
||||
|
#endif //PICOSHA2_H
|
||||
Loading…
Reference in new issue