From 5f0f4a3caaa7c75c22548a78de1f513a2fa06f5c Mon Sep 17 00:00:00 2001 From: Li Wei Date: Mon, 16 Nov 2026 18:30:31 +0800 Subject: [PATCH 1/2] feat(e2ee): support copying and moving encrypted items Enable encrypted file and folder transfers with confirmation when crossing encryption states. Reuse folder creation and upload operations, preserve display names, and delete move sources only after a complete copy with a matching source version. Assisted-by: Codex:GPT-6 Signed-off-by: Li Wei --- .../android/files/FileMenuFilter.java | 2 +- .../android/operations/CopyFileOperation.java | 10 + .../operations/EncryptedFileTransfer.kt | 129 ++++++++++ .../android/operations/FileTransferContent.kt | 106 ++++++++ .../android/operations/FileTransferSource.kt | 122 +++++++++ .../android/operations/MoveFileOperation.java | 10 + .../RemoveRemoteEncryptedFileOperation.kt | 107 ++++---- .../operations/UploadFileOperation.java | 11 + .../android/services/OperationsService.java | 10 + .../ui/activity/FolderPickerActivity.kt | 11 +- .../ui/helpers/FileOperationsHelper.kt | 52 +++- app/src/main/res/values/strings.xml | 6 + .../operations/EncryptedFileTransferTest.kt | 240 ++++++++++++++++++ .../operations/EncryptedTransferUploadTest.kt | 142 +++++++++++ .../operations/FileTransferContentTest.kt | 183 +++++++++++++ .../operations/FileTransferSourceTest.kt | 109 ++++++++ .../RemoveRemoteEncryptedFileOperationTest.kt | 216 ++++++++++++++++ 17 files changed, 1413 insertions(+), 53 deletions(-) create mode 100644 app/src/main/java/com/owncloud/android/operations/EncryptedFileTransfer.kt create mode 100644 app/src/main/java/com/owncloud/android/operations/FileTransferContent.kt create mode 100644 app/src/main/java/com/owncloud/android/operations/FileTransferSource.kt create mode 100644 app/src/test/java/com/owncloud/android/operations/EncryptedFileTransferTest.kt create mode 100644 app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt create mode 100644 app/src/test/java/com/owncloud/android/operations/FileTransferContentTest.kt create mode 100644 app/src/test/java/com/owncloud/android/operations/FileTransferSourceTest.kt create mode 100644 app/src/test/java/com/owncloud/android/operations/RemoveRemoteEncryptedFileOperationTest.kt diff --git a/app/src/main/java/com/owncloud/android/files/FileMenuFilter.java b/app/src/main/java/com/owncloud/android/files/FileMenuFilter.java index 0d7fa33d94a6..a721daba017a 100644 --- a/app/src/main/java/com/owncloud/android/files/FileMenuFilter.java +++ b/app/src/main/java/com/owncloud/android/files/FileMenuFilter.java @@ -419,7 +419,7 @@ private void filterRemove(List toHide, boolean synchronizing) { } private void filterMoveOrCopy(List toHide, boolean synchronizing) { - if (files.isEmpty() || synchronizing || containsEncryptedFile() || containsEncryptedFolder() || containsLockedFile()) { + if (files.isEmpty() || synchronizing || containsLockedFile()) { toHide.add(R.id.action_move_or_copy); } } 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..b7e560053cd0 --- /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.PUBLIC_KEY) + 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 e97363f50850..f8249d4abb8e 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 8ed1907a113f..57914dea9fda 100644 --- a/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java +++ b/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java @@ -154,6 +154,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; @@ -409,6 +410,10 @@ public Context getContext() { return mContext; } + public void setKeepE2EELockOnFailure(boolean keepLock) { + keepE2EELockOnFailure = keepLock; + } + public boolean isMissingPermissionThrown() { return missingPermissionThrown.get(); } @@ -952,6 +957,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 { 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 915c20c180cc..ea924bec9858 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 f3d6f60bf3e1..ba36e1c8ef22 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..c2c8c8826ae5 --- /dev/null +++ b/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt @@ -0,0 +1,142 @@ +/* + * 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.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.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 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 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 operation(file: OCFile = mock()): UploadFileOperation { + val upload: OCUpload = mock { on { localPath } doReturn "/cache/content" } + return UploadFileOperation( + mock(), 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..6f7c913de9ab --- /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.PUBLIC_KEY) + }.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() + } + } + } + } + } +} From 455ff29229d9448201d66afb258b06a031d88785 Mon Sep 17 00:00:00 2001 From: Li Wei Date: Mon, 16 Nov 2026 18:44:14 +0800 Subject: [PATCH 2/2] fix(e2ee): skip queue updates for transient transfer uploads Only persist upload results and encryption lock tokens when the reused upload operation has a stored upload ID. Copy and move transfers execute synchronously without a queue entry. Assisted-by: Codex:GPT-6 Signed-off-by: Li Wei --- .../operations/UploadFileOperation.java | 14 ++++- .../operations/EncryptedTransferUploadTest.kt | 55 ++++++++++++++++++- 2 files changed, 63 insertions(+), 6 deletions(-) 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 57914dea9fda..38bd9a58e5a9 100644 --- a/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java +++ b/app/src/main/java/com/owncloud/android/operations/UploadFileOperation.java @@ -414,6 +414,12 @@ 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(); } @@ -626,7 +632,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); @@ -647,7 +653,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; @@ -1207,7 +1215,7 @@ private RemoteOperationResult normalUpload(OwnCloudClient client) { } logResult(result, mOriginalStoragePath, mRemotePath); - uploadsStorageManager.updateDatabaseUploadResult(result, this); + updateStoredUploadResult(result); } if (result.isSuccess()) { diff --git a/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt b/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt index c2c8c8826ae5..950e3b9de016 100644 --- a/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt +++ b/app/src/test/java/com/owncloud/android/operations/EncryptedTransferUploadTest.kt @@ -8,6 +8,7 @@ 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 @@ -26,6 +27,7 @@ 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 @@ -36,6 +38,7 @@ 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() @@ -43,6 +46,42 @@ class EncryptedTransferUploadTest { 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) } @@ -120,10 +159,20 @@ class EncryptedTransferUploadTest { verify(utils).addFileToMetadata("new-ciphertext-id", file, data.iv, "tag", data.key, metadata) } - private fun operation(file: OCFile = mock()): UploadFileOperation { - val upload: OCUpload = mock { on { localPath } doReturn "/cache/content" } + 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( - mock(), mock(), mock(), mock(), file, upload, NameCollisionPolicy.ASK_USER, + uploads, mock(), mock(), mock(), file, upload, NameCollisionPolicy.ASK_USER, 0, mock(), false, false, true, storage ) }