Branch data Line data Source code
1 : : // Copyright (c) 2020-2021 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 <chainparams.h>
6 : : #include <key.h>
7 : : #include <psbt.h>
8 : : #include <pubkey.h>
9 : : #include <script/keyorigin.h>
10 : : #include <script/sign.h>
11 : : #include <script/signingprovider.h>
12 : : #include <streams.h>
13 : : #include <test/fuzz/FuzzedDataProvider.h>
14 : : #include <test/fuzz/fuzz.h>
15 : : #include <test/fuzz/util.h>
16 : : #include <test/util/transaction_utils.h>
17 : : #include <util/chaintype.h>
18 : : #include <util/translation.h>
19 : :
20 : : #include <cassert>
21 : : #include <cstdint>
22 : : #include <iostream>
23 : : #include <map>
24 : : #include <optional>
25 : : #include <string>
26 : : #include <vector>
27 : :
28 : 1 : void initialize_script_sign()
29 : : {
30 [ + - + - : 1 : static ECC_Context ecc_context{};
+ - ]
31 : 1 : SelectParams(ChainType::REGTEST);
32 : 1 : }
33 : :
34 [ + - ]: 3970 : FUZZ_TARGET(script_sign, .init = initialize_script_sign)
35 : : {
36 : 3558 : FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
37 : 3558 : const std::vector<uint8_t> key = ConsumeRandomLengthByteVector(fuzzed_data_provider, 128);
38 : :
39 : 3558 : {
40 : 3558 : DataStream random_data_stream{ConsumeDataStream(fuzzed_data_provider)};
41 [ + + ]: 3558 : std::map<CPubKey, KeyOriginInfo> hd_keypaths;
42 : 3558 : try {
43 [ + + ]: 3558 : DeserializeHDKeypaths(random_data_stream, key, hd_keypaths);
44 [ - + ]: 3520 : } catch (const std::ios_base::failure&) {
45 : 3520 : }
46 : 3558 : DataStream serialized{};
47 [ + - ]: 3558 : SerializeHDKeypaths(serialized, hd_keypaths, CompactSizeWriter(fuzzed_data_provider.ConsumeIntegral<uint8_t>()));
48 : 3558 : }
49 : :
50 : 3558 : {
51 : 3558 : std::map<CPubKey, KeyOriginInfo> hd_keypaths;
52 [ + + + - ]: 14511 : LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
53 : 12810 : const std::optional<CPubKey> pub_key = ConsumeDeserializable<CPubKey>(fuzzed_data_provider);
54 [ + + ]: 12810 : if (!pub_key) {
55 : : break;
56 : : }
57 : 11568 : const std::optional<KeyOriginInfo> key_origin_info = ConsumeDeserializable<KeyOriginInfo>(fuzzed_data_provider);
58 [ + + ]: 11568 : if (!key_origin_info) {
59 : : break;
60 : : }
61 [ + - + - ]: 10953 : hd_keypaths[*pub_key] = *key_origin_info;
62 : 11568 : }
63 : 3558 : DataStream serialized{};
64 : 3558 : try {
65 [ + + ]: 3558 : SerializeHDKeypaths(serialized, hd_keypaths, CompactSizeWriter(fuzzed_data_provider.ConsumeIntegral<uint8_t>()));
66 [ - + ]: 146 : } catch (const std::ios_base::failure&) {
67 : 146 : }
68 [ + + ]: 3558 : std::map<CPubKey, KeyOriginInfo> deserialized_hd_keypaths;
69 : 3558 : try {
70 [ + + ]: 3558 : DeserializeHDKeypaths(serialized, key, hd_keypaths);
71 [ - + ]: 3518 : } catch (const std::ios_base::failure&) {
72 : 3518 : }
73 [ - + ]: 3558 : assert(hd_keypaths.size() >= deserialized_hd_keypaths.size());
74 : 3558 : }
75 : :
76 : 3558 : {
77 : 3558 : SignatureData signature_data_1{ConsumeScript(fuzzed_data_provider)};
78 : 3558 : SignatureData signature_data_2{ConsumeScript(fuzzed_data_provider)};
79 [ + - + - ]: 3558 : signature_data_1.MergeSignatureData(signature_data_2);
80 : 3558 : }
81 : :
82 : 3558 : FillableSigningProvider provider;
83 : 3558 : CKey k = ConsumePrivateKey(fuzzed_data_provider);
84 [ + + ]: 3558 : if (k.IsValid()) {
85 [ + - ]: 3331 : provider.AddKey(k);
86 : : }
87 : :
88 : 3558 : {
89 : 3558 : const std::optional<CMutableTransaction> mutable_transaction = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
90 : 3558 : const std::optional<CTxOut> tx_out = ConsumeDeserializable<CTxOut>(fuzzed_data_provider);
91 : 3558 : const unsigned int n_in = fuzzed_data_provider.ConsumeIntegral<unsigned int>();
92 [ + + + + : 3558 : if (mutable_transaction && tx_out && mutable_transaction->vin.size() > n_in) {
+ + ]
93 [ + - ]: 326 : SignatureData signature_data_1 = DataFromTransaction(*mutable_transaction, n_in, *tx_out);
94 : 326 : CTxIn input;
95 [ + - ]: 326 : UpdateInput(input, signature_data_1);
96 : 326 : const CScript script = ConsumeScript(fuzzed_data_provider);
97 : 326 : SignatureData signature_data_2{script};
98 [ + - + - ]: 326 : signature_data_1.MergeSignatureData(signature_data_2);
99 : 652 : }
100 [ + + ]: 3558 : if (mutable_transaction) {
101 [ + - ]: 3093 : CTransaction tx_from{*mutable_transaction};
102 [ + - ]: 3093 : CMutableTransaction tx_to;
103 : 3093 : const std::optional<CMutableTransaction> opt_tx_to = ConsumeDeserializable<CMutableTransaction>(fuzzed_data_provider, TX_WITH_WITNESS);
104 [ + + ]: 3093 : if (opt_tx_to) {
105 [ + - ]: 2668 : tx_to = *opt_tx_to;
106 : : }
107 [ + - ]: 3093 : CMutableTransaction script_tx_to = tx_to;
108 [ + - ]: 3093 : CMutableTransaction sign_transaction_tx_to = tx_to;
109 [ + + + + ]: 3093 : if (n_in < tx_to.vin.size() && tx_to.vin[n_in].prevout.n < tx_from.vout.size()) {
110 : 8 : SignatureData empty;
111 [ + - ]: 8 : (void)SignSignature(provider, tx_from, tx_to, n_in, fuzzed_data_provider.ConsumeIntegral<int>(), empty);
112 : 8 : }
113 [ + + ]: 3093 : if (n_in < script_tx_to.vin.size()) {
114 : 505 : SignatureData empty;
115 : 505 : auto from_pub_key = ConsumeScript(fuzzed_data_provider);
116 : 505 : auto amount = ConsumeMoney(fuzzed_data_provider);
117 : 505 : auto n_hash_type = fuzzed_data_provider.ConsumeIntegral<int>();
118 [ + - ]: 505 : (void)SignSignature(provider, from_pub_key, script_tx_to, n_in, amount, n_hash_type, empty);
119 [ + - ]: 505 : MutableTransactionSignatureCreator signature_creator{tx_to, n_in, ConsumeMoney(fuzzed_data_provider), fuzzed_data_provider.ConsumeIntegral<int>()};
120 : 505 : std::vector<unsigned char> vch_sig;
121 : 505 : CKeyID address;
122 [ + + ]: 505 : if (fuzzed_data_provider.ConsumeBool()) {
123 [ + + + + ]: 834 : if (k.IsValid()) {
124 [ + - + - ]: 412 : address = k.GetPubKey().GetID();
125 : : }
126 : : } else {
127 : 88 : address = CKeyID{ConsumeUInt160(fuzzed_data_provider)};
128 : : }
129 : 505 : auto script_code = ConsumeScript(fuzzed_data_provider);
130 : 505 : auto sigversion = fuzzed_data_provider.PickValueInArray({SigVersion::BASE, SigVersion::WITNESS_V0});
131 [ + - ]: 505 : (void)signature_creator.CreateSig(provider, vch_sig, address, script_code, sigversion);
132 : 505 : }
133 : 3093 : std::map<COutPoint, Coin> coins{ConsumeCoins(fuzzed_data_provider)};
134 : 3093 : std::map<int, bilingual_str> input_errors;
135 [ + - ]: 3093 : (void)SignTransaction(sign_transaction_tx_to, &provider, coins, fuzzed_data_provider.ConsumeIntegral<int>(), input_errors);
136 [ + + ]: 18558 : }
137 [ + + ]: 3558 : }
138 : :
139 : 3558 : {
140 : 3558 : SignatureData signature_data_1;
141 [ + - ]: 3558 : (void)ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, ConsumeScript(fuzzed_data_provider), signature_data_1);
142 : 3558 : SignatureData signature_data_2;
143 [ + - ]: 3558 : (void)ProduceSignature(provider, DUMMY_MAXIMUM_SIGNATURE_CREATOR, ConsumeScript(fuzzed_data_provider), signature_data_2);
144 : 3558 : }
145 : 3558 : }
|
