Fixes to CDOC2 Recipient info display, CDOC2 settings saving, and Encrypt flow.

Modules/CryptoLib/Sources/CryptoObjC/include/Decrypt.mm

@@ -33,24 +33,24 @@ @implementation Addressee (label)
 - (instancetype)initWithLabel:(const std::string &)label pub:(NSData*)pub concatKDFAlgorithmURI:(NSString *)concatKDFAlgorithmURI {
     std::map<std::string, std::string> info = libcdoc::Recipient::parseLabel(label);
     id cn = info.contains("cn") ? [NSString stringWithStdString:info["cn"]] : nil;
-    id first = info.contains("first_name") ? [NSString stringWithStdString:info["first_name"]] : nil;
-    id last = info.contains("last_name") ? [NSString stringWithStdString:info["last_name"]] : nil;
+    id type = info.contains("last_name") ? [NSString stringWithStdString:info["type"]] : nil;
     id serial = info.contains("serial_number") ? [NSString stringWithStdString:info["serial_number"]] : nil;
-    id type = info.contains("type") ? [NSString stringWithStdString:info["type"]] : nil;
     CertType certType = CertTypeUnknownType;
-    if ([type isEqualToString:@"ID-card"]) {
+    if ([type isEqualToString:@"ID-card"] || [type isEqualToString:@"cert"]) {
         certType = CertTypeIDCardType;
     } else if ([type isEqualToString:@"Digi-ID"]) {
         certType = CertTypeDigiIDType;
     } else if ([type isEqualToString:@"Digi-ID E-RESIDENT"]) {
         certType = CertTypeEResidentType;
+    } else if (type == nil) {
+        certType = CertTypeESealType;
     }
     id validTo = nil;
     if (info.contains("server_exp")) {
         long long epochTime = [[NSString stringWithStdString:info["server_exp"]] longLongValue];
         validTo = [NSDate dateWithTimeIntervalSince1970:epochTime];
     }
-    if (self = [self initWithData:pub cnVal:cn givenName:first surname:last serialNumber:serial certType:certType validTo:validTo concatKDFAlgorithmURI:concatKDFAlgorithmURI]) {
+    if (self = [self initWithCnVal:cn serialNumber:serial certType:certType validTo:validTo data:pub  concatKDFAlgorithmURI:concatKDFAlgorithmURI]) {
     }
     return self;
 }

Modules/CryptoLib/Sources/CryptoObjCWrapper/Domain/Addressee.swift

@@ -63,6 +63,31 @@ import Foundation
         )
     }
 
+    @objc public init(
+        cnVal: String,
+        serialNumber: String?,
+        certType: CertType,
+        validTo: Date?,
+        data: Data,
+        concatKDFAlgorithmURI: String = ""
+    ) {
+        let split = cnVal.split(separator: ",").map { String($0) }
+        if split.count > 1 {
+            surname = split[0]
+            givenName = split[1]
+            identifier = split[2]
+        } else {
+            surname = nil
+            givenName = nil
+            identifier = cnVal
+        }
+        self.serialNumber = serialNumber
+        self.certType = certType
+        self.validTo = validTo
+        self.data = data
+        self.concatKDFAlgorithmURI = concatKDFAlgorithmURI
+    }
+
     public init(cert: Data, x509: X509Certificate?) {
         data = cert
         let cnVal = x509?.subject(oid: .commonName)?.joined(separator: ",") ?? ""

RIADigiDoc/CryptoSetup.swift

@@ -101,7 +101,7 @@ actor CryptoSetup: CryptoSetupProtocol {
         }
     }
 
