LCOV - code coverage report
Current view: top level - src - key.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 93.3 % 283 264
Test Date: 2024-12-02 12:23:29 Functions: 89.7 % 29 26
Branches: 58.5 % 246 144

             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                 :        1036 : int ec_seckey_import_der(const secp256k1_context* ctx, unsigned char *out32, const unsigned char *seckey, size_t seckeylen) {
      39                 :        1036 :     const unsigned char *end = seckey + seckeylen;
      40         [ +  - ]:        1036 :     memset(out32, 0, 32);
      41                 :             :     /* sequence header */
      42   [ +  -  +  + ]:        1036 :     if (end - seckey < 1 || *seckey != 0x30u) {
      43                 :             :         return 0;
      44                 :             :     }
      45                 :        1033 :     seckey++;
      46                 :             :     /* sequence length constructor */
      47   [ +  -  +  + ]:        1033 :     if (end - seckey < 1 || !(*seckey & 0x80u)) {
      48                 :             :         return 0;
      49                 :             :     }
      50                 :        1032 :     ptrdiff_t lenb = *seckey & ~0x80u; seckey++;
      51         [ +  + ]:        1032 :     if (lenb < 1 || lenb > 2) {
      52                 :             :         return 0;
      53                 :             :     }
      54         [ +  - ]:        1029 :     if (end - seckey < lenb) {
      55                 :             :         return 0;
      56                 :             :     }
      57                 :             :     /* sequence length */
      58         [ +  + ]:        1029 :     ptrdiff_t len = seckey[lenb-1] | (lenb > 1 ? seckey[lenb-2] << 8 : 0u);
      59                 :        1029 :     seckey += lenb;
      60         [ +  + ]:        1029 :     if (end - seckey < len) {
      61                 :             :         return 0;
      62                 :             :     }
      63                 :             :     /* sequence element 0: version number (=1) */
      64   [ +  -  +  +  :        1023 :     if (end - seckey < 3 || seckey[0] != 0x02u || seckey[1] != 0x01u || seckey[2] != 0x01u) {
             +  +  +  + ]
      65                 :             :         return 0;
      66                 :             :     }
      67                 :        1016 :     seckey += 3;
      68                 :             :     /* sequence element 1: octet string, up to 32 bytes */
      69   [ +  -  +  + ]:        1016 :     if (end - seckey < 2 || seckey[0] != 0x04u) {
      70                 :             :         return 0;
      71                 :             :     }
      72                 :        1014 :     ptrdiff_t oslen = seckey[1];
      73                 :        1014 :     seckey += 2;
      74   [ +  +  +  - ]:        1014 :     if (oslen > 32 || end - seckey < oslen) {
      75                 :             :         return 0;
      76                 :             :     }
      77                 :        1012 :     memcpy(out32 + (32 - oslen), seckey, oslen);
      78         [ +  + ]:        1012 :     if (!secp256k1_ec_seckey_verify(ctx, out32)) {
      79                 :           1 :         memset(out32, 0, 32);
      80                 :           1 :         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                 :       38957 : int ec_seckey_export_der(const secp256k1_context *ctx, unsigned char *seckey, size_t *seckeylen, const unsigned char *key32, bool compressed) {
      96         [ -  + ]:       38957 :     assert(*seckeylen >= CKey::SIZE);
      97                 :       38957 :     secp256k1_pubkey pubkey;
      98                 :       38957 :     size_t pubkeylen = 0;
      99         [ +  + ]:       38957 :     if (!secp256k1_ec_pubkey_create(ctx, &pubkey, key32)) {
     100                 :          12 :         *seckeylen = 0;
     101                 :          12 :         return 0;
     102                 :             :     }
     103         [ +  + ]:       38945 :     if (compressed) {
     104                 :       38932 :         static const unsigned char begin[] = {
     105                 :             :             0x30,0x81,0xD3,0x02,0x01,0x01,0x04,0x20
     106                 :             :         };
     107                 :       38932 :         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                 :       38932 :         unsigned char *ptr = seckey;
     119                 :       38932 :         memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
     120                 :       38932 :         memcpy(ptr, key32, 32); ptr += 32;
     121                 :       38932 :         memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
     122                 :       38932 :         pubkeylen = CPubKey::COMPRESSED_SIZE;
     123                 :       38932 :         secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_COMPRESSED);
     124                 :       38932 :         ptr += pubkeylen;
     125                 :       38932 :         *seckeylen = ptr - seckey;
     126         [ -  + ]:       38932 :         assert(*seckeylen == CKey::COMPRESSED_SIZE);
     127                 :             :     } else {
     128                 :          13 :         static const unsigned char begin[] = {
     129                 :             :             0x30,0x82,0x01,0x13,0x02,0x01,0x01,0x04,0x20
     130                 :             :         };
     131                 :          13 :         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                 :          13 :         unsigned char *ptr = seckey;
     145                 :          13 :         memcpy(ptr, begin, sizeof(begin)); ptr += sizeof(begin);
     146                 :          13 :         memcpy(ptr, key32, 32); ptr += 32;
     147                 :          13 :         memcpy(ptr, middle, sizeof(middle)); ptr += sizeof(middle);
     148                 :          13 :         pubkeylen = CPubKey::SIZE;
     149                 :          13 :         secp256k1_ec_pubkey_serialize(ctx, ptr, &pubkeylen, &pubkey, SECP256K1_EC_UNCOMPRESSED);
     150                 :          13 :         ptr += pubkeylen;
     151                 :          13 :         *seckeylen = ptr - seckey;
     152         [ -  + ]:          13 :         assert(*seckeylen == CKey::SIZE);
     153                 :             :     }
     154                 :             :     return 1;
     155                 :             : }
     156                 :             : 
     157                 :      470351 : bool CKey::Check(const unsigned char *vch) {
     158                 :      470351 :     return secp256k1_ec_seckey_verify(secp256k1_context_sign, vch);
     159                 :             : }
     160                 :             : 
     161                 :           0 : void CKey::MakeNewKey(bool fCompressedIn) {
     162                 :           0 :     MakeKeyData();
     163                 :           0 :     do {
     164                 :           0 :         GetStrongRandBytes(*keydata);
     165         [ #  # ]:           0 :     } while (!Check(keydata->data()));
     166                 :           0 :     fCompressed = fCompressedIn;
     167                 :           0 : }
     168                 :             : 
     169                 :       38929 : CPrivKey CKey::GetPrivKey() const {
     170         [ -  + ]:       38929 :     assert(keydata);
     171                 :       38929 :     CPrivKey seckey;
     172                 :       38929 :     int ret;
     173                 :       38929 :     size_t seckeylen;
     174         [ +  - ]:       38929 :     seckey.resize(SIZE);
     175                 :       38929 :     seckeylen = SIZE;
     176   [ +  -  +  - ]:       77858 :     ret = ec_seckey_export_der(secp256k1_context_sign, seckey.data(), &seckeylen, UCharCast(begin()), fCompressed);
     177         [ -  + ]:       38929 :     assert(ret);
     178         [ +  - ]:       38929 :     seckey.resize(seckeylen);
     179                 :       38929 :     return seckey;
     180                 :           0 : }
     181                 :             : 
     182                 :     1016604 : CPubKey CKey::GetPubKey() const {
     183         [ -  + ]:     1016604 :     assert(keydata);
     184                 :     1016604 :     secp256k1_pubkey pubkey;
     185                 :     1016604 :     size_t clen = CPubKey::SIZE;
     186                 :     1016604 :     CPubKey result;
     187                 :     1016604 :     int ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &pubkey, UCharCast(begin()));
     188         [ -  + ]:     1016604 :     assert(ret);
     189         [ +  + ]:     1032029 :     secp256k1_ec_pubkey_serialize(secp256k1_context_sign, (unsigned char*)result.begin(), &clen, &pubkey, fCompressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
     190         [ -  + ]:     1016604 :     assert(result.size() == clen);
     191   [ -  +  -  + ]:     2033208 :     assert(result.IsValid());
     192                 :     1016604 :     return result;
     193                 :             : }
     194                 :             : 
     195                 :             : // Check that the sig has a low R value and will be less than 71 bytes
     196                 :       69453 : bool SigHasLowR(const secp256k1_ecdsa_signature* sig)
     197                 :             : {
     198                 :       69453 :     unsigned char compact_sig[64];
     199                 :       69453 :     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                 :       69453 :     return compact_sig[0] < 0x80;
     206                 :             : }
     207                 :             : 
     208                 :       33195 : bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, bool grind, uint32_t test_case) const {
     209         [ +  - ]:       33195 :     if (!keydata)
     210                 :             :         return false;
     211                 :       33195 :     vchSig.resize(CPubKey::SIGNATURE_SIZE);
     212                 :       33195 :     size_t nSigLen = CPubKey::SIGNATURE_SIZE;
     213                 :       33195 :     unsigned char extra_entropy[32] = {0};
     214                 :       33195 :     WriteLE32(extra_entropy, test_case);
     215                 :       33195 :     secp256k1_ecdsa_signature sig;
     216                 :       33195 :     uint32_t counter = 0;
     217   [ +  -  +  - ]:       99585 :     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   [ +  -  +  +  :      102544 :     while (ret && !SigHasLowR(&sig) && grind) {
                   +  + ]
     221                 :       36154 :         WriteLE32(extra_entropy, ++counter);
     222         [ +  - ]:       72308 :         ret = secp256k1_ecdsa_sign(secp256k1_context_sign, &sig, hash.begin(), UCharCast(begin()), secp256k1_nonce_function_rfc6979, extra_entropy);
     223                 :             :     }
     224         [ -  + ]:       33195 :     assert(ret);
     225                 :       33195 :     secp256k1_ecdsa_signature_serialize_der(secp256k1_context_sign, vchSig.data(), &nSigLen, &sig);
     226                 :       33195 :     vchSig.resize(nSigLen);
     227                 :             :     // Additional verification step to prevent using a potentially corrupted signature
     228                 :       33195 :     secp256k1_pubkey pk;
     229         [ +  - ]:       66390 :     ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &pk, UCharCast(begin()));
     230         [ -  + ]:       33195 :     assert(ret);
     231                 :       33195 :     ret = secp256k1_ecdsa_verify(secp256k1_context_static, &sig, hash.begin(), &pk);
     232         [ -  + ]:       33195 :     assert(ret);
     233                 :             :     return true;
     234                 :             : }
     235                 :             : 
     236                 :         992 : bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
     237         [ +  - ]:         992 :     if (pubkey.IsCompressed() != fCompressed) {
     238                 :             :         return false;
     239                 :             :     }
     240                 :         992 :     unsigned char rnd[8];
     241                 :         992 :     std::string str = "Bitcoin key verification\n";
     242                 :         992 :     GetRandBytes(rnd);
     243         [ +  - ]:         992 :     uint256 hash{Hash(str, rnd)};
     244                 :         992 :     std::vector<unsigned char> vchSig;
     245         [ +  - ]:         992 :     Sign(hash, vchSig);
     246         [ +  - ]:         992 :     return pubkey.Verify(hash, vchSig);
     247                 :         992 : }
     248                 :             : 
     249                 :        5191 : bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
     250         [ +  + ]:        5191 :     if (!keydata)
     251                 :             :         return false;
     252                 :        5129 :     vchSig.resize(CPubKey::COMPACT_SIGNATURE_SIZE);
     253                 :        5129 :     int rec = -1;
     254                 :        5129 :     secp256k1_ecdsa_recoverable_signature rsig;
     255         [ +  - ]:       10258 :     int ret = secp256k1_ecdsa_sign_recoverable(secp256k1_context_sign, &rsig, hash.begin(), UCharCast(begin()), secp256k1_nonce_function_rfc6979, nullptr);
     256         [ -  + ]:        5129 :     assert(ret);
     257                 :        5129 :     ret = secp256k1_ecdsa_recoverable_signature_serialize_compact(secp256k1_context_sign, &vchSig[1], &rec, &rsig);
     258         [ -  + ]:        5129 :     assert(ret);
     259         [ -  + ]:        5129 :     assert(rec != -1);
     260   [ +  +  +  - ]:        5570 :     vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
     261                 :             :     // Additional verification step to prevent using a potentially corrupted signature
     262                 :        5129 :     secp256k1_pubkey epk, rpk;
     263         [ +  - ]:       10258 :     ret = secp256k1_ec_pubkey_create(secp256k1_context_sign, &epk, UCharCast(begin()));
     264         [ -  + ]:        5129 :     assert(ret);
     265                 :        5129 :     ret = secp256k1_ecdsa_recover(secp256k1_context_static, &rpk, &rsig, hash.begin());
     266         [ -  + ]:        5129 :     assert(ret);
     267                 :        5129 :     ret = secp256k1_ec_pubkey_cmp(secp256k1_context_static, &epk, &rpk);
     268         [ -  + ]:        5129 :     assert(ret == 0);
     269                 :             :     return true;
     270                 :             : }
     271                 :             : 
     272                 :       12122 : bool CKey::SignSchnorr(const uint256& hash, Span<unsigned char> sig, const uint256* merkle_root, const uint256& aux) const
     273                 :             : {
     274                 :       12122 :     KeyPair kp = ComputeKeyPair(merkle_root);
     275         [ +  - ]:       12122 :     return kp.SignSchnorr(hash, sig, aux);
     276                 :       12122 : }
     277                 :             : 
     278                 :         992 : bool CKey::Load(const CPrivKey &seckey, const CPubKey &vchPubKey, bool fSkipCheck=false) {
     279                 :         992 :     MakeKeyData();
     280   [ +  -  -  + ]:        1984 :     if (!ec_seckey_import_der(secp256k1_context_sign, (unsigned char*)begin(), seckey.data(), seckey.size())) {
     281                 :           0 :         ClearKeyData();
     282                 :           0 :         return false;
     283                 :             :     }
     284         [ +  + ]:         992 :     fCompressed = vchPubKey.IsCompressed();
     285                 :             : 
     286         [ +  + ]:         992 :     if (fSkipCheck)
     287                 :             :         return true;
     288                 :             : 
     289                 :         496 :     return VerifyPubKey(vchPubKey);
     290                 :             : }
     291                 :             : 
     292                 :      255587 : bool CKey::Derive(CKey& keyChild, ChainCode &ccChild, unsigned int nChild, const ChainCode& cc) const {
     293         [ -  + ]:      255587 :     assert(IsValid());
     294         [ -  + ]:      255587 :     assert(IsCompressed());
     295                 :      255587 :     std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
     296         [ +  + ]:      255587 :     if ((nChild >> 31) == 0) {
     297         [ +  - ]:      171164 :         CPubKey pubkey = GetPubKey();
     298         [ -  + ]:      171164 :         assert(pubkey.size() == CPubKey::COMPRESSED_SIZE);
     299         [ +  - ]:      171164 :         BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin()+1, vout.data());
     300                 :             :     } else {
     301         [ +  - ]:       84423 :         assert(size() == 32);
     302         [ +  - ]:       84423 :         BIP32Hash(cc, nChild, 0, UCharCast(begin()), vout.data());
     303                 :             :     }
     304         [ +  - ]:      255587 :     memcpy(ccChild.begin(), vout.data()+32, 32);
     305   [ +  -  +  - ]:      511174 :     keyChild.Set(begin(), begin() + 32, true);
     306   [ +  -  +  - ]:      511174 :     bool ret = secp256k1_ec_seckey_tweak_add(secp256k1_context_sign, (unsigned char*)keyChild.begin(), vout.data());
     307         [ -  + ]:      255587 :     if (!ret) keyChild.ClearKeyData();
     308                 :      255587 :     return ret;
     309                 :      255587 : }
     310                 :             : 
     311                 :        4008 : EllSwiftPubKey CKey::EllSwiftCreate(Span<const std::byte> ent32) const
     312                 :             : {
     313         [ -  + ]:        4008 :     assert(keydata);
     314         [ -  + ]:        4008 :     assert(ent32.size() == 32);
     315                 :        4008 :     std::array<std::byte, EllSwiftPubKey::size()> encoded_pubkey;
     316                 :             : 
     317                 :        4008 :     auto success = secp256k1_ellswift_create(secp256k1_context_sign,
     318                 :             :                                              UCharCast(encoded_pubkey.data()),
     319                 :        4008 :                                              keydata->data(),
     320                 :             :                                              UCharCast(ent32.data()));
     321                 :             : 
     322                 :             :     // Should always succeed for valid keys (asserted above).
     323         [ -  + ]:        4008 :     assert(success);
     324                 :        4008 :     return {encoded_pubkey};
     325                 :             : }
     326                 :             : 
     327                 :        3169 : ECDHSecret CKey::ComputeBIP324ECDHSecret(const EllSwiftPubKey& their_ellswift, const EllSwiftPubKey& our_ellswift, bool initiating) const
     328                 :             : {
     329         [ -  + ]:        3169 :     assert(keydata);
     330                 :             : 
     331                 :        3169 :     ECDHSecret output;
     332                 :             :     // BIP324 uses the initiator as party A, and the responder as party B. Remap the inputs
     333                 :             :     // accordingly:
     334         [ +  + ]:        6338 :     bool success = secp256k1_ellswift_xdh(secp256k1_context_sign,
     335                 :             :                                           UCharCast(output.data()),
     336                 :        3169 :                                           UCharCast(initiating ? our_ellswift.data() : their_ellswift.data()),
     337                 :        3169 :                                           UCharCast(initiating ? their_ellswift.data() : our_ellswift.data()),
     338                 :        3169 :                                           keydata->data(),
     339                 :             :                                           initiating ? 0 : 1,
     340                 :             :                                           secp256k1_ellswift_xdh_hash_function_bip324,
     341                 :        3169 :                                           nullptr);
     342                 :             :     // Should always succeed for valid keys (assert above).
     343         [ -  + ]:        3169 :     assert(success);
     344                 :        3169 :     return output;
     345                 :             : }
     346                 :             : 
     347                 :       12122 : KeyPair CKey::ComputeKeyPair(const uint256* merkle_root) const
     348                 :             : {
     349                 :       12122 :     return KeyPair(*this, merkle_root);
     350                 :             : }
     351                 :             : 
     352                 :           0 : CKey GenerateRandomKey(bool compressed) noexcept
     353                 :             : {
     354                 :           0 :     CKey key;
     355                 :           0 :     key.MakeNewKey(/*fCompressed=*/compressed);
     356                 :           0 :     return key;
     357                 :             : }
     358                 :             : 
     359                 :      255091 : bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
     360         [ +  - ]:      255091 :     if (nDepth == std::numeric_limits<unsigned char>::max()) return false;
     361                 :      255091 :     out.nDepth = nDepth + 1;
     362                 :      255091 :     CKeyID id = key.GetPubKey().GetID();
     363                 :      255091 :     memcpy(out.vchFingerprint, &id, 4);
     364                 :      255091 :     out.nChild = _nChild;
     365                 :      255091 :     return key.Derive(out.key, out.chaincode, _nChild, chaincode);
     366                 :             : }
     367                 :             : 
     368                 :         168 : void CExtKey::SetSeed(Span<const std::byte> seed)
     369                 :             : {
     370                 :         168 :     static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
     371                 :         168 :     std::vector<unsigned char, secure_allocator<unsigned char>> vout(64);
     372   [ +  -  +  -  :         168 :     CHMAC_SHA512{hashkey, sizeof(hashkey)}.Write(UCharCast(seed.data()), seed.size()).Finalize(vout.data());
                   +  - ]
     373         [ +  - ]:         168 :     key.Set(vout.data(), vout.data() + 32, true);
     374                 :         168 :     memcpy(chaincode.begin(), vout.data() + 32, 32);
     375                 :         168 :     nDepth = 0;
     376                 :         168 :     nChild = 0;
     377                 :         168 :     memset(vchFingerprint, 0, sizeof(vchFingerprint));
     378                 :         168 : }
     379                 :             : 
     380                 :      229117 : CExtPubKey CExtKey::Neuter() const {
     381                 :      229117 :     CExtPubKey ret;
     382                 :      229117 :     ret.nDepth = nDepth;
     383                 :      229117 :     memcpy(ret.vchFingerprint, vchFingerprint, 4);
     384                 :      229117 :     ret.nChild = nChild;
     385                 :      229117 :     ret.pubkey = key.GetPubKey();
     386                 :      229117 :     ret.chaincode = chaincode;
     387                 :      229117 :     return ret;
     388                 :             : }
     389                 :             : 
     390                 :       28728 : void CExtKey::Encode(unsigned char code[BIP32_EXTKEY_SIZE]) const {
     391                 :       28728 :     code[0] = nDepth;
     392                 :       28728 :     memcpy(code+1, vchFingerprint, 4);
     393                 :       28728 :     WriteBE32(code+5, nChild);
     394         [ -  + ]:       28728 :     memcpy(code+9, chaincode.begin(), 32);
     395                 :       28728 :     code[41] = 0;
     396         [ -  + ]:       28728 :     assert(key.size() == 32);
     397                 :       28728 :     memcpy(code+42, key.begin(), 32);
     398                 :       28728 : }
     399                 :             : 
     400                 :      135656 : void CExtKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
     401                 :      135656 :     nDepth = code[0];
     402                 :      135656 :     memcpy(vchFingerprint, code+1, 4);
     403                 :      135656 :     nChild = ReadBE32(code+5);
     404                 :      135656 :     memcpy(chaincode.begin(), code+9, 32);
     405                 :      135656 :     key.Set(code+42, code+BIP32_EXTKEY_SIZE, true);
     406   [ +  +  +  -  :      135656 :     if ((nDepth == 0 && (nChild != 0 || ReadLE32(vchFingerprint) != 0)) || code[41] != 0) key = CKey();
             +  -  -  + ]
     407                 :      135656 : }
     408                 :             : 
     409         [ +  - ]:       12122 : KeyPair::KeyPair(const CKey& key, const uint256* merkle_root)
     410                 :             : {
     411                 :       12122 :     static_assert(std::tuple_size<KeyType>() == sizeof(secp256k1_keypair));
     412         [ +  - ]:       12122 :     MakeKeyPairData();
     413         [ +  - ]:       12122 :     auto keypair = reinterpret_cast<secp256k1_keypair*>(m_keypair->data());
     414   [ +  -  +  - ]:       24244 :     bool success = secp256k1_keypair_create(secp256k1_context_sign, keypair, UCharCast(key.data()));
     415         [ +  + ]:       12122 :     if (success && merkle_root) {
     416                 :       11354 :         secp256k1_xonly_pubkey pubkey;
     417                 :       11354 :         unsigned char pubkey_bytes[32];
     418   [ +  -  -  + ]:       11354 :         assert(secp256k1_keypair_xonly_pub(secp256k1_context_sign, &pubkey, nullptr, keypair));
     419   [ +  -  -  + ]:       11354 :         assert(secp256k1_xonly_pubkey_serialize(secp256k1_context_sign, pubkey_bytes, &pubkey));
     420   [ -  +  +  - ]:       11354 :         uint256 tweak = XOnlyPubKey(pubkey_bytes).ComputeTapTweakHash(merkle_root->IsNull() ? nullptr : merkle_root);
     421         [ +  - ]:       11354 :         success = secp256k1_keypair_xonly_tweak_add(secp256k1_context_static, keypair, tweak.data());
     422                 :             :     }
     423         [ -  + ]:       12122 :     if (!success) ClearKeyPairData();
     424                 :       12122 : }
     425                 :             : 
     426                 :       12122 : bool KeyPair::SignSchnorr(const uint256& hash, Span<unsigned char> sig, const uint256& aux) const
     427                 :             : {
     428         [ -  + ]:       12122 :     assert(sig.size() == 64);
     429         [ +  - ]:       12122 :     if (!IsValid()) return false;
     430                 :       12122 :     auto keypair = reinterpret_cast<const secp256k1_keypair*>(m_keypair->data());
     431                 :       12122 :     bool ret = secp256k1_schnorrsig_sign32(secp256k1_context_sign, sig.data(), hash.data(), keypair, aux.data());
     432         [ +  - ]:       12122 :     if (ret) {
     433                 :             :         // Additional verification step to prevent using a potentially corrupted signature
     434                 :       12122 :         secp256k1_xonly_pubkey pubkey_verify;
     435                 :       12122 :         ret = secp256k1_keypair_xonly_pub(secp256k1_context_static, &pubkey_verify, nullptr, keypair);
     436                 :       12122 :         ret &= secp256k1_schnorrsig_verify(secp256k1_context_static, sig.data(), hash.begin(), 32, &pubkey_verify);
     437                 :             :     }
     438         [ -  + ]:       12122 :     if (!ret) memory_cleanse(sig.data(), sig.size());
     439                 :             :     return ret;
     440                 :             : }
     441                 :             : 
     442                 :           0 : bool ECC_InitSanityCheck() {
     443                 :           0 :     CKey key = GenerateRandomKey();
     444         [ #  # ]:           0 :     CPubKey pubkey = key.GetPubKey();
     445         [ #  # ]:           0 :     return key.VerifyPubKey(pubkey);
     446                 :           0 : }
     447                 :             : 
     448                 :             : /** Initialize the elliptic curve support. May not be called twice without calling ECC_Stop first. */
     449                 :        1353 : static void ECC_Start() {
     450         [ -  + ]:        1353 :     assert(secp256k1_context_sign == nullptr);
     451                 :             : 
     452                 :        1353 :     secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
     453         [ -  + ]:        1353 :     assert(ctx != nullptr);
     454                 :             : 
     455                 :        1353 :     {
     456                 :             :         // Pass in a random blinding seed to the secp256k1 context.
     457                 :        1353 :         std::vector<unsigned char, secure_allocator<unsigned char>> vseed(32);
     458                 :        1353 :         GetRandBytes(vseed);
     459         [ +  - ]:        1353 :         bool ret = secp256k1_context_randomize(ctx, vseed.data());
     460         [ -  + ]:        1353 :         assert(ret);
     461                 :        1353 :     }
     462                 :             : 
     463                 :        1353 :     secp256k1_context_sign = ctx;
     464                 :        1353 : }
     465                 :             : 
     466                 :             : /** Deinitialize the elliptic curve support. No-op if ECC_Start wasn't called first. */
     467                 :        1353 : static void ECC_Stop() {
     468                 :        1353 :     secp256k1_context *ctx = secp256k1_context_sign;
     469                 :        1353 :     secp256k1_context_sign = nullptr;
     470                 :             : 
     471         [ +  - ]:        1353 :     if (ctx) {
     472                 :        1353 :         secp256k1_context_destroy(ctx);
     473                 :             :     }
     474                 :        1353 : }
     475                 :             : 
     476                 :        1353 : ECC_Context::ECC_Context()
     477                 :             : {
     478                 :        1353 :     ECC_Start();
     479                 :        1353 : }
     480                 :             : 
     481                 :        1353 : ECC_Context::~ECC_Context()
     482                 :             : {
     483                 :        1353 :     ECC_Stop();
     484                 :        1353 : }
        

Generated by: LCOV version 2.0-1