,
direction: PaginationDirection) {
events.forEach { event ->
- val fakeEvent = event.toEntity(roomId, SendState.SYNCED, System.currentTimeMillis()).let {
+ val fakeEvent = event.toEntity(roomId, SendState.SYNCED, clock.epochMillis()).let {
realm.copyToRealm(it)
}
addTimelineEvent(
roomId = roomId,
eventEntity = fakeEvent,
direction = direction,
- roomMemberContentsByUser = emptyMap())
+ roomMemberContentsByUser = emptyMap()
+ )
}
}
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakeGetContextOfEventTask.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakeGetContextOfEventTask.kt
index b86c86c0c7..ccf1c7c2c9 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakeGetContextOfEventTask.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakeGetContextOfEventTask.kt
@@ -26,8 +26,8 @@ internal class FakeGetContextOfEventTask constructor(private val tokenChunkEvent
override suspend fun execute(params: GetContextOfEventTask.Params): TokenChunkEventPersistor.Result {
val fakeEvents = RoomDataHelper.createFakeListOfEvents(30)
val tokenChunkEvent = FakeTokenChunkEvent(
- Random.nextLong(System.currentTimeMillis()).toString(),
- Random.nextLong(System.currentTimeMillis()).toString(),
+ Random.nextLong().toString(),
+ Random.nextLong().toString(),
fakeEvents
)
return tokenChunkEventPersistor.insertInDb(tokenChunkEvent, params.roomId, PaginationDirection.BACKWARDS)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakePaginationTask.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakePaginationTask.kt
index d09bfb18c6..f241be0c5c 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakePaginationTask.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/FakePaginationTask.kt
@@ -25,7 +25,7 @@ internal class FakePaginationTask @Inject constructor(private val tokenChunkEven
override suspend fun execute(params: PaginationTask.Params): TokenChunkEventPersistor.Result {
val fakeEvents = RoomDataHelper.createFakeListOfEvents(30)
- val tokenChunkEvent = FakeTokenChunkEvent(params.from, Random.nextLong(System.currentTimeMillis()).toString(), fakeEvents)
+ val tokenChunkEvent = FakeTokenChunkEvent(params.from, Random.nextLong().toString(), fakeEvents)
return tokenChunkEventPersistor.insertInDb(tokenChunkEvent, params.roomId, params.direction)
}
}
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt
index 3864ea1cd1..d5b4a07fc0 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineForwardPaginationTest.kt
@@ -71,7 +71,8 @@ class TimelineForwardPaginationTest : InstrumentedTest {
val sentMessages = commonTestHelper.sendTextMessage(
roomFromAlicePOV,
message,
- numberOfMessagesToSend)
+ numberOfMessagesToSend
+ )
// Alice clear the cache and restart the sync
commonTestHelper.clearCacheAndSync(aliceSession)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelinePreviousLastForwardTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelinePreviousLastForwardTest.kt
index 5d09b74e6c..6e5fed8df9 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelinePreviousLastForwardTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelinePreviousLastForwardTest.kt
@@ -94,7 +94,8 @@ class TimelinePreviousLastForwardTest : InstrumentedTest {
val firstMessageFromAliceId = commonTestHelper.sendTextMessage(
roomFromAlicePOV,
firstMessage,
- 30)
+ 30
+ )
.last()
.eventId
@@ -130,7 +131,8 @@ class TimelinePreviousLastForwardTest : InstrumentedTest {
commonTestHelper.sendTextMessage(
roomFromAlicePOV,
secondMessage,
- 30)
+ 30
+ )
// Bob start to sync
bobSession.startSync(true)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineSimpleBackPaginationTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineSimpleBackPaginationTest.kt
index 251b2c614c..42f710d7cf 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineSimpleBackPaginationTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/room/timeline/TimelineSimpleBackPaginationTest.kt
@@ -64,7 +64,8 @@ class TimelineSimpleBackPaginationTest : InstrumentedTest {
commonTestHelper.sendTextMessage(
roomFromAlicePOV,
message,
- numberOfMessagesToSent)
+ numberOfMessagesToSent
+ )
val bobTimeline = roomFromBobPOV.timelineService().createTimeline(null, TimelineSettings(30))
bobTimeline.start()
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/search/SearchMessagesTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/search/SearchMessagesTest.kt
index ab0bbe7f73..e17b7efbd6 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/search/SearchMessagesTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/search/SearchMessagesTest.kt
@@ -85,7 +85,8 @@ class SearchMessagesTest : InstrumentedTest {
commonTestHelper.sendTextMessage(
roomFromAlicePOV,
MESSAGE,
- 2)
+ 2
+ )
val data = commonTestHelper.runBlockingTest {
block.invoke(cryptoTestData)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt
index d2c8b52fc7..6a17cb74ad 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/session/space/SpaceHierarchyTest.kt
@@ -177,21 +177,27 @@ class SpaceHierarchyTest : InstrumentedTest {
val commonTestHelper = CommonTestHelper(context())
val session = commonTestHelper.createAccount("John", SessionTestParams(true))
- val spaceAInfo = createPublicSpace(session, "SpaceA", listOf(
+ val spaceAInfo = createPublicSpace(
+ session, "SpaceA", listOf(
Triple("A1", true /*auto-join*/, true/*canonical*/),
Triple("A2", true, true)
- ))
+ )
+ )
- /* val spaceBInfo = */ createPublicSpace(session, "SpaceB", listOf(
+ /* val spaceBInfo = */ createPublicSpace(
+ session, "SpaceB", listOf(
Triple("B1", true /*auto-join*/, true/*canonical*/),
Triple("B2", true, true),
Triple("B3", true, true)
- ))
+ )
+ )
- val spaceCInfo = createPublicSpace(session, "SpaceC", listOf(
+ val spaceCInfo = createPublicSpace(
+ session, "SpaceC", listOf(
Triple("C1", true /*auto-join*/, true/*canonical*/),
Triple("C2", true, true)
- ))
+ )
+ )
// add C as a subspace of A
val spaceA = session.spaceService().getSpace(spaceAInfo.spaceId)
@@ -254,15 +260,19 @@ class SpaceHierarchyTest : InstrumentedTest {
val commonTestHelper = CommonTestHelper(context())
val session = commonTestHelper.createAccount("John", SessionTestParams(true))
- val spaceAInfo = createPublicSpace(session, "SpaceA", listOf(
+ val spaceAInfo = createPublicSpace(
+ session, "SpaceA", listOf(
Triple("A1", true /*auto-join*/, true/*canonical*/),
Triple("A2", true, true)
- ))
+ )
+ )
- val spaceCInfo = createPublicSpace(session, "SpaceC", listOf(
+ val spaceCInfo = createPublicSpace(
+ session, "SpaceC", listOf(
Triple("C1", true /*auto-join*/, true/*canonical*/),
Triple("C2", true, true)
- ))
+ )
+ )
// add C as a subspace of A
val spaceA = session.spaceService().getSpace(spaceAInfo.spaceId)
@@ -296,16 +306,20 @@ class SpaceHierarchyTest : InstrumentedTest {
val commonTestHelper = CommonTestHelper(context())
val session = commonTestHelper.createAccount("John", SessionTestParams(true))
- val spaceAInfo = createPublicSpace(session, "SpaceA", listOf(
+ val spaceAInfo = createPublicSpace(
+ session, "SpaceA", listOf(
Triple("A1", true /*auto-join*/, true/*canonical*/),
Triple("A2", true, true)
- ))
+ )
+ )
- val spaceBInfo = createPublicSpace(session, "SpaceB", listOf(
+ val spaceBInfo = createPublicSpace(
+ session, "SpaceB", listOf(
Triple("B1", true /*auto-join*/, true/*canonical*/),
Triple("B2", true, true),
Triple("B3", true, true)
- ))
+ )
+ )
// add B as a subspace of A
val spaceA = session.spaceService().getSpace(spaceAInfo.spaceId)
@@ -315,10 +329,12 @@ class SpaceHierarchyTest : InstrumentedTest {
session.spaceService().setSpaceParent(spaceBInfo.spaceId, spaceAInfo.spaceId, true, viaServers)
}
- val spaceCInfo = createPublicSpace(session, "SpaceC", listOf(
+ val spaceCInfo = createPublicSpace(
+ session, "SpaceC", listOf(
Triple("C1", true /*auto-join*/, true/*canonical*/),
Triple("C2", true, true)
- ))
+ )
+ )
commonTestHelper.waitWithLatch { latch ->
@@ -446,21 +462,27 @@ class SpaceHierarchyTest : InstrumentedTest {
val commonTestHelper = CommonTestHelper(context())
val session = commonTestHelper.createAccount("John", SessionTestParams(true))
- /* val spaceAInfo = */ createPublicSpace(session, "SpaceA", listOf(
+ /* val spaceAInfo = */ createPublicSpace(
+ session, "SpaceA", listOf(
Triple("A1", true /*auto-join*/, true/*canonical*/),
Triple("A2", true, true)
- ))
+ )
+ )
- val spaceBInfo = createPublicSpace(session, "SpaceB", listOf(
+ val spaceBInfo = createPublicSpace(
+ session, "SpaceB", listOf(
Triple("B1", true /*auto-join*/, true/*canonical*/),
Triple("B2", true, true),
Triple("B3", true, true)
- ))
+ )
+ )
- val spaceCInfo = createPublicSpace(session, "SpaceC", listOf(
+ val spaceCInfo = createPublicSpace(
+ session, "SpaceC", listOf(
Triple("C1", true /*auto-join*/, true/*canonical*/),
Triple("C2", true, true)
- ))
+ )
+ )
val viaServers = listOf(session.sessionParams.homeServerHost ?: "")
@@ -494,10 +516,12 @@ class SpaceHierarchyTest : InstrumentedTest {
val aliceSession = commonTestHelper.createAccount("Alice", SessionTestParams(true))
val bobSession = commonTestHelper.createAccount("Bib", SessionTestParams(true))
- val spaceAInfo = createPrivateSpace(aliceSession, "Private Space A", listOf(
+ val spaceAInfo = createPrivateSpace(
+ aliceSession, "Private Space A", listOf(
Triple("General", true /*suggested*/, true/*canonical*/),
Triple("Random", true, true)
- ))
+ )
+ )
commonTestHelper.runBlockingTest {
aliceSession.getRoom(spaceAInfo.spaceId)!!.membershipService().invite(bobSession.myUserId, null)
diff --git a/matrix-sdk-android/src/main/java/org/commonmark/ext/maths/internal/MathsHtmlNodeRenderer.kt b/matrix-sdk-android/src/main/java/org/commonmark/ext/maths/internal/MathsHtmlNodeRenderer.kt
index 0efecbbe8a..83fcae7190 100644
--- a/matrix-sdk-android/src/main/java/org/commonmark/ext/maths/internal/MathsHtmlNodeRenderer.kt
+++ b/matrix-sdk-android/src/main/java/org/commonmark/ext/maths/internal/MathsHtmlNodeRenderer.kt
@@ -28,8 +28,12 @@ internal class MathsHtmlNodeRenderer(private val context: HtmlNodeRendererContex
val display = node.javaClass == DisplayMaths::class.java
val contents = node.firstChild // should be the only child
val latex = (contents as Text).literal
- val attributes = context.extendAttributes(node, if (display) "div" else "span", Collections.singletonMap("data-mx-maths",
- latex))
+ val attributes = context.extendAttributes(
+ node, if (display) "div" else "span", Collections.singletonMap(
+ "data-mx-maths",
+ latex
+ )
+ )
html.tag(if (display) "div" else "span", attributes)
html.tag("code")
context.render(contents)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/Matrix.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/Matrix.kt
index 217f7e3da8..e7d1e64a2b 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/Matrix.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/Matrix.kt
@@ -132,9 +132,11 @@ class Matrix private constructor(context: Context, matrixConfiguration: MatrixCo
val matrixConfiguration = (appContext as MatrixConfiguration.Provider).providesMatrixConfiguration()
instance = Matrix(appContext, matrixConfiguration)
} else {
- throw IllegalStateException("Matrix is not initialized properly." +
- " If you want to manage your own Matrix instance use Matrix.createInstance" +
- " otherwise you should call Matrix.initialize or let your application implement MatrixConfiguration.Provider.")
+ throw IllegalStateException(
+ "Matrix is not initialized properly." +
+ " If you want to manage your own Matrix instance use Matrix.createInstance" +
+ " otherwise you should call Matrix.initialize or let your application implement MatrixConfiguration.Provider."
+ )
}
}
return instance
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/converter.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/converter.kt
index 1a4c1ee51c..80630bc4e7 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/converter.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/converter.kt
@@ -1,127 +1,129 @@
-/*
- * 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.api.auth
-
-import org.matrix.android.sdk.api.auth.data.LocalizedFlowDataLoginTerms
-import org.matrix.android.sdk.api.auth.registration.TermPolicies
-
-/**
- * This method extract the policies from the login terms parameter, regarding the user language.
- * For each policy, if user language is not found, the default language is used and if not found, the first url and name are used (not predictable)
- *
- * Example of Data:
- *
- * "m.login.terms": {
- * "policies": {
- * "privacy_policy": {
- * "version": "1.0",
- * "en": {
- * "url": "http:\/\/matrix.org\/_matrix\/consent?v=1.0",
- * "name": "Terms and Conditions"
- * }
- * }
- * }
- * }
- *
- *
- * @param userLanguage the user language
- * @param defaultLanguage the default language to use if the user language is not found for a policy in registrationFlowResponse
- */
-fun TermPolicies.toLocalizedLoginTerms(userLanguage: String,
- defaultLanguage: String = "en"): List {
- val result = ArrayList()
-
- val policies = get("policies")
- if (policies is Map<*, *>) {
- policies.keys.forEach { policyName ->
- val localizedFlowDataLoginTermsPolicyName = policyName as String
- var localizedFlowDataLoginTermsVersion: String? = null
- var localizedFlowDataLoginTermsLocalizedUrl: String? = null
- var localizedFlowDataLoginTermsLocalizedName: String? = null
-
- val policy = policies[policyName]
-
- // Enter this policy
- if (policy is Map<*, *>) {
- // Version
- localizedFlowDataLoginTermsVersion = policy["version"] as String?
-
- var userLanguageUrlAndName: UrlAndName? = null
- var defaultLanguageUrlAndName: UrlAndName? = null
- var firstUrlAndName: UrlAndName? = null
-
- // Search for language
- policy.keys.forEach { policyKey ->
- when (policyKey) {
- "version" -> Unit // Ignore
- userLanguage -> {
- // We found the data for the user language
- userLanguageUrlAndName = extractUrlAndName(policy[policyKey])
- }
- defaultLanguage -> {
- // We found default language
- defaultLanguageUrlAndName = extractUrlAndName(policy[policyKey])
- }
- else -> {
- if (firstUrlAndName == null) {
- // Get at least some data
- firstUrlAndName = extractUrlAndName(policy[policyKey])
- }
- }
- }
- }
-
- // Copy found language data by priority
- when {
- userLanguageUrlAndName != null -> {
- localizedFlowDataLoginTermsLocalizedUrl = userLanguageUrlAndName!!.url
- localizedFlowDataLoginTermsLocalizedName = userLanguageUrlAndName!!.name
- }
- defaultLanguageUrlAndName != null -> {
- localizedFlowDataLoginTermsLocalizedUrl = defaultLanguageUrlAndName!!.url
- localizedFlowDataLoginTermsLocalizedName = defaultLanguageUrlAndName!!.name
- }
- firstUrlAndName != null -> {
- localizedFlowDataLoginTermsLocalizedUrl = firstUrlAndName!!.url
- localizedFlowDataLoginTermsLocalizedName = firstUrlAndName!!.name
- }
- }
- }
-
- result.add(LocalizedFlowDataLoginTerms(
- policyName = localizedFlowDataLoginTermsPolicyName,
- version = localizedFlowDataLoginTermsVersion,
- localizedUrl = localizedFlowDataLoginTermsLocalizedUrl,
- localizedName = localizedFlowDataLoginTermsLocalizedName
- ))
- }
- }
-
- return result
-}
-
-private fun extractUrlAndName(policyData: Any?): UrlAndName? {
- if (policyData is Map<*, *>) {
- val url = policyData["url"] as String?
- val name = policyData["name"] as String?
-
- if (url != null && name != null) {
- return UrlAndName(url, name)
- }
- }
- return null
-}
+/*
+ * 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.api.auth
+
+import org.matrix.android.sdk.api.auth.data.LocalizedFlowDataLoginTerms
+import org.matrix.android.sdk.api.auth.registration.TermPolicies
+
+/**
+ * This method extract the policies from the login terms parameter, regarding the user language.
+ * For each policy, if user language is not found, the default language is used and if not found, the first url and name are used (not predictable)
+ *
+ * Example of Data:
+ *
+ * "m.login.terms": {
+ * "policies": {
+ * "privacy_policy": {
+ * "version": "1.0",
+ * "en": {
+ * "url": "http:\/\/matrix.org\/_matrix\/consent?v=1.0",
+ * "name": "Terms and Conditions"
+ * }
+ * }
+ * }
+ * }
+ *
+ *
+ * @param userLanguage the user language
+ * @param defaultLanguage the default language to use if the user language is not found for a policy in registrationFlowResponse
+ */
+fun TermPolicies.toLocalizedLoginTerms(userLanguage: String,
+ defaultLanguage: String = "en"): List {
+ val result = ArrayList()
+
+ val policies = get("policies")
+ if (policies is Map<*, *>) {
+ policies.keys.forEach { policyName ->
+ val localizedFlowDataLoginTermsPolicyName = policyName as String
+ var localizedFlowDataLoginTermsVersion: String? = null
+ var localizedFlowDataLoginTermsLocalizedUrl: String? = null
+ var localizedFlowDataLoginTermsLocalizedName: String? = null
+
+ val policy = policies[policyName]
+
+ // Enter this policy
+ if (policy is Map<*, *>) {
+ // Version
+ localizedFlowDataLoginTermsVersion = policy["version"] as String?
+
+ var userLanguageUrlAndName: UrlAndName? = null
+ var defaultLanguageUrlAndName: UrlAndName? = null
+ var firstUrlAndName: UrlAndName? = null
+
+ // Search for language
+ policy.keys.forEach { policyKey ->
+ when (policyKey) {
+ "version" -> Unit // Ignore
+ userLanguage -> {
+ // We found the data for the user language
+ userLanguageUrlAndName = extractUrlAndName(policy[policyKey])
+ }
+ defaultLanguage -> {
+ // We found default language
+ defaultLanguageUrlAndName = extractUrlAndName(policy[policyKey])
+ }
+ else -> {
+ if (firstUrlAndName == null) {
+ // Get at least some data
+ firstUrlAndName = extractUrlAndName(policy[policyKey])
+ }
+ }
+ }
+ }
+
+ // Copy found language data by priority
+ when {
+ userLanguageUrlAndName != null -> {
+ localizedFlowDataLoginTermsLocalizedUrl = userLanguageUrlAndName!!.url
+ localizedFlowDataLoginTermsLocalizedName = userLanguageUrlAndName!!.name
+ }
+ defaultLanguageUrlAndName != null -> {
+ localizedFlowDataLoginTermsLocalizedUrl = defaultLanguageUrlAndName!!.url
+ localizedFlowDataLoginTermsLocalizedName = defaultLanguageUrlAndName!!.name
+ }
+ firstUrlAndName != null -> {
+ localizedFlowDataLoginTermsLocalizedUrl = firstUrlAndName!!.url
+ localizedFlowDataLoginTermsLocalizedName = firstUrlAndName!!.name
+ }
+ }
+ }
+
+ result.add(
+ LocalizedFlowDataLoginTerms(
+ policyName = localizedFlowDataLoginTermsPolicyName,
+ version = localizedFlowDataLoginTermsVersion,
+ localizedUrl = localizedFlowDataLoginTermsLocalizedUrl,
+ localizedName = localizedFlowDataLoginTermsLocalizedName
+ )
+ )
+ }
+ }
+
+ return result
+}
+
+private fun extractUrlAndName(policyData: Any?): UrlAndName? {
+ if (policyData is Map<*, *>) {
+ val url = policyData["url"] as String?
+ val name = policyData["name"] as String?
+
+ if (url != null && name != null) {
+ return UrlAndName(url, name)
+ }
+ }
+ return null
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/registration/RegistrationFlowResponse.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/registration/RegistrationFlowResponse.kt
index 0da9eb4b7e..2b421f2873 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/registration/RegistrationFlowResponse.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/auth/registration/RegistrationFlowResponse.kt
@@ -88,8 +88,10 @@ fun RegistrationFlowResponse.toFlowResult(): FlowResult {
val isMandatory = flows?.all { type in it.stages.orEmpty() } == true
val stage = when (type) {
- LoginFlowTypes.RECAPTCHA -> Stage.ReCaptcha(isMandatory, ((params?.get(type) as? Map<*, *>)?.get("public_key") as? String)
- ?: "")
+ LoginFlowTypes.RECAPTCHA -> Stage.ReCaptcha(
+ isMandatory, ((params?.get(type) as? Map<*, *>)?.get("public_key") as? String)
+ ?: ""
+ )
LoginFlowTypes.DUMMY -> Stage.Dummy(isMandatory)
LoginFlowTypes.TERMS -> Stage.Terms(isMandatory, params?.get(type) as? TermPolicies ?: emptyMap())
LoginFlowTypes.EMAIL_IDENTITY -> Stage.Email(isMandatory)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/crypto/MXCryptoConfig.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/crypto/MXCryptoConfig.kt
index 9a686de2e1..9507ddda65 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/crypto/MXCryptoConfig.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/crypto/MXCryptoConfig.kt
@@ -31,5 +31,11 @@ data class MXCryptoConfig constructor(
* If set to false, the request will be forwarded to the application layer; in this
* case the application can decide to prompt the user.
*/
- val discardRoomKeyRequestsFromUntrustedDevices: Boolean = true
+ val discardRoomKeyRequestsFromUntrustedDevices: Boolean = true,
+
+ /**
+ * Currently megolm keys are requested to the sender device and to all of our devices.
+ * You can limit request only to your sessions by turning this setting to `true`
+ */
+ val limitRoomKeyRequestsToMyDevices: Boolean = false,
)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt
index d6d1248de7..b8c08d23dc 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt
@@ -26,6 +26,7 @@ import org.matrix.android.sdk.api.session.crypto.crosssigning.CrossSigningServic
import org.matrix.android.sdk.api.session.crypto.crosssigning.DeviceTrustLevel
import org.matrix.android.sdk.api.session.crypto.keysbackup.KeysBackupService
import org.matrix.android.sdk.api.session.crypto.keyshare.GossipingRequestListener
+import org.matrix.android.sdk.api.session.crypto.model.AuditTrail
import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.DeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.DevicesListResponse
@@ -35,8 +36,6 @@ import org.matrix.android.sdk.api.session.crypto.model.MXDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.MXEncryptEventContentResult
import org.matrix.android.sdk.api.session.crypto.model.MXEventDecryptionResult
import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
import org.matrix.android.sdk.api.session.crypto.verification.VerificationService
import org.matrix.android.sdk.api.session.events.model.Content
import org.matrix.android.sdk.api.session.events.model.Event
@@ -76,6 +75,15 @@ interface CryptoService {
fun setGlobalBlacklistUnverifiedDevices(block: Boolean)
+ /**
+ * Enable or disable key gossiping.
+ * Default is true.
+ * If set to false this device won't send key_request nor will accept key forwarded
+ */
+ fun enableKeyGossiping(enable: Boolean)
+
+ fun isKeyGossipingEnabled(): Boolean
+
fun setRoomUnBlacklistUnverifiedDevices(roomId: String)
fun getDeviceTrackingStatus(userId: String): Int
@@ -94,8 +102,6 @@ interface CryptoService {
fun reRequestRoomKeyForEvent(event: Event)
- fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody)
-
fun addRoomKeysRequestListener(listener: GossipingRequestListener)
fun removeRoomKeysRequestListener(listener: GossipingRequestListener)
@@ -142,14 +148,20 @@ interface CryptoService {
fun addNewSessionListener(newSessionListener: NewSessionListener)
fun removeSessionListener(listener: NewSessionListener)
- fun getOutgoingRoomKeyRequests(): List
- fun getOutgoingRoomKeyRequestsPaged(): LiveData>
+ fun getOutgoingRoomKeyRequests(): List
+ fun getOutgoingRoomKeyRequestsPaged(): LiveData>
fun getIncomingRoomKeyRequests(): List
fun getIncomingRoomKeyRequestsPaged(): LiveData>
- fun getGossipingEventsTrail(): LiveData>
- fun getGossipingEvents(): List
+ /**
+ * Can be called by the app layer to accept a request manually
+ * Use carefully as it is prone to social attacks
+ */
+ suspend fun manuallyAcceptRoomKeyRequest(request: IncomingRoomKeyRequest)
+
+ fun getGossipingEventsTrail(): LiveData>
+ fun getGossipingEvents(): List
// For testing shared session
fun getSharedWithInfo(roomId: String?, sessionId: String): MXUsersDevicesMap
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/OutgoingKeyRequest.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/OutgoingKeyRequest.kt
new file mode 100644
index 0000000000..855f17a34f
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/OutgoingKeyRequest.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2022 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.api.session.crypto
+
+import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
+import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
+
+data class RequestReply(
+ val userId: String,
+ val fromDevice: String?,
+ val result: RequestResult
+)
+
+sealed class RequestResult {
+ data class Success(val chainIndex: Int) : RequestResult()
+ data class Failure(val code: WithHeldCode) : RequestResult()
+}
+
+data class OutgoingKeyRequest(
+ var requestBody: RoomKeyRequestBody?,
+ // recipients for the request map of users to list of deviceId
+ val recipients: Map>,
+ val fromIndex: Int,
+ // Unique id for this request. Used for both
+ // an id within the request for later pairing with a cancellation, and for
+ // the transaction id when sending the to_device messages to our local
+ val requestId: String, // current state of this request
+ val state: OutgoingRoomKeyRequestState,
+ val results: List
+) {
+ /**
+ * Used only for log.
+ *
+ * @return the room id.
+ */
+ val roomId = requestBody?.roomId
+
+ /**
+ * Used only for log.
+ *
+ * @return the session id
+ */
+ val sessionId = requestBody?.sessionId
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequest.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/OutgoingRoomKeyRequestState.kt
similarity index 55%
rename from matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequest.kt
rename to matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/OutgoingRoomKeyRequestState.kt
index 2438e01102..6e80bdc133 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequest.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/OutgoingRoomKeyRequestState.kt
@@ -1,5 +1,5 @@
/*
- * Copyright 2020 The Matrix.org Foundation C.I.C.
+ * Copyright (c) 2022 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.
@@ -14,14 +14,20 @@
* limitations under the License.
*/
-package org.matrix.android.sdk.internal.crypto
+package org.matrix.android.sdk.api.session.crypto
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
+enum class OutgoingRoomKeyRequestState {
+ UNSENT,
+ SENT,
+ SENT_THEN_CANCELED,
+ CANCELLATION_PENDING,
+ CANCELLATION_PENDING_AND_WILL_RESEND;
-internal interface OutgoingGossipingRequest {
- val recipients: Map>
- val requestId: String
- val state: OutgoingGossipingRequestState
- // transaction id for the cancellation, if any
- // var cancellationTxnId: String?
+ companion object {
+ fun pendingStates() = setOf(
+ UNSENT,
+ CANCELLATION_PENDING_AND_WILL_RESEND,
+ CANCELLATION_PENDING
+ )
+ }
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/crosssigning/CryptoCrossSigningKey.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/crosssigning/CryptoCrossSigningKey.kt
index 11996e673e..70ff76a4ef 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/crosssigning/CryptoCrossSigningKey.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/crosssigning/CryptoCrossSigningKey.kt
@@ -93,7 +93,8 @@ data class CryptoCrossSigningKey(
userId = userId,
usages = listOf(usage.value),
keys = mapOf("ed25519:$b64key" to b64key),
- signatures = signMap)
+ signatures = signMap
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/keyshare/GossipingRequestListener.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/keyshare/GossipingRequestListener.kt
index 3cd36c2ce8..24d3cf4004 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/keyshare/GossipingRequestListener.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/keyshare/GossipingRequestListener.kt
@@ -16,9 +16,8 @@
package org.matrix.android.sdk.api.session.crypto.keyshare
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRequestCancellation
import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.IncomingSecretShareRequest
+import org.matrix.android.sdk.api.session.crypto.model.SecretShareRequest
/**
* Room keys events listener
@@ -35,12 +34,12 @@ interface GossipingRequestListener {
* Returns the secret value to be shared
* @return true if is handled
*/
- fun onSecretShareRequest(request: IncomingSecretShareRequest): Boolean
+ fun onSecretShareRequest(request: SecretShareRequest): Boolean
/**
* A room key request cancellation has been received.
*
* @param request the cancellation request
*/
- fun onRoomKeyRequestCancellation(request: IncomingRequestCancellation)
+ fun onRequestCancelled(request: IncomingRoomKeyRequest)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/AuditTrail.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/AuditTrail.kt
new file mode 100644
index 0000000000..861f3bd30b
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/AuditTrail.kt
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2022 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.api.session.crypto.model
+
+import com.squareup.moshi.JsonClass
+import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
+
+enum class TrailType {
+ OutgoingKeyForward,
+ IncomingKeyForward,
+ OutgoingKeyWithheld,
+ IncomingKeyRequest,
+ Unknown
+}
+
+interface AuditInfo {
+ val roomId: String
+ val sessionId: String
+ val senderKey: String
+ val alg: String
+ val userId: String
+ val deviceId: String
+}
+
+@JsonClass(generateAdapter = true)
+data class ForwardInfo(
+ override val roomId: String,
+ override val sessionId: String,
+ override val senderKey: String,
+ override val alg: String,
+ override val userId: String,
+ override val deviceId: String,
+ val chainIndex: Long?
+) : AuditInfo
+
+object UnknownInfo : AuditInfo {
+ override val roomId: String = ""
+ override val sessionId: String = ""
+ override val senderKey: String = ""
+ override val alg: String = ""
+ override val userId: String = ""
+ override val deviceId: String = ""
+}
+
+@JsonClass(generateAdapter = true)
+data class WithheldInfo(
+ override val roomId: String,
+ override val sessionId: String,
+ override val senderKey: String,
+ override val alg: String,
+ val code: WithHeldCode,
+ override val userId: String,
+ override val deviceId: String
+) : AuditInfo
+
+@JsonClass(generateAdapter = true)
+data class IncomingKeyRequestInfo(
+ override val roomId: String,
+ override val sessionId: String,
+ override val senderKey: String,
+ override val alg: String,
+ override val userId: String,
+ override val deviceId: String,
+ val requestId: String
+) : AuditInfo
+
+data class AuditTrail(
+ val ageLocalTs: Long,
+ val type: TrailType,
+ val info: AuditInfo
+)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRequestCancellation.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRequestCancellation.kt
deleted file mode 100755
index 74ca7304f7..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRequestCancellation.kt
+++ /dev/null
@@ -1,63 +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.api.session.crypto.model
-
-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.IncomingShareRequestCommon
-import org.matrix.android.sdk.internal.crypto.model.rest.ShareRequestCancellation
-
-/**
- * IncomingRequestCancellation describes the incoming room key cancellation.
- */
-data class IncomingRequestCancellation(
- /**
- * The user id
- */
- override val userId: String? = null,
-
- /**
- * The device id
- */
- override val deviceId: String? = null,
-
- /**
- * The request id
- */
- override val requestId: String? = null,
- override val localCreationTimestamp: Long?
-) : IncomingShareRequestCommon {
- companion object {
- /**
- * Factory
- *
- * @param event the event
- */
- fun fromEvent(event: Event): IncomingRequestCancellation? {
- return event.getClearContent()
- .toModel()
- ?.let {
- IncomingRequestCancellation(
- userId = event.senderId,
- deviceId = it.requestingDeviceId,
- requestId = it.requestId,
- localCreationTimestamp = event.ageLocalTs ?: System.currentTimeMillis()
- )
- }
- }
- }
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRoomKeyRequest.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRoomKeyRequest.kt
index 45b0926d89..0a28478a10 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRoomKeyRequest.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingRoomKeyRequest.kt
@@ -16,9 +16,7 @@
package org.matrix.android.sdk.api.session.crypto.model
-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.IncomingShareRequestCommon
+import org.matrix.android.sdk.internal.util.time.Clock
/**
* IncomingRoomKeyRequest class defines the incoming room keys request.
@@ -27,56 +25,62 @@ data class IncomingRoomKeyRequest(
/**
* The user id
*/
- override val userId: String? = null,
+ val userId: String? = null,
/**
* The device id
*/
- override val deviceId: String? = null,
+ val deviceId: String? = null,
/**
* The request id
*/
- override val requestId: String? = null,
+ val requestId: String? = null,
/**
* The request body
*/
val requestBody: RoomKeyRequestBody? = null,
- val state: GossipingRequestState = GossipingRequestState.NONE,
-
- /**
- * The runnable to call to accept to share the keys
- */
- @Transient
- var share: Runnable? = null,
-
- /**
- * The runnable to call to ignore the key share request.
- */
- @Transient
- var ignore: Runnable? = null,
- override val localCreationTimestamp: Long?
-) : IncomingShareRequestCommon {
+ val localCreationTimestamp: Long?
+) {
companion object {
/**
* Factory
*
* @param event the event
+ * @param currentTimeMillis the current time in milliseconds
*/
- fun fromEvent(event: Event): IncomingRoomKeyRequest? {
- return event.getClearContent()
- .toModel()
+ fun fromEvent(trail: AuditTrail): IncomingRoomKeyRequest? {
+ return trail
+ .takeIf { it.type == TrailType.IncomingKeyRequest }
+ ?.let {
+ it.info as? IncomingKeyRequestInfo
+ }
?.let {
IncomingRoomKeyRequest(
- userId = event.senderId,
- deviceId = it.requestingDeviceId,
+ userId = it.userId,
+ deviceId = it.deviceId,
requestId = it.requestId,
- requestBody = it.body ?: RoomKeyRequestBody(),
- localCreationTimestamp = event.ageLocalTs ?: System.currentTimeMillis()
+ requestBody = RoomKeyRequestBody(
+ algorithm = it.alg,
+ roomId = it.roomId,
+ senderKey = it.senderKey,
+ sessionId = it.sessionId
+ ),
+ localCreationTimestamp = trail.ageLocalTs
)
}
}
+
+ internal fun fromRestRequest(senderId: String, request: RoomKeyShareRequest, clock: Clock): IncomingRoomKeyRequest? {
+ return IncomingRoomKeyRequest(
+ userId = senderId,
+ deviceId = request.requestingDeviceId,
+ requestId = request.requestId,
+ requestBody = request.body,
+ localCreationTimestamp = clock.epochMillis()
+ )
+ }
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingSecretShareRequest.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingSecretShareRequest.kt
deleted file mode 100755
index 5afffef1ae..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/IncomingSecretShareRequest.kt
+++ /dev/null
@@ -1,82 +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.api.session.crypto.model
-
-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.IncomingShareRequestCommon
-
-/**
- * IncomingSecretShareRequest class defines the incoming secret keys request.
- */
-data class IncomingSecretShareRequest(
- /**
- * The user id
- */
- override val userId: String? = null,
-
- /**
- * The device id
- */
- override val deviceId: String? = null,
-
- /**
- * The request id
- */
- override val requestId: String? = null,
-
- /**
- * The request body
- */
- val secretName: String? = null,
-
- /**
- * The runnable to call to accept to share the keys
- */
- @Transient
- var share: ((String) -> Unit)? = null,
-
- /**
- * The runnable to call to ignore the key share request.
- */
- @Transient
- var ignore: Runnable? = null,
-
- override val localCreationTimestamp: Long?
-
-) : IncomingShareRequestCommon {
- companion object {
- /**
- * Factory
- *
- * @param event the event
- */
- fun fromEvent(event: Event): IncomingSecretShareRequest? {
- return event.getClearContent()
- .toModel()
- ?.let {
- IncomingSecretShareRequest(
- userId = event.senderId,
- deviceId = it.requestingDeviceId,
- requestId = it.requestId,
- secretName = it.secretName,
- localCreationTimestamp = event.ageLocalTs ?: System.currentTimeMillis()
- )
- }
- }
- }
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/OutgoingRoomKeyRequest.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/OutgoingRoomKeyRequest.kt
deleted file mode 100755
index 5f35cc908f..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/model/OutgoingRoomKeyRequest.kt
+++ /dev/null
@@ -1,55 +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.api.session.crypto.model
-
-import com.squareup.moshi.JsonClass
-import org.matrix.android.sdk.internal.crypto.OutgoingGossipingRequest
-
-/**
- * Represents an outgoing room key request
- */
-@JsonClass(generateAdapter = true)
-data class OutgoingRoomKeyRequest(
- // RequestBody
- val requestBody: RoomKeyRequestBody?,
- // list of recipients for the request
- override val recipients: Map>,
- // Unique id for this request. Used for both
- // an id within the request for later pairing with a cancellation, and for
- // the transaction id when sending the to_device messages to our local
- override val requestId: String, // current state of this request
- override val state: OutgoingGossipingRequestState
- // transaction id for the cancellation, if any
- // override var cancellationTxnId: String? = null
-) : OutgoingGossipingRequest {
-
- /**
- * Used only for log.
- *
- * @return the room id.
- */
- val roomId: String?
- get() = requestBody?.roomId
-
- /**
- * Used only for log.
- *
- * @return the session id
- */
- val sessionId: String?
- get() = requestBody?.sessionId
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/verification/VerificationService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/verification/VerificationService.kt
index b9d0c0ad2c..ec67e4b31d 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/verification/VerificationService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/verification/VerificationService.kt
@@ -129,11 +129,10 @@ interface VerificationService {
private const val TEN_MINUTES_IN_MILLIS = 10 * 60 * 1000
private const val FIVE_MINUTES_IN_MILLIS = 5 * 60 * 1000
- fun isValidRequest(age: Long?): Boolean {
+ fun isValidRequest(age: Long?, currentTimeMillis: Long): Boolean {
if (age == null) return false
- val now = System.currentTimeMillis()
- val tooInThePast = now - TEN_MINUTES_IN_MILLIS
- val tooInTheFuture = now + FIVE_MINUTES_IN_MILLIS
+ val tooInThePast = currentTimeMillis - TEN_MINUTES_IN_MILLIS
+ val tooInTheFuture = currentTimeMillis + FIVE_MINUTES_IN_MILLIS
return age in tooInThePast..tooInTheFuture
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/events/model/content/RoomKeyWithHeldContent.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/events/model/content/RoomKeyWithHeldContent.kt
index a577daf9e4..1eac1d6b2d 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/events/model/content/RoomKeyWithHeldContent.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/events/model/content/RoomKeyWithHeldContent.kt
@@ -52,7 +52,13 @@ data class RoomKeyWithHeldContent(
/**
* A human-readable reason for why the key was not sent. The receiving client should only use this string if it does not understand the code.
*/
- @Json(name = "reason") val reason: String? = null
+ @Json(name = "reason") val reason: String? = null,
+
+ /**
+ * the device ID of the device sending the m.room_key.withheld message
+ * MSC3735
+ */
+ @Json(name = "from_device") val fromDevice: String? = null
) {
val code: WithHeldCode?
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/file/FileService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/file/FileService.kt
index e3ccbad249..8e930f2a50 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/file/FileService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/file/FileService.kt
@@ -68,7 +68,8 @@ interface FileService {
mxcUrl = messageContent.getFileUrl(),
fileName = messageContent.getFileName(),
mimeType = messageContent.mimeType,
- elementToDecrypt = messageContent.encryptedFileInfo?.toElementToDecrypt())
+ elementToDecrypt = messageContent.encryptedFileInfo?.toElementToDecrypt()
+ )
/**
* Use this URI and pass it to intent using flag Intent.FLAG_GRANT_READ_URI_PERMISSION
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/securestorage/SharedSecretStorageService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/securestorage/SharedSecretStorageService.kt
index 721a2bc8af..3bb8fad810 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/securestorage/SharedSecretStorageService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/securestorage/SharedSecretStorageService.kt
@@ -131,7 +131,7 @@ interface SharedSecretStorageService {
fun checkShouldBeAbleToAccessSecrets(secretNames: List, keyId: String?): IntegrityResult
- fun requestSecret(name: String, myOtherDeviceId: String)
+ suspend fun requestSecret(name: String, myOtherDeviceId: String)
data class KeyRef(
val keyId: String?,
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/DefaultAuthenticationService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/DefaultAuthenticationService.kt
index 8784d85c10..f1cfe3fee5 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/DefaultAuthenticationService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/DefaultAuthenticationService.kt
@@ -379,24 +379,33 @@ internal class DefaultAuthenticationService @Inject constructor(
throw MatrixIdFailure.InvalidMatrixId
}
- return getWellknownTask.execute(GetWellknownTask.Params(
- domain = matrixId.getDomain(),
- homeServerConnectionConfig = homeServerConnectionConfig)
+ return getWellknownTask.execute(
+ GetWellknownTask.Params(
+ domain = matrixId.getDomain(),
+ homeServerConnectionConfig = homeServerConnectionConfig.orWellKnownDefaults()
+ )
)
}
+ private fun HomeServerConnectionConfig?.orWellKnownDefaults() = this ?: HomeServerConnectionConfig.Builder()
+ // server uri is ignored when doing a wellknown lookup as we use the matrix id domain instead
+ .withHomeServerUri("https://dummy.org")
+ .build()
+
override suspend fun directAuthentication(homeServerConnectionConfig: HomeServerConnectionConfig,
matrixId: String,
password: String,
initialDeviceName: String,
deviceId: String?): Session {
- return directLoginTask.execute(DirectLoginTask.Params(
- homeServerConnectionConfig = homeServerConnectionConfig,
- userId = matrixId,
- password = password,
- deviceName = initialDeviceName,
- deviceId = deviceId
- ))
+ return directLoginTask.execute(
+ DirectLoginTask.Params(
+ homeServerConnectionConfig = homeServerConnectionConfig,
+ userId = matrixId,
+ password = password,
+ deviceName = initialDeviceName,
+ deviceId = deviceId
+ )
+ )
}
private fun buildAuthAPI(homeServerConnectionConfig: HomeServerConnectionConfig): AuthAPI {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/AuthRealmModule.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/AuthRealmModule.kt
index a92384b4ed..08d683af7f 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/AuthRealmModule.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/AuthRealmModule.kt
@@ -21,9 +21,11 @@ import io.realm.annotations.RealmModule
/**
* Realm module for authentication classes
*/
-@RealmModule(library = true,
+@RealmModule(
+ library = true,
classes = [
SessionParamsEntity::class,
PendingSessionEntity::class
- ])
+ ]
+)
internal class AuthRealmModule
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/PendingSessionMapper.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/PendingSessionMapper.kt
index 8e4043c11b..1296ea7cc4 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/PendingSessionMapper.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/PendingSessionMapper.kt
@@ -44,7 +44,8 @@ internal class PendingSessionMapper @Inject constructor(moshi: Moshi) {
resetPasswordData = resetPasswordData,
currentSession = entity.currentSession,
isRegistrationStarted = entity.isRegistrationStarted,
- currentThreePidData = threePidData)
+ currentThreePidData = threePidData
+ )
}
fun map(sessionData: PendingSessionData?): PendingSessionEntity? {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/SessionParamsMapper.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/SessionParamsMapper.kt
index 147c0e8be0..86929b1afe 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/SessionParamsMapper.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/db/SessionParamsMapper.kt
@@ -54,6 +54,7 @@ internal class SessionParamsMapper @Inject constructor(moshi: Moshi) {
sessionParams.userId,
credentialsJson,
homeServerConnectionConfigJson,
- sessionParams.isTokenValid)
+ sessionParams.isTokenValid
+ )
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/registration/DefaultRegistrationWizard.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/registration/DefaultRegistrationWizard.kt
index 590b333e90..890cb68aad 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/registration/DefaultRegistrationWizard.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/registration/DefaultRegistrationWizard.kt
@@ -120,21 +120,25 @@ internal class DefaultRegistrationWizard(
RegisterAddThreePidTask.Params(
threePid,
pendingSessionData.clientSecret,
- pendingSessionData.sendAttempt))
+ pendingSessionData.sendAttempt
+ )
+ )
pendingSessionData = pendingSessionData.copy(sendAttempt = pendingSessionData.sendAttempt + 1)
.also { pendingSessionStore.savePendingSessionData(it) }
val params = RegistrationParams(
auth = if (threePid is RegisterThreePid.Email) {
- AuthParams.createForEmailIdentity(safeSession,
+ AuthParams.createForEmailIdentity(
+ safeSession,
ThreePidCredentials(
clientSecret = pendingSessionData.clientSecret,
sid = response.sid
)
)
} else {
- AuthParams.createForMsisdnIdentity(safeSession,
+ AuthParams.createForMsisdnIdentity(
+ safeSession,
ThreePidCredentials(
clientSecret = pendingSessionData.clientSecret,
sid = response.sid
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/version/Versions.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/version/Versions.kt
index d07d5ecd64..203dbcc60e 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/version/Versions.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/version/Versions.kt
@@ -74,8 +74,8 @@ internal fun Versions.isLoginAndRegistrationSupportedBySdk(): Boolean {
* Indicate if the homeserver support MSC3440 for threads
*/
internal fun Versions.doesServerSupportThreads(): Boolean {
- return getMaxVersion() >= HomeServerVersion.v1_3_0 ||
- unstableFeatures?.get(FEATURE_THREADS_MSC3440_STABLE) ?: false
+ // TODO: Check for v1.3 or whichever spec version formally specifies MSC3440.
+ return unstableFeatures?.get(FEATURE_THREADS_MSC3440_STABLE) ?: false
}
/**
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CancelGossipRequestWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CancelGossipRequestWorker.kt
deleted file mode 100644
index 4380e31bff..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/CancelGossipRequestWorker.kt
+++ /dev/null
@@ -1,121 +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
-
-import android.content.Context
-import androidx.work.WorkerParameters
-import com.squareup.moshi.JsonClass
-import org.matrix.android.sdk.api.auth.data.Credentials
-import org.matrix.android.sdk.api.failure.shouldBeRetried
-import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
-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.toContent
-import org.matrix.android.sdk.internal.SessionManager
-import org.matrix.android.sdk.internal.crypto.model.rest.ShareRequestCancellation
-import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
-import org.matrix.android.sdk.internal.crypto.tasks.createUniqueTxnId
-import org.matrix.android.sdk.internal.session.SessionComponent
-import org.matrix.android.sdk.internal.worker.SessionSafeCoroutineWorker
-import org.matrix.android.sdk.internal.worker.SessionWorkerParams
-import javax.inject.Inject
-
-internal class CancelGossipRequestWorker(context: Context, params: WorkerParameters, sessionManager: SessionManager) :
- SessionSafeCoroutineWorker(context, params, sessionManager, Params::class.java) {
-
- @JsonClass(generateAdapter = true)
- internal data class Params(
- override val sessionId: String,
- val requestId: String,
- val recipients: Map>,
- // The txnId for the sendToDevice request. Nullable for compatibility reasons, but MUST always be provided
- // to use the same value if this worker is retried.
- val txnId: String? = null,
- override val lastFailureMessage: String? = null
- ) : SessionWorkerParams {
- companion object {
- fun fromRequest(sessionId: String, request: OutgoingGossipingRequest): Params {
- return Params(
- sessionId = sessionId,
- requestId = request.requestId,
- recipients = request.recipients,
- txnId = createUniqueTxnId(),
- lastFailureMessage = null
- )
- }
- }
- }
-
- @Inject lateinit var sendToDeviceTask: SendToDeviceTask
- @Inject lateinit var cryptoStore: IMXCryptoStore
- @Inject lateinit var credentials: Credentials
-
- override fun injectWith(injector: SessionComponent) {
- injector.inject(this)
- }
-
- override suspend fun doSafeWork(params: Params): Result {
- // params.txnId should be provided in all cases now. But Params can be deserialized by
- // the WorkManager from data serialized in a previous version of the application, so without the txnId field.
- // So if not present, we create a txnId
- val txnId = params.txnId ?: createUniqueTxnId()
- val contentMap = MXUsersDevicesMap()
- val toDeviceContent = ShareRequestCancellation(
- requestingDeviceId = credentials.deviceId,
- requestId = params.requestId
- )
- cryptoStore.saveGossipingEvent(Event(
- type = EventType.ROOM_KEY_REQUEST,
- content = toDeviceContent.toContent(),
- senderId = credentials.userId
- ).also {
- it.ageLocalTs = System.currentTimeMillis()
- })
-
- params.recipients.forEach { userToDeviceMap ->
- userToDeviceMap.value.forEach { deviceId ->
- contentMap.setObject(userToDeviceMap.key, deviceId, toDeviceContent)
- }
- }
-
- try {
- cryptoStore.updateOutgoingGossipingRequestState(params.requestId, OutgoingGossipingRequestState.CANCELLING)
- sendToDeviceTask.execute(
- SendToDeviceTask.Params(
- eventType = EventType.ROOM_KEY_REQUEST,
- contentMap = contentMap,
- transactionId = txnId
- )
- )
- cryptoStore.updateOutgoingGossipingRequestState(params.requestId, OutgoingGossipingRequestState.CANCELLED)
- return Result.success()
- } catch (throwable: Throwable) {
- return if (throwable.shouldBeRetried()) {
- Result.retry()
- } else {
- cryptoStore.updateOutgoingGossipingRequestState(params.requestId, OutgoingGossipingRequestState.FAILED_TO_CANCEL)
- buildErrorResult(params, throwable.localizedMessage ?: "error")
- }
- }
- }
-
- 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/DefaultCryptoService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
index 6a57d94677..fd4bf6adfd 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
@@ -42,12 +42,14 @@ import org.matrix.android.sdk.api.logger.LoggerTag
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.NewSessionListener
+import org.matrix.android.sdk.api.session.crypto.OutgoingKeyRequest
import org.matrix.android.sdk.api.session.crypto.crosssigning.DeviceTrustLevel
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
import org.matrix.android.sdk.api.session.crypto.crosssigning.SELF_SIGNING_KEY_SSSS_NAME
import org.matrix.android.sdk.api.session.crypto.crosssigning.USER_SIGNING_KEY_SSSS_NAME
import org.matrix.android.sdk.api.session.crypto.keyshare.GossipingRequestListener
+import org.matrix.android.sdk.api.session.crypto.model.AuditTrail
import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.DeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.DevicesListResponse
@@ -57,15 +59,13 @@ import org.matrix.android.sdk.api.session.crypto.model.MXDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.MXEncryptEventContentResult
import org.matrix.android.sdk.api.session.crypto.model.MXEventDecryptionResult
import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
+import org.matrix.android.sdk.api.session.crypto.model.RoomKeyShareRequest
+import org.matrix.android.sdk.api.session.crypto.model.TrailType
import org.matrix.android.sdk.api.session.events.model.Content
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.content.EncryptedEventContent
import org.matrix.android.sdk.api.session.events.model.content.RoomKeyContent
import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
-import org.matrix.android.sdk.api.session.events.model.content.SecretSendEventContent
import org.matrix.android.sdk.api.session.events.model.toModel
import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibility
@@ -76,7 +76,6 @@ import org.matrix.android.sdk.internal.crypto.actions.MegolmSessionDataImporter
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.IMXGroupEncryption
-import org.matrix.android.sdk.internal.crypto.algorithms.IMXWithHeldExtension
import org.matrix.android.sdk.internal.crypto.algorithms.megolm.MXMegolmEncryptionFactory
import org.matrix.android.sdk.internal.crypto.algorithms.olm.MXOlmEncryptionFactory
import org.matrix.android.sdk.internal.crypto.crosssigning.DefaultCrossSigningService
@@ -91,6 +90,7 @@ import org.matrix.android.sdk.internal.crypto.tasks.GetDevicesTask
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.crypto.verification.VerificationMessageProcessor
import org.matrix.android.sdk.internal.di.DeviceId
import org.matrix.android.sdk.internal.di.MoshiProvider
import org.matrix.android.sdk.internal.di.UserId
@@ -103,6 +103,7 @@ import org.matrix.android.sdk.internal.task.TaskThread
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.time.Clock
import org.matrix.olm.OlmManager
import timber.log.Timber
import java.util.concurrent.atomic.AtomicBoolean
@@ -130,6 +131,7 @@ internal class DefaultCryptoService @Inject constructor(
private val userId: String,
@DeviceId
private val deviceId: String?,
+ private val clock: Clock,
private val myDeviceInfoHolder: Lazy,
// the crypto store
private val cryptoStore: IMXCryptoStore,
@@ -154,9 +156,10 @@ internal class DefaultCryptoService @Inject constructor(
private val crossSigningService: DefaultCrossSigningService,
//
- private val incomingGossipingRequestManager: IncomingGossipingRequestManager,
+ private val incomingKeyRequestManager: IncomingKeyRequestManager,
+ private val secretShareManager: SecretShareManager,
//
- private val outgoingGossipingRequestManager: OutgoingGossipingRequestManager,
+ private val outgoingKeyRequestManager: OutgoingKeyRequestManager,
// Actions
private val setDeviceVerificationAction: SetDeviceVerificationAction,
private val megolmSessionDataImporter: MegolmSessionDataImporter,
@@ -176,6 +179,7 @@ internal class DefaultCryptoService @Inject constructor(
private val taskExecutor: TaskExecutor,
private val cryptoCoroutineScope: CoroutineScope,
private val eventDecryptor: EventDecryptor,
+ private val verificationMessageProcessor: VerificationMessageProcessor,
private val liveEventManager: Lazy
) : CryptoService {
@@ -190,7 +194,7 @@ internal class DefaultCryptoService @Inject constructor(
}
}
- fun onLiveEvent(roomId: String, event: Event) {
+ fun onLiveEvent(roomId: String, event: Event, isInitialSync: Boolean) {
// handle state events
if (event.isStateEvent()) {
when (event.type) {
@@ -199,9 +203,18 @@ internal class DefaultCryptoService @Inject constructor(
EventType.STATE_ROOM_HISTORY_VISIBILITY -> onRoomHistoryVisibilityEvent(roomId, event)
}
}
+
+ // handle verification
+ if (!isInitialSync) {
+ if (event.type != null && verificationMessageProcessor.shouldProcess(event.type)) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.dmVerif) {
+ verificationMessageProcessor.process(event)
+ }
+ }
+ }
}
- val gossipingBuffer = mutableListOf()
+// val gossipingBuffer = mutableListOf()
override fun setDeviceName(deviceId: String, deviceName: String, callback: MatrixCallback) {
setDeviceNameTask
@@ -377,27 +390,8 @@ internal class DefaultCryptoService @Inject constructor(
// Open the store
cryptoStore.open()
- runCatching {
-// if (isInitialSync) {
-// // refresh the devices list for each known room members
-// deviceListManager.invalidateAllDeviceLists()
-// deviceListManager.refreshOutdatedDeviceLists()
-// } else {
-
- // Why would we do that? it will be called at end of syn
- incomingGossipingRequestManager.processReceivedGossipingRequests()
-// }
- }.fold(
- {
- isStarting.set(false)
- isStarted.set(true)
- },
- {
- isStarting.set(false)
- isStarted.set(false)
- Timber.tag(loggerTag.value).e(it, "Start failed")
- }
- )
+ isStarting.set(false)
+ isStarted.set(true)
}
/**
@@ -405,7 +399,8 @@ internal class DefaultCryptoService @Inject constructor(
*/
fun close() = runBlocking(coroutineDispatchers.crypto) {
cryptoCoroutineScope.coroutineContext.cancelChildren(CancellationException("Closing crypto module"))
- incomingGossipingRequestManager.close()
+ incomingKeyRequestManager.close()
+ outgoingKeyRequestManager.close()
olmDevice.release()
cryptoStore.close()
}
@@ -470,15 +465,28 @@ internal class DefaultCryptoService @Inject constructor(
}
oneTimeKeysUploader.maybeUploadOneTimeKeys()
- incomingGossipingRequestManager.processReceivedGossipingRequests()
}
- }
- tryOrNull {
- gossipingBuffer.toList().let {
- cryptoStore.saveGossipingEvents(it)
+ // Process pending key requests
+ try {
+ if (toDevices.isEmpty()) {
+ // this is not blocking
+ outgoingKeyRequestManager.requireProcessAllPendingKeyRequests()
+ } else {
+ Timber.tag(loggerTag.value)
+ .w("Don't process key requests yet as there might be more to_device to catchup")
+ }
+ } catch (failure: Throwable) {
+ // just for safety but should not throw
+ Timber.tag(loggerTag.value).w("failed to process pending request")
+ }
+
+ try {
+ incomingKeyRequestManager.processIncomingRequests()
+ } catch (failure: Throwable) {
+ // just for safety but should not throw
+ Timber.tag(loggerTag.value).w("failed to process incoming room key requests")
}
- gossipingBuffer.clear()
}
}
}
@@ -592,7 +600,7 @@ internal class DefaultCryptoService @Inject constructor(
// (for now at least. Maybe we should alert the user somehow?)
val existingAlgorithm = cryptoStore.getRoomAlgorithm(roomId)
- if (existingAlgorithm == algorithm && roomEncryptorsStore.get(roomId) != null) {
+ if (existingAlgorithm == algorithm) {
// ignore
Timber.tag(loggerTag.value).e("setEncryptionInRoom() : Ignoring m.room.encryption for same alg ($algorithm) in $roomId")
return false
@@ -701,17 +709,19 @@ internal class DefaultCryptoService @Inject constructor(
}
val safeAlgorithm = alg
if (safeAlgorithm != null) {
- val t0 = System.currentTimeMillis()
+ val t0 = clock.epochMillis()
Timber.tag(loggerTag.value).v("encryptEventContent() starts")
runCatching {
val content = safeAlgorithm.encryptEventContent(eventContent, eventType, userIds)
- Timber.tag(loggerTag.value).v("## CRYPTO | encryptEventContent() : succeeds after ${System.currentTimeMillis() - t0} ms")
+ Timber.tag(loggerTag.value).v("## CRYPTO | encryptEventContent() : succeeds after ${clock.epochMillis() - t0} ms")
MXEncryptEventContentResult(content, EventType.ENCRYPTED)
}.foldToCallback(callback)
} else {
val algorithm = getEncryptionAlgorithm(roomId)
- val reason = String.format(MXCryptoError.UNABLE_TO_ENCRYPT_REASON,
- algorithm ?: MXCryptoError.NO_MORE_ALGORITHM_REASON)
+ val reason = String.format(
+ MXCryptoError.UNABLE_TO_ENCRYPT_REASON,
+ algorithm ?: MXCryptoError.NO_MORE_ALGORITHM_REASON
+ )
Timber.tag(loggerTag.value).e("encryptEventContent() : failed $reason")
callback.onFailure(Failure.CryptoError(MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_ENCRYPT, reason)))
}
@@ -783,19 +793,25 @@ internal class DefaultCryptoService @Inject constructor(
cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
when (event.getClearType()) {
EventType.ROOM_KEY, EventType.FORWARDED_ROOM_KEY -> {
- gossipingBuffer.add(event)
// Keys are imported directly, not waiting for end of sync
onRoomKeyEvent(event)
}
- EventType.REQUEST_SECRET,
+ EventType.REQUEST_SECRET -> {
+ secretShareManager.handleSecretRequest(event)
+ }
EventType.ROOM_KEY_REQUEST -> {
- // save audit trail
- gossipingBuffer.add(event)
- // Requests are stacked, and will be handled one by one at the end of the sync (onSyncComplete)
- incomingGossipingRequestManager.onGossipingRequestEvent(event)
+ event.getClearContent().toModel()?.let { req ->
+ // We'll always get these because we send room key requests to
+ // '*' (ie. 'all devices') which includes the sending device,
+ // so ignore requests from ourself because apart from it being
+ // very silly, it won't work because an Olm session cannot send
+ // messages to itself.
+ if (req.requestingDeviceId != deviceId) { // ignore self requests
+ event.senderId?.let { incomingKeyRequestManager.addNewIncomingRequest(it, req) }
+ }
+ }
}
EventType.SEND_SECRET -> {
- gossipingBuffer.add(event)
onSecretSendReceived(event)
}
EventType.ROOM_KEY_WITHHELD -> {
@@ -833,50 +849,38 @@ internal class DefaultCryptoService @Inject constructor(
val withHeldContent = event.getClearContent().toModel() ?: return Unit.also {
Timber.tag(loggerTag.value).i("Malformed onKeyWithHeldReceived() : missing fields")
}
- Timber.tag(loggerTag.value).i("onKeyWithHeldReceived() received from:${event.senderId}, content <$withHeldContent>")
- val alg = roomDecryptorProvider.getOrCreateRoomDecryptor(withHeldContent.roomId, withHeldContent.algorithm)
- if (alg is IMXWithHeldExtension) {
- alg.onRoomKeyWithHeldEvent(withHeldContent)
- } else {
- Timber.tag(loggerTag.value).e("onKeyWithHeldReceived() from:${event.senderId}: Unable to handle WithHeldContent for ${withHeldContent.algorithm}")
- return
+ val senderId = event.senderId ?: return Unit.also {
+ Timber.tag(loggerTag.value).i("Malformed onKeyWithHeldReceived() : missing fields")
}
+ withHeldContent.sessionId ?: return
+ withHeldContent.algorithm ?: return
+ withHeldContent.roomId ?: return
+ withHeldContent.senderKey ?: return
+ outgoingKeyRequestManager.onRoomKeyWithHeld(
+ sessionId = withHeldContent.sessionId,
+ algorithm = withHeldContent.algorithm,
+ roomId = withHeldContent.roomId,
+ senderKey = withHeldContent.senderKey,
+ fromDevice = withHeldContent.fromDevice,
+ event = Event(
+ type = EventType.ROOM_KEY_WITHHELD,
+ senderId = senderId,
+ content = event.getClearContent()
+ )
+ )
}
- private fun onSecretSendReceived(event: Event) {
- Timber.tag(loggerTag.value).i("GOSSIP onSecretSend() from ${event.senderId} : onSecretSendReceived ${event.content?.get("sender_key")}")
- if (!event.isEncrypted()) {
- // secret send messages must be encrypted
- Timber.tag(loggerTag.value).e("GOSSIP onSecretSend() :Received unencrypted secret send event")
- return
- }
-
- // Was that sent by us?
- if (event.senderId != userId) {
- Timber.tag(loggerTag.value).e("GOSSIP onSecretSend() : Ignore secret from other user ${event.senderId}")
- return
- }
-
- val secretContent = event.getClearContent().toModel() ?: return
-
- val existingRequest = cryptoStore
- .getOutgoingSecretKeyRequests().firstOrNull { it.requestId == secretContent.requestId }
-
- if (existingRequest == null) {
- Timber.tag(loggerTag.value).i("GOSSIP onSecretSend() : Ignore secret that was not requested: ${secretContent.requestId}")
- return
- }
-
- if (!handleSDKLevelGossip(existingRequest.secretName, secretContent.secretValue)) {
- // TODO Ask to application layer?
- Timber.tag(loggerTag.value).v("onSecretSend() : secret not handled by SDK")
+ private suspend fun onSecretSendReceived(event: Event) {
+ secretShareManager.onSecretSendReceived(event) { secretName, secretValue ->
+ handleSDKLevelGossip(secretName, secretValue)
}
}
/**
* Returns true if handled by SDK, otherwise should be sent to application layer
*/
- private fun handleSDKLevelGossip(secretName: String?, secretValue: String): Boolean {
+ private fun handleSDKLevelGossip(secretName: String?,
+ secretValue: String): Boolean {
return when (secretName) {
MASTER_KEY_SSSS_NAME -> {
crossSigningService.onSecretMSKGossip(secretValue)
@@ -1022,9 +1026,9 @@ internal class DefaultCryptoService @Inject constructor(
return withContext(coroutineDispatchers.crypto) {
Timber.tag(loggerTag.value).v("importRoomKeys starts")
- val t0 = System.currentTimeMillis()
+ val t0 = clock.epochMillis()
val roomKeys = MXMegolmExportEncryption.decryptMegolmKeyFile(roomKeysAsArray, password)
- val t1 = System.currentTimeMillis()
+ val t1 = clock.epochMillis()
Timber.tag(loggerTag.value).v("importRoomKeys : decryptMegolmKeyFile done in ${t1 - t0} ms")
@@ -1032,7 +1036,7 @@ internal class DefaultCryptoService @Inject constructor(
.adapter>(Types.newParameterizedType(List::class.java, MegolmSessionData::class.java))
.fromJson(roomKeys)
- val t2 = System.currentTimeMillis()
+ val t2 = clock.epochMillis()
Timber.tag(loggerTag.value).v("importRoomKeys : JSON parsing ${t2 - t1} ms")
@@ -1091,6 +1095,12 @@ internal class DefaultCryptoService @Inject constructor(
cryptoStore.setGlobalBlacklistUnverifiedDevices(block)
}
+ override fun enableKeyGossiping(enable: Boolean) {
+ cryptoStore.enableKeyGossiping(enable)
+ }
+
+ override fun isKeyGossipingEnabled() = cryptoStore.isKeyGossipingEnabled()
+
/**
* Tells whether the client should ever send encrypted messages to unverified devices.
* The default value is false.
@@ -1154,52 +1164,17 @@ internal class DefaultCryptoService @Inject constructor(
setRoomBlacklistUnverifiedDevices(roomId, false)
}
-// TODO Check if this method is still necessary
- /**
- * Cancel any earlier room key request
- *
- * @param requestBody requestBody
- */
- override fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody) {
- outgoingGossipingRequestManager.cancelRoomKeyRequest(requestBody)
- }
-
/**
* Re request the encryption keys required to decrypt an event.
*
* @param event the event to decrypt again.
*/
override fun reRequestRoomKeyForEvent(event: Event) {
- val wireContent = event.content.toModel() ?: return Unit.also {
- Timber.tag(loggerTag.value).e("reRequestRoomKeyForEvent Failed to re-request key, null content")
- }
-
- val requestBody = RoomKeyRequestBody(
- algorithm = wireContent.algorithm,
- roomId = event.roomId,
- senderKey = wireContent.senderKey,
- sessionId = wireContent.sessionId
- )
-
- outgoingGossipingRequestManager.resendRoomKeyRequest(requestBody)
+ outgoingKeyRequestManager.requestKeyForEvent(event, true)
}
override fun requestRoomKeyForEvent(event: Event) {
- val wireContent = event.content.toModel() ?: return Unit.also {
- Timber.tag(loggerTag.value).e("requestRoomKeyForEvent Failed to request key, null content eventId: ${event.eventId}")
- }
-
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
-// if (!isStarted()) {
-// Timber.v("## CRYPTO | requestRoomKeyForEvent() : wait after e2e init")
-// internalStart(false)
-// }
- roomDecryptorProvider
- .getOrCreateRoomDecryptor(event.roomId, wireContent.algorithm)
- ?.requestKeysForEvent(event, false) ?: run {
- Timber.tag(loggerTag.value).v("requestRoomKeyForEvent() : No room decryptor for roomId:${event.roomId} algorithm:${wireContent.algorithm}")
- }
- }
+ outgoingKeyRequestManager.requestKeyForEvent(event, false)
}
/**
@@ -1208,7 +1183,8 @@ internal class DefaultCryptoService @Inject constructor(
* @param listener listener
*/
override fun addRoomKeysRequestListener(listener: GossipingRequestListener) {
- incomingGossipingRequestManager.addRoomKeysRequestListener(listener)
+ incomingKeyRequestManager.addRoomKeysRequestListener(listener)
+ secretShareManager.addListener(listener)
}
/**
@@ -1217,42 +1193,10 @@ internal class DefaultCryptoService @Inject constructor(
* @param listener listener
*/
override fun removeRoomKeysRequestListener(listener: GossipingRequestListener) {
- incomingGossipingRequestManager.removeRoomKeysRequestListener(listener)
+ incomingKeyRequestManager.removeRoomKeysRequestListener(listener)
+ secretShareManager.removeListener(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("type" to EventType.DUMMY)
-//
-// val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
-// val sendToDeviceMap = MXUsersDevicesMap()
-// 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
*
@@ -1298,27 +1242,41 @@ internal class DefaultCryptoService @Inject constructor(
return "DefaultCryptoService of $userId ($deviceId)"
}
- override fun getOutgoingRoomKeyRequests(): List {
+ override fun getOutgoingRoomKeyRequests(): List {
return cryptoStore.getOutgoingRoomKeyRequests()
}
- override fun getOutgoingRoomKeyRequestsPaged(): LiveData> {
+ override fun getOutgoingRoomKeyRequestsPaged(): LiveData> {
return cryptoStore.getOutgoingRoomKeyRequestsPaged()
}
- override fun getIncomingRoomKeyRequestsPaged(): LiveData> {
- return cryptoStore.getIncomingRoomKeyRequestsPaged()
- }
-
override fun getIncomingRoomKeyRequests(): List {
- return cryptoStore.getIncomingRoomKeyRequests()
+ return cryptoStore.getGossipingEvents()
+ .mapNotNull {
+ IncomingRoomKeyRequest.fromEvent(it)
+ }
}
- override fun getGossipingEventsTrail(): LiveData> {
+ override fun getIncomingRoomKeyRequestsPaged(): LiveData> {
+ return cryptoStore.getGossipingEventsTrail(TrailType.IncomingKeyRequest) {
+ IncomingRoomKeyRequest.fromEvent(it)
+ ?: IncomingRoomKeyRequest(localCreationTimestamp = 0L)
+ }
+ }
+
+ /**
+ * If you registered a `GossipingRequestListener`, you will be notified of key request
+ * that was not accepted by the SDK. You can call back this manually to accept anyhow.
+ */
+ override suspend fun manuallyAcceptRoomKeyRequest(request: IncomingRoomKeyRequest) {
+ incomingKeyRequestManager.manuallyAcceptRoomKeyRequest(request)
+ }
+
+ override fun getGossipingEventsTrail(): LiveData> {
return cryptoStore.getGossipingEventsTrail()
}
- override fun getGossipingEvents(): List {
+ override fun getGossipingEvents(): List {
return cryptoStore.getGossipingEvents()
}
@@ -1342,8 +1300,8 @@ internal class DefaultCryptoService @Inject constructor(
loadRoomMembersTask.execute(LoadRoomMembersTask.Params(roomId))
} catch (failure: Throwable) {
Timber.tag(loggerTag.value).e("prepareToEncrypt() : Failed to load room members")
- callback.onFailure(failure)
- return@launch
+ // we probably shouldn't block sending on that (but questionable)
+ // but some members won't be able to decrypt
}
val userIds = getRoomUserIds(roomId)
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 6cae2d0935..f546b35fcf 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
@@ -31,19 +31,23 @@ import org.matrix.android.sdk.internal.session.SessionScope
import org.matrix.android.sdk.internal.session.sync.SyncTokenStore
import org.matrix.android.sdk.internal.task.TaskExecutor
import org.matrix.android.sdk.internal.util.logLimit
+import org.matrix.android.sdk.internal.util.time.Clock
import timber.log.Timber
import javax.inject.Inject
// Legacy name: MXDeviceList
@SessionScope
-internal class DeviceListManager @Inject constructor(private val cryptoStore: IMXCryptoStore,
- private val olmDevice: MXOlmDevice,
- private val syncTokenStore: SyncTokenStore,
- private val credentials: Credentials,
- private val downloadKeysForUsersTask: DownloadKeysForUsersTask,
- private val cryptoSessionInfoProvider: CryptoSessionInfoProvider,
- coroutineDispatchers: MatrixCoroutineDispatchers,
- private val taskExecutor: TaskExecutor) {
+internal class DeviceListManager @Inject constructor(
+ private val cryptoStore: IMXCryptoStore,
+ private val olmDevice: MXOlmDevice,
+ private val syncTokenStore: SyncTokenStore,
+ private val credentials: Credentials,
+ private val downloadKeysForUsersTask: DownloadKeysForUsersTask,
+ private val cryptoSessionInfoProvider: CryptoSessionInfoProvider,
+ coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val taskExecutor: TaskExecutor,
+ private val clock: Clock,
+) {
interface UserDevicesUpdateListener {
fun onUsersDeviceUpdate(userIds: List)
@@ -310,11 +314,20 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
stored
} else {
Timber.v("## CRYPTO | downloadKeys() : starts")
- val t0 = System.currentTimeMillis()
- val result = doKeyDownloadForUsers(downloadUsers)
- Timber.v("## CRYPTO | downloadKeys() : doKeyDownloadForUsers succeeds after ${System.currentTimeMillis() - t0} ms")
- result.also {
- it.addEntriesFromMap(stored)
+ val t0 = clock.epochMillis()
+ try {
+ val result = doKeyDownloadForUsers(downloadUsers)
+ Timber.v("## CRYPTO | downloadKeys() : doKeyDownloadForUsers succeeds after ${clock.epochMillis() - t0} ms")
+ result.also {
+ it.addEntriesFromMap(stored)
+ }
+ } catch (failure: Throwable) {
+ Timber.w(failure, "## CRYPTO | downloadKeys() : doKeyDownloadForUsers failed after ${clock.epochMillis() - t0} ms")
+ if (forceDownload) {
+ throw failure
+ } else {
+ stored
+ }
}
}
}
@@ -475,8 +488,10 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
}
if (!isVerified) {
- Timber.e("## CRYPTO | validateDeviceKeys() : Unable to verify signature on device " + userId + ":" +
- deviceKeys.deviceId + " with error " + errorMessage)
+ Timber.e(
+ "## CRYPTO | validateDeviceKeys() : Unable to verify signature on device " + userId + ":" +
+ deviceKeys.deviceId + " with error " + errorMessage
+ )
return false
}
@@ -486,9 +501,11 @@ internal class DeviceListManager @Inject constructor(private val cryptoStore: IM
// best off sticking with the original keys.
//
// Should we warn the user about it somehow?
- Timber.e("## CRYPTO | validateDeviceKeys() : WARNING:Ed25519 key for device " + userId + ":" +
- deviceKeys.deviceId + " has changed : " +
- previouslyStoredDeviceKeys.fingerprint() + " -> " + signKey)
+ Timber.e(
+ "## CRYPTO | validateDeviceKeys() : WARNING:Ed25519 key for device " + userId + ":" +
+ deviceKeys.deviceId + " has changed : " +
+ previouslyStoredDeviceKeys.fingerprint() + " -> " + signKey
+ )
Timber.e("## CRYPTO | validateDeviceKeys() : $previouslyStoredDeviceKeys -> $deviceKeys")
Timber.e("## CRYPTO | validateDeviceKeys() : ${previouslyStoredDeviceKeys.keys} -> ${deviceKeys.keys}")
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
index 1c8bce7377..a094189645 100644
--- 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
@@ -36,6 +36,7 @@ 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.time.Clock
import timber.log.Timber
import javax.inject.Inject
@@ -47,6 +48,7 @@ private val loggerTag = LoggerTag("CryptoSyncHandler", LoggerTag.CRYPTO)
internal class EventDecryptor @Inject constructor(
private val cryptoCoroutineScope: CoroutineScope,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val clock: Clock,
private val roomDecryptorProvider: RoomDecryptorProvider,
private val messageEncrypter: MessageEncrypter,
private val sendToDeviceTask: SendToDeviceTask,
@@ -153,7 +155,7 @@ internal class EventDecryptor @Inject constructor(
// we should force start a new session for those
Timber.tag(loggerTag.value).v("Unwedging: ${wedgedDevices.size} are wedged")
// get the one that should be retried according to rate limit
- val now = System.currentTimeMillis()
+ val now = clock.epochMillis()
val toUnwedge = wedgedDevices.filter {
val lastForcedDate = lastNewSessionForcedDates[it] ?: 0
if (now - lastForcedDate < DefaultCryptoService.CRYPTO_MIN_FORCE_SESSION_PERIOD_MILLIS) {
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/GossipingWorkManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/GossipingWorkManager.kt
deleted file mode 100644
index 0013c31eea..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/GossipingWorkManager.kt
+++ /dev/null
@@ -1,57 +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
-
-import androidx.work.BackoffPolicy
-import androidx.work.Data
-import androidx.work.ExistingWorkPolicy
-import androidx.work.ListenableWorker
-import androidx.work.OneTimeWorkRequest
-import org.matrix.android.sdk.api.util.Cancelable
-import org.matrix.android.sdk.internal.di.WorkManagerProvider
-import org.matrix.android.sdk.internal.session.SessionScope
-import org.matrix.android.sdk.internal.util.CancelableWork
-import org.matrix.android.sdk.internal.worker.startChain
-import java.util.concurrent.TimeUnit
-import javax.inject.Inject
-
-@SessionScope
-internal class GossipingWorkManager @Inject constructor(
- private val workManagerProvider: WorkManagerProvider
-) {
-
- inline fun createWork(data: Data, startChain: Boolean): OneTimeWorkRequest {
- return workManagerProvider.matrixOneTimeWorkRequestBuilder()
- .setConstraints(WorkManagerProvider.workConstraints)
- .startChain(startChain)
- .setInputData(data)
- .setBackoffCriteria(BackoffPolicy.LINEAR, WorkManagerProvider.BACKOFF_DELAY_MILLIS, TimeUnit.MILLISECONDS)
- .build()
- }
-
- // Prevent sending queue to stay broken after app restart
- // The unique queue id will stay the same as long as this object is instanciated
- val queueSuffixApp = System.currentTimeMillis()
-
- fun postWork(workRequest: OneTimeWorkRequest, policy: ExistingWorkPolicy = ExistingWorkPolicy.APPEND): Cancelable {
- workManagerProvider.workManager
- .beginUniqueWork(this::class.java.name + "_$queueSuffixApp", policy, workRequest)
- .enqueue()
-
- return CancelableWork(workManagerProvider.workManager, workRequest.id)
- }
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/IncomingGossipingRequestManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/IncomingGossipingRequestManager.kt
deleted file mode 100644
index b907b57f82..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/IncomingGossipingRequestManager.kt
+++ /dev/null
@@ -1,472 +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
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
-import org.matrix.android.sdk.api.auth.data.Credentials
-import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM
-import org.matrix.android.sdk.api.crypto.MXCryptoConfig
-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
-import org.matrix.android.sdk.api.session.crypto.crosssigning.SELF_SIGNING_KEY_SSSS_NAME
-import org.matrix.android.sdk.api.session.crypto.crosssigning.USER_SIGNING_KEY_SSSS_NAME
-import org.matrix.android.sdk.api.session.crypto.keysbackup.extractCurveKeyFromRecoveryKey
-import org.matrix.android.sdk.api.session.crypto.keyshare.GossipingRequestListener
-import org.matrix.android.sdk.api.session.crypto.model.GossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.GossipingToDeviceObject
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRequestCancellation
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.IncomingSecretShareRequest
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
-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.api.util.toBase64NoPadding
-import org.matrix.android.sdk.internal.crypto.algorithms.IMXGroupEncryption
-import org.matrix.android.sdk.internal.crypto.model.rest.GossipingDefaultContent
-import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.createUniqueTxnId
-import org.matrix.android.sdk.internal.di.SessionId
-import org.matrix.android.sdk.internal.session.SessionScope
-import org.matrix.android.sdk.internal.worker.WorkerParamsFactory
-import timber.log.Timber
-import java.util.concurrent.Executors
-import javax.inject.Inject
-
-@SessionScope
-internal class IncomingGossipingRequestManager @Inject constructor(
- @SessionId private val sessionId: String,
- private val credentials: Credentials,
- private val cryptoStore: IMXCryptoStore,
- private val cryptoConfig: MXCryptoConfig,
- private val gossipingWorkManager: GossipingWorkManager,
- private val roomEncryptorsStore: RoomEncryptorsStore,
- private val roomDecryptorProvider: RoomDecryptorProvider,
- private val coroutineDispatchers: MatrixCoroutineDispatchers,
- private val cryptoCoroutineScope: CoroutineScope) {
-
- private val executor = Executors.newSingleThreadExecutor()
-
- // list of IncomingRoomKeyRequests/IncomingRoomKeyRequestCancellations
- // we received in the current sync.
- private val receivedGossipingRequests = ArrayList()
- private val receivedRequestCancellations = ArrayList()
-
- // the listeners
- private val gossipingRequestListeners: MutableSet = HashSet()
-
- init {
- receivedGossipingRequests.addAll(cryptoStore.getPendingIncomingGossipingRequests())
- }
-
- fun close() {
- executor.shutdownNow()
- }
-
- // Recently verified devices (map of deviceId and timestamp)
- private val recentlyVerifiedDevices = HashMap()
-
- /**
- * Called when a session has been verified.
- * This information can be used by the manager to decide whether or not to fullfil gossiping requests
- */
- fun onVerificationCompleteForDevice(deviceId: String) {
- // For now we just keep an in memory cache
- synchronized(recentlyVerifiedDevices) {
- recentlyVerifiedDevices[deviceId] = System.currentTimeMillis()
- }
- }
-
- private fun hasBeenVerifiedLessThanFiveMinutesFromNow(deviceId: String): Boolean {
- val verifTimestamp: Long?
- synchronized(recentlyVerifiedDevices) {
- verifTimestamp = recentlyVerifiedDevices[deviceId]
- }
- if (verifTimestamp == null) return false
-
- val age = System.currentTimeMillis() - verifTimestamp
-
- return age < FIVE_MINUTES_IN_MILLIS
- }
-
- /**
- * Called when we get an m.room_key_request event
- * It must be called on CryptoThread
- *
- * @param event the announcement event.
- */
- fun onGossipingRequestEvent(event: Event) {
- val roomKeyShare = event.getClearContent().toModel()
- Timber.i("## CRYPTO | GOSSIP onGossipingRequestEvent received type ${event.type} from user:${event.senderId}, content:$roomKeyShare")
- // val ageLocalTs = event.unsignedData?.age?.let { System.currentTimeMillis() - it }
- when (roomKeyShare?.action) {
- GossipingToDeviceObject.ACTION_SHARE_REQUEST -> {
- if (event.getClearType() == EventType.REQUEST_SECRET) {
- IncomingSecretShareRequest.fromEvent(event)?.let {
- if (event.senderId == credentials.userId && it.deviceId == credentials.deviceId) {
- // ignore, it was sent by me as *
- Timber.v("## GOSSIP onGossipingRequestEvent type ${event.type} ignore remote echo")
- } else {
-// // save in DB
-// cryptoStore.storeIncomingGossipingRequest(it, ageLocalTs)
- receivedGossipingRequests.add(it)
- }
- }
- } else if (event.getClearType() == EventType.ROOM_KEY_REQUEST) {
- IncomingRoomKeyRequest.fromEvent(event)?.let {
- if (event.senderId == credentials.userId && it.deviceId == credentials.deviceId) {
- // ignore, it was sent by me as *
- Timber.v("## GOSSIP onGossipingRequestEvent type ${event.type} ignore remote echo")
- } else {
-// cryptoStore.storeIncomingGossipingRequest(it, ageLocalTs)
- receivedGossipingRequests.add(it)
- }
- }
- }
- }
- GossipingToDeviceObject.ACTION_SHARE_CANCELLATION -> {
- IncomingRequestCancellation.fromEvent(event)?.let {
- receivedRequestCancellations.add(it)
- }
- }
- else -> {
- Timber.e("## GOSSIP onGossipingRequestEvent() : unsupported action ${roomKeyShare?.action}")
- }
- }
- }
-
- /**
- * Process any m.room_key_request or m.secret.request events which were queued up during the
- * current sync.
- * It must be called on CryptoThread
- */
- fun processReceivedGossipingRequests() {
- val roomKeyRequestsToProcess = receivedGossipingRequests.toList()
- receivedGossipingRequests.clear()
-
- Timber.v("## CRYPTO | GOSSIP processReceivedGossipingRequests() : ${roomKeyRequestsToProcess.size} request to process")
-
- var receivedRequestCancellations: List? = null
-
- synchronized(this.receivedRequestCancellations) {
- if (this.receivedRequestCancellations.isNotEmpty()) {
- receivedRequestCancellations = this.receivedRequestCancellations.toList()
- this.receivedRequestCancellations.clear()
- }
- }
-
- executor.execute {
- cryptoStore.storeIncomingGossipingRequests(roomKeyRequestsToProcess)
- for (request in roomKeyRequestsToProcess) {
- if (request is IncomingRoomKeyRequest) {
- processIncomingRoomKeyRequest(request)
- } else if (request is IncomingSecretShareRequest) {
- processIncomingSecretShareRequest(request)
- }
- }
-
- receivedRequestCancellations?.forEach { request ->
- Timber.v("## CRYPTO | GOSSIP processReceivedGossipingRequests() : m.room_key_request cancellation $request")
- // we should probably only notify the app of cancellations we told it
- // about, but we don't currently have a record of that, so we just pass
- // everything through.
- if (request.userId == credentials.userId && request.deviceId == credentials.deviceId) {
- // ignore remote echo
- return@forEach
- }
- val matchingIncoming = cryptoStore.getIncomingRoomKeyRequest(request.userId ?: "", request.deviceId ?: "", request.requestId ?: "")
- if (matchingIncoming == null) {
- // ignore that?
- return@forEach
- } else {
- // If it was accepted from this device, keep the information, do not mark as cancelled
- if (matchingIncoming.state != GossipingRequestState.ACCEPTED) {
- onRoomKeyRequestCancellation(request)
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.CANCELLED_BY_REQUESTER)
- }
- }
- }
- }
- }
-
- private fun processIncomingRoomKeyRequest(request: IncomingRoomKeyRequest) {
- val userId = request.userId ?: return
- val deviceId = request.deviceId ?: return
- val body = request.requestBody ?: return
- val roomId = body.roomId ?: return
- val alg = body.algorithm ?: return
-
- Timber.v("## CRYPTO | GOSSIP processIncomingRoomKeyRequest from $userId:$deviceId for $roomId / ${body.sessionId} id ${request.requestId}")
- if (credentials.userId != userId) {
- handleKeyRequestFromOtherUser(body, request, alg, roomId, userId, deviceId)
- return
- }
- // TODO: should we queue up requests we don't yet have keys for, in case they turn up later?
- // if we don't have a decryptor for this room/alg, we don't have
- // the keys for the requested events, and can drop the requests.
- val decryptor = roomDecryptorProvider.getRoomDecryptor(roomId, alg)
- if (null == decryptor) {
- Timber.w("## CRYPTO | GOSSIP processReceivedGossipingRequests() : room key request for unknown $alg in room $roomId")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
- if (!decryptor.hasKeysForKeyRequest(request)) {
- Timber.w("## CRYPTO | GOSSIP processReceivedGossipingRequests() : room key request for unknown session ${body.sessionId!!}")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
-
- if (credentials.deviceId == deviceId && credentials.userId == userId) {
- Timber.v("## CRYPTO | GOSSIP processReceivedGossipingRequests() : oneself device - ignored")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
- request.share = Runnable {
- decryptor.shareKeysWithDevice(request)
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.ACCEPTED)
- }
- request.ignore = Runnable {
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- }
- // if the device is verified already, share the keys
- val device = cryptoStore.getUserDevice(userId, deviceId)
- if (device != null) {
- if (device.isVerified) {
- Timber.v("## CRYPTO | GOSSIP processReceivedGossipingRequests() : device is already verified: sharing keys")
- request.share?.run()
- return
- }
-
- if (device.isBlocked) {
- Timber.v("## CRYPTO | GOSSIP processReceivedGossipingRequests() : device is blocked -> ignored")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
- }
-
- // As per config we automatically discard untrusted devices request
- if (cryptoConfig.discardRoomKeyRequestsFromUntrustedDevices) {
- Timber.v("## CRYPTO | processReceivedGossipingRequests() : discardRoomKeyRequestsFromUntrustedDevices")
- // At this point the device is unknown, we don't want to bother user with that
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
-
- // Pass to application layer to decide what to do
- onRoomKeyRequest(request)
- }
-
- private fun handleKeyRequestFromOtherUser(body: RoomKeyRequestBody,
- request: IncomingRoomKeyRequest,
- alg: String,
- roomId: String,
- userId: String,
- deviceId: String) {
- Timber.w("## CRYPTO | GOSSIP processReceivedGossipingRequests() : room key request from other user")
- val senderKey = body.senderKey ?: return Unit
- .also { Timber.w("missing senderKey") }
- .also { cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED) }
- val sessionId = body.sessionId ?: return Unit
- .also { Timber.w("missing sessionId") }
- .also { cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED) }
-
- if (alg != MXCRYPTO_ALGORITHM_MEGOLM) {
- return Unit
- .also { Timber.w("Only megolm is accepted here") }
- .also { cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED) }
- }
-
- val roomEncryptor = roomEncryptorsStore.get(roomId) ?: return Unit
- .also { Timber.w("no room Encryptor") }
- .also { cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED) }
-
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- if (roomEncryptor is IMXGroupEncryption) {
- val isSuccess = roomEncryptor.reshareKey(sessionId, userId, deviceId, senderKey)
-
- if (isSuccess) {
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.ACCEPTED)
- } else {
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.UNABLE_TO_PROCESS)
- }
- } else {
- Timber.e("## CRYPTO | handleKeyRequestFromOtherUser() from:$userId: Unable to handle IMXGroupEncryption.reshareKey for $alg")
- }
- }
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.RE_REQUESTED)
- }
-
- private fun processIncomingSecretShareRequest(request: IncomingSecretShareRequest) {
- val secretName = request.secretName ?: return Unit.also {
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- Timber.v("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Missing secret name")
- }
-
- val userId = request.userId
- if (userId == null || credentials.userId != userId) {
- Timber.e("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Ignoring secret share request from other users")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
-
- val deviceId = request.deviceId
- ?: return Unit.also {
- Timber.e("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Malformed request, no ")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- }
-
- val device = cryptoStore.getUserDevice(userId, deviceId)
- ?: return Unit.also {
- Timber.e("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Received secret share request from unknown device ${request.deviceId}")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- }
-
- if (!device.isVerified || device.isBlocked) {
- Timber.v("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Ignoring secret share request from untrusted/blocked session $device")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- return
- }
-
- val isDeviceLocallyVerified = cryptoStore.getUserDevice(userId, deviceId)?.trustLevel?.isLocallyVerified()
-
- when (secretName) {
- MASTER_KEY_SSSS_NAME -> cryptoStore.getCrossSigningPrivateKeys()?.master
- SELF_SIGNING_KEY_SSSS_NAME -> cryptoStore.getCrossSigningPrivateKeys()?.selfSigned
- USER_SIGNING_KEY_SSSS_NAME -> cryptoStore.getCrossSigningPrivateKeys()?.user
- KEYBACKUP_SECRET_SSSS_NAME -> cryptoStore.getKeyBackupRecoveryKeyInfo()?.recoveryKey
- ?.let {
- extractCurveKeyFromRecoveryKey(it)?.toBase64NoPadding()
- }
- else -> null
- }?.let { secretValue ->
- Timber.i("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Sharing secret $secretName with $device locally trusted")
- if (isDeviceLocallyVerified == true && hasBeenVerifiedLessThanFiveMinutesFromNow(deviceId)) {
- val params = SendGossipWorker.Params(
- sessionId = sessionId,
- secretValue = secretValue,
- requestUserId = request.userId,
- requestDeviceId = request.deviceId,
- requestId = request.requestId,
- txnId = createUniqueTxnId()
- )
-
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.ACCEPTING)
- val workRequest = gossipingWorkManager.createWork(WorkerParamsFactory.toData(params), true)
- gossipingWorkManager.postWork(workRequest)
- } else {
- Timber.v("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : Can't share secret $secretName with $device, verification too old")
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- }
- return
- }
-
- Timber.v("## CRYPTO | GOSSIP processIncomingSecretShareRequest() : $secretName unknown at SDK level, asking to app layer")
-
- request.ignore = Runnable {
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.REJECTED)
- }
-
- request.share = { secretValue ->
- val params = SendGossipWorker.Params(
- sessionId = userId,
- secretValue = secretValue,
- requestUserId = request.userId,
- requestDeviceId = request.deviceId,
- requestId = request.requestId,
- txnId = createUniqueTxnId()
- )
-
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.ACCEPTING)
- val workRequest = gossipingWorkManager.createWork(WorkerParamsFactory.toData(params), true)
- gossipingWorkManager.postWork(workRequest)
- cryptoStore.updateGossipingRequestState(request, GossipingRequestState.ACCEPTED)
- }
-
- onShareRequest(request)
- }
-
- /**
- * Dispatch onRoomKeyRequest
- *
- * @param request the request
- */
- private fun onRoomKeyRequest(request: IncomingRoomKeyRequest) {
- synchronized(gossipingRequestListeners) {
- for (listener in gossipingRequestListeners) {
- try {
- listener.onRoomKeyRequest(request)
- } catch (e: Exception) {
- Timber.e(e, "## CRYPTO | onRoomKeyRequest() failed")
- }
- }
- }
- }
-
- /**
- * Ask for a value to the listeners, and take the first one
- */
- private fun onShareRequest(request: IncomingSecretShareRequest) {
- synchronized(gossipingRequestListeners) {
- for (listener in gossipingRequestListeners) {
- try {
- if (listener.onSecretShareRequest(request)) {
- return
- }
- } catch (e: Exception) {
- Timber.e(e, "## CRYPTO | GOSSIP onRoomKeyRequest() failed")
- }
- }
- }
- // Not handled, ignore
- request.ignore?.run()
- }
-
- /**
- * A room key request cancellation has been received.
- *
- * @param request the cancellation request
- */
- private fun onRoomKeyRequestCancellation(request: IncomingRequestCancellation) {
- synchronized(gossipingRequestListeners) {
- for (listener in gossipingRequestListeners) {
- try {
- listener.onRoomKeyRequestCancellation(request)
- } catch (e: Exception) {
- Timber.e(e, "## CRYPTO | GOSSIP onRoomKeyRequestCancellation() failed")
- }
- }
- }
- }
-
- fun addRoomKeysRequestListener(listener: GossipingRequestListener) {
- synchronized(gossipingRequestListeners) {
- gossipingRequestListeners.add(listener)
- }
- }
-
- fun removeRoomKeysRequestListener(listener: GossipingRequestListener) {
- synchronized(gossipingRequestListeners) {
- gossipingRequestListeners.remove(listener)
- }
- }
-
- companion object {
- private const val FIVE_MINUTES_IN_MILLIS = 5 * 60 * 1000
- }
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/IncomingKeyRequestManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/IncomingKeyRequestManager.kt
new file mode 100644
index 0000000000..13f2fb861a
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/IncomingKeyRequestManager.kt
@@ -0,0 +1,463 @@
+/*
+ * Copyright 2022 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
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
+import org.matrix.android.sdk.api.auth.data.Credentials
+import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM
+import org.matrix.android.sdk.api.crypto.MXCryptoConfig
+import org.matrix.android.sdk.api.extensions.tryOrNull
+import org.matrix.android.sdk.api.logger.LoggerTag
+import org.matrix.android.sdk.api.session.crypto.keyshare.GossipingRequestListener
+import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
+import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
+import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
+import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
+import org.matrix.android.sdk.api.session.crypto.model.RoomKeyShareRequest
+import org.matrix.android.sdk.api.session.events.model.EventType
+import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
+import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
+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.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.task.SemaphoreCoroutineSequencer
+import org.matrix.android.sdk.internal.util.time.Clock
+import timber.log.Timber
+import java.util.concurrent.Executors
+import javax.inject.Inject
+import kotlin.system.measureTimeMillis
+
+private val loggerTag = LoggerTag("IncomingKeyRequestManager", LoggerTag.CRYPTO)
+
+@SessionScope
+internal class IncomingKeyRequestManager @Inject constructor(
+ private val credentials: Credentials,
+ private val cryptoStore: IMXCryptoStore,
+ private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction,
+ private val olmDevice: MXOlmDevice,
+ private val cryptoConfig: MXCryptoConfig,
+ private val messageEncrypter: MessageEncrypter,
+ private val coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val sendToDeviceTask: SendToDeviceTask,
+ private val clock: Clock,
+) {
+
+ private val dispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+ private val outgoingRequestScope = CoroutineScope(SupervisorJob() + dispatcher)
+ val sequencer = SemaphoreCoroutineSequencer()
+
+ private val incomingRequestBuffer = mutableListOf()
+
+ // the listeners
+ private val gossipingRequestListeners: MutableSet = HashSet()
+
+ enum class MegolmRequestAction {
+ Request, Cancel
+ }
+
+ data class ValidMegolmRequestBody(
+ val requestId: String,
+ val requestingUserId: String,
+ val requestingDeviceId: String,
+ val roomId: String,
+ val senderKey: String,
+ val sessionId: String,
+ val action: MegolmRequestAction
+ ) {
+ fun shortDbgString() = "Request from $requestingUserId|$requestingDeviceId for session $sessionId in room $roomId"
+ }
+
+ private fun RoomKeyShareRequest.toValidMegolmRequest(senderId: String): ValidMegolmRequestBody? {
+ val deviceId = requestingDeviceId ?: return null
+ val body = body ?: return null
+ val roomId = body.roomId ?: return null
+ val sessionId = body.sessionId ?: return null
+ val senderKey = body.senderKey ?: return null
+ val requestId = this.requestId ?: return null
+ if (body.algorithm != MXCRYPTO_ALGORITHM_MEGOLM) return null
+ val action = when (this.action) {
+ "request" -> MegolmRequestAction.Request
+ "request_cancellation" -> MegolmRequestAction.Cancel
+ else -> null
+ } ?: return null
+ return ValidMegolmRequestBody(
+ requestId = requestId,
+ requestingUserId = senderId,
+ requestingDeviceId = deviceId,
+ roomId = roomId,
+ senderKey = senderKey,
+ sessionId = sessionId,
+ action = action
+ )
+ }
+
+ fun addNewIncomingRequest(senderId: String, request: RoomKeyShareRequest) {
+ if (!cryptoStore.isKeyGossipingEnabled()) {
+ Timber.tag(loggerTag.value)
+ .i("Ignore incoming key request as per crypto config in room ${request.body?.roomId}")
+ return
+ }
+ outgoingRequestScope.launch {
+ // It is important to handle requests in order
+ sequencer.post {
+ val validMegolmRequest = request.toValidMegolmRequest(senderId) ?: return@post Unit.also {
+ Timber.tag(loggerTag.value).w("Received key request for unknown algorithm ${request.body?.algorithm}")
+ }
+
+ // is there already one like that?
+ val existing = incomingRequestBuffer.firstOrNull { it == validMegolmRequest }
+ if (existing == null) {
+ when (validMegolmRequest.action) {
+ MegolmRequestAction.Request -> {
+ // just add to the buffer
+ incomingRequestBuffer.add(validMegolmRequest)
+ }
+ MegolmRequestAction.Cancel -> {
+ // ignore, we can't cancel as it's not known (probably already processed)
+ // still notify app layer if it was passed up previously
+ IncomingRoomKeyRequest.fromRestRequest(senderId, request, clock)?.let { iReq ->
+ outgoingRequestScope.launch(coroutineDispatchers.computation) {
+ val listenersCopy = synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.toList()
+ }
+ listenersCopy.onEach {
+ tryOrNull {
+ withContext(coroutineDispatchers.main) {
+ it.onRequestCancelled(iReq)
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ } else {
+ when (validMegolmRequest.action) {
+ MegolmRequestAction.Request -> {
+ // it's already in buffer, nop keep existing
+ }
+ MegolmRequestAction.Cancel -> {
+ // discard the request in buffer
+ incomingRequestBuffer.remove(existing)
+ outgoingRequestScope.launch(coroutineDispatchers.computation) {
+ val listenersCopy = synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.toList()
+ }
+ listenersCopy.onEach {
+ IncomingRoomKeyRequest.fromRestRequest(senderId, request, clock)?.let { iReq ->
+ withContext(coroutineDispatchers.main) {
+ tryOrNull { it.onRequestCancelled(iReq) }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ fun processIncomingRequests() {
+ outgoingRequestScope.launch {
+ sequencer.post {
+ measureTimeMillis {
+ Timber.tag(loggerTag.value).v("processIncomingKeyRequests : ${incomingRequestBuffer.size} request to process")
+ incomingRequestBuffer.forEach {
+ // should not happen, we only store requests
+ if (it.action != MegolmRequestAction.Request) return@forEach
+ try {
+ handleIncomingRequest(it)
+ } catch (failure: Throwable) {
+ // ignore and continue, should not happen
+ Timber.tag(loggerTag.value).w(failure, "processIncomingKeyRequests : failed to process request $it")
+ }
+ }
+ incomingRequestBuffer.clear()
+ }.let { duration ->
+ Timber.tag(loggerTag.value).v("Finish processing incoming key request in $duration ms")
+ }
+ }
+ }
+ }
+
+ private suspend fun handleIncomingRequest(request: ValidMegolmRequestBody) {
+ // We don't want to download keys, if we don't know the device yet we won't share any how?
+ val requestingDevice =
+ cryptoStore.getUserDevice(request.requestingUserId, request.requestingDeviceId)
+ ?: return Unit.also {
+ Timber.tag(loggerTag.value).d("Ignoring key request: ${request.shortDbgString()}")
+ }
+
+ cryptoStore.saveIncomingKeyRequestAuditTrail(
+ request.requestId,
+ request.roomId,
+ request.sessionId,
+ request.senderKey,
+ MXCRYPTO_ALGORITHM_MEGOLM,
+ request.requestingUserId,
+ request.requestingDeviceId
+ )
+
+ val roomAlgorithm = // withContext(coroutineDispatchers.crypto) {
+ cryptoStore.getRoomAlgorithm(request.roomId)
+// }
+ if (roomAlgorithm != MXCRYPTO_ALGORITHM_MEGOLM) {
+ // strange we received a request for a room that is not encrypted
+ // maybe a broken state?
+ Timber.tag(loggerTag.value).w("Received a key request in a room with unsupported alg:$roomAlgorithm , req:${request.shortDbgString()}")
+ return
+ }
+
+ // Is it for one of our sessions?
+ if (request.requestingUserId == credentials.userId) {
+ Timber.tag(loggerTag.value).v("handling request from own user: megolm session ${request.sessionId}")
+
+ if (request.requestingDeviceId == credentials.deviceId) {
+ // ignore it's a remote echo
+ return
+ }
+ // If it's verified we share from the early index we know
+ // if not we check if it was originaly shared or not
+ if (requestingDevice.isVerified) {
+ // we share from the earliest known chain index
+ shareMegolmKey(request, requestingDevice, null)
+ } else {
+ shareIfItWasPreviouslyShared(request, requestingDevice)
+ }
+ } else {
+ if (cryptoConfig.limitRoomKeyRequestsToMyDevices) {
+ Timber.tag(loggerTag.value).v("Ignore request from other user as per crypto config: ${request.shortDbgString()}")
+ return
+ }
+ Timber.tag(loggerTag.value).v("handling request from other user: megolm session ${request.sessionId}")
+ if (requestingDevice.isBlocked) {
+ // it's blocked, so send a withheld code
+ sendWithheldForRequest(request, WithHeldCode.BLACKLISTED)
+ } else {
+ shareIfItWasPreviouslyShared(request, requestingDevice)
+ }
+ }
+ }
+
+ private suspend fun shareIfItWasPreviouslyShared(request: ValidMegolmRequestBody, requestingDevice: CryptoDeviceInfo) {
+ // we don't reshare unless it was previously shared with
+ val wasSessionSharedWithUser = withContext(coroutineDispatchers.crypto) {
+ cryptoStore.getSharedSessionInfo(request.roomId, request.sessionId, requestingDevice)
+ }
+ if (wasSessionSharedWithUser.found && wasSessionSharedWithUser.chainIndex != null) {
+ // we share from the index it was previously shared with
+ shareMegolmKey(request, requestingDevice, wasSessionSharedWithUser.chainIndex.toLong())
+ } else {
+ val isOwnDevice = requestingDevice.userId == credentials.userId
+ sendWithheldForRequest(request, if (isOwnDevice) WithHeldCode.UNVERIFIED else WithHeldCode.UNAUTHORISED)
+ // if it's our device we could delegate to the app layer to decide
+ if (isOwnDevice) {
+ outgoingRequestScope.launch(coroutineDispatchers.computation) {
+ val listenersCopy = synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.toList()
+ }
+ val iReq = IncomingRoomKeyRequest(
+ userId = requestingDevice.userId,
+ deviceId = requestingDevice.deviceId,
+ requestId = request.requestId,
+ requestBody = RoomKeyRequestBody(
+ algorithm = MXCRYPTO_ALGORITHM_MEGOLM,
+ senderKey = request.senderKey,
+ sessionId = request.sessionId,
+ roomId = request.roomId
+ ),
+ localCreationTimestamp = clock.epochMillis()
+ )
+ listenersCopy.onEach {
+ withContext(coroutineDispatchers.main) {
+ tryOrNull { it.onRoomKeyRequest(iReq) }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private suspend fun sendWithheldForRequest(request: ValidMegolmRequestBody, code: WithHeldCode) {
+ Timber.tag(loggerTag.value)
+ .w("Send withheld $code for req: ${request.shortDbgString()}")
+ val withHeldContent = RoomKeyWithHeldContent(
+ roomId = request.roomId,
+ senderKey = request.senderKey,
+ algorithm = MXCRYPTO_ALGORITHM_MEGOLM,
+ sessionId = request.sessionId,
+ codeString = code.value,
+ fromDevice = credentials.deviceId
+ )
+
+ val params = SendToDeviceTask.Params(
+ EventType.ROOM_KEY_WITHHELD,
+ MXUsersDevicesMap().apply {
+ setObject(request.requestingUserId, request.requestingDeviceId, withHeldContent)
+ }
+ )
+ try {
+ withContext(coroutineDispatchers.io) {
+ sendToDeviceTask.execute(params)
+ Timber.tag(loggerTag.value)
+ .d("Send withheld $code req: ${request.shortDbgString()}")
+ }
+
+ cryptoStore.saveWithheldAuditTrail(
+ roomId = request.roomId,
+ sessionId = request.sessionId,
+ senderKey = request.senderKey,
+ algorithm = MXCRYPTO_ALGORITHM_MEGOLM,
+ code = code,
+ userId = request.requestingUserId,
+ deviceId = request.requestingDeviceId
+ )
+ } catch (failure: Throwable) {
+ // Ignore it's not that important?
+ // do we want to fallback to a worker?
+ Timber.tag(loggerTag.value)
+ .w("Failed to send withheld $code req: ${request.shortDbgString()} reason:${failure.localizedMessage}")
+ }
+ }
+
+ suspend fun manuallyAcceptRoomKeyRequest(request: IncomingRoomKeyRequest) {
+ request.requestId ?: return
+ request.deviceId ?: return
+ request.userId ?: return
+ request.requestBody?.roomId ?: return
+ request.requestBody.senderKey ?: return
+ request.requestBody.sessionId ?: return
+ val validReq = ValidMegolmRequestBody(
+ requestId = request.requestId,
+ requestingDeviceId = request.deviceId,
+ requestingUserId = request.userId,
+ roomId = request.requestBody.roomId,
+ senderKey = request.requestBody.senderKey,
+ sessionId = request.requestBody.sessionId,
+ action = MegolmRequestAction.Request
+ )
+ val requestingDevice =
+ cryptoStore.getUserDevice(request.userId, request.deviceId)
+ ?: return Unit.also {
+ Timber.tag(loggerTag.value).d("Ignoring key request: ${validReq.shortDbgString()}")
+ }
+
+ shareMegolmKey(validReq, requestingDevice, null)
+ }
+
+ private suspend fun shareMegolmKey(validRequest: ValidMegolmRequestBody,
+ requestingDevice: CryptoDeviceInfo,
+ chainIndex: Long?): Boolean {
+ Timber.tag(loggerTag.value)
+ .d("try to re-share Megolm Key at index $chainIndex for ${validRequest.shortDbgString()}")
+
+ val devicesByUser = mapOf(validRequest.requestingUserId to listOf(requestingDevice))
+ val usersDeviceMap = try {
+ ensureOlmSessionsForDevicesAction.handle(devicesByUser)
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value)
+ .w("Failed to establish olm session")
+ sendWithheldForRequest(validRequest, WithHeldCode.NO_OLM)
+ return false
+ }
+
+ val olmSessionResult = usersDeviceMap.getObject(requestingDevice.userId, requestingDevice.deviceId)
+ if (olmSessionResult?.sessionId == null) {
+ Timber.tag(loggerTag.value)
+ .w("reshareKey: no session with this device, probably because there were no one-time keys")
+ sendWithheldForRequest(validRequest, WithHeldCode.NO_OLM)
+ return false
+ }
+ val sessionHolder = try {
+ olmDevice.getInboundGroupSession(validRequest.sessionId, validRequest.senderKey, validRequest.roomId)
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value)
+ .e(failure, "shareKeysWithDevice: failed to get session ${validRequest.requestingUserId}")
+ // It's unavailable
+ sendWithheldForRequest(validRequest, WithHeldCode.UNAVAILABLE)
+ return false
+ }
+
+ val export = sessionHolder.mutex.withLock {
+ sessionHolder.wrapper.exportKeys(chainIndex)
+ } ?: return false.also {
+ Timber.tag(loggerTag.value)
+ .e("shareKeysWithDevice: failed to export group session ${validRequest.sessionId}")
+ }
+
+ val payloadJson = mapOf(
+ "type" to EventType.FORWARDED_ROOM_KEY,
+ "content" to export
+ )
+
+ val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(requestingDevice))
+ val sendToDeviceMap = MXUsersDevicesMap()
+ sendToDeviceMap.setObject(requestingDevice.userId, requestingDevice.deviceId, encodedPayload)
+ Timber.tag(loggerTag.value).d("reshareKey() : try sending session ${validRequest.sessionId} to ${requestingDevice.shortDebugString()}")
+ val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
+ return try {
+ sendToDeviceTask.execute(sendToDeviceParams)
+ Timber.tag(loggerTag.value)
+ .i("successfully re-shared session ${validRequest.sessionId} to ${requestingDevice.shortDebugString()}")
+ cryptoStore.saveForwardKeyAuditTrail(
+ validRequest.roomId,
+ validRequest.sessionId,
+ validRequest.senderKey,
+ MXCRYPTO_ALGORITHM_MEGOLM,
+ requestingDevice.userId,
+ requestingDevice.deviceId,
+ chainIndex
+ )
+ true
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value)
+ .e(failure, "fail to re-share session ${validRequest.sessionId} to ${requestingDevice.shortDebugString()}")
+ false
+ }
+ }
+
+ fun addRoomKeysRequestListener(listener: GossipingRequestListener) {
+ synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.add(listener)
+ }
+ }
+
+ fun removeRoomKeysRequestListener(listener: GossipingRequestListener) {
+ synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.remove(listener)
+ }
+ }
+
+ fun close() {
+ try {
+ outgoingRequestScope.cancel("User Terminate")
+ incomingRequestBuffer.clear()
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value).w("Failed to shutDown request manager")
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXMegolmExportEncryption.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXMegolmExportEncryption.kt
index f8235bf344..89e38cb7cf 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXMegolmExportEncryption.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/MXMegolmExportEncryption.kt
@@ -29,6 +29,7 @@ import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
import kotlin.experimental.xor
import kotlin.math.min
+import kotlin.system.measureTimeMillis
/**
* Utility class to import/export the crypto data
@@ -310,40 +311,40 @@ internal object MXMegolmExportEncryption {
*/
@Throws(Exception::class)
private fun deriveKeys(salt: ByteArray, iterations: Int, password: String): ByteArray {
- val t0 = System.currentTimeMillis()
-
- // based on https://en.wikipedia.org/wiki/PBKDF2 algorithm
- // it is simpler than the generic algorithm because the expected key length is equal to the mac key length.
- // noticed as dklen/hlen
- val prf = Mac.getInstance("HmacSHA512")
- prf.init(SecretKeySpec(password.toByteArray(Charsets.UTF_8), "HmacSHA512"))
-
- // 512 bits key length
val key = ByteArray(64)
- val uc = ByteArray(64)
+ measureTimeMillis {
+ // based on https://en.wikipedia.org/wiki/PBKDF2 algorithm
+ // it is simpler than the generic algorithm because the expected key length is equal to the mac key length.
+ // noticed as dklen/hlen
+ val prf = Mac.getInstance("HmacSHA512")
+ prf.init(SecretKeySpec(password.toByteArray(Charsets.UTF_8), "HmacSHA512"))
- // U1 = PRF(Password, Salt || INT_32_BE(i))
- prf.update(salt)
- val int32BE = ByteArray(4) { 0.toByte() }
- int32BE[3] = 1.toByte()
- prf.update(int32BE)
- prf.doFinal(uc, 0)
+ // 512 bits key length
+ val uc = ByteArray(64)
- // copy to the key
- System.arraycopy(uc, 0, key, 0, uc.size)
-
- for (index in 2..iterations) {
- // Uc = PRF(Password, Uc-1)
- prf.update(uc)
+ // U1 = PRF(Password, Salt || INT_32_BE(i))
+ prf.update(salt)
+ val int32BE = ByteArray(4) { 0.toByte() }
+ int32BE[3] = 1.toByte()
+ prf.update(int32BE)
prf.doFinal(uc, 0)
- // F(Password, Salt, c, i) = U1 ^ U2 ^ ... ^ Uc
- for (byteIndex in uc.indices) {
- key[byteIndex] = key[byteIndex] xor uc[byteIndex]
- }
- }
+ // copy to the key
+ System.arraycopy(uc, 0, key, 0, uc.size)
- Timber.v("## deriveKeys() : $iterations in ${System.currentTimeMillis() - t0} ms")
+ for (index in 2..iterations) {
+ // Uc = PRF(Password, Uc-1)
+ prf.update(uc)
+ prf.doFinal(uc, 0)
+
+ // F(Password, Salt, c, i) = U1 ^ U2 ^ ... ^ Uc
+ for (byteIndex in uc.indices) {
+ key[byteIndex] = key[byteIndex] xor uc[byteIndex]
+ }
+ }
+ }.also {
+ Timber.v("## deriveKeys() : $iterations in $it ms")
+ }
return key
}
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 4947761f05..68a1519670 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
@@ -35,6 +35,7 @@ import org.matrix.android.sdk.internal.session.SessionScope
import org.matrix.android.sdk.internal.util.JsonCanonicalizer
import org.matrix.android.sdk.internal.util.convertFromUTF8
import org.matrix.android.sdk.internal.util.convertToUTF8
+import org.matrix.android.sdk.internal.util.time.Clock
import org.matrix.olm.OlmAccount
import org.matrix.olm.OlmException
import org.matrix.olm.OlmMessage
@@ -42,7 +43,6 @@ import org.matrix.olm.OlmOutboundGroupSession
import org.matrix.olm.OlmSession
import org.matrix.olm.OlmUtility
import timber.log.Timber
-import java.net.URLEncoder
import javax.inject.Inject
private val loggerTag = LoggerTag("MXOlmDevice", LoggerTag.CRYPTO)
@@ -55,7 +55,8 @@ internal class MXOlmDevice @Inject constructor(
*/
private val store: IMXCryptoStore,
private val olmSessionStore: OlmSessionStore,
- private val inboundGroupSessionStore: InboundGroupSessionStore
+ private val inboundGroupSessionStore: InboundGroupSessionStore,
+ private val clock: Clock,
) {
val mutex = Mutex()
@@ -277,7 +278,7 @@ internal class MXOlmDevice @Inject constructor(
// Pretend we've received a message at this point, otherwise
// if we try to send a message to the device, it won't use
// this session
- olmSessionWrapper.onMessageReceived()
+ olmSessionWrapper.onMessageReceived(clock.epochMillis())
olmSessionStore.storeSession(olmSessionWrapper, theirIdentityKey)
@@ -329,14 +330,6 @@ internal class MXOlmDevice @Inject constructor(
Timber.tag(loggerTag.value).e(e, "## createInboundSession() : removeOneTimeKeys failed")
}
- Timber.tag(loggerTag.value).v("## createInboundSession() : ciphertext: $ciphertext")
- try {
- val sha256 = olmUtility!!.sha256(URLEncoder.encode(ciphertext, "utf-8"))
- Timber.tag(loggerTag.value).v("## createInboundSession() :ciphertext: SHA256: $sha256")
- } catch (e: Exception) {
- Timber.tag(loggerTag.value).e(e, "## createInboundSession() :ciphertext: cannot encode ciphertext")
- }
-
val olmMessage = OlmMessage()
olmMessage.mCipherText = ciphertext
olmMessage.mType = messageType.toLong()
@@ -348,7 +341,7 @@ internal class MXOlmDevice @Inject constructor(
val olmSessionWrapper = OlmSessionWrapper(olmSession, 0)
// This counts as a received message: set last received message time to now
- olmSessionWrapper.onMessageReceived()
+ olmSessionWrapper.onMessageReceived(clock.epochMillis())
olmSessionStore.storeSession(olmSessionWrapper, theirDeviceIdentityKey)
} catch (e: Exception) {
@@ -454,7 +447,7 @@ internal class MXOlmDevice @Inject constructor(
payloadString =
olmSessionWrapper.mutex.withLock {
olmSessionWrapper.olmSession.decryptMessage(olmMessage).also {
- olmSessionWrapper.onMessageReceived()
+ olmSessionWrapper.onMessageReceived(clock.epochMillis())
}
}
olmSessionStore.storeSession(olmSessionWrapper, theirDeviceIdentityKey)
@@ -520,6 +513,7 @@ internal class MXOlmDevice @Inject constructor(
return MXOutboundSessionInfo(
sessionId = sessionId,
sharedWithHelper = SharedWithHelper(roomId, sessionId, store),
+ clock,
restoredOutboundGroupSession.creationTime
)
}
@@ -586,6 +580,13 @@ internal class MXOlmDevice @Inject constructor(
// Inbound group session
+ sealed interface AddSessionResult {
+ data class Imported(val ratchetIndex: Int) : AddSessionResult
+ abstract class Failure : AddSessionResult
+ object NotImported : Failure()
+ data class NotImportedHigherIndex(val newIndex: Int) : Failure()
+ }
+
/**
* Add an inbound group session to the session store.
*
@@ -604,7 +605,7 @@ internal class MXOlmDevice @Inject constructor(
senderKey: String,
forwardingCurve25519KeyChain: List,
keysClaimed: Map,
- exportFormat: Boolean): Boolean {
+ exportFormat: Boolean): AddSessionResult {
val candidateSession = OlmInboundGroupSessionWrapper2(sessionKey, exportFormat)
val existingSessionHolder = tryOrNull { getInboundGroupSession(sessionId, senderKey, roomId) }
val existingSession = existingSessionHolder?.wrapper
@@ -612,7 +613,7 @@ internal class MXOlmDevice @Inject constructor(
if (existingSession != null) {
Timber.tag(loggerTag.value).d("## addInboundGroupSession() check if known session is better than candidate session")
try {
- val existingFirstKnown = existingSession.firstKnownIndex ?: return false.also {
+ val existingFirstKnown = existingSession.firstKnownIndex ?: return AddSessionResult.NotImported.also {
// This is quite unexpected, could throw if native was released?
Timber.tag(loggerTag.value).e("## addInboundGroupSession() null firstKnownIndex on existing session")
candidateSession.olmInboundGroupSession?.releaseSession()
@@ -623,12 +624,12 @@ internal class MXOlmDevice @Inject constructor(
if (newKnownFirstIndex != null && existingFirstKnown <= newKnownFirstIndex) {
Timber.tag(loggerTag.value).d("## addInboundGroupSession() : ignore session our is better $senderKey/$sessionId")
candidateSession.olmInboundGroupSession?.releaseSession()
- return false
+ return AddSessionResult.NotImportedHigherIndex(newKnownFirstIndex.toInt())
}
} catch (failure: Throwable) {
Timber.tag(loggerTag.value).e("## addInboundGroupSession() Failed to add inbound: ${failure.localizedMessage}")
candidateSession.olmInboundGroupSession?.releaseSession()
- return false
+ return AddSessionResult.NotImported
}
}
@@ -638,19 +639,19 @@ internal class MXOlmDevice @Inject constructor(
val candidateOlmInboundSession = candidateSession.olmInboundGroupSession
if (null == candidateOlmInboundSession) {
Timber.tag(loggerTag.value).e("## addInboundGroupSession : invalid session ")
- return false
+ return AddSessionResult.NotImported
}
try {
if (candidateOlmInboundSession.sessionIdentifier() != sessionId) {
Timber.tag(loggerTag.value).e("## addInboundGroupSession : ERROR: Mismatched group session ID from senderKey: $senderKey")
candidateOlmInboundSession.releaseSession()
- return false
+ return AddSessionResult.NotImported
}
} catch (e: Throwable) {
candidateOlmInboundSession.releaseSession()
Timber.tag(loggerTag.value).e(e, "## addInboundGroupSession : sessionIdentifier() failed")
- return false
+ return AddSessionResult.NotImported
}
candidateSession.senderKey = senderKey
@@ -664,7 +665,7 @@ internal class MXOlmDevice @Inject constructor(
inboundGroupSessionStore.storeInBoundGroupSession(InboundGroupSessionHolder(candidateSession), sessionId, senderKey)
}
- return true
+ return AddSessionResult.Imported(candidateSession.firstKnownIndex?.toInt() ?: 0)
}
/**
@@ -787,7 +788,7 @@ internal class MXOlmDevice @Inject constructor(
if (timelineSet.contains(messageIndexKey)) {
val reason = String.format(MXCryptoError.DUPLICATE_MESSAGE_INDEX_REASON, decryptResult.mIndex)
- Timber.tag(loggerTag.value).e("## decryptGroupMessage() : $reason")
+ Timber.tag(loggerTag.value).e("## decryptGroupMessage() timelineId=$timeline: $reason")
throw MXCryptoError.Base(MXCryptoError.ErrorType.DUPLICATED_MESSAGE_INDEX, reason)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OneTimeKeysUploader.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OneTimeKeysUploader.kt
index 792c9a25dc..8143e36892 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OneTimeKeysUploader.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OneTimeKeysUploader.kt
@@ -23,6 +23,7 @@ import org.matrix.android.sdk.internal.crypto.model.rest.KeysUploadResponse
import org.matrix.android.sdk.internal.crypto.tasks.UploadKeysTask
import org.matrix.android.sdk.internal.session.SessionScope
import org.matrix.android.sdk.internal.util.JsonCanonicalizer
+import org.matrix.android.sdk.internal.util.time.Clock
import org.matrix.olm.OlmAccount
import timber.log.Timber
import javax.inject.Inject
@@ -38,6 +39,7 @@ internal class OneTimeKeysUploader @Inject constructor(
private val olmDevice: MXOlmDevice,
private val objectSigner: ObjectSigner,
private val uploadKeysTask: UploadKeysTask,
+ private val clock: Clock,
context: Context
) {
// tell if there is a OTK check in progress
@@ -77,7 +79,7 @@ internal class OneTimeKeysUploader @Inject constructor(
Timber.v("maybeUploadOneTimeKeys: already in progress")
return
}
- if (System.currentTimeMillis() - lastOneTimeKeyCheck < ONE_TIME_KEY_UPLOAD_PERIOD) {
+ if (clock.epochMillis() - lastOneTimeKeyCheck < ONE_TIME_KEY_UPLOAD_PERIOD) {
// we've done a key upload recently.
Timber.v("maybeUploadOneTimeKeys: executed too recently")
return
@@ -94,7 +96,7 @@ internal class OneTimeKeysUploader @Inject constructor(
Timber.d("maybeUploadOneTimeKeys: otk count $oneTimeKeyCountFromSync , unpublished fallback key ${olmDevice.hasUnpublishedFallbackKey()}")
- lastOneTimeKeyCheck = System.currentTimeMillis()
+ lastOneTimeKeyCheck = clock.epochMillis()
// We then check how many keys we can store in the Account object.
val maxOneTimeKeys = olmDevice.getMaxNumberOfOneTimeKeys()
@@ -126,7 +128,7 @@ internal class OneTimeKeysUploader @Inject constructor(
// Check if we need to forget a fallback key
val latestPublishedTime = getLastFallbackKeyPublishTime()
- if (latestPublishedTime != 0L && System.currentTimeMillis() - latestPublishedTime > FALLBACK_KEY_FORGET_DELAY) {
+ if (latestPublishedTime != 0L && clock.epochMillis() - latestPublishedTime > FALLBACK_KEY_FORGET_DELAY) {
// This should be called once you are reasonably certain that you will not receive any more messages
// that use the old fallback key
Timber.d("## forgetFallbackKey()")
@@ -168,7 +170,7 @@ internal class OneTimeKeysUploader @Inject constructor(
olmDevice.markKeysAsPublished()
if (hadUnpublishedFallbackKey) {
// It had an unpublished fallback key that was published just now
- saveLastFallbackKeyPublishTime(System.currentTimeMillis())
+ saveLastFallbackKeyPublishTime(clock.epochMillis())
}
if (response.hasOneTimeKeyCountsForAlgorithm(MXKey.KEY_SIGNED_CURVE_25519_TYPE)) {
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
deleted file mode 100755
index e6f6ac5053..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingGossipingRequestManager.kt
+++ /dev/null
@@ -1,167 +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
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
-import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.createUniqueTxnId
-import org.matrix.android.sdk.internal.crypto.util.RequestIdHelper
-import org.matrix.android.sdk.internal.di.SessionId
-import org.matrix.android.sdk.internal.session.SessionScope
-import org.matrix.android.sdk.internal.worker.WorkerParamsFactory
-import timber.log.Timber
-import javax.inject.Inject
-
-@SessionScope
-internal class OutgoingGossipingRequestManager @Inject constructor(
- @SessionId private val sessionId: String,
- private val cryptoStore: IMXCryptoStore,
- private val coroutineDispatchers: MatrixCoroutineDispatchers,
- private val cryptoCoroutineScope: CoroutineScope,
- private val gossipingWorkManager: GossipingWorkManager) {
-
- /**
- * Send off a room key request, if we haven't already done so.
- *
- *
- * The `requestBody` is compared (with a deep-equality check) against
- * previous queued or sent requests and if it matches, no change is made.
- * Otherwise, a request is added to the pending list, and a job is started
- * in the background to send it.
- *
- * @param requestBody requestBody
- * @param recipients recipients
- */
- fun sendRoomKeyRequest(requestBody: RoomKeyRequestBody, recipients: Map>) {
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- cryptoStore.getOrAddOutgoingRoomKeyRequest(requestBody, recipients)?.let {
- // Don't resend if it's already done, you need to cancel first (reRequest)
- if (it.state == OutgoingGossipingRequestState.SENDING || it.state == OutgoingGossipingRequestState.SENT) {
- Timber.v("## CRYPTO - GOSSIP sendOutgoingRoomKeyRequest() : we already request for that session: $it")
- return@launch
- }
-
- sendOutgoingGossipingRequest(it)
- }
- }
- }
-
- fun sendSecretShareRequest(secretName: String, recipients: Map>) {
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- // A bit dirty, but for better stability give other party some time to mark
- // devices trusted :/
- delay(1500)
- cryptoStore.getOrAddOutgoingSecretShareRequest(secretName, recipients)?.let {
- // TODO check if there is already one that is being sent?
- if (it.state == OutgoingGossipingRequestState.SENDING
- /**|| it.state == OutgoingGossipingRequestState.SENT*/
- ) {
- Timber.v("## CRYPTO - GOSSIP sendSecretShareRequest() : we are already sending for that session: $it")
- return@launch
- }
-
- sendOutgoingGossipingRequest(it)
- }
- }
- }
-
- /**
- * Cancel room key requests, if any match the given details
- *
- * @param requestBody requestBody
- */
- fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody) {
- cryptoCoroutineScope.launch(coroutineDispatchers.computation) {
- cancelRoomKeyRequest(requestBody, false)
- }
- }
-
- /**
- * Cancel room key requests, if any match the given details, and resend
- *
- * @param requestBody requestBody
- */
- fun resendRoomKeyRequest(requestBody: RoomKeyRequestBody) {
- cryptoCoroutineScope.launch(coroutineDispatchers.computation) {
- cancelRoomKeyRequest(requestBody, true)
- }
- }
-
- /**
- * Cancel room key requests, if any match the given details, and resend
- *
- * @param requestBody requestBody
- * @param andResend true to resend the key request
- */
- private fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody, andResend: Boolean) {
- val req = cryptoStore.getOutgoingRoomKeyRequest(requestBody) // no request was made for this key
- ?: return Unit.also {
- Timber.v("## CRYPTO - GOSSIP cancelRoomKeyRequest() Unknown request $requestBody")
- }
-
- sendOutgoingRoomKeyRequestCancellation(req, andResend)
- }
-
- /**
- * Send the outgoing key request.
- *
- * @param request the request
- */
- private fun sendOutgoingGossipingRequest(request: OutgoingGossipingRequest) {
- Timber.v("## CRYPTO - GOSSIP sendOutgoingGossipingRequest() : Requesting keys $request")
-
- val params = SendGossipRequestWorker.Params(
- sessionId = sessionId,
- keyShareRequest = request as? OutgoingRoomKeyRequest,
- secretShareRequest = request as? OutgoingSecretRequest,
- txnId = createUniqueTxnId()
- )
- cryptoStore.updateOutgoingGossipingRequestState(request.requestId, OutgoingGossipingRequestState.SENDING)
- val workRequest = gossipingWorkManager.createWork(WorkerParamsFactory.toData(params), true)
- gossipingWorkManager.postWork(workRequest)
- }
-
- /**
- * Given a OutgoingRoomKeyRequest, cancel it and delete the request record
- *
- * @param request the request
- */
- private fun sendOutgoingRoomKeyRequestCancellation(request: OutgoingRoomKeyRequest, resend: Boolean = false) {
- Timber.v("## CRYPTO - sendOutgoingRoomKeyRequestCancellation $request")
- val params = CancelGossipRequestWorker.Params.fromRequest(sessionId, request)
- cryptoStore.updateOutgoingGossipingRequestState(request.requestId, OutgoingGossipingRequestState.CANCELLING)
-
- val workRequest = gossipingWorkManager.createWork(WorkerParamsFactory.toData(params), true)
- gossipingWorkManager.postWork(workRequest)
-
- if (resend) {
- val reSendParams = SendGossipRequestWorker.Params(
- sessionId = sessionId,
- keyShareRequest = request.copy(requestId = RequestIdHelper.createUniqueRequestId()),
- txnId = createUniqueTxnId()
- )
- val reSendWorkRequest = gossipingWorkManager.createWork(WorkerParamsFactory.toData(reSendParams), true)
- gossipingWorkManager.postWork(reSendWorkRequest)
- }
- }
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingKeyRequestManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingKeyRequestManager.kt
new file mode 100755
index 0000000000..09a9868428
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingKeyRequestManager.kt
@@ -0,0 +1,518 @@
+/*
+ * 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
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
+import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM
+import org.matrix.android.sdk.api.crypto.MXCryptoConfig
+import org.matrix.android.sdk.api.extensions.tryOrNull
+import org.matrix.android.sdk.api.logger.LoggerTag
+import org.matrix.android.sdk.api.session.crypto.OutgoingKeyRequest
+import org.matrix.android.sdk.api.session.crypto.OutgoingRoomKeyRequestState
+import org.matrix.android.sdk.api.session.crypto.model.GossipingToDeviceObject
+import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
+import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
+import org.matrix.android.sdk.api.session.crypto.model.RoomKeyShareRequest
+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.content.EncryptedEventContent
+import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
+import org.matrix.android.sdk.api.session.events.model.toModel
+import org.matrix.android.sdk.api.util.fromBase64
+import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
+import org.matrix.android.sdk.internal.di.SessionId
+import org.matrix.android.sdk.internal.di.UserId
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.task.SemaphoreCoroutineSequencer
+import timber.log.Timber
+import java.util.Stack
+import java.util.concurrent.Executors
+import javax.inject.Inject
+import kotlin.system.measureTimeMillis
+
+private val loggerTag = LoggerTag("OutgoingKeyRequestManager", LoggerTag.CRYPTO)
+
+/**
+ * This class is responsible for sending key requests to other devices when a message failed to decrypt.
+ * It's lifecycle is based on the sync pulse:
+ * - You can post queries for session, or report when you got a session
+ * - At the end of the sync (onSyncComplete) it will then process all the posted request and send to devices
+ * If a request failed it will be retried at the end of the next sync
+ */
+@SessionScope
+internal class OutgoingKeyRequestManager @Inject constructor(
+ @SessionId private val sessionId: String,
+ @UserId private val myUserId: String,
+ private val cryptoStore: IMXCryptoStore,
+ private val coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val cryptoConfig: MXCryptoConfig,
+ private val inboundGroupSessionStore: InboundGroupSessionStore,
+ private val sendToDeviceTask: SendToDeviceTask,
+ private val deviceListManager: DeviceListManager,
+ private val perSessionBackupQueryRateLimiter: PerSessionBackupQueryRateLimiter) {
+
+ private val dispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+ private val outgoingRequestScope = CoroutineScope(SupervisorJob() + dispatcher)
+ private val sequencer = SemaphoreCoroutineSequencer()
+
+ // We only have one active key request per session, so we don't request if it's already requested
+ // But it could make sense to check more the backup, as it's evolving.
+ // We keep a stack as we consider that the key requested last is more likely to be on screen?
+ private val requestDiscardedBecauseAlreadySentThatCouldBeTriedWithBackup = Stack>()
+
+ fun requestKeyForEvent(event: Event, force: Boolean) {
+ val (targets, body) = getRoomKeyRequestTargetForEvent(event) ?: return
+ val index = ratchetIndexForMessage(event) ?: 0
+ postRoomKeyRequest(body, targets, index, force)
+ }
+
+ private fun getRoomKeyRequestTargetForEvent(event: Event): Pair>, RoomKeyRequestBody>? {
+ val sender = event.senderId ?: return null
+ val encryptedEventContent = event.content.toModel() ?: return null.also {
+ Timber.tag(loggerTag.value).e("getRoomKeyRequestTargetForEvent Failed to re-request key, null content")
+ }
+ if (encryptedEventContent.algorithm != MXCRYPTO_ALGORITHM_MEGOLM) return null
+
+ val senderDevice = encryptedEventContent.deviceId
+ val recipients = if (cryptoConfig.limitRoomKeyRequestsToMyDevices) {
+ mapOf(
+ myUserId to listOf("*")
+ )
+ } else {
+ if (event.senderId == myUserId) {
+ mapOf(
+ myUserId to listOf("*")
+ )
+ } else {
+ // for the case where you share the key with a device that has a broken olm session
+ // The other user might Re-shares a megolm session key with devices if the key has already been
+ // sent to them.
+ mapOf(
+ myUserId to listOf("*"),
+
+ // We might not have deviceId in the future due to https://github.com/matrix-org/matrix-spec-proposals/pull/3700
+ // so in this case query to all
+ sender to listOf(senderDevice ?: "*")
+ )
+ }
+ }
+
+ val requestBody = RoomKeyRequestBody(
+ roomId = event.roomId,
+ algorithm = encryptedEventContent.algorithm,
+ senderKey = encryptedEventContent.senderKey,
+ sessionId = encryptedEventContent.sessionId
+ )
+ return recipients to requestBody
+ }
+
+ private fun ratchetIndexForMessage(event: Event): Int? {
+ val encryptedContent = event.content.toModel() ?: return null
+ if (encryptedContent.algorithm != MXCRYPTO_ALGORITHM_MEGOLM) return null
+ return encryptedContent.ciphertext?.fromBase64()?.inputStream()?.reader()?.let {
+ tryOrNull {
+ val megolmVersion = it.read()
+ if (megolmVersion != 3) return@tryOrNull null
+ /** Int tag */
+ if (it.read() != 8) return@tryOrNull null
+ it.read()
+ }
+ }
+ }
+
+ fun postRoomKeyRequest(requestBody: RoomKeyRequestBody, recipients: Map>, fromIndex: Int, force: Boolean = false) {
+ outgoingRequestScope.launch {
+ sequencer.post {
+ internalQueueRequest(requestBody, recipients, fromIndex, force)
+ }
+ }
+ }
+
+ /**
+ * Typically called when we the session as been imported or received meanwhile
+ */
+ fun postCancelRequestForSessionIfNeeded(sessionId: String, roomId: String, senderKey: String, fromIndex: Int) {
+ outgoingRequestScope.launch {
+ sequencer.post {
+ internalQueueCancelRequest(sessionId, roomId, senderKey, fromIndex)
+ }
+ }
+ }
+
+ fun onSelfCrossSigningTrustChanged(newTrust: Boolean) {
+ if (newTrust) {
+ // we were previously not cross signed, but we are now
+ // so there is now more chances to get better replies for existing request
+ // Let's forget about sent request so that next time we try to decrypt we will resend requests
+ // We don't resend all because we don't want to generate a bulk of traffic
+ outgoingRequestScope.launch {
+ sequencer.post {
+ cryptoStore.deleteOutgoingRoomKeyRequestInState(OutgoingRoomKeyRequestState.SENT)
+ }
+
+ sequencer.post {
+ delay(1000)
+ perSessionBackupQueryRateLimiter.refreshBackupInfoIfNeeded(true)
+ }
+ }
+ }
+ }
+
+ fun onRoomKeyForwarded(sessionId: String,
+ algorithm: String,
+ roomId: String,
+ senderKey: String,
+ fromDevice: String?,
+ fromIndex: Int,
+ event: Event) {
+ Timber.tag(loggerTag.value).d("Key forwarded for $sessionId from ${event.senderId}|$fromDevice at index $fromIndex")
+ outgoingRequestScope.launch {
+ sequencer.post {
+ cryptoStore.updateOutgoingRoomKeyReply(
+ roomId = roomId,
+ sessionId = sessionId,
+ algorithm = algorithm,
+ senderKey = senderKey,
+ fromDevice = fromDevice,
+ // strip out encrypted stuff as it's just a trail?
+ event = event.copy(
+ type = event.getClearType(),
+ content = mapOf(
+ "chain_index" to fromIndex
+ )
+ )
+ )
+ }
+ }
+ }
+
+ fun onRoomKeyWithHeld(sessionId: String,
+ algorithm: String,
+ roomId: String,
+ senderKey: String,
+ fromDevice: String?,
+ event: Event) {
+ outgoingRequestScope.launch {
+ sequencer.post {
+ Timber.tag(loggerTag.value).d("Withheld received for $sessionId from ${event.senderId}|$fromDevice")
+ Timber.tag(loggerTag.value).v("Withheld content ${event.getClearContent()}")
+
+ // We want to store withheld code from the sender of the message (owner of the megolm session), not from
+ // other devices that might gossip the key. If not the initial reason might be overridden
+ // by a request to one of our session.
+ event.getClearContent().toModel()?.let { withheld ->
+ withContext(coroutineDispatchers.crypto) {
+ tryOrNull {
+ deviceListManager.downloadKeys(listOf(event.senderId ?: ""), false)
+ }
+ cryptoStore.getUserDeviceList(event.senderId ?: "")
+ .also { devices ->
+ Timber.tag(loggerTag.value)
+ .v("Withheld Devices for ${event.senderId} are ${devices.orEmpty().joinToString { it.identityKey() ?: "" }}")
+ }
+ ?.firstOrNull {
+ it.identityKey() == senderKey
+ }
+ }.also {
+ Timber.tag(loggerTag.value).v("Withheld device for sender key $senderKey is from ${it?.shortDebugString()}")
+ }?.let {
+ if (it.userId == event.senderId) {
+ if (fromDevice != null) {
+ if (it.deviceId == fromDevice) {
+ Timber.tag(loggerTag.value).v("Storing sender Withheld code ${withheld.code} for ${withheld.sessionId}")
+ cryptoStore.addWithHeldMegolmSession(withheld)
+ }
+ } else {
+ Timber.tag(loggerTag.value).v("Storing sender Withheld code ${withheld.code} for ${withheld.sessionId}")
+ cryptoStore.addWithHeldMegolmSession(withheld)
+ }
+ }
+ }
+ }
+
+ // Here we store the replies from a given request
+ cryptoStore.updateOutgoingRoomKeyReply(
+ roomId = roomId,
+ sessionId = sessionId,
+ algorithm = algorithm,
+ senderKey = senderKey,
+ fromDevice = fromDevice,
+ event = event
+ )
+ }
+ }
+ }
+
+ /**
+ * Should be called after a sync, ideally if no catchup sync needed (as keys might arrive in those)
+ */
+ fun requireProcessAllPendingKeyRequests() {
+ outgoingRequestScope.launch {
+ sequencer.post {
+ internalProcessPendingKeyRequests()
+ }
+ }
+ }
+
+ private fun internalQueueCancelRequest(sessionId: String, roomId: String, senderKey: String, localKnownChainIndex: Int) {
+ // do we have known requests for that session??
+ Timber.tag(loggerTag.value).v("Cancel Key Request if needed for $sessionId")
+ val knownRequest = cryptoStore.getOutgoingRoomKeyRequest(
+ algorithm = MXCRYPTO_ALGORITHM_MEGOLM,
+ roomId = roomId,
+ sessionId = sessionId,
+ senderKey = senderKey
+ )
+ if (knownRequest.isEmpty()) return Unit.also {
+ Timber.tag(loggerTag.value).v("Handle Cancel Key Request for $sessionId -- Was not currently requested")
+ }
+ if (knownRequest.size > 1) {
+ // It's worth logging, there should be only one
+ Timber.tag(loggerTag.value).w("Found multiple requests for same sessionId $sessionId")
+ }
+ knownRequest.forEach { request ->
+ when (request.state) {
+ OutgoingRoomKeyRequestState.UNSENT -> {
+ if (request.fromIndex >= localKnownChainIndex) {
+ // we have a good index we can cancel
+ cryptoStore.deleteOutgoingRoomKeyRequest(request.requestId)
+ }
+ }
+ OutgoingRoomKeyRequestState.SENT -> {
+ // It was already sent, and index satisfied we can cancel
+ if (request.fromIndex >= localKnownChainIndex) {
+ cryptoStore.updateOutgoingRoomKeyRequestState(request.requestId, OutgoingRoomKeyRequestState.CANCELLATION_PENDING)
+ }
+ }
+ OutgoingRoomKeyRequestState.CANCELLATION_PENDING -> {
+ // It is already marked to be cancelled
+ }
+ OutgoingRoomKeyRequestState.CANCELLATION_PENDING_AND_WILL_RESEND -> {
+ if (request.fromIndex >= localKnownChainIndex) {
+ // we just want to cancel now
+ cryptoStore.updateOutgoingRoomKeyRequestState(request.requestId, OutgoingRoomKeyRequestState.CANCELLATION_PENDING)
+ }
+ }
+ OutgoingRoomKeyRequestState.SENT_THEN_CANCELED -> {
+ // was already canceled
+ // if we need a better index, should we resend?
+ }
+ }
+ }
+ }
+
+ fun close() {
+ try {
+ outgoingRequestScope.cancel("User Terminate")
+ requestDiscardedBecauseAlreadySentThatCouldBeTriedWithBackup.clear()
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value).w("Failed to shutDown request manager")
+ }
+ }
+
+ private fun internalQueueRequest(requestBody: RoomKeyRequestBody, recipients: Map>, fromIndex: Int, force: Boolean) {
+ if (!cryptoStore.isKeyGossipingEnabled()) {
+ // we might want to try backup?
+ if (requestBody.roomId != null && requestBody.sessionId != null) {
+ requestDiscardedBecauseAlreadySentThatCouldBeTriedWithBackup.push(requestBody.roomId to requestBody.sessionId)
+ }
+ Timber.tag(loggerTag.value).d("discarding request for ${requestBody.sessionId} as gossiping is disabled")
+ return
+ }
+
+ Timber.tag(loggerTag.value).d("Queueing key request for ${requestBody.sessionId} force:$force")
+ val existing = cryptoStore.getOutgoingRoomKeyRequest(requestBody)
+ Timber.tag(loggerTag.value).v("Queueing key request exiting is ${existing?.state}")
+ when (existing?.state) {
+ null -> {
+ // create a new one
+ cryptoStore.getOrAddOutgoingRoomKeyRequest(requestBody, recipients, fromIndex)
+ }
+ OutgoingRoomKeyRequestState.UNSENT -> {
+ // nothing it's new or not yet handled
+ }
+ OutgoingRoomKeyRequestState.SENT -> {
+ // it was already requested
+ Timber.tag(loggerTag.value).d("The session ${requestBody.sessionId} is already requested")
+ if (force) {
+ // update to UNSENT
+ Timber.tag(loggerTag.value).d(".. force to request ${requestBody.sessionId}")
+ cryptoStore.updateOutgoingRoomKeyRequestState(existing.requestId, OutgoingRoomKeyRequestState.CANCELLATION_PENDING_AND_WILL_RESEND)
+ } else {
+ if (existing.roomId != null && existing.sessionId != null) {
+ requestDiscardedBecauseAlreadySentThatCouldBeTriedWithBackup.push(existing.roomId to existing.sessionId)
+ }
+ }
+ }
+ OutgoingRoomKeyRequestState.CANCELLATION_PENDING -> {
+ // request is canceled only if I got the keys so what to do here...
+ if (force) {
+ cryptoStore.updateOutgoingRoomKeyRequestState(existing.requestId, OutgoingRoomKeyRequestState.CANCELLATION_PENDING_AND_WILL_RESEND)
+ }
+ }
+ OutgoingRoomKeyRequestState.CANCELLATION_PENDING_AND_WILL_RESEND -> {
+ // It's already going to resend
+ }
+ OutgoingRoomKeyRequestState.SENT_THEN_CANCELED -> {
+ if (force) {
+ cryptoStore.deleteOutgoingRoomKeyRequest(existing.requestId)
+ cryptoStore.getOrAddOutgoingRoomKeyRequest(requestBody, recipients, fromIndex)
+ }
+ }
+ }
+
+ if (existing != null && existing.fromIndex >= fromIndex) {
+ // update the required index
+ cryptoStore.updateOutgoingRoomKeyRequiredIndex(existing.requestId, fromIndex)
+ }
+ }
+
+ private suspend fun internalProcessPendingKeyRequests() {
+ val toProcess = cryptoStore.getOutgoingRoomKeyRequests(OutgoingRoomKeyRequestState.pendingStates())
+ Timber.tag(loggerTag.value).v("Processing all pending key requests (found ${toProcess.size} pending)")
+
+ measureTimeMillis {
+ toProcess.forEach {
+ when (it.state) {
+ OutgoingRoomKeyRequestState.UNSENT -> handleUnsentRequest(it)
+ OutgoingRoomKeyRequestState.CANCELLATION_PENDING -> handleRequestToCancel(it)
+ OutgoingRoomKeyRequestState.CANCELLATION_PENDING_AND_WILL_RESEND -> handleRequestToCancelWillResend(it)
+ OutgoingRoomKeyRequestState.SENT_THEN_CANCELED,
+ OutgoingRoomKeyRequestState.SENT -> {
+ // these are filtered out
+ }
+ }
+ }
+ }.let {
+ Timber.tag(loggerTag.value).v("Finish processing pending key request in $it ms")
+ }
+
+ val maxBackupCallsBySync = 60
+ var currentCalls = 0
+ measureTimeMillis {
+ while (requestDiscardedBecauseAlreadySentThatCouldBeTriedWithBackup.isNotEmpty() && currentCalls < maxBackupCallsBySync) {
+ requestDiscardedBecauseAlreadySentThatCouldBeTriedWithBackup.pop().let { (roomId, sessionId) ->
+ // we want to rate limit that somehow :/
+ perSessionBackupQueryRateLimiter.tryFromBackupIfPossible(sessionId, roomId)
+ }
+ currentCalls++
+ }
+ }.let {
+ Timber.tag(loggerTag.value).v("Finish querying backup in $it ms")
+ }
+ }
+
+ private suspend fun handleUnsentRequest(request: OutgoingKeyRequest) {
+ // In order to avoid generating to_device traffic, we can first check if the key is backed up
+ Timber.tag(loggerTag.value).v("Handling unsent request for megolm session ${request.sessionId} in ${request.roomId}")
+ val sessionId = request.sessionId ?: return
+ val roomId = request.roomId ?: return
+ if (perSessionBackupQueryRateLimiter.tryFromBackupIfPossible(sessionId, roomId)) {
+ // let's see what's the index
+ val knownIndex = tryOrNull {
+ inboundGroupSessionStore.getInboundGroupSession(sessionId, request.requestBody?.senderKey ?: "")?.wrapper?.firstKnownIndex
+ }
+ if (knownIndex != null && knownIndex <= request.fromIndex) {
+ // we found the key in backup with good enough index, so we can just mark as cancelled, no need to send request
+ Timber.tag(loggerTag.value).v("Megolm session $sessionId successfully restored from backup, do not send request")
+ cryptoStore.deleteOutgoingRoomKeyRequest(request.requestId)
+ return
+ }
+ }
+
+ // we need to send the request
+ val toDeviceContent = RoomKeyShareRequest(
+ requestingDeviceId = cryptoStore.getDeviceId(),
+ requestId = request.requestId,
+ action = GossipingToDeviceObject.ACTION_SHARE_REQUEST,
+ body = request.requestBody
+ )
+ val contentMap = MXUsersDevicesMap()
+ request.recipients.forEach { userToDeviceMap ->
+ userToDeviceMap.value.forEach { deviceId ->
+ contentMap.setObject(userToDeviceMap.key, deviceId, toDeviceContent)
+ }
+ }
+
+ val params = SendToDeviceTask.Params(
+ eventType = EventType.ROOM_KEY_REQUEST,
+ contentMap = contentMap,
+ transactionId = request.requestId
+ )
+ try {
+ withContext(coroutineDispatchers.io) {
+ sendToDeviceTask.executeRetry(params, 3)
+ }
+ Timber.tag(loggerTag.value).d("Key request sent for $sessionId in room $roomId to ${request.recipients}")
+ // The request was sent, so update state
+ cryptoStore.updateOutgoingRoomKeyRequestState(request.requestId, OutgoingRoomKeyRequestState.SENT)
+ // TODO update the audit trail
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value).v("Failed to request $sessionId targets:${request.recipients}")
+ }
+ }
+
+ private suspend fun handleRequestToCancel(request: OutgoingKeyRequest): Boolean {
+ Timber.tag(loggerTag.value).v("handleRequestToCancel for megolm session ${request.sessionId}")
+ // we have to cancel this
+ val toDeviceContent = RoomKeyShareRequest(
+ requestingDeviceId = cryptoStore.getDeviceId(),
+ requestId = request.requestId,
+ action = GossipingToDeviceObject.ACTION_SHARE_CANCELLATION
+ )
+ val contentMap = MXUsersDevicesMap()
+ request.recipients.forEach { userToDeviceMap ->
+ userToDeviceMap.value.forEach { deviceId ->
+ contentMap.setObject(userToDeviceMap.key, deviceId, toDeviceContent)
+ }
+ }
+
+ val params = SendToDeviceTask.Params(
+ eventType = EventType.ROOM_KEY_REQUEST,
+ contentMap = contentMap,
+ transactionId = request.requestId
+ )
+ return try {
+ withContext(coroutineDispatchers.io) {
+ sendToDeviceTask.executeRetry(params, 3)
+ }
+ // The request cancellation was sent, we don't delete yet because we want
+ // to keep trace of the sent replies
+ cryptoStore.updateOutgoingRoomKeyRequestState(request.requestId, OutgoingRoomKeyRequestState.SENT_THEN_CANCELED)
+ true
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value).v("Failed to cancel request ${request.requestId} for session $sessionId targets:${request.recipients}")
+ false
+ }
+ }
+
+ private suspend fun handleRequestToCancelWillResend(request: OutgoingKeyRequest) {
+ if (handleRequestToCancel(request)) {
+ // this will create a new unsent request with no replies that will be process in the following call
+ cryptoStore.deleteOutgoingRoomKeyRequest(request.requestId)
+ request.requestBody?.let { cryptoStore.getOrAddOutgoingRoomKeyRequest(it, request.recipients, request.fromIndex) }
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingSecretRequest.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingSecretRequest.kt
deleted file mode 100755
index 2ba2f5c817..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/OutgoingSecretRequest.kt
+++ /dev/null
@@ -1,39 +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
-
-import com.squareup.moshi.JsonClass
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
-
-/**
- * Represents an outgoing room key request
- */
-@JsonClass(generateAdapter = true)
-internal class OutgoingSecretRequest(
- // Secret Name
- val secretName: String?,
- // list of recipients for the request
- override var recipients: Map>,
- // Unique id for this request. Used for both
- // an id within the request for later pairing with a cancellation, and for
- // the transaction id when sending the to_device messages to our local
- override var requestId: String,
- // current state of this request
- override var state: OutgoingGossipingRequestState) : OutgoingGossipingRequest {
-
- // transaction id for the cancellation, if any
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/PerSessionBackupQueryRateLimiter.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/PerSessionBackupQueryRateLimiter.kt
new file mode 100644
index 0000000000..0c059e7ca9
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/PerSessionBackupQueryRateLimiter.kt
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2022 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
+
+import dagger.Lazy
+import kotlinx.coroutines.withContext
+import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
+import org.matrix.android.sdk.api.logger.LoggerTag
+import org.matrix.android.sdk.api.session.crypto.keysbackup.KeysVersionResult
+import org.matrix.android.sdk.api.session.crypto.keysbackup.SavedKeyBackupKeyInfo
+import org.matrix.android.sdk.api.session.crypto.model.ImportRoomKeysResult
+import org.matrix.android.sdk.api.util.awaitCallback
+import org.matrix.android.sdk.internal.crypto.keysbackup.DefaultKeysBackupService
+import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.util.time.Clock
+import timber.log.Timber
+import javax.inject.Inject
+
+// I keep the same name as OutgoingGossipingRequestManager to ease filtering of logs
+private val loggerTag = LoggerTag("OutgoingGossipingRequestManager", LoggerTag.CRYPTO)
+
+/**
+ * Used to try to get the key for UISI messages before sending room key request.
+ * We are adding some rate limiting to avoid querying too much for a key not in backup.
+ * Nonetheless the backup can be updated so we might want to retry from time to time.
+ */
+internal class PerSessionBackupQueryRateLimiter @Inject constructor(
+ private val coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val keysBackupService: Lazy,
+ private val cryptoStore: IMXCryptoStore,
+ private val clock: Clock,
+) {
+
+ companion object {
+ val MIN_TRY_BACKUP_PERIOD_MILLIS = 60 * 60_000 // 1 hour
+ }
+
+ data class Info(
+ val megolmSessionId: String,
+ val roomId: String
+ )
+
+ data class LastTry(
+ val backupVersion: String,
+ val timestamp: Long
+ )
+
+ /**
+ * Remember what we already tried (a key not in backup or some server issue)
+ * We might want to retry from time to time as the backup could have been updated
+ */
+ private val lastFailureMap = mutableMapOf()
+
+ private var backupVersion: KeysVersionResult? = null
+ private var savedKeyBackupKeyInfo: SavedKeyBackupKeyInfo? = null
+ var backupWasCheckedFromServer: Boolean = false
+ val now = clock.epochMillis()
+
+ fun refreshBackupInfoIfNeeded(force: Boolean = false) {
+ if (backupWasCheckedFromServer && !force) return
+ Timber.tag(loggerTag.value).v("Checking if can access a backup")
+ backupWasCheckedFromServer = true
+ val knownBackupSecret = cryptoStore.getKeyBackupRecoveryKeyInfo()
+ ?: return Unit.also {
+ Timber.tag(loggerTag.value).v("We don't have the backup secret!")
+ }
+ this.backupVersion = keysBackupService.get().keysBackupVersion
+ this.savedKeyBackupKeyInfo = knownBackupSecret
+ }
+
+ suspend fun tryFromBackupIfPossible(sessionId: String, roomId: String): Boolean {
+ Timber.tag(loggerTag.value).v("tryFromBackupIfPossible for session:$sessionId in $roomId")
+ refreshBackupInfoIfNeeded()
+ val currentVersion = backupVersion
+ if (savedKeyBackupKeyInfo?.version == null ||
+ currentVersion == null ||
+ currentVersion.version != savedKeyBackupKeyInfo?.version) {
+ // We can't access the backup
+ Timber.tag(loggerTag.value).v("Can't get backup version info")
+ return false
+ }
+ val cacheKey = Info(sessionId, roomId)
+ val lastTry = lastFailureMap[cacheKey]
+ val shouldQuery =
+ lastTry == null ||
+ lastTry.backupVersion != currentVersion.version ||
+ (now - lastTry.timestamp) > MIN_TRY_BACKUP_PERIOD_MILLIS
+
+ if (!shouldQuery) return false
+
+ val successfullyImported = withContext(coroutineDispatchers.io) {
+ try {
+ awaitCallback {
+ keysBackupService.get().restoreKeysWithRecoveryKey(
+ currentVersion,
+ savedKeyBackupKeyInfo?.recoveryKey ?: "",
+ roomId,
+ sessionId,
+ null,
+ it
+ )
+ }.successfullyNumberOfImportedKeys
+ } catch (failure: Throwable) {
+ // Fail silently
+ Timber.tag(loggerTag.value).v("getFromBackup failed ${failure.localizedMessage}")
+ 0
+ }
+ }
+ if (successfullyImported == 1) {
+ Timber.tag(loggerTag.value).v("Found key in backup session:$sessionId in $roomId")
+ lastFailureMap.remove(cacheKey)
+ return true
+ } else {
+ Timber.tag(loggerTag.value).v("Failed to find key in backup session:$sessionId in $roomId")
+ lastFailureMap[cacheKey] = LastTry(currentVersion.version, clock.epochMillis())
+ return false
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/RoomEncryptorsStore.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/RoomEncryptorsStore.kt
index ba97d96133..1a8c160d9c 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/RoomEncryptorsStore.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/RoomEncryptorsStore.kt
@@ -16,12 +16,21 @@
package org.matrix.android.sdk.internal.crypto
+import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM
+import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_OLM
import org.matrix.android.sdk.internal.crypto.algorithms.IMXEncrypting
+import org.matrix.android.sdk.internal.crypto.algorithms.megolm.MXMegolmEncryptionFactory
+import org.matrix.android.sdk.internal.crypto.algorithms.olm.MXOlmEncryptionFactory
+import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
import org.matrix.android.sdk.internal.session.SessionScope
import javax.inject.Inject
@SessionScope
-internal class RoomEncryptorsStore @Inject constructor() {
+internal class RoomEncryptorsStore @Inject constructor(
+ private val cryptoStore: IMXCryptoStore,
+ private val megolmEncryptionFactory: MXMegolmEncryptionFactory,
+ private val olmEncryptionFactory: MXOlmEncryptionFactory,
+) {
// MXEncrypting instance for each room.
private val roomEncryptors = mutableMapOf()
@@ -34,7 +43,18 @@ internal class RoomEncryptorsStore @Inject constructor() {
fun get(roomId: String): IMXEncrypting? {
return synchronized(roomEncryptors) {
- roomEncryptors[roomId]
+ val cache = roomEncryptors[roomId]
+ if (cache != null) {
+ return@synchronized cache
+ } else {
+ val alg: IMXEncrypting? = when (cryptoStore.getRoomAlgorithm(roomId)) {
+ MXCRYPTO_ALGORITHM_MEGOLM -> megolmEncryptionFactory.create(roomId)
+ MXCRYPTO_ALGORITHM_OLM -> olmEncryptionFactory.create(roomId)
+ else -> null
+ }
+ alg?.let { roomEncryptors.put(roomId, it) }
+ return@synchronized alg
+ }
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SecretShareManager.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SecretShareManager.kt
new file mode 100644
index 0000000000..6fb6914206
--- /dev/null
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SecretShareManager.kt
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2022 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
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
+import org.matrix.android.sdk.api.auth.data.Credentials
+import org.matrix.android.sdk.api.logger.LoggerTag
+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
+import org.matrix.android.sdk.api.session.crypto.crosssigning.SELF_SIGNING_KEY_SSSS_NAME
+import org.matrix.android.sdk.api.session.crypto.crosssigning.USER_SIGNING_KEY_SSSS_NAME
+import org.matrix.android.sdk.api.session.crypto.keysbackup.extractCurveKeyFromRecoveryKey
+import org.matrix.android.sdk.api.session.crypto.keyshare.GossipingRequestListener
+import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
+import org.matrix.android.sdk.api.session.crypto.model.SecretShareRequest
+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.content.SecretSendEventContent
+import org.matrix.android.sdk.api.session.events.model.toModel
+import org.matrix.android.sdk.api.util.toBase64NoPadding
+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.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
+import org.matrix.android.sdk.internal.crypto.tasks.createUniqueTxnId
+import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.util.time.Clock
+import timber.log.Timber
+import javax.inject.Inject
+
+private val loggerTag = LoggerTag("SecretShareManager", LoggerTag.CRYPTO)
+
+@SessionScope
+internal class SecretShareManager @Inject constructor(
+ private val credentials: Credentials,
+ private val cryptoStore: IMXCryptoStore,
+ private val cryptoCoroutineScope: CoroutineScope,
+ private val messageEncrypter: MessageEncrypter,
+ private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction,
+ private val sendToDeviceTask: SendToDeviceTask,
+ private val coroutineDispatchers: MatrixCoroutineDispatchers,
+ private val clock: Clock,
+) {
+
+ companion object {
+ private const val SECRET_SHARE_WINDOW_DURATION = 5 * 60 * 1000 // 5 minutes
+ }
+
+ /**
+ * Secret gossiping only occurs during a limited window period after interactive verification.
+ * We keep track of recent verification in memory for that purpose (no need to persist)
+ */
+ private val recentlyVerifiedDevices = mutableMapOf()
+ private val verifMutex = Mutex()
+
+ /**
+ * Secrets are exchanged as part of interactive verification,
+ * so we can just store in memory.
+ */
+ private val outgoingSecretRequests = mutableListOf()
+
+ // the listeners
+ private val gossipingRequestListeners: MutableSet = HashSet()
+
+ fun addListener(listener: GossipingRequestListener) {
+ synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.add(listener)
+ }
+ }
+
+ fun removeListener(listener: GossipingRequestListener) {
+ synchronized(gossipingRequestListeners) {
+ gossipingRequestListeners.remove(listener)
+ }
+ }
+
+ /**
+ * Called when a session has been verified.
+ * This information can be used by the manager to decide whether or not to fullfill gossiping requests.
+ * This should be called as fast as possible after a successful self interactive verification
+ */
+ fun onVerificationCompleteForDevice(deviceId: String) {
+ // For now we just keep an in memory cache
+ cryptoCoroutineScope.launch {
+ verifMutex.withLock {
+ recentlyVerifiedDevices[deviceId] = clock.epochMillis()
+ }
+ }
+ }
+
+ suspend fun handleSecretRequest(toDevice: Event) {
+ val request = toDevice.getClearContent().toModel()
+ ?: return Unit.also {
+ Timber.tag(loggerTag.value)
+ .w("handleSecretRequest() : malformed request")
+ }
+
+// val (action, requestingDeviceId, requestId, secretName) = it
+ val secretName = request.secretName ?: return Unit.also {
+ Timber.tag(loggerTag.value)
+ .v("handleSecretRequest() : Missing secret name")
+ }
+
+ val userId = toDevice.senderId ?: return Unit.also {
+ Timber.tag(loggerTag.value)
+ .v("handleSecretRequest() : Missing senderId")
+ }
+
+ if (userId != credentials.userId) {
+ // secrets are only shared between our own devices
+ Timber.tag(loggerTag.value)
+ .e("Ignoring secret share request from other users $userId")
+ return
+ }
+
+ val deviceId = request.requestingDeviceId
+ ?: return Unit.also {
+ Timber.tag(loggerTag.value)
+ .w("handleSecretRequest() : malformed request norequestingDeviceId ")
+ }
+
+ val device = cryptoStore.getUserDevice(credentials.userId, deviceId)
+ ?: return Unit.also {
+ Timber.tag(loggerTag.value)
+ .e("Received secret share request from unknown device $deviceId")
+ }
+
+ val isRequestingDeviceTrusted = device.isVerified
+ val isRecentInteractiveVerification = hasBeenVerifiedLessThanFiveMinutesFromNow(device.deviceId)
+ if (isRequestingDeviceTrusted && isRecentInteractiveVerification) {
+ // we can share the secret
+
+ val secretValue = when (secretName) {
+ MASTER_KEY_SSSS_NAME -> cryptoStore.getCrossSigningPrivateKeys()?.master
+ SELF_SIGNING_KEY_SSSS_NAME -> cryptoStore.getCrossSigningPrivateKeys()?.selfSigned
+ USER_SIGNING_KEY_SSSS_NAME -> cryptoStore.getCrossSigningPrivateKeys()?.user
+ KEYBACKUP_SECRET_SSSS_NAME -> cryptoStore.getKeyBackupRecoveryKeyInfo()?.recoveryKey
+ ?.let {
+ extractCurveKeyFromRecoveryKey(it)?.toBase64NoPadding()
+ }
+ else -> null
+ }
+ if (secretValue == null) {
+ Timber.tag(loggerTag.value)
+ .i("The secret is unknown $secretName, passing to app layer")
+ val toList = synchronized(gossipingRequestListeners) { gossipingRequestListeners.toList() }
+ toList.onEach { listener ->
+ listener.onSecretShareRequest(request)
+ }
+ return
+ }
+
+ val payloadJson = mapOf(
+ "type" to EventType.SEND_SECRET,
+ "content" to mapOf(
+ "request_id" to request.requestId,
+ "secret" to secretValue
+ )
+ )
+
+ // Is it possible that we don't have an olm session?
+ val devicesByUser = mapOf(device.userId to listOf(device))
+ val usersDeviceMap = try {
+ ensureOlmSessionsForDevicesAction.handle(devicesByUser)
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value)
+ .w("Can't share secret ${request.secretName}: Failed to establish olm session")
+ return
+ }
+
+ val olmSessionResult = usersDeviceMap.getObject(device.userId, device.deviceId)
+ if (olmSessionResult?.sessionId == null) {
+ Timber.tag(loggerTag.value)
+ .w("secret share: no session with this device $deviceId, probably because there were no one-time keys")
+ return
+ }
+
+ val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(device))
+ val sendToDeviceMap = MXUsersDevicesMap()
+ sendToDeviceMap.setObject(device.userId, device.deviceId, encodedPayload)
+ val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
+ try {
+ // raise the retries for secret
+ sendToDeviceTask.executeRetry(sendToDeviceParams, 6)
+ Timber.tag(loggerTag.value)
+ .i("successfully shared secret $secretName to ${device.shortDebugString()}")
+ // TODO add a trail for that in audit logs
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value)
+ .e(failure, "failed to send shared secret $secretName to ${device.shortDebugString()}")
+ }
+ } else {
+ Timber.tag(loggerTag.value)
+ .d(" Received secret share request from un-authorised device ${device.deviceId}")
+ }
+ }
+
+ private suspend fun hasBeenVerifiedLessThanFiveMinutesFromNow(deviceId: String): Boolean {
+ val verifTimestamp = verifMutex.withLock {
+ recentlyVerifiedDevices[deviceId]
+ } ?: return false
+
+ val age = clock.epochMillis() - verifTimestamp
+
+ return age < SECRET_SHARE_WINDOW_DURATION
+ }
+
+ suspend fun requestSecretTo(deviceId: String, secretName: String) {
+ val cryptoDeviceInfo = cryptoStore.getUserDevice(credentials.userId, deviceId) ?: return Unit.also {
+ Timber.tag(loggerTag.value)
+ .d("Can't request secret for $secretName unknown device $deviceId")
+ }
+ val toDeviceContent = SecretShareRequest(
+ requestingDeviceId = credentials.deviceId,
+ secretName = secretName,
+ requestId = createUniqueTxnId()
+ )
+
+ verifMutex.withLock {
+ outgoingSecretRequests.add(toDeviceContent)
+ }
+
+ val contentMap = MXUsersDevicesMap()
+ contentMap.setObject(cryptoDeviceInfo.userId, cryptoDeviceInfo.deviceId, toDeviceContent)
+
+ val params = SendToDeviceTask.Params(
+ eventType = EventType.REQUEST_SECRET,
+ contentMap = contentMap
+ )
+ try {
+ withContext(coroutineDispatchers.io) {
+ sendToDeviceTask.executeRetry(params, 3)
+ }
+ Timber.tag(loggerTag.value)
+ .d("Secret request sent for $secretName to ${cryptoDeviceInfo.shortDebugString()}")
+ // TODO update the audit trail
+ } catch (failure: Throwable) {
+ Timber.tag(loggerTag.value)
+ .w("Failed to request secret $secretName to ${cryptoDeviceInfo.shortDebugString()}")
+ }
+ }
+
+ suspend fun onSecretSendReceived(toDevice: Event, handleGossip: ((name: String, value: String) -> Boolean)) {
+ Timber.tag(loggerTag.value)
+ .i("onSecretSend() from ${toDevice.senderId} : onSecretSendReceived ${toDevice.content?.get("sender_key")}")
+ if (!toDevice.isEncrypted()) {
+ // secret send messages must be encrypted
+ Timber.tag(loggerTag.value).e("onSecretSend() :Received unencrypted secret send event")
+ return
+ }
+
+ // Was that sent by us?
+ if (toDevice.senderId != credentials.userId) {
+ Timber.tag(loggerTag.value).e("onSecretSend() : Ignore secret from other user ${toDevice.senderId}")
+ return
+ }
+
+ val secretContent = toDevice.getClearContent().toModel() ?: return
+
+ val existingRequest = verifMutex.withLock {
+ outgoingSecretRequests.firstOrNull { it.requestId == secretContent.requestId }
+ }
+
+ // As per spec:
+ // Clients should ignore m.secret.send events received from devices that it did not send an m.secret.request event to.
+ if (existingRequest?.secretName == null) {
+ Timber.tag(loggerTag.value).i("onSecretSend() : Ignore secret that was not requested: ${secretContent.requestId}")
+ return
+ }
+ // we don't need to cancel the request as we only request to one device
+ // just forget about the request now
+ verifMutex.withLock {
+ outgoingSecretRequests.remove(existingRequest)
+ }
+
+ if (!handleGossip(existingRequest.secretName, secretContent.secretValue)) {
+ // TODO Ask to application layer?
+ Timber.tag(loggerTag.value).v("onSecretSend() : secret not handled by SDK")
+ }
+ }
+}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SendGossipRequestWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SendGossipRequestWorker.kt
deleted file mode 100644
index 69b405aedc..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SendGossipRequestWorker.kt
+++ /dev/null
@@ -1,151 +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
-
-import android.content.Context
-import androidx.work.WorkerParameters
-import com.squareup.moshi.JsonClass
-import org.matrix.android.sdk.api.auth.data.Credentials
-import org.matrix.android.sdk.api.failure.shouldBeRetried
-import org.matrix.android.sdk.api.session.crypto.model.GossipingToDeviceObject
-import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyShareRequest
-import org.matrix.android.sdk.api.session.crypto.model.SecretShareRequest
-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.toContent
-import org.matrix.android.sdk.internal.SessionManager
-import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
-import org.matrix.android.sdk.internal.crypto.tasks.createUniqueTxnId
-import org.matrix.android.sdk.internal.session.SessionComponent
-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 SendGossipRequestWorker(context: Context, params: WorkerParameters, sessionManager: SessionManager) :
- SessionSafeCoroutineWorker(context, params, sessionManager, Params::class.java) {
-
- @JsonClass(generateAdapter = true)
- internal data class Params(
- override val sessionId: String,
- val keyShareRequest: OutgoingRoomKeyRequest? = null,
- val secretShareRequest: OutgoingSecretRequest? = null,
- // The txnId for the sendToDevice request. Nullable for compatibility reasons, but MUST always be provided
- // to use the same value if this worker is retried.
- val txnId: String? = null,
- override val lastFailureMessage: String? = null
- ) : SessionWorkerParams
-
- @Inject lateinit var sendToDeviceTask: SendToDeviceTask
- @Inject lateinit var cryptoStore: IMXCryptoStore
- @Inject lateinit var credentials: Credentials
-
- override fun injectWith(injector: SessionComponent) {
- injector.inject(this)
- }
-
- override suspend fun doSafeWork(params: Params): Result {
- // params.txnId should be provided in all cases now. But Params can be deserialized by
- // the WorkManager from data serialized in a previous version of the application, so without the txnId field.
- // So if not present, we create a txnId
- val txnId = params.txnId ?: createUniqueTxnId()
- val contentMap = MXUsersDevicesMap()
- val eventType: String
- val requestId: String
- when {
- params.keyShareRequest != null -> {
- eventType = EventType.ROOM_KEY_REQUEST
- requestId = params.keyShareRequest.requestId
- val toDeviceContent = RoomKeyShareRequest(
- requestingDeviceId = credentials.deviceId,
- requestId = params.keyShareRequest.requestId,
- action = GossipingToDeviceObject.ACTION_SHARE_REQUEST,
- body = params.keyShareRequest.requestBody
- )
- cryptoStore.saveGossipingEvent(Event(
- type = eventType,
- content = toDeviceContent.toContent(),
- senderId = credentials.userId
- ).also {
- it.ageLocalTs = System.currentTimeMillis()
- })
-
- params.keyShareRequest.recipients.forEach { userToDeviceMap ->
- userToDeviceMap.value.forEach { deviceId ->
- contentMap.setObject(userToDeviceMap.key, deviceId, toDeviceContent)
- }
- }
- }
- params.secretShareRequest != null -> {
- eventType = EventType.REQUEST_SECRET
- requestId = params.secretShareRequest.requestId
- val toDeviceContent = SecretShareRequest(
- requestingDeviceId = credentials.deviceId,
- requestId = params.secretShareRequest.requestId,
- action = GossipingToDeviceObject.ACTION_SHARE_REQUEST,
- secretName = params.secretShareRequest.secretName
- )
-
- cryptoStore.saveGossipingEvent(Event(
- type = eventType,
- content = toDeviceContent.toContent(),
- senderId = credentials.userId
- ).also {
- it.ageLocalTs = System.currentTimeMillis()
- })
-
- params.secretShareRequest.recipients.forEach { userToDeviceMap ->
- userToDeviceMap.value.forEach { deviceId ->
- contentMap.setObject(userToDeviceMap.key, deviceId, toDeviceContent)
- }
- }
- }
- else -> {
- return buildErrorResult(params, "Unknown empty gossiping request").also {
- Timber.e("Unknown empty gossiping request: $params")
- }
- }
- }
- try {
- cryptoStore.updateOutgoingGossipingRequestState(requestId, OutgoingGossipingRequestState.SENDING)
- sendToDeviceTask.execute(
- SendToDeviceTask.Params(
- eventType = eventType,
- contentMap = contentMap,
- transactionId = txnId
- )
- )
- cryptoStore.updateOutgoingGossipingRequestState(requestId, OutgoingGossipingRequestState.SENT)
- return Result.success()
- } catch (throwable: Throwable) {
- return if (throwable.shouldBeRetried()) {
- Result.retry()
- } else {
- cryptoStore.updateOutgoingGossipingRequestState(requestId, OutgoingGossipingRequestState.FAILED_TO_SEND)
- buildErrorResult(params, throwable.localizedMessage ?: "error")
- }
- }
- }
-
- 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/SendGossipWorker.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SendGossipWorker.kt
deleted file mode 100644
index fd472fe73b..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/SendGossipWorker.kt
+++ /dev/null
@@ -1,168 +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
-
-import android.content.Context
-import androidx.work.WorkerParameters
-import com.squareup.moshi.JsonClass
-import org.matrix.android.sdk.api.auth.data.Credentials
-import org.matrix.android.sdk.api.failure.shouldBeRetried
-import org.matrix.android.sdk.api.session.crypto.model.GossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-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.content.SecretSendEventContent
-import org.matrix.android.sdk.api.session.events.model.toContent
-import org.matrix.android.sdk.internal.SessionManager
-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.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
-import org.matrix.android.sdk.internal.crypto.tasks.createUniqueTxnId
-import org.matrix.android.sdk.internal.session.SessionComponent
-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 SendGossipWorker(
- context: Context,
- params: WorkerParameters,
- sessionManager: SessionManager
-) : SessionSafeCoroutineWorker(context, params, sessionManager, Params::class.java) {
-
- @JsonClass(generateAdapter = true)
- internal data class Params(
- override val sessionId: String,
- val secretValue: String,
- val requestUserId: String?,
- val requestDeviceId: String?,
- val requestId: String?,
- // The txnId for the sendToDevice request. Nullable for compatibility reasons, but MUST always be provided
- // to use the same value if this worker is retried.
- val txnId: String? = null,
- override val lastFailureMessage: String? = null
- ) : SessionWorkerParams
-
- @Inject lateinit var sendToDeviceTask: SendToDeviceTask
- @Inject lateinit var cryptoStore: IMXCryptoStore
- @Inject lateinit var credentials: Credentials
- @Inject lateinit var messageEncrypter: MessageEncrypter
- @Inject lateinit var ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction
-
- override fun injectWith(injector: SessionComponent) {
- injector.inject(this)
- }
-
- override suspend fun doSafeWork(params: Params): Result {
- // params.txnId should be provided in all cases now. But Params can be deserialized by
- // the WorkManager from data serialized in a previous version of the application, so without the txnId field.
- // So if not present, we create a txnId
- val txnId = params.txnId ?: createUniqueTxnId()
- val eventType: String = EventType.SEND_SECRET
-
- val toDeviceContent = SecretSendEventContent(
- requestId = params.requestId ?: "",
- secretValue = params.secretValue
- )
-
- val requestingUserId = params.requestUserId ?: ""
- val requestingDeviceId = params.requestDeviceId ?: ""
- val deviceInfo = cryptoStore.getUserDevice(requestingUserId, requestingDeviceId)
- ?: return buildErrorResult(params, "Unknown deviceInfo, cannot send message").also {
- cryptoStore.updateGossipingRequestState(
- requestUserId = params.requestUserId,
- requestDeviceId = params.requestDeviceId,
- requestId = params.requestId,
- state = GossipingRequestState.FAILED_TO_ACCEPTED
- )
- Timber.e("Unknown deviceInfo, cannot send message, sessionId: ${params.requestDeviceId}")
- }
-
- val sendToDeviceMap = MXUsersDevicesMap()
-
- val devicesByUser = mapOf(requestingUserId to listOf(deviceInfo))
- val usersDeviceMap = ensureOlmSessionsForDevicesAction.handle(devicesByUser)
- val olmSessionResult = usersDeviceMap.getObject(requestingUserId, requestingDeviceId)
- if (olmSessionResult?.sessionId == null) {
- // no session with this device, probably because there
- // were no one-time keys.
- return buildErrorResult(params, "no session with this device").also {
- cryptoStore.updateGossipingRequestState(
- requestUserId = params.requestUserId,
- requestDeviceId = params.requestDeviceId,
- requestId = params.requestId,
- state = GossipingRequestState.FAILED_TO_ACCEPTED
- )
- Timber.e("no session with this device $requestingDeviceId, probably because there were no one-time keys.")
- }
- }
-
- val payloadJson = mapOf(
- "type" to EventType.SEND_SECRET,
- "content" to toDeviceContent.toContent()
- )
-
- try {
- val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
- sendToDeviceMap.setObject(requestingUserId, requestingDeviceId, encodedPayload)
- } catch (failure: Throwable) {
- Timber.e("## Fail to encrypt gossip + ${failure.localizedMessage}")
- }
-
- cryptoStore.saveGossipingEvent(Event(
- type = eventType,
- content = toDeviceContent.toContent(),
- senderId = credentials.userId
- ).also {
- it.ageLocalTs = System.currentTimeMillis()
- })
-
- try {
- sendToDeviceTask.execute(
- SendToDeviceTask.Params(
- eventType = EventType.ENCRYPTED,
- contentMap = sendToDeviceMap,
- transactionId = txnId
- )
- )
- cryptoStore.updateGossipingRequestState(
- requestUserId = params.requestUserId,
- requestDeviceId = params.requestDeviceId,
- requestId = params.requestId,
- state = GossipingRequestState.ACCEPTED
- )
- return Result.success()
- } catch (throwable: Throwable) {
- return if (throwable.shouldBeRetried()) {
- Result.retry()
- } else {
- cryptoStore.updateGossipingRequestState(
- requestUserId = params.requestUserId,
- requestDeviceId = params.requestDeviceId,
- requestId = params.requestId,
- state = GossipingRequestState.FAILED_TO_ACCEPTED
- )
- buildErrorResult(params, throwable.localizedMessage ?: "error")
- }
- }
- }
-
- 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/actions/EnsureOlmSessionsForDevicesAction.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/EnsureOlmSessionsForDevicesAction.kt
index fffc2b4d4b..df29a494db 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/EnsureOlmSessionsForDevicesAction.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/EnsureOlmSessionsForDevicesAction.kt
@@ -137,10 +137,14 @@ internal class EnsureOlmSessionsForDevicesAction @Inject constructor(
olmDevice.verifySignature(fingerprint, oneTimeKey.signalableJSONDictionary(), signature)
isVerified = true
} catch (e: Exception) {
- Timber.tag(loggerTag.value).d(e, "verifyKeyAndStartSession() : Verify error for otk: ${oneTimeKey.signalableJSONDictionary()}," +
- " signature:$signature fingerprint:$fingerprint")
- Timber.tag(loggerTag.value).e("verifyKeyAndStartSession() : Verify error for ${deviceInfo.userId}|${deviceInfo.deviceId} " +
- " - signable json ${oneTimeKey.signalableJSONDictionary()}")
+ Timber.tag(loggerTag.value).d(
+ e, "verifyKeyAndStartSession() : Verify error for otk: ${oneTimeKey.signalableJSONDictionary()}," +
+ " signature:$signature fingerprint:$fingerprint"
+ )
+ Timber.tag(loggerTag.value).e(
+ "verifyKeyAndStartSession() : Verify error for ${deviceInfo.userId}|${deviceInfo.deviceId} " +
+ " - signable json ${oneTimeKey.signalableJSONDictionary()}"
+ )
errorMessage = e.message
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/MegolmSessionDataImporter.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/MegolmSessionDataImporter.kt
index f9bcdf2c68..22c4e59b18 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/MegolmSessionDataImporter.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/actions/MegolmSessionDataImporter.kt
@@ -17,22 +17,28 @@
package org.matrix.android.sdk.internal.crypto.actions
import androidx.annotation.WorkerThread
+import org.matrix.android.sdk.api.extensions.tryOrNull
import org.matrix.android.sdk.api.listeners.ProgressListener
+import org.matrix.android.sdk.api.logger.LoggerTag
import org.matrix.android.sdk.api.session.crypto.model.ImportRoomKeysResult
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
import org.matrix.android.sdk.internal.crypto.MXOlmDevice
import org.matrix.android.sdk.internal.crypto.MegolmSessionData
-import org.matrix.android.sdk.internal.crypto.OutgoingGossipingRequestManager
+import org.matrix.android.sdk.internal.crypto.OutgoingKeyRequestManager
import org.matrix.android.sdk.internal.crypto.RoomDecryptorProvider
import org.matrix.android.sdk.internal.crypto.algorithms.megolm.MXMegolmDecryption
import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
+import org.matrix.android.sdk.internal.util.time.Clock
import timber.log.Timber
import javax.inject.Inject
+private val loggerTag = LoggerTag("MegolmSessionDataImporter", LoggerTag.CRYPTO)
+
internal class MegolmSessionDataImporter @Inject constructor(private val olmDevice: MXOlmDevice,
private val roomDecryptorProvider: RoomDecryptorProvider,
- private val outgoingGossipingRequestManager: OutgoingGossipingRequestManager,
- private val cryptoStore: IMXCryptoStore) {
+ private val outgoingKeyRequestManager: OutgoingKeyRequestManager,
+ private val cryptoStore: IMXCryptoStore,
+ private val clock: Clock,
+) {
/**
* Import a list of megolm session keys.
@@ -47,7 +53,7 @@ internal class MegolmSessionDataImporter @Inject constructor(private val olmDevi
fun handle(megolmSessionsData: List,
fromBackup: Boolean,
progressListener: ProgressListener?): ImportRoomKeysResult {
- val t0 = System.currentTimeMillis()
+ val t0 = clock.epochMillis()
val totalNumbersOfKeys = megolmSessionsData.size
var lastProgress = 0
@@ -62,19 +68,23 @@ internal class MegolmSessionDataImporter @Inject constructor(private val olmDevi
if (null != decrypting) {
try {
val sessionId = megolmSessionData.sessionId
- Timber.v("## importRoomKeys retrieve senderKey " + megolmSessionData.senderKey + " sessionId " + sessionId)
+ Timber.tag(loggerTag.value).v("## importRoomKeys retrieve senderKey ${megolmSessionData.senderKey} sessionId $sessionId")
totalNumbersOfImportedKeys++
// cancel any outstanding room key requests for this session
- val roomKeyRequestBody = RoomKeyRequestBody(
- algorithm = megolmSessionData.algorithm,
- roomId = megolmSessionData.roomId,
- senderKey = megolmSessionData.senderKey,
- sessionId = megolmSessionData.sessionId
- )
- outgoingGossipingRequestManager.cancelRoomKeyRequest(roomKeyRequestBody)
+ Timber.tag(loggerTag.value).d("Imported megolm session $sessionId from backup=$fromBackup in ${megolmSessionData.roomId}")
+ outgoingKeyRequestManager.postCancelRequestForSessionIfNeeded(
+ megolmSessionData.sessionId ?: "",
+ megolmSessionData.roomId ?: "",
+ megolmSessionData.senderKey ?: "",
+ tryOrNull {
+ olmInboundGroupSessionWrappers
+ .firstOrNull { it.olmInboundGroupSession?.sessionIdentifier() == megolmSessionData.sessionId }
+ ?.firstKnownIndex?.toInt()
+ } ?: 0
+ )
// Have another go at decrypting events sent with this session
when (decrypting) {
@@ -83,7 +93,7 @@ internal class MegolmSessionDataImporter @Inject constructor(private val olmDevi
}
}
} catch (e: Exception) {
- Timber.e(e, "## importRoomKeys() : onNewSession failed")
+ Timber.tag(loggerTag.value).e(e, "## importRoomKeys() : onNewSession failed")
}
}
@@ -103,9 +113,9 @@ internal class MegolmSessionDataImporter @Inject constructor(private val olmDevi
cryptoStore.markBackupDoneForInboundGroupSessions(olmInboundGroupSessionWrappers)
}
- val t1 = System.currentTimeMillis()
+ val t1 = clock.epochMillis()
- Timber.v("## importMegolmSessionsData : sessions import " + (t1 - t0) + " ms (" + megolmSessionsData.size + " sessions)")
+ Timber.tag(loggerTag.value).v("## importMegolmSessionsData : sessions import " + (t1 - t0) + " ms (" + megolmSessionsData.size + " sessions)")
return ImportRoomKeysResult(totalNumbersOfKeys, totalNumbersOfImportedKeys)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXDecrypting.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXDecrypting.kt
index 2ea4e1dd29..d555062442 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXDecrypting.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXDecrypting.kt
@@ -17,8 +17,6 @@
package org.matrix.android.sdk.internal.crypto.algorithms
import org.matrix.android.sdk.api.session.crypto.MXCryptoError
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.IncomingSecretShareRequest
import org.matrix.android.sdk.api.session.crypto.model.MXEventDecryptionResult
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.internal.crypto.keysbackup.DefaultKeysBackupService
@@ -44,23 +42,4 @@ internal interface IMXDecrypting {
* @param event the key event.
*/
fun onRoomKeyEvent(event: Event, defaultKeysBackupService: DefaultKeysBackupService) {}
-
- /**
- * Determine if we have the keys necessary to respond to a room key request
- *
- * @param request keyRequest
- * @return true if we have the keys and could (theoretically) share
- */
- fun hasKeysForKeyRequest(request: IncomingRoomKeyRequest): Boolean = false
-
- /**
- * Send the response to a room key request.
- *
- * @param request keyRequest
- */
- fun shareKeysWithDevice(request: IncomingRoomKeyRequest) {}
-
- fun shareSecretWithDevice(request: IncomingSecretShareRequest, secretValue: String) {}
-
- fun requestKeysForEvent(event: Event, withHeld: Boolean)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXWithHeldExtension.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXWithHeldExtension.kt
deleted file mode 100644
index 585bcdbbde..0000000000
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/IMXWithHeldExtension.kt
+++ /dev/null
@@ -1,23 +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.algorithms
-
-import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
-
-internal interface IMXWithHeldExtension {
- fun onRoomKeyWithHeldEvent(withHeldInfo: RoomKeyWithHeldContent)
-}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt
index 4c407c9eb9..d65b05f655 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt
@@ -17,51 +17,32 @@
package org.matrix.android.sdk.internal.crypto.algorithms.megolm
import dagger.Lazy
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.withLock
-import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
import org.matrix.android.sdk.api.logger.LoggerTag
import org.matrix.android.sdk.api.session.crypto.MXCryptoError
import org.matrix.android.sdk.api.session.crypto.NewSessionListener
import org.matrix.android.sdk.api.session.crypto.model.ForwardedRoomKeyContent
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
import org.matrix.android.sdk.api.session.crypto.model.MXEventDecryptionResult
-import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
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.content.EncryptedEventContent
import org.matrix.android.sdk.api.session.events.model.content.RoomKeyContent
-import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
import org.matrix.android.sdk.api.session.events.model.toModel
-import org.matrix.android.sdk.internal.crypto.DeviceListManager
import org.matrix.android.sdk.internal.crypto.MXOlmDevice
-import org.matrix.android.sdk.internal.crypto.OutgoingGossipingRequestManager
-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.OutgoingKeyRequestManager
import org.matrix.android.sdk.internal.crypto.algorithms.IMXDecrypting
-import org.matrix.android.sdk.internal.crypto.algorithms.IMXWithHeldExtension
import org.matrix.android.sdk.internal.crypto.keysbackup.DefaultKeysBackupService
import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
import org.matrix.android.sdk.internal.session.StreamEventsManager
import timber.log.Timber
private val loggerTag = LoggerTag("MXMegolmDecryption", LoggerTag.CRYPTO)
-internal class MXMegolmDecryption(private val userId: String,
- private val olmDevice: MXOlmDevice,
- private val deviceListManager: DeviceListManager,
- private val outgoingGossipingRequestManager: OutgoingGossipingRequestManager,
- private val messageEncrypter: MessageEncrypter,
- private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction,
- private val cryptoStore: IMXCryptoStore,
- private val sendToDeviceTask: SendToDeviceTask,
- private val coroutineDispatchers: MatrixCoroutineDispatchers,
- private val cryptoCoroutineScope: CoroutineScope,
- private val liveEventManager: Lazy
-) : IMXDecrypting, IMXWithHeldExtension {
+internal class MXMegolmDecryption(
+ private val olmDevice: MXOlmDevice,
+ private val outgoingKeyRequestManager: OutgoingKeyRequestManager,
+ private val cryptoStore: IMXCryptoStore,
+ private val liveEventManager: Lazy
+) : IMXDecrypting {
var newSessionListener: NewSessionListener? = null
@@ -73,10 +54,7 @@ internal class MXMegolmDecryption(private val userId: String,
@Throws(MXCryptoError::class)
override suspend fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
- // If cross signing is enabled, we don't send request until the keys are trusted
- // There could be a race effect here when xsigning is enabled, we should ensure that keys was downloaded once
- val requestOnFail = cryptoStore.getMyCrossSigningInfo()?.isTrusted() == true
- return decryptEvent(event, timeline, requestOnFail)
+ return decryptEvent(event, timeline, true)
}
@Throws(MXCryptoError::class)
@@ -96,11 +74,13 @@ internal class MXMegolmDecryption(private val userId: String,
}
return runCatching {
- olmDevice.decryptGroupMessage(encryptedEventContent.ciphertext,
+ olmDevice.decryptGroupMessage(
+ encryptedEventContent.ciphertext,
event.roomId,
timeline,
encryptedEventContent.sessionId,
- encryptedEventContent.senderKey)
+ encryptedEventContent.senderKey
+ )
}
.fold(
{ olmDecryptionResult ->
@@ -124,27 +104,27 @@ internal class MXMegolmDecryption(private val userId: String,
if (throwable is MXCryptoError.OlmError) {
// TODO Check the value of .message
if (throwable.olmException.message == "UNKNOWN_MESSAGE_INDEX") {
- // addEventToPendingList(event, timeline)
- // The session might has been partially withheld (and only pass ratcheted)
- val withHeldInfo = cryptoStore.getWithHeldMegolmSession(event.roomId, encryptedEventContent.sessionId)
- if (withHeldInfo != null) {
- if (requestKeysOnFail) {
- requestKeysForEvent(event, true)
- }
- // Encapsulate as withHeld exception
- throw MXCryptoError.Base(MXCryptoError.ErrorType.KEYS_WITHHELD,
- withHeldInfo.code?.value ?: "",
- withHeldInfo.reason)
- }
+ // So we know that session, but it's ratcheted and we can't decrypt at that index
if (requestKeysOnFail) {
- requestKeysForEvent(event, false)
+ requestKeysForEvent(event)
+ }
+ // Check if partially withheld
+ val withHeldInfo = cryptoStore.getWithHeldMegolmSession(event.roomId, encryptedEventContent.sessionId)
+ if (withHeldInfo != null) {
+ // Encapsulate as withHeld exception
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.KEYS_WITHHELD,
+ withHeldInfo.code?.value ?: "",
+ withHeldInfo.reason
+ )
}
throw MXCryptoError.Base(
MXCryptoError.ErrorType.UNKNOWN_MESSAGE_INDEX,
"UNKNOWN_MESSAGE_INDEX",
- null)
+ null
+ )
}
val reason = String.format(MXCryptoError.OLM_REASON, throwable.olmException.message)
@@ -153,28 +133,26 @@ internal class MXMegolmDecryption(private val userId: String,
throw MXCryptoError.Base(
MXCryptoError.ErrorType.OLM,
reason,
- detailedReason)
+ detailedReason
+ )
}
if (throwable is MXCryptoError.Base) {
- if (
- /** if the session is unknown*/
- throwable.errorType == MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID
- ) {
+ if (throwable.errorType == MXCryptoError.ErrorType.UNKNOWN_INBOUND_SESSION_ID) {
+ // Check if it was withheld by sender to enrich error code
val withHeldInfo = cryptoStore.getWithHeldMegolmSession(event.roomId, encryptedEventContent.sessionId)
if (withHeldInfo != null) {
if (requestKeysOnFail) {
- requestKeysForEvent(event, true)
+ requestKeysForEvent(event)
}
// Encapsulate as withHeld exception
- throw MXCryptoError.Base(MXCryptoError.ErrorType.KEYS_WITHHELD,
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.KEYS_WITHHELD,
withHeldInfo.code?.value ?: "",
withHeldInfo.reason)
- } else {
- // This is un-used in Matrix Android SDK2, not sure if needed
- // addEventToPendingList(event, timeline)
- if (requestKeysOnFail) {
- requestKeysForEvent(event, false)
- }
+ }
+
+ if (requestKeysOnFail) {
+ requestKeysForEvent(event)
}
}
}
@@ -190,55 +168,10 @@ internal class MXMegolmDecryption(private val userId: String,
*
* @param event the event
*/
- override fun requestKeysForEvent(event: Event, withHeld: Boolean) {
- val sender = event.senderId ?: return
- val encryptedEventContent = event.content.toModel()
- val senderDevice = encryptedEventContent?.deviceId ?: return
-
- val recipients = if (event.senderId == userId || withHeld) {
- mapOf(
- userId to listOf("*")
- )
- } else {
- // for the case where you share the key with a device that has a broken olm session
- // The other user might Re-shares a megolm session key with devices if the key has already been
- // sent to them.
- mapOf(
- userId to listOf("*"),
- sender to listOf(senderDevice)
- )
- }
-
- val requestBody = RoomKeyRequestBody(
- roomId = event.roomId,
- algorithm = encryptedEventContent.algorithm,
- senderKey = encryptedEventContent.senderKey,
- sessionId = encryptedEventContent.sessionId
- )
-
- outgoingGossipingRequestManager.sendRoomKeyRequest(requestBody, recipients)
+ private fun requestKeysForEvent(event: Event) {
+ outgoingKeyRequestManager.requestKeyForEvent(event, false)
}
-// /**
-// * Add an event to the list of those we couldn't decrypt the first time we
-// * saw them.
-// *
-// * @param event the event to try to decrypt later
-// * @param timelineId the timeline identifier
-// */
-// private fun addEventToPendingList(event: Event, timelineId: String) {
-// val encryptedEventContent = event.content.toModel() ?: return
-// val pendingEventsKey = "${encryptedEventContent.senderKey}|${encryptedEventContent.sessionId}"
-//
-// val timeline = pendingEvents.getOrPut(pendingEventsKey) { HashMap() }
-// val events = timeline.getOrPut(timelineId) { ArrayList() }
-//
-// if (event !in events) {
-// Timber.v("## CRYPTO | addEventToPendingList() : add Event ${event.eventId} in room id ${event.roomId}")
-// events.add(event)
-// }
-// }
-
/**
* Handle a key event.
*
@@ -258,6 +191,11 @@ internal class MXMegolmDecryption(private val userId: String,
return
}
if (event.getClearType() == EventType.FORWARDED_ROOM_KEY) {
+ if (!cryptoStore.isKeyGossipingEnabled()) {
+ Timber.tag(loggerTag.value)
+ .i("onRoomKeyEvent(), ignore forward adding as per crypto config : ${roomKeyContent.roomId}|${roomKeyContent.sessionId}")
+ return
+ }
Timber.tag(loggerTag.value).i("onRoomKeyEvent(), forward adding key : ${roomKeyContent.roomId}|${roomKeyContent.sessionId}")
val forwardedRoomKeyContent = event.getClearContent().toModel()
?: return
@@ -298,26 +236,57 @@ internal class MXMegolmDecryption(private val userId: String,
}
Timber.tag(loggerTag.value).i("onRoomKeyEvent addInboundGroupSession ${roomKeyContent.sessionId}")
- val added = olmDevice.addInboundGroupSession(roomKeyContent.sessionId,
+ val addSessionResult = olmDevice.addInboundGroupSession(
+ roomKeyContent.sessionId,
roomKeyContent.sessionKey,
roomKeyContent.roomId,
senderKey,
forwardingCurve25519KeyChain,
keysClaimed,
- exportFormat)
+ exportFormat
+ )
- if (added) {
+ when (addSessionResult) {
+ is MXOlmDevice.AddSessionResult.Imported -> addSessionResult.ratchetIndex
+ is MXOlmDevice.AddSessionResult.NotImportedHigherIndex -> addSessionResult.newIndex
+ else -> null
+ }?.let { index ->
+ if (event.getClearType() == EventType.FORWARDED_ROOM_KEY) {
+ val fromDevice = (event.content?.get("sender_key") as? String)?.let { senderDeviceIdentityKey ->
+ cryptoStore.getUserDeviceList(event.senderId ?: "")
+ ?.firstOrNull {
+ it.identityKey() == senderDeviceIdentityKey
+ }
+ }?.deviceId
+
+ outgoingKeyRequestManager.onRoomKeyForwarded(
+ sessionId = roomKeyContent.sessionId,
+ algorithm = roomKeyContent.algorithm ?: "",
+ roomId = roomKeyContent.roomId,
+ senderKey = senderKey,
+ fromIndex = index,
+ fromDevice = fromDevice,
+ event = event)
+
+ cryptoStore.saveIncomingForwardKeyAuditTrail(
+ roomId = roomKeyContent.roomId,
+ sessionId = roomKeyContent.sessionId,
+ senderKey = senderKey,
+ algorithm = roomKeyContent.algorithm ?: "",
+ userId = event.senderId ?: "",
+ deviceId = fromDevice ?: "",
+ chainIndex = index.toLong())
+
+ // The index is used to decide if we cancel sent request or if we wait for a better key
+ outgoingKeyRequestManager.postCancelRequestForSessionIfNeeded(roomKeyContent.sessionId, roomKeyContent.roomId, senderKey, index)
+ }
+ }
+
+ if (addSessionResult is MXOlmDevice.AddSessionResult.Imported) {
+ Timber.tag(loggerTag.value)
+ .d("onRoomKeyEvent(${event.getClearType()}) : Added megolm session ${roomKeyContent.sessionId} in ${roomKeyContent.roomId}")
defaultKeysBackupService.maybeBackupKeys()
- val content = RoomKeyRequestBody(
- algorithm = roomKeyContent.algorithm,
- roomId = roomKeyContent.roomId,
- sessionId = roomKeyContent.sessionId,
- senderKey = senderKey
- )
-
- outgoingGossipingRequestManager.cancelRoomKeyRequest(content)
-
onNewSession(roomKeyContent.roomId, senderKey, roomKeyContent.sessionId)
}
}
@@ -333,77 +302,4 @@ internal class MXMegolmDecryption(private val userId: String,
Timber.tag(loggerTag.value).v("ON NEW SESSION $sessionId - $senderKey")
newSessionListener?.onNewSession(roomId, senderKey, sessionId)
}
-
- override fun hasKeysForKeyRequest(request: IncomingRoomKeyRequest): Boolean {
- val roomId = request.requestBody?.roomId ?: return false
- val senderKey = request.requestBody.senderKey ?: return false
- val sessionId = request.requestBody.sessionId ?: return false
- return olmDevice.hasInboundSessionKeys(roomId, senderKey, sessionId)
- }
-
- override fun shareKeysWithDevice(request: IncomingRoomKeyRequest) {
- // sanity checks
- if (request.requestBody == null) {
- return
- }
- val userId = request.userId ?: return
-
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- val body = request.requestBody
- val sessionHolder = try {
- olmDevice.getInboundGroupSession(body.sessionId, body.senderKey, body.roomId)
- } catch (failure: Throwable) {
- Timber.tag(loggerTag.value).e(failure, "shareKeysWithDevice: failed to get session for request $body")
- return@launch
- }
-
- val export = sessionHolder.mutex.withLock {
- sessionHolder.wrapper.exportKeys()
- } ?: return@launch Unit.also {
- Timber.tag(loggerTag.value).e("shareKeysWithDevice: failed to export group session ${body.sessionId}")
- }
-
- runCatching { deviceListManager.downloadKeys(listOf(userId), false) }
- .mapCatching {
- val deviceId = request.deviceId
- val deviceInfo = cryptoStore.getUserDevice(userId, deviceId ?: "")
- if (deviceInfo == null) {
- throw RuntimeException()
- } else {
- val devicesByUser = mapOf(userId to listOf(deviceInfo))
- val usersDeviceMap = ensureOlmSessionsForDevicesAction.handle(devicesByUser)
- val olmSessionResult = usersDeviceMap.getObject(userId, deviceId)
- if (olmSessionResult?.sessionId == null) {
- // no session with this device, probably because there
- // were no one-time keys.
- Timber.tag(loggerTag.value).e("no session with this device $deviceId, probably because there were no one-time keys.")
- return@mapCatching
- }
- Timber.tag(loggerTag.value).i("shareKeysWithDevice() : sharing session ${body.sessionId} with device $userId:$deviceId")
-
- val payloadJson = mapOf(
- "type" to EventType.FORWARDED_ROOM_KEY,
- "content" to export
- )
-
- val encodedPayload = messageEncrypter.encryptMessage(payloadJson, listOf(deviceInfo))
- val sendToDeviceMap = MXUsersDevicesMap()
- sendToDeviceMap.setObject(userId, deviceId, encodedPayload)
- Timber.tag(loggerTag.value).i("shareKeysWithDevice() : sending ${body.sessionId} to $userId:$deviceId")
- val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, sendToDeviceMap)
- try {
- sendToDeviceTask.execute(sendToDeviceParams)
- } catch (failure: Throwable) {
- Timber.tag(loggerTag.value).e(failure, "shareKeysWithDevice() : Failed to send ${body.sessionId} to $userId:$deviceId")
- }
- }
- }
- }
- }
-
- override fun onRoomKeyWithHeldEvent(withHeldInfo: RoomKeyWithHeldContent) {
- cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
- cryptoStore.addWithHeldMegolmSession(withHeldInfo)
- }
- }
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryptionFactory.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryptionFactory.kt
index 3eba04b9f1..096773a959 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryptionFactory.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmDecryptionFactory.kt
@@ -17,45 +17,24 @@
package org.matrix.android.sdk.internal.crypto.algorithms.megolm
import dagger.Lazy
-import kotlinx.coroutines.CoroutineScope
-import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
-import org.matrix.android.sdk.internal.crypto.DeviceListManager
import org.matrix.android.sdk.internal.crypto.MXOlmDevice
-import org.matrix.android.sdk.internal.crypto.OutgoingGossipingRequestManager
-import org.matrix.android.sdk.internal.crypto.actions.EnsureOlmSessionsForDevicesAction
-import org.matrix.android.sdk.internal.crypto.actions.MessageEncrypter
+import org.matrix.android.sdk.internal.crypto.OutgoingKeyRequestManager
import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
-import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
-import org.matrix.android.sdk.internal.di.UserId
import org.matrix.android.sdk.internal.session.StreamEventsManager
import javax.inject.Inject
internal class MXMegolmDecryptionFactory @Inject constructor(
- @UserId private val userId: String,
private val olmDevice: MXOlmDevice,
- private val deviceListManager: DeviceListManager,
- private val outgoingGossipingRequestManager: OutgoingGossipingRequestManager,
- private val messageEncrypter: MessageEncrypter,
- private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction,
+ private val outgoingKeyRequestManager: OutgoingKeyRequestManager,
private val cryptoStore: IMXCryptoStore,
- private val sendToDeviceTask: SendToDeviceTask,
- private val coroutineDispatchers: MatrixCoroutineDispatchers,
- private val cryptoCoroutineScope: CoroutineScope,
private val eventsManager: Lazy
) {
fun create(): MXMegolmDecryption {
return MXMegolmDecryption(
- userId,
olmDevice,
- deviceListManager,
- outgoingGossipingRequestManager,
- messageEncrypter,
- ensureOlmSessionsForDevicesAction,
+ outgoingKeyRequestManager,
cryptoStore,
- sendToDeviceTask,
- coroutineDispatchers,
- cryptoCoroutineScope,
eventsManager)
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt
index f052194230..061c349645 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt
@@ -28,7 +28,6 @@ import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
import org.matrix.android.sdk.api.session.crypto.model.forEach
import org.matrix.android.sdk.api.session.events.model.Content
-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.content.RoomKeyWithHeldContent
import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
@@ -46,6 +45,7 @@ import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
import org.matrix.android.sdk.internal.util.JsonCanonicalizer
import org.matrix.android.sdk.internal.util.convertToUTF8
+import org.matrix.android.sdk.internal.util.time.Clock
import timber.log.Timber
private val loggerTag = LoggerTag("MXMegolmEncryption", LoggerTag.CRYPTO)
@@ -64,7 +64,8 @@ internal class MXMegolmEncryption(
private val messageEncrypter: MessageEncrypter,
private val warnOnUnknownDevicesRepository: WarnOnUnknownDeviceRepository,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
- private val cryptoCoroutineScope: CoroutineScope
+ private val cryptoCoroutineScope: CoroutineScope,
+ private val clock: Clock,
) : IMXEncrypting, IMXGroupEncryption {
// OutboundSessionInfo. Null if we haven't yet started setting one up. Note
@@ -86,11 +87,11 @@ internal class MXMegolmEncryption(
override suspend fun encryptEventContent(eventContent: Content,
eventType: String,
userIds: List): Content {
- val ts = System.currentTimeMillis()
+ val ts = clock.epochMillis()
Timber.tag(loggerTag.value).v("encryptEventContent : getDevicesInRoom")
val devices = getDevicesInRoom(userIds)
Timber.tag(loggerTag.value).d("encrypt event in room=$roomId - devices count in room ${devices.allowedDevices.toDebugCount()}")
- Timber.tag(loggerTag.value).v("encryptEventContent ${System.currentTimeMillis() - ts}: getDevicesInRoom ${devices.allowedDevices.toDebugString()}")
+ Timber.tag(loggerTag.value).v("encryptEventContent ${clock.epochMillis() - ts}: getDevicesInRoom ${devices.allowedDevices.toDebugString()}")
val outboundSession = ensureOutboundSession(devices.allowedDevices)
return encryptContent(outboundSession, eventType, eventContent)
@@ -99,7 +100,7 @@ internal class MXMegolmEncryption(
// annoyingly we have to serialize again the saved outbound session to store message index :/
// if not we would see duplicate message index errors
olmDevice.storeOutboundGroupSessionForRoom(roomId, outboundSession.sessionId)
- Timber.tag(loggerTag.value).d("encrypt event in room=$roomId Finished in ${System.currentTimeMillis() - ts} millis")
+ Timber.tag(loggerTag.value).d("encrypt event in room=$roomId Finished in ${clock.epochMillis() - ts} millis")
}
}
@@ -125,14 +126,14 @@ internal class MXMegolmEncryption(
}
override suspend fun preshareKey(userIds: List) {
- val ts = System.currentTimeMillis()
+ val ts = clock.epochMillis()
Timber.tag(loggerTag.value).d("preshareKey started in $roomId ...")
val devices = getDevicesInRoom(userIds)
val outboundSession = ensureOutboundSession(devices.allowedDevices)
notifyWithheldForSession(devices.withHeldDevices, outboundSession)
- Timber.tag(loggerTag.value).d("preshareKey in $roomId done in ${System.currentTimeMillis() - ts} millis")
+ Timber.tag(loggerTag.value).d("preshareKey in $roomId done in ${clock.epochMillis() - ts} millis")
}
/**
@@ -148,12 +149,14 @@ internal class MXMegolmEncryption(
"ed25519" to olmDevice.deviceEd25519Key!!
)
- olmDevice.addInboundGroupSession(sessionId!!, olmDevice.getSessionKey(sessionId)!!, roomId, olmDevice.deviceCurve25519Key!!,
- emptyList(), keysClaimedMap, false)
+ olmDevice.addInboundGroupSession(
+ sessionId!!, olmDevice.getSessionKey(sessionId)!!, roomId, olmDevice.deviceCurve25519Key!!,
+ emptyList(), keysClaimedMap, false
+ )
defaultKeysBackupService.maybeBackupKeys()
- return MXOutboundSessionInfo(sessionId, SharedWithHelper(roomId, sessionId, cryptoStore))
+ return MXOutboundSessionInfo(sessionId, SharedWithHelper(roomId, sessionId, cryptoStore), clock)
}
/**
@@ -243,12 +246,12 @@ internal class MXMegolmEncryption(
payload["type"] = EventType.ROOM_KEY
payload["content"] = submap
- var t0 = System.currentTimeMillis()
+ var t0 = clock.epochMillis()
Timber.tag(loggerTag.value).v("shareUserDevicesKey() : starts")
val results = ensureOlmSessionsForDevicesAction.handle(devicesByUser)
Timber.tag(loggerTag.value).v(
- """shareUserDevicesKey(): ensureOlmSessionsForDevices succeeds after ${System.currentTimeMillis() - t0} ms"""
+ """shareUserDevicesKey(): ensureOlmSessionsForDevices succeeds after ${clock.epochMillis() - t0} ms"""
.trimMargin()
)
val contentMap = MXUsersDevicesMap()
@@ -281,27 +284,16 @@ internal class MXMegolmEncryption(
// attempted to share with) rather than the contentMap (those we did
// share with), because we don't want to try to claim a one-time-key
// for dead devices on every message.
- val gossipingEventBuffer = arrayListOf()
- for ((userId, devicesToShareWith) in devicesByUser) {
+ for ((_, devicesToShareWith) in devicesByUser) {
for (deviceInfo in devicesToShareWith) {
session.sharedWithHelper.markedSessionAsShared(deviceInfo, chainIndex)
- gossipingEventBuffer.add(
- Event(
- type = EventType.ROOM_KEY,
- senderId = myUserId,
- content = submap.apply {
- this["session_key"] = ""
- // we add a fake key for trail
- this["_dest"] = "$userId|${deviceInfo.deviceId}"
- }
- ))
+ // XXX is it needed to add it to the audit trail?
+ // For now decided that no, we are more interested by forward trail
}
}
- cryptoStore.saveGossipingEvents(gossipingEventBuffer)
-
if (haveTargets) {
- t0 = System.currentTimeMillis()
+ t0 = clock.epochMillis()
Timber.tag(loggerTag.value).i("shareUserDevicesKey() ${session.sessionId} : has target")
Timber.tag(loggerTag.value).d("sending to device room key for ${session.sessionId} to ${contentMap.toDebugString()}")
val sendToDeviceParams = SendToDeviceTask.Params(EventType.ENCRYPTED, contentMap)
@@ -309,7 +301,7 @@ internal class MXMegolmEncryption(
withContext(coroutineDispatchers.io) {
sendToDeviceTask.execute(sendToDeviceParams)
}
- Timber.tag(loggerTag.value).i("shareUserDevicesKey() : sendToDevice succeeds after ${System.currentTimeMillis() - t0} ms")
+ Timber.tag(loggerTag.value).i("shareUserDevicesKey() : sendToDevice succeeds after ${clock.epochMillis() - t0} ms")
} catch (failure: Throwable) {
// What to do here...
Timber.tag(loggerTag.value).e("shareUserDevicesKey() : Failed to share <${session.sessionId}>")
@@ -333,14 +325,17 @@ internal class MXMegolmEncryption(
sessionId: String,
senderKey: String?,
code: WithHeldCode) {
- Timber.tag(loggerTag.value).d("notifyKeyWithHeld() :sending withheld for session:$sessionId and code $code to" +
- " ${targets.joinToString { "${it.userId}|${it.deviceId}" }}")
+ Timber.tag(loggerTag.value).d(
+ "notifyKeyWithHeld() :sending withheld for session:$sessionId and code $code to" +
+ " ${targets.joinToString { "${it.userId}|${it.deviceId}" }}"
+ )
val withHeldContent = RoomKeyWithHeldContent(
roomId = roomId,
senderKey = senderKey,
algorithm = MXCRYPTO_ALGORITHM_MEGOLM,
sessionId = sessionId,
- codeString = code.value
+ codeString = code.value,
+ fromDevice = myDeviceId
)
val params = SendToDeviceTask.Params(
EventType.ROOM_KEY_WITHHELD,
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt
index 136fdc05f5..4225d604aa 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt
@@ -28,6 +28,7 @@ import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
import org.matrix.android.sdk.internal.crypto.tasks.SendToDeviceTask
import org.matrix.android.sdk.internal.di.DeviceId
import org.matrix.android.sdk.internal.di.UserId
+import org.matrix.android.sdk.internal.util.time.Clock
import javax.inject.Inject
internal class MXMegolmEncryptionFactory @Inject constructor(
@@ -42,7 +43,9 @@ internal class MXMegolmEncryptionFactory @Inject constructor(
private val messageEncrypter: MessageEncrypter,
private val warnOnUnknownDevicesRepository: WarnOnUnknownDeviceRepository,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
- private val cryptoCoroutineScope: CoroutineScope) {
+ private val cryptoCoroutineScope: CoroutineScope,
+ private val clock: Clock,
+) {
fun create(roomId: String): MXMegolmEncryption {
return MXMegolmEncryption(
@@ -58,7 +61,8 @@ internal class MXMegolmEncryptionFactory @Inject constructor(
messageEncrypter = messageEncrypter,
warnOnUnknownDevicesRepository = warnOnUnknownDevicesRepository,
coroutineDispatchers = coroutineDispatchers,
- cryptoCoroutineScope = cryptoCoroutineScope
+ cryptoCoroutineScope = cryptoCoroutineScope,
+ clock = clock,
)
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXOutboundSessionInfo.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXOutboundSessionInfo.kt
index 091abd4974..28d925d8fd 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXOutboundSessionInfo.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/MXOutboundSessionInfo.kt
@@ -18,21 +18,24 @@ package org.matrix.android.sdk.internal.crypto.algorithms.megolm
import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
+import org.matrix.android.sdk.internal.util.time.Clock
import timber.log.Timber
internal class MXOutboundSessionInfo(
// The id of the session
val sessionId: String,
val sharedWithHelper: SharedWithHelper,
+ private val clock: Clock,
// When the session was created
- private val creationTime: Long = System.currentTimeMillis()) {
+ private val creationTime: Long = clock.epochMillis(),
+) {
// Number of times this session has been used
var useCount: Int = 0
fun needsRotation(rotationPeriodMsgs: Int, rotationPeriodMs: Int): Boolean {
var needsRotation = false
- val sessionLifetime = System.currentTimeMillis() - creationTime
+ val sessionLifetime = clock.epochMillis() - creationTime
if (useCount >= rotationPeriodMsgs || sessionLifetime >= rotationPeriodMs) {
Timber.v("## needsRotation() : Rotating megolm session after $useCount, ${sessionLifetime}ms")
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/SharedWithHelper.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/SharedWithHelper.kt
index 59d78c3e05..61ad345c62 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/SharedWithHelper.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/megolm/SharedWithHelper.kt
@@ -36,6 +36,7 @@ internal class SharedWithHelper(
userId = deviceInfo.userId,
deviceId = deviceInfo.deviceId,
deviceIdentityKey = deviceInfo.identityKey() ?: "",
- chainIndex = chainIndex)
+ chainIndex = chainIndex
+ )
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryption.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryption.kt
index 0db8700852..1e66fe84c9 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryption.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryption.kt
@@ -45,20 +45,26 @@ internal class MXOlmDecryption(
override suspend fun decryptEvent(event: Event, timeline: String): MXEventDecryptionResult {
val olmEventContent = event.content.toModel() ?: run {
Timber.tag(loggerTag.value).e("## decryptEvent() : bad event format")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_EVENT_FORMAT,
- MXCryptoError.BAD_EVENT_FORMAT_TEXT_REASON)
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.BAD_EVENT_FORMAT,
+ MXCryptoError.BAD_EVENT_FORMAT_TEXT_REASON
+ )
}
val cipherText = olmEventContent.ciphertext ?: run {
Timber.tag(loggerTag.value).e("## decryptEvent() : missing cipher text")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_CIPHER_TEXT,
- MXCryptoError.MISSING_CIPHER_TEXT_REASON)
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.MISSING_CIPHER_TEXT,
+ MXCryptoError.MISSING_CIPHER_TEXT_REASON
+ )
}
val senderKey = olmEventContent.senderKey ?: run {
Timber.tag(loggerTag.value).e("## decryptEvent() : missing sender key")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_SENDER_KEY,
- MXCryptoError.MISSING_SENDER_KEY_TEXT_REASON)
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.MISSING_SENDER_KEY,
+ MXCryptoError.MISSING_SENDER_KEY_TEXT_REASON
+ )
}
val messageAny = cipherText[olmDevice.deviceCurve25519Key] ?: run {
@@ -98,52 +104,70 @@ internal class MXOlmDecryption(
}
if (olmPayloadContent.recipient != userId) {
- Timber.tag(loggerTag.value).e("## decryptEvent() : Event ${event.eventId}:" +
- " Intended recipient ${olmPayloadContent.recipient} does not match our id $userId")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_RECIPIENT,
- String.format(MXCryptoError.BAD_RECIPIENT_REASON, olmPayloadContent.recipient))
+ Timber.tag(loggerTag.value).e(
+ "## decryptEvent() : Event ${event.eventId}:" +
+ " Intended recipient ${olmPayloadContent.recipient} does not match our id $userId"
+ )
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.BAD_RECIPIENT,
+ String.format(MXCryptoError.BAD_RECIPIENT_REASON, olmPayloadContent.recipient)
+ )
}
val recipientKeys = olmPayloadContent.recipientKeys ?: run {
- Timber.tag(loggerTag.value).e("## decryptEvent() : Olm event (id=${event.eventId}) contains no 'recipient_keys'" +
- " property; cannot prevent unknown-key attack")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
- String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "recipient_keys"))
+ Timber.tag(loggerTag.value).e(
+ "## decryptEvent() : Olm event (id=${event.eventId}) contains no 'recipient_keys'" +
+ " property; cannot prevent unknown-key attack"
+ )
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.MISSING_PROPERTY,
+ String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "recipient_keys")
+ )
}
val ed25519 = recipientKeys["ed25519"]
if (ed25519 != olmDevice.deviceEd25519Key) {
Timber.tag(loggerTag.value).e("## decryptEvent() : Event ${event.eventId}: Intended recipient ed25519 key $ed25519 did not match ours")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_RECIPIENT_KEY,
- MXCryptoError.BAD_RECIPIENT_KEY_REASON)
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.BAD_RECIPIENT_KEY,
+ MXCryptoError.BAD_RECIPIENT_KEY_REASON
+ )
}
if (olmPayloadContent.sender.isNullOrBlank()) {
Timber.tag(loggerTag.value)
.e("## decryptEvent() : Olm event (id=${event.eventId}) contains no 'sender' property; cannot prevent unknown-key attack")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.MISSING_PROPERTY,
- String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "sender"))
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.MISSING_PROPERTY,
+ String.format(MXCryptoError.ERROR_MISSING_PROPERTY_REASON, "sender")
+ )
}
if (olmPayloadContent.sender != event.senderId) {
Timber.tag(loggerTag.value)
.e("Event ${event.eventId}: sender ${olmPayloadContent.sender} does not match reported sender ${event.senderId}")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.FORWARDED_MESSAGE,
- String.format(MXCryptoError.FORWARDED_MESSAGE_REASON, olmPayloadContent.sender))
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.FORWARDED_MESSAGE,
+ String.format(MXCryptoError.FORWARDED_MESSAGE_REASON, olmPayloadContent.sender)
+ )
}
if (olmPayloadContent.roomId != event.roomId) {
Timber.tag(loggerTag.value)
.e("## decryptEvent() : Event ${event.eventId}: room ${olmPayloadContent.roomId} does not match reported room ${event.roomId}")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.BAD_ROOM,
- String.format(MXCryptoError.BAD_ROOM_REASON, olmPayloadContent.roomId))
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.BAD_ROOM,
+ String.format(MXCryptoError.BAD_ROOM_REASON, olmPayloadContent.roomId)
+ )
}
val keys = olmPayloadContent.keys ?: run {
Timber.tag(loggerTag.value).e("## decryptEvent failed : null keys")
- throw MXCryptoError.Base(MXCryptoError.ErrorType.UNABLE_TO_DECRYPT,
- MXCryptoError.MISSING_CIPHER_TEXT_REASON)
+ throw MXCryptoError.Base(
+ MXCryptoError.ErrorType.UNABLE_TO_DECRYPT,
+ MXCryptoError.MISSING_CIPHER_TEXT_REASON
+ )
}
return MXEventDecryptionResult(
@@ -241,8 +265,4 @@ internal class MXOlmDecryption(
return res["payload"]
}
-
- override fun requestKeysForEvent(event: Event, withHeld: Boolean) {
- // nop
- }
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryptionFactory.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryptionFactory.kt
index 972176e25b..d5c5e85e41 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryptionFactory.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmDecryptionFactory.kt
@@ -26,6 +26,7 @@ internal class MXOlmDecryptionFactory @Inject constructor(private val olmDevice:
fun create(): MXOlmDecryption {
return MXOlmDecryption(
olmDevice,
- userId)
+ userId
+ )
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmEncryptionFactory.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmEncryptionFactory.kt
index 50ce2d2bf3..44e55900e4 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmEncryptionFactory.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/algorithms/olm/MXOlmEncryptionFactory.kt
@@ -38,6 +38,7 @@ internal class MXOlmEncryptionFactory @Inject constructor(private val olmDevice:
cryptoStore,
messageEncrypter,
deviceListManager,
- ensureOlmSessionsForUsersAction)
+ ensureOlmSessionsForUsersAction
+ )
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/attachments/MXEncryptedAttachments.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/attachments/MXEncryptedAttachments.kt
index 91b6af6fc3..65bbb0c412 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/attachments/MXEncryptedAttachments.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/attachments/MXEncryptedAttachments.kt
@@ -23,6 +23,7 @@ import org.matrix.android.sdk.api.session.crypto.model.EncryptedFileKey
import org.matrix.android.sdk.internal.util.base64ToBase64Url
import org.matrix.android.sdk.internal.util.base64ToUnpaddedBase64
import org.matrix.android.sdk.internal.util.base64UrlToBase64
+import org.matrix.android.sdk.internal.util.time.Clock
import timber.log.Timber
import java.io.ByteArrayOutputStream
import java.io.File
@@ -42,8 +43,9 @@ internal object MXEncryptedAttachments {
fun encrypt(clearStream: InputStream,
outputFile: File,
+ clock: Clock,
progress: ((current: Int, total: Int) -> Unit)): EncryptedFileInfo {
- val t0 = System.currentTimeMillis()
+ val t0 = clock.epochMillis()
val secureRandom = SecureRandom()
val initVectorBytes = ByteArray(16) { 0.toByte() }
@@ -100,7 +102,7 @@ internal object MXEncryptedAttachments {
hashes = mapOf("sha256" to base64ToUnpaddedBase64(Base64.encodeToString(messageDigest.digest(), Base64.DEFAULT))),
v = "v2"
)
- .also { Timber.v("Encrypt in ${System.currentTimeMillis() - t0}ms") }
+ .also { Timber.v("Encrypt in ${clock.epochMillis() - t0}ms") }
}
// fun cipherInputStream(attachmentStream: InputStream, mimetype: String?): Pair {
@@ -159,8 +161,8 @@ internal object MXEncryptedAttachments {
* @param attachmentStream the attachment stream. Will be closed after this method call.
* @return the encryption file info
*/
- fun encryptAttachment(attachmentStream: InputStream): EncryptionResult {
- val t0 = System.currentTimeMillis()
+ fun encryptAttachment(attachmentStream: InputStream, clock: Clock): EncryptionResult {
+ val t0 = clock.epochMillis()
val secureRandom = SecureRandom()
// generate a random iv key
@@ -221,7 +223,7 @@ internal object MXEncryptedAttachments {
),
encryptedByteArray = byteArrayOutputStream.toByteArray()
)
- .also { Timber.v("Encrypt in ${System.currentTimeMillis() - t0}ms") }
+ .also { Timber.v("Encrypt in ${clock.epochMillis() - t0}ms") }
}
/**
@@ -234,14 +236,16 @@ internal object MXEncryptedAttachments {
*/
fun decryptAttachment(attachmentStream: InputStream?,
elementToDecrypt: ElementToDecrypt?,
- outputStream: OutputStream): Boolean {
+ outputStream: OutputStream,
+ clock: Clock
+ ): Boolean {
// sanity checks
if (null == attachmentStream || elementToDecrypt == null) {
Timber.e("## decryptAttachment() : null stream")
return false
}
- val t0 = System.currentTimeMillis()
+ val t0 = clock.epochMillis()
try {
val key = Base64.decode(base64UrlToBase64(elementToDecrypt.k), Base64.DEFAULT)
@@ -279,7 +283,8 @@ internal object MXEncryptedAttachments {
return false
}
- return true.also { Timber.v("Decrypt in ${System.currentTimeMillis() - t0}ms") }
+ Timber.v("Decrypt in ${clock.epochMillis() - t0} ms")
+ return true
} catch (oom: OutOfMemoryError) {
Timber.e(oom, "## decryptAttachment() failed: OOM")
} catch (e: Exception) {
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 ba1718688f..b8cdc922cc 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
@@ -38,6 +38,7 @@ import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.util.Optional
import org.matrix.android.sdk.api.util.fromBase64
import org.matrix.android.sdk.internal.crypto.DeviceListManager
+import org.matrix.android.sdk.internal.crypto.OutgoingKeyRequestManager
import org.matrix.android.sdk.internal.crypto.model.rest.UploadSignatureQueryBuilder
import org.matrix.android.sdk.internal.crypto.store.IMXCryptoStore
import org.matrix.android.sdk.internal.crypto.tasks.InitializeCrossSigningTask
@@ -70,6 +71,7 @@ internal class DefaultCrossSigningService @Inject constructor(
private val coroutineDispatchers: MatrixCoroutineDispatchers,
private val cryptoCoroutineScope: CoroutineScope,
private val workManagerProvider: WorkManagerProvider,
+ private val outgoingKeyRequestManager: OutgoingKeyRequestManager,
private val updateTrustWorkerDataRepository: UpdateTrustWorkerDataRepository
) : CrossSigningService,
DeviceListManager.UserDevicesUpdateListener {
@@ -566,8 +568,10 @@ internal class DefaultCrossSigningService @Inject constructor(
}
// Sign the other MasterKey with our UserSigning key
- val newSignature = JsonCanonicalizer.getCanonicalJson(Map::class.java,
- otherMasterKeys.signalableJSONDictionary()).let { userPkSigning?.sign(it) }
+ val newSignature = JsonCanonicalizer.getCanonicalJson(
+ Map::class.java,
+ otherMasterKeys.signalableJSONDictionary()
+ ).let { userPkSigning?.sign(it) }
if (newSignature == null) {
// race??
@@ -684,7 +688,8 @@ internal class DefaultCrossSigningService @Inject constructor(
val otherSSKSignature = otherDevice.signatures?.get(otherUserId)?.get("ed25519:${otherKeys.selfSigningKey()?.unpaddedBase64PublicKey}")
?: return legacyFallbackTrust(
locallyTrusted,
- DeviceTrustResult.MissingDeviceSignature(otherDeviceId, otherKeys.selfSigningKey()
+ DeviceTrustResult.MissingDeviceSignature(
+ otherDeviceId, otherKeys.selfSigningKey()
?.unpaddedBase64PublicKey
?: ""
)
@@ -733,7 +738,8 @@ internal class DefaultCrossSigningService @Inject constructor(
val otherSSKSignature = otherDevice.signatures?.get(otherKeys.userId)?.get("ed25519:${otherKeys.selfSigningKey()?.unpaddedBase64PublicKey}")
?: return legacyFallbackTrust(
locallyTrusted,
- DeviceTrustResult.MissingDeviceSignature(otherDevice.deviceId, otherKeys.selfSigningKey()
+ DeviceTrustResult.MissingDeviceSignature(
+ otherDevice.deviceId, otherKeys.selfSigningKey()
?.unpaddedBase64PublicKey
?: ""
)
@@ -781,7 +787,8 @@ internal class DefaultCrossSigningService @Inject constructor(
// If it's me, recheck trust of all users and devices?
val users = ArrayList()
if (otherUserId == userId && currentTrust != trusted) {
-// reRequestAllPendingRoomKeyRequest()
+ // notify key requester
+ outgoingKeyRequestManager.onSelfCrossSigningTrustChanged(trusted)
cryptoStore.updateUsersTrust {
users.add(it)
checkUserTrust(it).isVerified()
@@ -796,19 +803,4 @@ internal class DefaultCrossSigningService @Inject constructor(
}
}
}
-
-// private fun reRequestAllPendingRoomKeyRequest() {
-// cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
-// Timber.d("## CrossSigning - reRequest pending outgoing room key requests")
-// cryptoStore.getOutgoingRoomKeyRequests().forEach {
-// it.requestBody?.let { requestBody ->
-// if (cryptoStore.getInboundGroupSession(requestBody.sessionId ?: "", requestBody.senderKey ?: "") == null) {
-// outgoingRoomKeyRequestManager.resendRoomKeyRequest(requestBody)
-// } else {
-// outgoingRoomKeyRequestManager.cancelRoomKeyRequest(requestBody)
-// }
-// }
-// }
-// }
-// }
}
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 e63a6dc791..d2dae1c112 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
@@ -63,16 +63,11 @@ import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.RoomKeysBack
import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.UpdateKeysBackupVersionBody
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.CreateKeysBackupVersionTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.DeleteBackupTask
-import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.DeleteRoomSessionDataTask
-import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.DeleteRoomSessionsDataTask
-import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.DeleteSessionsDataTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.GetKeysBackupLastVersionTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.GetKeysBackupVersionTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.GetRoomSessionDataTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.GetRoomSessionsDataTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.GetSessionsDataTask
-import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.StoreRoomSessionDataTask
-import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.StoreRoomSessionsDataTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.StoreSessionsDataTask
import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.UpdateKeysBackupVersionTask
import org.matrix.android.sdk.internal.crypto.model.OlmInboundGroupSessionWrapper2
@@ -112,16 +107,11 @@ internal class DefaultKeysBackupService @Inject constructor(
// Tasks
private val createKeysBackupVersionTask: CreateKeysBackupVersionTask,
private val deleteBackupTask: DeleteBackupTask,
- private val deleteRoomSessionDataTask: DeleteRoomSessionDataTask,
- private val deleteRoomSessionsDataTask: DeleteRoomSessionsDataTask,
- private val deleteSessionDataTask: DeleteSessionsDataTask,
private val getKeysBackupLastVersionTask: GetKeysBackupLastVersionTask,
private val getKeysBackupVersionTask: GetKeysBackupVersionTask,
private val getRoomSessionDataTask: GetRoomSessionDataTask,
private val getRoomSessionsDataTask: GetRoomSessionsDataTask,
private val getSessionsDataTask: GetSessionsDataTask,
- private val storeRoomSessionDataTask: StoreRoomSessionDataTask,
- private val storeSessionsDataTask: StoreRoomSessionsDataTask,
private val storeSessionDataTask: StoreSessionsDataTask,
private val updateKeysBackupVersionTask: UpdateKeysBackupVersionTask,
// Task executor
@@ -168,58 +158,63 @@ internal class DefaultKeysBackupService @Inject constructor(
override fun prepareKeysBackupVersion(password: String?,
progressListener: ProgressListener?,
callback: MatrixCallback) {
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
- runCatching {
- withContext(coroutineDispatchers.crypto) {
- val olmPkDecryption = OlmPkDecryption()
- val signalableMegolmBackupAuthData = if (password != null) {
- // Generate a private key from the password
- val backgroundProgressListener = if (progressListener == null) {
- null
- } else {
- object : ProgressListener {
- override fun onProgress(progress: Int, total: Int) {
- uiHandler.post {
- try {
- progressListener.onProgress(progress, total)
- } catch (e: Exception) {
- Timber.e(e, "prepareKeysBackupVersion: onProgress failure")
- }
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
+ try {
+ val olmPkDecryption = OlmPkDecryption()
+ val signalableMegolmBackupAuthData = if (password != null) {
+ // Generate a private key from the password
+ val backgroundProgressListener = if (progressListener == null) {
+ null
+ } else {
+ object : ProgressListener {
+ override fun onProgress(progress: Int, total: Int) {
+ uiHandler.post {
+ try {
+ progressListener.onProgress(progress, total)
+ } catch (e: Exception) {
+ Timber.e(e, "prepareKeysBackupVersion: onProgress failure")
}
}
}
}
-
- val generatePrivateKeyResult = generatePrivateKeyWithPassword(password, backgroundProgressListener)
- SignalableMegolmBackupAuthData(
- publicKey = olmPkDecryption.setPrivateKey(generatePrivateKeyResult.privateKey),
- privateKeySalt = generatePrivateKeyResult.salt,
- privateKeyIterations = generatePrivateKeyResult.iterations
- )
- } else {
- val publicKey = olmPkDecryption.generateKey()
-
- SignalableMegolmBackupAuthData(
- publicKey = publicKey
- )
}
- val canonicalJson = JsonCanonicalizer.getCanonicalJson(Map::class.java, signalableMegolmBackupAuthData.signalableJSONDictionary())
-
- val signedMegolmBackupAuthData = MegolmBackupAuthData(
- publicKey = signalableMegolmBackupAuthData.publicKey,
- privateKeySalt = signalableMegolmBackupAuthData.privateKeySalt,
- privateKeyIterations = signalableMegolmBackupAuthData.privateKeyIterations,
- signatures = objectSigner.signObject(canonicalJson)
+ val generatePrivateKeyResult = generatePrivateKeyWithPassword(password, backgroundProgressListener)
+ SignalableMegolmBackupAuthData(
+ publicKey = olmPkDecryption.setPrivateKey(generatePrivateKeyResult.privateKey),
+ privateKeySalt = generatePrivateKeyResult.salt,
+ privateKeyIterations = generatePrivateKeyResult.iterations
)
+ } else {
+ val publicKey = olmPkDecryption.generateKey()
- MegolmBackupCreationInfo(
- algorithm = MXCRYPTO_ALGORITHM_MEGOLM_BACKUP,
- authData = signedMegolmBackupAuthData,
- recoveryKey = computeRecoveryKey(olmPkDecryption.privateKey())
+ SignalableMegolmBackupAuthData(
+ publicKey = publicKey
)
}
- }.foldToCallback(callback)
+
+ val canonicalJson = JsonCanonicalizer.getCanonicalJson(Map::class.java, signalableMegolmBackupAuthData.signalableJSONDictionary())
+
+ val signedMegolmBackupAuthData = MegolmBackupAuthData(
+ publicKey = signalableMegolmBackupAuthData.publicKey,
+ privateKeySalt = signalableMegolmBackupAuthData.privateKeySalt,
+ privateKeyIterations = signalableMegolmBackupAuthData.privateKeyIterations,
+ signatures = objectSigner.signObject(canonicalJson)
+ )
+
+ val creationInfo = MegolmBackupCreationInfo(
+ algorithm = MXCRYPTO_ALGORITHM_MEGOLM_BACKUP,
+ authData = signedMegolmBackupAuthData,
+ recoveryKey = computeRecoveryKey(olmPkDecryption.privateKey())
+ )
+ uiHandler.post {
+ callback.onSuccess(creationInfo)
+ }
+ } catch (failure: Throwable) {
+ uiHandler.post {
+ callback.onFailure(failure)
+ }
+ }
}
}
@@ -267,41 +262,39 @@ internal class DefaultKeysBackupService @Inject constructor(
}
override fun deleteBackup(version: String, callback: MatrixCallback?) {
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
- withContext(coroutineDispatchers.crypto) {
- // If we're currently backing up to this backup... stop.
- // (We start using it automatically in createKeysBackupVersion so this is symmetrical).
- if (keysBackupVersion != null && version == keysBackupVersion?.version) {
- resetKeysBackupData()
- keysBackupVersion = null
- keysBackupStateManager.state = KeysBackupState.Unknown
- }
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
+ // If we're currently backing up to this backup... stop.
+ // (We start using it automatically in createKeysBackupVersion so this is symmetrical).
+ if (keysBackupVersion != null && version == keysBackupVersion?.version) {
+ resetKeysBackupData()
+ keysBackupVersion = null
+ keysBackupStateManager.state = KeysBackupState.Unknown
+ }
- deleteBackupTask
- .configureWith(DeleteBackupTask.Params(version)) {
- this.callback = object : MatrixCallback {
- private fun eventuallyRestartBackup() {
- // Do not stay in KeysBackupState.Unknown but check what is available on the homeserver
- if (state == KeysBackupState.Unknown) {
- checkAndStartKeysBackup()
- }
- }
-
- override fun onSuccess(data: Unit) {
- eventuallyRestartBackup()
-
- uiHandler.post { callback?.onSuccess(Unit) }
- }
-
- override fun onFailure(failure: Throwable) {
- eventuallyRestartBackup()
-
- uiHandler.post { callback?.onFailure(failure) }
+ deleteBackupTask
+ .configureWith(DeleteBackupTask.Params(version)) {
+ this.callback = object : MatrixCallback {
+ private fun eventuallyRestartBackup() {
+ // Do not stay in KeysBackupState.Unknown but check what is available on the homeserver
+ if (state == KeysBackupState.Unknown) {
+ checkAndStartKeysBackup()
}
}
+
+ override fun onSuccess(data: Unit) {
+ eventuallyRestartBackup()
+
+ uiHandler.post { callback?.onSuccess(Unit) }
+ }
+
+ override fun onFailure(failure: Throwable) {
+ eventuallyRestartBackup()
+
+ uiHandler.post { callback?.onFailure(failure) }
+ }
}
- .executeBy(taskExecutor)
- }
+ }
+ .executeBy(taskExecutor)
}
}
@@ -480,10 +473,11 @@ internal class DefaultKeysBackupService @Inject constructor(
if (authData == null) {
Timber.w("trustKeyBackupVersion:trust: Key backup is missing required data")
-
- callback.onFailure(IllegalArgumentException("Missing element"))
+ uiHandler.post {
+ callback.onFailure(IllegalArgumentException("Missing element"))
+ }
} else {
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
val updateKeysBackupVersionBody = withContext(coroutineDispatchers.crypto) {
// Get current signatures, or create an empty set
val myUserSignatures = authData.signatures?.get(userId).orEmpty().toMutableMap()
@@ -516,7 +510,8 @@ internal class DefaultKeysBackupService @Inject constructor(
UpdateKeysBackupVersionBody(
algorithm = keysBackupVersion.algorithm,
authData = newMegolmBackupAuthDataWithNewSignature.toJsonDict(),
- version = keysBackupVersion.version)
+ version = keysBackupVersion.version
+ )
}
// And send it to the homeserver
@@ -535,11 +530,15 @@ internal class DefaultKeysBackupService @Inject constructor(
checkAndStartWithKeysBackupVersion(newKeysBackupVersion)
- callback.onSuccess(data)
+ uiHandler.post {
+ callback.onSuccess(data)
+ }
}
override fun onFailure(failure: Throwable) {
- callback.onFailure(failure)
+ uiHandler.post {
+ callback.onFailure(failure)
+ }
}
}
}
@@ -553,15 +552,14 @@ internal class DefaultKeysBackupService @Inject constructor(
callback: MatrixCallback) {
Timber.v("trustKeysBackupVersionWithRecoveryKey: version ${keysBackupVersion.version}")
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
- val isValid = withContext(coroutineDispatchers.crypto) {
- isValidRecoveryKeyForKeysBackupVersion(recoveryKey, keysBackupVersion)
- }
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
+ val isValid = isValidRecoveryKeyForKeysBackupVersion(recoveryKey, keysBackupVersion)
if (!isValid) {
Timber.w("trustKeyBackupVersionWithRecoveryKey: Invalid recovery key.")
-
- callback.onFailure(IllegalArgumentException("Invalid recovery key or password"))
+ uiHandler.post {
+ callback.onFailure(IllegalArgumentException("Invalid recovery key or password"))
+ }
} else {
trustKeysBackupVersion(keysBackupVersion, true, callback)
}
@@ -573,15 +571,14 @@ internal class DefaultKeysBackupService @Inject constructor(
callback: MatrixCallback) {
Timber.v("trustKeysBackupVersionWithPassphrase: version ${keysBackupVersion.version}")
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
- val recoveryKey = withContext(coroutineDispatchers.crypto) {
- recoveryKeyFromPassword(password, keysBackupVersion, null)
- }
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
+ val recoveryKey = recoveryKeyFromPassword(password, keysBackupVersion, null)
if (recoveryKey == null) {
Timber.w("trustKeysBackupVersionWithPassphrase: Key backup is missing required data")
-
- callback.onFailure(IllegalArgumentException("Missing element"))
+ uiHandler.post {
+ callback.onFailure(IllegalArgumentException("Missing element"))
+ }
} else {
// Check trust using the recovery key
trustKeysBackupVersionWithRecoveryKey(keysBackupVersion, recoveryKey, callback)
@@ -592,30 +589,28 @@ internal class DefaultKeysBackupService @Inject constructor(
override fun onSecretKeyGossip(secret: String) {
Timber.i("## CrossSigning - onSecretKeyGossip")
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
try {
- when (val keysBackupLastVersionResult = getKeysBackupLastVersionTask.execute(Unit)) {
- KeysBackupLastVersionResult.NoKeysBackup -> {
- Timber.d("No keys backup found")
- }
- is KeysBackupLastVersionResult.KeysBackup -> {
- val keysBackupVersion = keysBackupLastVersionResult.keysVersionResult
- val recoveryKey = computeRecoveryKey(secret.fromBase64())
- if (isValidRecoveryKeyForKeysBackupVersion(recoveryKey, keysBackupVersion)) {
- awaitCallback {
- trustKeysBackupVersion(keysBackupVersion, true, it)
- }
- val importResult = awaitCallback {
- restoreKeysWithRecoveryKey(keysBackupVersion, recoveryKey, null, null, null, it)
- }
- withContext(coroutineDispatchers.crypto) {
- cryptoStore.saveBackupRecoveryKey(recoveryKey, keysBackupVersion.version)
- }
- Timber.i("onSecretKeyGossip: Recovered keys $importResult")
- } else {
- Timber.e("onSecretKeyGossip: Recovery key is not valid ${keysBackupVersion.version}")
+ val keysBackupVersion = getKeysBackupLastVersionTask.execute(Unit).toKeysVersionResult()
+ ?: return@launch Unit.also {
+ Timber.d("Failed to get backup last version")
}
+ val recoveryKey = computeRecoveryKey(secret.fromBase64())
+ if (isValidRecoveryKeyForKeysBackupVersion(recoveryKey, keysBackupVersion)) {
+ awaitCallback {
+ trustKeysBackupVersion(keysBackupVersion, true, it)
}
+ // we don't want to start immediately downloading all as it can take very long
+
+// val importResult = awaitCallback {
+// restoreKeysWithRecoveryKey(keysBackupVersion, recoveryKey, null, null, null, it)
+// }
+ withContext(coroutineDispatchers.crypto) {
+ cryptoStore.saveBackupRecoveryKey(recoveryKey, keysBackupVersion.version)
+ }
+ Timber.i("onSecretKeyGossip: saved valid backup key")
+ } else {
+ Timber.e("onSecretKeyGossip: Recovery key is not valid ${keysBackupVersion.version}")
}
} catch (failure: Throwable) {
Timber.e("onSecretKeyGossip: failed to trust key backup version ${keysBackupVersion?.version}")
@@ -678,9 +673,9 @@ internal class DefaultKeysBackupService @Inject constructor(
callback: MatrixCallback) {
Timber.v("restoreKeysWithRecoveryKey: From backup version: ${keysVersionResult.version}")
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
runCatching {
- val decryption = withContext(coroutineDispatchers.crypto) {
+ val decryption = withContext(coroutineDispatchers.computation) {
// Check if the recovery is valid before going any further
if (!isValidRecoveryKeyForKeysBackupVersion(recoveryKey, keysVersionResult)) {
Timber.e("restoreKeysWithRecoveryKey: Invalid recovery key for this keys version")
@@ -719,14 +714,18 @@ internal class DefaultKeysBackupService @Inject constructor(
}
}
}
- Timber.v("restoreKeysWithRecoveryKey: Decrypted ${sessionsData.size} keys out" +
- " of $sessionsFromHsCount from the backup store on the homeserver")
+ Timber.v(
+ "restoreKeysWithRecoveryKey: Decrypted ${sessionsData.size} keys out" +
+ " of $sessionsFromHsCount from the backup store on the homeserver"
+ )
// Do not trigger a backup for them if they come from the backup version we are using
val backUp = keysVersionResult.version != keysBackupVersion?.version
if (backUp) {
- Timber.v("restoreKeysWithRecoveryKey: Those keys will be backed up" +
- " to backup version: ${keysBackupVersion?.version}")
+ Timber.v(
+ "restoreKeysWithRecoveryKey: Those keys will be backed up" +
+ " to backup version: ${keysBackupVersion?.version}"
+ )
}
// Import them into the crypto store
@@ -749,7 +748,19 @@ internal class DefaultKeysBackupService @Inject constructor(
}
result
}
- }.foldToCallback(callback)
+ }.foldToCallback(object : MatrixCallback {
+ override fun onSuccess(data: ImportRoomKeysResult) {
+ uiHandler.post {
+ callback.onSuccess(data)
+ }
+ }
+
+ override fun onFailure(failure: Throwable) {
+ uiHandler.post {
+ callback.onFailure(failure)
+ }
+ }
+ })
}
}
@@ -761,7 +772,7 @@ internal class DefaultKeysBackupService @Inject constructor(
callback: MatrixCallback) {
Timber.v("[MXKeyBackup] restoreKeyBackup with password: From backup version: ${keysBackupVersion.version}")
- cryptoCoroutineScope.launch(coroutineDispatchers.main) {
+ cryptoCoroutineScope.launch(coroutineDispatchers.io) {
runCatching {
val progressListener = if (stepProgressListener != null) {
object : ProgressListener {
@@ -786,7 +797,19 @@ internal class DefaultKeysBackupService @Inject constructor(
restoreKeysWithRecoveryKey(keysBackupVersion, recoveryKey, roomId, sessionId, stepProgressListener, it)
}
}
- }.foldToCallback(callback)
+ }.foldToCallback(object : MatrixCallback {
+ override fun onSuccess(data: ImportRoomKeysResult) {
+ uiHandler.post {
+ callback.onSuccess(data)
+ }
+ }
+
+ override fun onFailure(failure: Throwable) {
+ uiHandler.post {
+ callback.onFailure(failure)
+ }
+ }
+ })
}
}
@@ -801,19 +824,27 @@ internal class DefaultKeysBackupService @Inject constructor(
// Get key for the room and for the session
val data = getRoomSessionDataTask.execute(GetRoomSessionDataTask.Params(roomId, sessionId, version))
// Convert to KeysBackupData
- KeysBackupData(mutableMapOf(
- roomId to RoomKeysBackupData(mutableMapOf(
- sessionId to data
- ))
- ))
+ KeysBackupData(
+ mutableMapOf(
+ roomId to RoomKeysBackupData(
+ mutableMapOf(
+ sessionId to data
+ )
+ )
+ )
+ )
} else if (roomId != null) {
// Get all keys for the room
- val data = getRoomSessionsDataTask.execute(GetRoomSessionsDataTask.Params(roomId, version))
+ val data = withContext(coroutineDispatchers.io) {
+ getRoomSessionsDataTask.execute(GetRoomSessionsDataTask.Params(roomId, version))
+ }
// Convert to KeysBackupData
KeysBackupData(mutableMapOf(roomId to data))
} else {
// Get all keys
- getSessionsDataTask.execute(GetSessionsDataTask.Params(version))
+ withContext(coroutineDispatchers.io) {
+ getSessionsDataTask.execute(GetSessionsDataTask.Params(version))
+ }
}
}
@@ -1326,7 +1357,8 @@ internal class DefaultKeysBackupService @Inject constructor(
"sender_key" to sessionData.senderKey,
"sender_claimed_keys" to sessionData.senderClaimedKeys,
"forwarding_curve25519_key_chain" to (sessionData.forwardingCurve25519KeyChain.orEmpty()),
- "session_key" to sessionData.sessionKey)
+ "session_key" to sessionData.sessionKey
+ )
val json = MoshiProvider.providesMoshi()
.adapter(Map::class.java)
@@ -1354,7 +1386,8 @@ internal class DefaultKeysBackupService @Inject constructor(
sessionData = mapOf(
"ciphertext" to encryptedSessionBackupData.mCipherText,
"mac" to encryptedSessionBackupData.mMac,
- "ephemeral" to encryptedSessionBackupData.mEphemeralKey)
+ "ephemeral" to encryptedSessionBackupData.mEphemeralKey
+ )
)
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupPassword.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupPassword.kt
index c12879dbee..4d5b38acbf 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupPassword.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupPassword.kt
@@ -26,6 +26,7 @@ import java.util.UUID
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.xor
+import kotlin.system.measureTimeMillis
private const val SALT_LENGTH = 32
private const val DEFAULT_ITERATION = 500_000
@@ -91,52 +92,53 @@ internal fun deriveKey(password: String,
iterations: Int,
progressListener: ProgressListener?): ByteArray {
// Note: copied and adapted from MXMegolmExportEncryption
- val t0 = System.currentTimeMillis()
-
// based on https://en.wikipedia.org/wiki/PBKDF2 algorithm
// it is simpler than the generic algorithm because the expected key length is equal to the mac key length.
// noticed as dklen/hlen
- // dklen = 256
- // hlen = 512
- val prf = Mac.getInstance("HmacSHA512")
-
- prf.init(SecretKeySpec(password.toByteArray(), "HmacSHA512"))
-
// 256 bits key length
val dk = ByteArray(32)
- val uc = ByteArray(64)
- // U1 = PRF(Password, Salt || INT_32_BE(i)) with i goes from 1 to dklen/hlen
- prf.update(salt.toByteArray())
- val int32BE = byteArrayOf(0, 0, 0, 1)
- prf.update(int32BE)
- prf.doFinal(uc, 0)
+ measureTimeMillis {
+ // dklen = 256
+ // hlen = 512
+ val prf = Mac.getInstance("HmacSHA512")
- // copy to the key
- System.arraycopy(uc, 0, dk, 0, dk.size)
+ prf.init(SecretKeySpec(password.toByteArray(), "HmacSHA512"))
- var lastProgress = -1
+ val uc = ByteArray(64)
- for (index in 2..iterations) {
- // Uc = PRF(Password, Uc-1)
- prf.update(uc)
+ // U1 = PRF(Password, Salt || INT_32_BE(i)) with i goes from 1 to dklen/hlen
+ prf.update(salt.toByteArray())
+ val int32BE = byteArrayOf(0, 0, 0, 1)
+ prf.update(int32BE)
prf.doFinal(uc, 0)
- // F(Password, Salt, c, i) = U1 ^ U2 ^ ... ^ Uc
- for (byteIndex in dk.indices) {
- dk[byteIndex] = dk[byteIndex] xor uc[byteIndex]
- }
+ // copy to the key
+ System.arraycopy(uc, 0, dk, 0, dk.size)
- val progress = (index + 1) * 100 / iterations
- if (progress != lastProgress) {
- lastProgress = progress
- progressListener?.onProgress(lastProgress, 100)
+ var lastProgress = -1
+
+ for (index in 2..iterations) {
+ // Uc = PRF(Password, Uc-1)
+ prf.update(uc)
+ prf.doFinal(uc, 0)
+
+ // F(Password, Salt, c, i) = U1 ^ U2 ^ ... ^ Uc
+ for (byteIndex in dk.indices) {
+ dk[byteIndex] = dk[byteIndex] xor uc[byteIndex]
+ }
+
+ val progress = (index + 1) * 100 / iterations
+ if (progress != lastProgress) {
+ lastProgress = progress
+ progressListener?.onProgress(lastProgress, 100)
+ }
}
+ }.also {
+ Timber.v("KeysBackupPassword: deriveKeys() : $iterations in $it ms")
}
- Timber.v("KeysBackupPassword: deriveKeys() : " + iterations + " in " + (System.currentTimeMillis() - t0) + " ms")
-
return dk
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionDataTask.kt
index 7f1b03b932..f90522b036 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionDataTask.kt
@@ -40,7 +40,8 @@ internal class DefaultDeleteRoomSessionDataTask @Inject constructor(
roomKeysApi.deleteRoomSessionData(
params.roomId,
params.sessionId,
- params.version)
+ params.version
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionsDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionsDataTask.kt
index 394cc861d6..7db33e0c46 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionsDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/DeleteRoomSessionsDataTask.kt
@@ -38,7 +38,8 @@ internal class DefaultDeleteRoomSessionsDataTask @Inject constructor(
return executeRequest(globalErrorReceiver) {
roomKeysApi.deleteRoomSessionsData(
params.roomId,
- params.version)
+ params.version
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionDataTask.kt
index ff515ed80f..df8e6bfebf 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionDataTask.kt
@@ -41,7 +41,8 @@ internal class DefaultGetRoomSessionDataTask @Inject constructor(
roomKeysApi.getRoomSessionData(
params.roomId,
params.sessionId,
- params.version)
+ params.version
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionsDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionsDataTask.kt
index 1b4fe2d966..f9ea078ef2 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionsDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetRoomSessionsDataTask.kt
@@ -39,7 +39,8 @@ internal class DefaultGetRoomSessionsDataTask @Inject constructor(
return executeRequest(globalErrorReceiver) {
roomKeysApi.getRoomSessionsData(
params.roomId,
- params.version)
+ params.version
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionDataTask.kt
index 180aaecf82..637c6ddeb7 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionDataTask.kt
@@ -44,7 +44,8 @@ internal class DefaultStoreRoomSessionDataTask @Inject constructor(
params.roomId,
params.sessionId,
params.version,
- params.keyBackupData)
+ params.keyBackupData
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionsDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionsDataTask.kt
index d1aa9d2eb0..09e52da755 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionsDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreRoomSessionsDataTask.kt
@@ -42,7 +42,8 @@ internal class DefaultStoreRoomSessionsDataTask @Inject constructor(
roomKeysApi.storeRoomSessionsData(
params.roomId,
params.version,
- params.roomKeysBackupData)
+ params.roomKeysBackupData
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreSessionsDataTask.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreSessionsDataTask.kt
index 3dbeafe9de..47f2578c43 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreSessionsDataTask.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/StoreSessionsDataTask.kt
@@ -40,7 +40,8 @@ internal class DefaultStoreSessionsDataTask @Inject constructor(
return executeRequest(globalErrorReceiver) {
roomKeysApi.storeSessionsData(
params.version,
- params.keysBackupData)
+ params.keysBackupData
+ )
}
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/model/OlmSessionWrapper.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/model/OlmSessionWrapper.kt
index 927d049eca..d7ce553f39 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/model/OlmSessionWrapper.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/model/OlmSessionWrapper.kt
@@ -34,7 +34,7 @@ internal data class OlmSessionWrapper(
/**
* Notify that a message has been received on this olm session so that it updates `lastReceivedMessageTs`
*/
- fun onMessageReceived() {
- lastReceivedMessageTs = System.currentTimeMillis()
+ fun onMessageReceived(currentTimeMillis: Long) {
+ lastReceivedMessageTs = currentTimeMillis
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/secrets/DefaultSharedSecretStorageService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/secrets/DefaultSharedSecretStorageService.kt
index 8c877593e7..1ded9c6c7e 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/secrets/DefaultSharedSecretStorageService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/secrets/DefaultSharedSecretStorageService.kt
@@ -40,7 +40,7 @@ import org.matrix.android.sdk.api.session.securestorage.SsssKeySpec
import org.matrix.android.sdk.api.session.securestorage.SsssPassphrase
import org.matrix.android.sdk.api.util.fromBase64
import org.matrix.android.sdk.api.util.toBase64NoPadding
-import org.matrix.android.sdk.internal.crypto.OutgoingGossipingRequestManager
+import org.matrix.android.sdk.internal.crypto.SecretShareManager
import org.matrix.android.sdk.internal.crypto.keysbackup.generatePrivateKeyWithPassword
import org.matrix.android.sdk.internal.crypto.tools.HkdfSha256
import org.matrix.android.sdk.internal.crypto.tools.withOlmDecryption
@@ -57,7 +57,7 @@ import kotlin.experimental.and
internal class DefaultSharedSecretStorageService @Inject constructor(
@UserId private val userId: String,
private val accountDataService: SessionAccountDataService,
- private val outgoingGossipingRequestManager: OutgoingGossipingRequestManager,
+ private val secretShareManager: SecretShareManager,
private val coroutineDispatchers: MatrixCoroutineDispatchers,
private val cryptoCoroutineScope: CoroutineScope
) : SharedSecretStorageService {
@@ -213,7 +213,8 @@ internal class DefaultSharedSecretStorageService @Inject constructor(
secretKey.privateKey,
ByteArray(32) { 0.toByte() },
secretName.toByteArray(),
- 64)
+ 64
+ )
// The first 32 bytes are used as the AES key, and the next 32 bytes are used as the MAC key
val aesKey = pseudoRandomKey.copyOfRange(0, 32)
@@ -255,7 +256,8 @@ internal class DefaultSharedSecretStorageService @Inject constructor(
secretKey.privateKey,
ByteArray(32) { 0.toByte() },
secretName.toByteArray(),
- 64)
+ 64
+ )
// The first 32 bytes are used as the AES key, and the next 32 bytes are used as the MAC key
val aesKey = pseudoRandomKey.copyOfRange(0, 32)
@@ -378,10 +380,7 @@ internal class DefaultSharedSecretStorageService @Inject constructor(
return IntegrityResult.Success(keyInfo.content.passphrase != null)
}
- override fun requestSecret(name: String, myOtherDeviceId: String) {
- outgoingGossipingRequestManager.sendSecretShareRequest(
- name,
- mapOf(userId to listOf(myOtherDeviceId))
- )
+ override suspend fun requestSecret(name: String, myOtherDeviceId: String) {
+ secretShareManager.requestSecretTo(myOtherDeviceId, name)
}
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/IMXCryptoStore.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/IMXCryptoStore.kt
index 8bedb78808..d720777ae1 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/IMXCryptoStore.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/IMXCryptoStore.kt
@@ -19,23 +19,22 @@ package org.matrix.android.sdk.internal.crypto.store
import androidx.lifecycle.LiveData
import androidx.paging.PagedList
import org.matrix.android.sdk.api.session.crypto.NewSessionListener
+import org.matrix.android.sdk.api.session.crypto.OutgoingKeyRequest
+import org.matrix.android.sdk.api.session.crypto.OutgoingRoomKeyRequestState
import org.matrix.android.sdk.api.session.crypto.crosssigning.CryptoCrossSigningKey
import org.matrix.android.sdk.api.session.crypto.crosssigning.MXCrossSigningInfo
import org.matrix.android.sdk.api.session.crypto.crosssigning.PrivateKeysInfo
import org.matrix.android.sdk.api.session.crypto.keysbackup.SavedKeyBackupKeyInfo
+import org.matrix.android.sdk.api.session.crypto.model.AuditTrail
import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.DeviceInfo
-import org.matrix.android.sdk.api.session.crypto.model.GossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingRoomKeyRequest
import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
+import org.matrix.android.sdk.api.session.crypto.model.TrailType
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
+import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
import org.matrix.android.sdk.api.util.Optional
-import org.matrix.android.sdk.internal.crypto.IncomingShareRequestCommon
-import org.matrix.android.sdk.internal.crypto.OutgoingSecretRequest
import org.matrix.android.sdk.internal.crypto.model.OlmInboundGroupSessionWrapper2
import org.matrix.android.sdk.internal.crypto.model.OlmSessionWrapper
import org.matrix.android.sdk.internal.crypto.model.OutboundGroupSessionWrapper
@@ -82,6 +81,15 @@ internal interface IMXCryptoStore {
*/
fun setGlobalBlacklistUnverifiedDevices(block: Boolean)
+ /**
+ * Enable or disable key gossiping.
+ * Default is true.
+ * If set to false this device won't send key_request nor will accept key forwarded
+ */
+ fun enableKeyGossiping(enable: Boolean)
+
+ fun isKeyGossipingEnabled(): Boolean
+
/**
* Provides the rooms ids list in which the messages are not encrypted for the unverified devices.
*
@@ -125,18 +133,6 @@ internal interface IMXCryptoStore {
*/
fun getDeviceTrackingStatuses(): Map
- /**
- * @return the pending IncomingRoomKeyRequest requests
- */
- fun getPendingIncomingRoomKeyRequests(): List
-
- fun getPendingIncomingGossipingRequests(): List
-
- fun storeIncomingGossipingRequest(request: IncomingShareRequestCommon, ageLocalTS: Long?)
-
- fun storeIncomingGossipingRequests(requests: List)
-// fun getPendingIncomingSecretShareRequests(): List
-
/**
* Indicate if the store contains data for the passed account.
*
@@ -377,7 +373,9 @@ internal interface IMXCryptoStore {
* @param requestBody the request body
* @return an OutgoingRoomKeyRequest instance or null
*/
- fun getOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody): OutgoingRoomKeyRequest?
+ fun getOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody): OutgoingKeyRequest?
+ fun getOutgoingRoomKeyRequest(requestId: String): OutgoingKeyRequest?
+ fun getOutgoingRoomKeyRequest(roomId: String, sessionId: String, algorithm: String, senderKey: String): List
/**
* Look for an existing outgoing room key request, and if none is found, add a new one.
@@ -385,39 +383,59 @@ internal interface IMXCryptoStore {
* @param request the request
* @return either the same instance as passed in, or the existing one.
*/
- fun getOrAddOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody, recipients: Map>): OutgoingRoomKeyRequest?
+ fun getOrAddOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody, recipients: Map>, fromIndex: Int): OutgoingKeyRequest
+ fun updateOutgoingRoomKeyRequestState(requestId: String, newState: OutgoingRoomKeyRequestState)
+ fun updateOutgoingRoomKeyRequiredIndex(requestId: String, newIndex: Int)
+ fun updateOutgoingRoomKeyReply(
+ roomId: String,
+ sessionId: String,
+ algorithm: String,
+ senderKey: String,
+ fromDevice: String?,
+ event: Event)
- fun getOrAddOutgoingSecretShareRequest(secretName: String, recipients: Map>): OutgoingSecretRequest?
+ fun deleteOutgoingRoomKeyRequest(requestId: String)
+ fun deleteOutgoingRoomKeyRequestInState(state: OutgoingRoomKeyRequestState)
- fun saveGossipingEvent(event: Event) = saveGossipingEvents(listOf(event))
+ fun saveIncomingKeyRequestAuditTrail(
+ requestId: String,
+ roomId: String,
+ sessionId: String,
+ senderKey: String,
+ algorithm: String,
+ fromUser: String,
+ fromDevice: String
+ )
- fun saveGossipingEvents(events: List)
+ fun saveWithheldAuditTrail(
+ roomId: String,
+ sessionId: String,
+ senderKey: String,
+ algorithm: String,
+ code: WithHeldCode,
+ userId: String,
+ deviceId: String
+ )
- fun updateGossipingRequestState(request: IncomingShareRequestCommon, state: GossipingRequestState) {
- updateGossipingRequestState(
- requestUserId = request.userId,
- requestDeviceId = request.deviceId,
- requestId = request.requestId,
- state = state
- )
- }
+ fun saveForwardKeyAuditTrail(
+ roomId: String,
+ sessionId: String,
+ senderKey: String,
+ algorithm: String,
+ userId: String,
+ deviceId: String,
+ chainIndex: Long?
+ )
- fun updateGossipingRequestState(requestUserId: String?,
- requestDeviceId: String?,
- requestId: String?,
- state: GossipingRequestState)
-
- /**
- * Search an IncomingRoomKeyRequest
- *
- * @param userId the user id
- * @param deviceId the device id
- * @param requestId the request id
- * @return an IncomingRoomKeyRequest if it exists, else null
- */
- fun getIncomingRoomKeyRequest(userId: String, deviceId: String, requestId: String): IncomingRoomKeyRequest?
-
- fun updateOutgoingGossipingRequestState(requestId: String, state: OutgoingGossipingRequestState)
+ fun saveIncomingForwardKeyAuditTrail(
+ roomId: String,
+ sessionId: String,
+ senderKey: String,
+ algorithm: String,
+ userId: String,
+ deviceId: String,
+ chainIndex: Long?
+ )
fun addNewSessionListener(listener: NewSessionListener)
@@ -477,17 +495,15 @@ internal interface IMXCryptoStore {
fun getSharedWithInfo(roomId: String?, sessionId: String): MXUsersDevicesMap
// Dev tools
- fun getOutgoingRoomKeyRequests(): List
- fun getOutgoingRoomKeyRequestsPaged(): LiveData>
- fun getOutgoingSecretKeyRequests(): List
- fun getOutgoingSecretRequest(secretName: String): OutgoingSecretRequest?
- fun getIncomingRoomKeyRequests(): List
- fun getIncomingRoomKeyRequestsPaged(): LiveData>
- fun getGossipingEventsTrail(): LiveData>
- fun getGossipingEvents(): List
+ fun getOutgoingRoomKeyRequests(): List
+ fun getOutgoingRoomKeyRequestsPaged(): LiveData>
+ fun getGossipingEventsTrail(): LiveData>
+ fun getGossipingEventsTrail(type: TrailType, mapper: ((AuditTrail) -> T)): LiveData>
+ fun getGossipingEvents(): List
fun setDeviceKeysUploaded(uploaded: Boolean)
fun areDeviceKeysUploaded(): Boolean
fun tidyUpDataBase()
fun logDbUsageInfo()
+ fun getOutgoingRoomKeyRequests(inStates: Set): List
}
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/db/RealmCryptoStore.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/db/RealmCryptoStore.kt
index fad901f95d..d5750a2e2a 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/db/RealmCryptoStore.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/store/db/RealmCryptoStore.kt
@@ -24,37 +24,40 @@ import com.zhuinden.monarchy.Monarchy
import io.realm.Realm
import io.realm.RealmConfiguration
import io.realm.Sort
+import io.realm.kotlin.createObject
import io.realm.kotlin.where
import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM
import org.matrix.android.sdk.api.extensions.tryOrNull
+import org.matrix.android.sdk.api.logger.LoggerTag
import org.matrix.android.sdk.api.session.crypto.NewSessionListener
+import org.matrix.android.sdk.api.session.crypto.OutgoingKeyRequest
+import org.matrix.android.sdk.api.session.crypto.OutgoingRoomKeyRequestState
import org.matrix.android.sdk.api.session.crypto.crosssigning.CryptoCrossSigningKey
import org.matrix.android.sdk.api.session.crypto.crosssigning.MXCrossSigningInfo
import org.matrix.android.sdk.api.session.crypto.crosssigning.PrivateKeysInfo
import org.matrix.android.sdk.api.session.crypto.keysbackup.SavedKeyBackupKeyInfo
+import org.matrix.android.sdk.api.session.crypto.model.AuditTrail
import org.matrix.android.sdk.api.session.crypto.model.CryptoDeviceInfo
import org.matrix.android.sdk.api.session.crypto.model.DeviceInfo
-import org.matrix.android.sdk.api.session.crypto.model.GossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.IncomingRoomKeyRequest
-import org.matrix.android.sdk.api.session.crypto.model.IncomingSecretShareRequest
+import org.matrix.android.sdk.api.session.crypto.model.ForwardInfo
+import org.matrix.android.sdk.api.session.crypto.model.IncomingKeyRequestInfo
import org.matrix.android.sdk.api.session.crypto.model.MXUsersDevicesMap
-import org.matrix.android.sdk.api.session.crypto.model.OlmDecryptionResult
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingGossipingRequestState
-import org.matrix.android.sdk.api.session.crypto.model.OutgoingRoomKeyRequest
import org.matrix.android.sdk.api.session.crypto.model.RoomKeyRequestBody
+import org.matrix.android.sdk.api.session.crypto.model.TrailType
+import org.matrix.android.sdk.api.session.crypto.model.WithheldInfo
import org.matrix.android.sdk.api.session.events.model.Event
import org.matrix.android.sdk.api.session.events.model.content.RoomKeyWithHeldContent
-import org.matrix.android.sdk.api.session.room.send.SendState
+import org.matrix.android.sdk.api.session.events.model.content.WithHeldCode
import org.matrix.android.sdk.api.util.Optional
import org.matrix.android.sdk.api.util.toOptional
-import org.matrix.android.sdk.internal.crypto.GossipRequestType
-import org.matrix.android.sdk.internal.crypto.IncomingShareRequestCommon
-import org.matrix.android.sdk.internal.crypto.OutgoingSecretRequest
import org.matrix.android.sdk.internal.crypto.model.OlmInboundGroupSessionWrapper2
import org.matrix.android.sdk.internal.crypto.model.OlmSessionWrapper
import org.matrix.android.sdk.internal.crypto.model.OutboundGroupSessionWrapper
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.AuditTrailEntity
+import org.matrix.android.sdk.internal.crypto.store.db.model.AuditTrailEntityFields
+import org.matrix.android.sdk.internal.crypto.store.db.model.AuditTrailMapper
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
@@ -63,10 +66,6 @@ import org.matrix.android.sdk.internal.crypto.store.db.model.CryptoRoomEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.CryptoRoomEntityFields
import org.matrix.android.sdk.internal.crypto.store.db.model.DeviceInfoEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.DeviceInfoEntityFields
-import org.matrix.android.sdk.internal.crypto.store.db.model.GossipingEventEntity
-import org.matrix.android.sdk.internal.crypto.store.db.model.GossipingEventEntityFields
-import org.matrix.android.sdk.internal.crypto.store.db.model.IncomingGossipingRequestEntity
-import org.matrix.android.sdk.internal.crypto.store.db.model.IncomingGossipingRequestEntityFields
import org.matrix.android.sdk.internal.crypto.store.db.model.KeysBackupDataEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.MyDeviceLastSeenInfoEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.OlmInboundGroupSessionEntity
@@ -74,8 +73,8 @@ import org.matrix.android.sdk.internal.crypto.store.db.model.OlmInboundGroupSess
import org.matrix.android.sdk.internal.crypto.store.db.model.OlmSessionEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.OlmSessionEntityFields
import org.matrix.android.sdk.internal.crypto.store.db.model.OutboundGroupSessionInfoEntity
-import org.matrix.android.sdk.internal.crypto.store.db.model.OutgoingGossipingRequestEntity
-import org.matrix.android.sdk.internal.crypto.store.db.model.OutgoingGossipingRequestEntityFields
+import org.matrix.android.sdk.internal.crypto.store.db.model.OutgoingKeyRequestEntity
+import org.matrix.android.sdk.internal.crypto.store.db.model.OutgoingKeyRequestEntityFields
import org.matrix.android.sdk.internal.crypto.store.db.model.SharedSessionEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.TrustLevelEntity
import org.matrix.android.sdk.internal.crypto.store.db.model.UserEntity
@@ -89,7 +88,6 @@ import org.matrix.android.sdk.internal.crypto.store.db.query.get
import org.matrix.android.sdk.internal.crypto.store.db.query.getById
import org.matrix.android.sdk.internal.crypto.store.db.query.getOrCreate
import org.matrix.android.sdk.internal.crypto.util.RequestIdHelper
-import org.matrix.android.sdk.internal.database.mapper.ContentMapper
import org.matrix.android.sdk.internal.database.tools.RealmDebugTools
import org.matrix.android.sdk.internal.di.CryptoDatabase
import org.matrix.android.sdk.internal.di.DeviceId
@@ -97,6 +95,7 @@ import org.matrix.android.sdk.internal.di.MoshiProvider
import org.matrix.android.sdk.internal.di.UserId
import org.matrix.android.sdk.internal.extensions.clearWith
import org.matrix.android.sdk.internal.session.SessionScope
+import org.matrix.android.sdk.internal.util.time.Clock
import org.matrix.olm.OlmAccount
import org.matrix.olm.OlmException
import org.matrix.olm.OlmOutboundGroupSession
@@ -105,12 +104,15 @@ import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.inject.Inject
+private val loggerTag = LoggerTag("RealmCryptoStore", LoggerTag.CRYPTO)
+
@SessionScope
internal class RealmCryptoStore @Inject constructor(
@CryptoDatabase private val realmConfiguration: RealmConfiguration,
private val crossSigningKeysMapper: CrossSigningKeysMapper,
@UserId private val userId: String,
- @DeviceId private val deviceId: String?
+ @DeviceId private val deviceId: String?,
+ private val clock: Clock,
) : IMXCryptoStore {
/* ==========================================================================================
@@ -271,12 +273,13 @@ internal class RealmCryptoStore @Inject constructor(
}
override fun deviceWithIdentityKey(identityKey: String): CryptoDeviceInfo? {
- return doWithRealm(realmConfiguration) {
- it.where()
- .equalTo(DeviceInfoEntityFields.IDENTITY_KEY, identityKey)
- .findFirst()
- ?.let { deviceInfo ->
- CryptoMapper.mapToModel(deviceInfo)
+ return doWithRealm(realmConfiguration) { realm ->
+ realm.where()
+ .contains(DeviceInfoEntityFields.KEYS_MAP_JSON, identityKey)
+ .findAll()
+ .mapNotNull { CryptoMapper.mapToModel(it) }
+ .firstOrNull {
+ it.identityKey() == identityKey
}
}
}
@@ -307,7 +310,7 @@ internal class RealmCryptoStore @Inject constructor(
// Add the device
Timber.d("Add device ${cryptoDeviceInfo.deviceId} of user $userId")
val newEntity = CryptoMapper.mapToEntity(cryptoDeviceInfo)
- newEntity.firstTimeSeenLocalTs = System.currentTimeMillis()
+ newEntity.firstTimeSeenLocalTs = clock.epochMillis()
userEntity.devices.add(newEntity)
} else {
// Update the device
@@ -741,14 +744,23 @@ internal class RealmCryptoStore @Inject constructor(
if (sessionIdentifier != null) {
val key = OlmInboundGroupSessionEntity.createPrimaryKey(sessionIdentifier, session.senderKey)
- val realmOlmInboundGroupSession = OlmInboundGroupSessionEntity().apply {
- primaryKey = key
- sessionId = sessionIdentifier
- senderKey = session.senderKey
- putInboundGroupSession(session)
- }
+ val existing = realm.where()
+ .equalTo(OlmInboundGroupSessionEntityFields.PRIMARY_KEY, key)
+ .findFirst()
- realm.insertOrUpdate(realmOlmInboundGroupSession)
+ if (existing != null) {
+ // we want to keep the existing backup status
+ existing.putInboundGroupSession(session)
+ } else {
+ val realmOlmInboundGroupSession = OlmInboundGroupSessionEntity().apply {
+ primaryKey = key
+ sessionId = sessionIdentifier
+ senderKey = session.senderKey
+ putInboundGroupSession(session)
+ }
+
+ realm.insertOrUpdate(realmOlmInboundGroupSession)
+ }
}
}
}
@@ -792,7 +804,7 @@ internal class RealmCryptoStore @Inject constructor(
if (outboundGroupSession != null) {
val info = realm.createObject(OutboundGroupSessionInfoEntity::class.java).apply {
- creationTime = System.currentTimeMillis()
+ creationTime = clock.epochMillis()
putOutboundGroupSession(outboundGroupSession)
}
entity.outboundSessionInfo = info
@@ -877,17 +889,33 @@ internal class RealmCryptoStore @Inject constructor(
return
}
- doRealmTransaction(realmConfiguration) {
+ doRealmTransaction(realmConfiguration) { realm ->
olmInboundGroupSessionWrappers.forEach { olmInboundGroupSessionWrapper ->
try {
+ val sessionIdentifier = olmInboundGroupSessionWrapper.olmInboundGroupSession?.sessionIdentifier()
val key = OlmInboundGroupSessionEntity.createPrimaryKey(
- olmInboundGroupSessionWrapper.olmInboundGroupSession?.sessionIdentifier(),
- olmInboundGroupSessionWrapper.senderKey)
+ sessionIdentifier,
+ olmInboundGroupSessionWrapper.senderKey
+ )
- it.where()
+ val existing = realm.where()
.equalTo(OlmInboundGroupSessionEntityFields.PRIMARY_KEY, key)
.findFirst()
- ?.backedUp = true
+
+ if (existing != null) {
+ existing.backedUp = true
+ } else {
+ // ... might be in cache but not yet persisted, create a record to persist backedup state
+ val realmOlmInboundGroupSession = OlmInboundGroupSessionEntity().apply {
+ primaryKey = key
+ sessionId = sessionIdentifier
+ senderKey = olmInboundGroupSessionWrapper.senderKey
+ putInboundGroupSession(olmInboundGroupSessionWrapper)
+ backedUp = true
+ }
+
+ realm.insertOrUpdate(realmOlmInboundGroupSession)
+ }
} catch (e: OlmException) {
Timber.e(e, "OlmException")
}
@@ -926,6 +954,18 @@ internal class RealmCryptoStore @Inject constructor(
}
}
+ override fun enableKeyGossiping(enable: Boolean) {
+ doRealmTransaction(realmConfiguration) {
+ it.where().findFirst()?.globalEnableKeyGossiping = enable
+ }
+ }
+
+ override fun isKeyGossipingEnabled(): Boolean {
+ return doWithRealm(realmConfiguration) {
+ it.where().findFirst()?.globalEnableKeyGossiping
+ } ?: true
+ }
+
override fun getGlobalBlacklistUnverifiedDevices(): Boolean {
return doWithRealm(realmConfiguration) {
it.where().findFirst()?.globalBlacklistUnverifiedDevices
@@ -1007,12 +1047,13 @@ internal class RealmCryptoStore @Inject constructor(
?: defaultValue
}
- override fun getOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody): OutgoingRoomKeyRequest? {
+ override fun getOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody): OutgoingKeyRequest? {
return monarchy.fetchAllCopiedSync { realm ->
- realm.where()
- .equalTo(OutgoingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.KEY.name)
- }.mapNotNull {
- it.toOutgoingGossipingRequest() as? OutgoingRoomKeyRequest
+ realm.where()
+ .equalTo(OutgoingKeyRequestEntityFields.ROOM_ID, requestBody.roomId)
+ .equalTo(OutgoingKeyRequestEntityFields.MEGOLM_SESSION_ID, requestBody.sessionId)
+ }.map {
+ it.toOutgoingKeyRequest()
}.firstOrNull {
it.requestBody?.algorithm == requestBody.algorithm &&
it.requestBody?.roomId == requestBody.roomId &&
@@ -1021,87 +1062,118 @@ internal class RealmCryptoStore @Inject constructor(
}
}
- override fun getOutgoingSecretRequest(secretName: String): OutgoingSecretRequest? {
+ override fun getOutgoingRoomKeyRequest(requestId: String): OutgoingKeyRequest? {
return monarchy.fetchAllCopiedSync { realm ->
- realm.where()
- .equalTo(OutgoingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.SECRET.name)
- .equalTo(OutgoingGossipingRequestEntityFields.REQUESTED_INFO_STR, secretName)
- }.mapNotNull {
- it.toOutgoingGossipingRequest() as? OutgoingSecretRequest
+ realm.where()
+ .equalTo(OutgoingKeyRequestEntityFields.REQUEST_ID, requestId)
+ }.map {
+ it.toOutgoingKeyRequest()
}.firstOrNull()
}
- override fun getIncomingRoomKeyRequests(): List {
+ override fun getOutgoingRoomKeyRequest(roomId: String, sessionId: String, algorithm: String, senderKey: String): List {
+ // TODO this annoying we have to load all
return monarchy.fetchAllCopiedSync { realm ->
- realm.where()
- .equalTo(IncomingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.KEY.name)
- }.mapNotNull {
- it.toIncomingGossipingRequest() as? IncomingRoomKeyRequest
+ realm.where()
+ .equalTo(OutgoingKeyRequestEntityFields.ROOM_ID, roomId)
+ .equalTo(OutgoingKeyRequestEntityFields.MEGOLM_SESSION_ID, sessionId)
+ }.map {
+ it.toOutgoingKeyRequest()
+ }.filter {
+ it.requestBody?.algorithm == algorithm &&
+ it.requestBody?.senderKey == senderKey
}
}
- override fun getIncomingRoomKeyRequestsPaged(): LiveData> {
+ override fun getGossipingEventsTrail(): LiveData> {
val realmDataSourceFactory = monarchy.createDataSourceFactory { realm ->
- realm.where()
- .equalTo(IncomingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.KEY.name)
- .sort(IncomingGossipingRequestEntityFields.LOCAL_CREATION_TIMESTAMP, Sort.DESCENDING)
+ realm.where().sort(AuditTrailEntityFields.AGE_LOCAL_TS, Sort.DESCENDING)
}
val dataSourceFactory = realmDataSourceFactory.map {
- it.toIncomingGossipingRequest() as? IncomingRoomKeyRequest
- ?: IncomingRoomKeyRequest(
- requestBody = null,
- deviceId = "",
- userId = "",
- requestId = "",
- state = GossipingRequestState.NONE,
- localCreationTimestamp = 0
- )
+ AuditTrailMapper.map(it)
+ // mm we can't map not null...
+ ?: createUnknownTrail()
}
- return monarchy.findAllPagedWithChanges(realmDataSourceFactory,
- LivePagedListBuilder(dataSourceFactory,
+ return monarchy.findAllPagedWithChanges(
+ realmDataSourceFactory,
+ LivePagedListBuilder(
+ dataSourceFactory,
PagedList.Config.Builder()
.setPageSize(20)
.setEnablePlaceholders(false)
.setPrefetchDistance(1)
- .build())
+ .build()
+ )
)
}
- override fun getGossipingEventsTrail(): LiveData> {
+ private fun createUnknownTrail() = AuditTrail(
+ clock.epochMillis(),
+ TrailType.Unknown,
+ IncomingKeyRequestInfo(
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ )
+ )
+
+ override fun getGossipingEventsTrail(type: TrailType, mapper: ((AuditTrail) -> T)): LiveData> {
val realmDataSourceFactory = monarchy.createDataSourceFactory { realm ->
- realm.where().sort(GossipingEventEntityFields.AGE_LOCAL_TS, Sort.DESCENDING)
+ realm.where()
+ .equalTo(AuditTrailEntityFields.TYPE, type.name)
+ .sort(AuditTrailEntityFields.AGE_LOCAL_TS, Sort.DESCENDING)
}
- val dataSourceFactory = realmDataSourceFactory.map { it.toModel() }
- val trail = monarchy.findAllPagedWithChanges(realmDataSourceFactory,
- LivePagedListBuilder(dataSourceFactory,
+ val dataSourceFactory = realmDataSourceFactory.map { entity ->
+ (AuditTrailMapper.map(entity)
+ // mm we can't map not null...
+ ?: createUnknownTrail()
+ ).let { mapper.invoke(it) }
+ }
+ return monarchy.findAllPagedWithChanges(
+ realmDataSourceFactory,
+ LivePagedListBuilder(
+ dataSourceFactory,
PagedList.Config.Builder()
.setPageSize(20)
.setEnablePlaceholders(false)
.setPrefetchDistance(1)
- .build())
+ .build()
+ )
)
- return trail
}
- override fun getGossipingEvents(): List {
+ override fun getGossipingEvents(): List {
return monarchy.fetchAllCopiedSync { realm ->
- realm.where()
- }.map {
- it.toModel()
+ realm.where()
+ }.mapNotNull {
+ AuditTrailMapper.map(it)
}
}
- override fun getOrAddOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody, recipients: Map>): OutgoingRoomKeyRequest? {
+ override fun getOrAddOutgoingRoomKeyRequest(requestBody: RoomKeyRequestBody,
+ recipients: Map>,
+ fromIndex: Int): OutgoingKeyRequest {
// Insert the request and return the one passed in parameter
- var request: OutgoingRoomKeyRequest? = null
+ lateinit var request: OutgoingKeyRequest
doRealmTransaction(realmConfiguration) { realm ->
- val existing = realm.where()
- .equalTo(OutgoingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.KEY.name)
+ val existing = realm.where()
+ .equalTo(OutgoingKeyRequestEntityFields.MEGOLM_SESSION_ID, requestBody.sessionId)
+ .equalTo(OutgoingKeyRequestEntityFields.ROOM_ID, requestBody.roomId)
.findAll()
- .mapNotNull {
- it.toOutgoingGossipingRequest() as? OutgoingRoomKeyRequest
- }.firstOrNull {
+ .map {
+ it.toOutgoingKeyRequest()
+ }.also {
+ if (it.size > 1) {
+ // there should be one or zero but not more, worth warning
+ Timber.tag(loggerTag.value).w("There should not be more than one active key request per session")
+ }
+ }
+ .firstOrNull {
it.requestBody?.algorithm == requestBody.algorithm &&
it.requestBody?.sessionId == requestBody.sessionId &&
it.requestBody?.senderKey == requestBody.senderKey &&
@@ -1109,13 +1181,14 @@ internal class RealmCryptoStore @Inject constructor(
}
if (existing == null) {
- request = realm.createObject(OutgoingGossipingRequestEntity::class.java).apply {
+ request = realm.createObject(OutgoingKeyRequestEntity::class.java).apply {
this.requestId = RequestIdHelper.createUniqueRequestId()
this.setRecipients(recipients)
- this.requestState = OutgoingGossipingRequestState.UNSENT
- this.type = GossipRequestType.KEY
- this.requestedInfoStr = requestBody.toJson()
- }.toOutgoingGossipingRequest() as? OutgoingRoomKeyRequest
+ this.requestedIndex = fromIndex
+ this.requestState = OutgoingRoomKeyRequestState.UNSENT
+ this.setRequestBody(requestBody)
+ this.creationTimeStamp = clock.epochMillis()
+ }.toOutgoingKeyRequest()
} else {
request = existing
}
@@ -1123,284 +1196,175 @@ internal class RealmCryptoStore @Inject constructor(
return request
}
- override fun getOrAddOutgoingSecretShareRequest(secretName: String, recipients: Map>): OutgoingSecretRequest? {
- var request: OutgoingSecretRequest? = null
-
- // Insert the request and return the one passed in parameter
+ override fun updateOutgoingRoomKeyRequestState(requestId: String, newState: OutgoingRoomKeyRequestState) {
doRealmTransaction(realmConfiguration) { realm ->
- val existing = realm.where()
- .equalTo(OutgoingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.SECRET.name)
- .equalTo(OutgoingGossipingRequestEntityFields.REQUESTED_INFO_STR, secretName)
- .findAll()
- .mapNotNull {
- it.toOutgoingGossipingRequest() as? OutgoingSecretRequest
- }.firstOrNull()
- if (existing == null) {
- request = realm.createObject(OutgoingGossipingRequestEntity::class.java).apply {
- this.type = GossipRequestType.SECRET
- setRecipients(recipients)
- this.requestState = OutgoingGossipingRequestState.UNSENT
- this.requestId = RequestIdHelper.createUniqueRequestId()
- this.requestedInfoStr = secretName
- }.toOutgoingGossipingRequest() as? OutgoingSecretRequest
- } else {
- request = existing
- }
- }
-
- return request
- }
-
- override fun saveGossipingEvents(events: List) {
- monarchy.writeAsync { realm ->
- val now = System.currentTimeMillis()
- events.forEach { event ->
- val ageLocalTs = event.unsignedData?.age?.let { now - it } ?: now
- val entity = GossipingEventEntity(
- type = event.type,
- sender = event.senderId,
- ageLocalTs = ageLocalTs,
- content = ContentMapper.map(event.content)
- ).apply {
- sendState = SendState.SYNCED
- decryptionResultJson = MoshiProvider.providesMoshi().adapter(OlmDecryptionResult::class.java).toJson(event.mxDecryptionResult)
- decryptionErrorCode = event.mCryptoError?.name
- }
- realm.insertOrUpdate(entity)
- }
- }
- }
-
-// override fun getOutgoingRoomKeyRequestByState(states: Set): OutgoingRoomKeyRequest? {
-// val statesIndex = states.map { it.ordinal }.toTypedArray()
-// return doRealmQueryAndCopy(realmConfiguration) { realm ->
-// realm.where()
-// .equalTo(GossipingEventEntityFields.SENDER, credentials.userId)
-// .findAll()
-// .filter {entity ->
-// states.any { it == entity.requestState}
-// }
-// }.mapNotNull {
-// ContentMapper.map(it.content)?.toModel()
-// }
-// ?.toOutgoingRoomKeyRequest()
-// }
-//
-// override fun getOutgoingSecretShareRequestByState(states: Set): OutgoingSecretRequest? {
-// val statesIndex = states.map { it.ordinal }.toTypedArray()
-// return doRealmQueryAndCopy(realmConfiguration) {
-// it.where()
-// .`in`(OutgoingSecretRequestEntityFields.STATE, statesIndex)
-// .findFirst()
-// }
-// ?.toOutgoingSecretRequest()
-// }
-
-// override fun updateOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest) {
-// doRealmTransaction(realmConfiguration) {
-// val obj = OutgoingRoomKeyRequestEntity().apply {
-// requestId = request.requestId
-// cancellationTxnId = request.cancellationTxnId
-// state = request.state.ordinal
-// putRecipients(request.recipients)
-// putRequestBody(request.requestBody)
-// }
-//
-// it.insertOrUpdate(obj)
-// }
-// }
-
-// override fun deleteOutgoingRoomKeyRequest(transactionId: String) {
-// doRealmTransaction(realmConfiguration) {
-// it.where()
-// .equalTo(OutgoingRoomKeyRequestEntityFields.REQUEST_ID, transactionId)
-// .findFirst()
-// ?.deleteFromRealm()
-// }
-// }
-
-// override fun storeIncomingRoomKeyRequest(incomingRoomKeyRequest: IncomingRoomKeyRequest?) {
-// if (incomingRoomKeyRequest == null) {
-// return
-// }
-//
-// doRealmTransaction(realmConfiguration) {
-// // Delete any previous store request with the same parameters
-// it.where()
-// .equalTo(IncomingRoomKeyRequestEntityFields.USER_ID, incomingRoomKeyRequest.userId)
-// .equalTo(IncomingRoomKeyRequestEntityFields.DEVICE_ID, incomingRoomKeyRequest.deviceId)
-// .equalTo(IncomingRoomKeyRequestEntityFields.REQUEST_ID, incomingRoomKeyRequest.requestId)
-// .findAll()
-// .deleteAllFromRealm()
-//
-// // Then store it
-// it.createObject(IncomingRoomKeyRequestEntity::class.java).apply {
-// userId = incomingRoomKeyRequest.userId
-// deviceId = incomingRoomKeyRequest.deviceId
-// requestId = incomingRoomKeyRequest.requestId
-// putRequestBody(incomingRoomKeyRequest.requestBody)
-// }
-// }
-// }
-
-// override fun deleteIncomingRoomKeyRequest(incomingRoomKeyRequest: IncomingShareRequestCommon) {
-// doRealmTransaction(realmConfiguration) {
-// it.where()
-// .equalTo(GossipingEventEntityFields.TYPE, EventType.ROOM_KEY_REQUEST)
-// .notEqualTo(GossipingEventEntityFields.SENDER, credentials.userId)
-// .findAll()
-// .filter {
-// ContentMapper.map(it.content).toModel()?.let {
-//
-// }
-// }
-// // .equalTo(IncomingRoomKeyRequestEntityFields.USER_ID, incomingRoomKeyRequest.userId)
-// // .equalTo(IncomingRoomKeyRequestEntityFields.DEVICE_ID, incomingRoomKeyRequest.deviceId)
-// // .equalTo(IncomingRoomKeyRequestEntityFields.REQUEST_ID, incomingRoomKeyRequest.requestId)
-// // .findAll()
-// // .deleteAllFromRealm()
-// }
-// }
-
- override fun updateGossipingRequestState(requestUserId: String?,
- requestDeviceId: String?,
- requestId: String?,
- state: GossipingRequestState) {
- doRealmTransaction(realmConfiguration) { realm ->
- realm.where()
- .equalTo(IncomingGossipingRequestEntityFields.OTHER_USER_ID, requestUserId)
- .equalTo(IncomingGossipingRequestEntityFields.OTHER_DEVICE_ID, requestDeviceId)
- .equalTo(IncomingGossipingRequestEntityFields.REQUEST_ID, requestId)
- .findAll().forEach {
- it.requestState = state
- }
- }
- }
-
- override fun updateOutgoingGossipingRequestState(requestId: String, state: OutgoingGossipingRequestState) {
- doRealmTransaction(realmConfiguration) { realm ->
- realm.where()
- .equalTo(OutgoingGossipingRequestEntityFields.REQUEST_ID, requestId)
- .findAll().forEach {
- it.requestState = state
- }
- }
- }
-
- override fun getIncomingRoomKeyRequest(userId: String, deviceId: String, requestId: String): IncomingRoomKeyRequest? {
- return doWithRealm(realmConfiguration) { realm ->
- realm.where()
- .equalTo(IncomingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.KEY.name)
- .equalTo(IncomingGossipingRequestEntityFields.OTHER_DEVICE_ID, deviceId)
- .equalTo(IncomingGossipingRequestEntityFields.OTHER_USER_ID, userId)
- .findAll()
- .mapNotNull { entity ->
- entity.toIncomingGossipingRequest() as? IncomingRoomKeyRequest
- }
- .firstOrNull()
- }
- }
-
- override fun getPendingIncomingRoomKeyRequests(): List {
- return doWithRealm(realmConfiguration) {
- it.where()
- .equalTo(IncomingGossipingRequestEntityFields.TYPE_STR, GossipRequestType.KEY.name)
- .equalTo(IncomingGossipingRequestEntityFields.REQUEST_STATE_STR, GossipingRequestState.PENDING.name)
- .findAll()
- .map { entity ->
- IncomingRoomKeyRequest(
- userId = entity.otherUserId,
- deviceId = entity.otherDeviceId,
- requestId = entity.requestId,
- requestBody = entity.getRequestedKeyInfo(),
- localCreationTimestamp = entity.localCreationTimestamp
- )
- }
- }
- }
-
- override fun getPendingIncomingGossipingRequests(): List
](https://play.google.com/store/apps/details?id=im.vector.app)
[
](https://f-droid.org/app/im.vector.app)
-Nightly build: [](https://buildkite.com/matrix-dot-org/element-android/builds?branch=develop) Nighly test status: [](https://github.com/vector-im/element-android/actions/workflows/nightly.yml)
+Nightly build: [](https://buildkite.com/matrix-dot-org/element-android/builds?branch=develop) Nightly test status: [](https://github.com/vector-im/element-android/actions/workflows/nightly.yml)
# New Android SDK
@@ -53,3 +53,4 @@ Come chat with the community in the dedicated Matrix [room](https://matrix.to/#/
Issues are triaged by community members and the Android App Team, following the [triage process](https://github.com/vector-im/element-meta/wiki/Triage-process).
We use [issue labels](https://github.com/vector-im/element-meta/wiki/Issue-labelling) to sort all incoming issues.
+
diff --git a/build.gradle b/build.gradle
index 1d86f482da..fa26638015 100644
--- a/build.gradle
+++ b/build.gradle
@@ -5,10 +5,17 @@ buildscript {
apply from: 'dependencies_groups.gradle'
repositories {
- google()
+ // Do not use `google()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://maven.google.com'
+ }
maven {
url "https://plugins.gradle.org/m2/"
}
+ // Do not use `mavenCentral()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://repo1.maven.org/maven2'
+ }
}
dependencies {
@@ -47,7 +54,9 @@ allprojects {
apply plugin: "org.jlleitschuh.gradle.ktlint"
repositories {
- mavenCentral {
+ // Do not use `mavenCentral()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://repo1.maven.org/maven2'
content {
groups.mavenCentral.regex.each { includeGroupByRegex it }
groups.mavenCentral.group.each { includeGroup it }
@@ -70,14 +79,18 @@ allprojects {
groups.jitsi.group.each { includeGroup it }
}
}
- google {
+ // Do not use `google()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://maven.google.com'
content {
groups.google.regex.each { includeGroupByRegex it }
groups.google.group.each { includeGroup it }
}
}
//noinspection JcenterRepositoryObsolete
- jcenter {
+ // Do not use `jcenter`, it prevents Dependabot from working properly
+ maven {
+ url 'https://jcenter.bintray.com'
content {
groups.jcenter.regex.each { includeGroupByRegex it }
groups.jcenter.group.each { includeGroup it }
diff --git a/changelog.d/46312.misc b/changelog.d/46312.misc
new file mode 100644
index 0000000000..5e0112372f
--- /dev/null
+++ b/changelog.d/46312.misc
@@ -0,0 +1 @@
+Notify the user for each new message
diff --git a/changelog.d/5151.misc b/changelog.d/5151.misc
new file mode 100644
index 0000000000..b785c4229c
--- /dev/null
+++ b/changelog.d/5151.misc
@@ -0,0 +1 @@
+Improve threads rendering in the main timeline
diff --git a/changelog.d/5421.bugfix b/changelog.d/5421.bugfix
deleted file mode 100644
index 2f9a1c0b1c..0000000000
--- a/changelog.d/5421.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixes crash when accepting or receiving VOIP calls
diff --git a/changelog.d/5494.feature b/changelog.d/5494.feature
new file mode 100644
index 0000000000..59b8a78a2c
--- /dev/null
+++ b/changelog.d/5494.feature
@@ -0,0 +1 @@
+Use key backup before requesting keys + refactor & improvement of key request/forward
\ No newline at end of file
diff --git a/changelog.d/5559.sdk b/changelog.d/5559.sdk
new file mode 100644
index 0000000000..2466fcef48
--- /dev/null
+++ b/changelog.d/5559.sdk
@@ -0,0 +1,4 @@
+- New API to enable/disable key forwarding CryptoService#enableKeyGossiping()
+- New API to limit room key request only to own devices MXCryptoConfig#limitRoomKeyRequestsToMyDevices
+- Event Trail API has changed, now using AuditTrail events
+- New API to manually accept an incoming key request CryptoService#manuallyAcceptRoomKeyRequest()
diff --git a/changelog.d/5575.sdk b/changelog.d/5575.sdk
deleted file mode 100644
index 19339bdce2..0000000000
--- a/changelog.d/5575.sdk
+++ /dev/null
@@ -1,2 +0,0 @@
-- Added registrationCustom into RegistrationWizard to send custom auth params for sign up
-- Moved terms converter into api package to make it accessible in sdk
\ No newline at end of file
diff --git a/changelog.d/5592.bugfix b/changelog.d/5592.bugfix
deleted file mode 100644
index f0df3dc646..0000000000
--- a/changelog.d/5592.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Improve/fix crashes on messages decryption
diff --git a/changelog.d/5652.bugfix b/changelog.d/5652.bugfix
deleted file mode 100644
index 8ebea1558f..0000000000
--- a/changelog.d/5652.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Tentative fix of images crashing when being sent or shared from gallery
diff --git a/changelog.d/5721.bugfix b/changelog.d/5721.bugfix
deleted file mode 100644
index 8b752b43a9..0000000000
--- a/changelog.d/5721.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Improving deactivation experience along with a crash fix
\ No newline at end of file
diff --git a/changelog.d/5772.feature b/changelog.d/5772.feature
deleted file mode 100644
index 85eec0a1ad..0000000000
--- a/changelog.d/5772.feature
+++ /dev/null
@@ -1 +0,0 @@
-Improve management of ignored users
\ No newline at end of file
diff --git a/changelog.d/5773.misc b/changelog.d/5773.misc
deleted file mode 100644
index 39c8b42073..0000000000
--- a/changelog.d/5773.misc
+++ /dev/null
@@ -1 +0,0 @@
-Move "Ignored users" setting section into "Security & Privacy"
\ No newline at end of file
diff --git a/changelog.d/5774.misc b/changelog.d/5774.misc
deleted file mode 100644
index 795106381b..0000000000
--- a/changelog.d/5774.misc
+++ /dev/null
@@ -1 +0,0 @@
-Add a picto for ignored users in the room member list screen
\ No newline at end of file
diff --git a/changelog.d/5783.wip b/changelog.d/5783.wip
deleted file mode 100644
index e306c0f217..0000000000
--- a/changelog.d/5783.wip
+++ /dev/null
@@ -1 +0,0 @@
-Reorders the registration steps to prioritise email, then terms for the FTUE onboarding
diff --git a/changelog.d/5805.misc b/changelog.d/5805.misc
deleted file mode 100644
index e0e6a311b4..0000000000
--- a/changelog.d/5805.misc
+++ /dev/null
@@ -1 +0,0 @@
-Autoformats entire project
diff --git a/changelog.d/5811.feature b/changelog.d/5811.feature
deleted file mode 100644
index 12111e323b..0000000000
--- a/changelog.d/5811.feature
+++ /dev/null
@@ -1 +0,0 @@
-VoIP Screen Sharing Permission
\ No newline at end of file
diff --git a/changelog.d/5812.sdk b/changelog.d/5812.sdk
deleted file mode 100644
index 5ddd8cfac1..0000000000
--- a/changelog.d/5812.sdk
+++ /dev/null
@@ -1 +0,0 @@
-Move package `org.matrix.android.sdk.api.pushrules` to `org.matrix.android.sdk.api.session.pushrules`
diff --git a/changelog.d/5814.feature b/changelog.d/5814.feature
deleted file mode 100644
index c892702486..0000000000
--- a/changelog.d/5814.feature
+++ /dev/null
@@ -1 +0,0 @@
-Live location sharing: updating beacon state event content structure
diff --git a/changelog.d/5816.sdk b/changelog.d/5816.sdk
deleted file mode 100644
index 17233c66e5..0000000000
--- a/changelog.d/5816.sdk
+++ /dev/null
@@ -1,2 +0,0 @@
-Some `Session` apis are now available by requesting the service first. For instance `Session.updateAvatar(...)` is now `Session.profileService().updateAvatar(...)`
-The shortcut `Room.search()` has been removed, you have to use `Session.searchService().search()`
diff --git a/changelog.d/5825.bugfix b/changelog.d/5825.bugfix
new file mode 100644
index 0000000000..77560027ba
--- /dev/null
+++ b/changelog.d/5825.bugfix
@@ -0,0 +1 @@
+Changed copy and list order in member profile screen.
\ No newline at end of file
diff --git a/changelog.d/5826.bugfix b/changelog.d/5826.bugfix
deleted file mode 100644
index 2735568f73..0000000000
--- a/changelog.d/5826.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Adds missing suggested tag for rooms in Explore Space
diff --git a/changelog.d/5832.misc b/changelog.d/5832.misc
deleted file mode 100644
index ace9dff5d4..0000000000
--- a/changelog.d/5832.misc
+++ /dev/null
@@ -1 +0,0 @@
-Add a GH workflow to push ElementX issues to the global board.
\ No newline at end of file
diff --git a/changelog.d/5836.doc b/changelog.d/5836.doc
deleted file mode 100644
index 42073d66ef..0000000000
--- a/changelog.d/5836.doc
+++ /dev/null
@@ -1 +0,0 @@
-Update the PR process doc with 2 reviewers and a new reviewer team.
\ No newline at end of file
diff --git a/changelog.d/5847.bugfix b/changelog.d/5847.bugfix
deleted file mode 100644
index acd13dec9a..0000000000
--- a/changelog.d/5847.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixes missing call icons when threads are enabled
diff --git a/changelog.d/5854.doc b/changelog.d/5854.doc
deleted file mode 100644
index 38a1c756af..0000000000
--- a/changelog.d/5854.doc
+++ /dev/null
@@ -1 +0,0 @@
-Improve documentation of the project and of the SDK
diff --git a/changelog.d/5855.sdk b/changelog.d/5855.sdk
deleted file mode 100644
index bad5a11398..0000000000
--- a/changelog.d/5855.sdk
+++ /dev/null
@@ -1 +0,0 @@
-- Add return type to RoomApi.sendStateEvent() to retrieve the created event id
diff --git a/changelog.d/5858.sdk b/changelog.d/5858.sdk
deleted file mode 100644
index 9f2e7ef0f2..0000000000
--- a/changelog.d/5858.sdk
+++ /dev/null
@@ -1 +0,0 @@
-`Room` apis are now available by requesting the service first. For instance `Room.updateAvatar(...)` is now `Room.stateService().updateAvatar(...)`
diff --git a/changelog.d/5862.wip b/changelog.d/5862.wip
deleted file mode 100644
index 303a054c5e..0000000000
--- a/changelog.d/5862.wip
+++ /dev/null
@@ -1 +0,0 @@
-[Live location sharing] Improve aggregation process of events
diff --git a/changelog.d/5871.bugfix b/changelog.d/5871.bugfix
deleted file mode 100644
index b223ddd141..0000000000
--- a/changelog.d/5871.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fix UX freezing when creating secure backup
diff --git a/changelog.d/5872.misc b/changelog.d/5872.misc
deleted file mode 100644
index 1e15229800..0000000000
--- a/changelog.d/5872.misc
+++ /dev/null
@@ -1 +0,0 @@
-Faster Olm decrypt when there is a lot of existing sessions
diff --git a/changelog.d/5886.bugfix b/changelog.d/5886.bugfix
deleted file mode 100644
index c4239e5c3a..0000000000
--- a/changelog.d/5886.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fix UISIDetector grace period bug
diff --git a/changelog.d/5890.sdk b/changelog.d/5890.sdk
deleted file mode 100644
index 0d5e8d783d..0000000000
--- a/changelog.d/5890.sdk
+++ /dev/null
@@ -1 +0,0 @@
-Remove unecessary field `eventId` from `EventAnnotationsSummary` and `ReferencesAggregatedSummary`
diff --git a/changelog.d/5911.feature b/changelog.d/5911.feature
new file mode 100644
index 0000000000..368a3b4056
--- /dev/null
+++ b/changelog.d/5911.feature
@@ -0,0 +1 @@
+Screen sharing over WebRTC
diff --git a/changelog.d/5925.bugfix b/changelog.d/5925.bugfix
deleted file mode 100644
index eff0c17a5c..0000000000
--- a/changelog.d/5925.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixes crash on android api 21/22 devices when opening messages due to Konfetti library
diff --git a/changelog.d/5936.feature b/changelog.d/5936.feature
new file mode 100644
index 0000000000..cbf14aaba1
--- /dev/null
+++ b/changelog.d/5936.feature
@@ -0,0 +1 @@
+Added themed launch icons for Android 13
\ No newline at end of file
diff --git a/changelog.d/5941.bugfix b/changelog.d/5941.bugfix
new file mode 100644
index 0000000000..0ea17668c6
--- /dev/null
+++ b/changelog.d/5941.bugfix
@@ -0,0 +1 @@
+If animations are disable on the System, chat effects and confetti will be disabled too
diff --git a/changelog.d/5953.misc b/changelog.d/5953.misc
new file mode 100644
index 0000000000..a3ad5dae93
--- /dev/null
+++ b/changelog.d/5953.misc
@@ -0,0 +1 @@
+Reformatted project code
diff --git a/changelog.d/5965.sdk b/changelog.d/5965.sdk
new file mode 100644
index 0000000000..5bb6c3aac4
--- /dev/null
+++ b/changelog.d/5965.sdk
@@ -0,0 +1 @@
+Including SSL/TLS error handing when doing WellKnown lookups without a custom HomeServerConnectionConfig
diff --git a/changelog.d/5997.misc b/changelog.d/5997.misc
new file mode 100644
index 0000000000..328f3c0079
--- /dev/null
+++ b/changelog.d/5997.misc
@@ -0,0 +1 @@
+Update check for server-side threads support to match spec.
diff --git a/dependencies.gradle b/dependencies.gradle
index 7666a3bf9f..90990810a4 100644
--- a/dependencies.gradle
+++ b/dependencies.gradle
@@ -7,26 +7,26 @@ ext.versions = [
'targetCompat' : JavaVersion.VERSION_11,
]
-def gradle = "7.0.4"
+def gradle = "7.2.0"
// Ref: https://kotlinlang.org/releases.html
-def kotlin = "1.6.0"
+def kotlin = "1.6.21"
def kotlinCoroutines = "1.6.0"
-def dagger = "2.40.5"
+def dagger = "2.42"
def retrofit = "2.9.0"
def arrow = "0.8.2"
def markwon = "4.6.2"
def moshi = "1.13.0"
-def lifecycle = "2.4.0"
+def lifecycle = "2.4.1"
def flowBinding = "1.2.0"
def epoxy = "4.6.2"
-def mavericks = "2.5.0"
-def glide = "4.12.0"
+def mavericks = "2.6.1"
+def glide = "4.13.2"
def bigImageViewer = "1.8.1"
-def jjwt = "0.11.2"
-def vanniktechEmoji = "0.8.0"
+def jjwt = "0.11.5"
+def vanniktechEmoji = "0.9.0"
// Testing
-def mockk = "1.12.1"
+def mockk = "1.12.4"
def espresso = "3.4.0"
def androidxTest = "1.4.0"
def androidxOrchestrator = "1.4.1"
@@ -45,15 +45,15 @@ ext.libs = [
'coroutinesTest' : "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlinCoroutines"
],
androidx : [
- 'appCompat' : "androidx.appcompat:appcompat:1.4.0",
+ 'appCompat' : "androidx.appcompat:appcompat:1.4.1",
'core' : "androidx.core:core-ktx:1.7.0",
'recyclerview' : "androidx.recyclerview:recyclerview:1.2.1",
'exifinterface' : "androidx.exifinterface:exifinterface:1.3.3",
- 'fragmentKtx' : "androidx.fragment:fragment-ktx:1.4.0",
- 'constraintLayout' : "androidx.constraintlayout:constraintlayout:2.1.2",
+ 'fragmentKtx' : "androidx.fragment:fragment-ktx:1.4.1",
+ 'constraintLayout' : "androidx.constraintlayout:constraintlayout:2.1.3",
'work' : "androidx.work:work-runtime-ktx:2.7.1",
'autoFill' : "androidx.autofill:autofill:1.1.0",
- 'preferenceKtx' : "androidx.preference:preference-ktx:1.1.1",
+ 'preferenceKtx' : "androidx.preference:preference-ktx:1.2.0",
'junit' : "androidx.test.ext:junit:1.1.3",
'lifecycleCommon' : "androidx.lifecycle:lifecycle-common:$lifecycle",
'lifecycleLivedata' : "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle",
@@ -72,7 +72,7 @@ ext.libs = [
'espressoIntents' : "androidx.test.espresso:espresso-intents:$espresso"
],
google : [
- 'material' : "com.google.android.material:material:1.5.0"
+ 'material' : "com.google.android.material:material:1.6.0"
],
dagger : [
'dagger' : "com.google.dagger:dagger:$dagger",
diff --git a/docs/ui-tests.md b/docs/ui-tests.md
index 05eb50f525..667a6ed7fb 100644
--- a/docs/ui-tests.md
+++ b/docs/ui-tests.md
@@ -176,4 +176,4 @@ class SettingsAdvancedRobot {
clickOn(R.string.settings_developer_mode_summary)
}
}
-```
\ No newline at end of file
+```
diff --git a/fastlane/metadata/android/cs-CZ/changelogs/40104100.txt b/fastlane/metadata/android/cs-CZ/changelogs/40104100.txt
new file mode 100644
index 0000000000..46a75b77a7
--- /dev/null
+++ b/fastlane/metadata/android/cs-CZ/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Hlavní změny v této verzi: Posun přehrávání v hlasových zprávách. Opravy různých chyb a vylepšení stability.
+Úplný seznam změn: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/cs-CZ/changelogs/40104110.txt b/fastlane/metadata/android/cs-CZ/changelogs/40104110.txt
new file mode 100644
index 0000000000..578549ce6c
--- /dev/null
+++ b/fastlane/metadata/android/cs-CZ/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Hlavní změny v této verzi: Opravy různých chyb a vylepšení stability.
+Úplný seznam změn: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/en-US/changelogs/40104140.txt b/fastlane/metadata/android/en-US/changelogs/40104140.txt
new file mode 100644
index 0000000000..5cbd25f4d3
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/40104140.txt
@@ -0,0 +1,2 @@
+Main changes in this version: Improve management of ignored users. Various bug fixes and stability improvements.
+Full changelog: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/es-ES/changelogs/40103030.txt b/fastlane/metadata/android/es-ES/changelogs/40103030.txt
new file mode 100644
index 0000000000..36f59a2308
--- /dev/null
+++ b/fastlane/metadata/android/es-ES/changelogs/40103030.txt
@@ -0,0 +1,2 @@
+Cambios principales en esta versión: Hacer la política de servidores de indentidad visible en los ajusted. Temporalmente quitar soporte para Android Auto.
+Registro de cambios: https://github.com/vector-im/element-android/releases/tag/v1.3.3
diff --git a/fastlane/metadata/android/es-ES/changelogs/40104110.txt b/fastlane/metadata/android/es-ES/changelogs/40104110.txt
new file mode 100644
index 0000000000..281df19388
--- /dev/null
+++ b/fastlane/metadata/android/es-ES/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Cambios principales en esta versión: Varias correciones de bugs y mejoras en la estabilidad
+Registro de cambios: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/es-ES/full_description.txt b/fastlane/metadata/android/es-ES/full_description.txt
index fdba15e90e..0e484158d9 100644
--- a/fastlane/metadata/android/es-ES/full_description.txt
+++ b/fastlane/metadata/android/es-ES/full_description.txt
@@ -37,3 +37,6 @@ Mensajería, llamadas de voz y video, uso compartido de archivos, uso compartido
Continúa donde lo dejaste
Manténgase en contacto donde quiera que esté con el historial de mensajes totalmente sincronizado en todos sus dispositivos y en la web en https://app.element.io
+
+Código abierto
+Element Android es un proyecto de código abierto, alojado en GitHub. Porfavor, reporta bugs y problemas en esta dirección: https://github.com/vector-im/element-android
diff --git a/fastlane/metadata/android/et/changelogs/40104100.txt b/fastlane/metadata/android/et/changelogs/40104100.txt
new file mode 100644
index 0000000000..b164935ba4
--- /dev/null
+++ b/fastlane/metadata/android/et/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Põhilised muutused selles versioonis: kerimine häälsõnumites ning erinevate vigade parandused ja stabiilsust edendavad kohendused.
+Kogu ingliskeelne muudatuste logi: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/et/changelogs/40104110.txt b/fastlane/metadata/android/et/changelogs/40104110.txt
new file mode 100644
index 0000000000..1df5ac4176
--- /dev/null
+++ b/fastlane/metadata/android/et/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Põhilised muutused selles versioonis: erinevate vigade parandused ja stabiilsust edendavad kohendused.
+Kogu ingliskeelne muudatuste logi: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/fa/changelogs/40104100.txt b/fastlane/metadata/android/fa/changelogs/40104100.txt
new file mode 100644
index 0000000000..e7cdca6641
--- /dev/null
+++ b/fastlane/metadata/android/fa/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+تغییرات عمده در این نگارش: لغزش در پیامهای صوتی. رفع اشکالهای مختلف و بهبودهای امنیتی.
+گزارش دگرگونی کامل: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/fa/changelogs/40104110.txt b/fastlane/metadata/android/fa/changelogs/40104110.txt
new file mode 100644
index 0000000000..29efb95925
--- /dev/null
+++ b/fastlane/metadata/android/fa/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+تغییرات عمده در این نگارش: رفع اشکالهای مختلف و بهبودهای پایداری.
+گزارش دگرگونی کامل: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/id/changelogs/40104100.txt b/fastlane/metadata/android/id/changelogs/40104100.txt
new file mode 100644
index 0000000000..3cda40aecc
--- /dev/null
+++ b/fastlane/metadata/android/id/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Perubahan utama dalam versi ini: Gulir di pesan suara. Banyak perbaikan kutu dan perbaikan stabilitas.
+Catatan perubahan lanjutan: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/id/changelogs/40104110.txt b/fastlane/metadata/android/id/changelogs/40104110.txt
new file mode 100644
index 0000000000..1017951d47
--- /dev/null
+++ b/fastlane/metadata/android/id/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Perubahan utama dalam versi ini: Banyak perbaikan kutu dan perbaikan stabilitas.
+Catatan perubahan lanjutan: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/it-IT/changelogs/40104100.txt b/fastlane/metadata/android/it-IT/changelogs/40104100.txt
new file mode 100644
index 0000000000..6376e6c45a
--- /dev/null
+++ b/fastlane/metadata/android/it-IT/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Modifiche principali in questa versione: scorrimento nei vocali. Varie correzioni e miglioramenti della stabilità.
+Cronologia completa: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/it-IT/changelogs/40104110.txt b/fastlane/metadata/android/it-IT/changelogs/40104110.txt
new file mode 100644
index 0000000000..556a6fc7ea
--- /dev/null
+++ b/fastlane/metadata/android/it-IT/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Modifiche principali in questa versione: varie correzioni di errori e miglioramenti della stabilità.
+Cronologia completa: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/lo/changelogs/40100100.txt b/fastlane/metadata/android/lo/changelogs/40100100.txt
new file mode 100644
index 0000000000..fe0ee08327
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100100.txt
@@ -0,0 +1,2 @@
+ສະບັບໃຫມ່ນີ້ສ່ວນໃຫຍ່ແມ່ນມີການແກ້ໄຂແລະການປັບປຸງ bug. ຕອນນີ້ການສົ່ງຂໍ້ຄວາມແມ່ນໄວຂຶ້ນຫຼາຍ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.10
diff --git a/fastlane/metadata/android/lo/changelogs/40100110.txt b/fastlane/metadata/android/lo/changelogs/40100110.txt
new file mode 100644
index 0000000000..69139783ad
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100110.txt
@@ -0,0 +1,2 @@
+ຮຸ່ນໃຫມ່ນີ້ສ່ວນໃຫຍ່ແມ່ນປະກອບດ້ວຍໜ້າຕາແອັບແລະການປັບປຸງປະສົບການຂອງຜູ້ໃຊ້. ດຽວນີ້ທ່ານສາມາດເຊີນໝູ່, ແລະສ້າງການສົນທະນາກົງໄດ້ໄວຂຶ້ນໂດຍການສະແກນລະຫັດ QR.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.11
diff --git a/fastlane/metadata/android/lo/changelogs/40100120.txt b/fastlane/metadata/android/lo/changelogs/40100120.txt
new file mode 100644
index 0000000000..256cd1a437
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100120.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຕົວຢ່າງ URL, ແປ້ນພິມ Emoji ໃໝ່, ຄວາມສາມາດໃນການຕັ້ງຄ່າຫ້ອງໃໝ່, ແລະຫິມະສຳລັບວັນຄຣິດສະມາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.12
diff --git a/fastlane/metadata/android/lo/changelogs/40100130.txt b/fastlane/metadata/android/lo/changelogs/40100130.txt
new file mode 100644
index 0000000000..c4878ea5f6
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100130.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຕົວຢ່າງ URL, ແປ້ນພິມ Emoji ໃໝ່, ຄວາມສາມາດໃນການຕັ້ງຄ່າຫ້ອງໃໝ່, ແລະຫິມະສຳລັບວັນຄຣິດສະມາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.13
diff --git a/fastlane/metadata/android/lo/changelogs/40100140.txt b/fastlane/metadata/android/lo/changelogs/40100140.txt
new file mode 100644
index 0000000000..591b9b94b3
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100140.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂການອະນຸຍາດຫ້ອງ, ຮູບແບບ ແຈ້ງ / ມືດອັດຕະໂນມັດ, ແລະການແກ້ໄຂບັນຫາຈຳນວນໜຶ່ງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.14
diff --git a/fastlane/metadata/android/lo/changelogs/40100150.txt b/fastlane/metadata/android/lo/changelogs/40100150.txt
new file mode 100644
index 0000000000..98577742c7
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100150.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຮັບຮອງການເຂົ້າລະບົບດ້ວຍສື່ສັງຄົມອອນລາຍ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.15
diff --git a/fastlane/metadata/android/lo/changelogs/40100160.txt b/fastlane/metadata/android/lo/changelogs/40100160.txt
new file mode 100644
index 0000000000..c369fc88d3
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100160.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຮັບຮອງການເຂົ້າລະບົບດ້ວຍສື່ສັງຄົມອອນລາຍ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.15 and https://github.com/vector-im/element-android/releases/tag/v1.0.16
diff --git a/fastlane/metadata/android/lo/changelogs/40100170.txt b/fastlane/metadata/android/lo/changelogs/40100170.txt
new file mode 100644
index 0000000000..776e1b6082
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40100170.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂຂໍ້ຜິດພາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.0.17
diff --git a/fastlane/metadata/android/lo/changelogs/40101000.txt b/fastlane/metadata/android/lo/changelogs/40101000.txt
new file mode 100644
index 0000000000..f7d621404a
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101000.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ປັບປຸງປະສິດທິພາບຂອງ VoIP (ໂທສຽງ ແລະໂທວີດີໂອໃນການສົນທະນາກົງ) ແລະແກ້ໄຂຂໍ້ຜິດພາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.0
diff --git a/fastlane/metadata/android/lo/changelogs/40101010.txt b/fastlane/metadata/android/lo/changelogs/40101010.txt
new file mode 100644
index 0000000000..e2e1778b7a
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101010.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ປັບປຸງປະສິດທິພາບ ແລະແກ້ໄຂຂໍ້ຜິດພາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.1
diff --git a/fastlane/metadata/android/lo/changelogs/40101020.txt b/fastlane/metadata/android/lo/changelogs/40101020.txt
new file mode 100644
index 0000000000..581db95e90
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101020.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ປັບປຸງປະສິດທິພາບ ແລະແກ້ໄຂຂໍ້ຜິດພາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.2
diff --git a/fastlane/metadata/android/lo/changelogs/40101030.txt b/fastlane/metadata/android/lo/changelogs/40101030.txt
new file mode 100644
index 0000000000..46d861995f
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101030.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ປັບປຸງປະສິດທິພາບ ແລະແກ້ໄຂຂໍ້ຜິດພາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.3
diff --git a/fastlane/metadata/android/lo/changelogs/40101040.txt b/fastlane/metadata/android/lo/changelogs/40101040.txt
new file mode 100644
index 0000000000..8ea7cac4f4
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101040.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ປັບປຸງປະສິດທິພາບ ແລະແກ້ໄຂຂໍ້ຜິດພາດ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.4
diff --git a/fastlane/metadata/android/lo/changelogs/40101050.txt b/fastlane/metadata/android/lo/changelogs/40101050.txt
new file mode 100644
index 0000000000..2823c04b06
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101050.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການແກ້ບັນຫາດ່ວນສໍາລັບ 1.1.4
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.5
diff --git a/fastlane/metadata/android/lo/changelogs/40101060.txt b/fastlane/metadata/android/lo/changelogs/40101060.txt
new file mode 100644
index 0000000000..0cdea9e2c7
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101060.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການແກ້ບັນຫາດ່ວນສໍາລັບ 1.1.5
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.6
diff --git a/fastlane/metadata/android/lo/changelogs/40101070.txt b/fastlane/metadata/android/lo/changelogs/40101070.txt
new file mode 100644
index 0000000000..08926229f9
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101070.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຮອງຮັບເບຕ້າສຳລັບ Spaces. ບີບອັດວິດີໂອກ່ອນທີ່ຈະສົ່ງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.7
diff --git a/fastlane/metadata/android/lo/changelogs/40101080.txt b/fastlane/metadata/android/lo/changelogs/40101080.txt
new file mode 100644
index 0000000000..f2947aae63
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101080.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປັບປຸງສໍາລັບ Spaces.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.8
diff --git a/fastlane/metadata/android/lo/changelogs/40101090.txt b/fastlane/metadata/android/lo/changelogs/40101090.txt
new file mode 100644
index 0000000000..129f86c562
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101090.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮັບຮອງສໍາລັບເຄືອຂ່າຍ gitter.im.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.9
diff --git a/fastlane/metadata/android/lo/changelogs/40101100.txt b/fastlane/metadata/android/lo/changelogs/40101100.txt
new file mode 100644
index 0000000000..337137d3bc
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101100.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ອັບເດດຮູບແບບສີສັນ ແລະຮູບແບບສີສັນ ແລະຄຸນສົມບັດໃໝ່ສຳລັບຊ່ອງຫວ່າງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.10
diff --git a/fastlane/metadata/android/lo/changelogs/40101110.txt b/fastlane/metadata/android/lo/changelogs/40101110.txt
new file mode 100644
index 0000000000..f95972eaa9
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101110.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ອັບເດດຮູບແບບສີສັນ ແລະຮູບແບບສີສັນ ແລະຄຸນສົມບັດໃໝ່ສຳລັບຊ່ອງຫວ່າງ (bugfix ສຳລັບ 1.1.10)
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.11
diff --git a/fastlane/metadata/android/lo/changelogs/40101120.txt b/fastlane/metadata/android/lo/changelogs/40101120.txt
new file mode 100644
index 0000000000..a613e176aa
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101120.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ອັບເດດຮູບແບບສີສັນ ແລະຮູບແບບ ແລະແກ້ໄຂການຂັດຂ້ອງຫຼັງຈາກການໂທວິດີໂອ
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.12
diff --git a/fastlane/metadata/android/lo/changelogs/40101130.txt b/fastlane/metadata/android/lo/changelogs/40101130.txt
new file mode 100644
index 0000000000..3cc85bc6f8
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101130.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັນຫາກ່ຽວຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.13
diff --git a/fastlane/metadata/android/lo/changelogs/40101140.txt b/fastlane/metadata/android/lo/changelogs/40101140.txt
new file mode 100644
index 0000000000..11a5df1059
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101140.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັນຫາກ່ຽວກັບຂໍ້ຄວາມທີ່ຖືກເຂົ້າລະຫັດ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.14
diff --git a/fastlane/metadata/android/lo/changelogs/40101150.txt b/fastlane/metadata/android/lo/changelogs/40101150.txt
new file mode 100644
index 0000000000..8751496a49
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101150.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປະຕິບັດຂໍ້ຄວາມສຽງພາຍໃຕ້ການຕັ້ງຄ່າຫ້ອງທົດລອງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.15
diff --git a/fastlane/metadata/android/lo/changelogs/40101160.txt b/fastlane/metadata/android/lo/changelogs/40101160.txt
new file mode 100644
index 0000000000..c102140102
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40101160.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂຂໍ້ຜິດພາດໃນເວລາສົ່ງຂໍ້ຄວາມເຂົ້າລະຫັດຖ້າມີຄົນຢູ່ໃນຫ້ອງອອກຈາກລະບົບ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.1.16
diff --git a/fastlane/metadata/android/lo/changelogs/40102000.txt b/fastlane/metadata/android/lo/changelogs/40102000.txt
new file mode 100644
index 0000000000..69f1667b93
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40102000.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການສົນທະນາດ້ວຍສຽງເປີດໄວ້ໂດຍມາດຕະຖານ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.2.0
diff --git a/fastlane/metadata/android/lo/changelogs/40102010.txt b/fastlane/metadata/android/lo/changelogs/40102010.txt
new file mode 100644
index 0000000000..237b48ba3b
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40102010.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປັບປຸງຫຼາຍຢ່າງກ່ຽວກັບ VoIP ແລະ Spaces (ຍັງຢູ່ໃນເບຕ້າ).
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.2.1
diff --git a/fastlane/metadata/android/lo/changelogs/40103000.txt b/fastlane/metadata/android/lo/changelogs/40103000.txt
new file mode 100644
index 0000000000..8e386df4a7
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103000.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຈັດລະບຽບຫ້ອງຂອງທ່ານໂດຍໃຊ້ Spaces!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.0
diff --git a/fastlane/metadata/android/lo/changelogs/40103010.txt b/fastlane/metadata/android/lo/changelogs/40103010.txt
new file mode 100644
index 0000000000..0a6a6461fd
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103010.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຈັດລະບຽບຫ້ອງຂອງທ່ານໂດຍໃຊ້ Spaces! v1.3.1 ກຳລັງແກ້ໄຂບັນແອັບໃຊ້ບໍ່ໄດ້ທີ່ສາມາດເກີດຂຶ້ນໃນ v1.3.0.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.1
diff --git a/fastlane/metadata/android/lo/changelogs/40103020.txt b/fastlane/metadata/android/lo/changelogs/40103020.txt
new file mode 100644
index 0000000000..8b9ed12a3a
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103020.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮອງຮັບ Android Auto. ການແກ້ໄຂຍັກຫຼາຍອັນ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.2
diff --git a/fastlane/metadata/android/lo/changelogs/40103030.txt b/fastlane/metadata/android/lo/changelogs/40103030.txt
new file mode 100644
index 0000000000..6374f4fdf5
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103030.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເຮັດໃຫ້ນະໂຍບາຍຂອງເຄື່ອງແມ່ຂ່າຍຢັ້ງຢືນຕົວຕົນ (ຫຼາຍໜ່ວຍ) ໃຫ້ເຫັນຢູ່ໃນການຕັ້ງຄ່າ. ລຶບການຮອງຮັບ Android Auto ອອກຊົ່ວຄາວ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.3
diff --git a/fastlane/metadata/android/lo/changelogs/40103040.txt b/fastlane/metadata/android/lo/changelogs/40103040.txt
new file mode 100644
index 0000000000..896d9190ce
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103040.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮອງຮັບການມີຢູ່, ສໍາລັບຫ້ອງຂໍ້ຄວາມໂດຍກົງ (ໝາຍເຫດ: ການມີຢູ່ຖືກປິດການໃຊ້ງານຢູ່ໃນ matrix.org). ເພີ່ມການຮອງຮັບ Android Auto ອີກຄັ້ງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.4
diff --git a/fastlane/metadata/android/lo/changelogs/40103050.txt b/fastlane/metadata/android/lo/changelogs/40103050.txt
new file mode 100644
index 0000000000..b76db1a80c
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103050.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮອງຮັບການມີຢູ່, ສໍາລັບຫ້ອງຂໍ້ຄວາມໂດຍກົງ (ໝາຍເຫດ: ການມີຢູ່ຖືກປິດການໃຊ້ງານຢູ່ໃນ matrix.org). ເພີ່ມການຮອງຮັບ Android Auto ອີກຄັ້ງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.5
diff --git a/fastlane/metadata/android/lo/changelogs/40103060.txt b/fastlane/metadata/android/lo/changelogs/40103060.txt
new file mode 100644
index 0000000000..2e97183a56
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103060.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮອງຮັບການມີຢູ່, ສໍາລັບຫ້ອງຂໍ້ຄວາມໂດຍກົງ (ໝາຍເຫດ: ການມີຢູ່ຖືກປິດການໃຊ້ງານຢູ່ໃນ matrix.org). ເພີ່ມການຮອງຮັບ Android Auto ອີກຄັ້ງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.6
diff --git a/fastlane/metadata/android/lo/changelogs/40103070.txt b/fastlane/metadata/android/lo/changelogs/40103070.txt
new file mode 100644
index 0000000000..47eb6c7b4d
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103070.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັກສ່ວນໃຫຍ່ກ່ຽວກັບການແຈ້ງເຕືອນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.7-RC2
diff --git a/fastlane/metadata/android/lo/changelogs/40103080.txt b/fastlane/metadata/android/lo/changelogs/40103080.txt
new file mode 100644
index 0000000000..a12d374d20
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103080.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັກ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.8
diff --git a/fastlane/metadata/android/lo/changelogs/40103090.txt b/fastlane/metadata/android/lo/changelogs/40103090.txt
new file mode 100644
index 0000000000..ee93ca0a96
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103090.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮອງຮັບສະບັບຮ່າງການສົນທະນາດ້ວຍສຽງ. ແກ້ໄຂບັກຫຼາຍໆອັນ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.09
diff --git a/fastlane/metadata/android/lo/changelogs/40103100.txt b/fastlane/metadata/android/lo/changelogs/40103100.txt
new file mode 100644
index 0000000000..b8b65387ef
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103100.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການຮອງຮັບແບບສໍາຫຼວດ (ໃນຫ້ອງທົດລອງ). ການອອກແບບຕົວຢ່າງ URL ໃໝ່.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.10
diff --git a/fastlane/metadata/android/lo/changelogs/40103110.txt b/fastlane/metadata/android/lo/changelogs/40103110.txt
new file mode 100644
index 0000000000..f64ee3b469
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103110.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັກ!
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.11
diff --git a/fastlane/metadata/android/lo/changelogs/40103120.txt b/fastlane/metadata/android/lo/changelogs/40103120.txt
new file mode 100644
index 0000000000..a7b8412cfb
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103120.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັກ!.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.12
diff --git a/fastlane/metadata/android/lo/changelogs/40103130.txt b/fastlane/metadata/android/lo/changelogs/40103130.txt
new file mode 100644
index 0000000000..cb725ee68c
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103130.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປ່ຽນແປງຄັ້ງທໍາອິດໃນຫນ້າຈໍເລີ່ມຕົ້ນ, ລວມທັງການວິເຄາະເລືອກເຂົ້າຮ່ວມ. ຮອງຮັບເຫດການທີ່ມີຄະນິດສາດເພີ່ມຢູ່ໃນຫ້ອງທົດລອງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.13
diff --git a/fastlane/metadata/android/lo/changelogs/40103140.txt b/fastlane/metadata/android/lo/changelogs/40103140.txt
new file mode 100644
index 0000000000..1f72757cf1
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103140.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປ່ຽນແປງຄັ້ງທໍາອິດໃນຫນ້າຈໍເລີ່ມຕົ້ນ, ລວມທັງການວິເຄາະເລືອກເຂົ້າຮ່ວມ. ຮອງຮັບເຫດການທີ່ມີຄະນິດສາດເພີ່ມຢູ່ໃນຫ້ອງທົດລອງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.14
diff --git a/fastlane/metadata/android/lo/changelogs/40103150.txt b/fastlane/metadata/android/lo/changelogs/40103150.txt
new file mode 100644
index 0000000000..c11acd15d6
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103150.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປ່ຽນແປງຄັ້ງທໍາອິດໃນຫນ້າຈໍເລີ່ມຕົ້ນ, ລວມທັງການວິເຄາະເລືອກເຂົ້າຮ່ວມ. ຮອງຮັບເຫດການທີ່ມີຄະນິດສາດເພີ່ມຢູ່ໃນຫ້ອງທົດລອງ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.15
diff --git a/fastlane/metadata/android/lo/changelogs/40103160.txt b/fastlane/metadata/android/lo/changelogs/40103160.txt
new file mode 100644
index 0000000000..a17f218463
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103160.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ສົ່ງສະຖານທີ່ຂອງທ່ານໄປຫາຫ້ອງໃດກໍໄດ້. ແກ້ໄຂແບບສຳຫຼວດ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.16
diff --git a/fastlane/metadata/android/lo/changelogs/40103170.txt b/fastlane/metadata/android/lo/changelogs/40103170.txt
new file mode 100644
index 0000000000..b8337a19cc
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103170.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ສົ່ງສະຖານທີ່ຂອງທ່ານໄປຫາຫ້ອງໃດກໍໄດ້. ແກ້ໄຂແບບສຳຫຼວດ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.17
diff --git a/fastlane/metadata/android/lo/changelogs/40103180.txt b/fastlane/metadata/android/lo/changelogs/40103180.txt
new file mode 100644
index 0000000000..e6b65ff812
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40103180.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ສົ່ງສະຖານທີ່ຂອງທ່ານໄປຫາຫ້ອງໃດກໍໄດ້. ແກ້ໄຂແບບສຳຫຼວດ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.3.18
diff --git a/fastlane/metadata/android/lo/changelogs/40104000.txt b/fastlane/metadata/android/lo/changelogs/40104000.txt
new file mode 100644
index 0000000000..9d849da5b7
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104000.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການປະຕິບັດເບື້ອງຕົ້ນຂອງຂໍ້ຄວາມແບບກະທູ້. ຂໍ້ຄວາມຮູບແບບປຸມເປົ້າ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.4.0
diff --git a/fastlane/metadata/android/lo/changelogs/40104020.txt b/fastlane/metadata/android/lo/changelogs/40104020.txt
new file mode 100644
index 0000000000..358ca7fd39
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104020.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເພີ່ມການສະຫນັບສະຫນູນກັບ @room ແລະແບບສໍາຫຼວດທີ່ບໍ່ເປີດເຜີຍໃນບັນດາການປ່ຽນແປງເລັກນ້ອຍອື່ນໆ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.4.2
diff --git a/fastlane/metadata/android/lo/changelogs/40104040.txt b/fastlane/metadata/android/lo/changelogs/40104040.txt
new file mode 100644
index 0000000000..7bfaf76bf2
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104040.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ຕົວສະແດງການພິມ ແລະປັບປັງ IU. ແກ້ໄຂບັກຫຼາຍບ່ອນ ແລະ ປັບປຸງຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.4.4
diff --git a/fastlane/metadata/android/lo/changelogs/40104060.txt b/fastlane/metadata/android/lo/changelogs/40104060.txt
new file mode 100644
index 0000000000..10ae599698
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104060.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ທາມລາຍກະທູ້ ປະຈຸບັນເປັນແບບຖ່າຍທອດສົດ ແລະໄວຂຶ້ນ. ແກ້ໄຂບັກຫຼາຍບ່ອນ ແລະ ປັບປຸງຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.4.6
diff --git a/fastlane/metadata/android/lo/changelogs/40104070.txt b/fastlane/metadata/android/lo/changelogs/40104070.txt
new file mode 100644
index 0000000000..4ede801350
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104070.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ແກ້ໄຂບັກຫຼາຍບ່ອນ ແລະ ປັບປຸງຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases/tag/v1.4.7
diff --git a/fastlane/metadata/android/lo/changelogs/40104080.txt b/fastlane/metadata/android/lo/changelogs/40104080.txt
new file mode 100644
index 0000000000..5d7de22065
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104080.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເລື່ອນໃນຂໍ້ຄວາມສຽງ. ແກ້ໄຂບັກຫຼາຍບ່ອນ ແລະ ປັບປຸງຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/lo/changelogs/40104100.txt b/fastlane/metadata/android/lo/changelogs/40104100.txt
new file mode 100644
index 0000000000..5d7de22065
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ເລື່ອນໃນຂໍ້ຄວາມສຽງ. ແກ້ໄຂບັກຫຼາຍບ່ອນ ແລະ ປັບປຸງຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/lo/changelogs/40104110.txt b/fastlane/metadata/android/lo/changelogs/40104110.txt
new file mode 100644
index 0000000000..edc025cb39
--- /dev/null
+++ b/fastlane/metadata/android/lo/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+ການປ່ຽນແປງຫຼັກໃນສະບັບນີ້: ການແກ້ໄຂ bug ຕ່າງໆແລະການປັບປຸງຄວາມສະຖຽນ.
+ບັນທຶກການປ່ຽນແປງສະບັບເຕັມ: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/lo/full_description.txt b/fastlane/metadata/android/lo/full_description.txt
new file mode 100644
index 0000000000..094c1b57f5
--- /dev/null
+++ b/fastlane/metadata/android/lo/full_description.txt
@@ -0,0 +1,42 @@
+ລະບົບແຊັດນີ້ ມີຄວາມປອດໄພ ແລະເປັນແອັບທີ່ເຮັດຊ່ວຍສົ່ງເສີ່ມການເຮັດວຽກຮ່ວມກັນຢ່າງມີປະສິດທິຜົນໝາະສົມສຳລັບການສົນທະນາກຸ່ມໃນຂະນະທີ່ເຮັດວຽກທາງໄກ. ແອັບສົນທະນານີ້ໃຊ້ການເຂົ້າລະຫັດແບບຕົ້ນທາງຈົນຈົບເພື່ອໃຫ້ການປະຊຸມວິດີໂອທີ່ມີປະສິດທິພາບ, ການແບ່ງປັນໄຟລ໌ ແລະການໂທແບບສຽງ.
+
+ຄຸນສົມບັດຂອງລະບົບລວມມີ:
+- ເຄື່ອງມືການສື່ສານອອນໄລນ໌ແບບລຳ້ໜ້າ
+- ຂໍ້ຄວາມມີການເຂົ້າລະຫັດຢ່າງເຕັມສ່ວນເພື່ອໃຫ້ການສື່ສານຂອງອົງກອນມີຄວາມປອດໄພ, ເຖິງແມ່ນວ່າຈະເຮັດວຽກຈາກທາງໄກ
+- ລະບົບແຊັດແບບແບ່ງກະຈາຍການຄຸ້ມຄອງໂດຍນຳໃຊ້ນະວັດຕະກຳເປີດຂອງລະບົບ Matrix
+- ການແບ່ງປັນໄຟລ໌ຢ່າງປອດໄພກັບຂໍ້ມູນທີ່ເຂົ້າລະຫັດໄວ້ໃນຂະນະທີ່ຈັດການໂຄງການ
+- ວິດີໂອສົນທະນາກັບ Voice over IP ແລະການແບ່ງປັນຫນ້າຈໍ
+- ການເຊື່ອມໂຍງງ່າຍດາຍກັບເຄື່ອງມືການຮ່ວມມືອອນໄລນ໌ຂອງທ່ານ, ເຄື່ອງມືການຄຸ້ມຄອງໂຄງການ, ການບໍລິການ VoIP ແລະຂໍ້ຄວາມອື່ນໆຂອງທີມ
+
+ລະບົບນີ້ແມ່ນແຕກຕ່າງກັນຢ່າງສິ້ນເຊີງຈາກແອັບຯສົ່ງຂໍ້ຄວາມ ແລະແອັບສົ່ງເສີມການຮ່ວມມືອື່ນໆ. ມັນດໍາເນີນການຢູ່ໃນ Matrix, ເຄືອຂ່າຍເປີດສໍາລັບການສົ່ງຂໍ້ຄວາມທີ່ປອດໄພແລະການສື່ສານແບບກະຈາຍການຄຸ້ມຄອງ. ທ່ານສາມາດຕັ້ງສະຖານີດ້ວຍຕົນເອງເພື່ອໃຫ້ຜູ້ໃຊ້ເປັນເຈົ້າຂອງສູງສຸດແລະຄຸ້ມຄອງຂໍ້ມູນແລະຂໍ້ຄວາມຂອງຕົນເອງ.
+
+ຄວາມເປັນສ່ວນຕົວ ແລະຂໍ້ຄວາມເຂົ້າລະຫັດ
+ລະບົບຈະປົກປ້ອງທ່ານຈາກການໂຄສະນາທີ່ບໍ່ຕ້ອງການ, ການຂຸດຄົ້ນຂໍ້ມູນແລະການສ້າງເງື່ອນໄຂປິດລ້ອມ. ລະບົບຍັງຮັບປະກັນຂໍ້ມູນທັງຫມົດຂອງທ່ານ, ການໂທວິດີໂອແບບຫນຶ່ງຕໍ່ຫນຶ່ງແລະການສື່ສານສຽງໂດຍຜ່ານການເຂົ້າລະຫັດແບບຕົ້ນທາງຫາປາຍທາງ ແລະການກວດສອບອຸປະກອນກ່ອນເຊື່ອມຕໍ່.
+
+ລະບົບເຮົາໃຫ້ທ່ານຄວບຄຸມຄວາມເປັນສ່ວນຕົວຂອງທ່ານໃນຂະນະທີ່ອະນຸຍາດໃຫ້ທ່ານຕິດຕໍ່ສື່ສານຢ່າງປອດໄພກັບທຸກຄົນໃນເຄືອຂ່າຍ Matrix, ຫຼືເຄື່ອງມືທີ່ທ່ານຄຸ້ນເຄີຍເຊັ່ນ Whatsapp, Slack, Facebook.
+
+ທ່ານສາມາດສ້າງສະຖານີຂອງຕົນເອງ
+ເພື່ອໃຫ້ສາມາດຄວບຄຸມຂໍ້ມູນແລະການສົນທະນາທີ່ລະອຽດອ່ອນຂອງທ່ານຫຼາຍຂຶ້ນ, ທ່ານສາມາດຕິດຕັ້ງສະຖານີສື່ສານຂອງຕົນເອງຫຼືທ່ານສາມາດເລືອກຕິດຕັ້ງໄວ້ກັບເຄືອຂ່າຍ Matrix - ມາດຕະຖານສໍາລັບລະບົບເປີດ, ການສື່ສານແບບກະຈາຍການຄຸ້ມຄອງ. ລະບົບພວກເຮົາໃຫ້ທ່ານມີຄວາມເປັນສ່ວນຕົວ, ໄດ້ຕາມມາດຕະຖານຄວາມປອດໄພແລະມີຄວາມຍືດຫຍຸ່ນໃນການເຊື່ອມໂຍງ.
+
+ເປັນເຈົ້າຂອງຂໍ້ມູນຂອງທ່ານເອງ
+ທ່ານສາມາດເລືອກໄດ້ວ່າຈະເກັບຂໍ້ມູນ ແລະຂໍ້ຄວາມຂອງທ່ານຢູ່ໃສ. ໂດຍບໍ່ມີຄວາມສ່ຽງຕໍ່ການຂຸດຄົ້ນຂໍ້ມູນຫຼືການເຂົ້າເຖິງຈາກພາກສ່ວນທີສາມ.
+
+ລະບົບພວກເຮົາເຮັດໃຫ້ທ່ານສາມາດຄວບຄຸມດ້ວຍວິທີຕ່າງໆ:
+1. ຮັບບັນຊີຟຣີໃນເຊີບເວີສາທາລະນະ matrix.org ທີ່ໂຮສໂດຍຜູ້ພັດທະນາ Matrix, ຫຼືເລືອກຈາກເຄື່ອງແມ່ຂ່າຍສາທາລະນະຫຼາຍພັນເຊີບເວີທີ່ໂຮສໂດຍອາສາສະໝັກ.
+2. ຈັດການບັນຊີຂອງທ່ານເອງໂດຍການແລ່ນເຊີບເວີໃນໂຄງລ່າງພື້ນຖານ IT ຂອງທ່ານເອງ
+3. ລົງທະບຽນສໍາລັບບັນຊີຢູ່ໃນເຄື່ອງແມ່ຂ່າຍທີ່ກໍາຫນົດເອງໂດຍພຽງແຕ່ສະຫມັກກັບ Element Matrix Services hosting platform
+
+ສົ່ງຂໍ້ຄວາມ ແລະການຮ່ວມມືກັບລະບົບອື່ນໆທີ່ທ່ານຄຸ້ນເຄີຍ
+ທ່ານສາມາດສົນທະນາກັບທຸກຄົນໃນເຄືອຂ່າຍ Matrix, ບໍ່ວ່າເຂົາເຈົ້າກໍາລັງໃຊ້ Element, ແອັບ Matrix ອື່ນ ຫຼືເຖິງແມ່ນວ່າເຂົາເຈົ້າກຳລັງໃຊ້ແອັບສົ່ງຂໍ້ຄວາມອື່ນຢູ່.
+
+ປອດໄພທີ່ສຸດ
+ການເຂົ້າລະຫັດຈາກຕົ້ນທາງຫາປາຍທາງ (ມີພຽງແຕ່ຜູ້ທີ່ຢູ່ໃນການສົນທະນາສາມາດຖອດລະຫັດຂໍ້ຄວາມໄດ້), ແລະການຢັ້ງຢືນອຸປະກອນໂດຍການລົງນາມຂ້າມອຸປະກອນ.
+
+ການສື່ສານແລະການເຊື່ອມໂຍງທີ່ຄົບຖ້ວນສົມບູນ
+ການສົ່ງຂໍ້ຄວາມ, ການໂທສຽງ ແລະວິດີໂອ, ການແບ່ງປັນໄຟລ໌, ການແບ່ງປັນໜ້າຈໍ ແລະການເຊື່ອມໂຍງທັງໝົດ, ບັອດ ແລະວິດເຈັດ. ສ້າງຫ້ອງ, ຊຸມຊົນ, ຕິດຕໍ່ພົວພັນແລະເຮັດສິ່ງຕ່າງໆ.
+
+ສືບຕໍ່ຈາກການສົນທະນາລ້າສຸດ
+ທ່ານສາມາດຕິດຕໍ່ພົວພັນໄດ້ທຸກບ່ອນທີ່ຕ້ອງການ ເຊິ່ງປະຫວັດການສົນທະນາຈະຖືກອັບເດດໄປຫາບັນດາອຸປະກອນຕ່າງໆຂອງທ່ານ ລວມເຖິງໃນເວັບໄຊຕ໌ທີ່ https://app.element.io
+
+ເຕັກໂນໂລຊີໂອເພິນຊອດ
+Element ເປັນໂຄງການເຕັກໂນໂລຊີໂອເພິນຊອດ, ເປັນເຈົ້າພາບໂດຍ GitHub. ກະລຸນາລາຍງານຂໍ້ບົກພ່ອງ ແລະ/ຫຼື ປະກອບສ່ວນເຂົ້າໃນການພັດທະນາຂອງລະບົບຢູ່ https://github.com/vector-im/element-android
diff --git a/fastlane/metadata/android/lo/short_description.txt b/fastlane/metadata/android/lo/short_description.txt
new file mode 100644
index 0000000000..625b078915
--- /dev/null
+++ b/fastlane/metadata/android/lo/short_description.txt
@@ -0,0 +1 @@
+ສົ່ງຂໍ້ຄວາມກຸ່ມ - ສົ່ງຂໍ້ຄວາມທີ່ເຂົ້າລະຫັດ, ສົນທະນາກຸ່ມ ແລະໂທວິດີໂອ
diff --git a/fastlane/metadata/android/lo/title.txt b/fastlane/metadata/android/lo/title.txt
new file mode 100644
index 0000000000..a9054d803b
--- /dev/null
+++ b/fastlane/metadata/android/lo/title.txt
@@ -0,0 +1 @@
+ລະບົບສື່ສານທີ່ມີຄວາມປອດໄພສູງ
diff --git a/fastlane/metadata/android/pt-BR/changelogs/40104100.txt b/fastlane/metadata/android/pt-BR/changelogs/40104100.txt
new file mode 100644
index 0000000000..eb746aca2b
--- /dev/null
+++ b/fastlane/metadata/android/pt-BR/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Principais mudanças nesta versão: Rolar em mensagem de voz. Vários consertos de bugs e melhorias de estabilidade.
+Changelog completo: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/pt-BR/changelogs/40104110.txt b/fastlane/metadata/android/pt-BR/changelogs/40104110.txt
new file mode 100644
index 0000000000..6e11e92579
--- /dev/null
+++ b/fastlane/metadata/android/pt-BR/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Principais mudanças nesta versão: Vários consertos de bugs e melhorias de estabilidade.
+Changelog completo: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/sk/changelogs/40104100.txt b/fastlane/metadata/android/sk/changelogs/40104100.txt
new file mode 100644
index 0000000000..b96a539364
--- /dev/null
+++ b/fastlane/metadata/android/sk/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Hlavné zmeny v tejto verzii: Posúvanie v hlasovej správe. Rôzne opravy chýb a vylepšenia stability.
+Úplný zoznam zmien: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/sk/changelogs/40104110.txt b/fastlane/metadata/android/sk/changelogs/40104110.txt
new file mode 100644
index 0000000000..50670f18c2
--- /dev/null
+++ b/fastlane/metadata/android/sk/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Hlavné zmeny v tejto verzii: Rôzne opravy chýb a vylepšenia stability.
+Úplný zoznam zmien: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/sq/changelogs/40104100.txt b/fastlane/metadata/android/sq/changelogs/40104100.txt
new file mode 100644
index 0000000000..c45c2b9a33
--- /dev/null
+++ b/fastlane/metadata/android/sq/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Ndryshimet kryesore në këtë version: Rrëshqitje në mesazh zanor. Ndreqje të metash të ndryshme dhe përmirësime qëndrueshmërie.
+Regjistër i plotë ndryshimesh: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/sq/changelogs/40104110.txt b/fastlane/metadata/android/sq/changelogs/40104110.txt
new file mode 100644
index 0000000000..df9b377adb
--- /dev/null
+++ b/fastlane/metadata/android/sq/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Ndryshimet kryesore në këtë version: Ndreqje të metash të ndryshme dhe përmirësime qëndrueshmërie.
+Regjistër i plotë ndryshimesh: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/sv-SE/changelogs/40104100.txt b/fastlane/metadata/android/sv-SE/changelogs/40104100.txt
new file mode 100644
index 0000000000..a1585aacf5
--- /dev/null
+++ b/fastlane/metadata/android/sv-SE/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Huvudsakliga ändringar i denna version: Scrolla i röstmeddelanden. Diverse buggfixar och förbättrad stabilitet.
+Fullständig lista över ändringar: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/sv-SE/changelogs/40104110.txt b/fastlane/metadata/android/sv-SE/changelogs/40104110.txt
new file mode 100644
index 0000000000..92cce13669
--- /dev/null
+++ b/fastlane/metadata/android/sv-SE/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Huvudsakliga ändringar i denna version: Diverse buggfixar och förbättrad stabilitet.
+Fullständig lista över ändringar: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/uk/changelogs/40104100.txt b/fastlane/metadata/android/uk/changelogs/40104100.txt
new file mode 100644
index 0000000000..93c9fe4b70
--- /dev/null
+++ b/fastlane/metadata/android/uk/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+Основні зміни в цій версії: Прокручування в голосових повідомленнях. Усунуто різні вади й поліпшено стабільність.
+Вичерпний перелік змін: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/uk/changelogs/40104110.txt b/fastlane/metadata/android/uk/changelogs/40104110.txt
new file mode 100644
index 0000000000..252a57c9d9
--- /dev/null
+++ b/fastlane/metadata/android/uk/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+Основні зміни в цій версії: Усунуто різні вади й поліпшено стабільність.
+Вичерпний перелік змін: https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/zh-TW/changelogs/40104100.txt b/fastlane/metadata/android/zh-TW/changelogs/40104100.txt
new file mode 100644
index 0000000000..c78ed7dd2d
--- /dev/null
+++ b/fastlane/metadata/android/zh-TW/changelogs/40104100.txt
@@ -0,0 +1,2 @@
+此版本中的主要變動：捲動音訊訊息。多個臭蟲修復與穩定性改善。
+完整的變更紀錄：https://github.com/vector-im/element-android/releases
diff --git a/fastlane/metadata/android/zh-TW/changelogs/40104110.txt b/fastlane/metadata/android/zh-TW/changelogs/40104110.txt
new file mode 100644
index 0000000000..4bcca9a0b8
--- /dev/null
+++ b/fastlane/metadata/android/zh-TW/changelogs/40104110.txt
@@ -0,0 +1,2 @@
+此版本中的主要變動：多個臭蟲修復與穩定性改善。
+完整的變更紀錄：https://github.com/vector-im/element-android/releases
diff --git a/library/core-utils/build.gradle b/library/core-utils/build.gradle
index ad3a948808..d3afd8d29b 100644
--- a/library/core-utils/build.gradle
+++ b/library/core-utils/build.gradle
@@ -44,7 +44,7 @@ android {
kotlinOptions {
jvmTarget = "11"
freeCompilerArgs += [
- "-Xopt-in=kotlin.RequiresOptIn"
+ "-opt-in=kotlin.RequiresOptIn"
]
}
}
@@ -52,4 +52,4 @@ android {
dependencies {
implementation libs.androidx.appCompat
implementation libs.jetbrains.coroutinesAndroid
-}
\ No newline at end of file
+}
diff --git a/library/jsonviewer/build.gradle b/library/jsonviewer/build.gradle
index 0cad8ac171..2110747feb 100644
--- a/library/jsonviewer/build.gradle
+++ b/library/jsonviewer/build.gradle
@@ -6,8 +6,14 @@ apply plugin: 'com.jakewharton.butterknife'
buildscript {
repositories {
- google()
- mavenCentral()
+ // Do not use `google()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://maven.google.com'
+ }
+ // Do not use `mavenCentral()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://repo1.maven.org/maven2'
+ }
}
dependencies {
classpath 'com.jakewharton:butterknife-gradle-plugin:10.2.3'
diff --git a/matrix-sdk-android/build.gradle b/matrix-sdk-android/build.gradle
index 2aab8510ce..c840b9a6e9 100644
--- a/matrix-sdk-android/build.gradle
+++ b/matrix-sdk-android/build.gradle
@@ -7,7 +7,10 @@ apply plugin: "org.jetbrains.dokka"
buildscript {
repositories {
- mavenCentral()
+ // Do not use `mavenCentral()`, it prevents Dependabot from working properly
+ maven {
+ url 'https://repo1.maven.org/maven2'
+ }
}
dependencies {
classpath "io.realm:realm-gradle-plugin:10.9.0"
@@ -53,7 +56,7 @@ android {
// that the app's state is completely cleared between tests.
testInstrumentationRunnerArguments clearPackageData: 'true'
- buildConfigField "String", "SDK_VERSION", "\"1.4.14\""
+ buildConfigField "String", "SDK_VERSION", "\"1.4.16\""
buildConfigField "String", "GIT_SDK_REVISION", "\"${gitRevision()}\""
buildConfigField "String", "GIT_SDK_REVISION_UNIX_DATE", "\"${gitRevisionUnixDate()}\""
@@ -98,6 +101,9 @@ android {
freeCompilerArgs += [
// Disabled for now, there are too many errors. Could be handled in another dedicated PR
// '-Xexplicit-api=strict', // or warning
+ "-opt-in=kotlin.RequiresOptIn",
+ // Opt in for kotlinx.coroutines.FlowPreview
+ "-opt-in=kotlinx.coroutines.FlowPreview",
]
}
@@ -175,7 +181,7 @@ dependencies {
implementation libs.arrow.instances
// olm lib is now hosted in MavenCentral
- implementation 'org.matrix.android:olm-sdk:3.2.10'
+ implementation 'org.matrix.android:olm-sdk:3.2.11'
// DI
implementation libs.dagger.dagger
@@ -192,7 +198,7 @@ dependencies {
implementation libs.apache.commonsImaging
// Phone number https://github.com/google/libphonenumber
- implementation 'com.googlecode.libphonenumber:libphonenumber:8.12.47'
+ implementation 'com.googlecode.libphonenumber:libphonenumber:8.12.48'
testImplementation libs.tests.junit
testImplementation 'org.robolectric:robolectric:4.7.3'
diff --git a/matrix-sdk-android/docs/modules.md b/matrix-sdk-android/docs/modules.md
index edf5af64d0..b19bc73534 100644
--- a/matrix-sdk-android/docs/modules.md
+++ b/matrix-sdk-android/docs/modules.md
@@ -1,5 +1,8 @@
# Module matrix-sdk-android
+
+**Note**: You are viewing the nightly documentation of the Android Matrix SDK library. The documentation of the released library can be found here: [https://matrix-org.github.io/matrix-android-sdk2/](https://matrix-org.github.io/matrix-android-sdk2/)
+
## Welcome to the matrix-sdk-android documentation!
This pages list the complete API that this SDK is exposing to a client application.
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/PermalinkParserTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/PermalinkParserTest.kt
index b11a538949..8717b3f7a8 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/PermalinkParserTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/PermalinkParserTest.kt
@@ -37,7 +37,10 @@ class PermalinkParserTest {
Assert.assertTrue("Should be parsed as email invite but was ${parsedLink::class.java}", parsedLink is PermalinkData.RoomEmailInviteLink)
parsedLink as PermalinkData.RoomEmailInviteLink
Assert.assertEquals("!MRBNLPtFnMAazZVPMO:matrix.org", parsedLink.roomId)
- Assert.assertEquals("XmOwRZnSFabCRhTywFbJWKXWVNPysOpXIbroMGaUymqkJSvHeVKRsjHajwjCYdBsvGSvHauxbKfJmOxtXldtyLnyBMLKpBQCMzyYggrdapbVIceWZBtmslOQrXLABRoe", parsedLink.token)
+ Assert.assertEquals(
+ "XmOwRZnSFabCRhTywFbJWKXWVNPysOpXIbroMGaUymqkJSvHeVKRsjHajwjCYdBsvGSvHauxbKfJmOxtXldtyLnyBMLKpBQCMzyYggrdapbVIceWZBtmslOQrXLABRoe",
+ parsedLink.token
+ )
Assert.assertEquals("vector.im", parsedLink.identityServer)
Assert.assertEquals("Team2", parsedLink.roomName)
Assert.assertEquals("hiphop5", parsedLink.inviterName)
@@ -45,7 +48,8 @@ class PermalinkParserTest {
@Test
fun testParseLinkWIthEvent() {
- val rawInvite = "https://matrix.to/#/!OGEhHVWSdvArJzumhm:matrix.org/\$xuvJUVDJnwEeVjPx029rAOZ50difpmU_5gZk_T0jGfc?via=matrix.org&via=libera.chat&via=matrix.example.io"
+ val rawInvite =
+ "https://matrix.to/#/!OGEhHVWSdvArJzumhm:matrix.org/\$xuvJUVDJnwEeVjPx029rAOZ50difpmU_5gZk_T0jGfc?via=matrix.org&via=libera.chat&via=matrix.example.io"
val parsedLink = PermalinkParser.parse(rawInvite)
Assert.assertTrue("Should be parsed as room link", parsedLink is PermalinkData.RoomLink)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/SingleThreadCoroutineDispatcher.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/SingleThreadCoroutineDispatcher.kt
index 3e3af10799..a44cd6c80f 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/SingleThreadCoroutineDispatcher.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/SingleThreadCoroutineDispatcher.kt
@@ -21,5 +21,7 @@ import kotlinx.coroutines.asCoroutineDispatcher
import org.matrix.android.sdk.api.MatrixCoroutineDispatchers
import java.util.concurrent.Executors
-internal val testCoroutineDispatchers = MatrixCoroutineDispatchers(Main, Main, Main, Main,
- Executors.newSingleThreadExecutor().asCoroutineDispatcher())
+internal val testCoroutineDispatchers = MatrixCoroutineDispatchers(
+ Main, Main, Main, Main,
+ Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/account/DeactivateAccountTest.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/account/DeactivateAccountTest.kt
index 52dbfc7155..d2dfe4d945 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/account/DeactivateAccountTest.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/account/DeactivateAccountTest.kt
@@ -67,9 +67,11 @@ class DeactivateAccountTest : InstrumentedTest {
val throwable = commonTestHelper.logAccountWithError(session.myUserId, TestConstants.PASSWORD)
// Test the error
- assertTrue(throwable is Failure.ServerError &&
- throwable.error.code == MatrixError.M_USER_DEACTIVATED &&
- throwable.error.message == "This account has been deactivated")
+ assertTrue(
+ throwable is Failure.ServerError &&
+ throwable.error.code == MatrixError.M_USER_DEACTIVATED &&
+ throwable.error.message == "This account has been deactivated"
+ )
// Try to create an account with the deactivate account user id, it will fail (M_USER_IN_USE)
val hs = commonTestHelper.createHomeServerConfig()
@@ -95,8 +97,10 @@ class DeactivateAccountTest : InstrumentedTest {
// Test the error
accountCreationError.let {
- assertTrue(it is Failure.ServerError &&
- it.error.code == MatrixError.M_USER_IN_USE)
+ assertTrue(
+ it is Failure.ServerError &&
+ it.error.code == MatrixError.M_USER_IN_USE
+ )
}
// No need to close the session, it has been deactivated
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt
index 54d02d226e..4b9e605cd0 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CommonTestHelper.kt
@@ -57,7 +57,8 @@ import java.util.concurrent.TimeUnit
class CommonTestHelper(context: Context) {
internal val matrix: TestMatrix
- val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+ private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+ private var accountNumber = 0
fun getTestInterceptor(session: Session): MockOkHttpInterceptor? = TestModule.interceptorForSession(session.sessionId) as? MockOkHttpInterceptor
@@ -167,7 +168,8 @@ class CommonTestHelper(context: Context) {
if (rootThreadEventId != null) {
room.relationService().replyInThread(
rootThreadEventId = rootThreadEventId,
- replyInThreadText = formattedMessage)
+ replyInThreadText = formattedMessage
+ )
} else {
room.sendService().sendTextMessage(formattedMessage)
}
@@ -237,7 +239,7 @@ class CommonTestHelper(context: Context) {
password: String,
testParams: SessionTestParams): Session {
val session = createAccountAndSync(
- userNamePrefix + "_" + System.currentTimeMillis() + UUID.randomUUID(),
+ userNamePrefix + "_" + accountNumber++ + "_" + UUID.randomUUID(),
password,
testParams
)
diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt
index 058b1f7933..dfb4863d5b 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/common/CryptoTestHelper.kt
@@ -19,6 +19,7 @@ package org.matrix.android.sdk.common
import android.os.SystemClock
import android.util.Log
import androidx.lifecycle.Observer
+import org.amshove.kluent.fail
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
@@ -31,8 +32,16 @@ import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM
import org.matrix.android.sdk.api.crypto.MXCRYPTO_ALGORITHM_MEGOLM_BACKUP
import org.matrix.android.sdk.api.extensions.orFalse
import org.matrix.android.sdk.api.session.Session
+import org.matrix.android.sdk.api.session.crypto.MXCryptoError
+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
+import org.matrix.android.sdk.api.session.crypto.crosssigning.SELF_SIGNING_KEY_SSSS_NAME
+import org.matrix.android.sdk.api.session.crypto.crosssigning.USER_SIGNING_KEY_SSSS_NAME
+import org.matrix.android.sdk.api.session.crypto.keysbackup.KeysVersion
import org.matrix.android.sdk.api.session.crypto.keysbackup.MegolmBackupAuthData
import org.matrix.android.sdk.api.session.crypto.keysbackup.MegolmBackupCreationInfo
+import org.matrix.android.sdk.api.session.crypto.keysbackup.extractCurveKeyFromRecoveryKey
+import org.matrix.android.sdk.api.session.crypto.model.OlmDecryptionResult
import org.matrix.android.sdk.api.session.crypto.verification.IncomingSasVerificationTransaction
import org.matrix.android.sdk.api.session.crypto.verification.OutgoingSasVerificationTransaction
import org.matrix.android.sdk.api.session.crypto.verification.VerificationMethod
@@ -40,13 +49,19 @@ import org.matrix.android.sdk.api.session.crypto.verification.VerificationTxStat
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.toContent
+import org.matrix.android.sdk.api.session.events.model.toModel
import org.matrix.android.sdk.api.session.getRoom
import org.matrix.android.sdk.api.session.room.Room
import org.matrix.android.sdk.api.session.room.model.Membership
import org.matrix.android.sdk.api.session.room.model.RoomSummary
import org.matrix.android.sdk.api.session.room.model.create.CreateRoomParams
+import org.matrix.android.sdk.api.session.room.model.message.MessageContent
import org.matrix.android.sdk.api.session.room.roomSummaryQueryParams
+import org.matrix.android.sdk.api.session.securestorage.EmptyKeySigner
+import org.matrix.android.sdk.api.session.securestorage.SharedSecretStorageService
import org.matrix.android.sdk.api.util.Optional
+import org.matrix.android.sdk.api.util.awaitCallback
+import org.matrix.android.sdk.api.util.toBase64NoPadding
import java.util.UUID
import kotlin.coroutines.Continuation
import kotlin.coroutines.resume
@@ -291,7 +306,61 @@ class CryptoTestHelper(private val testHelper: CommonTestHelper) {
)
)
}
- }, it)
+ }, it
+ )
+ }
+ }
+
+ /**
+ * Initialize cross-signing, set up megolm backup and save all in 4S
+ */
+ fun bootstrapSecurity(session: Session) {
+ initializeCrossSigning(session)
+ val ssssService = session.sharedSecretStorageService()
+ testHelper.runBlockingTest {
+ val keyInfo = ssssService.generateKey(
+ UUID.randomUUID().toString(),
+ null,
+ "ssss_key",
+ EmptyKeySigner()
+ )
+ ssssService.setDefaultKey(keyInfo.keyId)
+
+ ssssService.storeSecret(
+ MASTER_KEY_SSSS_NAME,
+ session.cryptoService().crossSigningService().getCrossSigningPrivateKeys()!!.master!!,
+ listOf(SharedSecretStorageService.KeyRef(keyInfo.keyId, keyInfo.keySpec))
+ )
+
+ ssssService.storeSecret(
+ SELF_SIGNING_KEY_SSSS_NAME,
+ session.cryptoService().crossSigningService().getCrossSigningPrivateKeys()!!.selfSigned!!,
+ listOf(SharedSecretStorageService.KeyRef(keyInfo.keyId, keyInfo.keySpec))
+ )
+
+ ssssService.storeSecret(
+ USER_SIGNING_KEY_SSSS_NAME,
+ session.cryptoService().crossSigningService().getCrossSigningPrivateKeys()!!.user!!,
+ listOf(SharedSecretStorageService.KeyRef(keyInfo.keyId, keyInfo.keySpec))
+ )
+
+ // set up megolm backup
+ val creationInfo = awaitCallback