-    public func setCdoc2Settings(_ configurationProvider: ConfigurationProvider?, _ certData: Data? = nil) async {
+    public func setCdoc2Settings(_ configurationProvider: ConfigurationProvider?) async {
         var defaultUseCdoc2Encryption = Constants.CryptoDefaultValues.encryptionUseCdoc2
         if let useCdoc2Encryption = configurationProvider?.cdoc2Default {
             defaultUseCdoc2Encryption = useCdoc2Encryption
@@ -129,8 +129,23 @@ actor CryptoSetup: CryptoSetupProtocol {
             Decrypt.setCdoc2Config(cdoc2Conf.asNSDictionary())
         }
 
+        if let certBundle = configurationProvider?.certBundle {
+            Encrypt.setCerts(certBundle)
+            Decrypt.setCerts(certBundle)
+        }
+
         let proxyInfo = await proxyUtil.getProxyInfo()
+        await setCdoc2ProxyInfo(proxyInfo)
+    }
+
+    public func setCdoc2CustomCert(_ certData: Data? = nil) async {
+        if let certData {
+            Encrypt.setCert(certData)
+            Decrypt.setCert(certData)
+        }
+    }
 
+    public func setCdoc2ProxyInfo(_ proxyInfo: ProxyInfo) async {
         Encrypt.setProxy(
             proxyInfo.host,
             port: proxyInfo.port,
@@ -144,16 +159,5 @@ actor CryptoSetup: CryptoSetupProtocol {
             username: proxyInfo.username,
             password: proxyInfo.password
         )
-
-        if let certBundle = configurationProvider?.certBundle {
-            Encrypt.setCerts(certBundle)
-            Decrypt.setCerts(certBundle)
-        }
-
-        if let certData {
-            Encrypt.setCert(certData)
-            Decrypt.setCert(certData)
-        }
     }
-
 }

RIADigiDoc/CryptoSetupProtocol.swift

@@ -18,11 +18,14 @@
  */
 
 import Foundation
+import CommonsLib
 import ConfigLib
 
 /// @mockable
 public protocol CryptoSetupProtocol: Sendable {
     func setLdapConfig(_ configurationProvider: ConfigurationProvider?) async
     func setCdoc2Config(_ configurationProvider: ConfigurationProvider?) async
-    func setCdoc2Settings(_ configurationProvider: ConfigurationProvider?, _ certData: Data?) async
+    func setCdoc2Settings(_ configurationProvider: ConfigurationProvider?) async
+    func setCdoc2CustomCert(_ certData: Data?) async
+    func setCdoc2ProxyInfo(_ proxyInfo: ProxyInfo) async
 }

RIADigiDoc/DI/AppContainer.swift

@@ -255,7 +255,8 @@ extension Container {
                 dataStore: self.dataStore(),
                 proxyUtil: self.proxyUtil(),
                 userAgentUtil: self.userAgentUtil(),
-                fileUtil: self.fileUtil()
+                fileUtil: self.fileUtil(),
+                cryptoSetup: self.cryptoSetup()
             )
         }
     }
@@ -324,7 +325,8 @@ extension Container {
             ProxySettingsViewModel(
                 proxyUtil: self.proxyUtil(),
                 userAgentUtil: self.userAgentUtil(),
-                dataStore: self.dataStore()
+                dataStore: self.dataStore(),
+                cryptoSetup: self.cryptoSetup()
             )
         }
     }

RIADigiDoc/LibrarySetup.swift

@@ -119,7 +119,7 @@ actor LibrarySetup: Loggable {
 
             await cryptoSetup.setLdapConfig(configurationProvider)
             await cryptoSetup.setCdoc2Config(configurationProvider)
-            await cryptoSetup.setCdoc2Settings(configurationProvider, nil)
+            await cryptoSetup.setCdoc2Settings(configurationProvider)
 
             try saveLDAPCertsToLibrary(ldapCertsBundle: configurationProvider?.ldapCerts)
         } catch let error {

RIADigiDoc/Supporting files/Localizable.xcstrings

@@ -287,6 +287,42 @@
         }
       }
     },
+    "Cannot create an empty crypto container" : {
+      "comment" : "CryptoContainer empty error message",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Cannot create an empty crypto container"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Ei saa luua tühja krüptokonteinerit"
+          }
+        }
+      }
+    },
+    "Cannot create crypto container without recipients" : {
+      "comment" : "CryptoContainer no recipients error message",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Cannot create crypto container without recipients"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Ei saa luua krüptokonteinerit ilma adressaatideta"
+          }
+        }
+      }
+    },
     "Certificate details" : {
       "comment" : "Title of Certificate Details view",
       "localizations" : {
@@ -304,6 +340,24 @@
         }
       }
     },
