From 7e7a9533453c5de2e3b90b03333a24bb0d7a42f0 Mon Sep 17 00:00:00 2001
From: Valere <valeref@matrix.org>
Date: Thu, 22 Oct 2020 16:52:32 +0200
Subject: [PATCH] Crypto cleaning and perf improvement
---
.../crypto/CryptoSessionInfoProvider.kt | 61 ++++
.../internal/crypto/DefaultCryptoService.kt | 171 +++-------
.../sdk/internal/crypto/DeviceListManager.kt | 2 +-
.../sdk/internal/crypto/EventDecryptor.kt | 169 ++++++++++
.../crypto/InboundGroupSessionStore.kt | 96 ++++++
.../sdk/internal/crypto/MXOlmDevice.kt | 8 +-
.../crypto/OutgoingGossipingRequestManager.kt | 4 +-
.../DefaultCrossSigningService.kt | 123 +++++--
.../SessionToCryptoRoomMembersUpdate.kt | 26 --
.../crypto/crosssigning/ShieldTrustUpdater.kt | 126 -------
.../crypto/crosssigning/UpdateTrustWorker.kt | 318 ++++++++++++++++++
.../keysbackup/DefaultKeysBackupService.kt | 13 +-
.../internal/crypto/tasks/EncryptEventTask.kt | 11 +-
.../internal/crypto/tasks/SendEventTask.kt | 7 +-
.../tasks/SendVerificationMessageTask.kt | 13 +-
.../DefaultVerificationService.kt | 8 +-
.../SendVerificationMessageWorker.kt | 5 +-
.../VerificationMessageProcessor.kt | 6 +-
.../database/EventInsertLiveObserver.kt | 41 ++-
.../sdk/internal/session/DefaultSession.kt | 5 +-
.../sdk/internal/session/SessionComponent.kt | 3 +
.../sdk/internal/session/SessionModule.kt | 5 -
.../EventRelationsAggregationProcessor.kt | 8 +-
.../room/relation/DefaultRelationService.kt | 15 +-
.../session/room/send/DefaultSendService.kt | 8 +-
.../session/room/send/SendEventWorker.kt | 2 +-
.../room/send/queue/SendEventQueuedTask.kt | 2 +-
.../room/summary/RoomSummaryUpdater.kt | 34 +-
.../session/room/timeline/DefaultTimeline.kt | 2 +-
.../room/timeline/TimelineEventDecryptor.kt | 48 +--
.../internal/session/sync/RoomSyncHandler.kt | 10 +-
.../internal/session/sync/job/SyncThread.kt | 2 +-
32 files changed, 898 insertions(+), 454 deletions(-)
create mode 100644 matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CryptoSessionInfoProvider.kt
create mode 100644 matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/EventDecryptor.kt
create mode 100644 matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/InboundGroupSessionStore.kt
delete mode 100644 matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/SessionToCryptoRoomMembersUpdate.kt
delete mode 100644 matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/ShieldTrustUpdater.kt
create mode 100644 matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/UpdateTrustWorker.kt
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CryptoSessionInfoProvider.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CryptoSessionInfoProvider.kt
new file mode 100644
index 0000000000..68cc139521
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CryptoSessionInfoProvider.kt
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.crypto
+
+import com.zhuinden.monarchy.Monarchy
+import org.matrix.android.sdk.api.session.events.model.EventType
+import org.matrix.android.sdk.internal.database.model.EventEntity
+import org.matrix.android.sdk.internal.database.model.EventEntityFields
+import org.matrix.android.sdk.internal.database.query.whereType
+import org.matrix.android.sdk.internal.di.SessionDatabase
+import org.matrix.android.sdk.internal.session.room.membership.RoomMemberHelper
+import org.matrix.android.sdk.internal.util.fetchCopied
+import javax.inject.Inject
+
+/**
+ * The crypto module needs some information regarding rooms that are stored
+ * in the session DB, this class encapsulate this functionality
+ */
+class CryptoSessionInfoProvider @Inject constructor(
+ @SessionDatabase private val monarchy: Monarchy,
+) {
+
+ fun isRoomEncrypted(roomId: String): Boolean {
+ val encryptionEvent = monarchy.fetchCopied { realm ->
+ EventEntity.whereType(realm, roomId = roomId, type = EventType.STATE_ROOM_ENCRYPTION)
+ .contains(EventEntityFields.CONTENT, "\"algorithm\":\"$MXCRYPTO_ALGORITHM_MEGOLM\"")
+ .isNotNull(EventEntityFields.STATE_KEY) // should be an empty key
+ .findFirst()
+ }
+ return encryptionEvent != null
+ }
+
+ /**
+ * @param allActive if true return joined as well as invited, if false, only joined
+ */
+ fun getRoomUserIdsForCrypto(roomId: String, allActive: Boolean): List<String> {
+ var userIds: List<String> = emptyList()
+ monarchy.doWithRealm { realm ->
+ userIds = if (allActive) {
+ RoomMemberHelper(realm, roomId).getActiveRoomMemberIds()
+ } else {
+ RoomMemberHelper(realm, roomId).getJoinedRoomMemberIds()
+ }
+ }
+ return userIds
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
index b78afe6d41..0a18aba8ba 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
@@ -17,12 +17,9 @@
package org.matrix.android.sdk.internal.crypto
import android.content.Context
-import android.os.Handler
-import android.os.Looper
import androidx.annotation.VisibleForTesting
import androidx.lifecycle.LiveData
import com.squareup.moshi.Types
-import com.zhuinden.monarchy.Monarchy
import dagger.Lazy
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
@@ -51,9 +48,7 @@ import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibility
import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibilityContent
import org.matrix.android.sdk.api.session.room.model.RoomMemberContent
-import org.matrix.android.sdk.internal.crypto.actions.EnsureOlmSessionsForDevicesAction
import org.matrix.android.sdk.internal.crypto.actions.MegolmSessionDataImporter
-import org.matrix.android.sdk.internal.crypto.actions.MessageEncrypter
import org.matrix.android.sdk.internal.crypto.actions.SetDeviceVerificationAction
import org.matrix.android.sdk.internal.crypto.algorithms.IMXEncrypting
import org.matrix.android.sdk.internal.crypto.algorithms.IMXWithHeldExtension
@@ -68,7 +63,6 @@ import org.matrix.android.sdk.internal.crypto.model.MXDeviceInfo
import org.matrix.android.sdk.internal.crypto.model.MXEncryptEventContentResult
import org.matrix.android.sdk.internal.crypto.model.MXUsersDevicesMap
import org.matrix.android.sdk.internal.crypto.model.event.EncryptedEventContent
-import org.matrix.android.sdk.internal.crypto.model.event.OlmEventContent
import org.matrix.android.sdk.internal.crypto.model.event.RoomKeyContent
import org.matrix.android.sdk.internal.crypto.model.event.RoomKeyWithHeldContent
import org.matrix.android.sdk.internal.crypto.model.event.SecretSendEventContent
@@ -82,21 +76,15 @@ import org.matrix.android.sdk.internal.crypto.tasks.DeleteDeviceTask
import org.matrix.android.sdk.internal.crypto.tasks.DeleteDeviceWithUserPasswordTask
import org.matrix.android.sdk.internal.crypto.tasks.GetDeviceInfoTask
import org.matrix.android.sdk.internal.crypto.tasks.GetDevicesTask
-import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
import org.matrix.android.sdk.internal.crypto.tasks.SetDeviceNameTask
import org.matrix.android.sdk.internal.crypto.tasks.UploadKeysTask
import org.matrix.android.sdk.internal.crypto.verification.DefaultVerificationService
-import org.matrix.android.sdk.internal.database.model.EventEntity
-import org.matrix.android.sdk.internal.database.model.EventEntityFields
-import org.matrix.android.sdk.internal.database.query.whereType
import org.matrix.android.sdk.internal.di.DeviceId
import org.matrix.android.sdk.internal.di.MoshiProvider
-import org.matrix.android.sdk.internal.di.SessionDatabase
import org.matrix.android.sdk.internal.di.UserId
import org.matrix.android.sdk.internal.extensions.foldToCallback
import org.matrix.android.sdk.internal.session.SessionScope
import org.matrix.android.sdk.internal.session.room.membership.LoadRoomMembersTask
-import org.matrix.android.sdk.internal.session.room.membership.RoomMemberHelper
import org.matrix.android.sdk.internal.session.sync.model.SyncResponse
import org.matrix.android.sdk.internal.task.TaskExecutor
import org.matrix.android.sdk.internal.task.TaskThread
@@ -104,11 +92,11 @@ import org.matrix.android.sdk.internal.task.configureWith
import org.matrix.android.sdk.internal.task.launchToCallback
import org.matrix.android.sdk.internal.util.JsonCanonicalizer
import org.matrix.android.sdk.internal.util.MatrixCoroutineDispatchers
-import org.matrix.android.sdk.internal.util.fetchCopied
import org.matrix.olm.OlmManager
import timber.log.Timber
import java.util.concurrent.atomic.AtomicBoolean
import javax.inject.Inject
+import kotlin.jvm.Throws
import kotlin.math.max
/**
@@ -171,28 +159,16 @@ internal class DefaultCryptoService @Inject constructor(
private val setDeviceNameTask: SetDeviceNameTask,
private val uploadKeysTask: UploadKeysTask,
private val loadRoomMembersTask: LoadRoomMembersTask,
- @SessionDatabase private val monarchy: Monarchy,
+ private val cryptoSessionInfoProvider: CryptoSessionInfoProvider,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
private val taskExecutor: TaskExecutor,
private val cryptoCoroutineScope: CoroutineScope,
- private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction,
- private val sendToDeviceTask: SendToDeviceTask,
- private val messageEncrypter: MessageEncrypter
+ private val eventDecryptor: EventDecryptor
) : CryptoService {
- init {
- verificationService.cryptoService = this
- }
-
- private val uiHandler = Handler(Looper.getMainLooper())
-
private val isStarting = AtomicBoolean(false)
private val isStarted = AtomicBoolean(false)
- // The date of the last time we forced establishment
- // of a new session for each user:device.
- private val lastNewSessionForcedDates = MXUsersDevicesMap<Long>()
-
fun onStateEvent(roomId: String, event: Event) {
when (event.getClearType()) {
EventType.STATE_ROOM_ENCRYPTION -> onRoomEncryptionEvent(roomId, event)
@@ -612,13 +588,7 @@ internal class DefaultCryptoService @Inject constructor(
* @return true if the room is encrypted with algorithm MXCRYPTO_ALGORITHM_MEGOLM
*/
override fun isRoomEncrypted(roomId: String): Boolean {
- val encryptionEvent = monarchy.fetchCopied { realm ->
- EventEntity.whereType(realm, roomId = roomId, type = EventType.STATE_ROOM_ENCRYPTION)
- .contains(EventEntityFields.CONTENT, "\"algorithm\":\"$MXCRYPTO_ALGORITHM_MEGOLM\"")
- .isNotNull(EventEntityFields.STATE_KEY)
- .findFirst()
- }
- return encryptionEvent != null
+ return cryptoSessionInfoProvider.isRoomEncrypted(roomId)
}
/**
@@ -660,11 +630,8 @@ internal class DefaultCryptoService @Inject constructor(
eventType: String,
roomId: String,
callback: MatrixCallback<MXEncryptEventContentResult>) {
+ // moved to crypto scope to have uptodate values
cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
-// if (!isStarted()) {
-// Timber.v("## CRYPTO | encryptEventContent() : wait after e2e init")
-// internalStart(false)
-// }
val userIds = getRoomUserIds(roomId)
var alg = roomEncryptorsStore.get(roomId)
if (alg == null) {
@@ -720,14 +687,7 @@ internal class DefaultCryptoService @Inject constructor(
* @param callback the callback to return data or null
*/
override fun decryptEventAsync(event: Event, timeline: String, callback: MatrixCallback<MXEventDecryptionResult>) {
- cryptoCoroutineScope.launch {
- val result = runCatching {
- withContext(coroutineDispatchers.crypto) {
- internalDecryptEvent(event, timeline)
- }
- }
- result.foldToCallback(callback)
- }
+ eventDecryptor.decryptEventAsync(event, timeline, callback)
}
/**
@@ -739,42 +699,7 @@ internal class DefaultCryptoService @Inject constructor(
*/
@Throws(MXCryptoError::class)
private fun internalDecryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
- val eventContent = event.content
- if (eventContent == null) {
- Timber.e("## CRYPTO | decryptEvent : empty event content")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE, MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON)
- } else {
- val algorithm = eventContent["algorithm"]?.toString()
- val alg = roomDecryptorProvider.getOrCreateRoomDecryptor(event.roomId, algorithm)
- if (alg == null) {
- val reason = String.format(MXCryptoError.UNABLE_TO_DECRYPT_REASON, event.eventId, algorithm)
- Timber.e("## CRYPTO | decryptEvent() : $reason")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT, reason)
- } else {
- try {
- return alg.decryptEvent(event, timeline)
- } catch (mxCryptoError: MXCryptoError) {
- Timber.d("## CRYPTO | internalDecryptEvent : Failed to decrypt ${event.eventId} reason: $mxCryptoError")
- if (algorithm == MXCRYPTO_ALGORITHM_OLM) {
- if (mxCryptoError is MXCryptoError.Base
- && mxCryptoError.errorType == MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE) {
- // need to find sending device
- val olmContent = event.content.toModel<OlmEventContent>()
- cryptoStore.getUserDevices(event.senderId ?: "")
- ?.values
- ?.firstOrNull { it.identityKey() == olmContent?.senderKey }
- ?.let {
- markOlmSessionForUnwedging(event.senderId ?: "", it)
- }
- ?: run {
- Timber.v("## CRYPTO | markOlmSessionForUnwedging() : Failed to find sender crypto device")
- }
- }
- }
- throw mxCryptoError
- }
- }
- }
+ return eventDecryptor.decryptEvent(event, timeline)
}
/**
@@ -828,7 +753,7 @@ internal class DefaultCryptoService @Inject constructor(
*/
private fun onRoomKeyEvent(event: Event) {
val roomKeyContent = event.getClearContent().toModel<RoomKeyContent>() ?: return
- Timber.v("## CRYPTO | GOSSIP onRoomKeyEvent() : type<${event.type}> , sessionId<${roomKeyContent.sessionId}>")
+ Timber.v("## CRYPTO | GOSSIP onRoomKeyEvent() : type<${event.getClearType()}> , sessionId<${roomKeyContent.sessionId}>")
if (roomKeyContent.roomId.isNullOrEmpty() || roomKeyContent.algorithm.isNullOrEmpty()) {
Timber.e("## CRYPTO | GOSSIP onRoomKeyEvent() : missing fields")
return
@@ -935,19 +860,9 @@ internal class DefaultCryptoService @Inject constructor(
}
private fun getRoomUserIds(roomId: String): List<String> {
- var userIds: List<String> = emptyList()
- monarchy.doWithRealm { realm ->
- // Check whether the event content must be encrypted for the invited members.
- val encryptForInvitedMembers = isEncryptionEnabledForInvitedUser()
- && shouldEncryptForInvitedMembers(roomId)
-
- userIds = if (encryptForInvitedMembers) {
- RoomMemberHelper(realm, roomId).getActiveRoomMemberIds()
- } else {
- RoomMemberHelper(realm, roomId).getJoinedRoomMemberIds()
- }
- }
- return userIds
+ val encryptForInvitedMembers = isEncryptionEnabledForInvitedUser()
+ && shouldEncryptForInvitedMembers(roomId)
+ return cryptoSessionInfoProvider.getRoomUserIdsForCrypto(roomId, encryptForInvitedMembers)
}
/**
@@ -1257,38 +1172,38 @@ internal class DefaultCryptoService @Inject constructor(
incomingGossipingRequestManager.removeRoomKeysRequestListener(listener)
}
- private fun markOlmSessionForUnwedging(senderId: String, deviceInfo: CryptoDeviceInfo) {
- val deviceKey = deviceInfo.identityKey()
-
- val lastForcedDate = lastNewSessionForcedDates.getObject(senderId, deviceKey) ?: 0
- val now = System.currentTimeMillis()
- if (now - lastForcedDate < CRYPTO_MIN_FORCE_SESSION_PERIOD_MILLIS) {
- Timber.d("## CRYPTO | markOlmSessionForUnwedging: New session already forced with device at $lastForcedDate. Not forcing another")
- return
- }
-
- Timber.d("## CRYPTO | markOlmSessionForUnwedging from $senderId:${deviceInfo.deviceId}")
- lastNewSessionForcedDates.setObject(senderId, deviceKey, now)
-
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- ensureOlmSessionsForDevicesAction.handle(mapOf(senderId to listOf(deviceInfo)), force = true)
-
- // Now send a blank message on that session so the other side knows about it.
- // (The keyshare request is sent in the clear so that won't do)
- // We send this first such that, as long as the toDevice messages arrive in the
- // same order we sent them, the other end will get this first, set up the new session,
- // then get the keyshare request and send the key over this new session (because it
- // is the session it has most recently received a message on).
- val payloadJson = mapOf<String, Any>("type" to EventType.DUMMY)
-
- val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
- val sendToDeviceMap = MXUsersDevicesMap<Any>()
- sendToDeviceMap.setObject(senderId, deviceInfo.deviceId, encodedPayload)
- Timber.v("## CRYPTO | markOlmSessionForUnwedging() : sending to $senderId:${deviceInfo.deviceId}")
- val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
- sendToDeviceTask.execute(sendToDeviceParams)
- }
- }
+// private fun markOlmSessionForUnwedging(senderId: String, deviceInfo: CryptoDeviceInfo) {
+// val deviceKey = deviceInfo.identityKey()
+//
+// val lastForcedDate = lastNewSessionForcedDates.getObject(senderId, deviceKey) ?: 0
+// val now = System.currentTimeMillis()
+// if (now - lastForcedDate < CRYPTO_MIN_FORCE_SESSION_PERIOD_MILLIS) {
+// Timber.d("## CRYPTO | markOlmSessionForUnwedging: New session already forced with device at $lastForcedDate. Not forcing another")
+// return
+// }
+//
+// Timber.d("## CRYPTO | markOlmSessionForUnwedging from $senderId:${deviceInfo.deviceId}")
+// lastNewSessionForcedDates.setObject(senderId, deviceKey, now)
+//
+// cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+// ensureOlmSessionsForDevicesAction.handle(mapOf(senderId to listOf(deviceInfo)), force = true)
+//
+// // Now send a blank message on that session so the other side knows about it.
+// // (The keyshare request is sent in the clear so that won't do)
+// // We send this first such that, as long as the toDevice messages arrive in the
+// // same order we sent them, the other end will get this first, set up the new session,
+// // then get the keyshare request and send the key over this new session (because it
+// // is the session it has most recently received a message on).
+// val payloadJson = mapOf<String, Any>("type" to EventType.DUMMY)
+//
+// val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
+// val sendToDeviceMap = MXUsersDevicesMap<Any>()
+// sendToDeviceMap.setObject(senderId, deviceInfo.deviceId, encodedPayload)
+// Timber.v("## CRYPTO | markOlmSessionForUnwedging() : sending to $senderId:${deviceInfo.deviceId}")
+// val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
+// sendToDeviceTask.execute(sendToDeviceParams)
+// }
+// }
/**
* Provides the list of unknown devices
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DeviceListManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DeviceListManager.kt
index ab30d3052d..42df6b354b 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DeviceListManager.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DeviceListManager.kt
@@ -377,7 +377,7 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
}
// Update devices trust for these users
- dispatchDeviceChange(downloadUsers)
+ // dispatchDeviceChange(downloadUsers)
return onKeysDownloadSucceed(filteredUsers, response.failures)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/EventDecryptor.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/EventDecryptor.kt
new file mode 100644
index 0000000000..b423b5d738
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/EventDecryptor.kt
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.crypto
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.matrix.android.sdk.api.MatrixCallback
+import org.matrix.android.sdk.api.session.crypto.MXCryptoError
+import org.matrix.android.sdk.api.session.events.model.Event
+import org.matrix.android.sdk.api.session.events.model.EventType
+import org.matrix.android.sdk.api.session.events.model.toModel
+import org.matrix.android.sdk.internal.crypto.actions.EnsureOlmSessionsForDevicesAction
+import org.matrix.android.sdk.internal.crypto.actions.MessageEncrypter
+import org.matrix.android.sdk.internal.crypto.model.CryptoDeviceInfo
+import org.matrix.android.sdk.internal.crypto.model.MXUsersDevicesMap
+import org.matrix.android.sdk.internal.crypto.model.event.OlmEventContent
+import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
+import org.matrix.android.sdk.internal.extensions.foldToCallback
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.util.MatrixCoroutineDispatchers
+import timber.log.Timber
+import javax.inject.Inject
+import kotlin.jvm.Throws
+
+@SessionScope
+internal class EventDecryptor @Inject constructor(
+ private val cryptoCoroutineScope: CoroutineScope,
+ private val coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val roomDecryptorProvider: RoomDecryptorProvider,
+ private val messageEncrypter: MessageEncrypter,
+ private val sendToDeviceTask: SendToDeviceTask,
+ private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction,
+ private val cryptoStore: IMXCryptoStore
+) {
+
+ // The date of the last time we forced establishment
+ // of a new session for each user:device.
+ private val lastNewSessionForcedDates = MXUsersDevicesMap<Long>()
+
+ /**
+ * Decrypt an event
+ *
+ * @param event the raw event.
+ * @param timeline the id of the timeline where the event is decrypted. It is used to prevent replay attack.
+ * @return the MXEventDecryptionResult data, or throw in case of error
+ */
+ @Throws(MXCryptoError::class)
+ fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
+ return internalDecryptEvent(event, timeline)
+ }
+
+ /**
+ * Decrypt an event asynchronously
+ *
+ * @param event the raw event.
+ * @param timeline the id of the timeline where the event is decrypted. It is used to prevent replay attack.
+ * @param callback the callback to return data or null
+ */
+ fun decryptEventAsync(event: Event, timeline: String, callback: MatrixCallback<MXEventDecryptionResult>) {
+ // is it needed to do that on the crypto scope??
+ cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ runCatching {
+ internalDecryptEvent(event, timeline)
+ }.foldToCallback(callback)
+ }
+ }
+
+ /**
+ * Decrypt an event
+ *
+ * @param event the raw event.
+ * @param timeline the id of the timeline where the event is decrypted. It is used to prevent replay attack.
+ * @return the MXEventDecryptionResult data, or null in case of error
+ */
+ @Throws(MXCryptoError::class)
+ private fun internalDecryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
+ val eventContent = event.content
+ if (eventContent == null) {
+ Timber.e("## CRYPTO | decryptEvent : empty event content")
+ throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE, MXCryptoError.BAD_ENCRYPTED_MESSAGE_REASON)
+ } else {
+ val algorithm = eventContent["algorithm"]?.toString()
+ val alg = roomDecryptorProvider.getOrCreateRoomDecryptor(event.roomId, algorithm)
+ if (alg == null) {
+ val reason = String.format(MXCryptoError.UNABLE_TO_DECRYPT_REASON, event.eventId, algorithm)
+ Timber.e("## CRYPTO | decryptEvent() : $reason")
+ throw MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT, reason)
+ } else {
+ try {
+ return alg.decryptEvent(event, timeline)
+ } catch (mxCryptoError: MXCryptoError) {
+ Timber.d("## CRYPTO | internalDecryptEvent : Failed to decrypt ${event.eventId} reason: $mxCryptoError")
+ if (algorithm == MXCRYPTO_ALGORITHM_OLM) {
+ if (mxCryptoError is MXCryptoError.Base
+ && mxCryptoError.errorType == MXCryptoError.ErrorType.BAD_ENCRYPTED_MESSAGE) {
+ // need to find sending device
+ cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ val olmContent = event.content.toModel<OlmEventContent>()
+ cryptoStore.getUserDevices(event.senderId ?: "")
+ ?.values
+ ?.firstOrNull { it.identityKey() == olmContent?.senderKey }
+ ?.let {
+ markOlmSessionForUnwedging(event.senderId ?: "", it)
+ }
+ ?: run {
+ Timber.v("## CRYPTO | markOlmSessionForUnwedging() : Failed to find sender crypto device")
+ }
+ }
+ }
+ }
+ throw mxCryptoError
+ }
+ }
+ }
+ }
+
+ // coroutineDispatchers.crypto scope
+ private fun markOlmSessionForUnwedging(senderId: String, deviceInfo: CryptoDeviceInfo) {
+ val deviceKey = deviceInfo.identityKey()
+
+ val lastForcedDate = lastNewSessionForcedDates.getObject(senderId, deviceKey) ?: 0
+ val now = System.currentTimeMillis()
+ if (now - lastForcedDate < DefaultCryptoService.CRYPTO_MIN_FORCE_SESSION_PERIOD_MILLIS) {
+ Timber.d("## CRYPTO | markOlmSessionForUnwedging: New session already forced with device at $lastForcedDate. Not forcing another")
+ return
+ }
+
+ Timber.d("## CRYPTO | markOlmSessionForUnwedging from $senderId:${deviceInfo.deviceId}")
+ lastNewSessionForcedDates.setObject(senderId, deviceKey, now)
+
+ // offload this from crypto thread (?)
+ cryptoCoroutineScope.launch(coroutineDispatchers.computation) {
+ ensureOlmSessionsForDevicesAction.handle(mapOf(senderId to listOf(deviceInfo)), force = true)
+
+ // Now send a blank message on that session so the other side knows about it.
+ // (The keyshare request is sent in the clear so that won't do)
+ // We send this first such that, as long as the toDevice messages arrive in the
+ // same order we sent them, the other end will get this first, set up the new session,
+ // then get the keyshare request and send the key over this new session (because it
+ // is the session it has most recently received a message on).
+ val payloadJson = mapOf<String, Any>("type" to EventType.DUMMY)
+
+ val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
+ val sendToDeviceMap = MXUsersDevicesMap<Any>()
+ sendToDeviceMap.setObject(senderId, deviceInfo.deviceId, encodedPayload)
+ Timber.v("## CRYPTO | markOlmSessionForUnwedging() : sending to $senderId:${deviceInfo.deviceId}")
+ withContext(coroutineDispatchers.io) {
+ val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
+ sendToDeviceTask.execute(sendToDeviceParams)
+ }
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/InboundGroupSessionStore.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/InboundGroupSessionStore.kt
new file mode 100644
index 0000000000..722fc0d92d
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/InboundGroupSessionStore.kt
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.crypto
+
+import android.util.LruCache
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import org.matrix.android.sdk.internal.crypto.model.OlmInboundGroupSessionWrapper2
+import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.util.MatrixCoroutineDispatchers
+import timber.log.Timber
+import java.util.Timer
+import java.util.TimerTask
+import javax.inject.Inject
+
+/**
+ * Allows to cache and batch store operations on inbound group session store.
+ * Because it is used in the decrypt flow, that can be called quite rapidly
+ */
+internal class InboundGroupSessionStore @Inject constructor(
+ private val store: IMXCryptoStore,
+ private val cryptoCoroutineScope: CoroutineScope,
+ private val coroutineDispatchers: MatrixCoroutineDispatchers) {
+
+ private data class CacheKey(
+ val sessionId: String,
+ val senderKey: String
+ )
+
+ private val sessionCache = object : LruCache<CacheKey, OlmInboundGroupSessionWrapper2>(30) {
+ override fun entryRemoved(evicted: Boolean, key: CacheKey?, oldValue: OlmInboundGroupSessionWrapper2?, newValue: OlmInboundGroupSessionWrapper2?) {
+ if (evicted && oldValue != null) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ Timber.v("## Inbound: entryRemoved ${oldValue.roomId}-${oldValue.senderKey}")
+ store.storeInboundGroupSessions(listOf(oldValue))
+ }
+ }
+ }
+ }
+
+ private val timer = Timer()
+ private var timerTask: TimerTask? = null
+
+ private val dirtySession = mutableListOf<OlmInboundGroupSessionWrapper2>()
+
+ @Synchronized
+ fun getInboundGroupSession(sessionId: String, senderKey: String): OlmInboundGroupSessionWrapper2? {
+ synchronized(sessionCache) {
+ val known = sessionCache[CacheKey(sessionId, senderKey)]
+ Timber.v("## Inbound: getInboundGroupSession in cache ${known != null}")
+ return known ?: store.getInboundGroupSession(sessionId, senderKey)?.also {
+ Timber.v("## Inbound: getInboundGroupSession cache populate ${it.roomId}")
+ sessionCache.put(CacheKey(sessionId, senderKey), it)
+ }
+ }
+ }
+
+ @Synchronized
+ fun storeInBoundGroupSession(wrapper: OlmInboundGroupSessionWrapper2) {
+ Timber.v("## Inbound: getInboundGroupSession mark as dirty ${wrapper.roomId}-${wrapper.senderKey}")
+ // We want to batch this a bit for performances
+ dirtySession.add(wrapper)
+
+ timerTask?.cancel()
+ timerTask = object : TimerTask() {
+ override fun run() {
+ batchSave()
+ }
+ }
+ timer.schedule(timerTask!!, 2_000)
+ }
+
+ @Synchronized
+ private fun batchSave() {
+ val toSave = mutableListOf<OlmInboundGroupSessionWrapper2>().apply { addAll(dirtySession) }
+ dirtySession.clear()
+ cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ Timber.v("## Inbound: getInboundGroupSession batching save of ${dirtySession.size}")
+ store.storeInboundGroupSessions(toSave)
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXOlmDevice.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXOlmDevice.kt
index 7a546993b8..1a4d1136c8 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXOlmDevice.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXOlmDevice.kt
@@ -44,7 +44,9 @@ internal class MXOlmDevice @Inject constructor(
/**
* The store where crypto data is saved.
*/
- private val store: IMXCryptoStore) {
+ private val store: IMXCryptoStore,
+ private val inboundGroupSessionStore: InboundGroupSessionStore
+ ) {
/**
* @return the Curve25519 key for the account.
@@ -657,7 +659,7 @@ internal class MXOlmDevice @Inject constructor(
timelineSet.add(messageIndexKey)
}
- store.storeInboundGroupSessions(listOf(session))
+ inboundGroupSessionStore.storeInBoundGroupSession(session)
val payload = try {
val adapter = MoshiProvider.providesMoshi().adapter<JsonDict>(JSON_DICT_PARAMETERIZED_TYPE)
val payloadString = convertFromUTF8(decryptResult.mDecryptedMessage)
@@ -745,7 +747,7 @@ internal class MXOlmDevice @Inject constructor(
throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_SENDER_KEY, MXCryptoError.ERROR_MISSING_PROPERTY_REASON)
}
- val session = store.getInboundGroupSession(sessionId, senderKey)
+ val session = inboundGroupSessionStore.getInboundGroupSession(sessionId, senderKey)
if (session != null) {
// Check that the room id matches the original one for the session. This stops
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequestManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequestManager.kt
index efda663230..c86f2be0a3 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequestManager.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequestManager.kt
@@ -88,7 +88,7 @@ internal class OutgoingGossipingRequestManager @Inject constructor(
* @param requestBody requestBody
*/
fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody) {
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.computation) {
cancelRoomKeyRequest(requestBody, false)
}
}
@@ -99,7 +99,7 @@ internal class OutgoingGossipingRequestManager @Inject constructor(
* @param requestBody requestBody
*/
fun resendRoomKeyRequest(requestBody: RoomKeyRequestBody) {
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.computation) {
cancelRoomKeyRequest(requestBody, true)
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/DefaultCrossSigningService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/DefaultCrossSigningService.kt
index b5056a0efd..1871dba0e2 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/DefaultCrossSigningService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/DefaultCrossSigningService.kt
@@ -17,6 +17,8 @@
package org.matrix.android.sdk.internal.crypto.crosssigning
import androidx.lifecycle.LiveData
+import androidx.work.BackoffPolicy
+import androidx.work.ExistingWorkPolicy
import org.matrix.android.sdk.api.MatrixCallback
import org.matrix.android.sdk.api.extensions.orFalse
import org.matrix.android.sdk.api.session.crypto.crosssigning.CrossSigningService
@@ -39,15 +41,20 @@ import org.matrix.android.sdk.internal.util.MatrixCoroutineDispatchers
import org.matrix.android.sdk.internal.util.withoutPrefix
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
-import org.greenrobot.eventbus.EventBus
+import org.matrix.android.sdk.internal.crypto.model.CryptoDeviceInfo
+import org.matrix.android.sdk.internal.di.SessionId
+import org.matrix.android.sdk.internal.di.WorkManagerProvider
+import org.matrix.android.sdk.internal.worker.WorkerParamsFactory
import org.matrix.olm.OlmPkSigning
import org.matrix.olm.OlmUtility
import timber.log.Timber
+import java.util.concurrent.TimeUnit
import javax.inject.Inject
@SessionScope
internal class DefaultCrossSigningService @Inject constructor(
@UserId private val userId: String,
+ @SessionId private val sessionId: String,
private val cryptoStore: IMXCryptoStore,
private val deviceListManager: DeviceListManager,
private val initializeCrossSigningTask: InitializeCrossSigningTask,
@@ -55,7 +62,7 @@ internal class DefaultCrossSigningService @Inject constructor(
private val taskExecutor: TaskExecutor,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
private val cryptoCoroutineScope: CoroutineScope,
- private val eventBus: EventBus) : CrossSigningService, DeviceListManager.UserDevicesUpdateListener {
+ private val workManagerProvider: WorkManagerProvider) : CrossSigningService, DeviceListManager.UserDevicesUpdateListener {
private var olmUtility: OlmUtility? = null
@@ -360,6 +367,12 @@ internal class DefaultCrossSigningService @Inject constructor(
// First let's get my user key
val myCrossSigningInfo = cryptoStore.getCrossSigningInfo(userId)
+ checkOtherMSKTrusted(myCrossSigningInfo, cryptoStore.getCrossSigningInfo(otherUserId))
+
+ return UserTrustResult.Success
+ }
+
+ fun checkOtherMSKTrusted(myCrossSigningInfo: MXCrossSigningInfo?, otherInfo: MXCrossSigningInfo?): UserTrustResult {
val myUserKey = myCrossSigningInfo?.userKey()
?: return UserTrustResult.CrossSigningNotConfigured(userId)
@@ -368,15 +381,15 @@ internal class DefaultCrossSigningService @Inject constructor(
}
// Let's get the other user master key
- val otherMasterKey = cryptoStore.getCrossSigningInfo(otherUserId)?.masterKey()
- ?: return UserTrustResult.UnknownCrossSignatureInfo(otherUserId)
+ val otherMasterKey = otherInfo?.masterKey()
+ ?: return UserTrustResult.UnknownCrossSignatureInfo(otherInfo?.userId ?: "")
val masterKeySignaturesMadeByMyUserKey = otherMasterKey.signatures
?.get(userId) // Signatures made by me
?.get("ed25519:${myUserKey.unpaddedBase64PublicKey}")
if (masterKeySignaturesMadeByMyUserKey.isNullOrBlank()) {
- Timber.d("## CrossSigning checkUserTrust false for $otherUserId, not signed by my UserSigningKey")
+ Timber.d("## CrossSigning checkUserTrust false for ${otherInfo.userId}, not signed by my UserSigningKey")
return UserTrustResult.KeyNotSigned(otherMasterKey)
}
@@ -396,6 +409,15 @@ internal class DefaultCrossSigningService @Inject constructor(
// and that MSK is trusted (i know the private key, or is signed by a trusted device)
val myCrossSigningInfo = cryptoStore.getCrossSigningInfo(userId)
+ return checkSelfTrust(myCrossSigningInfo, cryptoStore.getUserDeviceList(userId))
+ }
+
+ fun checkSelfTrust(myCrossSigningInfo: MXCrossSigningInfo?, myDevices: List<CryptoDeviceInfo>?): UserTrustResult {
+ // Special case when it's me,
+ // I have to check that MSK -> USK -> SSK
+ // and that MSK is trusted (i know the private key, or is signed by a trusted device)
+// val myCrossSigningInfo = cryptoStore.getCrossSigningInfo(userId)
+
val myMasterKey = myCrossSigningInfo?.masterKey()
?: return UserTrustResult.CrossSigningNotConfigured(userId)
@@ -423,7 +445,7 @@ internal class DefaultCrossSigningService @Inject constructor(
// Maybe it's signed by a locally trusted device?
myMasterKey.signatures?.get(userId)?.forEach { (key, value) ->
val potentialDeviceId = key.withoutPrefix("ed25519:")
- val potentialDevice = cryptoStore.getUserDevice(userId, potentialDeviceId)
+ val potentialDevice = myDevices?.firstOrNull { it.deviceId == potentialDeviceId } // cryptoStore.getUserDevice(userId, potentialDeviceId)
if (potentialDevice != null && potentialDevice.isVerified) {
// Check signature validity?
try {
@@ -561,6 +583,8 @@ internal class DefaultCrossSigningService @Inject constructor(
cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
cryptoStore.markMyMasterKeyAsLocallyTrusted(true)
checkSelfTrust()
+ // re-verify all trusts
+ onUsersDeviceUpdate(listOf(userId))
}
}
@@ -666,6 +690,55 @@ internal class DefaultCrossSigningService @Inject constructor(
return DeviceTrustResult.Success(DeviceTrustLevel(crossSigningVerified = true, locallyVerified = locallyTrusted))
}
+ fun checkDeviceTrust(myKeys: MXCrossSigningInfo?, otherKeys: MXCrossSigningInfo?, otherDevice: CryptoDeviceInfo) : DeviceTrustResult {
+ val locallyTrusted = otherDevice.trustLevel?.isLocallyVerified()
+ myKeys ?: return legacyFallbackTrust(locallyTrusted, DeviceTrustResult.CrossSigningNotConfigured(userId))
+
+ if (!myKeys.isTrusted()) return legacyFallbackTrust(locallyTrusted, DeviceTrustResult.KeysNotTrusted(myKeys))
+
+ otherKeys ?: return legacyFallbackTrust(locallyTrusted, DeviceTrustResult.CrossSigningNotConfigured(otherDevice.userId))
+
+ // TODO should we force verification ?
+ if (!otherKeys.isTrusted()) return legacyFallbackTrust(locallyTrusted, DeviceTrustResult.KeysNotTrusted(otherKeys))
+
+ // Check if the trust chain is valid
+ /*
+ * ┏━━━━━━━━┓ ┏━━━━━━━━┓
+ * ┃ ALICE ┃ ┃ BOB ┃
+ * ┗━━━━━━━━┛ ┗━━━━━━━━┛
+ * MSK ┌────────────▶MSK
+ * │
+ * │ │ │
+ * │ SSK │ └──▶ SSK ──────────────────┐
+ * │ │ │
+ * │ │ USK │
+ * └──▶ USK ────────────┘ (not visible by │
+ * Alice) │
+ * ▼
+ * ┌──────────────┐
+ * │ BOB's Device │
+ * └──────────────┘
+ */
+
+ val otherSSKSignature = otherDevice.signatures?.get(otherKeys.userId)?.get("ed25519:${otherKeys.selfSigningKey()?.unpaddedBase64PublicKey}")
+ ?: return legacyFallbackTrust(
+ locallyTrusted,
+ DeviceTrustResult.MissingDeviceSignature(otherDevice.deviceId, otherKeys.selfSigningKey()
+ ?.unpaddedBase64PublicKey
+ ?: ""
+ )
+ )
+
+ // Check bob's device is signed by bob's SSK
+ try {
+ olmUtility!!.verifyEd25519Signature(otherSSKSignature, otherKeys.selfSigningKey()?.unpaddedBase64PublicKey, otherDevice.canonicalSignable())
+ } catch (e: Throwable) {
+ return legacyFallbackTrust(locallyTrusted, DeviceTrustResult.InvalidDeviceSignature(otherDevice.deviceId, otherSSKSignature, e))
+ }
+
+ return DeviceTrustResult.Success(DeviceTrustLevel(crossSigningVerified = true, locallyVerified = locallyTrusted))
+ }
+
private fun legacyFallbackTrust(locallyTrusted: Boolean?, crossSignTrustFail: DeviceTrustResult): DeviceTrustResult {
return if (locallyTrusted == true) {
DeviceTrustResult.Success(DeviceTrustLevel(crossSigningVerified = false, locallyVerified = true))
@@ -675,36 +748,18 @@ internal class DefaultCrossSigningService @Inject constructor(
}
override fun onUsersDeviceUpdate(userIds: List<String>) {
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- Timber.d("## CrossSigning - onUsersDeviceUpdate for ${userIds.size} users")
- userIds.forEach { otherUserId ->
- checkUserTrust(otherUserId).let {
- Timber.v("## CrossSigning - update trust for $otherUserId , verified=${it.isVerified()}")
- setUserKeysAsTrusted(otherUserId, it.isVerified())
- }
- }
- }
+ Timber.d("## CrossSigning - onUsersDeviceUpdate for $userIds")
+ val workerParams = UpdateTrustWorker.Params(sessionId = sessionId, updatedUserIds = userIds)
+ val workerData = WorkerParamsFactory.toData(workerParams)
- // now check device trust
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- userIds.forEach { otherUserId ->
- // TODO if my keys have changes, i should recheck all devices of all users?
- val devices = cryptoStore.getUserDeviceList(otherUserId)
- devices?.forEach { device ->
- val updatedTrust = checkDeviceTrust(otherUserId, device.deviceId, device.trustLevel?.isLocallyVerified() ?: false)
- Timber.v("## CrossSigning - update trust for device ${device.deviceId} of user $otherUserId , verified=$updatedTrust")
- cryptoStore.setDeviceTrust(otherUserId, device.deviceId, updatedTrust.isCrossSignedVerified(), updatedTrust.isLocallyVerified())
- }
+ val workRequest = workManagerProvider.matrixOneTimeWorkRequestBuilder<UpdateTrustWorker>()
+ .setInputData(workerData)
+ .setBackoffCriteria(BackoffPolicy.LINEAR, 2_000L, TimeUnit.MILLISECONDS)
+ .build()
- if (otherUserId == userId) {
- // It's me, i should check if a newly trusted device is signing my master key
- // In this case it will change my MSK trust, and should then re-trigger a check of all other user trust
- setUserKeysAsTrusted(otherUserId, checkSelfTrust().isVerified())
- }
- }
-
- eventBus.post(CryptoToSessionUserTrustChange(userIds))
- }
+ workManagerProvider.workManager
+ .beginUniqueWork("TRUST_UPDATE_QUEUE", ExistingWorkPolicy.APPEND_OR_REPLACE, workRequest)
+ .enqueue()
}
private fun setUserKeysAsTrusted(otherUserId: String, trusted: Boolean) {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/SessionToCryptoRoomMembersUpdate.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/SessionToCryptoRoomMembersUpdate.kt
deleted file mode 100644
index 271b9e52d3..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/SessionToCryptoRoomMembersUpdate.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright 2020 The Matrix.org Foundation C.I.C.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.matrix.android.sdk.internal.crypto.crosssigning
-
-data class SessionToCryptoRoomMembersUpdate(
- val roomId: String,
- val isDirect: Boolean,
- val userIds: List<String>
-)
-
-data class CryptoToSessionUserTrustChange(
- val userIds: List<String>
-)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/ShieldTrustUpdater.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/ShieldTrustUpdater.kt
deleted file mode 100644
index 05ceba5965..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/ShieldTrustUpdater.kt
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright 2020 The Matrix.org Foundation C.I.C.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.matrix.android.sdk.internal.crypto.crosssigning
-
-import org.matrix.android.sdk.api.extensions.orFalse
-import org.matrix.android.sdk.internal.database.model.RoomMemberSummaryEntity
-import org.matrix.android.sdk.internal.database.model.RoomMemberSummaryEntityFields
-import org.matrix.android.sdk.internal.database.model.RoomSummaryEntity
-import org.matrix.android.sdk.internal.database.query.where
-import org.matrix.android.sdk.internal.di.SessionDatabase
-import org.matrix.android.sdk.internal.session.SessionLifecycleObserver
-import org.matrix.android.sdk.internal.session.room.summary.RoomSummaryUpdater
-import org.matrix.android.sdk.internal.session.room.membership.RoomMemberHelper
-import org.matrix.android.sdk.internal.task.TaskExecutor
-import org.matrix.android.sdk.internal.util.createBackgroundHandler
-import io.realm.Realm
-import io.realm.RealmConfiguration
-import kotlinx.coroutines.android.asCoroutineDispatcher
-import kotlinx.coroutines.launch
-import org.greenrobot.eventbus.EventBus
-import org.greenrobot.eventbus.Subscribe
-import timber.log.Timber
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicReference
-import javax.inject.Inject
-
-internal class ShieldTrustUpdater @Inject constructor(
- private val eventBus: EventBus,
- private val computeTrustTask: ComputeTrustTask,
- private val taskExecutor: TaskExecutor,
- @SessionDatabase private val sessionRealmConfiguration: RealmConfiguration,
- private val roomSummaryUpdater: RoomSummaryUpdater
-) : SessionLifecycleObserver {
-
- companion object {
- private val BACKGROUND_HANDLER = createBackgroundHandler("SHIELD_CRYPTO_DB_THREAD")
- private val BACKGROUND_HANDLER_DISPATCHER = BACKGROUND_HANDLER.asCoroutineDispatcher()
- }
-
- private val backgroundSessionRealm = AtomicReference<Realm>()
-
- private val isStarted = AtomicBoolean()
-
- override fun onStart() {
- if (isStarted.compareAndSet(false, true)) {
- eventBus.register(this)
- BACKGROUND_HANDLER.post {
- backgroundSessionRealm.set(Realm.getInstance(sessionRealmConfiguration))
- }
- }
- }
-
- override fun onStop() {
- if (isStarted.compareAndSet(true, false)) {
- eventBus.unregister(this)
- BACKGROUND_HANDLER.post {
- backgroundSessionRealm.getAndSet(null).also {
- it?.close()
- }
- }
- }
- }
-
- @Subscribe
- fun onRoomMemberChange(update: SessionToCryptoRoomMembersUpdate) {
- if (!isStarted.get()) {
- return
- }
- taskExecutor.executorScope.launch(BACKGROUND_HANDLER_DISPATCHER) {
- val updatedTrust = computeTrustTask.execute(ComputeTrustTask.Params(update.userIds, update.isDirect))
- // We need to send that back to session base
- backgroundSessionRealm.get()?.executeTransaction { realm ->
- roomSummaryUpdater.updateShieldTrust(realm, update.roomId, updatedTrust)
- }
- }
- }
-
- @Subscribe
- fun onTrustUpdate(update: CryptoToSessionUserTrustChange) {
- if (!isStarted.get()) {
- return
- }
- onCryptoDevicesChange(update.userIds)
- }
-
- private fun onCryptoDevicesChange(users: List<String>) {
- taskExecutor.executorScope.launch(BACKGROUND_HANDLER_DISPATCHER) {
- val realm = backgroundSessionRealm.get() ?: return@launch
- val distinctRoomIds = realm.where(RoomMemberSummaryEntity::class.java)
- .`in`(RoomMemberSummaryEntityFields.USER_ID, users.toTypedArray())
- .distinct(RoomMemberSummaryEntityFields.ROOM_ID)
- .findAll()
- .map { it.roomId }
-
- distinctRoomIds.forEach { roomId ->
- val roomSummary = RoomSummaryEntity.where(realm, roomId).findFirst()
- if (roomSummary?.isEncrypted.orFalse()) {
- val allActiveRoomMembers = RoomMemberHelper(realm, roomId).getActiveRoomMemberIds()
- try {
- val updatedTrust = computeTrustTask.execute(
- ComputeTrustTask.Params(allActiveRoomMembers, roomSummary?.isDirect == true)
- )
- realm.executeTransaction {
- roomSummaryUpdater.updateShieldTrust(it, roomId, updatedTrust)
- }
- } catch (failure: Throwable) {
- Timber.e(failure)
- }
- }
- }
- }
- }
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/UpdateTrustWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/UpdateTrustWorker.kt
new file mode 100644
index 0000000000..e3ac387ddc
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/crosssigning/UpdateTrustWorker.kt
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2020 The Matrix.org Foundation C.I.C.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.crypto.crosssigning
+
+import android.content.Context
+import androidx.work.WorkerParameters
+import com.squareup.moshi.JsonClass
+import io.realm.Realm
+import io.realm.RealmConfiguration
+import io.realm.kotlin.where
+import org.matrix.android.sdk.api.crypto.RoomEncryptionTrustLevel
+import org.matrix.android.sdk.api.extensions.orFalse
+import org.matrix.android.sdk.api.session.crypto.crosssigning.MXCrossSigningInfo
+import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.crypto.store.db.mapper.CrossSigningKeysMapper
+import org.matrix.android.sdk.internal.crypto.store.db.model.CrossSigningInfoEntity
+import org.matrix.android.sdk.internal.crypto.store.db.model.CrossSigningInfoEntityFields
+import org.matrix.android.sdk.internal.crypto.store.db.model.CryptoMapper
+import org.matrix.android.sdk.internal.crypto.store.db.model.TrustLevelEntity
+import org.matrix.android.sdk.internal.crypto.store.db.model.UserEntity
+import org.matrix.android.sdk.internal.crypto.store.db.model.UserEntityFields
+import org.matrix.android.sdk.internal.database.model.RoomMemberSummaryEntity
+import org.matrix.android.sdk.internal.database.model.RoomMemberSummaryEntityFields
+import org.matrix.android.sdk.internal.database.model.RoomSummaryEntity
+import org.matrix.android.sdk.internal.database.query.where
+import org.matrix.android.sdk.internal.di.CryptoDatabase
+import org.matrix.android.sdk.internal.di.SessionDatabase
+import org.matrix.android.sdk.internal.di.UserId
+import org.matrix.android.sdk.internal.session.SessionComponent
+import org.matrix.android.sdk.internal.session.room.membership.RoomMemberHelper
+import org.matrix.android.sdk.internal.worker.SessionSafeCoroutineWorker
+import org.matrix.android.sdk.internal.worker.SessionWorkerParams
+import timber.log.Timber
+import javax.inject.Inject
+
+internal class UpdateTrustWorker(context: Context,
+ params: WorkerParameters)
+ : SessionSafeCoroutineWorker<UpdateTrustWorker.Params>(context, params, Params::class.java) {
+
+ @JsonClass(generateAdapter = true)
+ internal data class Params(
+ override val sessionId: String,
+ override val lastFailureMessage: String? = null,
+ val updatedUserIds: List<String>
+ ) : SessionWorkerParams
+
+ @Inject lateinit var crossSigningService: DefaultCrossSigningService
+
+ // It breaks the crypto store contract, but we need to batch things :/
+ @CryptoDatabase @Inject lateinit var realmConfiguration: RealmConfiguration
+ @UserId @Inject lateinit var myUserId: String
+ @Inject lateinit var crossSigningKeysMapper: CrossSigningKeysMapper
+ @SessionDatabase @Inject lateinit var sessionRealmConfiguration: RealmConfiguration
+
+ // @Inject lateinit var roomSummaryUpdater: RoomSummaryUpdater
+ @Inject lateinit var cryptoStore: IMXCryptoStore
+
+ override fun injectWith(injector: SessionComponent) {
+ injector.inject(this)
+ }
+
+ override suspend fun doSafeWork(params: Params): Result {
+ var userList = params.updatedUserIds
+ // Unfortunately we don't have much info on what did exactly changed (is it the cross signing keys of that user,
+ // or a new device?) So we check all again :/
+
+ Timber.d("## CrossSigning - Updating trust for $userList")
+
+ // First we check that the users MSK are trusted by mine
+ // After that we check the trust chain for each devices of each users
+ Realm.getInstance(realmConfiguration).use { realm ->
+ realm.executeTransaction {
+ // By mapping here to model, this object is not live
+ // I should update it if needed
+ var myCrossSigningInfo = realm.where(CrossSigningInfoEntity::class.java)
+ .equalTo(CrossSigningInfoEntityFields.USER_ID, myUserId)
+ .findFirst()?.let { mapCrossSigningInfoEntity(it) }
+
+ var myTrustResult: UserTrustResult? = null
+
+ if (userList.contains(myUserId)) {
+ Timber.d("## CrossSigning - Clear all trust as a change on my user was detected")
+ // i am in the list.. but i don't know exactly the delta of change :/
+ // If it's my cross signing keys we should refresh all trust
+ // do it anyway ?
+ userList = realm.where(CrossSigningInfoEntity::class.java)
+ .findAll().mapNotNull { it.userId }
+ Timber.d("## CrossSigning - Updating trust for all $userList")
+
+ // check right now my keys and mark it as trusted as other trust depends on it
+ val myDevices = realm.where<UserEntity>()
+ .equalTo(UserEntityFields.USER_ID, myUserId)
+ .findFirst()
+ ?.devices
+ ?.map { deviceInfo ->
+ CryptoMapper.mapToModel(deviceInfo)
+ }
+ myTrustResult = crossSigningService.checkSelfTrust(myCrossSigningInfo, myDevices).also {
+ updateCrossSigningKeysTrust(realm, myUserId, it.isVerified())
+ // update model reference
+ myCrossSigningInfo = realm.where(CrossSigningInfoEntity::class.java)
+ .equalTo(CrossSigningInfoEntityFields.USER_ID, myUserId)
+ .findFirst()?.let { mapCrossSigningInfoEntity(it) }
+ }
+ }
+
+ val otherInfos = userList.map {
+ it to realm.where(CrossSigningInfoEntity::class.java)
+ .equalTo(CrossSigningInfoEntityFields.USER_ID, it)
+ .findFirst()?.let { mapCrossSigningInfoEntity(it) }
+ }
+ .toMap()
+
+ val trusts = otherInfos.map { infoEntry ->
+ infoEntry.key to when (infoEntry.key) {
+ myUserId -> myTrustResult
+ else -> {
+ crossSigningService.checkOtherMSKTrusted(myCrossSigningInfo, infoEntry.value).also {
+ Timber.d("## CrossSigning - user:${infoEntry.key} result:$it")
+ }
+ }
+ }
+ }.toMap()
+
+ // TODO! if it's me and my keys has changed... I have to reset trust for everyone!
+ // i have all the new trusts, update DB
+ trusts.forEach {
+ val verified = it.value?.isVerified() == true
+ updateCrossSigningKeysTrust(realm, it.key, verified)
+ }
+
+ // Ok so now we have to check device trust for all these users..
+ Timber.v("## CrossSigning - Updating devices cross trust users ${trusts.keys}")
+ trusts.keys.forEach {
+ val devicesEntities = realm.where<UserEntity>()
+ .equalTo(UserEntityFields.USER_ID, it)
+ .findFirst()
+ ?.devices
+
+ val trustMap = devicesEntities?.map { device ->
+ device to crossSigningService.checkDeviceTrust(myCrossSigningInfo, otherInfos[it], CryptoMapper.mapToModel(device))
+ }?.toMap()
+
+ // Update trust if needed
+ devicesEntities?.forEach { device ->
+ val crossSignedVerified = trustMap?.get(device)?.isCrossSignedVerified()
+ Timber.d("## CrossSigning - Trust for ${device.userId}|${device.deviceId} : cross verified: ${trustMap?.get(device)}")
+ if (device.trustLevelEntity?.crossSignedVerified != crossSignedVerified) {
+ Timber.d("## CrossSigning - Trust change detected for ${device.userId}|${device.deviceId} : cross verified: $crossSignedVerified")
+ // need to save
+ val trustEntity = device.trustLevelEntity
+ if (trustEntity == null) {
+ realm.createObject(TrustLevelEntity::class.java).let {
+ it.locallyVerified = false
+ it.crossSignedVerified = crossSignedVerified
+ device.trustLevelEntity = it
+ }
+ } else {
+ trustEntity.crossSignedVerified = crossSignedVerified
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // So Cross Signing keys trust is updated, device trust is updated
+ // We can now update room shields? in the session DB?
+
+ Timber.d("## CrossSigning - Updating shields for impacted rooms...")
+ Realm.getInstance(sessionRealmConfiguration).use { it ->
+ it.executeTransaction { realm ->
+ val distinctRoomIds = realm.where(RoomMemberSummaryEntity::class.java)
+ .`in`(RoomMemberSummaryEntityFields.USER_ID, userList.toTypedArray())
+ .distinct(RoomMemberSummaryEntityFields.ROOM_ID)
+ .findAll()
+ .map { it.roomId }
+ Timber.d("## CrossSigning - ... impacted rooms $distinctRoomIds")
+ distinctRoomIds.forEach { roomId ->
+ val roomSummary = RoomSummaryEntity.where(realm, roomId).findFirst()
+ if (roomSummary?.isEncrypted == true) {
+ Timber.d("## CrossSigning - Check shield state for room $roomId")
+ val allActiveRoomMembers = RoomMemberHelper(realm, roomId).getActiveRoomMemberIds()
+ try {
+ val updatedTrust = computeRoomShield(allActiveRoomMembers, roomSummary)
+ if (roomSummary.roomEncryptionTrustLevel != updatedTrust) {
+ Timber.d("## CrossSigning - Shield change detected for $roomId -> $updatedTrust")
+ roomSummary.roomEncryptionTrustLevel = updatedTrust
+ }
+ } catch (failure: Throwable) {
+ Timber.e(failure)
+ }
+ }
+ }
+ }
+ }
+
+ return Result.success()
+ }
+
+ private fun updateCrossSigningKeysTrust(realm: Realm, userId: String, verified: Boolean) {
+ val xInfoEntity = realm.where(CrossSigningInfoEntity::class.java)
+ .equalTo(CrossSigningInfoEntityFields.USER_ID, userId)
+ .findFirst()
+ xInfoEntity?.crossSigningKeys?.forEach { info ->
+ // optimization to avoid trigger updates when there is no change..
+ if (info.trustLevelEntity?.isVerified() != verified) {
+ Timber.d("## CrossSigning - Trust change for $userId : $verified")
+ val level = info.trustLevelEntity
+ if (level == null) {
+ val newLevel = realm.createObject(TrustLevelEntity::class.java)
+ newLevel.locallyVerified = verified
+ newLevel.crossSignedVerified = verified
+ info.trustLevelEntity = newLevel
+ } else {
+ level.locallyVerified = verified
+ level.crossSignedVerified = verified
+ }
+ }
+ }
+ }
+
+ private fun computeRoomShield(activeMemberUserIds: List<String>, roomSummaryEntity: RoomSummaryEntity): RoomEncryptionTrustLevel {
+ Timber.d("## CrossSigning - computeRoomShield ${roomSummaryEntity.roomId} -> $activeMemberUserIds")
+ // The set of “all users” depends on the type of room:
+ // For regular / topic rooms, all users including yourself, are considered when decorating a room
+ // For 1:1 and group DM rooms, all other users (i.e. excluding yourself) are considered when decorating a room
+ val listToCheck = if (roomSummaryEntity.isDirect) {
+ activeMemberUserIds.filter { it != myUserId }
+ } else {
+ activeMemberUserIds
+ }
+
+ val allTrustedUserIds = listToCheck
+ .filter { userId ->
+ Realm.getInstance(realmConfiguration).use {
+ it.where(CrossSigningInfoEntity::class.java)
+ .equalTo(CrossSigningInfoEntityFields.USER_ID, userId)
+ .findFirst()?.let { mapCrossSigningInfoEntity(it) }?.isTrusted() == true
+ }
+ }
+ val myCrossKeys = Realm.getInstance(realmConfiguration).use {
+ it.where(CrossSigningInfoEntity::class.java)
+ .equalTo(CrossSigningInfoEntityFields.USER_ID, myUserId)
+ .findFirst()?.let { mapCrossSigningInfoEntity(it) }
+ }
+
+ return if (allTrustedUserIds.isEmpty()) {
+ RoomEncryptionTrustLevel.Default
+ } else {
+ // If one of the verified user as an untrusted device -> warning
+ // If all devices of all verified users are trusted -> green
+ // else -> black
+ allTrustedUserIds
+ .mapNotNull { uid ->
+ Realm.getInstance(realmConfiguration).use {
+ it.where<UserEntity>()
+ .equalTo(UserEntityFields.USER_ID, uid)
+ .findFirst()
+ ?.devices
+ ?.map {
+ CryptoMapper.mapToModel(it)
+ }
+ }
+ }
+ .flatten()
+ .let { allDevices ->
+ Timber.v("## CrossSigning - computeRoomShield ${roomSummaryEntity.roomId} devices ${allDevices.map { it.deviceId }}")
+ if (myCrossKeys != null) {
+ allDevices.any { !it.trustLevel?.crossSigningVerified.orFalse() }
+ } else {
+ // Legacy method
+ allDevices.any { !it.isVerified }
+ }
+ }
+ .let { hasWarning ->
+ if (hasWarning) {
+ RoomEncryptionTrustLevel.Warning
+ } else {
+ if (listToCheck.size == allTrustedUserIds.size) {
+ // all users are trusted and all devices are verified
+ RoomEncryptionTrustLevel.Trusted
+ } else {
+ RoomEncryptionTrustLevel.Default
+ }
+ }
+ }
+ }
+ }
+
+ private fun mapCrossSigningInfoEntity(xsignInfo: CrossSigningInfoEntity): MXCrossSigningInfo {
+ val userId = xsignInfo.userId ?: ""
+ return MXCrossSigningInfo(
+ userId = userId,
+ crossSigningKeys = xsignInfo.crossSigningKeys.mapNotNull {
+ crossSigningKeysMapper.map(userId, it)
+ }
+ )
+ }
+
+ override fun buildErrorParams(params: Params, message: String): Params {
+ return params.copy(lastFailureMessage = params.lastFailureMessage ?: message)
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/DefaultKeysBackupService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/DefaultKeysBackupService.kt
index 64579c1b67..bbd8ebd000 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/DefaultKeysBackupService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/DefaultKeysBackupService.kt
@@ -234,7 +234,10 @@ internal class DefaultKeysBackupService @Inject constructor(
this.callback = object : MatrixCallback<KeysVersion> {
override fun onSuccess(data: KeysVersion) {
// Reset backup markers.
- cryptoStore.resetBackupMarkers()
+ cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ // move tx out of UI thread
+ cryptoStore.resetBackupMarkers()
+ }
val keyBackupVersion = KeysVersionResult(
algorithm = createKeysBackupVersionBody.algorithm,
@@ -596,7 +599,9 @@ internal class DefaultKeysBackupService @Inject constructor(
val importResult = awaitCallback<ImportRoomKeysResult> {
restoreKeysWithRecoveryKey(keysBackupVersion, recoveryKey, null, null, null, it)
}
- cryptoStore.saveBackupRecoveryKey(recoveryKey, keysBackupVersion.version)
+ withContext(coroutineDispatchers.crypto) {
+ cryptoStore.saveBackupRecoveryKey(recoveryKey, keysBackupVersion.version)
+ }
Timber.i("onSecretKeyGossip: Recovered keys ${importResult.successfullyNumberOfImportedKeys} out of ${importResult.totalNumberOfKeys}")
} else {
Timber.e("onSecretKeyGossip: Recovery key is not valid ${keysBackupVersion.version}")
@@ -1123,7 +1128,9 @@ internal class DefaultKeysBackupService @Inject constructor(
if (retrievedMegolmBackupAuthData != null) {
keysBackupVersion = keysVersionResult
- cryptoStore.setKeyBackupVersion(keysVersionResult.version)
+ cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
+ cryptoStore.setKeyBackupVersion(keysVersionResult.version)
+ }
onServerDataRetrieved(keysVersionResult.count, keysVersionResult.hash)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/EncryptEventTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/EncryptEventTask.kt
index 1b88fbe9cc..56b267decd 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/EncryptEventTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/EncryptEventTask.kt
@@ -33,14 +33,13 @@ internal interface EncryptEventTask : Task<EncryptEventTask.Params, Event> {
data class Params(val roomId: String,
val event: Event,
/**Do not encrypt these keys, keep them as is in encrypted content (e.g. m.relates_to)*/
- val keepKeys: List<String>? = null,
- val crypto: CryptoService
+ val keepKeys: List<String>? = null
)
}
internal class DefaultEncryptEventTask @Inject constructor(
-// private val crypto: CryptoService
- private val localEchoRepository: LocalEchoRepository
+ private val localEchoRepository: LocalEchoRepository,
+ private val cryptoService: CryptoService
) : EncryptEventTask {
override suspend fun execute(params: EncryptEventTask.Params): Event {
// don't want to wait for any query
@@ -60,7 +59,7 @@ internal class DefaultEncryptEventTask @Inject constructor(
// try {
// let it throws
awaitCallback<MXEncryptEventContentResult> {
- params.crypto.encryptEventContent(localMutableContent, localEvent.type, params.roomId, it)
+ cryptoService.encryptEventContent(localMutableContent, localEvent.type, params.roomId, it)
}.let { result ->
val modifiedContent = HashMap(result.eventContent)
params.keepKeys?.forEach { toKeep ->
@@ -81,7 +80,7 @@ internal class DefaultEncryptEventTask @Inject constructor(
).toContent(),
forwardingCurve25519KeyChain = emptyList(),
senderCurve25519Key = result.eventContent["sender_key"] as? String,
- claimedEd25519Key = params.crypto.getMyDevice().fingerprint()
+ claimedEd25519Key = cryptoService.getMyDevice().fingerprint()
)
} else {
null
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendEventTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendEventTask.kt
index 1a712036c8..8b739c4b64 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendEventTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendEventTask.kt
@@ -16,7 +16,6 @@
package org.matrix.android.sdk.internal.crypto.tasks
import org.greenrobot.eventbus.EventBus
-import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.room.send.SendState
import org.matrix.android.sdk.internal.network.executeRequest
@@ -29,8 +28,7 @@ import javax.inject.Inject
internal interface SendEventTask : Task<SendEventTask.Params, String> {
data class Params(
val event: Event,
- val encrypt: Boolean,
- val cryptoService: CryptoService?
+ val encrypt: Boolean
)
}
@@ -68,8 +66,7 @@ internal class DefaultSendEventTask @Inject constructor(
return encryptEventTask.execute(EncryptEventTask.Params(
params.event.roomId ?: "",
params.event,
- listOf("m.relates_to"),
- params.cryptoService!!
+ listOf("m.relates_to")
))
}
return params.event
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendVerificationMessageTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendVerificationMessageTask.kt
index 782300c7b0..cedb7a6618 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendVerificationMessageTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/SendVerificationMessageTask.kt
@@ -15,21 +15,20 @@
*/
package org.matrix.android.sdk.internal.crypto.tasks
-import org.matrix.android.sdk.api.session.crypto.CryptoService
+import org.greenrobot.eventbus.EventBus
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.room.send.SendState
+import org.matrix.android.sdk.internal.crypto.CryptoSessionInfoProvider
import org.matrix.android.sdk.internal.network.executeRequest
import org.matrix.android.sdk.internal.session.room.RoomAPI
import org.matrix.android.sdk.internal.session.room.send.LocalEchoRepository
import org.matrix.android.sdk.internal.session.room.send.SendResponse
import org.matrix.android.sdk.internal.task.Task
-import org.greenrobot.eventbus.EventBus
import javax.inject.Inject
internal interface SendVerificationMessageTask : Task<SendVerificationMessageTask.Params, String> {
data class Params(
- val event: Event,
- val cryptoService: CryptoService?
+ val event: Event
)
}
@@ -37,6 +36,7 @@ internal class DefaultSendVerificationMessageTask @Inject constructor(
private val localEchoRepository: LocalEchoRepository,
private val encryptEventTask: DefaultEncryptEventTask,
private val roomAPI: RoomAPI,
+ private val cryptoSessionInfoProvider: CryptoSessionInfoProvider,
private val eventBus: EventBus) : SendVerificationMessageTask {
override suspend fun execute(params: SendVerificationMessageTask.Params): String {
@@ -62,13 +62,12 @@ internal class DefaultSendVerificationMessageTask @Inject constructor(
}
private suspend fun handleEncryption(params: SendVerificationMessageTask.Params): Event {
- if (params.cryptoService?.isRoomEncrypted(params.event.roomId ?: "") == true) {
+ if (cryptoSessionInfoProvider.isRoomEncrypted(params.event.roomId ?: "")) {
try {
return encryptEventTask.execute(EncryptEventTask.Params(
params.event.roomId ?: "",
params.event,
- listOf("m.relates_to"),
- params.cryptoService
+ listOf("m.relates_to")
))
} catch (throwable: Throwable) {
// We said it's ok to send verification request in clear
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/DefaultVerificationService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/DefaultVerificationService.kt
index c0f4671046..f3a794154c 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/DefaultVerificationService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/DefaultVerificationService.kt
@@ -20,7 +20,6 @@ import android.os.Handler
import android.os.Looper
import dagger.Lazy
import org.matrix.android.sdk.api.MatrixCallback
-import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.crypto.crosssigning.CrossSigningService
import org.matrix.android.sdk.api.session.crypto.crosssigning.KEYBACKUP_SECRET_SSSS_NAME
import org.matrix.android.sdk.api.session.crypto.crosssigning.MASTER_KEY_SSSS_NAME
@@ -111,9 +110,6 @@ internal class DefaultVerificationService @Inject constructor(
private val uiHandler = Handler(Looper.getMainLooper())
- // Cannot be injected in constructor as it creates a dependency cycle
- lateinit var cryptoService: CryptoService
-
// map [sender : [transaction]]
private val txMap = HashMap<String, HashMap<String, DefaultVerificationTransaction>>()
@@ -1203,7 +1199,9 @@ internal class DefaultVerificationService @Inject constructor(
// TODO refactor this with the DM one
Timber.i("## Requesting verification to user: $otherUserId with device list $otherDevices")
- val targetDevices = otherDevices ?: cryptoService.getUserDevices(otherUserId).map { it.deviceId }
+ val targetDevices = otherDevices ?: cryptoStore.getUserDevices(otherUserId)
+ ?.values?.map { it.deviceId } ?: emptyList()
+
val requestsForUser = pendingRequests.getOrPut(otherUserId) { mutableListOf() }
val transport = verificationTransportToDeviceFactory.createTransport(null)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/SendVerificationMessageWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/SendVerificationMessageWorker.kt
index fa7cd2e6f9..538d7b56e9 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/SendVerificationMessageWorker.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/SendVerificationMessageWorker.kt
@@ -20,7 +20,6 @@ import androidx.work.Data
import androidx.work.WorkerParameters
import com.squareup.moshi.JsonClass
import org.matrix.android.sdk.api.failure.shouldBeRetried
-import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.internal.crypto.tasks.SendVerificationMessageTask
import org.matrix.android.sdk.internal.session.SessionComponent
import org.matrix.android.sdk.internal.session.room.send.CancelSendTracker
@@ -47,7 +46,6 @@ internal class SendVerificationMessageWorker(context: Context,
@Inject lateinit var sendVerificationMessageTask: SendVerificationMessageTask
@Inject lateinit var localEchoRepository: LocalEchoRepository
- @Inject lateinit var cryptoService: CryptoService
@Inject lateinit var cancelSendTracker: CancelSendTracker
override fun injectWith(injector: SessionComponent) {
@@ -70,8 +68,7 @@ internal class SendVerificationMessageWorker(context: Context,
return try {
val resultEventId = sendVerificationMessageTask.execute(
SendVerificationMessageTask.Params(
- event = localEvent,
- cryptoService = cryptoService
+ event = localEvent
)
)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/VerificationMessageProcessor.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/VerificationMessageProcessor.kt
index 4994325625..74827eeb2a 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/VerificationMessageProcessor.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/verification/VerificationMessageProcessor.kt
@@ -15,7 +15,6 @@
*/
package org.matrix.android.sdk.internal.crypto.verification
-import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.crypto.MXCryptoError
import org.matrix.android.sdk.api.session.crypto.verification.VerificationService
import org.matrix.android.sdk.api.session.events.model.Event
@@ -34,12 +33,13 @@ import org.matrix.android.sdk.internal.di.DeviceId
import org.matrix.android.sdk.internal.di.UserId
import org.matrix.android.sdk.internal.session.EventInsertLiveProcessor
import io.realm.Realm
+import org.matrix.android.sdk.internal.crypto.EventDecryptor
import timber.log.Timber
import java.util.ArrayList
import javax.inject.Inject
internal class VerificationMessageProcessor @Inject constructor(
- private val cryptoService: CryptoService,
+ private val eventDecryptor: EventDecryptor,
private val verificationService: DefaultVerificationService,
@UserId private val userId: String,
@DeviceId private val deviceId: String?
@@ -82,7 +82,7 @@ internal class VerificationMessageProcessor @Inject constructor(
// TODO use a global event decryptor? attache to session and that listen to new sessionId?
// for now decrypt sync
try {
- val result = cryptoService.decryptEvent(event, "")
+ val result = eventDecryptor.decryptEvent(event, "")
event.mxDecryptionResult = OlmDecryptionResult(
payload = result.clearEvent,
senderKey = result.senderCurve25519Key,
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/EventInsertLiveObserver.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/EventInsertLiveObserver.kt
index 11a877e7c4..71f978c03c 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/EventInsertLiveObserver.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/EventInsertLiveObserver.kt
@@ -17,10 +17,6 @@
package org.matrix.android.sdk.internal.database
import com.zhuinden.monarchy.Monarchy
-import org.matrix.android.sdk.api.session.crypto.CryptoService
-import org.matrix.android.sdk.api.session.crypto.MXCryptoError
-import org.matrix.android.sdk.api.session.events.model.Event
-import org.matrix.android.sdk.internal.crypto.algorithms.olm.OlmDecryptionResult
import org.matrix.android.sdk.internal.database.mapper.asDomain
import org.matrix.android.sdk.internal.database.model.EventEntity
import org.matrix.android.sdk.internal.database.model.EventInsertEntity
@@ -31,12 +27,13 @@ import org.matrix.android.sdk.internal.session.EventInsertLiveProcessor
import io.realm.RealmConfiguration
import io.realm.RealmResults
import kotlinx.coroutines.launch
+import org.matrix.android.sdk.internal.crypto.EventDecryptor
import timber.log.Timber
import javax.inject.Inject
internal class EventInsertLiveObserver @Inject constructor(@SessionDatabase realmConfiguration: RealmConfiguration,
private val processors: Set<@JvmSuppressWildcards EventInsertLiveProcessor>,
- private val cryptoService: CryptoService)
+ private val eventDecryptor: EventDecryptor)
: RealmLiveEntityObserver<EventInsertEntity>(realmConfiguration) {
override val query = Monarchy.Query<EventInsertEntity> {
@@ -74,7 +71,7 @@ internal class EventInsertLiveObserver @Inject constructor(@SessionDatabase real
return@forEach
}
val domainEvent = event.asDomain()
- decryptIfNeeded(domainEvent)
+// decryptIfNeeded(domainEvent)
processors.filter {
it.shouldProcess(eventId, domainEvent.getClearType(), eventInsert.insertType)
}.forEach {
@@ -89,22 +86,22 @@ internal class EventInsertLiveObserver @Inject constructor(@SessionDatabase real
}
}
- private fun decryptIfNeeded(event: Event) {
- if (event.isEncrypted() && event.mxDecryptionResult == null) {
- try {
- val result = cryptoService.decryptEvent(event, event.roomId ?: "")
- event.mxDecryptionResult = OlmDecryptionResult(
- payload = result.clearEvent,
- senderKey = result.senderCurve25519Key,
- keysClaimed = result.claimedEd25519Key?.let { k -> mapOf("ed25519" to k) },
- forwardingCurve25519KeyChain = result.forwardingCurve25519KeyChain
- )
- } catch (e: MXCryptoError) {
- Timber.v("Failed to decrypt event")
- // TODO -> we should keep track of this and retry, or some processing will never be handled
- }
- }
- }
+// private fun decryptIfNeeded(event: Event) {
+// if (event.isEncrypted() && event.mxDecryptionResult == null) {
+// try {
+// val result = eventDecryptor.decryptEvent(event, event.roomId ?: "")
+// event.mxDecryptionResult = OlmDecryptionResult(
+// payload = result.clearEvent,
+// senderKey = result.senderCurve25519Key,
+// keysClaimed = result.claimedEd25519Key?.let { k -> mapOf("ed25519" to k) },
+// forwardingCurve25519KeyChain = result.forwardingCurve25519KeyChain
+// )
+// } catch (e: MXCryptoError) {
+// Timber.v("Failed to decrypt event")
+// // TODO -> we should keep track of this and retry, or some processing will never be handled
+// }
+// }
+// }
private fun shouldProcess(eventInsertEntity: EventInsertEntity): Boolean {
return processors.any {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
index 359dd265d8..7e182525a9 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/DefaultSession.kt
@@ -65,7 +65,6 @@ import org.matrix.android.sdk.internal.di.UnauthenticatedWithCertificate
import org.matrix.android.sdk.internal.di.WorkManagerProvider
import org.matrix.android.sdk.internal.session.identity.DefaultIdentityService
import org.matrix.android.sdk.internal.session.room.send.queue.EventSenderProcessor
-import org.matrix.android.sdk.internal.session.room.timeline.TimelineEventDecryptor
import org.matrix.android.sdk.internal.session.sync.SyncTokenStore
import org.matrix.android.sdk.internal.session.sync.job.SyncThread
import org.matrix.android.sdk.internal.session.sync.job.SyncWorker
@@ -115,7 +114,6 @@ internal class DefaultSession @Inject constructor(
private val accountDataService: Lazy<AccountDataService>,
private val _sharedSecretStorageService: Lazy<SharedSecretStorageService>,
private val accountService: Lazy<AccountService>,
- private val timelineEventDecryptor: TimelineEventDecryptor,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
private val defaultIdentityService: DefaultIdentityService,
private val integrationManagerService: IntegrationManagerService,
@@ -162,7 +160,6 @@ internal class DefaultSession @Inject constructor(
lifecycleObservers.forEach { it.onStart() }
}
eventBus.register(this)
- timelineEventDecryptor.start()
eventSenderProcessor.start()
}
@@ -200,7 +197,7 @@ internal class DefaultSession @Inject constructor(
override fun close() {
assert(isOpen)
stopSync()
- timelineEventDecryptor.destroy()
+ // timelineEventDecryptor.destroy()
uiHandler.post {
lifecycleObservers.forEach { it.onStop() }
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt
index ed586d35f8..e6fd5a7a0c 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionComponent.kt
@@ -24,6 +24,7 @@ import org.matrix.android.sdk.internal.crypto.CancelGossipRequestWorker
import org.matrix.android.sdk.internal.crypto.CryptoModule
import org.matrix.android.sdk.internal.crypto.SendGossipRequestWorker
import org.matrix.android.sdk.internal.crypto.SendGossipWorker
+import org.matrix.android.sdk.internal.crypto.crosssigning.UpdateTrustWorker
import org.matrix.android.sdk.internal.crypto.verification.SendVerificationMessageWorker
import org.matrix.android.sdk.internal.di.MatrixComponent
import org.matrix.android.sdk.internal.di.SessionAssistedInjectModule
@@ -128,6 +129,8 @@ internal interface SessionComponent {
fun inject(worker: SendGossipWorker)
+ fun inject(worker: UpdateTrustWorker)
+
@Component.Factory
interface Factory {
fun create(
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionModule.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionModule.kt
index 102a34d9de..32949d60c4 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionModule.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/SessionModule.kt
@@ -41,7 +41,6 @@ import org.matrix.android.sdk.api.session.permalinks.PermalinkService
import org.matrix.android.sdk.api.session.securestorage.SecureStorageService
import org.matrix.android.sdk.api.session.securestorage.SharedSecretStorageService
import org.matrix.android.sdk.api.session.typing.TypingUsersTracker
-import org.matrix.android.sdk.internal.crypto.crosssigning.ShieldTrustUpdater
import org.matrix.android.sdk.internal.crypto.secrets.DefaultSharedSecretStorageService
import org.matrix.android.sdk.internal.crypto.tasks.DefaultRedactEventTask
import org.matrix.android.sdk.internal.crypto.tasks.RedactEventTask
@@ -333,10 +332,6 @@ internal abstract class SessionModule {
@IntoSet
abstract fun bindWidgetUrlFormatter(formatter: DefaultWidgetURLFormatter): SessionLifecycleObserver
- @Binds
- @IntoSet
- abstract fun bindShieldTrustUpdated(updater: ShieldTrustUpdater): SessionLifecycleObserver
-
@Binds
@IntoSet
abstract fun bindIdentityService(service: DefaultIdentityService): SessionLifecycleObserver
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/EventRelationsAggregationProcessor.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/EventRelationsAggregationProcessor.kt
index 9ff0deec89..d090ba5296 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/EventRelationsAggregationProcessor.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/EventRelationsAggregationProcessor.kt
@@ -15,7 +15,7 @@
*/
package org.matrix.android.sdk.internal.session.room
-import org.matrix.android.sdk.api.session.crypto.CryptoService
+import io.realm.Realm
import org.matrix.android.sdk.api.session.events.model.AggregatedAnnotation
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.events.model.EventType
@@ -47,7 +47,6 @@ import org.matrix.android.sdk.internal.database.query.getOrCreate
import org.matrix.android.sdk.internal.database.query.where
import org.matrix.android.sdk.internal.di.UserId
import org.matrix.android.sdk.internal.session.EventInsertLiveProcessor
-import io.realm.Realm
import timber.log.Timber
import javax.inject.Inject
@@ -78,9 +77,8 @@ private fun VerificationState?.toState(newState: VerificationState): Verificatio
return newState
}
-internal class EventRelationsAggregationProcessor @Inject constructor(@UserId private val userId: String,
- private val cryptoService: CryptoService
-) : EventInsertLiveProcessor {
+internal class EventRelationsAggregationProcessor @Inject constructor(@UserId private val userId: String)
+ : EventInsertLiveProcessor {
private val allowedTypes = listOf(
EventType.MESSAGE,
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/relation/DefaultRelationService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/relation/DefaultRelationService.kt
index 38c542e07e..a7f3f83980 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/relation/DefaultRelationService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/relation/DefaultRelationService.kt
@@ -21,7 +21,6 @@ import com.squareup.inject.assisted.Assisted
import com.squareup.inject.assisted.AssistedInject
import com.zhuinden.monarchy.Monarchy
import org.matrix.android.sdk.api.MatrixCallback
-import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.room.model.EventAnnotationsSummary
import org.matrix.android.sdk.api.session.room.model.message.MessageType
@@ -31,13 +30,13 @@ import org.matrix.android.sdk.api.util.Cancelable
import org.matrix.android.sdk.api.util.NoOpCancellable
import org.matrix.android.sdk.api.util.Optional
import org.matrix.android.sdk.api.util.toOptional
+import org.matrix.android.sdk.internal.crypto.CryptoSessionInfoProvider
import org.matrix.android.sdk.internal.database.mapper.TimelineEventMapper
import org.matrix.android.sdk.internal.database.mapper.asDomain
import org.matrix.android.sdk.internal.database.model.EventAnnotationsSummaryEntity
import org.matrix.android.sdk.internal.database.model.TimelineEventEntity
import org.matrix.android.sdk.internal.database.query.where
import org.matrix.android.sdk.internal.di.SessionDatabase
-import org.matrix.android.sdk.internal.di.SessionId
import org.matrix.android.sdk.internal.session.room.send.LocalEchoEventFactory
import org.matrix.android.sdk.internal.session.room.send.queue.EventSenderProcessor
import org.matrix.android.sdk.internal.task.TaskExecutor
@@ -47,11 +46,9 @@ import timber.log.Timber
internal class DefaultRelationService @AssistedInject constructor(
@Assisted private val roomId: String,
- @SessionId private val sessionId: String,
-// private val timeLineSendEventWorkCommon: TimelineSendEventWorkCommon,
private val eventSenderProcessor: EventSenderProcessor,
private val eventFactory: LocalEchoEventFactory,
- private val cryptoService: CryptoService,
+ private val cryptoSessionInfoProvider: CryptoSessionInfoProvider,
private val findReactionEventForUndoTask: FindReactionEventForUndoTask,
private val fetchEditHistoryTask: FetchEditHistoryTask,
private val timelineEventMapper: TimelineEventMapper,
@@ -122,7 +119,7 @@ internal class DefaultRelationService @AssistedInject constructor(
val event = eventFactory
.createReplaceTextEvent(roomId, targetEventId, newBodyText, newBodyAutoMarkdown, msgType, compatibilityBodyText)
.also { saveLocalEcho(it) }
- return eventSenderProcessor.postEvent(event, cryptoService.isRoomEncrypted(roomId))
+ return eventSenderProcessor.postEvent(event, cryptoSessionInfoProvider.isRoomEncrypted(roomId))
}
override fun editReply(replyToEdit: TimelineEvent,
@@ -139,11 +136,11 @@ internal class DefaultRelationService @AssistedInject constructor(
compatibilityBodyText
)
.also { saveLocalEcho(it) }
- return eventSenderProcessor.postEvent(event, cryptoService.isRoomEncrypted(roomId))
+ return eventSenderProcessor.postEvent(event, cryptoSessionInfoProvider.isRoomEncrypted(roomId))
}
override fun fetchEditHistory(eventId: String, callback: MatrixCallback<List<Event>>) {
- val params = FetchEditHistoryTask.Params(roomId, cryptoService.isRoomEncrypted(roomId), eventId)
+ val params = FetchEditHistoryTask.Params(roomId, cryptoSessionInfoProvider.isRoomEncrypted(roomId), eventId)
fetchEditHistoryTask
.configureWith(params) {
this.callback = callback
@@ -156,7 +153,7 @@ internal class DefaultRelationService @AssistedInject constructor(
?.also { saveLocalEcho(it) }
?: return null
- return eventSenderProcessor.postEvent(event, cryptoService.isRoomEncrypted(roomId))
+ return eventSenderProcessor.postEvent(event, cryptoSessionInfoProvider.isRoomEncrypted(roomId))
}
override fun getEventAnnotationsSummary(eventId: String): EventAnnotationsSummary? {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt
index 5c395c1907..b13ce15da6 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt
@@ -25,7 +25,6 @@ import com.squareup.inject.assisted.Assisted
import com.squareup.inject.assisted.AssistedInject
import kotlinx.coroutines.launch
import org.matrix.android.sdk.api.session.content.ContentAttachmentData
-import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.events.model.isAttachmentMessage
import org.matrix.android.sdk.api.session.events.model.isTextMessage
@@ -45,6 +44,7 @@ import org.matrix.android.sdk.api.util.Cancelable
import org.matrix.android.sdk.api.util.CancelableBag
import org.matrix.android.sdk.api.util.JsonDict
import org.matrix.android.sdk.api.util.NoOpCancellable
+import org.matrix.android.sdk.internal.crypto.CryptoSessionInfoProvider
import org.matrix.android.sdk.internal.di.SessionId
import org.matrix.android.sdk.internal.di.WorkManagerProvider
import org.matrix.android.sdk.internal.session.content.UploadContentWorker
@@ -64,7 +64,7 @@ internal class DefaultSendService @AssistedInject constructor(
private val workManagerProvider: WorkManagerProvider,
@SessionId private val sessionId: String,
private val localEchoEventFactory: LocalEchoEventFactory,
- private val cryptoService: CryptoService,
+ private val cryptoSessionInfoProvider: CryptoSessionInfoProvider,
private val taskExecutor: TaskExecutor,
private val localEchoRepository: LocalEchoRepository,
private val eventSenderProcessor: EventSenderProcessor,
@@ -251,7 +251,7 @@ internal class DefaultSendService @AssistedInject constructor(
private fun internalSendMedia(allLocalEchoes: List<Event>, attachment: ContentAttachmentData, compressBeforeSending: Boolean): Cancelable {
val cancelableBag = CancelableBag()
- allLocalEchoes.groupBy { cryptoService.isRoomEncrypted(it.roomId!!) }
+ allLocalEchoes.groupBy { cryptoSessionInfoProvider.isRoomEncrypted(it.roomId!!) }
.apply {
keys.forEach { isRoomEncrypted ->
// Should never be empty
@@ -282,7 +282,7 @@ internal class DefaultSendService @AssistedInject constructor(
}
private fun sendEvent(event: Event): Cancelable {
- return eventSenderProcessor.postEvent(event, cryptoService.isRoomEncrypted(event.roomId!!))
+ return eventSenderProcessor.postEvent(event, cryptoSessionInfoProvider.isRoomEncrypted(event.roomId!!))
}
private fun createLocalEcho(event: Event) {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/SendEventWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/SendEventWorker.kt
index 2c835ff56c..37a429d242 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/SendEventWorker.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/SendEventWorker.kt
@@ -87,7 +87,7 @@ internal class SendEventWorker(context: Context,
Timber.v("## SendEvent: [${System.currentTimeMillis()}] Send event ${params.eventId}")
return try {
- sendEventTask.execute(SendEventTask.Params(event, params.isEncrypted ?: cryptoService.isRoomEncrypted(event.roomId), cryptoService))
+ sendEventTask.execute(SendEventTask.Params(event, params.isEncrypted ?: cryptoService.isRoomEncrypted(event.roomId)))
Result.success()
} catch (exception: Throwable) {
if (/*currentAttemptCount >= MAX_NUMBER_OF_RETRY_BEFORE_FAILING ||**/ !exception.shouldBeRetried()) {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/queue/SendEventQueuedTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/queue/SendEventQueuedTask.kt
index 09da0908f9..21a4145a9d 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/queue/SendEventQueuedTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/queue/SendEventQueuedTask.kt
@@ -38,7 +38,7 @@ internal class SendEventQueuedTask(
override fun toString() = "[SendEventRunnableTask ${event.eventId}]"
override suspend fun execute() {
- sendEventTask.execute(SendEventTask.Params(event, encrypt, cryptoService))
+ sendEventTask.execute(SendEventTask.Params(event, encrypt))
}
override fun onTaskFailed() {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/summary/RoomSummaryUpdater.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/summary/RoomSummaryUpdater.kt
index f9a27c367c..8c71604183 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/summary/RoomSummaryUpdater.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/summary/RoomSummaryUpdater.kt
@@ -16,10 +16,8 @@
package org.matrix.android.sdk.internal.session.room.summary
-import dagger.Lazy
import io.realm.Realm
-import org.greenrobot.eventbus.EventBus
-import org.matrix.android.sdk.api.crypto.RoomEncryptionTrustLevel
+import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.api.session.events.model.EventType
import org.matrix.android.sdk.api.session.events.model.toModel
import org.matrix.android.sdk.api.session.room.model.Membership
@@ -28,9 +26,11 @@ import org.matrix.android.sdk.api.session.room.model.RoomCanonicalAliasContent
import org.matrix.android.sdk.api.session.room.model.RoomNameContent
import org.matrix.android.sdk.api.session.room.model.RoomTopicContent
import org.matrix.android.sdk.api.session.room.send.SendState
+import org.matrix.android.sdk.internal.crypto.EventDecryptor
import org.matrix.android.sdk.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM
-import org.matrix.android.sdk.internal.crypto.crosssigning.SessionToCryptoRoomMembersUpdate
+import org.matrix.android.sdk.internal.crypto.crosssigning.DefaultCrossSigningService
import org.matrix.android.sdk.internal.database.mapper.ContentMapper
+import org.matrix.android.sdk.internal.database.mapper.asDomain
import org.matrix.android.sdk.internal.database.model.CurrentStateEventEntity
import org.matrix.android.sdk.internal.database.model.EventEntity
import org.matrix.android.sdk.internal.database.model.EventEntityFields
@@ -46,7 +46,6 @@ import org.matrix.android.sdk.internal.di.UserId
import org.matrix.android.sdk.internal.session.room.RoomAvatarResolver
import org.matrix.android.sdk.internal.session.room.membership.RoomDisplayNameResolver
import org.matrix.android.sdk.internal.session.room.membership.RoomMemberHelper
-import org.matrix.android.sdk.internal.session.room.timeline.TimelineEventDecryptor
import org.matrix.android.sdk.internal.session.sync.model.RoomSyncSummary
import org.matrix.android.sdk.internal.session.sync.model.RoomSyncUnreadNotifications
import timber.log.Timber
@@ -56,8 +55,8 @@ internal class RoomSummaryUpdater @Inject constructor(
@UserId private val userId: String,
private val roomDisplayNameResolver: RoomDisplayNameResolver,
private val roomAvatarResolver: RoomAvatarResolver,
- private val timelineEventDecryptor: Lazy<TimelineEventDecryptor>,
- private val eventBus: EventBus) {
+ private val eventDecryptor: EventDecryptor,
+ private val crossSigningService: DefaultCrossSigningService) {
fun update(realm: Realm,
roomId: String,
@@ -126,9 +125,14 @@ internal class RoomSummaryUpdater @Inject constructor(
}
roomSummaryEntity.updateHasFailedSending()
- if (latestPreviewableEvent?.root?.type == EventType.ENCRYPTED && latestPreviewableEvent.root?.decryptionResultJson == null) {
+ val root = latestPreviewableEvent?.root
+ if (root?.type == EventType.ENCRYPTED && root.decryptionResultJson == null) {
Timber.v("Should decrypt ${latestPreviewableEvent.eventId}")
- timelineEventDecryptor.get().requestDecryption(TimelineEventDecryptor.DecryptionRequest(latestPreviewableEvent.eventId, ""))
+ // mmm i want to decrypt now or is it ok to do it async?
+ tryOrNull {
+ eventDecryptor.decryptEvent(root.asDomain(), "")
+ // eventDecryptor.decryptEventAsync(root.asDomain(), "", NoOpMatrixCallback())
+ }
}
if (updateMembers) {
@@ -142,7 +146,8 @@ internal class RoomSummaryUpdater @Inject constructor(
roomSummaryEntity.otherMemberIds.clear()
roomSummaryEntity.otherMemberIds.addAll(otherRoomMembers)
if (roomSummaryEntity.isEncrypted) {
- eventBus.post(SessionToCryptoRoomMembersUpdate(roomId, roomSummaryEntity.isDirect, roomSummaryEntity.otherMemberIds.toList() + userId))
+ // mmm maybe we could only refresh shield instead of checking trust also?
+ crossSigningService.onUsersDeviceUpdate(roomSummaryEntity.otherMemberIds.toList())
}
}
}
@@ -156,13 +161,4 @@ internal class RoomSummaryUpdater @Inject constructor(
roomSummaryEntity.updateHasFailedSending()
roomSummaryEntity.latestPreviewableEvent = RoomSummaryEventsHelper.getLatestPreviewableEvent(realm, roomId)
}
-
- fun updateShieldTrust(realm: Realm,
- roomId: String,
- trust: RoomEncryptionTrustLevel?) {
- val roomSummaryEntity = RoomSummaryEntity.getOrCreate(realm, roomId)
- if (roomSummaryEntity.isEncrypted) {
- roomSummaryEntity.roomEncryptionTrustLevel = trust
- }
- }
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/DefaultTimeline.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/DefaultTimeline.kt
index 1e5c3600d3..f720a4ede0 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/DefaultTimeline.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/DefaultTimeline.kt
@@ -630,7 +630,7 @@ internal class DefaultTimeline(
if (timelineEvent.isEncrypted()
&& timelineEvent.root.mxDecryptionResult == null) {
- timelineEvent.root.eventId?.also { eventDecryptor.requestDecryption(TimelineEventDecryptor.DecryptionRequest(it, timelineID)) }
+ timelineEvent.root.eventId?.also { eventDecryptor.requestDecryption(TimelineEventDecryptor.DecryptionRequest(timelineEvent.root, timelineID)) }
}
val position = if (direction == Timeline.Direction.FORWARDS) 0 else builtEvents.size
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/TimelineEventDecryptor.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/TimelineEventDecryptor.kt
index e91487eab0..3517f26c5d 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/TimelineEventDecryptor.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/TimelineEventDecryptor.kt
@@ -15,24 +15,22 @@
*/
package org.matrix.android.sdk.internal.session.room.timeline
+import io.realm.Realm
+import io.realm.RealmConfiguration
import org.matrix.android.sdk.api.session.crypto.CryptoService
import org.matrix.android.sdk.api.session.crypto.MXCryptoError
+import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.events.model.toModel
import org.matrix.android.sdk.internal.crypto.NewSessionListener
import org.matrix.android.sdk.internal.crypto.model.event.EncryptedEventContent
-import org.matrix.android.sdk.internal.database.mapper.asDomain
import org.matrix.android.sdk.internal.database.model.EventEntity
import org.matrix.android.sdk.internal.database.query.where
import org.matrix.android.sdk.internal.di.SessionDatabase
-import org.matrix.android.sdk.internal.session.SessionScope
-import io.realm.Realm
-import io.realm.RealmConfiguration
import timber.log.Timber
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import javax.inject.Inject
-@SessionScope
internal class TimelineEventDecryptor @Inject constructor(
@SessionDatabase
private val realmConfiguration: RealmConfiguration,
@@ -83,14 +81,14 @@ internal class TimelineEventDecryptor @Inject constructor(
synchronized(unknownSessionsFailure) {
for (requests in unknownSessionsFailure.values) {
if (request in requests) {
- Timber.d("Skip Decryption request for event ${request.eventId}, unknown session")
+ Timber.d("Skip Decryption request for event ${request.event.eventId}, unknown session")
return
}
}
}
synchronized(existingRequests) {
if (!existingRequests.add(request)) {
- Timber.d("Skip Decryption request for event ${request.eventId}, already requested")
+ Timber.d("Skip Decryption request for event ${request.event.eventId}, already requested")
return
}
}
@@ -101,25 +99,29 @@ internal class TimelineEventDecryptor @Inject constructor(
}
}
- private fun processDecryptRequest(request: DecryptionRequest, realm: Realm) = realm.executeTransaction {
- val eventId = request.eventId
+ private fun processDecryptRequest(request: DecryptionRequest, realm: Realm) {
+ val event = request.event
val timelineId = request.timelineId
- Timber.v("Decryption request for event $eventId")
- val eventEntity = EventEntity.where(realm, eventId = eventId).findFirst()
- ?: return@executeTransaction Unit.also {
- Timber.d("Decryption request for unknown message")
- }
- val event = eventEntity.asDomain()
try {
- val result = cryptoService.decryptEvent(event, timelineId)
- Timber.v("Successfully decrypted event $eventId")
- eventEntity.setDecryptionResult(result)
+ val result = cryptoService.decryptEvent(request.event, timelineId)
+ Timber.v("Successfully decrypted event ${event.eventId}")
+ realm.executeTransaction {
+ EventEntity.where(it, eventId = event.eventId ?: "")
+ .findFirst()
+ ?.setDecryptionResult(result)
+ }
} catch (e: MXCryptoError) {
- Timber.v(e, "Failed to decrypt event $eventId")
+ Timber.v("Failed to decrypt event ${event.eventId} : ${e.localizedMessage}")
if (e is MXCryptoError.Base /*&& e.errorType == MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID*/) {
// Keep track of unknown sessions to automatically try to decrypt on new session
- eventEntity.decryptionErrorCode = e.errorType.name
- eventEntity.decryptionErrorReason = e.technicalMessage.takeIf { it.isNotEmpty() } ?: e.detailedErrorDescription
+ realm.executeTransaction {
+ EventEntity.where(it, eventId = event.eventId ?: "")
+ .findFirst()
+ ?.let {
+ it.decryptionErrorCode = e.errorType.name
+ it.decryptionErrorReason = e.technicalMessage.takeIf { it.isNotEmpty() } ?: e.detailedErrorDescription
+ }
+ }
event.content?.toModel<EncryptedEventContent>()?.let { content ->
content.sessionId?.let { sessionId ->
synchronized(unknownSessionsFailure) {
@@ -130,7 +132,7 @@ internal class TimelineEventDecryptor @Inject constructor(
}
}
} catch (t: Throwable) {
- Timber.e("Failed to decrypt event $eventId, ${t.localizedMessage}")
+ Timber.e("Failed to decrypt event ${event.eventId}, ${t.localizedMessage}")
} finally {
synchronized(existingRequests) {
existingRequests.remove(request)
@@ -139,7 +141,7 @@ internal class TimelineEventDecryptor @Inject constructor(
}
data class DecryptionRequest(
- val eventId: String,
+ val event: Event,
val timelineId: String
)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/RoomSyncHandler.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/RoomSyncHandler.kt
index 8589889b30..b1b2f65dc2 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/RoomSyncHandler.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/RoomSyncHandler.kt
@@ -16,6 +16,9 @@
package org.matrix.android.sdk.internal.session.sync
+import io.realm.Realm
+import io.realm.kotlin.createObject
+import org.greenrobot.eventbus.EventBus
import org.matrix.android.sdk.R
import org.matrix.android.sdk.api.session.crypto.MXCryptoError
import org.matrix.android.sdk.api.session.events.model.Event
@@ -54,16 +57,12 @@ import org.matrix.android.sdk.internal.session.room.read.FullyReadContent
import org.matrix.android.sdk.internal.session.room.summary.RoomSummaryUpdater
import org.matrix.android.sdk.internal.session.room.timeline.DefaultTimeline
import org.matrix.android.sdk.internal.session.room.timeline.PaginationDirection
-import org.matrix.android.sdk.internal.session.room.timeline.TimelineEventDecryptor
import org.matrix.android.sdk.internal.session.room.typing.TypingEventContent
import org.matrix.android.sdk.internal.session.sync.model.InvitedRoomSync
import org.matrix.android.sdk.internal.session.sync.model.RoomSync
import org.matrix.android.sdk.internal.session.sync.model.RoomSyncAccountData
import org.matrix.android.sdk.internal.session.sync.model.RoomSyncEphemeral
import org.matrix.android.sdk.internal.session.sync.model.RoomsSyncResponse
-import io.realm.Realm
-import io.realm.kotlin.createObject
-import org.greenrobot.eventbus.EventBus
import timber.log.Timber
import javax.inject.Inject
@@ -76,8 +75,7 @@ internal class RoomSyncHandler @Inject constructor(private val readReceiptHandle
private val roomTypingUsersHandler: RoomTypingUsersHandler,
private val roomChangeMembershipStateDataSource: RoomChangeMembershipStateDataSource,
@UserId private val userId: String,
- private val eventBus: EventBus,
- private val timelineEventDecryptor: TimelineEventDecryptor) {
+ private val eventBus: EventBus) {
sealed class HandlingStrategy {
data class JOINED(val data: Map<String, RoomSync>) : HandlingStrategy()
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt
index cfd7865269..74cba5e796 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/sync/job/SyncThread.kt
@@ -54,7 +54,7 @@ internal class SyncThread @Inject constructor(private val syncTask: SyncTask,
private val networkConnectivityChecker: NetworkConnectivityChecker,
private val backgroundDetectionObserver: BackgroundDetectionObserver,
private val activeCallHandler: ActiveCallHandler
-) : Thread(), NetworkConnectivityChecker.Listener, BackgroundDetectionObserver.Listener {
+) : Thread("SyncThread"), NetworkConnectivityChecker.Listener, BackgroundDetectionObserver.Listener {
private var state: SyncState = SyncState.Idle
private var liveState = MutableLiveData<SyncState>(state)