coding

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

iOSClient/Main/Collection Common/NCCollectionViewCommon.swift

@@ -1124,7 +1124,7 @@ class NCCollectionViewCommon: UIViewController, UIGestureRecognizerDelegate, UIS
                     if let metadataFolder = metadataFolder, metadataFolder.e2eEncrypted, CCUtility.isEnd(toEndEnabled: self.appDelegate.account) {
                         NextcloudKit.shared.getE2EEMetadata(fileId: metadataFolder.ocId, e2eToken: nil) { account, e2eMetadata, data, error in
                             if error == .success, let e2eMetadata = e2eMetadata {
-                                if NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: self.serverUrl, account: self.appDelegate.account, urlBase: self.appDelegate.urlBase, userId: self.appDelegate.userId) {
+                                if NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: self.serverUrl, account: self.appDelegate.account, urlBase: self.appDelegate.urlBase, userId: self.appDelegate.userId, ownerId: metadataFolder.ownerId) {
                                     self.reloadDataSource()
                                 } else {
                                     let error = NKError(errorCode: NCGlobal.shared.errorDecodeMetadata, errorDescription: "_e2e_error_decode_metadata_")

iOSClient/NCGlobal.swift

@@ -127,7 +127,7 @@ class NCGlobal: NSObject {
     //
     let e2eeMaxFileSize: UInt64                     = 500000000     // 500 MB
     let e2eePassphraseTest                          = "more over television factory tendency independence international intellectual impress interest sentence pony"
-    @objc let e2eeVersion                           = "1.1"
+    @objc let e2eeVersion                           = "2"
     
     // Video
     //

iOSClient/Networking/E2EE/NCEndToEndEncryption.h

@@ -38,14 +38,15 @@
 - (NSString *)decryptPrivateKey:(NSString *)privateKeyCipher passphrase:(NSString *)passphrase publicKey:(NSString *)publicKey;
 
 - (NSData *)encryptAsymmetricString:(NSString *)plain publicKey:(NSString *)publicKey privateKey:(NSString *)privateKey;
-- (NSString *)decryptAsymmetricData:(NSData *)cipherData privateKey:(NSString *)privateKey;
+- (NSData *)decryptAsymmetricData:(NSData *)cipherData privateKey:(NSString *)privateKey;
 
 - (NSString *)encryptEncryptedJson:(NSString *)encrypted key:(NSString *)key;
 - (NSString *)decryptEncryptedJson:(NSString *)encrypted key:(NSString *)key;
+- (NSData *)decryptEncryptedJsonV12:(NSString *)encrypted key:(NSString *)key;
 
 - (void)encryptkey:(NSString **)key initializationVector:(NSString **)initializationVector;
-- (BOOL)encryptFileName:(NSString *)fileName fileNameIdentifier:(NSString *)fileNameIdentifier directory:(NSString *)directory key:(NSString **)key initializationVector:(NSString **)initializationVector authenticationTag:(NSString **)authenticationTag;
-- (BOOL)decryptFileName:(NSString *)fileName fileNameView:(NSString *)fileNameView ocId:(NSString *)ocId key:(NSString *)key initializationVector:(NSString *)initializationVector authenticationTag:(NSString *)authenticationTag;
+- (BOOL)encryptFile:(NSString *)fileName fileNameIdentifier:(NSString *)fileNameIdentifier directory:(NSString *)directory key:(NSString **)key initializationVector:(NSString **)initializationVector authenticationTag:(NSString **)authenticationTag;
+- (BOOL)decryptFile:(NSString *)fileName fileNameView:(NSString *)fileNameView ocId:(NSString *)ocId key:(NSString *)key initializationVector:(NSString *)initializationVector authenticationTag:(NSString *)authenticationTag;
 
 - (NSData *)generateKey:(int)length;
 - (NSString *)createSHA512:(NSString *)string;

iOSClient/Networking/E2EE/NCEndToEndEncryption.m

@@ -395,7 +395,10 @@
     NSData *tagData = [[NSData alloc] initWithBase64EncodedString:tagBase64 options:0];
     NSData *ivData = [[NSData alloc] initWithBase64EncodedString:privateKeyCipherArray[1] options:0];
     NSData *saltData = [[NSData alloc] initWithBase64EncodedString:privateKeyCipherArray[2] options:0];
-    
+
+    // Remove TAG
+    privateKeyCipherData = [privateKeyCipherData subdataWithRange:NSMakeRange(0, privateKeyCipherData.length - AES_GCM_TAG_LENGTH)];
+
     // Remove all whitespaces from passphrase
     passphrase = [passphrase stringByReplacingOccurrencesOfString:@" " withString:@""];
     
@@ -404,28 +407,18 @@
     BOOL result = [self decryptData:privateKeyCipherData plainData:&privateKeyData keyData:keyData keyLen:AES_KEY_256_LENGTH ivData:ivData tagData:tagData];
     
     if (result && privateKeyData)
-        
-        /* DENCODE 64 privateKey JAVA compatibility */
         privateKey = [self base64DecodeData:privateKeyData];
-        /* ---------------------------------------- */
-    
         if (privateKey) {
-        
             NSData *encryptData = [self encryptAsymmetricString:ASYMMETRIC_STRING_TEST publicKey:publicKey privateKey:nil];
             if (!encryptData)
                 return nil;
-        
-            NSString *decryptString = [self decryptAsymmetricData:encryptData privateKey:privateKey];
-        
+            NSData *decryptData = [self decryptAsymmetricData:encryptData privateKey:privateKey];
+            NSString *decryptString = [[NSString alloc] initWithData:decryptData encoding:NSUTF8StringEncoding];
             if (decryptString && [decryptString isEqualToString:ASYMMETRIC_STRING_TEST])
                 return privateKey;
             else
                 return nil;
-            
-            return privateKey;
-            
     } else {
-        
         return nil;
     }
 }
@@ -439,19 +432,17 @@
     NSMutableData *cipherData;
     NSData *tagData = [NSData new];
     
-    // ENCODE 64 encrypted JAVA compatibility */
-    NSData *encryptedData = [encrypted dataUsingEncoding:NSUTF8StringEncoding];
-    NSString *encryptedDataBase64 = [encryptedData base64EncodedStringWithOptions:0];
-    NSData *encryptedData64Data = [encryptedDataBase64 dataUsingEncoding:NSUTF8StringEncoding];
-    /* --------------------------------------- */
-    
+    NSData *data = [encrypted dataUsingEncoding:NSUTF8StringEncoding];
+    NSString *data64 = [data base64EncodedStringWithOptions:0];
+    data = [data64 dataUsingEncoding:NSUTF8StringEncoding];
+
     // Key
     NSData *keyData = [[NSData alloc] initWithBase64EncodedString:key options:0];
 
     // IV
     NSData *ivData = [self generateIV:AES_IVEC_LENGTH];
     
-    BOOL result = [self encryptData:encryptedData64Data cipherData:&cipherData keyData:keyData keyLen:AES_KEY_128_LENGTH ivData:ivData tagData:&tagData];
+    BOOL result = [self encryptData:data cipherData:&cipherData keyData:keyData keyLen:AES_KEY_128_LENGTH ivData:ivData tagData:&tagData];
     
     if (cipherData != nil && result) {
         
@@ -475,14 +466,14 @@
             return nil;
         }
     }
-    
+
     // Cipher
     NSString *cipher = [encrypted substringToIndex:(range.location)];
     NSData *cipherData = [[NSData alloc] initWithBase64EncodedString:cipher options:0];
-    
+
     // Key
     NSData *keyData = [[NSData alloc] initWithBase64EncodedString:key options:0];
-    
+
     // IV
     NSString *iv  = [encrypted substringWithRange:NSMakeRange(range.location + range.length, encrypted.length - (range.location + range.length))];
     NSData *ivData = [[NSData alloc] initWithBase64EncodedString:iv options:0];
@@ -490,18 +481,53 @@
     // TAG
     NSString *tag = [cipher substringWithRange:NSMakeRange(cipher.length - AES_GCM_TAG_LENGTH, AES_GCM_TAG_LENGTH)];
     NSData *tagData = [[NSData alloc] initWithBase64EncodedString:tag options:0];
-    
+
     BOOL result = [self decryptData:cipherData plainData:&plainData keyData:keyData keyLen:AES_KEY_128_LENGTH ivData:ivData tagData:tagData];
-    
+
     if (plainData != nil && result) {
-        
+
         /* DENCODE 64 JAVA compatibility            */
         NSString *plain = [self base64DecodeData:plainData];
         /* ---------------------------------------- */
-    
+
         return plain;
     }
-        
+
+    return nil;
+}
+
+- (NSData *)decryptEncryptedJsonV12:(NSString *)encrypted key:(NSString *)key
+{
+    NSMutableData *plainData;
+    NSRange range = [encrypted rangeOfString:IV_DELIMITER_ENCODED];
+    if (range.location == NSNotFound) {
+        range = [encrypted rangeOfString:IV_DELIMITER_ENCODED_OLD];
+        if (range.location == NSNotFound) {
+            return nil;
+        }
+    }
+
+    // Cipher
+    NSString *cipher = [encrypted substringToIndex:(range.location)];
+    NSData *cipherData = [[NSData alloc] initWithBase64EncodedString:cipher options:0];
+
+    // Key
+    NSData *keyData = [[NSData alloc] initWithBase64EncodedString:key options:0];
+
+    // IV
+    NSString *iv  = [encrypted substringWithRange:NSMakeRange(range.location + range.length, encrypted.length - (range.location + range.length))];
+    NSData *ivData = [[NSData alloc] initWithBase64EncodedString:iv options:0];
+
+    // TAG
+    NSString *tag = [cipher substringWithRange:NSMakeRange(cipher.length - AES_GCM_TAG_LENGTH, AES_GCM_TAG_LENGTH)];
+    NSData *tagData = [[NSData alloc] initWithBase64EncodedString:tag options:0];
+
+    BOOL result = [self decryptData:cipherData plainData:&plainData keyData:keyData keyLen:AES_KEY_128_LENGTH ivData:ivData tagData:tagData];
+
+    if (plainData != nil && result) {
+        return plainData;
+    }
+
     return nil;
 }
 
@@ -519,7 +545,7 @@
 }
 
 
