No OneTemporary
Actions

Size

43 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/actions/encryption.cpp b/src/client/actions/encryption.cpp
	index 31c777c..a2b7721 100644
	--- a/src/client/actions/encryption.cpp
	+++ b/src/client/actions/encryption.cpp
	@@ -1,603 +1,616 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2024 tusooa <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 <immer-utils.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 keys =
	immer::map<std::string, std::string>{}
	.set(ed25519 + ":" + m.deviceId, m.constCrypto().ed25519IdentityKey())
	.set(curve25519 + ":" + m.deviceId, m.constCrypto().curve25519IdentityKey());

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

	auto j = json(k);

	auto sig = m.withCrypto([&](auto &crypto) { return 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 };
	}

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

	auto maxNumKeys = m.constCrypto().maxNumberOfOneTimeKeys();
	auto numLocalKeys = m.constCrypto().numUnpublishedOneTimeKeys();
	auto numStoredKeys = m.constCrypto().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) {
	m.withCrypto([&](auto &c) { c.genOneTimeKeysWithRandom(a.random, numKeysToGenerate); });
	}
	kzo.client.dbg() << "Generating done." << std::endl;

	auto keys = m.constCrypto().unpublishedOneTimeKeys();

	auto cv25519Keys = keys.at(curve25519);
	json oneTimeKeys = json::object();
	for (auto [id, keyStr] : cv25519Keys.items()) {
	json keyObject = json::object();
	keyObject["key"] = keyStr;
	keyObject["signatures"] = convertSignature(m, m.withCrypto([&](auto &c) { return c.sign(keyObject); }));

	oneTimeKeys[signedCurve25519 + ":" + id] = 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 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), failWithResponse(r) };
	}

	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), failWithResponse(r) };
	}

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

	m.withCrypto([&](auto &c) { c.markOneTimeKeysAsPublished(); });
	}

	m.withCrypto([&](auto &c) { c.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)
	{
	bool valid = true;

	try {
	std::string algo = e.originalJson().get().at("content").at("algorithm");
	if (algo == olmAlgo) {
	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();

	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) == m.constCrypto().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;
	}
	} 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;
	}

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

	auto maybePlainText = m.withCrypto([&](Crypto &c) {
	return c.decrypt(e.originalJson().get());
	});

	if (! maybePlainText) {
	kzo.client.dbg() << "Cannot decrypt: " << maybePlainText.reason() << std::endl;
	return e.setDecryptedJson(cannotDecryptEvent(maybePlainText.reason()), Event::NotDecrypted);
	} else {
	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;
	}

	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;
	}

	try {
	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");

	auto k = KeyOfGroupSession{roomId, sessionId};

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

	if (m.withCrypto([&](auto &c) { return c.createInboundGroupSession(k, sessionKey, ed25519Key); })) {
	return false; // such that this event is removed
	}
	} catch (...) {
	kzo.client.dbg() << "cannot create group session";
	return false;
	}
	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);
	+ auto undecryptedEvents = room.undecryptedEvents;
	+ for (auto [sessionId, eventIds] : undecryptedEvents) {
	+ if (m.constCrypto().hasInboundGroupSession({
	+ room.roomId,
	+ sessionId,
	+ })) {
	+ auto nextEventIds = intoImmer(
	+ immer::flex_vector<std::string>{},
	+ zug::filter([&](auto eventId) {
	+ auto event = room.messages[eventId];
	+ auto decrypted = decryptFunc(event);
	+ if (decrypted.decrypted()) {
	+ room.messages = std::move(room.messages)
	+ .set(eventId, decrypted);
	+ }
	+ return !decrypted.decrypted();
	+ }),
	+ eventIds
	+ );
	+ if (nextEventIds.empty()) {
	+ room.undecryptedEvents = std::move(room.undecryptedEvents).erase(sessionId);
	+ } else {
	+ room.undecryptedEvents = std::move(room.undecryptedEvents).set(sessionId, nextEventIds);
	+ }
	+ }
	+ }
	+
	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), simpleFail };
	}

	if (! r.success()) {
	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 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.withCrypto([&](Crypto &c) {
	m.deviceLists.addDevice(userId, deviceId, deviceInfo, c);
	});
	}
	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 };
	}

	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 = m.withCrypto([&](auto &c) { return 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), failWithResponse(r) };
	}

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

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

	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) {
	auto keys = 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 = m.withCrypto([&](auto &c) { return 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;
	m.withCrypto([&](auto &c) { 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, SetDeviceTrustLevelAction a)
	{
	auto maybeOldInfo = m.deviceLists.get(a.userId, a.deviceId);
	if (!maybeOldInfo) {
	return {
	std::move(m),
	[=](auto && /* ctx */) {
	auto retJson = json::object({
	{"error", "No such device"},
	{"errorCode", "MOE_KAZV_MXC_KAZV_NO_SUCH_DEVICE"},
	});

	return EffectStatus(/* succ = */ false, retJson);
	}
	};
	}

	m.deviceLists.deviceLists = updateIn(
	std::move(m.deviceLists.deviceLists),
	[a](auto device) {
	device.trustLevel = a.trustLevel;
	return device;
	},
	a.userId,
	a.deviceId
	);

	return { m, lager::noop };
	}

	ClientResult updateClient(ClientModel m, SetTrustLevelNeededToSendKeysAction a)
	{
	m.trustLevelNeededToSendKeys = a.trustLevel;
	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, PrepareForSharingRoomKeyAction a)
	{
	auto messages = m.olmEncryptSplit(a.e, a.devices, a.random);

	auto txnId = getTxnId(Event(), m);

	m.roomList = RoomListModel::update(
	std::move(m.roomList),
	UpdateRoomAction{
	a.roomId,
	AddPendingRoomKeyAction{
	PendingRoomKeyEvent{txnId, messages}
	}
	}
	);

	return { std::move(m), [txnId](auto &&) {
	return EffectStatus(/* succ = */ true, json::object({{"txnId", txnId}}));
	} };
	}
	}
	diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
	index 4d4b913..4248197 100644
	--- a/src/tests/CMakeLists.txt
	+++ b/src/tests/CMakeLists.txt
	@@ -1,115 +1,116 @@

	include(CTest)

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

	function(libkazv_add_tests)
	set(options "")
	set(oneValueArgs "")
	set(multiValueArgs EXTRA_LINK_LIBRARIES EXTRA_INCLUDE_DIRECTORIES)
	cmake_parse_arguments(PARSE_ARGV 0 libkazv_add_tests "${options}" "${oneValueArgs}" "${multiValueArgs}")
	foreach(test_source ${libkazv_add_tests_UNPARSED_ARGUMENTS})
	string(REGEX REPLACE "\\.cpp$" "" test_executable "${test_source}")
	string(REGEX REPLACE "/\|\\\\" "--" test_executable "${test_executable}")
	message(STATUS "Test ${test_executable} added")
	add_executable("${test_executable}" "${test_source}")
	target_link_libraries("${test_executable}"
	PRIVATE Catch2::Catch2WithMain
	Threads::Threads
	${libkazv_add_tests_EXTRA_LINK_LIBRARIES}
	)

	target_include_directories(
	"${test_executable}"
	PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}/..
	${libkazv_add_tests_EXTRA_INCLUDE_DIRECTORIES}
	)

	target_compile_definitions("${test_executable}" PRIVATE CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)

	add_test(NAME "${test_executable}" COMMAND "${test_executable}" "--allow-running-no-tests" "~[needs-internet]")
	endforeach()
	endfunction()

	libkazv_add_tests(
	event-test.cpp
	cursorutiltest.cpp
	base/serialization-test.cpp
	base/types-test.cpp
	base/immer-utils-test.cpp
	base/json-utils-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase
	)

	add_library(client-test-lib SHARED client/client-test-util.cpp)
	target_link_libraries(client-test-lib PUBLIC kazvjob kazvclient)
	libkazv_add_tests(
	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/join-test.cpp
	client/keys-test.cpp
	client/device-ops-test.cpp
	client/send-test.cpp
	client/encryption-test.cpp
	client/redact-test.cpp
	client/tagging-test.cpp
	client/account-data-test.cpp
	client/room/room-actions-test.cpp
	client/room/local-echo-test.cpp
	client/room/event-relationships-test.cpp
	client/room/member-membership-test.cpp
	client/push-rules-desc-test.cpp
	client/notification-handler-test.cpp
	client/validator-test.cpp
	client/power-levels-desc-test.cpp
	client/client-test.cpp
	client/create-room-test.cpp
	client/device-list-tracker-benchmark-test.cpp
	client/room/read-receipt-test.cpp
	client/room/undecrypted-events-test.cpp
	+ client/encryption-benchmark-test.cpp
	EXTRA_LINK_LIBRARIES kazvclient kazveventemitter kazvjob client-test-lib kazvtestfixtures
	EXTRA_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/client
	)

	libkazv_add_tests(
	basejobtest.cpp
	kazvjobtest.cpp
	file-desc-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazvjob
	)

	libkazv_add_tests(
	promise-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazvjob kazvstore
	)

	libkazv_add_tests(
	event-emitter-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazveventemitter
	)

	libkazv_add_tests(
	crypto-test.cpp
	crypto/deterministic-test.cpp
	EXTRA_LINK_LIBRARIES kazvcrypto
	)

	libkazv_add_tests(
	store-test.cpp
	EXTRA_LINK_LIBRARIES kazvstore kazvjob
	)
	diff --git a/src/tests/client/client-test.cpp b/src/tests/client/client-test.cpp
	index 4bf583b..887de52 100644
	--- a/src/tests/client/client-test.cpp
	+++ b/src/tests/client/client-test.cpp
	@@ -1,43 +1,53 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2024 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <catch2/catch_test_macros.hpp>

	#include <client/client-model.hpp>
	#include <client/actions/encryption.hpp>

	#include "factory.hpp"

	using namespace Kazv;
	using namespace Kazv::Factory;

	TEST_CASE("ClientModel copying should not invoke Crypto copy-constructor", "[client][copy]")
	{
	ClientModel m = makeClient(withCrypto(makeCrypto()));

	auto m2 = m;

	REQUIRE(m.crypto.value().get() == m2.crypto.value().get());
	}

	TEST_CASE("Modifying Crypto in Client when it is not unique should invoke Crypto's copy constructor", "[client][copy]")
	{
	- ClientModel m = makeClient(
	+ auto roomId = "!someroom:example.com";
	+ auto room = makeRoom(
	+ withRoomEncrypted(true)
	+ \| withRoomId(roomId)
	+ );
	+ auto client = makeClient(
	withCrypto(makeCrypto())
	- \| withRoom(makeRoom(
	- withRoomEncrypted(true)
	- \| withRoomTimeline({
	- makeEvent(withEventType("m.room.encrypted"))
	- })))
	+ \| withRoom(room)
	);

	- auto m2 = m;
	+ auto plainText = makeEvent();
	+ auto [encrypted, sessionId] = client.megOlmEncrypt(plainText, roomId, 1719196953000,
	+ genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	+
	+ withRoomTimeline({
	+ encrypted
	+ })(room);
	+ withRoom(room)(client);
	+
	+ auto m2 = client;

	- auto m3 = tryDecryptEvents(std::move(m));
	+ auto m3 = tryDecryptEvents(std::move(client));
	REQUIRE(!(m3.crypto.value().get() == m2.crypto.value().get()));
	}
	diff --git a/src/tests/client/encryption-benchmark-test.cpp b/src/tests/client/encryption-benchmark-test.cpp
	new file mode 100644
	index 0000000..2aa7e95
	--- /dev/null
	+++ b/src/tests/client/encryption-benchmark-test.cpp
	@@ -0,0 +1,100 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2024 tusooa <tusooa@kazv.moe>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#include <libkazv-config.hpp>
	+#include <iostream>
	+#include <catch2/catch_test_macros.hpp>
	+#include <catch2/benchmark/catch_benchmark.hpp>
	+#include <actions/encryption.hpp>
	+#include <client-model.hpp>
	+#include "factory.hpp"
	+
	+using namespace Kazv;
	+using namespace Kazv::Factory;
	+
	+// The assumption here is that undecrypted events take only a small
	+// part in the room timeline, and most undecrypted events are so because
	+// we do not have the corresponding session key.
	+// This should hold when the most of the
	+// messages in the timeline is received after the session begins
	+// (until we implement key sharing).
	+static ClientModel data(
	+ std::size_t roomCount,
	+ std::size_t messagesPerRoom,
	+ std::size_t undecryptableMessagesPerRoom,
	+ std::size_t decryptableMessagesPerRoom
	+)
	+{
	+ std::cerr << "Generating data" << std::endl;
	+ auto client = makeClient(withCrypto(makeCrypto()));
	+
	+ std::size_t generated = 0;
	+ auto makeNewEvent = [&](const std::string &roomId, std::size_t m) {
	+ if (m < undecryptableMessagesPerRoom) {
	+ return makeEvent(withEventType("m.room.encrypted")
	+ \| withEventContent(json{
	+ {"algorithm", CryptoConstants::megOlmAlgo},
	+ {"ciphertext", "does not matter"},
	+ {"device_id", "somedevice"},
	+ {"sender_key", "somekey"},
	+ // rotating the session once per 100 messages
	+ {"session_id", "some-session-id" + std::to_string(m / 100)},
	+ })
	+ \| withEventKV("/room_id"_json_pointer, roomId));
	+ } else if (m < undecryptableMessagesPerRoom + decryptableMessagesPerRoom) {
	+ auto event = makeEvent();
	+ auto [encrypted, sessionId] = client.megOlmEncrypt(
	+ event, roomId, 1719196953000,
	+ genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	+ return encrypted;
	+ } else {
	+ return makeEvent();
	+ }
	+ };
	+
	+ for (std::size_t r = 0; r < roomCount; ++r) {
	+ auto room = makeRoom(withRoomEncrypted(true));
	+ withRoom(room)(client);
	+ auto events = EventList{};
	+ for (std::size_t m = 0; m < messagesPerRoom; ++m) {
	+ auto event = makeNewEvent(room.roomId, m);
	+ events = std::move(events).push_back(event);
	+ ++generated;
	+ if (generated % 10000 == 0) {
	+ std::cerr << "Generated " << generated << " events" << std::endl;
	+ }
	+ }
	+ withRoomTimeline(events)(room);
	+ withRoom(room)(client);
	+ }
	+ return client;
	+}
	+
	+// correspond to the case where the session is pretty new
	+TEST_CASE("tryDecryptEvents() benchmark: small", "[client][encryption][!benchmark]")
	+{
	+ auto client = data(10, 200, 100, 5);
	+ BENCHMARK("tryDecryptEvents()") {
	+ return tryDecryptEvents(client);
	+ };
	+}
	+
	+TEST_CASE("tryDecryptEvents() benchmark: medium", "[client][encryption][!benchmark]")
	+{
	+ auto client = data(50, 1000, 200, 5);
	+ BENCHMARK("tryDecryptEvents()") {
	+ return tryDecryptEvents(client);
	+ };
	+}
	+
	+// A somewhat unrealistic case
	+TEST_CASE("tryDecryptEvents() benchmark: large", "[client][encryption][!benchmark]")
	+{
	+ auto client = data(100, 4000, 400, 5);
	+ BENCHMARK("tryDecryptEvents()") {
	+ return tryDecryptEvents(client);
	+ };
	+}
	diff --git a/src/tests/client/encryption-test.cpp b/src/tests/client/encryption-test.cpp
	index 627b9c8..5107fef 100644
	--- a/src/tests/client/encryption-test.cpp
	+++ b/src/tests/client/encryption-test.cpp
	@@ -1,189 +1,256 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <catch2/catch_all.hpp>
	#include <client/actions/encryption.hpp>
	#include <client-model.hpp>

	#include "client-test-util.hpp"
	#include "factory.hpp"

	using namespace Kazv::Factory;

	TEST_CASE("PrepareForSharingRoomKeyAction: adds the encrypted event to pending events", "[client][encryption]")
	{
	ClientModel m;
	m.crypto = Crypto(RandomTag{}, genRandomData(Crypto::constructRandomSize()));
	RoomModel room;
	room.encrypted = true;
	room.roomId = "!exampleroomid:example.com";
	m.roomList.rooms = m.roomList.rooms.set("!exampleroomid:example.com", room);

	auto event = Event{json{
	{"type", "m.room_key"},
	{"content", {{"some", "thing"}}},
	}};

	auto [next, dontCareEffect] = ClientModel::update(m, PrepareForSharingRoomKeyAction{"!exampleroomid:example.com", {}, event, {}});

	auto nextRoom = next.roomList.rooms.at("!exampleroomid:example.com");
	REQUIRE(nextRoom.pendingRoomKeyEvents.size() == 1);
	}

	TEST_CASE("encrypted event will keep a copy of m.relates_to in plaintext", "[client][encryption]")
	{
	auto room = makeRoom(withRoomEncrypted(true));
	auto client = makeClient(
	withCrypto(makeCrypto())
	\| withRoom(room)
	);

	auto eventToEncrypt = makeEvent(
	withEventType("m.room.message")
	\| withEventRelationship("moe.kazv.mxc.custom-rel-type", "$some-event-id")
	);

	auto [encryptedEvent, maybeKey] = client.megOlmEncrypt(
	eventToEncrypt,
	room.roomId,
	0,
	genRandomData(EncryptMegOlmEventAction::maxRandomSize())
	);

	// because we do not have session key yet, it should always be rotated
	REQUIRE(maybeKey.has_value());

	// check we can still access relationship
	REQUIRE(encryptedEvent.relationship() == std::pair<std::string, std::string>{"moe.kazv.mxc.custom-rel-type", "$some-event-id"});

	// check that the relationship is also in plaintext
	REQUIRE(encryptedEvent.originalJson().get()["content"]["m.relates_to"] == json{
	{"rel_type", "moe.kazv.mxc.custom-rel-type"},
	{"event_id", "$some-event-id"},
	});
	}

	TEST_CASE("encrypting event without relationship should not put m.relates_to key in plaintext", "[client][encryption]")
	{
	auto room = makeRoom(withRoomEncrypted(true));
	auto client = makeClient(
	withCrypto(makeCrypto())
	\| withRoom(room)
	);

	auto eventToEncrypt = makeEvent(
	withEventType("m.room.message")
	);

	auto [encryptedEvent, maybeKey] = client.megOlmEncrypt(
	eventToEncrypt,
	room.roomId,
	0,
	genRandomData(EncryptMegOlmEventAction::maxRandomSize())
	);

	REQUIRE(maybeKey.has_value());

	REQUIRE(!encryptedEvent.originalJson().get()["content"].contains("m.relates_to"));
	}

	TEST_CASE("ClientModel::olmEncryptSplit()", "[client][encryption]")
	{
	auto makeDeviceInfo = [](const Crypto &crypto, std::string userId, std::string deviceId) {
	auto client = makeClient(withCrypto(crypto));
	client.userId = userId;
	client.deviceId = deviceId;
	auto [next, _] = updateClient(client, UploadIdentityKeysAction{});
	return json::parse(std::get<Bytes>(next.nextJobs[0].requestBody()))["device_keys"];
	};

	auto receiver1 = makeCrypto();
	receiver1.genOneTimeKeysWithRandom(genRandomData(Crypto::genOneTimeKeysRandomSize(1)), 1);
	auto receiver2 = makeCrypto();
	receiver2.genOneTimeKeysWithRandom(genRandomData(Crypto::genOneTimeKeysRandomSize(1)), 1);

	auto oneTimeKeys1 = receiver1.unpublishedOneTimeKeys();
	auto cv25519Key1 = oneTimeKeys1["curve25519"].items().begin().value().template get<std::string>();
	auto oneTimeKeys2 = receiver2.unpublishedOneTimeKeys();
	auto cv25519Key2 = oneTimeKeys2["curve25519"].items().begin().value().template get<std::string>();

	auto queryKeysRespJson = json{
	{"device_keys", {{"@receiver:example.com", {
	{"device1", makeDeviceInfo(receiver1, "@receiver:example.com", "device1")},
	{"device2", makeDeviceInfo(receiver2, "@receiver:example.com", "device2")},
	}}}},
	};

	// Query keys
	auto client = makeClient(withCrypto(makeCrypto()));
	std::tie(client, std::ignore) = processResponse(client, QueryKeysResponse(
	makeResponse("QueryKeys", withResponseJsonBody(queryKeysRespJson))
	));

	// Claim keys
	client.withCrypto([&](auto &c) { c.createOutboundSessionWithRandom(genRandomData(Crypto::createOutboundSessionRandomSize()), receiver1.curve25519IdentityKey(), cv25519Key1); });
	client.withCrypto([&](auto &c) { c.createOutboundSessionWithRandom(genRandomData(Crypto::createOutboundSessionRandomSize()), receiver2.curve25519IdentityKey(), cv25519Key2); });

	// encrypt
	auto res = client.olmEncryptSplit(Event(json::object()),
	{{"@receiver:example.com", {"device1", "device2"}}},
	genRandomData(Crypto::encryptOlmMaxRandomSize() * 2));

	REQUIRE(res["@receiver:example.com"]["device1"].originalJson().get().at("content").at("ciphertext").size() == 1);
	REQUIRE(res["@receiver:example.com"]["device1"].originalJson().get().at("content").at("ciphertext").contains(receiver1.curve25519IdentityKey()));
	REQUIRE(res["@receiver:example.com"]["device2"].originalJson().get().at("content").at("ciphertext").size() == 1);
	REQUIRE(res["@receiver:example.com"]["device2"].originalJson().get().at("content").at("ciphertext").contains(receiver2.curve25519IdentityKey()));
	}

	TEST_CASE("tryDecryptEvents()", "[client][encryption]")
	{
	auto roomId = "!someroom:example.com";
	auto room = makeRoom(
	withRoomEncrypted(true)
	\| withRoomId(roomId)
	);
	auto client = makeClient(
	withCrypto(makeCrypto())
	\| withRoom(room)
	);

	auto plainText = makeEvent();
	auto [encrypted, sessionId] = client.megOlmEncrypt(plainText, roomId, 1719196953000,
	genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	auto plainText2 = makeEvent();
	// verify that we can decrypt events without sender_key or device_id
	auto [encrypted2, sessionId2] = client.megOlmEncrypt(plainText2, roomId, 1719196953000,
	genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	auto j = encrypted2.originalJson().get();
	j["content"].erase("sender_key");
	j["content"].erase("device_id");
	encrypted2 = Event(j);

	auto events = EventList{
	makeEvent(),
	makeEvent(),
	encrypted,
	encrypted2,
	};

	withRoomTimeline(events)(room);
	withRoom(room)(client);

	auto nextClient = tryDecryptEvents(client);
	auto decryptedEvent = nextClient.roomList.rooms[roomId].messages[encrypted.id()];
	REQUIRE(decryptedEvent.encrypted());
	REQUIRE(decryptedEvent.decrypted());
	REQUIRE(decryptedEvent.type() == plainText.type());
	REQUIRE(decryptedEvent.content() == plainText.content());

	auto decryptedEvent2 = nextClient.roomList.rooms[roomId].messages[encrypted2.id()];
	REQUIRE(decryptedEvent2.encrypted());
	REQUIRE(decryptedEvent2.decrypted());
	REQUIRE(decryptedEvent2.type() == plainText2.type());
	REQUIRE(decryptedEvent2.content() == plainText2.content());
	+
	+ REQUIRE(nextClient.roomList.rooms[roomId].undecryptedEvents
	+ ==
	+ immer::map<std::string, immer::flex_vector<std::string>>{});
	+}
	+
	+TEST_CASE("tryDecryptEvents() will update room.undecryptedEvents", "[client][encryption]")
	+{
	+ auto roomId = "!someroom:example.com";
	+ auto room = makeRoom(
	+ withRoomEncrypted(true)
	+ \| withRoomId(roomId)
	+ );
	+ auto client = makeClient(
	+ withCrypto(makeCrypto())
	+ \| withRoom(room)
	+ );
	+
	+ auto plainText = makeEvent();
	+ auto [encrypted, sessionId] = client.megOlmEncrypt(plainText, roomId, 1719196953000,
	+ genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	+ auto plainText2 = makeEvent();
	+ auto [encrypted2, sessionId2] = client.megOlmEncrypt(plainText2, roomId, 1719196953000,
	+ genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	+ auto j = encrypted2.originalJson().get();
	+ // simulate an undecryptable event with a known session id
	+ j["content"]["/////"];
	+ encrypted2 = Event(j);
	+ // simulate an undecryptable event with an unknown session id
	+ auto plainText3 = makeEvent();
	+ auto [encrypted3, sessionId3] = client.megOlmEncrypt(plainText3, roomId, 1719196953000,
	+ genRandomData(EncryptMegOlmEventAction::maxRandomSize()));
	+ j["content"]["session_id"] = "some-session-id";
	+ encrypted3 = Event(j);
	+
	+ auto events = EventList{
	+ makeEvent(),
	+ makeEvent(),
	+ encrypted,
	+ encrypted2,
	+ encrypted3,
	+ };
	+
	+ withRoomTimeline(events)(room);
	+ withRoom(room)(client);
	+
	+ auto nextClient = tryDecryptEvents(client);
	+ auto decryptedEvent = nextClient.roomList.rooms[roomId].messages[encrypted.id()];
	+ REQUIRE(decryptedEvent.encrypted());
	+ REQUIRE(decryptedEvent.decrypted());
	+ REQUIRE(decryptedEvent.type() == plainText.type());
	+ REQUIRE(decryptedEvent.content() == plainText.content());
	+
	+ auto decryptedEvent2 = nextClient.roomList.rooms[roomId].messages[encrypted2.id()];
	+ REQUIRE(decryptedEvent2.encrypted());
	+ REQUIRE(!decryptedEvent2.decrypted());
	+
	+ auto decryptedEvent3 = nextClient.roomList.rooms[roomId].messages[encrypted2.id()];
	+ REQUIRE(decryptedEvent3.encrypted());
	+ REQUIRE(!decryptedEvent3.decrypted());
	+
	+ REQUIRE(nextClient.roomList.rooms[roomId].undecryptedEvents
	+ ==
	+ immer::map<std::string, immer::flex_vector<std::string>>{
	+ {encrypted.originalJson().get()["content"]["session_id"], {encrypted2.id()}},
	+ {encrypted3.originalJson().get()["content"]["session_id"], {encrypted3.id()}},
	+ });
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 14, 11:02 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 167294
Default Alt Text: (43 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions