Add forwarded keys and some fixes

include/mtx/events.hpp

@@ -32,6 +32,8 @@ enum class EventType
         Reaction,
         /// m.room_key
         RoomKey,
+        /// m.forwarded_room_key
+        ForwardedRoomKey,
         /// m.room_key_request
         RoomKeyRequest,
         /// m.room.aliases

include/mtx/events/collections.hpp

@@ -46,6 +46,7 @@ namespace msgs         = mtx::events::msg;
 
 //! Collection of key verification events
 using DeviceEvents = std::variant<events::DeviceEvent<msgs::RoomKey>,
+                                  events::DeviceEvent<msgs::ForwardedRoomKey>,
                                   events::DeviceEvent<msgs::KeyRequest>,
                                   events::DeviceEvent<msgs::OlmEncrypted>,
                                   events::DeviceEvent<msgs::Encrypted>,
@@ -243,6 +244,9 @@ template<>
 constexpr inline EventType to_device_content_to_type<mtx::events::msg::RoomKey> =
   EventType::RoomKey;
 template<>
+constexpr inline EventType to_device_content_to_type<mtx::events::msg::ForwardedRoomKey> =
+  EventType::ForwardedRoomKey;
+template<>
 constexpr inline EventType to_device_content_to_type<mtx::events::msg::KeyRequest> =
   EventType::RoomKeyRequest;
 // template<>

include/mtx/events/encrypted.hpp

@@ -106,6 +106,24 @@ from_json(const nlohmann::json &obj, RoomKey &event);
 void
 to_json(nlohmann::json &obj, const RoomKey &event);
 
+//! Content of the `m.forwarded_room_key` event.
+struct ForwardedRoomKey
+{
+        std::string algorithm;
+        std::string room_id;
+        std::string session_id;
+        std::string session_key;
+        std::string sender_key;
+        std::string sender_claimed_ed25519_key;
+        std::vector<std::string> forwarding_curve25519_key_chain;
+};
+
+void
+from_json(const nlohmann::json &obj, ForwardedRoomKey &event);
+
+void
+to_json(nlohmann::json &obj, const ForwardedRoomKey &event);
+
 enum class RequestAction
 {
         // request
@@ -382,6 +400,12 @@ struct DeviceEventVisitor
                 mtx::events::to_json(j, roomKey);
                 return j;
         }
+        nlohmann::json operator()(const DeviceEvent<mtx::events::msg::ForwardedRoomKey> &roomKey)
+        {
+                json j;
+                mtx::events::to_json(j, roomKey);
+                return j;
+        }
         nlohmann::json operator()(const DeviceEvent<mtx::events::msg::KeyRequest> &keyReq)
         {
                 json j;

include/mtxclient/crypto/client.hpp

@@ -180,6 +180,7 @@ public:
         //! Create an outbount megolm session.
         OutboundGroupSessionPtr init_outbound_group_session();
         InboundGroupSessionPtr init_inbound_group_session(const std::string &session_key);
+        InboundGroupSessionPtr import_inbound_group_session(const std::string &session_key);
         OlmSessionPtr create_outbound_session(const std::string &identity_key,
                                               const std::string &one_time_key);
         OlmSessionPtr create_inbound_session(const BinaryBuf &one_time_key_message);

lib/crypto/client.cpp

@@ -184,8 +184,24 @@ OlmClient::init_inbound_group_session(const std::string &session_key)
 {
         auto session = create_olm_object<InboundSessionObject>();
 
+        auto temp     = session_key;
         const int ret = olm_init_inbound_group_session(
-          session.get(), reinterpret_cast<const uint8_t *>(session_key.data()), session_key.size());
+          session.get(), reinterpret_cast<const uint8_t *>(temp.data()), temp.size());
+
+        if (ret == -1)
+                throw olm_exception("init_inbound_group_session", session.get());
+
+        return session;
+}
+
+InboundGroupSessionPtr
+OlmClient::import_inbound_group_session(const std::string &session_key)
+{
+        auto session = create_olm_object<InboundSessionObject>();
+
+        auto temp     = session_key;
+        const int ret = olm_import_inbound_group_session(
+          session.get(), reinterpret_cast<const uint8_t *>(temp.data()), temp.size());
 
         if (ret == -1)
                 throw olm_exception("init_inbound_group_session", session.get());

lib/http/client.cpp

@@ -374,7 +374,7 @@ Client::logout(Callback<mtx::responses::Logout> callback)
                                                  RequestErr err) {
                   if (!err) {
                           // Clear the now invalid access token when logout is successful
-                          _this->access_token_.clear();
+                          _this->clear();
                   }
                   // Pass up response and error to supplied callback
                   callback(res, err);
@@ -957,6 +957,7 @@ Client::send_to_device(const std::string &event_type,
         const auto api_path = "/client/r0/sendToDevice/" +
                               mtx::client::utils::url_encode(event_type) + "/" +
                               mtx::client::utils::url_encode(txn_id);
+
         put<nlohmann::json>(api_path, body, callback);
 }
 

lib/structs/events.cpp

@@ -26,6 +26,10 @@ getEventType(const std::string &type)
                 return EventType::KeyVerificationCancel;
         else if (type == "m.reaction")
                 return EventType::Reaction;
+        else if (type == "m.room_key")
+                return EventType::RoomKey;
+        else if (type == "m.forwarded_room_key")
+                return EventType::ForwardedRoomKey;
         else if (type == "m.room_key_request")
                 return EventType::RoomKeyRequest;
         else if (type == "m.room.aliases")
@@ -80,7 +84,7 @@ getEventType(const std::string &type)
                 return EventType::CallHangUp;
         else if (type == "im.nheko.hidden_events")
                 return EventType::NhekoHiddenEvents;
-
+        else
                 return EventType::Unsupported;
 }
 
