E2EE review

Signed-off-by: Marino Faggiana <marino@marinofaggiana.com>

iOSClient/Networking/E2EE/NCNetworkingE2EE.swift

@@ -31,213 +31,6 @@ import Alamofire
         return instance
     }()
 
-    // MARK: - WebDav Rename
-
-    func renameMetadata(_ metadata: tableMetadata, fileNameNew: String, completion: @escaping (_ error: NKError) -> Void) {
-
-        // verify if exists the new fileName
-        if NCManageDatabase.shared.getE2eEncryption(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@ AND fileName == %@", metadata.account, metadata.serverUrl, fileNameNew)) != nil {
-
-            return completion(NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_file_already_exists_"))
-
-        } else {
-
-            self.sendE2EMetadata(account: metadata.account, serverUrl: metadata.serverUrl, fileNameRename: metadata.fileName, fileNameNewRename: fileNameNew, deleteE2eEncryption: nil, urlBase: metadata.urlBase, userId: metadata.userId) { e2eToken, error in
-
-                if error == .success {
-                    NCManageDatabase.shared.setMetadataFileNameView(serverUrl: metadata.serverUrl, fileName: metadata.fileName, newFileNameView: fileNameNew, account: metadata.account)
-
-                    // Move file system
-                    let atPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId) + "/" + metadata.fileNameView
-                    let toPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId) + "/" + fileNameNew
-                    do {
-                        try FileManager.default.moveItem(atPath: atPath, toPath: toPath)
-                    } catch { }
-
-                    NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterRenameFile, userInfo: ["ocId": metadata.ocId, "account": metadata.account])
-                }
-
-                // unlock
-                if let tableLock = NCManageDatabase.shared.getE2ETokenLock(account: metadata.account, serverUrl: metadata.serverUrl) {
-                    NextcloudKit.shared.lockE2EEFolder(fileId: tableLock.fileId, e2eToken: tableLock.e2eToken, method: "DELETE") { _, _, _, _ in }
-                }
-
-                completion(error)
-            }
-        }
-    }
-
-    // MARK: - Upload
-
-    func upload(metadata: tableMetadata, start: @escaping () -> Void, completion: @escaping (_ error: NKError) -> Void) {
-
-        let objectE2eEncryption = tableE2eEncryption()
-        var key: NSString?, initializationVector: NSString?, authenticationTag: NSString?
-        let ocIdTemp = metadata.ocId
-        let serverUrl = metadata.serverUrl
-
-        // Verify max size
-        if metadata.size > NCGlobal.shared.e2eeMaxFileSize {
-            NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", ocIdTemp))
-            NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadedFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "ocIdTemp": ocIdTemp, "error": NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "E2E Error file too big")])
-            start()
-            return completion(NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "E2E Error file too big"))
-        }
-
-        // Update metadata
-        var metadata = tableMetadata.init(value: metadata)
-        metadata.fileName = CCUtility.generateRandomIdentifier()!
-        metadata.e2eEncrypted = true
-        metadata.session = NKCommon.shared.sessionIdentifierUpload
-        metadata.sessionError = ""
-        NCManageDatabase.shared.addMetadata(metadata)
-
-        let fileNameLocalPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: metadata.fileName)!
-        let fileNameLocalPathRequest = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: metadata.fileNameView)!
-        let serverUrlFileName = serverUrl + "/" + metadata.fileName
-
-        if NCEndToEndEncryption.sharedManager()?.encryptFileName(metadata.fileNameView, fileNameIdentifier: metadata.fileName, directory: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId), key: &key, initializationVector: &initializationVector, authenticationTag: &authenticationTag) == false {
-            NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", ocIdTemp))
-            NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadedFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "ocIdTemp": ocIdTemp, "error": NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_e2e_error_create_encrypted_")])
-            start()
-            return completion(NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_e2e_error_create_encrypted_"))
-        }
-
-        if let result = NCManageDatabase.shared.getE2eEncryption(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", metadata.account, serverUrl)) {
-            objectE2eEncryption.metadataKey = result.metadataKey
-            objectE2eEncryption.metadataKeyIndex = result.metadataKeyIndex
-        } else {
-            let key = NCEndToEndEncryption.sharedManager()?.generateKey(16) as NSData?
-            objectE2eEncryption.metadataKey = key!.base64EncodedString()
-            objectE2eEncryption.metadataKeyIndex = 0
-        }
-
-        objectE2eEncryption.account = metadata.account
-        objectE2eEncryption.authenticationTag = authenticationTag as String?
-        objectE2eEncryption.fileName = metadata.fileNameView
-        objectE2eEncryption.fileNameIdentifier = metadata.fileName
-        objectE2eEncryption.fileNamePath = fileNameLocalPath
-        objectE2eEncryption.key = key! as String
-        objectE2eEncryption.initializationVector = initializationVector! as String
-        objectE2eEncryption.mimeType = metadata.contentType
-        objectE2eEncryption.serverUrl = serverUrl
-        objectE2eEncryption.version = 1
-
-        NCManageDatabase.shared.addE2eEncryption(objectE2eEncryption)
-
-        if let getMetadata = NCManageDatabase.shared.getMetadataFromOcId(ocIdTemp) {
-            metadata = getMetadata
-        } else {
-            start()
-            return completion(NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_e2e_error_create_encrypted_"))
-        }
-
-        NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterReloadDataSource, userInfo: ["serverUrl": metadata.serverUrl])
-        NCContentPresenter.shared.noteTop(text: NSLocalizedString("_upload_e2ee_", comment: ""), image: nil, type: NCContentPresenter.messageType.info, delay: NCGlobal.shared.dismissAfterSecond, priority: .max)
-        NCNetworkingE2EE.shared.sendE2EMetadata(account: metadata.account, serverUrl: serverUrl, fileNameRename: nil, fileNameNewRename: nil, deleteE2eEncryption: nil, urlBase: metadata.urlBase, userId: metadata.userId, upload: true) { e2eToken, error in
-
-            start()
-
-            if error == .success && e2eToken != nil {
-
-                NextcloudKit.shared.upload(serverUrlFileName: serverUrlFileName, fileNameLocalPath: fileNameLocalPath, dateCreationFile: metadata.date as Date, dateModificationFile: metadata.date as Date, addCustomHeaders: ["e2e-token": e2eToken!], requestHandler: { request in
-
-                    NCNetworking.shared.uploadRequest[fileNameLocalPathRequest] = request
-                    NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, session: nil, sessionError: nil, sessionSelector: nil, sessionTaskIdentifier: nil, status: NCGlobal.shared.metadataStatusUploading)
-                    NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadStartFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "sessionSelector": metadata.sessionSelector])
-
-                }, taskHandler: { _ in
-
-                }, progressHandler: { progress in
-
-                    NotificationCenter.default.postOnMainThread(
-                        name: NCGlobal.shared.notificationCenterProgressTask,
-                        userInfo: [
-                            "account": metadata.account,
-                            "ocId": metadata.ocId,
-                            "fileName": metadata.fileName,
-                            "serverUrl": serverUrl,
-                            "status": NSNumber(value: NCGlobal.shared.metadataStatusInUpload),
-                            "progress": NSNumber(value: progress.fractionCompleted),
-                            "totalBytes": NSNumber(value: progress.totalUnitCount),
-                            "totalBytesExpected": NSNumber(value: progress.completedUnitCount)])
-
-                }) { account, ocId, etag, date, _, _, afError, error in
-
-                    NCNetworkingE2EE.shared.unlock(account: metadata.account, serverUrl: serverUrl) { _, _, errorLock in
-
-                        NCNetworking.shared.uploadRequest.removeValue(forKey: fileNameLocalPath)
-                        if let metadata = NCManageDatabase.shared.getMetadataFromOcId(metadata.ocId) {
-                            if afError?.isExplicitlyCancelledError ?? false {
-
-                                CCUtility.removeFile(atPath: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId))
-                                NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", metadata.ocId))
-                                NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadedFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "ocIdTemp": ocIdTemp, "error": error])
-
-                            } else if error == .success && ocId != nil {
-
-                                NCUtilityFileSystem.shared.moveFileInBackground(atPath: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId), toPath: CCUtility.getDirectoryProviderStorageOcId(ocId))
-
-                                metadata.date = date ?? NSDate()
-                                metadata.etag = etag ?? ""
-                                metadata.ocId = ocId!
-
-                                metadata.session = ""
-                                metadata.sessionError = ""
-                                metadata.sessionTaskIdentifier = 0
-                                metadata.status = NCGlobal.shared.metadataStatusNormal
-
-                                NCManageDatabase.shared.addMetadata(metadata)
-                                NCManageDatabase.shared.deleteMetadata(predicate: NSPredicate(format: "ocId == %@", ocIdTemp))
-                                NCManageDatabase.shared.addLocalFile(metadata: metadata)
-
-                                NCUtility.shared.createImageFrom(fileNameView: metadata.fileNameView, ocId: metadata.ocId, etag: metadata.etag, classFile: metadata.classFile)
-                                NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadedFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "ocIdTemp": ocIdTemp, "error": error])
-
-                            } else {
-
-                                NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, session: nil, sessionError: error.errorDescription, sessionTaskIdentifier: 0, status: NCGlobal.shared.metadataStatusUploadError)
-
-                                NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadedFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "ocIdTemp": ocIdTemp, "error": error])
-                            }
-                        }
-                        completion(error)
-                    }
-                }
-
-            } else {
-
-                if let metadata = NCManageDatabase.shared.getMetadataFromOcId(ocIdTemp) {
-                    NCManageDatabase.shared.setMetadataSession(ocId: metadata.ocId, session: nil, sessionError: error.errorDescription, sessionTaskIdentifier: 0, status: NCGlobal.shared.metadataStatusUploadError)
-                    NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterUploadedFile, userInfo: ["ocId": metadata.ocId, "serverUrl": metadata.serverUrl, "account": metadata.account, "fileName": metadata.fileName, "ocIdTemp": ocIdTemp, "error": error])
-                }
-                completion(error)
-            }
-        }
-    }
-
-    // MARK: - E2EE
-
-    @objc func lock(account: String, serverUrl: String, completion: @escaping (_ direcrtory: tableDirectory?, _ e2eToken: String?, _ error: NKError) -> Void) {
-
-        var e2eToken: String?
-
-        guard let directory = NCManageDatabase.shared.getTableDirectory(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl)) else {
-            return completion(nil, nil, NKError())
-        }
-
-        if let tableLock = NCManageDatabase.shared.getE2ETokenLock(account: account, serverUrl: serverUrl) {
-            e2eToken = tableLock.e2eToken
-        }
-
-        NextcloudKit.shared.lockE2EEFolder(fileId: directory.fileId, e2eToken: e2eToken, method: "POST") { account, e2eToken, data, error in
-            if error == .success && e2eToken != nil {
-                NCManageDatabase.shared.setE2ETokenLock(account: account, serverUrl: serverUrl, fileId: directory.fileId, e2eToken: e2eToken!)
-            }
-            completion(directory, e2eToken, error)
-        }
-    }
-
     func lock(account: String, serverUrl: String) async -> (directory: tableDirectory?, e2eToken: String?, error: NKError) {
 
         var e2eToken: String?
@@ -258,26 +51,6 @@ import Alamofire
         return (directory, lockE2EEFolderResults.e2eToken, lockE2EEFolderResults.error)
     }
 
