X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fkeystore.h;h=438752fa03f046b86794754c4ffce45202974712;hb=5f3f7465db4444e49dd4a896f88c090b40d0a303;hp=f03ffb3794ba5446cfc7731861e591cda52f9d01;hpb=31442f0370ff570f249d60cc8b99752b1ddb0715;p=novacoin.git

diff --git a/src/keystore.h b/src/keystore.h
index f03ffb3..438752f 100644
--- a/src/keystore.h
+++ b/src/keystore.h
@@ -40,7 +40,7 @@ public:
     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.
@@ -70,6 +70,7 @@ public:
     }
 
     virtual bool CheckOwnership(const CPubKey &pubKeyVariant, const CPubKey &R) const =0;
+    virtual bool CheckOwnership(const CPubKey &pubKeyVariant, const CPubKey &R, CMalleableKeyView &view) const =0;
     virtual bool CreatePrivKey(const CPubKey &pubKeyVariant, const CPubKey &R, CKey &privKey) const =0;
     virtual void ListMalleableViews(std::list<CMalleableKeyView> &malleableViewList) const =0;
 };
@@ -77,7 +78,7 @@ public:
 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
@@ -91,7 +92,7 @@ protected:
 
 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
     {
         {
@@ -99,7 +100,7 @@ public:
             MalleableKeyMap::const_iterator mi = mapMalleableKeys.find(keyView);
             if (mi != mapMalleableKeys.end())
             {
-                mKey = mi->second;
+                mKey = mi->first.GetMalleableKey(mi->second);
                 return true;
             }
         }
@@ -160,14 +161,33 @@ public:
         return false;
     }
 
-    bool CreatePrivKey(const CPubKey &pubKeyVariant, const CPubKey &R, CKey &privKey) const
+    bool CheckOwnership(const CPubKey &pubKeyVariant, const CPubKey &R, CMalleableKeyView &view) const
     {
         {
             LOCK(cs_KeyStore);
             for (MalleableKeyMap::const_iterator mi = mapMalleableKeys.begin(); mi != mapMalleableKeys.end(); mi++)
             {
-                if (mi->second.CheckKeyVariant(R, pubKeyVariant, privKey))
+                if (mi->first.CheckKeyVariant(R, pubKeyVariant))
+                {
+                    view = mi->first;
                     return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    bool CreatePrivKey(const CPubKey &pubKeyVariant, const CPubKey &R, CKey &privKey) const
+    {
+        {
+            LOCK(cs_KeyStore);
+            for (MalleableKeyMap::const_iterator mi = mapMalleableKeys.begin(); mi != mapMalleableKeys.end(); mi++)
+            {
+                if (mi->first.CheckKeyVariant(R, pubKeyVariant))
+                {
+                    CMalleableKey mKey = mi->first.GetMalleableKey(mi->second);
+                    return mKey.CheckKeyVariant(R, pubKeyVariant, privKey);
+                }
             }
         }
         return false;
@@ -176,16 +196,32 @@ public:
     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.
@@ -194,6 +230,7 @@ class CCryptoKeyStore : public CBasicKeyStore
 {
 private:
     CryptedKeyMap mapCryptedKeys;
+    CryptedMalleableKeyMap mapCryptedMalleableKeys;
 
     CKeyingMaterial vMasterKey;
 
@@ -233,7 +270,10 @@ public:
     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
     {
         {
@@ -261,6 +301,73 @@ public:
         }
     }
 
+    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 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.
      */