Line data    Source code

       1             : // Copyright (c) 2018-2019 The Dash Core developers
       2             : // Copyright (c) 2021-2022 The PIVX Core developers
       3             : // Distributed under the MIT/X11 software license, see the accompanying
       4             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5             : 
       6             : #include "llmq/quorums_commitment.h"
       7             : 
       8             : #include "bls/key_io.h"
       9             : #include "chainparams.h"
      10             : #include "llmq/quorums_utils.h"
      11             : #include "logging.h"
      12             : 
      13             : 
      14             : namespace llmq
      15             : {
      16             : 
      17          91 : CFinalCommitment::CFinalCommitment(const Consensus::LLMQParams& params, const uint256& _quorumHash) :
      18          91 :         llmqType(params.type),
      19             :         quorumHash(_quorumHash),
      20          91 :         signers(params.size),
      21         364 :         validMembers(params.size)
      22             : {
      23          91 : }
      24             : 
      25         926 : bool CFinalCommitment::IsNull() const
      26             : {
      27         926 :     if (CountSigners() > 0 || CountValidMembers() > 0) {
      28          31 :         return false;
      29             :     }
      30             : 
      31         895 :     if (quorumPublicKey.IsValid() ||
      32       29535 :         !quorumVvecHash.IsNull() ||
      33        1790 :         membersSig.IsValid() ||
      34         895 :         quorumSig.IsValid()) {
      35           0 :         return false;
      36             :     }
      37             : 
      38             :     return true;
      39             : }
      40             : 
      41           0 : void CFinalCommitment::ToJson(UniValue& obj) const
      42             : {
      43           0 :     obj.setObject();
      44           0 :     obj.pushKV("version", (int)nVersion);
      45           0 :     obj.pushKV("llmqType", (int)llmqType);
      46           0 :     obj.pushKV("quorumHash", quorumHash.ToString());
      47           0 :     obj.pushKV("signersCount", CountSigners());
      48           0 :     obj.pushKV("signers", utils::ToHexStr(signers));
      49           0 :     obj.pushKV("validMembersCount", CountValidMembers());
      50           0 :     obj.pushKV("validMembers", utils::ToHexStr(validMembers));
      51           0 :     obj.pushKV("quorumPublicKey", bls::EncodePublic(Params(), quorumPublicKey));
      52           0 :     obj.pushKV("quorumVvecHash", quorumVvecHash.ToString());
      53           0 :     obj.pushKV("quorumSig", quorumSig.ToString());
      54           0 :     obj.pushKV("membersSig", membersSig.ToString());
      55           0 : }
      56             : 
      57             : template<typename... Args>
      58           1 : static bool errorFinalCommitment(const char* fmt, const Args&... args)
      59             : {
      60             :     try {
      61           1 :         LogPrint(BCLog::LLMQ, "Invalid Final Commitment -- %s\n", tfm::format(fmt, args...));
      62           0 :     } catch (tinyformat::format_error &e) {
      63           0 :         LogPrintf("Error (%s) while formatting message %s\n", std::string(e.what()), fmt);
      64             :     }
      65           1 :     return false;
      66             : }
      67             : 
      68          14 : bool CFinalCommitment::Verify(const std::vector<CBLSPublicKey>& allkeys, const Consensus::LLMQParams& params) const
      69             : {
      70          14 :     int count_validmembers = CountValidMembers();
      71          14 :     if (count_validmembers < params.minSize) {
      72           0 :         return errorFinalCommitment("valid members count (%d < %d)", count_validmembers, params.minSize);
      73             :     }
      74          14 :     int count_signers = CountSigners();
      75          14 :     if (count_signers < params.minSize) {
      76           0 :         return errorFinalCommitment("signers count (%d < %d)", count_signers, params.minSize);
      77             :     }
      78             : 
      79          14 :     if (!quorumPublicKey.IsValid()) {
      80           0 :         return errorFinalCommitment("public key");
      81             :     }
      82          28 :     if (quorumVvecHash.IsNull()) {
      83           0 :         return errorFinalCommitment("quorumVvecHash");
      84             :     }
      85          14 :     if (!membersSig.IsValid()) {
      86           0 :         return errorFinalCommitment("membersSig");
      87             :     }
      88          14 :     if (!quorumSig.IsValid()) {
      89           0 :         return errorFinalCommitment("quorumSig");
      90             :     }
      91             : 
      92          14 :     for (int i = allkeys.size(); i < params.size; i++) {
      93           0 :         if (validMembers[i]) {
      94           0 :             return errorFinalCommitment("validMembers bitset (bit %d should not be set)", i);
      95             :         }
      96           0 :         if (signers[i]) {
      97           0 :             return errorFinalCommitment("signers bitset (bit %d should not be set)", i);
      98             :         }
      99             :     }
     100             : 
     101             :     // check signatures
     102          14 :     uint256 commitmentHash = utils::BuildCommitmentHash(params.type, quorumHash, validMembers, quorumPublicKey, quorumVvecHash);
     103          28 :     std::vector<CBLSPublicKey> memberPubKeys;
     104          56 :     for (size_t i = 0; i < allkeys.size(); i++) {
     105          42 :         if (!signers[i]) {
     106           9 :             continue;
     107             :         }
     108          33 :         memberPubKeys.emplace_back(allkeys[i]);
     109             :     }
     110          14 :     if (!membersSig.VerifySecureAggregated(memberPubKeys, commitmentHash)) {
     111           1 :         return errorFinalCommitment("aggregated members signature");
     112             :     }
     113          13 :     if (!quorumSig.VerifyInsecure(quorumPublicKey, commitmentHash)) {
     114           0 :         return errorFinalCommitment("invalid quorum signature");
     115             :     }
     116             : 
     117             :     return true;
     118             : }
     119             : 
     120         744 : bool CFinalCommitment::VerifySizes(const Consensus::LLMQParams& params) const
     121             : {
     122         744 :     if ((int)signers.size() != params.size) {
     123           0 :         return errorFinalCommitment("signers size (%d != %d)", signers.size(), params.size);
     124             :     }
     125         744 :     if ((int)validMembers.size() != params.size) {
     126           0 :         return errorFinalCommitment("validMembers size (%d != %d)", validMembers.size(), params.size);
     127             :     }
     128             :     return true;
     129             : }
     130             : 
     131           0 : void LLMQCommPL::ToJson(UniValue& obj) const
     132             : {
     133           0 :     obj.setObject();
     134           0 :     obj.pushKV("version", (int)nVersion);
     135           0 :     obj.pushKV("height", (int)nHeight);
     136             : 
     137           0 :     UniValue qcObj;
     138           0 :     commitment.ToJson(qcObj);
     139           0 :     obj.pushKV("commitment", qcObj);
     140           0 : }
     141             : 
     142             : } // namespace llmq