@@ -108,6 +112,8 @@ to_string(EventType type)
                 return "m.reaction";
         case EventType::RoomKey:
                 return "m.room_key";
+        case EventType::ForwardedRoomKey:
+                return "m.forwarded_room_key";
         case EventType::RoomKeyRequest:
                 return "m.room_key_request";
         case EventType::RoomAliases:
@@ -212,7 +218,11 @@ getMessageType(const json &obj)
         if (obj.find("msgtype") == obj.end())
                 return MessageType::Unknown;
 
+        try {
                 return getMessageType(obj.at("msgtype").get<std::string>());
+        } catch (...) {
+                return MessageType::Unknown;
+        }
 }
 }
 }

lib/structs/events/collections.cpp

@@ -200,6 +200,7 @@ from_json(const json &obj, TimelineEvent &e)
         }
         case events::EventType::RoomPinnedEvents:
         case events::EventType::RoomKey:        // not part of the timeline
+        case events::EventType::ForwardedRoomKey: // not part of the timeline
         case events::EventType::RoomKeyRequest: // Not part of the timeline
         case events::EventType::Tag:            // Not part of the timeline
         case events::EventType::Presence:       // Not part of the timeline

lib/structs/events/encrypted.cpp

@@ -139,6 +139,31 @@ to_json(json &obj, const RoomKey &event)
         obj["session_key"] = event.session_key;
 }
 
+void
+from_json(const json &obj, ForwardedRoomKey &event)
+{
+        event.algorithm                  = obj.at("algorithm").get<std::string>();
+        event.room_id                    = obj.at("room_id").get<std::string>();
+        event.session_id                 = obj.at("session_id").get<std::string>();
+        event.session_key                = obj.at("session_key").get<std::string>();
+        event.sender_key                 = obj.at("sender_key").get<std::string>();
+        event.sender_claimed_ed25519_key = obj.at("sender_claimed_ed25519_key").get<std::string>();
+        event.forwarding_curve25519_key_chain =
+          obj.at("forwarding_curve25519_key_chain").get<std::vector<std::string>>();
+}
+
+void
+to_json(json &obj, const ForwardedRoomKey &event)
+{
+        obj["algorithm"]                       = event.algorithm;
+        obj["room_id"]                         = event.room_id;
+        obj["session_id"]                      = event.session_id;
+        obj["session_key"]                     = event.session_key;
+        obj["sender_key"]                      = event.sender_key;
+        obj["sender_claimed_ed25519_key"]      = event.sender_claimed_ed25519_key;
+        obj["forwarding_curve25519_key_chain"] = event.forwarding_curve25519_key_chain;
+}
+
 void
 from_json(const json &obj, KeyRequest &event)
 {
@@ -321,6 +346,7 @@ from_json(const json &obj, KeyVerificationAccept &event)
         event.short_authentication_string =
           obj.at("short_authentication_string").get<std::vector<SASMethods>>();
         event.commitment = obj.at("commitment").get<std::string>();
+        event.method     = obj.value("method", VerificationMethods::SASv1);
         if (obj.count("m.relates_to") != 0)
                 event.relates_to = obj.at("m.relates_to").get<common::RelatesTo>();
 }
