move e2e to new class

iOSClient/Main/CCMain.m

@@ -1195,7 +1195,7 @@
         } else {
             
             // Initialize
-            [self initEndToEnd];
+            [app.endToEndInterface initEndToEndEncryption];
         }
     }
 #endif
@@ -1237,249 +1237,6 @@
     [app addNetworkingOperationQueue:app.netQueue delegate:self metadataNet:metadataNet];
 }
 
-#pragma mark -
-#pragma --------------------------------------------------------------------------------------------
-#pragma mark ==== End-to-End Encryption  ====
-#pragma --------------------------------------------------------------------------------------------
-
-// ++++++++++++++++++++++ INITIALIZE ++++++++++++++++++++++
-
-- (void)initEndToEnd
-{
-    // request keys to server
-    CCMetadataNet *metadataNet = [[CCMetadataNet alloc] initWithAccount:app.activeAccount];
-
-    metadataNet.action = actionGetEndToEndPublicKeys;
-    [app addNetworkingOperationQueue:app.netQueue delegate:self metadataNet:metadataNet];
-    
-    metadataNet.action = actionGetEndToEndPrivateKeyCipher;
-    [app addNetworkingOperationQueue:app.netQueue delegate:self metadataNet:metadataNet];
-    
-    metadataNet.action = actionGetEndToEndServerPublicKey;
-    [app addNetworkingOperationQueue:app.netQueue delegate:self metadataNet:metadataNet];
-}
-
-// ++++++++++++++++++++++ PUBLIC KEYS (SIGN) ++++++++++++++++++++++
-
-- (void)getEndToEndPublicKeysSuccess:(CCMetadataNet *)metadataNet
-{
-    // store key locally keychain
-    [CCUtility setEndToEndPublicKeySign:app.activeAccount publicKey:metadataNet.key];
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"E2E PublicKeys present on Server and stored to keychain" type:k_activityTypeSuccess verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)getEndToEndPublicKeysFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    switch (errorCode) {
-        case 400:
-            message = @"bad request: unpredictable internal error";
-            [app messageNotification:@"E2E public keys" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-        case 404: {
-            // remove keychain
-            [CCUtility setEndToEndPublicKeySign:app.activeAccount publicKey:nil];
-            
-            CCMetadataNet *metadataNet = [[CCMetadataNet alloc] initWithAccount:app.activeAccount];
-            
-            NSString *publicKey = [[NCEndToEndEncryption sharedManager] createEndToEndPublicKey:app.activeUserID directoryUser:app.directoryUser];
-            
-            if (publicKey) {
-                
-                metadataNet.action = actionSignEndToEndPublicKey;
-                metadataNet.key = publicKey;
-                
-                [app addNetworkingOperationQueue:app.netQueue delegate:self metadataNet:metadataNet];
-                
-            } else {
-                // Activity
-                [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"E2E Error to create PublicKeyEncoded" type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-            }
-            
-            message = @"public keys couldn't be found";
-        }
-            break;
-        case 409:
-            message = @"forbidden: the user can't access the public keys";
-            [app messageNotification:@"E2E public keys" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-        default:
-            [app messageNotification:@"E2E public keys" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-    }
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:message type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)signEndToEndPublicKeySuccess:(CCMetadataNet *)metadataNet
-{
-    // Insert CSR To Cheychain end delete
-    NSString *publicKey = [[NCEndToEndEncryption sharedManager] getCSRFromDisk:app.directoryUser delete:YES];
-    
-    // OK signed key locally keychain
-    [CCUtility setEndToEndPublicKeySign:app.activeAccount publicKey:publicKey];
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"E2E PublicKey sign on Server and stored locally" type:k_activityTypeSuccess verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)signEndToEndPublicKeyFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    [app messageNotification:@"E2E sign public key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:message type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)deleteEndToEndPublicKeySuccess:(CCMetadataNet *)metadataNet
-{
-    [app messageNotification:@"E2E delete public key" description:@"Public key was deleted" visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeSuccess errorCode:0];
-}
-
-- (void)deleteEndToEndPublicKeyFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    [app messageNotification:@"E2E delete public key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-}
-
-// ++++++++++++++++++++++ PRIVATE KEY ++++++++++++++++++++++
-
-- (void)getEndToEndPrivateKeyCipherSuccess:(CCMetadataNet *)metadataNet
-{
-    // Verify KeyPair on server
-    NSString *privateKey = [[NCEndToEndEncryption sharedManager] decryptPrivateKeyCipher:metadataNet.key mnemonic:k_Mnemonic_test];
-    
-    if (privateKey) {
-        
-        // OK privatekey locally keychain
-        [CCUtility setEndToEndPrivateKey:app.activeAccount privateKey:privateKey];
-        
-        // Strore mnemonic locally keychain
-        [CCUtility setEndToEndMnemonic:app.activeAccount mnemonic:k_Mnemonic_test];
-
-        // Activity
-        [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"E2E PrivateKey present on Server and stored to keychain" type:k_activityTypeSuccess verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-        
-    } else {
-        
-        // Activity
-        [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"E2E PrivateKey error to decrypt" type:k_activityTypeSuccess verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-    }
-}
-
-- (void)getEndToEndPrivateKeyCipherFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    switch (errorCode) {
-        case 400:
-            message = @"bad request: unpredictable internal error";
-            [app messageNotification:@"E2E private key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-        case 404: {
-            // remove keychain
-            [CCUtility setEndToEndPrivateKey:app.activeAccount privateKey:nil];
-            [CCUtility setEndToEndMnemonic:app.activeAccount mnemonic:nil];
-            
-            NSString *mnemonic = [[NYMnemonic generateMnemonicString:@128 language:@"english"] stringByReplacingOccurrencesOfString:@" " withString:@""];
-            mnemonic = k_Mnemonic_test;
-            
-            NSString *privateKeyChiper = [[NCEndToEndEncryption sharedManager] createEndToEndPrivateKey:app.activeUserID directoryUser:app.directoryUser mnemonic:mnemonic];
-            
-            if (privateKeyChiper) {
-                
-                CCMetadataNet *metadataNet = [[CCMetadataNet alloc] initWithAccount:app.activeAccount];
-
-                metadataNet.action = actionStoreEndToEndPrivateKeyCipher;
-                metadataNet.key = privateKeyChiper;
-                metadataNet.password = mnemonic;
-                
-                [app addNetworkingOperationQueue:app.netQueue delegate:self metadataNet:metadataNet];
-                
-            } else {
-                // Activity
-                [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"Error to create PrivateKeyEncoded" type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-            }
-            
-            message = @"private key doesn't exists";
-        }
-            break;
-        case 409:
-            message = @"forbidden: the user can't access the private key";
-            [app messageNotification:@"E2E private key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-        default:
-            [app messageNotification:@"E2E private key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-    }
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:message type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)storeEndToEndPrivateKeyCipherSuccess:(CCMetadataNet *)metadataNet
-{
-    // Insert PrivateKey To Cheychain end delete
-    NSString *privateKey = [[NCEndToEndEncryption sharedManager] getPrivateKeyFromDisk:app.directoryUser delete:YES];
-    
-    // OK privatekey locally keychain
-    [CCUtility setEndToEndPrivateKey:app.activeAccount privateKey:privateKey];
-    
-    // Strore mnemonic locally keychain
-    [CCUtility setEndToEndMnemonic:app.activeAccount mnemonic:metadataNet.password];
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:@"E2E PrivateKey stored on Server and stored locally" type:k_activityTypeSuccess verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)storeEndToEndPrivateKeyCipherFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    [app messageNotification:@"E2E sign private key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:message type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
-- (void)deleteEndToEndPrivateKeySuccess:(CCMetadataNet *)metadataNet
-{
-    [app messageNotification:@"E2E delete private key" description:@"Private key was deleted" visible:YES delay:1 type:TWMessageBarMessageTypeSuccess errorCode:0];
-}
-
-- (void)deleteEndToEndPrivateKeyFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    [app messageNotification:@"E2E delete private key" description:message visible:YES delay:1 type:TWMessageBarMessageTypeError errorCode:errorCode];
-}
-
-// ++++++++++++++++++++++ SERVER PUBLIC KEY ++++++++++++++++++++++
-
-- (void)getEndToEndServerPublicKeySuccess:(CCMetadataNet *)metadataNet
-{
-}
-
-- (void)getEndToEndServerPublicKeyFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-{
-    switch (errorCode) {
-        case 400:
-            message = @"bad request: unpredictable internal error";
-            [app messageNotification:@"E2E Server public key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-        case 404: {
-            
-            message = @"private key doesn't exists";
-        }
-            break;
-        case 409:
-            message = @"forbidden: the user can't access the private key";
-            [app messageNotification:@"E2E private key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-        default:
-            [app messageNotification:@"E2E private key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
-            break;
-    }
-    
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:message type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
-}
-
 #pragma mark -
 #pragma --------------------------------------------------------------------------------------------
 #pragma mark ==== Download Thumbnail Delegate ====

iOSClient/Security/NCEntoToEndInterface.swift

@@ -48,47 +48,48 @@ class NCEntoToEndInterface : NSObject, OCNetworkingDelegate  {
         appDelegate.addNetworkingOperationQueue(appDelegate.netQueue, delegate: self, metadataNet: metadataNet)
     }
     
-    
-    func getEndToEndServerPublicKeySuccess(_ metadataNet: CCMetadataNet!) {
+    func getEndToEndPublicKeysSuccess(_ metadataNet: CCMetadataNet!) {
     
         CCUtility.setEndToEndPublicKeySign(appDelegate.activeAccount, publicKey: metadataNet.key)
         
-        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E PublicKeys present on Server and stored to keychain", type: k_activityTypeSuccess, verbose: true, activeUrl: appDelegate.activeUrl)
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E PublicKeys present on Server and stored to keychain", type: k_activityTypeSuccess, verbose: false, activeUrl: "")
     }
     
     func getEndToEndPublicKeysFailure(_ metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
     
-        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: actionSignEndToEndPublicKey, note: message as String!, type: k_activityTypeFailure, verbose: true, activeUrl: appDelegate.activeUrl)
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: message as String!, type: k_activityTypeFailure, verbose: false, activeUrl: "")
         
         switch errorCode {
             
-        case 400:
-            appDelegate.messageNotification("E2E public keys", description: "bad request: unpredictable internal error" as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
-        case 404:
-            // public keys couldn't be found
-            // remove keychain
-            CCUtility.setEndToEndPublicKeySign(appDelegate.activeAccount, publicKey: nil)
-            
-            let metadataNet: CCMetadataNet = CCMetadataNet.init(account: appDelegate.activeAccount)
-            let publicKey = NCEndToEndEncryption.sharedManager().createEnd(toEndPublicKey: appDelegate.activeUserID, directoryUser: appDelegate.directoryUser)
+            case 400:
+                appDelegate.messageNotification("E2E public keys", description: "bad request: unpredictable internal error", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            case 404:
+                // public keys couldn't be found
+                // remove keychain
+                CCUtility.setEndToEndPublicKeySign(appDelegate.activeAccount, publicKey: nil)
             
-            if (publicKey != nil) {
+                let publicKey = NCEndToEndEncryption.sharedManager().createEnd(toEndPublicKey: appDelegate.activeUserID, directoryUser: appDelegate.directoryUser)
+                if (publicKey != nil) {
                 
-                metadataNet.action = actionSignEndToEndPublicKey;
-                metadataNet.key = publicKey;
+                    let metadataNet: CCMetadataNet = CCMetadataNet.init(account: appDelegate.activeAccount)
+
+                    metadataNet.action = actionSignEndToEndPublicKey;
+                    metadataNet.key = publicKey;
+                
+                    appDelegate.addNetworkingOperationQueue(appDelegate.netQueue, delegate: self, metadataNet: metadataNet)
                 
-                appDelegate.addNetworkingOperationQueue(appDelegate.netQueue, delegate: self, metadataNet: metadataNet)
+                } else {
                 
-            } else {
+                    appDelegate.messageNotification("E2E public keys", description: "E2E Error to create PublicKey", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
                 
-                NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: actionSignEndToEndPublicKey, note: "E2E Error to create PublicKeyEncoded", type: k_activityTypeFailure, verbose: true, activeUrl: appDelegate.activeUrl)
-            }
+                    NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: actionSignEndToEndPublicKey, note: "E2E Error to create PublicKey", type: k_activityTypeFailure, verbose: false, activeUrl: "")
+                }
             
-        case 409:
-            appDelegate.messageNotification("E2E public keys", description: "forbidden: the user can't access the public keys", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            case 409:
+                appDelegate.messageNotification("E2E public keys", description: "forbidden: the user can't access the public keys", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
             
-        default:
-            appDelegate.messageNotification("E2E public keys", description: message as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            default:
+                appDelegate.messageNotification("E2E public keys", description: message as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
         }
     }
 
@@ -96,26 +97,155 @@ class NCEntoToEndInterface : NSObject, OCNetworkingDelegate  {
 
         // Insert CSR To Cheychain end delete
         let publicKey = NCEndToEndEncryption.sharedManager().getCSRFromDisk(appDelegate.directoryUser, delete: true)
+        
         // OK signed key locally keychain
         CCUtility.setEndToEndPublicKeySign(appDelegate.activeAccount, publicKey: publicKey)
         
-        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E PublicKey sign on Server and stored locally", type: k_activityTypeFailure, verbose: true, activeUrl: appDelegate.activeUrl)
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E PublicKey sign on Server and stored locally", type: k_activityTypeFailure, verbose: false, activeUrl: "")
     }
 
     func signEnd(toEndPublicKeyFailure metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
         
+        appDelegate.messageNotification("E2E sign public keys", description: message as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+        
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: message, type: k_activityTypeFailure, verbose: false, activeUrl: "")
+    }
+    
+    func deleteEnd(toEndPublicKeySuccess metadataNet: CCMetadataNet!) {
+        appDelegate.messageNotification("E2E delete public key", description: "Public key was deleted", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.success, errorCode: 0)
+    }
+    
+    func deleteEnd(toEndPublicKeyFailure metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
+        appDelegate.messageNotification("E2E delete public key", description: message, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: 0)
+    }
+    
+    // --------------------------------------------------------------------------------------------
+    // MARK: End To End Encryption - PrivateKey
+    // --------------------------------------------------------------------------------------------
+    
+    func getEndToEndPrivateKeyCipherSuccess(_ metadataNet: CCMetadataNet!) {
+        
+        let privateKey = NCEndToEndEncryption.sharedManager().decryptPrivateKeyCipher(metadataNet.key, mnemonic: k_Mnemonic_test)
+        
+        if (privateKey != nil) {
+            
+            // Save to keychain
+            CCUtility.setEndToEndPrivateKey(appDelegate.activeAccount, privateKey: privateKey)
+            
+            // Save mnemonic to keychain
+            CCUtility.setEndToEndMnemonic(appDelegate.activeAccount, mnemonic:k_Mnemonic_test)
+
+            NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E PrivateKey present on Server and stored to keychain", type: k_activityTypeSuccess, verbose: false, activeUrl: "")
+            
+        } else {
+            
+            appDelegate.messageNotification("E2E decrypt private key", description: "E2E Error to decrypt Private Key", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: 0)
+            
+            NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E Error to decrypt Private Key", type: k_activityTypeFailure, verbose: false, activeUrl: "")
+        }
+    }
+    
+    func getEndToEndPrivateKeyCipherFailure(_ metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
+        
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: message as String!, type: k_activityTypeFailure, verbose: false, activeUrl: "")
+        
+        switch errorCode {
+            
+            case 400:
+                
+                appDelegate.messageNotification("E2E public keys", description: "bad request: unpredictable internal error", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            
+            case 404:
+                // private keys couldn't be found
+                // remove keychain
+                CCUtility.setEndToEndPrivateKey(appDelegate.activeAccount, privateKey: nil)
+                CCUtility.setEndToEndMnemonic(appDelegate.activeAccount, mnemonic: nil)
+
+                let mnemonic = k_Mnemonic_test;
+            
+                let privateKeyChiper = NCEndToEndEncryption.sharedManager().createEnd(toEndPrivateKey: appDelegate.activeUserID, directoryUser: appDelegate.directoryUser, mnemonic: mnemonic)
+            
+                if (privateKeyChiper != nil) {
+                    
+                    let metadataNet: CCMetadataNet = CCMetadataNet.init(account: appDelegate.activeAccount)
+                    
+                    metadataNet.action = actionStoreEndToEndPrivateKeyCipher
+                    metadataNet.key = privateKeyChiper
+                    metadataNet.password = mnemonic
+                    
+                    appDelegate.addNetworkingOperationQueue(appDelegate.netQueue, delegate: self, metadataNet: metadataNet)
+                    
+                } else {
+                    
+                    appDelegate.messageNotification("E2E private keys", description: "E2E Error to create PublicKey chiper", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+                    
+                    NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: actionSignEndToEndPublicKey, note: "E2E Error to create PublicKey chiper", type: k_activityTypeFailure, verbose: false, activeUrl: "")
+                }
+            
+            case 409:
+                appDelegate.messageNotification("E2E private keys", description: "forbidden: the user can't access the private keys", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            
+            default:
+                appDelegate.messageNotification("E2E private keys", description: message as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+        }
+    }
+    
+    func storeEnd(toEndPrivateKeyCipherSuccess metadataNet: CCMetadataNet!) {
+        
+        // Insert PrivateKey (end delete) and mnemonic to Cheychain
+        let privateKey = NCEndToEndEncryption.sharedManager().getPrivateKey(fromDisk: appDelegate.directoryUser, delete: true)
+        
+        CCUtility.setEndToEndPrivateKey(appDelegate.activeAccount, privateKey: privateKey)
+        CCUtility.setEndToEndMnemonic(appDelegate.activeAccount, mnemonic:metadataNet.password)
+        
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: actionSignEndToEndPublicKey, note: "E2E PrivateKey stored on Server and stored locally", type: k_activityTypeSuccess, verbose: false, activeUrl: "")
     }
     
-    /*
-    - (void)signEndToEndPublicKeyFailure:(CCMetadataNet *)metadataNet message:(NSString *)message errorCode:(NSInteger)errorCode
-    {
-    [app messageNotification:@"E2E sign public key" description:message visible:YES delay:k_dismissAfterSecond type:TWMessageBarMessageTypeError errorCode:errorCode];
+    func storeEnd(toEndPrivateKeyCipherFailure metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
+        
+        appDelegate.messageNotification("E2E sign private key", description: message as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+        
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: message, type: k_activityTypeFailure, verbose: false, activeUrl: "")
+    }
     
-    // Activity
-    [[NCManageDatabase sharedInstance] addActivityClient:@"" fileID:@"" action:k_activityDebugActionEndToEndEncryption selector:metadataNet.selector note:message type:k_activityTypeFailure verbose:k_activityVerboseHigh activeUrl:app.activeUrl];
+    func deleteEnd(toEndPrivateKeySuccess metadataNet: CCMetadataNet!) {
+        appDelegate.messageNotification("E2E delete private key", description: "Private key was deleted", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.success, errorCode: 0)
     }
-    */
     
+    func deleteEnd(toEndPrivateKeyFailure metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
+        appDelegate.messageNotification("E2E delete private key", description: message, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: 0)
+    }
+    
+    // --------------------------------------------------------------------------------------------
+    // MARK: End To End Encryption - Server PublicKey
+    // --------------------------------------------------------------------------------------------
+    
+    func getEndToEndServerPublicKeySuccess(_ metadataNet: CCMetadataNet!) {
+        
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: "E2E Server PublicKey present on Server and stored to keychain", type: k_activityTypeSuccess, verbose: false, activeUrl: "")
+    }
+    
+    func getEndToEndServerPublicKeyFailure(_ metadataNet: CCMetadataNet!, message: String!, errorCode: Int) {
+        
+        NCManageDatabase.sharedInstance.addActivityClient("", fileID: "", action: k_activityDebugActionEndToEndEncryption, selector: metadataNet.selector, note: message as String!, type: k_activityTypeFailure, verbose: false, activeUrl: "")
+        
+        switch (errorCode) {
+            
+        case 400:
+            
+            appDelegate.messageNotification("E2E Server public key", description: "bad request: unpredictable internal error", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            
+        case 404:
+            
+            appDelegate.messageNotification("E2E Server public key", description: "Server publickey doesn't exists", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            
+        case 409:
+            appDelegate.messageNotification("E2E Server public key", description: "forbidden: the user can't access the Server publickey", visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+            
+        default:
+            appDelegate.messageNotification("E2E Server public key", description: message as String!, visible: true, delay: TimeInterval(k_dismissAfterSecond), type: TWMessageBarMessageType.error, errorCode: errorCode)
+        }
+    }
     
     // --------------------------------------------------------------------------------------------
     // MARK: Mark/Delete Encrypted Folder