Basic support for minecraft 1.19 (#2084)

* merge commit from milutinke
* chat signature & encrypted login
* Bug fix :EncryptionResponse format error below 1.18.2
* Implemented chat command signature
* Chat message parsing and verification for 1.19
* Add signature settings
* Update Simplified Chinese Translation
* Clear up comments
* Fix wrong variable naming
* Bug fix: SignatureV2 Processing

MinecraftClient/Protocol/ProfileKey/KeysCache.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Timers;
+using MinecraftClient.Protocol.Session;
+
+namespace MinecraftClient.Protocol.Keys
+{
+    /// <summary>
+    /// Handle keys caching and storage.
+    /// </summary>
+    public static class KeysCache
+    {
+        private const string KeysCacheFilePlaintext = "ProfileKeyCache.ini";
+
+        private static FileMonitor cachemonitor;
+        private static Dictionary<string, PlayerKeyPair> keys = new Dictionary<string, PlayerKeyPair>();
+        private static Timer updatetimer = new Timer(100);
+        private static List<KeyValuePair<string, PlayerKeyPair>> pendingadds = new List<KeyValuePair<string, PlayerKeyPair>>();
+        private static BinaryFormatter formatter = new BinaryFormatter();
+
+        /// <summary>
+        /// Retrieve whether KeysCache contains a keys for the given login.
+        /// </summary>
+        /// <param name="login">User login used with Minecraft.net</param>
+        /// <returns>TRUE if keys are available</returns>
+        public static bool Contains(string login)
+        {
+            return keys.ContainsKey(login);
+        }
+
+        /// <summary>
+        /// Store keys and save it to disk if required.
+        /// </summary>
+        /// <param name="login">User login used with Minecraft.net</param>
+        /// <param name="playerKeyPair">User keys</param>
+        public static void Store(string login, PlayerKeyPair playerKeyPair)
+        {
+            if (Contains(login))
+            {
+                keys[login] = playerKeyPair;
+            }
+            else
+            {
+                keys.Add(login, playerKeyPair);
+            }
+
+            if (Settings.ProfileKeyCaching == CacheType.Disk && updatetimer.Enabled == true)
+            {
+                pendingadds.Add(new KeyValuePair<string, PlayerKeyPair>(login, playerKeyPair));
+            }
+            else if (Settings.ProfileKeyCaching == CacheType.Disk)
+            {
+                SaveToDisk();
+            }
+        }
+
+        /// <summary>
+        /// Retrieve keys for the given login.
+        /// </summary>
+        /// <param name="login">User login used with Minecraft.net</param>
+        /// <returns>PlayerKeyPair for given login</returns>
+        public static PlayerKeyPair Get(string login)
+        {
+            return keys[login];
+        }
+
+        /// <summary>
+        /// Initialize cache monitoring to keep cache updated with external changes.
+        /// </summary>
+        /// <returns>TRUE if keys are seeded from file</returns>
+        public static bool InitializeDiskCache()
+        {
+            cachemonitor = new FileMonitor(AppDomain.CurrentDomain.BaseDirectory, KeysCacheFilePlaintext, new FileSystemEventHandler(OnChanged));
+            updatetimer.Elapsed += HandlePending;
+            return LoadFromDisk();
+        }
+
+        /// <summary>
+        /// Reloads cache on external cache file change.
+        /// </summary>
+        /// <param name="sender">Sender</param>
+        /// <param name="e">Event data</param>
+        private static void OnChanged(object sender, FileSystemEventArgs e)
+        {
+            updatetimer.Stop();
+            updatetimer.Start();
+        }
+
+        /// <summary>
+        /// Called after timer elapsed. Reads disk cache and adds new/modified keys back.
+        /// </summary>
+        /// <param name="sender">Sender</param>
+        /// <param name="e">Event data</param>
+        private static void HandlePending(object sender, ElapsedEventArgs e)
+        {
+            updatetimer.Stop();
+            LoadFromDisk();
+
+            foreach (KeyValuePair<string, PlayerKeyPair> pending in pendingadds.ToArray())
+            {
+                Store(pending.Key, pending.Value);
+                pendingadds.Remove(pending);
+            }
+        }
+
+        /// <summary>
+        /// Reads cache file and loads KeysInfos into KeysCache.
+        /// </summary>
+        /// <returns>True if data is successfully loaded</returns>
+        private static bool LoadFromDisk()
+        {
+            //User-editable keys cache file in text format
+            if (File.Exists(KeysCacheFilePlaintext))
+            {
+                if (Settings.DebugMessages)
+                    ConsoleIO.WriteLineFormatted(Translations.Get("cache.loading_keys", KeysCacheFilePlaintext));
+
+                try
+                {
+                    foreach (string line in FileMonitor.ReadAllLinesWithRetries(KeysCacheFilePlaintext))
+                    {
+                        if (!line.Trim().StartsWith("#"))
+                        {
+
+                            int separatorIdx = line.IndexOf('=');
+                            if (separatorIdx >= 1 && line.Length > separatorIdx + 1)
+                            {
+                                string login = line.Substring(0, separatorIdx);
+                                string value = line.Substring(separatorIdx + 1);
+                                try
+                                {
+                                    PlayerKeyPair playerKeyPair = PlayerKeyPair.FromString(value);
+                                    keys[login] = playerKeyPair;
+                                    if (Settings.DebugMessages)
+                                        ConsoleIO.WriteLineFormatted(Translations.Get("cache.loaded_keys", playerKeyPair.ExpiresAt.ToString()));
+                                }
+                                catch (InvalidDataException e)
+                                {
+                                    if (Settings.DebugMessages)
+                                        ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_string_keys", value, e.Message));
+                                }
+                                catch (FormatException e)
+                                {
+                                    if (Settings.DebugMessages)
+                                        ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_string_keys", value, e.Message));
+                                }
+                                catch (ArgumentNullException e)
+                                {
+                                    if (Settings.DebugMessages)
+                                        ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_string_keys", value, e.Message));
+
+                                }
+                            }
+                            else if (Settings.DebugMessages)
+                            {
+                                ConsoleIO.WriteLineFormatted(Translations.Get("cache.ignore_line_keys", line));
+                            }
+                        }
+                    }
+                }
+                catch (IOException e)
+                {
+                    ConsoleIO.WriteLineFormatted(Translations.Get("cache.read_fail_plain_keys", e.Message));
+                }
+            }
+
+            return keys.Count > 0;
+        }
+
+        /// <summary>
+        /// Saves player's keypair from KeysCache into cache file.
+        /// </summary>
+        private static void SaveToDisk()
+        {
+            if (Settings.DebugMessages)
+                Translations.WriteLineFormatted("cache.saving_keys");
+
+            List<string> KeysCacheLines = new List<string>();
+            KeysCacheLines.Add("# Generated by MCC v" + Program.Version + " - Keep it secret & Edit at own risk!");
+            KeysCacheLines.Add("# ProfileKey=PublicKey(base64),PublicKeySignature(base64),PublicKeySignatureV2(base64),PrivateKey(base64),ExpiresAt,RefreshAfter");
+            foreach (KeyValuePair<string, PlayerKeyPair> entry in keys)
+                KeysCacheLines.Add(entry.Key + '=' + entry.Value.ToString());
+
+            try
+            {
+                FileMonitor.WriteAllLinesWithRetries(KeysCacheFilePlaintext, KeysCacheLines);
+            }
+            catch (IOException e)
+            {
+                ConsoleIO.WriteLineFormatted(Translations.Get("cache.save_fail_keys", e.Message));
+            }
+        }
+    }
+}