matrixion/src/ui/UserProfile.cpp

329 lines
15 KiB
C++
Raw Normal View History

2020-05-17 16:34:47 +03:00
#include "UserProfile.h"
2020-06-28 18:31:34 +03:00
#include "Cache.h"
2020-06-26 01:54:42 +03:00
#include "ChatPage.h"
2020-07-05 19:03:27 +03:00
#include "DeviceVerificationFlow.h"
2020-05-17 16:34:47 +03:00
#include "Logging.h"
#include "Utils.h"
2020-05-22 08:47:02 +03:00
#include "mtx/responses/crypto.hpp"
2020-08-09 06:05:15 +03:00
#include "timeline/TimelineModel.h"
2020-05-17 16:34:47 +03:00
2020-07-17 23:16:30 +03:00
#include <iostream> // only for debugging
2020-08-09 06:05:15 +03:00
UserProfile::UserProfile(QString roomid, QString userid, TimelineModel *parent)
2020-07-04 05:24:28 +03:00
: QObject(parent)
, roomid_(roomid)
, userid_(userid)
2020-08-09 06:05:15 +03:00
, model(parent)
2020-07-04 05:24:28 +03:00
{
fetchDeviceList(this->userid_);
}
2020-06-28 18:31:34 +03:00
2020-07-04 05:24:28 +03:00
QHash<int, QByteArray>
DeviceInfoModel::roleNames() const
{
return {
{DeviceId, "deviceId"},
{DeviceName, "deviceName"},
{VerificationStatus, "verificationStatus"},
};
}
2020-07-01 15:17:10 +03:00
2020-07-04 05:24:28 +03:00
QVariant
DeviceInfoModel::data(const QModelIndex &index, int role) const
2020-07-01 15:17:10 +03:00
{
2020-07-04 05:24:28 +03:00
if (!index.isValid() || index.row() >= (int)deviceList_.size() || index.row() < 0)
return {};
switch (role) {
case DeviceId:
return deviceList_[index.row()].device_id;
case DeviceName:
return deviceList_[index.row()].display_name;
case VerificationStatus:
return QVariant::fromValue(deviceList_[index.row()].verification_status);
default:
return {};
}
2020-07-01 15:17:10 +03:00
}
2020-05-17 16:34:47 +03:00
2020-07-04 05:24:28 +03:00
void
DeviceInfoModel::reset(const std::vector<DeviceInfo> &deviceList)
2020-05-27 11:49:26 +03:00
{
2020-07-04 05:24:28 +03:00
beginResetModel();
this->deviceList_ = std::move(deviceList);
endResetModel();
}
DeviceInfoModel *
UserProfile::deviceList()
{
return &this->deviceList_;
2020-05-17 16:34:47 +03:00
}
2020-05-22 08:47:02 +03:00
QString
2020-07-04 05:24:28 +03:00
UserProfile::userid()
2020-05-27 11:49:26 +03:00
{
2020-07-04 05:24:28 +03:00
return this->userid_;
2020-05-22 08:47:02 +03:00
}
2020-07-04 05:24:28 +03:00
QString
UserProfile::displayName()
2020-05-27 11:49:26 +03:00
{
2020-07-04 05:24:28 +03:00
return cache::displayName(roomid_, userid_);
}
QString
UserProfile::avatarUrl()
{
return cache::avatarUrl(roomid_, userid_);
2020-05-22 08:47:02 +03:00
}
2020-07-17 23:16:30 +03:00
bool
UserProfile::getUserStatus()
{
return isUserVerified;
}
2020-06-28 18:31:34 +03:00
void
UserProfile::fetchDeviceList(const QString &userID)
{
2020-08-24 11:26:50 +03:00
auto localUser = utils::localUser();
mtx::requests::QueryKeys req;
req.device_keys[userID.toStdString()] = {};
ChatPage::instance()->query_keys(
req,
[user_id = userID.toStdString(), this](const mtx::responses::QueryKeys &res,
mtx::http::RequestErr err) {
2020-08-24 11:26:50 +03:00
if (err) {
nhlog::net()->warn("failed to query device keys: {},{}",
err->matrix_error.errcode,
static_cast<int>(err->status_code));
return;
}
if (res.device_keys.empty() ||
(res.device_keys.find(user_id) == res.device_keys.end())) {
nhlog::net()->warn("no devices retrieved {}", user_id);
return;
}
// Finding if the User is Verified or not based on the Signatures
mtx::requests::QueryKeys req;
req.device_keys[utils::localUser().toStdString()] = {};
2020-08-24 11:26:50 +03:00
ChatPage::instance()->query_keys(
req,
[user_id, other_res = res, this](const mtx::responses::QueryKeys &res,
mtx::http::RequestErr err) {
2020-08-24 11:26:50 +03:00
using namespace mtx;
std::string local_user_id = utils::localUser().toStdString();
2020-08-24 11:26:50 +03:00
if (err) {
nhlog::net()->warn("failed to query device keys: {},{}",
err->matrix_error.errcode,
static_cast<int>(err->status_code));
return;
}
if (res.device_keys.empty() ||
(res.device_keys.find(local_user_id) == res.device_keys.end())) {
nhlog::net()->warn("no devices retrieved {}", user_id);
return;
}
std::vector<DeviceInfo> deviceInfo;
auto devices = other_res.device_keys.at(user_id);
auto device_verified = cache::getVerifiedCache(user_id);
if (device_verified.has_value()) {
isUserVerified = device_verified.value().is_user_verified;
}
2020-08-24 11:26:50 +03:00
std::optional<crypto::CrossSigningKeys> lmk, lsk, luk, mk, sk, uk;
if (!res.master_keys.empty())
2020-08-24 11:26:50 +03:00
lmk = res.master_keys.at(local_user_id);
if (!res.user_signing_keys.empty())
2020-08-24 11:26:50 +03:00
luk = res.user_signing_keys.at(local_user_id);
if (!res.self_signing_keys.empty())
2020-08-24 11:26:50 +03:00
lsk = res.self_signing_keys.at(local_user_id);
if (!other_res.master_keys.empty())
2020-08-24 11:26:50 +03:00
mk = other_res.master_keys.at(user_id);
if (!other_res.user_signing_keys.empty())
2020-08-24 11:26:50 +03:00
uk = other_res.user_signing_keys.at(user_id);
if (!other_res.self_signing_keys.empty())
2020-08-24 11:26:50 +03:00
sk = other_res.self_signing_keys.at(user_id);
// First checking if the user is verified
if (luk.has_value() && mk.has_value()) {
// iterating through the public key of local user_signing keys
for (auto sign_key : luk.value().keys) {
// checking if the signatures are empty as "at" could
// cause exceptions
2020-08-29 11:07:51 +03:00
auto signs = mk->signatures;
if (!signs.empty() &&
signs.find(local_user_id) != signs.end()) {
auto sign = signs.at(local_user_id);
try {
isUserVerified =
isUserVerified ||
2020-08-24 11:26:50 +03:00
(olm::client()->ed25519_verify_sig(
sign_key.second,
json(mk.value()),
2020-08-29 11:07:51 +03:00
sign.at(sign_key.first)));
} catch (std::out_of_range) {
isUserVerified =
isUserVerified || false;
2020-08-24 11:26:50 +03:00
}
}
}
}
for (const auto &d : devices) {
auto device = d.second;
verification::Status verified =
verification::Status::UNVERIFIED;
if (device_verified.has_value()) {
if (std::find(device_verified->cross_verified.begin(),
device_verified->cross_verified.end(),
d.first) !=
device_verified->cross_verified.end())
verified = verification::Status::VERIFIED;
if (std::find(device_verified->device_verified.begin(),
device_verified->device_verified.end(),
d.first) !=
device_verified->device_verified.end())
verified = verification::Status::VERIFIED;
if (std::find(device_verified->device_blocked.begin(),
device_verified->device_blocked.end(),
d.first) !=
device_verified->device_blocked.end())
verified = verification::Status::BLOCKED;
} else if (isUserVerified) {
device_verified = DeviceVerifiedCache{};
}
2020-08-24 11:26:50 +03:00
// won't check for already verified devices
if (verified != verification::Status::VERIFIED &&
isUserVerified) {
if ((sk.has_value()) && (!device.signatures.empty())) {
for (auto sign_key : sk.value().keys) {
auto signs =
device.signatures.at(user_id);
try {
if (olm::client()
->ed25519_verify_sig(
sign_key.second,
json(device),
signs.at(
sign_key.first))) {
verified =
verification::Status::
VERIFIED;
device_verified.value()
.cross_verified
.push_back(d.first);
}
} catch (std::out_of_range) {
}
}
}
}
if (device_verified.has_value()) {
device_verified.value().is_user_verified =
isUserVerified;
cache::setVerifiedCache(user_id,
device_verified.value());
}
deviceInfo.push_back(
{QString::fromStdString(d.first),
QString::fromStdString(
device.unsigned_info.device_display_name),
verified});
}
std::cout << (isUserVerified ? "Yes" : "No") << std::endl;
std::sort(deviceInfo.begin(),
deviceInfo.end(),
[](const DeviceInfo &a, const DeviceInfo &b) {
return a.device_id > b.device_id;
});
this->deviceList_.queueReset(std::move(deviceInfo));
});
2020-08-24 11:26:50 +03:00
});
2020-05-17 16:34:47 +03:00
}
2020-05-27 11:49:26 +03:00
2020-06-26 01:54:42 +03:00
void
UserProfile::banUser()
{
2020-07-04 05:24:28 +03:00
ChatPage::instance()->banUser(this->userid_, "");
2020-06-26 01:54:42 +03:00
}
// void ignoreUser(){
// }
void
UserProfile::kickUser()
{
2020-07-04 05:24:28 +03:00
ChatPage::instance()->kickUser(this->userid_, "");
2020-06-26 01:54:42 +03:00
}
void
UserProfile::startChat()
{
mtx::requests::CreateRoom req;
req.preset = mtx::requests::Preset::PrivateChat;
req.visibility = mtx::requests::Visibility::Private;
2020-07-04 05:24:28 +03:00
if (utils::localUser() != this->userid_)
req.invite = {this->userid_.toStdString()};
2020-06-26 01:54:42 +03:00
emit ChatPage::instance()->createRoom(req);
2020-07-17 23:16:30 +03:00
}
2020-08-09 06:05:15 +03:00
DeviceVerificationFlow *
UserProfile::createFlow(bool isVerifyUser)
2020-07-17 23:16:30 +03:00
{
2020-08-09 06:05:15 +03:00
if (!isVerifyUser)
return (new DeviceVerificationFlow(this, DeviceVerificationFlow::Type::ToDevice));
else {
std::cout << "CHECKING IF IT TO START ROOM_VERIFICATION OR TO_DEVICE VERIFICATION"
<< std::endl;
auto joined_rooms = cache::joinedRooms();
auto room_infos = cache::getRoomInfo(joined_rooms);
for (std::string room_id : joined_rooms) {
if ((room_infos[QString::fromStdString(room_id)].member_count == 2) &&
cache::isRoomEncrypted(room_id)) {
auto room_members = cache::roomMembers(room_id);
if (std::find(room_members.begin(),
room_members.end(),
(this->userid()).toStdString()) !=
room_members.end()) {
std::cout
<< "FOUND A ENCRYPTED ROOM WITH THIS USER : " << room_id
2020-07-17 23:16:30 +03:00
<< std::endl;
2020-08-09 06:05:15 +03:00
if (this->roomid_.toStdString() == room_id) {
auto newflow = new DeviceVerificationFlow(
2020-08-18 08:59:02 +03:00
this,
DeviceVerificationFlow::Type::RoomMsg,
this->model);
2020-08-09 06:05:15 +03:00
return (std::move(newflow));
} else {
std::cout << "FOUND A ENCRYPTED ROOM BUT CURRENTLY "
"NOT IN THAT ROOM : "
<< room_id << std::endl;
}
}
2020-07-17 23:16:30 +03:00
}
}
2020-08-09 06:05:15 +03:00
std::cout << "DIDN'T FIND A ENCRYPTED ROOM WITH THIS USER" << std::endl;
return (new DeviceVerificationFlow(this, DeviceVerificationFlow::Type::ToDevice));
}
2020-07-05 19:03:27 +03:00
}