crypto.hpp

Go to the documentation of this file.

/*
 * This file is part of libkazv.
 * SPDX-FileCopyrightText: 2020-2024 tusooa <tusooa@kazv.moe>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */
 
#pragma once
#include <libkazv-config.hpp>
 
#include <memory>
 
#include <nlohmann/json.hpp>
 
#include <immer/map.hpp>
#include <immer/flex_vector.hpp>
 
#include <maybe.hpp>
 
#include "crypto-util.hpp"
#include "time-util.hpp"
 
namespace Kazv
{
    class Session;
 
    struct MegOlmSessionRotateDesc
    {
        Timestamp ms{};
        int messages{};
    };
 
    struct CryptoPrivate;
    class Crypto
    {
    public:
        explicit Crypto();
 
        static std::size_t constructRandomSize();
 
        Crypto(RandomTag, RandomData data);
 
        Crypto(const Crypto &that);
        Crypto(Crypto &&that);
        Crypto &operator=(const Crypto &that);
        Crypto &operator=(Crypto &&that);
        ~Crypto();
 
        bool operator==(const Crypto &that) const;
 
        bool valid() const;
 
        std::string ed25519IdentityKey() const;
        std::string curve25519IdentityKey() const;
 
        std::string sign(nlohmann::json j);
 
        void setUploadedOneTimeKeysCount(immer::map<std::string /* algorithm */, int> uploadedOneTimeKeysCount);
 
        int uploadedOneTimeKeysCount(std::string algorithm) const;
 
        std::size_t maxNumberOfOneTimeKeys() const;
 
        static std::size_t genOneTimeKeysRandomSize(int num);
 
        void genOneTimeKeysWithRandom(RandomData random, int num);
 
        nlohmann::json unpublishedOneTimeKeys() const;
 
        int numUnpublishedOneTimeKeys() const;
 
        void markOneTimeKeysAsPublished();
 
        MaybeString decrypt(nlohmann::json eventJson);
 
        std::size_t encryptOlmRandomSize(std::string theirCurve25519IdentityKey) const;
 
        static std::size_t encryptOlmMaxRandomSize();
 
        nlohmann::json encryptOlmWithRandom(
            RandomData random, nlohmann::json eventJson, std::string theirCurve25519IdentityKey);
 
        nlohmann::json encryptMegOlm(nlohmann::json eventJson);
 
        bool createInboundGroupSession(KeyOfGroupSession k, std::string sessionKey, std::string ed25519Key);
 
        std::size_t importInboundGroupSessions(const nlohmann::json &keys);
 
        bool hasInboundGroupSession(KeyOfGroupSession k) const;
 
        std::string outboundGroupSessionInitialKey(std::string roomId);
 
        std::string outboundGroupSessionCurrentKey(std::string roomId);
 
        bool verify(nlohmann::json object, std::string userId, std::string deviceId, std::string ed25519Key);
 
        MaybeString getInboundGroupSessionEd25519KeyFromEvent(const nlohmann::json &eventJson) const;
 
        static std::size_t rotateMegOlmSessionRandomSize();
 
        std::string rotateMegOlmSessionWithRandom(RandomData random, Timestamp timeMs, std::string roomId);
 
        std::optional<std::string> rotateMegOlmSessionWithRandomIfNeeded(
            RandomData random,
            Timestamp timeMs,
            std::string roomId,
            MegOlmSessionRotateDesc desc);
 
        using UserIdToDeviceIdMap = immer::map<std::string, immer::flex_vector<std::string>>;
        UserIdToDeviceIdMap devicesMissingOutboundSessionKey(
            immer::map<std::string, immer::map<std::string /* deviceId */,
            std::string /* curve25519IdentityKey */>> keyMap) const;
 
        static std::size_t createOutboundSessionRandomSize();
 
        void createOutboundSessionWithRandom(
            RandomData random,
            std::string theirIdentityKey,
            std::string theirOneTimeKey);
 
        template<class Archive>
        void save(Archive & ar, const unsigned int /* version */) const {
            ar << toJson().dump();
        }
 
        template<class Archive>
        void load(Archive &ar, const unsigned int /* version */) {
            std::string j;
            ar >> j;
            loadJson(nlohmann::json::parse(std::move(j)));
        }
 
        BOOST_SERIALIZATION_SPLIT_MEMBER()
 
        nlohmann::json toJson() const;
        void loadJson(const nlohmann::json &j);
 
    private:
 
        friend class Session;
        friend struct SessionPrivate;
        std::unique_ptr<CryptoPrivate> m_d;
    };
}
 
BOOST_CLASS_VERSION(Kazv::Crypto, 0)