-    @objc func unlock(account: String, serverUrl: String, completion: @escaping (_ direcrtory: tableDirectory?, _ e2eToken: String?, _ error: NKError) -> Void) {
-
-        var e2eToken: String?
-
-        guard let directory = NCManageDatabase.shared.getTableDirectory(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl)) else {
-            return completion(nil, nil, NKError())
-        }
-
-        if let tableLock = NCManageDatabase.shared.getE2ETokenLock(account: account, serverUrl: serverUrl) {
-            e2eToken = tableLock.e2eToken
-        }
-
-        NextcloudKit.shared.lockE2EEFolder(fileId: directory.fileId, e2eToken: e2eToken, method: "DELETE") { account, e2eToken, data, error in
-            if error == .success {
-                NCManageDatabase.shared.deteleE2ETokenLock(account: account, serverUrl: serverUrl)
-            }
-            completion(directory, e2eToken, error)
-        }
-    }
-
     @discardableResult
     func unlock(account: String, serverUrl: String) async -> (directory: tableDirectory?, e2eToken: String?, error: NKError) {
 
@@ -299,57 +72,6 @@ import Alamofire
         return (directory, lockE2EEFolderResults.e2eToken, lockE2EEFolderResults.error)
     }
 
-    @objc func sendE2EMetadata(account: String, serverUrl: String, fileNameRename: String?, fileNameNewRename: String?, deleteE2eEncryption: NSPredicate?, urlBase: String, userId: String, upload: Bool = false, completion: @escaping (_ e2eToken: String?, _ error: NKError) -> Void) {
-
-        self.lock(account: account, serverUrl: serverUrl) { directory, e2eToken, error in
-            if error == .success && e2eToken != nil && directory != nil {
-
-                NextcloudKit.shared.getE2EEMetadata(fileId: directory!.fileId, e2eToken: e2eToken) { account, e2eMetadata, data, error in
-                    var method = "POST"
-                    var e2eMetadataNew: String?
-
-                    if error == .success && e2eMetadata != nil {
-                        if !NCEndToEndMetadata.shared.decoderMetadata(e2eMetadata!, privateKey: CCUtility.getEndToEndPrivateKey(account), serverUrl: serverUrl, account: account, urlBase: urlBase, userId: userId) {
-                            return completion(e2eToken, NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: NSLocalizedString("_e2e_error_encode_metadata_", comment: "")))
-                        }
-                        method = "PUT"
-                    }
-
-                    // Rename
-                    if fileNameRename != nil && fileNameNewRename != nil {
-                        NCManageDatabase.shared.renameFileE2eEncryption(serverUrl: serverUrl, fileNameIdentifier: fileNameRename!, newFileName: fileNameNewRename!, newFileNamePath: CCUtility.returnFileNamePath(fromFileName: fileNameNewRename!, serverUrl: serverUrl, urlBase: urlBase, userId: userId, account: account))
-                    }
-
-                    // Delete
-                    if deleteE2eEncryption != nil {
-                        NCManageDatabase.shared.deleteE2eEncryption(predicate: deleteE2eEncryption!)
-                    }
-
-                    // Rebuild metadata for send it
-                    let tableE2eEncryption = NCManageDatabase.shared.getE2eEncryptions(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl))
-                    if tableE2eEncryption != nil {
-                        e2eMetadataNew = NCEndToEndMetadata.shared.encoderMetadata(tableE2eEncryption!, privateKey: CCUtility.getEndToEndPrivateKey(account), serverUrl: serverUrl)
-                    } else {
-                        method = "DELETE"
-                    }
-
-                    NextcloudKit.shared.putE2EEMetadata(fileId: directory!.fileId, e2eToken: e2eToken!, e2eMetadata: e2eMetadataNew, method: method) { account, _, _, error in
-
-                        if upload {
-                            completion(e2eToken, error)
-                        } else {
-                            self.unlock(account: account, serverUrl: serverUrl) { _, e2eToken, _ in
-                                completion(e2eToken, error)
-                            }
-                        }
-                    }
-                }
-            } else {
-                completion(e2eToken, error)
-            }
-        }
-    }
-
     func sendE2EMetadata(account: String, serverUrl: String, fileNameRename: String?, fileNameNewRename: String?, deleteE2eEncryption: NSPredicate?, urlBase: String, userId: String, upload: Bool = false) async -> (e2eToken: String?, error: NKError) {
 
         // Lock

iOSClient/Networking/E2EE/NCNetworkingE2EERename.swift

@@ -32,7 +32,7 @@ import Foundation
         return instance
     }()
 