-- (BOOL)encryptFileName:(NSString *)fileName fileNameIdentifier:(NSString *)fileNameIdentifier directory:(NSString *)directory key:(NSString **)key initializationVector:(NSString **)initializationVector authenticationTag:(NSString **)authenticationTag
+- (BOOL)encryptFile:(NSString *)fileName fileNameIdentifier:(NSString *)fileNameIdentifier directory:(NSString *)directory key:(NSString **)key initializationVector:(NSString **)initializationVector authenticationTag:(NSString **)authenticationTag
 {
     NSMutableData *cipherData;
     NSData *tagData;
@@ -551,7 +577,7 @@
     return false;
 }
 
-- (BOOL)decryptFileName:(NSString *)fileName fileNameView:(NSString *)fileNameView ocId:(NSString *)ocId key:(NSString *)key initializationVector:(NSString *)initializationVector authenticationTag:(NSString *)authenticationTag
+- (BOOL)decryptFile:(NSString *)fileName fileNameView:(NSString *)fileNameView ocId:(NSString *)ocId key:(NSString *)key initializationVector:(NSString *)initializationVector authenticationTag:(NSString *)authenticationTag
 {
     NSMutableData *plainData;
 
@@ -659,7 +685,7 @@
     return outData;
 }
 
-- (NSString *)decryptAsymmetricData:(NSData *)cipherData privateKey:(NSString *)privateKey
+- (NSData *)decryptAsymmetricData:(NSData *)cipherData privateKey:(NSString *)privateKey
 {
     unsigned char *pKey = (unsigned char *)[privateKey UTF8String];
     int status = 0;
@@ -701,13 +727,14 @@
     status = EVP_PKEY_decrypt(ctx, out, &outLen, [cipherData bytes], (int)[cipherData length]);
     if (status <= 0)
         return nil;
-    
-    NSString *outString = [[NSString alloc] initWithBytes:out length:outLen encoding:NSUTF8StringEncoding];
-    
+
+    NSData *outData = [[NSData alloc] initWithBytes:out length:outLen];
+    //NSString *out64 = [outData base64EncodedStringWithOptions:0];
+
     if (out)
         free(out);
     
-    return outString;
+    return outData;
 }
 
 #
