Make CHash256/CHash160 output to Span

sipa · sipa · commit 02c4cc5c5ddf · 2020-07-30T13:57:54.000-07:00
diff --git a/src/bench/verify_script.cpp b/src/bench/verify_script.cpp
@@ -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).Finalize(pubkeyHash.begin());
+    CHash160().Write(pubkey).Finalize(pubkeyHash);
 
     // Script.
     CScript scriptPubKey = CScript() << witnessversion << ToByteVector(pubkeyHash);
diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp
@@ -291,7 +291,7 @@ uint256 BlockFilter::GetHash() const
     const std::vector<unsigned char>& data = GetEncodedFilter();
 
     uint256 result;
-    CHash256().Write(data).Finalize(result.begin());
+    CHash256().Write(data).Finalize(result);
     return result;
 }
 
@@ -303,6 +303,6 @@ uint256 BlockFilter::ComputeHeader(const uint256& prev_header) const
     CHash256()
         .Write(filter_hash)
         .Write(prev_header)
-        .Finalize(result.begin());
+        .Finalize(result);
     return result;
 }
diff --git a/src/hash.h b/src/hash.h
@@ -25,10 +25,11 @@ class CHash256 {
 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(Span<const unsigned char> input) {
@@ -49,10 +50,11 @@ class CHash160 {
 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(Span<const unsigned char> input) {
@@ -73,7 +75,7 @@ inline uint256 Hash(const T1 pbegin, const T1 pend)
     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);
+              .Finalize(result);
     return result;
 }
 
@@ -85,7 +87,7 @@ inline uint256 Hash(const T1 p1begin, const T1 p1end,
     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);
+              .Finalize(result);
     return result;
 }
 
@@ -96,7 +98,7 @@ inline uint160 Hash160(const T1 pbegin, const T1 pend)
     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);
+              .Finalize(result);
     return result;
 }
 
@@ -135,7 +137,7 @@ class CHashWriter
     // invalidates the object
     uint256 GetHash() {
         uint256 result;
-        ctx.Finalize((unsigned char*)&result);
+        ctx.Finalize(result);
         return result;
     }
 
diff --git a/src/key.cpp b/src/key.cpp
@@ -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(MakeUCharSpan(str)).Write(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);
diff --git a/src/net.cpp b/src/net.cpp
@@ -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;
 }
 
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
@@ -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).Finalize(vchHash.data());
+                        CHash160().Write(vch).Finalize(vchHash);
                     else if (opcode == OP_HASH256)
-                        CHash256().Write(vch).Finalize(vchHash.data());
+                        CHash256().Write(vch).Finalize(vchHash);
                     popstack(stack);
                     stack.push_back(vchHash);
                 }
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
@@ -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);
diff --git a/src/test/fuzz/crypto.cpp b/src/test/fuzz/crypto.cpp
@@ -73,12 +73,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: {
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
@@ -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(MakeUCharSpan(str)).Write(rnd).Finalize(hash.begin());
+    CHash256().Write(MakeUCharSpan(str)).Write(rnd).Finalize(hash);
 
     // import the static test key
     CKey key = DecodeSecret(strSecret1C);
diff --git a/src/test/merkle_tests.cpp b/src/test/merkle_tests.cpp
@@ -60,7 +60,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot
                 }
             }
             mutated |= (inner[level] == h);
-            CHash256().Write(inner[level]).Write(h).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).Write(h).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]).Write(h).Finalize(h.begin());
+            CHash256().Write(inner[level]).Write(h).Finalize(h);
             level++;
         }
     }
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
@@ -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).Finalize(keyhash.begin());
+    CHash160().Write(pubkey).Finalize(keyhash);
     BOOST_CHECK(boost::get<WitnessV0KeyHash>(&address) && *boost::get<WitnessV0KeyHash>(&address) == keyhash);
 
     // TxoutType::WITNESS_V0_SCRIPTHASH
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
@@ -282,7 +282,7 @@ class TestBuilder
         CScript scriptPubKey = script;
         if (wm == WitnessMode::PKH) {
             uint160 hash;
-            CHash160().Write(MakeSpan(script).subspan(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) {
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -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).Write(ret).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).Write(block.vtx[0]->vin[0].scriptWitness.stack[0]).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__));
             }