+    "Certificate for Encryption" : {
+      "comment" : "Certificate type",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Certificate for Encryption"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Krüpteerimissertifikaat"
+          }
+        }
+      }
+    },
     "Certificate has expired" : {
       "comment" : "OperationAuthenticateWithWebEID Certificate validity check",
       "extractionState" : "manual",
@@ -1164,6 +1218,24 @@
         }
       }
     },
+    "Digi-ID" : {
+      "comment" : "Certificate type",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Digi-ID"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Digi-ID"
+          }
+        }
+      }
+    },
     "DigiDoc" : {
       "comment" : "DigiDoc title on homesview",
       "extractionState" : "manual",
@@ -1236,6 +1308,24 @@
         }
       }
     },
+    "E-Resident" : {
+      "comment" : "Certificate type",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "E-Resident"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "E-Resident"
+          }
+        }
+      }
+    },
     "Empty file in container" : {
       "comment" : "Empty file message in container notifications",
       "extractionState" : "manual",
@@ -1290,6 +1380,24 @@
         }
       }
     },
+    "Encrypt general error" : {
+      "comment" : "CryptoContainer encrypt error message",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Container encryption was unsuccessful"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "needs_review",
+            "value" : "Ümbriku krüpteerimine ebaõnnestus"
+          }
+        }
+      }
+    },
     "Enter current PIN code" : {
       "comment" : "My eID current PIN or PUK code step title",
       "extractionState" : "manual",
@@ -1865,6 +1973,24 @@
         }
       }
     },
+    "ID-card" : {
+      "comment" : "Certificate type",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ID-card"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "ID-kaart"
+          }
+        }
+      }
+    },
     "ID-card via NFC" : {
       "comment" : "ID-card via NFC signing method",
       "extractionState" : "manual",
@@ -7513,6 +7639,24 @@
         }
       }
     },
+    "Unknown" : {
+      "comment" : "Certificate type",
+      "extractionState" : "manual",
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Unknown"
+          }
+        },
+        "et" : {
+          "stringUnit" : {
+            "state" : "translated",
+            "value" : "Tundmatu"
+          }
+        }
+      }
+    },
     "Unknown signature" : {
       "comment" : "Unknown signature message in container notifications",
       "extractionState" : "manual",

RIADigiDoc/UI/Component/Container/Crypto/EncryptView.swift

@@ -364,11 +364,8 @@ struct EncryptView: View {
                                                 await updateAsyncLabels()
                                                 await viewModel.updateAsyncProperties()
 
-                                                Toast.show(languageSettings.localized(
-                                                    "Container successfully encrypted"
-                                                ))
-
                                                 encryptionButtonEnabled = true
+                                                isWithEncryption = false
                                             }
                                         }
                                     }
@@ -407,10 +404,6 @@ struct EncryptView: View {
                                 await updateAsyncLabels()
                                 await viewModel.updateAsyncProperties()
 
-                                Toast.show(languageSettings.localized(
-                                    "Container successfully encrypted"
-                                ))
-
                                 encryptionButtonEnabled = true
                                 isWithEncryption = false
                             } else if isWithDecryption {
@@ -479,12 +472,19 @@ struct EncryptView: View {
         .animation(.easeInOut, value: showRenameModal)
         .onChange(of: viewModel.errorMessage) { _, error in
             guard let error else { return }
-            Toast.show(String(
-                format: languageSettings.localized(error.key),
-                error.args.joined(separator: ", "))
+            Toast.show(
+                languageSettings.localized(error.key, [error.args.joined(separator: ", ")])
             )
+            viewModel.resetErrorMessage()
             encryptionButtonEnabled = true
         }
+        .onChange(of: viewModel.successMessage) { _, message in
+            guard let message else { return }
+            Toast.show(
+                languageSettings.localized(message.key, [message.args.joined(separator: ", ")])
+            )
+            viewModel.resetSuccessMessage()
+        }
     }
 
     func updateAsyncLabels() async {