lime_lime.hpp

Go to the documentation of this file.

/*
    lime_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_lime_hpp
#define lime_lime_hpp

#include <memory>
#include <unordered_map>
#include <vector>
#include <mutex>

#include "lime_defines.hpp"

namespace lime {

    
    // forward declarations
    class DR;
    class X3DH;

    class LimeGeneric {

    public:
        // Encrypt/Decrypt
        virtual void encrypt(std::shared_ptr<lime::EncryptionContext> encryptionContext, const std::shared_ptr<limeCallback> callback, const std::shared_ptr<limeRandomSeedCallback> randomSeedCallback = nullptr) = 0;

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

        virtual std::unique_lock<std::mutex> lock(void) = 0;

        virtual void processEncryptionQueue(void) = 0;

        virtual void DRcache_delete(const std::string &deviceId) = 0;

        virtual void DRcache_insert(const std::string &deviceId, std::shared_ptr<DR> DRsession) = 0;

        virtual std::shared_ptr<X3DH> get_X3DH(void) = 0;

        // User management
        virtual void publish_user(const std::shared_ptr<limeCallback> callback, const uint16_t OPkInitialBatchSize) = 0;

        virtual void delete_user(const std::shared_ptr<limeCallback> callback) = 0;

        virtual void delete_peerDevice(const std::string &peerDeviceId) = 0;



        // User keys management
        virtual void update_SPk(const std::shared_ptr<limeCallback> callback) = 0;

        virtual void update_OPk(const std::shared_ptr<limeCallback> callback, uint16_t OPkServerLowLimit, uint16_t OPkBatchSize) = 0;

        virtual void get_Ik(std::vector<uint8_t> &Ik) = 0;

        virtual void set_x3dhServerUrl(const std::string &x3dhServerUrl) = 0;

        virtual std::string get_x3dhServerUrl() = 0;

        virtual void stale_sessions(const std::string &peerDeviceId) = 0;

        virtual ~LimeGeneric() {};
    };

    /* Lime Factory functions : return a pointer to the implementation using the specified elliptic curve. Two functions: one for creation, one for loading from local storage */

    std::shared_ptr<LimeGeneric> insert_LimeUser(std::shared_ptr<lime::Db> localStorage, const DeviceId &deviceId, const std::string &url, const uint16_t OPkInitialBatchSize,
            const limeX3DHServerPostData &X3DH_post_data, const std::shared_ptr<limeCallback> callback);

    std::shared_ptr<LimeGeneric> load_LimeUser(std::shared_ptr<lime::Db> localStorage, const DeviceId &deviceId, const limeX3DHServerPostData &X3DH_post_data, const bool allStatus=false);

}
#endif // lime_lime_hpp