GabrielTofvesson/BankProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Major changes

Browse Source 
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
This commit is contained in:
Gabriel Tofvesson 2018-04-26 00:24:58 +02:00
parent 308639da5f
commit 100f5a32be
45 changed files with 2135 additions and 1029 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

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

3
Bank.sln
View File

@ -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

114
Client.psess Normal file
View File

@ -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>

2
Client/Client.csproj
View File

@ -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>

9
Client/ConsoleForms/ConsoleController.cs
View File

@ -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();
});

11
Client/ConsoleForms/Context.cs
View File

@ -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);
}
}
}

4
Client/ConsoleForms/Graphics/DialogView.cs
View File

@ -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");

2
Client/ConsoleForms/Graphics/InputView.cs
View File

@ -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)

4
Client/ConsoleForms/Graphics/ListView.cs
View File

@ -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);

2
Client/ConsoleForms/Graphics/TextView.cs
View File

@ -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; }

14
Client/ConsoleForms/Graphics/View.cs
View File

@ -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.Write(Filler(Border, ContentWidth + 1));
Console.SetCursorPosition(left - 1, top - 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.Write(Filler(Border, ContentWidth + 2));
Console.SetCursorPosition(left-1, top + ContentHeight);
Console.Write(Filler(Border, ContentWidth + 4));
Console.BackgroundColor = ConsoleColor.Black;
}
protected abstract void _Draw(int left, ref int top);

12
Client/ConsoleForms/LangManager.cs
View File

