Gav Wood
11 years ago
9 changed files with 54 additions and 806 deletions
@ -1,351 +0,0 @@ |
|||
/********************************************************************\
|
|||
* |
|||
* FILE: rmd160.c |
|||
* |
|||
* CONTENTS: 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 |
|||
* |
|||
\********************************************************************/ |
|||
|
|||
/* header files */ |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include "rmd160.h" |
|||
|
|||
#include <cstdint> |
|||
|
|||
/********************************************************************/ |
|||
|
|||
/* typedef 8 and 32 bit types, resp. */ |
|||
/* adapt these, if necessary,
|
|||
for your operating system and compiler */ |
|||
typedef unsigned char byte; |
|||
typedef uint32_t dword; |
|||
|
|||
/* if this line causes a compiler error,
|
|||
adapt the defintion of dword above */ |
|||
typedef int the_correct_size_was_chosen [sizeof (dword) == 4? 1: -1]; |
|||
|
|||
/********************************************************************/ |
|||
|
|||
/* macro definitions */ |
|||
|
|||
|
|||
/* 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(dword *MDbuf) |
|||
{ |
|||
MDbuf[0] = 0x67452301UL; |
|||
MDbuf[1] = 0xefcdab89UL; |
|||
MDbuf[2] = 0x98badcfeUL; |
|||
MDbuf[3] = 0x10325476UL; |
|||
MDbuf[4] = 0xc3d2e1f0UL; |
|||
|
|||
return; |
|||
} |
|||
|
|||
/********************************************************************/ |
|||
|
|||
void compress(dword *MDbuf, dword *X) |
|||
{ |
|||
dword aa = MDbuf[0], bb = MDbuf[1], cc = MDbuf[2], |
|||
dd = MDbuf[3], ee = MDbuf[4]; |
|||
dword 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(dword *MDbuf, byte const *strptr, dword lswlen, dword mswlen) |
|||
{ |
|||
unsigned int i; /* counter */ |
|||
dword X[16]; /* message words */ |
|||
|
|||
memset(X, 0, 16*sizeof(dword)); |
|||
|
|||
/* 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] ^= (dword) *strptr++ << (8 * (i&3)); |
|||
} |
|||
|
|||
/* append the bit m_n == 1 */ |
|||
X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7); |
|||
|
|||
if ((lswlen & 63) > 55) { |
|||
/* length goes to next block */ |
|||
compress(MDbuf, X); |
|||
memset(X, 0, 16*sizeof(dword)); |
|||
} |
|||
|
|||
/* append length in bits*/ |
|||
X[14] = lswlen << 3; |
|||
X[15] = (lswlen >> 29) | (mswlen << 3); |
|||
compress(MDbuf, X); |
|||
|
|||
return; |
|||
} |
|||
|
|||
/************************ end of file rmd160.c **********************/ |
|||
@ -1,48 +0,0 @@ |
|||
/********************************************************************\
|
|||
* |
|||
* FILE: rmd160.h |
|||
* |
|||
* 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 |
|||
* |
|||
\********************************************************************/ |
|||
|
|||
#ifndef RMD160H /* make sure this file is read only once */ |
|||
#define RMD160H |
|||
|
|||
#include <cstdint> |
|||
|
|||
/********************************************************************/ |
|||
|
|||
/* function prototypes */ |
|||
|
|||
void MDinit(uint32_t *MDbuf); |
|||
/*
|
|||
* initializes MDbuffer to "magic constants" |
|||
*/ |
|||
|
|||
void compress(uint32_t *MDbuf, uint32_t *X); |
|||
/*
|
|||
* the compression function. |
|||
* transforms MDbuf using message bytes X[0] through X[15] |
|||
*/ |
|||
|
|||
void MDfinish(uint32_t *MDbuf, unsigned char const *strptr, uint32_t lswlen, uint32_t mswlen); |
|||
/*
|
|||
* puts bytes from strptr into X and pad out; appends length |
|||
* and finally, compresses the last block(s) |
|||
* note: length in bits == 8 * (lswlen + 2^32 mswlen). |
|||
* note: there are (lswlen mod 64) bytes left in strptr. |
|||
*/ |
|||
|
|||
#endif /* RMD160H */ |
|||
|
|||
/*********************** end of file rmd160.h ***********************/ |
|||
@ -1,229 +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. |
|||
|
|||
Foobar 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 Foobar. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file sha256.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @author Oliver Gay <olivier.gay@a3.epfl.ch> |
|||
* @date 2014 |
|||
* @note Modified from an original version with BSD licence. |
|||
*/ |
|||
|
|||
/*
|
|||
* Updated to C++, zedwood.com 2012 |
|||
* Based on Olivier Gay's version |
|||
* See Modified BSD License below: |
|||
* |
|||
* FIPS 180-2 SHA-224/256/384/512 implementation |
|||
* Issue date: 04/30/2005 |
|||
* http://www.ouah.org/ogay/sha2/
|
|||
* |
|||
* Copyright (C) 2005, 2007 Olivier Gay <olivier.gay@a3.epfl.ch> |
|||
* All rights reserved. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* 3. Neither the name of the project nor the names of its contributors |
|||
* may be used to endorse or promote products derived from this software |
|||
* without specific prior written permission. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND |
|||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|||
* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE |
|||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
|||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
|||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
|||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
|||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
|||
* SUCH DAMAGE. |
|||
*/ |
|||
|
|||
#include <cstring> |
|||
#include <fstream> |
|||
#include "sha256.h" |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
const uint32_t SHA256::sha256_k[64] = //UL = uint32_t
|
|||
{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}; |
|||
|
|||
void SHA256::transform(byte const* message, unsigned block_nb) |
|||
{ |
|||
uint32_t w[64]; |
|||
uint32_t wv[8]; |
|||
uint32_t t1, t2; |
|||
const unsigned char *sub_block; |
|||
int i; |
|||
int j; |
|||
for (i = 0; i < (int) block_nb; i++) { |
|||
sub_block = message + (i << 6); |
|||
for (j = 0; j < 16; j++) { |
|||
SHA2_PACK32(&sub_block[j << 2], &w[j]); |
|||
} |
|||
for (j = 16; j < 64; j++) { |
|||
w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16]; |
|||
} |
|||
for (j = 0; j < 8; j++) { |
|||
wv[j] = m_h[j]; |
|||
} |
|||
for (j = 0; j < 64; j++) { |
|||
t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6]) |
|||
+ sha256_k[j] + w[j]; |
|||
t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]); |
|||
wv[7] = wv[6]; |
|||
wv[6] = wv[5]; |
|||
wv[5] = wv[4]; |
|||
wv[4] = wv[3] + t1; |
|||
wv[3] = wv[2]; |
|||
wv[2] = wv[1]; |
|||
wv[1] = wv[0]; |
|||
wv[0] = t1 + t2; |
|||
} |
|||
for (j = 0; j < 8; j++) { |
|||
m_h[j] += wv[j]; |
|||
} |
|||
} |
|||
} |
|||
|
|||
void SHA256::init() |
|||
{ |
|||
m_h[0] = 0x6a09e667; |
|||
m_h[1] = 0xbb67ae85; |
|||
m_h[2] = 0x3c6ef372; |
|||
m_h[3] = 0xa54ff53a; |
|||
m_h[4] = 0x510e527f; |
|||
m_h[5] = 0x9b05688c; |
|||
m_h[6] = 0x1f83d9ab; |
|||
m_h[7] = 0x5be0cd19; |
|||
m_len = 0; |
|||
m_tot_len = 0; |
|||
} |
|||
|
|||
void SHA256::update(byte const* message, unsigned len) |
|||
{ |
|||
unsigned int block_nb; |
|||
unsigned int new_len, rem_len, tmp_len; |
|||
const unsigned char *shifted_message; |
|||
tmp_len = SHA224_256_BLOCK_SIZE - m_len; |
|||
rem_len = len < tmp_len ? len : tmp_len; |
|||
memcpy(&m_block[m_len], message, rem_len); |
|||
if (m_len + len < SHA224_256_BLOCK_SIZE) { |
|||
m_len += len; |
|||
return; |
|||
} |
|||
new_len = len - rem_len; |
|||
block_nb = new_len / SHA224_256_BLOCK_SIZE; |
|||
shifted_message = message + rem_len; |
|||
transform(m_block, 1); |
|||
transform(shifted_message, block_nb); |
|||
rem_len = new_len % SHA224_256_BLOCK_SIZE; |
|||
memcpy(m_block, &shifted_message[block_nb << 6], rem_len); |
|||
m_len = rem_len; |
|||
m_tot_len += (block_nb + 1) << 6; |
|||
} |
|||
|
|||
void SHA256::final(byte* digest) |
|||
{ |
|||
unsigned block_nb; |
|||
unsigned pm_len; |
|||
unsigned len_b; |
|||
int i; |
|||
block_nb = (1 + ((SHA224_256_BLOCK_SIZE - 9) |
|||
< (m_len % SHA224_256_BLOCK_SIZE))); |
|||
len_b = (m_tot_len + m_len) << 3; |
|||
pm_len = block_nb << 6; |
|||
memset(m_block + m_len, 0, pm_len - m_len); |
|||
m_block[m_len] = 0x80; |
|||
SHA2_UNPACK32(len_b, m_block + pm_len - 4); |
|||
transform(m_block, block_nb); |
|||
|
|||
for (i = 0 ; i < 8; i++) { |
|||
SHA2_UNPACK32(m_h[i], &digest[i << 2]); |
|||
} |
|||
} |
|||
|
|||
std::string eth::sha256(std::string const& _input, bool _hex) |
|||
{ |
|||
if (!_hex) |
|||
{ |
|||
string ret(SHA256::DIGEST_SIZE, '\0'); |
|||
SHA256 ctx = SHA256(); |
|||
ctx.init(); |
|||
ctx.update( (unsigned char*)_input.c_str(), _input.length()); |
|||
ctx.final((byte*)ret.data()); |
|||
return ret; |
|||
} |
|||
|
|||
unsigned char digest[SHA256::DIGEST_SIZE]; |
|||
memset(digest,0,SHA256::DIGEST_SIZE); |
|||
|
|||
SHA256 ctx = SHA256(); |
|||
ctx.init(); |
|||
ctx.update( (unsigned char*)_input.c_str(), _input.length()); |
|||
ctx.final(digest); |
|||
|
|||
char buf[2*SHA256::DIGEST_SIZE+1]; |
|||
buf[2*SHA256::DIGEST_SIZE] = 0; |
|||
for (unsigned int i = 0; i < SHA256::DIGEST_SIZE; i++) |
|||
sprintf(buf+i*2, "%02x", digest[i]); |
|||
return std::string(buf); |
|||
} |
|||
|
|||
bytes eth::sha256Bytes(bytesConstRef _input) |
|||
{ |
|||
bytes ret(SHA256::DIGEST_SIZE); |
|||
SHA256 ctx = SHA256(); |
|||
ctx.init(); |
|||
ctx.update((byte*)_input.data(), _input.size()); |
|||
ctx.final(ret.data()); |
|||
return ret; |
|||
} |
|||
|
|||
u256 eth::sha256(bytesConstRef _input) |
|||
{ |
|||
u256 ret = 0; |
|||
|
|||
SHA256 ctx = SHA256(); |
|||
ctx.init(); |
|||
ctx.update(_input.data(), _input.size()); |
|||
uint8_t buf[SHA256::DIGEST_SIZE]; |
|||
ctx.final(buf); |
|||
for (unsigned i = 0; i < 32; ++i) |
|||
ret = (ret << 8) | buf[i]; |
|||
return ret; |
|||
} |
|||
@ -1,86 +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. |
|||
|
|||
Foobar 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 Foobar. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file sha256.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @author Oliver Gay <olivier.gay@a3.epfl.ch> |
|||
* @date 2014 |
|||
* @note Modified from an original version with BSD licence. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <string> |
|||
#include "Common.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
class SHA256 |
|||
{ |
|||
protected: |
|||
const static uint32_t sha256_k[]; |
|||
static const unsigned SHA224_256_BLOCK_SIZE = (512/8); |
|||
public: |
|||
void init(); |
|||
void update(byte const* message, unsigned len); |
|||
void final(byte* digest); |
|||
static const unsigned int DIGEST_SIZE = ( 256 / 8); |
|||
|
|||
protected: |
|||
void transform(byte const* message, unsigned block_nb); |
|||
unsigned m_tot_len; |
|||
unsigned m_len; |
|||
byte m_block[2*SHA224_256_BLOCK_SIZE]; |
|||
uint32_t m_h[8]; |
|||
}; |
|||
|
|||
std::string sha256(std::string const& _input, bool _hex); |
|||
|
|||
bytes sha256Bytes(bytesConstRef _input); |
|||
inline bytes sha256Bytes(std::string const& _input) { return sha256Bytes((std::string*)&_input); } |
|||
inline bytes sha256Bytes(bytes const& _input) { return sha256Bytes((bytes*)&_input); } |
|||
|
|||
u256 sha256(bytesConstRef _input); |
|||
inline u256 sha256(bytes const& _input) { return sha256(bytesConstRef((bytes*)&_input)); } |
|||
|
|||
#define SHA2_SHFR(x, n) (x >> n) |
|||
#define SHA2_ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n))) |
|||
#define SHA2_ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n))) |
|||
#define SHA2_CH(x, y, z) ((x & y) ^ (~x & z)) |
|||
#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z)) |
|||
#define SHA256_F1(x) (SHA2_ROTR(x, 2) ^ SHA2_ROTR(x, 13) ^ SHA2_ROTR(x, 22)) |
|||
#define SHA256_F2(x) (SHA2_ROTR(x, 6) ^ SHA2_ROTR(x, 11) ^ SHA2_ROTR(x, 25)) |
|||
#define SHA256_F3(x) (SHA2_ROTR(x, 7) ^ SHA2_ROTR(x, 18) ^ SHA2_SHFR(x, 3)) |
|||
#define SHA256_F4(x) (SHA2_ROTR(x, 17) ^ SHA2_ROTR(x, 19) ^ SHA2_SHFR(x, 10)) |
|||
#define SHA2_UNPACK32(x, str) \ |
|||
{ \ |
|||
*((str) + 3) = (uint8_t) ((x) ); \ |
|||
*((str) + 2) = (uint8_t) ((x) >> 8); \ |
|||
*((str) + 1) = (uint8_t) ((x) >> 16); \ |
|||
*((str) + 0) = (uint8_t) ((x) >> 24); \ |
|||
} |
|||
#define SHA2_PACK32(str, x) \ |
|||
{ \ |
|||
*(x) = ((uint32_t) *((str) + 3) ) \ |
|||
| ((uint32_t) *((str) + 2) << 8) \ |
|||
| ((uint32_t) *((str) + 1) << 16) \ |
|||
| ((uint32_t) *((str) + 0) << 24); \ |
|||
} |
|||
|
|||
} |
|||
|
|||
|
|||
Loading…
Reference in new issue