src/wallet/crypter.h

   1 // Copyright (c) 2009-2016 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 #ifndef BITCOIN_WALLET_CRYPTER_H
   6 #define BITCOIN_WALLET_CRYPTER_H
   7
   8 #include "keystore.h"
   9 #include "serialize.h"
  10 #include "support/allocators/secure.h"
  11
  12 class uint256;
  13
  14 const unsigned int WALLET_CRYPTO_KEY_SIZE = 32;
  15 const unsigned int WALLET_CRYPTO_SALT_SIZE = 8;
  16 const unsigned int WALLET_CRYPTO_IV_SIZE = 16;
  17
  18 /**
  19  * Private key encryption is done based on a CMasterKey,
  20  * which holds a salt and random encryption key.
  21  *
  22  * CMasterKeys are encrypted using AES-256-CBC using a key
  23  * derived using derivation method nDerivationMethod
  24  * (0 == EVP_sha512()) and derivation iterations nDeriveIterations.
  25  * vchOtherDerivationParameters is provided for alternative algorithms
  26  * which may require more parameters (such as scrypt).
  27  *
  28  * Wallet Private Keys are then encrypted using AES-256-CBC
  29  * with the double-sha256 of the public key as the IV, and the
  30  * master key's key as the encryption key (see keystore.[ch]).
  31  */
  32
  33 /** Master key for wallet encryption */
  34 class CMasterKey
  35 {
  36 public:
  37     std::vector<unsigned char> vchCryptedKey;
  38     std::vector<unsigned char> vchSalt;
  39     //! 0 = EVP_sha512()
  40     //! 1 = scrypt()
  41     unsigned int nDerivationMethod;
  42     unsigned int nDeriveIterations;
  43     //! Use this for more parameters to key derivation,
  44     //! such as the various parameters to scrypt
  45     std::vector<unsigned char> vchOtherDerivationParameters;
  46
  47     ADD_SERIALIZE_METHODS;
  48
  49     template <typename Stream, typename Operation>
  50     inline void SerializationOp(Stream& s, Operation ser_action) {
  51         READWRITE(vchCryptedKey);
  52         READWRITE(vchSalt);
  53         READWRITE(nDerivationMethod);
  54         READWRITE(nDeriveIterations);
  55         READWRITE(vchOtherDerivationParameters);
  56     }
  57
  58     CMasterKey()
  59     {
  60         // 25000 rounds is just under 0.1 seconds on a 1.86 GHz Pentium M
  61         // ie slightly lower than the lowest hardware we need bother supporting
  62         nDeriveIterations = 25000;
  63         nDerivationMethod = 0;
  64         vchOtherDerivationParameters = std::vector<unsigned char>(0);
  65     }
  66 };
  67
  68 typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKeyingMaterial;
  69
  70 namespace wallet_crypto
  71 {
  72     class TestCrypter;
  73 }
  74
  75 /** Encryption/decryption context with key information */
  76 class CCrypter
  77 {
  78 friend class wallet_crypto::TestCrypter; // for test access to chKey/chIV
  79 private:
  80     std::vector<unsigned char, secure_allocator<unsigned char>> vchKey;
  81     std::vector<unsigned char, secure_allocator<unsigned char>> vchIV;
  82     bool fKeySet;
  83
  84     int BytesToKeySHA512AES(const std::vector<unsigned char>& chSalt, const SecureString& strKeyData, int count, unsigned char *key,unsigned char *iv) const;
  85
  86 public:
  87     bool SetKeyFromPassphrase(const SecureString &strKeyData, const std::vector<unsigned char>& chSalt, const unsigned int nRounds, const unsigned int nDerivationMethod);
  88     bool Encrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned char> &vchCiphertext) const;
  89     bool Decrypt(const std::vector<unsigned char>& vchCiphertext, CKeyingMaterial& vchPlaintext) const;
  90     bool SetKey(const CKeyingMaterial& chNewKey, const std::vector<unsigned char>& chNewIV);
  91
  92     void CleanKey()
  93     {
  94         memory_cleanse(vchKey.data(), vchKey.size());
  95         memory_cleanse(vchIV.data(), vchIV.size());
  96         fKeySet = false;
  97     }
  98
  99     CCrypter()
 100     {
 101         fKeySet = false;
 102         vchKey.resize(WALLET_CRYPTO_KEY_SIZE);
 103         vchIV.resize(WALLET_CRYPTO_IV_SIZE);
 104     }
 105
 106     ~CCrypter()
 107     {
 108         CleanKey();
 109     }
 110 };
 111
 112 /** Keystore which keeps the private keys encrypted.
 113  * It derives from the basic key store, which is used if no encryption is active.
 114  */
 115 class CCryptoKeyStore : public CBasicKeyStore
 116 {
 117 private:
 118     CryptedKeyMap mapCryptedKeys;
 119
 120     CKeyingMaterial vMasterKey;
 121
 122     //! if fUseCrypto is true, mapKeys must be empty
 123     //! if fUseCrypto is false, vMasterKey must be empty
 124     bool fUseCrypto;
 125
 126     //! keeps track of whether Unlock has run a thorough check before
 127     bool fDecryptionThoroughlyChecked;
 128
 129 protected:
 130     bool SetCrypted();
 131
 132     //! will encrypt previously unencrypted keys
 133     bool EncryptKeys(CKeyingMaterial& vMasterKeyIn);
 134
 135     bool Unlock(const CKeyingMaterial& vMasterKeyIn);
 136
 137 public:
 138     CCryptoKeyStore() : fUseCrypto(false), fDecryptionThoroughlyChecked(false)
 139     {
 140     }
 141
 142     bool IsCrypted() const
 143     {
 144         return fUseCrypto;
 145     }
 146
 147     bool IsLocked() const
 148     {
 149         if (!IsCrypted())
 150             return false;
 151         bool result;
 152         {
 153             LOCK(cs_KeyStore);
 154             result = vMasterKey.empty();
 155         }
 156         return result;
 157     }
 158
 159     bool Lock();
 160
 161     virtual bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
 162     bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey);
 163     bool HaveKey(const CKeyID &address) const
 164     {
 165         {
 166             LOCK(cs_KeyStore);
 167             if (!IsCrypted())
 168                 return CBasicKeyStore::HaveKey(address);
 169             return mapCryptedKeys.count(address) > 0;
 170         }
 171         return false;
 172     }
 173     bool GetKey(const CKeyID &address, CKey& keyOut) const;
 174     bool GetPubKey(const CKeyID &address, CPubKey& vchPubKeyOut) const;
 175     void GetKeys(std::set<CKeyID> &setAddress) const
 176     {
 177         if (!IsCrypted())
 178         {
 179             CBasicKeyStore::GetKeys(setAddress);
 180             return;
 181         }
 182         setAddress.clear();
 183         CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
 184         while (mi != mapCryptedKeys.end())
 185         {
 186             setAddress.insert((*mi).first);
 187             mi++;
 188         }
 189     }
 190
 191     /**
 192      * Wallet status (encrypted, locked) changed.
 193      * Note: Called without locks held.
 194      */
 195     boost::signals2::signal<void (CCryptoKeyStore* wallet)> NotifyStatusChanged;
 196 };
 197
 198 #endif // BITCOIN_WALLET_CRYPTER_H