yann300
10 years ago
114 changed files with 1758 additions and 452 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,223 @@ |
|||
/*
|
|||
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 SHA3.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "SHA3.h" |
|||
#include <cstdint> |
|||
#include <cstdio> |
|||
#include <cstdlib> |
|||
#include <cstring> |
|||
#include <libdevcore/RLP.h> |
|||
#include "picosha2.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
h256 EmptySHA3 = sha3(bytesConstRef()); |
|||
h256 EmptyListSHA3 = sha3(rlpList()); |
|||
|
|||
namespace keccak |
|||
{ |
|||
|
|||
/** libkeccak-tiny
|
|||
* |
|||
* A single-file implementation of SHA-3 and SHAKE. |
|||
* |
|||
* Implementor: David Leon Gil |
|||
* License: CC0, attribution kindly requested. Blame taken too, |
|||
* but not liability. |
|||
*/ |
|||
|
|||
#define decshake(bits) \ |
|||
int shake##bits(uint8_t*, size_t, const uint8_t*, size_t); |
|||
|
|||
#define decsha3(bits) \ |
|||
int sha3_##bits(uint8_t*, size_t, const uint8_t*, size_t); |
|||
|
|||
decshake(128) |
|||
decshake(256) |
|||
decsha3(224) |
|||
decsha3(256) |
|||
decsha3(384) |
|||
decsha3(512) |
|||
|
|||
/******** The Keccak-f[1600] permutation ********/ |
|||
|
|||
/*** Constants. ***/ |
|||
static const uint8_t rho[24] = \ |
|||
{ 1, 3, 6, 10, 15, 21, |
|||
28, 36, 45, 55, 2, 14, |
|||
27, 41, 56, 8, 25, 43, |
|||
62, 18, 39, 61, 20, 44}; |
|||
static const uint8_t pi[24] = \ |
|||
{10, 7, 11, 17, 18, 3, |
|||
5, 16, 8, 21, 24, 4, |
|||
15, 23, 19, 13, 12, 2, |
|||
20, 14, 22, 9, 6, 1}; |
|||
static const uint64_t RC[24] = \ |
|||
{1ULL, 0x8082ULL, 0x800000000000808aULL, 0x8000000080008000ULL, |
|||
0x808bULL, 0x80000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL, |
|||
0x8aULL, 0x88ULL, 0x80008009ULL, 0x8000000aULL, |
|||
0x8000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL, 0x8000000000008003ULL, |
|||
0x8000000000008002ULL, 0x8000000000000080ULL, 0x800aULL, 0x800000008000000aULL, |
|||
0x8000000080008081ULL, 0x8000000000008080ULL, 0x80000001ULL, 0x8000000080008008ULL}; |
|||
|
|||
/*** Helper macros to unroll the permutation. ***/ |
|||
#define rol(x, s) (((x) << s) | ((x) >> (64 - s))) |
|||
#define REPEAT6(e) e e e e e e |
|||
#define REPEAT24(e) REPEAT6(e e e e) |
|||
#define REPEAT5(e) e e e e e |
|||
#define FOR5(v, s, e) \ |
|||
v = 0; \ |
|||
REPEAT5(e; v += s;) |
|||
|
|||
/*** Keccak-f[1600] ***/ |
|||
static inline void keccakf(void* state) { |
|||
uint64_t* a = (uint64_t*)state; |
|||
uint64_t b[5] = {0}; |
|||
uint64_t t = 0; |
|||
uint8_t x, y; |
|||
|
|||
for (int i = 0; i < 24; i++) { |
|||
// Theta
|
|||
FOR5(x, 1, |
|||
b[x] = 0; |
|||
FOR5(y, 5, |
|||
b[x] ^= a[x + y]; )) |
|||
FOR5(x, 1, |
|||
FOR5(y, 5, |
|||
a[y + x] ^= b[(x + 4) % 5] ^ rol(b[(x + 1) % 5], 1); )) |
|||
// Rho and pi
|
|||
t = a[1]; |
|||
x = 0; |
|||
REPEAT24(b[0] = a[pi[x]]; |
|||
a[pi[x]] = rol(t, rho[x]); |
|||
t = b[0]; |
|||
x++; ) |
|||
// Chi
|
|||
FOR5(y, |
|||
5, |
|||
FOR5(x, 1, |
|||
b[x] = a[y + x];) |
|||
FOR5(x, 1, |
|||
a[y + x] = b[x] ^ ((~b[(x + 1) % 5]) & b[(x + 2) % 5]); )) |
|||
// Iota
|
|||
a[0] ^= RC[i]; |
|||
} |
|||
} |
|||
|
|||
/******** The FIPS202-defined functions. ********/ |
|||
|
|||
/*** Some helper macros. ***/ |
|||
|
|||
#define _(S) do { S } while (0) |
|||
#define FOR(i, ST, L, S) \ |
|||
_(for (size_t i = 0; i < L; i += ST) { S; }) |
|||
#define mkapply_ds(NAME, S) \ |
|||
static inline void NAME(uint8_t* dst, \ |
|||
const uint8_t* src, \ |
|||
size_t len) { \ |
|||
FOR(i, 1, len, S); \ |
|||
} |
|||
#define mkapply_sd(NAME, S) \ |
|||
static inline void NAME(const uint8_t* src, \ |
|||
uint8_t* dst, \ |
|||
size_t len) { \ |
|||
FOR(i, 1, len, S); \ |
|||
} |
|||
|
|||
mkapply_ds(xorin, dst[i] ^= src[i]) // xorin
|
|||
mkapply_sd(setout, dst[i] = src[i]) // setout
|
|||
|
|||
#define P keccakf |
|||
#define Plen 200 |
|||
|
|||
// Fold P*F over the full blocks of an input.
|
|||
#define foldP(I, L, F) \ |
|||
while (L >= rate) { \ |
|||
F(a, I, rate); \ |
|||
P(a); \ |
|||
I += rate; \ |
|||
L -= rate; \ |
|||
} |
|||
|
|||
/** The sponge-based hash construction. **/ |
|||
static inline int hash(uint8_t* out, size_t outlen, |
|||
const uint8_t* in, size_t inlen, |
|||
size_t rate, uint8_t delim) { |
|||
if ((out == NULL) || ((in == NULL) && inlen != 0) || (rate >= Plen)) { |
|||
return -1; |
|||
} |
|||
uint8_t a[Plen] = {0}; |
|||
// Absorb input.
|
|||
foldP(in, inlen, xorin); |
|||
// Xor in the DS and pad frame.
|
|||
a[inlen] ^= delim; |
|||
a[rate - 1] ^= 0x80; |
|||
// Xor in the last block.
|
|||
xorin(a, in, inlen); |
|||
// Apply P
|
|||
P(a); |
|||
// Squeeze output.
|
|||
foldP(out, outlen, setout); |
|||
setout(a, out, outlen); |
|||
memset(a, 0, 200); |
|||
return 0; |
|||
} |
|||
|
|||
/*** Helper macros to define SHA3 and SHAKE instances. ***/ |
|||
#define defshake(bits) \ |
|||
int shake##bits(uint8_t* out, size_t outlen, \ |
|||
const uint8_t* in, size_t inlen) { \ |
|||
return hash(out, outlen, in, inlen, 200 - (bits / 4), 0x1f); \ |
|||
} |
|||
#define defsha3(bits) \ |
|||
int sha3_##bits(uint8_t* out, size_t outlen, \ |
|||
const uint8_t* in, size_t inlen) { \ |
|||
if (outlen > (bits/8)) { \ |
|||
return -1; \ |
|||
} \ |
|||
return hash(out, outlen, in, inlen, 200 - (bits / 4), 0x01); \ |
|||
} |
|||
|
|||
/*** FIPS202 SHAKE VOFs ***/ |
|||
defshake(128) |
|||
defshake(256) |
|||
|
|||
/*** FIPS202 SHA3 FOFs ***/ |
|||
defsha3(224) |
|||
defsha3(256) |
|||
defsha3(384) |
|||
defsha3(512) |
|||
|
|||
} |
|||
|
|||
h256 sha3(bytesConstRef _input) |
|||
{ |
|||
// FIXME: What with unaligned memory?
|
|||
h256 ret; |
|||
keccak::sha3_256(ret.data(), 32, _input.data(), _input.size()); |
|||
// keccak::keccak(ret.data(), 32, (uint64_t const*)_input.data(), _input.size());
|
|||
return ret; |
|||
} |
|||
|
|||
} |
|||
@ -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
|
|||
@ -1,129 +0,0 @@ |
|||
/*
|
|||
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 SHA3.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "SHA3.h" |
|||
|
|||
#include <libdevcore/RLP.h> |
|||
#include "CryptoPP.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
h256 EmptySHA3 = sha3(bytesConstRef()); |
|||
h256 EmptyListSHA3 = sha3(rlpList()); |
|||
|
|||
std::string sha3(std::string const& _input, bool _hex) |
|||
{ |
|||
if (!_hex) |
|||
{ |
|||
string ret(32, '\0'); |
|||
sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)ret.data(), 32)); |
|||
return ret; |
|||
} |
|||
|
|||
uint8_t buf[32]; |
|||
sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)&(buf[0]), 32)); |
|||
std::string ret(64, '\0'); |
|||
for (unsigned int i = 0; i < 32; i++) |
|||
sprintf((char*)(ret.data())+i*2, "%02x", buf[i]); |
|||
return ret; |
|||
} |
|||
|
|||
void sha3(bytesConstRef _input, bytesRef _output) |
|||
{ |
|||
CryptoPP::SHA3_256 ctx; |
|||
ctx.Update((byte*)_input.data(), _input.size()); |
|||
assert(_output.size() >= 32); |
|||
ctx.Final(_output.data()); |
|||
} |
|||
|
|||
void ripemd160(bytesConstRef _input, bytesRef _output) |
|||
{ |
|||
CryptoPP::RIPEMD160 ctx; |
|||
ctx.Update((byte*)_input.data(), _input.size()); |
|||
assert(_output.size() >= 32); |
|||
ctx.Final(_output.data()); |
|||
} |
|||
|
|||
void sha256(bytesConstRef _input, bytesRef _output) |
|||
{ |
|||
CryptoPP::SHA256 ctx; |
|||
ctx.Update((byte*)_input.data(), _input.size()); |
|||
assert(_output.size() >= 32); |
|||
ctx.Final(_output.data()); |
|||
} |
|||
|
|||
bytes sha3Bytes(bytesConstRef _input) |
|||
{ |
|||
bytes ret(32); |
|||
sha3(_input, &ret); |
|||
return ret; |
|||
} |
|||
|
|||
h256 sha3(bytesConstRef _input) |
|||
{ |
|||
h256 ret; |
|||
sha3(_input, bytesRef(&ret[0], 32)); |
|||
return ret; |
|||
} |
|||
|
|||
void sha3mac(bytesConstRef _secret, bytesConstRef _plain, bytesRef _output) |
|||
{ |
|||
CryptoPP::SHA3_256 ctx; |
|||
assert(_secret.size() > 0); |
|||
ctx.Update((byte*)_secret.data(), _secret.size()); |
|||
ctx.Update((byte*)_plain.data(), _plain.size()); |
|||
assert(_output.size() >= 32); |
|||
ctx.Final(_output.data()); |
|||
} |
|||
|
|||
bytes aesDecrypt(bytesConstRef _ivCipher, std::string const& _password, unsigned _rounds, bytesConstRef _salt) |
|||
{ |
|||
bytes pw = asBytes(_password); |
|||
|
|||
if (!_salt.size()) |
|||
_salt = &pw; |
|||
|
|||
bytes target(64); |
|||
CryptoPP::PKCS5_PBKDF2_HMAC<CryptoPP::SHA256>().DeriveKey(target.data(), target.size(), 0, pw.data(), pw.size(), _salt.data(), _salt.size(), _rounds); |
|||
|
|||
try |
|||
{ |
|||
CryptoPP::AES::Decryption aesDecryption(target.data(), 16); |
|||
auto cipher = _ivCipher.cropped(16); |
|||
auto iv = _ivCipher.cropped(0, 16); |
|||
CryptoPP::CBC_Mode_ExternalCipher::Decryption cbcDecryption(aesDecryption, iv.data()); |
|||
std::string decrypted; |
|||
CryptoPP::StreamTransformationFilter stfDecryptor(cbcDecryption, new CryptoPP::StringSink(decrypted)); |
|||
stfDecryptor.Put(cipher.data(), cipher.size()); |
|||
stfDecryptor.MessageEnd(); |
|||
return asBytes(decrypted); |
|||
} |
|||
catch (exception const& e) |
|||
{ |
|||
cerr << e.what() << endl; |
|||
return bytes(); |
|||
} |
|||
} |
|||
|
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue