Better fix subfolders in encrypted folders (using existing metadata retrieval function)

Signed-off-by: daniele-verducci <daniele.verducci@nextcloud.com>

Author: daniele-verducci

app/src/main/java/com/nextcloud/utils/e2ee/E2EEKeyInspector.kt

@@ -14,19 +14,18 @@ import com.owncloud.android.datamodel.ArbitraryDataProvider
 import com.owncloud.android.datamodel.FileDataStorageManager
 import com.owncloud.android.datamodel.OCFile
 import com.owncloud.android.datamodel.e2e.v1.encrypted.EncryptedFolderMetadataFileV1
-import com.owncloud.android.datamodel.e2e.v2.encrypted.EncryptedFolderMetadataFile
 import com.owncloud.android.lib.common.OwnCloudClient
 import com.owncloud.android.lib.common.OwnCloudClientFactory
 import com.owncloud.android.lib.common.utils.Log_OC
 import com.owncloud.android.lib.resources.e2ee.GetMetadataRemoteOperation
-import com.owncloud.android.lib.resources.e2ee.MetadataResponse
 import com.owncloud.android.lib.resources.status.OCCapability
 import com.owncloud.android.lib.resources.users.GetPublicKeyRemoteOperation
 import com.owncloud.android.lib.resources.users.GetServerPublicKeyRemoteOperation
 import com.owncloud.android.operations.GetCapabilitiesOperation
 import com.owncloud.android.ui.dialog.setupEncryption.CertificateValidator
 import com.owncloud.android.ui.dialog.setupEncryption.model.DownloadKeyResult
 import com.owncloud.android.utils.EncryptionUtils
+import com.owncloud.android.utils.EncryptionUtilsV2
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.apache.commons.httpclient.HttpStatus
@@ -89,66 +88,54 @@ class E2EEKeyInspector @Inject constructor(
             Log_OC.d(TAG, "checking folder metadata key")
 
             val client = OwnCloudClientFactory.createOwnCloudClient(accountManager.currentAccount, context)
+            val metadataResult = GetMetadataRemoteOperation(folder.localId).execute(client)
+
+            if (!metadataResult.isSuccess) {
+                return@withContext false
+            }
 
             val privateKey = arbitraryDataProvider.getValue(accountManager.user, EncryptionUtils.PRIVATE_KEY)
             if (privateKey.isEmpty()) {
                 Log_OC.e(TAG, "user try to decrypt folder with empty private key")
                 return@withContext false
             }
 
+            val metadata = metadataResult.resultData
+
             return@withContext if (E2EVersionHelper.isV2Plus(capability)) {
-                decryptsMetadataV2(client, privateKey, folder)
+                decryptsMetadataV2(folder, privateKey, client)
             } else {
-                decryptsMetadataV1(client, privateKey, folder)
+                decryptsMetadataV1(metadata.metadata, privateKey, folder.localId)
             }
         }
 
-    private fun obtainMetadata(client: OwnCloudClient, folder: OCFile): MetadataResponse? {
-        val metadataResult = GetMetadataRemoteOperation(folder.localId).execute(client)
-
-        if (!metadataResult.isSuccess) {
-            return null
-        }
-
-        return metadataResult.resultData
-    }
-
-    private fun getNearestEncryptedMetadataKey(client: OwnCloudClient, folder: OCFile): String? {
-        val metadata = obtainMetadata(client, folder) ?: return null
-        val metadataFile = EncryptionUtils.deserializeJSON(
-            metadata.metadata,
-            object : TypeToken<EncryptedFolderMetadataFile>() {}
+    private fun decryptsMetadataV2(ocFile: OCFile, privateKey: String, client: OwnCloudClient): Boolean {
+        val userId = client.userId
+        val metadata = EncryptionUtilsV2().retrieveTopMostMetadata(
+            ocFile,
+            storageManager,
+            client,
+            userId,
+            privateKey,
+            accountManager.user,
+            context,
+            arbitraryDataProvider
         )
-
-        val user = metadataFile.users?.find { it.userId == client.userId }
-        if (user != null) {
-            return user.encryptedMetadataKey
-        }
-
-        val parentFolder = storageManager.getFileById(folder.parentId)
-        if (parentFolder?.isEncrypted == true) {
-            return getNearestEncryptedMetadataKey(client, parentFolder)
-        }
-
-        return null
-    }
-
-    private fun decryptsMetadataV2(client: OwnCloudClient, privateKey: String, folder: OCFile): Boolean {
-        val encryptedMetadataKey = getNearestEncryptedMetadataKey(client, folder) ?: return false
+        val user = metadata.users.find { it.userId == userId }
+            ?: throw IllegalStateException("cannot find current user in metadata")
 
         return try {
-            EncryptionUtils.decryptStringAsymmetricV2(encryptedMetadataKey, privateKey)
+            EncryptionUtils.decryptStringAsymmetricV2(user.decryptedMetadataKey, privateKey)
             true
         } catch (e: Exception) {
             Log_OC.w(TAG, "user tried to decrypt folder's metadata with different private key: $e")
             false
         }
     }
 
-    private fun decryptsMetadataV1(client: OwnCloudClient, privateKey: String, folder: OCFile): Boolean {
-        val metadata = obtainMetadata(client, folder) ?: return false
+    private fun decryptsMetadataV1(serializedMetadata: String, privateKey: String, folderLocalId: Long): Boolean {
         val metadataFile = EncryptionUtils.deserializeJSON(
-            metadata.metadata,
+            serializedMetadata,
             object : TypeToken<EncryptedFolderMetadataFileV1?>() {}
         )
 
@@ -158,7 +145,7 @@ class E2EEKeyInspector @Inject constructor(
                 privateKey,
                 arbitraryDataProvider,
                 accountManager.user,
-                folder.localId
+                folderLocalId
             )
             true
         } catch (e: Exception) {