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 <map>
#include <vector>
#include <list>
#include <functional>
#include <string>
#include <mutex>
#include <ostream>

namespace lime {

    enum class CurveId : uint8_t {
        unset=0, 
        c25519=1, 
        c448=2, 
        c25519k512=3, 
        c25519mlk512=4, 
        c448mlk1024=5, 
    };

    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; 
        bool done; 
        RecipientData(const std::string &deviceId) : deviceId{deviceId}, peerStatus{lime::PeerDeviceStatus::unknown}, DRmessage{}, done(false) {};
        void dump(std::ostringstream &os, std::string indent="        ") const;
    };

    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, std::vector<uint8_t> &&message, const limeX3DHServerResponseProcess &reponseProcess)>;

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

    /****************************************************************************/
    /*                                                                          */
    /* Lime Helpers functions                                                   */
    /*                                                                          */
    /****************************************************************************/

    lime::CurveId string2CurveId(const std::string &algo);
    std::string CurveId2String(const lime::CurveId algo);
    std::string CurveId2String(const std::vector<lime::CurveId> algos, const std::string separator=",");

    std::string PeerDeviceStatus2String(const lime::PeerDeviceStatus status);

    bool lime_is_PQ_available(void);

    class DeviceId {
        private:
            std::string username;
            lime::CurveId baseAlgo;
        public:
            DeviceId(const std::string &username, const lime::CurveId baseAlgo) : username{username}, baseAlgo{baseAlgo} {};
            const std::string &getUsername() const {return username;}
            const lime::CurveId &getAlgo() const {return baseAlgo;}
            const std::string getAlgoString() const {return CurveId2String(baseAlgo);}
            explicit operator std::string() const { return std::string{username}.append(" on ").append(CurveId2String(baseAlgo));}
            bool operator==(const DeviceId &other) const {
                return (username==other.username && baseAlgo == other.baseAlgo);
            }
            static std::size_t hash(const lime::DeviceId& d) {
                std::hash<std::string> username_hash;
                std::hash<lime::CurveId> baseAlgo_hash;
                // combine the hash
                return username_hash(d.username) ^ (baseAlgo_hash(d.baseAlgo) << 1);
            }
    };

    // a class holding all data structure to encrypt
    struct EncryptionContext {
            const std::vector<uint8_t> m_associatedData;
            std::vector<RecipientData> m_recipients;
            const std::vector<uint8_t> m_plainMessage;
            std::vector<uint8_t> m_cipherMessage;
            const lime::EncryptionPolicy m_encryptionPolicy;

            // constructor with associated data being a string or a buffer
            EncryptionContext(const std::vector<uint8_t> &associatedData, const std::vector<uint8_t> &plainMessage, const lime::EncryptionPolicy encryptionPolicy=lime::EncryptionPolicy::optimizeUploadSize ) :
                m_associatedData(associatedData), m_plainMessage(plainMessage), m_encryptionPolicy(encryptionPolicy) {};
            EncryptionContext(const std::string &associatedData, const std::vector<uint8_t> &plainMessage, const lime::EncryptionPolicy encryptionPolicy=lime::EncryptionPolicy::optimizeUploadSize) :
                m_associatedData(associatedData.cbegin(), associatedData.cend()), m_plainMessage(plainMessage),  m_encryptionPolicy(encryptionPolicy) {};
            // insert a recipient address
            void addRecipient(const std::string &recipientAddress) { m_recipients.emplace_back(recipientAddress); }
            void dump(std::ostringstream &os, std::string indent="        ") const;
    };

    /****************************************************************************/
    /*                                                                          */
    /* Lime API: all interactions use LimeManager Class                         */
    /*                                                                          */
    /****************************************************************************/

    class LimeManager {
        private :

            std::unordered_map<lime::DeviceId, std::shared_ptr<LimeGeneric>, decltype(&lime::DeviceId::hash)> m_users_cache; // cache of already opened Lime Session, identified by user Id (GRUU/algo)
            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
            std::shared_ptr<LimeGeneric> load_user(const lime::DeviceId &localDeviceId, const bool allStatus=false); // helper function, get from m_users_cache or local Storage the requested Lime object
            std::shared_ptr<LimeGeneric> load_user_noexcept(const lime::DeviceId &localDeviceId) noexcept; // helper function, get from m_users_cache or local Storage the requested Lime object

        public :

            void create_user(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, const std::string &x3dhServerUrl, const uint16_t OPkInitialBatchSize, limeCallback callback);
            void create_user(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, const std::string &x3dhServerUrl, limeCallback callback);

            void delete_user(const DeviceId &localDeviceId, limeCallback callback);

            bool is_user(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos);
            bool is_user(const DeviceId &localDeviceId);

            void encrypt(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, std::shared_ptr<lime::EncryptionContext> encryptionContext, limeCallback callback);

            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);
            lime::PeerDeviceStatus decrypt(const std::string &localDeviceId, const std::vector<uint8_t> &associatedData, 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::vector<uint8_t> &associatedData, const std::string &senderDeviceId, const std::vector<uint8_t> &DRmessage, std::vector<uint8_t> &plainMessage);

            void update(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, limeCallback callback, uint16_t OPkServerLowLimit, uint16_t OPkBatchSize);
            void update(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, limeCallback callback);

            void get_selfIdentityKey(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, std::map<lime::CurveId, std::vector<uint8_t>> &Iks);

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

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

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

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

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

            void stale_sessions(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, const std::string &peerDeviceId);

            void set_x3dhServerUrl(const std::string &localDeviceId, const std::vector<lime::CurveId> &algos, const std::string &x3dhServerUrl);

            std::string get_x3dhServerUrl(const DeviceId &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);

            ~LimeManager() = default;
    };

} //namespace lime

#endif /* lime_hpp */