private void UpdateKeys()
{
if (session.SessionId == null)
{
session.SessionId = kexProcessor.ExchangeHash;
}
var a1 = Cipher.Create(ClientKexInit.EncAlgorithmsClient[0]);
var a2 = Cipher.Create(ClientKexInit.EncAlgorithmsServer[0]);
var a3 = MacWriter.Create(ClientKexInit.MacAlgorithmsClient[0]);
var a4 = MacWriter.Create(ClientKexInit.MacAlgorithmsServer[0]);
var desiredLengths = new int[] { a1.BlockSize, a2.BlockSize, a1.KeySize,
a2.KeySize, a3.KeySize, a4.KeySize };
Debug.WriteLine(string.Format("Shared Secret: {0}", kexProcessor.SharedSecret.HexDump()));
byte[][] keys = new byte[6][];
using (var hash = HashWriter.Create(ClientKexInit.KexAlgorithms[0]))
{
var i = 0;
for (char c = 'A'; c <= 'F'; c++, i++)
{
hash.WriteString(kexProcessor.SharedSecret);
hash.Write(kexProcessor.ExchangeHash);
hash.Write(c);
hash.Write(session.SessionId);
var key = hash.Hash;
hash.Reset();
while (key.Length < desiredLengths[i])
{
hash.WriteString(kexProcessor.SharedSecret);
hash.Write(kexProcessor.ExchangeHash);
hash.Write(key);
var h = hash.Hash;
var buffer = new byte[key.Length + h.Length];
Buffer.BlockCopy(key, 0, buffer, 0, key.Length);
Buffer.BlockCopy(h, 0, buffer, key.Length, h.Length);
key = buffer;
Extensions.Random.ClearBytes(buffer, 0, buffer.Length);
hash.Reset();
}
keys[i] = new byte[desiredLengths[i]];
Buffer.BlockCopy(key, 0, keys[i], 0, desiredLengths[i]);
Extensions.Random.ClearBytes(key, 0, key.Length);
Debug.WriteLine("Key '{0}': {1}", c, keys[i].HexDump());
}
}
a1.Initialize(Cipher.CipherMode.Encryption, keys[2], keys[0]);
a2.Initialize(Cipher.CipherMode.Decryption, keys[3], keys[1]);
session.Socket.Encryptor = a1;
session.Socket.Decryptor = a2;
session.Socket.EncryptorMac = MacWriter.Create(ClientKexInit.MacAlgorithmsClient[0], keys[4]);
session.Socket.DecryptorMac = MacWriter.Create(ClientKexInit.MacAlgorithmsServer[0], keys[5]);
for (var i = 0; i < keys.Length; i++)
{
Extensions.Random.ClearBytes(keys[i], 0, keys[i].Length);
}
}
public override void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter)
{
if (!(GetValue(obj) is Material[] materials))
{
return;
}
using (var stream = new MemoryStream())
using (var dataWriter = new BinaryWriter(stream)) {
foreach (var material in materials)
{
if (IsPhysics)
{
material.PhysicsMaterialData.Write(dataWriter);
}
else
{
material.UpdateData();
material.MaterialData.Write(dataWriter);
}
}
var data = stream.ToArray();
WriteStart(writer, data.Length, hashWriter);
writer.Write(data);
hashWriter?.Write(data);
}
}
public void Partial()
{
var data = "Some random stuff for testing purposes.".AsciiToBytes();
UInt256 h1;
UInt256 refOnce;
UInt256 refTwice;
using (var alg = new SHA256Managed()) {
alg.TransformFinalBlock(data, 0, data.Length);
refOnce = h1 = (UInt256)alg.Hash;
alg.TransformFinalBlock(data, 0, data.Length);
UInt256 h2 = (UInt256)alg.Hash;
Assert.Equal(h1, h2);
alg.TransformFinalBlock(h1, 0, 32);
refTwice = (UInt256)alg.Hash;
}
using (var alg = new SHA256Managed()) {
alg.TransformBlock(data, 0, data.Length - 12, null, 0);
alg.TransformFinalBlock(data, data.Length - 12, 12);
h1 = (UInt256)alg.Hash;
Assert.Equal(refOnce, h1);
}
using (var alg = new SHA256Managed()) {
alg.TransformBlock(data, 0, data.Length, null, 0);
alg.TransformFinalBlock(data, 0, 0);
h1 = (UInt256)alg.Hash;
Assert.Equal(refOnce, h1);
}
using var hw = new HashWriter();
hw.Add(data[..12]);
public override void Write(BinaryWriter writer, HashWriter hashWriter)
{
writer.Write(Encoding.Default.GetBytes(Name).Length);
writer.Write(Encoding.Default.GetBytes(Name));
writer.Write(Encoding.Default.GetBytes(Path).Length);
writer.Write(Encoding.Default.GetBytes(Path));
writer.Write(Encoding.Default.GetBytes(InternalName).Length);
writer.Write(Encoding.Default.GetBytes(InternalName));
if (IsWav)
{
Wfx.Write(writer);
}
writer.Write(Data.Length);
writer.Write(Data);
writer.Write(OutputTarget);
writer.Write(Volume);
writer.Write(Balance);
writer.Write(Fade);
writer.Write(Volume);
}
public override void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter)
{
if (obj is PrimitiveData primitiveData)
{
if (!primitiveData.Use3DMesh)
{
// don't write animation if not using 3d mesh
return;
}
for (var i = 0; i < primitiveData.Mesh.AnimationFrames.Count; i++)
{
var animationData = SerializeAnimation(primitiveData.Mesh.AnimationFrames[i]);
var data = IsCompressed ? BiffZlib.Compress(animationData) : animationData;
WriteStart(writer, 4, hashWriter, "M3AY");
writer.Write(data.Length);
WriteStart(writer, data.Length, hashWriter);
writer.Write(data);
hashWriter?.Write(data);
}
}
else
{
throw new InvalidOperationException("Unknown type for [" + GetType().Name + "] on field \"" + Name + "\".");
}
}
public void ClientProxy_Dispose_DisposeWhenWriting()
{
const int distrServer1 = 22370;
const int distrServer12 = 22371;
const int storageServer = 22372;
#region hell
var writer = new HashWriter(new HashMapConfiguration("TestProxyDispose", HashMapCreationMode.CreateNew, 1, 1, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer, 157);
writer.Save();
var common = new CommonConfiguration(1, 100);
var distr =
new DistributorApi(
new DistributorNetConfiguration("localhost", distrServer1, distrServer12, "testService"),
new DistributorConfiguration(1, "TestProxyDispose"), common);
var storage = new WriterApi(
new StorageNetConfiguration("localhost", storageServer, 157, "testService"),
new StorageConfiguration(1, "TestProxyDispose"),
new CommonConfiguration());
#endregion
distr.Build();
distr.Start();
var result = _proxy.Int.SayIAmHere("localhost", distrServer1);
Assert.AreEqual(RequestState.Complete, result.State, result.ToString());
storage.Build();
storage.AddDbModule(new TestInMemoryDbFactory());
storage.Start();
const int count = 500;
for (int i = 0; i < count; i++)
{
if (i == count / 4)
{
Task.Run(() => _proxy.Dispose());
}
var state = _proxy.Int.CreateSync(i, i);
if (!(state.State == RequestState.Complete || state.State == RequestState.Error &&
state.ErrorDescription == "System disposed" || i == count / 4))
{
Assert.Fail(state + " " + i);
}
}
distr.Dispose();
storage.Dispose();
}
public void Writer_ProcessDataFromDistributor_SendResultBack()
{
const int distrServer1 = 22180;
const int distrServer12 = 23180;
const int storageServer1 = 22181;
var writer =
new HashWriter(new HashMapConfiguration("TestTransaction1D1S", HashMapCreationMode.CreateNew, 1, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
_distributor1.Build(1, distrServer1, distrServer12, "TestTransaction1D1S");
_writer1.Build(storageServer1, "TestTransaction1D1S", 1);
_distributor1.Start();
_writer1.Start();
var list = new List <InnerData>();
const int count = 100;
for (int i = 1; i < count + 1; i++)
{
var ev =
new InnerData(new Transaction(HashConvertor.GetString(i.ToString(CultureInfo.InvariantCulture)), "")
{
OperationName = OperationName.Create,
OperationType = OperationType.Async
})
{
Data = CommonDataSerializer.Serialize(i),
Key = CommonDataSerializer.Serialize(i),
Transaction = { TableName = "Int" }
};
list.Add(ev);
}
foreach (var data in list)
{
_distributor1.Input.ProcessAsync(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
foreach (var data in list)
{
var transaction = _distributor1.Main.GetTransactionState(data.Transaction.UserTransaction);
Assert.AreEqual(TransactionState.Complete, transaction.State);
}
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
Assert.AreEqual(count, mem.Local);
_writer1.Dispose();
_distributor1.Dispose();
}
protected static void WriteEnd(BinaryWriter writer, HashWriter hashWriter)
{
var endTag = Encoding.Default.GetBytes("ENDB");
writer.Write(4);
writer.Write(endTag);
hashWriter?.Write(endTag);
}
private byte[] GetBytes(HashWriter hashWriter)
{
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream)) {
Write(writer, hashWriter);
return(stream.ToArray());
}
}
public void Write(BinaryWriter writer, HashWriter hashWriter)
{
writer.Write(new byte[] { 0x01, 0x0, 0x0 });
writer.Write((byte)(Italic ? 0x02 : 0x0));
writer.Write(Weight);
writer.Write(Size);
writer.Write((byte)Name.Length);
writer.Write(Encoding.Default.GetBytes(Name));
}
public void Writer_Restore_TwoServersWhenOneServerNotAvailable()
{
#region hell
var writer =
new HashWriter(new HashMapConfiguration("TestRestore", HashMapCreationMode.CreateNew, 2, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.SetServer(1, "localhost", storageServer2, 157);
writer.Save();
var common = new CommonConfiguration(1, 100);
var storageNet1 = new StorageNetConfiguration("localhost", storageServer1, 157, "testService", 10);
var storageConfig = new StorageConfiguration("TestRestore", 1, 10,
TimeSpan.FromMilliseconds(10000),
TimeSpan.FromMilliseconds(200), TimeSpan.FromHours(1), TimeSpan.FromHours(1), false);
var storage1 = new WriterApi(storageNet1, storageConfig, common);
var storageNet2 = new StorageNetConfiguration("localhost", storageServer2, 157, "testService", 10);
var storage2 = new WriterApi(storageNet2, storageConfig, common);
#endregion
_proxy.Start();
_distr.Start();
storage1.Build();
storage1.AddDbModule(new TestInMemoryDbFactory());
storage1.Start();
storage1.Api.Restore(new ServerAddress("localhost", distrServer12), false);
Thread.Sleep(4000);
Assert.IsTrue(storage1.Api.IsRestoreCompleted());
var list = storage1.Api.FailedServers();
Assert.AreEqual(1, list.Count);
storage2.Build();
storage2.AddDbModule(new TestInMemoryDbFactory());
storage2.Start();
storage1.Api.Restore(new ServerAddress("localhost", distrServer12), list, false);
Thread.Sleep(1000);
Assert.IsTrue(storage1.Api.IsRestoreCompleted());
Thread.Sleep(1000);
_proxy.Dispose();
_distr.Dispose();
storage1.Dispose();
storage2.Dispose();
}
private static UInt256 GetSequenceHash(Transaction txTo)
{
using var hw = new HashWriter();
foreach (var i in txTo.Inputs)
{
hw.Add(i.Sequence);
}
return(hw.GetHashFinal());
}
private static UInt256 GetOutputsHash(Transaction txTo)
{
using var hw = new HashWriter();
foreach (var o in txTo.Outputs)
{
hw.Add(o);
}
return(hw.GetHashFinal());
}
public long GetHash()
{
HashWriter ss = new HashWriter(nType, nVersion);
ss << obj;
return(ss.GetHash());
return(SerializeHash(this));
}
public static UInt256 GetPrevOutHash(Transaction txTo)
{
using var hw = new HashWriter();
foreach (var i in txTo.Inputs)
{
hw.Add(i.PrevOut);
}
return(hw.GetHashFinal());
}
public void DbModule_LocalAndRemoteData_Count()
{
var provider = new IntHashConvertor();
var writer =
new HashWriter(new HashMapConfiguration("TestLocalAndRemote", HashMapCreationMode.CreateNew, 2, 3,
HashFileType.Collector));
writer.CreateMap();
writer.SetServer(0, "localhost", 157, 157);
writer.SetServer(1, "localhost", 11011, 157);
writer.Save();
_writer1.Build(157, "TestLocalAndRemote", 1);
var list = new List <InnerData>();
const int count = 100;
for (int i = 0; i < count; i++)
{
var ev =
new InnerData(new Transaction(provider.CalculateHashFromKey(i), "")
{
OperationName = OperationName.Create
})
{
Data = CommonDataSerializer.Serialize(i),
Key = CommonDataSerializer.Serialize(i),
Transaction = { Distributor = new ServerId("localhost", 22188) }
};
ev.Transaction.TableName = "Int";
list.Add(ev);
}
TestHelper.OpenDistributorHostForDb(new ServerId("localhost", 22188), new ConnectionConfiguration("testService", 10));
_writer1.Start();
foreach (var data in list)
{
_writer1.Input.Process(data);
}
Thread.Sleep(1000);
var mem = _writer1.Db.GetDbModules.First() as TestDbInMemory;
Assert.AreNotEqual(count, mem.Local);
Assert.AreNotEqual(count, mem.Remote);
Assert.AreEqual(count, mem.Local + mem.Remote);
_writer1.Dispose();
}
public override void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter)
{
if (!AsInt)
{
WriteValue <TItem, float>(obj, writer, WriteFloat, hashWriter);
}
else
{
WriteValue <TItem, int>(obj, writer, WriteFloat, hashWriter);
}
}
static void Main(string[] args)
{
HashWriter.ArgonParams argonParams = new HashWriter.ArgonParams(2, 8192, 4);
Console.WriteLine("hash test 1, salt = C560325F-6617-4FE9-BF30-04E67D591637");
Console.WriteLine(HashWriter.Hash("hash test 1", "C560325F-6617-4FE9-BF30-04E67D591637", argonParams));
Console.WriteLine("hash test 2, salt = C560325F-6617-4FE9-BF30-04E67D591637");
Console.WriteLine(HashWriter.Hash("hash test 2", "C560325F-6617-4FE9-BF30-04E67D591637", argonParams));
Console.WriteLine("hash test 1, salt = dsdadasd25F-6s17-4FE9-BF30-04E67D591637");
Console.WriteLine(HashWriter.Hash("hash test 1", "dsdadasd25F-6s17-4FE9-BF30-04E67D591637", argonParams));
Console.ReadKey();
}
private byte[] HashExchangeHash()
{
var h = new byte[0];
using (var pw = HashWriter.Create(session.Algorithms.KeyAlgorithmsServer[0]))
{
pw.Write(ExchangeHash, 0, ExchangeHash.Length);
h = pw.Hash;
}
return(h);
}
public override byte[] Sign(byte[] data)
{
Decrypt();
byte[] H;
using (var hw = HashWriter.Create(AlgorithmName))
{
hw.Write(data);
H = hw.Hash;
}
return(((ECDSAManaged)Algorithm).SignHash(H));
}
public override void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter)
{
if (GetValue(obj) is Font font)
{
WriteStart(writer, 0, hashWriter);
font.Write(writer, hashWriter);
}
else
{
throw new InvalidOperationException("Unknown type for [" + GetType().Name + "] on field \"" + Name + "\".");
}
}
private static byte[] GenerateJsonHashImpl(
object obj,
IHashFunction hashFunction,
JsonWriterOptions writerOptions,
JsonSerializerOptions?serializerOptions)
{
var hashWriter = new HashWriter(hashFunction);
JsonSerializer.Serialize(new Utf8JsonWriter(hashWriter, writerOptions), obj, serializerOptions);
return(hashWriter.GetResult());
}
protected void WriteStart(BinaryWriter writer, int dataLength, HashWriter hashWriter)
{
var tag = Encoding.Default.GetBytes(Name);
if (Name.Length < 4)
{
tag = tag.Concat(new byte[4 - Name.Length]).ToArray();
}
writer.Write(dataLength + 4);
writer.Write(tag);
hashWriter?.Write(tag); // only write tag
}
private void WriteVertex3D(BinaryWriter writer, Vertex3D value, HashWriter hashWriter)
{
writer.Write(value.X);
writer.Write(value.Y);
if (!WriteAsVertex2D)
{
writer.Write(value.Z);
if (IsPadded)
{
writer.Write(0f);
}
}
}
public override void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter)
{
if (Type == typeof(byte[]))
{
var bytes = GetValue(obj) as byte[];
WriteStart(writer, bytes.Length, WriteHash(obj) ? hashWriter : null);
writer.Write(bytes);
if (WriteHash(obj))
{
hashWriter?.Write(bytes);
}
}
}
public void ProxyAndDistributor_Read_DirectReadFromOneServerMock()
{
const int storageServer = 22261;
var writer = new HashWriter(new HashMapConfiguration("TestProxyAndDistributorRead1Servers", HashMapCreationMode.CreateNew, 1, 3, HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer, 157);
writer.Save();
var dhc = new DistributorHashConfiguration(1);
var queue = new QueueConfiguration(1, 100);
var connection = new ConnectionConfiguration("testService", 10);
var dcc = new DistributorCacheConfiguration(TimeSpan.FromMilliseconds(600), TimeSpan.FromMilliseconds(1000));
var ndrc = new NetReceiverConfiguration(22260, "localhost", "testService");
var ndrc12 = new NetReceiverConfiguration(23260, "localhost", "testService");
var distr = new DistributorSystem(new ServerId("localhost", 22260),
new ServerId("localhost", 23260),
dhc, queue, connection, dcc, ndrc, ndrc12,
new TransactionConfiguration(1),
new HashMapConfiguration("TestProxyAndDistributorRead1Servers",
HashMapCreationMode.ReadFromFile, 1, 1, HashFileType.Distributor),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new AsyncTasksConfiguration(TimeSpan.FromMinutes(5)),
new ConnectionTimeoutConfiguration(Consts.OpenTimeout, Consts.SendTimeout));
var server = new ServerId("localhost", 23260);
distr.Build();
_proxy.Start();
distr.Start();
GlobalQueue.Queue.Start();
_proxy.Distributor.SayIAmHere(server);
var s = TestHelper.OpenWriterHost(new ServerId("localhost", storageServer), connection);
s.retData = TestHelper.CreateEvent(new StoredDataHashCalculator(), 10);
var api = _proxy.CreateApi("Event", false, new StoredDataHashCalculator());
UserTransaction transaction;
var read = (StoredData)api.Read(10, out transaction);
Assert.AreEqual(10, read.Id);
_proxy.Dispose();
distr.Dispose();
}
public void Writer_ProcessData_SendResultToDistributerMock()
{
const int distributorServer1 = 22171;
const int storageServer1 = 22172;
var writer =
new HashWriter(new HashMapConfiguration("TestDbTransaction", HashMapCreationMode.CreateNew, 1, 1,
HashFileType.Distributor));
writer.CreateMap();
writer.SetServer(0, "localhost", storageServer1, 157);
writer.Save();
_writer1.Build(storageServer1, "TestDbTransaction", 1);
_writer1.Start();
var s = TestHelper.OpenDistributorHostForDb(new ServerId("localhost", distributorServer1),
new ConnectionConfiguration("testService", 10));
var list = new List <InnerData>();
const int count = 100;
for (int i = 1; i < count + 1; i++)
{
var ev =
new InnerData(new Transaction(HashConvertor.GetString(i.ToString(CultureInfo.InvariantCulture)), "")
{
OperationName = OperationName.Create
})
{
Data = CommonDataSerializer.Serialize(i),
Key = CommonDataSerializer.Serialize(i),
Transaction = { Distributor = new ServerId("localhost", distributorServer1) }
};
ev.Transaction.TableName = "Int";
list.Add(ev);
}
foreach (var data in list)
{
_writer1.Q.DbInputProcessQueue.Add(data);
}
Thread.Sleep(TimeSpan.FromMilliseconds(1000));
Assert.AreEqual(count, s.SendValue);
_writer1.Dispose();
}
private byte[] CalculateExchangeHash()
{
using (var pw = HashWriter.Create(session.Algorithms.KexAlgorithms[0]))
{
pw.WriteString(session.ClientIdentifier.ToSshMessage());
pw.WriteString(session.ServerIdentifier.ToSshMessage());
pw.WriteString(session.KexProcessor.ClientKexInit.ToSshMessage());
pw.WriteString(session.KexProcessor.ServerKexInit.ToSshMessage());
pw.WriteString(ServerHostKey);
pw.WriteString(ClientPublicKey);
pw.WriteString(ServerPublicKey);
pw.WriteString(SharedSecret);
return(pw.Hash);
}
}
public void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter) where TItem : BiffData
{
var tag = Encoding.Default.GetBytes(Name);
if (Name.Length < 4)
{
tag = tag.Concat(new byte[4 - Name.Length]).ToArray();
}
writer.Write(Data.Length + 4);
writer.Write(tag);
writer.Write(Data);
hashWriter?.Write(tag);
hashWriter?.Write(Data);
}
public override void Write <TItem>(TItem obj, BinaryWriter writer, HashWriter hashWriter)
{
if (Type == typeof(int))
{
WriteValue <TItem, int>(obj, writer, WriteInt, hashWriter);
}
else if (Type == typeof(uint))
{
WriteValue <TItem, uint>(obj, writer, WriteUInt, hashWriter);
}
else
{
throw new InvalidOperationException("Unknown type for [BiffInt] on field \"" + Name + "\".");
}
}
