Major changes

Refactorings:
  * BinaryCollector -> BitWriter
  * BinaryDistributor -> BitReader

Additions:
  * Output class for making serverside output pretty and more readable
  * Better RSA keys (private keys withheld)

Changes:
  * Minor changes to all views and their rendering
  * Added corrective resizing to resize listener to prevent errant window sizes
  * Removed "default" language in favour of a purely priority-based system
  * NetContext now attempts to verify server identity before continuing to next context
  * Simplified common operations in Context
  * Minor updates to some layouts
  * Completed translations for english and swedish
  * Promise system now supports internal processing before notifying original caller
  * Bank interactor methods are now async
  * Added support for multiple accounts per user (separate repositories for money)
  * Removed test code from client program
  * Updated Database to support multiple accounts
  * Reimplemented RSA on the server side purely as an identity verification system on top of the networking layer (rather than part of the layer)
  * Added Account management endpoints
  * Added full support for System-sourced transactions
  * Added Account availability endpoint
  * Added verbose error responses

.gitignore

@@ -12,3 +12,6 @@
 /Server/Resources/0x200.d
 /Server/bin
 /Server/obj
+/Server/Resources/0x100.d
+/Server/Resources/0x100.e
+/Server/Resources/0x100.n

Bank.sln

@@ -10,6 +10,9 @@ EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Common", "Common\Common.csproj", "{23EB87D4-E310-48C4-A931-0961C83892D7}"
 EndProject
 Global
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU

Client.psess

@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VSPerformanceSession Version="1.00">
+  <Options>
+    <Solution>Bank.sln</Solution>
+    <CollectionMethod>Sampling</CollectionMethod>
+    <AllocationMethod>None</AllocationMethod>
+    <AddReport>true</AddReport>
+    <ResourceBasedAnalysisSelected>true</ResourceBasedAnalysisSelected>
+    <UniqueReport>Timestamp</UniqueReport>
+    <SamplingMethod>Cycles</SamplingMethod>
+    <CycleCount>10000000</CycleCount>
+    <PageFaultCount>10</PageFaultCount>
+    <SysCallCount>10</SysCallCount>
+    <SamplingCounter Name="" ReloadValue="00000000000f4240" DisplayName="" />
+    <RelocateBinaries>false</RelocateBinaries>
+    <HardwareCounters EnableHWCounters="false" />
+    <EtwSettings />
+    <PdhSettings>
+      <PdhCountersEnabled>false</PdhCountersEnabled>
+      <PdhCountersRate>500</PdhCountersRate>
+      <PdhCounters>
+        <PdhCounter>\Memory\Pages/sec</PdhCounter>
+        <PdhCounter>\PhysicalDisk(_Total)\Avg. Disk Queue Length</PdhCounter>
+        <PdhCounter>\Processor(_Total)\% Processor Time</PdhCounter>
+      </PdhCounters>
+    </PdhSettings>
+  </Options>
+  <ExcludeSmallFuncs>true</ExcludeSmallFuncs>
+  <InteractionProfilingEnabled>false</InteractionProfilingEnabled>
+  <JScriptProfilingEnabled>false</JScriptProfilingEnabled>
+  <PreinstrumentEvent>
+    <InstrEventExclude>false</InstrEventExclude>
+  </PreinstrumentEvent>
+  <PostinstrumentEvent>
+    <InstrEventExclude>false</InstrEventExclude>
+  </PostinstrumentEvent>
+  <Binaries>
+    <ProjBinary>
+      <Path>Client\obj\Release\Client.exe</Path>
+      <ArgumentTimestamp>01/01/0001 00:00:00</ArgumentTimestamp>
+      <Instrument>true</Instrument>
+      <Sample>true</Sample>
+      <ExternalWebsite>false</ExternalWebsite>
+      <InteractionProfilingEnabled>false</InteractionProfilingEnabled>
+      <IsLocalJavascript>false</IsLocalJavascript>
+      <IsWindowsStoreApp>false</IsWindowsStoreApp>
+      <IsWWA>false</IsWWA>
+      <LaunchProject>true</LaunchProject>
+      <OverrideProjectSettings>false</OverrideProjectSettings>
+      <LaunchMethod>Executable</LaunchMethod>
+      <ExecutablePath>Client\bin\Release\Client.exe</ExecutablePath>
+      <StartupDirectory>Client\bin\Release\</StartupDirectory>
+      <Arguments>
+      </Arguments>
+      <NetAppHost>IIS</NetAppHost>
+      <NetBrowser>InternetExplorer</NetBrowser>
+      <ExcludeSmallFuncs>true</ExcludeSmallFuncs>
+      <JScriptProfilingEnabled>false</JScriptProfilingEnabled>
+      <PreinstrumentEvent>
+        <InstrEventExclude>false</InstrEventExclude>
+      </PreinstrumentEvent>
+      <PostinstrumentEvent>
+        <InstrEventExclude>false</InstrEventExclude>
+      </PostinstrumentEvent>
+      <ProjRef>{2236D5D4-7816-4630-8C86-0F0BDD46D7D8}|Client\Client.csproj</ProjRef>
+      <ProjPath>Client\Client.csproj</ProjPath>
+      <ProjName>Client</ProjName>
+    </ProjBinary>
+    <ProjBinary>
+      <Path>Server\obj\Release\Server.exe</Path>
+      <ArgumentTimestamp>01/01/0001 00:00:00</ArgumentTimestamp>
+      <Instrument>true</Instrument>
+      <Sample>true</Sample>
+      <ExternalWebsite>false</ExternalWebsite>
+      <InteractionProfilingEnabled>false</InteractionProfilingEnabled>
+      <IsLocalJavascript>false</IsLocalJavascript>
+      <IsWindowsStoreApp>false</IsWindowsStoreApp>
+      <IsWWA>false</IsWWA>
+      <LaunchProject>true</LaunchProject>
+      <OverrideProjectSettings>false</OverrideProjectSettings>
+      <LaunchMethod>Executable</LaunchMethod>
+      <ExecutablePath>Server\bin\Release\Server.exe</ExecutablePath>
+      <StartupDirectory>Server\bin\Release\</StartupDirectory>
+      <Arguments>
+      </Arguments>
+      <NetAppHost>IIS</NetAppHost>
+      <NetBrowser>InternetExplorer</NetBrowser>
+      <ExcludeSmallFuncs>true</ExcludeSmallFuncs>
+      <JScriptProfilingEnabled>false</JScriptProfilingEnabled>
+      <PreinstrumentEvent>
+        <InstrEventExclude>false</InstrEventExclude>
+      </PreinstrumentEvent>
+      <PostinstrumentEvent>
+        <InstrEventExclude>false</InstrEventExclude>
+      </PostinstrumentEvent>
+      <ProjRef>{B458552A-5884-4B27-BA6B-826BC5590106}|Server\Server.csproj</ProjRef>
+      <ProjPath>Server\Server.csproj</ProjPath>
+      <ProjName>Server</ProjName>
+    </ProjBinary>
+  </Binaries>
+  <Reports>
+    <Report>
+      <Path>Client180412.vspx</Path>
+    </Report>
+  </Reports>
+  <Launches>
+    <ProjBinary>
+      <Path>:PB:{2236D5D4-7816-4630-8C86-0F0BDD46D7D8}|Client\Client.csproj</Path>
+    </ProjBinary>
+    <ProjBinary>
+      <Path>:PB:{B458552A-5884-4B27-BA6B-826BC5590106}|Server\Server.csproj</Path>
+    </ProjBinary>
+  </Launches>
+</VSPerformanceSession>

Client/Client.csproj

@@ -80,6 +80,8 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="Resources\0x100.e" />
+    <None Include="Resources\0x100.n" />
     <None Include="Resources\0x200.e" />
     <None Include="Resources\0x200.n" />
   </ItemGroup>

Client/ConsoleForms/ConsoleController.cs

@@ -49,6 +49,12 @@ namespace Client.ConsoleForms
             if (resizeListener) EnableResizeListener();
             RegisterListener((w, h) =>
             {
+                // Corrective resizing to prevent rendering issues
+                if (w < 20 || h < 20)
+                {
+                    Console.SetWindowSize(Math.Max(w, 60), Math.Max(h, 40));
+                    return;
+                }
                 width = w;
                 height = h;
                 Draw();
@@ -56,6 +62,9 @@ namespace Client.ConsoleForms
 
             RegisterListener((w1, h1, w2, h2) =>
             {
+                // Corrective resizing to prevent rendering issues
+                if (w2 < 20 || h2 < 20)
+                    Console.SetWindowSize(Math.Max(w2, 60), Math.Max(h2, 40));
                 Console.BackgroundColor = ConsoleColor.Black;
                 Console.Clear();
             });

Client/ConsoleForms/Context.cs

@@ -53,5 +53,16 @@ namespace Client.ConsoleForms
                     ((DialogView)v).RegisterSelectListener(listener);
             }
         }
+        protected void Show(View v) => controller.AddView(v);
+        protected void Show(string viewID) => controller.AddView(views.GetNamed(viewID));
+        protected T GetView<T>(string viewID) where T : View => (T) views.GetNamed(viewID);
+        protected View GetView(string viewID) => views.GetNamed(viewID);
+        protected void Hide(string viewID) => controller.CloseView(views.GetNamed(viewID));
+        protected void Hide(View v) => controller.CloseView(v);
+        protected void HideAll()
+        {
+            foreach (var viewEntry in views)
+                Hide(viewEntry.Item2);
+        }
     }
 }

Client/ConsoleForms/Graphics/DialogView.cs

@@ -21,7 +21,7 @@ namespace Client.ConsoleForms.Graphics
             get => select;
             set => select = value < 0 ? 0 : value >= options.Length ? options.Length - 1 : value;
         }
-        public override Region Occlusion => new Region(new Rectangle(0, -1, ContentWidth + 2, ContentHeight + 2));
+        public override Region Occlusion => new Region(new Rectangle(-1, -1, ContentWidth + 4, ContentHeight + 2));
 
         public ConsoleColor SelectColor { get; set; }
         public ConsoleColor NotSelectColor { get; set; }
@@ -33,7 +33,7 @@ namespace Client.ConsoleForms.Graphics
             base(parameters.SetAttribute("width",
                 Math.Max(
                     parameters.AttribueAsInt("width") < 1 ? parameters.NestedText("Text").Length : parameters.AttribueAsInt("width"),
-                    ComputeLength(parameters.Get("Options").CollectSub("Option"))
+                    ComputeLength(parameters.Get("Options")?.CollectSub("Option") ?? new Tuple<string, string>[0])
                 )), lang)
         {
             ViewData optionsData = parameters.Get("Options");

Client/ConsoleForms/Graphics/InputView.cs

@@ -157,7 +157,7 @@ namespace Client.ConsoleForms.Graphics
                 computedSize += splitInputs[i].Length;
             }
             ContentHeight += computedSize + Inputs.Length * 2;
-            ++ContentWidth; // Idk, it works, though...
+            //++ContentWidth; // Idk, it works, though...
         }
 
         protected override void _Draw(int left, ref int top)

Client/ConsoleForms/Graphics/ListView.cs

@@ -13,7 +13,8 @@ namespace Client.ConsoleForms.Graphics
         public ConsoleColor SelectBackground { get; set; }
         public ConsoleColor SelectText { get; set; }
 
-        public override Region Occlusion => new Region(new Rectangle(0, 0, ContentWidth, ContentHeight));
+
+        public override Region Occlusion => new Region(new Rectangle(-padding.Left(), -padding.Top(), ContentWidth + padding.Right(), ContentHeight + padding.Bottom()));
 
         public ListView(ViewData parameters, LangManager lang) : base(parameters, lang)
         {
@@ -30,6 +31,7 @@ namespace Client.ConsoleForms.Graphics
                 if (limited && view.AttribueAsInt("width") > maxWidth) view.attributes["width"] = maxWidth.ToString();
 
                 Tuple<string, View> v = ConsoleController.LoadView(parameters.attributes["xmlns"], view, I18n); // Load the view in with standard namespace
+                v.Item2.DrawBorder = false;
                 innerViews.Add(v);
 
                 if (!limited) maxWidth = Math.Max(v.Item2.ContentWidth, maxWidth);

Client/ConsoleForms/Graphics/TextView.cs

@@ -36,7 +36,7 @@ namespace Client.ConsoleForms.Graphics
                 Dirty = true;
             }
         }
-        public override Region Occlusion => new Region(new Rectangle(0, DrawBorder ? -1 : 0, ContentWidth + (DrawBorder ? 2 : 0), ContentHeight));
+        public override Region Occlusion => new Region(new Rectangle(DrawBorder ? -1 : 0, DrawBorder ? -1 : 0, ContentWidth + (DrawBorder ? 3 : 0), ContentHeight));
 
         //public char Border { get; set; }
         //public ConsoleColor BorderColor { get; set; }

Client/ConsoleForms/Graphics/View.cs

@@ -39,7 +39,7 @@ namespace Client.ConsoleForms.Graphics
             BackgroundColor = (ConsoleColor)parameters.AttribueAsInt("color_background", (int)ConsoleColor.White);
             TextColor = (ConsoleColor)parameters.AttribueAsInt("color_text", (int)ConsoleColor.Black);
             Border = ' ';
-            DrawBorder = parameters.attributes.ContainsKey("border");
+            DrawBorder = true;// parameters.attributes.ContainsKey("border");
             I18n = lang;
 
             back_data = parameters.GetAttribute("back");
@@ -68,17 +68,17 @@ namespace Client.ConsoleForms.Graphics
         public virtual void _DrawBorder(int left, int top)
         {
             Console.BackgroundColor = BorderColor;
-            Console.SetCursorPosition(left, top - 1);
+            Console.SetCursorPosition(left - 1, top - 1);
-            Console.Write(Filler(Border, ContentWidth + 1));
+            Console.Write(Filler(Border, ContentWidth + 2));
             for (int i = -1; i < ContentHeight; ++i)
             {
-                Console.SetCursorPosition(left, top + i);
+                Console.SetCursorPosition(left-1, top + i);
                 Console.Write(Filler(Border, 2));
-                Console.SetCursorPosition(left + ContentWidth, top + i);
+                Console.SetCursorPosition(left + ContentWidth + 1, top + i);
                 Console.Write(Filler(Border, 2));
             }
-            Console.SetCursorPosition(left, top + ContentHeight);
+            Console.SetCursorPosition(left-1, top + ContentHeight);
-            Console.Write(Filler(Border, ContentWidth + 2));
+            Console.Write(Filler(Border, ContentWidth + 4));
             Console.BackgroundColor = ConsoleColor.Black;
         }
         protected abstract void _Draw(int left, ref int top);

Client/ConsoleForms/LangManager.cs

