Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <script/sign.h>
7 : :
8 : : #include <consensus/amount.h>
9 : : #include <key.h>
10 : : #include <musig.h>
11 : : #include <policy/policy.h>
12 : : #include <primitives/transaction.h>
13 : : #include <random.h>
14 : : #include <script/keyorigin.h>
15 : : #include <script/miniscript.h>
16 : : #include <script/script.h>
17 : : #include <script/signingprovider.h>
18 : : #include <script/solver.h>
19 : : #include <uint256.h>
20 : : #include <util/translation.h>
21 : : #include <util/vector.h>
22 : :
23 : : typedef std::vector<unsigned char> valtype;
24 : :
25 : 5587 : MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(const CMutableTransaction& tx, unsigned int input_idx, const CAmount& amount, int hash_type)
26 : 5587 : : m_txto{tx}, nIn{input_idx}, nHashType{hash_type}, amount{amount}, checker{&m_txto, nIn, amount, MissingDataBehavior::FAIL},
27 : 5587 : m_txdata(nullptr)
28 : : {
29 : 5587 : }
30 : :
31 : 89639 : MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(const CMutableTransaction& tx, unsigned int input_idx, const CAmount& amount, const PrecomputedTransactionData* txdata, int hash_type)
32 : 89639 : : m_txto{tx}, nIn{input_idx}, nHashType{hash_type}, amount{amount},
33 [ + - ]: 89639 : checker{txdata ? MutableTransactionSignatureChecker{&m_txto, nIn, amount, *txdata, MissingDataBehavior::FAIL} :
34 : : MutableTransactionSignatureChecker{&m_txto, nIn, amount, MissingDataBehavior::FAIL}},
35 [ + - ]: 89639 : m_txdata(txdata)
36 : : {
37 : 89639 : }
38 : :
39 : 31307 : bool MutableTransactionSignatureCreator::CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& address, const CScript& scriptCode, SigVersion sigversion) const
40 : : {
41 [ - + ]: 31307 : assert(sigversion == SigVersion::BASE || sigversion == SigVersion::WITNESS_V0);
42 : :
43 : 31307 : CKey key;
44 [ + - + + ]: 31307 : if (!provider.GetKey(address, key))
45 : : return false;
46 : :
47 : : // Signing with uncompressed keys is disabled in witness scripts
48 [ + + + + ]: 16223 : if (sigversion == SigVersion::WITNESS_V0 && !key.IsCompressed())
49 : : return false;
50 : :
51 : : // Signing without known amount does not work in witness scripts.
52 [ + + + - ]: 16219 : if (sigversion == SigVersion::WITNESS_V0 && !MoneyRange(amount)) return false;
53 : :
54 : : // BASE/WITNESS_V0 signatures don't support explicit SIGHASH_DEFAULT, use SIGHASH_ALL instead.
55 [ + + ]: 16219 : const int hashtype = nHashType == SIGHASH_DEFAULT ? SIGHASH_ALL : nHashType;
56 : :
57 [ + - ]: 16219 : uint256 hash = SignatureHash(scriptCode, m_txto, nIn, hashtype, amount, sigversion, m_txdata);
58 [ + - + - ]: 16219 : if (!key.Sign(hash, vchSig))
59 : : return false;
60 [ + - ]: 31307 : vchSig.push_back((unsigned char)hashtype);
61 : : return true;
62 : 31307 : }
63 : :
64 : 1236 : std::optional<uint256> MutableTransactionSignatureCreator::ComputeSchnorrSignatureHash(const uint256* leaf_hash, SigVersion sigversion) const
65 : : {
66 [ - + ]: 1236 : assert(sigversion == SigVersion::TAPROOT || sigversion == SigVersion::TAPSCRIPT);
67 : :
68 : : // BIP341/BIP342 signing needs lots of precomputed transaction data. While some
69 : : // (non-SIGHASH_DEFAULT) sighash modes exist that can work with just some subset
70 : : // of data present, for now, only support signing when everything is provided.
71 [ + - + - : 1236 : if (!m_txdata || !m_txdata->m_bip341_taproot_ready || !m_txdata->m_spent_outputs_ready) return std::nullopt;
- + ]
72 : :
73 [ + + ]: 1236 : ScriptExecutionData execdata;
74 : 1236 : execdata.m_annex_init = true;
75 : 1236 : execdata.m_annex_present = false; // Only support annex-less signing for now.
76 [ + + ]: 1236 : if (sigversion == SigVersion::TAPSCRIPT) {
77 : 557 : execdata.m_codeseparator_pos_init = true;
78 : 557 : execdata.m_codeseparator_pos = 0xFFFFFFFF; // Only support non-OP_CODESEPARATOR BIP342 signing for now.
79 [ - + ]: 557 : if (!leaf_hash) return std::nullopt; // BIP342 signing needs leaf hash.
80 : 557 : execdata.m_tapleaf_hash_init = true;
81 : 557 : execdata.m_tapleaf_hash = *leaf_hash;
82 : : }
83 : 1236 : uint256 hash;
84 [ - + ]: 1236 : if (!SignatureHashSchnorr(hash, execdata, m_txto, nIn, nHashType, sigversion, *m_txdata, MissingDataBehavior::FAIL)) return std::nullopt;
85 : 1236 : return hash;
86 : : }
87 : :
88 : 109613 : bool MutableTransactionSignatureCreator::CreateSchnorrSig(const SigningProvider& provider, std::vector<unsigned char>& sig, const XOnlyPubKey& pubkey, const uint256* leaf_hash, const uint256* merkle_root, SigVersion sigversion) const
89 : : {
90 : 109613 : CKey key;
91 [ + - + + ]: 109613 : if (!provider.GetKeyByXOnly(pubkey, key)) return false;
92 : :
93 [ + - ]: 1041 : std::optional<uint256> hash = ComputeSchnorrSignatureHash(leaf_hash, sigversion);
94 [ + - ]: 1041 : if (!hash.has_value()) return false;
95 : :
96 [ + - ]: 1041 : sig.resize(64);
97 : : // Use uint256{} as aux_rnd for now.
98 [ - + + - : 1041 : if (!key.SignSchnorr(*hash, sig, merkle_root, {})) return false;
+ - ]
99 [ + + + - ]: 109613 : if (nHashType) sig.push_back(nHashType);
100 : : return true;
101 : 109613 : }
102 : :
103 : 2312 : std::vector<uint8_t> MutableTransactionSignatureCreator::CreateMuSig2Nonce(const SigningProvider& provider, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256* leaf_hash, const uint256* merkle_root, SigVersion sigversion, const SignatureData& sigdata) const
104 : : {
105 [ - + ]: 2312 : assert(sigversion == SigVersion::TAPROOT || sigversion == SigVersion::TAPSCRIPT);
106 : :
107 : : // Retrieve the private key
108 : 2312 : CKey key;
109 [ + - + - : 2312 : if (!provider.GetKey(part_pubkey.GetID(), key)) return {};
+ + ]
110 : :
111 : : // Retrieve participant pubkeys
112 : 63 : auto it = sigdata.musig2_pubkeys.find(aggregate_pubkey);
113 [ - + ]: 63 : if (it == sigdata.musig2_pubkeys.end()) return {};
114 : 63 : const std::vector<CPubKey>& pubkeys = it->second;
115 [ - + ]: 63 : if (std::find(pubkeys.begin(), pubkeys.end(), part_pubkey) == pubkeys.end()) return {};
116 : :
117 : : // Compute sighash
118 [ + - ]: 63 : std::optional<uint256> sighash = ComputeSchnorrSignatureHash(leaf_hash, sigversion);
119 [ - + ]: 63 : if (!sighash.has_value()) return {};
120 : :
121 [ + - ]: 63 : MuSig2SecNonce secnonce;
122 [ + - ]: 63 : std::vector<uint8_t> out = key.CreateMuSig2Nonce(secnonce, *sighash, aggregate_pubkey, pubkeys);
123 [ - + ]: 63 : if (out.empty()) return {};
124 : :
125 : : // Store the secnonce in the SigningProvider
126 [ + - + - ]: 63 : provider.SetMuSig2SecNonce(MuSig2SessionID(script_pubkey, part_pubkey, *sighash), std::move(secnonce));
127 : :
128 : 63 : return out;
129 : 2375 : }
130 : :
131 : 4527 : bool MutableTransactionSignatureCreator::CreateMuSig2PartialSig(const SigningProvider& provider, uint256& partial_sig, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256* leaf_hash, const std::vector<std::pair<uint256, bool>>& tweaks, SigVersion sigversion, const SignatureData& sigdata) const
132 : : {
133 [ - + ]: 4527 : assert(sigversion == SigVersion::TAPROOT || sigversion == SigVersion::TAPSCRIPT);
134 : :
135 : : // Retrieve private key
136 : 4527 : CKey key;
137 [ + - + - : 4527 : if (!provider.GetKey(part_pubkey.GetID(), key)) return false;
+ + ]
138 : :
139 : : // Retrieve participant pubkeys
140 : 221 : auto it = sigdata.musig2_pubkeys.find(aggregate_pubkey);
141 [ + - ]: 221 : if (it == sigdata.musig2_pubkeys.end()) return false;
142 : 221 : const std::vector<CPubKey>& pubkeys = it->second;
143 [ + - ]: 221 : if (std::find(pubkeys.begin(), pubkeys.end(), part_pubkey) == pubkeys.end()) return {};
144 : :
145 : : // Retrieve pubnonces
146 [ + + ]: 221 : auto this_leaf_aggkey = std::make_pair(script_pubkey, leaf_hash ? *leaf_hash : uint256());
147 : 221 : auto pubnonce_it = sigdata.musig2_pubnonces.find(this_leaf_aggkey);
148 [ + + ]: 221 : if (pubnonce_it == sigdata.musig2_pubnonces.end()) return false;
149 [ - + ]: 198 : const std::map<CPubKey, std::vector<uint8_t>>& pubnonces = pubnonce_it->second;
150 : :
151 : : // Check if enough pubnonces
152 [ - + + + ]: 198 : if (pubnonces.size() != pubkeys.size()) return false;
153 : :
154 : : // Compute sighash
155 [ + - ]: 98 : std::optional<uint256> sighash = ComputeSchnorrSignatureHash(leaf_hash, sigversion);
156 [ + - ]: 98 : if (!sighash.has_value()) return false;
157 : :
158 : : // Retrieve the secnonce
159 [ + - ]: 98 : uint256 session_id = MuSig2SessionID(script_pubkey, part_pubkey, *sighash);
160 [ + - ]: 98 : std::optional<std::reference_wrapper<MuSig2SecNonce>> secnonce = provider.GetMuSig2SecNonce(session_id);
161 [ + + + - : 98 : if (!secnonce || !secnonce->get().IsValid()) return false;
- + ]
162 : :
163 : : // Compute the sig
164 [ + - ]: 55 : std::optional<uint256> sig = key.CreateMuSig2PartialSig(*sighash, aggregate_pubkey, pubkeys, pubnonces, *secnonce, tweaks);
165 [ + - ]: 55 : if (!sig) return false;
166 [ + - ]: 55 : partial_sig = std::move(*sig);
167 : :
168 : : // Delete the secnonce now that we're done with it
169 [ + - - + ]: 55 : assert(!secnonce->get().IsValid());
170 [ + - ]: 55 : provider.DeleteMuSig2Session(session_id);
171 : :
172 : : return true;
173 : 4527 : }
174 : :
175 : 1653 : bool MutableTransactionSignatureCreator::CreateMuSig2AggregateSig(const std::vector<CPubKey>& participants, std::vector<uint8_t>& sig, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const uint256* leaf_hash, const std::vector<std::pair<uint256, bool>>& tweaks, SigVersion sigversion, const SignatureData& sigdata) const
176 : : {
177 [ - + ]: 1653 : assert(sigversion == SigVersion::TAPROOT || sigversion == SigVersion::TAPSCRIPT);
178 [ - + + - ]: 1653 : if (!participants.size()) return false;
179 : :
180 : : // Retrieve pubnonces and partial sigs
181 [ + + ]: 1653 : auto this_leaf_aggkey = std::make_pair(script_pubkey, leaf_hash ? *leaf_hash : uint256());
182 : 1653 : auto pubnonce_it = sigdata.musig2_pubnonces.find(this_leaf_aggkey);
183 [ + + ]: 1653 : if (pubnonce_it == sigdata.musig2_pubnonces.end()) return false;
184 : 1491 : const std::map<CPubKey, std::vector<uint8_t>>& pubnonces = pubnonce_it->second;
185 : 1491 : auto partial_sigs_it = sigdata.musig2_partial_sigs.find(this_leaf_aggkey);
186 [ + + ]: 1491 : if (partial_sigs_it == sigdata.musig2_partial_sigs.end()) return false;
187 [ - + ]: 299 : const std::map<CPubKey, uint256>& partial_sigs = partial_sigs_it->second;
188 : :
189 : : // Check if enough pubnonces and partial sigs
190 [ - + + - ]: 299 : if (pubnonces.size() != participants.size()) return false;
191 [ + + ]: 299 : if (partial_sigs.size() != participants.size()) return false;
192 : :
193 : : // Compute sighash
194 : 34 : std::optional<uint256> sighash = ComputeSchnorrSignatureHash(leaf_hash, sigversion);
195 [ + - ]: 34 : if (!sighash.has_value()) return false;
196 : :
197 : 34 : std::optional<std::vector<uint8_t>> res = ::CreateMuSig2AggregateSig(participants, aggregate_pubkey, tweaks, *sighash, pubnonces, partial_sigs);
198 [ + - ]: 34 : if (!res) return false;
199 [ + - ]: 34 : sig = res.value();
200 [ + + + - ]: 34 : if (nHashType) sig.push_back(nHashType);
201 : :
202 : : return true;
203 : 34 : }
204 : :
205 : 7693 : static bool GetCScript(const SigningProvider& provider, const SignatureData& sigdata, const CScriptID& scriptid, CScript& script)
206 : : {
207 [ + + ]: 7693 : if (provider.GetCScript(scriptid, script)) {
208 : : return true;
209 : : }
210 : : // Look for scripts in SignatureData
211 [ + + ]: 5752 : if (CScriptID(sigdata.redeem_script) == scriptid) {
212 : 3865 : script = sigdata.redeem_script;
213 : 3865 : return true;
214 [ + + ]: 1887 : } else if (CScriptID(sigdata.witness_script) == scriptid) {
215 : 328 : script = sigdata.witness_script;
216 : 328 : return true;
217 : : }
218 : : return false;
219 : : }
220 : :
221 : 83206 : static bool GetPubKey(const SigningProvider& provider, const SignatureData& sigdata, const CKeyID& address, CPubKey& pubkey)
222 : : {
223 : : // Look for pubkey in all partial sigs
224 : 83206 : const auto it = sigdata.signatures.find(address);
225 [ + + ]: 83206 : if (it != sigdata.signatures.end()) {
226 : 57 : pubkey = it->second.first;
227 : 57 : return true;
228 : : }
229 : : // Look for pubkey in pubkey lists
230 : 83149 : const auto& pk_it = sigdata.misc_pubkeys.find(address);
231 [ + + ]: 83149 : if (pk_it != sigdata.misc_pubkeys.end()) {
232 : 13427 : pubkey = pk_it->second.first;
233 : 13427 : return true;
234 : : }
235 : 69722 : const auto& tap_pk_it = sigdata.tap_pubkeys.find(address);
236 [ + + ]: 69722 : if (tap_pk_it != sigdata.tap_pubkeys.end()) {
237 : 17 : pubkey = tap_pk_it->second.GetEvenCorrespondingCPubKey();
238 : 17 : return true;
239 : : }
240 : : // Query the underlying provider
241 : 69705 : return provider.GetPubKey(address, pubkey);
242 : : }
243 : :
244 : 31982 : static bool CreateSig(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const CPubKey& pubkey, const CScript& scriptcode, SigVersion sigversion)
245 : : {
246 : 31982 : CKeyID keyid = pubkey.GetID();
247 : 31982 : const auto it = sigdata.signatures.find(keyid);
248 [ + + ]: 31982 : if (it != sigdata.signatures.end()) {
249 : 671 : sig_out = it->second.second;
250 : 671 : return true;
251 : : }
252 [ + - ]: 31311 : KeyOriginInfo info;
253 [ + - + + ]: 31311 : if (provider.GetKeyOrigin(keyid, info)) {
254 [ + - ]: 23602 : sigdata.misc_pubkeys.emplace(keyid, std::make_pair(pubkey, std::move(info)));
255 : : }
256 [ + - + + ]: 31311 : if (creator.CreateSig(provider, sig_out, keyid, scriptcode, sigversion)) {
257 [ + - + - ]: 32446 : auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
258 [ - + ]: 16223 : assert(i.second);
259 : : return true;
260 : : }
261 : : // Could not make signature or signature not found, add keyid to missing
262 [ + - ]: 15088 : sigdata.missing_sigs.push_back(keyid);
263 : : return false;
264 : 31311 : }
265 : :
266 : 108572 : static bool SignMuSig2(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const XOnlyPubKey& script_pubkey, const uint256* merkle_root, const uint256* leaf_hash, SigVersion sigversion)
267 : : {
268 [ - + ]: 108572 : Assert(sigversion == SigVersion::TAPROOT || sigversion == SigVersion::TAPSCRIPT);
269 : :
270 : : // Lookup derivation paths for the script pubkey
271 : 108572 : KeyOriginInfo agg_info;
272 : 108572 : auto misc_pk_it = sigdata.taproot_misc_pubkeys.find(script_pubkey);
273 [ + + ]: 108572 : if (misc_pk_it != sigdata.taproot_misc_pubkeys.end()) {
274 [ + - ]: 100339 : agg_info = misc_pk_it->second.second;
275 : : }
276 : :
277 [ - + + + ]: 113482 : for (const auto& [agg_pub, part_pks] : sigdata.musig2_pubkeys) {
278 [ - + ]: 4910 : if (part_pks.empty()) continue;
279 : :
280 : : // Fill participant derivation path info
281 [ + + ]: 18368 : for (const auto& part_pk : part_pks) {
282 [ + - ]: 13458 : KeyOriginInfo part_info;
283 [ + - + - : 13458 : if (provider.GetKeyOrigin(part_pk.GetID(), part_info)) {
+ + ]
284 : 2789 : XOnlyPubKey xonly_part(part_pk);
285 : 2789 : auto it = sigdata.taproot_misc_pubkeys.find(xonly_part);
286 [ + + ]: 2789 : if (it == sigdata.taproot_misc_pubkeys.end()) {
287 [ + - + - ]: 106 : it = sigdata.taproot_misc_pubkeys.emplace(xonly_part, std::make_pair(std::set<uint256>(), part_info)).first;
288 : : }
289 [ + + + - ]: 2789 : if (leaf_hash) it->second.first.insert(*leaf_hash);
290 : : }
291 : 13458 : }
292 : :
293 : : // The pubkey in the script may not be the actual aggregate of the participants, but derived from it.
294 : : // Check the derivation, and compute the BIP 32 derivation tweaks
295 : 4910 : std::vector<std::pair<uint256, bool>> tweaks;
296 : 4910 : CPubKey plain_pub = agg_pub;
297 [ + + ]: 4910 : if (XOnlyPubKey(agg_pub) != script_pubkey) {
298 [ + + ]: 4211 : if (agg_info.path.empty()) continue;
299 : : // Compute and compare fingerprint
300 [ + - ]: 2044 : CKeyID keyid = agg_pub.GetID();
301 [ + + ]: 2044 : if (!std::equal(agg_info.fingerprint, agg_info.fingerprint + sizeof(agg_info.fingerprint), keyid.data())) {
302 : 1090 : continue;
303 : : }
304 : : // Get the BIP32 derivation tweaks
305 [ + - ]: 954 : CExtPubKey extpub = CreateMuSig2SyntheticXpub(agg_pub);
306 [ + + ]: 2862 : for (const int i : agg_info.path) {
307 [ + - + - ]: 1908 : auto& [t, xonly] = tweaks.emplace_back();
308 : 1908 : xonly = false;
309 [ + - + - ]: 1908 : if (!extpub.Derive(extpub, i, &t)) {
310 : : return false;
311 : : }
312 : : }
313 [ - + ]: 954 : Assert(XOnlyPubKey(extpub.pubkey) == script_pubkey);
314 : 954 : plain_pub = extpub.pubkey;
315 : : }
316 : :
317 : : // Add the merkle root tweak
318 [ + + ]: 1653 : if (sigversion == SigVersion::TAPROOT && merkle_root) {
319 [ + + + - : 1171 : tweaks.emplace_back(script_pubkey.ComputeTapTweakHash(merkle_root->IsNull() ? nullptr : merkle_root), true);
+ - ]
320 [ + + + - ]: 645 : std::optional<std::pair<XOnlyPubKey, bool>> tweaked = script_pubkey.CreateTapTweak(merkle_root->IsNull() ? nullptr : merkle_root);
321 [ + - ]: 526 : if (!Assume(tweaked)) return false;
322 [ + - + + ]: 1052 : plain_pub = tweaked->first.GetCPubKeys().at(tweaked->second ? 1 : 0);
323 : : }
324 : :
325 : : // First try to aggregate
326 [ + - + + ]: 1653 : if (creator.CreateMuSig2AggregateSig(part_pks, sig_out, agg_pub, plain_pub, leaf_hash, tweaks, sigversion, sigdata)) {
327 [ + + ]: 34 : if (sigversion == SigVersion::TAPROOT) {
328 [ + - ]: 20 : sigdata.taproot_key_path_sig = sig_out;
329 : : } else {
330 [ + - ]: 14 : auto lookup_key = std::make_pair(script_pubkey, leaf_hash ? *leaf_hash : uint256());
331 [ + - + - ]: 14 : sigdata.taproot_script_sigs[lookup_key] = sig_out;
332 : : }
333 : 34 : continue;
334 : 34 : }
335 : : // Cannot aggregate, try making partial sigs for every participant
336 [ + + ]: 1619 : auto pub_key_leaf_hash = std::make_pair(plain_pub, leaf_hash ? *leaf_hash : uint256());
337 [ + + ]: 6146 : for (const CPubKey& part_pk : part_pks) {
338 : 4527 : uint256 partial_sig;
339 [ + - + + : 4582 : if (creator.CreateMuSig2PartialSig(provider, partial_sig, agg_pub, plain_pub, part_pk, leaf_hash, tweaks, sigversion, sigdata) && Assume(!partial_sig.IsNull())) {
+ - ]
340 [ + - + - ]: 55 : sigdata.musig2_partial_sigs[pub_key_leaf_hash].emplace(part_pk, partial_sig);
341 : : }
342 : : }
343 : : // If there are any partial signatures, continue with next aggregate pubkey
344 : 1619 : auto partial_sigs_it = sigdata.musig2_partial_sigs.find(pub_key_leaf_hash);
345 [ + + - + ]: 1619 : if (partial_sigs_it != sigdata.musig2_partial_sigs.end() && !partial_sigs_it->second.empty()) {
346 : 320 : continue;
347 : : }
348 : : // No partial sigs, try to make pubnonces
349 [ + - ]: 1299 : std::map<CPubKey, std::vector<uint8_t>>& pubnonces = sigdata.musig2_pubnonces[pub_key_leaf_hash];
350 [ + + ]: 4914 : for (const CPubKey& part_pk : part_pks) {
351 [ + + ]: 3615 : if (pubnonces.contains(part_pk)) continue;
352 [ + - ]: 2312 : std::vector<uint8_t> pubnonce = creator.CreateMuSig2Nonce(provider, agg_pub, plain_pub, part_pk, leaf_hash, merkle_root, sigversion, sigdata);
353 [ + + ]: 2312 : if (pubnonce.empty()) continue;
354 [ + - ]: 63 : pubnonces[part_pk] = std::move(pubnonce);
355 : 2312 : }
356 : 4910 : }
357 : : return true;
358 : 108572 : }
359 : :
360 : 98568 : static bool CreateTaprootScriptSig(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const XOnlyPubKey& pubkey, const uint256& leaf_hash, SigVersion sigversion)
361 : : {
362 [ + - ]: 98568 : KeyOriginInfo info;
363 [ + - + + ]: 98568 : if (provider.GetKeyOriginByXOnly(pubkey, info)) {
364 : 47389 : auto it = sigdata.taproot_misc_pubkeys.find(pubkey);
365 [ + + ]: 47389 : if (it == sigdata.taproot_misc_pubkeys.end()) {
366 [ + - + - ]: 1370 : sigdata.taproot_misc_pubkeys.emplace(pubkey, std::make_pair(std::set<uint256>({leaf_hash}), info));
367 : : } else {
368 [ + - ]: 46704 : it->second.first.insert(leaf_hash);
369 : : }
370 : : }
371 : :
372 : 98568 : auto lookup_key = std::make_pair(pubkey, leaf_hash);
373 : 98568 : auto it = sigdata.taproot_script_sigs.find(lookup_key);
374 [ + + ]: 98568 : if (it != sigdata.taproot_script_sigs.end()) {
375 [ + - ]: 543 : sig_out = it->second;
376 : : return true;
377 : : }
378 : :
379 [ + - + + ]: 98025 : if (creator.CreateSchnorrSig(provider, sig_out, pubkey, &leaf_hash, nullptr, sigversion)) {
380 [ + - + - ]: 474 : sigdata.taproot_script_sigs[lookup_key] = sig_out;
381 [ + - + - ]: 97551 : } else if (!SignMuSig2(creator, sigdata, provider, sig_out, pubkey, /*merkle_root=*/nullptr, &leaf_hash, sigversion)) {
382 : : return false;
383 : : }
384 : :
385 : 98025 : return sigdata.taproot_script_sigs.contains(lookup_key);
386 : 98568 : }
387 : :
388 : : template<typename M, typename K, typename V>
389 : 73 : miniscript::Availability MsLookupHelper(const M& map, const K& key, V& value)
390 : : {
391 [ + + ]: 73 : auto it = map.find(key);
392 [ + + ]: 73 : if (it != map.end()) {
393 : 41 : value = it->second;
394 : 41 : return miniscript::Availability::YES;
395 : : }
396 : : return miniscript::Availability::NO;
397 : : }
398 : :
399 : : /**
400 : : * Context for solving a Miniscript.
401 : : * If enough material (access to keys, hash preimages, ..) is given, produces a valid satisfaction.
402 : : */
403 : : template<typename Pk>
404 : : struct Satisfier {
405 : : using Key = Pk;
406 : :
407 : : const SigningProvider& m_provider;
408 : : SignatureData& m_sig_data;
409 : : const BaseSignatureCreator& m_creator;
410 : : const CScript& m_witness_script;
411 : : //! The context of the script we are satisfying (either P2WSH or Tapscript).
412 : : const miniscript::MiniscriptContext m_script_ctx;
413 : :
414 : 2985 : explicit Satisfier(const SigningProvider& provider LIFETIMEBOUND, SignatureData& sig_data LIFETIMEBOUND,
415 : : const BaseSignatureCreator& creator LIFETIMEBOUND,
416 : : const CScript& witscript LIFETIMEBOUND,
417 : 2985 : miniscript::MiniscriptContext script_ctx) : m_provider(provider),
418 : 2985 : m_sig_data(sig_data),
419 : 2985 : m_creator(creator),
420 : 2985 : m_witness_script(witscript),
421 : 2985 : m_script_ctx(script_ctx) {}
422 : :
423 [ + + + + : 319823 : static bool KeyCompare(const Key& a, const Key& b) {
- - - - -
- - - + +
+ + + + ]
424 [ - + + - : 321141 : return a < b;
- - - - -
- - - + +
+ + - - -
- - - - -
+ + + + +
- + + + +
+ + ]
425 : : }
426 : :
427 : : //! Get a CPubKey from a key hash. Note the key hash may be of an xonly pubkey.
428 : : template<typename I>
429 [ - + ]: 90 : std::optional<CPubKey> CPubFromPKHBytes(I first, I last) const {
430 [ - + ]: 90 : assert(last - first == 20);
431 : 90 : CPubKey pubkey;
432 : 90 : CKeyID key_id;
433 : 90 : std::copy(first, last, key_id.begin());
434 [ + + ]: 90 : if (GetPubKey(m_provider, m_sig_data, key_id, pubkey)) return pubkey;
435 : 1 : m_sig_data.missing_pubkeys.push_back(key_id);
436 : 1 : return {};
437 : : }
438 : :
439 : : //! Conversion to raw public key.
440 : 89 : std::vector<unsigned char> ToPKBytes(const Key& key) const { return {key.begin(), key.end()}; }
441 : :
442 : : //! Time lock satisfactions.
443 : 253 : bool CheckAfter(uint32_t value) const { return m_creator.Checker().CheckLockTime(CScriptNum(value)); }
444 : 115 : bool CheckOlder(uint32_t value) const { return m_creator.Checker().CheckSequence(CScriptNum(value)); }
445 : :
446 : : //! Hash preimage satisfactions.
447 : 25 : miniscript::Availability SatSHA256(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
448 [ + - - - ]: 25 : return MsLookupHelper(m_sig_data.sha256_preimages, hash, preimage);
449 : : }
450 : 12 : miniscript::Availability SatRIPEMD160(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
451 [ + - - - ]: 12 : return MsLookupHelper(m_sig_data.ripemd160_preimages, hash, preimage);
452 : : }
453 : 24 : miniscript::Availability SatHASH256(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
454 [ + - + - ]: 24 : return MsLookupHelper(m_sig_data.hash256_preimages, hash, preimage);
455 : : }
456 : 12 : miniscript::Availability SatHASH160(const std::vector<unsigned char>& hash, std::vector<unsigned char>& preimage) const {
457 [ + - - - ]: 12 : return MsLookupHelper(m_sig_data.hash160_preimages, hash, preimage);
458 : : }
459 : :
460 : 6930834 : miniscript::MiniscriptContext MsContext() const {
461 [ - - + - : 6930834 : return m_script_ctx;
+ - + - +
- + - + -
+ - + - +
- + - - -
+ - + - +
- + - + -
- - + - +
- + - - -
- - + - +
- + - + -
- - - - +
- + - + -
- - - - -
- + - - -
- - + - +
- + - + -
+ - + - -
- + - + -
+ - - - -
- - - - -
+ - - - ]
462 : : }
463 : : };
464 : :
465 : : /** Miniscript satisfier specific to P2WSH context. */
466 : : struct WshSatisfier: Satisfier<CPubKey> {
467 : 271 : explicit WshSatisfier(const SigningProvider& provider LIFETIMEBOUND, SignatureData& sig_data LIFETIMEBOUND,
468 : : const BaseSignatureCreator& creator LIFETIMEBOUND, const CScript& witscript LIFETIMEBOUND)
469 : 271 : : Satisfier(provider, sig_data, creator, witscript, miniscript::MiniscriptContext::P2WSH) {}
470 : :
471 : : //! Conversion from a raw compressed public key.
472 : : template <typename I>
473 : 615 : std::optional<CPubKey> FromPKBytes(I first, I last) const {
474 [ + + ]: 615 : CPubKey pubkey{first, last};
475 [ + + ]: 615 : if (pubkey.IsValid()) return pubkey;
476 : 1 : return {};
477 : : }
478 : :
479 : : //! Conversion from a raw compressed public key hash.
480 : : template<typename I>
481 : 63 : std::optional<CPubKey> FromPKHBytes(I first, I last) const {
482 [ + - ]: 63 : return Satisfier::CPubFromPKHBytes(first, last);
483 : : }
484 : :
485 : : //! Satisfy an ECDSA signature check.
486 : 676 : miniscript::Availability Sign(const CPubKey& key, std::vector<unsigned char>& sig) const {
487 [ + + ]: 676 : if (CreateSig(m_creator, m_sig_data, m_provider, sig, key, m_witness_script, SigVersion::WITNESS_V0)) {
488 : 367 : return miniscript::Availability::YES;
489 : : }
490 : : return miniscript::Availability::NO;
491 : : }
492 : : };
493 : :
494 : : /** Miniscript satisfier specific to Tapscript context. */
495 : : struct TapSatisfier: Satisfier<XOnlyPubKey> {
496 : : const uint256& m_leaf_hash;
497 : :
498 : 2714 : explicit TapSatisfier(const SigningProvider& provider LIFETIMEBOUND, SignatureData& sig_data LIFETIMEBOUND,
499 : : const BaseSignatureCreator& creator LIFETIMEBOUND, const CScript& script LIFETIMEBOUND,
500 : : const uint256& leaf_hash LIFETIMEBOUND)
501 : 2714 : : Satisfier(provider, sig_data, creator, script, miniscript::MiniscriptContext::TAPSCRIPT),
502 : 2714 : m_leaf_hash(leaf_hash) {}
503 : :
504 : : //! Conversion from a raw xonly public key.
505 : : template <typename I>
506 [ + + ]: 98542 : std::optional<XOnlyPubKey> FromPKBytes(I first, I last) const {
507 [ + + ]: 98542 : if (last - first != 32) return {};
508 : 98541 : XOnlyPubKey pubkey;
509 : 98541 : std::copy(first, last, pubkey.begin());
510 : 98541 : return pubkey;
511 : : }
512 : :
513 : : //! Conversion from a raw xonly public key hash.
514 : : template<typename I>
515 : 27 : std::optional<XOnlyPubKey> FromPKHBytes(I first, I last) const {
516 [ + - ]: 27 : if (auto pubkey = Satisfier::CPubFromPKHBytes(first, last)) return XOnlyPubKey{*pubkey};
517 : 0 : return {};
518 : : }
519 : :
520 : : //! Satisfy a BIP340 signature check.
521 : 98568 : miniscript::Availability Sign(const XOnlyPubKey& key, std::vector<unsigned char>& sig) const {
522 [ + + ]: 98568 : if (CreateTaprootScriptSig(m_creator, m_sig_data, m_provider, sig, key, m_leaf_hash, SigVersion::TAPSCRIPT)) {
523 : 1031 : return miniscript::Availability::YES;
524 : : }
525 : : return miniscript::Availability::NO;
526 : : }
527 : : };
528 : :
529 : 2714 : static bool SignTaprootScript(const SigningProvider& provider, const BaseSignatureCreator& creator, SignatureData& sigdata, int leaf_version, std::span<const unsigned char> script_bytes, std::vector<valtype>& result)
530 : : {
531 : : // Only BIP342 tapscript signing is supported for now.
532 [ + - ]: 2714 : if (leaf_version != TAPROOT_LEAF_TAPSCRIPT) return false;
533 : :
534 : 2714 : uint256 leaf_hash = ComputeTapleafHash(leaf_version, script_bytes);
535 : 2714 : CScript script = CScript(script_bytes.begin(), script_bytes.end());
536 : :
537 : 2714 : TapSatisfier ms_satisfier{provider, sigdata, creator, script, leaf_hash};
538 [ + - ]: 2714 : const auto ms = miniscript::FromScript(script, ms_satisfier);
539 [ + + + - : 2714 : return ms && ms->Satisfy(ms_satisfier, result) == miniscript::Availability::YES;
+ + ]
540 : 2714 : }
541 : :
542 : 6270 : static bool SignTaproot(const SigningProvider& provider, const BaseSignatureCreator& creator, const WitnessV1Taproot& output, SignatureData& sigdata, std::vector<valtype>& result)
543 : : {
544 [ + - ]: 6270 : TaprootSpendData spenddata;
545 [ + - ]: 6270 : TaprootBuilder builder;
546 : :
547 : : // Gather information about this output.
548 [ + - + + ]: 6270 : if (provider.GetTaprootSpendData(output, spenddata)) {
549 [ + - + - ]: 2550 : sigdata.tr_spenddata.Merge(spenddata);
550 : : }
551 [ + - + + ]: 6270 : if (provider.GetTaprootBuilder(output, builder)) {
552 [ + - ]: 1275 : sigdata.tr_builder = builder;
553 : : }
554 [ + - + + ]: 6270 : if (auto agg_keys = provider.GetAllMuSig2ParticipantPubkeys(); !agg_keys.empty()) {
555 [ + - ]: 6270 : sigdata.musig2_pubkeys.insert(agg_keys.begin(), agg_keys.end());
556 : 0 : }
557 : :
558 : :
559 : : // Try key path spending.
560 : 6270 : {
561 [ + - ]: 6270 : KeyOriginInfo internal_key_info;
562 [ + - + + ]: 6270 : if (provider.GetKeyOriginByXOnly(sigdata.tr_spenddata.internal_key, internal_key_info)) {
563 : 1247 : auto it = sigdata.taproot_misc_pubkeys.find(sigdata.tr_spenddata.internal_key);
564 [ + + ]: 1247 : if (it == sigdata.taproot_misc_pubkeys.end()) {
565 [ + - + - ]: 780 : sigdata.taproot_misc_pubkeys.emplace(sigdata.tr_spenddata.internal_key, std::make_pair(std::set<uint256>(), internal_key_info));
566 : : }
567 : : }
568 : :
569 [ + - ]: 6270 : KeyOriginInfo output_key_info;
570 [ + - + + ]: 6270 : if (provider.GetKeyOriginByXOnly(output, output_key_info)) {
571 : 110 : auto it = sigdata.taproot_misc_pubkeys.find(output);
572 [ + + ]: 110 : if (it == sigdata.taproot_misc_pubkeys.end()) {
573 [ + - + - ]: 44 : sigdata.taproot_misc_pubkeys.emplace(output, std::make_pair(std::set<uint256>(), output_key_info));
574 : : }
575 : : }
576 : :
577 : 17854 : auto make_keypath_sig = [&](const XOnlyPubKey& pk, const uint256* merkle_root) {
578 : 11584 : std::vector<unsigned char> sig;
579 [ + - + + ]: 11584 : if (creator.CreateSchnorrSig(provider, sig, pk, nullptr, merkle_root, SigVersion::TAPROOT)) {
580 [ + - ]: 563 : sigdata.taproot_key_path_sig = sig;
581 : : } else {
582 [ + - ]: 11021 : SignMuSig2(creator, sigdata, provider, sig, pk, merkle_root, /*leaf_hash=*/nullptr, SigVersion::TAPROOT);
583 : : }
584 : 11584 : };
585 : :
586 : : // First try signing with internal key
587 [ - + + + ]: 6270 : if (sigdata.taproot_key_path_sig.size() == 0) {
588 [ + - ]: 6062 : make_keypath_sig(sigdata.tr_spenddata.internal_key, &sigdata.tr_spenddata.merkle_root);
589 : : }
590 : : // Try signing with output key if still no signature
591 [ - + + + ]: 6270 : if (sigdata.taproot_key_path_sig.size() == 0) {
592 [ + - ]: 5522 : make_keypath_sig(output, nullptr);
593 : : }
594 [ - + + + ]: 6270 : if (sigdata.taproot_key_path_sig.size()) {
595 [ + - ]: 1582 : result = Vector(sigdata.taproot_key_path_sig);
596 : 791 : return true;
597 : : }
598 : 6270 : }
599 : :
600 : : // Try script path spending.
601 : 5479 : std::vector<std::vector<unsigned char>> smallest_result_stack;
602 [ - + + + ]: 8193 : for (const auto& [key, control_blocks] : sigdata.tr_spenddata.scripts) {
603 : 2714 : const auto& [script, leaf_ver] = key;
604 : 2714 : std::vector<std::vector<unsigned char>> result_stack;
605 [ - + + - : 2714 : if (SignTaprootScript(provider, creator, sigdata, leaf_ver, script, result_stack)) {
+ + ]
606 [ + - ]: 640 : result_stack.emplace_back(std::begin(script), std::end(script)); // Push the script
607 [ + - ]: 640 : result_stack.push_back(*control_blocks.begin()); // Push the smallest control block
608 [ - + + + : 652 : if (smallest_result_stack.size() == 0 ||
+ + ]
609 : 12 : GetSerializeSize(result_stack) < GetSerializeSize(smallest_result_stack)) {
610 : 634 : smallest_result_stack = std::move(result_stack);
611 : : }
612 : : }
613 : 2714 : }
614 [ - + + + ]: 5479 : if (smallest_result_stack.size() != 0) {
615 : 628 : result = std::move(smallest_result_stack);
616 : 628 : return true;
617 : : }
618 : :
619 : : return false;
620 : 11749 : }
621 : :
622 : : /**
623 : : * Sign scriptPubKey using signature made with creator.
624 : : * Signatures are returned in scriptSigRet (or returns false if scriptPubKey can't be signed),
625 : : * unless whichTypeRet is TxoutType::SCRIPTHASH, in which case scriptSigRet is the redemption script.
626 : : * Returns false if scriptPubKey could not be completely satisfied.
627 : : */
628 : 138112 : static bool SignStep(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& scriptPubKey,
629 : : std::vector<valtype>& ret, TxoutType& whichTypeRet, SigVersion sigversion, SignatureData& sigdata)
630 : : {
631 : 138112 : CScript scriptRet;
632 : 138112 : ret.clear();
633 : 138112 : std::vector<unsigned char> sig;
634 : :
635 : 138112 : std::vector<valtype> vSolutions;
636 [ + - ]: 138112 : whichTypeRet = Solver(scriptPubKey, vSolutions);
637 : :
638 [ + + + + : 138112 : switch (whichTypeRet) {
+ + + + -
+ ]
639 : : case TxoutType::NONSTANDARD:
640 : : case TxoutType::NULL_DATA:
641 : : case TxoutType::WITNESS_UNKNOWN:
642 : : return false;
643 : 253 : case TxoutType::PUBKEY:
644 [ - + + - : 253 : if (!CreateSig(creator, sigdata, provider, sig, CPubKey(vSolutions[0]), scriptPubKey, sigversion)) return false;
+ + ]
645 [ + - ]: 177 : ret.push_back(std::move(sig));
646 : : return true;
647 : 83116 : case TxoutType::PUBKEYHASH: {
648 [ - + + - ]: 83116 : CKeyID keyID = CKeyID(uint160(vSolutions[0]));
649 [ + - ]: 83116 : CPubKey pubkey;
650 [ + - + + ]: 83116 : if (!GetPubKey(provider, sigdata, keyID, pubkey)) {
651 : : // Pubkey could not be found, add to missing
652 [ + - ]: 54105 : sigdata.missing_pubkeys.push_back(keyID);
653 : : return false;
654 : : }
655 [ + - + + ]: 29011 : if (!CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) return false;
656 [ + - ]: 15120 : ret.push_back(std::move(sig));
657 [ + - ]: 30240 : ret.push_back(ToByteVector(pubkey));
658 : 15120 : return true;
659 : : }
660 : 6653 : case TxoutType::SCRIPTHASH: {
661 [ - + ]: 6653 : uint160 h160{vSolutions[0]};
662 [ + - + + ]: 6653 : if (GetCScript(provider, sigdata, CScriptID{h160}, scriptRet)) {
663 [ + + + - ]: 5397 : ret.emplace_back(scriptRet.begin(), scriptRet.end());
664 : : return true;
665 : : }
666 : : // Could not find redeemScript, add to missing
667 : 1366 : sigdata.missing_redeem_script = h160;
668 : 1366 : return false;
669 : : }
670 : 455 : case TxoutType::MULTISIG: {
671 [ + - ]: 455 : size_t required = vSolutions.front()[0];
672 [ + - ]: 455 : ret.emplace_back(); // workaround CHECKMULTISIG bug
673 [ - + + + ]: 2497 : for (size_t i = 1; i < vSolutions.size() - 1; ++i) {
674 [ - + ]: 2042 : CPubKey pubkey = CPubKey(vSolutions[i]);
675 : : // We need to always call CreateSig in order to fill sigdata with all
676 : : // possible signatures that we can create. This will allow further PSBT
677 : : // processing to work as it needs all possible signature and pubkey pairs
678 [ + - + + ]: 2042 : if (CreateSig(creator, sigdata, provider, sig, pubkey, scriptPubKey, sigversion)) {
679 [ - + + + ]: 1230 : if (ret.size() < required + 1) {
680 [ + - ]: 2042 : ret.push_back(std::move(sig));
681 : : }
682 : : }
683 : : }
684 [ - + ]: 455 : bool ok = ret.size() == required + 1;
685 [ - + + + ]: 792 : for (size_t i = 0; i + ret.size() < required + 1; ++i) {
686 [ + - ]: 337 : ret.emplace_back();
687 : : }
688 : : return ok;
689 : : }
690 : 40084 : case TxoutType::WITNESS_V0_KEYHASH:
691 [ + - ]: 40084 : ret.push_back(vSolutions[0]);
692 : : return true;
693 : :
694 : 1040 : case TxoutType::WITNESS_V0_SCRIPTHASH:
695 [ - + + - : 1040 : if (GetCScript(provider, sigdata, CScriptID{RIPEMD160(vSolutions[0])}, scriptRet)) {
+ - + + ]
696 [ + + + - ]: 1408 : ret.emplace_back(scriptRet.begin(), scriptRet.end());
697 : : return true;
698 : : }
699 : : // Could not find witnessScript, add to missing
700 [ - + ]: 193 : sigdata.missing_witness_script = uint256(vSolutions[0]);
701 : 193 : return false;
702 : :
703 : 6270 : case TxoutType::WITNESS_V1_TAPROOT:
704 [ - + + - ]: 6270 : return SignTaproot(provider, creator, WitnessV1Taproot(XOnlyPubKey{vSolutions[0]}), sigdata, ret);
705 : :
706 : 1 : case TxoutType::ANCHOR:
707 : 1 : return true;
708 : : } // no default case, so the compiler can warn about missing cases
709 : 0 : assert(false);
710 : 138112 : }
711 : :
712 : 92107 : static CScript PushAll(const std::vector<valtype>& values)
713 : : {
714 : 92107 : CScript result;
715 [ + + ]: 108984 : for (const valtype& v : values) {
716 [ - + + + ]: 16877 : if (v.size() == 0) {
717 [ + - ]: 241 : result << OP_0;
718 [ - + - - : 16636 : } else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
- - ]
719 [ # # ]: 0 : result << CScript::EncodeOP_N(v[0]);
720 [ - + - - ]: 16636 : } else if (v.size() == 1 && v[0] == 0x81) {
721 [ # # ]: 0 : result << OP_1NEGATE;
722 : : } else {
723 : 16636 : result << v;
724 : : }
725 : : }
726 : 92107 : return result;
727 : 0 : }
728 : :
729 : 95741 : bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& fromPubKey, SignatureData& sigdata)
730 : : {
731 [ + + ]: 95741 : if (sigdata.complete) return true;
732 : :
733 : 92107 : std::vector<valtype> result;
734 : 92107 : TxoutType whichType;
735 [ + - ]: 92107 : bool solved = SignStep(provider, creator, fromPubKey, result, whichType, SigVersion::BASE, sigdata);
736 : 92107 : bool P2SH = false;
737 : 92107 : CScript subscript;
738 : :
739 [ + + + + ]: 92107 : if (solved && whichType == TxoutType::SCRIPTHASH)
740 : : {
741 : : // Solver returns the subscript that needs to be evaluated;
742 : : // the final scriptSig is the signatures from that
743 : : // and then the serialized subscript:
744 : 5287 : subscript = CScript(result[0].begin(), result[0].end());
745 : 5287 : sigdata.redeem_script = subscript;
746 [ + - + + : 5287 : solved = solved && SignStep(provider, creator, subscript, result, whichType, SigVersion::BASE, sigdata) && whichType != TxoutType::SCRIPTHASH;
+ - ]
747 : : P2SH = true;
748 : : }
749 : :
750 [ + + ]: 47805 : if (solved && whichType == TxoutType::WITNESS_V0_KEYHASH)
751 : : {
752 : 39882 : CScript witnessscript;
753 [ + - + - : 79764 : witnessscript << OP_DUP << OP_HASH160 << ToByteVector(result[0]) << OP_EQUALVERIFY << OP_CHECKSIG;
+ - + - +
- ]
754 : 39882 : TxoutType subType;
755 [ + - + - : 39882 : solved = solved && SignStep(provider, creator, witnessscript, result, subType, SigVersion::WITNESS_V0, sigdata);
+ + ]
756 [ + - ]: 39882 : sigdata.scriptWitness.stack = result;
757 : 39882 : sigdata.witness = true;
758 : 39882 : result.clear();
759 : 39882 : }
760 [ + + + + ]: 52128 : else if (solved && whichType == TxoutType::WITNESS_V0_SCRIPTHASH)
761 : : {
762 : 836 : CScript witnessscript(result[0].begin(), result[0].end());
763 : 836 : sigdata.witness_script = witnessscript;
764 : :
765 : 836 : TxoutType subType{TxoutType::NONSTANDARD};
766 [ + - + + : 836 : solved = solved && SignStep(provider, creator, witnessscript, result, subType, SigVersion::WITNESS_V0, sigdata) && subType != TxoutType::SCRIPTHASH && subType != TxoutType::WITNESS_V0_SCRIPTHASH && subType != TxoutType::WITNESS_V0_KEYHASH;
+ - + + +
+ ]
767 : :
768 : : // If we couldn't find a solution with the legacy satisfier, try satisfying the script using Miniscript.
769 : : // Note we need to check if the result stack is empty before, because it might be used even if the Script
770 : : // isn't fully solved. For instance the CHECKMULTISIG satisfaction in SignStep() pushes partial signatures
771 : : // and the extractor relies on this behaviour to combine witnesses.
772 [ + + ]: 686 : if (!solved && result.empty()) {
773 : 271 : WshSatisfier ms_satisfier{provider, sigdata, creator, witnessscript};
774 [ + - ]: 271 : const auto ms = miniscript::FromScript(witnessscript, ms_satisfier);
775 [ + + + - : 271 : solved = ms && ms->Satisfy(ms_satisfier, result) == miniscript::Availability::YES;
+ + ]
776 : 271 : }
777 [ + + + - ]: 1390 : result.emplace_back(witnessscript.begin(), witnessscript.end());
778 : :
779 [ + - ]: 836 : sigdata.scriptWitness.stack = result;
780 : 836 : sigdata.witness = true;
781 : 836 : result.clear();
782 [ + + + - ]: 52225 : } else if (whichType == TxoutType::WITNESS_V1_TAPROOT && !P2SH) {
783 : 6267 : sigdata.witness = true;
784 [ + + ]: 6267 : if (solved) {
785 : 1416 : sigdata.scriptWitness.stack = std::move(result);
786 : : }
787 : 6267 : result.clear();
788 [ + + - + ]: 45122 : } else if (solved && whichType == TxoutType::WITNESS_UNKNOWN) {
789 : 0 : sigdata.witness = true;
790 : : }
791 : :
792 [ + + ]: 92107 : if (!sigdata.witness) sigdata.scriptWitness.stack.clear();
793 [ + + ]: 92107 : if (P2SH) {
794 [ + + + - ]: 5397 : result.emplace_back(subscript.begin(), subscript.end());
795 : : }
796 [ + - ]: 92107 : sigdata.scriptSig = PushAll(result);
797 : :
798 : : // Test solution
799 [ + + + - : 92107 : sigdata.complete = solved && VerifyScript(sigdata.scriptSig, fromPubKey, &sigdata.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
+ - + + ]
800 : 92107 : return sigdata.complete;
801 : 92107 : }
802 : :
803 : : namespace {
804 : 66575 : class SignatureExtractorChecker final : public DeferringSignatureChecker
805 : : {
806 : : private:
807 : : SignatureData& sigdata;
808 : :
809 : : public:
810 : 66575 : SignatureExtractorChecker(SignatureData& sigdata, BaseSignatureChecker& checker) : DeferringSignatureChecker(checker), sigdata(sigdata) {}
811 : :
812 : 4450 : bool CheckECDSASignature(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override
813 : : {
814 [ + + ]: 4450 : if (m_checker.CheckECDSASignature(scriptSig, vchPubKey, scriptCode, sigversion)) {
815 [ - + ]: 3743 : CPubKey pubkey(vchPubKey);
816 [ + - + - ]: 3743 : sigdata.signatures.emplace(pubkey.GetID(), SigPair(pubkey, scriptSig));
817 : 3743 : return true;
818 : : }
819 : : return false;
820 : : }
821 : : };
822 : :
823 : 66575 : struct Stacks
824 : : {
825 : : std::vector<valtype> script;
826 : : std::vector<valtype> witness;
827 : :
828 : : Stacks() = delete;
829 : : Stacks(const Stacks&) = delete;
830 [ + - ]: 66575 : explicit Stacks(const SignatureData& data) : witness(data.scriptWitness.stack) {
831 [ + - ]: 66575 : EvalScript(script, data.scriptSig, SCRIPT_VERIFY_STRICTENC, BaseSignatureChecker(), SigVersion::BASE);
832 : 66575 : }
833 : : };
834 : : }
835 : :
836 : : // Extracts signatures and scripts from incomplete scriptSigs. Please do not extend this, use PSBT instead
837 : 66575 : SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nIn, const CTxOut& txout)
838 : : {
839 : 66575 : SignatureData data;
840 [ - + - + ]: 66575 : assert(tx.vin.size() > nIn);
841 : 66575 : data.scriptSig = tx.vin[nIn].scriptSig;
842 [ + - ]: 66575 : data.scriptWitness = tx.vin[nIn].scriptWitness;
843 [ + - ]: 66575 : Stacks stack(data);
844 : :
845 : : // Get signatures
846 [ + - ]: 66575 : MutableTransactionSignatureChecker tx_checker(&tx, nIn, txout.nValue, MissingDataBehavior::FAIL);
847 [ + - ]: 66575 : SignatureExtractorChecker extractor_checker(data, tx_checker);
848 [ + - + + ]: 66575 : if (VerifyScript(data.scriptSig, txout.scriptPubKey, &data.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, extractor_checker)) {
849 : 3631 : data.complete = true;
850 : 3631 : return data;
851 : : }
852 : :
853 : : // Get scripts
854 : 62944 : std::vector<std::vector<unsigned char>> solutions;
855 [ + - ]: 62944 : TxoutType script_type = Solver(txout.scriptPubKey, solutions);
856 : 62944 : SigVersion sigversion = SigVersion::BASE;
857 : 62944 : CScript next_script = txout.scriptPubKey;
858 : :
859 [ + + + + : 62944 : if (script_type == TxoutType::SCRIPTHASH && !stack.script.empty() && !stack.script.back().empty()) {
+ - ]
860 : : // Get the redeemScript
861 : 30 : CScript redeem_script(stack.script.back().begin(), stack.script.back().end());
862 : 30 : data.redeem_script = redeem_script;
863 : 30 : next_script = std::move(redeem_script);
864 : :
865 : : // Get redeemScript type
866 [ + - ]: 30 : script_type = Solver(next_script, solutions);
867 : 30 : stack.script.pop_back();
868 : 30 : }
869 [ + + + + : 62944 : if (script_type == TxoutType::WITNESS_V0_SCRIPTHASH && !stack.witness.empty() && !stack.witness.back().empty()) {
+ - ]
870 : : // Get the witnessScript
871 : 34 : CScript witness_script(stack.witness.back().begin(), stack.witness.back().end());
872 : 34 : data.witness_script = witness_script;
873 : 34 : next_script = std::move(witness_script);
874 : :
875 : : // Get witnessScript type
876 [ + - ]: 34 : script_type = Solver(next_script, solutions);
877 : 34 : stack.witness.pop_back();
878 : 34 : stack.script = std::move(stack.witness);
879 : 34 : stack.witness.clear();
880 : 34 : sigversion = SigVersion::WITNESS_V0;
881 : 34 : }
882 [ + + + - ]: 62944 : if (script_type == TxoutType::MULTISIG && !stack.script.empty()) {
883 : : // Build a map of pubkey -> signature by matching sigs to pubkeys:
884 [ - + - + ]: 50 : assert(solutions.size() > 1);
885 : 50 : unsigned int num_pubkeys = solutions.size()-2;
886 : 50 : unsigned int last_success_key = 0;
887 [ + + ]: 341 : for (const valtype& sig : stack.script) {
888 [ + + ]: 900 : for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
889 [ - + ]: 756 : const valtype& pubkey = solutions[i+1];
890 : : // We either have a signature for this pubkey, or we have found a signature and it is valid
891 [ - + + - : 756 : if (data.signatures.contains(CPubKey(pubkey).GetID()) || extractor_checker.CheckECDSASignature(sig, pubkey, next_script, sigversion)) {
+ - + - +
+ ]
892 : : last_success_key = i + 1;
893 : : break;
894 : : }
895 : : }
896 : : }
897 : : }
898 : :
899 : 62944 : return data;
900 : 133150 : }
901 : :
902 : 71159 : void UpdateInput(CTxIn& input, const SignatureData& data)
903 : : {
904 : 71159 : input.scriptSig = data.scriptSig;
905 : 71159 : input.scriptWitness = data.scriptWitness;
906 : 71159 : }
907 : :
908 : 78 : void SignatureData::MergeSignatureData(SignatureData sigdata)
909 : : {
910 [ + + ]: 78 : if (complete) return;
911 [ + + ]: 73 : if (sigdata.complete) {
912 : 8 : *this = std::move(sigdata);
913 : 8 : return;
914 : : }
915 [ + + + + : 78 : if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
+ + + + ]
916 : 13 : redeem_script = sigdata.redeem_script;
917 : : }
918 [ + + + + : 95 : if (witness_script.empty() && !sigdata.witness_script.empty()) {
+ + + + ]
919 : 14 : witness_script = sigdata.witness_script;
920 : : }
921 : 65 : signatures.insert(std::make_move_iterator(sigdata.signatures.begin()), std::make_move_iterator(sigdata.signatures.end()));
922 : : }
923 : :
924 : : namespace {
925 : : /** Dummy signature checker which accepts all signatures. */
926 : : class DummySignatureChecker final : public BaseSignatureChecker
927 : : {
928 : : public:
929 : : DummySignatureChecker() = default;
930 [ - + ]: 8 : bool CheckECDSASignature(const std::vector<unsigned char>& sig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override { return sig.size() != 0; }
931 : 0 : bool CheckSchnorrSignature(std::span<const unsigned char> sig, std::span<const unsigned char> pubkey, SigVersion sigversion, ScriptExecutionData& execdata, ScriptError* serror) const override { return sig.size() != 0; }
932 : 0 : bool CheckLockTime(const CScriptNum& nLockTime) const override { return true; }
933 : 0 : bool CheckSequence(const CScriptNum& nSequence) const override { return true; }
934 : : };
935 : : }
936 : :
937 : : const BaseSignatureChecker& DUMMY_CHECKER = DummySignatureChecker();
938 : :
939 : : namespace {
940 : : class DummySignatureCreator final : public BaseSignatureCreator {
941 : : private:
942 : : char m_r_len = 32;
943 : : char m_s_len = 32;
944 : : public:
945 : : DummySignatureCreator(char r_len, char s_len) : m_r_len(r_len), m_s_len(s_len) {}
946 : 7 : const BaseSignatureChecker& Checker() const override { return DUMMY_CHECKER; }
947 : 4 : bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const override
948 : : {
949 : : // Create a dummy signature that is a valid DER-encoding
950 : 4 : vchSig.assign(m_r_len + m_s_len + 7, '\000');
951 : 4 : vchSig[0] = 0x30;
952 : 4 : vchSig[1] = m_r_len + m_s_len + 4;
953 : 4 : vchSig[2] = 0x02;
954 : 4 : vchSig[3] = m_r_len;
955 : 4 : vchSig[4] = 0x01;
956 : 4 : vchSig[4 + m_r_len] = 0x02;
957 : 4 : vchSig[5 + m_r_len] = m_s_len;
958 : 4 : vchSig[6 + m_r_len] = 0x01;
959 : 4 : vchSig[6 + m_r_len + m_s_len] = SIGHASH_ALL;
960 : 4 : return true;
961 : : }
962 : 3 : bool CreateSchnorrSig(const SigningProvider& provider, std::vector<unsigned char>& sig, const XOnlyPubKey& pubkey, const uint256* leaf_hash, const uint256* tweak, SigVersion sigversion) const override
963 : : {
964 : 3 : sig.assign(64, '\000');
965 : 3 : return true;
966 : : }
967 : 0 : std::vector<uint8_t> CreateMuSig2Nonce(const SigningProvider& provider, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256* leaf_hash, const uint256* merkle_root, SigVersion sigversion, const SignatureData& sigdata) const override
968 : : {
969 : 0 : std::vector<uint8_t> out;
970 [ # # ]: 0 : out.assign(MUSIG2_PUBNONCE_SIZE, '\000');
971 : 0 : return out;
972 : 0 : }
973 : 0 : bool CreateMuSig2PartialSig(const SigningProvider& provider, uint256& partial_sig, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const CPubKey& part_pubkey, const uint256* leaf_hash, const std::vector<std::pair<uint256, bool>>& tweaks, SigVersion sigversion, const SignatureData& sigdata) const override
974 : : {
975 : 0 : partial_sig = uint256::ONE;
976 : 0 : return true;
977 : : }
978 : 0 : bool CreateMuSig2AggregateSig(const std::vector<CPubKey>& participants, std::vector<uint8_t>& sig, const CPubKey& aggregate_pubkey, const CPubKey& script_pubkey, const uint256* leaf_hash, const std::vector<std::pair<uint256, bool>>& tweaks, SigVersion sigversion, const SignatureData& sigdata) const override
979 : : {
980 : 0 : sig.assign(64, '\000');
981 : 0 : return true;
982 : : }
983 : : };
984 : :
985 : : }
986 : :
987 : : const BaseSignatureCreator& DUMMY_SIGNATURE_CREATOR = DummySignatureCreator(32, 32);
988 : : const BaseSignatureCreator& DUMMY_MAXIMUM_SIGNATURE_CREATOR = DummySignatureCreator(33, 32);
989 : :
990 : 0 : bool IsSegWitOutput(const SigningProvider& provider, const CScript& script)
991 : : {
992 : 0 : int version;
993 : 0 : valtype program;
994 [ # # # # ]: 0 : if (script.IsWitnessProgram(version, program)) return true;
995 [ # # # # ]: 0 : if (script.IsPayToScriptHash()) {
996 : 0 : std::vector<valtype> solutions;
997 [ # # ]: 0 : auto whichtype = Solver(script, solutions);
998 [ # # ]: 0 : if (whichtype == TxoutType::SCRIPTHASH) {
999 [ # # ]: 0 : auto h160 = uint160(solutions[0]);
1000 : 0 : CScript subscript;
1001 [ # # # # ]: 0 : if (provider.GetCScript(CScriptID{h160}, subscript)) {
1002 [ # # # # ]: 0 : if (subscript.IsWitnessProgram(version, program)) return true;
1003 : : }
1004 : 0 : }
1005 : 0 : }
1006 : : return false;
1007 : 0 : }
1008 : :
1009 : 18881 : bool SignTransaction(CMutableTransaction& mtx, const SigningProvider* keystore, const std::map<COutPoint, Coin>& coins, int nHashType, std::map<int, bilingual_str>& input_errors)
1010 : : {
1011 : 18881 : bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);
1012 : :
1013 : : // Use CTransaction for the constant parts of the
1014 : : // transaction to avoid rehashing.
1015 : 18881 : const CTransaction txConst(mtx);
1016 : :
1017 : 18881 : PrecomputedTransactionData txdata;
1018 : 18881 : std::vector<CTxOut> spent_outputs;
1019 [ - + + + ]: 85398 : for (unsigned int i = 0; i < mtx.vin.size(); ++i) {
1020 : 66527 : CTxIn& txin = mtx.vin[i];
1021 : 66527 : auto coin = coins.find(txin.prevout);
1022 [ + - + + ]: 66527 : if (coin == coins.end() || coin->second.IsSpent()) {
1023 [ + - ]: 10 : txdata.Init(txConst, /*spent_outputs=*/{}, /*force=*/true);
1024 : 10 : break;
1025 : : } else {
1026 [ + - ]: 66517 : spent_outputs.emplace_back(coin->second.out.nValue, coin->second.out.scriptPubKey);
1027 : : }
1028 : : }
1029 [ - + - + : 18881 : if (spent_outputs.size() == mtx.vin.size()) {
+ + ]
1030 [ + - ]: 18871 : txdata.Init(txConst, std::move(spent_outputs), true);
1031 : : }
1032 : :
1033 : : // Sign what we can:
1034 [ - + + + ]: 85417 : for (unsigned int i = 0; i < mtx.vin.size(); ++i) {
1035 : 66536 : CTxIn& txin = mtx.vin[i];
1036 : 66536 : auto coin = coins.find(txin.prevout);
1037 [ + - + + ]: 66536 : if (coin == coins.end() || coin->second.IsSpent()) {
1038 [ + - + - ]: 19 : input_errors[i] = _("Input not found or already spent");
1039 : 19 : continue;
1040 : : }
1041 [ + - ]: 66517 : const CScript& prevPubKey = coin->second.out.scriptPubKey;
1042 : 66517 : const CAmount& amount = coin->second.out.nValue;
1043 : :
1044 [ + - ]: 133023 : SignatureData sigdata = DataFromTransaction(mtx, i, coin->second.out);
1045 : : // Only sign SIGHASH_SINGLE if there's a corresponding output:
1046 [ - + - - : 66517 : if (!fHashSingle || (i < mtx.vout.size())) {
- - ]
1047 [ + - + - ]: 133034 : ProduceSignature(*keystore, MutableTransactionSignatureCreator(mtx, i, amount, &txdata, nHashType), prevPubKey, sigdata);
1048 : : }
1049 : :
1050 [ + - ]: 66517 : UpdateInput(txin, sigdata);
1051 : :
1052 : : // amount must be specified for valid segwit signature
1053 [ + + + + ]: 66517 : if (amount == MAX_MONEY && !txin.scriptWitness.IsNull()) {
1054 [ + - + - ]: 11 : input_errors[i] = _("Missing amount");
1055 : 11 : continue;
1056 : : }
1057 : :
1058 : 66506 : ScriptError serror = SCRIPT_ERR_OK;
1059 [ + + + - : 119725 : if (!sigdata.complete && !VerifyScript(txin.scriptSig, prevPubKey, &txin.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, TransactionSignatureChecker(&txConst, i, amount, txdata, MissingDataBehavior::FAIL), &serror)) {
+ + + + ]
1060 [ + + ]: 53199 : if (serror == SCRIPT_ERR_INVALID_STACK_OPERATION) {
1061 : : // Unable to sign input and verification failed (possible attempt to partially sign).
1062 [ + - + - : 68982 : input_errors[i] = Untranslated("Unable to sign input, invalid stack size (possibly missing key)");
+ - ]
1063 [ + + ]: 18708 : } else if (serror == SCRIPT_ERR_SIG_NULLFAIL) {
1064 : : // Verification failed (possibly due to insufficient signatures).
1065 [ + - + - : 136 : input_errors[i] = Untranslated("CHECK(MULTI)SIG failing with non-zero signature (possibly need more signatures)");
+ - ]
1066 : : } else {
1067 [ + - + - : 37280 : input_errors[i] = Untranslated(ScriptErrorString(serror));
+ - ]
1068 : : }
1069 : : } else {
1070 : : // If this input succeeds, make sure there is no error set for it
1071 : 13307 : input_errors.erase(i);
1072 : : }
1073 : 66517 : }
1074 : 18881 : return input_errors.empty();
1075 : 37762 : }
|
