lime.hpp

Go to the documentation of this file.

/*
    lime.hpp
    @author Johan Pascal
    @copyright  Copyright (C) 2017  Belledonne Communications SARL

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef lime_hpp
#define lime_hpp

#include <memory> //smart ptrs
#include <unordered_map>
#include <vector>
#include <list>
#include <functional>
#include <string>
#include <mutex>

namespace lime {

    enum class CurveId : uint8_t {
        unset=0, 
        c25519=1, 
        c448=2 
    };

    enum class EncryptionPolicy {
        DRMessage, 
        cipherMessage, 
        optimizeUploadSize, 
        optimizeGlobalBandwidth 
    };

    enum class PeerDeviceStatus : uint8_t {
        untrusted=0, 
        trusted=1, 
        unsafe=2, 
        fail, 
        unknown 
    };

    struct RecipientData {
        const std::string deviceId; 
        lime::PeerDeviceStatus peerStatus; 
        std::vector<uint8_t> DRmessage; 
        RecipientData(const std::string &deviceId) : deviceId{deviceId}, peerStatus{lime::PeerDeviceStatus::unknown}, DRmessage{} {};
    };

    enum class CallbackReturn : uint8_t {
        success, 
        fail 
    };
    using limeCallback = std::function<void(const lime::CallbackReturn status, const std::string message)>;

    /* X3DH server communication : these functions prototypes are used to post data and get response from/to the X3DH server */
    using limeX3DHServerResponseProcess = std::function<void(int responseCode, const std::vector<uint8_t> &responseBody)>;

    using limeX3DHServerPostData = std::function<void(const std::string &url, const std::string &from, const std::vector<uint8_t> &message, const limeX3DHServerResponseProcess &reponseProcess)>;

    /* Forward declare the class managing one lime user and class managing database */
    class LimeGeneric;
    class Db;

    class LimeManager {
        private :
            std::unordered_map<std::string, std::shared_ptr<LimeGeneric>> m_users_cache; // cache of already opened Lime Session, identified by user Id (GRUU)
            std::mutex m_users_mutex; // m_users_cache mutex
            std::shared_ptr<lime::Db> m_localStorage; // DB access information forwarded to SOCI to correctly access database
            limeX3DHServerPostData m_X3DH_post_data; // send data to the X3DH key server
            void load_user(std::shared_ptr<LimeGeneric> &user, const std::string &localDeviceId, const bool allStatus=false); // helper function, get from m_users_cache of local Storage the requested Lime object

        public :

            void create_user(const std::string &localDeviceId, const std::string &x3dhServerUrl, const lime::CurveId curve, const uint16_t OPkInitialBatchSize, const limeCallback &callback);
            void create_user(const std::string &localDeviceId, const std::string &x3dhServerUrl, const lime::CurveId curve, const limeCallback &callback);

            void delete_user(const std::string &localDeviceId, const limeCallback &callback);

            bool is_user(const std::string &localDeviceId);

            void encrypt(const std::string &localDeviceId, std::shared_ptr<const std::string> recipientUserId, std::shared_ptr<std::vector<RecipientData>> recipients, std::shared_ptr<const std::vector<uint8_t>> plainMessage, std::shared_ptr<std::vector<uint8_t>> cipherMessage, const limeCallback &callback, lime::EncryptionPolicy encryptionPolicy=lime::EncryptionPolicy::optimizeUploadSize);

            lime::PeerDeviceStatus decrypt(const std::string &localDeviceId, const std::string &recipientUserId, const std::string &senderDeviceId, const std::vector<uint8_t> &DRmessage, const std::vector<uint8_t> &cipherMessage, std::vector<uint8_t> &plainMessage);
            lime::PeerDeviceStatus decrypt(const std::string &localDeviceId, const std::string &recipientUserId, const std::string &senderDeviceId, const std::vector<uint8_t> &DRmessage, std::vector<uint8_t> &plainMessage);

            void update(const std::string &localDeviceId, const limeCallback &callback, uint16_t OPkServerLowLimit, uint16_t OPkBatchSize);
            void update(const std::string &localDeviceId, const limeCallback &callback);

            void get_selfIdentityKey(const std::string &localDeviceId, std::vector<uint8_t> &Ik);

            void set_peerDeviceStatus(const std::string &peerDeviceId, const std::vector<uint8_t> &Ik, lime::PeerDeviceStatus status);

            void set_peerDeviceStatus(const std::string &peerDeviceId, lime::PeerDeviceStatus status);

            lime::PeerDeviceStatus get_peerDeviceStatus(const std::string &peerDeviceId);

            lime::PeerDeviceStatus get_peerDeviceStatus(const std::list<std::string> &peerDeviceIds);

            bool is_localUser(const std::string &deviceId);

            void delete_peerDevice(const std::string &peerDeviceId);

            void stale_sessions(const std::string &localDeviceId, const std::string &peerDeviceId);

            void set_x3dhServerUrl(const std::string &localDeviceId, const std::string &x3dhServerUrl);

            std::string get_x3dhServerUrl(const std::string &localDeviceId);

            LimeManager() = delete; // no manager without Database and http provider
            LimeManager(const LimeManager&) = delete; // no copy constructor
            LimeManager operator=(const LimeManager &) = delete; // nor copy operator

            LimeManager(const std::string &db_access, const limeX3DHServerPostData &X3DH_post_data, std::shared_ptr<std::recursive_mutex> db_mutex);
            LimeManager(const std::string &db_access, const limeX3DHServerPostData &X3DH_post_data);

            ~LimeManager() = default;
    };
} //namespace lime
#endif /* lime_hpp */