mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 20:12:57 +01:00
8598a3fbb8
7d1fc66d91
chore: run `contrib/devtools/copyright_header.py update .` (UdjinM6)c2acde0f9b
chore: update copyright_header.py and BitPay copyright strings (UdjinM6) Pull request description: ## Issue being fixed or feature implemented A little bit of housekeeping ## What was done? ## How Has This Been Tested? ## Breaking Changes ## Checklist: - [ ] I have performed a self-review of my own code - [ ] I have commented my code, particularly in hard-to-understand areas - [ ] I have added or updated relevant unit/integration/functional/e2e tests - [ ] I have made corresponding changes to the documentation - [x] I have assigned this pull request to a milestone _(for repository code-owners and collaborators only)_ ACKs for top commit: PastaPastaPasta: utACK7d1fc66d91
Tree-SHA512: f62a15139d10d10c155deef70c218d8dd14bfe3648703c4af39c299fa56537c806e84bccb7e99159633dea02d6d145b64990874d6114cfecf2a4467c7ab2cd6d
245 lines
6.1 KiB
C++
245 lines
6.1 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2020 The Bitcoin Core developers
|
|
// Copyright (c) 2014-2024 The Dash Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_HASH_H
|
|
#define BITCOIN_HASH_H
|
|
|
|
#include <attributes.h>
|
|
#include <crypto/common.h>
|
|
#include <crypto/ripemd160.h>
|
|
#include <crypto/sha256.h>
|
|
#include <prevector.h>
|
|
#include <serialize.h>
|
|
#include <uint256.h>
|
|
#include <version.h>
|
|
|
|
#include <vector>
|
|
|
|
typedef uint256 ChainCode;
|
|
|
|
/* ----------- Bitcoin Hash ------------------------------------------------- */
|
|
/** A hasher class for Bitcoin's 256-bit hash (double SHA-256). */
|
|
class CHash256 {
|
|
private:
|
|
CSHA256 sha;
|
|
public:
|
|
static const size_t OUTPUT_SIZE = CSHA256::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(output.data());
|
|
}
|
|
|
|
CHash256& Write(Span<const unsigned char> input) {
|
|
sha.Write(input.data(), input.size());
|
|
return *this;
|
|
}
|
|
|
|
CHash256& Reset() {
|
|
sha.Reset();
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/** A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160). */
|
|
class CHash160 {
|
|
private:
|
|
CSHA256 sha;
|
|
public:
|
|
static const size_t OUTPUT_SIZE = CRIPEMD160::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(output.data());
|
|
}
|
|
|
|
CHash160& Write(Span<const unsigned char> input) {
|
|
sha.Write(input.data(), input.size());
|
|
return *this;
|
|
}
|
|
|
|
CHash160& Reset() {
|
|
sha.Reset();
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/** Compute the 256-bit hash of an object. */
|
|
template<typename T>
|
|
inline uint256 Hash(const T& in1)
|
|
{
|
|
uint256 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& in1, const T2& in2) {
|
|
uint256 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& in1)
|
|
{
|
|
uint160 result;
|
|
CHash160().Write(MakeUCharSpan(in1)).Finalize(result);
|
|
return result;
|
|
}
|
|
|
|
/** A writer stream (for serialization) that computes a 256-bit hash. */
|
|
class HashWriter
|
|
{
|
|
private:
|
|
CSHA256 ctx;
|
|
|
|
public:
|
|
void write(Span<const std::byte> src)
|
|
{
|
|
ctx.Write(UCharCast(src.data()), src.size());
|
|
}
|
|
|
|
/** Compute the double-SHA256 hash of all data written to this object.
|
|
*
|
|
* Invalidates this object.
|
|
*/
|
|
uint256 GetHash() {
|
|
uint256 result;
|
|
ctx.Finalize(result.begin());
|
|
ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin());
|
|
return result;
|
|
}
|
|
|
|
/** Compute the SHA256 hash of all data written to this object.
|
|
*
|
|
* Invalidates this object.
|
|
*/
|
|
uint256 GetSHA256() {
|
|
uint256 result;
|
|
ctx.Finalize(result.begin());
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns the first 64 bits from the resulting hash.
|
|
*/
|
|
inline uint64_t GetCheapHash() {
|
|
uint256 result = GetHash();
|
|
return ReadLE64(result.begin());
|
|
}
|
|
|
|
template <typename T>
|
|
HashWriter& operator<<(const T& obj)
|
|
{
|
|
::Serialize(*this, obj);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
class CHashWriter : public HashWriter
|
|
{
|
|
private:
|
|
const int nType;
|
|
const int nVersion;
|
|
|
|
public:
|
|
CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {}
|
|
|
|
int GetType() const { return nType; }
|
|
int GetVersion() const { return nVersion; }
|
|
|
|
template<typename T>
|
|
CHashWriter& operator<<(const T& obj) {
|
|
// Serialize to this stream
|
|
::Serialize(*this, obj);
|
|
return (*this);
|
|
}
|
|
};
|
|
|
|
/** Reads data from an underlying stream, while hashing the read data. */
|
|
template<typename Source>
|
|
class CHashVerifier : public CHashWriter
|
|
{
|
|
private:
|
|
Source* source;
|
|
|
|
public:
|
|
explicit CHashVerifier(Source* source_) : CHashWriter(source_->GetType(), source_->GetVersion()), source(source_) {}
|
|
|
|
void read(Span<std::byte> dst)
|
|
{
|
|
source->read(dst);
|
|
this->write(dst);
|
|
}
|
|
|
|
void ignore(size_t nSize)
|
|
{
|
|
std::byte data[1024];
|
|
while (nSize > 0) {
|
|
size_t now = std::min<size_t>(nSize, 1024);
|
|
read({data, now});
|
|
nSize -= now;
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
CHashVerifier<Source>& operator>>(T&& obj)
|
|
{
|
|
// Unserialize from this stream
|
|
::Unserialize(*this, obj);
|
|
return (*this);
|
|
}
|
|
};
|
|
|
|
/** Writes data to an underlying source stream, while hashing the written data. */
|
|
template <typename Source>
|
|
class HashedSourceWriter : public CHashWriter
|
|
{
|
|
private:
|
|
Source& m_source;
|
|
|
|
public:
|
|
explicit HashedSourceWriter(Source& source LIFETIMEBOUND) : CHashWriter{source.GetType(), source.GetVersion()}, m_source{source} {}
|
|
|
|
void write(Span<const std::byte> src)
|
|
{
|
|
m_source.write(src);
|
|
CHashWriter::write(src);
|
|
}
|
|
|
|
template <typename T>
|
|
HashedSourceWriter& operator<<(const T& obj)
|
|
{
|
|
::Serialize(*this, obj);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/** Compute the 256-bit hash of an object's serialization. */
|
|
template<typename T>
|
|
uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION)
|
|
{
|
|
CHashWriter ss(nType, nVersion);
|
|
ss << obj;
|
|
return ss.GetHash();
|
|
}
|
|
|
|
/** Single-SHA256 a 32-byte input (represented as uint256). */
|
|
[[nodiscard]] uint256 SHA256Uint256(const uint256& input);
|
|
|
|
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]);
|
|
|
|
#endif // BITCOIN_HASH_H
|