return true;
}
+bool CBasicKeyStore::AddMalleableKey(const CMalleableKeyView& keyView, const CSecret& vchSecretH)
+{
+ {
+ LOCK(cs_KeyStore);
+ mapMalleableKeys[CMalleableKeyView(keyView)] = vchSecretH;
+ }
+ return true;
+}
+
bool CBasicKeyStore::AddCScript(const CScript& redeemScript)
{
if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
if (vchSecret.size() != 32)
return false;
CKey key;
- key.SetPubKey(vchPubKey);
key.SetSecret(vchSecret);
+ key.SetCompressedPubKey(vchPubKey.IsCompressed());
if (key.GetPubKey() == vchPubKey)
break;
return false;
}
+
vMasterKey = vMasterKeyIn;
}
NotifyStatusChanged(this);
return true;
}
+bool CCryptoKeyStore::AddMalleableKey(const CMalleableKeyView& keyView, const CSecret &vchSecretH)
+{
+ {
+ LOCK(cs_KeyStore);
+ if (!SetCrypted())
+ return CBasicKeyStore::AddMalleableKey(keyView, vchSecretH);
+
+ if (IsLocked())
+ return false;
+
+ CKey keyH;
+ keyH.SetSecret(vchSecretH, true);
+
+ std::vector<unsigned char> vchCryptedSecretH;
+ if (!EncryptSecret(vMasterKey, vchSecretH, keyH.GetPubKey().GetHash(), vchCryptedSecretH))
+ return false;
+
+ if (!AddCryptedMalleableKey(keyView, vchCryptedSecretH))
+ return false;
+ }
+ return true;
+}
bool CCryptoKeyStore::AddCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
{
return true;
}
+bool CCryptoKeyStore::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const std::vector<unsigned char> &vchCryptedSecretH)
+{
+ {
+ LOCK(cs_KeyStore);
+ if (!SetCrypted())
+ return false;
+
+ mapCryptedMalleableKeys[CMalleableKeyView(keyView)] = vchCryptedSecretH;
+ }
+ return true;
+}
+
+bool CCryptoKeyStore::CreatePrivKey(const CPubKey &pubKeyVariant, const CPubKey &R, CKey &privKey) const
+{
+ {
+ LOCK(cs_KeyStore);
+ if (!IsCrypted())
+ return CBasicKeyStore::CreatePrivKey(pubKeyVariant, R, privKey);
+
+ for (CryptedMalleableKeyMap::const_iterator mi = mapCryptedMalleableKeys.begin(); mi != mapCryptedMalleableKeys.end(); mi++)
+ {
+ if (mi->first.CheckKeyVariant(R, pubKeyVariant))
+ {
+ const CPubKey H = mi->first.GetMalleablePubKey().GetH();
+
+ CSecret vchSecretH;
+ if (!DecryptSecret(vMasterKey, mi->second, H.GetHash(), vchSecretH))
+ return false;
+ if (vchSecretH.size() != 32)
+ return false;
+
+ CMalleableKey mKey = mi->first.GetMalleableKey(vchSecretH);
+ return mKey.CheckKeyVariant(R, pubKeyVariant, privKey);;
+ }
+ }
+
+ }
+ return true;
+}
+
+bool CCryptoKeyStore::GetMalleableKey(const CMalleableKeyView &keyView, CMalleableKey &mKey) const
+{
+ {
+ LOCK(cs_KeyStore);
+ if (!IsCrypted())
+ return CBasicKeyStore::GetMalleableKey(keyView, mKey);
+ CryptedMalleableKeyMap::const_iterator mi = mapCryptedMalleableKeys.find(keyView);
+ if (mi != mapCryptedMalleableKeys.end())
+ {
+ const CPubKey H = keyView.GetMalleablePubKey().GetH();
+
+ CSecret vchSecretH;
+ if (!DecryptSecret(vMasterKey, mi->second, H.GetHash(), vchSecretH))
+ return false;
+
+ if (vchSecretH.size() != 32)
+ return false;
+ mKey = mi->first.GetMalleableKey(vchSecretH);
+
+ return true;
+ }
+ }
+ return false;
+}
+
bool CCryptoKeyStore::GetKey(const CKeyID &address, CKey& keyOut) const
{
{
return false;
if (vchSecret.size() != 32)
return false;
- keyOut.SetPubKey(vchPubKey);
keyOut.SetSecret(vchSecret);
+ keyOut.SetCompressedPubKey(vchPubKey.IsCompressed());
return true;
}
}
return false;
fUseCrypto = true;
- BOOST_FOREACH(KeyMap::value_type& mKey, mapKeys)
+ for (KeyMap::value_type& mKey : mapKeys)
{
CKey key;
if (!key.SetSecret(mKey.second.first, mKey.second.second))
return false;
}
mapKeys.clear();
+
+ for (MalleableKeyMap::value_type& mKey : mapMalleableKeys)
+ {
+ const CPubKey vchPubKeyH = mKey.first.GetMalleablePubKey().GetH();
+ std::vector<unsigned char> vchCryptedSecretH;
+ if (!EncryptSecret(vMasterKeyIn, mKey.second, vchPubKeyH.GetHash(), vchCryptedSecretH))
+ return false;
+ if (!AddCryptedMalleableKey(mKey.first, vchCryptedSecretH))
+ return false;
+ }
+ mapMalleableKeys.clear();
}
return true;
}
if (vchSecret.size() != 32)
return false;
CKey key;
- key.SetPubKey(vchPubKey);
key.SetSecret(vchSecret);
+ key.SetCompressedPubKey(vchPubKey.IsCompressed());
if (!CBasicKeyStore::AddKey(key))
return false;
}
mapCryptedKeys.clear();
+
+ CryptedMalleableKeyMap::const_iterator mi2 = mapCryptedMalleableKeys.begin();
+ for(; mi2 != mapCryptedMalleableKeys.end(); ++mi2)
+ {
+ const CPubKey vchPubKeyH = mi2->first.GetMalleablePubKey().GetH();
+
+ CSecret vchSecretH;
+ if(!DecryptSecret(vMasterKeyIn, mi2->second, vchPubKeyH.GetHash(), vchSecretH))
+ return false;
+ if (vchSecretH.size() != 32)
+ return false;
+
+ if (!CBasicKeyStore::AddMalleableKey(mi2->first, vchSecretH))
+ return false;
+ }
+ mapCryptedMalleableKeys.clear();
}
return true;