From 48b09db84b74f01f45492fa724a27af363fd0d60 Mon Sep 17 00:00:00 2001 From: Gav Wood Date: Thu, 9 Jan 2014 23:08:49 +0000 Subject: [PATCH] Move crypto/hash algos over to libcrypto++. --- README.md | 4 +- libethereum/Common.cpp | 86 ++-------- libethereum/Common.h | 9 + libethereum/State.cpp | 42 +++-- libethereum/rmd160.cpp | 351 --------------------------------------- libethereum/rmd160.h | 48 ------ libethereum/sha256.cpp | 229 ------------------------- libethereum/sha256.h | 86 ---------- libethereum/vector_ref.h | 5 +- 9 files changed, 54 insertions(+), 806 deletions(-) delete mode 100644 libethereum/rmd160.cpp delete mode 100644 libethereum/rmd160.h delete mode 100644 libethereum/sha256.cpp delete mode 100644 libethereum/sha256.h diff --git a/README.md b/README.md index 98df0ed76..21ac2e10e 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,5 @@ On Ubuntu: ## Contributing -Read CodingStandards.txt thoroughly, before making alterations to the code base. - -Do *NOT* use an editor that automatically reformats whitespace away from astylerc or the formating guidelines as describled in CodingStandards.txt. Your contributions will be refused and your commits will be reversed. +Please read CodingStandards.txt thoroughly before making alterations to the code base. Please do *NOT* use an editor that automatically reformats whitespace away from astylerc or the formating guidelines as describled in CodingStandards.txt. diff --git a/libethereum/Common.cpp b/libethereum/Common.cpp index 389e13bdf..a0d75849b 100644 --- a/libethereum/Common.cpp +++ b/libethereum/Common.cpp @@ -23,12 +23,9 @@ #include #include "Common.h" #include "Exceptions.h" -#include "rmd160.h" using namespace std; using namespace eth; - - std::string eth::escaped(std::string const& _s, bool _all) { std::string ret; @@ -98,99 +95,42 @@ bytes eth::toHex(std::string const& _s) return ret; } -// ///////////////////////////////////////////////// -// RIPEMD-160 stuff. Leave well alone. -// ///////////////////////////////////////////////// - -/* 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))) - -u160 eth::ripemd160(bytesConstRef _message) -/* - * returns RMD(message) - * message should be a string terminated by '\0' - */ -{ - static const uint RMDsize = 160; - uint32_t MDbuf[RMDsize/32]; /* contains (A, B, C, D(, E)) */ - static byte hashcode[RMDsize/8]; /* for final hash-value */ - uint32_t X[16]; /* current 16-word chunk */ - unsigned int i; /* counter */ - uint32_t length; /* length in bytes of message */ - uint32_t nbytes; /* # of bytes not yet processed */ - - /* initialize */ - MDinit(MDbuf); - length = _message.size(); - auto message = _message.data(); - - /* process message in 16-word chunks */ - for (nbytes=length; nbytes > 63; nbytes-=64) { - for (i=0; i<16; i++) { - X[i] = BYTES_TO_DWORD(message); - message += 4; - } - compress(MDbuf, X); - } /* length mod 64 bytes left */ - - /* finish: */ - MDfinish(MDbuf, message, length, 0); - - for (i=0; i>2]; /* implicit cast to byte */ - hashcode[i+1] = (MDbuf[i>>2] >> 8); /* extracts the 8 least */ - hashcode[i+2] = (MDbuf[i>>2] >> 16); /* significant bits. */ - hashcode[i+3] = (MDbuf[i>>2] >> 24); - } - - u160 ret = 0; - for (i = 0; i < RMDsize / 8; ++i) - ret = (ret << 8) | hashcode[i]; - return ret; -} - std::string eth::sha3(std::string const& _input, bool _hex) { if (!_hex) { string ret(32, '\0'); - CryptoPP::SHA3_256 ctx; - ctx.Update( (unsigned char*)_input.c_str(), _input.length()); - ctx.Final((byte*)ret.data()); + sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)ret.data(), 32)); return ret; } - CryptoPP::SHA3_256 ctx; - ctx.Update( (unsigned char*)_input.c_str(), _input.length()); - unsigned char digest[32]; - ctx.Final(digest); - + 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", digest[i]); + sprintf((char*)(ret.data())+i*2, "%02x", buf[i]); return ret; } -bytes eth::sha3Bytes(bytesConstRef _input) +void eth::sha3(bytesConstRef _input, bytesRef _output) { CryptoPP::SHA3_256 ctx; ctx.Update((byte*)_input.data(), _input.size()); + assert(_output.size() >= 32); + ctx.Final(_output.data()); +} + +bytes eth::sha3Bytes(bytesConstRef _input) +{ bytes ret(32); - ctx.Final(ret.data()); + sha3(_input, &ret); return ret; } u256 eth::sha3(bytesConstRef _input) { - CryptoPP::SHA3_256 ctx; - ctx.Update(_input.data(), _input.size()); uint8_t buf[32]; - ctx.Final(buf); - + sha3(_input, bytesRef(&buf[0], 32)); u256 ret = 0; for (unsigned i = 0; i < 32; ++i) ret = (ret << 8) | buf[i]; diff --git a/libethereum/Common.h b/libethereum/Common.h index 705ea4350..7ed6bd3ba 100644 --- a/libethereum/Common.h +++ b/libethereum/Common.h @@ -201,6 +201,13 @@ inline u160 low160(_T const& _t) return (u160)(_t & ((((_T)1) << 160) - 1)); } +/// Convert the given value into u160 (160-bit unsigned integer) by taking the lowest order 160-bits and discarding the rest. +template +inline u160 high160(_T const& _t) +{ + return (u160)(_t >> 96); +} + /// Convert the given value safely into u160 (160-bit unsigned integer). /// @note Currently unsafe. template @@ -231,6 +238,8 @@ inline std::vector<_T> operator+(std::vector +#include +#include #include -#include "sha256.h" #include "Trie.h" #include "BlockChain.h" #include "Instruction.h" @@ -490,26 +491,41 @@ void State::execute(Address _myAddress, Address _txSender, u256 _txValue, u256 _ stack.push_back(m_currentBlock.difficulty); break; case Instruction::SHA256: + { + uint s = (uint)min(stack.back(), (u256)(stack.size() - 1) * 32); + stack.pop_back(); + + CryptoPP::SHA256 digest; + uint i = 0; + for (; s; s = (s >= 32 ? s - 32 : 0), i += 32) + { + bytes b = toBigEndian(stack.back()); + digest.Update(b.data(), (int)min(32, s)); // b.size() == 32 + stack.pop_back(); + } + array final; + digest.TruncatedFinal(final.data(), 32); + stack.push_back(fromBigEndian(final)); + break; + } case Instruction::RIPEMD160: { uint s = (uint)min(stack.back(), (u256)(stack.size() - 1) * 32); - bytes b(s); + stack.pop_back(); + + CryptoPP::RIPEMD160 digest; uint i = 0; for (; s; s = (s >= 32 ? s - 32 : 0), i += 32) { + bytes b = toBigEndian(stack.back()); + digest.Update(b.data(), (int)min(32, s)); // b.size() == 32 stack.pop_back(); - u256 v = stack.back(); - int sz = (int)min(32, s) - 1; // sz is one fewer than the number of bytes we're interested in. - v >>= ((31 - sz) * 8); // kill unused low-order bytes. - for (int j = 0; j <= sz; ++j, v >>= 8) // cycle through bytes, starting at low-order end. - b[i + sz - j] = (byte)(v & 0xff); // set each 32-byte (256-bit) chunk in reverse - (i.e. we want to put low-order last). } - if (inst == Instruction::SHA256) - stack.back() = sha256(b); - else - // NOTE: this aligns to right of 256-bit container (low-order bytes). - // This won't work if they're treated as byte-arrays and thus left-aligned in a 256-bit container. - stack.back() = ripemd160(&b); + array final; + digest.TruncatedFinal(final.data(), 20); + // NOTE: this aligns to right of 256-bit container (low-order bytes). + // This won't work if they're treated as byte-arrays and thus left-aligned in a 256-bit container. + stack.push_back((u256)fromBigEndian(final)); break; } case Instruction::ECMUL: diff --git a/libethereum/rmd160.cpp b/libethereum/rmd160.cpp deleted file mode 100644 index 46abe8910..000000000 --- a/libethereum/rmd160.cpp +++ /dev/null @@ -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 -#include -#include -#include "rmd160.h" - -#include - -/********************************************************************/ - -/* 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 **********************/ diff --git a/libethereum/rmd160.h b/libethereum/rmd160.h deleted file mode 100644 index 52ef5234f..000000000 --- a/libethereum/rmd160.h +++ /dev/null @@ -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 - -/********************************************************************/ - -/* 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 ***********************/ diff --git a/libethereum/sha256.cpp b/libethereum/sha256.cpp deleted file mode 100644 index 9bed1f66e..000000000 --- a/libethereum/sha256.cpp +++ /dev/null @@ -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 . -*/ -/** @file sha256.cpp - * @author Gav Wood - * @author Oliver Gay - * @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 - * 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 -#include -#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; -} diff --git a/libethereum/sha256.h b/libethereum/sha256.h deleted file mode 100644 index 68eec4e53..000000000 --- a/libethereum/sha256.h +++ /dev/null @@ -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 . -*/ -/** @file sha256.h - * @author Gav Wood - * @author Oliver Gay - * @date 2014 - * @note Modified from an original version with BSD licence. - */ - -#pragma once - -#include -#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); \ -} - -} - - diff --git a/libethereum/vector_ref.h b/libethereum/vector_ref.h index 61193c10d..3f05c0f1a 100644 --- a/libethereum/vector_ref.h +++ b/libethereum/vector_ref.h @@ -17,11 +17,10 @@ public: typedef _T element_type; vector_ref(): m_data(nullptr), m_count(0) {} - vector_ref(std::vector::type>* _data): m_data(_data->data()), m_count(_data->size()) {} vector_ref(_T* _data, unsigned _count): m_data(_data), m_count(_count) {} vector_ref(std::string* _data): m_data((_T*)_data->data()), m_count(_data->size() / sizeof(_T)) {} - vector_ref(std::vector::value, typename std::remove_const<_T>::type>::type> const* _data): m_data(_data->data()), m_count(_data->size()) {} - vector_ref(std::enable_if::value, std::string const&> _data): m_data((_T*)_data->data()), m_count(_data->size() / sizeof(_T)) {} + vector_ref(typename std::conditional::value, std::vector::type> const*, std::vector<_T>*>::type _data): m_data(_data->data()), m_count(_data->size()) {} + vector_ref(typename std::conditional::value, std::string const&, std::string&>::type _data): m_data((_T*)_data->data()), m_count(_data->size() / sizeof(_T)) {} vector_ref(leveldb::Slice const& _s): m_data(_s.data()), m_count(_s.size() / sizeof(_T)) {} explicit operator bool() const { return m_data && m_count; }