Branch data Line data Source code
1 : : // Copyright (c) 2009-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 <core_io.h>
6 : :
7 : : #include <primitives/block.h>
8 : : #include <primitives/transaction.h>
9 : : #include <script/script.h>
10 : : #include <script/sign.h>
11 : : #include <serialize.h>
12 : : #include <streams.h>
13 : : #include <util/result.h>
14 : : #include <util/strencodings.h>
15 : : #include <version.h>
16 : :
17 : : #include <algorithm>
18 : : #include <string>
19 : :
20 : : namespace {
21 : : class OpCodeParser
22 : : {
23 : : private:
24 : : std::map<std::string, opcodetype> mapOpNames;
25 : :
26 : : public:
27 : 1 : OpCodeParser()
28 : : {
29 [ + + ]: 187 : for (unsigned int op = 0; op <= MAX_OPCODE; ++op) {
30 : : // Allow OP_RESERVED to get into mapOpNames
31 [ + + + + ]: 186 : if (op < OP_NOP && op != OP_RESERVED) {
32 : 96 : continue;
33 : : }
34 : :
35 [ + - ]: 90 : std::string strName = GetOpName(static_cast<opcodetype>(op));
36 [ + - + - ]: 90 : if (strName == "OP_UNKNOWN") {
37 : 0 : continue;
38 : : }
39 [ + - ]: 90 : mapOpNames[strName] = static_cast<opcodetype>(op);
40 : : // Convenience: OP_ADD and just ADD are both recognized:
41 [ + - + - ]: 90 : if (strName.compare(0, 3, "OP_") == 0) { // strName starts with "OP_"
42 [ + - + - ]: 90 : mapOpNames[strName.substr(3)] = static_cast<opcodetype>(op);
43 : 90 : }
44 [ - - + ]: 90 : }
45 : 1 : }
46 : 7528 : opcodetype Parse(const std::string& s) const
47 : : {
48 : 7528 : auto it = mapOpNames.find(s);
49 [ + + + - ]: 7528 : if (it == mapOpNames.end()) throw std::runtime_error("script parse error: unknown opcode");
50 : 7463 : return it->second;
51 : 0 : }
52 : : };
53 : :
54 : 7528 : opcodetype ParseOpCode(const std::string& s)
55 : : {
56 [ + + - + : 7528 : static const OpCodeParser ocp;
+ - ]
57 : 7528 : return ocp.Parse(s);
58 : 0 : }
59 : :
60 : : } // namespace
61 : :
62 : 142 : CScript ParseScript(const std::string& s)
63 : : {
64 : 142 : CScript result;
65 : :
66 [ + - ]: 142 : std::vector<std::string> words = SplitString(s, " \t\n");
67 : :
68 [ + + ]: 82688 : for (const std::string& w : words) {
69 [ + + ]: 82615 : if (w.empty()) {
70 : : // Empty string, ignore. (SplitString doesn't combine multiple separators)
71 [ + - + + : 110824 : } else if (std::all_of(w.begin(), w.end(), ::IsDigit) ||
+ + ]
72 [ + + + - : 28209 : (w.front() == '-' && w.size() > 1 && std::all_of(w.begin() + 1, w.end(), ::IsDigit)))
+ - ]
73 : : {
74 : 173 : // Number
75 [ + - ]: 50768 : const auto num{ToIntegral<int64_t>(w)};
76 : :
77 : : // limit the range of numbers ParseScript accepts in decimal
78 : : // since numbers outside -0xFFFFFFFF...0xFFFFFFFF are illegal in scripts
79 [ + - + - : 50768 : if (!num.has_value() || num > int64_t{0xffffffff} || num < -1 * int64_t{0xffffffff}) {
+ + + - +
+ ]
80 [ + - - + ]: 4 : throw std::runtime_error("script parse error: decimal numeric value only allowed in the "
81 : : "range -0xFFFFFFFF...0xFFFFFFFF");
82 : : }
83 : :
84 [ + - + - ]: 50764 : result << num.value();
85 [ + - - + : 79238 : } else if (w.substr(0, 2) == "0x" && w.size() > 2 && IsHex(std::string(w.begin() + 2, w.end()))) {
+ + - + -
+ - + + +
+ + + + #
# # # ]
86 : : // Raw hex data, inserted NOT pushed onto stack:
87 [ - + - + ]: 773 : std::vector<unsigned char> raw = ParseHex(std::string(w.begin() + 2, w.end()));
88 [ + - + - ]: 773 : result.insert(result.end(), raw.begin(), raw.end());
89 [ + + + + : 27694 : } else if (w.size() >= 2 && w.front() == '\'' && w.back() == '\'') {
+ + ]
90 : : // Single-quoted string, pushed as data. NOTE: this is poor-man's
91 : : // parsing, spaces/tabs/newlines in single-quoted strings won't work.
92 [ - + ]: 19393 : std::vector<unsigned char> value(w.begin() + 1, w.end() - 1);
93 [ + - ]: 19393 : result << value;
94 : 19393 : } else {
95 : : // opcode, e.g. OP_ADD or ADD:
96 [ + + + - ]: 7528 : result << ParseOpCode(w);
97 : : }
98 : : }
99 : :
100 : 73 : return result;
101 [ + - ]: 142 : }
102 : :
103 : : // Check that all of the input and output scripts of a transaction contains valid opcodes
104 : 2504 : static bool CheckTxScriptsSanity(const CMutableTransaction& tx)
105 : : {
106 : : // Check input scripts for non-coinbase txs
107 [ + - + + ]: 2504 : if (!CTransaction(tx).IsCoinBase()) {
108 [ + + ]: 8275 : for (unsigned int i = 0; i < tx.vin.size(); i++) {
109 [ + + - + ]: 6852 : if (!tx.vin[i].scriptSig.HasValidOps() || tx.vin[i].scriptSig.size() > MAX_SCRIPT_SIZE) {
110 : 1051 : return false;
111 : : }
112 : 5801 : }
113 : 1423 : }
114 : : // Check output scripts
115 [ + + ]: 9999 : for (unsigned int i = 0; i < tx.vout.size(); i++) {
116 [ + + + - ]: 8740 : if (!tx.vout[i].scriptPubKey.HasValidOps() || tx.vout[i].scriptPubKey.size() > MAX_SCRIPT_SIZE) {
117 : 194 : return false;
118 : : }
119 : 8546 : }
120 : :
121 : 1259 : return true;
122 : 2504 : }
123 : :
124 : 2623 : static bool DecodeTx(CMutableTransaction& tx, const std::vector<unsigned char>& tx_data, bool try_no_witness, bool try_witness)
125 : : {
126 : : // General strategy:
127 : : // - Decode both with extended serialization (which interprets the 0x0001 tag as a marker for
128 : : // the presence of witnesses) and with legacy serialization (which interprets the tag as a
129 : : // 0-input 1-output incomplete transaction).
130 : : // - Restricted by try_no_witness (which disables legacy if false) and try_witness (which
131 : : // disables extended if false).
132 : : // - Ignore serializations that do not fully consume the hex string.
133 : : // - If neither succeeds, fail.
134 : : // - If only one succeeds, return that one.
135 : : // - If both decode attempts succeed:
136 : : // - If only one passes the CheckTxScriptsSanity check, return that one.
137 : : // - If neither or both pass CheckTxScriptsSanity, return the extended one.
138 : :
139 [ + - ]: 2623 : CMutableTransaction tx_extended, tx_legacy;
140 : 2623 : bool ok_extended = false, ok_legacy = false;
141 : :
142 : : // Try decoding with extended serialization support, and remember if the result successfully
143 : : // consumes the entire input.
144 [ + + ]: 2623 : if (try_witness) {
145 [ + - + - ]: 2233 : CDataStream ssData(tx_data, SER_NETWORK, PROTOCOL_VERSION);
146 : : try {
147 [ + + ]: 2233 : ssData >> tx_extended;
148 [ + - + + ]: 2130 : if (ssData.empty()) ok_extended = true;
149 [ - + ]: 2233 : } catch (const std::exception&) {
150 : : // Fall through.
151 [ + - ]: 103 : }
152 : 2233 : }
153 : :
154 : : // Optimization: if extended decoding succeeded and the result passes CheckTxScriptsSanity,
155 : : // don't bother decoding the other way.
156 [ + + + - : 2623 : if (ok_extended && CheckTxScriptsSanity(tx_extended)) {
+ + ]
157 : 1222 : tx = std::move(tx_extended);
158 : 1222 : return true;
159 : : }
160 : :
161 : : // Try decoding with legacy serialization, and remember if the result successfully consumes the entire input.
162 [ + + ]: 1401 : if (try_no_witness) {
163 [ + - + - ]: 535 : CDataStream ssData(tx_data, SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS);
164 : : try {
165 [ + + ]: 535 : ssData >> tx_legacy;
166 [ + - + + ]: 477 : if (ssData.empty()) ok_legacy = true;
167 [ - + ]: 535 : } catch (const std::exception&) {
168 : : // Fall through.
169 [ - + ]: 58 : }
170 : 535 : }
171 : :
172 : : // If legacy decoding succeeded and passes CheckTxScriptsSanity, that's our answer, as we know
173 : : // at this point that extended decoding either failed or doesn't pass the sanity check.
174 [ + + + - : 1401 : if (ok_legacy && CheckTxScriptsSanity(tx_legacy)) {
+ + ]
175 : 37 : tx = std::move(tx_legacy);
176 : 37 : return true;
177 : : }
178 : :
179 : : // If extended decoding succeeded, and neither decoding passes sanity, return the extended one.
180 [ + + ]: 1364 : if (ok_extended) {
181 : 904 : tx = std::move(tx_extended);
182 : 904 : return true;
183 : : }
184 : :
185 : : // If legacy decoding succeeded and extended didn't, return the legacy one.
186 [ + + ]: 460 : if (ok_legacy) {
187 : 104 : tx = std::move(tx_legacy);
188 : 104 : return true;
189 : : }
190 : :
191 : : // If none succeeded, we failed.
192 : 356 : return false;
193 : 2784 : }
194 : :
195 : 2650 : bool DecodeHexTx(CMutableTransaction& tx, const std::string& hex_tx, bool try_no_witness, bool try_witness)
196 : : {
197 [ + + ]: 2650 : if (!IsHex(hex_tx)) {
198 : 27 : return false;
199 : : }
200 : :
201 : 2623 : std::vector<unsigned char> txData(ParseHex(hex_tx));
202 [ - + ]: 2623 : return DecodeTx(tx, txData, try_no_witness, try_witness);
203 : 2650 : }
204 : :
205 : 216 : bool DecodeHexBlockHeader(CBlockHeader& header, const std::string& hex_header)
206 : : {
207 [ + + ]: 216 : if (!IsHex(hex_header)) return false;
208 : :
209 : 166 : const std::vector<unsigned char> header_data{ParseHex(hex_header)};
210 [ + - + - ]: 166 : DataStream ser_header{header_data};
211 : : try {
212 [ + + ]: 166 : ser_header >> header;
213 [ - + ]: 166 : } catch (const std::exception&) {
214 : 22 : return false;
215 [ - + ]: 22 : }
216 : 144 : return true;
217 : 238 : }
218 : :
219 : 237 : bool DecodeHexBlk(CBlock& block, const std::string& strHexBlk)
220 : : {
221 [ + + ]: 237 : if (!IsHex(strHexBlk))
222 : 50 : return false;
223 : :
224 : 187 : std::vector<unsigned char> blockData(ParseHex(strHexBlk));
225 [ + - + - ]: 187 : CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);
226 : : try {
227 [ + + ]: 187 : ssBlock >> block;
228 [ - + ]: 187 : }
229 : : catch (const std::exception&) {
230 : 163 : return false;
231 [ - + ]: 163 : }
232 : :
233 : 24 : return true;
234 : 400 : }
235 : :
236 : 235 : bool ParseHashStr(const std::string& strHex, uint256& result)
237 : : {
238 [ + + - + ]: 235 : if ((strHex.size() != 64) || !IsHex(strHex))
239 : 231 : return false;
240 : :
241 : 4 : result.SetHex(strHex);
242 : 4 : return true;
243 : 235 : }
244 : :
245 : 880 : util::Result<int> SighashFromStr(const std::string& sighash)
246 : : {
247 [ + + - + : 887 : static std::map<std::string, int> map_sighash_values = {
+ - # # ]
248 [ + - + - ]: 1 : {std::string("DEFAULT"), int(SIGHASH_DEFAULT)},
249 [ + - + - ]: 1 : {std::string("ALL"), int(SIGHASH_ALL)},
250 [ + - + - ]: 1 : {std::string("ALL|ANYONECANPAY"), int(SIGHASH_ALL|SIGHASH_ANYONECANPAY)},
251 [ + - + - ]: 1 : {std::string("NONE"), int(SIGHASH_NONE)},
252 [ + - + - ]: 1 : {std::string("NONE|ANYONECANPAY"), int(SIGHASH_NONE|SIGHASH_ANYONECANPAY)},
253 [ + - + - ]: 1 : {std::string("SINGLE"), int(SIGHASH_SINGLE)},
254 [ + - + - ]: 1 : {std::string("SINGLE|ANYONECANPAY"), int(SIGHASH_SINGLE|SIGHASH_ANYONECANPAY)},
255 : : };
256 : 880 : const auto& it = map_sighash_values.find(sighash);
257 [ + + ]: 880 : if (it != map_sighash_values.end()) {
258 : 1 : return it->second;
259 : : } else {
260 [ + - + - ]: 879 : return util::Error{Untranslated(sighash + " is not a valid sighash parameter.")};
261 : : }
262 : 880 : }
|
