sikkienl/dash
1
0
Fork 0
mirror of https://github.com/dashpay/dash.git synced 2024-12-24 11:32:46 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge 47972aab8c into dd96032e12

Browse Source
This commit is contained in:
PastaPastaPasta 2024-12-18 13:58:00 +00:00 committed by GitHub
commit 0a7e30a1f2
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 82 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/bls/bls.h
View File

@ -123,6 +123,14 @@ public:
cachedHash.SetNull();
}
std::array<uint8_t, SerSize> ToBytes(const bool specificLegacyScheme) const
{
if (!fValid) {
return std::array<uint8_t, SerSize>{};
}
return impl.SerializeToArray(specificLegacyScheme);
}
std::vector<uint8_t> ToByteVector(const bool specificLegacyScheme) const
{
if (!fValid) {
@ -131,9 +139,9 @@ public:
return impl.Serialize(specificLegacyScheme);
}
std::vector<uint8_t> ToByteVector() const
std::array<uint8_t, SerSize> ToBytes() const
{
return ToByteVector(bls::bls_legacy_scheme.load());
return ToBytes(bls::bls_legacy_scheme.load());
}
const uint256& GetHash() const
@ -167,7 +175,7 @@ public:
template <typename Stream>
inline void Serialize(Stream& s, const bool specificLegacyScheme) const
{
s.write(AsBytes(Span{ToByteVector(specificLegacyScheme).data(), SerSize}));
s.write(AsBytes(Span{ToBytes(specificLegacyScheme)}));
}
template <typename Stream>
@ -206,7 +214,7 @@ public:
inline bool CheckMalleable(Span<uint8_t> vecBytes, const bool specificLegacyScheme) const
{
if (memcmp(vecBytes.data(), ToByteVector(specificLegacyScheme).data(), SerSize)) {
if (memcmp(vecBytes.data(), ToBytes(specificLegacyScheme).data(), SerSize)) {
// TODO not sure if this is actually possible with the BLS libs. I'm assuming here that somewhere deep inside
// these libs masking might happen, so that 2 different binary representations could result in the same object
// representation
@ -222,7 +230,7 @@ public:
inline std::string ToString(const bool specificLegacyScheme) const
{
std::vector<uint8_t> buf = ToByteVector(specificLegacyScheme);
auto buf = ToBytes(specificLegacyScheme);
return HexStr(buf);
}
@ -245,10 +253,12 @@ struct CBLSIdImplicit : public uint256
memcpy(instance.begin(), buffer, sizeof(CBLSIdImplicit));
return instance;
}
[[nodiscard]] std::vector<uint8_t> Serialize(const bool fLegacy) const
[[nodiscard]] std::vector<uint8_t> SerializeToVec(const bool fLegacy) const
{
return {begin(), end()};
}
[[nodiscard]] std::array<uint8_t, WIDTH> Serialize(const bool fLegacy) const { return m_data; }
[[nodiscard]] std::array<uint8_t, WIDTH> SerializeToArray(const bool fLegacy) const { return Serialize(fLegacy); }
};
class CBLSId : public CBLSWrapper<CBLSIdImplicit, BLS_CURVE_ID_SIZE, CBLSId>
@ -381,7 +391,7 @@ class CBLSLazyWrapper
private:
mutable std::mutex mutex;
mutable std::vector<uint8_t> vecBytes;
mutable std::array<uint8_t, BLSObject::SerSize> vecBytes{};
mutable bool bufValid{false};
mutable bool bufLegacyScheme{true};
@ -392,7 +402,6 @@ private:
public:
CBLSLazyWrapper() :
vecBytes(BLSObject::SerSize, 0),
bufLegacyScheme(bls::bls_legacy_scheme.load())
{}
@ -410,7 +419,6 @@ public:
if (r.bufValid) {
vecBytes = r.vecBytes;
} else {
vecBytes.resize(BLSObject::SerSize);
std::fill(vecBytes.begin(), vecBytes.end(), 0);
}
objInitialized = r.objInitialized;
@ -433,10 +441,9 @@ public:
{
std::unique_lock<std::mutex> l(mutex);
if (!objInitialized && !bufValid) {
vecBytes.resize(BLSObject::SerSize);
std::fill(vecBytes.begin(), vecBytes.end(), 0);
} else if (!bufValid || (bufLegacyScheme != specificLegacyScheme)) {
vecBytes = obj.ToByteVector(specificLegacyScheme);
vecBytes = obj.ToBytes(specificLegacyScheme);
bufValid = true;
bufLegacyScheme = specificLegacyScheme;
hash.SetNull();
@ -518,11 +525,10 @@ public:
{
std::unique_lock<std::mutex> l(mutex);
if (!objInitialized && !bufValid) {
vecBytes.resize(BLSObject::SerSize);
std::fill(vecBytes.begin(), vecBytes.end(), 0);
hash.SetNull();
} else if (!bufValid) {
vecBytes = obj.ToByteVector(bufLegacyScheme);
vecBytes = obj.ToBytes(bufLegacyScheme);
bufValid = true;
hash.SetNull();
}

15
src/bls/bls_ies.cpp
View File

@ -49,8 +49,7 @@ bool CBLSIESEncryptedBlob::Encrypt(size_t idx, const CBLSPublicKey& peerPubKey,
return false;
}
std::vector<unsigned char> symKey = pk.ToByteVector();
symKey.resize(32);
auto symKey = pk.ToBytes();
uint256 iv = GetIV(idx);
return EncryptBlob(plainTextData, dataSize, data, symKey.data(), iv.begin());
@ -63,10 +62,9 @@ bool CBLSIESEncryptedBlob::Decrypt(size_t idx, const CBLSSecretKey& secretKey, C
return false;
}
std::vector<unsigned char> symKey = pk.ToByteVector();
symKey.resize(32);
uint256 iv = GetIV(idx);
auto symKey = pk.ToBytes();
return DecryptBlob(data.data(), data.size(), decryptedDataRet, symKey.data(), iv.begin());
}
@ -117,8 +115,7 @@ bool CBLSIESMultiRecipientBlobs::Encrypt(size_t idx, const CBLSPublicKey& recipi
return false;
}
std::vector<uint8_t> symKey = pk.ToByteVector();
symKey.resize(32);
auto symKey = pk.ToBytes();
return EncryptBlob(blob.data(), blob.size(), blobs[idx], symKey.data(), ivVector[idx].begin());
}
@ -134,13 +131,11 @@ bool CBLSIESMultiRecipientBlobs::Decrypt(size_t idx, const CBLSSecretKey& sk, Bl
return false;
}
std::vector<uint8_t> symKey = pk.ToByteVector();
symKey.resize(32);
uint256 iv = ivSeed;
for (size_t i = 0; i < idx; i++) {
iv = ::SerializeHash(iv);
}
auto symKey = pk.ToBytes();
return DecryptBlob(blobs[idx].data(), blobs[idx].size(), blobRet, symKey.data(), iv.begin());
}

4
src/coinjoin/coinjoin.cpp
View File

@ -55,7 +55,7 @@ bool CCoinJoinQueue::Sign(const CActiveMasternodeManager& mn_activeman)
if (!sig.IsValid()) {
return false;
}
vchSig = sig.ToByteVector(false);
vchSig = sig.ToBytes(false);
return true;
}
@ -94,7 +94,7 @@ bool CCoinJoinBroadcastTx::Sign(const CActiveMasternodeManager& mn_activeman)
if (!sig.IsValid()) {
return false;
}
vchSig = sig.ToByteVector(false);
vchSig = sig.ToBytes(false);
return true;
}

