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 <key.h>
7 : :
8 : : #include <crypto/common.h>
9 : : #include <crypto/hmac_sha512.h>
10 : : #include <hash.h>
11 : : #include <random.h>
12 : :
13 : : #include <secp256k1.h>
14 : : #include <secp256k1_ellswift.h>
15 : : #include <secp256k1_extrakeys.h>
16 : : #include <secp256k1_recovery.h>
17 : : #include <secp256k1_schnorrsig.h>
18 : :
19 : : static secp256k1_context* secp256k1_context_sign = nullptr;
20 : :
21 : : /** These functions are taken from the libsecp256k1 distribution and are very ugly. */
22 : :
23 : : /**
24 : : * This parses a format loosely based on a DER encoding of the ECPrivateKey type from
25 : : * section C.4 of SEC 1 <https://www.secg.org/sec1-v2.pdf>, with the following caveats:
26 : : *
27 : : * * The octet-length of the SEQUENCE must be encoded as 1 or 2 octets. It is not
28 : : * required to be encoded as one octet if it is less than 256, as DER would require.
29 : : * * The octet-length of the SEQUENCE must not be greater than the remaining
30 : : * length of the key encoding, but need not match it (i.e. the encoding may contain
31 : : * junk after the encoded SEQUENCE).
32 : : * * The privateKey OCTET STRING is zero-filled on the left to 32 octets.
33 : : * * Anything after the encoding of the privateKey OCTET STRING is ignored, whether
34 : : * or not it is validly encoded DER.
35 : : *
36 : : * out32 must point to an output buffer of length at least 32 bytes.
37 : : */
38 : 1688 : int ec_seckey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *seckey, size_t seckeylen) {
39 : 1688 : const unsigned char *end = seckey + seckeylen;
40 [ + - ]: 1688 : memset(out32, 0, 32);
41 : : /* sequence header */
42 [ + - + - ]: 1688 : if (end - seckey < 1 || *seckey != 0x30u) {
43 : : return 0;
44 : : }
45 : 1688 : seckey++;
46 : : /* sequence length constructor */
47 [ + - + - ]: 1688 : if (end - seckey < 1 || !(*seckey & 0x80u)) {
48 : : return 0;
49 : : }
50 : 1688 : ptrdiff_t lenb = *seckey & ~0x80u; seckey++;
51 [ + - ]: 1688 : if (lenb < 1 || lenb > 2) {
52 : : return 0;
53 : : }
54 [ + - ]: 1688 : if (end - seckey < lenb) {
55 : : return 0;
56 : : }
57 : : /* sequence length */
58 [ - + ]: 1688 : ptrdiff_t len = seckey[lenb-1] | (lenb > 1 ? seckey[lenb-2] << 8 : 0u);
59 : 1688 : seckey += lenb;
60 [ + - ]: 1688 : if (end - seckey < len) {
61 : : return 0;
62 : : }
63 : : /* sequence element 0: version number (=1) */
64 [ + - + - : 1688 : if (end - seckey < 3 || seckey[0] != 0x02u || seckey[1] != 0x01u || seckey[2] != 0x01u) {
+ - + - ]
65 : : return 0;
66 : : }
67 : 1688 : seckey += 3;
68 : : /* sequence element 1: octet string, up to 32 bytes */
69 [ + - + - ]: 1688 : if (end - seckey < 2 || seckey[0] != 0x04u) {
70 : : return 0;
71 : : }
72 : 1688 : ptrdiff_t oslen = seckey[1];
73 : 1688 : seckey += 2;
74 [ + - + - ]: 1688 : if (oslen > 32 || end - seckey < oslen) {
75 : : return 0;
76 : : }
77 : 1688 : memcpy(out32 + (32 - oslen), seckey, oslen);
78 [ - + ]: 1688 : if (!secp256k1_ec_seckey_verify(ctx, out32)) {
79 : 0 : memset(out32, 0, 32);
80 : 0 : return 0;
81 : : }
82 : : return 1;
83 : : }
84 : :
85 : : /**
86 : : * This serializes to a DER encoding of the ECPrivateKey type from section C.4 of SEC 1
87 : : * <https://www.secg.org/sec1-v2.pdf>. The optional parameters and publicKey fields are
88 : : * included.
89 : : *
90 : : * seckey must point to an output buffer of length at least CKey::SIZE bytes.
91 : : * seckeylen must initially be set to the size of the seckey buffer. Upon return it
92 : : * will be set to the number of bytes used in the buffer.
93 : : * key32 must point to a 32-byte raw private key.
94 : : */
95 : 4079 : int ec_seckey_export_der(const secp256k1_context *ctx, unsigned char *seckey, size_t *seckeylen, const unsigned char *key32, bool compressed) {
96 [ - + ]: 4079 : assert(*seckeylen >= CKey::SIZE);
97 : 4079 : secp256k1_pubkey pubkey;
98 : 4079 : size_t pubkeylen = 0;
99 [ - + ]: 4079 : if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
100 : 0 : *seckeylen = 0;
101 : 0 : return 0;
102 : : }
103 [ + + ]: 4079 : if (compressed) {
104 : 4069 : static const unsigned char begin[] = {
105 : : 0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
106 : : };
107 : 4069 : static const unsigned char middle[] = {
108 : : 0xA0,0x81,0x85,0x30,0x81,0x82,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
109 : : 0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
110 : : 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
111 : : 0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
112 : : 0x21,0x02,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
113 : : 0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
114 : : 0x17,0x98,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
115 : : 0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
116 : : 0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x24,0x03,0x22,0x00
117 : : };
118 : 4069 : unsigned char *ptr = seckey;
119 : 4069 : memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
120 : 4069 : memcpy(ptr, key32, 32); ptr += 32;
121 : 4069 : memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
122 : 4069 : pubkeylen = CPubKey::COMPRESSED_SIZE;
123 : 4069 : secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
124 : 4069 : ptr += pubkeylen;
125 : 4069 : *seckeylen = ptr - seckey;
126 [ - + ]: 4069 : assert(*seckeylen == CKey::COMPRESSED_SIZE);
127 : : } else {
128 : 10 : static const unsigned char begin[] = {
129 : : 0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
130 : : };
131 : 10 : static const unsigned char middle[] = {
132 : : 0xA0,0x81,0xA5,0x30,0x81,0xA2,0x02,0x01,0x01,0x30,0x2C,0x06,0x07,0x2A,0x86,0x48,
133 : : 0xCE,0x3D,0x01,0x01,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
134 : : 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
135 : : 0xFF,0xFF,0xFE,0xFF,0xFF,0xFC,0x2F,0x30,0x06,0x04,0x01,0x00,0x04,0x01,0x07,0x04,
136 : : 0x41,0x04,0x79,0xBE,0x66,0x7E,0xF9,0xDC,0xBB,0xAC,0x55,0xA0,0x62,0x95,0xCE,0x87,
137 : : 0x0B,0x07,0x02,0x9B,0xFC,0xDB,0x2D,0xCE,0x28,0xD9,0x59,0xF2,0x81,0x5B,0x16,0xF8,
138 : : 0x17,0x98,0x48,0x3A,0xDA,0x77,0x26,0xA3,0xC4,0x65,0x5D,0xA4,0xFB,0xFC,0x0E,0x11,
139 : : 0x08,0xA8,0xFD,0x17,0xB4,0x48,0xA6,0x85,0x54,0x19,0x9C,0x47,0xD0,0x8F,0xFB,0x10,
140 : : 0xD4,0xB8,0x02,0x21,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
141 : : 0xFF,0xFF,0xFF,0xFF,0xFE,0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,0xBF,0xD2,0x5E,
142 : : 0x8C,0xD0,0x36,0x41,0x41,0x02,0x01,0x01,0xA1,0x44,0x03,0x42,0x00
143 : : };
144 : 10 : unsigned char *ptr = seckey;
145 : 10 : memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
146 : 10 : memcpy(ptr, key32, 32); ptr += 32;
147 : 10 : memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
148 : 10 : pubkeylen = CPubKey::SIZE;
149 : 10 : secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
150 : 10 : ptr += pubkeylen;
151 : 10 : *seckeylen = ptr - seckey;
152 [ - + ]: 10 : assert(*seckeylen == CKey::SIZE);
153 : : }
154 : : return 1;
155 : : }
156 : :
157 : 115131 : bool CKey::Check(const unsigned char *vch) {
158 : 115131 : return secp256k1_ec_seckey_verify(secp256k1_context_sign, vch);
159 : : }
160 : :
161 : 1712 : void CKey::MakeNewKey(bool fCompressedIn) {
162 : 1712 : MakeKeyData();
163 : 1712 : do {
164 : 1712 : GetStrongRandBytes(*keydata);
165 [ - + ]: 1712 : } while (!Check(keydata->data()));
166 : 1712 : fCompressed = fCompressedIn;
167 : 1712 : }
168 : :
169 : 4079 : CPrivKey CKey::GetPrivKey() const {
170 [ - + ]: 4079 : assert(keydata);
171 : 4079 : CPrivKey seckey;
172 : 4079 : int ret;
173 : 4079 : size_t seckeylen;
174 [ + - ]: 4079 : seckey.resize(SIZE);
175 : 4079 : seckeylen = SIZE;
176 [ + - + - ]: 8158 : ret = ec_seckey_export_der(secp256k1_context_sign, seckey.data(), &seckeylen, UCharCast(begin()), fCompressed);
177 [ - + ]: 4079 : assert(ret);
178 [ + - ]: 4079 : seckey.resize(seckeylen);
179 : 4079 : return seckey;
180 : 0 : }
181 : :
182 : 234059 : CPubKey CKey::GetPubKey() const {
183 [ - + ]: 234059 : assert(keydata);
184 : 234059 : secp256k1_pubkey pubkey;
185 : 234059 : size_t clen = CPubKey::SIZE;
186 : 234059 : CPubKey result;
187 : 234059 : int ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &pubkey, UCharCast(begin()));
188 [ - + ]: 234059 : assert(ret);
189 [ + + ]: 234145 : secp256k1_ec_pubkey_serialize(secp256k1_context_sign, (unsigned char*)result.begin(), &clen, &pubkey, fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
190 [ - + ]: 234059 : assert(result.size() == clen);
191 [ - + - + ]: 468118 : assert(result.IsValid());
192 : 234059 : return result;
193 : : }
194 : :
195 : : // Check that the sig has a low R value and will be less than 71 bytes
196 : 52745 : bool SigHasLowR(const secp256k1_ecdsa_signature* sig)
197 : : {
198 : 52745 : unsigned char compact_sig[64];
199 : 52745 : secp256k1_ecdsa_signature_serialize_compact(secp256k1_context_sign, compact_sig, sig);
200 : :
201 : : // In DER serialization, all values are interpreted as big-endian, signed integers. The highest bit in the integer indicates
202 : : // its signed-ness; 0 is positive, 1 is negative. When the value is interpreted as a negative integer, it must be converted
203 : : // to a positive value by prepending a 0x00 byte so that the highest bit is 0. We can avoid this prepending by ensuring that
204 : : // our highest bit is always 0, and thus we must check that the first byte is less than 0x80.
205 : 52745 : return compact_sig[0] < 0x80;
206 : : }
207 : :
208 : 26866 : bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, bool grind, uint32_t test_case) const {
209 [ + - ]: 26866 : if (!keydata)
210 : : return false;
211 : 26866 : vchSig.resize(CPubKey::SIGNATURE_SIZE);
212 : 26866 : size_t nSigLen = CPubKey::SIGNATURE_SIZE;
213 : 26866 : unsigned char extra_entropy[32] = {0};
214 : 26866 : WriteLE32(extra_entropy, test_case);
215 : 26866 : secp256k1_ecdsa_signature sig;
216 : 26866 : uint32_t counter = 0;
217 [ + + + - ]: 79399 : int ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(), UCharCast(begin()), secp256k1_nonce_function_rfc6979, (!grind && test_case) ? extra_entropy : nullptr);
218 : :
219 : : // Grind for low R
220 [ + - + + : 79611 : while (ret && !SigHasLowR(&sig) && grind) {
+ + ]
221 : 25879 : WriteLE32(extra_entropy, ++counter);
222 [ + - ]: 51758 : ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(), UCharCast(begin()), secp256k1_nonce_function_rfc6979, extra_entropy);
223 : : }
224 [ - + ]: 26866 : assert(ret);
225 : 26866 : secp256k1_ecdsa_signature_serialize_der(secp256k1_context_sign, vchSig.data(), &nSigLen, &sig);
226 : 26866 : vchSig.resize(nSigLen);
227 : : // Additional verification step to prevent using a potentially corrupted signature
228 : 26866 : secp256k1_pubkey pk;
229 [ + - ]: 53732 : ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &pk, UCharCast(begin()));
230 [ - + ]: 26866 : assert(ret);
231 : 26866 : ret = secp256k1_ecdsa_verify(secp256k1_context_static, &sig, hash.begin(), &pk);
232 [ - + ]: 26866 : assert(ret);
233 : : return true;
234 : : }
235 : :
236 : 9345 : bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
237 [ + + ]: 9345 : if (pubkey.IsCompressed() != fCompressed) {
238 : : return false;
239 : : }
240 : 9337 : unsigned char rnd[8];
241 : 9337 : std::string str = "Bitcoin key verification\n";
242 : 9337 : GetRandBytes(rnd);
243 [ + - ]: 9337 : uint256 hash{Hash(str, rnd)};
244 : 9337 : std::vector<unsigned char> vchSig;
245 [ + - ]: 9337 : Sign(hash, vchSig);
246 [ + - ]: 9337 : return pubkey.Verify(hash, vchSig);
247 : 9337 : }
248 : :
249 : 80 : bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
250 [ + + ]: 80 : if (!keydata)
251 : : return false;
252 : 79 : vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
253 : 79 : int rec = -1;
254 : 79 : secp256k1_ecdsa_recoverable_signature rsig;
255 [ + - ]: 158 : int ret = secp256k1_ecdsa_sign_recoverable(secp256k1_context_sign, &rsig, hash.begin(), UCharCast(begin()), secp256k1_nonce_function_rfc6979, nullptr);
256 [ - + ]: 79 : assert(ret);
257 : 79 : ret = secp256k1_ecdsa_recoverable_signature_serialize_compact(secp256k1_context_sign, &vchSig[1], &rec, &rsig);
258 [ - + ]: 79 : assert(ret);
259 [ - + ]: 79 : assert(rec != -1);
260 [ + + + - ]: 113 : vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
261 : : // Additional verification step to prevent using a potentially corrupted signature
262 : 79 : secp256k1_pubkey epk, rpk;
263 [ + - ]: 158 : ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &epk, UCharCast(begin()));
264 [ - + ]: 79 : assert(ret);
265 : 79 : ret = secp256k1_ecdsa_recover(secp256k1_context_static, &rpk, &rsig, hash.begin());
266 [ - + ]: 79 : assert(ret);
267 : 79 : ret = secp256k1_ec_pubkey_cmp(secp256k1_context_static, &epk, &rpk);
268 [ - + ]: 79 : assert(ret == 0);
269 : : return true;
270 : : }
271 : :
272 : 1287 : bool CKey::SignSchnorr(const uint256& hash, Span<unsigned char> sig, const uint256* merkle_root, const uint256& aux) const
273 : : {
274 : 1287 : KeyPair kp = ComputeKeyPair(merkle_root);
275 [ + - ]: 1287 : return kp.SignSchnorr(hash, sig, aux);
276 : 1287 : }
277 : :
278 : 1688 : bool CKey::Load(const CPrivKey &seckey, const CPubKey &vchPubKey, bool fSkipCheck=false) {
279 : 1688 : MakeKeyData();
280 [ + - - + ]: 3376 : if (!ec_seckey_import_der(secp256k1_context_sign, (unsigned char*)begin(), seckey.data(), seckey.size())) {
281 : 0 : ClearKeyData();
282 : 0 : return false;
283 : : }
284 [ - + ]: 1688 : fCompressed = vchPubKey.IsCompressed();
285 : :
286 [ - + ]: 1688 : if (fSkipCheck)
287 : : return true;
288 : :
289 : 0 : return VerifyPubKey(vchPubKey);
290 : : }
291 : :
292 : 102672 : bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
293 [ - + ]: 102672 : assert(IsValid());
294 [ - + ]: 102672 : assert(IsCompressed());
295 : 102672 : std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
296 [ + + ]: 102672 : if ((nChild >> 31) == 0) {
297 [ + - ]: 28023 : CPubKey pubkey = GetPubKey();
298 [ - + ]: 28023 : assert(pubkey.size() == CPubKey::COMPRESSED_SIZE);
299 [ + - ]: 28023 : BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin()+1, vout.data());
300 : : } else {
301 [ + - ]: 74649 : assert(size() == 32);
302 [ + - ]: 74649 : BIP32Hash(cc, nChild, 0, UCharCast(begin()), vout.data());
303 : : }
304 [ + - ]: 102672 : memcpy(ccChild.begin(), vout.data()+32, 32);
305 [ + - + - ]: 205344 : keyChild.Set(begin(), begin() + 32, true);
306 [ + - + - ]: 205344 : bool ret = secp256k1_ec_seckey_tweak_add(secp256k1_context_sign, (unsigned char*)keyChild.begin(), vout.data());
307 [ - + ]: 102672 : if (!ret) keyChild.ClearKeyData();
308 : 102672 : return ret;
309 : 102672 : }
310 : :
311 : 354 : EllSwiftPubKey CKey::EllSwiftCreate(Span<const std::byte> ent32) const
312 : : {
313 [ - + ]: 354 : assert(keydata);
314 [ - + ]: 354 : assert(ent32.size() == 32);
315 : 354 : std::array<std::byte, EllSwiftPubKey::size()> encoded_pubkey;
316 : :
317 : 354 : auto success = secp256k1_ellswift_create(secp256k1_context_sign,
318 : : UCharCast(encoded_pubkey.data()),
319 : 354 : keydata->data(),
320 : : UCharCast(ent32.data()));
321 : :
322 : : // Should always succeed for valid keys (asserted above).
323 [ - + ]: 354 : assert(success);
324 : 354 : return {encoded_pubkey};
325 : : }
326 : :
327 : 435 : ECDHSecret CKey::ComputeBIP324ECDHSecret(const EllSwiftPubKey& their_ellswift, const EllSwiftPubKey& our_ellswift, bool initiating) const
328 : : {
329 [ - + ]: 435 : assert(keydata);
330 : :
331 : 435 : ECDHSecret output;
332 : : // BIP324 uses the initiator as party A, and the responder as party B. Remap the inputs
333 : : // accordingly:
334 [ + + ]: 870 : bool success = secp256k1_ellswift_xdh(secp256k1_context_sign,
335 : : UCharCast(output.data()),
336 : 435 : UCharCast(initiating ? our_ellswift.data() : their_ellswift.data()),
337 : 435 : UCharCast(initiating ? their_ellswift.data() : our_ellswift.data()),
338 : 435 : keydata->data(),
339 : : initiating ? 0 : 1,
340 : : secp256k1_ellswift_xdh_hash_function_bip324,
341 : 435 : nullptr);
342 : : // Should always succeed for valid keys (assert above).
343 [ - + ]: 435 : assert(success);
344 : 435 : return output;
345 : : }
346 : :
347 : 1331 : KeyPair CKey::ComputeKeyPair(const uint256* merkle_root) const
348 : : {
349 : 1331 : return KeyPair(*this, merkle_root);
350 : : }
351 : :
352 : 1654 : CKey GenerateRandomKey(bool compressed) noexcept
353 : : {
354 : 1654 : CKey key;
355 : 1654 : key.MakeNewKey(/*fCompressed=*/compressed);
356 : 1654 : return key;
357 : : }
358 : :
359 : 102673 : bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
360 [ + + ]: 102673 : if (nDepth == std::numeric_limits<unsigned char>::max()) return false;
361 : 102672 : out.nDepth = nDepth + 1;
362 : 102672 : CKeyID id = key.GetPubKey().GetID();
363 : 102672 : memcpy(out.vchFingerprint, &id, 4);
364 : 102672 : out.nChild = _nChild;
365 : 102672 : return key.Derive(out.key, out.chaincode, _nChild, chaincode);
366 : : }
367 : :
368 : 2344 : void CExtKey::SetSeed(Span<const std::byte> seed)
369 : : {
370 : 2344 : static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
371 : 2344 : std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
372 [ + - + - : 2344 : CHMAC_SHA512{hashkey, sizeof(hashkey)}.Write(UCharCast(seed.data()), seed.size()).Finalize(vout.data());
+ - ]
373 [ + - ]: 2344 : key.Set(vout.data(), vout.data() + 32, true);
374 : 2344 : memcpy(chaincode.begin(), vout.data() + 32, 32);
375 : 2344 : nDepth = 0;
376 : 2344 : nChild = 0;
377 : 2344 : memset(vchFingerprint, 0, sizeof(vchFingerprint));
378 : 2344 : }
379 : :
380 : 73161 : CExtPubKey CExtKey::Neuter() const {
381 : 73161 : CExtPubKey ret;
382 : 73161 : ret.nDepth = nDepth;
383 : 73161 : memcpy(ret.vchFingerprint, vchFingerprint, 4);
384 : 73161 : ret.nChild = nChild;
385 : 73161 : ret.pubkey = key.GetPubKey();
386 : 73161 : ret.chaincode = chaincode;
387 : 73161 : return ret;
388 : : }
389 : :
390 : 322 : void CExtKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
391 : 322 : code[0] = nDepth;
392 : 322 : memcpy(code+1, vchFingerprint, 4);
393 : 322 : WriteBE32(code+5, nChild);
394 [ - + ]: 322 : memcpy(code+9, chaincode.begin(), 32);
395 : 322 : code[41] = 0;
396 [ - + ]: 322 : assert(key.size() == 32);
397 : 322 : memcpy(code+42, key.begin(), 32);
398 : 322 : }
399 : :
400 : 654 : void CExtKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
401 : 654 : nDepth = code[0];
402 : 654 : memcpy(vchFingerprint, code+1, 4);
403 : 654 : nChild = ReadBE32(code+5);
404 : 654 : memcpy(chaincode.begin(), code+9, 32);
405 : 654 : key.Set(code+42, code+BIP32_EXTKEY_SIZE, true);
406 [ + + + + : 654 : if ((nDepth == 0 && (nChild != 0 || ReadLE32(vchFingerprint) != 0)) || code[41] != 0) key = CKey();
+ + + + ]
407 : 654 : }
408 : :
409 [ + - ]: 1331 : KeyPair::KeyPair(const CKey& key, const uint256* merkle_root)
410 : : {
411 : 1331 : static_assert(std::tuple_size<KeyType>() == sizeof(secp256k1_keypair));
412 [ + - ]: 1331 : MakeKeyPairData();
413 [ + - ]: 1331 : auto keypair = reinterpret_cast<secp256k1_keypair*>(m_keypair->data());
414 [ + - + - ]: 2662 : bool success = secp256k1_keypair_create(secp256k1_context_sign, keypair, UCharCast(key.data()));
415 [ + + ]: 1331 : if (success && merkle_root) {
416 : 583 : secp256k1_xonly_pubkey pubkey;
417 : 583 : unsigned char pubkey_bytes[32];
418 [ + - - + ]: 583 : assert(secp256k1_keypair_xonly_pub(secp256k1_context_sign, &pubkey, nullptr, keypair));
419 [ + - - + ]: 583 : assert(secp256k1_xonly_pubkey_serialize(secp256k1_context_sign, pubkey_bytes, &pubkey));
420 [ + + + - ]: 819 : uint256 tweak = XOnlyPubKey(pubkey_bytes).ComputeTapTweakHash(merkle_root->IsNull() ? nullptr : merkle_root);
421 [ + - ]: 583 : success = secp256k1_keypair_xonly_tweak_add(secp256k1_context_static, keypair, tweak.data());
422 : : }
423 [ - + ]: 1331 : if (!success) ClearKeyPairData();
424 : 1331 : }
425 : :
426 : 1331 : bool KeyPair::SignSchnorr(const uint256& hash, Span<unsigned char> sig, const uint256& aux) const
427 : : {
428 [ - + ]: 1331 : assert(sig.size() == 64);
429 [ + - ]: 1331 : if (!IsValid()) return false;
430 : 1331 : auto keypair = reinterpret_cast<const secp256k1_keypair*>(m_keypair->data());
431 : 1331 : bool ret = secp256k1_schnorrsig_sign32(secp256k1_context_sign, sig.data(), hash.data(), keypair, aux.data());
432 [ + - ]: 1331 : if (ret) {
433 : : // Additional verification step to prevent using a potentially corrupted signature
434 : 1331 : secp256k1_xonly_pubkey pubkey_verify;
435 : 1331 : ret = secp256k1_keypair_xonly_pub(secp256k1_context_static, &pubkey_verify, nullptr, keypair);
436 : 1331 : ret &= secp256k1_schnorrsig_verify(secp256k1_context_static, sig.data(), hash.begin(), 32, &pubkey_verify);
437 : : }
438 [ - + ]: 1331 : if (!ret) memory_cleanse(sig.data(), sig.size());
439 : : return ret;
440 : : }
441 : :
442 : 991 : bool ECC_InitSanityCheck() {
443 : 991 : CKey key = GenerateRandomKey();
444 [ + - ]: 991 : CPubKey pubkey = key.GetPubKey();
445 [ + - ]: 991 : return key.VerifyPubKey(pubkey);
446 : 991 : }
447 : :
448 : : /** Initialize the elliptic curve support. May not be called twice without calling ECC_Stop first. */
449 : 1633 : static void ECC_Start() {
450 [ - + ]: 1633 : assert(secp256k1_context_sign == nullptr);
451 : :
452 : 1633 : secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
453 [ - + ]: 1633 : assert(ctx != nullptr);
454 : :
455 : 1633 : {
456 : : // Pass in a random blinding seed to the secp256k1 context.
457 : 1633 : std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
458 : 1633 : GetRandBytes(vseed);
459 [ + - ]: 1633 : bool ret = secp256k1_context_randomize(ctx, vseed.data());
460 [ - + ]: 1633 : assert(ret);
461 : 1633 : }
462 : :
463 : 1633 : secp256k1_context_sign = ctx;
464 : 1633 : }
465 : :
466 : : /** Deinitialize the elliptic curve support. No-op if ECC_Start wasn't called first. */
467 : 1632 : static void ECC_Stop() {
468 : 1632 : secp256k1_context *ctx = secp256k1_context_sign;
469 : 1632 : secp256k1_context_sign = nullptr;
470 : :
471 [ + - ]: 1632 : if (ctx) {
472 : 1632 : secp256k1_context_destroy(ctx);
473 : : }
474 : 1632 : }
475 : :
476 : 1633 : ECC_Context::ECC_Context()
477 : : {
478 : 1633 : ECC_Start();
479 : 1633 : }
480 : :
481 : 1632 : ECC_Context::~ECC_Context()
482 : : {
483 : 1632 : ECC_Stop();
484 : 1632 : }
|
