1 // Copyright (c) 2013-2020 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/tx_check.h>
6 #include <consensus/validation.h>
7 #include <hash.h>
8 #include <script/interpreter.h>
9 #include <script/script.h>
10 #include <serialize.h>
11 #include <streams.h>
12 #include <test/data/sighash.json.h>
13 #include <test/util/setup_common.h>
14 #include <util/strencodings.h>
15 #include <util/system.h>
16 #include <version.h>
17
18 #include <iostream>
19
20 #include <boost/test/unit_test.hpp>
21
22 #include <univalue.h>
23
24 extern UniValue read_json(const std::string& jsondata);
25
26 // Old script.cpp SignatureHash function
SignatureHashOld(CScript scriptCode,const CTransaction & txTo,unsigned int nIn,int nHashType)27 uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
28 {
29 if (nIn >= txTo.vin.size())
30 {
31 return uint256::ONE;
32 }
33 CMutableTransaction txTmp(txTo);
34
35 // In case concatenating two scripts ends up with two codeseparators,
36 // or an extra one at the end, this prevents all those possible incompatibilities.
37 FindAndDelete(scriptCode, CScript(OP_CODESEPARATOR));
38
39 // Blank out other inputs' signatures
40 for (unsigned int i = 0; i < txTmp.vin.size(); i++)
41 txTmp.vin[i].scriptSig = CScript();
42 txTmp.vin[nIn].scriptSig = scriptCode;
43
44 // Blank out some of the outputs
45 if ((nHashType & 0x1f) == SIGHASH_NONE)
46 {
47 // Wildcard payee
48 txTmp.vout.clear();
49
50 // Let the others update at will
51 for (unsigned int i = 0; i < txTmp.vin.size(); i++)
52 if (i != nIn)
53 txTmp.vin[i].nSequence = 0;
54 }
55 else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
56 {
57 // Only lock-in the txout payee at same index as txin
58 unsigned int nOut = nIn;
59 if (nOut >= txTmp.vout.size())
60 {
61 return uint256::ONE;
62 }
63 txTmp.vout.resize(nOut+1);
64 for (unsigned int i = 0; i < nOut; i++)
65 txTmp.vout[i].SetNull();
66
67 // Let the others update at will
68 for (unsigned int i = 0; i < txTmp.vin.size(); i++)
69 if (i != nIn)
70 txTmp.vin[i].nSequence = 0;
71 }
72
73 // Blank out other inputs completely, not recommended for open transactions
74 if (nHashType & SIGHASH_ANYONECANPAY)
75 {
76 txTmp.vin[0] = txTmp.vin[nIn];
77 txTmp.vin.resize(1);
78 }
79
80 // Serialize and hash
81 CHashWriter ss(SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
82 ss << txTmp << nHashType;
83 return ss.GetHash();
84 }
85
RandomScript(CScript & script)86 void static RandomScript(CScript &script) {
87 static const opcodetype oplist[] = {OP_FALSE, OP_1, OP_2, OP_3, OP_CHECKSIG, OP_IF, OP_VERIF, OP_RETURN, OP_CODESEPARATOR};
88 script = CScript();
89 int ops = (InsecureRandRange(10));
90 for (int i=0; i<ops; i++)
91 script << oplist[InsecureRandRange(sizeof(oplist)/sizeof(oplist[0]))];
92 }
93
RandomTransaction(CMutableTransaction & tx,bool fSingle)94 void static RandomTransaction(CMutableTransaction &tx, bool fSingle) {
95 tx.nVersion = InsecureRand32();
96 tx.vin.clear();
97 tx.vout.clear();
98 tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0;
99 int ins = (InsecureRandBits(2)) + 1;
100 int outs = fSingle ? ins : (InsecureRandBits(2)) + 1;
101 for (int in = 0; in < ins; in++) {
102 tx.vin.push_back(CTxIn());
103 CTxIn &txin = tx.vin.back();
104 txin.prevout.hash = InsecureRand256();
105 txin.prevout.n = InsecureRandBits(2);
106 RandomScript(txin.scriptSig);
107 txin.nSequence = (InsecureRandBool()) ? InsecureRand32() : std::numeric_limits<uint32_t>::max();
108 }
109 for (int out = 0; out < outs; out++) {
110 tx.vout.push_back(CTxOut());
111 CTxOut &txout = tx.vout.back();
112 txout.nValue = InsecureRandRange(100000000);
113 RandomScript(txout.scriptPubKey);
114 }
115 }
116
BOOST_FIXTURE_TEST_SUITE(sighash_tests,BasicTestingSetup)117 BOOST_FIXTURE_TEST_SUITE(sighash_tests, BasicTestingSetup)
118
119 BOOST_AUTO_TEST_CASE(sighash_test)
120 {
121 #if defined(PRINT_SIGHASH_JSON)
122 std::cout << "[\n";
123 std::cout << "\t[\"raw_transaction, script, input_index, hashType, signature_hash (result)\"],\n";
124 int nRandomTests = 500;
125 #else
126 int nRandomTests = 50000;
127 #endif
128 for (int i=0; i<nRandomTests; i++) {
129 int nHashType = InsecureRand32();
130 CMutableTransaction txTo;
131 RandomTransaction(txTo, (nHashType & 0x1f) == SIGHASH_SINGLE);
132 CScript scriptCode;
133 RandomScript(scriptCode);
134 int nIn = InsecureRandRange(txTo.vin.size());
135
136 uint256 sh, sho;
137 sho = SignatureHashOld(scriptCode, CTransaction(txTo), nIn, nHashType);
138 sh = SignatureHash(scriptCode, txTo, nIn, nHashType, 0, SigVersion::BASE);
139 #if defined(PRINT_SIGHASH_JSON)
140 CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
141 ss << txTo;
142
143 std::cout << "\t[\"" ;
144 std::cout << HexStr(ss) << "\", \"";
145 std::cout << HexStr(scriptCode) << "\", ";
146 std::cout << nIn << ", ";
147 std::cout << nHashType << ", \"";
148 std::cout << sho.GetHex() << "\"]";
149 if (i+1 != nRandomTests) {
150 std::cout << ",";
151 }
152 std::cout << "\n";
153 #endif
154 BOOST_CHECK(sh == sho);
155 }
156 #if defined(PRINT_SIGHASH_JSON)
157 std::cout << "]\n";
158 #endif
159 }
160
161 // Goal: check that SignatureHash generates correct hash
BOOST_AUTO_TEST_CASE(sighash_from_data)162 BOOST_AUTO_TEST_CASE(sighash_from_data)
163 {
164 UniValue tests = read_json(std::string(json_tests::sighash, json_tests::sighash + sizeof(json_tests::sighash)));
165
166 for (unsigned int idx = 0; idx < tests.size(); idx++) {
167 UniValue test = tests[idx];
168 std::string strTest = test.write();
169 if (test.size() < 1) // Allow for extra stuff (useful for comments)
170 {
171 BOOST_ERROR("Bad test: " << strTest);
172 continue;
173 }
174 if (test.size() == 1) continue; // comment
175
176 std::string raw_tx, raw_script, sigHashHex;
177 int nIn, nHashType;
178 uint256 sh;
179 CTransactionRef tx;
180 CScript scriptCode = CScript();
181
182 try {
183 // deserialize test data
184 raw_tx = test[0].get_str();
185 raw_script = test[1].get_str();
186 nIn = test[2].get_int();
187 nHashType = test[3].get_int();
188 sigHashHex = test[4].get_str();
189
190 CDataStream stream(ParseHex(raw_tx), SER_NETWORK, PROTOCOL_VERSION);
191 stream >> tx;
192
193 TxValidationState state;
194 BOOST_CHECK_MESSAGE(CheckTransaction(*tx, state), strTest);
195 BOOST_CHECK(state.IsValid());
196
197 std::vector<unsigned char> raw = ParseHex(raw_script);
198 scriptCode.insert(scriptCode.end(), raw.begin(), raw.end());
199 } catch (...) {
200 BOOST_ERROR("Bad test, couldn't deserialize data: " << strTest);
201 continue;
202 }
203
204 sh = SignatureHash(scriptCode, *tx, nIn, nHashType, 0, SigVersion::BASE);
205 BOOST_CHECK_MESSAGE(sh.GetHex() == sigHashHex, strTest);
206 }
207 }
208 BOOST_AUTO_TEST_SUITE_END()
209