Add decryption (and caching) of data, even when adding encryption key after data has been added

1 files changed, 47 insertions, 6 deletions

diff --git a/include/odhtdb/DatabaseStorage.hpp b/include/odhtdb/DatabaseStorage.hpp
index 34e523e..85a61eb 100644
--- a/include/odhtdb/DatabaseStorage.hpp
+++ b/include/odhtdb/DatabaseStorage.hpp
@@ -8,6 +8,8 @@
 #include "Group.hpp"
 #include "LocalUser.hpp"
 #include "LocalUserEncrypted.hpp"
+#include "OwnedMemory.hpp"
+#include "DatabaseOperation.hpp"
 #include <vector>
 #include <stdexcept>
 #include <boost/filesystem/path.hpp>
@@ -16,21 +18,42 @@
 
 namespace odhtdb
 {
+    class Database;
+    
+    struct DatabaseStorageObjectDecrypted
+    {
+        DatabaseOperation operation;
+        OwnedMemory data;
+    };
+    
     struct DatabaseStorageObject
     {
+        Hash requestHash;
         DataView data;
         u64 createdTimestamp; // In microseconds
         Signature::PublicKey creatorPublicKey;
+        DatabaseStorageObjectDecrypted decryptedObject;
         
-        DatabaseStorageObject(DataView &_data, u64 _timestamp, const Signature::PublicKey &_creatorPublicKey);
+        DatabaseStorageObject(const Hash &_requestHash, DataView &_data, u64 _timestamp, const Signature::PublicKey &_creatorPublicKey);
     };
     
     struct DatabaseStorageObjectList
     {
+        Signature::PublicKey creatorPublicKey;
         DataView data;
+        u32 offsetToEncryptedData;
         u64 createdTimestamp; // In microseconds
+        std::string nodeName;
+        bool isDecrypted;
         std::vector<Group*> groups;
         std::vector<DatabaseStorageObject*> objects;
+        
+        DatabaseStorageObjectList(const Signature::PublicKey &_creatorPublicKey) : 
+            creatorPublicKey(_creatorPublicKey),
+            isDecrypted(false)
+        {
+            
+        }
     };
     
     struct DatabaseStorageQuarantineObject
@@ -86,20 +109,24 @@ namespace odhtdb
     const int PASSWORD_SALT_LEN = 16;
     const int HASHED_PASSWORD_LEN = 32;
     
-    using NodeLocalUser = std::pair<Hash, LocalUser*>;
+    struct NodeLocalUser
+    {
+        Hash nodeHash;
+        LocalUser *localUser;
+    };
     
     class DatabaseStorage
     {
     public:
         // Throws DatabaseStorageCorrupt if storage is corrupted
-        DatabaseStorage(const boost::filesystem::path &storagePath);
+        DatabaseStorage(Database *database, const boost::filesystem::path &storagePath);
         
         // Throws DatabaseStorageAlreadyExists if data with hash already exists
-        void createStorage(const Hash &hash, Group *creatorGroup, u64 timestamp, const u8 *data, usize dataSize);
+        void createStorage(const Hash &hash, Group *creatorGroup, u64 timestamp, const u8 *data, usize dataSize, u32 offsetToEncryptedData);
         
         // Throws DatabaseStorageNotFound if data with @nodeHash hash has not been created yet.
         // Throws DatabaseStorageAlreadyExists if same data has been added before (hash of @data, in @dataHash)
-        void appendStorage(const Hash &nodeHash, const Hash &dataHash, const User *creatorUser, u64 timestamp, const u8 *data, usize dataSize);
+        void appendStorage(const Hash &nodeHash, const Hash &dataHash, DatabaseOperation operation, const User *creatorUser, u64 timestamp, const u8 *data, usize dataSize, const DataView &encryptedDataView);
         
         // Throws DatabaseStorageAlreadyExists if same data has been added before (hash of @data, in @dataHash)
         void addToQuarantine(const Hash &dataHash, const Signature::PublicKey &creatorPublicKey, u64 timestamp, const u8 *data, usize dataSize);
@@ -132,6 +159,8 @@ namespace odhtdb
         // Safe to call multiple times.
         std::vector<NodeLocalUser> getLocalNodeUsers(const Signature::KeyPair &keyPair);
         
+        void setNodeDecryptionKey(const Hash &nodeHash, const DataView &decryptionKey);
+        
         const dht::crypto::Identity& getIdentity() const;
         
         // Update storage state (remove quarantine objects if they are too old, etc)
@@ -141,21 +170,33 @@ namespace odhtdb
         void loadUsersFromFile();
         void loadDataFromFile();
         void loadLocalUsersFromFile();
+        void loadNodeDecryptionKeysFromFile();
+        void loadDecryptedDataFromFile();
         void loadMetadataFromFile();
         void loadStorageCreate(sibs::SafeDeserializer &deserializer);
         void loadStorageAppend(sibs::SafeDeserializer &deserializer);
+        void loadDecryptedStorageCreate(sibs::SafeDeserializer &deserializer);
+        void loadDecryptedStorageAddData(sibs::SafeDeserializer &deserializer);
+        void loadDecryptedStorageAddUser(sibs::SafeDeserializer &deserializer);
+        
+        bool decryptNodeData(const Hash &nodeHash, DatabaseStorageObjectList *databaseCreateObject, const std::shared_ptr<OwnedMemory> decryptionKey);
+        bool decryptNodeAppendedData(const Hash &nodeHash, DatabaseStorageObject *databaseAppendObject, const std::shared_ptr<OwnedMemory> decryptionKey);
     private:
+        Database *database;
         DatabaseStorageMap storageMap;
         DatabaseStorageQuarantineMap quarantineStorageMap;
-        SetHash storedDataHash; // Prevent duplicate data from being added
+        MapHash<DatabaseStorageObject*> storedDataHash; // Prevent duplicate data from being added
         MapHash<Signature::MapPublicKey<User*>*> nodePublicKeyUserDataMap;
         MapHash<DataViewMap<Group*>*> nodeGroupByIdMap;
+        MapHash<std::shared_ptr<OwnedMemory>> nodeDecryptionKeyMap;
         std::unordered_map<std::string, LocalUserEncrypted*> nameLocalUsersMap;
         boost::filesystem::path groupsFilePath;
         boost::filesystem::path usersFilePath;
         boost::filesystem::path dataFilePath;
         boost::filesystem::path metadataFilePath;
         boost::filesystem::path localUsersFilePath;
+        boost::filesystem::path nodeDecryptionKeysFilePath;
+        boost::filesystem::path decryptedDataFilePath;
         u8 passwordSalt[PASSWORD_SALT_LEN];
         std::pair<std::shared_ptr<dht::crypto::PrivateKey>, std::shared_ptr<dht::crypto::Certificate>> identity;
     };