diff --git a/app/src/androidTest/java/com/owncloud/android/files/FileMenuFilterIT.kt b/app/src/androidTest/java/com/owncloud/android/files/FileMenuFilterIT.kt index e3f5f2cb372e..822c482b1751 100644 --- a/app/src/androidTest/java/com/owncloud/android/files/FileMenuFilterIT.kt +++ b/app/src/androidTest/java/com/owncloud/android/files/FileMenuFilterIT.kt @@ -181,6 +181,8 @@ class FileMenuFilterIT : AbstractIT() { var sut = filterFactory.newInstance(encryptedFolder, mockComponentsGetter, true, user) var toHide = sut.getToHide(false) + assertFalse(toHide.contains(R.id.action_move_or_copy)) + // encrypted folder, with content assertTrue(toHide.contains(R.id.action_unset_encrypted)) assertTrue(toHide.contains(R.id.action_encrypted)) @@ -239,6 +241,12 @@ class FileMenuFilterIT : AbstractIT() { var sut = filterFactory.newInstance(encryptedVideo, mockComponentsGetter, true, user) var toHide = sut.getToHide(false) + assertFalse(toHide.contains(R.id.action_move_or_copy)) + + encryptedVideo.isLocked = true + sut = filterFactory.newInstance(encryptedVideo, mockComponentsGetter, true, user) + assertTrue(sut.getToHide(false).contains(R.id.action_move_or_copy)) + // encrypted video, with content assertTrue(toHide.contains(R.id.action_stream_media)) diff --git a/app/src/main/java/com/owncloud/android/files/FileMenuFilter.kt b/app/src/main/java/com/owncloud/android/files/FileMenuFilter.kt index 1c71b9f9b999..10247e97f693 100644 --- a/app/src/main/java/com/owncloud/android/files/FileMenuFilter.kt +++ b/app/src/main/java/com/owncloud/android/files/FileMenuFilter.kt @@ -71,7 +71,7 @@ class FileMenuFilter internal constructor( if (isEditHidden(capability)) add(R.id.action_edit) if (!selection.isSingleSelection || synchronizing || containsEncryptedOrLocked) add(R.id.action_rename_file) - if (synchronizing || containsEncryptedOrLocked) add(R.id.action_move_or_copy) + if (synchronizing || selection.containsLocked) add(R.id.action_move_or_copy) if (synchronizing || selection.containsLocked || selection.containsEncryptedFolderContent()) { add(R.id.action_remove_file) } diff --git a/app/src/main/java/com/owncloud/android/operations/CopyFileOperation.java b/app/src/main/java/com/owncloud/android/operations/CopyFileOperation.java index bd7d21a6db16..95b530c83dd8 100644 --- a/app/src/main/java/com/owncloud/android/operations/CopyFileOperation.java +++ b/app/src/main/java/com/owncloud/android/operations/CopyFileOperation.java @@ -26,6 +26,7 @@ public class CopyFileOperation extends SyncOperation { private final String srcPath; private String targetParentPath; + private EncryptedFileTransfer encryptedTransfer; /** * Constructor @@ -43,6 +44,10 @@ public CopyFileOperation(String srcPath, String targetParentPath, FileDataStorag } } + public void setEncryptedTransfer(EncryptedFileTransfer transfer) { + encryptedTransfer = transfer; + } + /** * Performs the operation. * @@ -59,6 +64,11 @@ protected RemoteOperationResult run(OwnCloudClient client) { return new RemoteOperationResult(ResultCode.FILE_NOT_FOUND); } + OCFile parent = getStorageManager().getFileByEncryptedRemotePath(targetParentPath); + if (encryptedTransfer != null && parent != null && (file.isEncrypted() || parent.isEncrypted())) { + return encryptedTransfer.copy(file, parent, client); + } + /// 2. remote copy String targetPath = targetParentPath + file.getFileName(); if (file.isFolder()) { diff --git a/app/src/main/java/com/owncloud/android/operations/EncryptedFileTransfer.kt b/app/src/main/java/com/owncloud/android/operations/EncryptedFileTransfer.kt new file mode 100644 index 000000000000..4e9ba69b6daf --- /dev/null +++ b/app/src/main/java/com/owncloud/android/operations/EncryptedFileTransfer.kt @@ -0,0 +1,129 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import android.content.Context +import com.nextcloud.client.account.User +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import com.owncloud.android.lib.resources.files.ReadFileRemoteOperation +import com.owncloud.android.lib.resources.files.model.RemoteFile +import com.owncloud.android.operations.factory.UploadFileOperationFactory + +@Suppress("DEPRECATION") +class EncryptedFileTransfer( + private val storageManager: FileDataStorageManager, + private val user: User, + private val context: Context, + uploadFactory: UploadFileOperationFactory, + private val keepEncryption: Boolean +) { + private val content = FileTransferContent(context, user, storageManager, uploadFactory) + + fun copy(file: OCFile, parent: OCFile, client: OwnCloudClient): RemoteOperationResult<*> = + transfer(file, parent, client, false) + + fun move(file: OCFile, parent: OCFile, client: OwnCloudClient): RemoteOperationResult<*> = + transfer(file, parent, client, true) + + private fun transfer( + file: OCFile, + parent: OCFile, + client: OwnCloudClient, + removeSource: Boolean + ): RemoteOperationResult<*> { + invalidTarget(file, parent, removeSource)?.let { return RemoteOperationResult(it) } + + return try { + val source = FileTransferSource(context, user, storageManager) + if (source.hasLocalChanges(file)) return RemoteOperationResult(ResultCode.SYNC_CONFLICT) + val stat = ReadFileRemoteOperation(file.remotePath).execute(client) + if (!stat.isSuccess) return stat + val original = stat.data.firstOrNull() as? RemoteFile + ?: return RemoteOperationResult(ResultCode.FILE_NOT_FOUND) + val sourceEtag = original.etag.orEmpty() + if (removeSource && sourceEtag.isEmpty()) { + return RemoteOperationResult(ResultCode.UNKNOWN_ERROR) + } + + val refreshed = refresh(parent, client) + if (!refreshed.isSuccess) return refreshed + val filename = targetName(file, parent, client, !removeSource) + ?: return RemoteOperationResult(ResultCode.INVALID_OVERWRITE) + val copied = copyTree(file, parent, filename, client) + if (!copied.isSuccess || !removeSource) return copied + + source.remove(file, sourceEtag, client) + } catch (e: Exception) { + RemoteOperationResult(e) + } + } + + private fun invalidTarget(file: OCFile, parent: OCFile, removeSource: Boolean): ResultCode? = when { + file.remotePath == OCFile.ROOT_PATH || (file.isFolder && parent.remotePath.startsWith(file.remotePath)) -> + if (removeSource) ResultCode.INVALID_MOVE_INTO_DESCENDANT else ResultCode.INVALID_COPY_INTO_DESCENDANT + + removeSource && file.parentId == parent.fileId -> ResultCode.INVALID_OVERWRITE + + else -> null + } + + private fun targetName(file: OCFile, parent: OCFile, client: OwnCloudClient, allowRename: Boolean): String? { + val names = storageManager.getFolderContent(parent, false).asSequence().map { it.decryptedFileName }.toList() + if (names.none { it.equals(file.decryptedFileName, ignoreCase = true) }) return file.decryptedFileName + if (!allowRename || file.parentId != parent.fileId) return null + return UploadFileOperation.getNewAvailableRemotePath( + client, + file.decryptedFileName, + names, + true + ) + } + + private fun copyTree( + source: OCFile, + parent: OCFile, + filename: String, + client: OwnCloudClient + ): RemoteOperationResult<*> { + if (source.isLocked) return RemoteOperationResult(ResultCode.LOCK_FAILED) + if (!source.isFolder) return content.copy(source, parent, filename, client) + + val refreshed = refresh(source, client) + if (!refreshed.isSuccess) return refreshed + // Capture the complete server listing before creating anything in the destination. + val children = storageManager.getFolderContent(source, false).toList() + val path = parent.decryptedRemotePath + filename + OCFile.PATH_SEPARATOR + val created = CreateFolderOperation(path, user, context, storageManager).execute(client) + if (!created.isSuccess) return created + val destination = storageManager.getFileByDecryptedRemotePath(path) + ?: return RemoteOperationResult(ResultCode.FILE_NOT_FOUND) + if (keepEncryption && source.isEncrypted && !parent.isEncrypted) { + val encrypted = FileTransferSource(context, user, storageManager).encrypt(destination, client) + if (!encrypted.isSuccess) return encrypted + } + for (child in children) { + val copied = copyTree(child, destination, child.decryptedFileName, client) + if (!copied.isSuccess) return copied + } + return RemoteOperationResult(ResultCode.OK) + } + + private fun refresh(folder: OCFile, client: OwnCloudClient): RemoteOperationResult<*> = RefreshFolderOperation( + folder, + System.currentTimeMillis(), + false, + true, + true, + storageManager, + user, + context + ).execute(client) +} diff --git a/app/src/main/java/com/owncloud/android/operations/FileTransferContent.kt b/app/src/main/java/com/owncloud/android/operations/FileTransferContent.kt new file mode 100644 index 000000000000..1de9a13cef9c --- /dev/null +++ b/app/src/main/java/com/owncloud/android/operations/FileTransferContent.kt @@ -0,0 +1,106 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import android.content.Context +import com.nextcloud.client.account.User +import com.nextcloud.client.jobs.upload.FileUploadWorker +import com.nextcloud.utils.extensions.toNextcloudClient +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.datamodel.e2e.v1.decrypted.DecryptedFolderMetadataFileV1 +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedFolderMetadataFile +import com.owncloud.android.db.OCUpload +import com.owncloud.android.files.services.NameCollisionPolicy +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.utils.Log_OC +import com.owncloud.android.lib.resources.files.DownloadFileRemoteOperation +import com.owncloud.android.operations.factory.UploadFileOperationFactory +import com.owncloud.android.utils.EncryptionUtils +import java.io.IOException +import java.nio.file.Files +import java.nio.file.Path +import javax.crypto.Cipher + +@Suppress("DEPRECATION") +class FileTransferContent( + private val context: Context, + private val user: User, + private val storageManager: FileDataStorageManager, + private val uploadFactory: UploadFileOperationFactory +) { + fun copy(source: OCFile, parent: OCFile, filename: String, client: OwnCloudClient): RemoteOperationResult<*> { + val directoryPath = Files.createTempDirectory(context.cacheDir.toPath(), "file-transfer-") + val directory = directoryPath.toFile() + try { + val raw = directoryPath.resolve(source.remotePath.trimStart('/')).normalize() + require(raw != directoryPath && raw.startsWith(directoryPath)) + val download = DownloadFileRemoteOperation(source.remotePath, directory.absolutePath, source.fileLength) + val downloaded = download.execute(client.toNextcloudClient(context)) + if (!downloaded.isSuccess) return downloaded + + val plaintext = directoryPath.resolve("content") + if (source.isEncrypted) { + decrypt(source, raw, plaintext, client) + } else { + Files.move(raw, plaintext) + } + if (!plaintext.toFile().setLastModified(download.modificationTimestamp)) { + Log_OC.w(TAG, "Unable to preserve transfer modification time") + } + val upload = OCUpload(plaintext.toString(), parent.remotePath + filename, user.accountName).apply { + localAction = FileUploadWorker.LOCAL_BEHAVIOUR_FORGET + nameCollisionPolicy = NameCollisionPolicy.ASK_USER + setUseWifiOnly(false) + } + val operation = uploadFactory.create(context, upload, user = user, storageManager = storageManager) + operation.setKeepE2EELockOnFailure(true) + operation.file.mimeType = source.mimeType + return operation.execute(client) + } finally { + if (!directory.deleteRecursively()) Log_OC.w(TAG, "Unable to remove temporary transfer content") + } + } + + private fun decrypt(source: OCFile, raw: Path, plaintext: Path, client: OwnCloudClient) { + val parent = storageManager.getFileById(source.parentId) + ?: throw IOException("Encrypted transfer source has no parent") + val metadata = EncryptionUtils.downloadFolderMetadata(parent, client, context, user) + val (key, nonce) = when (metadata) { + is DecryptedFolderMetadataFile -> metadata.metadata.files[source.encryptedFileName]?.let { + it.key to it.nonce + } + + is DecryptedFolderMetadataFileV1 -> metadata.files[source.encryptedFileName]?.let { + it.encrypted.key to it.initializationVector + } + + else -> null + } ?: throw IOException("Encrypted transfer source is missing from metadata") + val cipher = EncryptionUtils.getCipher( + Cipher.DECRYPT_MODE, + EncryptionUtils.decodeStringToBase64Bytes(key), + EncryptionUtils.decodeStringToBase64Bytes(nonce) + ) + Files.newInputStream(raw).use { input -> + Files.newOutputStream(plaintext).use { output -> + val buffer = ByteArray(DEFAULT_BUFFER_SIZE) + var count = input.read(buffer) + while (count != -1) { + output.write(cipher.update(buffer, 0, count) ?: byteArrayOf()) + count = input.read(buffer) + } + output.write(cipher.doFinal()) + } + } + } + + companion object { + private val TAG = FileTransferContent::class.java.simpleName + } +} diff --git a/app/src/main/java/com/owncloud/android/operations/FileTransferSource.kt b/app/src/main/java/com/owncloud/android/operations/FileTransferSource.kt new file mode 100644 index 000000000000..6ac828a3298a --- /dev/null +++ b/app/src/main/java/com/owncloud/android/operations/FileTransferSource.kt @@ -0,0 +1,122 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import android.content.Context +import androidx.core.util.component1 +import androidx.core.util.component2 +import com.nextcloud.client.account.User +import com.nextcloud.utils.AppConstants.DEFAULT_CONNECTION_TIMEOUT_MS +import com.nextcloud.utils.e2ee.E2EVersionHelper +import com.owncloud.android.datamodel.ArbitraryDataProviderImpl +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import com.owncloud.android.lib.resources.e2ee.ToggleEncryptionRemoteOperation +import com.owncloud.android.utils.EncryptionUtils +import com.owncloud.android.utils.EncryptionUtilsV2 +import org.apache.jackrabbit.webdav.client.methods.DeleteMethod + +@Suppress("DEPRECATION") +class FileTransferSource( + private val context: Context, + private val user: User, + private val storageManager: FileDataStorageManager +) { + fun hasLocalChanges(source: OCFile): Boolean { + if (source.isInConflict) return true + return if (source.isFolder) { + storageManager.getFolderContent(source, false).any(::hasLocalChanges) + } else { + source.localModificationTimestamp > source.lastSyncDateForData + } + } + + fun remove(source: OCFile, etag: String, client: OwnCloudClient): RemoteOperationResult<*> { + if (hasLocalChanges(source)) return RemoteOperationResult(ResultCode.SYNC_CONFLICT) + val result = if (source.isEncrypted) { + val parent = storageManager.getFileById(source.parentId) + ?: return RemoteOperationResult(ResultCode.FILE_NOT_FOUND) + RemoveRemoteEncryptedFileOperation( + source.remotePath, + user, + context, + source.encryptedFileName, + if (parent.isEncrypted) parent else source, + source.isFolder, + etag + ).execute(client) + } else { + delete(source.remotePath, etag, client) + } + if (!result.isSuccess) return result + return if (storageManager.removeFile(source, true, true)) { + result + } else { + RemoteOperationResult(ResultCode.LOCAL_STORAGE_NOT_REMOVED) + } + } + + private fun delete(remotePath: String, etag: String, client: OwnCloudClient): RemoteOperationResult<*> { + val method = DeleteMethod(client.getFilesDavUri(remotePath)) + try { + method.setRequestHeader("If-Match", quotedEtag(etag)) + client.executeMethod(method, DEFAULT_CONNECTION_TIMEOUT_MS, DEFAULT_CONNECTION_TIMEOUT_MS) + method.responseBodyAsString + return RemoteOperationResult(method.succeeded(), method) + } finally { + method.releaseConnection() + } + } + + fun encrypt(folder: OCFile, client: OwnCloudClient): RemoteOperationResult<*> { + val toggled = ToggleEncryptionRemoteOperation(folder.localId, folder.remotePath, true).execute(client) + if (!toggled.isSuccess) return toggled + folder.isEncrypted = true + storageManager.saveFile(folder) + val provider = ArbitraryDataProviderImpl(context) + val publicKey = provider.getValue(user.accountName, EncryptionUtils.CERTIFICATE) + val privateKey = provider.getValue(user.accountName, EncryptionUtils.PRIVATE_KEY) + val isV2 = E2EVersionHelper.isV2Plus(storageManager.getCapability(user)) + val counter = if (isV2) EncryptionUtils.E2E_V2_INITIAL_COUNTER else EncryptionUtils.E2E_V1_INITIAL_COUNTER + val token = EncryptionUtils.lockFolder(folder, client, counter) + // Failed metadata writes must stay staged until the server rolls them back. + if (isV2) { + val utils = EncryptionUtilsV2() + val (exists, metadata) = utils.retrieveMetadata(folder, client, user, context) + utils.serializeAndUploadMetadata(folder, metadata, token, client, exists, context, user, storageManager) + } else { + val (exists, metadata) = EncryptionUtils.retrieveMetadataV1( + folder, + client, + privateKey, + publicKey, + provider, + user, + storageManager.getE2EEVersion(user) + ) + val encrypted = EncryptionUtils.encryptFolderMetadata(metadata, publicKey, folder.localId, user, provider) + EncryptionUtils.uploadMetadata( + folder, EncryptionUtils.serializeJSON(encrypted), token, client, exists, + storageManager.getE2EEVersionObject(user), "", provider, user + ) + } + val unlocked = if (isV2) { + EncryptionUtils.unlockFolder(folder, client, token) + } else { + EncryptionUtils.unlockFolderV1(folder, client, token) + } + if (unlocked.isSuccess && isV2) storageManager.updateE2EECounter(folder, counter) + return unlocked + } + + companion object { + internal fun quotedEtag(etag: String): String = "\"${etag.trim('"')}\"" + } +} diff --git a/app/src/main/java/com/owncloud/android/operations/MoveFileOperation.java b/app/src/main/java/com/owncloud/android/operations/MoveFileOperation.java index 8e2d1d192b5c..26faa2a697a6 100644 --- a/app/src/main/java/com/owncloud/android/operations/MoveFileOperation.java +++ b/app/src/main/java/com/owncloud/android/operations/MoveFileOperation.java @@ -25,6 +25,7 @@ public class MoveFileOperation extends SyncOperation { private final String srcPath; private String targetParentPath; + private EncryptedFileTransfer encryptedTransfer; /** * Constructor @@ -42,6 +43,10 @@ public MoveFileOperation(String srcPath, String targetParentPath, FileDataStorag } } + public void setEncryptedTransfer(EncryptedFileTransfer transfer) { + encryptedTransfer = transfer; + } + /** * Performs the operation. * @@ -58,6 +63,11 @@ protected RemoteOperationResult run(OwnCloudClient client) { return new RemoteOperationResult(ResultCode.FILE_NOT_FOUND); } + OCFile parent = getStorageManager().getFileByEncryptedRemotePath(targetParentPath); + if (encryptedTransfer != null && parent != null && (file.isEncrypted() || parent.isEncrypted())) { + return encryptedTransfer.move(file, parent, client); + } + /// 2. remote move String targetPath = targetParentPath + file.getFileName(); if (file.isFolder()) { diff --git a/app/src/main/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperation.kt b/app/src/main/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperation.kt index 9c83e279f93b..baac69a43815 100644 --- a/app/src/main/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperation.kt +++ b/app/src/main/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperation.kt @@ -24,99 +24,110 @@ import com.owncloud.android.lib.common.utils.Log_OC import com.owncloud.android.lib.resources.status.E2EVersion import com.owncloud.android.utils.EncryptionUtils import com.owncloud.android.utils.EncryptionUtilsV2 -import com.owncloud.android.utils.theme.CapabilityUtils import org.apache.commons.httpclient.HttpStatus import org.apache.commons.httpclient.NameValuePair import org.apache.jackrabbit.webdav.client.methods.DeleteMethod import com.nextcloud.utils.AppConstants.DEFAULT_CONNECTION_TIMEOUT_MS -class RemoveRemoteEncryptedFileOperation internal constructor( +class RemoveRemoteEncryptedFileOperation @JvmOverloads internal constructor( private val remotePath: String, private val user: User, private val context: Context, private val fileName: String, private val parentFolder: OCFile, - private val isFolder: Boolean + private val isFolder: Boolean, + private val expectedEtag: String? = null ) : RemoteOperation() { + @Volatile + private var canCommit = true @Deprecated("Deprecated in Java") override fun run(client: OwnCloudClient): RemoteOperationResult { - var result: RemoteOperationResult - var delete: DeleteMethod? = null + var result = RemoteOperationResult(RemoteOperationResult.ResultCode.UNKNOWN_ERROR) var token: String? = null - val capability = CapabilityUtils.getCapability(context) + val storageManager = FileDataStorageManager(user, context.contentResolver) + val capability = storageManager.getCapability(user) val isE2EVersionAtLeast2 = (E2EVersionHelper.isV2Plus(capability)) val e2eeVersion = capability.endToEndEncryptionApiVersion - val storageManager = FileDataStorageManager(user, context.contentResolver) - val counter = parentFolder.e2eCounter + 1 + var counter = parentFolder.e2eCounter + 1 + canCommit = true try { + if (isE2EVersionAtLeast2) { + val (_, metadata) = EncryptionUtilsV2().retrieveMetadata(parentFolder, client, user, context) + counter = metadata.metadata.counter + 1 + } token = EncryptionUtils.lockFolder(parentFolder, client, counter) - return if (isE2EVersionAtLeast2) { - val deleteResult = deleteForV2(counter, storageManager, client, token) - result = deleteResult.first - delete = deleteResult.second - result + result = if (isE2EVersionAtLeast2) { + deleteForV2(counter, storageManager, client, token) } else { - val deleteResult = deleteForV1(client, token, e2eeVersion) - result = deleteResult.first - delete = deleteResult.second - result + deleteForV1(client, token, e2eeVersion) } } catch (e: Exception) { result = RemoteOperationResult(e) Log_OC.e(TAG, "Remove " + remotePath + ": " + result.logMessage, e) } finally { - delete?.releaseConnection() - token?.let { unlockFile(counter, storageManager, client, it, isE2EVersionAtLeast2) } + if (canCommit && token != null) { + val unlocked = unlockFile( + counter.takeIf { result.isSuccess }, + storageManager, + client, + token, + isE2EVersionAtLeast2 + ) + if (result.isSuccess && !unlocked.isSuccess) result = unlocked + } } return result } private fun unlockFile( - counter: Long, + counter: Long?, storageManager: FileDataStorageManager, client: OwnCloudClient, token: String, isE2EVersionAtLeast2: Boolean - ) { + ): RemoteOperationResult { val unlockFileOperationResult = if (isE2EVersionAtLeast2) { EncryptionUtils.unlockFolder(parentFolder, client, token) } else { EncryptionUtils.unlockFolderV1(parentFolder, client, token) } - if (unlockFileOperationResult.isSuccess && isE2EVersionAtLeast2) { - storageManager.updateE2EECounter(parentFolder, counter) + if (unlockFileOperationResult.isSuccess) { + if (isE2EVersionAtLeast2 && counter != null) storageManager.updateE2EECounter(parentFolder, counter) } else { Log_OC.e(TAG, "Failed to unlock " + parentFolder.localId) } + return unlockFileOperationResult } - private fun deleteRemoteFile( - client: OwnCloudClient, - token: String? - ): Pair, DeleteMethod> { + private fun deleteRemoteFile(client: OwnCloudClient, token: String?): RemoteOperationResult { val delete = DeleteMethod(client.getFilesDavUri(remotePath)).apply { setQueryString(arrayOf(NameValuePair(E2E_TOKEN, token))) + expectedEtag?.let { setRequestHeader("If-Match", FileTransferSource.quotedEtag(it)) } } - val status = client.executeMethod(delete, REMOVE_READ_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT_MS) - delete.getResponseBodyAsString() // exhaust the response, although not interesting - - val result = RemoteOperationResult(delete.succeeded() || status == HttpStatus.SC_NOT_FOUND, delete) - Log_OC.i(TAG, "Remove " + remotePath + ": " + result.logMessage) - - return Pair(result, delete) + try { + canCommit = false + val status = client.executeMethod(delete, REMOVE_READ_TIMEOUT, DEFAULT_CONNECTION_TIMEOUT_MS) + delete.getResponseBodyAsString() // exhaust the response, although not interesting + val result = RemoteOperationResult(delete.succeeded() || status == HttpStatus.SC_NOT_FOUND, delete) + canCommit = !result.isSuccess + Log_OC.i(TAG, "Remove " + remotePath + ": " + result.logMessage) + return result + } finally { + delete.releaseConnection() + } } private fun deleteForV1( client: OwnCloudClient, token: String?, e2eeVersion: E2EVersion - ): Pair, DeleteMethod> { + ): RemoteOperationResult { @Suppress("DEPRECATION") val arbitraryDataProvider: ArbitraryDataProvider = ArbitraryDataProviderImpl(context) val privateKey = arbitraryDataProvider.getValue(user.accountName, EncryptionUtils.PRIVATE_KEY) @@ -132,9 +143,11 @@ class RemoveRemoteEncryptedFileOperation internal constructor( e2eeVersion.value ) - val (result, delete) = deleteRemoteFile(client, token) + val result = deleteRemoteFile(client, token) + if (!result.isSuccess) return result + canCommit = false - if (!isFolder) { + if (remotePath != parentFolder.remotePath) { EncryptionUtils.removeFileFromMetadata(fileName, metadata) } @@ -159,8 +172,9 @@ class RemoveRemoteEncryptedFileOperation internal constructor( arbitraryDataProvider, user ) + canCommit = true - return Pair(result, delete) + return result } private fun deleteForV2( @@ -168,7 +182,7 @@ class RemoveRemoteEncryptedFileOperation internal constructor( storageManager: FileDataStorageManager, client: OwnCloudClient, token: String? - ): Pair, DeleteMethod> { + ): RemoteOperationResult { val encryptionUtilsV2 = EncryptionUtilsV2() val (metadataExists, metadata) = encryptionUtilsV2.retrieveMetadata( @@ -178,16 +192,16 @@ class RemoveRemoteEncryptedFileOperation internal constructor( context ) - // update counter before delete - metadata.metadata.counter = counter + val result = deleteRemoteFile(client, token) + if (!result.isSuccess) return result + canCommit = false - val (result, delete) = deleteRemoteFile(client, token) - - if (isFolder) { + if (isFolder && remotePath != parentFolder.remotePath) { encryptionUtilsV2.removeFolderFromMetadata(fileName, metadata) - } else { + } else if (!isFolder) { encryptionUtilsV2.removeFileFromMetadata(fileName, metadata) } + metadata.metadata.counter = counter encryptionUtilsV2.serializeAndUploadMetadata( parentFolder, @@ -199,8 +213,9 @@ class RemoveRemoteEncryptedFileOperation internal constructor( user, storageManager ) + canCommit = true - return Pair(result, delete) + return result } companion object { diff --git a/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java b/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java index 4270b3e4bdb2..36b3145db354 100644 --- a/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java +++ b/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java @@ -153,6 +153,7 @@ public class UploadFileOperation extends SyncOperation { * Local path to file which is to be uploaded (before any possible renaming or moving). */ private String mOriginalStoragePath; + private volatile boolean keepE2EELockOnFailure; private final Set mDataTransferListeners = new HashSet<>(); private OnRenameListener mRenameUploadListener; @@ -408,6 +409,16 @@ public Context getContext() { return mContext; } + public void setKeepE2EELockOnFailure(boolean keepLock) { + keepE2EELockOnFailure = keepLock; + } + + private void updateStoredUploadResult(RemoteOperationResult result) { + if (mOCUploadId >= 0) { + uploadsStorageManager.updateDatabaseUploadResult(result, this); + } + } + public boolean isMissingPermissionThrown() { return missingPermissionThrown.get(); } @@ -620,7 +631,7 @@ private RemoteOperationResult encryptedUpload(OwnCloudClient client, OCFile pare result = releaseLocksAndUnlockE2EFolder(fileLock, channel, e2eFiles, result, object, client, token); // update upload status - uploadsStorageManager.updateDatabaseUploadResult(result, this); + updateStoredUploadResult(result); } handleLocalBehaviourOrSaveConflictAndDeleteTemporalFile(result, e2eFiles, client); @@ -641,7 +652,9 @@ private String getFolderUnlockTokenOrLockFolder(OwnCloudClient client, OCFile pa } mUpload.setFolderUnlockToken(token); - uploadsStorageManager.updateUpload(mUpload); + if (mOCUploadId >= 0) { + uploadsStorageManager.updateUpload(mUpload); + } Log_OC.d(TAG, "Folder locked successfully, token saved"); return token; @@ -951,6 +964,12 @@ private RemoteOperationResult releaseLocksAndUnlockE2EFolder(FileLock fileLock, return result; } + // Unlock commits staged content even if its metadata could not be written. + if (keepE2EELockOnFailure && !result.isSuccess()) { + e2eFiles.deleteEncryptedTempFile(); + return result; + } + // Unlock must be done otherwise folder stays locked and user can't upload any file RemoteOperationResult unlockFolderResult; try { @@ -1195,7 +1214,7 @@ private RemoteOperationResult normalUpload(OwnCloudClient client) { } logResult(result, mOriginalStoragePath, mRemotePath); - uploadsStorageManager.updateDatabaseUploadResult(result, this); + updateStoredUploadResult(result); } if (result.isSuccess()) { diff --git a/app/src/main/java/com/owncloud/android/services/OperationsService.java b/app/src/main/java/com/owncloud/android/services/OperationsService.java index c328008b7b19..e465c49b58cc 100644 --- a/app/src/main/java/com/owncloud/android/services/OperationsService.java +++ b/app/src/main/java/com/owncloud/android/services/OperationsService.java @@ -56,6 +56,7 @@ import com.owncloud.android.operations.CreateFolderOperation; import com.owncloud.android.operations.CreateShareViaLinkOperation; import com.owncloud.android.operations.CreateShareWithShareeOperation; +import com.owncloud.android.operations.EncryptedFileTransfer; import com.owncloud.android.operations.GetServerInfoOperation; import com.owncloud.android.operations.MoveFileOperation; import com.owncloud.android.operations.RemoveFileOperation; @@ -69,6 +70,7 @@ import com.owncloud.android.operations.UpdateSharePermissionsOperation; import com.owncloud.android.operations.UpdateShareViaLinkOperation; import com.owncloud.android.operations.albums.CopyFileToAlbumOperation; +import com.owncloud.android.operations.factory.UploadFileOperationFactory; import java.io.IOException; import java.util.Optional; @@ -96,6 +98,7 @@ public class OperationsService extends Service { public static final String EXTRA_REMOVE_ONLY_LOCAL = "REMOVE_LOCAL_COPY"; public static final String EXTRA_SYNC_FILE_CONTENTS = "SYNC_FILE_CONTENTS"; public static final String EXTRA_NEW_PARENT_PATH = "NEW_PARENT_PATH"; + public static final String EXTRA_KEEP_ENCRYPTION = "KEEP_ENCRYPTION"; public static final String EXTRA_FILE = "FILE"; public static final String EXTRA_FILE_VERSION = "FILE_VERSION"; public static final String EXTRA_SHARE_PASSWORD = "SHARE_PASSWORD"; @@ -150,6 +153,7 @@ public class OperationsService extends Service { @Inject UserAccountManager accountManager; @Inject ArbitraryDataProvider arbitraryDataProvider; + @Inject UploadFileOperationFactory uploadFileOperationFactory; private static class Target { public Uri mServerUrl; @@ -766,12 +770,18 @@ private Pair newOperation(Intent operationIntent) { remotePath = operationIntent.getStringExtra(EXTRA_REMOTE_PATH); newParentPath = operationIntent.getStringExtra(EXTRA_NEW_PARENT_PATH); operation = new MoveFileOperation(remotePath, newParentPath, fileDataStorageManager); + ((MoveFileOperation) operation).setEncryptedTransfer(new EncryptedFileTransfer( + fileDataStorageManager, user, getApplicationContext(), uploadFileOperationFactory, + operationIntent.getBooleanExtra(EXTRA_KEEP_ENCRYPTION, true))); break; case ACTION_COPY_FILE: remotePath = operationIntent.getStringExtra(EXTRA_REMOTE_PATH); newParentPath = operationIntent.getStringExtra(EXTRA_NEW_PARENT_PATH); operation = new CopyFileOperation(remotePath, newParentPath, fileDataStorageManager); + ((CopyFileOperation) operation).setEncryptedTransfer(new EncryptedFileTransfer( + fileDataStorageManager, user, getApplicationContext(), uploadFileOperationFactory, + operationIntent.getBooleanExtra(EXTRA_KEEP_ENCRYPTION, true))); break; case ACTION_CHECK_CURRENT_CREDENTIALS: diff --git a/app/src/main/java/com/owncloud/android/ui/activity/FolderPickerActivity.kt b/app/src/main/java/com/owncloud/android/ui/activity/FolderPickerActivity.kt index f71f54bf079c..ad6ada65805d 100644 --- a/app/src/main/java/com/owncloud/android/ui/activity/FolderPickerActivity.kt +++ b/app/src/main/java/com/owncloud/android/ui/activity/FolderPickerActivity.kt @@ -493,11 +493,14 @@ open class FolderPickerActivity : } targetFilePaths?.let { filePaths -> - action?.let { action -> - fileOperationsHelper.moveOrCopyFiles(action, filePaths, file) - } - resultData.putStringArrayListExtra(EXTRA_FILE_PATHS, filePaths) + if (action != null) { + fileOperationsHelper.moveOrCopyFiles(action, filePaths, file) { + setResult(RESULT_OK, resultData) + finish() + } + return + } } setResult(RESULT_OK, resultData) diff --git a/app/src/main/java/com/owncloud/android/ui/helpers/FileOperationsHelper.kt b/app/src/main/java/com/owncloud/android/ui/helpers/FileOperationsHelper.kt index 0738d904c22a..ffdf812f35c2 100755 --- a/app/src/main/java/com/owncloud/android/ui/helpers/FileOperationsHelper.kt +++ b/app/src/main/java/com/owncloud/android/ui/helpers/FileOperationsHelper.kt @@ -29,6 +29,8 @@ import android.webkit.MimeTypeMap import androidx.core.content.FileProvider import androidx.core.net.toUri import androidx.lifecycle.lifecycleScope +import com.google.android.material.dialog.MaterialAlertDialogBuilder +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings import com.nextcloud.client.account.CurrentAccountProvider import com.nextcloud.client.account.User import com.nextcloud.client.jobs.BackgroundJobManager @@ -742,17 +744,63 @@ class FileOperationsHelper( queueOperation(intent) } - fun moveOrCopyFiles(action: String?, filePaths: List, targetFolder: OCFile?) { + fun moveOrCopyFiles(action: String?, filePaths: List, targetFolder: OCFile?, onQueued: () -> Unit) { targetFolder ?: return + val targetPath = targetFolder.remotePath + val sources = filePaths.asSequence() + .mapNotNull { fileActivity.storageManager.getFileByEncryptedRemotePath(it) }.toList() + if (sources.none { it.isEncrypted != targetFolder.isEncrypted }) { + queueMoveOrCopy(action, filePaths, targetPath, true, onQueued) + return + } + val builder = MaterialAlertDialogBuilder(fileActivity) + .setTitle(R.string.transfer_encryption_title) + .setNegativeButton(R.string.common_cancel, null) + if (targetFolder.isEncrypted) { + builder.setMessage(R.string.transfer_encrypt_message) + .setPositiveButton(R.string.common_ok) { _, _ -> + queueMoveOrCopy(action, filePaths, targetPath, true, onQueued) + } + } else if (sources.any { it.isFolder && it.isEncrypted }) { + builder.setMessage(R.string.transfer_encrypted_folder_message) + .setPositiveButton(R.string.transfer_keep_encryption) { _, _ -> + queueMoveOrCopy(action, filePaths, targetPath, true, onQueued) + } + .setNeutralButton(R.string.transfer_decrypt) { _, _ -> + queueMoveOrCopy(action, filePaths, targetPath, false, onQueued) + } + } else { + builder.setMessage(R.string.transfer_decrypt_message) + .setPositiveButton(R.string.common_ok) { _, _ -> + queueMoveOrCopy(action, filePaths, targetPath, false, onQueued) + } + } + fileActivity.viewThemeUtils.dialog.colorMaterialAlertDialogBackground(fileActivity, builder) + builder.show() + } + + @SuppressFBWarnings( + "PDP_POORLY_DEFINED_PARAMETER", + justification = "Kotlin erases the string element type of filePaths at the JVM level." + ) + private fun queueMoveOrCopy( + action: String?, + filePaths: List, + targetPath: String, + keepEncryption: Boolean, + onQueued: () -> Unit + ) { filePaths.forEach { path -> val intent = operationIntent(action).apply { - putExtra(OperationsService.EXTRA_NEW_PARENT_PATH, targetFolder.remotePath) + putExtra(OperationsService.EXTRA_NEW_PARENT_PATH, targetPath) putExtra(OperationsService.EXTRA_REMOTE_PATH, path) + putExtra(OperationsService.EXTRA_KEEP_ENCRYPTION, keepEncryption) } queueOperation(intent) } showWaitDialog() + onQueued() } fun cancelTransference(file: OCFile) { diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 3ac930b69134..294066000e23 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -278,6 +278,12 @@ Yes No OK + Copy or move encrypted items + The destination folder is encrypted. The selected files and folders will be encrypted during this operation. Continue? + The destination folder is not encrypted. The selected encrypted files will be decrypted during this operation. Continue? + The destination folder is not encrypted. Keep the selected folders encrypted, or decrypt their contents? Individually selected files will be decrypted in either case. + Keep folders encrypted + Decrypt items Remove Now Cancel sync diff --git a/app/src/test/java/com/owncloud/android/operations/EncryptedFileTransferTest.kt b/app/src/test/java/com/owncloud/android/operations/EncryptedFileTransferTest.kt new file mode 100644 index 000000000000..2211564d1437 --- /dev/null +++ b/app/src/test/java/com/owncloud/android/operations/EncryptedFileTransferTest.kt @@ -0,0 +1,240 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import com.owncloud.android.lib.resources.files.ReadFileRemoteOperation +import com.owncloud.android.lib.resources.files.model.RemoteFile +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.mockito.Mockito.mockConstruction +import org.mockito.kotlin.any +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.doAnswer +import org.mockito.kotlin.inOrder +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +@Suppress("DEPRECATION") +class EncryptedFileTransferTest { + private val storage: FileDataStorageManager = mock() + private val client: OwnCloudClient = mock() + private val source = node("/secret/id", "/secret/report.txt", 2, 1, false) + private val destination = node("/public/", "/public/", 3, 0, true) + private val ok = RemoteOperationResult(ResultCode.OK) + private val failed = RemoteOperationResult(ResultCode.UNKNOWN_ERROR) + private var sourceEtag = "original-version" + + @Test + fun moveDeletesSourceOnlyAfterSuccessfulCopy() = withOperations { content, remover -> + doReturn(ok).whenever(content).copy(source, destination, "report.txt", client) + doReturn(ok).whenever(remover).remove(source, "original-version", client) + + assertTrue(transfer().move(source, destination, client).isSuccess) + + inOrder(content, remover) { + verify(content).copy(source, destination, "report.txt", client) + verify(remover).remove(source, "original-version", client) + } + } + + @Test + fun uploadFailurePreservesSource() = withOperations { content, remover -> + doReturn(failed).whenever(content).copy(source, destination, "report.txt", client) + + assertFalse(transfer().move(source, destination, client).isSuccess) + + verify(remover, never()).remove(any(), any(), any()) + } + + @Test + fun copyDoesNotDeleteSource() = withOperations { content, remover -> + doReturn(ok).whenever(content).copy(source, destination, "report.txt", client) + + assertTrue(transfer().copy(source, destination, client).isSuccess) + + verify(remover, never()).remove(any(), any(), any()) + } + + @Test + fun rejectedConditionalDeleteIsReportedAsFailure() = withOperations { content, remover -> + doReturn(ok).whenever(content).copy(source, destination, "report.txt", client) + doReturn(failed).whenever(remover).remove(source, "original-version", client) + + assertFalse(transfer().move(source, destination, client).isSuccess) + } + + @Test + fun moveWithoutSourceVersionDoesNotStartCopying() = withOperations { content, remover -> + sourceEtag = "" + assertFalse(transfer().move(source, destination, client).isSuccess) + verify(content, never()).copy(any(), any(), any(), any()) + verify(remover, never()).remove(any(), any(), any()) + } + + @Test + fun unsyncedLocalChangesPreventCopyingAnOlderServerVersion() = withOperations { content, remover -> + doReturn(true).whenever(remover).hasLocalChanges(source) + + assertEquals(ResultCode.SYNC_CONFLICT, transfer().move(source, destination, client).code) + + verify(content, never()).copy(any(), any(), any(), any()) + verify(remover, never()).remove(any(), any(), any()) + } + + @Test + fun sameFolderCopyRenamesOnlyTheFilenameWhenParentContainsDots() = withOperations { content, _ -> + doReturn(destination.fileId).whenever(source).parentId + doReturn("README").whenever(source).fileName + doReturn("README").whenever(source).decryptedFileName + doReturn("/secret.v2/").whenever(destination).remotePath + doReturn(listOf(source)).whenever(storage).getFolderContent(destination, false) + doReturn(ok).whenever(content).copy(source, destination, "README (2)", client) + + assertTrue(transfer().copy(source, destination, client).isSuccess) + + verify(content).copy(source, destination, "README (2)", client) + } + + @Test + fun folderMoveKeepsWholeSourceWhenAChildFails() = withOperations { content, remover -> + val folder = node("/secret/folder/", "/secret/photos/", 4, 1, true) + val target = node("/public/photos/", "/public/photos/", 5, 3, true) + val second = node("/secret/folder/second", "/secret/photos/second.txt", 6, 4, false) + doReturn(listOf(source, second)).whenever(storage).getFolderContent(folder, false) + doReturn(target).whenever(storage).getFileByDecryptedRemotePath("/public/photos/") + doReturn(ok).whenever(content).copy(source, target, "report.txt", client) + doReturn(failed).whenever(content).copy(second, target, "second.txt", client) + + mockConstruction(CreateFolderOperation::class.java) { create, _ -> + doReturn(ok).whenever(create).execute(client) + }.use { + assertFalse(transfer().move(folder, destination, client).isSuccess) + } + + verify(content).copy(source, target, "report.txt", client) + verify(remover, never()).remove(any(), any(), any()) + } + + @Test + fun keepingEncryptionEncryptsNewFolderBeforeCopyingChildren() = withOperations { content, remover -> + val folder = node("/secret/folder/", "/secret/photos/", 4, 1, true) + val target = node("/public/photos/", "/public/photos/", 5, 3, true) + doReturn(listOf(source)).whenever(storage).getFolderContent(folder, false) + doReturn(target).whenever(storage).getFileByDecryptedRemotePath("/public/photos/") + doReturn(ok).whenever(remover).encrypt(target, client) + doReturn(ok).whenever(content).copy(source, target, "report.txt", client) + + mockConstruction(CreateFolderOperation::class.java) { create, _ -> + doReturn(ok).whenever(create).execute(client) + }.use { + assertTrue(transfer(keepEncryption = true).copy(folder, destination, client).isSuccess) + } + + inOrder(remover, content) { + verify(remover).encrypt(target, client) + verify(content).copy(source, target, "report.txt", client) + } + } + + @Test + fun encryptedFolderCopyUsesDisplayPathsForCreationAndDisplayNamesForChildren() = withOperations { content, _ -> + val folder = node("/secret/source-id/", "/保险箱/项目资料/", 4, 1, true) + val parent = node("/secret/target-id/", "/加密区/目标/", 5, 1, true) + val target = node("/secret/target-id/new-id/", "/加密区/目标/项目资料/", 6, 5, true) + doReturn(listOf(source)).whenever(storage).getFolderContent(folder, false) + doReturn(target).whenever(storage).getFileByDecryptedRemotePath("/加密区/目标/项目资料/") + doReturn(ok).whenever(content).copy(source, target, "report.txt", client) + + mockConstruction(CreateFolderOperation::class.java) { create, construction -> + assertEquals("/加密区/目标/项目资料/", construction.arguments()[0]) + doReturn(ok).whenever(create).execute(client) + }.use { + assertTrue(transfer().copy(folder, parent, client).isSuccess) + } + + verify(content).copy(source, target, "report.txt", client) + } + + @Test + fun folderCannotBeCopiedIntoItsOwnDescendant() = withOperations { content, remover -> + val folder = node("/secret/folder/", "/secret/photos/", 4, 1, true) + val descendant = node("/secret/folder/child/", "/secret/photos/child/", 5, 4, true) + + val result = transfer().copy(folder, descendant, client) + + assertEquals(ResultCode.INVALID_COPY_INTO_DESCENDANT, result.code) + verify(content, never()).copy(any(), any(), any(), any()) + verify(remover, never()).remove(any(), any(), any()) + } + + private fun transfer(keepEncryption: Boolean = false) = EncryptedFileTransfer( + storage, + mock(), + mock(), + mock(), + keepEncryption + ) + + private fun withOperations(test: (FileTransferContent, FileTransferSource) -> Unit) { + doReturn(emptyList()).whenever(storage).getFolderContent(destination, false) + val content: FileTransferContent = mock() + val remover: FileTransferSource = mock() + mockConstruction(FileTransferContent::class.java) { copy, _ -> + doAnswer { + content.copy(it.getArgument(0), it.getArgument(1), it.getArgument(2), it.getArgument(3)) + }.whenever(copy).copy(any(), any(), any(), any()) + }.use { + mockConstruction(FileTransferSource::class.java) { source, _ -> + doAnswer { remover.hasLocalChanges(it.getArgument(0)) } + .whenever(source).hasLocalChanges(any()) + doAnswer { + remover.remove(it.getArgument(0), it.getArgument(1), it.getArgument(2)) + }.whenever(source).remove(any(), any(), any()) + doAnswer { + remover.encrypt(it.getArgument(0), it.getArgument(1)) + }.whenever(source).encrypt(any(), any()) + }.use { + mockConstruction(RefreshFolderOperation::class.java) { refresh, _ -> + doReturn(ok).whenever(refresh).execute(client) + }.use { + withStat { test(content, remover) } + } + } + } + } + + private fun withStat(test: () -> Unit) { + val remote: RemoteFile = mock { on { etag } doAnswer { sourceEtag } } + val stat: RemoteOperationResult = mock { + on { isSuccess } doReturn true + on { data } doReturn arrayListOf(remote) + } + mockConstruction(ReadFileRemoteOperation::class.java) { read, _ -> + doReturn(stat).whenever(read).execute(client) + }.use { test() } + } + + private fun node(path: String, displayPath: String, id: Long, parent: Long, folder: Boolean): OCFile = mock { + on { remotePath } doReturn path + on { decryptedRemotePath } doReturn displayPath + on { fileName } doReturn displayPath.trimEnd('/').substringAfterLast('/') + on { decryptedFileName } doReturn displayPath.trimEnd('/').substringAfterLast('/') + on { fileId } doReturn id + on { parentId } doReturn parent + on { isFolder } doReturn folder + on { isEncrypted } doReturn path.startsWith("/secret/") + } +} diff --git a/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt b/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt new file mode 100644 index 000000000000..950e3b9de016 --- /dev/null +++ b/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt @@ -0,0 +1,191 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.datamodel.UploadsStorageManager +import com.owncloud.android.datamodel.ArbitraryDataProvider +import com.owncloud.android.datamodel.e2e.v1.encrypted.EncryptedFile +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedFolderMetadataFile +import com.owncloud.android.db.OCUpload +import com.owncloud.android.files.services.NameCollisionPolicy +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import com.owncloud.android.operations.e2e.E2EFiles +import com.owncloud.android.operations.e2e.E2EData +import com.owncloud.android.operations.e2e.E2EClientData +import com.owncloud.android.utils.EncryptionUtils +import com.owncloud.android.utils.EncryptionUtilsV2 +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Test +import org.mockito.Mockito.mockStatic +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.any +import org.mockito.kotlin.whenever +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import java.nio.channels.FileChannel +import java.nio.channels.FileLock + +@Suppress("DEPRECATION") +class EncryptedTransferUploadTest { + private val storage: FileDataStorageManager = mock() + private val uploads: UploadsStorageManager = mock() + private val client: OwnCloudClient = mock() + private val parent: OCFile = mock() + private val metadata: DecryptedFolderMetadataFile = mock() + private val files: E2EFiles = mock { on { parentFile } doReturn parent } + private val ok = RemoteOperationResult(ResultCode.OK) + private val failed = RemoteOperationResult(ResultCode.UNKNOWN_ERROR) + + @Test + fun transientTransferDoesNotUpdateAnUnregisteredUpload() { + val operation = operation(uploadId = -1) + + updateStoredResult(operation) + + verify(uploads, never()).updateDatabaseUploadResult(any(), any()) + } + + @Test + fun queuedUploadStillUpdatesItsStoredResult() { + val operation = operation(uploadId = 17) + + updateStoredResult(operation) + + verify(uploads).updateDatabaseUploadResult(ok, operation) + } + + @Test + fun transientTransferLocksWithoutPersistingAnUnregisteredUpload() { + mockStatic(EncryptionUtils::class.java).use { crypto -> + crypto.`when` { EncryptionUtils.lockFolder(parent, client, 1L) }.thenReturn("token") + + val token = UploadFileOperation::class.java.getDeclaredMethod( + "getFolderUnlockTokenOrLockFolder", + OwnCloudClient::class.java, + OCFile::class.java, + Long::class.javaPrimitiveType + ).apply { isAccessible = true }.invoke(operation(uploadId = -1), client, parent, 1L) + + assertEquals("token", token) + } + verify(uploads, never()).updateUpload(any()) + verify(uploads, never()).getUploadById(any()) + } + + @Test + fun failedTransferDoesNotCommitCiphertextWithoutMetadata() { + val operation = operation().apply { setKeepE2EELockOnFailure(true) } + mockStatic(EncryptionUtils::class.java).use { crypto -> + assertSame(failed, release(operation, failed)) + + crypto.verify({ EncryptionUtils.unlockFolder(parent, client, "token") }, never()) + } + verify(files).deleteEncryptedTempFile() + verify(storage, never()).updateE2EECounter(parent, metadata) + } + + @Test + fun successfulTransferCommitsMetadataAndUpdatesCounter() { + val operation = operation().apply { setKeepE2EELockOnFailure(true) } + mockStatic(EncryptionUtils::class.java).use { crypto -> + crypto.`when`> { EncryptionUtils.unlockFolder(parent, client, "token") } + .thenReturn(ok) + + assertSame(ok, release(operation, ok)) + + crypto.verify { EncryptionUtils.unlockFolder(parent, client, "token") } + } + verify(storage).updateE2EECounter(parent, metadata) + verify(files).deleteEncryptedTempFile() + } + + @Test + fun defaultUploadKeepsItsExistingUnlockBehaviour() { + mockStatic(EncryptionUtils::class.java).use { crypto -> + crypto.`when`> { EncryptionUtils.unlockFolder(parent, client, "token") } + .thenReturn(ok) + + assertSame(failed, release(operation(), failed)) + + crypto.verify { EncryptionUtils.unlockFolder(parent, client, "token") } + } + } + + @Test + fun metadataUsesTheDisplayFilenameWhileTheUploadedFileGetsANewCiphertextName() { + val file = OCFile("/cipher-parent/季度报告.txt").apply { + decryptedRemotePath = "/资料/加密目录/content" + } + doReturn("/资料/加密目录/").whenever(parent).decryptedRemotePath + doReturn("/cipher-parent/").whenever(parent).remotePath + val encrypted: EncryptedFile = mock { on { authenticationTag } doReturn "tag" } + val data = E2EData(byteArrayOf(), byteArrayOf(), encrypted, "new-ciphertext-id") + val utils: EncryptionUtilsV2 = mock() + val clientData = E2EClientData(client, "token", "public-key") + + UploadFileOperation::class.java.getDeclaredMethod( + "upsertMetadata", + Any::class.java, + E2EData::class.java, + E2EClientData::class.java, + E2EFiles::class.java, + ArbitraryDataProvider::class.java, + EncryptionUtilsV2::class.java, + Boolean::class.javaPrimitiveType + ).apply { isAccessible = true }.invoke( + operation(file), + metadata, + data, + clientData, + files, + mock(), + utils, + false + ) + + assertEquals("/cipher-parent/new-ciphertext-id", file.remotePath) + assertEquals("/资料/加密目录/季度报告.txt", file.decryptedRemotePath) + assertEquals("季度报告.txt", file.decryptedFileName) + verify(utils).addFileToMetadata("new-ciphertext-id", file, data.iv, "tag", data.key, metadata) + } + + private fun updateStoredResult(operation: UploadFileOperation) { + UploadFileOperation::class.java.getDeclaredMethod( + "updateStoredUploadResult", + RemoteOperationResult::class.java + ).apply { isAccessible = true }.invoke(operation, ok) + } + + private fun operation(file: OCFile = mock(), uploadId: Long = 0): UploadFileOperation { + val upload: OCUpload = mock { + on { localPath } doReturn "/cache/content" + on { getUploadId() } doReturn uploadId + } + return UploadFileOperation( + uploads, mock(), mock(), mock(), file, upload, NameCollisionPolicy.ASK_USER, + 0, mock(), false, false, true, storage + ) + } + + private fun release(operation: UploadFileOperation, result: RemoteOperationResult): Any? = + UploadFileOperation::class.java.getDeclaredMethod( + "releaseLocksAndUnlockE2EFolder", + FileLock::class.java, + FileChannel::class.java, + E2EFiles::class.java, + RemoteOperationResult::class.java, + Any::class.java, + OwnCloudClient::class.java, + String::class.java + ).apply { isAccessible = true }.invoke(operation, null, null, files, result, metadata, client, "token") +} diff --git a/app/src/test/java/com/owncloud/android/operations/FileTransferContentTest.kt b/app/src/test/java/com/owncloud/android/operations/FileTransferContentTest.kt new file mode 100644 index 000000000000..ab22e081229c --- /dev/null +++ b/app/src/test/java/com/owncloud/android/operations/FileTransferContentTest.kt @@ -0,0 +1,183 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import android.content.Context +import com.nextcloud.client.account.User +import com.nextcloud.common.NextcloudClient +import com.nextcloud.utils.extensions.toNextcloudClient +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedFile +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedFolderMetadataFile +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedMetadata +import com.owncloud.android.db.OCUpload +import com.owncloud.android.files.services.NameCollisionPolicy +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import com.owncloud.android.lib.resources.files.DownloadFileRemoteOperation +import com.owncloud.android.operations.factory.UploadFileOperationFactory +import com.owncloud.android.utils.EncryptionUtils +import org.junit.Assert.assertEquals +import org.junit.Assert.assertThrows +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.mockito.Mockito.mockConstruction +import org.mockito.Mockito.mockStatic +import org.mockito.kotlin.any +import org.mockito.kotlin.doAnswer +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.eq +import org.mockito.kotlin.isNull +import org.mockito.kotlin.mock +import org.mockito.kotlin.verifyNoInteractions +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import java.io.File +import javax.crypto.AEADBadTagException +import javax.crypto.Cipher +import javax.crypto.spec.GCMParameterSpec +import javax.crypto.spec.SecretKeySpec + +@Suppress("DEPRECATION", "NestedBlockDepth", "MagicNumber") +class FileTransferContentTest { + @get:Rule + val temporary = TemporaryFolder() + + private val key = ByteArray(16) { it.toByte() } + private val nonce = ByteArray(12) { it.toByte() } + private val content = "Content requiring authenticated decryption" + private val client: OwnCloudClient = mock() + private val nextcloud: NextcloudClient = mock() + private val storage: FileDataStorageManager = mock() + private val factory: UploadFileOperationFactory = mock() + private val user: User = mock { on { accountName } doReturn "test-account" } + private val context: Context = mock { on { cacheDir } doAnswer { temporary.root } } + private val source: OCFile = mock { + on { remotePath } doReturn "/secret/blob" + on { encryptedFileName } doReturn "blob" + on { parentId } doReturn 1L + on { isEncrypted } doReturn true + on { mimeType } doReturn "text/plain" + } + private val destination: OCFile = mock { on { remotePath } doReturn "/public/" } + + @Test + fun authenticatedPlaintextIsUploadedWithoutRetainingTemporaryContent() { + val uploaded = RemoteOperationResult(ResultCode.OK) + val operation: UploadFileOperation = mock() + doReturn(mock()).whenever(operation).file + doReturn(uploaded).whenever(operation).execute(client) + doAnswer { + val upload = it.getArgument(1) + assertEquals(content, File(upload.localPath).readText()) + assertEquals("/public/report.txt", upload.remotePath) + verify(upload).setNameCollisionPolicy(NameCollisionPolicy.ASK_USER) + operation + }.whenever(factory).create(eq(context), any(), isNull(), eq(true), eq(user), eq(storage)) + + withDownload(cipher(Cipher.ENCRYPT_MODE).doFinal(content.toByteArray())) { + assertTrue( + FileTransferContent(context, user, storage, factory).copy( + source, + destination, + "report.txt", + client + ).isSuccess + ) + } + + assertTrue(temporary.root.listFiles().orEmpty().isEmpty()) + verify(operation).setKeepE2EELockOnFailure(true) + } + + @Test + fun corruptedCiphertextIsNeverUploadedAndTemporaryPlaintextIsRemoved() { + val encrypted = cipher(Cipher.ENCRYPT_MODE).doFinal(content.toByteArray()) + encrypted[encrypted.lastIndex] = (encrypted.last().toInt() xor 1).toByte() + + withDownload(encrypted) { + assertThrows(AEADBadTagException::class.java) { + FileTransferContent(context, user, storage, factory).copy(source, destination, "report.txt", client) + } + } + + verifyNoInteractions(factory) + assertTrue(temporary.root.listFiles().orEmpty().isEmpty()) + } + + @Test + fun encryptedDestinationUsesItsStoragePathWithTheDecryptedFilename() { + doReturn("/target/opaque-folder/").whenever(destination).remotePath + doReturn("/资料/加密目录/").whenever(destination).decryptedRemotePath + doReturn(true).whenever(destination).isEncrypted + val operation: UploadFileOperation = mock() + doReturn(mock()).whenever(operation).file + doReturn(RemoteOperationResult(ResultCode.OK)).whenever(operation).execute(client) + doAnswer { + val upload = it.getArgument(1) + assertEquals("/target/opaque-folder/季度报告.txt", upload.remotePath) + assertEquals(content, File(upload.localPath).readText()) + operation + }.whenever(factory).create(eq(context), any(), isNull(), eq(true), eq(user), eq(storage)) + + withDownload(cipher(Cipher.ENCRYPT_MODE).doFinal(content.toByteArray())) { + assertTrue( + FileTransferContent(context, user, storage, factory).copy( + source, + destination, + "季度报告.txt", + client + ).isSuccess + ) + } + assertTrue(temporary.root.listFiles().orEmpty().isEmpty()) + } + + private fun withDownload(encrypted: ByteArray, test: () -> Unit) { + val parent: OCFile = mock() + doReturn(parent).whenever(storage).getFileById(1L) + val metadata = DecryptedFolderMetadataFile( + metadata = DecryptedMetadata( + files = mutableMapOf("blob" to DecryptedFile("report.txt", "text/plain", "nonce", "tag", "key")) + ), + version = "2.0" + ) + mockStatic(EncryptionUtils::class.java).use { crypto -> + crypto.`when` { EncryptionUtils.downloadFolderMetadata(parent, client, context, user) } + .thenReturn(metadata) + crypto.`when` { EncryptionUtils.decodeStringToBase64Bytes("key") }.thenReturn(key) + crypto.`when` { EncryptionUtils.decodeStringToBase64Bytes("nonce") }.thenReturn(nonce) + crypto.`when` { EncryptionUtils.getCipher(Cipher.DECRYPT_MODE, key, nonce) } + .thenAnswer { cipher(Cipher.DECRYPT_MODE) } + mockStatic(Class.forName("com.nextcloud.utils.extensions.OwnCloudClientExtensionsKt")).use { extensions -> + extensions.`when` { client.toNextcloudClient(context) }.thenReturn(nextcloud) + mockConstruction(OCUpload::class.java) { upload, construction -> + doReturn(construction.arguments()[0]).whenever(upload).localPath + doReturn(construction.arguments()[1]).whenever(upload).remotePath + }.use { + mockConstruction(DownloadFileRemoteOperation::class.java) { download, construction -> + doAnswer { + File(construction.arguments()[1].toString() + "/secret/blob").apply { + parentFile.mkdirs() + writeBytes(encrypted) + } + RemoteOperationResult(ResultCode.OK) + }.whenever(download).execute(nextcloud) + }.use { test() } + } + } + } + } + + private fun cipher(mode: Int): Cipher = Cipher.getInstance("AES/GCM/NoPadding").apply { + init(mode, SecretKeySpec(key, "AES"), GCMParameterSpec(128, nonce)) + } +} diff --git a/app/src/test/java/com/owncloud/android/operations/FileTransferSourceTest.kt b/app/src/test/java/com/owncloud/android/operations/FileTransferSourceTest.kt new file mode 100644 index 000000000000..bcf2cbe12cc6 --- /dev/null +++ b/app/src/test/java/com/owncloud/android/operations/FileTransferSourceTest.kt @@ -0,0 +1,109 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test +import org.mockito.Mockito.mockConstruction +import org.mockito.kotlin.any +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.eq +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever + +@Suppress("DEPRECATION") +class FileTransferSourceTest { + private val storage: FileDataStorageManager = mock() + private val client: OwnCloudClient = mock() + private val source: OCFile = mock { + on { remotePath } doReturn "/secret/" + on { encryptedFileName } doReturn "secret" + on { parentId } doReturn 1L + on { isEncrypted } doReturn true + on { isFolder } doReturn true + } + private val parent: OCFile = mock() + + @Test + fun encryptedRootIsLockedThroughItsOwnMetadata() { + doReturn(parent).whenever(storage).getFileById(1L) + doReturn(true).whenever(storage).removeFile(source, true, true) + mockConstruction(RemoveRemoteEncryptedFileOperation::class.java) { removal, construction -> + assertSame(source, construction.arguments()[4]) + assertEquals("original-etag", construction.arguments()[6]) + doReturn(RemoteOperationResult(ResultCode.OK)).whenever(removal).execute(client) + }.use { + assertTrue(FileTransferSource(mock(), mock(), storage).remove(source, "original-etag", client).isSuccess) + } + verify(storage).removeFile(source, true, true) + } + + @Test + fun encryptedSubfolderUsesItsEncryptedParentMetadata() { + doReturn(true).whenever(parent).isEncrypted + doReturn(parent).whenever(storage).getFileById(1L) + doReturn(true).whenever(storage).removeFile(source, true, true) + mockConstruction(RemoveRemoteEncryptedFileOperation::class.java) { removal, construction -> + assertSame(parent, construction.arguments()[4]) + doReturn(RemoteOperationResult(ResultCode.OK)).whenever(removal).execute(client) + }.use { + assertTrue(FileTransferSource(mock(), mock(), storage).remove(source, "original-etag", client).isSuccess) + } + } + + @Test + fun failedRemoteDeleteDoesNotRemoveLocalSource() { + doReturn(parent).whenever(storage).getFileById(1L) + mockConstruction(RemoveRemoteEncryptedFileOperation::class.java) { removal, _ -> + doReturn(RemoteOperationResult(ResultCode.UNKNOWN_ERROR)).whenever(removal).execute(client) + }.use { + assertFalse(FileTransferSource(mock(), mock(), storage).remove(source, "original-etag", client).isSuccess) + } + verify(storage, never()).removeFile(eq(source), any(), any()) + } + + @Test + fun editingADownloadedChildDuringTransferPreservesTheWholeSource() { + val child: OCFile = mock { + on { localModificationTimestamp } doReturn 2L + on { lastSyncDateForData } doReturn 1L + } + doReturn(listOf(child)).whenever(storage).getFolderContent(source, false) + + val result = FileTransferSource(mock(), mock(), storage).remove(source, "original-etag", client) + + assertEquals(ResultCode.SYNC_CONFLICT, result.code) + verify(storage, never()).removeFile(eq(source), any(), any()) + verify(storage, never()).getFileById(any()) + } + + @Test + fun unresolvedConflictPreventsSourceDeletion() { + doReturn(true).whenever(source).isInConflict + + val result = FileTransferSource(mock(), mock(), storage).remove(source, "original-etag", client) + + assertEquals(ResultCode.SYNC_CONFLICT, result.code) + verify(storage, never()).removeFile(eq(source), any(), any()) + } + + @Test + fun conditionalDeleteQuotesBothRawAndAlreadyQuotedEtags() { + assertEquals("\"version\"", FileTransferSource.quotedEtag("version")) + assertEquals("\"version\"", FileTransferSource.quotedEtag("\"version\"")) + } +} diff --git a/app/src/test/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperationTest.kt b/app/src/test/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperationTest.kt new file mode 100644 index 000000000000..e60fb8502150 --- /dev/null +++ b/app/src/test/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperationTest.kt @@ -0,0 +1,216 @@ +/* + * Nextcloud - Android Client + * + * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors + * SPDX-License-Identifier: AGPL-3.0-or-later + */ +package com.owncloud.android.operations + +import android.content.Context +import com.nextcloud.client.account.User +import com.owncloud.android.datamodel.ArbitraryDataProviderImpl +import com.owncloud.android.datamodel.FileDataStorageManager +import com.owncloud.android.datamodel.OCFile +import com.owncloud.android.datamodel.e2e.v1.decrypted.DecryptedFolderMetadataFileV1 +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedFolderMetadataFile +import com.owncloud.android.datamodel.e2e.v2.decrypted.DecryptedMetadata +import com.owncloud.android.lib.common.OwnCloudClient +import com.owncloud.android.lib.common.operations.RemoteOperationResult +import com.owncloud.android.lib.common.operations.RemoteOperationResult.ResultCode +import com.owncloud.android.lib.resources.status.E2EVersion +import com.owncloud.android.lib.resources.status.OCCapability +import com.owncloud.android.utils.EncryptionUtils +import com.owncloud.android.utils.EncryptionUtilsV2 +import org.apache.commons.httpclient.Header +import org.apache.jackrabbit.webdav.client.methods.DeleteMethod +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.mockito.MockedStatic +import org.mockito.Mockito.mockConstruction +import org.mockito.Mockito.mockStatic +import org.mockito.kotlin.any +import org.mockito.kotlin.doAnswer +import org.mockito.kotlin.eq +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.mock +import org.mockito.kotlin.never +import org.mockito.kotlin.verify +import org.mockito.kotlin.whenever +import java.io.IOException + +@Suppress("DEPRECATION", "NestedBlockDepth", "MagicNumber") +class RemoveRemoteEncryptedFileOperationTest { + private val context: Context = mock() + private val user: User = mock { on { accountName } doReturn "test" } + private val client: OwnCloudClient = mock() + private val parent: OCFile = mock { + on { remotePath } doReturn "/secret/" + on { e2eCounter } doReturn 2L + } + private val capability: OCCapability = mock { + on { endToEndEncryptionApiVersion } doReturn E2EVersion.V2_0 + } + private val metadata = DecryptedFolderMetadataFile( + DecryptedMetadata(counter = 48L, metadataKey = byteArrayOf()), + version = "2.0" + ) + private val metadataV1: DecryptedFolderMetadataFileV1 = mock() + private val ok = RemoteOperationResult(ResultCode.OK) + private val failed = RemoteOperationResult(ResultCode.UNKNOWN_ERROR) + private var deleteStatus = 204 + private var failMetadata = false + private var unlockResult = ok + private val events = mutableListOf() + + @Test + fun usesLatestVerifiedMetadataCounterAndRereadsInsideLock() = withOperations { storage, _, crypto -> + assertTrue(operation().execute(client).isSuccess) + assertEquals(listOf("metadata", "lock", "metadata"), events) + assertEquals(49L, metadata.metadata.counter) + crypto.verify { EncryptionUtils.lockFolder(parent, client, 49L) } + verify(storage.single()).updateE2EECounter(parent, 49L) + } + + @Test + fun rejectedConditionalDeleteDoesNotChangeMetadata() { + deleteStatus = 412 + withOperations { storage, utils, _ -> + assertFalse(operation().execute(client).isSuccess) + assertEquals(48L, metadata.metadata.counter) + verify(utils.last(), never()).removeFileFromMetadata(any(), any()) + verify(utils.last(), never()).serializeAndUploadMetadata( + any(), + any(), + any(), + any(), + any(), + any(), + any(), + any() + ) + verify(storage.single(), never()).updateE2EECounter(any(), any()) + } + } + + @Test + fun metadataFailureDoesNotCommitStagedDelete() { + failMetadata = true + withOperations { _, _, crypto -> + assertFalse(operation().execute(client).isSuccess) + crypto.verify({ EncryptionUtils.unlockFolder(parent, client, "token") }, never()) + } + } + + @Test + fun unlockFailureIsReportedWithoutUpdatingLocalCounter() { + unlockResult = failed + withOperations { storage, _, _ -> + assertFalse(operation().execute(client).isSuccess) + verify(storage.single(), never()).updateE2EECounter(any(), any()) + } + } + + @Test + fun deletingEncryptedRootDoesNotRemoveItFromItsOwnFolderMap() = withOperations { _, utils, _ -> + assertTrue(operation("/secret/", true).execute(client).isSuccess) + verify(utils.last(), never()).removeFolderFromMetadata(any(), any()) + } + + @Test + fun deletingV1SubfolderRemovesItsEntryFromParentMetadata() { + doReturn(E2EVersion.V1_2).whenever(capability).endToEndEncryptionApiVersion + withOperations { _, _, crypto -> + assertTrue(operation(folder = true).execute(client).isSuccess) + crypto.verify { EncryptionUtils.removeFileFromMetadata("blob", metadataV1) } + } + } + + @Test + fun rejectedV1DeletePreservesItsMetadataEntry() { + doReturn(E2EVersion.V1_2).whenever(capability).endToEndEncryptionApiVersion + deleteStatus = 412 + withOperations { _, _, crypto -> + assertFalse(operation(folder = true).execute(client).isSuccess) + crypto.verify({ EncryptionUtils.removeFileFromMetadata("blob", metadataV1) }, never()) + } + } + + private fun operation(path: String = "/secret/blob", folder: Boolean = false) = + RemoveRemoteEncryptedFileOperation(path, user, context, "blob", parent, folder, "original-version") + + private fun withOperations( + test: (List, List, MockedStatic) -> Unit + ) { + mockConstruction(FileDataStorageManager::class.java) { storage, _ -> + doReturn(capability).whenever(storage).getCapability(user) + }.use { storage -> + mockConstruction(EncryptionUtilsV2::class.java) { utils, _ -> + doAnswer { + events.add("metadata") + Pair(true, metadata) + }.whenever(utils).retrieveMetadata(parent, client, user, context) + doAnswer { + if (failMetadata) throw IOException("metadata write failed") + Unit + }.whenever(utils).serializeAndUploadMetadata( + any(), + any(), + any(), + any(), + any(), + any(), + any(), + any() + ) + }.use { utils -> + mockConstruction(DeleteMethod::class.java) { delete, _ -> + doReturn(deleteStatus in 200..299).whenever(delete).succeeded() + doReturn(deleteStatus).whenever(delete).statusCode + doReturn(emptyArray
()).whenever(delete).responseHeaders + }.use { deletes -> + doReturn(deleteStatus).whenever(client).executeMethod(any(), any(), any()) + mockConstruction(ArbitraryDataProviderImpl::class.java) { provider, _ -> + doReturn("private").whenever(provider).getValue("test", EncryptionUtils.PRIVATE_KEY) + doReturn("public").whenever(provider).getValue("test", EncryptionUtils.CERTIFICATE) + }.use { + mockStatic(EncryptionUtils::class.java).use { crypto -> + val v1Pair = mock>() + android.util.Pair::class.java.getField("first").set(v1Pair, true) + android.util.Pair::class.java.getField("second").set(v1Pair, metadataV1) + crypto.`when`> { + EncryptionUtils.retrieveMetadataV1( + eq(parent), + eq(client), + eq("private"), + eq("public"), + any(), + eq(user), + eq("1.2") + ) + }.thenReturn(v1Pair) + crypto.`when` { + EncryptionUtils.lockFolder(eq(parent), eq(client), any()) + }.thenAnswer { + events.add("lock") + "token" + } + crypto.`when`> { + EncryptionUtils.unlockFolder(parent, client, "token") + }.thenReturn(unlockResult) + crypto.`when`> { + EncryptionUtils.unlockFolderV1(parent, client, "token") + }.thenReturn(unlockResult) + test(storage.constructed(), utils.constructed(), crypto) + } + } + deletes.constructed().forEach { delete -> + verify(delete).setRequestHeader("If-Match", "\"original-version\"") + verify(delete).releaseConnection() + } + } + } + } + } +}