LCOV - code coverage report
Current view: top level - src/test - pmt_tests.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 98.4 % 64 63
Test Date: 2024-11-04 05:10:19 Functions: 100.0 % 5 5
Branches: 54.4 % 204 111

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2012-2022 The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <consensus/merkle.h>
       6                 :             : #include <merkleblock.h>
       7                 :             : #include <serialize.h>
       8                 :             : #include <streams.h>
       9                 :             : #include <test/util/random.h>
      10                 :             : #include <test/util/setup_common.h>
      11                 :             : #include <uint256.h>
      12                 :             : 
      13                 :             : #include <vector>
      14                 :             : 
      15                 :             : #include <boost/test/unit_test.hpp>
      16                 :             : 
      17                 :           0 : class CPartialMerkleTreeTester : public CPartialMerkleTree
      18                 :             : {
      19                 :             : public:
      20                 :         336 :     CPartialMerkleTreeTester(FastRandomContext& rng) : m_rng{rng} {}
      21                 :             : 
      22                 :             :     // flip one bit in one of the hashes - this should break the authentication
      23                 :         672 :     void Damage() {
      24                 :         672 :         unsigned int n = m_rng.randrange(vHash.size());
      25                 :         672 :         int bit = m_rng.randbits(8);
      26                 :         672 :         *(vHash[n].begin() + (bit>>3)) ^= 1<<(bit&7);
      27                 :         672 :     }
      28                 :             : 
      29                 :             :     FastRandomContext& m_rng;
      30                 :             : };
      31                 :             : 
      32                 :             : BOOST_FIXTURE_TEST_SUITE(pmt_tests, BasicTestingSetup)
      33                 :             : 
      34   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(pmt_test1)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
      35                 :             : {
      36                 :           1 :     static const unsigned int tx_counts[] = {1, 4, 7, 17, 56, 100, 127, 256, 312, 513, 1000, 4095};
      37                 :             : 
      38         [ +  + ]:          13 :     for (int i = 0; i < 12; i++) {
      39                 :          12 :         unsigned int nTx = tx_counts[i];
      40                 :             : 
      41                 :             :         // build a block with some dummy transactions
      42                 :          12 :         CBlock block;
      43         [ +  + ]:        6500 :         for (unsigned int j=0; j<nTx; j++) {
      44         [ +  - ]:        6488 :             CMutableTransaction tx;
      45                 :        6488 :             tx.nLockTime = j; // actual transaction data doesn't matter; just make the nLockTime's unique
      46   [ +  -  +  -  :       12976 :             block.vtx.push_back(MakeTransactionRef(std::move(tx)));
                   -  + ]
      47                 :        6488 :         }
      48                 :             : 
      49                 :             :         // calculate actual merkle root and height
      50         [ +  - ]:          12 :         uint256 merkleRoot1 = BlockMerkleRoot(block);
      51         [ +  - ]:          12 :         std::vector<uint256> vTxid(nTx, uint256());
      52         [ +  + ]:        6500 :         for (unsigned int j=0; j<nTx; j++)
      53                 :        6488 :             vTxid[j] = block.vtx[j]->GetHash();
      54                 :          12 :         int nHeight = 1, nTx_ = nTx;
      55         [ +  + ]:          91 :         while (nTx_ > 1) {
      56                 :          79 :             nTx_ = (nTx_+1)/2;
      57                 :          79 :             nHeight++;
      58                 :             :         }
      59                 :             : 
      60                 :             :         // check with random subsets with inclusion chances 1, 1/2, 1/4, ..., 1/128
      61         [ +  + ]:         180 :         for (int att = 1; att < 15; att++) {
      62                 :             :             // build random subset of txid's
      63         [ +  - ]:         168 :             std::vector<bool> vMatch(nTx, false);
      64                 :         168 :             std::vector<uint256> vMatchTxid1;
      65         [ +  + ]:       91000 :             for (unsigned int j=0; j<nTx; j++) {
      66                 :       90832 :                 bool fInclude = m_rng.randbits(att / 2) == 0;
      67                 :       90832 :                 vMatch[j] = fInclude;
      68         [ +  + ]:       90832 :                 if (fInclude)
      69         [ +  - ]:       19389 :                     vMatchTxid1.push_back(vTxid[j]);
      70                 :             :             }
      71                 :             : 
      72                 :             :             // build the partial merkle tree
      73         [ +  - ]:         168 :             CPartialMerkleTree pmt1(vTxid, vMatch);
      74                 :             : 
      75                 :             :             // serialize
      76                 :         168 :             DataStream ss{};
      77         [ +  - ]:         168 :             ss << pmt1;
      78                 :             : 
      79                 :             :             // verify CPartialMerkleTree's size guarantees
      80         [ +  + ]:         168 :             unsigned int n = std::min<unsigned int>(nTx, 1 + vMatchTxid1.size()*nHeight);
      81   [ +  -  +  -  :         336 :             BOOST_CHECK(ss.size() <= 10 + (258*n+7)/8);
                   +  - ]
      82                 :             : 
      83                 :             :             // deserialize into a tester copy
      84         [ +  - ]:         168 :             CPartialMerkleTreeTester pmt2{m_rng};
      85         [ +  - ]:         168 :             ss >> pmt2;
      86                 :             : 
      87                 :             :             // extract merkle root and matched txids from copy
      88                 :         168 :             std::vector<uint256> vMatchTxid2;
      89                 :         168 :             std::vector<unsigned int> vIndex;
      90         [ +  - ]:         168 :             uint256 merkleRoot2 = pmt2.ExtractMatches(vMatchTxid2, vIndex);
      91                 :             : 
      92                 :             :             // check that it has the same merkle root as the original, and a valid one
      93   [ +  -  +  -  :         336 :             BOOST_CHECK(merkleRoot1 == merkleRoot2);
                   +  - ]
      94   [ +  -  +  -  :         336 :             BOOST_CHECK(!merkleRoot2.IsNull());
                   +  - ]
      95                 :             : 
      96                 :             :             // check that it contains the matched transactions (in the same order!)
      97   [ +  -  +  - ]:         336 :             BOOST_CHECK(vMatchTxid1 == vMatchTxid2);
      98                 :             : 
      99                 :             :             // check that random bit flips break the authentication
     100         [ +  + ]:         840 :             for (int j=0; j<4; j++) {
     101         [ +  - ]:         672 :                 CPartialMerkleTreeTester pmt3(pmt2);
     102                 :         672 :                 pmt3.Damage();
     103                 :         672 :                 std::vector<uint256> vMatchTxid3;
     104         [ +  - ]:         672 :                 uint256 merkleRoot3 = pmt3.ExtractMatches(vMatchTxid3, vIndex);
     105   [ +  -  +  - ]:        1344 :                 BOOST_CHECK(merkleRoot3 != merkleRoot1);
     106                 :        1344 :             }
     107                 :         504 :         }
     108                 :          12 :     }
     109                 :           1 : }
     110                 :             : 
     111   [ +  -  +  -  :           7 : BOOST_AUTO_TEST_CASE(pmt_malleability)
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
                      - ]
     112                 :             : {
     113                 :           1 :     std::vector<uint256> vTxid{
     114                 :             :         uint256{1}, uint256{2},
     115                 :             :         uint256{3}, uint256{4},
     116                 :             :         uint256{5}, uint256{6},
     117                 :             :         uint256{7}, uint256{8},
     118                 :             :         uint256{9}, uint256{10},
     119                 :             :         uint256{9}, uint256{10},
     120                 :           1 :     };
     121         [ +  - ]:           1 :     std::vector<bool> vMatch = {false, false, false, false, false, false, false, false, false, true, true, false};
     122                 :             : 
     123         [ +  - ]:           1 :     CPartialMerkleTree tree(vTxid, vMatch);
     124                 :           1 :     std::vector<unsigned int> vIndex;
     125   [ +  -  +  -  :           2 :     BOOST_CHECK(tree.ExtractMatches(vTxid, vIndex).IsNull());
                   +  - ]
     126                 :           2 : }
     127                 :             : 
     128                 :             : BOOST_AUTO_TEST_SUITE_END()
        

Generated by: LCOV version 2.0-1