src/key.cpp

   1 // Copyright (c) 2009-2014 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "key.h"
   6
   7 #include "arith_uint256.h"
   8 #include "crypto/hmac_sha512.h"
   9 #include "crypto/rfc6979_hmac_sha256.h"
  10 #include "eccryptoverify.h"
  11 #include "pubkey.h"
  12 #include "random.h"
  13
  14 #include <secp256k1.h>
  15 #include "ecwrapper.h"
  16
  17 //! anonymous namespace
  18 namespace {
  19
  20 class CSecp256k1Init {
  21 public:
  22     CSecp256k1Init() {
  23         secp256k1_start(SECP256K1_START_SIGN);
  24     }
  25     ~CSecp256k1Init() {
  26         secp256k1_stop();
  27     }
  28 };
  29 static CSecp256k1Init instance_of_csecp256k1;
  30
  31 } // anon namespace
  32
  33 bool CKey::Check(const unsigned char *vch) {
  34     return eccrypto::Check(vch);
  35 }
  36
  37 void CKey::MakeNewKey(bool fCompressedIn) {
  38     RandAddSeedPerfmon();
  39     do {
  40         GetRandBytes(vch, sizeof(vch));
  41     } while (!Check(vch));
  42     fValid = true;
  43     fCompressed = fCompressedIn;
  44 }
  45
  46 bool CKey::SetPrivKey(const CPrivKey &privkey, bool fCompressedIn) {
  47     if (!secp256k1_ec_privkey_import((unsigned char*)begin(), &privkey[0], privkey.size()))
  48         return false;
  49     fCompressed = fCompressedIn;
  50     fValid = true;
  51     return true;
  52 }
  53
  54 CPrivKey CKey::GetPrivKey() const {
  55     assert(fValid);
  56     CPrivKey privkey;
  57     int privkeylen, ret;
  58     privkey.resize(279);
  59     privkeylen = 279;
  60     ret = secp256k1_ec_privkey_export(begin(), (unsigned char*)&privkey[0], &privkeylen, fCompressed);
  61     assert(ret);
  62     privkey.resize(privkeylen);
  63     return privkey;
  64 }
  65
  66 CPubKey CKey::GetPubKey() const {
  67     assert(fValid);
  68     CPubKey result;
  69     int clen = 65;
  70     int ret = secp256k1_ec_pubkey_create((unsigned char*)result.begin(), &clen, begin(), fCompressed);
  71     assert((int)result.size() == clen);
  72     assert(ret);
  73     assert(result.IsValid());
  74     return result;
  75 }
  76
  77 bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, uint32_t test_case) const {
  78     if (!fValid)
  79         return false;
  80     vchSig.resize(72);
  81     RFC6979_HMAC_SHA256 prng(begin(), 32, (unsigned char*)&hash, 32);
  82     do {
  83         uint256 nonce;
  84         prng.Generate((unsigned char*)&nonce, 32);
  85         nonce = ArithToUint256(UintToArith256(nonce) + test_case);
  86         int nSigLen = 72;
  87         int ret = secp256k1_ecdsa_sign((const unsigned char*)&hash, (unsigned char*)&vchSig[0], &nSigLen, begin(), (unsigned char*)&nonce);
  88         nonce = uint256();
  89         if (ret) {
  90             vchSig.resize(nSigLen);
  91             return true;
  92         }
  93     } while(true);
  94 }
  95
  96 bool CKey::VerifyPubKey(const CPubKey& pubkey) const {
  97     if (pubkey.IsCompressed() != fCompressed) {
  98         return false;
  99     }
 100     unsigned char rnd[8];
 101     std::string str = "Bitcoin key verification\n";
 102     GetRandBytes(rnd, sizeof(rnd));
 103     uint256 hash;
 104     CHash256().Write((unsigned char*)str.data(), str.size()).Write(rnd, sizeof(rnd)).Finalize((unsigned char*)&hash);
 105     std::vector<unsigned char> vchSig;
 106     Sign(hash, vchSig);
 107     return pubkey.Verify(hash, vchSig);
 108 }
 109
 110 bool CKey::SignCompact(const uint256 &hash, std::vector<unsigned char>& vchSig) const {
 111     if (!fValid)
 112         return false;
 113     vchSig.resize(65);
 114     int rec = -1;
 115     RFC6979_HMAC_SHA256 prng(begin(), 32, (unsigned char*)&hash, 32);
 116     do {
 117         uint256 nonce;
 118         prng.Generate((unsigned char*)&nonce, 32);
 119         int ret = secp256k1_ecdsa_sign_compact((const unsigned char*)&hash, &vchSig[1], begin(), (unsigned char*)&nonce, &rec);
 120         nonce = uint256();
 121         if (ret)
 122             break;
 123     } while(true);
 124     assert(rec != -1);
 125     vchSig[0] = 27 + rec + (fCompressed ? 4 : 0);
 126     return true;
 127 }
 128
 129 bool CKey::Load(CPrivKey &privkey, CPubKey &vchPubKey, bool fSkipCheck=false) {
 130     if (!secp256k1_ec_privkey_import((unsigned char*)begin(), &privkey[0], privkey.size()))
 131         return false;
 132     fCompressed = vchPubKey.IsCompressed();
 133     fValid = true;
 134
 135     if (fSkipCheck)
 136         return true;
 137
 138     return VerifyPubKey(vchPubKey);
 139 }
 140
 141 bool CKey::Derive(CKey& keyChild, unsigned char ccChild[32], unsigned int nChild, const unsigned char cc[32]) const {
 142     assert(IsValid());
 143     assert(IsCompressed());
 144     unsigned char out[64];
 145     LockObject(out);
 146     if ((nChild >> 31) == 0) {
 147         CPubKey pubkey = GetPubKey();
 148         assert(pubkey.begin() + 33 == pubkey.end());
 149         BIP32Hash(cc, nChild, *pubkey.begin(), pubkey.begin()+1, out);
 150     } else {
 151         assert(begin() + 32 == end());
 152         BIP32Hash(cc, nChild, 0, begin(), out);
 153     }
 154     memcpy(ccChild, out+32, 32);
 155     memcpy((unsigned char*)keyChild.begin(), begin(), 32);
 156     bool ret = secp256k1_ec_privkey_tweak_add((unsigned char*)keyChild.begin(), out);
 157     UnlockObject(out);
 158     keyChild.fCompressed = true;
 159     keyChild.fValid = ret;
 160     return ret;
 161 }
 162
 163 bool CExtKey::Derive(CExtKey &out, unsigned int nChild) const {
 164     out.nDepth = nDepth + 1;
 165     CKeyID id = key.GetPubKey().GetID();
 166     memcpy(&out.vchFingerprint[0], &id, 4);
 167     out.nChild = nChild;
 168     return key.Derive(out.key, out.vchChainCode, nChild, vchChainCode);
 169 }
 170
 171 void CExtKey::SetMaster(const unsigned char *seed, unsigned int nSeedLen) {
 172     static const unsigned char hashkey[] = {'B','i','t','c','o','i','n',' ','s','e','e','d'};
 173     unsigned char out[64];
 174     LockObject(out);
 175     CHMAC_SHA512(hashkey, sizeof(hashkey)).Write(seed, nSeedLen).Finalize(out);
 176     key.Set(&out[0], &out[32], true);
 177     memcpy(vchChainCode, &out[32], 32);
 178     UnlockObject(out);
 179     nDepth = 0;
 180     nChild = 0;
 181     memset(vchFingerprint, 0, sizeof(vchFingerprint));
 182 }
 183
 184 CExtPubKey CExtKey::Neuter() const {
 185     CExtPubKey ret;
 186     ret.nDepth = nDepth;
 187     memcpy(&ret.vchFingerprint[0], &vchFingerprint[0], 4);
 188     ret.nChild = nChild;
 189     ret.pubkey = key.GetPubKey();
 190     memcpy(&ret.vchChainCode[0], &vchChainCode[0], 32);
 191     return ret;
 192 }
 193
 194 void CExtKey::Encode(unsigned char code[74]) const {
 195     code[0] = nDepth;
 196     memcpy(code+1, vchFingerprint, 4);
 197     code[5] = (nChild >> 24) & 0xFF; code[6] = (nChild >> 16) & 0xFF;
 198     code[7] = (nChild >>  8) & 0xFF; code[8] = (nChild >>  0) & 0xFF;
 199     memcpy(code+9, vchChainCode, 32);
 200     code[41] = 0;
 201     assert(key.size() == 32);
 202     memcpy(code+42, key.begin(), 32);
 203 }
 204
 205 void CExtKey::Decode(const unsigned char code[74]) {
 206     nDepth = code[0];
 207     memcpy(vchFingerprint, code+1, 4);
 208     nChild = (code[5] << 24) | (code[6] << 16) | (code[7] << 8) | code[8];
 209     memcpy(vchChainCode, code+9, 32);
 210     key.Set(code+42, code+74, true);
 211 }
 212
 213 bool ECC_InitSanityCheck() {
 214 #if !defined(USE_SECP256K1)
 215     if (!CECKey::SanityCheck()) {
 216         return false;
 217     }
 218 #endif
 219     CKey key;
 220     key.MakeNewKey(true);
 221     CPubKey pubkey = key.GetPubKey();
 222     return key.VerifyPubKey(pubkey);
 223 }