5
src/coinjoin/coinjoin.h
View File

@ -7,6 +7,7 @@
#include <coinjoin/common.h>
#include <bls/bls.h>
#include <core_io.h>
#include <netaddress.h>
#include <primitives/block.h>
@ -183,7 +184,7 @@ public:
uint256 m_protxHash;
int64_t nTime{0};
bool fReady{false}; //ready for submit
std::vector<unsigned char> vchSig;
std::array<unsigned char, BLS_CURVE_SIG_SIZE> vchSig;
// memory only
bool fTried{false};
@ -243,7 +244,7 @@ public:
CTransactionRef tx;
COutPoint masternodeOutpoint;
uint256 m_protxHash;
std::vector<unsigned char> vchSig;
std::array<unsigned char, BLS_CURVE_SIG_SIZE> vchSig;
int64_t sigTime{0};
CCoinJoinBroadcastTx() :
tx(MakeTransactionRef(CMutableTransaction{}))

4
src/llmq/dkgsession.cpp
View File

@ -1016,12 +1016,12 @@ void CDKGSession::SendCommitment(CDKGPendingMessages& pendingMessages, PeerManag
if (lieType == 3) {
const bool is_bls_legacy = bls::bls_legacy_scheme.load();
std::vector<uint8_t> buf = qc.sig.ToByteVector(is_bls_legacy);
auto buf = qc.sig.ToBytes(is_bls_legacy);
buf[5]++;
qc.sig.SetByteVector(buf, is_bls_legacy);
} else if (lieType == 4) {
const bool is_bls_legacy = bls::bls_legacy_scheme.load();
std::vector<uint8_t> buf = qc.quorumSig.ToByteVector(is_bls_legacy);
auto buf = qc.quorumSig.ToBytes(is_bls_legacy);
buf[5]++;
qc.quorumSig.SetByteVector(buf, is_bls_legacy);
}

51
src/serialize.h
View File

@ -820,6 +820,9 @@ template<typename Stream, unsigned int N, typename T> inline void Unserialize(St
template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v);
template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v);
template <typename Stream, typename T, std::size_t N> void Serialize(Stream& os, const std::array<T, N>& a);
template <typename Stream, typename T, std::size_t N> void Unserialize(Stream& is, std::array<T, N>& a);
/**
* pair
*/
@ -1051,6 +1054,54 @@ void Unserialize(Stream& is, std::vector<T, A>& v)
}
}
/**
* array
*/
template <typename Stream, typename T, std::size_t N>
void Serialize(Stream& os, const std::array<T, N>& a)
{
if constexpr (std::is_same_v<T, unsigned char>) {
// Directly write the byte data without writing the size
if (!a.empty()) {
os.write(MakeByteSpan(a));
}
}
else if constexpr (std::is_same_v<T, bool>) {
// Serialize each bool individually
for (const bool& elem : a) {
::Serialize(os, elem);
}
}
else {
// Serialize each element using the default Serialize function
for (const T& elem : a) {
::Serialize(os, elem);
}
}
}
template <typename Stream, typename T, std::size_t N>
void Unserialize(Stream& is, std::array<T, N>& a)
{
if constexpr (std::is_same_v<T, unsigned char>) {
// Directly read the byte data without reading the size
if (N > 0) {
is.read(AsWritableBytes(Span{a}));
}
}
else if constexpr (std::is_same_v<T, bool>) {
// Unserialize each bool individually
for (bool& elem : a) {
::Unserialize(is, elem);
}
}
else {
// Unserialize each element using the default Unserialize function
for (T& elem : a) {
::Unserialize(is, elem);
}
}
}
/**
* pair