No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/base/types.hpp b/src/base/types.hpp
	index a2bc44a..df6470c 100644
	--- a/src/base/types.hpp
	+++ b/src/base/types.hpp
	@@ -1,221 +1,223 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2021 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/


	#pragma once
	#include "libkazv-config.hpp"

	#include <optional>
	#include <string>
	#include <variant>

	#include <nlohmann/json.hpp>
	#include <immer/array.hpp>
	#include <immer/flex_vector.hpp>
	#include <immer/map.hpp>
	#include <boost/hana/type.hpp>
	#include <lager/util.hpp>

	#include "jsonwrap.hpp"
	#include "event.hpp"
	#include "descendent.hpp"

	namespace Kazv
	{
	using Bytes = std::string;

	enum Status : bool
	{
	FAIL,
	SUCC,
	};

	namespace detail
	{
	constexpr auto hasEmptyMethod = boost::hana::is_valid(
	[](auto t) -> decltype((void)std::declval<typename decltype(t)::type>().empty()) {});
	template<class U>
	struct AddToJsonIfNeededT
	{
	template<class T>
	static void call(json &j, std::string name, T &&arg) {
	using Type = std::decay_t<T>;
	if constexpr (detail::hasEmptyMethod(boost::hana::type_c<Type>)) {
	if (! arg.empty()) {
	j[name] = std::forward<T>(arg);
	}
	} else {
	j[name] = std::forward<T>(arg);
	}
	}
	};

	template<class U>
	struct AddToJsonIfNeededT<std::optional<U>>
	{
	template<class T>
	static void call(json &j, std::string name, T &&arg) {
	if (arg.has_value()) {
	j[name] = std::forward<T>(arg).value();
	}
	}
	};

	}

	template<class T>
	inline void addToJsonIfNeeded(json &j, std::string name, T &&arg)
	{
	detail::AddToJsonIfNeededT<std::decay_t<T>>::call(j, name, std::forward<T>(arg));
	};

	// Provide a non-destructive way to add the map
	// to json.
	template<class MapT,
	// disallow json object here
	std::enable_if_t<!std::is_same_v<std::decay_t<MapT>, json>
	&& !std::is_same_v<std::decay_t<MapT>, JsonWrap>, int> = 0>
	inline void addPropertyMapToJson(json &j, MapT &&arg)
	{
	for (auto kv : std::forward<MapT>(arg)) {
	auto [k, v] = kv;
	j[k] = v;
	}
	};

	inline void addPropertyMapToJson(json &j, const json &arg)
	{
	for (auto kv : arg.items()) {
	auto [k, v] = kv;
	j[k] = v;
	}
	};

	using EventList = immer::flex_vector<Event>;

	using namespace std::string_literals;

	struct Null {};
	using Variant = std::variant<std::string, JsonWrap, Null>;

	namespace detail
	{
	struct DefaultValT
	{
	template<class T>
	constexpr operator T() const {
	return T();
	}
	};
	}

	constexpr detail::DefaultValT DEFVAL;

	enum RoomMembership
	{
	Invite, Join, Leave
	};

	namespace detail
	{
	// emulates declval() but returns lvalue reference
	template<class T>
	typename std::add_lvalue_reference<T>::type declref() noexcept;
	}
	}

	namespace nlohmann {
	template <class T, class V>
	struct adl_serializer<immer::map<T, V>> {
	static void to_json(json& j, immer::map<T, V> map) {
	if constexpr (std::is_same_v<T, std::string>) {
	j = json::object();
	for (auto [k, v] : map) {
	j[k] = v;
	}
	} else {
	j = json::array();
	for (auto [k, v] : map) {
	j.push_back(k);
	j.push_back(v);
	}
	}
	}

	static void from_json(const json& j, immer::map<T, V> &m) {
	immer::map<T, V> ret;
	if constexpr (std::is_same_v<T, std::string>) {
	for (const auto &[k, v] : j.items()) {
	ret = std::move(ret).set(k, v);
	}
	} else {
	for (std::size_t i = 0; i < j.size(); i += 2) {
	ret = std::move(ret).set(j[i], j[i+1]);
	}
	}
	m = ret;
	}
	};

	template <class T>
	struct adl_serializer<immer::array<T>> {
	static void to_json(json& j, immer::array<T> arr) {
	+ j = json::array();
	for (auto i : arr) {
	j.push_back(json(i));
	}
	}

	static void from_json(const json& j, immer::array<T> &a) {
	immer::array<T> ret;
	if (j.is_array()) {
	for (const auto &i : j) {
	ret = std::move(ret).push_back(i);
	}
	}
	a = ret;
	}
	};

	template <class T>
	struct adl_serializer<immer::flex_vector<T>> {
	static void to_json(json& j, immer::flex_vector<T> arr) {
	+ j = json::array();
	for (auto i : arr) {
	j.push_back(json(i));
	}
	}

	static void from_json(const json& j, immer::flex_vector<T> &a) {
	immer::flex_vector<T> ret;
	if (j.is_array()) {
	for (const auto &i : j) {
	ret = std::move(ret).push_back(i.get<T>());
	}
	}
	a = ret;
	}
	};

	template <>
	struct adl_serializer<Kazv::Variant> {
	static void to_json(json& j, const Kazv::Variant &var) {
	std::visit(lager::visitor{
	[&j](std::string i) { j = i; },
	[&j](Kazv::JsonWrap i) { j = i; },
	[&j](Kazv::Null) { j = nullptr; }
	}, var);
	}

	static void from_json(const json& j, Kazv::Variant &var) {
	if (j.is_string()) {
	var = j.get<std::string>();
	} else if (j.is_null()) {
	var = Kazv::Null{};
	} else { // is object
	var = Kazv::Variant(Kazv::JsonWrap(j));
	}
	}
	};
	}
	diff --git a/src/client/actions/encryption.cpp b/src/client/actions/encryption.cpp
	index d31578f..f81986a 100644
	--- a/src/client/actions/encryption.cpp
	+++ b/src/client/actions/encryption.cpp
	@@ -1,586 +1,586 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <zug/transducer/filter.hpp>
	#include <zug/transducer/cat.hpp>

	#include "encryption.hpp"

	#include <debug.hpp>
	#include "cursorutil.hpp"
	#include "status-utils.hpp"

	namespace Kazv
	{
	using namespace CryptoConstants;

	static json convertSignature(const ClientModel &m, std::string signature)
	{
	auto j = json::object();
	j[m.userId] = json::object();
	j[m.userId][ed25519 + ":" + m.deviceId] = signature;

	return j;
	}

	ClientResult updateClient(ClientModel m, UploadIdentityKeysAction)
	{
	if (! m.crypto) {
	kzo.client.warn() << "Client::crypto is invalid, ignoring it." << std::endl;
	return { std::move(m), lager::noop };
	}

	auto &crypto = m.crypto.value();

	auto keys =
	immer::map<std::string, std::string>{}
	.set(ed25519 + ":" + m.deviceId, crypto.ed25519IdentityKey())
	.set(curve25519 + ":" + m.deviceId, crypto.curve25519IdentityKey());

	DeviceKeys k {
	m.userId,
	m.deviceId,
	{olmAlgo, megOlmAlgo},
	keys,
	{} // signatures to be added soon
	};

	auto j = json(k);

	auto sig = crypto.sign(j);

	k.signatures = convertSignature(m, sig);

	auto job = m.job<UploadKeysJob>()
	.make(k)
	.withData(json{{"is", "identityKeys"}});

	kzo.client.dbg() << "Uploading identity keys" << std::endl;

	m.addJob(std::move(job));

	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, GenerateAndUploadOneTimeKeysAction a)
	{
	if (! m.crypto) {
	kzo.client.warn() << "Client::crypto is invalid, ignoring it." << std::endl;
	return { std::move(m), simpleFail };
	}

	auto &crypto = m.crypto.value();

	kzo.client.dbg() << "Generating one-time keys..." << std::endl;

	auto maxNumKeys = crypto.maxNumberOfOneTimeKeys();
	auto numLocalKeys = crypto.numUnpublishedOneTimeKeys();
	auto numStoredKeys = crypto.uploadedOneTimeKeysCount(signedCurve25519) + numLocalKeys;
	auto numKeysToGenerate = a.numToGen;
	auto genKeysLimit = maxNumKeys - numStoredKeys;

	if (numKeysToGenerate > genKeysLimit) {
	numKeysToGenerate = genKeysLimit;
	}

	if (numLocalKeys <= 0 && numKeysToGenerate <= 0) { // we have enough already
	kzo.client.dbg() << "We have enough one-time keys. Ignoring this." << std::endl;
	return { std::move(m), lager::noop };
	}

	if (numKeysToGenerate > 0) {
	crypto.genOneTimeKeysWithRandom(a.random, numKeysToGenerate);
	}
	kzo.client.dbg() << "Generating done." << std::endl;

	auto keys = crypto.unpublishedOneTimeKeys();

	auto cv25519Keys = keys.at(curve25519);
	immer::map<std::string, Variant> oneTimeKeys;
	for (auto [id, keyStr] : cv25519Keys.items()) {
	json keyObject = json::object();
	keyObject["key"] = keyStr;
	keyObject["signatures"] = convertSignature(m, crypto.sign(keyObject));

	oneTimeKeys = std::move(oneTimeKeys).set(signedCurve25519 + ":" + id, JsonWrap(keyObject));
	}

	auto job = m.job<UploadKeysJob>()
	.make(
	std::nullopt, // deviceKeys
	oneTimeKeys)
	.withData(json{{"is", "oneTimeKeys"}});

	kzo.client.dbg() << "Uploading one time keys" << std::endl;

	m.addJob(std::move(job));

	return { std::move(m), lager::noop };

	};

	ClientResult processResponse(ClientModel m, UploadKeysResponse r)
	{
	if (! m.crypto) {
	kzo.client.warn() << "Client::crypto is invalid, ignoring it." << std::endl;
	return { std::move(m), lager::noop };
	}

	auto &crypto = m.crypto.value();

	auto is = r.dataStr("is");

	if (is == "identityKeys") {
	if (! r.success()) {
	kzo.client.dbg() << "Uploading identity keys failed" << std::endl;
	m.addTrigger(UploadIdentityKeysFailed{r.errorCode(), r.errorMessage()});
	return { std::move(m), lager::noop };
	}

	kzo.client.dbg() << "Uploading identity keys successful" << std::endl;
	m.addTrigger(UploadIdentityKeysSuccessful{});

	m.identityKeysUploaded = true;
	} else {
	if (! r.success()) {
	kzo.client.dbg() << "Uploading one-time keys failed" << std::endl;
	m.addTrigger(UploadOneTimeKeysFailed{r.errorCode(), r.errorMessage()});
	return { std::move(m), lager::noop };
	}

	kzo.client.dbg() << "Uploading one-time keys successful" << std::endl;
	m.addTrigger(UploadOneTimeKeysSuccessful{});

	crypto.markOneTimeKeysAsPublished();
	}

	crypto.setUploadedOneTimeKeysCount(r.oneTimeKeyCounts());

	return { std::move(m), lager::noop };
	}

	static JsonWrap cannotDecryptEvent(std::string reason)
	{
	return json{
	{"type", "m.room.message"},
	{"content", {
	{"msgtype","moe.kazv.mxc.cannot.decrypt"},
	{"body", "This message cannot be decrypted due to " + reason + "."}}}};
	}

	static bool verifyEvent(ClientModel &m, Event e, const json &plainJson)
	{
	auto crypto = m.crypto.value();

	bool valid = true;

	try {
	std::string senderCurve25519Key = e.originalJson().get()
	.at("content").at("sender_key");

	auto deviceInfoOpt = m.deviceLists.findByCurve25519Key(e.sender(), senderCurve25519Key);

	if (! deviceInfoOpt) {
	kzo.client.dbg() << "Device key " << senderCurve25519Key
	<< " unknown, thus invalid" << std::endl;
	valid = false;
	}

	auto deviceInfo = deviceInfoOpt.value();

	std::string algo = e.originalJson().get().at("content").at("algorithm");
	if (algo == olmAlgo) {
	if (! (plainJson.at("sender") == e.sender())) {
	kzo.client.dbg() << "Sender does not match, thus invalid" << std::endl;
	valid = false;
	}
	if (! (plainJson.at("recipient") == m.userId)) {
	kzo.client.dbg() << "Recipient does not match, thus invalid" << std::endl;
	valid = false;
	}
	if (! (plainJson.at("recipient_keys").at(ed25519) == crypto.ed25519IdentityKey())) {
	kzo.client.dbg() << "Recipient key does not match, thus invalid" << std::endl;
	valid = false;
	}
	auto thisEd25519Key = plainJson.at("keys").at(ed25519).get<std::string>();
	if (thisEd25519Key != deviceInfo.ed25519Key) {
	kzo.client.dbg() << "Sender ed25519 key does not match, thus invalid" << std::endl;
	valid = false;
	}
	} else if (algo == megOlmAlgo) {
	if (! (plainJson.at("room_id").get<std::string>() ==
	e.originalJson().get().at("room_id").get<std::string>())) {
	kzo.client.dbg() << "Room id does not match, thus invalid" << std::endl;
	valid = false;
	}
	if (e.originalJson().get().at("content").at("device_id").get<std::string>()
	!= deviceInfo.deviceId) {
	kzo.client.dbg() << "Device id does not match, thus invalid" << std::endl;
	valid = false;
	}
	auto actualEd25519Key = crypto.getInboundGroupSessionEd25519KeyFromEvent(e.originalJson().get());
	if ((! actualEd25519Key)
	\|\| deviceInfo.ed25519Key != actualEd25519Key.value()) {
	kzo.client.dbg() << "sender ed25519 key does not match, thus invalid" << std::endl;
	kzo.client.dbg() << "From group session: "
	<< (actualEd25519Key ? actualEd25519Key.value() : "<none>") << std::endl;
	kzo.client.dbg() << "From device info: " << deviceInfo.ed25519Key << std::endl;
	valid = false;
	}
	} else {
	kzo.client.dbg() << "Unknown algorithm, thus invalid" << std::endl;
	valid = false;
	}
	} catch (const std::exception &) {
	kzo.client.dbg() << "json format is not correct, thus invalid" << std::endl;
	valid = false;
	}

	return valid;
	}

	static Event decryptEvent(ClientModel &m, Event e)
	{
	// no need for decryption
	if (e.decrypted() \|\| (! e.encrypted())) {
	return e;
	}

	auto &crypto = m.crypto.value();

	kzo.client.dbg() << "About to decrypt event: "
	<< e.originalJson().get().dump() << std::endl;

	auto maybePlainText = crypto.decrypt(e.originalJson().get());

	if (! maybePlainText) {
	kzo.client.dbg() << "Cannot decrypt: " << maybePlainText.reason() << std::endl;
	return e.setDecryptedJson(cannotDecryptEvent(maybePlainText.reason()), Event::NotDecrypted);
	} else {
	kzo.client.dbg() << "Decrypted message: " << maybePlainText.value() << std::endl;
	auto plainJson = json::parse(maybePlainText.value());
	auto valid = verifyEvent(m, e, plainJson);
	if (valid) {
	kzo.client.dbg() << "The decrypted event is valid." << std::endl;
	}
	return valid
	? e.setDecryptedJson(plainJson, Event::Decrypted)
	: e.setDecryptedJson(cannotDecryptEvent("invalid event"), Event::NotDecrypted);
	}
	}

	ClientModel tryDecryptEvents(ClientModel m)
	{
	if (! m.crypto) {
	kzo.client.dbg() << "We have no encryption enabled--ignoring decryption request" << std::endl;
	return m;
	}
	auto &crypto = m.crypto.value();

	kzo.client.dbg() << "Trying to decrypt events..." << std::endl;

	auto decryptFunc = [&](auto e) { return decryptEvent(m, e); };

	auto takeOutRoomKeyEvents =
	[&](auto e) {
	if (e.type() != "m.room_key") {
	// Leave it as it is
	return true;
	}

	auto content = e.content();
	std::string roomId = content.get().at("room_id");
	std::string sessionId = content.get().at("session_id");
	std::string sessionKey = content.get().at("session_key");
	std::string senderKey = e.originalJson().get().at("content").at("sender_key");

	auto k = KeyOfGroupSession{roomId, senderKey, sessionId};

	std::string ed25519Key = e.decryptedJson().get().at("keys").at(ed25519);

	if (crypto.createInboundGroupSession(k, sessionKey, ed25519Key)) {
	return false; // such that this event is removed
	}
	return true;
	};

	m.toDevice = intoImmer(
	EventList{},
	zug::map(decryptFunc)
	\| zug::filter(takeOutRoomKeyEvents),
	std::move(m.toDevice));

	auto decryptEventInRoom =
	[&](auto id, auto room) {
	if (! room.encrypted) {
	return;
	} else {
	auto messages = room.messages;
	room.messages = merge(
	room.messages,
	intoImmer(
	EventList{},
	zug::filter([](auto n) {
	auto e = n.second;
	return e.encrypted();
	})
	\| zug::map([=](auto n) {
	auto event = n.second;
	return decryptFunc(event);
	}),
	std::move(messages)),
	keyOfTimeline);
	m.roomList.rooms = std::move(m.roomList.rooms).set(id, room);
	}
	};

	auto rooms = m.roomList.rooms;
	for (auto [id, room]: rooms) {
	decryptEventInRoom(id, room);
	}

	return m;
	}

	std::optional<BaseJob> clientPerform(ClientModel m, QueryKeysAction a)
	{
	if (! m.crypto) {
	kzo.client.dbg() << "We have no encryption enabled--ignoring this" << std::endl;
	return std::nullopt;
	}

	immer::map<std::string, immer::array<std::string>> deviceKeys;
	auto encryptedUsers = m.deviceLists.outdatedUsers();

	if (encryptedUsers.empty()) {
	kzo.client.dbg() << "Keys are up-to-date." << std::endl;
	return std::nullopt;
	}

	kzo.client.dbg() << "We need to query keys for: " << std::endl;
	for (auto userId: encryptedUsers) {
	kzo.client.dbg() << userId << std::endl;
	deviceKeys = std::move(deviceKeys).set(userId, {});
	}
	kzo.client.dbg() << "^" << std::endl;

	auto job = m.job<QueryKeysJob>()
	.make(std::move(deviceKeys),
	std::nullopt, // timeout
	a.isInitialSync ? std::nullopt : m.syncToken
	);
	return job;
	}

	ClientResult updateClient(ClientModel m, QueryKeysAction a)
	{
	auto jobOpt = clientPerform(m, a);
	if (jobOpt) {
	m.addJob(jobOpt.value());
	}

	return { std::move(m), lager::noop };
	}

	ClientResult processResponse(ClientModel m, QueryKeysResponse r)
	{
	if (! m.crypto) {
	kzo.client.dbg() << "We have no encryption enabled--ignoring this" << std::endl;
	- return { std::move(m), lager::noop };
	+ return { std::move(m), simpleFail };
	}

	if (! r.success()) {
	- kzo.client.dbg() << "query keys failed" << std::endl;
	- return { std::move(m), lager::noop };
	+ kzo.client.dbg() << "query keys failed: " << r.errorCode() << r.errorMessage() << std::endl;
	+ return { std::move(m), failWithResponse(r) };
	}

	kzo.client.dbg() << "Received a query key response" << std::endl;
	auto &crypto = m.crypto.value();

	auto usersMap = r.deviceKeys();

	for (auto [userId, deviceMap] : usersMap) {
	for (auto [deviceId, deviceInfo] : deviceMap) {
	kzo.client.dbg() << "Key for " << userId
	<< "/" << deviceId
	<< ": " << json(deviceInfo).dump()
	<< std::endl;
	m.deviceLists.addDevice(userId, deviceId, deviceInfo, crypto);
	}
	m.deviceLists.markUpToDate(userId);
	}

	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, ClaimKeysAction a)
	{
	if (! m.crypto) {
	kzo.client.dbg() << "We have no encryption enabled--ignoring this" << std::endl;
	return { std::move(m), lager::noop };
	}

	auto &c = m.crypto.value();

	kzo.client.dbg() << "claim keys for: " << json(a.devicesToSend).dump() << std::endl;

	auto keyMap = immer::map<std::string, immer::map<std::string /* deviceId */,
	std::string /* curve25519IdentityKey */>>{};


	for (auto [userId, devices] : a.devicesToSend) {
	kzo.client.dbg() << "Iterating through user " << userId << std::endl;
	auto deviceToKey = immer::map<std::string, std::string>{};
	for (auto deviceId : devices) {
	kzo.client.dbg() << "Device: " << deviceId << std::endl;
	auto infoOpt = m.deviceLists.get(userId, deviceId);
	if (infoOpt) {
	kzo.client.dbg() << "Got device info, curve25519 key is: " << infoOpt.value().curve25519Key << std::endl;
	deviceToKey = std::move(deviceToKey)
	.set(deviceId, infoOpt.value().curve25519Key);
	} else {
	kzo.client.dbg() << "Did not get device info" << std::endl;
	}
	}
	keyMap = std::move(keyMap).set(userId, deviceToKey);
	}

	auto devicesToClaimKeys = c.devicesMissingOutboundSessionKey(keyMap);

	kzo.client.dbg() << "Really claim keys for: " << json(devicesToClaimKeys).dump() << std::endl;

	auto oneTimeKeys = immer::map<std::string, immer::map<std::string, std::string>>{};
	for (auto [userId, devices] : devicesToClaimKeys) {
	auto devKeys = immer::map<std::string, std::string>{};
	for (auto deviceId: devices) {
	devKeys = std::move(devKeys).set(deviceId, signedCurve25519);
	}
	oneTimeKeys = std::move(oneTimeKeys).set(userId, devKeys);
	}

	auto job = m.job<ClaimKeysJob>()
	.make(std::move(oneTimeKeys))
	.withData(json{
	{"roomId", a.roomId},
	{"sessionId", a.sessionId},
	{"sessionKey", a.sessionKey},
	{"devicesToSend", a.devicesToSend},
	{"random", a.random}
	});
	m.addJob(std::move(job));

	return { std::move(m), lager::noop };
	}

	ClientResult processResponse(ClientModel m, ClaimKeysResponse r)
	{
	if (! m.crypto) {
	kzo.client.dbg() << "We have no encryption enabled--ignoring this" << std::endl;
	return { std::move(m), simpleFail };
	}

	if (! r.success()) {
	kzo.client.dbg() << "claim keys failed" << std::endl;
	m.addTrigger(ClaimKeysFailed{r.errorCode(), r.errorMessage()});
	return { std::move(m), simpleFail };
	}

	kzo.client.dbg() << "claim keys successful" << std::endl;

	kzo.client.dbg() << "Json body: " << r.jsonBody().get().dump() << std::endl;

	auto &c = m.crypto.value();

	auto roomId = r.dataStr("roomId");
	auto sessionKey = r.dataStr("sessionKey");
	auto sessionId = r.dataStr("sessionId");
	auto devicesToSend =
	immer::map<std::string, immer::flex_vector<std::string>>(r.dataJson("devicesToSend"));
	auto random = r.dataJson("random").template get<RandomData>();

	// create outbound sessions for those devices
	auto oneTimeKeys = r.oneTimeKeys();

	for (auto [userId, deviceMap] : oneTimeKeys) {
	for (auto [deviceId, keyVar] : deviceMap) {
	if (std::holds_alternative<JsonWrap>(keyVar)) {
	auto keys = std::get<JsonWrap>(keyVar).get();
	for (auto [keyId, key] : keys.items()) {
	auto deviceInfoOpt = m.deviceLists.get(userId, deviceId);
	if (deviceInfoOpt) {
	auto deviceInfo = deviceInfoOpt.value();
	kzo.client.dbg() << "Verifying key for " << userId
	<< "/" << deviceId
	<< key.dump()
	<< " with ed25519 key "
	<< deviceInfo.ed25519Key << std::endl;
	auto verified = c.verify(key, userId, deviceId, deviceInfo.ed25519Key);
	kzo.client.dbg() << (verified ? "passed" : "did not pass") << std::endl;
	if (verified && key.contains("key")) {
	auto theirOneTimeKey = key.at("key");
	kzo.client.dbg() << "creating outbound session for it" << std::endl;
	c.createOutboundSessionWithRandom(random, deviceInfo.curve25519Key, theirOneTimeKey);
	random.erase(0, Crypto::createOutboundSessionRandomSize());
	kzo.client.dbg() << "done" << std::endl;
	}
	}
	}
	}
	}
	}

	auto eventJson = json{
	{"content", {{"algorithm", megOlmAlgo},
	{"room_id", roomId},
	{"session_id", sessionId},
	{"session_key", sessionKey}}},
	{"type", "m.room_key"}
	};

	auto event = Event(JsonWrap(eventJson));

	return {
	std::move(m),
	[event](auto &&) { return EffectStatus{ /* success = */ true, json{{ "keyEvent", event.originalJson() }} }; }
	};
	}

	ClientResult updateClient(ClientModel m, EncryptMegOlmEventAction a)
	{
	auto [encryptedEvent, maybeKey] = m.megOlmEncrypt(a.e, a.roomId, a.timeMs, a.random);

	return {
	std::move(m),
	[=](auto && /* ctx */) {
	auto retJson = json::object({
	{"encrypted", encryptedEvent.originalJson()},
	});
	if (maybeKey.has_value()) {
	retJson["key"] = maybeKey.value();
	}
	return EffectStatus(/* succ = */ true, retJson);
	}
	};
	}

	ClientResult updateClient(ClientModel m, EncryptOlmEventAction a)
	{
	auto encryptedEvent = m.olmEncrypt(a.e, a.devices, a.random);

	return {
	std::move(m),
	[=](auto && /* ctx */) {
	auto retJson = json::object({
	{"encrypted", encryptedEvent.originalJson()},
	});

	return EffectStatus(/* succ = */ true, retJson);
	}
	};
	}
	}
	diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
	index 2f8fea0..c18dbe9 100644
	--- a/src/tests/CMakeLists.txt
	+++ b/src/tests/CMakeLists.txt
	@@ -1,54 +1,55 @@


	include(CTest)

	set(KAZVTEST_RESPATH ${CMAKE_CURRENT_SOURCE_DIR}/resources)
	configure_file(kazvtest-respath.hpp.in kazvtest-respath.hpp)

	add_executable(kazvtest
	testmain.cpp
	basejobtest.cpp
	event-test.cpp
	cursorutiltest.cpp
	base/serialization-test.cpp
	base/types-test.cpp

	client/client-test-util.cpp
	client/discovery-test.cpp
	client/sync-test.cpp
	client/content-test.cpp
	client/paginate-test.cpp
	client/util-test.cpp
	client/serialization-test.cpp
	client/encrypted-file-test.cpp
	client/sdk-test.cpp
	client/thread-safety-test.cpp
	client/room-test.cpp
	client/random-generator-test.cpp
	client/profile-test.cpp
	client/kick-test.cpp
	client/ban-test.cpp
	+ client/keys-test.cpp
	client/room/room-actions-test.cpp

	kazvjobtest.cpp
	event-emitter-test.cpp
	crypto-test.cpp
	crypto/deterministic-test.cpp
	promise-test.cpp
	store-test.cpp
	file-desc-test.cpp
	)

	target_include_directories(
	kazvtest
	PRIVATE ${CMAKE_CURRENT_BINARY_DIR})

	target_link_libraries(kazvtest
	PRIVATE Catch2::Catch2
	PRIVATE kazv
	PRIVATE kazveventemitter
	PRIVATE kazvjob
	PRIVATE nlohmann_json::nlohmann_json
	PRIVATE immer
	PRIVATE lager
	PRIVATE zug)
	diff --git a/src/tests/base/types-test.cpp b/src/tests/base/types-test.cpp
	index c583aab..75e4660 100644
	--- a/src/tests/base/types-test.cpp
	+++ b/src/tests/base/types-test.cpp
	@@ -1,29 +1,53 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <catch2/catch.hpp>

	#include <types.hpp>

	using namespace Kazv;

	TEST_CASE("immer::map<std::string, X> should convert to json object", "[base][types]")
	{
	immer::map<std::string, int> m;
	json j = m;

	REQUIRE(j.is_object());
	}

	TEST_CASE("immer::map<non-std::string, X> should convert to json array", "[base][types]")
	{
	immer::map<int, int> m;
	json j = m;

	REQUIRE(j.is_array());
	}
	+
	+TEST_CASE("immer::array<X> should convert to json array", "[base][types]")
	+{
	+ immer::array<int> m;
	+ json j = m;
	+
	+ REQUIRE(j.is_array());
	+
	+ m = m.push_back(1);
	+ j = m;
	+ REQUIRE(j.is_array());
	+}
	+
	+TEST_CASE("immer::flex_vector<X> should convert to json array", "[base][types]")
	+{
	+ immer::flex_vector<int> m;
	+ json j = m;
	+
	+ REQUIRE(j.is_array());
	+
	+ m = m.push_back(1);
	+ j = m;
	+ REQUIRE(j.is_array());
	+}
	diff --git a/src/tests/client/keys-test.cpp b/src/tests/client/keys-test.cpp
	new file mode 100644
	index 0000000..8ff035c
	--- /dev/null
	+++ b/src/tests/client/keys-test.cpp
	@@ -0,0 +1,36 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2022 Tusooa Zhu <tusooa@kazv.moe>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#include <libkazv-config.hpp>
	+
	+#include <catch2/catch.hpp>
	+
	+#include <client-model.hpp>
	+
	+#include "client-test-util.hpp"
	+
	+using namespace Kazv;
	+
	+TEST_CASE("Query keys", "[client][keys]")
	+{
	+ ClientModel m;
	+ m.crypto = Crypto{};
	+ m.deviceLists.track(immer::flex_vector<std::string>{"@mew:example.org", "@mew2:example.org"});
	+
	+ WHEN("We query keys")
	+ {
	+ auto [res, dontCareEffect] = ClientModel::update(m, QueryKeysAction{true});
	+ THEN("It should make a request with a map of empty lists")
	+ {
	+ assert1Job(res);
	+ for1stJob(res, [](const auto &job) {
	+ auto body = json::parse(std::get<BytesBody>(job.requestBody()));
	+ REQUIRE(body.at("device_keys").at("@mew:example.org") == json::array());
	+ REQUIRE(body.at("device_keys").at("@mew2:example.org") == json::array());
	+ });
	+ }
	+ }
	+}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 10, 3:39 PM (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785307
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions