feat: Update CC to 55 and adopt E2EI changes [WPB-7126]

cryptography/src/commonJvmAndroid/kotlin/com.wire.kalium.cryptography/MLSClientImpl.kt

@@ -326,14 +326,14 @@ class MLSClientImpl(
             return clientId?.let {
                 WireIdentity(
                     CryptoQualifiedClientId.fromEncodedString(value.clientId)!!,
-                    value.handle,
-                    value.displayName,
-                    value.domain,
-                    value.certificate,
+                    value.x509Identity?.handle,
+                    value.x509Identity?.displayName,
+                    value.x509Identity?.domain,
+                    value.x509Identity?.certificate,
                     toDeviceStatus(value.status),
                     value.thumbprint,
-                    value.serialNumber,
-                    value.notAfter.toLong()
+                    value.x509Identity?.serialNumber,
+                    value.x509Identity?.notAfter?.toLong()
                 )
             }
         }

cryptography/src/commonMain/kotlin/com/wire/kalium/cryptography/IDs.kt

@@ -78,35 +78,54 @@ data class CryptoQualifiedClientId(
 
 data class WireIdentity(
     val clientId: CryptoQualifiedClientId,
-    val handle: Handle,
-    val displayName: String,
-    val domain: String,
-    val certificate: String,
+    val certificate: Certificate?,
     val status: CryptoCertificateStatus,
-    val thumbprint: String,
-    val serialNumber: String,
-    val endTimestampSeconds: Long
 ) {
-    constructor(
-        clientId: CryptoQualifiedClientId,
-        handle: String,
-        displayName: String,
-        domain: String,
-        certificate: String,
-        status: CryptoCertificateStatus,
-        thumbprint: String,
-        serialNumber: String,
-        endTimestampSeconds: Long
-    ) : this(
-        clientId = clientId,
-        handle = Handle.fromString(handle, domain),
-        displayName = displayName,
-        domain = domain,
-        certificate = certificate,
-        status = status,
-        thumbprint = thumbprint,
-        serialNumber = serialNumber,
-        endTimestampSeconds = endTimestampSeconds
+    companion object {
+        @Suppress("LongParameterList")
+        operator fun invoke(
+            clientId: CryptoQualifiedClientId,
+            handle: String?,
+            displayName: String?,
+            domain: String?,
+            certificate: String?,
+            status: CryptoCertificateStatus,
+            thumbprint: String?,
+            serialNumber: String?,
+            endTimestampSeconds: Long?
+        ): WireIdentity {
+            @Suppress("ComplexCondition")
+            val certificateData = if (handle == null || displayName == null || domain == null || certificate == null
+                || thumbprint == null || serialNumber == null || endTimestampSeconds == null
+            ) {
+                null
+            } else {
+                Certificate(
+                    Handle.fromString(handle, domain),
+                    displayName,
+                    domain,
+                    certificate,
+                    thumbprint,
+                    serialNumber,
+                    endTimestampSeconds
+                )
+            }
+            return WireIdentity(
+                clientId = clientId,
+                certificate = certificateData,
+                status = status
+            )
+        }
+    }
+
+    data class Certificate(
+        val handle: Handle,
+        val displayName: String,
+        val domain: String,
+        val certificate: String,
+        val thumbprint: String,
+        val serialNumber: String,
+        val endTimestampSeconds: Long
     )
 
     // WireIdentity handle format is "{scheme}%40{username}@{domain}"

gradle/libs.versions.toml

@@ -37,7 +37,7 @@ pbandk = "0.14.2"
 turbine = "1.0.0"
 avs = "9.6.13"
 jna = "5.14.0"
-core-crypto = "1.0.0-rc.54"
+core-crypto = "1.0.0-rc.55"
 core-crypto-multiplatform = "0.6.0-rc.3-multiplatform-pre1"
 completeKotlin = "1.1.0"
 desugar-jdk = "2.0.4"

logic/src/commonMain/kotlin/com/wire/kalium/logic/data/conversation/DecryptedMessageBundleMapper.kt

@@ -34,14 +34,16 @@ fun com.wire.kalium.cryptography.DecryptedMessageBundle.toModel(groupID: GroupID
         },
         commitDelay,
         identity?.let { identity ->
-            E2EIdentity(
-                identity.clientId,
-                identity.handle.handle,
-                identity.displayName,
-                identity.domain,
-                identity.certificate,
-                identity.status,
-                identity.thumbprint
-            )
+            identity.certificate?.let { certificate ->
+                E2EIdentity(
+                    identity.clientId,
+                    certificate.handle.handle,
+                    certificate.displayName,
+                    certificate.domain,
+                    certificate.certificate,
+                    identity.status,
+                    certificate.thumbprint
+                )
+            }
         }
     )

logic/src/commonMain/kotlin/com/wire/kalium/logic/data/e2ei/MLSConversationsVerificationStatusesHandler.kt

@@ -123,8 +123,9 @@ internal class MLSConversationsVerificationStatusesHandlerImpl(
                     val persistedMemberInfo = dbData.members[userId.toDao()]
                     val isUserVerified = wireIdentity.firstOrNull {
                         it.status != CryptoCertificateStatus.VALID ||
-                                it.displayName != persistedMemberInfo?.name ||
-                                it.handle.handle != persistedMemberInfo.handle
+                                it.certificate == null ||
+                                it.certificate?.displayName != persistedMemberInfo?.name ||
+                                it.certificate?.handle?.handle != persistedMemberInfo?.handle
                     } == null
                     if (!isUserVerified) {
                         newStatus = VerificationStatus.NOT_VERIFIED

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/e2ei/E2eiCertificate.kt

@@ -27,12 +27,14 @@ data class E2eiCertificate(
     val endAt: Instant
 ) {
     companion object {
-        fun fromWireIdentity(identity: WireIdentity, certificateStatusMapper: CertificateStatusMapper): E2eiCertificate =
-            E2eiCertificate(
-                status = certificateStatusMapper.toCertificateStatus(identity.status),
-                serialNumber = identity.serialNumber,
-                certificateDetail = identity.certificate,
-                endAt = Instant.fromEpochSeconds(identity.endTimestampSeconds)
-            )
+        fun fromWireIdentity(identity: WireIdentity, certificateStatusMapper: CertificateStatusMapper): E2eiCertificate? =
+            identity.certificate?.let {
+                E2eiCertificate(
+                    status = certificateStatusMapper.toCertificateStatus(identity.status),
+                    serialNumber = it.serialNumber,
+                    certificateDetail = it.certificate,
+                    endAt = Instant.fromEpochSeconds(it.endTimestampSeconds)
+                )
+            }
     }
 }

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/e2ei/usecase/GetE2EICertificateUseCase.kt

@@ -39,8 +39,9 @@ class GetE2eiCertificateUseCaseImpl internal constructor(
             { GetE2EICertificateUseCaseResult.Failure },
             {
                 it?.let {
-                    val certificate = E2eiCertificate.fromWireIdentity(it, certificateStatusMapper)
-                    GetE2EICertificateUseCaseResult.Success(certificate)
+                    E2eiCertificate.fromWireIdentity(it, certificateStatusMapper)?.let { certificate ->
+                        GetE2EICertificateUseCaseResult.Success(certificate)
+                    }
                 } ?: GetE2EICertificateUseCaseResult.NotActivated
             }
         )

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/e2ei/usecase/GetMembersE2EICertificateStatusesUseCase.kt

@@ -59,11 +59,11 @@ fun List<WireIdentity>.getUserCertificateStatus(certificateStatusMapper: Certifi
     val certificates = this.map {
         E2eiCertificate.fromWireIdentity(it, certificateStatusMapper)
     }
-    return if (certificates.isEmpty()) {
+    return if (certificates.isEmpty() || certificates.any { it == null }) {
         null
-    } else if (certificates.any { it.status == CertificateStatus.REVOKED }) {
+    } else if (certificates.any { it!!.status == CertificateStatus.REVOKED }) {
         CertificateStatus.REVOKED
-    } else if (certificates.any { it.status == CertificateStatus.EXPIRED }) {
+    } else if (certificates.any { it!!.status == CertificateStatus.EXPIRED }) {
         CertificateStatus.EXPIRED
     } else {
         CertificateStatus.VALID

logic/src/commonMain/kotlin/com/wire/kalium/logic/feature/e2ei/usecase/GetUserE2EIAllCertificatesUseCase.kt

@@ -44,8 +44,9 @@ class GetUserE2eiCertificatesUseCaseImpl internal constructor(
             mlsConversationRepository.getUserIdentity(userId).map { identities ->
                 val result = mutableMapOf<String, E2eiCertificate>()
                 identities.forEach {
-                    val certificate = E2eiCertificate.fromWireIdentity(it, certificateStatusMapper)
-                    result[it.clientId.value] = certificate
+                    E2eiCertificate.fromWireIdentity(it, certificateStatusMapper)?.let { certificate ->
+                        result[it.clientId.value] = certificate
+                    }
                 }
                 result
             }.getOrElse(mapOf())

logic/src/commonTest/kotlin/com/wire/kalium/logic/data/conversation/MLSConversationRepositoryTest.kt

@@ -1582,7 +1582,11 @@ class MLSConversationRepositoryTest {
         val domain = "domain.com"
         val handleWithSchemeAndDomain = "$scheme://%40$handle@$domain"
         val groupId = Arrangement.GROUP_ID.value
-        val wireIdentity = WIRE_IDENTITY.copy(handle = WireIdentity.Handle.fromString(handleWithSchemeAndDomain, domain))
+        val wireIdentity = WIRE_IDENTITY.copy(
+            certificate = WIRE_IDENTITY.certificate!!.copy(
+                handle = WireIdentity.Handle.fromString(handleWithSchemeAndDomain, domain)
+            )
+        )
         val (_, mlsConversationRepository) = Arrangement()
             .withGetEstablishedSelfMLSGroupIdReturns(groupId)
             .withGetMLSClientSuccessful()
@@ -1593,9 +1597,9 @@ class MLSConversationRepositoryTest {
         // then
         result.shouldSucceed() {
             it.forEach {
-                assertEquals(scheme, it.handle.scheme)
-                assertEquals(handle, it.handle.handle)
-                assertEquals(domain, it.handle.domain)
+                assertEquals(scheme, it.certificate?.handle?.scheme)
+                assertEquals(handle, it.certificate?.handle?.handle)
+                assertEquals(domain, it.certificate?.handle?.domain)
             }
         }
     }
@@ -1608,7 +1612,11 @@ class MLSConversationRepositoryTest {
         val domain = "domain.com"
         val handleWithSchemeAndDomain = "$scheme://%40$handle@$domain"
         val groupId = Arrangement.GROUP_ID.value
-        val wireIdentity = WIRE_IDENTITY.copy(handle = WireIdentity.Handle.fromString(handleWithSchemeAndDomain, domain))
+        val wireIdentity = WIRE_IDENTITY.copy(
+            certificate = WIRE_IDENTITY.certificate!!.copy(
+                handle = WireIdentity.Handle.fromString(handleWithSchemeAndDomain, domain)
+            )
+        )
         val (_, mlsConversationRepository) = Arrangement()
             .withGetMLSGroupIdByConversationIdReturns(groupId)
             .withGetMLSClientSuccessful()
@@ -1620,9 +1628,9 @@ class MLSConversationRepositoryTest {
         result.shouldSucceed() {
             it.values.forEach {
                 it.forEach {
-                    assertEquals(scheme, it.handle.scheme)
-                    assertEquals(handle, it.handle.handle)
-                    assertEquals(domain, it.handle.domain)
+                    assertEquals(scheme, it.certificate?.handle?.scheme)
+                    assertEquals(handle, it.certificate?.handle?.handle)
+                    assertEquals(domain, it.certificate?.handle?.domain)
                 }
             }
         }