⚡ Ensure idempotency in load private keys #130

Author: xecrets

src/Xecrets.Cli/Operation/LoadPrivateKeysOperation.cs

@@ -23,6 +23,7 @@
 
 #endregion Copyright and GPL License
 
+using AxCrypt.Abstractions;
 using AxCrypt.Api.Model;
 using AxCrypt.Core.Crypto;
 using AxCrypt.Core.Extensions;
@@ -71,11 +72,13 @@ private static Status RealAsyncInternal(Parameters parameters)
     {
         var store = New<IStandardIoDataStore>(parameters.Arg1);
         UserAccounts? userAccounts;
+        string json;
         using (StreamReader reader = new StreamReader(store.OpenRead()))
         {
+            json = reader.ReadToEnd();
             try
             {
-                userAccounts = UserAccounts.DeserializeFrom(reader);
+                userAccounts = New<IStringSerializer>().Deserialize<UserAccounts>(json);
             }
             catch (Exception ex)
             {
@@ -97,9 +100,18 @@ private static Status RealAsyncInternal(Parameters parameters)
         }
 
         store = New<IStandardIoDataStore>(parameters.Arg2);
+
         using (StreamWriter writer = new StreamWriter(store.OpenWrite()))
         {
-            reEncryptedAccounts.SerializeTo(writer);
+            // Ensure this operation is idempotent
+            if (object.ReferenceEquals(userAccounts, reEncryptedAccounts))
+            {
+                writer.Write(json);
+            }
+            else
+            {
+                reEncryptedAccounts.SerializeTo(writer);
+            }
         }
         return Status.Success;
     }
@@ -111,35 +123,56 @@ private static Status RealAsyncInternal(Parameters parameters)
             return userAccounts;
         }
 
+        Passphrase reEncryptionPassphrase = parameters.Identities.First(i => i.Passphrase != Passphrase.Empty).Passphrase;
+
         List<Passphrase> passphrases = [.. parameters.Identities
-            .Where(i => i.Passphrase != Passphrase.Empty)
+            .Where(i => i.Passphrase != Passphrase.Empty && i.Passphrase != reEncryptionPassphrase)
             .Select(i => i.Passphrase)];
 
-        List<UserKeyPair> userKeyPairs = [];
+        EmailAddress mainUserEmail = parameters.Identities
+            .FirstOrDefault(i => i.UserEmail != EmailAddress.Empty)?.UserEmail ?? EmailAddress.Empty;
+        string userEmail = mainUserEmail == EmailAddress.Empty
+            ? userAccounts.Accounts.First().UserName : mainUserEmail.Address;
+
+        List<UserKeyPair> decryptedKeyPairs = [];
         List<AccountKey> nonDecryptableAccountKeys = [];
+        bool statusChanged = userAccounts.Accounts.Where(a => a.UserName != userEmail).Any();
         foreach (AccountKey key in userAccounts.Accounts.Select(a => a.AccountKeys).SelectMany(a => a))
         {
-            if (TryDecryptKey(key, passphrases, out UserKeyPair? userKeyPair))
+            statusChanged |= key.User != userEmail;
+            if (TryDecryptKey(key, [reEncryptionPassphrase], out UserKeyPair? userKeyPair))
+            {
+                decryptedKeyPairs.Add(userKeyPair!);
+                statusChanged |= key.Status != PrivateKeyStatus.PassphraseKnown;
+                continue;
+            }
+
+            if (TryDecryptKey(key, passphrases, out userKeyPair))
             {
-                userKeyPairs.Add(userKeyPair!);
+                decryptedKeyPairs.Add(userKeyPair!);
+                statusChanged = true;
                 continue;
             }
+
             nonDecryptableAccountKeys.Add(key);
+            statusChanged |= key.Status != PrivateKeyStatus.PassphraseUnknown;
         }
-        userKeyPairs = [.. userKeyPairs.OrderByDescending(k => k.Timestamp)];
-        if (userKeyPairs.Count != 0)
+
+        decryptedKeyPairs = [.. decryptedKeyPairs.OrderByDescending(k => k.Timestamp)];
+        if (decryptedKeyPairs.Count != 0)
         {
-            parameters.Identities.Add(new LogOnIdentity(userKeyPairs, Passphrase.Empty));
+            parameters.Identities.Add(new LogOnIdentity(decryptedKeyPairs, Passphrase.Empty));
         }
+
         if (parameters.Arg2.Length == 0)
         {
             return null;
         }
-
-        EmailAddress mainUserEmail = parameters.Identities
-            .FirstOrDefault(i => i.UserEmail != EmailAddress.Empty)?.UserEmail ?? EmailAddress.Empty;
-        string userEmail = mainUserEmail == EmailAddress.Empty
-            ? userAccounts.Accounts.First().UserName : mainUserEmail.Address;
+        if (!statusChanged)
+        {
+            // Ensure idempotency
+            return userAccounts;
+        }
 
         UserAccount reEncryptedAccount = new UserAccount(userEmail)
         {
@@ -149,14 +182,14 @@ private static Status RealAsyncInternal(Parameters parameters)
             Tag = null!,
             Signature = null!,
         };
-        Passphrase firstPassphrase = parameters.Identities.First(i => i.Passphrase != Passphrase.Empty).Passphrase;
-        foreach (UserKeyPair keyPair in userKeyPairs)
+        foreach (UserKeyPair keyPair in decryptedKeyPairs)
         {
-            reEncryptedAccount.AccountKeys.Add(keyPair.ToAccountKey(firstPassphrase));
+            reEncryptedAccount.AccountKeys.Add(keyPair.ToAccountKey(reEncryptionPassphrase));
         }
         foreach (AccountKey key in nonDecryptableAccountKeys)
         {
             key.Status = PrivateKeyStatus.PassphraseUnknown;
+            key.User = userEmail;
             reEncryptedAccount.AccountKeys.Add(key);
         }
         UserAccounts reEncryptedAccounts = new()