Branch data Line data Source code
1 : : // Copyright (c) 2009-2022 The Bitcoin Core developers
2 : : // Copyright (c) 2017 The Zcash 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 <pubkey.h>
7 : :
8 : : #include <hash.h>
9 : : #include <secp256k1.h>
10 : : #include <secp256k1_ellswift.h>
11 : : #include <secp256k1_extrakeys.h>
12 : : #include <secp256k1_recovery.h>
13 : : #include <secp256k1_schnorrsig.h>
14 : : #include <span.h>
15 : : #include <uint256.h>
16 : :
17 : : #include <algorithm>
18 : : #include <cassert>
19 : :
20 : : namespace {
21 : :
22 : : struct Secp256k1SelfTester
23 : : {
24 : 173 : Secp256k1SelfTester() {
25 : : /* Run libsecp256k1 self-test before using the secp256k1_context_static. */
26 : 173 : secp256k1_selftest();
27 : 173 : }
28 : 173 : } SECP256K1_SELFTESTER;
29 : :
30 : : } // namespace
31 : :
32 : : /** This function is taken from the libsecp256k1 distribution and implements
33 : : * DER parsing for ECDSA signatures, while supporting an arbitrary subset of
34 : : * format violations.
35 : : *
36 : : * Supported violations include negative integers, excessive padding, garbage
37 : : * at the end, and overly long length descriptors. This is safe to use in
38 : : * Bitcoin because since the activation of BIP66, signatures are verified to be
39 : : * strict DER before being passed to this module, and we know it supports all
40 : : * violations present in the blockchain before that point.
41 : : */
42 : 86333 : int ecdsa_signature_parse_der_lax(secp256k1_ecdsa_signature* sig, const unsigned char *input, size_t inputlen) {
43 : : size_t rpos, rlen, spos, slen;
44 : 86333 : size_t pos = 0;
45 : : size_t lenbyte;
46 : 86333 : unsigned char tmpsig[64] = {0};
47 : 86333 : int overflow = 0;
48 : :
49 : : /* Hack to initialize sig with a correctly-parsed but invalid signature. */
50 : 86333 : secp256k1_ecdsa_signature_parse_compact(secp256k1_context_static, sig, tmpsig);
51 : :
52 : : /* Sequence tag byte */
53 [ + + + + ]: 86333 : if (pos == inputlen || input[pos] != 0x30) {
54 : 2376 : return 0;
55 : : }
56 : 83957 : pos++;
57 : :
58 : : /* Sequence length bytes */
59 [ + + ]: 83957 : if (pos == inputlen) {
60 : 243 : return 0;
61 : : }
62 : 83714 : lenbyte = input[pos++];
63 [ + + ]: 83714 : if (lenbyte & 0x80) {
64 : 921 : lenbyte -= 0x80;
65 [ + + ]: 921 : if (lenbyte > inputlen - pos) {
66 : 218 : return 0;
67 : : }
68 : 703 : pos += lenbyte;
69 : 703 : }
70 : :
71 : : /* Integer tag byte for R */
72 [ + + + + ]: 83496 : if (pos == inputlen || input[pos] != 0x02) {
73 : 682 : return 0;
74 : : }
75 : 82814 : pos++;
76 : :
77 : : /* Integer length for R */
78 [ + + ]: 82814 : if (pos == inputlen) {
79 : 206 : return 0;
80 : : }
81 : 82608 : lenbyte = input[pos++];
82 [ + + ]: 82608 : if (lenbyte & 0x80) {
83 : 1622 : lenbyte -= 0x80;
84 [ + + ]: 1622 : if (lenbyte > inputlen - pos) {
85 : 360 : return 0;
86 : : }
87 [ + + + + ]: 3055 : while (lenbyte > 0 && input[pos] == 0) {
88 : 1793 : pos++;
89 : 1793 : lenbyte--;
90 : : }
91 : : static_assert(sizeof(size_t) >= 4, "size_t too small");
92 [ + + ]: 1262 : if (lenbyte >= 4) {
93 : 236 : return 0;
94 : : }
95 : 1026 : rlen = 0;
96 [ + + ]: 2134 : while (lenbyte > 0) {
97 : 1108 : rlen = (rlen << 8) + input[pos];
98 : 1108 : pos++;
99 : 1108 : lenbyte--;
100 : : }
101 : 1026 : } else {
102 : 80986 : rlen = lenbyte;
103 : : }
104 [ + + ]: 82012 : if (rlen > inputlen - pos) {
105 : 551 : return 0;
106 : : }
107 : 81461 : rpos = pos;
108 : 81461 : pos += rlen;
109 : :
110 : : /* Integer tag byte for S */
111 [ + + + + ]: 81461 : if (pos == inputlen || input[pos] != 0x02) {
112 : 590 : return 0;
113 : : }
114 : 80871 : pos++;
115 : :
116 : : /* Integer length for S */
117 [ + + ]: 80871 : if (pos == inputlen) {
118 : 230 : return 0;
119 : : }
120 : 80641 : lenbyte = input[pos++];
121 [ + + ]: 80641 : if (lenbyte & 0x80) {
122 : 1094 : lenbyte -= 0x80;
123 [ + + ]: 1094 : if (lenbyte > inputlen - pos) {
124 : 208 : return 0;
125 : : }
126 [ + + + + ]: 2488 : while (lenbyte > 0 && input[pos] == 0) {
127 : 1602 : pos++;
128 : 1602 : lenbyte--;
129 : : }
130 : : static_assert(sizeof(size_t) >= 4, "size_t too small");
131 [ + + ]: 886 : if (lenbyte >= 4) {
132 : 130 : return 0;
133 : : }
134 : 756 : slen = 0;
135 [ + + ]: 1514 : while (lenbyte > 0) {
136 : 758 : slen = (slen << 8) + input[pos];
137 : 758 : pos++;
138 : 758 : lenbyte--;
139 : : }
140 : 756 : } else {
141 : 79547 : slen = lenbyte;
142 : : }
143 [ + + ]: 80303 : if (slen > inputlen - pos) {
144 : 537 : return 0;
145 : : }
146 : 79766 : spos = pos;
147 : :
148 : : /* Ignore leading zeroes in R */
149 [ + + + + ]: 115727 : while (rlen > 0 && input[rpos] == 0) {
150 : 35961 : rlen--;
151 : 35961 : rpos++;
152 : : }
153 : : /* Copy R value */
154 [ + + ]: 79766 : if (rlen > 32) {
155 : 625 : overflow = 1;
156 : 625 : } else {
157 : 79141 : memcpy(tmpsig + 32 - rlen, input + rpos, rlen);
158 : : }
159 : :
160 : : /* Ignore leading zeroes in S */
161 [ + + + + ]: 82864 : while (slen > 0 && input[spos] == 0) {
162 : 3098 : slen--;
163 : 3098 : spos++;
164 : : }
165 : : /* Copy S value */
166 [ + + ]: 79766 : if (slen > 32) {
167 : 654 : overflow = 1;
168 : 654 : } else {
169 : 79112 : memcpy(tmpsig + 64 - slen, input + spos, slen);
170 : : }
171 : :
172 [ + + ]: 79766 : if (!overflow) {
173 : 78487 : overflow = !secp256k1_ecdsa_signature_parse_compact(secp256k1_context_static, sig, tmpsig);
174 : 78487 : }
175 [ + + ]: 79766 : if (overflow) {
176 : : /* Overwrite the result again with a correctly-parsed but invalid
177 : : signature if parsing failed. */
178 : 1553 : memset(tmpsig, 0, 64);
179 : 1553 : secp256k1_ecdsa_signature_parse_compact(secp256k1_context_static, sig, tmpsig);
180 : 1553 : }
181 : 79766 : return 1;
182 : 86333 : }
183 : :
184 : 19854 : XOnlyPubKey::XOnlyPubKey(Span<const unsigned char> bytes)
185 : : {
186 [ + - ]: 19854 : assert(bytes.size() == 32);
187 : 19854 : std::copy(bytes.begin(), bytes.end(), m_keydata.begin());
188 : 19854 : }
189 : :
190 : 4554 : std::vector<CKeyID> XOnlyPubKey::GetKeyIDs() const
191 : : {
192 : 4554 : std::vector<CKeyID> out;
193 : : // For now, use the old full pubkey-based key derivation logic. As it is indexed by
194 : : // Hash160(full pubkey), we need to return both a version prefixed with 0x02, and one
195 : : // with 0x03.
196 : 4554 : unsigned char b[33] = {0x02};
197 [ + - + - : 4554 : std::copy(m_keydata.begin(), m_keydata.end(), b + 1);
+ - ]
198 [ + - ]: 4554 : CPubKey fullpubkey;
199 [ + - ]: 4554 : fullpubkey.Set(b, b + 33);
200 [ + - + - ]: 4554 : out.push_back(fullpubkey.GetID());
201 : 4554 : b[0] = 0x03;
202 [ + - ]: 4554 : fullpubkey.Set(b, b + 33);
203 [ + - + - ]: 4554 : out.push_back(fullpubkey.GetID());
204 : 4554 : return out;
205 [ + - ]: 4554 : }
206 : :
207 : 4690 : bool XOnlyPubKey::IsFullyValid() const
208 : : {
209 : : secp256k1_xonly_pubkey pubkey;
210 : 4690 : return secp256k1_xonly_pubkey_parse(secp256k1_context_static, &pubkey, m_keydata.data());
211 : : }
212 : :
213 : 1481 : bool XOnlyPubKey::VerifySchnorr(const uint256& msg, Span<const unsigned char> sigbytes) const
214 : : {
215 [ + - ]: 1481 : assert(sigbytes.size() == 64);
216 : : secp256k1_xonly_pubkey pubkey;
217 [ + + ]: 1481 : if (!secp256k1_xonly_pubkey_parse(secp256k1_context_static, &pubkey, m_keydata.data())) return false;
218 : 1473 : return secp256k1_schnorrsig_verify(secp256k1_context_static, sigbytes.data(), msg.begin(), 32, &pubkey);
219 : 1481 : }
220 : :
221 [ + - - + ]: 173 : static const HashWriter HASHER_TAPTWEAK{TaggedHash("TapTweak")};
222 : :
223 : 597 : uint256 XOnlyPubKey::ComputeTapTweakHash(const uint256* merkle_root) const
224 : : {
225 [ + + ]: 597 : if (merkle_root == nullptr) {
226 : : // We have no scripts. The actual tweak does not matter, but follow BIP341 here to
227 : : // allow for reproducible tweaking.
228 : 23 : return (HashWriter{HASHER_TAPTWEAK} << m_keydata).GetSHA256();
229 : : } else {
230 : 574 : return (HashWriter{HASHER_TAPTWEAK} << m_keydata << *merkle_root).GetSHA256();
231 : : }
232 : 597 : }
233 : :
234 : 294 : bool XOnlyPubKey::CheckTapTweak(const XOnlyPubKey& internal, const uint256& merkle_root, bool parity) const
235 : : {
236 : : secp256k1_xonly_pubkey internal_key;
237 [ + + ]: 294 : if (!secp256k1_xonly_pubkey_parse(secp256k1_context_static, &internal_key, internal.data())) return false;
238 : 280 : uint256 tweak = internal.ComputeTapTweakHash(&merkle_root);
239 : 280 : return secp256k1_xonly_pubkey_tweak_add_check(secp256k1_context_static, m_keydata.begin(), parity, &internal_key, tweak.begin());
240 : 294 : }
241 : :
242 : 317 : std::optional<std::pair<XOnlyPubKey, bool>> XOnlyPubKey::CreateTapTweak(const uint256* merkle_root) const
243 : : {
244 : : secp256k1_xonly_pubkey base_point;
245 [ + - ]: 317 : if (!secp256k1_xonly_pubkey_parse(secp256k1_context_static, &base_point, data())) return std::nullopt;
246 : : secp256k1_pubkey out;
247 : 317 : uint256 tweak = ComputeTapTweakHash(merkle_root);
248 [ + - ]: 317 : if (!secp256k1_xonly_pubkey_tweak_add(secp256k1_context_static, &out, &base_point, tweak.data())) return std::nullopt;
249 : 317 : int parity = -1;
250 : 317 : std::pair<XOnlyPubKey, bool> ret;
251 : : secp256k1_xonly_pubkey out_xonly;
252 [ + - ]: 317 : if (!secp256k1_xonly_pubkey_from_pubkey(secp256k1_context_static, &out_xonly, &parity, &out)) return std::nullopt;
253 : 317 : secp256k1_xonly_pubkey_serialize(secp256k1_context_static, ret.first.begin(), &out_xonly);
254 [ + + - + ]: 317 : assert(parity == 0 || parity == 1);
255 : 317 : ret.second = parity;
256 : 317 : return ret;
257 : 317 : }
258 : :
259 : :
260 : 79347 : bool CPubKey::Verify(const uint256 &hash, const std::vector<unsigned char>& vchSig) const {
261 [ + + ]: 79347 : if (!IsValid())
262 : 3 : return false;
263 : : secp256k1_pubkey pubkey;
264 : : secp256k1_ecdsa_signature sig;
265 [ + + ]: 79344 : if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size())) {
266 : 1571 : return false;
267 : : }
268 [ + + ]: 77773 : if (!ecdsa_signature_parse_der_lax(&sig, vchSig.data(), vchSig.size())) {
269 : 6490 : return false;
270 : : }
271 : : /* libsecp256k1's ECDSA verification requires lower-S signatures, which have
272 : : * not historically been enforced in Bitcoin, so normalize them first. */
273 : 71283 : secp256k1_ecdsa_signature_normalize(secp256k1_context_static, &sig, &sig);
274 : 71283 : return secp256k1_ecdsa_verify(secp256k1_context_static, &sig, hash.begin(), &pubkey);
275 : 79347 : }
276 : :
277 : 105 : bool CPubKey::RecoverCompact(const uint256 &hash, const std::vector<unsigned char>& vchSig) {
278 [ + + ]: 105 : if (vchSig.size() != COMPACT_SIGNATURE_SIZE)
279 : 1 : return false;
280 : 104 : int recid = (vchSig[0] - 27) & 3;
281 : 104 : bool fComp = ((vchSig[0] - 27) & 4) != 0;
282 : : secp256k1_pubkey pubkey;
283 : : secp256k1_ecdsa_recoverable_signature sig;
284 [ + - ]: 104 : if (!secp256k1_ecdsa_recoverable_signature_parse_compact(secp256k1_context_static, &sig, &vchSig[1], recid)) {
285 : 0 : return false;
286 : : }
287 [ - + ]: 104 : if (!secp256k1_ecdsa_recover(secp256k1_context_static, &pubkey, &sig, hash.begin())) {
288 : 0 : return false;
289 : : }
290 : : unsigned char pub[SIZE];
291 : 104 : size_t publen = SIZE;
292 : 104 : secp256k1_ec_pubkey_serialize(secp256k1_context_static, pub, &publen, &pubkey, fComp ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
293 : 104 : Set(pub, pub + publen);
294 : 104 : return true;
295 : 105 : }
296 : :
297 : 82008 : bool CPubKey::IsFullyValid() const {
298 [ + + ]: 82008 : if (!IsValid())
299 : 13174 : return false;
300 : : secp256k1_pubkey pubkey;
301 : 68834 : return secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size());
302 : 82008 : }
303 : :
304 : 12469 : bool CPubKey::Decompress() {
305 [ - + ]: 12469 : if (!IsValid())
306 : 0 : return false;
307 : : secp256k1_pubkey pubkey;
308 [ + + ]: 12469 : if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size())) {
309 : 3946 : return false;
310 : : }
311 : : unsigned char pub[SIZE];
312 : 8523 : size_t publen = SIZE;
313 : 8523 : secp256k1_ec_pubkey_serialize(secp256k1_context_static, pub, &publen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
314 : 8523 : Set(pub, pub + publen);
315 : 8523 : return true;
316 : 12469 : }
317 : :
318 : 234187 : bool CPubKey::Derive(CPubKey& pubkeyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
319 [ + - ]: 234187 : assert(IsValid());
320 [ + - ]: 234187 : assert((nChild >> 31) == 0);
321 [ - + ]: 234187 : assert(size() == COMPRESSED_SIZE);
322 : : unsigned char out[64];
323 : 234187 : BIP32Hash(cc, nChild, *begin(), begin()+1, out);
324 : 234187 : memcpy(ccChild.begin(), out+32, 32);
325 : : secp256k1_pubkey pubkey;
326 [ + - ]: 234187 : if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &pubkey, vch, size())) {
327 : 0 : return false;
328 : : }
329 [ - + ]: 234187 : if (!secp256k1_ec_pubkey_tweak_add(secp256k1_context_static, &pubkey, out)) {
330 : 0 : return false;
331 : : }
332 : : unsigned char pub[COMPRESSED_SIZE];
333 : 234187 : size_t publen = COMPRESSED_SIZE;
334 : 234187 : secp256k1_ec_pubkey_serialize(secp256k1_context_static, pub, &publen, &pubkey, SECP256K1_EC_COMPRESSED);
335 : 234187 : pubkeyChild.Set(pub, pub + publen);
336 : 234187 : return true;
337 : 234187 : }
338 : :
339 : 1951 : EllSwiftPubKey::EllSwiftPubKey(Span<const std::byte> ellswift) noexcept
340 : : {
341 [ + - ]: 1951 : assert(ellswift.size() == SIZE);
342 [ - + ]: 1951 : std::copy(ellswift.begin(), ellswift.end(), m_pubkey.begin());
343 : 1951 : }
344 : :
345 : 80 : CPubKey EllSwiftPubKey::Decode() const
346 : : {
347 : : secp256k1_pubkey pubkey;
348 : 80 : secp256k1_ellswift_decode(secp256k1_context_static, &pubkey, UCharCast(m_pubkey.data()));
349 : :
350 : 80 : size_t sz = CPubKey::COMPRESSED_SIZE;
351 : : std::array<uint8_t, CPubKey::COMPRESSED_SIZE> vch_bytes;
352 : :
353 : 80 : secp256k1_ec_pubkey_serialize(secp256k1_context_static, vch_bytes.data(), &sz, &pubkey, SECP256K1_EC_COMPRESSED);
354 [ + - ]: 80 : assert(sz == vch_bytes.size());
355 : :
356 : 80 : return CPubKey{vch_bytes.begin(), vch_bytes.end()};
357 : : }
358 : :
359 : 9003 : void CExtPubKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
360 : 9003 : code[0] = nDepth;
361 : 9003 : memcpy(code+1, vchFingerprint, 4);
362 : 9003 : WriteBE32(code+5, nChild);
363 : 9003 : memcpy(code+9, chaincode.begin(), 32);
364 [ + - ]: 9003 : assert(pubkey.size() == CPubKey::COMPRESSED_SIZE);
365 : 9003 : memcpy(code+41, pubkey.begin(), CPubKey::COMPRESSED_SIZE);
366 : 9003 : }
367 : :
368 : 23349 : void CExtPubKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
369 : 23349 : nDepth = code[0];
370 : 23349 : memcpy(vchFingerprint, code+1, 4);
371 : 23349 : nChild = ReadBE32(code+5);
372 : 23349 : memcpy(chaincode.begin(), code+9, 32);
373 : 23349 : pubkey.Set(code+41, code+BIP32_EXTKEY_SIZE);
374 [ + + + + : 23349 : if ((nDepth == 0 && (nChild != 0 || ReadLE32(vchFingerprint) != 0)) || !pubkey.IsFullyValid()) pubkey = CPubKey();
+ + ]
375 : 23349 : }
376 : :
377 : 4036 : void CExtPubKey::EncodeWithVersion(unsigned char code[BIP32_EXTKEY_WITH_VERSION_SIZE]) const
378 : : {
379 : 4036 : memcpy(code, version, 4);
380 : 4036 : Encode(&code[4]);
381 : 4036 : }
382 : :
383 : 11653 : void CExtPubKey::DecodeWithVersion(const unsigned char code[BIP32_EXTKEY_WITH_VERSION_SIZE])
384 : : {
385 : 11653 : memcpy(version, code, 4);
386 : 11653 : Decode(&code[4]);
387 : 11653 : }
388 : :
389 : 234214 : bool CExtPubKey::Derive(CExtPubKey &out, unsigned int _nChild) const {
390 [ + + ]: 234214 : if (nDepth == std::numeric_limits<unsigned char>::max()) return false;
391 : 234143 : out.nDepth = nDepth + 1;
392 : 234143 : CKeyID id = pubkey.GetID();
393 : 234143 : memcpy(out.vchFingerprint, &id, 4);
394 : 234143 : out.nChild = _nChild;
395 : 234143 : return pubkey.Derive(out.pubkey, out.chaincode, _nChild, chaincode);
396 : 234214 : }
397 : :
398 : 8511 : /* static */ bool CPubKey::CheckLowS(const std::vector<unsigned char>& vchSig) {
399 : : secp256k1_ecdsa_signature sig;
400 [ + + ]: 8511 : if (!ecdsa_signature_parse_der_lax(&sig, vchSig.data(), vchSig.size())) {
401 : 44 : return false;
402 : : }
403 : 8467 : return (!secp256k1_ecdsa_signature_normalize(secp256k1_context_static, nullptr, &sig));
404 : 8511 : }
|