@@ -778,11 +805,10 @@
     // Get the tag
     status = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, (int)sizeof(cTag), cTag);
     *tagData = [NSData dataWithBytes:cTag length:sizeof(cTag)];
-    
-    // Add TAG JAVA compatibility
+
+    // Append TAG
     [*cipherData appendData:*tagData];
-    // --------------------------
-    
+
     // Free
     EVP_CIPHER_CTX_free(ctx);
     

iOSClient/Networking/E2EE/NCEndToEndMetadata.swift

@@ -26,20 +26,13 @@ import NextcloudKit
 
 class NCEndToEndMetadata: NSObject {
 
-    struct E2ee: Codable {
+    struct E2eeV1: Codable {
 
         struct Metadata: Codable {
             let metadataKeys: [String: String]
             let version: Int
         }
 
-        /*
-        Version 2
-        struct Sharing: Codable {
-            let recipient: [String: String]
-        }
-        */
-
         struct Encrypted: Codable {
             let key: String
             let filename: String
@@ -66,8 +59,39 @@ class NCEndToEndMetadata: NSObject {
         let filedrop: [String: Filedrop]?
     }
 
+    struct E2eeV12: Codable {
+
+        struct Metadata: Codable {
+            let metadataKey: String
+            //let version: Int?
+        }
+
+        struct Encrypted: Codable {
+            let key: String
+            let filename: String
+            let mimetype: String
+            let version: Int
+        }
+
+        struct Files: Codable {
+            let initializationVector: String
+            let authenticationTag: String?
+            let encrypted: String
+        }
+
+        struct Filedrop: Codable {
+            let initializationVector: String
+            let authenticationTag: String?
+            let encrypted: String
+        }
+
+        let metadata: Metadata
+        let files: [String: Files]?
+        let filedrop: [String: Filedrop]?
+    }
+
     // --------------------------------------------------------------------------------------------
-    // MARK: Encode JSON Metadata
+    // MARK: Encode JSON Metadata V1
     // --------------------------------------------------------------------------------------------
 
     func encoderMetadata(_ items: [tableE2eEncryption], account: String, serverUrl: String) -> String? {
@@ -75,10 +99,10 @@ class NCEndToEndMetadata: NSObject {
         let encoder = JSONEncoder()
         var metadataKeys: [String: String] = [:]
         let metadataVersion: Int = 1
-        var files: [String: E2ee.Files] = [:]
-        var filesCodable: [String: E2ee.Files]?
-        var filedrop: [String: E2ee.Filedrop] = [:]
-        var filedropCodable: [String: E2ee.Filedrop]?
+        var files: [String: E2eeV1.Files] = [:]
+        var filesCodable: [String: E2eeV1.Files]?
+        var filedrop: [String: E2eeV1.Filedrop] = [:]
+        var filedropCodable: [String: E2eeV1.Filedrop]?
         let privateKey = CCUtility.getEndToEndPrivateKey(account)
 
         for item in items {
@@ -96,13 +120,13 @@ class NCEndToEndMetadata: NSObject {
             // files
             //
             if item.blob == "files" {
-                let encrypted = E2ee.Encrypted(key: item.key, filename: item.fileName, mimetype: item.mimeType, version: item.version)
+                let encrypted = E2eeV1.Encrypted(key: item.key, filename: item.fileName, mimetype: item.mimeType, version: item.version)
                 do {
                     // Create "encrypted"
                     let json = try encoder.encode(encrypted)
                     let encryptedString = String(data: json, encoding: .utf8)
                     if let encrypted = NCEndToEndEncryption.sharedManager().encryptEncryptedJson(encryptedString, key: item.metadataKey) {
-                        let record = E2ee.Files(initializationVector: item.initializationVector, authenticationTag: item.authenticationTag, metadataKey: 0, encrypted: encrypted)
+                        let record = E2eeV1.Files(initializationVector: item.initializationVector, authenticationTag: item.authenticationTag, metadataKey: 0, encrypted: encrypted)
                         files.updateValue(record, forKey: item.fileNameIdentifier)
                     }
                 } catch let error {
@@ -115,14 +139,14 @@ class NCEndToEndMetadata: NSObject {
             // filedrop
             //
             if item.blob == "filedrop" {
-                let encrypted = E2ee.Encrypted(key: item.key, filename: item.fileName, mimetype: item.mimeType, version: item.version)
+                let encrypted = E2eeV1.Encrypted(key: item.key, filename: item.fileName, mimetype: item.mimeType, version: item.version)
                 do {
                     // Create "encrypted"
                     let json = try encoder.encode(encrypted)
                     let encryptedString = (json.base64EncodedString())
                     if let encryptedData = NCEndToEndEncryption.sharedManager().encryptAsymmetricString(encryptedString, publicKey: nil, privateKey: privateKey) {
                         let encrypted = encryptedData.base64EncodedString()
-                        let record = E2ee.Filedrop(initializationVector: item.initializationVector, authenticationTag: item.authenticationTag, metadataKey: 0, encrypted: encrypted)
+                        let record = E2eeV1.Filedrop(initializationVector: item.initializationVector, authenticationTag: item.authenticationTag, metadataKey: 0, encrypted: encrypted)
                         filedrop.updateValue(record, forKey: item.fileNameIdentifier)
                     }
                 } catch let error {
@@ -133,10 +157,10 @@ class NCEndToEndMetadata: NSObject {
         }
 
         // Create Json
-        let metadata = E2ee.Metadata(metadataKeys: metadataKeys, version: metadataVersion)
+        let metadata = E2eeV1.Metadata(metadataKeys: metadataKeys, version: metadataVersion)
         if !files.isEmpty { filesCodable = files }
         if !filedrop.isEmpty { filedropCodable = filedrop }
-        let e2ee = E2ee(metadata: metadata, files: filesCodable, filedrop: filedropCodable)
+        let e2ee = E2eeV1(metadata: metadata, files: filesCodable, filedrop: filedropCodable)
         do {
             let data = try encoder.encode(e2ee)
             data.printJson()
@@ -149,10 +173,30 @@ class NCEndToEndMetadata: NSObject {
     }
 
     // --------------------------------------------------------------------------------------------
-    // MARK: Decode JSON Metadata
+    // MARK: Decode JSON Metadata Bridge
+    // --------------------------------------------------------------------------------------------
+
+    func decoderMetadata(_ json: String, serverUrl: String, account: String, urlBase: String, userId: String, ownerId: String?) -> Bool {
+        guard let data = json.data(using: .utf8) else { return false }
+
+        data.printJson()
+
+        let decoder = JSONDecoder()
+
+        if (try? decoder.decode(E2eeV1.self, from: data)) != nil {
+            return decoderMetadataV1(json, serverUrl: serverUrl, account: account, urlBase: urlBase, userId: userId)
+        } else if (try? decoder.decode(E2eeV12.self, from: data)) != nil {
+            return decoderMetadataV12(json, serverUrl: serverUrl, account: account, urlBase: urlBase, userId: userId, ownerId: ownerId)
+        } else {
+            return false
+        }
+    }
+
+    // --------------------------------------------------------------------------------------------
+    // MARK: Decode JSON Metadata V1
     // --------------------------------------------------------------------------------------------
 
-    func decoderMetadata(_ json: String, serverUrl: String, account: String, urlBase: String, userId: String) -> Bool {
+    func decoderMetadataV1(_ json: String, serverUrl: String, account: String, urlBase: String, userId: String) -> Bool {
         guard let data = json.data(using: .utf8) else { return false }
 
         let decoder = JSONDecoder()
@@ -160,7 +204,7 @@ class NCEndToEndMetadata: NSObject {
 
         do {
             data.printJson()
-            let json = try decoder.decode(E2ee.self, from: data)
+            let json = try decoder.decode(E2eeV1.self, from: data)
 
             let metadata = json.metadata
             let files = json.files
@@ -172,10 +216,10 @@ class NCEndToEndMetadata: NSObject {
             // metadata
             //
             for metadataKey in metadata.metadataKeys {
-                if let metadataKeyData: NSData = NSData(base64Encoded: metadataKey.value, options: NSData.Base64DecodingOptions(rawValue: 0)),
-                   let metadataKeyBase64 = NCEndToEndEncryption.sharedManager().decryptAsymmetricData(metadataKeyData as Data?, privateKey: privateKey),
-                   let metadataKeyBase64Data = Data(base64Encoded: metadataKeyBase64, options: NSData.Base64DecodingOptions(rawValue: 0)),
-                   let key = String(data: metadataKeyBase64Data, encoding: .utf8) {
+                let data = Data(base64Encoded: metadataKey.value)
+                if let decrypted = NCEndToEndEncryption.sharedManager().decryptAsymmetricData(data, privateKey: privateKey),
+                   let keyData = Data(base64Encoded: decrypted) {
+                    let key = String(data: keyData, encoding: .utf8)
                     metadataKeys[metadataKey.key] = key
                 }
             }
@@ -186,7 +230,7 @@ class NCEndToEndMetadata: NSObject {
             if let files = files {
                 for files in files {
                     let fileNameIdentifier = files.key
-                    let files = files.value as E2ee.Files
+                    let files = files.value as E2eeV1.Files
 
                     let encrypted = files.encrypted
                     let authenticationTag = files.authenticationTag
@@ -197,7 +241,7 @@ class NCEndToEndMetadata: NSObject {
                     if let encrypted = NCEndToEndEncryption.sharedManager().decryptEncryptedJson(encrypted, key: metadataKey),
                        let encryptedData = encrypted.data(using: .utf8) {
                         do {
-                            let encrypted = try decoder.decode(E2ee.Encrypted.self, from: encryptedData)
+                            let encrypted = try decoder.decode(E2eeV1.Encrypted.self, from: encryptedData)
 
                             if let metadata = NCManageDatabase.shared.getMetadata(predicate: NSPredicate(format: "account == %@ AND fileName == %@", account, fileNameIdentifier)) {
 
@@ -251,7 +295,7 @@ class NCEndToEndMetadata: NSObject {
             if let filedrop = filedrop {
                 for filedrop in filedrop {
                     let fileNameIdentifier = filedrop.key
-                    let filedrop = filedrop.value as E2ee.Filedrop
+                    let filedrop = filedrop.value as E2eeV1.Filedrop
 
                     let encrypted = filedrop.encrypted
                     let authenticationTag = filedrop.authenticationTag
@@ -266,7 +310,7 @@ class NCEndToEndMetadata: NSObject {
                        let encryptedData = encrypted.data(using: .utf8) {
 
                         do {
-                            let encrypted = try decoder.decode(E2ee.Encrypted.self, from: encryptedData)
+                            let encrypted = try decoder.decode(E2eeV1.Encrypted.self, from: encryptedData)
 
                             if let metadata = NCManageDatabase.shared.getMetadata(predicate: NSPredicate(format: "account == %@ AND fileName == %@", account, fileNameIdentifier)) {
 
@@ -321,4 +365,170 @@ class NCEndToEndMetadata: NSObject {
 
         return true
     }
+
+    // --------------------------------------------------------------------------------------------
+    // MARK: Decode JSON Metadata V2
+    // --------------------------------------------------------------------------------------------
+
+    func decoderMetadataV12(_ json: String, serverUrl: String, account: String, urlBase: String, userId: String, ownerId: String?) -> Bool {
+        guard let data = json.data(using: .utf8) else { return false }
+
+        let decoder = JSONDecoder()
+        let privateKey = CCUtility.getEndToEndPrivateKey(account)
+
+        do {
+            data.printJson()
+            let json = try decoder.decode(E2eeV12.self, from: data)
+
+            let metadata = json.metadata
+            let files = json.files
+            let filedrop = json.filedrop
+            var metadataKey = ""
+
+            //
+            // metadata
+            //
+            let data = Data(base64Encoded: metadata.metadataKey)
+            if let decrypted = NCEndToEndEncryption.sharedManager().decryptAsymmetricData(data, privateKey: privateKey),
+                let keyData = Data(base64Encoded: decrypted) {
+                metadataKey = String(data: keyData, encoding: .utf8) ?? ""
+            }
+
+            //
+            // files
+            //
+            if let files = files {
+                for files in files {
+                    let fileNameIdentifier = files.key
+                    let files = files.value as E2eeV12.Files
+
+                    let encrypted = files.encrypted
+                    let authenticationTag = files.authenticationTag
+                    let initializationVector = files.initializationVector
+
+                    if let decrypted = NCEndToEndEncryption.sharedManager().decryptEncryptedJsonV12(encrypted, key: metadataKey),
+                       let decryptedData = Data(base64Encoded: decrypted) {
+                        do {
+                            let encrypted = try decoder.decode(E2eeV12.Encrypted.self, from: decryptedData)
+
+                            if let metadata = NCManageDatabase.shared.getMetadata(predicate: NSPredicate(format: "account == %@ AND fileName == %@", account, fileNameIdentifier)) {
+
+                                let object = tableE2eEncryption()
+
+                                object.account = account
+                                object.authenticationTag = authenticationTag ?? ""
+                                object.blob = "files"
+                                object.fileName = encrypted.filename
+                                object.fileNameIdentifier = fileNameIdentifier
+                                object.fileNamePath = CCUtility.returnFileNamePath(fromFileName: encrypted.filename, serverUrl: serverUrl, urlBase: urlBase, userId: userId, account: account)
+                                object.key = encrypted.key
+                                object.initializationVector = initializationVector
+                                object.metadataKey = metadataKey
+                                object.metadataKeyIndex = 0
+                                object.metadataVersion = 0
+                                object.mimeType = encrypted.mimetype
+                                object.serverUrl = serverUrl
+                                object.version = encrypted.version
+
+                                // If exists remove records
+                                NCManageDatabase.shared.deleteE2eEncryption(predicate: NSPredicate(format: "account == %@ AND fileNamePath == %@", object.account, object.fileNamePath))
+                                NCManageDatabase.shared.deleteE2eEncryption(predicate: NSPredicate(format: "account == %@ AND fileNameIdentifier == %@", object.account, object.fileNameIdentifier))
+
+                                // Write file parameter for decrypted on DB
+                                NCManageDatabase.shared.addE2eEncryption(object)
+
+                                // Update metadata on tableMetadata
+                                metadata.fileNameView = encrypted.filename
+
+                                let results = NextcloudKit.shared.nkCommonInstance.getInternalType(fileName: encrypted.filename, mimeType: metadata.contentType, directory: metadata.directory)
+
+                                metadata.contentType = results.mimeType
+                                metadata.iconName = results.iconName
+                                metadata.classFile = results.classFile
+
+                                NCManageDatabase.shared.addMetadata(metadata)
+                            }
+
+                        } catch let error {
+                            print("Serious internal error in decoding files (" + error.localizedDescription + ")")
+                            return false
+                        }
+                    }
+                }
+            }
+
+            //
+            // filedrop
+            //
+            if let filedrop = filedrop {
+                for filedrop in filedrop {
+                    let fileNameIdentifier = filedrop.key
+                    let filedrop = filedrop.value as E2eeV12.Filedrop
+
+                    let encrypted = filedrop.encrypted
+                    let authenticationTag = filedrop.authenticationTag
+                    let initializationVector = filedrop.initializationVector
+
+                    if let encryptedData = NSData(base64Encoded: encrypted, options: NSData.Base64DecodingOptions(rawValue: 0)),
+                       let encryptedBase64 = NCEndToEndEncryption.sharedManager().decryptAsymmetricData(encryptedData as Data?, privateKey: privateKey),
+                       let encryptedBase64Data = Data(base64Encoded: encryptedBase64, options: NSData.Base64DecodingOptions(rawValue: 0)),
+                       let encrypted = String(data: encryptedBase64Data, encoding: .utf8),
+                       let encryptedData = encrypted.data(using: .utf8) {
+
+                        do {
+                            let encrypted = try decoder.decode(E2eeV1.Encrypted.self, from: encryptedData)
+
+                            if let metadata = NCManageDatabase.shared.getMetadata(predicate: NSPredicate(format: "account == %@ AND fileName == %@", account, fileNameIdentifier)) {
+
+                                let object = tableE2eEncryption()
+
+                                object.account = account
+                                object.authenticationTag = authenticationTag ?? ""
+                                object.blob = "filedrop"
+                                object.fileName = encrypted.filename
+                                object.fileNameIdentifier = fileNameIdentifier
+                                object.fileNamePath = CCUtility.returnFileNamePath(fromFileName: encrypted.filename, serverUrl: serverUrl, urlBase: urlBase, userId: userId, account: account)
+                                object.key = encrypted.key
+                                object.initializationVector = initializationVector
+                                object.metadataKey = metadataKey
+                                object.metadataKeyIndex = 0
+                                object.metadataVersion = 0
+                                object.mimeType = encrypted.mimetype
+                                object.serverUrl = serverUrl
+                                object.version = encrypted.version
+
+                                // If exists remove records
+                                NCManageDatabase.shared.deleteE2eEncryption(predicate: NSPredicate(format: "account == %@ AND fileNamePath == %@", object.account, object.fileNamePath))
+                                NCManageDatabase.shared.deleteE2eEncryption(predicate: NSPredicate(format: "account == %@ AND fileNameIdentifier == %@", object.account, object.fileNameIdentifier))
+
+                                // Write file parameter for decrypted on DB
+                                NCManageDatabase.shared.addE2eEncryption(object)
+
+                                // Update metadata on tableMetadata
+                                metadata.fileNameView = encrypted.filename
+
+                                let results = NextcloudKit.shared.nkCommonInstance.getInternalType(fileName: encrypted.filename, mimeType: metadata.contentType, directory: metadata.directory)
+
+                                metadata.contentType = results.mimeType
+                                metadata.iconName = results.iconName
+                                metadata.classFile = results.classFile
+
+                                NCManageDatabase.shared.addMetadata(metadata)
+                            }
+
+                        } catch let error {
+                            print("Serious internal error in decoding filedrop (" + error.localizedDescription + ")")
+                            return false
+                        }
+                    }
+                }
+            }
+
+        } catch let error {
+            print("Serious internal error in decoding metadata (" + error.localizedDescription + ")")
+            return false
+        }
+
+        return true
+    }
 }

iOSClient/Networking/E2EE/NCNetworkingE2EECreateFolder.swift

@@ -112,7 +112,7 @@ class NCNetworkingE2EECreateFolder: NSObject {
         // Get last metadata
         let getE2EEMetadataResults = await NextcloudKit.shared.getE2EEMetadata(fileId: fileIdLock, e2eToken: e2eToken)
         if getE2EEMetadataResults.error == .success, let e2eMetadata = getE2EEMetadataResults.e2eMetadata {
-            if !NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: serverUrl, account: account, urlBase: urlBase, userId: userId) {
+            if !NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: serverUrl, account: account, urlBase: urlBase, userId: userId, ownerId: nil) {
                 return NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: NSLocalizedString("_e2e_error_encode_metadata_", comment: ""))
             }
             method = "PUT"

iOSClient/Networking/E2EE/NCNetworkingE2EEDelete.swift

@@ -43,7 +43,7 @@ class NCNetworkingE2EEDelete: NSObject {
 
             // Get last metadata
             let getE2EEMetadataResults = await NextcloudKit.shared.getE2EEMetadata(fileId: fileId, e2eToken: e2eToken)
-            guard getE2EEMetadataResults.error == .success, let e2eMetadata = getE2EEMetadataResults.e2eMetadata, NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: metadata.serverUrl, account: metadata.account, urlBase: metadata.urlBase, userId: metadata.userId) else {
+            guard getE2EEMetadataResults.error == .success, let e2eMetadata = getE2EEMetadataResults.e2eMetadata, NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: metadata.serverUrl, account: metadata.account, urlBase: metadata.urlBase, userId: metadata.userId, ownerId: metadata.ownerId) else {
                     return NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: NSLocalizedString("_e2e_error_encode_metadata_", comment: ""))
             }
 

iOSClient/Networking/E2EE/NCNetworkingE2EERename.swift

@@ -40,7 +40,7 @@ class NCNetworkingE2EERename: NSObject {
 
             // Get last metadata
             let getE2EEMetadataResults = await NextcloudKit.shared.getE2EEMetadata(fileId: fileId, e2eToken: e2eToken)
-            guard getE2EEMetadataResults.error == .success, let e2eMetadata = getE2EEMetadataResults.e2eMetadata, NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: metadata.serverUrl, account: metadata.account, urlBase: metadata.urlBase, userId: metadata.userId) else {
+            guard getE2EEMetadataResults.error == .success, let e2eMetadata = getE2EEMetadataResults.e2eMetadata, NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: metadata.serverUrl, account: metadata.account, urlBase: metadata.urlBase, userId: metadata.userId, ownerId: metadata.ownerId) else {
                 return NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: NSLocalizedString("_e2e_error_encode_metadata_", comment: ""))
             }
 

iOSClient/Networking/E2EE/NCNetworkingE2EEUpload.swift

@@ -133,14 +133,14 @@ class NCNetworkingE2EEUpload: NSObject {
         let fileNameLocalPath = CCUtility.getDirectoryProviderStorageOcId(metadata.ocId, fileNameView: metadata.fileName)!
         var method = "POST"
 
-        if NCEndToEndEncryption.sharedManager()?.encryptFileName(metadata.fileNameView, fileNameIdentifier: metadata.fileName, directory: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId), key: &key, initializationVector: &initializationVector, authenticationTag: &authenticationTag) == false {
+        if NCEndToEndEncryption.sharedManager()?.encryptFile(metadata.fileNameView, fileNameIdentifier: metadata.fileName, directory: CCUtility.getDirectoryProviderStorageOcId(metadata.ocId), key: &key, initializationVector: &initializationVector, authenticationTag: &authenticationTag) == false {
             return NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: "_e2e_error_create_encrypted_")
         }
 
         // Get last metadata
         let getE2EEMetadataResults = await NextcloudKit.shared.getE2EEMetadata(fileId: fileId, e2eToken: e2eToken)
         if getE2EEMetadataResults.error == .success, let e2eMetadata = getE2EEMetadataResults.e2eMetadata {
-            if !NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: metadata.serverUrl, account: metadata.account, urlBase: metadata.urlBase, userId: metadata.userId) {
+            if !NCEndToEndMetadata().decoderMetadata(e2eMetadata, serverUrl: metadata.serverUrl, account: metadata.account, urlBase: metadata.urlBase, userId: metadata.userId, ownerId: metadata.ownerId) {
                 return NKError(errorCode: NCGlobal.shared.errorInternalError, errorDescription: NSLocalizedString("_e2e_error_encode_metadata_", comment: ""))
             }
             method = "PUT"

iOSClient/Networking/NCNetworking.swift

@@ -385,7 +385,7 @@ class NCNetworking: NSObject, NKCommonDelegate {
                 NCManageDatabase.shared.addLocalFile(metadata: metadata)
 #if !EXTENSION
                 if let result = NCManageDatabase.shared.getE2eEncryption(predicate: NSPredicate(format: "fileNameIdentifier == %@ AND serverUrl == %@", metadata.fileName, metadata.serverUrl)) {
-                    NCEndToEndEncryption.sharedManager()?.decryptFileName(metadata.fileName, fileNameView: metadata.fileNameView, ocId: metadata.ocId, key: result.key, initializationVector: result.initializationVector, authenticationTag: result.authenticationTag)
+                    NCEndToEndEncryption.sharedManager()?.decryptFile(metadata.fileName, fileNameView: metadata.fileNameView, ocId: metadata.ocId, key: result.key, initializationVector: result.initializationVector, authenticationTag: result.authenticationTag)
                 }
                 CCUtility.setExif(metadata) { _, _, _, _, _ in }
 #endif

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayer.swift

@@ -453,7 +453,7 @@ class NCPlayer: NSObject {
                 NCManageDatabase.shared.addLocalFile(metadata: self.metadata)
                 if isEncrypted {
                     if let result = NCManageDatabase.shared.getE2eEncryption(predicate: NSPredicate(format: "fileNameIdentifier == %@ AND serverUrl == %@", self.metadata.fileName, self.metadata.serverUrl)) {
-                        NCEndToEndEncryption.sharedManager()?.decryptFileName(self.metadata.fileName, fileNameView: self.metadata.fileNameView, ocId: self.metadata.ocId, key: result.key, initializationVector: result.initializationVector, authenticationTag: result.authenticationTag)
+                        NCEndToEndEncryption.sharedManager()?.decryptFile(self.metadata.fileName, fileNameView: self.metadata.fileNameView, ocId: self.metadata.ocId, key: result.key, initializationVector: result.initializationVector, authenticationTag: result.authenticationTag)
                     }
                 }
                 let urlVideo = NCKTVHTTPCache.shared.getVideoURL(metadata: self.metadata)