@@ -335,6 +361,7 @@ to_json(json &obj, const KeyVerificationAccept &event)
         obj["message_authentication_code"] = event.message_authentication_code;
         obj["short_authentication_string"] = event.short_authentication_string;
         obj["commitment"]                  = event.commitment;
+        obj["method"]                      = event.method;
         if (event.relates_to.has_value())
                 obj["m.relates_to"] = event.relates_to.value();
 }
@@ -345,8 +372,8 @@ from_json(const json &obj, KeyVerificationCancel &event)
         if (obj.count("transaction_id") != 0) {
                 event.transaction_id = obj.at("transaction_id").get<std::string>();
         }
-        event.reason = obj.at("reason").get<std::string>();
-        event.code   = obj.at("code").get<std::string>();
+        event.reason = obj.value("reason", "");
+        event.code   = obj.value("code", "");
         if (obj.count("m.relates_to") != 0)
                 event.relates_to = obj.at("m.relates_to").get<common::RelatesTo>();
 }

lib/structs/responses/common.cpp

@@ -118,6 +118,7 @@ parse_room_account_data_events(
                 case events::EventType::RoomHistoryVisibility:
                 case events::EventType::RoomJoinRules:
                 case events::EventType::RoomKey:
+                case events::EventType::ForwardedRoomKey:
                 case events::EventType::RoomKeyRequest:
                 case events::EventType::RoomMember:
                 case events::EventType::RoomMessage:
@@ -540,6 +541,7 @@ parse_timeline_events(const json &events,
                 case events::EventType::KeyVerificationRequest:
                 case events::EventType::RoomPinnedEvents:
                 case events::EventType::RoomKey:        // Not part of timeline or state
+                case events::EventType::ForwardedRoomKey: // Not part of timeline or state
                 case events::EventType::RoomKeyRequest: // Not part of the timeline
                 case events::EventType::Tag:            // Not part of the timeline or state
                 case events::EventType::Presence:       // Not part of the timeline or state
@@ -590,6 +592,15 @@ parse_device_events(const json &events,
 
                         break;
                 }
+                case events::EventType::ForwardedRoomKey: {
+                        try {
+                                container.emplace_back(events::DeviceEvent<ForwardedRoomKey>(e));
+                        } catch (json::exception &err) {
+                                log_error(err, e);
+                        }
+
+                        break;
+                }
                 case events::EventType::RoomKeyRequest: {
                         try {
                                 container.emplace_back(events::DeviceEvent<KeyRequest>(e));
@@ -807,6 +818,7 @@ parse_state_events(const json &events,
                 case events::EventType::Reaction:
                 case events::EventType::RoomEncrypted:  /* Does this need to be here? */
                 case events::EventType::RoomKey:        // Not part of timeline or state
+                case events::EventType::ForwardedRoomKey: // Not part of timeline or state
                 case events::EventType::RoomKeyRequest: // Not part of the timeline or state
                 case events::EventType::RoomMessage:
                 case events::EventType::RoomPinnedEvents:
@@ -959,6 +971,7 @@ parse_stripped_events(const json &events,
                 case events::EventType::RoomMessage:
                 case events::EventType::RoomRedaction:
                 case events::EventType::RoomKey:        // Not part of timeline or state
+                case events::EventType::ForwardedRoomKey: // Not part of timeline or state
                 case events::EventType::RoomKeyRequest: // Not part of the timeline or state
                 case events::EventType::RoomPinnedEvents:
                 case events::EventType::Tag:       // Not part of the timeline or state