From 01597a89dc828033836f218828ff02d7b61fdae2 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 17:53:27 +0100 Subject: [PATCH 01/16] Avoid code duplication --- .../internal/crypto/ssss/QuadSTests.kt | 36 +++++-------------- 1 file changed, 8 insertions(+), 28 deletions(-) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt index f0e2161d4c..57c065aaf8 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt @@ -25,11 +25,10 @@ import im.vector.matrix.android.api.session.Session import im.vector.matrix.android.api.session.securestorage.Curve25519AesSha2KeySpec import im.vector.matrix.android.api.session.securestorage.EncryptedSecretContent import im.vector.matrix.android.api.session.securestorage.KeySigner -import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo import im.vector.matrix.android.api.session.securestorage.SecretStorageKeyContent +import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo import im.vector.matrix.android.api.util.Optional import im.vector.matrix.android.common.CommonTestHelper -import im.vector.matrix.android.common.CryptoTestHelper import im.vector.matrix.android.common.SessionTestParams import im.vector.matrix.android.common.TestConstants import im.vector.matrix.android.common.TestMatrixCallback @@ -50,11 +49,16 @@ import org.junit.runners.MethodSorters import java.util.concurrent.CountDownLatch @RunWith(AndroidJUnit4::class) -@FixMethodOrder(MethodSorters.NAME_ASCENDING) +@FixMethodOrder(MethodSorters.JVM) class QuadSTests : InstrumentedTest { private val mTestHelper = CommonTestHelper(context()) - private val mCryptoTestHelper = CryptoTestHelper(mTestHelper) + + private val emptyKeySigner = object : KeySigner { + override fun sign(canonicalJson: String): Map>? { + return null + } + } @Test fun test_Generate4SKey() { @@ -64,12 +68,6 @@ class QuadSTests : InstrumentedTest { val quadS = aliceSession.sharedSecretStorageService - val emptyKeySigner = object : KeySigner { - override fun sign(canonicalJson: String): Map>? { - return null - } - } - var recoveryKey: String? = null val TEST_KEY_ID = "my.test.Key" @@ -207,12 +205,6 @@ class QuadSTests : InstrumentedTest { val quadS = aliceSession.sharedSecretStorageService - val emptyKeySigner = object : KeySigner { - override fun sign(canonicalJson: String): Map>? { - return null - } - } - val TEST_KEY_ID = "my.test.Key" val countDownLatch = CountDownLatch(1) @@ -354,12 +346,6 @@ class QuadSTests : InstrumentedTest { private fun generatedSecret(session: Session, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo { val quadS = session.sharedSecretStorageService - val emptyKeySigner = object : KeySigner { - override fun sign(canonicalJson: String): Map>? { - return null - } - } - var creationInfo: SsssKeyCreationInfo? = null val generateLatch = CountDownLatch(1) @@ -395,12 +381,6 @@ class QuadSTests : InstrumentedTest { private fun generatedSecretFromPassphrase(session: Session, passphrase: String, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo { val quadS = session.sharedSecretStorageService - val emptyKeySigner = object : KeySigner { - override fun sign(canonicalJson: String): Map>? { - return null - } - } - var creationInfo: SsssKeyCreationInfo? = null val generateLatch = CountDownLatch(1) From 7878da25b88a3757db52c6fa28b0cbb9bbeb26ad Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 18:18:10 +0100 Subject: [PATCH 02/16] Use doSync<>() to reduce boilerplate and add test checks and more cleanup --- .../internal/crypto/ssss/QuadSTests.kt | 280 +++++++----------- 1 file changed, 114 insertions(+), 166 deletions(-) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt index 57c065aaf8..82594f2645 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt @@ -40,8 +40,10 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.GlobalScope import kotlinx.coroutines.launch import kotlinx.coroutines.runBlocking -import org.junit.Assert -import org.junit.Assert.fail +import org.amshove.kluent.shouldBe +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull import org.junit.FixMethodOrder import org.junit.Test import org.junit.runner.RunWith @@ -64,28 +66,13 @@ class QuadSTests : InstrumentedTest { fun test_Generate4SKey() { val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) - val aliceLatch = CountDownLatch(1) - val quadS = aliceSession.sharedSecretStorageService - var recoveryKey: String? = null - val TEST_KEY_ID = "my.test.Key" - quadS.generateKey(TEST_KEY_ID, "Test Key", emptyKeySigner, - object : MatrixCallback { - override fun onSuccess(data: SsssKeyCreationInfo) { - recoveryKey = data.recoveryKey - aliceLatch.countDown() - } - - override fun onFailure(failure: Throwable) { - Assert.fail("onFailure " + failure.localizedMessage) - aliceLatch.countDown() - } - }) - - mTestHelper.await(aliceLatch) + val ssssKeyCreationInfo = mTestHelper.doSync { + quadS.generateKey(TEST_KEY_ID, "Test Key", emptyKeySigner, it) + } // Assert Account data is updated val accountDataLock = CountDownLatch(1) @@ -104,18 +91,18 @@ class QuadSTests : InstrumentedTest { mTestHelper.await(accountDataLock) - Assert.assertNotNull("Key should be stored in account data", accountData) + assertNotNull("Key should be stored in account data", accountData) val parsed = SecretStorageKeyContent.fromJson(accountData!!.content) - Assert.assertNotNull("Key Content cannot be parsed", parsed) - Assert.assertEquals("Unexpected Algorithm", SSSS_ALGORITHM_CURVE25519_AES_SHA2, parsed!!.algorithm) - Assert.assertEquals("Unexpected key name", "Test Key", parsed.name) - Assert.assertNull("Key was not generated from passphrase", parsed.passphrase) - Assert.assertNotNull("Pubkey should be defined", parsed.publicKey) + assertNotNull("Key Content cannot be parsed", parsed) + assertEquals("Unexpected Algorithm", SSSS_ALGORITHM_CURVE25519_AES_SHA2, parsed!!.algorithm) + assertEquals("Unexpected key name", "Test Key", parsed.name) + assertNull("Key was not generated from passphrase", parsed.passphrase) + assertNotNull("Pubkey should be defined", parsed.publicKey) - val privateKeySpec = Curve25519AesSha2KeySpec.fromRecoveryKey(recoveryKey!!) + val privateKeySpec = Curve25519AesSha2KeySpec.fromRecoveryKey(ssssKeyCreationInfo.recoveryKey) DefaultSharedSecretStorageService.withOlmDecryption { olmPkDecryption -> val pubKey = olmPkDecryption.setPrivateKey(privateKeySpec!!.privateKey) - Assert.assertEquals("Unexpected Public Key", pubKey, parsed.publicKey) + assertEquals("Unexpected Public Key", pubKey, parsed.publicKey) } // Set as default key @@ -137,8 +124,8 @@ class QuadSTests : InstrumentedTest { mTestHelper.await(defaultDataLock) - Assert.assertNotNull(defaultKeyAccountData?.content) - Assert.assertEquals("Unexpected default key ${defaultKeyAccountData?.content}", TEST_KEY_ID, defaultKeyAccountData?.content?.get("key")) + assertNotNull(defaultKeyAccountData?.content) + assertEquals("Unexpected default key ${defaultKeyAccountData?.content}", TEST_KEY_ID, defaultKeyAccountData?.content?.get("key")) mTestHelper.signout(aliceSession) } @@ -150,52 +137,40 @@ class QuadSTests : InstrumentedTest { val info = generatedSecret(aliceSession, keyId, true) // Store a secret - - val storeCountDownLatch = CountDownLatch(1) val clearSecret = Base64.encodeToString("42".toByteArray(), Base64.NO_PADDING or Base64.NO_WRAP) - aliceSession.sharedSecretStorageService.storeSecret( - "secret.of.life", - clearSecret, - null, // default key - TestMatrixCallback(storeCountDownLatch) - ) + mTestHelper.doSync { + aliceSession.sharedSecretStorageService.storeSecret( + "secret.of.life", + clearSecret, + null, // default key + it + ) + } val secretAccountData = assertAccountData(aliceSession, "secret.of.life") val encryptedContent = secretAccountData.content.get("encrypted") as? Map<*, *> - Assert.assertNotNull("Element should be encrypted", encryptedContent) - Assert.assertNotNull("Secret should be encrypted with default key", encryptedContent?.get(keyId)) + assertNotNull("Element should be encrypted", encryptedContent) + assertNotNull("Secret should be encrypted with default key", encryptedContent?.get(keyId)) val secret = EncryptedSecretContent.fromJson(encryptedContent?.get(keyId)) - Assert.assertNotNull(secret?.ciphertext) - Assert.assertNotNull(secret?.mac) - Assert.assertNotNull(secret?.ephemeral) + assertNotNull(secret?.ciphertext) + assertNotNull(secret?.mac) + assertNotNull(secret?.ephemeral) // Try to decrypt?? val keySpec = Curve25519AesSha2KeySpec.fromRecoveryKey(info.recoveryKey) - var decryptedSecret: String? = null + val decryptedSecret = mTestHelper.doSync { + aliceSession.sharedSecretStorageService.getSecret("secret.of.life", + null, // default key + keySpec!!, + it + ) + } - val decryptCountDownLatch = CountDownLatch(1) - aliceSession.sharedSecretStorageService.getSecret("secret.of.life", - null, // default key - keySpec!!, - object : MatrixCallback { - override fun onFailure(failure: Throwable) { - fail("Fail to decrypt -> " + failure.localizedMessage) - decryptCountDownLatch.countDown() - } - - override fun onSuccess(data: String) { - decryptedSecret = data - decryptCountDownLatch.countDown() - } - } - ) - mTestHelper.await(decryptCountDownLatch) - - Assert.assertEquals("Secret mismatch", clearSecret, decryptedSecret) + assertEquals("Secret mismatch", clearSecret, decryptedSecret) mTestHelper.signout(aliceSession) } @@ -207,16 +182,14 @@ class QuadSTests : InstrumentedTest { val TEST_KEY_ID = "my.test.Key" - val countDownLatch = CountDownLatch(1) - quadS.generateKey(TEST_KEY_ID, "Test Key", emptyKeySigner, - TestMatrixCallback(countDownLatch)) - - mTestHelper.await(countDownLatch) + mTestHelper.doSync { + quadS.generateKey(TEST_KEY_ID, "Test Key", emptyKeySigner, it) + } // Test that we don't need to wait for an account data sync to access directly the keyid from DB - val defaultLatch = CountDownLatch(1) - quadS.setDefaultKey(TEST_KEY_ID, TestMatrixCallback(defaultLatch)) - mTestHelper.await(defaultLatch) + mTestHelper.doSync { + quadS.setDefaultKey(TEST_KEY_ID, it) + } mTestHelper.signout(aliceSession) } @@ -231,38 +204,39 @@ class QuadSTests : InstrumentedTest { val mySecretText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit" - val storeLatch = CountDownLatch(1) - aliceSession.sharedSecretStorageService.storeSecret( - "my.secret", - mySecretText.toByteArray().toBase64NoPadding(), - listOf(keyId1, keyId2), - TestMatrixCallback(storeLatch) - ) - mTestHelper.await(storeLatch) + mTestHelper.doSync { + aliceSession.sharedSecretStorageService.storeSecret( + "my.secret", + mySecretText.toByteArray().toBase64NoPadding(), + listOf(keyId1, keyId2), + it + ) + } val accountDataEvent = aliceSession.getAccountDataEvent("my.secret") val encryptedContent = accountDataEvent?.content?.get("encrypted") as? Map<*, *> - Assert.assertEquals("Content should contains two encryptions", 2, encryptedContent?.keys?.size ?: 0) + assertEquals("Content should contains two encryptions", 2, encryptedContent?.keys?.size ?: 0) - Assert.assertNotNull(encryptedContent?.get(keyId1)) - Assert.assertNotNull(encryptedContent?.get(keyId2)) + assertNotNull(encryptedContent?.get(keyId1)) + assertNotNull(encryptedContent?.get(keyId2)) // Assert that can decrypt with both keys - val decryptCountDownLatch = CountDownLatch(2) - aliceSession.sharedSecretStorageService.getSecret("my.secret", - keyId1, - Curve25519AesSha2KeySpec.fromRecoveryKey(key1Info.recoveryKey)!!, - TestMatrixCallback(decryptCountDownLatch) - ) + mTestHelper.doSync { + aliceSession.sharedSecretStorageService.getSecret("my.secret", + keyId1, + Curve25519AesSha2KeySpec.fromRecoveryKey(key1Info.recoveryKey)!!, + it + ) + } - aliceSession.sharedSecretStorageService.getSecret("my.secret", - keyId2, - Curve25519AesSha2KeySpec.fromRecoveryKey(key2Info.recoveryKey)!!, - TestMatrixCallback(decryptCountDownLatch) - ) - - mTestHelper.await(decryptCountDownLatch) + mTestHelper.doSync { + aliceSession.sharedSecretStorageService.getSecret("my.secret", + keyId2, + Curve25519AesSha2KeySpec.fromRecoveryKey(key2Info.recoveryKey)!!, + it + ) + } mTestHelper.signout(aliceSession) } @@ -276,16 +250,17 @@ class QuadSTests : InstrumentedTest { val mySecretText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit" - val storeLatch = CountDownLatch(1) - aliceSession.sharedSecretStorageService.storeSecret( - "my.secret", - mySecretText.toByteArray().toBase64NoPadding(), - listOf(keyId1), - TestMatrixCallback(storeLatch) - ) - mTestHelper.await(storeLatch) + mTestHelper.doSync { + aliceSession.sharedSecretStorageService.storeSecret( + "my.secret", + mySecretText.toByteArray().toBase64NoPadding(), + listOf(keyId1), + it + ) + } - val decryptCountDownLatch = CountDownLatch(2) + val decryptCountDownLatch = CountDownLatch(1) + var error = false aliceSession.sharedSecretStorageService.getSecret("my.secret", keyId1, Curve25519AesSha2KeySpec.fromPassphrase( @@ -296,29 +271,32 @@ class QuadSTests : InstrumentedTest { object : MatrixCallback { override fun onSuccess(data: String) { decryptCountDownLatch.countDown() - fail("Should not be able to decrypt") } override fun onFailure(failure: Throwable) { - Assert.assertTrue(true) + error = true decryptCountDownLatch.countDown() } } ) - // Now try with correct key - aliceSession.sharedSecretStorageService.getSecret("my.secret", - keyId1, - Curve25519AesSha2KeySpec.fromPassphrase( - passphrase, - key1Info.content?.passphrase?.salt ?: "", - key1Info.content?.passphrase?.iterations ?: 0, - null), - TestMatrixCallback(decryptCountDownLatch) - ) - mTestHelper.await(decryptCountDownLatch) + error shouldBe true + + // Now try with correct key + mTestHelper.doSync { + aliceSession.sharedSecretStorageService.getSecret("my.secret", + keyId1, + Curve25519AesSha2KeySpec.fromPassphrase( + passphrase, + key1Info.content?.passphrase?.salt ?: "", + key1Info.content?.passphrase?.iterations ?: 0, + null), + it + ) + } + mTestHelper.signout(aliceSession) } @@ -338,7 +316,7 @@ class QuadSTests : InstrumentedTest { GlobalScope.launch(Dispatchers.Main) { liveAccountData.observeForever(accountDataObserver) } mTestHelper.await(accountDataLock) - Assert.assertNotNull("Account Data type:$type should be found", accountData) + assertNotNull("Account Data type:$type should be found", accountData) return accountData!! } @@ -346,64 +324,34 @@ class QuadSTests : InstrumentedTest { private fun generatedSecret(session: Session, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo { val quadS = session.sharedSecretStorageService - var creationInfo: SsssKeyCreationInfo? = null - - val generateLatch = CountDownLatch(1) - - quadS.generateKey(keyId, keyId, emptyKeySigner, - object : MatrixCallback { - override fun onSuccess(data: SsssKeyCreationInfo) { - creationInfo = data - generateLatch.countDown() - } - - override fun onFailure(failure: Throwable) { - Assert.fail("onFailure " + failure.localizedMessage) - generateLatch.countDown() - } - }) - - mTestHelper.await(generateLatch) - - Assert.assertNotNull(creationInfo) + val creationInfo = mTestHelper.doSync { + quadS.generateKey(keyId, keyId, emptyKeySigner, it) + } assertAccountData(session, "m.secret_storage.key.$keyId") + if (asDefault) { - val setDefaultLatch = CountDownLatch(1) - quadS.setDefaultKey(keyId, TestMatrixCallback(setDefaultLatch)) - mTestHelper.await(setDefaultLatch) + mTestHelper.doSync { + quadS.setDefaultKey(keyId, it) + } assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID) } - return creationInfo!! + return creationInfo } private fun generatedSecretFromPassphrase(session: Session, passphrase: String, keyId: String, asDefault: Boolean = true): SsssKeyCreationInfo { val quadS = session.sharedSecretStorageService - var creationInfo: SsssKeyCreationInfo? = null - - val generateLatch = CountDownLatch(1) - - quadS.generateKeyWithPassphrase(keyId, keyId, - passphrase, - emptyKeySigner, - null, - object : MatrixCallback { - override fun onSuccess(data: SsssKeyCreationInfo) { - creationInfo = data - generateLatch.countDown() - } - - override fun onFailure(failure: Throwable) { - Assert.fail("onFailure " + failure.localizedMessage) - generateLatch.countDown() - } - }) - - mTestHelper.await(generateLatch) - - Assert.assertNotNull(creationInfo) + val creationInfo = mTestHelper.doSync { + quadS.generateKeyWithPassphrase( + keyId, + keyId, + passphrase, + emptyKeySigner, + null, + it) + } assertAccountData(session, "m.secret_storage.key.$keyId") if (asDefault) { @@ -413,6 +361,6 @@ class QuadSTests : InstrumentedTest { assertAccountData(session, DefaultSharedSecretStorageService.DEFAULT_KEY_ID) } - return creationInfo!! + return creationInfo } } From 4c3b754de499955c667962fc8549314ea986235a Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 18:33:15 +0100 Subject: [PATCH 03/16] Use const from DefaultSharedSecretStorageService --- .idea/dictionaries/bmarty.xml | 1 + .../matrix/android/internal/crypto/ssss/QuadSTests.kt | 8 ++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/.idea/dictionaries/bmarty.xml b/.idea/dictionaries/bmarty.xml index 680a1d57cf..f351ec8bfd 100644 --- a/.idea/dictionaries/bmarty.xml +++ b/.idea/dictionaries/bmarty.xml @@ -22,6 +22,7 @@ signin signout signup + ssss threepid diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt index 82594f2645..33d4e9dbd2 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt @@ -79,10 +79,10 @@ class QuadSTests : InstrumentedTest { var accountData: UserAccountDataEvent? = null val liveAccountData = runBlocking(Dispatchers.Main) { - aliceSession.getLiveAccountDataEvent("m.secret_storage.key.$TEST_KEY_ID") + aliceSession.getLiveAccountDataEvent("${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") } val accountDataObserver = Observer?> { t -> - if (t?.getOrNull()?.type == "m.secret_storage.key.$TEST_KEY_ID") { + if (t?.getOrNull()?.type == "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$TEST_KEY_ID") { accountData = t.getOrNull() accountDataLock.countDown() } @@ -328,7 +328,7 @@ class QuadSTests : InstrumentedTest { quadS.generateKey(keyId, keyId, emptyKeySigner, it) } - assertAccountData(session, "m.secret_storage.key.$keyId") + assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId") if (asDefault) { mTestHelper.doSync { @@ -353,7 +353,7 @@ class QuadSTests : InstrumentedTest { it) } - assertAccountData(session, "m.secret_storage.key.$keyId") + assertAccountData(session, "${DefaultSharedSecretStorageService.KEY_ID_BASE}.$keyId") if (asDefault) { val setDefaultLatch = CountDownLatch(1) quadS.setDefaultKey(keyId, TestMatrixCallback(setDefaultLatch)) From 7ddea99fc6f8246c7004b409180266f733c5c3fd Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 18:51:27 +0100 Subject: [PATCH 04/16] Move and improve withOlmDecryption() and withOlmEncryption() --- .../internal/crypto/ssss/QuadSTests.kt | 7 +-- .../DefaultSharedSecretStorageService.kt | 54 ++++++------------- .../android/internal/crypto/tools/Tools.kt | 38 +++++++++++++ 3 files changed, 58 insertions(+), 41 deletions(-) create mode 100644 matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/tools/Tools.kt diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt index 33d4e9dbd2..7802096338 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/ssss/QuadSTests.kt @@ -35,6 +35,7 @@ import im.vector.matrix.android.common.TestMatrixCallback import im.vector.matrix.android.internal.crypto.SSSS_ALGORITHM_CURVE25519_AES_SHA2 import im.vector.matrix.android.internal.crypto.crosssigning.toBase64NoPadding import im.vector.matrix.android.internal.crypto.secrets.DefaultSharedSecretStorageService +import im.vector.matrix.android.internal.crypto.tools.withOlmDecryption import im.vector.matrix.android.internal.session.sync.model.accountdata.UserAccountDataEvent import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.GlobalScope @@ -100,10 +101,10 @@ class QuadSTests : InstrumentedTest { assertNotNull("Pubkey should be defined", parsed.publicKey) val privateKeySpec = Curve25519AesSha2KeySpec.fromRecoveryKey(ssssKeyCreationInfo.recoveryKey) - DefaultSharedSecretStorageService.withOlmDecryption { olmPkDecryption -> - val pubKey = olmPkDecryption.setPrivateKey(privateKeySpec!!.privateKey) - assertEquals("Unexpected Public Key", pubKey, parsed.publicKey) + val pubKey = withOlmDecryption { olmPkDecryption -> + olmPkDecryption.setPrivateKey(privateKeySpec!!.privateKey) } + assertEquals("Unexpected Public Key", pubKey, parsed.publicKey) // Set as default key quadS.setDefaultKey(TEST_KEY_ID, object : MatrixCallback {}) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt index f741021e6c..37b29047fc 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt @@ -25,21 +25,21 @@ import im.vector.matrix.android.api.session.securestorage.EncryptedSecretContent import im.vector.matrix.android.api.session.securestorage.KeyInfo import im.vector.matrix.android.api.session.securestorage.KeyInfoResult import im.vector.matrix.android.api.session.securestorage.KeySigner -import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo import im.vector.matrix.android.api.session.securestorage.SSSSKeySpec import im.vector.matrix.android.api.session.securestorage.SSSSPassphrase import im.vector.matrix.android.api.session.securestorage.SecretStorageKeyContent import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageError import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageService +import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo import im.vector.matrix.android.internal.crypto.SSSS_ALGORITHM_CURVE25519_AES_SHA2 import im.vector.matrix.android.internal.crypto.keysbackup.generatePrivateKeyWithPassword import im.vector.matrix.android.internal.crypto.keysbackup.util.computeRecoveryKey +import im.vector.matrix.android.internal.crypto.tools.withOlmEncryption import im.vector.matrix.android.internal.extensions.foldToCallback import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.launch import org.matrix.olm.OlmPkDecryption -import org.matrix.olm.OlmPkEncryption import org.matrix.olm.OlmPkMessage import javax.inject.Inject @@ -198,15 +198,15 @@ internal class DefaultSharedSecretStorageService @Inject constructor( when (key) { is KeyInfoResult.Success -> { if (key.keyInfo.content.algorithm == SSSS_ALGORITHM_CURVE25519_AES_SHA2) { - withOlmEncryption { olmEncrypt -> + val encryptedResult = withOlmEncryption { olmEncrypt -> olmEncrypt.setRecipientKey(key.keyInfo.content.publicKey) - val encryptedResult = olmEncrypt.encrypt(secretBase64) - encryptedContents[key.keyInfo.id] = EncryptedSecretContent( - ciphertext = encryptedResult.mCipherText, - ephemeral = encryptedResult.mEphemeralKey, - mac = encryptedResult.mMac - ) + olmEncrypt.encrypt(secretBase64) } + encryptedContents[key.keyInfo.id] = EncryptedSecretContent( + ciphertext = encryptedResult.mCipherText, + ephemeral = encryptedResult.mEphemeralKey, + mac = encryptedResult.mMac + ) } else { // Unknown algorithm callback.onFailure(SharedSecretStorageError.UnknownAlgorithm(key.keyInfo.content.algorithm ?: "")) @@ -226,15 +226,15 @@ internal class DefaultSharedSecretStorageService @Inject constructor( when (key) { is KeyInfoResult.Success -> { if (key.keyInfo.content.algorithm == SSSS_ALGORITHM_CURVE25519_AES_SHA2) { - withOlmEncryption { olmEncrypt -> + val encryptedResult = withOlmEncryption { olmEncrypt -> olmEncrypt.setRecipientKey(key.keyInfo.content.publicKey) - val encryptedResult = olmEncrypt.encrypt(secretBase64) - encryptedContents[keyId] = EncryptedSecretContent( - ciphertext = encryptedResult.mCipherText, - ephemeral = encryptedResult.mEphemeralKey, - mac = encryptedResult.mMac - ) + olmEncrypt.encrypt(secretBase64) } + encryptedContents[keyId] = EncryptedSecretContent( + ciphertext = encryptedResult.mCipherText, + ephemeral = encryptedResult.mEphemeralKey, + mac = encryptedResult.mMac + ) } else { // Unknown algorithm callback.onFailure(SharedSecretStorageError.UnknownAlgorithm(key.keyInfo.content.algorithm ?: "")) @@ -332,27 +332,5 @@ internal class DefaultSharedSecretStorageService @Inject constructor( const val KEY_ID_BASE = "m.secret_storage.key" const val ENCRYPTED = "encrypted" const val DEFAULT_KEY_ID = "m.secret_storage.default_key" - - fun withOlmEncryption(block: (OlmPkEncryption) -> Unit) { - val olmPkEncryption = OlmPkEncryption() - try { - block(olmPkEncryption) - } catch (failure: Throwable) { - throw failure - } finally { - olmPkEncryption.releaseEncryption() - } - } - - fun withOlmDecryption(block: (OlmPkDecryption) -> Unit) { - val olmPkDecryption = OlmPkDecryption() - try { - block(olmPkDecryption) - } catch (failure: Throwable) { - throw failure - } finally { - olmPkDecryption.releaseDecryption() - } - } } } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/tools/Tools.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/tools/Tools.kt new file mode 100644 index 0000000000..260e6165ba --- /dev/null +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/tools/Tools.kt @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2020 New Vector Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package im.vector.matrix.android.internal.crypto.tools + +import org.matrix.olm.OlmPkDecryption +import org.matrix.olm.OlmPkEncryption + +fun withOlmEncryption(block: (OlmPkEncryption) -> T): T { + val olmPkEncryption = OlmPkEncryption() + try { + return block(olmPkEncryption) + } finally { + olmPkEncryption.releaseEncryption() + } +} + +fun withOlmDecryption(block: (OlmPkDecryption) -> T): T { + val olmPkDecryption = OlmPkDecryption() + try { + return block(olmPkDecryption) + } finally { + olmPkDecryption.releaseDecryption() + } +} From a305ce302eb9cb5387b09573e79821db6e13ce5e Mon Sep 17 00:00:00 2001 From: Ganard Date: Tue, 11 Feb 2020 12:08:47 +0100 Subject: [PATCH 05/16] Coroutine sequencer: use semaphore --- .../session/sync/SyncTaskSequencer.kt | 4 +- .../internal/task/CoroutineSequencer.kt | 63 +++---------------- .../internal/task/CoroutineSequencersTest.kt | 10 +-- 3 files changed, 16 insertions(+), 61 deletions(-) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/SyncTaskSequencer.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/SyncTaskSequencer.kt index bfa49b7af5..d2d393de00 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/SyncTaskSequencer.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/SyncTaskSequencer.kt @@ -17,8 +17,8 @@ package im.vector.matrix.android.internal.session.sync import im.vector.matrix.android.internal.session.SessionScope -import im.vector.matrix.android.internal.task.ChannelCoroutineSequencer +import im.vector.matrix.android.internal.task.SemaphoreCoroutineSequencer import javax.inject.Inject @SessionScope -internal class SyncTaskSequencer @Inject constructor() : ChannelCoroutineSequencer() +internal class SyncTaskSequencer @Inject constructor() : SemaphoreCoroutineSequencer() diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt index 7062c63816..d36b769ef3 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt @@ -16,72 +16,27 @@ package im.vector.matrix.android.internal.task -import kotlinx.coroutines.* -import kotlinx.coroutines.channels.Channel -import java.util.concurrent.Executors +import kotlinx.coroutines.sync.Semaphore +import kotlinx.coroutines.sync.withPermit /** * This class intends to be used for ensure suspendable methods are played sequentially all the way long. */ -internal interface CoroutineSequencer { +internal interface CoroutineSequencer { /** * @param block the suspendable block to execute * @return the result of the block */ - suspend fun post(block: suspend () -> T): T - - /** - * Cancel all and close, so you won't be able to post anything else after - */ - fun close() + suspend fun post(block: suspend () -> T): T } -internal open class ChannelCoroutineSequencer : CoroutineSequencer { +internal open class SemaphoreCoroutineSequencer : CoroutineSequencer { - private data class Message( - val block: suspend () -> T, - val deferred: CompletableDeferred - ) + private val semaphore = Semaphore(1) // Permits 1 suspend function at a time. - private var messageChannel: Channel> = Channel() - private val coroutineScope = CoroutineScope(SupervisorJob()) - // This will ensure - private val singleDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher() - - init { - launchCoroutine() - } - - private fun launchCoroutine() { - coroutineScope.launch(singleDispatcher) { - for (message in messageChannel) { - try { - val result = message.block() - message.deferred.complete(result) - } catch (exception: Throwable) { - message.deferred.completeExceptionally(exception) - } - } - } - } - - override fun close() { - coroutineScope.coroutineContext.cancelChildren() - messageChannel.close() - } - - override suspend fun post(block: suspend () -> T): T { - val deferred = CompletableDeferred() - val message = Message(block, deferred) - messageChannel.send(message) - return try { - deferred.await() - } catch (cancellation: CancellationException) { - // In case of cancellation, we stop the current coroutine context - // and relaunch one to consume next messages - coroutineScope.coroutineContext.cancelChildren() - launchCoroutine() - throw cancellation + override suspend fun post(block: suspend () -> T): T { + return semaphore.withPermit { + block() } } } diff --git a/matrix-sdk-android/src/test/java/im/vector/matrix/android/internal/task/CoroutineSequencersTest.kt b/matrix-sdk-android/src/test/java/im/vector/matrix/android/internal/task/CoroutineSequencersTest.kt index 9591feaa32..a70713c44b 100644 --- a/matrix-sdk-android/src/test/java/im/vector/matrix/android/internal/task/CoroutineSequencersTest.kt +++ b/matrix-sdk-android/src/test/java/im/vector/matrix/android/internal/task/CoroutineSequencersTest.kt @@ -32,7 +32,7 @@ class CoroutineSequencersTest { @Test fun sequencer_should_run_sequential() { - val sequencer = ChannelCoroutineSequencer() + val sequencer = SemaphoreCoroutineSequencer() val results = ArrayList() val jobs = listOf( @@ -63,9 +63,9 @@ class CoroutineSequencersTest { @Test fun sequencer_should_run_parallel() { - val sequencer1 = ChannelCoroutineSequencer() - val sequencer2 = ChannelCoroutineSequencer() - val sequencer3 = ChannelCoroutineSequencer() + val sequencer1 = SemaphoreCoroutineSequencer() + val sequencer2 = SemaphoreCoroutineSequencer() + val sequencer3 = SemaphoreCoroutineSequencer() val results = ArrayList() val jobs = listOf( GlobalScope.launch(dispatcher) { @@ -92,7 +92,7 @@ class CoroutineSequencersTest { @Test fun sequencer_should_jump_to_next_when_current_job_canceled() { - val sequencer = ChannelCoroutineSequencer() + val sequencer = SemaphoreCoroutineSequencer() val results = ArrayList() val jobs = listOf( GlobalScope.launch(dispatcher) { From 2d6f57e21456020549f770ff7cb845f73221bf9c Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 20:50:21 +0100 Subject: [PATCH 06/16] More cleanup/code lisibility --- .../securestorage/SecretStorageKeyContent.kt | 33 +++---- .../securestorage/SharedSecretStorageError.kt | 1 - .../SharedSecretStorageService.kt | 2 +- .../api/session/securestorage/SsssKeySpec.kt | 4 +- .../DefaultSharedSecretStorageService.kt | 86 +++++++++---------- 5 files changed, 61 insertions(+), 65 deletions(-) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt index 02c3e96658..f803011415 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt @@ -54,25 +54,28 @@ data class SecretStorageKeyContent( /** Currently support m.secret_storage.v1.curve25519-aes-sha2 */ @Json(name = "algorithm") val algorithm: String? = null, @Json(name = "name") val name: String? = null, - @Json(name = "passphrase") val passphrase: SSSSPassphrase? = null, + @Json(name = "passphrase") val passphrase: SsssPassphrase? = null, @Json(name = "pubkey") val publicKey: String? = null, - @Json(name = "signatures") - var signatures: Map>? = null + @Json(name = "signatures") val signatures: Map>? = null ) { private fun signalableJSONDictionary(): Map { - val map = HashMap() - algorithm?.let { map["algorithm"] = it } - name?.let { map["name"] = it } - publicKey?.let { map["pubkey"] = it } - passphrase?.let { ssspp -> - map["passphrase"] = mapOf( - "algorithm" to ssspp.algorithm, - "iterations" to ssspp.salt, - "salt" to ssspp.salt - ) + return mutableMapOf().apply { + algorithm + ?.let { this["algorithm"] = it } + name + ?.let { this["name"] = it } + publicKey + ?.let { this["pubkey"] = it } + passphrase + ?.let { ssssPassphrase -> + this["passphrase"] = mapOf( + "algorithm" to ssssPassphrase.algorithm, + "iterations" to ssssPassphrase.salt, + "salt" to ssssPassphrase.salt + ) + } } - return map } fun canonicalSignable(): String { @@ -93,7 +96,7 @@ data class SecretStorageKeyContent( } @JsonClass(generateAdapter = true) -data class SSSSPassphrase( +data class SsssPassphrase( @Json(name = "algorithm") val algorithm: String?, @Json(name = "iterations") val iterations: Int, @Json(name = "salt") val salt: String? diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageError.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageError.kt index f882375e5c..e1a216ab37 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageError.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageError.kt @@ -17,7 +17,6 @@ package im.vector.matrix.android.api.session.securestorage sealed class SharedSecretStorageError(message: String?) : Throwable(message) { - data class UnknownSecret(val secretName: String) : SharedSecretStorageError("Unknown Secret $secretName") data class UnknownKey(val keyId: String) : SharedSecretStorageError("Unknown key $keyId") data class UnknownAlgorithm(val keyId: String) : SharedSecretStorageError("Unknown algorithm $keyId") diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageService.kt index 02ccc11026..35579f756c 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SharedSecretStorageService.kt @@ -108,5 +108,5 @@ interface SharedSecretStorageService { * */ @Throws - fun getSecret(name: String, keyId: String?, secretKey: SSSSKeySpec, callback: MatrixCallback) + fun getSecret(name: String, keyId: String?, secretKey: SsssKeySpec, callback: MatrixCallback) } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SsssKeySpec.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SsssKeySpec.kt index 9e61f7f8ff..90dcb92449 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SsssKeySpec.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SsssKeySpec.kt @@ -21,11 +21,11 @@ import im.vector.matrix.android.internal.crypto.keysbackup.deriveKey import im.vector.matrix.android.internal.crypto.keysbackup.util.extractCurveKeyFromRecoveryKey /** Tag class */ -interface SSSSKeySpec +interface SsssKeySpec data class Curve25519AesSha2KeySpec( val privateKey: ByteArray -) : SSSSKeySpec { +) : SsssKeySpec { companion object { diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt index 37b29047fc..4bc68f86c2 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/secrets/DefaultSharedSecretStorageService.kt @@ -25,8 +25,8 @@ import im.vector.matrix.android.api.session.securestorage.EncryptedSecretContent import im.vector.matrix.android.api.session.securestorage.KeyInfo import im.vector.matrix.android.api.session.securestorage.KeyInfoResult import im.vector.matrix.android.api.session.securestorage.KeySigner -import im.vector.matrix.android.api.session.securestorage.SSSSKeySpec -import im.vector.matrix.android.api.session.securestorage.SSSSPassphrase +import im.vector.matrix.android.api.session.securestorage.SsssKeySpec +import im.vector.matrix.android.api.session.securestorage.SsssPassphrase import im.vector.matrix.android.api.session.securestorage.SecretStorageKeyContent import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageError import im.vector.matrix.android.api.session.securestorage.SharedSecretStorageService @@ -34,15 +34,21 @@ import im.vector.matrix.android.api.session.securestorage.SsssKeyCreationInfo import im.vector.matrix.android.internal.crypto.SSSS_ALGORITHM_CURVE25519_AES_SHA2 import im.vector.matrix.android.internal.crypto.keysbackup.generatePrivateKeyWithPassword import im.vector.matrix.android.internal.crypto.keysbackup.util.computeRecoveryKey +import im.vector.matrix.android.internal.crypto.tools.withOlmDecryption import im.vector.matrix.android.internal.crypto.tools.withOlmEncryption import im.vector.matrix.android.internal.extensions.foldToCallback import im.vector.matrix.android.internal.util.MatrixCoroutineDispatchers import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.launch -import org.matrix.olm.OlmPkDecryption import org.matrix.olm.OlmPkMessage import javax.inject.Inject +private data class Key( + val publicKey: String, + @Suppress("ArrayInDataClass") + val privateKey: ByteArray +) + internal class DefaultSharedSecretStorageService @Inject constructor( private val accountDataService: AccountDataService, private val coroutineDispatchers: MatrixCoroutineDispatchers, @@ -54,25 +60,22 @@ internal class DefaultSharedSecretStorageService @Inject constructor( keySigner: KeySigner, callback: MatrixCallback) { cryptoCoroutineScope.launch(coroutineDispatchers.main) { - val pkDecryption = OlmPkDecryption() - val pubKey: String - val privateKey: ByteArray - try { - pubKey = pkDecryption.generateKey() - privateKey = pkDecryption.privateKey() - } catch (failure: Throwable) { - return@launch Unit.also { - callback.onFailure(failure) + val key = try { + withOlmDecryption { olmPkDecryption -> + val pubKey = olmPkDecryption.generateKey() + val privateKey = olmPkDecryption.privateKey() + Key(pubKey, privateKey) } - } finally { - pkDecryption.releaseDecryption() + } catch (failure: Throwable) { + callback.onFailure(failure) + return@launch } val storageKeyContent = SecretStorageKeyContent( name = keyName, algorithm = SSSS_ALGORITHM_CURVE25519_AES_SHA2, passphrase = null, - publicKey = pubKey + publicKey = key.publicKey ) val signedContent = keySigner.sign(storageKeyContent.canonicalSignable())?.let { @@ -93,7 +96,7 @@ internal class DefaultSharedSecretStorageService @Inject constructor( callback.onSuccess(SsssKeyCreationInfo( keyId = keyId, content = storageKeyContent, - recoveryKey = computeRecoveryKey(privateKey) + recoveryKey = computeRecoveryKey(key.privateKey) )) } } @@ -110,21 +113,18 @@ internal class DefaultSharedSecretStorageService @Inject constructor( cryptoCoroutineScope.launch(coroutineDispatchers.main) { val privatePart = generatePrivateKeyWithPassword(passphrase, progressListener) - val pkDecryption = OlmPkDecryption() - val pubKey: String - try { - pubKey = pkDecryption.setPrivateKey(privatePart.privateKey) - } catch (failure: Throwable) { - return@launch Unit.also { - callback.onFailure(failure) + val pubKey = try { + withOlmDecryption { olmPkDecryption -> + olmPkDecryption.setPrivateKey(privatePart.privateKey) } - } finally { - pkDecryption.releaseDecryption() + } catch (failure: Throwable) { + callback.onFailure(failure) + return@launch } val storageKeyContent = SecretStorageKeyContent( algorithm = SSSS_ALGORITHM_CURVE25519_AES_SHA2, - passphrase = SSSSPassphrase(algorithm = "m.pbkdf2", iterations = privatePart.iterations, salt = privatePart.salt), + passphrase = SsssPassphrase(algorithm = "m.pbkdf2", iterations = privatePart.iterations, salt = privatePart.salt), publicKey = pubKey ) @@ -192,10 +192,9 @@ internal class DefaultSharedSecretStorageService @Inject constructor( cryptoCoroutineScope.launch(coroutineDispatchers.main) { val encryptedContents = HashMap() try { - if (keys == null || keys.isEmpty()) { + if (keys.isNullOrEmpty()) { // use default key - val key = getDefaultKey() - when (key) { + when (val key = getDefaultKey()) { is KeyInfoResult.Success -> { if (key.keyInfo.content.algorithm == SSSS_ALGORITHM_CURVE25519_AES_SHA2) { val encryptedResult = withOlmEncryption { olmEncrypt -> @@ -222,8 +221,7 @@ internal class DefaultSharedSecretStorageService @Inject constructor( keys.forEach { val keyId = it // encrypt the content - val key = getKey(keyId) - when (key) { + when (val key = getKey(keyId)) { is KeyInfoResult.Success -> { if (key.keyInfo.content.algorithm == SSSS_ALGORITHM_CURVE25519_AES_SHA2) { val encryptedResult = withOlmEncryption { olmEncrypt -> @@ -279,7 +277,7 @@ internal class DefaultSharedSecretStorageService @Inject constructor( return results } - override fun getSecret(name: String, keyId: String?, secretKey: SSSSKeySpec, callback: MatrixCallback) { + override fun getSecret(name: String, keyId: String?, secretKey: SsssKeySpec, callback: MatrixCallback) { val accountData = accountDataService.getAccountDataEvent(name) ?: return Unit.also { callback.onFailure(SharedSecretStorageError.UnknownSecret(name)) } @@ -306,20 +304,16 @@ internal class DefaultSharedSecretStorageService @Inject constructor( } cryptoCoroutineScope.launch(coroutineDispatchers.main) { kotlin.runCatching { - // decryt from recovery key - val keyBytes = keySpec.privateKey - val decryption = OlmPkDecryption() - try { - decryption.setPrivateKey(keyBytes) - decryption.decrypt(OlmPkMessage().apply { - mCipherText = secretContent.ciphertext - mEphemeralKey = secretContent.ephemeral - mMac = secretContent.mac - }) - } catch (failure: Throwable) { - throw failure - } finally { - decryption.releaseDecryption() + // decrypt from recovery key + withOlmDecryption { olmPkDecryption -> + olmPkDecryption.setPrivateKey(keySpec.privateKey) + olmPkDecryption.decrypt(OlmPkMessage() + .apply { + mCipherText = secretContent.ciphertext + mEphemeralKey = secretContent.ephemeral + mMac = secretContent.mac + } + ) } }.foldToCallback(callback) } From 446d826dd3643b08d70ff5be8557a50d20f2ca90 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 20:53:45 +0100 Subject: [PATCH 07/16] Create tag interface AccountDataContent --- .../securestorage/EncryptedSecretContent.kt | 3 ++- .../sync/model/accountdata/UserAccountData.kt | 3 ++- .../user/accountdata/AccountDataContent.kt | 22 +++++++++++++++++++ 3 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/AccountDataContent.kt diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/EncryptedSecretContent.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/EncryptedSecretContent.kt index 4c8b51c668..f88b39fd13 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/EncryptedSecretContent.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/EncryptedSecretContent.kt @@ -19,6 +19,7 @@ package im.vector.matrix.android.api.session.securestorage import com.squareup.moshi.Json import com.squareup.moshi.JsonClass import im.vector.matrix.android.internal.di.MoshiProvider +import im.vector.matrix.android.internal.session.user.accountdata.AccountDataContent /** * The account_data will have an encrypted property that is a map from key ID to an object. @@ -32,7 +33,7 @@ data class EncryptedSecretContent( @Json(name = "ciphertext") val ciphertext: String? = null, @Json(name = "mac") val mac: String? = null, @Json(name = "ephemeral") val ephemeral: String? = null -) { +) : AccountDataContent { companion object { /** * Facility method to convert from object which must be comprised of maps, lists, diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/model/accountdata/UserAccountData.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/model/accountdata/UserAccountData.kt index 3ec6c3c7eb..c508413665 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/model/accountdata/UserAccountData.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/sync/model/accountdata/UserAccountData.kt @@ -17,8 +17,9 @@ package im.vector.matrix.android.internal.session.sync.model.accountdata import com.squareup.moshi.Json +import im.vector.matrix.android.internal.session.user.accountdata.AccountDataContent -abstract class UserAccountData { +abstract class UserAccountData : AccountDataContent { @Json(name = "type") abstract val type: String diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/AccountDataContent.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/AccountDataContent.kt new file mode 100644 index 0000000000..5335f8a7f1 --- /dev/null +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/AccountDataContent.kt @@ -0,0 +1,22 @@ +/* + * Copyright (c) 2020 New Vector Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package im.vector.matrix.android.internal.session.user.accountdata + +/** + * Tag class to identify every account data content + */ +internal interface AccountDataContent From 76085a42845840865cd97db794b53bc2a611673a Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 21:26:16 +0100 Subject: [PATCH 08/16] AccountData cleanup and Javadoc --- .../java/im/vector/matrix/rx/RxSession.kt | 6 ++-- .../session/accountdata/AccountDataService.kt | 25 ++++++++++++++--- .../android/internal/session/SessionModule.kt | 2 +- .../accountdata/DefaultAccountDataService.kt | 28 +++++++++---------- .../settings/devtools/AccountDataViewModel.kt | 2 +- 5 files changed, 40 insertions(+), 23 deletions(-) diff --git a/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt b/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt index 0417504cb7..960c00bb71 100644 --- a/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt +++ b/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt @@ -123,10 +123,10 @@ class RxSession(private val session: Session) { } } - fun liveAccountData(filter: List): Observable> { - return session.getLiveAccountDataEvents(filter).asObservable() + fun liveAccountData(types: Set): Observable> { + return session.getLiveAccountDataEvents(types).asObservable() .startWithCallable { - session.getAccountDataEvents(filter) + session.getAccountDataEvents(types) } } } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/accountdata/AccountDataService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/accountdata/AccountDataService.kt index 7af7fea214..ee13d1f097 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/accountdata/AccountDataService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/accountdata/AccountDataService.kt @@ -19,18 +19,35 @@ package im.vector.matrix.android.api.session.accountdata import androidx.lifecycle.LiveData import im.vector.matrix.android.api.MatrixCallback import im.vector.matrix.android.api.session.events.model.Content +import im.vector.matrix.android.api.util.Cancelable import im.vector.matrix.android.api.util.Optional import im.vector.matrix.android.internal.session.sync.model.accountdata.UserAccountDataEvent interface AccountDataService { - + /** + * Retrieve the account data with the provided type or null if not found + */ fun getAccountDataEvent(type: String): UserAccountDataEvent? + /** + * Observe the account data with the provided type + */ fun getLiveAccountDataEvent(type: String): LiveData> - fun getAccountDataEvents(filterType: List): List + /** + * Retrieve the account data with the provided types. The return list can have a different size that + * the size of the types set, because some AccountData may not exist. + * If an empty set is provided, all the AccountData are retrieved + */ + fun getAccountDataEvents(types: Set): List - fun getLiveAccountDataEvents(filterType: List): LiveData> + /** + * Observe the account data with the provided types. If an empty set is provided, all the AccountData are observed + */ + fun getLiveAccountDataEvents(types: Set): LiveData> - fun updateAccountData(type: String, content: Content, callback: MatrixCallback? = null) + /** + * Update the account data with the provided type and the provided account data content + */ + fun updateAccountData(type: String, content: Content, callback: MatrixCallback? = null): Cancelable } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/SessionModule.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/SessionModule.kt index 7352b79073..908c610914 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/SessionModule.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/SessionModule.kt @@ -269,7 +269,7 @@ internal abstract class SessionModule { abstract fun bindHomeServerCapabilitiesService(homeServerCapabilitiesService: DefaultHomeServerCapabilitiesService): HomeServerCapabilitiesService @Binds - abstract fun bindAccountDataService(accountDataService: DefaultAccountDataService): AccountDataService + abstract fun bindAccountDataService(service: DefaultAccountDataService): AccountDataService @Binds abstract fun bindSharedSecretStorageService(service: DefaultSharedSecretStorageService): SharedSecretStorageService diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/DefaultAccountDataService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/DefaultAccountDataService.kt index b40c75992a..7756b22510 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/DefaultAccountDataService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/user/accountdata/DefaultAccountDataService.kt @@ -22,13 +22,13 @@ import com.zhuinden.monarchy.Monarchy import im.vector.matrix.android.api.MatrixCallback import im.vector.matrix.android.api.session.accountdata.AccountDataService import im.vector.matrix.android.api.session.events.model.Content +import im.vector.matrix.android.api.util.Cancelable import im.vector.matrix.android.api.util.JSON_DICT_PARAMETERIZED_TYPE import im.vector.matrix.android.api.util.Optional import im.vector.matrix.android.api.util.toOptional import im.vector.matrix.android.internal.database.model.UserAccountDataEntity import im.vector.matrix.android.internal.database.model.UserAccountDataEntityFields import im.vector.matrix.android.internal.di.MoshiProvider -import im.vector.matrix.android.internal.di.SessionId import im.vector.matrix.android.internal.session.sync.UserAccountDataSyncHandler import im.vector.matrix.android.internal.session.sync.model.accountdata.UserAccountDataEvent import im.vector.matrix.android.internal.task.TaskExecutor @@ -37,7 +37,6 @@ import javax.inject.Inject internal class DefaultAccountDataService @Inject constructor( private val monarchy: Monarchy, - @SessionId private val sessionId: String, private val updateUserAccountDataTask: UpdateUserAccountDataTask, private val userAccountDataSyncHandler: UserAccountDataSyncHandler, private val taskExecutor: TaskExecutor @@ -47,39 +46,39 @@ internal class DefaultAccountDataService @Inject constructor( private val adapter = moshi.adapter>(JSON_DICT_PARAMETERIZED_TYPE) override fun getAccountDataEvent(type: String): UserAccountDataEvent? { - return getAccountDataEvents(listOf(type)).firstOrNull() + return getAccountDataEvents(setOf(type)).firstOrNull() } override fun getLiveAccountDataEvent(type: String): LiveData> { - return Transformations.map(getLiveAccountDataEvents(listOf(type))) { + return Transformations.map(getLiveAccountDataEvents(setOf(type))) { it.firstOrNull()?.toOptional() } } - override fun getAccountDataEvents(filterType: List): List { + override fun getAccountDataEvents(types: Set): List { return monarchy.fetchAllCopiedSync { realm -> realm.where(UserAccountDataEntity::class.java) .apply { - if (filterType.isNotEmpty()) { - `in`(UserAccountDataEntityFields.TYPE, filterType.toTypedArray()) + if (types.isNotEmpty()) { + `in`(UserAccountDataEntityFields.TYPE, types.toTypedArray()) } } - }?.mapNotNull { entity -> + }.mapNotNull { entity -> entity.type?.let { type -> UserAccountDataEvent( type = type, content = entity.contentStr?.let { adapter.fromJson(it) } ?: emptyMap() ) } - } ?: emptyList() + } } - override fun getLiveAccountDataEvents(filterType: List): LiveData> { + override fun getLiveAccountDataEvents(types: Set): LiveData> { return monarchy.findAllMappedWithChanges({ realm -> realm.where(UserAccountDataEntity::class.java) .apply { - if (filterType.isNotEmpty()) { - `in`(UserAccountDataEntityFields.TYPE, filterType.toTypedArray()) + if (types.isNotEmpty()) { + `in`(UserAccountDataEntityFields.TYPE, types.toTypedArray()) } } }, { entity -> @@ -90,14 +89,15 @@ internal class DefaultAccountDataService @Inject constructor( }) } - override fun updateAccountData(type: String, content: Content, callback: MatrixCallback?) { - updateUserAccountDataTask.configureWith(UpdateUserAccountDataTask.AnyParams( + override fun updateAccountData(type: String, content: Content, callback: MatrixCallback?): Cancelable { + return updateUserAccountDataTask.configureWith(UpdateUserAccountDataTask.AnyParams( type = type, any = content )) { this.retryCount = 5 this.callback = object : MatrixCallback { override fun onSuccess(data: Unit) { + // TODO Move that to the task (but it created a circular dependencies...) monarchy.runTransactionSync { realm -> userAccountDataSyncHandler.handleGenericAccountData(realm, type, content) } diff --git a/vector/src/main/java/im/vector/riotx/features/settings/devtools/AccountDataViewModel.kt b/vector/src/main/java/im/vector/riotx/features/settings/devtools/AccountDataViewModel.kt index b0b23a62d1..32ce17c660 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/devtools/AccountDataViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/devtools/AccountDataViewModel.kt @@ -40,7 +40,7 @@ class AccountDataViewModel @AssistedInject constructor(@Assisted initialState: A : VectorViewModel(initialState) { init { - session.rx().liveAccountData(emptyList()) + session.rx().liveAccountData(emptySet()) .execute { copy(accountData = it) } From a61f508b5d9230620b3ea0cd819e1f5e3ca743b9 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Fri, 14 Feb 2020 22:00:36 +0100 Subject: [PATCH 09/16] Fix a nice bug --- .../api/session/securestorage/SecretStorageKeyContent.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt index f803011415..129f4bab9d 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/securestorage/SecretStorageKeyContent.kt @@ -71,7 +71,7 @@ data class SecretStorageKeyContent( ?.let { ssssPassphrase -> this["passphrase"] = mapOf( "algorithm" to ssssPassphrase.algorithm, - "iterations" to ssssPassphrase.salt, + "iterations" to ssssPassphrase.iterations, "salt" to ssssPassphrase.salt ) } From e349a35419ec4f07966470bc888d281b897b3985 Mon Sep 17 00:00:00 2001 From: ganfra Date: Sun, 16 Feb 2020 15:40:31 +0100 Subject: [PATCH 10/16] Crypto: expose cryptoService by a getter, removing the session implementation delegation --- .../java/im/vector/matrix/rx/RxSession.kt | 8 ++-- .../matrix/android/api/session/Session.kt | 7 +++- .../api/session/crypto/CryptoService.kt | 12 +++--- .../internal/crypto/DefaultCryptoService.kt | 6 +-- .../internal/session/DefaultSession.kt | 5 +-- .../vector/riotx/core/extensions/Session.kt | 4 +- .../features/crypto/keys/KeysExporter.kt | 2 +- .../features/crypto/keys/KeysImporter.kt | 2 +- .../KeysBackupRestoreFromKeyViewModel.kt | 2 +- .../KeysBackupRestoreSharedViewModel.kt | 2 +- ...eysBackupSettingsRecyclerViewController.kt | 4 +- .../settings/KeysBackupSettingsViewModel.kt | 6 +-- .../setup/KeysBackupSetupSharedViewModel.kt | 8 ++-- .../crypto/keysrequest/KeyRequestHandler.kt | 14 +++---- .../IncomingVerificationRequestHandler.kt | 6 +-- .../VerificationBottomSheetViewModel.kt | 38 ++++++++++--------- .../VerificationChooseMethodViewModel.kt | 10 ++--- .../emoji/VerificationEmojiCodeViewModel.kt | 6 +-- .../riotx/features/home/HomeActivity.kt | 4 +- .../home/room/detail/RoomDetailViewModel.kt | 8 ++-- .../edithistory/ViewEditHistoryViewModel.kt | 2 +- .../features/navigation/DefaultNavigator.kt | 6 +-- .../notifications/NotifiableEventResolver.kt | 2 +- .../riotx/features/rageshake/BugReporter.kt | 2 +- .../RoomMemberProfileViewModel.kt | 2 +- .../devices/DeviceListBottomSheetViewModel.kt | 2 +- .../members/RoomMemberListViewModel.kt | 4 +- .../VectorSettingsHelpAboutFragment.kt | 2 +- .../settings/VectorSettingsLabsFragment.kt | 2 +- .../VectorSettingsSecurityPrivacyFragment.kt | 14 +++---- .../CrossSigningSettingsViewModel.kt | 6 +-- ...iceVerificationInfoBottomSheetViewModel.kt | 2 +- .../settings/devices/DevicesViewModel.kt | 22 +++++------ .../workers/signout/SignOutViewModel.kt | 14 +++---- 34 files changed, 121 insertions(+), 115 deletions(-) diff --git a/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt b/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt index 0417504cb7..5146e3f199 100644 --- a/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt +++ b/matrix-sdk-android-rx/src/main/java/im/vector/matrix/rx/RxSession.kt @@ -111,15 +111,15 @@ class RxSession(private val session: Session) { } fun liveUserCryptoDevices(userId: String): Observable> { - return session.getLiveCryptoDeviceInfo(userId).asObservable().startWithCallable { - session.getCryptoDeviceInfo(userId) + return session.cryptoService().getLiveCryptoDeviceInfo(userId).asObservable().startWithCallable { + session.cryptoService().getCryptoDeviceInfo(userId) } } fun liveCrossSigningInfo(userId: String): Observable> { - return session.getCrossSigningService().getLiveCrossSigningKeys(userId).asObservable() + return session.cryptoService().crossSigningService().getLiveCrossSigningKeys(userId).asObservable() .startWithCallable { - session.getCrossSigningService().getUserCrossSigningKeys(userId).toOptional() + session.cryptoService().crossSigningService().getUserCrossSigningKeys(userId).toOptional() } } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt index 4167131c68..de981efdf0 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt @@ -39,6 +39,7 @@ import im.vector.matrix.android.api.session.signout.SignOutService import im.vector.matrix.android.api.session.sync.FilterService import im.vector.matrix.android.api.session.sync.SyncState import im.vector.matrix.android.api.session.user.UserService +import im.vector.matrix.android.internal.crypto.DefaultCryptoService /** * This interface defines interactions with a session. @@ -49,7 +50,6 @@ interface Session : RoomDirectoryService, GroupService, UserService, - CryptoService, CacheService, SignOutService, FilterService, @@ -139,6 +139,11 @@ interface Session : */ fun contentUploadProgressTracker(): ContentUploadStateTracker + /** + * Returns the cryptoService associated with the session + */ + fun cryptoService(): CryptoService + /** * Add a listener to the session. * @param listener the listener to add. diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/crypto/CryptoService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/crypto/CryptoService.kt index 46539d9029..d277c496e3 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/crypto/CryptoService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/crypto/CryptoService.kt @@ -40,6 +40,12 @@ import im.vector.matrix.android.internal.crypto.model.rest.RoomKeyRequestBody interface CryptoService { + fun verificationService(): VerificationService + + fun crossSigningService(): CrossSigningService + + fun keysBackupService(): KeysBackupService + fun setDeviceName(deviceId: String, deviceName: String, callback: MatrixCallback) fun deleteDevice(deviceId: String, callback: MatrixCallback) @@ -50,12 +56,6 @@ interface CryptoService { fun isCryptoEnabled(): Boolean - fun getVerificationService(): VerificationService - - fun getCrossSigningService(): CrossSigningService - - fun getKeysBackupService(): KeysBackupService - fun isRoomBlacklistUnverifiedDevices(roomId: String?): Boolean fun setWarnOnUnknownDevices(warn: Boolean) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt index 26a35bd919..593cbb493c 100755 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt @@ -340,14 +340,14 @@ internal class DefaultCryptoService @Inject constructor( /** * @return the Keys backup Service */ - override fun getKeysBackupService() = keysBackup + override fun keysBackupService() = keysBackup /** * @return the VerificationService */ - override fun getVerificationService() = verificationService + override fun verificationService() = verificationService - override fun getCrossSigningService() = crossSigningService + override fun crossSigningService() = crossSigningService /** * A sync response has been received diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt index 46264ceb85..c0141156f9 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt @@ -88,7 +88,6 @@ internal class DefaultSession @Inject constructor( private val syncThreadProvider: Provider, private val contentUrlResolver: ContentUrlResolver, private val syncTokenStore: SyncTokenStore, - private val syncTaskSequencer: SyncTaskSequencer, private val sessionParamsStore: SessionParamsStore, private val contentUploadProgressTracker: ContentUploadStateTracker, private val initialSyncProgressService: Lazy, @@ -101,7 +100,6 @@ internal class DefaultSession @Inject constructor( RoomDirectoryService by roomDirectoryService.get(), GroupService by groupService.get(), UserService by userService.get(), - CryptoService by cryptoService.get(), SignOutService by signOutService.get(), FilterService by filterService.get(), PushRuleService by pushRuleService.get(), @@ -170,7 +168,6 @@ internal class DefaultSession @Inject constructor( cryptoService.get().close() isOpen = false eventBus.unregister(this) - syncTaskSequencer.close() shieldTrustUpdater.stop() } @@ -212,6 +209,8 @@ internal class DefaultSession @Inject constructor( override fun contentUploadProgressTracker() = contentUploadProgressTracker + override fun cryptoService(): CryptoService = cryptoService.get() + override fun addListener(listener: Session.Listener) { sessionListeners.addListener(listener) } diff --git a/vector/src/main/java/im/vector/riotx/core/extensions/Session.kt b/vector/src/main/java/im/vector/riotx/core/extensions/Session.kt index 0a8345c650..eb3fca66c6 100644 --- a/vector/src/main/java/im/vector/riotx/core/extensions/Session.kt +++ b/vector/src/main/java/im/vector/riotx/core/extensions/Session.kt @@ -66,6 +66,6 @@ fun Session.startSyncing(context: Context) { * Tell is the session has unsaved e2e keys in the backup */ fun Session.hasUnsavedKeys(): Boolean { - return inboundGroupSessionsCount(false) > 0 - && getKeysBackupService().state != KeysBackupState.ReadyToBackUp + return cryptoService().inboundGroupSessionsCount(false) > 0 + && cryptoService().keysBackupService().state != KeysBackupState.ReadyToBackUp } diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysExporter.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysExporter.kt index 9642c2d8c6..cae8b50523 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysExporter.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysExporter.kt @@ -38,7 +38,7 @@ class KeysExporter(private val session: Session) { fun export(context: Context, password: String, callback: MatrixCallback) { GlobalScope.launch(Dispatchers.Main) { runCatching { - val data = awaitCallback { session.exportRoomKeys(password, it) } + val data = awaitCallback { session.cryptoService().exportRoomKeys(password, it) } withContext(Dispatchers.IO) { val parentDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS) val file = File(parentDir, "riotx-keys-" + System.currentTimeMillis() + ".txt") diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysImporter.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysImporter.kt index b60e25af04..5f550c032a 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysImporter.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keys/KeysImporter.kt @@ -59,7 +59,7 @@ class KeysImporter(private val session: Session) { } awaitCallback { - session.importRoomKeys(data, password, null, it) + session.cryptoService().importRoomKeys(data, password, null, it) } } }.foldToCallback(callback) diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt index 7ece88e086..7c95c3f3fe 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromKeyViewModel.kt @@ -47,7 +47,7 @@ class KeysBackupRestoreFromKeyViewModel @Inject constructor() : ViewModel() { fun recoverKeys(context: Context, sharedViewModel: KeysBackupRestoreSharedViewModel) { val session = sharedViewModel.session - val keysBackup = session.getKeysBackupService() + val keysBackup = session.cryptoService().keysBackupService() recoveryCodeErrorText.value = null val recoveryKey = recoveryCode.value!! diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt index 83b4daa383..5586d0cf05 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt @@ -63,7 +63,7 @@ class KeysBackupRestoreSharedViewModel @Inject constructor() : ViewModel() { } fun getLatestVersion(context: Context) { - val keysBackup = session.getKeysBackupService() + val keysBackup = session.cryptoService().keysBackupService() loadingEvent.value = WaitingViewData(context.getString(R.string.keys_backup_restore_is_getting_backup_version)) diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsRecyclerViewController.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsRecyclerViewController.kt index 7b60cb2f9b..4f2d806ce3 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsRecyclerViewController.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsRecyclerViewController.kt @@ -119,8 +119,8 @@ class KeysBackupSettingsRecyclerViewController @Inject constructor(private val s style(GenericItem.STYLE.BIG_TEXT) hasIndeterminateProcess(true) - val totalKeys = session.inboundGroupSessionsCount(false) - val backedUpKeys = session.inboundGroupSessionsCount(true) + val totalKeys = session.cryptoService().inboundGroupSessionsCount(false) + val backedUpKeys = session.cryptoService().inboundGroupSessionsCount(true) val remainingKeysToBackup = totalKeys - backedUpKeys diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsViewModel.kt index e4bbd39684..cdea487439 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/settings/KeysBackupSettingsViewModel.kt @@ -47,13 +47,13 @@ class KeysBackupSettingsViewModel @AssistedInject constructor(@Assisted initialS } } - private var keysBackupService: KeysBackupService = session.getKeysBackupService() + private val keysBackupService: KeysBackupService = session.cryptoService().keysBackupService() init { setState { this.copy( - keysBackupState = session.getKeysBackupService().state, - keysBackupVersion = session.getKeysBackupService().keysBackupVersion + keysBackupState = keysBackupService.state, + keysBackupVersion = keysBackupService.keysBackupVersion ) } keysBackupService.addListener(this) diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt index 8d9392a919..d9a90eb457 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt @@ -102,7 +102,7 @@ class KeysBackupSetupSharedViewModel @Inject constructor() : ViewModel() { session.let { mxSession -> val requestedId = currentRequestId.value!! - mxSession.getKeysBackupService().prepareKeysBackupVersion(withPassphrase, + mxSession.cryptoService().keysBackupService().prepareKeysBackupVersion(withPassphrase, object : ProgressListener { override fun onProgress(progress: Int, total: Int) { if (requestedId != currentRequestId.value) { @@ -125,7 +125,7 @@ class KeysBackupSetupSharedViewModel @Inject constructor() : ViewModel() { megolmBackupCreationInfo = data copyHasBeenMade = false - val keyBackup = session.getKeysBackupService() + val keyBackup = session.cryptoService().keysBackupService() createKeysBackup(context, keyBackup) } @@ -145,14 +145,14 @@ class KeysBackupSetupSharedViewModel @Inject constructor() : ViewModel() { } fun forceCreateKeyBackup(context: Context) { - val keyBackup = session.getKeysBackupService() + val keyBackup = session.cryptoService().keysBackupService() createKeysBackup(context, keyBackup, true) } fun stopAndKeepAfterDetectingExistingOnServer() { loadingStatus.value = null navigateEvent.value = LiveEvent(NAVIGATE_FINISH) - session.getKeysBackupService().checkAndStartKeysBackup() + session.cryptoService().keysBackupService().checkAndStartKeysBackup() } private fun createKeysBackup(context: Context, keysBackup: KeysBackupService, forceOverride: Boolean = false) { diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysrequest/KeyRequestHandler.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysrequest/KeyRequestHandler.kt index f890aef91b..a6f992a614 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysrequest/KeyRequestHandler.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysrequest/KeyRequestHandler.kt @@ -64,13 +64,13 @@ class KeyRequestHandler @Inject constructor(private val context: Context) fun start(session: Session) { this.session = session - session.getVerificationService().addListener(this) - session.addRoomKeysRequestListener(this) + session.cryptoService().verificationService().addListener(this) + session.cryptoService().addRoomKeysRequestListener(this) } fun stop() { - session?.getVerificationService()?.removeListener(this) - session?.removeRoomKeysRequestListener(this) + session?.cryptoService()?.verificationService()?.removeListener(this) + session?.cryptoService()?.removeRoomKeysRequestListener(this) session = null } @@ -100,7 +100,7 @@ class KeyRequestHandler @Inject constructor(private val context: Context) alertsToRequests[mappingKey] = ArrayList().apply { this.add(request) } // Add a notification for every incoming request - session?.downloadKeys(listOf(userId), false, object : MatrixCallback> { + session?.cryptoService()?.downloadKeys(listOf(userId), false, object : MatrixCallback> { override fun onSuccess(data: MXUsersDevicesMap) { val deviceInfo = data.getObject(userId, deviceId) @@ -111,12 +111,12 @@ class KeyRequestHandler @Inject constructor(private val context: Context) } if (deviceInfo.isUnknown) { - session?.setDeviceVerification(DeviceTrustLevel(false, false), userId, deviceId) + session?.cryptoService()?.setDeviceVerification(DeviceTrustLevel(false, false), userId, deviceId) deviceInfo.trustLevel = DeviceTrustLevel(false, false) // can we get more info on this device? - session?.getDevicesList(object : MatrixCallback { + session?.cryptoService()?.getDevicesList(object : MatrixCallback { override fun onSuccess(data: DevicesListResponse) { data.devices?.find { it.deviceId == deviceId }?.let { postAlert(context, userId, deviceId, true, deviceInfo, it) diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/verification/IncomingVerificationRequestHandler.kt b/vector/src/main/java/im/vector/riotx/features/crypto/verification/IncomingVerificationRequestHandler.kt index 8765dbc0d9..1cec40e7f1 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/verification/IncomingVerificationRequestHandler.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/verification/IncomingVerificationRequestHandler.kt @@ -40,11 +40,11 @@ class IncomingVerificationRequestHandler @Inject constructor(private val context fun start(session: Session) { this.session = session - session.getVerificationService().addListener(this) + session.cryptoService().verificationService().addListener(this) } fun stop() { - session?.getVerificationService()?.removeListener(this) + session?.cryptoService()?.verificationService()?.removeListener(this) this.session = null } @@ -139,7 +139,7 @@ class IncomingVerificationRequestHandler @Inject constructor(private val context } } dismissedAction = Runnable { - session?.getVerificationService()?.declineVerificationRequestInDMs(pr.otherUserId, + session?.cryptoService()?.verificationService()?.declineVerificationRequestInDMs(pr.otherUserId, pr.transactionId ?: "", pr.roomId ?: "" ) diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/verification/VerificationBottomSheetViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/verification/VerificationBottomSheetViewModel.kt index 85b878fe16..343f58b20c 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/verification/VerificationBottomSheetViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/verification/VerificationBottomSheetViewModel.kt @@ -63,7 +63,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini VerificationService.Listener { init { - session.getVerificationService().addListener(this) + session.cryptoService().verificationService().addListener(this) val userItem = session.getUser(args.otherUserId) @@ -73,7 +73,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini val pr = if (isWaitingForOtherMode) { // See if active tx for this user and take it - session.getVerificationService().getExistingVerificationRequest(args.otherUserId) + session.cryptoService().verificationService().getExistingVerificationRequest(args.otherUserId) ?.lastOrNull { !it.isFinished } ?.also { verificationRequest -> if (verificationRequest.isIncoming && !verificationRequest.isReady) { @@ -82,15 +82,15 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini } } } else { - session.getVerificationService().getExistingVerificationRequest(args.otherUserId, args.verificationId) + session.cryptoService().verificationService().getExistingVerificationRequest(args.otherUserId, args.verificationId) } val sasTx = (pr?.transactionId ?: args.verificationId)?.let { - session.getVerificationService().getExistingTransaction(args.otherUserId, it) as? SasVerificationTransaction + session.cryptoService().verificationService().getExistingTransaction(args.otherUserId, it) as? SasVerificationTransaction } val qrTx = (pr?.transactionId ?: args.verificationId)?.let { - session.getVerificationService().getExistingTransaction(args.otherUserId, it) as? QrCodeVerificationTransaction + session.cryptoService().verificationService().getExistingTransaction(args.otherUserId, it) as? QrCodeVerificationTransaction } setState { @@ -108,7 +108,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini if (autoReady) { // TODO, can I be here in DM mode? in this case should test if roomID is null? - session.getVerificationService() + session.cryptoService().verificationService() .readyPendingVerification(supportedVerificationMethods, pr!!.otherUserId, pr.transactionId ?: "") @@ -116,7 +116,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini } override fun onCleared() { - session.getVerificationService().removeListener(this) + session.cryptoService().verificationService().removeListener(this) super.onCleared() } @@ -164,7 +164,8 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini roomId = data, pendingRequest = Success( session - .getVerificationService() + .cryptoService() + .verificationService() .requestKeyVerificationInDMs(supportedVerificationMethods, otherUserId, data, pendingLocalId) ) ) @@ -181,7 +182,8 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini setState { copy( pendingRequest = Success(session - .getVerificationService() + .cryptoService() + .verificationService() .requestKeyVerificationInDMs(supportedVerificationMethods, otherUserId, roomId) ) ) @@ -190,18 +192,18 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini Unit } is VerificationAction.StartSASVerification -> { - val request = session.getVerificationService().getExistingVerificationRequest(otherUserId, action.pendingRequestTransactionId) + val request = session.cryptoService().verificationService().getExistingVerificationRequest(otherUserId, action.pendingRequestTransactionId) ?: return@withState val otherDevice = if (request.isIncoming) request.requestInfo?.fromDevice else request.readyInfo?.fromDevice if (roomId == null) { - session.getVerificationService().beginKeyVerification( + session.cryptoService().verificationService().beginKeyVerification( VerificationMethod.SAS, otherUserId = request.otherUserId, otherDeviceId = otherDevice ?: "", transactionId = action.pendingRequestTransactionId ) } else { - session.getVerificationService().beginKeyVerificationInDMs( + session.cryptoService().verificationService().beginKeyVerificationInDMs( VerificationMethod.SAS, transactionId = action.pendingRequestTransactionId, roomId = roomId, @@ -213,7 +215,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini Unit } is VerificationAction.RemoteQrCodeScanned -> { - val existingTransaction = session.getVerificationService() + val existingTransaction = session.cryptoService().verificationService() .getExistingTransaction(action.otherUserId, action.transactionId) as? QrCodeVerificationTransaction existingTransaction ?.userHasScannedOtherQrCode(action.scannedData) @@ -221,7 +223,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini is VerificationAction.OtherUserScannedSuccessfully -> { val transactionId = state.transactionId ?: return@withState - val existingTransaction = session.getVerificationService() + val existingTransaction = session.cryptoService().verificationService() .getExistingTransaction(otherUserId, transactionId) as? QrCodeVerificationTransaction existingTransaction ?.otherUserScannedMyQrCode() @@ -229,18 +231,18 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini is VerificationAction.OtherUserDidNotScanned -> { val transactionId = state.transactionId ?: return@withState - val existingTransaction = session.getVerificationService() + val existingTransaction = session.cryptoService().verificationService() .getExistingTransaction(otherUserId, transactionId) as? QrCodeVerificationTransaction existingTransaction ?.otherUserDidNotScannedMyQrCode() } is VerificationAction.SASMatchAction -> { - (session.getVerificationService() + (session.cryptoService().verificationService() .getExistingTransaction(action.otherUserId, action.sasTransactionId) as? SasVerificationTransaction)?.userHasVerifiedShortCode() } is VerificationAction.SASDoNotMatchAction -> { - (session.getVerificationService() + (session.cryptoService().verificationService() .getExistingTransaction(action.otherUserId, action.sasTransactionId) as? SasVerificationTransaction) ?.shortCodeDoesNotMatch() @@ -312,7 +314,7 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(@Assisted ini if (!pr.isReady) { // auto ready in this case, as we are waiting // TODO, can I be here in DM mode? in this case should test if roomID is null? - session.getVerificationService() + session.cryptoService().verificationService() .readyPendingVerification(supportedVerificationMethods, pr.otherUserId, pr.transactionId ?: "") diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt index bdb07ed0dc..1fcdfbf05b 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt @@ -62,7 +62,7 @@ class VerificationChooseMethodViewModel @AssistedInject constructor( } override fun verificationRequestUpdated(pr: PendingVerificationRequest) = withState { state -> - val pvr = session.getVerificationService().getExistingVerificationRequest(state.otherUserId, state.transactionId) + val pvr = session.cryptoService().verificationService().getExistingVerificationRequest(state.otherUserId, state.transactionId) setState { copy( @@ -79,12 +79,12 @@ class VerificationChooseMethodViewModel @AssistedInject constructor( } init { - session.getVerificationService().addListener(this) + session.cryptoService().verificationService().addListener(this) } override fun onCleared() { super.onCleared() - session.getVerificationService().removeListener(this) + session.cryptoService().verificationService().removeListener(this) } companion object : MvRxViewModelFactory { @@ -96,10 +96,10 @@ class VerificationChooseMethodViewModel @AssistedInject constructor( override fun initialState(viewModelContext: ViewModelContext): VerificationChooseMethodViewState? { val args: VerificationBottomSheet.VerificationArgs = viewModelContext.args() val session = (viewModelContext.activity as HasScreenInjector).injector().activeSessionHolder().getActiveSession() - val pvr = session.getVerificationService().getExistingVerificationRequest(args.otherUserId, args.verificationId) + val pvr = session.cryptoService().verificationService().getExistingVerificationRequest(args.otherUserId, args.verificationId) // Get the QR code now, because transaction is already created, so transactionCreated() will not be called - val qrCodeVerificationTransaction = session.getVerificationService().getExistingTransaction(args.otherUserId, args.verificationId ?: "") + val qrCodeVerificationTransaction = session.cryptoService().verificationService().getExistingTransaction(args.otherUserId, args.verificationId ?: "") return VerificationChooseMethodViewState(otherUserId = args.otherUserId, transactionId = args.verificationId ?: "", diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/verification/emoji/VerificationEmojiCodeViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/verification/emoji/VerificationEmojiCodeViewModel.kt index 637b7d7cc9..ad282f7dc9 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/verification/emoji/VerificationEmojiCodeViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/verification/emoji/VerificationEmojiCodeViewModel.kt @@ -56,16 +56,16 @@ class VerificationEmojiCodeViewModel @AssistedInject constructor( init { withState { state -> - refreshStateFromTx(session.getVerificationService() + refreshStateFromTx(session.cryptoService().verificationService() .getExistingTransaction(state.otherUser?.id ?: "", state.transactionId ?: "") as? SasVerificationTransaction) } - session.getVerificationService().addListener(this) + session.cryptoService().verificationService().addListener(this) } override fun onCleared() { - session.getVerificationService().removeListener(this) + session.cryptoService().verificationService().removeListener(this) super.onCleared() } diff --git a/vector/src/main/java/im/vector/riotx/features/home/HomeActivity.kt b/vector/src/main/java/im/vector/riotx/features/home/HomeActivity.kt index 94e14ab214..2eac4e946e 100644 --- a/vector/src/main/java/im/vector/riotx/features/home/HomeActivity.kt +++ b/vector/src/main/java/im/vector/riotx/features/home/HomeActivity.kt @@ -130,7 +130,7 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable { if (sharedActionViewModel.hasDisplayedCompleteSecurityPrompt) return // ensure keys are downloaded - session.downloadKeys(listOf(session.myUserId), true, object : MatrixCallback> { + session.cryptoService().downloadKeys(listOf(session.myUserId), true, object : MatrixCallback> { override fun onSuccess(data: MXUsersDevicesMap) { runOnUiThread { alertCompleteSecurity(session) @@ -140,7 +140,7 @@ class HomeActivity : VectorBaseActivity(), ToolbarConfigurable { } private fun alertCompleteSecurity(session: Session) { - val myCrossSigningKeys = session.getCrossSigningService() + val myCrossSigningKeys = session.cryptoService().crossSigningService() .getMyCrossSigningKeys() val crossSigningEnabledOnAccount = myCrossSigningKeys != null diff --git a/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt b/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt index 2ca372707f..47738d3cf4 100644 --- a/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt @@ -420,7 +420,7 @@ class RoomDetailViewModel @AssistedInject constructor(@Assisted initialState: Ro popDraft() } is ParsedCommand.VerifyUser -> { - session.getVerificationService().requestKeyVerificationInDMs(supportedVerificationMethods, slashCommandResult.userId, room.roomId) + session.cryptoService().verificationService().requestKeyVerificationInDMs(supportedVerificationMethods, slashCommandResult.userId, room.roomId) _viewEvents.post(RoomDetailViewEvents.SlashCommandHandled()) popDraft() } @@ -826,7 +826,7 @@ class RoomDetailViewModel @AssistedInject constructor(@Assisted initialState: Ro private fun handleAcceptVerification(action: RoomDetailAction.AcceptVerificationRequest) { Timber.v("## SAS handleAcceptVerification ${action.otherUserId}, roomId:${room.roomId}, txId:${action.transactionId}") - if (session.getVerificationService().readyPendingVerificationInDMs( + if (session.cryptoService().verificationService().readyPendingVerificationInDMs( supportedVerificationMethods, action.otherUserId, room.roomId, @@ -838,7 +838,7 @@ class RoomDetailViewModel @AssistedInject constructor(@Assisted initialState: Ro } private fun handleDeclineVerification(action: RoomDetailAction.DeclineVerificationRequest) { - session.getVerificationService().declineVerificationRequestInDMs( + session.cryptoService().verificationService().declineVerificationRequestInDMs( action.otherUserId, action.transactionId, room.roomId) @@ -851,7 +851,7 @@ class RoomDetailViewModel @AssistedInject constructor(@Assisted initialState: Ro private fun handleResumeRequestVerification(action: RoomDetailAction.ResumeVerification) { // Check if this request is still active and handled by me - session.getVerificationService().getExistingVerificationRequestInRoom(room.roomId, action.transactionId)?.let { + session.cryptoService().verificationService().getExistingVerificationRequestInRoom(room.roomId, action.transactionId)?.let { if (it.handledByOtherSession) return if (!it.isFinished) { _viewEvents.post(RoomDetailViewEvents.ActionSuccess(action.copy( diff --git a/vector/src/main/java/im/vector/riotx/features/home/room/detail/timeline/edithistory/ViewEditHistoryViewModel.kt b/vector/src/main/java/im/vector/riotx/features/home/room/detail/timeline/edithistory/ViewEditHistoryViewModel.kt index 3c98d24ccf..f03a1c8704 100644 --- a/vector/src/main/java/im/vector/riotx/features/home/room/detail/timeline/edithistory/ViewEditHistoryViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/home/room/detail/timeline/edithistory/ViewEditHistoryViewModel.kt @@ -100,7 +100,7 @@ class ViewEditHistoryViewModel @AssistedInject constructor(@Assisted if (it.isEncrypted() && it.mxDecryptionResult == null) { // for now decrypt sync try { - val result = session.decryptEvent(it, timelineID) + val result = session.cryptoService().decryptEvent(it, timelineID) it.mxDecryptionResult = OlmDecryptionResult( payload = result.clearEvent, senderKey = result.senderCurve25519Key, diff --git a/vector/src/main/java/im/vector/riotx/features/navigation/DefaultNavigator.kt b/vector/src/main/java/im/vector/riotx/features/navigation/DefaultNavigator.kt index ecc806c798..027cb85863 100644 --- a/vector/src/main/java/im/vector/riotx/features/navigation/DefaultNavigator.kt +++ b/vector/src/main/java/im/vector/riotx/features/navigation/DefaultNavigator.kt @@ -66,7 +66,7 @@ class DefaultNavigator @Inject constructor( override fun performDeviceVerification(context: Context, otherUserId: String, sasTransationId: String) { val session = sessionHolder.getSafeActiveSession() ?: return - val tx = session.getVerificationService().getExistingTransaction(otherUserId, sasTransationId) ?: return + val tx = session.cryptoService().verificationService().getExistingTransaction(otherUserId, sasTransationId) ?: return (tx as? IncomingSasVerificationTransaction)?.performAccept() if (context is VectorBaseActivity) { VerificationBottomSheet.withArgs( @@ -79,10 +79,10 @@ class DefaultNavigator @Inject constructor( override fun requestSessionVerification(context: Context) { val session = sessionHolder.getSafeActiveSession() ?: return - val pr = session.getVerificationService().requestKeyVerification( + val pr = session.cryptoService().verificationService().requestKeyVerification( listOf(VerificationMethod.SAS, VerificationMethod.QR_CODE_SCAN, VerificationMethod.QR_CODE_SHOW), session.myUserId, - session.getUserDevices(session.myUserId).map { it.deviceId }) + session.cryptoService().getUserDevices(session.myUserId).map { it.deviceId }) if (context is VectorBaseActivity) { VerificationBottomSheet.withArgs( roomId = null, diff --git a/vector/src/main/java/im/vector/riotx/features/notifications/NotifiableEventResolver.kt b/vector/src/main/java/im/vector/riotx/features/notifications/NotifiableEventResolver.kt index 11d770adc4..17339956e5 100644 --- a/vector/src/main/java/im/vector/riotx/features/notifications/NotifiableEventResolver.kt +++ b/vector/src/main/java/im/vector/riotx/features/notifications/NotifiableEventResolver.kt @@ -114,7 +114,7 @@ class NotifiableEventResolver @Inject constructor(private val stringProvider: St // TODO use a global event decryptor? attache to session and that listen to new sessionId? // for now decrypt sync try { - val result = session.decryptEvent(event.root, event.root.roomId + UUID.randomUUID().toString()) + val result = session.cryptoService().decryptEvent(event.root, event.root.roomId + UUID.randomUUID().toString()) event.root.mxDecryptionResult = OlmDecryptionResult( payload = result.clearEvent, senderKey = result.senderCurve25519Key, diff --git a/vector/src/main/java/im/vector/riotx/features/rageshake/BugReporter.kt b/vector/src/main/java/im/vector/riotx/features/rageshake/BugReporter.kt index dc353363d5..b41c100003 100755 --- a/vector/src/main/java/im/vector/riotx/features/rageshake/BugReporter.kt +++ b/vector/src/main/java/im/vector/riotx/features/rageshake/BugReporter.kt @@ -211,7 +211,7 @@ class BugReporter @Inject constructor(private val activeSessionHolder: ActiveSes activeSessionHolder.getSafeActiveSession()?.let { session -> userId = session.myUserId deviceId = session.sessionParams.credentials.deviceId ?: "undefined" - olmVersion = session.getCryptoVersion(context, true) + olmVersion = session.cryptoService().getCryptoVersion(context, true) } if (!mIsCancelled) { diff --git a/vector/src/main/java/im/vector/riotx/features/roommemberprofile/RoomMemberProfileViewModel.kt b/vector/src/main/java/im/vector/riotx/features/roommemberprofile/RoomMemberProfileViewModel.kt index e3dd53104c..d6a1018e80 100644 --- a/vector/src/main/java/im/vector/riotx/features/roommemberprofile/RoomMemberProfileViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/roommemberprofile/RoomMemberProfileViewModel.kt @@ -148,7 +148,7 @@ class RoomMemberProfileViewModel @AssistedInject constructor(@Assisted private v // ok, let's find or create the DM room _viewEvents.post(RoomMemberProfileViewEvents.StartVerification( userId = state.userId, - canCrossSign = session.getCrossSigningService().canCrossSign() + canCrossSign = session.cryptoService().crossSigningService().canCrossSign() )) } } diff --git a/vector/src/main/java/im/vector/riotx/features/roommemberprofile/devices/DeviceListBottomSheetViewModel.kt b/vector/src/main/java/im/vector/riotx/features/roommemberprofile/devices/DeviceListBottomSheetViewModel.kt index b12ed58a73..253a21e3fa 100644 --- a/vector/src/main/java/im/vector/riotx/features/roommemberprofile/devices/DeviceListBottomSheetViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/roommemberprofile/devices/DeviceListBottomSheetViewModel.kt @@ -100,7 +100,7 @@ class DeviceListBottomSheetViewModel @AssistedInject constructor(@Assisted priva } private fun manuallyVerify(action: DeviceListAction.ManuallyVerify) { - session.getVerificationService().beginKeyVerification(VerificationMethod.SAS, userId, action.deviceId, null)?.let { txID -> + session.cryptoService().verificationService().beginKeyVerification(VerificationMethod.SAS, userId, action.deviceId, null)?.let { txID -> _viewEvents.post(DeviceListBottomSheetViewEvents.Verify(userId, txID)) } } diff --git a/vector/src/main/java/im/vector/riotx/features/roomprofile/members/RoomMemberListViewModel.kt b/vector/src/main/java/im/vector/riotx/features/roomprofile/members/RoomMemberListViewModel.kt index 72b4af4474..81b2809c4f 100644 --- a/vector/src/main/java/im/vector/riotx/features/roomprofile/members/RoomMemberListViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/roomprofile/members/RoomMemberListViewModel.kt @@ -95,7 +95,7 @@ class RoomMemberListViewModel @AssistedInject constructor(@Assisted initialState room.rx().liveRoomMembers(roomMemberQueryParams) .observeOn(AndroidSchedulers.mainThread()) .switchMap { membersSummary -> - session.getLiveCryptoDeviceInfo(membersSummary.map { it.userId }) + session.cryptoService().getLiveCryptoDeviceInfo(membersSummary.map { it.userId }) .asObservable() .doOnError { Timber.e(it) } .map { deviceList -> @@ -104,7 +104,7 @@ class RoomMemberListViewModel @AssistedInject constructor(@Assisted initialState val allDeviceTrusted = it.value.fold(it.value.isNotEmpty()) { prev, next -> prev && next.trustLevel?.isCrossSigningVerified().orFalse() } - if (session.getCrossSigningService().getUserCrossSigningKeys(it.key)?.isTrusted().orFalse()) { + if (session.cryptoService().crossSigningService().getUserCrossSigningKeys(it.key)?.isTrusted().orFalse()) { if (allDeviceTrusted) RoomEncryptionTrustLevel.Trusted else RoomEncryptionTrustLevel.Warning } else { RoomEncryptionTrustLevel.Default diff --git a/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsHelpAboutFragment.kt b/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsHelpAboutFragment.kt index 6c10b8695d..7b892ec88b 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsHelpAboutFragment.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsHelpAboutFragment.kt @@ -77,7 +77,7 @@ class VectorSettingsHelpAboutFragment @Inject constructor( // olm version findPreference(VectorPreferences.SETTINGS_OLM_VERSION_PREFERENCE_KEY)!! - .summary = session.getCryptoVersion(requireContext(), false) + .summary = session.cryptoService().getCryptoVersion(requireContext(), false) // copyright findPreference(VectorPreferences.SETTINGS_COPYRIGHT_PREFERENCE_KEY)!! diff --git a/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsLabsFragment.kt b/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsLabsFragment.kt index 8b1a2dba31..66c56455b9 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsLabsFragment.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsLabsFragment.kt @@ -37,7 +37,7 @@ class VectorSettingsLabsFragment @Inject constructor( // val useCryptoPref = findPreference(VectorPreferences.SETTINGS_ROOM_SETTINGS_LABS_END_TO_END_PREFERENCE_KEY) as SwitchPreference // val cryptoIsEnabledPref = findPreference(VectorPreferences.SETTINGS_ROOM_SETTINGS_LABS_END_TO_END_IS_ACTIVE_PREFERENCE_KEY) - if (session.isCryptoEnabled()) { + if (session.cryptoService().isCryptoEnabled()) { // mLabsCategory.removePreference(useCryptoPref) // // cryptoIsEnabledPref.isEnabled = false diff --git a/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsSecurityPrivacyFragment.kt b/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsSecurityPrivacyFragment.kt index 0637d6d545..4324c79dfd 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsSecurityPrivacyFragment.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsSecurityPrivacyFragment.kt @@ -134,10 +134,10 @@ class VectorSettingsSecurityPrivacyFragment @Inject constructor( private fun refreshXSigningStatus() { if (vectorPreferences.developerMode()) { - val crossSigningKeys = session.getCrossSigningService().getMyCrossSigningKeys() + val crossSigningKeys = session.cryptoService().crossSigningService().getMyCrossSigningKeys() val xSigningIsEnableInAccount = crossSigningKeys != null - val xSigningKeysAreTrusted = session.getCrossSigningService().checkUserTrust(session.myUserId).isVerified() - val xSigningKeyCanSign = session.getCrossSigningService().canCrossSign() + val xSigningKeysAreTrusted = session.cryptoService().crossSigningService().checkUserTrust(session.myUserId).isVerified() + val xSigningKeyCanSign = session.cryptoService().crossSigningService().canCrossSign() if (xSigningKeyCanSign) { mCrossSigningStatePreference.setIcon(R.drawable.ic_shield_trusted) @@ -412,10 +412,10 @@ class VectorSettingsSecurityPrivacyFragment @Inject constructor( sendToUnverifiedDevicesPref.isChecked = false - sendToUnverifiedDevicesPref.isChecked = session.getGlobalBlacklistUnverifiedDevices() + sendToUnverifiedDevicesPref.isChecked = session.cryptoService().getGlobalBlacklistUnverifiedDevices() sendToUnverifiedDevicesPref.onPreferenceClickListener = Preference.OnPreferenceClickListener { - session.setGlobalBlacklistUnverifiedDevices(sendToUnverifiedDevicesPref.isChecked) + session.cryptoService().setGlobalBlacklistUnverifiedDevices(sendToUnverifiedDevicesPref.isChecked) true } @@ -426,7 +426,7 @@ class VectorSettingsSecurityPrivacyFragment @Inject constructor( // ============================================================================================================== private fun refreshMyDevice() { - session.getUserDevices(session.myUserId).map { + session.cryptoService().getUserDevices(session.myUserId).map { DeviceInfo( user_id = session.myUserId, deviceId = it.deviceId, @@ -436,7 +436,7 @@ class VectorSettingsSecurityPrivacyFragment @Inject constructor( refreshCryptographyPreference(it) } // TODO Move to a ViewModel... - session.getDevicesList(object : MatrixCallback { + session.cryptoService().getDevicesList(object : MatrixCallback { override fun onSuccess(data: DevicesListResponse) { if (isAdded) { refreshCryptographyPreference(data.devices ?: emptyList()) diff --git a/vector/src/main/java/im/vector/riotx/features/settings/crosssigning/CrossSigningSettingsViewModel.kt b/vector/src/main/java/im/vector/riotx/features/settings/crosssigning/CrossSigningSettingsViewModel.kt index 2ad2e8c1ca..8ddb1802f3 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/crosssigning/CrossSigningSettingsViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/crosssigning/CrossSigningSettingsViewModel.kt @@ -57,8 +57,8 @@ class CrossSigningSettingsViewModel @AssistedInject constructor(@Assisted privat .execute { val crossSigningKeys = it.invoke()?.getOrNull() val xSigningIsEnableInAccount = crossSigningKeys != null - val xSigningKeysAreTrusted = session.getCrossSigningService().checkUserTrust(session.myUserId).isVerified() - val xSigningKeyCanSign = session.getCrossSigningService().canCrossSign() + val xSigningKeysAreTrusted = session.cryptoService().crossSigningService().checkUserTrust(session.myUserId).isVerified() + val xSigningKeyCanSign = session.cryptoService().crossSigningService().canCrossSign() copy( crossSigningInfo = crossSigningKeys, xSigningIsEnableInAccount = xSigningIsEnableInAccount, @@ -97,7 +97,7 @@ class CrossSigningSettingsViewModel @AssistedInject constructor(@Assisted privat setState { copy(isUploadingKeys = true) } - session.getCrossSigningService().initializeCrossSigning(auth, object : MatrixCallback { + session.cryptoService().crossSigningService().initializeCrossSigning(auth, object : MatrixCallback { override fun onSuccess(data: Unit) { _pendingSession = null diff --git a/vector/src/main/java/im/vector/riotx/features/settings/devices/DeviceVerificationInfoBottomSheetViewModel.kt b/vector/src/main/java/im/vector/riotx/features/settings/devices/DeviceVerificationInfoBottomSheetViewModel.kt index f2625cbc37..7ee79a279f 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/devices/DeviceVerificationInfoBottomSheetViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/devices/DeviceVerificationInfoBottomSheetViewModel.kt @@ -63,7 +63,7 @@ class DeviceVerificationInfoBottomSheetViewModel @AssistedInject constructor(@As setState { copy(deviceInfo = Loading()) } - session.getDeviceInfo(deviceId, object : MatrixCallback { + session.cryptoService().getDeviceInfo(deviceId, object : MatrixCallback { override fun onSuccess(data: DeviceInfo) { setState { copy(deviceInfo = Success(data)) diff --git a/vector/src/main/java/im/vector/riotx/features/settings/devices/DevicesViewModel.kt b/vector/src/main/java/im/vector/riotx/features/settings/devices/DevicesViewModel.kt index b931f5d66f..931f7a261f 100644 --- a/vector/src/main/java/im/vector/riotx/features/settings/devices/DevicesViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/settings/devices/DevicesViewModel.kt @@ -74,7 +74,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic init { refreshDevicesList() - session.getVerificationService().addListener(this) + session.cryptoService().verificationService().addListener(this) session.rx().liveUserCryptoDevices(session.myUserId) .execute { @@ -85,7 +85,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic } override fun onCleared() { - session.getVerificationService().removeListener(this) + session.cryptoService().verificationService().removeListener(this) super.onCleared() } @@ -103,7 +103,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic private fun refreshDevicesList() { if (!session.sessionParams.credentials.deviceId.isNullOrEmpty()) { // display something asap - val localKnown = session.getUserDevices(session.myUserId).map { + val localKnown = session.cryptoService().getUserDevices(session.myUserId).map { DeviceInfo( user_id = session.myUserId, deviceId = it.deviceId, @@ -118,7 +118,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic ) } - session.getDevicesList(object : MatrixCallback { + session.cryptoService().getDevicesList(object : MatrixCallback { override fun onSuccess(data: DevicesListResponse) { setState { copy( @@ -141,16 +141,16 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic setState { copy( myDeviceId = session.sessionParams.credentials.deviceId ?: "", - cryptoDevices = Success(session.getUserDevices(session.myUserId)) + cryptoDevices = Success(session.cryptoService().getUserDevices(session.myUserId)) ) } // then force download - session.downloadKeys(listOf(session.myUserId), true, object : MatrixCallback> { + session.cryptoService().downloadKeys(listOf(session.myUserId), true, object : MatrixCallback> { override fun onSuccess(data: MXUsersDevicesMap) { setState { copy( - cryptoDevices = Success(session.getUserDevices(session.myUserId)) + cryptoDevices = Success(session.cryptoService().getUserDevices(session.myUserId)) ) } } @@ -172,7 +172,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic } private fun handleVerify(action: DevicesAction.VerifyMyDevice) { - val txID = session.getVerificationService().requestKeyVerification(supportedVerificationMethods, session.myUserId, listOf(action.deviceId)) + val txID = session.cryptoService().verificationService().requestKeyVerification(supportedVerificationMethods, session.myUserId, listOf(action.deviceId)) _viewEvents.post(DevicesViewEvents.ShowVerifyDevice( session.myUserId, txID.transactionId @@ -187,7 +187,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic } private fun handleRename(action: DevicesAction.Rename) { - session.setDeviceName(action.deviceId, action.newName, object : MatrixCallback { + session.cryptoService().setDeviceName(action.deviceId, action.newName, object : MatrixCallback { override fun onSuccess(data: Unit) { setState { copy( @@ -222,7 +222,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic ) } - session.deleteDevice(deviceId, object : MatrixCallback { + session.cryptoService().deleteDevice(deviceId, object : MatrixCallback { override fun onFailure(failure: Throwable) { var isPasswordRequestFound = false @@ -284,7 +284,7 @@ class DevicesViewModel @AssistedInject constructor(@Assisted initialState: Devic ) } - session.deleteDeviceWithUserPassword(currentDeviceId, _currentSession, action.password, object : MatrixCallback { + session.cryptoService().deleteDeviceWithUserPassword(currentDeviceId, _currentSession, action.password, object : MatrixCallback { override fun onSuccess(data: Unit) { _currentDeviceId = null _currentSession = null diff --git a/vector/src/main/java/im/vector/riotx/features/workers/signout/SignOutViewModel.kt b/vector/src/main/java/im/vector/riotx/features/workers/signout/SignOutViewModel.kt index 2526e8cbe3..2f26fdf377 100644 --- a/vector/src/main/java/im/vector/riotx/features/workers/signout/SignOutViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/workers/signout/SignOutViewModel.kt @@ -30,36 +30,36 @@ class SignOutViewModel @Inject constructor(private val session: Session) : ViewM var keysBackupState = MutableLiveData() init { - session.getKeysBackupService().addListener(this) + session.cryptoService().keysBackupService().addListener(this) - keysBackupState.value = session.getKeysBackupService().state + keysBackupState.value = session.cryptoService().keysBackupService().state } /** * Safe way to get the current KeysBackup version */ fun getCurrentBackupVersion(): String { - return session.getKeysBackupService().currentBackupVersion ?: "" + return session.cryptoService().keysBackupService().currentBackupVersion ?: "" } /** * Safe way to get the number of keys to backup */ fun getNumberOfKeysToBackup(): Int { - return session.inboundGroupSessionsCount(false) + return session.cryptoService().inboundGroupSessionsCount(false) } /** * Safe way to tell if there are more keys on the server */ fun canRestoreKeys(): Boolean { - return session.getKeysBackupService().canRestoreKeys() + return session.cryptoService().keysBackupService().canRestoreKeys() } override fun onCleared() { super.onCleared() - session.getKeysBackupService().removeListener(this) + session.cryptoService().keysBackupService().removeListener(this) } override fun onStateChange(newState: KeysBackupState) { @@ -68,7 +68,7 @@ class SignOutViewModel @Inject constructor(private val session: Session) : ViewM fun refreshRemoteStateIfNeeded() { if (keysBackupState.value == KeysBackupState.Disabled) { - session.getKeysBackupService().checkAndStartKeysBackup() + session.cryptoService().keysBackupService().checkAndStartKeysBackup() } } } From fd0dceb5979ffef6779e56ccdb1401d9760c15ae Mon Sep 17 00:00:00 2001 From: ganfra Date: Mon, 17 Feb 2020 15:23:24 +0100 Subject: [PATCH 11/16] Clean code --- .../java/im/vector/matrix/android/api/session/Session.kt | 1 - .../vector/matrix/android/internal/session/DefaultSession.kt | 1 - .../verification/choose/VerificationChooseMethodViewModel.kt | 5 +++-- .../riotx/features/home/room/detail/RoomDetailViewModel.kt | 5 ++++- 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt index de981efdf0..c2fa7d2d32 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/Session.kt @@ -39,7 +39,6 @@ import im.vector.matrix.android.api.session.signout.SignOutService import im.vector.matrix.android.api.session.sync.FilterService import im.vector.matrix.android.api.session.sync.SyncState import im.vector.matrix.android.api.session.user.UserService -import im.vector.matrix.android.internal.crypto.DefaultCryptoService /** * This interface defines interactions with a session. diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt index c0141156f9..e7cb963c5f 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/DefaultSession.kt @@ -49,7 +49,6 @@ import im.vector.matrix.android.internal.crypto.crosssigning.ShieldTrustUpdater import im.vector.matrix.android.internal.database.LiveEntityObserver import im.vector.matrix.android.internal.di.SessionId import im.vector.matrix.android.internal.di.WorkManagerProvider -import im.vector.matrix.android.internal.session.sync.SyncTaskSequencer import im.vector.matrix.android.internal.session.sync.SyncTokenStore import im.vector.matrix.android.internal.session.sync.job.SyncThread import im.vector.matrix.android.internal.session.sync.job.SyncWorker diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt index 1fcdfbf05b..d7ee17a397 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/verification/choose/VerificationChooseMethodViewModel.kt @@ -96,10 +96,11 @@ class VerificationChooseMethodViewModel @AssistedInject constructor( override fun initialState(viewModelContext: ViewModelContext): VerificationChooseMethodViewState? { val args: VerificationBottomSheet.VerificationArgs = viewModelContext.args() val session = (viewModelContext.activity as HasScreenInjector).injector().activeSessionHolder().getActiveSession() - val pvr = session.cryptoService().verificationService().getExistingVerificationRequest(args.otherUserId, args.verificationId) + val verificationService = session.cryptoService().verificationService() + val pvr = verificationService.getExistingVerificationRequest(args.otherUserId, args.verificationId) // Get the QR code now, because transaction is already created, so transactionCreated() will not be called - val qrCodeVerificationTransaction = session.cryptoService().verificationService().getExistingTransaction(args.otherUserId, args.verificationId ?: "") + val qrCodeVerificationTransaction = verificationService.getExistingTransaction(args.otherUserId, args.verificationId ?: "") return VerificationChooseMethodViewState(otherUserId = args.otherUserId, transactionId = args.verificationId ?: "", diff --git a/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt b/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt index 47738d3cf4..4cbf16e49c 100644 --- a/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailViewModel.kt @@ -420,7 +420,10 @@ class RoomDetailViewModel @AssistedInject constructor(@Assisted initialState: Ro popDraft() } is ParsedCommand.VerifyUser -> { - session.cryptoService().verificationService().requestKeyVerificationInDMs(supportedVerificationMethods, slashCommandResult.userId, room.roomId) + session + .cryptoService() + .verificationService() + .requestKeyVerificationInDMs(supportedVerificationMethods, slashCommandResult.userId, room.roomId) _viewEvents.post(RoomDetailViewEvents.SlashCommandHandled()) popDraft() } From 91cbcebf73efd1a46b425063d64b2dac9edade61 Mon Sep 17 00:00:00 2001 From: ganfra Date: Mon, 17 Feb 2020 15:50:42 +0100 Subject: [PATCH 12/16] Make test compile --- .../matrix/android/common/CryptoTestHelper.kt | 4 +- .../crypto/crosssigning/XSigningTest.kt | 38 ++-- .../crypto/keysbackup/KeysBackupTest.kt | 194 +++++++++--------- .../internal/crypto/verification/SASTest.kt | 44 ++-- .../verification/qrcode/VerificationTest.kt | 8 +- 5 files changed, 144 insertions(+), 144 deletions(-) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CryptoTestHelper.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CryptoTestHelper.kt index f94c8455c2..7368c87252 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CryptoTestHelper.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/common/CryptoTestHelper.kt @@ -230,9 +230,9 @@ class CryptoTestHelper(val mTestHelper: CommonTestHelper) { val aliceRoomId = cryptoTestData.roomId val bobSession = cryptoTestData.secondSession!! - bobSession.setWarnOnUnknownDevices(false) + bobSession.cryptoService().setWarnOnUnknownDevices(false) - aliceSession.setWarnOnUnknownDevices(false) + aliceSession.cryptoService().setWarnOnUnknownDevices(false) val roomFromBobPOV = bobSession.getRoom(aliceRoomId)!! val roomFromAlicePOV = aliceSession.getRoom(aliceRoomId)!! diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/crosssigning/XSigningTest.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/crosssigning/XSigningTest.kt index c8e7355d7a..069d32acaf 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/crosssigning/XSigningTest.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/crosssigning/XSigningTest.kt @@ -35,7 +35,7 @@ class XSigningTest : InstrumentedTest { val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true)) val aliceLatch = CountDownLatch(1) - aliceSession.getCrossSigningService() + aliceSession.cryptoService().crossSigningService() .initializeCrossSigning(UserPasswordAuth( user = aliceSession.myUserId, password = TestConstants.PASSWORD @@ -43,7 +43,7 @@ class XSigningTest : InstrumentedTest { mTestHelper.await(aliceLatch) - val myCrossSigningKeys = aliceSession.getCrossSigningService().getMyCrossSigningKeys() + val myCrossSigningKeys = aliceSession.cryptoService().crossSigningService().getMyCrossSigningKeys() val masterPubKey = myCrossSigningKeys?.masterKey() assertNotNull("Master key should be stored", masterPubKey?.unpaddedBase64PublicKey) val selfSigningKey = myCrossSigningKeys?.selfSigningKey() @@ -53,7 +53,7 @@ class XSigningTest : InstrumentedTest { assertTrue("Signing Keys should be trusted", myCrossSigningKeys?.isTrusted() == true) - assertTrue("Signing Keys should be trusted", aliceSession.getCrossSigningService().checkUserTrust(aliceSession.myUserId).isVerified()) + assertTrue("Signing Keys should be trusted", aliceSession.cryptoService().crossSigningService().checkUserTrust(aliceSession.myUserId).isVerified()) mTestHelper.signout(aliceSession) } @@ -76,23 +76,23 @@ class XSigningTest : InstrumentedTest { val latch = CountDownLatch(2) - aliceSession.getCrossSigningService().initializeCrossSigning(aliceAuthParams, TestMatrixCallback(latch)) - bobSession.getCrossSigningService().initializeCrossSigning(bobAuthParams, TestMatrixCallback(latch)) + aliceSession.cryptoService().crossSigningService().initializeCrossSigning(aliceAuthParams, TestMatrixCallback(latch)) + bobSession.cryptoService().crossSigningService().initializeCrossSigning(bobAuthParams, TestMatrixCallback(latch)) mTestHelper.await(latch) // Check that alice can see bob keys val downloadLatch = CountDownLatch(1) - aliceSession.downloadKeys(listOf(bobSession.myUserId), true, TestMatrixCallback(downloadLatch)) + aliceSession.cryptoService().downloadKeys(listOf(bobSession.myUserId), true, TestMatrixCallback(downloadLatch)) mTestHelper.await(downloadLatch) - val bobKeysFromAlicePOV = aliceSession.getCrossSigningService().getUserCrossSigningKeys(bobSession.myUserId) + val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobSession.myUserId) assertNotNull("Alice can see bob Master key", bobKeysFromAlicePOV!!.masterKey()) assertNull("Alice should not see bob User key", bobKeysFromAlicePOV.userKey()) assertNotNull("Alice can see bob SelfSigned key", bobKeysFromAlicePOV.selfSigningKey()) - assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.masterKey()?.unpaddedBase64PublicKey, bobSession.getCrossSigningService().getMyCrossSigningKeys()?.masterKey()?.unpaddedBase64PublicKey) - assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.selfSigningKey()?.unpaddedBase64PublicKey, bobSession.getCrossSigningService().getMyCrossSigningKeys()?.selfSigningKey()?.unpaddedBase64PublicKey) + assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.masterKey()?.unpaddedBase64PublicKey, bobSession.cryptoService().crossSigningService().getMyCrossSigningKeys()?.masterKey()?.unpaddedBase64PublicKey) + assertEquals("Bob keys from alice pov should match", bobKeysFromAlicePOV.selfSigningKey()?.unpaddedBase64PublicKey, bobSession.cryptoService().crossSigningService().getMyCrossSigningKeys()?.selfSigningKey()?.unpaddedBase64PublicKey) assertFalse("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV.isTrusted()) @@ -118,22 +118,22 @@ class XSigningTest : InstrumentedTest { val latch = CountDownLatch(2) - aliceSession.getCrossSigningService().initializeCrossSigning(aliceAuthParams, TestMatrixCallback(latch)) - bobSession.getCrossSigningService().initializeCrossSigning(bobAuthParams, TestMatrixCallback(latch)) + aliceSession.cryptoService().crossSigningService().initializeCrossSigning(aliceAuthParams, TestMatrixCallback(latch)) + bobSession.cryptoService().crossSigningService().initializeCrossSigning(bobAuthParams, TestMatrixCallback(latch)) mTestHelper.await(latch) // Check that alice can see bob keys val downloadLatch = CountDownLatch(1) val bobUserId = bobSession.myUserId - aliceSession.downloadKeys(listOf(bobUserId), true, TestMatrixCallback(downloadLatch)) + aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, TestMatrixCallback(downloadLatch)) mTestHelper.await(downloadLatch) - val bobKeysFromAlicePOV = aliceSession.getCrossSigningService().getUserCrossSigningKeys(bobUserId) + val bobKeysFromAlicePOV = aliceSession.cryptoService().crossSigningService().getUserCrossSigningKeys(bobUserId) assertTrue("Bob keys from alice pov should not be trusted", bobKeysFromAlicePOV?.isTrusted() == false) val trustLatch = CountDownLatch(1) - aliceSession.getCrossSigningService().trustUser(bobUserId, object : MatrixCallback { + aliceSession.cryptoService().crossSigningService().trustUser(bobUserId, object : MatrixCallback { override fun onSuccess(data: Unit) { trustLatch.countDown() } @@ -152,7 +152,7 @@ class XSigningTest : InstrumentedTest { // Check that bob first session sees the new login val bobKeysLatch = CountDownLatch(1) - bobSession.downloadKeys(listOf(bobUserId), true, object : MatrixCallback> { + bobSession.cryptoService().downloadKeys(listOf(bobUserId), true, object : MatrixCallback> { override fun onFailure(failure: Throwable) { fail("Failed to get device") } @@ -166,12 +166,12 @@ class XSigningTest : InstrumentedTest { }) mTestHelper.await(bobKeysLatch) - val bobSecondDevicePOVFirstDevice = bobSession.getDeviceInfo(bobUserId, bobSecondDeviceId) + val bobSecondDevicePOVFirstDevice = bobSession.cryptoService().getDeviceInfo(bobUserId, bobSecondDeviceId) assertNotNull("Bob Second device should be known and persisted from first", bobSecondDevicePOVFirstDevice) // Manually mark it as trusted from first session val bobSignLatch = CountDownLatch(1) - bobSession.getCrossSigningService().signDevice(bobSecondDeviceId!!, object : MatrixCallback { + bobSession.cryptoService().crossSigningService().signDevice(bobSecondDeviceId!!, object : MatrixCallback { override fun onSuccess(data: Unit) { bobSignLatch.countDown() } @@ -184,7 +184,7 @@ class XSigningTest : InstrumentedTest { // Now alice should cross trust bob's second device val aliceKeysLatch = CountDownLatch(1) - aliceSession.downloadKeys(listOf(bobUserId), true, object : MatrixCallback> { + aliceSession.cryptoService().downloadKeys(listOf(bobUserId), true, object : MatrixCallback> { override fun onFailure(failure: Throwable) { fail("Failed to get device") } @@ -199,7 +199,7 @@ class XSigningTest : InstrumentedTest { }) mTestHelper.await(aliceKeysLatch) - val result = aliceSession.getCrossSigningService().checkDeviceTrust(bobUserId, bobSecondDeviceId, null) + val result = aliceSession.cryptoService().crossSigningService().checkDeviceTrust(bobUserId, bobSecondDeviceId, null) assertTrue("Bob second device should be trusted from alice POV", result.isCrossSignedVerified()) mTestHelper.signout(aliceSession) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt index 312ad03a06..66ce44ad4f 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt @@ -77,21 +77,21 @@ class KeysBackupTest : InstrumentedTest { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() // From doE2ETestWithAliceAndBobInARoomWithEncryptedMessages, we should have no backed up keys - val cryptoStore = (cryptoTestData.firstSession.getKeysBackupService() as KeysBackup).store + val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup).store val sessions = cryptoStore.inboundGroupSessionsToBackup(100) val sessionsCount = sessions.size assertFalse(sessions.isEmpty()) - assertEquals(sessionsCount, cryptoTestData.firstSession.inboundGroupSessionsCount(false)) - assertEquals(0, cryptoTestData.firstSession.inboundGroupSessionsCount(true)) + assertEquals(sessionsCount, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false)) + assertEquals(0, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true)) // - Check backup keys after having marked one as backed up val session = sessions[0] cryptoStore.markBackupDoneForInboundGroupSessions(Collections.singletonList(session)) - assertEquals(sessionsCount, cryptoTestData.firstSession.inboundGroupSessionsCount(false)) - assertEquals(1, cryptoTestData.firstSession.inboundGroupSessionsCount(true)) + assertEquals(sessionsCount, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false)) + assertEquals(1, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true)) val sessions2 = cryptoStore.inboundGroupSessionsToBackup(100) assertEquals(sessionsCount - 1, sessions2.size) @@ -101,8 +101,8 @@ class KeysBackupTest : InstrumentedTest { val sessions3 = cryptoStore.inboundGroupSessionsToBackup(100) assertEquals(sessionsCount, sessions3.size) - assertEquals(sessionsCount, cryptoTestData.firstSession.inboundGroupSessionsCount(false)) - assertEquals(0, cryptoTestData.firstSession.inboundGroupSessionsCount(true)) + assertEquals(sessionsCount, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false)) + assertEquals(0, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true)) } /** @@ -112,9 +112,9 @@ class KeysBackupTest : InstrumentedTest { fun prepareKeysBackupVersionTest() { val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams) - assertNotNull(bobSession.getKeysBackupService()) + assertNotNull(bobSession.cryptoService().keysBackupService()) - val keysBackup = bobSession.getKeysBackupService() + val keysBackup = bobSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -154,7 +154,7 @@ class KeysBackupTest : InstrumentedTest { fun createKeysBackupVersionTest() { val bobSession = mTestHelper.createAccount(TestConstants.USER_BOB, defaultSessionParams) - val keysBackup = bobSession.getKeysBackupService() + val keysBackup = bobSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -209,12 +209,12 @@ class KeysBackupTest : InstrumentedTest { fun backupAfterCreateKeysBackupVersionTest() { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val latch = CountDownLatch(1) - assertEquals(2, cryptoTestData.firstSession.inboundGroupSessionsCount(false)) - assertEquals(0, cryptoTestData.firstSession.inboundGroupSessionsCount(true)) + assertEquals(2, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false)) + assertEquals(0, cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true)) val stateObserver = StateObserver(keysBackup, latch, 5) @@ -222,8 +222,8 @@ class KeysBackupTest : InstrumentedTest { mTestHelper.await(latch) - val nbOfKeys = cryptoTestData.firstSession.inboundGroupSessionsCount(false) - val backedUpKeys = cryptoTestData.firstSession.inboundGroupSessionsCount(true) + val nbOfKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false) + val backedUpKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true) assertEquals(2, nbOfKeys) assertEquals("All keys must have been marked as backed up", nbOfKeys, backedUpKeys) @@ -248,14 +248,14 @@ class KeysBackupTest : InstrumentedTest { fun backupAllGroupSessionsTest() { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) prepareAndCreateKeysBackupData(keysBackup) // Check that backupAllGroupSessions returns valid data - val nbOfKeys = cryptoTestData.firstSession.inboundGroupSessionsCount(false) + val nbOfKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(false) assertEquals(2, nbOfKeys) @@ -273,7 +273,7 @@ class KeysBackupTest : InstrumentedTest { mTestHelper.await(latch) assertEquals(nbOfKeys, lastBackedUpKeysProgress) - val backedUpKeys = cryptoTestData.firstSession.inboundGroupSessionsCount(true) + val backedUpKeys = cryptoTestData.firstSession.cryptoService().inboundGroupSessionsCount(true) assertEquals("All keys must have been marked as backed up", nbOfKeys, backedUpKeys) @@ -293,7 +293,7 @@ class KeysBackupTest : InstrumentedTest { fun testEncryptAndDecryptKeysBackupData() { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() as KeysBackup + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup val stateObserver = StateObserver(keysBackup) @@ -337,7 +337,7 @@ class KeysBackupTest : InstrumentedTest { // - Restore the e2e backup from the homeserver val latch2 = CountDownLatch(1) var importRoomKeysResult: ImportRoomKeysResult? = null - testData.aliceSession2.getKeysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, null, null, @@ -373,7 +373,7 @@ class KeysBackupTest : InstrumentedTest { val testData = createKeysBackupScenarioWithPassword(null) // - Check the SDK sent key share requests - val cryptoStore2 = (testData.aliceSession2.getKeysBackupService() as KeysBackup).store + val cryptoStore2 = (testData.aliceSession2.cryptoService().keysBackupService() as KeysBackup).store val unsentRequest = cryptoStore2 .getOutgoingRoomKeyRequestByState(setOf(OutgoingRoomKeyRequest.RequestState.UNSENT)) val sentRequest = cryptoStore2 @@ -385,7 +385,7 @@ class KeysBackupTest : InstrumentedTest { // - Restore the e2e backup from the homeserver val latch2 = CountDownLatch(1) var importRoomKeysResult: ImportRoomKeysResult? = null - testData.aliceSession2.getKeysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, null, null, @@ -429,17 +429,17 @@ class KeysBackupTest : InstrumentedTest { // - And log Alice on a new device val testData = createKeysBackupScenarioWithPassword(null) - val stateObserver = StateObserver(testData.aliceSession2.getKeysBackupService()) + val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) // - The new device must see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Trust the backup from the new device val latch = CountDownLatch(1) - testData.aliceSession2.getKeysBackupService().trustKeysBackupVersion( - testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersion( + testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, true, TestMatrixCallback(latch) ) @@ -449,13 +449,13 @@ class KeysBackupTest : InstrumentedTest { waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) // - Backup must be enabled on the new device, on the same version - assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.getKeysBackupService().keysBackupVersion?.version) - assertTrue(testData.aliceSession2.getKeysBackupService().isEnabled) + assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion?.version) + assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) // - Retrieve the last version from the server val latch2 = CountDownLatch(1) var keysVersionResult: KeysVersionResult? = null - testData.aliceSession2.getKeysBackupService().getCurrentVersion( + testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion( object : TestMatrixCallback(latch2) { override fun onSuccess(data: KeysVersionResult?) { keysVersionResult = data @@ -470,7 +470,7 @@ class KeysBackupTest : InstrumentedTest { val latch3 = CountDownLatch(1) var keysBackupVersionTrust: KeysBackupVersionTrust? = null - testData.aliceSession2.getKeysBackupService().getKeysBackupTrust(keysVersionResult!!, + testData.aliceSession2.cryptoService().keysBackupService().getKeysBackupTrust(keysVersionResult!!, object : TestMatrixCallback(latch3) { override fun onSuccess(data: KeysBackupVersionTrust) { keysBackupVersionTrust = data @@ -503,17 +503,17 @@ class KeysBackupTest : InstrumentedTest { // - And log Alice on a new device val testData = createKeysBackupScenarioWithPassword(null) - val stateObserver = StateObserver(testData.aliceSession2.getKeysBackupService()) + val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) // - The new device must see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Trust the backup from the new device with the recovery key val latch = CountDownLatch(1) - testData.aliceSession2.getKeysBackupService().trustKeysBackupVersionWithRecoveryKey( - testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersionWithRecoveryKey( + testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, TestMatrixCallback(latch) ) @@ -523,13 +523,13 @@ class KeysBackupTest : InstrumentedTest { waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) // - Backup must be enabled on the new device, on the same version - assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.getKeysBackupService().keysBackupVersion?.version) - assertTrue(testData.aliceSession2.getKeysBackupService().isEnabled) + assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion?.version) + assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) // - Retrieve the last version from the server val latch2 = CountDownLatch(1) var keysVersionResult: KeysVersionResult? = null - testData.aliceSession2.getKeysBackupService().getCurrentVersion( + testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion( object : TestMatrixCallback(latch2) { override fun onSuccess(data: KeysVersionResult?) { keysVersionResult = data @@ -544,7 +544,7 @@ class KeysBackupTest : InstrumentedTest { val latch3 = CountDownLatch(1) var keysBackupVersionTrust: KeysBackupVersionTrust? = null - testData.aliceSession2.getKeysBackupService().getKeysBackupTrust(keysVersionResult!!, + testData.aliceSession2.cryptoService().keysBackupService().getKeysBackupTrust(keysVersionResult!!, object : TestMatrixCallback(latch3) { override fun onSuccess(data: KeysBackupVersionTrust) { keysBackupVersionTrust = data @@ -575,26 +575,26 @@ class KeysBackupTest : InstrumentedTest { // - And log Alice on a new device val testData = createKeysBackupScenarioWithPassword(null) - val stateObserver = StateObserver(testData.aliceSession2.getKeysBackupService()) + val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) // - The new device must see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Try to trust the backup from the new device with a wrong recovery key val latch = CountDownLatch(1) - testData.aliceSession2.getKeysBackupService().trustKeysBackupVersionWithRecoveryKey( - testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersionWithRecoveryKey( + testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, "Bad recovery key", TestMatrixCallback(latch, false) ) mTestHelper.await(latch) // - The new device must still see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) stateObserver.stopAndCheckStates(null) testData.cryptoTestData.close() @@ -618,17 +618,17 @@ class KeysBackupTest : InstrumentedTest { // - And log Alice on a new device val testData = createKeysBackupScenarioWithPassword(password) - val stateObserver = StateObserver(testData.aliceSession2.getKeysBackupService()) + val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) // - The new device must see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Trust the backup from the new device with the password val latch = CountDownLatch(1) - testData.aliceSession2.getKeysBackupService().trustKeysBackupVersionWithPassphrase( - testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersionWithPassphrase( + testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, password, TestMatrixCallback(latch) ) @@ -638,13 +638,13 @@ class KeysBackupTest : InstrumentedTest { waitForKeysBackupToBeInState(testData.aliceSession2, KeysBackupState.ReadyToBackUp) // - Backup must be enabled on the new device, on the same version - assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.getKeysBackupService().keysBackupVersion?.version) - assertTrue(testData.aliceSession2.getKeysBackupService().isEnabled) + assertEquals(testData.prepareKeysBackupDataResult.version, testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion?.version) + assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) // - Retrieve the last version from the server val latch2 = CountDownLatch(1) var keysVersionResult: KeysVersionResult? = null - testData.aliceSession2.getKeysBackupService().getCurrentVersion( + testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion( object : TestMatrixCallback(latch2) { override fun onSuccess(data: KeysVersionResult?) { keysVersionResult = data @@ -659,7 +659,7 @@ class KeysBackupTest : InstrumentedTest { val latch3 = CountDownLatch(1) var keysBackupVersionTrust: KeysBackupVersionTrust? = null - testData.aliceSession2.getKeysBackupService().getKeysBackupTrust(keysVersionResult!!, + testData.aliceSession2.cryptoService().keysBackupService().getKeysBackupTrust(keysVersionResult!!, object : TestMatrixCallback(latch3) { override fun onSuccess(data: KeysBackupVersionTrust) { keysBackupVersionTrust = data @@ -693,26 +693,26 @@ class KeysBackupTest : InstrumentedTest { // - And log Alice on a new device val testData = createKeysBackupScenarioWithPassword(password) - val stateObserver = StateObserver(testData.aliceSession2.getKeysBackupService()) + val stateObserver = StateObserver(testData.aliceSession2.cryptoService().keysBackupService()) // - The new device must see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) // - Try to trust the backup from the new device with a wrong password val latch = CountDownLatch(1) - testData.aliceSession2.getKeysBackupService().trustKeysBackupVersionWithPassphrase( - testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().trustKeysBackupVersionWithPassphrase( + testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, badPassword, TestMatrixCallback(latch, false) ) mTestHelper.await(latch) // - The new device must still see the previous backup as not trusted - assertNotNull(testData.aliceSession2.getKeysBackupService().keysBackupVersion) - assertFalse(testData.aliceSession2.getKeysBackupService().isEnabled) - assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.getKeysBackupService().state) + assertNotNull(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion) + assertFalse(testData.aliceSession2.cryptoService().keysBackupService().isEnabled) + assertEquals(KeysBackupState.NotTrusted, testData.aliceSession2.cryptoService().keysBackupService().state) stateObserver.stopAndCheckStates(null) testData.cryptoTestData.close() @@ -731,7 +731,7 @@ class KeysBackupTest : InstrumentedTest { // - Try to restore the e2e backup with a wrong recovery key val latch2 = CountDownLatch(1) var importRoomKeysResult: ImportRoomKeysResult? = null - testData.aliceSession2.getKeysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, "EsTc LW2K PGiF wKEA 3As5 g5c4 BXwk qeeJ ZJV8 Q9fu gUMN UE4d", null, null, @@ -768,7 +768,7 @@ class KeysBackupTest : InstrumentedTest { var importRoomKeysResult: ImportRoomKeysResult? = null val steps = ArrayList() - testData.aliceSession2.getKeysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, password, null, null, @@ -828,7 +828,7 @@ class KeysBackupTest : InstrumentedTest { // - Try to restore the e2e backup with a wrong password val latch2 = CountDownLatch(1) var importRoomKeysResult: ImportRoomKeysResult? = null - testData.aliceSession2.getKeysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, wrongPassword, null, null, @@ -863,7 +863,7 @@ class KeysBackupTest : InstrumentedTest { // - Restore the e2e backup with the recovery key. val latch2 = CountDownLatch(1) var importRoomKeysResult: ImportRoomKeysResult? = null - testData.aliceSession2.getKeysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, testData.prepareKeysBackupDataResult.megolmBackupCreationInfo.recoveryKey, null, null, @@ -895,7 +895,7 @@ class KeysBackupTest : InstrumentedTest { // - Try to restore the e2e backup with a password val latch2 = CountDownLatch(1) var importRoomKeysResult: ImportRoomKeysResult? = null - testData.aliceSession2.getKeysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.getKeysBackupService().keysBackupVersion!!, + testData.aliceSession2.cryptoService().keysBackupService().restoreKeyBackupWithPassword(testData.aliceSession2.cryptoService().keysBackupService().keysBackupVersion!!, "password", null, null, @@ -924,7 +924,7 @@ class KeysBackupTest : InstrumentedTest { // - Create a backup version val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -967,7 +967,7 @@ class KeysBackupTest : InstrumentedTest { val signature = keysBackupVersionTrust!!.signatures[0] assertTrue(signature.valid) assertNotNull(signature.device) - assertEquals(cryptoTestData.firstSession.getMyDevice().deviceId, signature.deviceId) + assertEquals(cryptoTestData.firstSession.cryptoService().getMyDevice().deviceId, signature.deviceId) assertEquals(signature.device!!.deviceId, cryptoTestData.firstSession.sessionParams.credentials.deviceId) stateObserver.stopAndCheckStates(null) @@ -986,7 +986,7 @@ class KeysBackupTest : InstrumentedTest { // - Create a backup version val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -1002,7 +1002,7 @@ class KeysBackupTest : InstrumentedTest { cryptoTestData.close() - val keysBackup2 = aliceSession2.getKeysBackupService() + val keysBackup2 = aliceSession2.cryptoService().keysBackupService() val stateObserver2 = StateObserver(keysBackup2) @@ -1046,7 +1046,7 @@ class KeysBackupTest : InstrumentedTest { // - Create a backup version val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -1086,7 +1086,7 @@ class KeysBackupTest : InstrumentedTest { mTestHelper.await(latch) // Reset the store backup status for keys - (cryptoTestData.firstSession.getKeysBackupService() as KeysBackup).store.resetBackupMarkers() + (cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup).store.resetBackupMarkers() // - Make alice back up all her keys again val latch2 = CountDownLatch(1) @@ -1121,7 +1121,7 @@ class KeysBackupTest : InstrumentedTest { // - Create a backup version val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -1147,14 +1147,14 @@ class KeysBackupTest : InstrumentedTest { val aliceSession2 = mTestHelper.logIntoAccount(aliceUserId, defaultSessionParamsWithInitialSync) // - Post a message to have a new megolm session - aliceSession2.setWarnOnUnknownDevices(false) + aliceSession2.cryptoService().setWarnOnUnknownDevices(false) val room2 = aliceSession2.getRoom(cryptoTestData.roomId)!! mTestHelper.sendTextMessage(room2, "New key", 1) // - Try to backup all in aliceSession2, it must fail - val keysBackup2 = aliceSession2.getKeysBackupService() + val keysBackup2 = aliceSession2.cryptoService().keysBackupService() val stateObserver2 = StateObserver(keysBackup2) @@ -1178,7 +1178,7 @@ class KeysBackupTest : InstrumentedTest { assertFalse(keysBackup2.isEnabled) // - Validate the old device from the new one - aliceSession2.setDeviceVerification(DeviceTrustLevel(false, true), aliceSession2.myUserId, oldDeviceId) + aliceSession2.cryptoService().setDeviceVerification(DeviceTrustLevel(false, true), aliceSession2.myUserId, oldDeviceId) // -> Backup should automatically enable on the new device val latch4 = CountDownLatch(1) @@ -1196,14 +1196,14 @@ class KeysBackupTest : InstrumentedTest { mTestHelper.await(latch4) // -> It must use the same backup version - assertEquals(oldKeyBackupVersion, aliceSession2.getKeysBackupService().currentBackupVersion) + assertEquals(oldKeyBackupVersion, aliceSession2.cryptoService().keysBackupService().currentBackupVersion) val latch5 = CountDownLatch(1) - aliceSession2.getKeysBackupService().backupAllGroupSessions(null, TestMatrixCallback(latch5)) + aliceSession2.cryptoService().keysBackupService().backupAllGroupSessions(null, TestMatrixCallback(latch5)) mTestHelper.await(latch5) // -> It must success - assertTrue(aliceSession2.getKeysBackupService().isEnabled) + assertTrue(aliceSession2.cryptoService().keysBackupService().isEnabled) stateObserver.stopAndCheckStates(null) stateObserver2.stopAndCheckStates(null) @@ -1220,7 +1220,7 @@ class KeysBackupTest : InstrumentedTest { // - Create a backup version val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -1254,17 +1254,17 @@ class KeysBackupTest : InstrumentedTest { */ private fun waitForKeysBackupToBeInState(session: Session, state: KeysBackupState) { // If already in the wanted state, return - if (session.getKeysBackupService().state == state) { + if (session.cryptoService().keysBackupService().state == state) { return } // Else observe state changes val latch = CountDownLatch(1) - session.getKeysBackupService().addListener(object : KeysBackupStateListener { + session.cryptoService().keysBackupService().addListener(object : KeysBackupStateListener { override fun onStateChange(newState: KeysBackupState) { if (newState == state) { - session.getKeysBackupService().removeListener(this) + session.cryptoService().keysBackupService().removeListener(this) latch.countDown() } } @@ -1359,8 +1359,8 @@ class KeysBackupTest : InstrumentedTest { private fun createKeysBackupScenarioWithPassword(password: String?): KeysBackupScenarioData { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val cryptoStore = (cryptoTestData.firstSession.getKeysBackupService() as KeysBackup).store - val keysBackup = cryptoTestData.firstSession.getKeysBackupService() + val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup).store + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -1394,7 +1394,7 @@ class KeysBackupTest : InstrumentedTest { val aliceSession2 = mTestHelper.logIntoAccount(aliceUserId, defaultSessionParamsWithInitialSync) // Test check: aliceSession2 has no keys at login - assertEquals(0, aliceSession2.inboundGroupSessionsCount(false)) + assertEquals(0, aliceSession2.cryptoService().inboundGroupSessionsCount(false)) // Wait for backup state to be NotTrusted waitForKeysBackupToBeInState(aliceSession2, KeysBackupState.NotTrusted) @@ -1421,11 +1421,11 @@ class KeysBackupTest : InstrumentedTest { assertEquals(total, imported) // - The new device must have the same count of megolm keys - assertEquals(testData.aliceKeys.size, testData.aliceSession2.inboundGroupSessionsCount(false)) + assertEquals(testData.aliceKeys.size, testData.aliceSession2.cryptoService().inboundGroupSessionsCount(false)) // - Alice must have the same keys on both devices for (aliceKey1 in testData.aliceKeys) { - val aliceKey2 = (testData.aliceSession2.getKeysBackupService() as KeysBackup).store + val aliceKey2 = (testData.aliceSession2.cryptoService().keysBackupService() as KeysBackup).store .getInboundGroupSession(aliceKey1.olmInboundGroupSession!!.sessionIdentifier(), aliceKey1.senderKey!!) assertNotNull(aliceKey2) assertKeysEquals(aliceKey1.exportKeys(), aliceKey2!!.exportKeys()) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/SASTest.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/SASTest.kt index 79670bb21e..7fad87b82d 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/SASTest.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/SASTest.kt @@ -62,8 +62,8 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession - val aliceVerificationService = aliceSession.getVerificationService() - val bobVerificationService = bobSession!!.getVerificationService() + val aliceVerificationService = aliceSession.cryptoService().verificationService() + val bobVerificationService = bobSession!!.cryptoService().verificationService() val bobTxCreatedLatch = CountDownLatch(1) val bobListener = object : VerificationService.Listener { @@ -75,7 +75,7 @@ class SASTest : InstrumentedTest { val txID = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobSession.myUserId, - bobSession.getMyDevice().deviceId, + bobSession.cryptoService().getMyDevice().deviceId, null) assertNotNull("Alice should have a started transaction", txID) @@ -157,7 +157,7 @@ class SASTest : InstrumentedTest { } } } - bobSession.getVerificationService().addListener(bobListener) + bobSession.cryptoService().verificationService().addListener(bobListener) // TODO bobSession!!.dataHandler.addListener(object : MXEventListener() { // TODO override fun onToDeviceEvent(event: Event?) { @@ -172,7 +172,7 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val aliceUserID = aliceSession.myUserId - val aliceDevice = aliceSession.getMyDevice().deviceId + val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId val aliceListener = object : VerificationService.Listener { override fun transactionUpdated(tx: VerificationTransaction) { @@ -181,7 +181,7 @@ class SASTest : InstrumentedTest { } } } - aliceSession.getVerificationService().addListener(aliceListener) + aliceSession.cryptoService().verificationService().addListener(aliceListener) fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, protocols = protocols) @@ -218,7 +218,7 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val aliceUserID = aliceSession.myUserId - val aliceDevice = aliceSession.getMyDevice().deviceId + val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, mac = mac) @@ -256,7 +256,7 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val aliceUserID = aliceSession.myUserId - val aliceDevice = aliceSession.getMyDevice().deviceId + val aliceDevice = aliceSession.cryptoService().getMyDevice().deviceId fakeBobStart(bobSession, aliceUserID, aliceDevice, tid, codes = codes) @@ -277,7 +277,7 @@ class SASTest : InstrumentedTest { mac: List = SASDefaultVerificationTransaction.KNOWN_MACS, codes: List = SASDefaultVerificationTransaction.KNOWN_SHORT_CODES) { val startMessage = KeyVerificationStart( - fromDevice = bobSession.getMyDevice().deviceId, + fromDevice = bobSession.cryptoService().getMyDevice().deviceId, method = VerificationMethod.SAS.toValue(), transactionID = tid, keyAgreementProtocols = protocols, @@ -307,7 +307,7 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession - val aliceVerificationService = aliceSession.getVerificationService() + val aliceVerificationService = aliceSession.cryptoService().verificationService() val aliceCreatedLatch = CountDownLatch(2) val aliceCancelledLatch = CountDownLatch(2) @@ -327,7 +327,7 @@ class SASTest : InstrumentedTest { aliceVerificationService.addListener(aliceListener) val bobUserId = bobSession!!.myUserId - val bobDeviceId = bobSession.getMyDevice().deviceId + val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) @@ -347,8 +347,8 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession - val aliceVerificationService = aliceSession.getVerificationService() - val bobVerificationService = bobSession!!.getVerificationService() + val aliceVerificationService = aliceSession.cryptoService().verificationService() + val bobVerificationService = bobSession!!.cryptoService().verificationService() var accepted: KeyVerificationAccept? = null var startReq: KeyVerificationStart? = null @@ -377,7 +377,7 @@ class SASTest : InstrumentedTest { bobVerificationService.addListener(bobListener) val bobUserId = bobSession.myUserId - val bobDeviceId = bobSession.getMyDevice().deviceId + val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) mTestHelper.await(aliceAcceptedLatch) @@ -403,8 +403,8 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession - val aliceVerificationService = aliceSession.getVerificationService() - val bobVerificationService = bobSession!!.getVerificationService() + val aliceVerificationService = aliceSession.cryptoService().verificationService() + val bobVerificationService = bobSession!!.cryptoService().verificationService() val aliceSASLatch = CountDownLatch(1) val aliceListener = object : VerificationService.Listener { @@ -438,7 +438,7 @@ class SASTest : InstrumentedTest { bobVerificationService.addListener(bobListener) val bobUserId = bobSession.myUserId - val bobDeviceId = bobSession.getMyDevice().deviceId + val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId val verificationSAS = aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) mTestHelper.await(aliceSASLatch) mTestHelper.await(bobSASLatch) @@ -459,8 +459,8 @@ class SASTest : InstrumentedTest { val aliceSession = cryptoTestData.firstSession val bobSession = cryptoTestData.secondSession - val aliceVerificationService = aliceSession.getVerificationService() - val bobVerificationService = bobSession!!.getVerificationService() + val aliceVerificationService = aliceSession.cryptoService().verificationService() + val bobVerificationService = bobSession!!.cryptoService().verificationService() val aliceSASLatch = CountDownLatch(1) val aliceListener = object : VerificationService.Listener { @@ -500,14 +500,14 @@ class SASTest : InstrumentedTest { bobVerificationService.addListener(bobListener) val bobUserId = bobSession.myUserId - val bobDeviceId = bobSession.getMyDevice().deviceId + val bobDeviceId = bobSession.cryptoService().getMyDevice().deviceId aliceVerificationService.beginKeyVerification(VerificationMethod.SAS, bobUserId, bobDeviceId, null) mTestHelper.await(aliceSASLatch) mTestHelper.await(bobSASLatch) // Assert that devices are verified - val bobDeviceInfoFromAlicePOV: CryptoDeviceInfo? = aliceSession.getDeviceInfo(bobUserId, bobDeviceId) - val aliceDeviceInfoFromBobPOV: CryptoDeviceInfo? = bobSession.getDeviceInfo(aliceSession.myUserId, aliceSession.getMyDevice().deviceId) + val bobDeviceInfoFromAlicePOV: CryptoDeviceInfo? = aliceSession.cryptoService().getDeviceInfo(bobUserId, bobDeviceId) + val aliceDeviceInfoFromBobPOV: CryptoDeviceInfo? = bobSession.cryptoService().getDeviceInfo(aliceSession.myUserId, aliceSession.cryptoService().getMyDevice().deviceId) // latch wait a bit again Thread.sleep(1000) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/VerificationTest.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/VerificationTest.kt index 61ea0f35b4..d62aef077e 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/VerificationTest.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/verification/qrcode/VerificationTest.kt @@ -156,7 +156,7 @@ class VerificationTest : InstrumentedTest { val bobSession = cryptoTestData.secondSession!! mTestHelper.doSync { callback -> - aliceSession.getCrossSigningService() + aliceSession.cryptoService().crossSigningService() .initializeCrossSigning(UserPasswordAuth( user = aliceSession.myUserId, password = TestConstants.PASSWORD @@ -164,15 +164,15 @@ class VerificationTest : InstrumentedTest { } mTestHelper.doSync { callback -> - bobSession.getCrossSigningService() + bobSession.cryptoService().crossSigningService() .initializeCrossSigning(UserPasswordAuth( user = bobSession.myUserId, password = TestConstants.PASSWORD ), callback) } - val aliceVerificationService = aliceSession.getVerificationService() - val bobVerificationService = bobSession.getVerificationService() + val aliceVerificationService = aliceSession.cryptoService().verificationService() + val bobVerificationService = bobSession.cryptoService().verificationService() var aliceReadyPendingVerificationRequest: PendingVerificationRequest? = null var bobReadyPendingVerificationRequest: PendingVerificationRequest? = null From 6d2025b61ad12de2e4c1b3308951315533565c08 Mon Sep 17 00:00:00 2001 From: ganfra Date: Mon, 17 Feb 2020 15:54:17 +0100 Subject: [PATCH 13/16] Update CHANGES --- CHANGES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGES.md b/CHANGES.md index 3e771a79d4..91d3c5d7e3 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -15,7 +15,7 @@ Translations 🗣: - SDK API changes ⚠️: - - + - Get crypto methods through Session.cryptoService() Build 🧱: - From 141c7d6af02f34ad48eed5a56ce4a089720dbbc8 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Mon, 17 Feb 2020 18:43:04 +0100 Subject: [PATCH 14/16] Update comment --- .../matrix/android/internal/task/CoroutineSequencer.kt | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt index d36b769ef3..46cc446b87 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/task/CoroutineSequencer.kt @@ -20,7 +20,7 @@ import kotlinx.coroutines.sync.Semaphore import kotlinx.coroutines.sync.withPermit /** - * This class intends to be used for ensure suspendable methods are played sequentially all the way long. + * This class intends to be used to ensure suspendable methods are played sequentially all the way long. */ internal interface CoroutineSequencer { /** @@ -32,7 +32,8 @@ internal interface CoroutineSequencer { internal open class SemaphoreCoroutineSequencer : CoroutineSequencer { - private val semaphore = Semaphore(1) // Permits 1 suspend function at a time. + // Permits 1 suspend function at a time. + private val semaphore = Semaphore(1) override suspend fun post(block: suspend () -> T): T { return semaphore.withPermit { From f716e9d7890baf8dd7d0a0d5865331f444795a6e Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Mon, 17 Feb 2020 18:49:45 +0100 Subject: [PATCH 15/16] Fix compilation issue --- .../restore/KeysBackupRestoreFromPassphraseViewModel.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt index 4e86f60909..92a3504b5c 100644 --- a/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt +++ b/vector/src/main/java/im/vector/riotx/features/crypto/keysbackup/restore/KeysBackupRestoreFromPassphraseViewModel.kt @@ -49,7 +49,7 @@ class KeysBackupRestoreFromPassphraseViewModel @Inject constructor() : ViewModel } fun recoverKeys(context: Context, sharedViewModel: KeysBackupRestoreSharedViewModel) { - val keysBackup = sharedViewModel.session.getKeysBackupService() + val keysBackup = sharedViewModel.session.cryptoService().keysBackupService() passphraseErrorText.value = null From 67ed86fee5c305b53c8e8fc18c68b4bf8d93dd32 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Mon, 17 Feb 2020 18:51:06 +0100 Subject: [PATCH 16/16] Rename KeysBackup to DefaultKeysBackupService --- .../internal/crypto/keysbackup/KeysBackupTest.kt | 14 +++++++------- .../internal/crypto/DefaultCryptoService.kt | 10 +++++----- .../crypto/actions/SetDeviceVerificationAction.kt | 6 +++--- .../internal/crypto/algorithms/IMXDecrypting.kt | 4 ++-- .../crypto/algorithms/megolm/MXMegolmDecryption.kt | 6 +++--- .../crypto/algorithms/megolm/MXMegolmEncryption.kt | 6 +++--- .../algorithms/megolm/MXMegolmEncryptionFactory.kt | 6 +++--- .../{KeysBackup.kt => DefaultKeysBackupService.kt} | 5 ++--- 8 files changed, 28 insertions(+), 29 deletions(-) rename matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/{KeysBackup.kt => DefaultKeysBackupService.kt} (99%) diff --git a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt index 66ce44ad4f..2edc0c3976 100644 --- a/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt +++ b/matrix-sdk-android/src/androidTest/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackupTest.kt @@ -77,7 +77,7 @@ class KeysBackupTest : InstrumentedTest { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() // From doE2ETestWithAliceAndBobInARoomWithEncryptedMessages, we should have no backed up keys - val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup).store + val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService).store val sessions = cryptoStore.inboundGroupSessionsToBackup(100) val sessionsCount = sessions.size @@ -293,7 +293,7 @@ class KeysBackupTest : InstrumentedTest { fun testEncryptAndDecryptKeysBackupData() { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup + val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService val stateObserver = StateObserver(keysBackup) @@ -373,7 +373,7 @@ class KeysBackupTest : InstrumentedTest { val testData = createKeysBackupScenarioWithPassword(null) // - Check the SDK sent key share requests - val cryptoStore2 = (testData.aliceSession2.cryptoService().keysBackupService() as KeysBackup).store + val cryptoStore2 = (testData.aliceSession2.cryptoService().keysBackupService() as DefaultKeysBackupService).store val unsentRequest = cryptoStore2 .getOutgoingRoomKeyRequestByState(setOf(OutgoingRoomKeyRequest.RequestState.UNSENT)) val sentRequest = cryptoStore2 @@ -1082,11 +1082,11 @@ class KeysBackupTest : InstrumentedTest { val latch = CountDownLatch(1) val megolmBackupCreationInfo = mCryptoTestHelper.createFakeMegolmBackupCreationInfo() - (keysBackup as KeysBackup).createFakeKeysBackupVersion(megolmBackupCreationInfo, TestMatrixCallback(latch)) + (keysBackup as DefaultKeysBackupService).createFakeKeysBackupVersion(megolmBackupCreationInfo, TestMatrixCallback(latch)) mTestHelper.await(latch) // Reset the store backup status for keys - (cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup).store.resetBackupMarkers() + (cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService).store.resetBackupMarkers() // - Make alice back up all her keys again val latch2 = CountDownLatch(1) @@ -1359,7 +1359,7 @@ class KeysBackupTest : InstrumentedTest { private fun createKeysBackupScenarioWithPassword(password: String?): KeysBackupScenarioData { val cryptoTestData = mCryptoTestHelper.doE2ETestWithAliceAndBobInARoomWithEncryptedMessages() - val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as KeysBackup).store + val cryptoStore = (cryptoTestData.firstSession.cryptoService().keysBackupService() as DefaultKeysBackupService).store val keysBackup = cryptoTestData.firstSession.cryptoService().keysBackupService() val stateObserver = StateObserver(keysBackup) @@ -1425,7 +1425,7 @@ class KeysBackupTest : InstrumentedTest { // - Alice must have the same keys on both devices for (aliceKey1 in testData.aliceKeys) { - val aliceKey2 = (testData.aliceSession2.cryptoService().keysBackupService() as KeysBackup).store + val aliceKey2 = (testData.aliceSession2.cryptoService().keysBackupService() as DefaultKeysBackupService).store .getInboundGroupSession(aliceKey1.olmInboundGroupSession!!.sessionIdentifier(), aliceKey1.senderKey!!) assertNotNull(aliceKey2) assertKeysEquals(aliceKey1.exportKeys(), aliceKey2!!.exportKeys()) diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt index 593cbb493c..b0acb031fc 100755 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/DefaultCryptoService.kt @@ -49,7 +49,7 @@ import im.vector.matrix.android.internal.crypto.algorithms.megolm.MXMegolmEncryp import im.vector.matrix.android.internal.crypto.algorithms.olm.MXOlmEncryptionFactory import im.vector.matrix.android.internal.crypto.crosssigning.DefaultCrossSigningService import im.vector.matrix.android.internal.crypto.crosssigning.DeviceTrustLevel -import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup +import im.vector.matrix.android.internal.crypto.keysbackup.DefaultKeysBackupService import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo import im.vector.matrix.android.internal.crypto.model.ImportRoomKeysResult import im.vector.matrix.android.internal.crypto.model.MXDeviceInfo @@ -122,7 +122,7 @@ internal class DefaultCryptoService @Inject constructor( // Device list manager private val deviceListManager: DeviceListManager, // The key backup service. - private val keysBackup: KeysBackup, + private val keysBackupService: DefaultKeysBackupService, // private val objectSigner: ObjectSigner, // @@ -301,7 +301,7 @@ internal class DefaultCryptoService @Inject constructor( uploadDeviceKeys() oneTimeKeysUploader.maybeUploadOneTimeKeys() outgoingRoomKeyRequestManager.start() - keysBackup.checkAndStartKeysBackup() + keysBackupService.checkAndStartKeysBackup() if (isInitialSync) { // refresh the devices list for each known room members deviceListManager.invalidateAllDeviceLists() @@ -340,7 +340,7 @@ internal class DefaultCryptoService @Inject constructor( /** * @return the Keys backup Service */ - override fun keysBackupService() = keysBackup + override fun keysBackupService() = keysBackupService /** * @return the VerificationService @@ -721,7 +721,7 @@ internal class DefaultCryptoService @Inject constructor( Timber.e("## onRoomKeyEvent() : Unable to handle keys for ${roomKeyContent.algorithm}") return } - alg.onRoomKeyEvent(event, keysBackup) + alg.onRoomKeyEvent(event, keysBackupService) } /** diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/SetDeviceVerificationAction.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/SetDeviceVerificationAction.kt index 8dad832617..d6538f041d 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/SetDeviceVerificationAction.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/actions/SetDeviceVerificationAction.kt @@ -17,7 +17,7 @@ package im.vector.matrix.android.internal.crypto.actions import im.vector.matrix.android.internal.crypto.crosssigning.DeviceTrustLevel -import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup +import im.vector.matrix.android.internal.crypto.keysbackup.DefaultKeysBackupService import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore import im.vector.matrix.android.internal.di.UserId import timber.log.Timber @@ -26,7 +26,7 @@ import javax.inject.Inject internal class SetDeviceVerificationAction @Inject constructor( private val cryptoStore: IMXCryptoStore, @UserId private val userId: String, - private val keysBackup: KeysBackup) { + private val defaultKeysBackupService: DefaultKeysBackupService) { fun handle(trustLevel: DeviceTrustLevel, userId: String, deviceId: String) { val device = cryptoStore.getUserDevice(userId, deviceId) @@ -42,7 +42,7 @@ internal class SetDeviceVerificationAction @Inject constructor( // If one of the user's own devices is being marked as verified / unverified, // check the key backup status, since whether or not we use this depends on // whether it has a signature from a verified device - keysBackup.checkAndStartKeysBackup() + defaultKeysBackupService.checkAndStartKeysBackup() } } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/IMXDecrypting.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/IMXDecrypting.kt index f63eaa93b3..e8fb6be6ff 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/IMXDecrypting.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/IMXDecrypting.kt @@ -20,7 +20,7 @@ package im.vector.matrix.android.internal.crypto.algorithms import im.vector.matrix.android.api.session.events.model.Event import im.vector.matrix.android.internal.crypto.IncomingRoomKeyRequest import im.vector.matrix.android.internal.crypto.MXEventDecryptionResult -import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup +import im.vector.matrix.android.internal.crypto.keysbackup.DefaultKeysBackupService /** * An interface for decrypting data @@ -41,7 +41,7 @@ internal interface IMXDecrypting { * * @param event the key event. */ - fun onRoomKeyEvent(event: Event, keysBackup: KeysBackup) {} + fun onRoomKeyEvent(event: Event, defaultKeysBackupService: DefaultKeysBackupService) {} /** * Check if the some messages can be decrypted with a new session diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt index 9121ce3fcb..054b38ad06 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmDecryption.kt @@ -30,7 +30,7 @@ import im.vector.matrix.android.internal.crypto.OutgoingRoomKeyRequestManager import im.vector.matrix.android.internal.crypto.actions.EnsureOlmSessionsForDevicesAction import im.vector.matrix.android.internal.crypto.actions.MessageEncrypter import im.vector.matrix.android.internal.crypto.algorithms.IMXDecrypting -import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup +import im.vector.matrix.android.internal.crypto.keysbackup.DefaultKeysBackupService import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap import im.vector.matrix.android.internal.crypto.model.event.EncryptedEventContent import im.vector.matrix.android.internal.crypto.model.event.RoomKeyContent @@ -198,7 +198,7 @@ internal class MXMegolmDecryption(private val userId: String, * * @param event the key event. */ - override fun onRoomKeyEvent(event: Event, keysBackup: KeysBackup) { + override fun onRoomKeyEvent(event: Event, defaultKeysBackupService: DefaultKeysBackupService) { var exportFormat = false val roomKeyContent = event.getClearContent().toModel() ?: return @@ -262,7 +262,7 @@ internal class MXMegolmDecryption(private val userId: String, exportFormat) if (added) { - keysBackup.maybeBackupKeys() + defaultKeysBackupService.maybeBackupKeys() val content = RoomKeyRequestBody() diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt index ee35810763..a2d21c4f89 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryption.kt @@ -28,7 +28,7 @@ import im.vector.matrix.android.internal.crypto.MXOlmDevice import im.vector.matrix.android.internal.crypto.actions.EnsureOlmSessionsForDevicesAction import im.vector.matrix.android.internal.crypto.actions.MessageEncrypter import im.vector.matrix.android.internal.crypto.algorithms.IMXEncrypting -import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup +import im.vector.matrix.android.internal.crypto.keysbackup.DefaultKeysBackupService import im.vector.matrix.android.internal.crypto.model.CryptoDeviceInfo import im.vector.matrix.android.internal.crypto.model.MXUsersDevicesMap import im.vector.matrix.android.internal.crypto.repository.WarnOnUnknownDeviceRepository @@ -42,7 +42,7 @@ internal class MXMegolmEncryption( // The id of the room we will be sending to. private var roomId: String, private val olmDevice: MXOlmDevice, - private val keysBackup: KeysBackup, + private val defaultKeysBackupService: DefaultKeysBackupService, private val cryptoStore: IMXCryptoStore, private val deviceListManager: DeviceListManager, private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction, @@ -85,7 +85,7 @@ internal class MXMegolmEncryption( olmDevice.addInboundGroupSession(sessionId!!, olmDevice.getSessionKey(sessionId)!!, roomId, olmDevice.deviceCurve25519Key!!, emptyList(), keysClaimedMap, false) - keysBackup.maybeBackupKeys() + defaultKeysBackupService.maybeBackupKeys() return MXOutboundSessionInfo(sessionId) } diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt index dadd810a4b..e9fe902f1f 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/algorithms/megolm/MXMegolmEncryptionFactory.kt @@ -21,7 +21,7 @@ import im.vector.matrix.android.internal.crypto.DeviceListManager import im.vector.matrix.android.internal.crypto.MXOlmDevice import im.vector.matrix.android.internal.crypto.actions.EnsureOlmSessionsForDevicesAction import im.vector.matrix.android.internal.crypto.actions.MessageEncrypter -import im.vector.matrix.android.internal.crypto.keysbackup.KeysBackup +import im.vector.matrix.android.internal.crypto.keysbackup.DefaultKeysBackupService import im.vector.matrix.android.internal.crypto.repository.WarnOnUnknownDeviceRepository import im.vector.matrix.android.internal.crypto.store.IMXCryptoStore import im.vector.matrix.android.internal.crypto.tasks.SendToDeviceTask @@ -29,7 +29,7 @@ import javax.inject.Inject internal class MXMegolmEncryptionFactory @Inject constructor( private val olmDevice: MXOlmDevice, - private val keysBackup: KeysBackup, + private val defaultKeysBackupService: DefaultKeysBackupService, private val cryptoStore: IMXCryptoStore, private val deviceListManager: DeviceListManager, private val ensureOlmSessionsForDevicesAction: EnsureOlmSessionsForDevicesAction, @@ -42,7 +42,7 @@ internal class MXMegolmEncryptionFactory @Inject constructor( return MXMegolmEncryption( roomId, olmDevice, - keysBackup, + defaultKeysBackupService, cryptoStore, deviceListManager, ensureOlmSessionsForDevicesAction, diff --git a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackup.kt b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/DefaultKeysBackupService.kt similarity index 99% rename from matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackup.kt rename to matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/DefaultKeysBackupService.kt index 595b55a7a6..a630467d4c 100644 --- a/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/KeysBackup.kt +++ b/matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/crypto/keysbackup/DefaultKeysBackupService.kt @@ -92,12 +92,11 @@ import javax.inject.Inject import kotlin.random.Random /** - * A KeysBackup class instance manage incremental backup of e2e keys (megolm keys) + * A DefaultKeysBackupService class instance manage incremental backup of e2e keys (megolm keys) * to the user's homeserver. */ - @SessionScope -internal class KeysBackup @Inject constructor( +internal class DefaultKeysBackupService @Inject constructor( @UserId private val userId: String, private val credentials: Credentials, private val cryptoStore: IMXCryptoStore,