-    func renameMetadata(_ metadata: tableMetadata, fileNameNew: String) async -> (NKError) {
+    func rename(metadata: tableMetadata, fileNameNew: String) async -> (NKError) {
 
         // verify if exists the new fileName
         if NCManageDatabase.shared.getE2eEncryption(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@ AND fileName == %@", metadata.account, metadata.serverUrl, fileNameNew)) != nil {

iOSClient/Networking/E2EE/NCNetworkingE2EEUpload.swift

@@ -46,7 +46,7 @@ import Foundation
         }
 
         // Create metadata for upload
-        metadata.fileName = filename //CCUtility.generateRandomIdentifier()!
+        metadata.fileName = filename
         metadata.e2eEncrypted = true
         metadata.session = NKCommon.shared.sessionIdentifierUpload
         metadata.sessionError = ""

iOSClient/Networking/NCNetworking.swift

@@ -391,7 +391,10 @@ import Photos
 
         if metadata.e2eEncrypted {
             #if !EXTENSION_FILE_PROVIDER_EXTENSION && !EXTENSION_WIDGET
-            NCNetworkingE2EE.shared.upload(metadata: metadata, start: start) { error in
+            Task {
+                let fineName = CCUtility.generateRandomIdentifier()!
+                start()
+                let error = await NCNetworkingE2EEUpload.shared.upload(metadata: metadata, filename: fineName)
                 completion(error)
             }
             #endif
@@ -1253,15 +1256,18 @@ import Photos
 
         if isDirectoryEncrypted {
             #if !EXTENSION
-            if metadataLive == nil {
-                NCNetworkingE2EE.shared.renameMetadata(metadata, fileNameNew: fileNameNew, completion: completion)
-            } else {
-                NCNetworkingE2EE.shared.renameMetadata(metadataLive!, fileNameNew: fileNameNewLive) { error in
+            Task {
+                if let metadataLive = metadataLive {
+                    let error = await NCNetworkingE2EERename.shared.rename(metadata: metadataLive, fileNameNew: fileNameNew)
                     if error == .success {
-                        NCNetworkingE2EE.shared.renameMetadata(metadata, fileNameNew: fileNameNew, completion: completion)
+                        let error = await NCNetworkingE2EERename.shared.rename(metadata: metadata, fileNameNew: fileNameNew)
+                        completion(error)
                     } else {
                         completion(error)
                     }
+                } else {
+                    let error = await NCNetworkingE2EERename.shared.rename(metadata: metadata, fileNameNew: fileNameNew)
+                    completion(error)
                 }
             }
             #endif