Line data Source code
1 : // Copyright (c) 2009-2019 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 <wallet/crypter.h>
6 :
7 : #include <crypto/aes.h>
8 : #include <crypto/sha512.h>
9 : #include <util/system.h>
10 :
11 : #include <vector>
12 :
13 206 : int CCrypter::BytesToKeySHA512AES(const std::vector<unsigned char>& chSalt, const SecureString& strKeyData, int count, unsigned char *key,unsigned char *iv) const
14 : {
15 : // This mimics the behavior of openssl's EVP_BytesToKey with an aes256cbc
16 : // cipher and sha512 message digest. Because sha512's output size (64b) is
17 : // greater than the aes256 block size (16b) + aes256 key size (32b),
18 : // there's no need to process more than once (D_0).
19 :
20 206 : if(!count || !key || !iv)
21 0 : return 0;
22 :
23 206 : unsigned char buf[CSHA512::OUTPUT_SIZE];
24 206 : CSHA512 di;
25 :
26 206 : di.Write((const unsigned char*)strKeyData.data(), strKeyData.size());
27 206 : di.Write(chSalt.data(), chSalt.size());
28 206 : di.Finalize(buf);
29 :
30 6249193 : for(int i = 0; i != count - 1; i++)
31 6248987 : di.Reset().Write(buf, sizeof(buf)).Finalize(buf);
32 :
33 206 : memcpy(key, buf, WALLET_CRYPTO_KEY_SIZE);
34 206 : memcpy(iv, buf + WALLET_CRYPTO_KEY_SIZE, WALLET_CRYPTO_IV_SIZE);
35 206 : memory_cleanse(buf, sizeof(buf));
36 : return WALLET_CRYPTO_KEY_SIZE;
37 206 : }
38 :
39 206 : bool CCrypter::SetKeyFromPassphrase(const SecureString& strKeyData, const std::vector<unsigned char>& chSalt, const unsigned int nRounds, const unsigned int nDerivationMethod)
40 : {
41 206 : if (nRounds < 1 || chSalt.size() != WALLET_CRYPTO_SALT_SIZE)
42 0 : return false;
43 :
44 : int i = 0;
45 206 : if (nDerivationMethod == 0)
46 206 : i = BytesToKeySHA512AES(chSalt, strKeyData, nRounds, vchKey.data(), vchIV.data());
47 :
48 206 : if (i != (int)WALLET_CRYPTO_KEY_SIZE)
49 : {
50 0 : memory_cleanse(vchKey.data(), vchKey.size());
51 0 : memory_cleanse(vchIV.data(), vchIV.size());
52 0 : return false;
53 : }
54 :
55 206 : fKeySet = true;
56 206 : return true;
57 206 : }
58 :
59 3268 : bool CCrypter::SetKey(const CKeyingMaterial& chNewKey, const std::vector<unsigned char>& chNewIV)
60 : {
61 3268 : if (chNewKey.size() != WALLET_CRYPTO_KEY_SIZE || chNewIV.size() != WALLET_CRYPTO_IV_SIZE)
62 0 : return false;
63 :
64 3268 : memcpy(vchKey.data(), chNewKey.data(), chNewKey.size());
65 3268 : memcpy(vchIV.data(), chNewIV.data(), chNewIV.size());
66 :
67 3268 : fKeySet = true;
68 3268 : return true;
69 3268 : }
70 :
71 4207 : bool CCrypter::Encrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned char> &vchCiphertext) const
72 : {
73 4207 : if (!fKeySet)
74 0 : return false;
75 :
76 : // max ciphertext len for a n bytes of plaintext is
77 : // n + AES_BLOCKSIZE bytes
78 4207 : vchCiphertext.resize(vchPlaintext.size() + AES_BLOCKSIZE);
79 :
80 4207 : AES256CBCEncrypt enc(vchKey.data(), vchIV.data(), true);
81 4207 : size_t nLen = enc.Encrypt(&vchPlaintext[0], vchPlaintext.size(), vchCiphertext.data());
82 4207 : if(nLen < vchPlaintext.size())
83 0 : return false;
84 4207 : vchCiphertext.resize(nLen);
85 :
86 4207 : return true;
87 4207 : }
88 :
89 5923 : bool CCrypter::Decrypt(const std::vector<unsigned char>& vchCiphertext, CKeyingMaterial& vchPlaintext) const
90 : {
91 5923 : if (!fKeySet)
92 0 : return false;
93 :
94 : // plaintext will always be equal to or lesser than length of ciphertext
95 5923 : int nLen = vchCiphertext.size();
96 :
97 5923 : vchPlaintext.resize(nLen);
98 :
99 5923 : AES256CBCDecrypt dec(vchKey.data(), vchIV.data(), true);
100 5923 : nLen = dec.Decrypt(vchCiphertext.data(), vchCiphertext.size(), &vchPlaintext[0]);
101 5923 : if(nLen == 0)
102 110 : return false;
103 5813 : vchPlaintext.resize(nLen);
104 5813 : return true;
105 5923 : }
106 :
107 852 : bool EncryptSecret(const CKeyingMaterial& vMasterKey, const CKeyingMaterial &vchPlaintext, const uint256& nIV, std::vector<unsigned char> &vchCiphertext)
108 : {
109 852 : CCrypter cKeyCrypter;
110 852 : std::vector<unsigned char> chIV(WALLET_CRYPTO_IV_SIZE);
111 852 : memcpy(chIV.data(), &nIV, WALLET_CRYPTO_IV_SIZE);
112 852 : if(!cKeyCrypter.SetKey(vMasterKey, chIV))
113 0 : return false;
114 852 : return cKeyCrypter.Encrypt(*((const CKeyingMaterial*)&vchPlaintext), vchCiphertext);
115 852 : }
116 :
117 2416 : bool DecryptSecret(const CKeyingMaterial& vMasterKey, const std::vector<unsigned char>& vchCiphertext, const uint256& nIV, CKeyingMaterial& vchPlaintext)
118 : {
119 2416 : CCrypter cKeyCrypter;
120 2416 : std::vector<unsigned char> chIV(WALLET_CRYPTO_IV_SIZE);
121 2416 : memcpy(chIV.data(), &nIV, WALLET_CRYPTO_IV_SIZE);
122 2416 : if(!cKeyCrypter.SetKey(vMasterKey, chIV))
123 0 : return false;
124 2416 : return cKeyCrypter.Decrypt(vchCiphertext, *((CKeyingMaterial*)&vchPlaintext));
125 2416 : }
126 :
127 2416 : bool DecryptKey(const CKeyingMaterial& vMasterKey, const std::vector<unsigned char>& vchCryptedSecret, const CPubKey& vchPubKey, CKey& key)
128 : {
129 2416 : CKeyingMaterial vchSecret;
130 2416 : if(!DecryptSecret(vMasterKey, vchCryptedSecret, vchPubKey.GetHash(), vchSecret))
131 0 : return false;
132 :
133 2416 : if (vchSecret.size() != 32)
134 0 : return false;
135 :
136 2416 : key.Set(vchSecret.begin(), vchSecret.end(), vchPubKey.IsCompressed());
137 2416 : return key.VerifyPubKey(vchPubKey);
138 2416 : }
|
