key.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2017 The Zcash developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_KEY_H
#define BITCOIN_KEY_H
 
#include <pubkey.h>
#include <support/allocators/secure.h>
#include <uint256.h>
 
#include <stdexcept>
#include <vector>
 
typedef std::vector<uint8_t, secure_allocator<uint8_t>> CPrivKey;
 
using SchnorrSig = std::array<uint8_t, CPubKey::SCHNORR_SIZE>;
 
class CKey {
public:
    static const unsigned int SIZE = 279;
    static const unsigned int COMPRESSED_SIZE = 214;
    static_assert(SIZE >= COMPRESSED_SIZE,
                  "COMPRESSED_SIZE is larger than SIZE");
 
private:
    bool fValid;
 
    bool fCompressed;
 
    std::vector<uint8_t, secure_allocator<uint8_t>> keydata;
 
    static bool Check(const uint8_t *vch);
 
public:
    CKey() : fValid(false), fCompressed(false) {
        // Important: vch must be 32 bytes in length to not break serialization
        keydata.resize(32);
    }
    static CKey MakeCompressedKey();
    static CKey MakeUncompressedKey();
 
    friend bool operator==(const CKey &a, const CKey &b) {
        return a.fCompressed == b.fCompressed && a.size() == b.size() &&
               memcmp(a.keydata.data(), b.keydata.data(), a.size()) == 0;
    }
 
    template <typename T>
    void Set(const T pbegin, const T pend, bool fCompressedIn) {
        if (size_t(pend - pbegin) != keydata.size()) {
            fValid = false;
        } else if (Check(&pbegin[0])) {
            memcpy(keydata.data(), (uint8_t *)&pbegin[0], keydata.size());
            fValid = true;
            fCompressed = fCompressedIn;
        } else {
            fValid = false;
        }
    }
 
    unsigned int size() const { return (fValid ? keydata.size() : 0); }
    const std::byte *data() const {
        return reinterpret_cast<const std::byte *>(keydata.data());
    }
    const uint8_t *begin() const { return keydata.data(); }
    const uint8_t *end() const { return keydata.data() + size(); }
 
    bool IsValid() const { return fValid; }
 
    bool IsCompressed() const { return fCompressed; }
 
    void MakeNewKey(bool fCompressed);
 
    bool Negate();
 
    CPrivKey GetPrivKey() const;
 
    CPubKey GetPubKey() const;
 
    bool SignECDSA(const uint256 &hash, std::vector<uint8_t> &vchSig,
                   bool grind = true, uint32_t test_case = 0) const;
 
    bool SignSchnorr(const uint256 &hash, SchnorrSig &sig,
                     uint32_t test_case = 0) const;
    bool SignSchnorr(const uint256 &hash, std::vector<uint8_t> &vchSig,
                     uint32_t test_case = 0) const;
 
    bool SignCompact(const uint256 &hash, std::vector<uint8_t> &vchSig) const;
 
    bool Derive(CKey &keyChild, ChainCode &ccChild, unsigned int nChild,
                const ChainCode &cc) const;
 
    bool VerifyPubKey(const CPubKey &vchPubKey) const;
 
    bool Load(const CPrivKey &privkey, const CPubKey &vchPubKey,
              bool fSkipCheck);
};
 
struct CExtKey {
    uint8_t nDepth;
    uint8_t vchFingerprint[4];
    unsigned int nChild;
    ChainCode chaincode;
    CKey key;
 
    friend bool operator==(const CExtKey &a, const CExtKey &b) {
        return a.nDepth == b.nDepth &&
               memcmp(a.vchFingerprint, b.vchFingerprint,
                      sizeof(vchFingerprint)) == 0 &&
               a.nChild == b.nChild && a.chaincode == b.chaincode &&
               a.key == b.key;
    }
 
    void Encode(uint8_t code[BIP32_EXTKEY_SIZE]) const;
    void Decode(const uint8_t code[BIP32_EXTKEY_SIZE]);
    bool Derive(CExtKey &out, unsigned int nChild) const;
    CExtPubKey Neuter() const;
    void SetSeed(Span<const std::byte> seed);
 
    CExtKey() = default;
};
 
void ECC_Start();
 
void ECC_Stop();
 
bool ECC_InitSanityCheck();
 
#endif // BITCOIN_KEY_H