summary refs log tree commit diff
path: root/src/ui/UserProfile.cpp
diff options
context:
space:
mode:
authorCH Chethan Reddy <40890937+Chethan2k1@users.noreply.github.com>2020-08-24 13:56:50 +0530
committerCH Chethan Reddy <40890937+Chethan2k1@users.noreply.github.com>2020-08-24 13:58:00 +0530
commit1d299951b61390c381013ca0503fb09df548c6ec (patch)
tree12a627382e339adb033143751a2d4f96fbabba48 /src/ui/UserProfile.cpp
parent[WIP] Room Verification Works! (diff)
downloadnheko-1d299951b61390c381013ca0503fb09df548c6ec.tar.xz
Cache Fix
Diffstat (limited to 'src/ui/UserProfile.cpp')
-rw-r--r--src/ui/UserProfile.cpp177
1 files changed, 111 insertions, 66 deletions
diff --git a/src/ui/UserProfile.cpp b/src/ui/UserProfile.cpp
index 87eae001..2426fe6c 100644
--- a/src/ui/UserProfile.cpp
+++ b/src/ui/UserProfile.cpp
@@ -85,79 +85,124 @@ UserProfile::getUserStatus()
 }
 
 void
-UserProfile::callback_fn(const mtx::responses::QueryKeys &res,
-                         mtx::http::RequestErr err,
-                         std::string user_id)
+UserProfile::fetchDeviceList(const QString &userID)
 {
-        if (err) {
-                nhlog::net()->warn("failed to query device keys: {},{}",
-                                   err->matrix_error.errcode,
-                                   static_cast<int>(err->status_code));
-                return;
-        }
+        auto localUser = utils::localUser();
 
-        if (res.device_keys.empty() || (res.device_keys.find(user_id) == res.device_keys.end())) {
-                nhlog::net()->warn("no devices retrieved {}", user_id);
-                return;
-        }
+        mtx::requests::QueryKeys req;
+        req.device_keys[userID.toStdString()] = {};
+        ChatPage::instance()->query_keys(
+          req,
+          [user_id = userID.toStdString(), local_user_id = localUser.toStdString(), this](
+            const mtx::responses::QueryKeys &res, mtx::http::RequestErr err) {
+                  if (err) {
+                          nhlog::net()->warn("failed to query device keys: {},{}",
+                                             err->matrix_error.errcode,
+                                             static_cast<int>(err->status_code));
+                          return;
+                  }
 
-        auto devices = res.device_keys.at(user_id);
-        std::vector<DeviceInfo> deviceInfo;
-        auto device_verified = cache::getVerifiedCache(user_id);
-
-        for (const auto &d : devices) {
-                auto device = d.second;
-
-                // TODO: Verify signatures and ignore those that don't pass.
-                verification::Status verified = verification::Status::UNVERIFIED;
-                isUserVerified                = device_verified->is_user_verified;
-                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;
-                }
+                  if (res.device_keys.empty() ||
+                      (res.device_keys.find(user_id) == res.device_keys.end())) {
+                          nhlog::net()->warn("no devices retrieved {}", user_id);
+                          return;
+                  }
 
-                deviceInfo.push_back(
-                  {QString::fromStdString(d.first),
-                   QString::fromStdString(device.unsigned_info.device_display_name),
-                   verified});
-        }
+                  auto devices = res.device_keys.at(user_id);
+                  std::vector<DeviceInfo> deviceInfo;
+                  auto device_verified = cache::getVerifiedCache(user_id);
 
-        std::sort(
-          deviceInfo.begin(), deviceInfo.end(), [](const DeviceInfo &a, const DeviceInfo &b) {
-                  return a.device_id > b.device_id;
-          });
+                  for (const auto &d : devices) {
+                          auto device = d.second;
 
-        this->deviceList_.queueReset(std::move(deviceInfo));
-}
+                          // TODO: Verify signatures and ignore those that don't pass.
+                          verification::Status verified = verification::Status::UNVERIFIED;
+                          isUserVerified                = device_verified->is_user_verified;
+                          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;
+                          }
 
-void
-UserProfile::fetchDeviceList(const QString &userID)
-{
-        auto localUser  = utils::localUser();
-        auto user_cache = cache::getUserCache(userID.toStdString());
-
-        if (user_cache.has_value()) {
-                this->callback_fn(user_cache->keys, {}, userID.toStdString());
-        } else {
-                mtx::requests::QueryKeys req;
-                req.device_keys[userID.toStdString()] = {};
-                http::client()->query_keys(
-                  req,
-                  [user_id = userID.toStdString(), this](const mtx::responses::QueryKeys &res,
-                                                         mtx::http::RequestErr err) {
-                          this->callback_fn(res, err, user_id);
-                  });
-        }
+                          deviceInfo.push_back(
+                            {QString::fromStdString(d.first),
+                             QString::fromStdString(device.unsigned_info.device_display_name),
+                             verified});
+                  }
+
+                  // Finding if the User is Verified or not based on the Signatures
+                  mtx::requests::QueryKeys req;
+                  req.device_keys[local_user_id] = {};
+
+                  ChatPage::instance()->query_keys(
+                    req,
+                    [&local_user_id, &user_id, other_res = res, this](
+                      const mtx::responses::QueryKeys &res, mtx::http::RequestErr err) {
+                            using namespace mtx;
+
+                            if (err) {
+                                    nhlog::net()->warn("failed to query device keys: {},{}",
+                                                       err->matrix_error.errcode,
+                                                       static_cast<int>(err->status_code));
+                                    return;
+                            }
+
+                            std::optional<crypto::CrossSigningKeys> lmk, lsk, luk, mk, sk, uk;
+
+                            if (res.master_keys.find(local_user_id) != res.master_keys.end())
+                                    lmk = res.master_keys.at(local_user_id);
+                            if (res.user_signing_keys.find(local_user_id) !=
+                                res.user_signing_keys.end())
+                                    luk = res.user_signing_keys.at(local_user_id);
+                            if (res.self_signing_keys.find(local_user_id) !=
+                                res.self_signing_keys.end())
+                                    lsk = res.self_signing_keys.at(local_user_id);
+                            if (other_res.master_keys.find(user_id) != other_res.master_keys.end())
+                                    mk = other_res.master_keys.at(user_id);
+                            if (other_res.user_signing_keys.find(user_id) !=
+                                other_res.user_signing_keys.end())
+                                    uk = other_res.user_signing_keys.at(user_id);
+                            if (other_res.self_signing_keys.find(user_id) !=
+                                other_res.self_signing_keys.end())
+                                    sk = other_res.self_signing_keys.at(user_id);
+
+                            // First checking if the user is verified
+                            if (lmk.has_value() && luk.has_value()) {
+                                    bool is_user_verified = false;
+                                    for (auto sign_key : lmk.value().keys) {
+                                            if (!luk.value().signatures.empty()) {
+                                                    for (auto signature :
+                                                         luk.value().signatures.at(local_user_id)) {
+                                                            is_user_verified =
+                                                              is_user_verified ||
+                                                              (olm::client()->ed25519_verify_sig(
+                                                                sign_key.second,
+                                                                json(luk.value()),
+                                                                signature.second));
+                                                    }
+                                            }
+                                    }
+                                    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));
+          });
 }
 
 void