Original file line number	Diff line number	Diff line change
`@@ -291,7 +291,7 @@ uint256 BlockFilter::GetHash() const`
`291`	`291`	`const std::vector<unsigned char>& data = GetEncodedFilter();`
`292`	`292`
`293`	`293`	`uint256 result;`
`294`		`- CHash256().Write(data).Finalize(result.begin());`
	`294`	`+ CHash256().Write(data).Finalize(result);`
`295`	`295`	`return result;`
`296`	`296`	`}`
`297`	`297`
`@@ -303,6 +303,6 @@ uint256 BlockFilter::ComputeHeader(const uint256& prev_header) const`
`303`	`303`	`CHash256()`
`304`	`304`	`.Write(filter_hash)`
`305`	`305`	`.Write(prev_header)`
`306`		`- .Finalize(result.begin());`
	`306`	`+ .Finalize(result);`
`307`	`307`	`return result;`
`308`	`308`	`}`
Original file line number	Diff line number	Diff line change
`@@ -696,7 +696,7 @@ const uint256& V1TransportDeserializer::GetMessageHash() const`
`696`	`696`	`{`
`697`	`697`	`assert(Complete());`
`698`	`698`	`if (data_hash.IsNull())`
`699`		`- hasher.Finalize(data_hash.begin());`
	`699`	`+ hasher.Finalize(data_hash);`
`700`	`700`	`return data_hash;`
`701`	`701`	`}`
`702`	`702`
Original file line number	Diff line number	Diff line change
`@@ -743,7 +743,7 @@ BOOST_AUTO_TEST_CASE(sha256d64)`
`743`	`743`	`in[j] = InsecureRandBits(8);`
`744`	`744`	`}`
`745`	`745`	`for (int j = 0; j < i; ++j) {`
`746`		`- CHash256().Write({in + 64 * j, 64}).Finalize(out1 + 32 * j);`
	`746`	`+ CHash256().Write({in + 64 * j, 64}).Finalize({out1 + 32 * j, 32});`
`747`	`747`	`}`
`748`	`748`	`SHA256D64(out2, in, i);`
`749`	`749`	`BOOST_CHECK(memcmp(out1, out2, 32 * i) == 0);`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`	`mutated \|= (inner[level] == h);`
`63`		`- CHash256().Write(inner[level]).Write(h).Finalize(h.begin());`
	`63`	`+ CHash256().Write(inner[level]).Write(h).Finalize(h);`
`64`	`64`	`}`
`65`	`65`	`// Store the resulting hash at inner position level.`
`66`	`66`	`inner[level] = h;`
`@@ -86,7 +86,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot`
`86`	`86`	`if (pbranch && matchh) {`
`87`	`87`	`pbranch->push_back(h);`
`88`	`88`	`}`
`89`		`- CHash256().Write(h).Write(h).Finalize(h.begin());`
	`89`	`+ CHash256().Write(h).Write(h).Finalize(h);`
`90`	`90`	`// Increment count to the value it would have if two entries at this`
`91`	`91`	`// level had existed.`
`92`	`92`	`count += (((uint32_t)1) << level);`
`@@ -101,7 +101,7 @@ static void MerkleComputation(const std::vector<uint256>& leaves, uint256* proot`
`101`	`101`	`matchh = true;`
`102`	`102`	`}`
`103`	`103`	`}`
`104`		`- CHash256().Write(inner[level]).Write(h).Finalize(h.begin());`
	`104`	`+ CHash256().Write(inner[level]).Write(h).Finalize(h);`
`105`	`105`	`level++;`
`106`	`106`	`}`
`107`	`107`	`}`