mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
4ee2114127
This commit is the culmination of several months of work to decouple Solidity from the webthree-umbrella so that it can be developed in parallel with cpp-ethereum (the Ethereum C++ runtime) and so that even for the Solidity unit-tests there is no hard-dependency onto the C++ runtime. The Tests-over-IPC refactoring was a major step in the same process which was already committed. This commit contains the following changes: - A subset of the CMake functionality in webthree-helpers was extracted and tailored for Solidity into ./cmake. Further cleanup is certainly possible. - A subset of the libdevcore functionality in libweb3core was extracted and tailored for Solidity into ./libdevcore. Further cleanup is certainly possible - The gas price constants in EVMSchedule were orphaned into libevmasm. - Some other refactorings and cleanups were made to sever unnecessary EVM dependencies in the Solidity unit-tests. - TravisCI and Appveyor support was added, covering builds and running of the unit-tests (Linux and macOS only for now) - A bug-fix was made to get the Tests-over-IPC running on macOS. - There are still reliability issues in the unit-tests, which need immediate attention. The Travis build has been flipped to run the unit-tests 5 times, to try to flush these out. - The Emscripten automation which was previously in webthree-umbrella was merged into the TravisCI automation here. - The development ZIP deployment step has been commented out, but we will want to read that ONLY for release branch. Further iteration on these changes will definitely be needed, but I feel these have got to sufficient maturity than holding them back further isn't winning us anything. It is go time :-)
224 lines
6.0 KiB
C++
224 lines
6.0 KiB
C++
/*
|
|
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 "picosha2.h"
|
|
using namespace std;
|
|
using namespace dev;
|
|
|
|
namespace dev
|
|
{
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
unsigned g_sha3Counter = 0;
|
|
|
|
bool sha3(bytesConstRef _input, bytesRef o_output)
|
|
{
|
|
// FIXME: What with unaligned memory?
|
|
if (o_output.size() != 32)
|
|
return false;
|
|
++g_sha3Counter;
|
|
keccak::sha3_256(o_output.data(), 32, _input.data(), _input.size());
|
|
// keccak::keccak(ret.data(), 32, (uint64_t const*)_input.data(), _input.size());
|
|
return true;
|
|
}
|
|
|
|
}
|