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

Implemented floating point value serialization

Browse Source 
Implemented floating point value deserialization
Separated Elliptic Curve Point class to its own file
This commit is contained in:
Gabriel Tofvesson 2018-04-09 20:49:05 +02:00
parent de2a53c1cf
commit 1da1b7878d
7 changed files with 151 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
Client/BinaryCollector.cs
View File

@ -14,6 +14,9 @@ namespace Client
// 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 List<Type> supportedTypes = new List<Type>()
{
typeof(bool),
@ -93,10 +96,11 @@ namespace Client
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(array.Length, writeTo, ref bitOffset);
Serialize((short)array.Length, writeTo, ref bitOffset);
foreach (var element in array)
Serialize(element, writeTo, ref bitOffset);
}
@ -111,9 +115,25 @@ namespace Client
WriteDynamic(writeTo, dec_hi.GetValue(t), 4, bitOffset + 64);
WriteDynamic(writeTo, dec_flags.GetValue(t), 4, bitOffset + 96);
}
else if(type == typeof(float))
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
lock (type_holder)
lock (holder)
{
type_holder.SetValue(t, 0); // Insert the value to convert into the preallocated holder array
Buffer.BlockCopy(type_holder, 0, holder, 0, bytes); // Perform an internal copy to the byte-based holder
for (int i = 0; i < bytes; ++i)
WriteByte(writeTo, holder[i], bitOffset + (i * 8)); // Write the converted value to the output array
}
}
else
{
dynamic value = t;
int type_size = Marshal.SizeOf(typeof(T));
for (int i = 0; i < type_size; ++i)
WriteByte(writeTo, (byte)(value >> (int)(i * 8)), bitOffset + (i * 8));
}
bitOffset += offset;
}
@ -126,25 +146,25 @@ namespace Client
if (type.IsArray)
{
Type elementType = type.GetElementType();
long allocSize = GetBitAllocation(elementType);
var array = t as Array;
count += 2; // Int16 array size. Arrays shouldn't be syncing more than 65k elements
if (allocSize != 0) // The array contents is known: compute the data size
count += allocSize * array.Length;
else // Unknown array contents type: iteratively assess serialization size
foreach (var element in t as Array)
count += GetBitCount(element);
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 float || t is double || t is decimal) count += ba;
else count += BytesToRead(t, Marshal.SizeOf(t)) * 8;
}
else if(IsSupportedType(type)) count += GetBitAllocation(type);
//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));
=> b[index / 8] = (byte)((b[index / 8] & ~(1 << (int)(index % 8))) | (bit ? 1 << (int)(index % 8) : 0));
private static void WriteByte(byte[] b, byte value, long index)
{
int byteIndex = (int)(index / 8);
@ -154,7 +174,7 @@ namespace Client
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)));
b[byteIndex + 1] = (byte)((b[byteIndex + 1] & upper_mask) | (value >> (8 - shift)));
}
private static void WriteDynamic(byte[] b, dynamic value, int byteCount, long index)
{
@ -162,6 +182,14 @@ namespace Client
WriteByte(b, (byte)((value >> (8 * i)) & 0xFF), index + (8 * i));
}
private static int BytesToRead(dynamic integer, int maxBytes)
{
for (int i = 0; i < maxBytes; ++i)
if ((integer >> (8 * i)) & 0xFF <= 127)
return i + 1;
return maxBytes;
}
// Supported datatypes for serialization
private static bool IsSupportedType(Type t) => supportedTypes.Contains(t);

68
Client/BinaryDistributor.cs Normal file
View File

@ -0,0 +1,68 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace Client
{
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 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>();
private T[] ReadFloatingArray<T>()
{
short size = (short)(ReadByte() | (ReadByte() << 8));
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;
T result;
lock(type_holder)
lock (holder)
{
for (int i = 0; i < size; ++i)
holder.SetValue(ReadByte(), i);
Buffer.BlockCopy(holder, 0, type_holder, 0, size);
result = (T) type_holder.GetValue(0);
}
return result;
}
}
}

1
Client/Client.csproj
View File

@ -44,6 +44,7 @@
</ItemGroup>
<ItemGroup>
<Compile Include="BinaryCollector.cs" />
<Compile Include="BinaryDistributor.cs" />
<Compile Include="ConsoleForms\CancellationPipe.cs" />
<Compile Include="ConsoleForms\ConsoleController.cs" />
<Compile Include="ConsoleForms\Context.cs" />

10
Client/Program.cs
View File

@ -18,14 +18,20 @@ namespace ConsoleForms
// Set up timestamps in debug output
DebugStream = new TimeStampWriter(DebugStream, "HH:mm:ss.fff");
byte[] serialized;
using (BinaryCollector collector = new BinaryCollector(1))
using (BinaryCollector collector = new BinaryCollector(2))
{
collector.Push(5f);
collector.Push(true);
collector.Push(new double[] { 6.0, 5.0 });
serialized = collector.ToArray();
}
BinaryDistributor bd = new BinaryDistributor(serialized);
bool bit = bd.ReadBit();
double[] result = bd.ReadDoubleArray();
Padding p = new AbsolutePadding(2, 2, 1, 1);

1
Common/Common.csproj
View File

@ -70,6 +70,7 @@
<Compile Include="Cryptography\KeyExchange\DiffieHellman.cs" />
<Compile Include="Cryptography\KeyExchange\EllipticDiffieHellman.cs" />
<Compile Include="Cryptography\KeyExchange\IKeyExchange.cs" />
<Compile Include="Cryptography\Point.cs" />
<Compile Include="KDF.cs" />
<Compile Include="NetClient.cs" />
<Compile Include="NetServer.cs" />

22
Common/Cryptography/EllipticCurve.cs
View File

@ -1,4 +1,6 @@
using System;
//#define SAFE_MATH
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
@ -8,24 +10,6 @@ using Tofvesson.Crypto;
namespace Common.Cryptography
{
public class Point
{
public static readonly Point POINT_AT_INFINITY = new Point();
public BigInteger X { get; private set; }
public BigInteger Y { get; private set; }
private bool pai = false;
public Point(BigInteger x, BigInteger y)
{
X = x;
Y = y;
}
private Point() { pai = true; } // Accessing corrdinates causes undocumented behaviour
public override string ToString()
{
return pai ? "(POINT_AT_INFINITY)" : "(" + X + ", " + Y + ")";
}
}
public class EllipticCurve
{
public enum CurveType { Weierstrass, Montgomery }

27
Common/Cryptography/Point.cs Normal file
View File

@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
namespace Common.Cryptography
{
public class Point
{
public static readonly Point POINT_AT_INFINITY = new Point();
public BigInteger X { get; private set; }
public BigInteger Y { get; private set; }
private bool pai = false;
public Point(BigInteger x, BigInteger y)
{
X = x;
Y = y;
}
private Point() { pai = true; } // Accessing corrdinates causes undocumented behaviour
public override string ToString()
{
return pai ? "(POINT_AT_INFINITY)" : "(" + X + ", " + Y + ")";
}
}
}