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