Add sharing existing inbound sessions functionality on new room invites

Author: ariskotsomitopoulos

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXDecrypting.kt

@@ -21,6 +21,7 @@ import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
 import org.matrix.android.sdk.api.session.crypto.model.IncomingSecretShareRequest
 import org.matrix.android.sdk.api.session.crypto.model.MXEventDecryptionResult
 import org.matrix.android.sdk.api.session.events.model.Event
+import org.matrix.android.sdk.internal.crypto.MegolmSessionData
 import org.matrix.android.sdk.internal.crypto.keysbackup.DefaultKeysBackupService
 
 /**
@@ -60,6 +61,8 @@ internal interface IMXDecrypting {
      */
     fun shareKeysWithDevice(request: IncomingRoomKeyRequest) {}
 
+    fun shareKeysWithDevice(exportedKeys: MegolmSessionData?, deviceId: String, userId: String) {}
+
     fun shareSecretWithDevice(request: IncomingSecretShareRequest, secretValue: String) {}
 
     fun requestKeysForEvent(event: Event, withHeld: Boolean)

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt

@@ -37,6 +37,7 @@ import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldCo
 import org.matrix.android.sdk.api.session.events.model.toModel
 import org.matrix.android.sdk.internal.crypto.DeviceListManager
 import org.matrix.android.sdk.internal.crypto.MXOlmDevice
+import org.matrix.android.sdk.internal.crypto.MegolmSessionData
 import org.matrix.android.sdk.internal.crypto.OutgoingGossipingRequestManager
 import org.matrix.android.sdk.internal.crypto.actions.EnsureOlmSessionsForDevicesAction
 import org.matrix.android.sdk.internal.crypto.actions.MessageEncrypter
@@ -341,6 +342,46 @@ internal class MXMegolmDecryption(private val userId: String,
         return olmDevice.hasInboundSessionKeys(roomId, senderKey, sessionId)
     }
 
+    override fun shareKeysWithDevice(exportedKeys: MegolmSessionData?, deviceId: String, userId: String) {
+        exportedKeys ?: return
+        cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+            runCatching { deviceListManager.downloadKeys(listOf(userId), false) }
+                    .mapCatching {
+                        val deviceInfo = cryptoStore.getUserDevice(userId, deviceId)
+                        if (deviceInfo == null) {
+                            throw RuntimeException()
+                        } else {
+                            val devicesByUser = mapOf(userId to listOf(deviceInfo))
+                            val usersDeviceMap = ensureOlmSessionsForDevicesAction.handle(devicesByUser)
+                            val olmSessionResult = usersDeviceMap.getObject(userId, deviceId)
+                            if (olmSessionResult?.sessionId == null) {
+                                // no session with this device, probably because there
+                                // were no one-time keys.
+                                Timber.tag(loggerTag.value).e("no session with this device $deviceId, probably because there were no one-time keys.")
+                                return@mapCatching
+                            }
+                            Timber.tag(loggerTag.value).i("shareKeysWithDevice() : sharing session ${exportedKeys.sessionId} with device $userId:$deviceId")
+
+                            val payloadJson = mapOf(
+                                    "type" to EventType.FORWARDED_ROOM_KEY,
+                                    "content" to exportedKeys
+                            )
+
+                            val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
+                            val sendToDeviceMap = MXUsersDevicesMap<Any>()
+                            sendToDeviceMap.setObject(userId, deviceId, encodedPayload)
+                            Timber.tag(loggerTag.value).i("shareKeysWithDevice() : sending ${exportedKeys.sessionId} to $userId:$deviceId")
+                            val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
+                            try {
+                                sendToDeviceTask.execute(sendToDeviceParams)
+                            } catch (failure: Throwable) {
+                                Timber.tag(loggerTag.value).e(failure, "shareKeysWithDevice() : Failed to send ${exportedKeys.sessionId} to $userId:$deviceId")
+                            }
+                        }
+                    }
+        }
+    }
+
     override fun shareKeysWithDevice(request: IncomingRoomKeyRequest) {
         // sanity checks
         if (request.requestBody == null) {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/IMXCryptoStore.kt

@@ -67,6 +67,14 @@ internal interface IMXCryptoStore {
      */
     fun getInboundGroupSessions(): List<OlmInboundGroupSessionWrapper2>
 
+    /**
+     * Retrieve the known inbound group sessions for the specified room
+     *
+     * @param roomId The roomId that the sessions will be returned
+     * @return the list of all known group sessions, for the provided roomId
+     */
+    fun getInboundGroupSessions(roomId: String): List<OlmInboundGroupSessionWrapper2>
+
     /**
      * @return true to unilaterally blacklist all unverified devices.
      */

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/db/RealmCryptoStore.kt

@@ -814,6 +814,18 @@ internal class RealmCryptoStore @Inject constructor(
         }
     }
 
+    override fun getInboundGroupSessions(roomId: String): List<OlmInboundGroupSessionWrapper2> {
+        return doWithRealm(realmConfiguration) {
+            it.where<OlmInboundGroupSessionEntity>()
+                    .findAll()
+                    .mapNotNull { inboundGroupSessionEntity ->
+                        inboundGroupSessionEntity.getInboundGroupSession()
+                    }.filter { inboundSession ->
+                        inboundSession.roomId == roomId
+                    }
+        }
+    }
+
     override fun removeInboundGroupSession(sessionId: String, senderKey: String) {
         val key = OlmInboundGroupSessionEntity.createPrimaryKey(sessionId, senderKey)
 

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/membership/DefaultMembershipService.kt

@@ -23,6 +23,7 @@ import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.realm.Realm
 import io.realm.RealmQuery
+import org.matrix.android.sdk.api.session.crypto.CryptoService
 import org.matrix.android.sdk.api.session.identity.ThreePid
 import org.matrix.android.sdk.api.session.room.members.MembershipService
 import org.matrix.android.sdk.api.session.room.members.RoomMemberQueryParams
@@ -47,6 +48,7 @@ internal class DefaultMembershipService @AssistedInject constructor(
         private val inviteTask: InviteTask,
         private val inviteThreePidTask: InviteThreePidTask,
         private val membershipAdminTask: MembershipAdminTask,
+        private val cryptoService: CryptoService,
         @UserId
         private val userId: String,
         private val queryStringValueProcessor: QueryStringValueProcessor
@@ -127,6 +129,7 @@ internal class DefaultMembershipService @AssistedInject constructor(
     }
 
     override suspend fun invite(userId: String, reason: String?) {
+        cryptoService.sendSharedHistoryKeys(roomId, userId)
         val params = InviteTask.Params(roomId, userId, reason)
         inviteTask.execute(params)
     }