mirror of
https://github.com/bitcoin/bitcoin.git
synced 2025-04-13 06:39:48 +02:00
Merge #19326: Simplify hash.h interface using Spans
77c507358bda9bd6c496f33e0f4418c0603bb08d Make Hash[160] consume range-like objects (Pieter Wuille) 02c4cc5c5ddf61f98ee366a4bea8abc26de492bd Make CHash256/CHash160 output to Span (Pieter Wuille) 0ef97b1b103231db54e04a64bbdb5dcc3f34f482 Make MurmurHash3 consume Spans (Pieter Wuille) e549bf8a9afae42fcda805e216a1cde62df195a6 Make CHash256 and CHash160 consume Spans (Pieter Wuille) 2a2182c387f607cd8284f33890bd285a81077b7f Make script/standard's BaseHash Span-convertible (Pieter Wuille) e63dcc3a6752e7d406e7a650c2d6c2e95cd39aab Add MakeUCharSpan, to help constructing Span<[const] unsigned char> (Pieter Wuille) 567825049fb0e47e698dcaad9caa65693a6b42d3 Make uint256 Span-convertible by adding ::data() (Pieter Wuille) 131a2f0337f5c396739a47b60bb856ed84ec8937 scripted-diff: rename base_blob::data to m_data (Pieter Wuille) Pull request description: This makes use of the implicit constructions and conversions to Span introduced in #18468 to simplify the hash.h interface: * All functions that take a pointer and a length are changed to take a Span instead. * The Hash() and Hash160() functions are changed to take in "range" objects instead of begin/end iterators. ACKs for top commit: laanwj: re-ACK 77c507358bda9bd6c496f33e0f4418c0603bb08d jonatack: Code review re-ACK 77c5073 per `git range-diff 14ceddd 49fc016 77c5073` Tree-SHA512: 9ec929891b1ddcf30eb14b946ee1bf142eca1442b9de0067ad6a3c181e0c7ea0c99c0e291e7f6e7a18bd7bdf78fe94ee3d5de66e167401674caf91e026269771
This commit is contained in:
Wladimir J. van der Laan
commit
34eb236258
@ -141,7 +141,7 @@ std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
|
||||
{
|
||||
// add 4-byte hash check to the end
|
||||
std::vector<unsigned char> vch(vchIn);
|
||||
uint256 hash = Hash(vch.begin(), vch.end());
|
||||
uint256 hash = Hash(vch);
|
||||
vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
|
||||
return EncodeBase58(vch);
|
||||
}
|
||||
@ -154,7 +154,7 @@ bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet, int
|
||||
return false;
|
||||
}
|
||||
// re-calculate the checksum, ensure it matches the included 4-byte checksum
|
||||
uint256 hash = Hash(vchRet.begin(), vchRet.end() - 4);
|
||||
uint256 hash = Hash(MakeSpan(vchRet).first(vchRet.size() - 4));
|
||||
if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {
|
||||
vchRet.clear();
|
||||
return false;
|
||||
|
||||
@ -93,7 +93,7 @@ static void HASH(benchmark::Bench& bench, size_t buffersize)
|
||||
uint8_t hash[CHash256::OUTPUT_SIZE];
|
||||
std::vector<uint8_t> in(buffersize,0);
|
||||
bench.batch(in.size()).unit("byte").run([&] {
|
||||
CHash256().Write(in.data(), in.size()).Finalize(hash);
|
||||
CHash256().Write(in).Finalize(hash);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@ -34,7 +34,7 @@ static void VerifyScriptBench(benchmark::Bench& bench)
|
||||
key.Set(vchKey.begin(), vchKey.end(), false);
|
||||
CPubKey pubkey = key.GetPubKey();
|
||||
uint160 pubkeyHash;
|
||||
CHash160().Write(pubkey.begin(), pubkey.size()).Finalize(pubkeyHash.begin());
|
||||
CHash160().Write(pubkey).Finalize(pubkeyHash);
|
||||
|
||||
// Script.
|
||||
CScript scriptPubKey = CScript() << witnessversion << ToByteVector(pubkeyHash);
|
||||
|
||||
@ -291,7 +291,7 @@ uint256 BlockFilter::GetHash() const
|
||||
const std::vector<unsigned char>& data = GetEncodedFilter();
|
||||
|
||||
uint256 result;
|
||||
CHash256().Write(data.data(), data.size()).Finalize(result.begin());
|
||||
CHash256().Write(data).Finalize(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -301,8 +301,8 @@ uint256 BlockFilter::ComputeHeader(const uint256& prev_header) const
|
||||
|
||||
uint256 result;
|
||||
CHash256()
|
||||
.Write(filter_hash.begin(), filter_hash.size())
|
||||
.Write(prev_header.begin(), prev_header.size())
|
||||
.Finalize(result.begin());
|
||||
.Write(filter_hash)
|
||||
.Write(prev_header)
|
||||
.Finalize(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -12,7 +12,7 @@ inline uint32_t ROTL32(uint32_t x, int8_t r)
|
||||
return (x << r) | (x >> (32 - r));
|
||||
}
|
||||
|
||||
unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash)
|
||||
unsigned int MurmurHash3(unsigned int nHashSeed, Span<const unsigned char> vDataToHash)
|
||||
{
|
||||
// The following is MurmurHash3 (x86_32), see http://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
|
||||
uint32_t h1 = nHashSeed;
|
||||
|
||||
59
src/hash.h
59
src/hash.h
@ -25,14 +25,15 @@ private:
|
||||
public:
|
||||
static const size_t OUTPUT_SIZE = CSHA256::OUTPUT_SIZE;
|
||||
|
||||
void Finalize(unsigned char hash[OUTPUT_SIZE]) {
|
||||
void Finalize(Span<unsigned char> output) {
|
||||
assert(output.size() == OUTPUT_SIZE);
|
||||
unsigned char buf[CSHA256::OUTPUT_SIZE];
|
||||
sha.Finalize(buf);
|
||||
sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
|
||||
sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
|
||||
}
|
||||
|
||||
CHash256& Write(const unsigned char *data, size_t len) {
|
||||
sha.Write(data, len);
|
||||
CHash256& Write(Span<const unsigned char> input) {
|
||||
sha.Write(input.data(), input.size());
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -49,14 +50,15 @@ private:
|
||||
public:
|
||||
static const size_t OUTPUT_SIZE = CRIPEMD160::OUTPUT_SIZE;
|
||||
|
||||
void Finalize(unsigned char hash[OUTPUT_SIZE]) {
|
||||
void Finalize(Span<unsigned char> output) {
|
||||
assert(output.size() == OUTPUT_SIZE);
|
||||
unsigned char buf[CSHA256::OUTPUT_SIZE];
|
||||
sha.Finalize(buf);
|
||||
CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(hash);
|
||||
CRIPEMD160().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data());
|
||||
}
|
||||
|
||||
CHash160& Write(const unsigned char *data, size_t len) {
|
||||
sha.Write(data, len);
|
||||
CHash160& Write(Span<const unsigned char> input) {
|
||||
sha.Write(input.data(), input.size());
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -67,52 +69,31 @@ public:
|
||||
};
|
||||
|
||||
/** Compute the 256-bit hash of an object. */
|
||||
template<typename T1>
|
||||
inline uint256 Hash(const T1 pbegin, const T1 pend)
|
||||
template<typename T>
|
||||
inline uint256 Hash(const T& in1)
|
||||
{
|
||||
static const unsigned char pblank[1] = {};
|
||||
uint256 result;
|
||||
CHash256().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
|
||||
.Finalize((unsigned char*)&result);
|
||||
CHash256().Write(MakeUCharSpan(in1)).Finalize(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Compute the 256-bit hash of the concatenation of two objects. */
|
||||
template<typename T1, typename T2>
|
||||
inline uint256 Hash(const T1 p1begin, const T1 p1end,
|
||||
const T2 p2begin, const T2 p2end) {
|
||||
static const unsigned char pblank[1] = {};
|
||||
inline uint256 Hash(const T1& in1, const T2& in2) {
|
||||
uint256 result;
|
||||
CHash256().Write(p1begin == p1end ? pblank : (const unsigned char*)&p1begin[0], (p1end - p1begin) * sizeof(p1begin[0]))
|
||||
.Write(p2begin == p2end ? pblank : (const unsigned char*)&p2begin[0], (p2end - p2begin) * sizeof(p2begin[0]))
|
||||
.Finalize((unsigned char*)&result);
|
||||
CHash256().Write(MakeUCharSpan(in1)).Write(MakeUCharSpan(in2)).Finalize(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Compute the 160-bit hash an object. */
|
||||
template<typename T1>
|
||||
inline uint160 Hash160(const T1 pbegin, const T1 pend)
|
||||
inline uint160 Hash160(const T1& in1)
|
||||
{
|
||||
static unsigned char pblank[1] = {};
|
||||
uint160 result;
|
||||
CHash160().Write(pbegin == pend ? pblank : (const unsigned char*)&pbegin[0], (pend - pbegin) * sizeof(pbegin[0]))
|
||||
.Finalize((unsigned char*)&result);
|
||||
CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Compute the 160-bit hash of a vector. */
|
||||
inline uint160 Hash160(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
return Hash160(vch.begin(), vch.end());
|
||||
}
|
||||
|
||||
/** Compute the 160-bit hash of a vector. */
|
||||
template<unsigned int N>
|
||||
inline uint160 Hash160(const prevector<N, unsigned char>& vch)
|
||||
{
|
||||
return Hash160(vch.begin(), vch.end());
|
||||
}
|
||||
|
||||
/** A writer stream (for serialization) that computes a 256-bit hash. */
|
||||
class CHashWriter
|
||||
{
|
||||
@ -129,13 +110,13 @@ public:
|
||||
int GetVersion() const { return nVersion; }
|
||||
|
||||
void write(const char *pch, size_t size) {
|
||||
ctx.Write((const unsigned char*)pch, size);
|
||||
ctx.Write({(const unsigned char*)pch, size});
|
||||
}
|
||||
|
||||
// invalidates the object
|
||||
uint256 GetHash() {
|
||||
uint256 result;
|
||||
ctx.Finalize((unsigned char*)&result);
|
||||
ctx.Finalize(result);
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -200,7 +181,7 @@ uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL
|
||||
return ss.GetHash();
|
||||
}
|
||||
|
||||
unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsigned char>& vDataToHash);
|
||||
unsigned int MurmurHash3(unsigned int nHashSeed, Span<const unsigned char> vDataToHash);
|
||||
|
||||
void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned char header, const unsigned char data[32], unsigned char output[64]);
|
||||
|
||||
|
||||
@ -237,7 +237,7 @@ bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
|
||||
std::string str = "Bitcoin key verification\n";
|
||||
GetRandBytes(rnd, sizeof(rnd));
|
||||
uint256 hash;
|
||||
CHash256().Write((unsigned char*)str.data(), str.size()).Write(rnd, sizeof(rnd)).Finalize(hash.begin());
|
||||
CHash256().Write(MakeUCharSpan(str)).Write(rnd).Finalize(hash);
|
||||
std::vector<unsigned char> vchSig;
|
||||
Sign(hash, vchSig);
|
||||
return pubkey.Verify(hash, vchSig);
|
||||
|
||||
@ -70,7 +70,7 @@ uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::ve
|
||||
else
|
||||
right = left;
|
||||
// combine subhashes
|
||||
return Hash(left.begin(), left.end(), right.begin(), right.end());
|
||||
return Hash(left, right);
|
||||
}
|
||||
}
|
||||
|
||||
@ -126,7 +126,7 @@ uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, uns
|
||||
right = left;
|
||||
}
|
||||
// and combine them before returning
|
||||
return Hash(left.begin(), left.end(), right.begin(), right.end());
|
||||
return Hash(left, right);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -685,7 +685,7 @@ int V1TransportDeserializer::readData(const char *pch, unsigned int nBytes)
|
||||
vRecv.resize(std::min(hdr.nMessageSize, nDataPos + nCopy + 256 * 1024));
|
||||
}
|
||||
|
||||
hasher.Write((const unsigned char*)pch, nCopy);
|
||||
hasher.Write({(const unsigned char*)pch, nCopy});
|
||||
memcpy(&vRecv[nDataPos], pch, nCopy);
|
||||
nDataPos += nCopy;
|
||||
|
||||
@ -696,7 +696,7 @@ const uint256& V1TransportDeserializer::GetMessageHash() const
|
||||
{
|
||||
assert(Complete());
|
||||
if (data_hash.IsNull())
|
||||
hasher.Finalize(data_hash.begin());
|
||||
hasher.Finalize(data_hash);
|
||||
return data_hash;
|
||||
}
|
||||
|
||||
@ -736,7 +736,7 @@ CNetMessage V1TransportDeserializer::GetMessage(const CMessageHeader::MessageSta
|
||||
|
||||
void V1TransportSerializer::prepareForTransport(CSerializedNetMsg& msg, std::vector<unsigned char>& header) {
|
||||
// create dbl-sha256 checksum
|
||||
uint256 hash = Hash(msg.data.begin(), msg.data.end());
|
||||
uint256 hash = Hash(msg.data);
|
||||
|
||||
// create header
|
||||
CMessageHeader hdr(Params().MessageStart(), msg.m_type.c_str(), msg.data.size());
|
||||
|
||||
@ -553,7 +553,7 @@ std::vector<unsigned char> CNetAddr::GetGroup(const std::vector<bool> &asmap) co
|
||||
|
||||
uint64_t CNetAddr::GetHash() const
|
||||
{
|
||||
uint256 hash = Hash(&ip[0], &ip[16]);
|
||||
uint256 hash = Hash(ip);
|
||||
uint64_t nRet;
|
||||
memcpy(&nRet, &hash, sizeof(nRet));
|
||||
return nRet;
|
||||
|
||||
@ -157,13 +157,13 @@ public:
|
||||
//! Get the KeyID of this public key (hash of its serialization)
|
||||
CKeyID GetID() const
|
||||
{
|
||||
return CKeyID(Hash160(vch, vch + size()));
|
||||
return CKeyID(Hash160(MakeSpan(vch).first(size())));
|
||||
}
|
||||
|
||||
//! Get the 256-bit hash of this public key.
|
||||
uint256 GetHash() const
|
||||
{
|
||||
return Hash(vch, vch + size());
|
||||
return Hash(MakeSpan(vch).first(size()));
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -601,7 +601,7 @@ static UniValue decodescript(const JSONRPCRequest& request)
|
||||
UniValue sr(UniValue::VOBJ);
|
||||
CScript segwitScr;
|
||||
if (which_type == TxoutType::PUBKEY) {
|
||||
segwitScr = GetScriptForDestination(WitnessV0KeyHash(Hash160(solutions_data[0].begin(), solutions_data[0].end())));
|
||||
segwitScr = GetScriptForDestination(WitnessV0KeyHash(Hash160(solutions_data[0])));
|
||||
} else if (which_type == TxoutType::PUBKEYHASH) {
|
||||
segwitScr = GetScriptForDestination(WitnessV0KeyHash(uint160{solutions_data[0]}));
|
||||
} else {
|
||||
|
||||
@ -986,9 +986,9 @@ bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript&
|
||||
else if (opcode == OP_SHA256)
|
||||
CSHA256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
|
||||
else if (opcode == OP_HASH160)
|
||||
CHash160().Write(vch.data(), vch.size()).Finalize(vchHash.data());
|
||||
CHash160().Write(vch).Finalize(vchHash);
|
||||
else if (opcode == OP_HASH256)
|
||||
CHash256().Write(vch.data(), vch.size()).Finalize(vchHash.data());
|
||||
CHash256().Write(vch).Finalize(vchHash);
|
||||
popstack(stack);
|
||||
stack.push_back(vchHash);
|
||||
}
|
||||
|
||||
@ -16,10 +16,10 @@ typedef std::vector<unsigned char> valtype;
|
||||
bool fAcceptDatacarrier = DEFAULT_ACCEPT_DATACARRIER;
|
||||
unsigned nMaxDatacarrierBytes = MAX_OP_RETURN_RELAY;
|
||||
|
||||
CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in.begin(), in.end())) {}
|
||||
CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
|
||||
CScriptID::CScriptID(const ScriptHash& in) : BaseHash(static_cast<uint160>(in)) {}
|
||||
|
||||
ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in.begin(), in.end())) {}
|
||||
ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
|
||||
ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
|
||||
|
||||
PKHash::PKHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
|
||||
@ -318,7 +318,7 @@ CScript GetScriptForWitness(const CScript& redeemscript)
|
||||
std::vector<std::vector<unsigned char> > vSolutions;
|
||||
TxoutType typ = Solver(redeemscript, vSolutions);
|
||||
if (typ == TxoutType::PUBKEY) {
|
||||
return GetScriptForDestination(WitnessV0KeyHash(Hash160(vSolutions[0].begin(), vSolutions[0].end())));
|
||||
return GetScriptForDestination(WitnessV0KeyHash(Hash160(vSolutions[0])));
|
||||
} else if (typ == TxoutType::PUBKEYHASH) {
|
||||
return GetScriptForDestination(WitnessV0KeyHash(uint160{vSolutions[0]}));
|
||||
}
|
||||
|
||||
@ -79,6 +79,9 @@ public:
|
||||
{
|
||||
return m_hash.size();
|
||||
}
|
||||
|
||||
unsigned char* data() { return m_hash.data(); }
|
||||
const unsigned char* data() const { return m_hash.data(); }
|
||||
};
|
||||
|
||||
/** A reference to a CScript: the Hash160 of its serialization (see script.h) */
|
||||
|
||||
12
src/span.h
12
src/span.h
@ -207,4 +207,16 @@ T& SpanPopBack(Span<T>& span)
|
||||
return back;
|
||||
}
|
||||
|
||||
// Helper functions to safely cast to unsigned char pointers.
|
||||
inline unsigned char* UCharCast(char* c) { return (unsigned char*)c; }
|
||||
inline unsigned char* UCharCast(unsigned char* c) { return c; }
|
||||
inline const unsigned char* UCharCast(const char* c) { return (unsigned char*)c; }
|
||||
inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
|
||||
|
||||
// Helper function to safely convert a Span to a Span<[const] unsigned char>.
|
||||
template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
|
||||
|
||||
/** Like MakeSpan, but for (const) unsigned char member types only. Only works for (un)signed char containers. */
|
||||
template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(MakeSpan(std::forward<V>(v)))) { return UCharSpanCast(MakeSpan(std::forward<V>(v))); }
|
||||
|
||||
#endif
|
||||
|
||||
@ -743,7 +743,7 @@ BOOST_AUTO_TEST_CASE(sha256d64)
|
||||
in[j] = InsecureRandBits(8);
|
||||
}
|
||||
for (int j = 0; j < i; ++j) {
|
||||
CHash256().Write(in + 64 * j, 64).Finalize(out1 + 32 * j);
|
||||
CHash256().Write({in + 64 * j, 64}).Finalize({out1 + 32 * j, 32});
|
||||
}
|
||||
SHA256D64(out2, in, i);
|
||||
BOOST_CHECK(memcmp(out1, out2, 32 * i) == 0);
|
||||
|
||||
@ -44,8 +44,8 @@ void test_one_input(const std::vector<uint8_t>& buffer)
|
||||
}
|
||||
}
|
||||
|
||||
(void)hash160.Write(data.data(), data.size());
|
||||
(void)hash256.Write(data.data(), data.size());
|
||||
(void)hash160.Write(data);
|
||||
(void)hash256.Write(data);
|
||||
(void)hmac_sha256.Write(data.data(), data.size());
|
||||
(void)hmac_sha512.Write(data.data(), data.size());
|
||||
(void)ripemd160.Write(data.data(), data.size());
|
||||
@ -54,9 +54,8 @@ void test_one_input(const std::vector<uint8_t>& buffer)
|
||||
(void)sha512.Write(data.data(), data.size());
|
||||
(void)sip_hasher.Write(data.data(), data.size());
|
||||
|
||||
(void)Hash(data.begin(), data.end());
|
||||
(void)Hash(data);
|
||||
(void)Hash160(data);
|
||||
(void)Hash160(data.begin(), data.end());
|
||||
(void)sha512.Size();
|
||||
break;
|
||||
}
|
||||
@ -73,12 +72,12 @@ void test_one_input(const std::vector<uint8_t>& buffer)
|
||||
switch (fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 8)) {
|
||||
case 0: {
|
||||
data.resize(CHash160::OUTPUT_SIZE);
|
||||
hash160.Finalize(data.data());
|
||||
hash160.Finalize(data);
|
||||
break;
|
||||
}
|
||||
case 1: {
|
||||
data.resize(CHash256::OUTPUT_SIZE);
|
||||
hash256.Finalize(data.data());
|
||||
hash256.Finalize(data);
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
|
||||
@ -85,7 +85,7 @@ void test_one_input(const std::vector<uint8_t>& buffer)
|
||||
assert(negated_key == key);
|
||||
}
|
||||
|
||||
const uint256 random_uint256 = Hash(buffer.begin(), buffer.end());
|
||||
const uint256 random_uint256 = Hash(buffer);
|
||||
|
||||
{
|
||||
CKey child_key;
|
||||
|
||||
@ -77,7 +77,7 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
||||
for (int n=0; n<16; n++)
|
||||
{
|
||||
std::string strMsg = strprintf("Very secret message %i: 11", n);
|
||||
uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
|
||||
uint256 hashMsg = Hash(strMsg);
|
||||
|
||||
// normal signatures
|
||||
|
||||
@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
||||
|
||||
std::vector<unsigned char> detsig, detsigc;
|
||||
std::string strMsg = "Very deterministic message";
|
||||
uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
|
||||
uint256 hashMsg = Hash(strMsg);
|
||||
BOOST_CHECK(key1.Sign(hashMsg, detsig));
|
||||
BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
|
||||
BOOST_CHECK(detsig == detsigc);
|
||||
@ -158,7 +158,7 @@ BOOST_AUTO_TEST_CASE(key_signature_tests)
|
||||
// When entropy is specified, we should see at least one high R signature within 20 signatures
|
||||
CKey key = DecodeSecret(strSecret1);
|
||||
std::string msg = "A message to be signed";
|
||||
uint256 msg_hash = Hash(msg.begin(), msg.end());
|
||||
uint256 msg_hash = Hash(msg);
|
||||
std::vector<unsigned char> sig;
|
||||
bool found = false;
|
||||
|
||||
@ -179,7 +179,7 @@ BOOST_AUTO_TEST_CASE(key_signature_tests)
|
||||
for (int i = 0; i < 256; ++i) {
|
||||
sig.clear();
|
||||
std::string msg = "A message to be signed" + ToString(i);
|
||||
msg_hash = Hash(msg.begin(), msg.end());
|
||||
msg_hash = Hash(msg);
|
||||
BOOST_CHECK(key.Sign(msg_hash, sig));
|
||||
found = sig[3] == 0x20;
|
||||
BOOST_CHECK(sig.size() <= 70);
|
||||
@ -196,7 +196,7 @@ BOOST_AUTO_TEST_CASE(key_key_negation)
|
||||
std::string str = "Bitcoin key verification\n";
|
||||
GetRandBytes(rnd, sizeof(rnd));
|
||||
uint256 hash;
|
||||
CHash256().Write((unsigned char*)str.data(), str.size()).Write(rnd, sizeof(rnd)).Finalize(hash.begin());
|
||||
CHash256().Write(MakeUCharSpan(str)).Write(rnd).Finalize(hash);
|
||||
|
||||
// import the static test key
|
||||
CKey key = DecodeSecret(strSecret1C);
|
||||
|
||||
@ -13,9 +13,9 @@ static uint256 ComputeMerkleRootFromBranch(const uint256& leaf, const std::vecto
|
||||
uint256 hash = leaf;
|
||||
for (std::vector<uint256>::const_iterator it = vMerkleBranch.begin(); it != vMerkleBranch.end(); ++it) {
|
||||
if (nIndex & 1) {
|
||||
hash = Hash(it->begin(), it->end(), hash.begin(), hash.end());
|
||||
hash = Hash(*it, hash);
|
||||
} else {
|
||||
hash = Hash(hash.begin(), hash.end(), it->begin(), it->end());
|
||||
hash = Hash(hash, *it);
|
||||
}
|
||||
nIndex >>= 1;
|
||||
}
|
||||
@ -60,7 +60,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot
|
||||
}
|
||||
}
|
||||
mutated |= (inner[level] == h);
|
||||
CHash256().Write(inner[level].begin(), 32).Write(h.begin(), 32).Finalize(h.begin());
|
||||
CHash256().Write(inner[level]).Write(h).Finalize(h);
|
||||
}
|
||||
// Store the resulting hash at inner position level.
|
||||
inner[level] = h;
|
||||
@ -86,7 +86,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot
|
||||
if (pbranch && matchh) {
|
||||
pbranch->push_back(h);
|
||||
}
|
||||
CHash256().Write(h.begin(), 32).Write(h.begin(), 32).Finalize(h.begin());
|
||||
CHash256().Write(h).Write(h).Finalize(h);
|
||||
// Increment count to the value it would have if two entries at this
|
||||
// level had existed.
|
||||
count += (((uint32_t)1) << level);
|
||||
@ -101,7 +101,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot
|
||||
matchh = true;
|
||||
}
|
||||
}
|
||||
CHash256().Write(inner[level].begin(), 32).Write(h.begin(), 32).Finalize(h.begin());
|
||||
CHash256().Write(inner[level]).Write(h).Finalize(h);
|
||||
level++;
|
||||
}
|
||||
}
|
||||
@ -144,8 +144,7 @@ static uint256 BlockBuildMerkleTree(const CBlock& block, bool* fMutated, std::ve
|
||||
// Two identical hashes at the end of the list at a particular level.
|
||||
mutated = true;
|
||||
}
|
||||
vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(), vMerkleTree[j+i].end(),
|
||||
vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));
|
||||
vMerkleTree.push_back(Hash(vMerkleTree[j+i], vMerkleTree[j+i2]));
|
||||
}
|
||||
j += nSize;
|
||||
}
|
||||
|
||||
@ -216,7 +216,7 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
|
||||
s << OP_0 << ToByteVector(pubkey.GetID());
|
||||
BOOST_CHECK(ExtractDestination(s, address));
|
||||
WitnessV0KeyHash keyhash;
|
||||
CHash160().Write(pubkey.begin(), pubkey.size()).Finalize(keyhash.begin());
|
||||
CHash160().Write(pubkey).Finalize(keyhash);
|
||||
BOOST_CHECK(boost::get<WitnessV0KeyHash>(&address) && *boost::get<WitnessV0KeyHash>(&address) == keyhash);
|
||||
|
||||
// TxoutType::WITNESS_V0_SCRIPTHASH
|
||||
|
||||
@ -282,7 +282,7 @@ public:
|
||||
CScript scriptPubKey = script;
|
||||
if (wm == WitnessMode::PKH) {
|
||||
uint160 hash;
|
||||
CHash160().Write(&script[1], script.size() - 1).Finalize(hash.begin());
|
||||
CHash160().Write(MakeSpan(script).subspan(1)).Finalize(hash);
|
||||
script = CScript() << OP_DUP << OP_HASH160 << ToByteVector(hash) << OP_EQUALVERIFY << OP_CHECKSIG;
|
||||
scriptPubKey = CScript() << witnessversion << ToByteVector(hash);
|
||||
} else if (wm == WitnessMode::SH) {
|
||||
|
||||
@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE(floats)
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
ss << float(i);
|
||||
}
|
||||
BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c"));
|
||||
BOOST_CHECK(Hash(ss) == uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c"));
|
||||
|
||||
// decode
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
@ -162,7 +162,7 @@ BOOST_AUTO_TEST_CASE(doubles)
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
ss << double(i);
|
||||
}
|
||||
BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
|
||||
BOOST_CHECK(Hash(ss) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
|
||||
|
||||
// decode
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
|
||||
@ -228,7 +228,7 @@ BOOST_FIXTURE_TEST_CASE(Merge, MergeTestingSetup)
|
||||
if (OnlyHasDefaultSectionSetting(settings, network, name)) desc += " ignored";
|
||||
desc += "\n";
|
||||
|
||||
out_sha.Write((const unsigned char*)desc.data(), desc.size());
|
||||
out_sha.Write(MakeUCharSpan(desc));
|
||||
if (out_file) {
|
||||
BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
|
||||
}
|
||||
|
||||
@ -1009,7 +1009,7 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
|
||||
|
||||
desc += "\n";
|
||||
|
||||
out_sha.Write((const unsigned char*)desc.data(), desc.size());
|
||||
out_sha.Write(MakeUCharSpan(desc));
|
||||
if (out_file) {
|
||||
BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
|
||||
}
|
||||
@ -1112,7 +1112,7 @@ BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup)
|
||||
}
|
||||
desc += "\n";
|
||||
|
||||
out_sha.Write((const unsigned char*)desc.data(), desc.size());
|
||||
out_sha.Write(MakeUCharSpan(desc));
|
||||
if (out_file) {
|
||||
BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
|
||||
}
|
||||
@ -2186,8 +2186,8 @@ BOOST_AUTO_TEST_CASE(message_hash)
|
||||
std::string(1, (char)unsigned_tx.length()) +
|
||||
unsigned_tx;
|
||||
|
||||
const uint256 signature_hash = Hash(unsigned_tx.begin(), unsigned_tx.end());
|
||||
const uint256 message_hash1 = Hash(prefixed_message.begin(), prefixed_message.end());
|
||||
const uint256 signature_hash = Hash(unsigned_tx);
|
||||
const uint256 message_hash1 = Hash(prefixed_message);
|
||||
const uint256 message_hash2 = MessageHash(unsigned_tx);
|
||||
|
||||
BOOST_CHECK_EQUAL(message_hash1, message_hash2);
|
||||
|
||||
@ -12,20 +12,20 @@
|
||||
template <unsigned int BITS>
|
||||
base_blob<BITS>::base_blob(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
assert(vch.size() == sizeof(data));
|
||||
memcpy(data, vch.data(), sizeof(data));
|
||||
assert(vch.size() == sizeof(m_data));
|
||||
memcpy(m_data, vch.data(), sizeof(m_data));
|
||||
}
|
||||
|
||||
template <unsigned int BITS>
|
||||
std::string base_blob<BITS>::GetHex() const
|
||||
{
|
||||
return HexStr(std::reverse_iterator<const uint8_t*>(data + sizeof(data)), std::reverse_iterator<const uint8_t*>(data));
|
||||
return HexStr(std::reverse_iterator<const uint8_t*>(m_data + sizeof(m_data)), std::reverse_iterator<const uint8_t*>(m_data));
|
||||
}
|
||||
|
||||
template <unsigned int BITS>
|
||||
void base_blob<BITS>::SetHex(const char* psz)
|
||||
{
|
||||
memset(data, 0, sizeof(data));
|
||||
memset(m_data, 0, sizeof(m_data));
|
||||
|
||||
// skip leading spaces
|
||||
while (IsSpace(*psz))
|
||||
@ -39,7 +39,7 @@ void base_blob<BITS>::SetHex(const char* psz)
|
||||
size_t digits = 0;
|
||||
while (::HexDigit(psz[digits]) != -1)
|
||||
digits++;
|
||||
unsigned char* p1 = (unsigned char*)data;
|
||||
unsigned char* p1 = (unsigned char*)m_data;
|
||||
unsigned char* pend = p1 + WIDTH;
|
||||
while (digits > 0 && p1 < pend) {
|
||||
*p1 = ::HexDigit(psz[--digits]);
|
||||
|
||||
@ -18,11 +18,11 @@ class base_blob
|
||||
{
|
||||
protected:
|
||||
static constexpr int WIDTH = BITS / 8;
|
||||
uint8_t data[WIDTH];
|
||||
uint8_t m_data[WIDTH];
|
||||
public:
|
||||
base_blob()
|
||||
{
|
||||
memset(data, 0, sizeof(data));
|
||||
memset(m_data, 0, sizeof(m_data));
|
||||
}
|
||||
|
||||
explicit base_blob(const std::vector<unsigned char>& vch);
|
||||
@ -30,17 +30,17 @@ public:
|
||||
bool IsNull() const
|
||||
{
|
||||
for (int i = 0; i < WIDTH; i++)
|
||||
if (data[i] != 0)
|
||||
if (m_data[i] != 0)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
void SetNull()
|
||||
{
|
||||
memset(data, 0, sizeof(data));
|
||||
memset(m_data, 0, sizeof(m_data));
|
||||
}
|
||||
|
||||
inline int Compare(const base_blob& other) const { return memcmp(data, other.data, sizeof(data)); }
|
||||
inline int Compare(const base_blob& other) const { return memcmp(m_data, other.m_data, sizeof(m_data)); }
|
||||
|
||||
friend inline bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
|
||||
friend inline bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
|
||||
@ -51,34 +51,37 @@ public:
|
||||
void SetHex(const std::string& str);
|
||||
std::string ToString() const;
|
||||
|
||||
const unsigned char* data() const { return m_data; }
|
||||
unsigned char* data() { return m_data; }
|
||||
|
||||
unsigned char* begin()
|
||||
{
|
||||
return &data[0];
|
||||
return &m_data[0];
|
||||
}
|
||||
|
||||
unsigned char* end()
|
||||
{
|
||||
return &data[WIDTH];
|
||||
return &m_data[WIDTH];
|
||||
}
|
||||
|
||||
const unsigned char* begin() const
|
||||
{
|
||||
return &data[0];
|
||||
return &m_data[0];
|
||||
}
|
||||
|
||||
const unsigned char* end() const
|
||||
{
|
||||
return &data[WIDTH];
|
||||
return &m_data[WIDTH];
|
||||
}
|
||||
|
||||
unsigned int size() const
|
||||
{
|
||||
return sizeof(data);
|
||||
return sizeof(m_data);
|
||||
}
|
||||
|
||||
uint64_t GetUint64(int pos) const
|
||||
{
|
||||
const uint8_t* ptr = data + pos * 8;
|
||||
const uint8_t* ptr = m_data + pos * 8;
|
||||
return ((uint64_t)ptr[0]) | \
|
||||
((uint64_t)ptr[1]) << 8 | \
|
||||
((uint64_t)ptr[2]) << 16 | \
|
||||
@ -92,13 +95,13 @@ public:
|
||||
template<typename Stream>
|
||||
void Serialize(Stream& s) const
|
||||
{
|
||||
s.write((char*)data, sizeof(data));
|
||||
s.write((char*)m_data, sizeof(m_data));
|
||||
}
|
||||
|
||||
template<typename Stream>
|
||||
void Unserialize(Stream& s)
|
||||
{
|
||||
s.read((char*)data, sizeof(data));
|
||||
s.read((char*)m_data, sizeof(m_data));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -3434,7 +3434,7 @@ std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBloc
|
||||
if (consensusParams.SegwitHeight != std::numeric_limits<int>::max()) {
|
||||
if (commitpos == -1) {
|
||||
uint256 witnessroot = BlockWitnessMerkleRoot(block, nullptr);
|
||||
CHash256().Write(witnessroot.begin(), 32).Write(ret.data(), 32).Finalize(witnessroot.begin());
|
||||
CHash256().Write(witnessroot).Write(ret).Finalize(witnessroot);
|
||||
CTxOut out;
|
||||
out.nValue = 0;
|
||||
out.scriptPubKey.resize(MINIMUM_WITNESS_COMMITMENT);
|
||||
@ -3579,7 +3579,7 @@ static bool ContextualCheckBlock(const CBlock& block, BlockValidationState& stat
|
||||
if (block.vtx[0]->vin[0].scriptWitness.stack.size() != 1 || block.vtx[0]->vin[0].scriptWitness.stack[0].size() != 32) {
|
||||
return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "bad-witness-nonce-size", strprintf("%s : invalid witness reserved value size", __func__));
|
||||
}
|
||||
CHash256().Write(hashWitness.begin(), 32).Write(&block.vtx[0]->vin[0].scriptWitness.stack[0][0], 32).Finalize(hashWitness.begin());
|
||||
CHash256().Write(hashWitness).Write(block.vtx[0]->vin[0].scriptWitness.stack[0]).Finalize(hashWitness);
|
||||
if (memcmp(hashWitness.begin(), &block.vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
|
||||
return state.Invalid(BlockValidationResult::BLOCK_MUTATED, "bad-witness-merkle-match", strprintf("%s : witness merkle commitment mismatch", __func__));
|
||||
}
|
||||
|
||||
@ -630,13 +630,13 @@ static size_t CalculateNestedKeyhashInputSize(bool use_max_sig)
|
||||
CPubKey pubkey = key.GetPubKey();
|
||||
|
||||
// Generate pubkey hash
|
||||
uint160 key_hash(Hash160(pubkey.begin(), pubkey.end()));
|
||||
uint160 key_hash(Hash160(pubkey));
|
||||
|
||||
// Create inner-script to enter into keystore. Key hash can't be 0...
|
||||
CScript inner_script = CScript() << OP_0 << std::vector<unsigned char>(key_hash.begin(), key_hash.end());
|
||||
|
||||
// Create outer P2SH script for the output
|
||||
uint160 script_id(Hash160(inner_script.begin(), inner_script.end()));
|
||||
uint160 script_id(Hash160(inner_script));
|
||||
CScript script_pubkey = CScript() << OP_HASH160 << std::vector<unsigned char>(script_id.begin(), script_id.end()) << OP_EQUAL;
|
||||
|
||||
// Add inner-script to key store and key to watchonly
|
||||
|
||||
@ -103,7 +103,7 @@ bool WalletBatch::WriteKey(const CPubKey& vchPubKey, const CPrivKey& vchPrivKey,
|
||||
vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
|
||||
vchKey.insert(vchKey.end(), vchPrivKey.begin(), vchPrivKey.end());
|
||||
|
||||
return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey.begin(), vchKey.end())), false);
|
||||
return WriteIC(std::make_pair(DBKeys::KEY, vchPubKey), std::make_pair(vchPrivKey, Hash(vchKey)), false);
|
||||
}
|
||||
|
||||
bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
|
||||
@ -115,7 +115,7 @@ bool WalletBatch::WriteCryptedKey(const CPubKey& vchPubKey,
|
||||
}
|
||||
|
||||
// Compute a checksum of the encrypted key
|
||||
uint256 checksum = Hash(vchCryptedSecret.begin(), vchCryptedSecret.end());
|
||||
uint256 checksum = Hash(vchCryptedSecret);
|
||||
|
||||
const auto key = std::make_pair(DBKeys::CRYPTED_KEY, vchPubKey);
|
||||
if (!WriteIC(key, std::make_pair(vchCryptedSecret, checksum), false)) {
|
||||
@ -209,7 +209,7 @@ bool WalletBatch::WriteDescriptorKey(const uint256& desc_id, const CPubKey& pubk
|
||||
key.insert(key.end(), pubkey.begin(), pubkey.end());
|
||||
key.insert(key.end(), privkey.begin(), privkey.end());
|
||||
|
||||
return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)), std::make_pair(privkey, Hash(key.begin(), key.end())), false);
|
||||
return WriteIC(std::make_pair(DBKeys::WALLETDESCRIPTORKEY, std::make_pair(desc_id, pubkey)), std::make_pair(privkey, Hash(key)), false);
|
||||
}
|
||||
|
||||
bool WalletBatch::WriteCryptedDescriptorKey(const uint256& desc_id, const CPubKey& pubkey, const std::vector<unsigned char>& secret)
|
||||
@ -365,7 +365,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
|
||||
vchKey.insert(vchKey.end(), vchPubKey.begin(), vchPubKey.end());
|
||||
vchKey.insert(vchKey.end(), pkey.begin(), pkey.end());
|
||||
|
||||
if (Hash(vchKey.begin(), vchKey.end()) != hash)
|
||||
if (Hash(vchKey) != hash)
|
||||
{
|
||||
strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
|
||||
return false;
|
||||
@ -414,7 +414,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
|
||||
if (!ssValue.eof()) {
|
||||
uint256 checksum;
|
||||
ssValue >> checksum;
|
||||
if ((checksum_valid = Hash(vchPrivKey.begin(), vchPrivKey.end()) != checksum)) {
|
||||
if ((checksum_valid = Hash(vchPrivKey) != checksum)) {
|
||||
strErr = "Error reading wallet database: Crypted key corrupt";
|
||||
return false;
|
||||
}
|
||||
@ -621,7 +621,7 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
|
||||
to_hash.insert(to_hash.end(), pubkey.begin(), pubkey.end());
|
||||
to_hash.insert(to_hash.end(), pkey.begin(), pkey.end());
|
||||
|
||||
if (Hash(to_hash.begin(), to_hash.end()) != hash)
|
||||
if (Hash(to_hash) != hash)
|
||||
{
|
||||
strErr = "Error reading wallet database: CPubKey/CPrivKey corrupt";
|
||||
return false;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user