@ -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);
else if (el.Name.Equals("Fallback"))
//if (el.Name.Equals("Default")) priorities.Insert(0, (XmlElement)node);
/*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)

74
Client/Context/NetContext.cs
View File

@ -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();
while (!t.IsCompleted)
if (t.IsCanceled || t.IsFaulted)
{
controller.AddView(views.GetNamed("ConnectError"));
return;
}
//var t = ita.Connect();
//while (!t.IsCompleted)
// if (t.IsCanceled || t.IsFaulted)
// {
// Show("ConnectError");
// 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 controller.AddView(views.GetNamed("PortError"));
else if (!ip) Show("IPError");
else Show("PortError");
};
}
public override void OnCreate()
{
controller.AddView(views.GetNamed("NetConnect"));
}
public override void OnDestroy()
{
foreach (var view in views)
controller.CloseView(view.Item2);
}
public override void OnCreate() => Show("NetConnect");
public override void OnDestroy() => HideAll();
//int gtrack = 0;

13
Client/Context/SessionContext.cs
View File

@ -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()
{
//controller.AddView(views.GetNamed("Success"));
controller.AddView(views.GetNamed("menu_options"));
}
public override void OnCreate() => Show("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
}
}

49
Client/Context/WelcomeContext.cs
View File

@ -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"));
promise = interactor.Authenticate(i.Inputs[0].Text, i.Inputs[1].Text);
Show("AuthWait");
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"));
promise = interactor.Register(i.Inputs[0].Text, i.Inputs[1].Text);
Show("RegWait");
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 controller.AddView(views.GetNamed("EmptyFieldError"));
else if (mismatch) Show("PasswordMismatchError");
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;
foreach (var v in ((InputView)views.GetNamed("Register")).Inputs)
GetView<InputView>("Register").SelectedField = 0;
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)
controller.CloseView(view.Item2);
HideAll();
// 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
}
}

203
Client/Networking.cs
View File

@ -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;
public bool Authenticating { get => authenticating; }
public bool PeerIsAuthenticated { get => authenticated; }
public RSA AuthenticatedKeys { get; private set; }
public bool IsAlive { get => client.IsAlive; }
public BankNetInteractor(string address, short port, bool checkIdentity = true)
protected readonly IPAddress addr;
protected readonly short port;
protected readonly EllipticDiffieHellman keyExchange;
public bool IsAlive { get => client != null && client.IsAlive; }
public bool IsLoggedIn
{
if(checkIdentity)
new Task(() =>
get
{
//AuthenticatedKeys = NetClient.CheckServerIdentity(address, port, provider);
authenticating = false;
authenticated = true;// AuthenticatedKeys != null;
}).Start();
else
{
authenticating = false;
authenticated = false;
if (loginTimeout >= DateTime.Now.Ticks) loginTimeout = -1;
return loginTimeout != -1;
}
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;
changeListeners[tkn = GetListenerToken()] = stateListener;
long tkn = GetListenerToken();
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;
p.HasValue = true;
p.Subscribe?.Invoke(p);
PostPromise(p, response);
if (promises.Count == 0) keepAlive = false;
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)
return new Promise
Promise p = RegisterPromise(pID);
p.handler = new Promise();
p.Subscribe = p1 =>
{
HasValue = true,
Value = "ERROR"
// If true, propogate result
if (a(p1)) PostPromise(p1.handler, p1.Value);
};
client.Send(CreateCommandMessage("Auth", username+":"+password, out long pID));
Promise p = new Promise();
promises[pID] = p;
return p;
return p.handler;
}
public virtual Promise Register(string username, string password)
protected bool RefreshSession(Promise p)
{
if (username.Length > 60)
return new Promise
{
HasValue = true,
Value = "ERROR"
};
client.Send(CreateCommandMessage("Reg", username + ":" + password, out long pID));
Promise p = new Promise();
promises[pID] = p;
return p;
if (!p.Value.StartsWith("ERROR")) loginTimeout = 280 * TimeSpan.TicksPerSecond;
return true;
}
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;
}
}
}

30
Client/Program.cs
View File

@ -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;

75
Client/Properties/Resources.Designer.cs generated
View File

@ -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 default=&quot;80&quot; input_type=&quot;integer&quot; max_length=&quot;5&quot;&gt;Port:&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;@string/NC_port&lt;/Field&gt;
/// &lt;/Fields&gt;
/// &lt;Text&gt;@string/NC_head&lt;/Text&gt;
/// &lt;/InputVie [rest of string was truncated]&quot;;.
/// &lt;Text&gt;@string/NC_head&lt;/Text&gt; /// [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:Register&quot; close=&quot;true&quot;&gt;Register&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;@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;ERR_empty&quot;&gt;One of more required field was empty!&lt;/Entry&gt;
///&lt;/Strings&gt;.
/// &lt;Entry name=&quot;NC_next&quot;&gt;Continue&lt;/Entry&gt;
/// &lt;Entry name=&quot;NC_cancel&quot;&gt;Cancel&lt;/Entry&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;ERR_empty&quot;&gt;One of more required field was empty!&lt;/Entry&gt;
///&lt;/Strings&gt;.
/// &lt;Entry name=&quot;NC_next&quot;&gt;Continue&lt;/Entry&gt;
/// &lt;Entry name=&quot;NC_cancel&quot;&gt;Cancel&lt;/Entry&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;ERR_empty&quot;&gt;Ett eller fler obligatoriska inputfält är tomma!&lt;/Entry&gt;
///&lt;/Strings&gt;.
/// &lt;Entry name=&quot;NC_next&quot;&gt;Fortsätt&lt;/Entry&gt;
/// &lt;Entry name=&quot;NC_cancel&quot;&gt;Avbryt&lt;/Entry&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;Default&gt;sv_SE&lt;/Default&gt;
/// &lt;Fallback priority=&quot;0&quot;&gt;en_US&lt;/Fallback&gt;
/// &lt;Fallback priority=&quot;1&quot;&gt;en_GB&gt;&lt;/Fallback&gt;
///&lt;/Lang&gt;.
///&lt;Strings&gt;
/// &lt;Lang priority=&quot;0&quot;&gt;sv_SE&lt;/Lang&gt;
/// &lt;Lang priority=&quot;1&quot;&gt;en_US&lt;/Lang&gt;
/// &lt;Lang priority=&quot;2&quot;&gt;en_GB&lt;/Lang&gt;
///&lt;/Strings&gt;.
/// </summary>
internal static string strings_meta {
get {

6
Client/Properties/Resources.resx
View File

@ -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>

BIN
Client/Resources/0x100.e Normal file
View File

Binary file not shown.

BIN
Client/Resources/0x100.n Normal file
View File

Binary file not shown.

11
Client/Resources/Layout/Networking.xml
View File

@ -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"

35
Client/Resources/Layout/Session.xml
View File

@ -23,20 +23,39 @@
padding_left="2"
padding_right="2"
padding_top="1"
padding_bottom="1"
border="2">
padding_bottom="1">
<Views>
<ButtonView id="history">
<Text>@string/SE_hist</Text>
</ButtonView>
<ButtonView id="create">
<Text>@string/SE_tx</Text>
<ButtonView id="view">
<Text>@string/SE_view</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>

10
Client/Resources/Strings/Meta.xml
View File

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

16
Client/Resources/Strings/en_GB/strings.xml
View File

@ -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>

16
Client/Resources/Strings/en_US/strings.xml
View File

@ -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>

49
Client/Resources/Strings/sv_SE/strings.xml
View File

@ -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>

BIN
Client180412.vspx Normal file
View File

Binary file not shown.

332
Common/BinaryCollector.cs
View File

@ -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;
}
}
}

108
Common/BinaryDistributor.cs
View File

@ -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));
}
}

137
Common/BinaryHelpers.cs Normal file
View File

@ -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;
}
}
}
}

111
Common/BitReader.cs Normal file
View File

@ -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));
}
}

404
Common/BitWriter.cs Normal file
View File

@ -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
}
}
}

5
Common/Common.csproj
View File

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

21
Common/NetClient.cs
View File

@ -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)
mLen = Support.ReadInt(ibuf.Dequeue(4), 0);
if (mLen == 0 && BinaryHelpers.TryReadVarInt(ibuf, 0, out mLen))
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;
return await new TaskFactory().StartNew<object>(() => { eventListener.Join(); return null; });
await new TaskFactory().StartNew(eventListener.Join);
}
// 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)

69
Common/NetSupport.cs
View File

@ -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];
Support.WriteToArray(nmsg, message.Length, 0);
Array.Copy(message, 0, nmsg, 4, message.Length);
int i = BinaryHelpers.VarIntSize(message.Length);
byte[] nmsg = new byte[message.Length + i];
//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];
}
}

95
Common/SHA.cs
View File

@ -32,12 +32,13 @@ namespace Tofvesson.Crypto
int chunks = msg.Length / 64;
// Perform hashing for each 512-bit block
for(int i = 0; i<chunks; ++i)
{
// Split block into words
// Split block into words (allocated out here to prevent massive garbage buildup)
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 :

19
Common/Support.cs
View File

@ -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)
{
ulong res = 0;
for(int i = 0; i<8; ++i)
res = (res << 8) | ((value >> i * 8) & 0xFF);
return res;
}
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));
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);

199
Server/Database.cs
View File

@ -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);
to.History.Add(tx);
Transaction tx = new Transaction(from == null ? "System" : from.Name, to.Name, amount, message, fromAccount, toAccount);
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(User user) => FirstUser(u => u.Name.Equals(user.Name)) != null;
public bool ContainsUser(string user) => user.Equals("System") || FirstUser(u => u.Name.Equals(user)) != 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);
u.History[i].from = Encode(u.History[i].from);
u.History[i].meta = Encode(u.History[i].meta);
account.name = Encode(account.name);
foreach(var transaction in account.History)
{
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);
u.History[i].from = Decode(u.History[i].from);
u.History[i].meta = Decode(u.History[i].meta);
account.name = Decode(account.name);
foreach (var transaction in account.History)
{
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; }
private User()
{
Name = "";
History = new List<Transaction>();
}
public List<Account> accounts = new List<Account>();
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)
: this(name, passHash, Encoding.UTF8.GetBytes(salt), balance, generatePass, transactionHistory, admin)
public User(string name, string passHash, string salt, bool generatePass = false, bool admin = false)
: 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)
{
History.Add(tx);
return this;
}
public void AddAccount(Account a) => accounts.Add(a);
public Account GetAccount(string name) => accounts.FirstOrDefault(a => a.name.Equals(name));
private Entry Serialize()
{
Entry root = new Entry("User")
.AddNested(new Entry("Name", Name))
.AddNested(new Entry("Balance", Balance.ToString()).AddAttribute("omit", "true"));
foreach (var transaction in History)
.AddNested(new Entry("Name", Name));
foreach (var account in accounts)
{
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(new Entry("Balance", transaction.amount.ToString()));
if (transaction.meta != null) tx.AddNested(new Entry("Meta", transaction.meta));
root.AddNested(tx);
.AddNested(transaction.to.Equals(Name) ? "From" : "To", transaction.to.Equals(Name) ? transaction.from : transaction.to)
.AddNested("FromAccount", transaction.fromAccount)
.AddNested("ToAccount", transaction.toAccount)
.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;
else user.History.Add(new Transaction(from, to, amount, meta));
if ( // Errant states for transaction data
(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;

38
Server/Output.cs Normal file
View File

@ -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;
}
}
}

308
Server/Program.cs
View File

@ -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);
//if (rsa == null)
//{
// Console.ForegroundColor = ConsoleColor.Red;
// Console.Error.WriteLine("No RSA keys available! Server identity will not be verifiable!");
// Console.ForegroundColor = ConsoleColor.Gray;
// Console.WriteLine("Generating session-specific RSA-keys...");
// rsa = new RSA(64, 8, 8, 5);
// Console.WriteLine("Done!");
//}
Task<RSA> t = new Task<RSA>(() =>
{
RSA rsa = new RSA(Resources.e_0x100, Resources.n_0x100, Resources.d_0x100);
if (rsa == null)
{
Output.Fatal("No RSA keys found! Server identity will not be verifiable!");
Output.Info("Generating session-specific RSA-keys...");
rsa = new RSA(128, 8, 7, 5);
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 (idx == -1) return GenerateResponse(id, "ERROR");
string user = cmd[1].Substring(0, idx);
string pass = cmd[1].Substring(idx + 1);
if(!ParseDataPair(cmd[1], out string user, out string pass))
{
Output.Error($"Recieved problematic username or password! (User: \"{user}\")");
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]);
Console.WriteLine("Prematurely expired session: "+cmd[1]);
if (manager.Expire(cmd[1])) Output.Info("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 (idx == -1) return GenerateResponse(id, "ERROR");
string user = cmd[1].Substring(0, idx);
string pass = cmd[1].Substring(idx + 1);
if (db.ContainsUser(user)) return GenerateResponse(id, "ERROR");
Database.User u = new Database.User(user, pass, random.GetBytes(Math.Abs(random.NextShort() % 60) + 20), 0, true);
if (!ParseDataPair(cmd[1], out string user, out string pass))
{
// Don't print input data to output in case sensitive information was included
Output.Error($"Recieved problematic username or password!");
return GenerateResponse(id, $"ERROR:{VERBOSE_RESPONSE}userpass");
}
// 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");
//if(!b && c.assignedValues.ContainsKey("session"))
// manager.Expire(c.assignedValues["session"]);
// Output.Info($"Client has {(b ? "C" : "Disc")}onnected");
if(!b && c.assignedValues.ContainsKey("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;
}
}

30
Server/Properties/Resources.Designer.cs generated
View File

@ -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>

9
Server/Properties/Resources.resx
View File

@ -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>

4
Server/Server.csproj
View File

@ -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" />

16
Server/SessionManager.cs
View File

@ -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;
}
}