#include "crypter.h"
#include "sync.h"
#include <boost/signals2/signal.hpp>
-#include <boost/variant.hpp>
+
+#include <variant>
class CScript;
*
* A CTxDestination is the internal data type encoded in a CBitcoinAddress.
*/
-typedef boost::variant<CNoDestination, CKeyID, CScriptID> CTxDestination;
+using CTxDestination = std::variant<CNoDestination, CKeyID, CScriptID>;
/** A virtual base class for key stores */
class CKeyStore
virtual bool AddKey(const CKey& key) =0;
// Add a malleable key to store.
- virtual bool AddMalleableKey(const CMalleableKey& mKey) =0;
+ virtual bool AddMalleableKey(const CMalleableKeyView &keyView, const CSecret &vchSecretH) =0;
virtual bool GetMalleableKey(const CMalleableKeyView &keyView, CMalleableKey &mKey) const =0;
// Check whether a key corresponding to a given address is present in the store.
typedef std::map<CKeyID, std::pair<CSecret, bool> > KeyMap;
typedef std::map<CScriptID, CScript > ScriptMap;
typedef std::set<CScript> WatchOnlySet;
-typedef std::map<CMalleableKeyView, CMalleableKey> MalleableKeyMap;
+typedef std::map<CMalleableKeyView, CSecret> MalleableKeyMap;
/** Basic key store, that keeps keys in an address->secret map */
class CBasicKeyStore : public CKeyStore
public:
bool AddKey(const CKey& key);
- bool AddMalleableKey(const CMalleableKey& mKey);
+ bool AddMalleableKey(const CMalleableKeyView& keyView, const CSecret &vchSecretH);
bool GetMalleableKey(const CMalleableKeyView &keyView, CMalleableKey &mKey) const
{
{
MalleableKeyMap::const_iterator mi = mapMalleableKeys.find(keyView);
if (mi != mapMalleableKeys.end())
{
- mKey = mi->second;
+ mKey = mi->first.GetMalleableKey(mi->second);
return true;
}
}
KeyMap::const_iterator mi = mapKeys.find(address);
if (mi != mapKeys.end())
{
- keyOut.Reset();
keyOut.SetSecret((*mi).second.first, (*mi).second.second);
return true;
}
LOCK(cs_KeyStore);
for (MalleableKeyMap::const_iterator mi = mapMalleableKeys.begin(); mi != mapMalleableKeys.end(); mi++)
{
- if (mi->second.CheckKeyVariant(R, pubKeyVariant, privKey))
- return true;
+ if (mi->first.CheckKeyVariant(R, pubKeyVariant))
+ {
+ CMalleableKey mKey = mi->first.GetMalleableKey(mi->second);
+ return mKey.CheckKeyVariant(R, pubKeyVariant, privKey);
+ }
}
}
return false;
void ListMalleableViews(std::list<CMalleableKeyView> &malleableViewList) const
{
malleableViewList.clear();
-
{
LOCK(cs_KeyStore);
for (MalleableKeyMap::const_iterator mi = mapMalleableKeys.begin(); mi != mapMalleableKeys.end(); mi++)
malleableViewList.push_back(CMalleableKeyView(mi->first));
}
}
+
+ bool GetMalleableView(const CMalleablePubKey &mpk, CMalleableKeyView &view)
+ {
+ const CKeyID &mpkID = mpk.GetID();
+ {
+ LOCK(cs_KeyStore);
+ for (MalleableKeyMap::const_iterator mi = mapMalleableKeys.begin(); mi != mapMalleableKeys.end(); mi++)
+ if (mi->first.GetID() == mpkID)
+ {
+ view = CMalleableKeyView(mi->first);
+ return true;
+ }
+ }
+
+ return false;
+ }
};
typedef std::map<CKeyID, std::pair<CPubKey, std::vector<unsigned char> > > CryptedKeyMap;
+typedef std::map<CMalleableKeyView, std::vector<unsigned char> > CryptedMalleableKeyMap;
/** Keystore which keeps the private keys encrypted.
* It derives from the basic key store, which is used if no encryption is active.
{
private:
CryptedKeyMap mapCryptedKeys;
+ CryptedMalleableKeyMap mapCryptedMalleableKeys;
CKeyingMaterial vMasterKey;
bool Lock();
virtual bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
+ virtual bool AddCryptedMalleableKey(const CMalleableKeyView& keyView, const std::vector<unsigned char> &vchCryptedSecretH);
+
bool AddKey(const CKey& key);
+ bool AddMalleableKey(const CMalleableKeyView& keyView, const CSecret &vchSecretH);
bool HaveKey(const CKeyID &address) const
{
{
}
}
+ bool GetMalleableKey(const CMalleableKeyView &keyView, CMalleableKey &mKey) const;
+
+ bool CheckOwnership(const CPubKey &pubKeyVariant, const CPubKey &R) const
+ {
+ {
+ LOCK(cs_KeyStore);
+ if (!IsCrypted())
+ return CBasicKeyStore::CheckOwnership(pubKeyVariant, R);
+ for (CryptedMalleableKeyMap::const_iterator mi = mapCryptedMalleableKeys.begin(); mi != mapCryptedMalleableKeys.end(); mi++)
+ {
+ if (mi->first.CheckKeyVariant(R, pubKeyVariant))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool CheckOwnership(const CPubKey &pubKeyVariant, const CPubKey &R, CMalleableKeyView &view) const
+ {
+ {
+ LOCK(cs_KeyStore);
+ if (!IsCrypted())
+ return CBasicKeyStore::CheckOwnership(pubKeyVariant, R, view);
+ for (CryptedMalleableKeyMap::const_iterator mi = mapCryptedMalleableKeys.begin(); mi != mapCryptedMalleableKeys.end(); mi++)
+ {
+ if (mi->first.CheckKeyVariant(R, pubKeyVariant))
+ {
+ view = mi->first;
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ bool CheckOwnership(const CMalleablePubKey &mpk)
+ {
+ CMalleableKeyView view;
+ return GetMalleableView(mpk, view);
+ }
+
+ bool CreatePrivKey(const CPubKey &pubKeyVariant, const CPubKey &R, CKey &privKey) const;
+
+ void ListMalleableViews(std::list<CMalleableKeyView> &malleableViewList) const
+ {
+ malleableViewList.clear();
+ {
+ LOCK(cs_KeyStore);
+ if (!IsCrypted())
+ return CBasicKeyStore::ListMalleableViews(malleableViewList);
+ for (CryptedMalleableKeyMap::const_iterator mi = mapCryptedMalleableKeys.begin(); mi != mapCryptedMalleableKeys.end(); mi++)
+ malleableViewList.push_back(CMalleableKeyView(mi->first));
+ }
+ }
+
+ bool GetMalleableView(const CMalleablePubKey &mpk, CMalleableKeyView &view)
+ {
+ const CKeyID &mpkID = mpk.GetID();
+ {
+ LOCK(cs_KeyStore);
+ if (!IsCrypted())
+ return CBasicKeyStore::GetMalleableView(mpk, view);
+ for (CryptedMalleableKeyMap::const_iterator mi = mapCryptedMalleableKeys.begin(); mi != mapCryptedMalleableKeys.end(); mi++)
+ if (mi->first.GetID() == mpkID)
+ {
+ view = CMalleableKeyView(mi->first);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
/* Wallet status (encrypted, locked) changed.
* Note: Called without locks held.
*/