@@ -88,16 +88,18 @@ namespace Client.ConsoleForms
         {
             XmlDocument doc = new XmlDocument();
             doc.LoadXml(metaString);
-            XmlNode lang = doc.GetElementsByTagName("Lang").Item(0);
+            XmlNode lang = doc.GetElementsByTagName("Strings").Item(0);
             List<XmlElement> priorities = new List<XmlElement>();
             foreach(var node in lang.ChildNodes)
                 if (node is XmlElement el)
                 {
-                    if (el.Name.Equals("Default")) priorities.Insert(0, (XmlElement)node);
+                    //if (el.Name.Equals("Default")) priorities.Insert(0, (XmlElement)node);
-                    else if (el.Name.Equals("Fallback"))
+                    /*else*/ if (el.Name.Equals(/*"Fallback"*/"Lang"))
                     {
+                        if (priorities.Count == 0) priorities.Add(el);
+                        else
                             for (int i = 0; i < priorities.Count; ++i)
-                            if (!priorities[i].Name.Equals("Default") && ComparePriority(el, priorities[i]))
+                                if (/*!priorities[i].Name.Equals("Default") && */ComparePriority(el, priorities[i]))
                                 {
                                     priorities.Insert(i, el);
                                     break;
@@ -125,7 +127,7 @@ namespace Client.ConsoleForms
                     break;
                 }
 
-            // Use defults and fallbacks
+            // Use defaults and fallbacks
             for (int i = 0; i<priorities.Count; ++i)
             {
                 foreach (var prop in properties)

Client/Context/NetContext.cs

@@ -7,60 +7,86 @@ using System.Text;
 using System.Threading.Tasks;
 using Tofvesson.Collections;
 using Client.ConsoleForms.Graphics;
+using Tofvesson.Crypto;
+using Client.Properties;
 
 namespace Client
 {
     public class NetContext : Context
     {
+        private static readonly RandomProvider provider = new RegularRandomProvider();
         public NetContext(ContextManager manager) : base(manager, "Networking", "Common")
         {
             // Just close when anything is selected and "submitted"
             RegisterSelectListeners((s, i, v) => controller.CloseView(s), "EmptyFieldError", "IPError", "PortError", "ConnectionError");
 
-            ((InputView)views.GetNamed("NetConnect")).SubmissionsListener = i =>
+            bool connecting = false;
+
+            GetView<InputView>("NetConnect").SubmissionsListener = i =>
             {
+                if (connecting)
+                {
+                    controller.Popup("Already connecting!", 1000, ConsoleColor.DarkRed);
+                    return;
+                }
                 bool
                     ip = ParseIP(i.Inputs[0].Text) != null,
                     port = short.TryParse(i.Inputs[1].Text, out short prt) && prt > 0;
 
-
                 if (ip && port)
                 {
+                    connecting = true;
                     // Connect to server here
-                    BankNetInteractor ita = new BankNetInteractor(i.Inputs[0].Text, prt, false); // Don't do identity check for now
+                    BankNetInteractor ita = new BankNetInteractor(i.Inputs[0].Text, prt);
+                    /*
                     try
                     {
-                        var t = ita.Connect();
+                        //var t = ita.Connect();
-                        while (!t.IsCompleted)
+                        //while (!t.IsCompleted)
-                            if (t.IsCanceled || t.IsFaulted)
+                        //    if (t.IsCanceled || t.IsFaulted)
-                            {
+                        //    {
-                                controller.AddView(views.GetNamed("ConnectError"));
+                        //        Show("ConnectError");
-                                return;
+                        //        return;
-                            }
+                        //    }
+                        //    else System.Threading.Thread.Sleep(125);
                     }
                     catch
                     {
-                        controller.AddView(views.GetNamed("ConnectionError"));
+                        Show("ConnectionError");
+                        connecting = false;
                         return;
                     }
-                    manager.LoadContext(new WelcomeContext(manager, ita));
+                    */
+                    
+                    Promise verify = Promise.AwaitPromise(ita.CheckIdentity(new RSA(Resources.e_0x100, Resources.n_0x100), provider.NextUShort()));
+                    verify.Subscribe =
+                        p =>
+                        {
+                            void load() => manager.LoadContext(new WelcomeContext(manager, ita));
+
+                            // Add condition check for remote peer verification
+                            if (bool.Parse(p.Value)) controller.Popup("Server identity verified!", 1000, ConsoleColor.Green, load);
+                            else controller.Popup("Remote server identity could not be verified!", 5000, ConsoleColor.Red, load);
+                        };
+                    DialogView identityNotify = GetView<DialogView>("IdentityVerify");
+                    identityNotify.RegisterSelectListener(
+                        (vw, ix, nm) => {
+                            verify.Subscribe = null; // Clear subscription
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                            ita.CancelAll();
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                            connecting = false;
+                        });
+                    Show(identityNotify);
                 }
                 else if (i.Inputs[0].Text.Length == 0 || i.Inputs[1].Text.Length == 0) controller.AddView(views.GetNamed("EmptyFieldError"));
-                else if (!ip) controller.AddView(views.GetNamed("IPError"));
+                else if (!ip) Show("IPError");
-                else controller.AddView(views.GetNamed("PortError"));
+                else Show("PortError");
             };
         }
 
-        public override void OnCreate()
+        public override void OnCreate() => Show("NetConnect");
-        {
+        public override void OnDestroy() => HideAll();
-            controller.AddView(views.GetNamed("NetConnect"));
-        }
-
-        public override void OnDestroy()
-        {
-            foreach (var view in views)
-                controller.CloseView(view.Item2);
-        }
 
 
         //int gtrack = 0;

Client/Context/SessionContext.cs

@@ -1,5 +1,6 @@
 using Client.ConsoleForms;
 using Client.ConsoleForms.Graphics;
+using Client.Properties;
 using ConsoleForms;
 using System;
 using System.Collections.Generic;
@@ -7,6 +8,8 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Tofvesson.Collections;
+using Tofvesson.Common;
+using Tofvesson.Crypto;
 
 namespace Client
 {
@@ -20,24 +23,20 @@ namespace Client
             this.interactor = interactor;
             this.sessionID = sessionID;
 
-            ((DialogView)views.GetNamed("Success")).RegisterSelectListener((v, i, s) =>
+            GetView<DialogView>("Success").RegisterSelectListener((v, i, s) =>
             {
                 interactor.Logout(sessionID);
                 manager.LoadContext(new NetContext(manager));
             });
         }
 
-        public override void OnCreate()
+        public override void OnCreate() => Show("menu_options");
-        {
-            //controller.AddView(views.GetNamed("Success"));
-            controller.AddView(views.GetNamed("menu_options"));
-        }
 
         public override void OnDestroy()
         {
             controller.CloseView(views.GetNamed("Success"));
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            interactor.Disconnect();
+            interactor.CancelAll();
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
     }

Client/Context/WelcomeContext.cs

@@ -27,7 +27,7 @@ namespace Client
             RegisterSelectListeners((s, i, v) => controller.CloseView(s), "DuplicateAccountError", "EmptyFieldError", "IPError", "PortError", "AuthError", "PasswordMismatchError");
 
 
-            ((InputView)views.GetNamed("Login")).SubmissionsListener = i =>
+            GetView<InputView>("Login").SubmissionsListener = i =>
             {
                 bool success = true;
 
@@ -43,14 +43,16 @@ namespace Client
                 if (success)
                 {
                     // Authenticate against server here
-                    controller.AddView(views.GetNamed("AuthWait"));
+                    Show("AuthWait");
-                    promise = interactor.Authenticate(i.Inputs[0].Text, i.Inputs[1].Text);
+                    Task<Promise> prom = interactor.Authenticate(i.Inputs[0].Text, i.Inputs[1].Text);
+                    if(!prom.IsCompleted) prom.RunSynchronously();
+                    promise = prom.Result;
                     promise.Subscribe =
                     response =>
                     {
-                        controller.CloseView(views.GetNamed("AuthWait"));
+                        Hide("AuthWait");
                         if (response.Value.Equals("ERROR"))
-                            controller.AddView(views.GetNamed("AuthError"));
+                            Show("AuthError");
                         else
                         {
                             forceDestroy = false;
@@ -58,18 +60,18 @@ namespace Client
                         }
                     };
                 }
-                else controller.AddView(views.GetNamed("EmptyFieldError"));
+                else Show("EmptyFieldError");
             };
 
             // For a smooth effect
-            ((InputView)views.GetNamed("Login")).InputListener = (v, c, i) =>
+            GetView<InputView>("Login").InputListener = (v, c, i) =>
             {
                 c.BackgroundColor = v.DefaultBackgroundColor;
                 c.SelectBackgroundColor = v.DefaultSelectBackgroundColor;
                 return true;
             };
 
-            ((InputView)views.GetNamed("Register")).SubmissionsListener = i =>
+            GetView<InputView>("Register").SubmissionsListener = i =>
             {
                 bool success = true, mismatch = false;
 
@@ -88,14 +90,14 @@ namespace Client
                 {
                     void a()
                     {
-                        controller.AddView(views.GetNamed("RegWait"));
+                        Show("RegWait");
-                        promise = interactor.Register(i.Inputs[0].Text, i.Inputs[1].Text);
+                        promise = Promise.AwaitPromise(interactor.Register(i.Inputs[0].Text, i.Inputs[1].Text));
                         promise.Subscribe =
                         response =>
                         {
-                            controller.CloseView(views.GetNamed("RegWait"));
+                            Hide("RegWait");
                             if (response.Value.Equals("ERROR"))
-                                controller.AddView(views.GetNamed("DuplicateAccountError"));
+                                Show("DuplicateAccountError");
                             else
                             {
                                 forceDestroy = false;
@@ -106,18 +108,18 @@ namespace Client
 
                     if (i.Inputs[1].Text.Length < 5 || i.Inputs[1].Text.StartsWith("asdfasdf") || i.Inputs[1].Text.StartsWith("asdf1234"))
                     {
-                        var warning = (DialogView)views.GetNamed("WeakPasswordWarning");
+                        var warning = GetView<DialogView>("WeakPasswordWarning");
                         warning.RegisterSelectListener((wrn, idx, sel) =>
                         {
-                            controller.CloseView(warning);
+                            Hide(warning);
                             if (idx == 0) a();
                         });
-                        controller.AddView(warning);
+                        Show(warning);
                     }
                     else a();
                 }
-                else if (mismatch) controller.AddView(views.GetNamed("PasswordMismatchError"));
+                else if (mismatch) Show("PasswordMismatchError");
-                else controller.AddView(views.GetNamed("EmptyFieldError"));
+                else Show("EmptyFieldError");
             };
 
             ((InputView)views.GetNamed("Register")).InputListener = (v, c, i) =>
@@ -136,13 +138,13 @@ namespace Client
             });
 
             // Add the initial view
-            controller.AddView(views.GetNamed("WelcomeScreen"));
+            Show("WelcomeScreen");
         }
 
         public override void OnDestroy()
         {
-            ((InputView)views.GetNamed("Register")).SelectedField = 0;
+            GetView<InputView>("Register").SelectedField = 0;
-            foreach (var v in ((InputView)views.GetNamed("Register")).Inputs)
+            foreach (var v in GetView<InputView>("Register").Inputs)
             {
                 v.Text = "";
                 v.SelectIndex = 0;
@@ -150,7 +152,7 @@ namespace Client
             }
 
             ((InputView)views.GetNamed("Login")).SelectedField = 0;
-            foreach (var v in ((InputView)views.GetNamed("Login")).Inputs)
+            foreach (var v in GetView<InputView>("Login").Inputs)
             {
                 v.Text = "";
                 v.SelectIndex = 0;
@@ -158,8 +160,7 @@ namespace Client
             }
 
             // Close views
-            foreach (var view in views)
+            HideAll();
-                controller.CloseView(view.Item2);
 
             // Unsubscribe from events
             if (promise != null && !promise.HasValue) promise.Subscribe = null;
@@ -168,7 +169,7 @@ namespace Client
             interactor.UnregisterListener(token);
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            if (forceDestroy) interactor.Disconnect();
+            if (forceDestroy) interactor.CancelAll();
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
     }

Client/Networking.cs

@@ -3,9 +3,11 @@ using Common.Cryptography.KeyExchange;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
+using Tofvesson.Common;
 using Tofvesson.Crypto;
 
 namespace Client
@@ -17,52 +19,57 @@ namespace Client
 
         protected Dictionary<long, Promise> promises = new Dictionary<long, Promise>();
         protected NetClient client;
-        private bool authenticating = true, authenticated = false;
+        protected readonly IPAddress addr;
-        public bool Authenticating { get => authenticating; }
+        protected readonly short port;
-        public bool PeerIsAuthenticated { get => authenticated; }
+        protected readonly EllipticDiffieHellman keyExchange;
-        public RSA AuthenticatedKeys { get; private set; }
+        public bool IsAlive { get => client != null && client.IsAlive; }
-        public bool IsAlive { get => client.IsAlive; }
+        public bool IsLoggedIn
-        
-        public BankNetInteractor(string address, short port, bool checkIdentity = true)
         {
-            if(checkIdentity)
+            get
-                new Task(() =>
             {
-                    //AuthenticatedKeys = NetClient.CheckServerIdentity(address, port, provider);
+                if (loginTimeout >= DateTime.Now.Ticks) loginTimeout = -1;
-                    authenticating = false;
+                return loginTimeout != -1;
-                    authenticated = true;// AuthenticatedKeys != null;
-                }).Start();
-            else
-            {
-                authenticating = false;
-                authenticated = false;
             }
-            var addr = System.Net.IPAddress.Parse(address);
+        }
+        protected long loginTimeout = -1;
+        protected string sessionID = null;
+        
+
+        public BankNetInteractor(string address, short port)
+        {
+            this.addr = IPAddress.Parse(address);
+            this.port = port;
+            this.keyExchange = EllipticDiffieHellman.Curve25519(EllipticDiffieHellman.Curve25519_GeneratePrivate(provider));
+        }
+
+        protected virtual async Task Connect()
+        {
+            if (IsAlive) return;
             client = new NetClient(
-                EllipticDiffieHellman.Curve25519(EllipticDiffieHellman.Curve25519_GeneratePrivate(provider)),
+                keyExchange,
                 addr,
                 port,
                 MessageRecievedHandler,
                 ClientConnectionHandler,
                 65536); // 64 KiB buffer
-        }
-
-        public virtual Task Connect()
-        {
             client.Connect();
             Task t = new Task(() =>
             {
                 while (!client.IsAlive) System.Threading.Thread.Sleep(125);
             });
             t.Start();
-            return t;
+            await t;
+        }
+        public async virtual Task CancelAll()
+        {
+            if (client == null) return;
+            await client.Disconnect();
         }
-        public async virtual Task<object> Disconnect() => await client.Disconnect();
 
         public long RegisterListener(OnClientConnectStateChanged stateListener)
         {
-            long tkn;
+            long tkn = GetListenerToken();
-            changeListeners[tkn = GetListenerToken()] = stateListener;
+            changeListeners[tkn] = stateListener;
             return tkn;
         }
 
@@ -74,9 +81,8 @@ namespace Client
             if (err || !promises.ContainsKey(pID)) return null;
             Promise p = promises[pID];
             promises.Remove(pID);
-            p.Value = response;
+            PostPromise(p, response);
-            p.HasValue = true;
+            if (promises.Count == 0) keepAlive = false;
-            p.Subscribe?.Invoke(p);
             return null;
         }
 
@@ -86,7 +92,80 @@ namespace Client
                 listener(client, connect);
         }
 
-        public virtual Promise CheckAccountAvailability(string username)
+        public async virtual Task<Promise> CheckAccountAvailability(string username)
+        {
+            await Connect();
+            if (username.Length > 60)
+                return new Promise
+                {
+                    HasValue = true,
+                    Value = "ERROR"
+                };
+            client.Send(CreateCommandMessage("Avail", username.ToBase64String(), out long pID));
+            return RegisterPromise(pID);
+        }
+
+        public async virtual Task<Promise> Authenticate(string username, string password)
+        {
+            await Connect();
+            if (username.Length > 60)
+                return new Promise
+                {
+                    HasValue = true,
+                    Value = "ERROR"
+                };
+            client.Send(CreateCommandMessage("Auth", username.ToBase64String()+":"+password.ToBase64String(), out long pID));
+
+            return RegisterEventPromise(pID, p =>
+            {
+                bool b = !p.Value.StartsWith("ERROR");
+                PostPromise(p.handler, b);
+                if (b)
+                {
+                    loginTimeout = 280 * TimeSpan.TicksPerSecond;
+                    sessionID = p.Value;
+                }
+                return false;
+            });
+        }
+
+        public async virtual Task<Promise> CreateAccount(string accountName)
+        {
+            if (!IsLoggedIn) throw new SystemException("Not logged in");
+            await Connect();
+            client.Send(CreateCommandMessage("Account_Create", $"{sessionID}:{accountName}", out long PID));
+            return RegisterEventPromise(PID, RefreshSession);
+        }
+
+        public async virtual Task<Promise> CheckIdentity(RSA check, ushort nonce)
+        {
+            long pID;
+            Task connect = Connect();
+            string ser;
+            using(BitWriter writer = new BitWriter())
+            {
+                writer.WriteULong(nonce);
+                ser = CreateCommandMessage("Verify", Convert.ToBase64String(writer.Finalize()), out pID);
+            }
+            await connect;
+            client.Send(ser);
+            return RegisterEventPromise(pID, manager =>
+            {
+                BitReader reader = new BitReader(Convert.FromBase64String(manager.Value));
+                try
+                {
+                    RSA remote = RSA.Deserialize(reader.ReadByteArray(), out int _);
+                    PostPromise(manager.handler, new BigInteger(remote.Decrypt(reader.ReadByteArray(), null, true)).Equals((BigInteger)nonce) && remote.Equals(check));
+                }
+                catch
+                {
+                    PostPromise(manager.handler, false);
+                }
+                return false;
+            });
+        }
+
+        public async virtual Task<Promise> Register(string username, string password)
         {
             if (username.Length > 60)
                 return new Promise
@@ -94,43 +173,43 @@ namespace Client
                     HasValue = true,
                     Value = "ERROR"
                 };
-            client.Send(CreateCommandMessage("Avail", username, out long pID));
+            await Connect();
+            client.Send(CreateCommandMessage("Reg", username.ToBase64String() + ":" + password.ToBase64String(), out long pID));
+            return RegisterPromise(pID);
+        }
+
+        public async virtual Task Logout(string sessionID)
+        {
+            if (!IsLoggedIn) return; // No need to unnecessarily trigger a logout that we know will fail
+            await Connect();
+            client.Send(CreateCommandMessage("Logout", sessionID, out long _));
+        }
+
+        protected Promise RegisterPromise(long pID)
+        {
             Promise p = new Promise();
             promises[pID] = p;
             return p;
         }
 
-        public virtual Promise Authenticate(string username, string password)
+        protected Promise RegisterEventPromise(long pID, Func<Promise, bool> a)
         {
-            if (username.Length > 60)
+            Promise p = RegisterPromise(pID);
-                return new Promise
+            p.handler = new Promise();
+            p.Subscribe = p1 =>
             {
-                    HasValue = true,
+                // If true, propogate result
-                    Value = "ERROR"
+                if (a(p1)) PostPromise(p1.handler, p1.Value);
             };
-            client.Send(CreateCommandMessage("Auth", username+":"+password, out long pID));
+            return p.handler;
-            Promise p = new Promise();
-            promises[pID] = p;
-            return p;
         }
 
-        public virtual Promise Register(string username, string password)
+        protected bool RefreshSession(Promise p)
         {
-            if (username.Length > 60)
+            if (!p.Value.StartsWith("ERROR")) loginTimeout = 280 * TimeSpan.TicksPerSecond;
-                return new Promise
+            return true;
-                {
-                    HasValue = true,
-                    Value = "ERROR"
-                };
-            client.Send(CreateCommandMessage("Reg", username + ":" + password, out long pID));
-            Promise p = new Promise();
-            promises[pID] = p;
-            return p;
         }
 
-        public virtual void Logout(string sessionID)
-            => client.Send(CreateCommandMessage("Logout", sessionID, out long _));
-
         protected long GetNewPromiseUID()
         {
             long l;
@@ -147,9 +226,9 @@ namespace Client
             return l;
         }
 
-        protected static void PostPromise(Promise p, string value)
+        protected static void PostPromise(Promise p, dynamic value)
         {
-            p.Value = value;
+            p.Value = value?.ToString() ?? "null";
             p.HasValue = true;
             p.Subscribe?.Invoke(p);
         }
@@ -165,6 +244,7 @@ namespace Client
     public delegate void Event(Promise p);
     public class Promise
     {
+        internal Promise handler = null; // For chained promise management
         private Event evt;
         public string Value { get; internal set; }
         public bool HasValue { get; internal set; }
@@ -173,10 +253,17 @@ namespace Client
             get => evt;
             set
             {
-                evt = value;
+                // Allows clearing subscriptions
+                if (evt == null || value == null) evt = value;
+                else evt += value;
                 if (HasValue)
                     evt(this);
             }
         }
+        public static Promise AwaitPromise(Task<Promise> p)
+        {
+            if (!p.IsCompleted) p.RunSynchronously();
+            return p.Result;
+        }
     }
 }

Client/Program.cs

@@ -1,44 +1,30 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.Numerics;
 using System.Runtime.InteropServices;
 using Client;
 using Client.ConsoleForms;
 using Client.ConsoleForms.Parameters;
 using Common;
-using Tofvesson.Common;
+using Tofvesson.Crypto;
 
 namespace ConsoleForms
 {
+
     class Program
     {
+        private static readonly RandomProvider provider = new RegularRandomProvider(new Random(1337));
         public static TextWriter DebugStream = new DebugAdapterWriter();
         private static ConsoleController controller = ConsoleController.singleton;        
 
-        static void Main(string[] args)
+        public static void Main(string[] args)
         {
             // Set up timestamps in debug output
             DebugStream = new TimeStampWriter(DebugStream, "HH:mm:ss.fff");
 
-
-            
-            byte[] serialized;
-
-            
-            using (BinaryCollector collector = new BinaryCollector(4))
-            {
-                collector.Push(true);
-                collector.Push(new double[] { 6.0, 123 });
-                collector.Push(new float[] { 512, 1.2f, 1.337f});
-                collector.Push(5);
-                serialized = collector.ToArray();
-            }
-
-            BinaryDistributor bd = new BinaryDistributor(serialized);
-            bool bit = bd.ReadBit();
-            double[] result = bd.ReadDoubleArray();
-            float[] f = bd.ReadFloatArray();
-            int number = bd.ReadInt();
-
             Padding p = new AbsolutePadding(2, 2, 1, 1);    
 
             Console.CursorVisible = false;

Client/Properties/Resources.Designer.cs

@@ -62,14 +62,14 @@ namespace Client.Properties {
         
         /// <summary>
         ///   Looks up a localized string similar to &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot; ?&gt; 
-        ///&lt;Resources&gt;
+        ///&lt;Resources xmlns=&quot;Client.ConsoleForms.Graphics&quot;&gt;
         ///  &lt;DialogView id=&quot;EmptyFieldError&quot;
         ///    padding_left=&quot;2&quot;
         ///    padding_right=&quot;2&quot;
         ///    padding_top=&quot;1&quot;
         ///    padding_bottom=&quot;1&quot;&gt;
         ///    &lt;Options&gt;
-        ///      &lt;Option&gt;Ok&lt;/Option&gt;
+        ///      &lt;Option&gt;@string/GENERIC_accept&lt;/Option&gt;
         ///    &lt;/Options&gt;
         ///    &lt;Text&gt;@string/ERR_empty&lt;/Text&gt;
         ///  &lt;/DialogView&gt;
@@ -81,6 +81,16 @@ namespace Client.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] e_0x100 {
+            get {
+                object obj = ResourceManager.GetObject("e_0x100", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Byte[].
         /// </summary>
@@ -91,6 +101,16 @@ namespace Client.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] n_0x100 {
+            get {
+                object obj = ResourceManager.GetObject("n_0x100", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Byte[].
         /// </summary>
@@ -111,11 +131,10 @@ namespace Client.Properties {
         ///                padding_top=&quot;1&quot;
         ///                padding_bottom=&quot;1&quot;&gt;
         ///    &lt;Fields&gt;
-        ///      &lt;Field input_type=&quot;decimal&quot; max_length=&quot;15&quot;&gt;Server IP:&lt;/Field&gt;
+        ///      &lt;Field input_type=&quot;decimal&quot; max_length=&quot;15&quot;&gt;@string/NC_ip&lt;/Field&gt;
-        ///      &lt;Field default=&quot;80&quot; input_type=&quot;integer&quot; max_length=&quot;5&quot;&gt;Port:&lt;/Field&gt;
+        ///      &lt;Field default=&quot;80&quot; input_type=&quot;integer&quot; max_length=&quot;5&quot;&gt;@string/NC_port&lt;/Field&gt;
         ///    &lt;/Fields&gt;
-        ///    &lt;Text&gt;@string/NC_head&lt;/Text&gt;
+        ///    &lt;Text&gt;@string/NC_head&lt;/Text&gt;
        /// [rest of string was truncated]&quot;;.
-        ///  &lt;/InputVie [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string Networking {
             get {
@@ -142,10 +161,10 @@ namespace Client.Properties {
         ///    padding_right=&quot;2&quot;
         ///    padding_top=&quot;1&quot;
         ///    padding_bottom=&quot;1&quot;&gt;
-        ///    &lt;Text&gt;Balance: $balance&lt;/Text&gt;
+        ///    &lt;Text&gt;@string/SE_bal&lt;/Text&gt;
         ///  &lt;/TextView&gt;
         ///  
-        ///  &lt;ListView id= [rest of string was truncated]&quot;;.
+        ///  &lt;ListView id=&quot;me [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string Session {
             get {
@@ -165,10 +184,10 @@ namespace Client.Properties {
         ///             padding_bottom=&quot;1&quot;
         ///             width=&quot;42&quot;&gt;
         ///    &lt;Options&gt;
-        ///      &lt;Option event=&quot;Setup:Login&quot; close=&quot;true&quot;&gt;Login&lt;/Option&gt;
+        ///      &lt;Option event=&quot;Setup:Login&quot; close=&quot;true&quot;&gt;@string/SU_login_label&lt;/Option&gt;
-        ///      &lt;Option event=&quot;Setup:Register&quot; close=&quot;true&quot;&gt;Register&lt;/Option&gt;
+        ///      &lt;Option event=&quot;Setup:Register&quot; close=&quot;true&quot;&gt;@string/SU_reg_label&lt;/Option&gt;
         ///    &lt;/Options&gt;
-        ///    &lt;Text&gt;Welcome to the Tofvesson banking [rest of string was truncated]&quot;;.
+        ///    &lt;Text&gt;@st [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string Setup {
             get {
@@ -182,9 +201,11 @@ namespace Client.Properties {
         ///	&lt;Entry name=&quot;NC_head&quot;&gt;Server configuration&lt;/Entry&gt;
         ///	&lt;Entry name=&quot;NC_sec&quot;&gt;The selected server&apos;s identity could not be verified. This implies that it is not an official server. Continue?&lt;/Entry&gt;
         ///	&lt;Entry name=&quot;NC_stall&quot;&gt;Connecting to server...&lt;/Entry&gt;
-        ///
+        ///	&lt;Entry name=&quot;NC_next&quot;&gt;Continue&lt;/Entry&gt;
-        ///	&lt;Entry name=&quot;ERR_empty&quot;&gt;One of more required field was empty!&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_cancel&quot;&gt;Cancel&lt;/Entry&gt;
-        ///&lt;/Strings&gt;.
+        ///	&lt;Entry name=&quot;NC_ip&quot;&gt;Server IP:&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_port&quot;&gt;Port:&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_iperr&quot;&gt;The s [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string strings_lang_en_GB {
             get {
@@ -198,9 +219,11 @@ namespace Client.Properties {
         ///	&lt;Entry name=&quot;NC_head&quot;&gt;Server configuration&lt;/Entry&gt;
         ///	&lt;Entry name=&quot;NC_sec&quot;&gt;The selected server&apos;s identity could not be verified. This implies that it is not an official server. Continue?&lt;/Entry&gt;
         ///	&lt;Entry name=&quot;NC_stall&quot;&gt;Connecting to server...&lt;/Entry&gt;
-        ///
+        ///	&lt;Entry name=&quot;NC_next&quot;&gt;Continue&lt;/Entry&gt;
-        ///	&lt;Entry name=&quot;ERR_empty&quot;&gt;One of more required field was empty!&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_cancel&quot;&gt;Cancel&lt;/Entry&gt;
-        ///&lt;/Strings&gt;.
+        ///	&lt;Entry name=&quot;NC_ip&quot;&gt;Server IP:&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_port&quot;&gt;Port:&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_iperr&quot;&gt;The s [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string strings_lang_en_US {
             get {
@@ -214,9 +237,11 @@ namespace Client.Properties {
         ///	&lt;Entry name=&quot;NC_head&quot;&gt;Serverkonfiguration&lt;/Entry&gt;
         ///	&lt;Entry name=&quot;NC_sec&quot;&gt;Den valda serverns identitet kunde inte verifieras. Detta innebär att det inte är en officiell server. Fortsätt?&lt;/Entry&gt;
         ///	&lt;Entry name=&quot;NC_stall&quot;&gt;Kopplar upp mot servern...&lt;/Entry&gt;
-        ///
+        ///	&lt;Entry name=&quot;NC_next&quot;&gt;Fortsätt&lt;/Entry&gt;
-        ///	&lt;Entry name=&quot;ERR_empty&quot;&gt;Ett eller fler obligatoriska inputfält är tomma!&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_cancel&quot;&gt;Avbryt&lt;/Entry&gt;
-        ///&lt;/Strings&gt;.
+        ///	&lt;Entry name=&quot;NC_ip&quot;&gt;Server IP:&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_port&quot;&gt;Port:&lt;/Entry&gt;
+        ///	&lt;Entry name=&quot;NC_iperr&quot;&gt;De [rest of string was truncated]&quot;;.
         /// </summary>
         internal static string strings_lang_sv_SE {
             get {
@@ -226,11 +251,11 @@ namespace Client.Properties {
         
         /// <summary>
         ///   Looks up a localized string similar to &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot; ?&gt; 
-        ///&lt;Lang&gt;
+        ///&lt;Strings&gt;
-        ///	&lt;Default&gt;sv_SE&lt;/Default&gt;
+        ///	&lt;Lang priority=&quot;0&quot;&gt;sv_SE&lt;/Lang&gt;
-        ///	&lt;Fallback priority=&quot;0&quot;&gt;en_US&lt;/Fallback&gt;
+        ///	&lt;Lang priority=&quot;1&quot;&gt;en_US&lt;/Lang&gt;
-        ///	&lt;Fallback priority=&quot;1&quot;&gt;en_GB&gt;&lt;/Fallback&gt;
+        ///	&lt;Lang priority=&quot;2&quot;&gt;en_GB&lt;/Lang&gt;
-        ///&lt;/Lang&gt;.
+        ///&lt;/Strings&gt;.
         /// </summary>
         internal static string strings_meta {
             get {

Client/Properties/Resources.resx

@@ -148,4 +148,10 @@
   <data name="strings_lang_en_GB" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\Strings\en_GB\strings.xml;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
   </data>
+  <data name="e_0x100" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\0x100.e;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
+  <data name="n_0x100" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\0x100.n;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
 </root>

Client/Resources/Layout/Networking.xml

@@ -37,6 +37,17 @@
     <Text>@string/NC_stall</Text>
   </DialogView>
 
+  <DialogView id="IdentityVerify"
+    padding_left="2"
+    padding_right="2"
+    padding_top="1"
+    padding_bottom="1">
+    <Options>
+      <Option>@string/NC_cancel</Option>
+    </Options>
+    <Text>@string/NC_identity</Text>
+  </DialogView>
+
   <DialogView id="IPError"
     padding_left="2"
     padding_right="2"

Client/Resources/Layout/Session.xml

@@ -23,20 +23,39 @@
     padding_left="2"
     padding_right="2"
     padding_top="1"
-    padding_bottom="1"
+    padding_bottom="1">
-    border="2">
     <Views>
-      <ButtonView id="history">
+      <ButtonView id="view">
-        <Text>@string/SE_hist</Text>
+        <Text>@string/SE_view</Text>
-      </ButtonView>
-
-      <ButtonView id="create">
-        <Text>@string/SE_tx</Text>
       </ButtonView>
 
       <ButtonView id="update">
         <Text>@string/SE_pwdu</Text>
       </ButtonView>
+    
+      <ButtonView id="exit">
+        <Text>@string/SE_exit</Text>
+      </ButtonView>
     </Views>
   </ListView>
+
+  <!-- Bank account list -->
+  <ListView id="account_show">
+    <Views>
+      <ButtonView id="close">
+        <Text>@string/GENERIC_dismiss</Text>
+      </ButtonView>
+    </Views>
+  </ListView>
+
+  <DialogView id="account_info"
+    padding_left="2"
+    padding_right="2"
+    padding_top="1"
+    padding_bottom="1">
+    <Options>
+      <Option>Ok</Option>
+    </Options>
+    <Text>@string/SE_info</Text>
+  </DialogView>
 </Elements>

Client/Resources/Strings/Meta.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8" ?> 
-<Lang>
+<Strings>
-	<Default>sv_SE</Default>
+	<Lang priority="0">sv_SE</Lang>
-	<Fallback priority="0">en_US</Fallback>
+	<Lang priority="1">en_US</Lang>
-	<Fallback priority="1">en_GB</Fallback>
+	<Lang priority="2">en_GB</Lang>
-</Lang>
+</Strings>

Client/Resources/Strings/en_GB/strings.xml

@@ -10,6 +10,7 @@
 	<Entry name="NC_iperr">The supplied IP-address is not valid</Entry>
 	<Entry name="NC_porterr">The supplied port is not valid</Entry>
 	<Entry name="NC_connerr">Could not connect to server</Entry>
+	<Entry name="NC_identity">Verifying server identity...</Entry>
 
 	<Entry name="SU_welcome">Welcome to the Tofvesson banking system! To continue, press [ENTER]               To go back, press [ESCAPE]</Entry>
 	<Entry name="SU_reg">Register Account</Entry>
@@ -27,10 +28,23 @@
 	<Entry name="SU_login_label">Login</Entry>
 
 	<Entry name="SE_bal">Balance: $1</Entry>
-	<Entry name="SE_hist">View transaction history</Entry>
+	<Entry name="SE_hist">Transaction history</Entry>
 	<Entry name="SE_tx">Transfer funds</Entry>
+	<Entry name="SE_who">Send to</Entry>
+	<Entry name="SE_where">Account</Entry>
+	<Entry name="SE_view">View accounts</Entry>
+	<Entry name="SE_amount">Amount to transfer</Entry>
+	<Entry name="SE_msg">Include a message</Entry>
 	<Entry name="SE_pwdu">Update password</Entry>
+    <Entry name="SE_exit">Log out</Entry>
+    <Entry name="SE_open">Open an account</Entry>
+    <Entry name="SE_close">Close an account</Entry>
+    <Entry name="SE_accounts">Show accounts</Entry>
+    <Entry name="SE_info">$0
+Balance: $1
+Date of creation: $2</Entry>
 
+	<Entry name="GENERIC_dismiss">Close</Entry>
 	<Entry name="GENERIC_accept">Ok</Entry>
 	<Entry name="GENERIC_positive">Yes</Entry>
 	<Entry name="GENERIC_negative">No</Entry>

Client/Resources/Strings/en_US/strings.xml

@@ -10,6 +10,7 @@
 	<Entry name="NC_iperr">The supplied IP-address is not valid</Entry>
 	<Entry name="NC_porterr">The supplied port is not valid</Entry>
 	<Entry name="NC_connerr">Could not connect to server</Entry>
+	<Entry name="NC_identity">Verifying server identity...</Entry>
 
 	<Entry name="SU_welcome">Welcome to the Tofvesson banking system! To continue, press [ENTER]               To go back, press [ESCAPE]</Entry>
 	<Entry name="SU_reg">Register Account</Entry>
@@ -27,10 +28,23 @@
 	<Entry name="SU_login_label">Login</Entry>
 
 	<Entry name="SE_bal">Balance: $1</Entry>
-	<Entry name="SE_hist">View transaction history</Entry>
+	<Entry name="SE_hist">Transaction history</Entry>
 	<Entry name="SE_tx">Transfer funds</Entry>
+	<Entry name="SE_who">Send to</Entry>
+	<Entry name="SE_where">Account</Entry>
+	<Entry name="SE_view">View accounts</Entry>
+	<Entry name="SE_amount">Amount to transfer</Entry>
+	<Entry name="SE_msg">Include a message</Entry>
 	<Entry name="SE_pwdu">Update password</Entry>
+    <Entry name="SE_exit">Log out</Entry>
+    <Entry name="SE_open">Open an account</Entry>
+    <Entry name="SE_close">Close an account</Entry>
+    <Entry name="SE_accounts">Show accounts</Entry>
+    <Entry name="SE_info">$0
+Balance: $1
+Date of creation: $2</Entry>
 
+	<Entry name="GENERIC_dismiss">Close</Entry>
 	<Entry name="GENERIC_accept">Ok</Entry>
 	<Entry name="GENERIC_positive">Yes</Entry>
 	<Entry name="GENERIC_negative">No</Entry>

Client/Resources/Strings/sv_SE/strings.xml

@@ -3,6 +3,53 @@
 	<Entry name="NC_head">Serverkonfiguration</Entry>
 	<Entry name="NC_sec">Den valda serverns identitet kunde inte verifieras. Detta innebär att det inte är en officiell server. Fortsätt?</Entry>
 	<Entry name="NC_stall">Kopplar upp mot servern...</Entry>
+	<Entry name="NC_next">Fortsätt</Entry>
+	<Entry name="NC_cancel">Avbryt</Entry>
+	<Entry name="NC_ip">Server IP:</Entry>
+	<Entry name="NC_port">Port:</Entry>
+	<Entry name="NC_iperr">Den givna IP-addressen är inte giltig</Entry>
+	<Entry name="NC_porterr">Den givna porten är inte giltig</Entry>
+	<Entry name="NC_connerr">Kunde inte koppla till servern</Entry>
+	<Entry name="NC_identity">Verifierar serverns identitet...</Entry>
 
-	<Entry name="ERR_empty">Ett eller fler obligatoriska inputfält är tomma!</Entry>
+	<Entry name="SU_welcome">Välkommen till Tofvessons banksystem!
+		För att fortsätta, tryck [ENTER]
+		För att backa, tryck [ESCAPE]</Entry>
+	<Entry name="SU_reg">Registrera konto</Entry>
+	<Entry name="SU_regstall">Registrerar...</Entry>
+	<Entry name="SU_dup">Ett konto med det givna användarnamnet finns redan!</Entry>
+	<Entry name="SU_mismatch">De givna lösenorden matchar inte!</Entry>
+	<Entry name="SU_weak">Det angivna lösenordet ases vara svagt. Är du säker på att du vill fortsätta?</Entry>
+	<Entry name="SU_login">Logga in</Entry>
+	<Entry name="SU_authstall">Autentiserar...</Entry>
+	<Entry name="SU_usrerr">Det givna användarnamnet eller lösenordet var felaktigt</Entry>
+	<Entry name="SU_usr">Användarnamn:</Entry>
+	<Entry name="SU_pwd">Lösenord:</Entry>
+	<Entry name="SU_pwdrep">Upprepa lösenord:</Entry>
+	<Entry name="SU_reg_label">Registrera</Entry>
+	<Entry name="SU_login_label">Logga in</Entry>
+
+	<Entry name="SE_bal">Kontobalans: $1</Entry>
+	<Entry name="SE_hist">Transaktionshistorik</Entry>
+	<Entry name="SE_tx">Överför pengar</Entry>
+	<Entry name="SE_who">Skicka till</Entry>
+	<Entry name="SE_where">Konto</Entry>
+	<Entry name="SE_view">Visa konton</Entry>
+	<Entry name="SE_amount">Värde att överföra</Entry>
+	<Entry name="SE_msg">Inkludera ett meddelande</Entry>
+	<Entry name="SE_pwdu">Uppdatera lösenord</Entry>
+    <Entry name="SE_exit">Logga ut</Entry>
+    <Entry name="SE_open">Öppna ett konto</Entry>
+    <Entry name="SE_close">Stäng ett konto</Entry>
+    <Entry name="SE_accounts">Visa konton</Entry>
+    <Entry name="SE_info">"$0"
+Kontobalans: $1
+Begynnelsedatum: $2</Entry>
+
+	<Entry name="GENERIC_dismiss">Stäng</Entry>
+	<Entry name="GENERIC_accept">Ok</Entry>
+	<Entry name="GENERIC_positive">Ja</Entry>
+	<Entry name="GENERIC_negative">Nej</Entry>
+
+	<Entry name="ERR_empty">Ett eller flera obligatoriska inputfält är tomma!</Entry>
 </Strings>

Common/BinaryCollector.cs

@@ -1,332 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-using Tofvesson.Crypto;
-
-namespace Tofvesson.Common
-{
-    public sealed class BinaryCollector : IDisposable
-    {
-        // Collects reusable 
-        private static readonly List<WeakReference<object[]>> expired = new List<WeakReference<object[]>>();
-
-        private static readonly byte[] holder = new byte[8];
-        private static readonly float[] holder_f = new float[1];
-        private static readonly double[] holder_d = new double[1];
-        private static readonly ulong[] holder_u = new ulong[1];
-        private static readonly uint[] holder_i = new uint[1];
-        private static readonly List<Type> supportedTypes = new List<Type>()
-        {
-            typeof(bool),
-            typeof(byte),
-            typeof(sbyte),
-            typeof(char),
-            typeof(short),
-            typeof(ushort),
-            typeof(int),
-            typeof(uint),
-            typeof(long),
-            typeof(ulong),
-            typeof(float),
-            typeof(double),
-            typeof(decimal)
-        };
-
-        private static readonly FieldInfo
-            dec_lo,
-            dec_mid,
-            dec_hi, 
-            dec_flags;
-
-        static BinaryCollector()
-        {
-            dec_lo = typeof(decimal).GetField("lo", BindingFlags.NonPublic);
-            dec_mid = typeof(decimal).GetField("mid", BindingFlags.NonPublic);
-            dec_hi = typeof(decimal).GetField("hi", BindingFlags.NonPublic);
-            dec_flags = typeof(decimal).GetField("flags", BindingFlags.NonPublic);
-        }
-
-        private object[] collect;
-        private readonly int bufferSize;
-        private int collectCount = 0;
-
-        /// <summary>
-        /// Allocates a new binary collector.
-        /// </summary>
-        public BinaryCollector(int bufferSize)
-        {
-            this.bufferSize = bufferSize;
-            for (int i = expired.Count - 1; i >= 0; --i)
-                if (expired[i].TryGetTarget(out collect))
-                {
-                    if (collect.Length >= bufferSize)
-                    {
-                        expired.RemoveAt(i); // This entry he been un-expired for now
-                        break;
-                    }
-                }
-                else expired.RemoveAt(i); // Entry has been collected by GC
-            if (collect == null || collect.Length < bufferSize)
-                collect = new object[bufferSize];
-        }
-
-        public void Push<T>(T b)
-        {
-            if (b is string || b.GetType().IsArray || IsSupportedType(b.GetType()))
-                collect[collectCount++] = b is string ? Encoding.UTF8.GetBytes(b as string) : b as object;
-            //else
-            //    Debug.LogWarning("MLAPI: The type \"" + b.GetType() + "\" is not supported by the Binary Serializer. It will be ignored");
-        }
-
-        public byte[] ToArray()
-        {
-            long bitCount = 0;
-            for (int i = 0; i < collectCount; ++i) bitCount += GetBitCount(collect[i]);
-
-            byte[] alloc = new byte[(bitCount / 8) + (bitCount % 8 == 0 ? 0 : 1)];
-            long bitOffset = 0;
-            foreach (var item in collect)
-                Serialize(item, alloc, ref bitOffset);
-
-            return alloc;
-        }
-
-        private static void Serialize<T>(T t, byte[] writeTo, ref long bitOffset)
-        {
-            Type type = t.GetType();
-            bool size = false;
-            if (type.IsArray)
-            {
-                var array = t as Array;
-                Serialize((ushort)array.Length, writeTo, ref bitOffset);
-                foreach (var element in array)
-                    Serialize(element, writeTo, ref bitOffset);
-            }
-            else if (IsSupportedType(type))
-            {
-                long offset = GetBitAllocation(type);
-                if (type == typeof(bool))
-                {
-                    WriteBit(writeTo, t as bool? ?? false, bitOffset);
-                    bitOffset += offset;
-                }
-                else if (type == typeof(decimal))
-                {
-                    WriteDynamic(writeTo, dec_lo.GetValue(t), 4, bitOffset);
-                    WriteDynamic(writeTo, dec_mid.GetValue(t), 4, bitOffset + 32);
-                    WriteDynamic(writeTo, dec_hi.GetValue(t), 4, bitOffset + 64);
-                    WriteDynamic(writeTo, dec_flags.GetValue(t), 4, bitOffset + 96);
-                    bitOffset += offset;
-                }
-                else if ((size = type == typeof(float)) || type == typeof(double))
-                {
-                    int bytes = size ? 4 : 8;
-                    Array type_holder = size ? holder_f as Array : holder_d as Array; // Fetch the preallocated array
-                    Array result_holder = size ? holder_i as Array : holder_u as Array;
-                    lock (result_holder)
-                        lock (type_holder)
-                        {
-                            // Clear artifacts
-                            if (size) result_holder.SetValue(0U, 0);
-                            else result_holder.SetValue(0UL, 0);
-                            type_holder.SetValue(t, 0); // Insert the value to convert into the preallocated holder array
-                            Buffer.BlockCopy(type_holder, 0, result_holder, 0, bytes); // Perform an internal copy to the byte-based holder
-                            dynamic d = result_holder.GetValue(0);
-
-                            // Since floating point flag bits are seemingly the highest bytes of the floating point values
-                            // and even very small values have them, we swap the endianness in the hopes of reducing the size
-                            Serialize(Support.SwapEndian(d), writeTo, ref bitOffset);
-                        }
-                    //bitOffset += offset;
-                }
-                else
-                {
-                    bool signed = IsSigned(t.GetType());
-                    dynamic value;
-                    if (signed)
-                    {
-                        Type t1 = t.GetType();
-                        if (t1 == typeof(sbyte)) value = (byte)ZigZagEncode(t);
-                        else if (t1 == typeof(short)) value = (ushort)ZigZagEncode(t);
-                        else if (t1 == typeof(int)) value = (uint)ZigZagEncode(t);
-                        else /*if (t1 == typeof(long))*/ value = (ulong)ZigZagEncode(t);
-                    }
-                    else value = t;
-
-                    if (value <= 240) WriteByte(writeTo, value, bitOffset);
-                    else if (value <= 2287)
-                    {
-                        WriteByte(writeTo, (value - 240) / 256 + 241, bitOffset);
-                        WriteByte(writeTo, (value - 240) % 256, bitOffset + 8);
-                    }
-                    else if (value <= 67823)
-                    {
-                        WriteByte(writeTo, 249, bitOffset);
-                        WriteByte(writeTo, (value - 2288) / 256, bitOffset + 8);
-                        WriteByte(writeTo, (value - 2288) % 256, bitOffset + 16);
-                    }
-                    else
-                    {
-                        WriteByte(writeTo, value & 255, bitOffset + 8);
-                        WriteByte(writeTo, (value >> 8) & 255, bitOffset + 16);
-                        WriteByte(writeTo, (value >> 16) & 255, bitOffset + 24);
-                        if (value > 16777215)
-                        {
-                            WriteByte(writeTo, (value >> 24) & 255, bitOffset + 32);
-                            if (value > 4294967295)
-                            {
-                                WriteByte(writeTo, (value >> 32) & 255, bitOffset + 40);
-                                if (value > 1099511627775)
-                                {
-                                    WriteByte(writeTo, (value >> 40) & 55, bitOffset + 48);
-                                    if (value > 281474976710655)
-                                    {
-                                        WriteByte(writeTo, (value >> 48) & 255, bitOffset + 56);
-                                        if (value > 72057594037927935)
-                                        {
-                                            WriteByte(writeTo, 255, bitOffset);
-                                            WriteByte(writeTo, (value >> 56) & 255, bitOffset + 64);
-                                        }
-                                        else WriteByte(writeTo, 254, bitOffset);
-                                    }
-                                    else WriteByte(writeTo, 253, bitOffset);
-                                }
-                                else WriteByte(writeTo, 252, bitOffset);
-                            }
-                            else WriteByte(writeTo, 251, bitOffset);
-                        }
-                        else WriteByte(writeTo, 250, bitOffset);
-                    }
-                    bitOffset += BytesToRead(value) * 8;
-                }
-            }
-        }
-
-        private static byte Read7BitRange(byte higher, byte lower, int bottomBits) => (byte)((higher << bottomBits) & (lower & (0xFF << (8-bottomBits))));
-        private static byte ReadNBits(byte from, int offset, int count) => (byte)(from & ((0xFF >> (8-count)) << offset));
-
-        private static bool IsSigned(Type t) => Convert.ToBoolean(t.GetField("MinValue").GetValue(null));
-
-        private static Type GetUnsignedType(Type t) =>
-            t == typeof(sbyte) ? typeof(byte) :
-            t == typeof(short) ? typeof(ushort) :
-            t == typeof(int) ? typeof(uint) :
-            t == typeof(long) ? typeof(ulong) :
-            null;
-
-        private static dynamic ZigZagEncode(dynamic d) => (((d >> (int)(Marshal.SizeOf(d) * 8 - 1))&1) | (d << 1));
-
-        private static long GetBitCount<T>(T t)
-        {
-            Type type = t.GetType();
-            long count = 0;
-            if (type.IsArray)
-            {
-                Type elementType = type.GetElementType();
-
-                count += 16; // Int16 array size. Arrays shouldn't be syncing more than 65k elements
-                foreach (var element in t as Array)
-                    count += GetBitCount(element);
-            }
-            else if (IsSupportedType(type))
-            {
-                long ba = GetBitAllocation(type);
-                if (ba == 0) count += Encoding.UTF8.GetByteCount(t as string);
-                else if (t is bool || t is decimal) count += ba;
-                else count += BytesToRead(t) * 8;
-            }
-            //else
-            //    Debug.LogWarning("MLAPI: The type \"" + b.GetType() + "\" is not supported by the Binary Serializer. It will be ignored");
-            return count;
-        }
-
-        private static void WriteBit(byte[] b, bool bit, long index)
-            => b[index / 8] = (byte)((b[index / 8] & ~(1 << (int)(index % 8))) | (bit ? 1 << (int)(index % 8) : 0));
-        private static void WriteByte(byte[] b, dynamic value, long index) => WriteByte(b, (byte)value, index);
-        private static void WriteByte(byte[] b, byte value, long index)
-        {
-            int byteIndex = (int)(index / 8);
-            int shift = (int)(index % 8);
-            byte upper_mask = (byte)(0xFF << shift);
-            byte lower_mask = (byte)~upper_mask;
-
-            b[byteIndex] = (byte)((b[byteIndex] & lower_mask) | (value << shift));
-            if(shift != 0 && byteIndex + 1 < b.Length)
-                b[byteIndex + 1] = (byte)((b[byteIndex + 1] & upper_mask) | (value >> (8 - shift)));
-        }
-        private static void WriteBits(byte[] b, byte value, int bits, int offset, long index)
-        {
-            for (int i = 0; i < bits; ++i)
-                WriteBit(b, (value & (1 << (i + offset))) != 0, index + i);
-        }
-        private static void WriteDynamic(byte[] b, dynamic value, int byteCount, long index)
-        {
-            for (int i = 0; i < byteCount; ++i)
-                WriteByte(b, (byte)((value >> (8 * i)) & 0xFF), index + (8 * i));
-        }
-
-        private static int BytesToRead(dynamic integer)
-        {
-            bool size;
-            if((size=integer is float) || integer is double)
-            {
-                int bytes = size ? 4 : 8;
-                Array type_holder = size ? holder_f as Array : holder_d as Array; // Fetch the preallocated array
-                Array result_holder = size ? holder_i as Array : holder_u as Array;
-                lock (result_holder)
-                    lock (type_holder)
-                    {
-                        // Clear artifacts
-                        if (size) result_holder.SetValue(0U, 0);
-                        else result_holder.SetValue(0UL, 0);
-
-                        type_holder.SetValue(integer, 0); // Insert the value to convert into the preallocated holder array
-                        Buffer.BlockCopy(type_holder, 0, result_holder, 0, bytes); // Perform an internal copy to the byte-based holder
-                        integer = Support.SwapEndian(integer = result_holder.GetValue(0));
-                    }
-            }
-            return
-                integer <= 240 ? 1 :
-                integer <= 2287 ? 2 :
-                integer <= 67823 ? 3 :
-                integer <= 16777215 ? 4 :
-                integer <= 4294967295 ? 5 :
-                integer <= 1099511627775 ? 6 :
-                integer <= 281474976710655 ? 7 :
-                integer <= 72057594037927935 ? 8 :
-                9;
-        }
-
-        // Supported datatypes for serialization
-        private static bool IsSupportedType(Type t) => supportedTypes.Contains(t);
-
-        // Specifies how many bits will be written
-        private static long GetBitAllocation(Type t) =>
-            t == typeof(bool) ? 1 :
-            t == typeof(byte) ? 8 :
-            t == typeof(sbyte) ? 8 :
-            t == typeof(short) ? 16 :
-            t == typeof(char) ? 16 :
-            t == typeof(ushort) ? 16 :
-            t == typeof(int) ? 32 :
-            t == typeof(uint) ? 32 :
-            t == typeof(long) ? 64 :
-            t == typeof(ulong) ? 64 :
-            t == typeof(float) ? 32 :
-            t == typeof(double) ? 64 :
-            t == typeof(decimal) ? 128 :
-            0; // Unknown type
-
-        // Creates a weak reference to the allocated collector so that reuse may be possible
-        public void Dispose()
-        {
-            expired.Add(new WeakReference<object[]>(collect));
-            collect = null;
-        }
-    }
-}

Common/BinaryDistributor.cs

@@ -1,108 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-using Tofvesson.Crypto;
-
-namespace Tofvesson.Common
-{
-    public class BinaryDistributor
-    {
-        private static readonly byte[] holder = new byte[8];
-        private static readonly float[] holder_f = new float[1];
-        private static readonly double[] holder_d = new double[1];
-        private static readonly ulong[] holder_u = new ulong[1];
-        private static readonly uint[] holder_i = new uint[1];
-
-        private readonly byte[] readFrom;
-        private long bitCount = 0;
-        public BinaryDistributor(byte[] readFrom) => this.readFrom = readFrom;
-
-        public bool ReadBit()
-        {
-            bool result = (readFrom[bitCount / 8] & (byte)(1 << (int)(bitCount % 8))) != 0;
-            ++bitCount;
-            return result;
-        }
-
-        public byte ReadByte()
-        {
-            int shift = (int)(bitCount % 8);
-            int index = (int)(bitCount / 8);
-            byte lower_mask = (byte)(0xFF << shift);
-            byte upper_mask = (byte)~lower_mask;
-            byte result = (byte)(((readFrom[index] & lower_mask) >> shift) | (shift == 0 ? 0 : (readFrom[index + 1] & upper_mask) << (8 - shift)));
-            bitCount += 8;
-            return result;
-        }
-
-        public float ReadFloat() => ReadFloating<float>();
-        public double ReadDouble() => ReadFloating<double>();
-        public float[] ReadFloatArray() => ReadFloatingArray<float>();
-        public double[] ReadDoubleArray() => ReadFloatingArray<double>();
-        public ushort ReadUShort() => ReadUnsigned<ushort>();
-        public uint ReadUInt() => ReadUnsigned<uint>();
-        public ulong ReadULong() => ReadUnsigned<ulong>();
-        public sbyte ReadSByte() => (sbyte)ZigZagDecode(ReadByte());
-        public short ReadShort() => (short)ZigZagDecode(ReadUShort());
-        public int ReadInt() => (int)ZigZagDecode(ReadUInt());
-        public long ReadLong() => (long)ZigZagDecode(ReadULong());
-
-        private T ReadUnsigned<T>()
-        {
-            dynamic header = ReadByte();
-            if (header <= 240) return (T) header;
-            if (header <= 248) return (T) (240 + 256 * (header - 241) + ReadByte());
-            if (header == 249) return (T) (header = 2288 + 256 * ReadByte() + ReadByte());
-            dynamic res = ReadByte() | ((long)ReadByte() << 8) | ((long)ReadByte() << 16);
-            if(header > 250)
-            {
-                res |= (long) ReadByte() << 24;
-                if(header > 251)
-                {
-                    res |= (long)ReadByte() << 32;
-                    if(header > 252)
-                    {
-                        res |= (long)ReadByte() << 40;
-                        if (header > 253)
-                        {
-                            res |= (long)ReadByte() << 48;
-                            if (header > 254) res |= (long)ReadByte() << 56;
-                        }
-                    }
-                }
-            }
-            return (T) res;
-        }
-        private T[] ReadFloatingArray<T>()
-        {
-            ushort size = ReadUShort();
-            T[] result = new T[size];
-            for (short s = 0; s < size; ++s)
-                result[s] = ReadFloating<T>();
-            return result;
-        }
-
-        private T ReadFloating<T>()
-        {
-            int size = Marshal.SizeOf(typeof(T));
-            Array type_holder = size == 4 ? holder_f as Array : holder_d as Array;
-            Array result_holder = size == 4 ? holder_i as Array : holder_u as Array;
-            T result;
-            lock(result_holder)
-                lock (type_holder)
-                {
-                    //for (int i = 0; i < size; ++i)
-                    //    holder.SetValue(ReadByte(), i);
-                    if (size == 4) result_holder.SetValue(Support.SwapEndian(ReadUInt()), 0);
-                    else result_holder.SetValue(Support.SwapEndian(ReadULong()), 0);
-                    Buffer.BlockCopy(result_holder, 0, type_holder, 0, size);
-                    result = (T)type_holder.GetValue(0);
-                }
-            return result;
-        }
-        private static dynamic ZigZagDecode(dynamic d) => (((d << (int)(Marshal.SizeOf(d) * 8 - 1)) & 1) | (d >> 1));
-    }
-}

Common/BinaryHelpers.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Tofvesson.Common
+{
+    public static class BinaryHelpers
+    {
+        // Swap endianness of a given integer
+        public static uint SwapEndian(uint value) => (uint)(((value >> 24) & (255 << 0)) | ((value >> 8) & (255 << 8)) | ((value << 8) & (255 << 16)) | ((value << 24) & (255 << 24)));
+        public static ulong SwapEndian(ulong value) =>
+            ((value >> 56) & 0xFF)           |
+            ((value >> 40) & (0xFFUL << 8))  |
+            ((value >> 24) & (0xFFUL << 16)) |
+            ((value >> 8)  & (0xFFUL << 24)) |
+            ((value << 56) & (0xFFUL << 56)) |
+            ((value << 40) & (0xFFUL << 48)) |
+            ((value << 24) & (0xFFUL << 40)) |
+            ((value << 8)  & (0xFFUL << 32)) ;
+
+
+        // How many bytes to write
+        public static int VarIntSize(dynamic integer) =>
+                integer is byte ||
+                integer <= 240 ? 1 :
+                integer <= 2287 ? 2 :
+                integer <= 67823 ? 3 :
+                integer <= 16777215 ? 4 :
+                integer <= 4294967295 ? 5 :
+                integer <= 1099511627775 ? 6 :
+                integer <= 281474976710655 ? 7 :
+                integer <= 72057594037927935 ? 8 :
+                9;
+
+        public static ulong ReadVarInt(IEnumerable<byte> from, int offset)
+        {
+            ulong header = from.ElementAt(0);
+            if (header <= 240) return header;
+            if (header <= 248) return 240 + 256 * (header - 241) + from.ElementAt(1);
+            if (header == 249) return 2288 + 256UL * from.ElementAt(1) + from.ElementAt(2);
+            ulong res = from.ElementAt(1) | ((ulong)from.ElementAt(2) << 8) | ((ulong)from.ElementAt(3) << 16);
+            if (header > 250)
+            {
+                res |= (ulong)from.ElementAt(4) << 24;
+                if (header > 251)
+                {
+                    res |= (ulong)from.ElementAt(5) << 32;
+                    if (header > 252)
+                    {
+                        res |= (ulong)from.ElementAt(6) << 40;
+                        if (header > 253)
+                        {
+                            res |= (ulong)from.ElementAt(7) << 48;
+                            if (header > 254) res |= (ulong)from.ElementAt(8) << 56;
+                        }
+                    }
+                }
+            }
+            return res;
+        }
+
+        public static bool TryReadVarInt(IEnumerable<byte> from, int offset, out int result)
+        {
+            bool b = TryReadVarInt(from, offset, out ulong res);
+            result = (int)res;
+            return b;
+        }
+        public static bool TryReadVarInt(IEnumerable<byte> from, int offset, out ulong result)
+        {
+            try
+            {
+                result = ReadVarInt(from, offset);
+                return true;
+            }
+            catch
+            {
+                result = 0;
+                return false;
+            }
+        }
+
+        public static void WriteVarInt(byte[] to, int offset, dynamic t)
+        {
+            if (t is byte)
+            {
+                to[offset] = (byte)t;
+                return;
+            }
+
+            if (t <= 240) to[offset] = (byte)t;
+            else if (t <= 2287)
+            {
+                to[offset] = (byte)((t - 240) / 256 + 241);
+                to[offset + 1] = (byte)((t - 240) % 256);
+            }
+            else if (t <= 67823)
+            {
+                to[offset] = 249;
+                to[offset + 1] = (byte)((t - 2288) / 256);
+                to[offset + 2] = (byte)((t - 2288) % 256);
+            }
+            else
+            {
+                to[offset + 1] = (byte)(t & 0xFF);
+                to[offset + 2] = (byte)((t >> 8) & 0xFF);
+                to[offset + 3] = (byte)((t >> 16) & 0xFF);
+                if (t > 16777215)
+                {
+                    to[offset + 4] = (byte)((t >> 24) & 0xFF);
+                    if (t > 4294967295)
+                    {
+                        to[offset + 5] = (byte)((t >> 32) & 0xFF);
+                        if (t > 1099511627775)
+                        {
+                            to[offset + 6] = (byte)((t >> 40) & 0xFF);
+                            if (t > 281474976710655)
+                            {
+                                to[offset + 7] = (byte)((t >> 48) & 0xFF);
+                                if (t > 72057594037927935)
+                                {
+                                    to[offset] = 255;
+                                    to[offset + 8] = (byte)((t >> 56) & 0xFF);
+                                }
+                                else to[offset] = 254;
+                            }
+                            else to[offset] = 253;
+                        }
+                        else to[offset] = 252;
+                    }
+                    else to[offset] = 251;
+                }
+                else to[offset] = 250;
+            }
+        }
+    }
+}

Common/BitReader.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Tofvesson.Common
+{
+    public class BitReader
+    {
+        private delegate T Getter<T>();
+        private static readonly float[] holder_f = new float[1];
+        private static readonly double[] holder_d = new double[1];
+        private static readonly ulong[] holder_u = new ulong[1];
+        private static readonly uint[] holder_i = new uint[1];
+
+        private readonly byte[] readFrom;
+        private long bitCount = 0;
+        public BitReader(byte[] readFrom) => this.readFrom = readFrom;
+
+        public bool ReadBool()
+        {
+            bool result = (readFrom[bitCount / 8] & (byte)(1 << (int)(bitCount % 8))) != 0;
+            ++bitCount;
+            return result;
+        }
+
+        public float ReadFloat() => ReadFloating<float>();
+        public double ReadDouble() => ReadFloating<double>();
+        public byte ReadByte()
+        {
+            int shift = (int)(bitCount % 8);
+            int index = (int)(bitCount / 8);
+            byte lower_mask = (byte)(0xFF << shift);
+            byte upper_mask = (byte)~lower_mask;
+            byte result = (byte)(((readFrom[index] & lower_mask) >> shift) | (shift == 0 ? 0 : (readFrom[index + 1] & upper_mask) << (8 - shift)));
+            bitCount += 8;
+            return result;
+        }
+        public void SkipPadded() => bitCount += (8 - (bitCount % 8)) % 8;
+        public ushort ReadUShort() => (ushort)ReadULong();
+        public uint ReadUInt() => (uint)ReadULong();
+        public sbyte ReadSByte() => (sbyte)ZigZagDecode(ReadByte(), 1);
+        public short ReadShort() => (short)ZigZagDecode(ReadUShort(), 2);
+        public int ReadInt() => (int)ZigZagDecode(ReadUInt(), 4);
+        public long ReadLong() => ZigZagDecode(ReadULong(), 8);
+        public float[] ReadFloatArray(int known = -1) => ReadArray(ReadFloat, known);
+        public double[] ReadDoubleArray(int known = -1) => ReadArray(ReadDouble, known);
+        public byte[] ReadByteArray(int known = -1) => ReadArray(ReadByte, known);
+        public ushort[] ReadUShortArray(int known = -1) => ReadArray(ReadUShort, known);
+        public uint[] ReadUIntArray(int known = -1) => ReadArray(ReadUInt, known);
+        public ulong[] ReadULongArray(int known = -1) => ReadArray(ReadULong, known);
+        public sbyte[] ReadSByteArray(int known = -1) => ReadArray(ReadSByte, known);
+        public short[] ReadShortArray(int known = -1) => ReadArray(ReadShort, known);
+        public int[] ReadIntArray(int known = -1) => ReadArray(ReadInt, known);
+        public long[] ReadLongArray(int known = -1) => ReadArray(ReadLong, known);
+        public string ReadString() => Encoding.UTF8.GetString(ReadByteArray());
+
+        public ulong ReadULong()
+        {
+            ulong header = ReadByte();
+            if (header <= 240) return header;
+            if (header <= 248) return 240 + 256 * (header - 241) + ReadByte();
+            if (header == 249) return 2288 + 256UL * ReadByte() + ReadByte();
+            ulong res = ReadByte() | ((ulong)ReadByte() << 8) | ((ulong)ReadByte() << 16);
+            if(header > 250)
+            {
+                res |= (ulong) ReadByte() << 24;
+                if(header > 251)
+                {
+                    res |= (ulong)ReadByte() << 32;
+                    if(header > 252)
+                    {
+                        res |= (ulong)ReadByte() << 40;
+                        if (header > 253)
+                        {
+                            res |= (ulong)ReadByte() << 48;
+                            if (header > 254) res |= (ulong)ReadByte() << 56;
+                        }
+                    }
+                }
+            }
+            return res;
+        }
+        private T[] ReadArray<T>(Getter<T> g, int knownSize = -1)
+        {
+            T[] result = new T[knownSize > 0 ? (uint)knownSize : ReadUInt()];
+            for (ushort s = 0; s < result.Length; ++s)
+                result[s] = g();
+            return result;
+        }
+
+        private T ReadFloating<T>()
+        {
+            int size = Marshal.SizeOf(typeof(T));
+            Array type_holder = size == 4 ? holder_f as Array : holder_d as Array;
+            Array result_holder = size == 4 ? holder_i as Array : holder_u as Array;
+            T result;
+            lock(result_holder)
+                lock (type_holder)
+                {
+                    //for (int i = 0; i < size; ++i)
+                    //    holder.SetValue(ReadByte(), i);
+                    if (size == 4) result_holder.SetValue(BinaryHelpers.SwapEndian(ReadUInt()), 0);
+                    else result_holder.SetValue(BinaryHelpers.SwapEndian(ReadULong()), 0);
+                    Buffer.BlockCopy(result_holder, 0, type_holder, 0, size);
+                    result = (T)type_holder.GetValue(0);
+                }
+            return result;
+        }
+        private static long ZigZagDecode(ulong d, int bytes) => (long)(((d << (bytes * 8 - 1)) & 1) | (d >> 1));
+    }
+}

Common/BitWriter.cs

@@ -0,0 +1,404 @@
+#define UNSAFE_PUSH
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Tofvesson.Common
+{
+    public sealed class BitWriter : IDisposable
+    {
+        private const int PREALLOC_COLLECT = 10;
+        private static readonly Queue<List<object>> listPool = new Queue<List<object>>();
+        
+        private static readonly float[] holder_f = new float[1];
+        private static readonly double[] holder_d = new double[1];
+        private static readonly ulong[] holder_u = new ulong[1];
+        private static readonly uint[] holder_i = new uint[1];
+        private static readonly List<Type> supportedTypes = new List<Type>()
+        {
+            typeof(bool),
+            typeof(byte),
+            typeof(sbyte),
+            typeof(char),
+            typeof(short),
+            typeof(ushort),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(ulong),
+            typeof(float),
+            typeof(double),
+            typeof(decimal)
+        };
+
+        private static readonly FieldInfo
+            dec_lo,
+            dec_mid,
+            dec_hi, 
+            dec_flags;
+
+        static BitWriter()
+        {
+            dec_lo = typeof(decimal).GetField("lo", BindingFlags.NonPublic);
+            dec_mid = typeof(decimal).GetField("mid", BindingFlags.NonPublic);
+            dec_hi = typeof(decimal).GetField("hi", BindingFlags.NonPublic);
+            dec_flags = typeof(decimal).GetField("flags", BindingFlags.NonPublic);
+
+            for (int i = 0; i < PREALLOC_COLLECT; i++)
+            {
+                listPool.Enqueue(new List<object>());
+            }
+        }
+
+        private List<object> collect = null;
+        private bool tempAlloc = false;
+
+        /// <summary>
+        /// Allocates a new binary collector.
+        /// </summary>
+        public BitWriter()
+        {
+            if (listPool.Count == 0)
+            {
+                Debug.WriteLine("BitWriter: Optimized for "+ PREALLOC_COLLECT + " BitWriters. Have you forgotten to dispose?");
+                collect = new List<object>();
+                tempAlloc = true;
+            }
+            else
+            {
+                collect = listPool.Dequeue();
+            }
+        }
+
+#if UNSAFE_PUSH
+        public
+#else
+        private
+# endif
+        void Push<T>(T b, bool known = false)
+        {
+            if (b == null) collect.Add(b);
+            else if (b is string || b.GetType().IsArray || IsSupportedType(b.GetType()))
+                collect.Add(b is string ? Encoding.UTF8.GetBytes(b as string) : b as object);
+            else
+                Debug.WriteLine("BitWriter: The type \"" + b.GetType() + "\" is not supported by the Binary Serializer. It will be ignored!");
+        }
+
+
+        public void WriteBool(bool b)               => Push(b);
+        public void WriteFloat(float f)             => Push(f);
+        public void WriteDouble(double d)           => Push(d);
+        public void WriteByte(byte b)               => Push(b);
+        public void WriteUShort(ushort s)           => Push(s);
+        public void WriteUInt(uint i)               => Push(i);
+        public void WriteULong(ulong l)             => Push(l);
+        public void WriteSByte(sbyte b)             => Push(ZigZagEncode(b, 8));
+        public void WriteShort(short s)             => Push(ZigZagEncode(s, 8));
+        public void WriteInt(int i)                 => Push(ZigZagEncode(i, 8));
+        public void WriteLong(long l)               => Push(ZigZagEncode(l, 8));
+        public void WriteString(string s)           => Push(s);
+        public void WriteAlignBits()                => Push<object>(null);
+        public void WriteFloatArray(float[] f, bool known = false)      => PushArray(f, known);
+        public void WriteDoubleArray(double[] d, bool known = false)    => PushArray(d, known);
+        public void WriteByteArray(byte[] b, bool known = false)        => PushArray(b, known);
+        public void WriteUShortArray(ushort[] s, bool known = false)    => PushArray(s, known);
+        public void WriteUIntArray(uint[] i, bool known = false)        => PushArray(i, known);
+        public void WriteULongArray(ulong[] l, bool known = false)      => PushArray(l, known);
+        public void WriteSByteArray(sbyte[] b, bool known = false)      => PushArray(b, known);
+        public void WriteShortArray(short[] s, bool known = false)      => PushArray(s, known);
+        public void WriteIntArray(int[] i, bool known = false)          => PushArray(i, known);
+        public void WriteLongArray(long[] l, bool known = false)        => PushArray(l, known);
+
+#if UNSAFE_PUSH
+        public
+#else
+        private
+#endif
+        void PushArray<T>(T[] t, bool knownSize = false)
+        {
+            if (!knownSize) Push((uint)t.Length);
+            bool signed = IsSigned(t.GetType().GetElementType());
+            int size = Marshal.SizeOf(t.GetType().GetElementType());
+            foreach (T t1 in t) Push(signed ? (object)ZigZagEncode(t1 as long? ?? t1 as int? ?? t1 as short? ?? t1 as sbyte? ?? 0, size) : (object)t1);
+        }
+
+        public byte[] Finalize()
+        {
+            byte[] b = new byte[GetFinalizeSize()];
+            Finalize(ref b);
+            return b;
+        }
+        public long Finalize(ref byte[] buffer)
+        {
+            if(buffer == null)
+            {
+                Debug.WriteLine("BitWriter: no buffer provided");
+                return 0;
+            }
+            long bitCount = 0;
+            for (int i = 0; i < collect.Count; ++i) bitCount += collect[i] == null ? (8 - (bitCount % 8)) % 8 : GetBitCount(collect[i]);
+
+            if (buffer.Length < ((bitCount / 8) + (bitCount % 8 == 0 ? 0 : 1)))
+            {
+                Debug.WriteLine("BitWriter: The buffer size is not large enough");
+                return 0;
+            }
+            long bitOffset = 0;
+            bool isAligned = true;
+            foreach (var item in collect)
+                if (item == null)
+                {
+                    bitOffset += (8 - (bitOffset % 8)) % 8;
+                    isAligned = true;
+                }
+                else Serialize(item, buffer, ref bitOffset, ref isAligned);
+
+            return (bitCount / 8) + (bitCount % 8 == 0 ? 0 : 1);
+        }
+
+        public long GetFinalizeSize()
+        {
+            long bitCount = 0;
+            for (int i = 0; i < collect.Count; ++i) bitCount += collect[i]==null ? (8 - (bitCount % 8)) % 8 : GetBitCount(collect[i]);
+            return ((bitCount / 8) + (bitCount % 8 == 0 ? 0 : 1));
+        }
+
+        private static void Serialize<T>(T t, byte[] writeTo, ref long bitOffset, ref bool isAligned)
+        {
+            Type type = t.GetType();
+            bool size = false;
+            if (type.IsArray)
+            {
+                var array = t as Array;
+                Serialize((uint)array.Length, writeTo, ref bitOffset, ref isAligned);
+                foreach (var element in array)
+                    Serialize(element, writeTo, ref bitOffset, ref isAligned);
+            }
+            else if (IsSupportedType(type))
+            {
+                long offset = t is bool ? 1 : BytesToRead(t) * 8;
+                if (type == typeof(bool))
+                {
+                    WriteBit(writeTo, t as bool? ?? false, bitOffset);
+                    bitOffset += offset;
+                    isAligned = bitOffset % 8 == 0;
+                }
+                else if (type == typeof(decimal))
+                {
+                    WriteDynamic(writeTo, (int)dec_lo.GetValue(t), 4, bitOffset, isAligned);
+                    WriteDynamic(writeTo, (int)dec_mid.GetValue(t), 4, bitOffset + 32, isAligned);
+                    WriteDynamic(writeTo, (int)dec_hi.GetValue(t), 4, bitOffset + 64, isAligned);
+                    WriteDynamic(writeTo, (int)dec_flags.GetValue(t), 4, bitOffset + 96, isAligned);
+                    bitOffset += offset;
+                }
+                else if ((size = type == typeof(float)) || type == typeof(double))
+                {
+                    int bytes = size ? 4 : 8;
+                    Array type_holder = size ? holder_f as Array : holder_d as Array; // Fetch the preallocated array
+                    Array result_holder = size ? holder_i as Array : holder_u as Array;
+                    lock (result_holder)
+                        lock (type_holder)
+                        {
+                            // Clear artifacts
+                            if (size) result_holder.SetValue(0U, 0);
+                            else result_holder.SetValue(0UL, 0);
+                            type_holder.SetValue(t, 0); // Insert the value to convert into the preallocated holder array
+                            Buffer.BlockCopy(type_holder, 0, result_holder, 0, bytes); // Perform an internal copy to the byte-based holder
+
+                            // Since floating point flag bits are seemingly the highest bytes of the floating point values
+                            // and even very small values have them, we swap the endianness in the hopes of reducing the size
+                            if(size) Serialize(BinaryHelpers.SwapEndian((uint)result_holder.GetValue(0)), writeTo, ref bitOffset, ref isAligned);
+                            else Serialize(BinaryHelpers.SwapEndian((ulong)result_holder.GetValue(0)), writeTo, ref bitOffset, ref isAligned);
+                        }
+                }
+                else
+                {
+                    //bool signed = IsSigned(t.GetType());
+                    ulong value;
+                    /*if (signed)
+                    {
+                        Type t1 = t.GetType();
+                        if (t1 == typeof(sbyte)) value = (byte)ZigZagEncode(t as sbyte? ?? 0, 1);
+                        else if (t1 == typeof(short)) value = (ushort)ZigZagEncode(t as short? ?? 0, 2);
+                        else if (t1 == typeof(int)) value = (uint)ZigZagEncode(t as int? ?? 0, 4);
+                        else /*if (t1 == typeof(long)) value = (ulong)ZigZagEncode(t as long? ?? 0, 8);
+                    }
+                    else*/
+                    if (t is byte)
+                    {
+                        WriteByte(writeTo, t as byte? ?? 0, bitOffset, isAligned);
+                        bitOffset += 8;
+                        return;
+                    }
+                    else if (t is ushort) value = t as ushort? ?? 0;
+                    else if (t is uint) value = t as uint? ?? 0;
+                    else /*if (t is ulong)*/ value = t as ulong? ?? 0;
+
+                    if (value <= 240) WriteByte(writeTo, (byte)value, bitOffset, isAligned);
+                    else if (value <= 2287)
+                    {
+                        WriteByte(writeTo, (value - 240) / 256 + 241, bitOffset, isAligned);
+                        WriteByte(writeTo, (value - 240) % 256, bitOffset + 8, isAligned);
+                    }
+                    else if (value <= 67823)
+                    {
+                        WriteByte(writeTo, 249, bitOffset, isAligned);
+                        WriteByte(writeTo, (value - 2288) / 256, bitOffset + 8, isAligned);
+                        WriteByte(writeTo, (value - 2288) % 256, bitOffset + 16, isAligned);
+                    }
+                    else
+                    {
+                        WriteByte(writeTo, value & 255, bitOffset + 8, isAligned);
+                        WriteByte(writeTo, (value >> 8) & 255, bitOffset + 16, isAligned);
+                        WriteByte(writeTo, (value >> 16) & 255, bitOffset + 24, isAligned);
+                        if (value > 16777215)
+                        {
+                            WriteByte(writeTo, (value >> 24) & 255, bitOffset + 32, isAligned);
+                            if (value > 4294967295)
+                            {
+                                WriteByte(writeTo, (value >> 32) & 255, bitOffset + 40, isAligned);
+                                if (value > 1099511627775)
+                                {
+                                    WriteByte(writeTo, (value >> 40) & 55, bitOffset + 48, isAligned);
+                                    if (value > 281474976710655)
+                                    {
+                                        WriteByte(writeTo, (value >> 48) & 255, bitOffset + 56, isAligned);
+                                        if (value > 72057594037927935)
+                                        {
+                                            WriteByte(writeTo, 255, bitOffset, isAligned);
+                                            WriteByte(writeTo, (value >> 56) & 255, bitOffset + 64, isAligned);
+                                        }
+                                        else WriteByte(writeTo, 254, bitOffset, isAligned);
+                                    }
+                                    else WriteByte(writeTo, 253, bitOffset, isAligned);
+                                }
+                                else WriteByte(writeTo, 252, bitOffset, isAligned);
+                            }
+                            else WriteByte(writeTo, 251, bitOffset, isAligned);
+                        }
+                        else WriteByte(writeTo, 250, bitOffset, isAligned);
+                    }
+                    bitOffset += BytesToRead(value) * 8;
+                }
+            }
+        }
+
+        private static byte Read7BitRange(byte higher, byte lower, int bottomBits) => (byte)((higher << bottomBits) & (lower & (0xFF << (8-bottomBits))));
+        private static byte ReadNBits(byte from, int offset, int count) => (byte)(from & ((0xFF >> (8-count)) << offset));
+
+        private static bool IsSigned(Type t) => t == typeof(sbyte) || t == typeof(short) || t == typeof(int) || t == typeof(long);
+
+        private static Type GetUnsignedType(Type t) =>
+            t == typeof(sbyte) ? typeof(byte) :
+            t == typeof(short) ? typeof(ushort) :
+            t == typeof(int) ? typeof(uint) :
+            t == typeof(long) ? typeof(ulong) :
+            null;
+
+        private static ulong ZigZagEncode(long d, int bytes) => (ulong)(((d >> (bytes * 8 - 1))&1) | (d << 1));
+
+        private static long GetBitCount<T>(T t)
+        {
+            Type type = t.GetType();
+            long count = 0;
+            if (type.IsArray)
+            {
+                Type elementType = type.GetElementType();
+
+                count += BytesToRead((t as Array).Length) * 8; // Int16 array size. Arrays shouldn't be syncing more than 65k elements
+
+                if (elementType == typeof(bool)) count += (t as Array).Length;
+                else
+                    foreach (var element in t as Array)
+                        count += GetBitCount(element);
+            }
+            else if (IsSupportedType(type))
+            {
+                long ba = t is bool ? 1 : BytesToRead(t)*8;
+                if (ba == 0) count += Encoding.UTF8.GetByteCount(t as string);
+                else if (t is bool || t is decimal) count += ba;
+                else count += BytesToRead(t) * 8;
+            }
+            //else
+            //    Debug.LogWarning("MLAPI: The type \"" + b.GetType() + "\" is not supported by the Binary Serializer. It will be ignored");
+            return count;
+        }
+
+        private static void WriteBit(byte[] b, bool bit, long index)
+            => b[index / 8] = (byte)((b[index / 8] & ~(1 << (int)(index % 8))) | (bit ? 1 << (int)(index % 8) : 0));
+        private static void WriteByte(byte[] b, ulong value, long index, bool isAligned) => WriteByte(b, (byte)value, index, isAligned);
+        private static void WriteByte(byte[] b, byte value, long index, bool isAligned)
+        {
+            if (isAligned) b[index / 8] = value;
+            else
+            {
+                int byteIndex = (int)(index / 8);
+                int shift = (int)(index % 8);
+                byte upper_mask = (byte)(0xFF << shift);
+
+                b[byteIndex] = (byte)((b[byteIndex] & (byte)~upper_mask) | (value << shift));
+                b[byteIndex + 1] = (byte)((b[byteIndex + 1] & upper_mask) | (value >> (8 - shift)));
+            }
+        }
+        private static void WriteDynamic(byte[] b, int value, int byteCount, long index, bool isAligned)
+        {
+            for (int i = 0; i < byteCount; ++i)
+                WriteByte(b, (byte)((value >> (8 * i)) & 0xFF), index + (8 * i), isAligned);
+        }
+
+        private static int BytesToRead(object i)
+        {
+            if (i is byte) return 1;
+            bool size;
+            ulong integer;
+            if (i is decimal) return BytesToRead((int)dec_flags.GetValue(i)) + BytesToRead((int)dec_lo.GetValue(i)) + BytesToRead((int)dec_mid.GetValue(i)) + BytesToRead((int)dec_hi.GetValue(i));
+            if ((size = i is float) || i is double)
+            {
+                int bytes = size ? 4 : 8;
+                Array type_holder = size ? holder_f as Array : holder_d as Array; // Fetch the preallocated array
+                Array result_holder = size ? holder_i as Array : holder_u as Array;
+                lock (result_holder)
+                    lock (type_holder)
+                    {
+                        // Clear artifacts
+                        if (size) result_holder.SetValue(0U, 0);
+                        else result_holder.SetValue(0UL, 0);
+
+                        type_holder.SetValue(i, 0); // Insert the value to convert into the preallocated holder array
+                        Buffer.BlockCopy(type_holder, 0, result_holder, 0, bytes); // Perform an internal copy to the byte-based holder
+                        if(size) integer = BinaryHelpers.SwapEndian((uint)result_holder.GetValue(0));
+                        else integer = BinaryHelpers.SwapEndian((ulong)result_holder.GetValue(0));
+                    }
+            }
+            else integer = i as ulong? ?? i as uint? ?? i as ushort? ?? i as byte? ?? 0;
+            return
+                integer <= 240 ? 1 :
+                integer <= 2287 ? 2 :
+                integer <= 67823 ? 3 :
+                integer <= 16777215 ? 4 :
+                integer <= 4294967295 ? 5 :
+                integer <= 1099511627775 ? 6 :
+                integer <= 281474976710655 ? 7 :
+                integer <= 72057594037927935 ? 8 :
+                9;
+        }
+
+        // Supported datatypes for serialization
+        private static bool IsSupportedType(Type t) => supportedTypes.Contains(t);
+        
+        // Creates a weak reference to the allocated collector so that reuse may be possible
+        public void Dispose()
+        {
+            if (!tempAlloc)
+            {
+                collect.Clear();
+                listPool.Enqueue(collect);
+            }
+            collect = null; //GC picks this
+        }
+    }
+}

Common/Common.csproj

@@ -63,8 +63,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AccountInfo.cs" />
-    <Compile Include="BinaryCollector.cs" />
+    <Compile Include="BinaryHelpers.cs" />
-    <Compile Include="BinaryDistributor.cs" />
+    <Compile Include="BitReader.cs" />
+    <Compile Include="BitWriter.cs" />
     <Compile Include="Cryptography\AES.cs" />
     <Compile Include="Cryptography\CBC.cs" />
     <Compile Include="Collections.cs" />

Common/NetClient.cs

@@ -9,6 +9,7 @@ using System.Numerics;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Tofvesson.Common;
 using Tofvesson.Crypto;
 
 namespace Common
@@ -155,7 +156,7 @@ namespace Common
             {
                 lock (messageBuffer)
                 {
-                    foreach (byte[] message in messageBuffer) Connection.Send(NetSupport.WithHeader(message));
+                    foreach (byte[] message in messageBuffer) Connection.Send(NetSupport.WithHeader(Crypto.Encrypt(message)));
                     if (messageBuffer.Count > 0) lastComm = DateTime.Now.Ticks;
                     messageBuffer.Clear();
                 }
@@ -166,8 +167,8 @@ namespace Common
                 ibuf.EnqueueAll(buffer, 0, read);
                 if (read > 0) lastComm = DateTime.Now.Ticks;
             }
-            if (mLen == 0 && ibuf.Count >= 4)
+            if (mLen == 0 && BinaryHelpers.TryReadVarInt(ibuf, 0, out mLen))
-                mLen = Support.ReadInt(ibuf.Dequeue(4), 0);
+                ibuf.Dequeue(BinaryHelpers.VarIntSize(mLen));
             if (mLen != 0 && ibuf.Count >= mLen)
             {
                 // Got a full message. Parse!
@@ -189,12 +190,13 @@ namespace Common
                     byte[] read = Crypto.Decrypt(message);
 
                     // Read the decrypted message length
-                    int mlenInner = Support.ReadInt(read, 0);
+                    int mlenInner = (int) BinaryHelpers.ReadVarInt(read, 0);
+                    int size = BinaryHelpers.VarIntSize(mlenInner);
                     if (mlenInner == 0) return false; // Got a ping packet
 
                     // Send the message to the handler and get a response
                     bool live = true;
-                    string response = handler(read.SubArray(4, 4 + mlenInner).ToUTF8String(), assignedValues, ref live);
+                    string response = handler(read.SubArray(size, size + mlenInner).ToUTF8String(), assignedValues, ref live);
 
                     // Send the response (if given one) and drop the connection if the handler tells us to
                     if (response != null) Connection.Send(NetSupport.WithHeader(Crypto.Encrypt(NetSupport.WithHeader(response.ToUTF8Bytes()))));
@@ -205,7 +207,7 @@ namespace Common
                         {
                             Connection.Close();
                         }
-                        catch (Exception) { }
+                        catch { }
                         return true;
                     }
                 }
@@ -220,13 +222,12 @@ namespace Common
         /// Disconnect from server
         /// </summary>
         /// <returns></returns>
-        public virtual async Task<object> Disconnect()
+        public virtual async Task Disconnect()
         {
             NetSupport.DoStateCheck(IsAlive, true);
             Running = false;
 
-
+            await new TaskFactory().StartNew(eventListener.Join);
-            return await new TaskFactory().StartNew<object>(() => { eventListener.Join(); return null; });
         }
 
         // Methods for sending data to the server
@@ -244,7 +245,7 @@ namespace Common
         public virtual void Send(byte[] message)
         {
             NetSupport.DoStateCheck(IsAlive, true);
-            lock (messageBuffer) messageBuffer.Enqueue(Crypto.Encrypt(NetSupport.WithHeader(message)));
+            lock (messageBuffer) messageBuffer.Enqueue(NetSupport.WithHeader(message));
         }
 
         private static bool Read(Socket sock, List<byte> read, byte[] buf, long timeout)

Common/NetSupport.cs

@@ -1,8 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
+using Tofvesson.Common;
 using Tofvesson.Crypto;
 
 namespace Common
@@ -10,20 +13,80 @@ namespace Common
     // Helper methods. WithHeader() should really just be in Support.cs
     public static class NetSupport
     {
+        public enum Compression { int16, int32, int64 }
         public static byte[] WithHeader(string message) => WithHeader(Encoding.UTF8.GetBytes(message));
         public static byte[] WithHeader(byte[] message)
         {
-            byte[] nmsg = new byte[message.Length + 4];
+            int i = BinaryHelpers.VarIntSize(message.Length);
-            Support.WriteToArray(nmsg, message.Length, 0);
+            byte[] nmsg = new byte[message.Length + i];
-            Array.Copy(message, 0, nmsg, 4, message.Length);
+            //Support.WriteToArray(nmsg, message.Length, 0);
+            BinaryHelpers.WriteVarInt(nmsg, 0, message.Length);
+            Array.Copy(message, 0, nmsg, i, message.Length);
+            Debug.WriteLine($"Compression:  {nmsg.Length}/{Compress(nmsg, Compression.int16).Length}/{Compress(nmsg, Compression.int32).Length}/{Compress(nmsg, Compression.int64).Length}");
+            Debug.WriteLine($"Matches: {Support.ArraysEqual(nmsg, Decompress(Compress(nmsg)))}");
             return nmsg;
         }
 
+        public static byte[] Decompress(byte[] cmpMessage, Compression method = Compression.int32)
+        {
+            BitReader reader = new BitReader(cmpMessage);
+            byte[] decomp = new byte[reader.ReadUInt()];
+            int size = method == Compression.int16 ? 2 : method == Compression.int32 ? 4 : 8;
+            int count = (decomp.Length / size) + (decomp.Length % size == 0 ? 0 : 1);
+            for(int i = 0; i<count; ++i)
+            {
+                dynamic value = size == 2 ? reader.ReadUShort() : size == 4 ? reader.ReadUInt() : reader.ReadULong();
+                for (int j = Math.Min(size, decomp.Length - (i * size)) - 1; j >= 0; --j) decomp[(i * size) + j] = (byte)((int)(value >> (8 * j)) & 0xFF);
+            }
+            return decomp;
+        }
+
         public static byte[] FromHeaded(byte[] msg, int offset) => msg.SubArray(offset + 4, offset + 4 + Support.ReadInt(msg, offset));
 
         internal static void DoStateCheck(bool state, bool target)
         {
             if (state != target) throw new InvalidOperationException("Bad state!");
         }
+
+        private delegate void WriteFunc(BitWriter writer, byte[] data, int index);
+        private static WriteFunc
+            func16 = (w, d, i) => w.WriteUShort(ReadUShort(d, i * 2)),
+            func32 = (w, d, i) => w.WriteUInt(ReadUInt(d, i * 4)),
+            func64 = (w, d, i) => w.WriteULong(ReadULong(d, i * 8));
+        private static byte[] Compress(byte[] data, Compression method = Compression.int32)
+        {
+            int size = method == Compression.int16 ? 2 : method == Compression.int32 ? 4 : 8;
+            int count = (data.Length / size) + (data.Length % size == 0 ? 0 : 1);
+            WriteFunc func = size == 2 ? func16 : size == 4 ? func32 : func64;
+            using (BitWriter writer = new BitWriter())
+            {
+                writer.WriteUInt((uint)data.Length);
+                for (int i = 0; i < count; ++i)
+                    func(writer, data, i);
+                return writer.Finalize();
+            }
+        }
+
+        private static ushort ReadUShort(byte[] b, int offset) =>
+            (ushort)((ushort)TryReadByte(b, offset) |
+            (ushort)((ushort)TryReadByte(b, offset + 1) << 8));
+
+        private static uint ReadUInt(byte[] b, int offset) =>
+             (uint)TryReadByte(b, offset) |
+            ((uint)TryReadByte(b, offset + 1) << 8) |
+            ((uint)TryReadByte(b, offset + 2) << 16) |
+            ((uint)TryReadByte(b, offset + 3) << 24);
+
+        private static ulong ReadULong(byte[] b, int offset) =>
+             (ulong)TryReadByte(b, offset) |
+            ((ulong)TryReadByte(b, offset + 1) << 8) |
+            ((ulong)TryReadByte(b, offset + 2) << 16) |
+            ((ulong)TryReadByte(b, offset + 3) << 24) |
+            ((ulong)TryReadByte(b, offset + 4) << 32) |
+            ((ulong)TryReadByte(b, offset + 5) << 40) |
+            ((ulong)TryReadByte(b, offset + 6) << 48) |
+            ((ulong)TryReadByte(b, offset + 7) << 56);
+
+        private static byte TryReadByte(byte[] b, int idx) => idx >= b.Length ? (byte) 0 : b[idx];
     }
 }

Common/SHA.cs

@@ -32,12 +32,13 @@ namespace Tofvesson.Crypto
 
             int chunks = msg.Length / 64;
 
-            // Perform hashing for each 512-bit block
+            // Split block into words (allocated out here to prevent massive garbage buildup)
-            for(int i = 0; i<chunks; ++i)
-            {
-
-                // Split block into words
             uint[] w = new uint[80];
+
+            // Perform hashing for each 512-bit block
+            for (int i = 0; i<chunks; ++i)
+            {
+                // Compute initial source data from padded message
                 for(int j = 0; j<16; ++j)
                     w[j] |= (uint) ((msg[i * 64 + j * 4] << 24) | (msg[i * 64 + j * 4 + 1] << 16) | (msg[i * 64 + j * 4 + 2] << 8) | (msg[i * 64 + j * 4 + 3] << 0));
 
@@ -63,6 +64,8 @@ namespace Tofvesson.Crypto
                     b = a;
                     a = tmp;
                 }
+
+                // Add to result
                 h0 += a;
                 h1 += b;
                 h2 += c;
@@ -73,6 +76,88 @@ namespace Tofvesson.Crypto
             return Support.WriteContiguous(new byte[20], 0, Support.SwapEndian(h0), Support.SwapEndian(h1), Support.SwapEndian(h2), Support.SwapEndian(h3), Support.SwapEndian(h4));
         }
 
+        public struct SHA1Result
+        {
+            public uint i0, i1, i2, i3, i4;
+            public byte Get(int idx) => (byte)((idx < 4 ? i0 : idx < 8 ? i1 : idx < 12 ? i2 : idx < 16 ? i3 : i4)>>(8*(idx%4)));
+        }
+        public static SHA1Result SHA1_Opt(byte[] message)
+        {
+            SHA1Result result = new SHA1Result
+            {
+                // Initialize buffers
+                i0 = 0x67452301,
+                i1 = 0xEFCDAB89,
+                i2 = 0x98BADCFE,
+                i3 = 0x10325476,
+                i4 = 0xC3D2E1F0
+            };
+
+            // Pad message
+            long len = message.Length * 8;
+            int
+                ml = message.Length + 1,
+                max = ml + ((960 - (ml * 8 % 512)) % 512) / 8 + 8;
+
+            // Replaces the allocation of a lot of bytes
+            byte GetMsg(int idx)
+            {
+                if (idx < message.Length)
+                    return message[idx];
+                else if (idx == message.Length)
+                    return 0x80;
+                else if (max - idx <= 8)
+                    return (byte)((len >> ((max - 1 - idx) * 8)) & 255);
+                return 0;
+            }
+
+            int chunks = max / 64;
+
+            // Replaces the recurring allocation of 80 uints
+            uint ComputeIndex(int block, int idx)
+            {
+                if (idx < 16)
+                    return (uint)((GetMsg(block * 64 + idx * 4) << 24) | (GetMsg(block * 64 + idx * 4 + 1) << 16) | (GetMsg(block * 64 + idx * 4 + 2) << 8) | (GetMsg(block * 64 + idx * 4 + 3) << 0));
+                else
+                    return Rot(ComputeIndex(block, idx - 3) ^ ComputeIndex(block, idx - 8) ^ ComputeIndex(block, idx - 14) ^ ComputeIndex(block, idx - 16), 1);
+            }
+
+            // Perform hashing for each 512-bit block
+            for (int i = 0; i < chunks; ++i)
+            {
+
+                // Initialize chunk-hash
+                uint
+                    a = result.i0,
+                    b = result.i1,
+                    c = result.i2,
+                    d = result.i3,
+                    e = result.i4;
+
+                // Do hash rounds
+                for (int t = 0; t < 80; ++t)
+                {
+                    uint tmp = Rot(a, 5) + func(t, b, c, d) + e + K(t) + ComputeIndex(i, t);
+                    e = d;
+                    d = c;
+                    c = Rot(b, 30);
+                    b = a;
+                    a = tmp;
+                }
+                result.i0 += a;
+                result.i1 += b;
+                result.i2 += c;
+                result.i3 += d;
+                result.i4 += e;
+            }
+            result.i0 = Support.SwapEndian(result.i0);
+            result.i1 = Support.SwapEndian(result.i1);
+            result.i2 = Support.SwapEndian(result.i2);
+            result.i3 = Support.SwapEndian(result.i3);
+            result.i4 = Support.SwapEndian(result.i4);
+            return result;
+        }
+
         private static uint func(int t, uint b, uint c, uint d) =>
             t < 20 ? (b & c) | ((~b) & d) :
             t < 40 ? b ^ c ^ d :

Common/Support.cs

@@ -422,13 +422,16 @@ namespace Tofvesson.Crypto
         
         // Swap endianness of a given integer
         public static uint SwapEndian(uint value) => (uint)(((value >> 24) & (255 << 0)) | ((value >> 8) & (255 << 8)) | ((value << 8) & (255 << 16)) | ((value << 24) & (255 << 24)));
-        public static ulong SwapEndian(ulong value)
+        public static ulong SwapEndian(ulong value) =>
-        {
+            ((value >> 56) & 0xFF) |
-            ulong res = 0;
+            ((value >> 40) & (0xFFUL << 8)) |
-            for(int i = 0; i<8; ++i)
+            ((value >> 24) & (0xFFUL << 16)) |
-                res = (res << 8) | ((value >> i * 8) & 0xFF);
+            ((value >> 8) & (0xFFUL << 24)) |
-            return res;
+            ((value << 56) & (0xFFUL << 56)) |
-        }
+            ((value << 40) & (0xFFUL << 48)) |
+            ((value << 24) & (0xFFUL << 40)) |
+            ((value << 8) & (0xFFUL << 32));
+
         public static ulong RightShift(this ulong value, int shift) => shift < 0 ? value << -shift : value >> shift;
         public static string ToHexString(byte[] value)
         {
@@ -440,6 +443,8 @@ namespace Tofvesson.Crypto
             }
             return builder.ToString();
         }
+        public static string ToBase64String(this string text) => Convert.ToBase64String(text.ToUTF8Bytes());
+        public static string FromBase64String(this string text) => Convert.FromBase64String(text).ToUTF8String();
 
         public static bool ReadYNBool(this TextReader reader, string nonDefault) => reader.ReadLine().ToLower().Equals(nonDefault);
 

Server/Database.cs

@@ -179,12 +179,19 @@ namespace Server
             writer.WriteStartElement("User");
             if (u.IsAdministrator) writer.WriteAttributeString("admin", "", "true");
             writer.WriteElementString("Name", u.Name);
-            writer.WriteElementString("Balance", u.Balance.ToString());
+            //writer.WriteElementString("Balance", u.Balance.ToString());
             writer.WriteElementString("Password", u.PasswordHash);
             writer.WriteElementString("Salt", u.Salt);
-            foreach (var tx in u.History)
+            foreach(var acc in u.accounts)
+            {
+                writer.WriteStartElement("Account");
+                writer.WriteElementString("Name", acc.name);
+                writer.WriteElementString("Balance", acc.balance.ToString());
+                foreach (var tx in acc.History)
                 {
                     writer.WriteStartElement("Transaction");
+                    writer.WriteElementString("FromAccount", tx.fromAccount);
+                    writer.WriteElementString("ToAccount", tx.toAccount);
                     writer.WriteElementString(tx.to.Equals(u.Name) ? "From" : "To", tx.to.Equals(u.Name) ? tx.from : tx.to);
                     writer.WriteElementString("Balance", tx.amount.ToString());
                     if (tx.meta != null && tx.meta.Length != 0) writer.WriteElementString("Meta", tx.meta);
@@ -192,6 +199,8 @@ namespace Server
                 }
                 writer.WriteEndElement();
             }
+            writer.WriteEndElement();
+        }
 
         private static string GenerateTempFileName(string prefix, string suffix)
         {
@@ -225,9 +234,10 @@ namespace Server
             return e;
         }
 
-        public User GetUser(string name) => FirstUser(u => u.Name.Equals(name));
+        public User GetUser(string name) => name.Equals("System") ? null : FirstUser(u => u.Name.Equals(name));
         public User FirstUser(Predicate<User> p)
         {
+            if (p == null) return null; // Done to conveniently handle system insertions
             User u;
             foreach (var entry in loadedUsers)
                 if (p(u=FromEncoded(entry)))
@@ -248,7 +258,7 @@ namespace Server
                     if (reader.Name.Equals("User"))
                     {
                         User n = User.Parse(ReadEntry(reader), this);
-                        if (n != null && p(n=FromEncoded(n)))
+                        if (n != null && p(FromEncoded(n)))
                         {
                             if (!loadedUsers.Contains(n)) loadedUsers.Add(n);
                             return n;
@@ -259,19 +269,30 @@ namespace Server
             return null;
         }
 
-        public bool AddTransaction(string sender, string recipient, long amount, string message = null)
+        public bool AddTransaction(string sender, string recipient, decimal amount, string fromAccount, string toAccount, string message = null)
         {
             User from = FirstUser(u => u.Name.Equals(sender));
             User to = FirstUser(u => u.Name.Equals(recipient));
+            Account fromAcc = from?.GetAccount(fromAccount);
+            Account toAcc = to.GetAccount(toAccount);
 
-            if (to == null || (from == null && !to.IsAdministrator)) return false;
+            // Errant states
+            if (
+                to == null ||
+                (from == null && !to.IsAdministrator) ||
+                toAcc == null ||
+                (from != null && fromAcc == null) ||
+                (from != null && fromAcc.balance<amount)
+                ) return false;
 
-            Transaction tx = new Transaction(from == null ? "System" : from.Name, to.Name, amount, message);
+            Transaction tx = new Transaction(from == null ? "System" : from.Name, to.Name, amount, message, fromAccount, toAccount);
-            to.History.Add(tx);
+            toAcc.History.Add(tx);
+            toAcc.balance += amount;
             AddUser(to);
             if (from != null)
             {
-                from.History.Add(tx);
+                fromAcc.History.Add(tx);
+                fromAcc.balance -= amount;
                 AddUser(from);
             }
             return true;
@@ -299,8 +320,8 @@ namespace Server
             return l.ToArray();
         }
 
-        public bool ContainsUser(string user) => FirstUser(u => u.Name.Equals(user)) != null;
+        public bool ContainsUser(string user) => user.Equals("System") || FirstUser(u => u.Name.Equals(user)) != null;
-        public bool ContainsUser(User user) => FirstUser(u => u.Name.Equals(user.Name)) != null;
+        public bool ContainsUser(User user) => user.Name.Equals("System") || FirstUser(u => u.Name.Equals(user.Name)) != null;
 
         private bool Traverse(XmlReader reader, params string[] downTo)
         {
@@ -324,11 +345,15 @@ namespace Server
         {
             User u = new User(entry);
             u.Name = Encode(u.Name);
-            for (int i = 0; i < u.History.Count; ++i)
+            foreach(var account in u.accounts)
             {
-                u.History[i].to = Encode(u.History[i].to);
+                account.name = Encode(account.name);
-                u.History[i].from = Encode(u.History[i].from);
+                foreach(var transaction in account.History)
-                u.History[i].meta = Encode(u.History[i].meta);
+                {
+                    transaction.to = Encode(transaction.to);
+                    transaction.from = Encode(transaction.from);
+                    transaction.meta = Encode(transaction.meta);
+                }
             }
             return u;
         }
@@ -337,11 +362,15 @@ namespace Server
         {
             User u = new User(entry);
             u.Name = Decode(u.Name);
-            for (int i = 0; i < u.History.Count; ++i)
+            foreach (var account in u.accounts)
             {
-                u.History[i].to = Decode(u.History[i].to);
+                account.name = Decode(account.name);
-                u.History[i].from = Decode(u.History[i].from);
+                foreach (var transaction in account.History)
-                u.History[i].meta = Decode(u.History[i].meta);
+                {
+                    transaction.to = Decode(transaction.to);
+                    transaction.from = Decode(transaction.from);
+                    transaction.meta = Decode(transaction.meta);
+                }
             }
             return u;
         }
@@ -380,6 +409,8 @@ namespace Server
                 return this;
             }
 
+            public Entry AddNested(string name, string text) => AddNested(new Entry(name, text));
+
             public Entry AddAttribute(string key, string value)
             {
                 Attributes[key] = value;
@@ -415,40 +446,56 @@ namespace Server
             }
         }
 
+        public class Account
+        {
+            public User owner;
+            public decimal balance;
+            public string name;
+            public List<Transaction> History { get; }
+            public Account(User owner, decimal balance, string name)
+            {
+                History = new List<Transaction>();
+                this.owner = owner;
+                this.balance = balance;
+                this.name = name;
+            }
+            public Account(Account copy) : this(copy.owner, copy.balance, copy.name)
+                => History.AddRange(copy.History);
+            public Account AddTransaction(Transaction tx)
+            {
+                History.Add(tx);
+                return this;
+            }
+        }
+
         public class User
         {
             public bool ProblematicTransactions { get; internal set; }
             public string Name { get; internal set; }
-            public long Balance { get; set; }
             public bool IsAdministrator { get; set; }
             public string PasswordHash { get; internal set; }
             public string Salt { get; internal set; }
-            public List<Transaction> History { get; }
+            public List<Account> accounts = new List<Account>();
-            private User()
-            {
-                Name = "";
-                History = new List<Transaction>();
-            }
 
-            public User(User copy) : this()
+            private User()
+            { }
+
+            public User(User copy)
             {
                 this.ProblematicTransactions = copy.ProblematicTransactions;
                 this.Name = copy.Name;
-                this.Balance = copy.Balance;
                 this.IsAdministrator = copy.IsAdministrator;
                 this.PasswordHash = copy.PasswordHash;
                 this.Salt = copy.Salt;
-                this.History.AddRange(copy.History);
+                accounts.AddRange(copy.accounts);
             }
 
-            public User(string name, string passHash, string salt, long balance, bool generatePass = false, List<Transaction> transactionHistory = null, bool admin = false)
+            public User(string name, string passHash, string salt, bool generatePass = false, bool admin = false)
-                : this(name, passHash, Encoding.UTF8.GetBytes(salt), balance, generatePass, transactionHistory, admin)
+                : this(name, passHash, Encoding.UTF8.GetBytes(salt), generatePass, admin)
             { }
 
-            public User(string name, string passHash, byte[] salt, long balance, bool generatePass = false, List<Transaction> transactionHistory = null, bool admin = false)
+            public User(string name, string passHash, byte[] salt, bool generatePass = false, bool admin = false)
             {
-                History = transactionHistory ?? new List<Transaction>();
-                Balance = balance;
                 Name = name;
                 IsAdministrator = admin;
                 Salt = Convert.ToBase64String(salt);
@@ -458,26 +505,30 @@ namespace Server
             public bool Authenticate(string password)
                 => Convert.ToBase64String(KDF.PBKDF2(KDF.HMAC_SHA1, Encoding.UTF8.GetBytes(password), Encoding.UTF8.GetBytes(Salt), 8192, 320)).Equals(PasswordHash);
 
-            public User AddTransaction(Transaction tx)
+            public void AddAccount(Account a) => accounts.Add(a);
-            {
+            public Account GetAccount(string name) => accounts.FirstOrDefault(a => a.name.Equals(name));
-                History.Add(tx);
-                return this;
-            }
-
             private Entry Serialize()
             {
                 Entry root = new Entry("User")
-                    .AddNested(new Entry("Name", Name))
+                    .AddNested(new Entry("Name", Name));
-                    .AddNested(new Entry("Balance", Balance.ToString()).AddAttribute("omit", "true"));
+                foreach (var account in accounts)
-                foreach (var transaction in History)
+                {
+                    Entry acc = new Entry("Account")
+                        .AddNested("Name", account.name)
+                        .AddNested(new Entry("Balance", account.balance.ToString()).AddAttribute("omit", "true"));
+                    foreach (var transaction in account.History)
                     {
                         Entry tx =
                             new Entry("Transaction")
                                 .AddAttribute("omit", "true")
-                            .AddNested(new Entry(transaction.to.Equals(Name) ? "From" : "To", transaction.to.Equals(Name) ? transaction.from : transaction.to))
+                                .AddNested(transaction.to.Equals(Name) ? "From" : "To", transaction.to.Equals(Name) ? transaction.from : transaction.to)
-                            .AddNested(new Entry("Balance", transaction.amount.ToString()));
+                                .AddNested("FromAccount", transaction.fromAccount)
-                    if (transaction.meta != null) tx.AddNested(new Entry("Meta", transaction.meta));
+                                .AddNested("ToAccount", transaction.toAccount)
-                    root.AddNested(tx);
+                                .AddNested("Balance", transaction.amount.ToString());
+                        if (transaction.meta != null) tx.AddNested("Meta", transaction.meta);
+                        acc.AddNested(tx);
+                    }
+                    root.AddNested(acc);
                 }
                 return root;
             }
@@ -489,38 +540,68 @@ namespace Server
                 foreach (var entry in e.NestedEntries)
                 {
                     if (entry.Name.Equals("Name")) user.Name = entry.Text;
-                    else if (entry.Name.Equals("Balance")) user.Balance = long.TryParse(entry.Text, out long l) ? l : 0;
+                    else if (entry.Name.Equals("Account"))
+                    {
+                        string name = null;
+                        decimal balance = 0;
+                        List<Transaction> history = new List<Transaction>();
+                        foreach (var accountData in entry.NestedEntries)
+                        {
+                            if (accountData.Name.Equals("Name")) name = accountData.Text;
                             else if (entry.Name.Equals("Transaction"))
                             {
+                                string fromAccount = null;
+                                string toAccount = null;
                                 string from = null;
                                 string to = null;
-                        long amount = -1;
+                                decimal amount = -1;
                                 string meta = "";
                                 foreach (var e1 in entry.NestedEntries)
                                 {
                                     if (e1.Name.Equals("To")) to = e1.Text;
                                     else if (e1.Name.Equals("From")) from = e1.Text;
-                            else if (e1.Name.Equals("Balance")) amount = long.TryParse(e1.Text, out amount) ? amount : 0;
+                                    else if (e1.Name.Equals("FromAccount")) fromAccount = e1.Text;
+                                    else if (e1.Name.Equals("ToAccount")) toAccount = e1.Text;
+                                    else if (e1.Name.Equals("Balance")) amount = decimal.TryParse(e1.Text, out amount) ? amount : 0;
                                     else if (e1.Name.Equals("Meta")) meta = e1.Text;
                                 }
-                        if ((from == null && to == null) || (from != null && to != null) || amount <= 0) user.ProblematicTransactions = true;
+                                if ( // Errant states for transaction data
-                        else user.History.Add(new Transaction(from, to, amount, meta));
+                                    (from == null && to == null) ||
+                                    (from != null && to != null) ||
+                                    amount <= 0 ||
+                                    fromAccount == null ||
+                                    toAccount == null
+                                    )
+                                    user.ProblematicTransactions = true;
+                                else history.Add(new Transaction(from, to, amount, meta, fromAccount, toAccount));
+                            }
+                            else if (entry.Name.Equals("Balance")) balance = decimal.TryParse(entry.Text, out decimal l) ? l : 0;
+                        }
+                        if (name == null || balance < 0)
+                        {
+                            Output.Fatal($"Found errant account entry! Detected user name: {user.Name}");
+                            return null; // This is a hard error
+                        }
+                        Account a = new Account(user, balance, name);
+                        a.History.AddRange(history);
+                        user.AddAccount(a);
                     }
                     else if (entry.Name.Equals("Password")) user.PasswordHash = entry.Text;
                     else if (entry.Name.Equals("Salt")) user.Salt = entry.Text;
                 }
                 if (user.Name == null || user.Name.Length == 0 || user.PasswordHash == null || user.Salt == null || user.PasswordHash.Length==0 || user.Salt.Length==0) return null;
-                if (user.Balance < 0) user.Balance = 0;
 
                 // Populate transaction names
-                foreach (var transaction in user.History)
+                foreach (var account in user.accounts)
+                    foreach (var transaction in account.History)
                         if (transaction.from == null) transaction.from = user.Name;
                         else if (transaction.to == null) transaction.to = user.Name;
 
                 return user;
             }
 
-            public Transaction CreateTransaction(User recipient, long amount, string message = null) => new Transaction(this.Name, recipient.Name, amount, message);
+            public Transaction CreateTransaction(User recipient, long amount, Account fromAccount, Account toAccount, string message = null) =>
+                new Transaction(this.Name, recipient.Name, amount, message, fromAccount.name, toAccount.name);
 
             public override bool Equals(object obj) => obj is User && ((User)obj).Name.Equals(Name);
 
@@ -532,13 +613,17 @@ namespace Server
 
         public class Transaction
         {
+            public string fromAccount;
+            public string toAccount;
             public string from;
             public string to;
-            public long amount;
+            public decimal amount;
             public string meta;
 
-            public Transaction(string from, string to, long amount, string meta)
+            public Transaction(string from, string to, decimal amount, string meta, string fromAccount, string toAccount)
             {
+                this.fromAccount = fromAccount;
+                this.toAccount = toAccount;
                 this.from = from;
                 this.to = to;
                 this.amount = amount;

Server/Output.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Server
+{
+    public static class Output
+    {
+        public static void WriteLine(string message, bool error = false)
+        {
+            if (error) Error(message);
+            else Info(message);
+        }
+        public static void Write(string message, bool error)
+        {
+            if (error) Error(message, false);
+            else Info(message, false);
+        }
+        public static void Positive(string message, bool newline = true) => Write(message, ConsoleColor.DarkGreen, ConsoleColor.Black, newline, Console.Out);
+        public static void Info(string message, bool newline = true) => Write(message, ConsoleColor.Gray, ConsoleColor.Black, newline, Console.Out);
+        public static void Error(string message, bool newline = true) => Write(message, ConsoleColor.Gray, ConsoleColor.Black, newline, Console.Out);
+        public static void Fatal(string message, bool newline = true) => Write(message, ConsoleColor.Gray, ConsoleColor.Black, newline, Console.Error);
+
+        private static void Write(string message, ConsoleColor f, ConsoleColor b, bool newline, TextWriter writer)
+        {
+            ConsoleColor f1 = Console.ForegroundColor, b1 = Console.BackgroundColor;
+            Console.ForegroundColor = f;
+            Console.BackgroundColor = b;
+            writer.Write(message);
+            if (newline) writer.WriteLine();
+            Console.ForegroundColor = f1;
+            Console.BackgroundColor = b1;
+        }
+    }
+}

Server/Program.cs

@@ -4,38 +4,124 @@ using Server.Properties;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
+using Tofvesson.Common;
 using Tofvesson.Crypto;
 
 namespace Server
 {
     class Program
     {
-        static void Main(string[] args)
+        private const string VERBOSE_RESPONSE = "@string/REMOTE_";
+        public static void Main(string[] args)
         {
+            // Set up fancy output
             Console.SetError(new TimeStampWriter(Console.Error, "HH:mm:ss.fff"));
             Console.SetOut(new TimeStampWriter(Console.Out, "HH:mm:ss.fff"));
 
-            SessionManager manager = new SessionManager(120 * TimeSpan.TicksPerSecond, 20);
+            // Create a client session manager and allow sessions to remain valid for up to 5 minutes of inactivity (300 seconds)
+            SessionManager manager = new SessionManager(300 * TimeSpan.TicksPerSecond, 20);
 
+            // Initialize the database
             Database db = new Database("BankDB", "Resources");
 
-            //Database.User me = db.GetUser("Gabriel Tofvesson");//new Database.User("Gabriel Tofvesson", "Hello, World", "NoRainbow", 1337, true, null, true);
+            // Create a secure random provider and start getting RSA stuff
-
-
             CryptoRandomProvider random = new CryptoRandomProvider();
-            //RSA rsa = null;// new RSA(Resources.e_0x200, Resources.n_0x200, Resources.d_0x200);
+            Task<RSA> t = new Task<RSA>(() =>
-            //if (rsa == null)
+            {
-            //{
+                RSA rsa = new RSA(Resources.e_0x100, Resources.n_0x100, Resources.d_0x100);
-            //    Console.ForegroundColor = ConsoleColor.Red;
+                if (rsa == null)
-            //    Console.Error.WriteLine("No RSA keys available! Server identity will not be verifiable!");
+                {
-            //    Console.ForegroundColor = ConsoleColor.Gray;
+                    Output.Fatal("No RSA keys found! Server identity will not be verifiable!");
-            //    Console.WriteLine("Generating session-specific RSA-keys...");
+                    Output.Info("Generating session-specific RSA-keys...");
-            //    rsa = new RSA(64, 8, 8, 5);
+                    rsa = new RSA(128, 8, 7, 5);
-            //    Console.WriteLine("Done!");
+                    rsa.Save("0x100");
-            //}
+                    Output.Info("Done!");
+                }
+                return rsa;
+            });
+            t.Start();
 
+            // Local methods to simplify common operations
+            bool ParseDataPair(string cmd, out string user, out string pass)
+            {
+                int idx = cmd.IndexOf(':');
+                user = "";
+                pass = "";
+                if (idx == -1) return false;
+                user = cmd.Substring(0, idx);
+                try
+                {
+                    user = user.FromBase64String();
+                    pass = cmd.Substring(idx + 1).FromBase64String();
+                }
+                catch
+                {
+                    Output.Error($"Recieved problematic username or password! (User: \"{user}\")");
+                    return false;
+                }
+                return true;
+            }
+
+            int ParseDataSet(string cmd, out string[] data)
+            {
+                List<string> gen = new List<string>();
+                int idx;
+                while ((idx = cmd.IndexOf(':')) != -1)
+                {
+                    try
+                    {
+                        gen.Add(cmd.Substring(0, idx).FromBase64String());
+                    }
+                    catch
+                    {
+                        data = null;
+                        return -1; // Hard error
+                    }
+                    cmd = cmd.Substring(idx + 1);
+                }
+                try
+                {
+                    gen.Add(cmd.FromBase64String());
+                }
+                catch
+                {
+                    data = null;
+                    return -1; // Hard error
+                }
+                data = gen.ToArray();
+                return gen.Count;
+            }
+
+            string[] ParseCommand(string cmd, out long id)
+            {
+                int idx = cmd.IndexOf(':'), idx1;
+                string sub;
+                if (idx == -1 || !(sub = cmd.Substring(idx + 1)).Contains(':') || !long.TryParse(sub.Substring(0, idx1 = sub.IndexOf(':')), out id))
+                {
+                    id = 0;
+                    return null;
+                }
+                return new string[] { cmd.Substring(0, idx), sub.Substring(idx1 + 1) };
+            }
+
+            string GenerateResponse(long id, dynamic d) => id + ":" + d.ToString();
+
+            bool GetUser(string sid, out Database.User user)
+            {
+                user = manager.GetUser(sid);
+                return user != null;
+            }
+
+            bool GetAccount(string name, Database.User user, out Database.Account acc)
+            {
+                acc = user.accounts.FirstOrDefault(a => a.name.Equals(name));
+                return acc != null;
+            }
+
+            // Create server
             NetServer server = new NetServer(
                 EllipticDiffieHellman.Curve25519(EllipticDiffieHellman.Curve25519_GeneratePrivate(random)),
                 80,
@@ -48,51 +134,176 @@ namespace Server
                     {
                         case "Auth":
                             {
-                                int idx = cmd[1].IndexOf(':');
+                                if(!ParseDataPair(cmd[1], out string user, out string pass))
-                                if (idx == -1) return GenerateResponse(id, "ERROR");
+                                {
-                                string user = cmd[1].Substring(0, idx);
+                                    Output.Error($"Recieved problematic username or password! (User: \"{user}\")");
-                                string pass = cmd[1].Substring(idx + 1);
+                                    return GenerateResponse(id, "ERROR");
+                                }
                                 Database.User usr = db.GetUser(user);
                                 if (usr == null || !usr.Authenticate(pass))
                                 {
-                                    Console.WriteLine("Authentcation failure for user: "+user);
+                                    Output.Error("Authentcation failure for user: "+user);
                                     return GenerateResponse(id, "ERROR");
                                 }
 
                                 string sess = manager.GetSession(usr, "ERROR");
-                                Console.WriteLine("Authentication success for user: "+user+"\nSession: "+sess);
+                                Output.Positive("Authentication success for user: "+user+"\nSession: "+sess);
                                 associations["session"] = sess;
                                 return GenerateResponse(id, sess);
                             }
                         case "Logout":
-                            manager.Expire(cmd[1]);
+                            if (manager.Expire(cmd[1])) Output.Info("Prematurely expired session: " + cmd[1]);
-                            Console.WriteLine("Prematurely expired session: "+cmd[1]);
+                            else Output.Error("Attempted to expire a non-existent session!");
                             break;
+                        case "Avail":
+                            {
+                                try
+                                {
+                                    string name = cmd[1].FromBase64String();
+                                    Output.Info($"Performing availability check on name \"{name}\"");
+                                    return GenerateResponse(id, !db.ContainsUser(name));
+                                }
+                                catch
+                                {
+                                    Output.Error($"Recieved improperly formatted base64 string: \"{cmd[1]}\"");
+                                    return GenerateResponse(id, false);
+                                }
+                            }
+                        case "Account_Create":
+                            {
+                                if (!ParseDataPair(cmd[1], out string session, out string name) || // Get session id and account name
+                                    !GetUser(session, out var user) || // Get user associated with session id
+                                    !GetAccount(name, user, out var account))
+                                {
+                                    // Don't print input data to output in case sensitive information was included
+                                    Output.Error($"Recieved problematic session id or account name!");
+                                    return GenerateResponse(id, "ERROR");
+                                }
+                                user.accounts.Add(new Database.Account(user, 0, name));
+                                db.AddUser(user); // Notify database of the update
+                                return GenerateResponse(id, true);
+                            }
+                        case "Account_Transaction_Create":
+                            {
+                                bool systemInsert = false;
+                                string error = VERBOSE_RESPONSE;
+
+                                // Default values used here because compiler can't infer their valid parsing further down
+                                Database.User user = null;
+                                Database.Account account = null;
+                                Database.User tUser = null;
+                                Database.Account tAccount = null;
+                                decimal amount = 0;
+
+                                // Expected data (in order): SessionID, AccountName, TargetUserName, TargetAccountName, Amount, [message]
+                                // Do checks to make sure the data we have been given isn't completely silly
+                                if (ParseDataSet(cmd[1], out string[] data) < 5 || data.Length > 6)
+                                    error += "general";         // General error (parse failed)
+                                else if (!GetUser(data[0], out user))
+                                    error += "badsession";      // Bad session id (could not get user from session manager)
+                                else if (!GetAccount(data[1], user, out account))
+                                    error += "badacc";          // Bad source account name
+                                else if (!db.ContainsUser(data[2]))
+                                    error += "notargetusr";     // Target user could not be found
+                                else if (!GetAccount(data[3], tUser = db.GetUser(data[2]), out tAccount))
+                                    error += "notargetacc";     // Target account could not be found
+                                else if ((!user.IsAdministrator && (systemInsert = (data[2].Equals(user.Name) && account.name.Equals(tAccount.name)))))
+                                    error += "unprivsysins";    // Unprivileged request for system-sourced transfer
+                                else if (!decimal.TryParse(data[4], out amount) || amount < 0)
+                                    error += "badbalance";      // Given sum was not a valid amount
+                                else if ((!systemInsert && amount > account.balance))
+                                    error += "insufficient";    // Insufficient funds in the source account
+                                
+                                // Checks if an error ocurred and handles such a situation appropriately
+                                if(!error.Equals(VERBOSE_RESPONSE))
+                                {
+                                    // Don't print input data to output in case sensitive information was included
+                                    Output.Error($"Recieved problematic transaction data ({error}): {data?.ToList().ToString() ?? "Data could not be parsed"}");
+                                    return GenerateResponse(id, $"ERROR:{error}");
+                                }
+                                // At this point, we know that all parsed variables above were successfully parsed and valid, therefore: no NREs
+                                // Parsed vars: 'user', 'account', 'tUser', 'tAccount', 'amount'
+                                // Perform and log the actual transaction
+                                return GenerateResponse(id,
+                                    db.AddTransaction(
+                                        systemInsert ? null : user.Name,
+                                        tUser.Name,
+                                        amount,
+                                        account.name,
+                                        tAccount.name,
+                                        data.Length == 6 ? data[5] : null
+                                    ));
+                            }
+                        case "Account_Close":
+                            {
+                                Database.User user = null;
+                                Database.Account account = null;
+                                if (!ParseDataPair(cmd[1], out string session, out string name) || // Get session id and account name
+                                    !GetUser(session, out user) || // Get user associated with session id
+                                    !GetAccount(name, user, out account) ||
+                                    account.balance != 0)
+                                {
+                                    // Don't print input data to output in case sensitive information was included
+                                    Output.Error($"Recieved problematic session id or account name!");
+
+                                    // Possible errors: bad session id, bad account name, balance in account isn't 0
+                                    return GenerateResponse(id, $"ERROR:{VERBOSE_RESPONSE} {(user==null? "badsession" : account==null? "badacc" : "hasbal")}");
+                                }
+                                break;
+                            }
                         case "Reg":
                             {
-                                int idx = cmd[1].IndexOf(':');
+                                if (!ParseDataPair(cmd[1], out string user, out string pass))
-                                if (idx == -1) return GenerateResponse(id, "ERROR");
+                                {
-                                string user = cmd[1].Substring(0, idx);
+                                    // Don't print input data to output in case sensitive information was included
-                                string pass = cmd[1].Substring(idx + 1);
+                                    Output.Error($"Recieved problematic username or password!");
-                                if (db.ContainsUser(user)) return GenerateResponse(id, "ERROR");
+                                    return GenerateResponse(id, $"ERROR:{VERBOSE_RESPONSE}userpass");
-                                Database.User u = new Database.User(user, pass, random.GetBytes(Math.Abs(random.NextShort() % 60) + 20), 0, true);
+                                }
+
+                                // Cannot register an account with an existing username
+                                if (db.ContainsUser(user)) return GenerateResponse(id, $"ERROR:{VERBOSE_RESPONSE}exists");
+
+                                // Create the database user entry and generate a personal password salt
+                                Database.User u = new Database.User(user, pass, random.GetBytes(Math.Abs(random.NextShort() % 60) + 20), true);
                                 db.AddUser(u);
+
+                                // Generate a session token
                                 string sess = manager.GetSession(u, "ERROR");
-                                Console.WriteLine("Registered account: " + u.Name + "\nSession: "+sess);
+                                Output.Positive("Registered account: " + u.Name + "\nSession: "+sess);
                                 associations["session"] = sess;
                                 return GenerateResponse(id, sess);
                             }
+                        case "Verify":
+                            {
+                                BitReader bd = new BitReader(Convert.FromBase64String(cmd[1]));
+                                try
+                                {
+                                    while (!t.IsCompleted) System.Threading.Thread.Sleep(75);
+                                    byte[] ser;
+                                    using (BitWriter collector = new BitWriter())
+                                    {
+                                        collector.PushArray(t.Result.Serialize());
+                                        collector.PushArray(t.Result.Encrypt(((BigInteger)bd.ReadUShort()).ToByteArray(), null, true));
+                                        ser = collector.Finalize();
+                                    }
+                                    return GenerateResponse(id, Convert.ToBase64String(ser));
+                                }
+                                catch
+                                {
+                                    return GenerateResponse(id, $"ERROR:{VERBOSE_RESPONSE}crypterr");
+                                }
+                            }
                         default:
-                            return GenerateResponse(id, "ERROR");
+                            return GenerateResponse(id, $"ERROR:{VERBOSE_RESPONSE}unwn"); // Unknown request
                     }
 
                     return null;
                 }, 
-                (c, b) =>
+                (c, b) => // Called every time a client connects or disconnects (conn + dc with every command/request)
                 {
-                    Console.WriteLine($"Client has {(b ? "C" : "Disc")}onnected");
+                    // Output.Info($"Client has {(b ? "C" : "Disc")}onnected");
-                    //if(!b && c.assignedValues.ContainsKey("session"))
+                    if(!b && c.assignedValues.ContainsKey("session"))
-                    //    manager.Expire(c.assignedValues["session"]);
+                        manager.Expire(c.assignedValues["session"]);
                 });
             server.StartListening();
             
@@ -100,32 +311,5 @@ namespace Server
 
             server.StopRunning();
         }
-
-        private static void HandleInput()
-        {
-            while (true)
-            {
-
-            }
-        }
-
-        private static string[] ParseCommand(string cmd, out long id)
-        {
-            int idx = cmd.IndexOf(':'), idx1;
-            string sub;
-            if (idx == -1 || !(sub = cmd.Substring(idx + 1)).Contains(':') || !long.TryParse(sub.Substring(0, idx1 = sub.IndexOf(':')), out id))
-            {
-                id = 0;
-                return null;
-            }
-            return new string[] { cmd.Substring(0, idx), sub.Substring(idx1 + 1) };
-        }
-
-        private static string GenerateResponse(long id, bool b) => GenerateResponse(id, b.ToString());
-        private static string GenerateResponse(long id, int b) => GenerateResponse(id, b.ToString());
-        private static string GenerateResponse(long id, long b) => GenerateResponse(id, b.ToString());
-        private static string GenerateResponse(long id, float b) => GenerateResponse(id, b.ToString());
-        private static string GenerateResponse(long id, double b) => GenerateResponse(id, b.ToString());
-        private static string GenerateResponse(long id, string response) => id + ":" + response;
     }
 }

Server/Properties/Resources.Designer.cs

@@ -60,6 +60,16 @@ namespace Server.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] d_0x100 {
+            get {
+                object obj = ResourceManager.GetObject("d_0x100", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Byte[].
         /// </summary>
@@ -70,6 +80,16 @@ namespace Server.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] e_0x100 {
+            get {
+                object obj = ResourceManager.GetObject("e_0x100", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Byte[].
         /// </summary>
@@ -80,6 +100,16 @@ namespace Server.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] n_0x100 {
+            get {
+                object obj = ResourceManager.GetObject("n_0x100", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Byte[].
         /// </summary>

Server/Properties/Resources.resx

@@ -118,12 +118,21 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="d_0x100" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\0x100.d;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
   <data name="d_0x200" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\0x200.d;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </data>
+  <data name="e_0x100" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\0x100.e;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
   <data name="e_0x200" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\0x200.e;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </data>
+  <data name="n_0x100" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\0x100.n;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </data>
   <data name="n_0x200" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\0x200.n;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </data>

Server/Server.csproj

@@ -44,6 +44,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Database.cs" />
+    <Compile Include="Output.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">
@@ -55,6 +56,9 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="Resources\0x100.d" />
+    <None Include="Resources\0x100.e" />
+    <None Include="Resources\0x100.n" />
     <None Include="Resources\0x200.d" />
     <None Include="Resources\0x200.e" />
     <None Include="Resources\0x200.n" />

Server/SessionManager.cs

@@ -34,6 +34,14 @@ namespace Server
             return s.sessionID;
         }
 
+        public Database.User GetUser(string SID)
+        {
+            foreach (var session in sessions)
+                if (session.sessionID.Equals(SID))
+                    return session.user;
+            return null;
+        }
+
         public bool Refresh(Database.User user)
         {
             Update();
@@ -74,16 +82,16 @@ namespace Server
             return false;
         }
 
-        public void Expire(string sid)
+        public bool Expire(string sid)
         {
             Update();
             for (int i = sessions.Count - 1; i >= 0; --i)
                 if (sessions[i].sessionID.Equals(sid))
                 {
                     sessions.RemoveAt(i);
-                    return;
+                    return true;
                 }
-            return;
+            return false;
         }
 
         public bool CheckSession(string sid, Database.User user)
@@ -106,7 +114,7 @@ namespace Server
         {
             string res;
             do res = random.NextString(sidLength);
-            while (res.Equals(invalid));
+            while (res.StartsWith(invalid));
             return res;
         }
     }