Merge pull request #124 from initsuj/Indev

Add session caching by initsuj

MinecraftClient/Cache/CacheType.cs

@@ -0,0 +1,4 @@
+namespace MinecraftClient.Cache
+{
+    public enum CacheType { NONE, MEMORY, DISK };
+}

MinecraftClient/Cache/SessionCache.cs

@@ -0,0 +1,174 @@
+using MinecraftClient.Protocol;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Timers;
+
+namespace MinecraftClient.Cache
+{
+    /// <summary>
+    /// Handle sessions caching and storage.
+    /// </summary>
+     
+    public static class SessionCache
+    {
+        const string filename = "cache.bin";
+        private static Dictionary<string, SessionToken> sessions = new Dictionary<string, SessionToken>();
+        private static FileSystemWatcher cachemonitor = new FileSystemWatcher();
+        private static Timer updatetimer = new Timer(100);
+        private static List<KeyValuePair<string, SessionToken>> pendingadds = new List<KeyValuePair<string, SessionToken>>();
+
+        private static BinaryFormatter formatter = new BinaryFormatter();
+
+        /// <summary>
+        /// Retrieve whether SessionCache contains a session for the given login.
+        /// </summary>
+        /// <param name="login">User login used with Minecraft.net</param>
+        /// <returns>TRUE if session is available</returns>
+
+        public static bool Contains(string login)
+        {
+            return sessions.ContainsKey(login);
+        }
+
+        /// <summary>
+        /// Store a session and save it to disk if required.
+        /// </summary>
+        /// <param name="login">User login used with Minecraft.net</param>
+        /// <param name="session">User session token used with Minecraft.net</param>
+
+        public static void Store(string login, SessionToken session)
+        {
+            if (Contains(login))
+            {
+                sessions[login] = session;
+            }
+            else
+            {
+                sessions.Add(login, session);
+            }
+
+            if (Settings.CacheType == CacheType.DISK && updatetimer.Enabled == true) {
+                pendingadds.Add(new KeyValuePair<string, SessionToken>(login, session));
+            }else if (Settings.CacheType == CacheType.DISK)
+            {
+                SaveToDisk();
+            }
+        }
+
+        /// <summary>
+        /// Retrieve a session token for the given login.
+        /// </summary>
+        /// <param name="login">User login used with Minecraft.net</param>
+        /// <returns>SessionToken for given login</returns>
+
+        public static SessionToken Get(string login)
+        {
+            return sessions[login];
+        }
+
+        /// <summary>
+        /// Initialize cache monitoring to keep cache updated with external changes.
+        /// </summary>
+        /// <returns>TRUE if session tokens are seeded from file</returns>
+
+        public static bool InitializeDiskCache()
+        {
+            cachemonitor.Path = AppDomain.CurrentDomain.BaseDirectory;
+            cachemonitor.IncludeSubdirectories = false;
+            cachemonitor.Filter = filename;
+            cachemonitor.NotifyFilter = NotifyFilters.LastWrite;
+            cachemonitor.Changed += new FileSystemEventHandler(OnChanged);
+            cachemonitor.EnableRaisingEvents = true;
+
+            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 sessions back.
+        /// </summary>
+        /// <param name="sender">Sender</param>
+        /// <param name="e">Event data</param>
+
+        private static void HandlePending(object sender, ElapsedEventArgs e)
+        {
+            LoadFromDisk();
+
+            foreach(KeyValuePair<string, SessionToken> pending in pendingadds.ToArray())
+            {
+                Store(pending.Key, pending.Value);
+                pendingadds.Remove(pending);
+            }
+        }
+
+        /// <summary>
+        /// Reads cache file and loads SessionTokens into SessionCache.
+        /// </summary>
+        /// <returns>True if data is successfully loaded</returns>
+
+        private static bool LoadFromDisk()
+        {
+            if (File.Exists(filename))
+            {
+                try
+                {
+                    using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
+                    {
+                        sessions = (Dictionary<string, SessionToken>)formatter.Deserialize(fs);
+                        return true;
+                    }
+                }
+                catch (IOException ex)
+                {
+                    Console.WriteLine("Error reading cached sessions from disk: " + ex.Message);
+                }
+                catch (SerializationException)
+                {
+                    Console.WriteLine("Malformed sessions from cache file ");
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Saves SessionToken's from SessionCache into cache file.
+        /// </summary>
+
+        private static void SaveToDisk()
+        {
+            bool fileexists = File.Exists(filename);
+
+            using (FileStream fs = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
+            {
+                cachemonitor.EnableRaisingEvents = false;
+
+                // delete existing file contents
+                if (fileexists)
+                {
+                    fs.SetLength(0);
+                    fs.Flush();
+                }
+
+                formatter.Serialize(fs, sessions);
+                cachemonitor.EnableRaisingEvents = true;
+            }
+
+        }
+    }
+}

MinecraftClient/MinecraftClient.csproj

@@ -63,6 +63,7 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
+    <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -72,6 +73,8 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AutoTimeout.cs" />
+    <Compile Include="Cache\CacheType.cs" />
+    <Compile Include="Cache\SessionCache.cs" />
     <Compile Include="ChatBots\Alerts.cs" />
     <Compile Include="ChatBots\AntiAFK.cs" />
     <Compile Include="ChatBots\AutoRespond.cs" />
@@ -148,6 +151,7 @@
     <Compile Include="Protocol\IMinecraftCom.cs" />
     <Compile Include="Protocol\IMinecraftComHandler.cs" />
     <Compile Include="Protocol\ProtocolHandler.cs" />
+    <Compile Include="Protocol\SessionToken.cs" />
     <Compile Include="Proxy\ProxyHandler.cs" />
     <Compile Include="Proxy\Handlers\EventArgs\CreateConnectionAsyncCompletedEventArgs.cs" />
     <Compile Include="Proxy\Handlers\Exceptions\ProxyException.cs" />

MinecraftClient/Program.cs

@@ -85,6 +85,12 @@ namespace MinecraftClient
                 Console.Title = Settings.ExpandVars(Settings.ConsoleTitle);
             }
 
+            //Load cached sessions from disk if necessary
+            if (Settings.CacheType == Cache.CacheType.DISK)
+            {
+                Console.WriteLine(Cache.SessionCache.InitializeDiskCache() ? "Cached sessions loaded." : "Cached sessions could not be loaded from disk");
+            }
+
             //Asking the user to type in missing data such as Username and Password
 
             if (Settings.Login == "")
@@ -92,57 +98,91 @@ namespace MinecraftClient
                 Console.Write(ConsoleIO.basicIO ? "Please type the username of your choice.\n" : "Username : ");
                 Settings.Login = Console.ReadLine();
             }
-            if (Settings.Password == "")
+            if (Settings.Password == "" && (Settings.CacheType == Cache.CacheType.NONE || !Cache.SessionCache.Contains(Settings.Login)))
             {
-                Console.Write(ConsoleIO.basicIO ? "Please type the password for " + Settings.Login + ".\n" : "Password : ");
+                RequestPassword();
-                Settings.Password = ConsoleIO.basicIO ? Console.ReadLine() : ConsoleIO.ReadPassword();
-                if (Settings.Password == "") { Settings.Password = "-"; }
-                if (!ConsoleIO.basicIO)
-                {
-                    //Hide password length
-                    Console.CursorTop--; Console.Write("Password : <******>");
-                    for (int i = 19; i < Console.BufferWidth; i++) { Console.Write(' '); }
-                }
             }
 
             startupargs = args;
             InitializeClient();
         }
 
+        /// <summary>
+        /// Reduest user to submit password.
+        /// </summary>
+        private static void RequestPassword()
+        {
+            Console.Write(ConsoleIO.basicIO ? "Please type the password for " + Settings.Login + ".\n" : "Password : ");
+            Settings.Password = ConsoleIO.basicIO ? Console.ReadLine() : ConsoleIO.ReadPassword();
+            if (Settings.Password == "") { Settings.Password = "-"; }
+            if (!ConsoleIO.basicIO)
+            {
+                //Hide password length
+                Console.CursorTop--; Console.Write("Password : <******>");
+                for (int i = 19; i < Console.BufferWidth; i++) { Console.Write(' '); }
+            }
+        }
+
         /// <summary>
         /// Start a new Client
         /// </summary>
 
         private static void InitializeClient()
         {
-            ProtocolHandler.LoginResult result;
+            SessionToken session = new SessionToken();
-            Settings.Username = Settings.Login;
+
-            string sessionID = "";
+            ProtocolHandler.LoginResult result = ProtocolHandler.LoginResult.LoginRequired;
-            string UUID = "";
 
             if (Settings.Password == "-")
             {
                 ConsoleIO.WriteLineFormatted("§8You chose to run in offline mode.");
                 result = ProtocolHandler.LoginResult.Success;
-                sessionID = "0";
+                session.PlayerID = "0";
+                session.PlayerName = Settings.Login;
             }
             else
             {
-                Console.WriteLine("Connecting to Minecraft.net...");
+                // Validate cached session or login new session.
-                result = ProtocolHandler.GetLogin(ref Settings.Username, Settings.Password, ref sessionID, ref UUID);
+                if (Settings.CacheType != Cache.CacheType.NONE && Cache.SessionCache.Contains(Settings.Login))
+                {
+                    session = Cache.SessionCache.Get(Settings.Login);
+                    result = ProtocolHandler.GetTokenValidation(session);
+
+                    if (result != ProtocolHandler.LoginResult.Success && Settings.Password == "")
+                    {
+                        RequestPassword();
+                    }
+
+                    Console.WriteLine("Cached session is " + (result == ProtocolHandler.LoginResult.Success ? "valid." : "invalid."));
+
+                }
+
+                if (result != ProtocolHandler.LoginResult.Success)
+                {
+                    Console.WriteLine("Connecting to Minecraft.net...");
+                    result = ProtocolHandler.GetLogin(Settings.Login, Settings.Password, out session);
+
+                    if (result == ProtocolHandler.LoginResult.Success && Settings.CacheType != Cache.CacheType.NONE)
+                    {
+                        Cache.SessionCache.Store(Settings.Login, session);
+                    }
+                }
+
             }
 
             if (result == ProtocolHandler.LoginResult.Success)
             {
+                Settings.Username = session.PlayerName;
+
                 if (Settings.ConsoleTitle != "")
                     Console.Title = Settings.ExpandVars(Settings.ConsoleTitle);
 
                 if (Settings.playerHeadAsIcon)
                     ConsoleIcon.setPlayerIconAsync(Settings.Username);
 
-                Console.WriteLine("Success. (session ID: " + sessionID + ')');
+                Console.WriteLine("Success. (session ID: " + session.ID + ')');
 
-                //ProtocolHandler.RealmsListWorlds(Settings.Username, UUID, sessionID); //TODO REMOVE
+                //ProtocolHandler.RealmsListWorlds(Settings.Username, PlayerID, sessionID); //TODO REMOVE
 
                 if (Settings.ServerIP == "")
                 {
@@ -193,9 +233,9 @@ namespace MinecraftClient
                         //Start the main TCP client
                         if (Settings.SingleCommand != "")
                         {
-                            Client = new McTcpClient(Settings.Username, UUID, sessionID, Settings.ServerIP, Settings.ServerPort, protocolversion, forgeInfo, Settings.SingleCommand);
+                            Client = new McTcpClient(session.PlayerName, session.PlayerID, session.ID, Settings.ServerIP, Settings.ServerPort, protocolversion, forgeInfo, Settings.SingleCommand);
                         }
-                        else Client = new McTcpClient(Settings.Username, UUID, sessionID, protocolversion, forgeInfo, Settings.ServerIP, Settings.ServerPort);
+                        else Client = new McTcpClient(session.PlayerName, session.PlayerID, session.ID, protocolversion, forgeInfo, Settings.ServerIP, Settings.ServerPort);
 
                         //Update console title
                         if (Settings.ConsoleTitle != "")

MinecraftClient/Protocol/ProtocolHandler.cs

@@ -8,6 +8,7 @@ using System.Net.Sockets;
 using System.Net.Security;
 using MinecraftClient.Protocol.Handlers.Forge;
 
+
 namespace MinecraftClient.Protocol
 {
     /// <summary>
@@ -140,7 +141,7 @@ namespace MinecraftClient.Protocol
             }
         }
 
-        public enum LoginResult { OtherError, ServiceUnavailable, SSLError, Success, WrongPassword, AccountMigrated, NotPremium };
+        public enum LoginResult { OtherError, ServiceUnavailable, SSLError, Success, WrongPassword, AccountMigrated, NotPremium, LoginRequired, InvalidToken, NullError };
 
         /// <summary>
         /// Allows to login to a premium Minecraft account using the Yggdrasil authentication scheme.
@@ -148,15 +149,19 @@ namespace MinecraftClient.Protocol
         /// <param name="user">Login</param>
         /// <param name="pass">Password</param>
         /// <param name="accesstoken">Will contain the access token returned by Minecraft.net, if the login is successful</param>
-        /// <param name="uuid">Will contain the player's UUID, needed for multiplayer</param>
+        /// <param name="clienttoken">Will contain the client token generated before sending to Minecraft.net</param>
+        /// <param name="uuid">Will contain the player's PlayerID, needed for multiplayer</param>
         /// <returns>Returns the status of the login (Success, Failure, etc.)</returns>
 
-        public static LoginResult GetLogin(ref string user, string pass, ref string accesstoken, ref string uuid)
+        public static LoginResult GetLogin(string user, string pass, out SessionToken session)
         {
+            session = new SessionToken() { ClientID = Guid.NewGuid().ToString().Replace("-", "") };
+
             try
             {
                 string result = "";
-                string json_request = "{\"agent\": { \"name\": \"Minecraft\", \"version\": 1 }, \"username\": \"" + jsonEncode(user) + "\", \"password\": \"" + jsonEncode(pass) + "\" }";
+
+                string json_request = "{\"agent\": { \"name\": \"Minecraft\", \"version\": 1 }, \"username\": \"" + jsonEncode(user) + "\", \"password\": \"" + jsonEncode(pass) + "\", \"clientToken\": \"" + jsonEncode(session.ClientID) + "\" }";
                 int code = doHTTPSPost("authserver.mojang.com", "/authenticate", json_request, ref result);
                 if (code == 200)
                 {
@@ -167,11 +172,11 @@ namespace MinecraftClient.Protocol
                     else
                     {
                         string[] temp = result.Split(new string[] { "accessToken\":\"" }, StringSplitOptions.RemoveEmptyEntries);
-                        if (temp.Length >= 2) { accesstoken = temp[1].Split('"')[0]; }
+                        if (temp.Length >= 2) { session.ID = temp[1].Split('"')[0]; }
                         temp = result.Split(new string[] { "name\":\"" }, StringSplitOptions.RemoveEmptyEntries);
-                        if (temp.Length >= 2) { user = temp[1].Split('"')[0]; }
+                        if (temp.Length >= 2) { session.PlayerName = temp[1].Split('"')[0]; }
                         temp = result.Split(new string[] { "availableProfiles\":[{\"id\":\"" }, StringSplitOptions.RemoveEmptyEntries);
-                        if (temp.Length >= 2) { uuid = temp[1].Split('"')[0]; }
+                        if (temp.Length >= 2) { session.PlayerID = temp[1].Split('"')[0]; }
                         return LoginResult.Success;
                     }
                 }
@@ -211,6 +216,90 @@ namespace MinecraftClient.Protocol
             }
         }
 
+        /// <summary>
+        /// Validates whether accessToken must be refreshed
+        /// </summary>
+        /// <param name="accesstoken">Will contain the cached access token previously returned by Minecraft.net</param>
+        /// <param name="clienttoken">Will contain the cached client token created on login</param>
+        /// <returns>Returns the status of the token (Valid, Invalid, etc.)</returns>
+        /// 
+        public static LoginResult GetTokenValidation(SessionToken session)
+        {
+            try
+            {
+                string result = "";
+                string json_request = "{\"accessToken\": \"" + jsonEncode(session.ID) + "\", \"clientToken\": \"" + jsonEncode(session.ClientID) + "\" }";
+                int code = doHTTPSPost("authserver.mojang.com", "/validate", json_request, ref result);
+                if (code == 204)
+                {
+                    return LoginResult.Success;
+                }
+                else if (code == 403)
+                {
+                    return LoginResult.LoginRequired;
+                }
+                else
+                {
+                    return LoginResult.OtherError;
+                }
+            }
+            catch
+            {
+                return LoginResult.OtherError;
+            }
+        }
+
+        /// <summary>
+        /// Refreshes invalid token
+        /// </summary>
+        /// <param name="user">Login</param>
+        /// <param name="accesstoken">Will contain the new access token returned by Minecraft.net, if the refresh is successful</param>
+        /// <param name="clienttoken">Will contain the client token generated before sending to Minecraft.net</param>
+        /// <param name="uuid">Will contain the player's PlayerID, needed for multiplayer</param>
+        /// <returns>Returns the status of the new token request (Success, Failure, etc.)</returns>
+        ///
+        public static LoginResult GetNewToken(SessionToken currentsession, out SessionToken newsession)
+        {
+            newsession = new SessionToken();
+            try
+            {
+                string result = "";
+                string json_request = "{ \"accessToken\": \"" + jsonEncode(currentsession.ID) + "\", \"clientToken\": \"" + jsonEncode(currentsession.ClientID) + "\", \"selectedProfile\": { \"id\": \"" + jsonEncode(currentsession.PlayerID) + "\", \"name\": \"" + jsonEncode(currentsession.PlayerName) + "\" } }";
+                int code = doHTTPSPost("authserver.mojang.com", "/refresh", json_request, ref result);
+                if (code == 200)
+                {
+                    if (result == null)
+                    {
+                        return LoginResult.NullError;
+                    }
+                    else {
+                        string[] temp = result.Split(new string[] { "accessToken\":\"" }, StringSplitOptions.RemoveEmptyEntries);
+                        if (temp.Length >= 2) { newsession.ID = temp[1].Split('"')[0]; }
+                        temp = result.Split(new string[] { "clientToken\":\"" }, StringSplitOptions.RemoveEmptyEntries);
+                        if (temp.Length >= 2) { newsession.ClientID = temp[1].Split('"')[0]; }
+                        temp = result.Split(new string[] { "name\":\"" }, StringSplitOptions.RemoveEmptyEntries);
+                        if (temp.Length >= 2) { newsession.PlayerName = temp[1].Split('"')[0]; }
+                        temp = result.Split(new string[] { "selectedProfile\":[{\"id\":\"" }, StringSplitOptions.RemoveEmptyEntries);
+                        if (temp.Length >= 2) { newsession.PlayerID = temp[1].Split('"')[0]; }
+                        return LoginResult.Success;
+                    }
+                }
+                else if (code == 403 && result.Contains("InvalidToken"))
+                {
+                    return LoginResult.InvalidToken;
+                }
+                else
+                {
+                    ConsoleIO.WriteLineFormatted("§8Got error code from server while refreshing authentication: " + code);
+                    return LoginResult.OtherError;
+                }
+            }
+            catch
+            {
+                return LoginResult.OtherError;
+            }
+        }
+
         /// <summary>
         /// Check session using Mojang's Yggdrasil authentication scheme. Allows to join an online-mode server
         /// </summary>

MinecraftClient/Protocol/SessionToken.cs

@@ -0,0 +1,14 @@
+using System;
+
+
+namespace MinecraftClient.Protocol
+{
+    [Serializable]
+    public class SessionToken
+    {
+        public string ID { get; set; } = string.Empty;
+        public string PlayerName { get; set; } = string.Empty;
+        public string PlayerID { get; set; } = string.Empty;
+        public string ClientID { get; set; } = string.Empty;
+    }
+}

MinecraftClient/Settings.cs

@@ -29,6 +29,9 @@ namespace MinecraftClient
         public static string SingleCommand = "";
         public static string ConsoleTitle = "";
 
+        //Cache Settings
+        public static Cache.CacheType CacheType = Cache.CacheType.NONE;
+
         //Proxy Settings
         public static bool ProxyEnabledLogin = false;
         public static bool ProxyEnabledIngame = false;
@@ -200,6 +203,12 @@ namespace MinecraftClient
                                                     }
                                                     break;
 
+                                                case "accountcache":
+                                                    if (argValue == "none") { CacheType = Cache.CacheType.NONE; }
+                                                    else if (argValue == "memory") { CacheType = Cache.CacheType.MEMORY; }
+                                                    else if (argValue == "disk") { CacheType = Cache.CacheType.DISK; }
+                                                    break;
+
                                                 case "accountlist":
                                                     if (File.Exists(argValue))
                                                     {
@@ -416,6 +425,7 @@ namespace MinecraftClient
                 + "showsystemmessages=true #system messages for server ops\r\n"
                 + "showxpbarmessages=true #messages displayed above xp bar\r\n"
                 + "terrainandmovements=false #uses more ram, cpu, bandwidth\r\n"
+                + "accountcache=none #use 'none', 'memory' or 'disk'\r\n"
                 + "accountlist=accounts.txt\r\n"
                 + "serverlist=servers.txt\r\n"
                 + "playerheadicon=true\r\n"