public void SendSomeMessagesBothDirectionsWithEcdhTest()
{
var(client, server) = Common.CreateAndInitialize();
RandomNumberGenerator rng = new RandomNumberGenerator();
byte[] cmessage1 = rng.Generate(32);
byte[] cmessage2 = rng.Generate(32);
byte[] cmessage3 = rng.Generate(32);
byte[] smessage1 = rng.Generate(32);
byte[] smessage2 = rng.Generate(32);
byte[] smessage3 = rng.Generate(32);
var cp1 = client.Send(cmessage1);
var sr1 = server.Receive(cp1).Payload;
Assert.Equal(cmessage1, sr1);
var sp1 = server.Send(smessage1);
var cr1 = client.Receive(sp1).Payload;
Assert.Equal(smessage1, cr1);
var cp2 = client.Send(cmessage2);
var sr2 = server.Receive(cp2).Payload;
Assert.Equal(cmessage2, sr2);
var sp2 = server.Send(smessage2);
var cr2 = client.Receive(sp2).Payload;
Assert.Equal(smessage2, cr2);
var cp3 = client.Send(cmessage3);
var sr3 = server.Receive(cp3).Payload;
Assert.Equal(cmessage3, sr3);
var sp3 = server.Send(smessage3);
var cr3 = client.Receive(sp3).Payload;
Assert.Equal(smessage3, cr3);
using var cms = new MemoryStream();
using var sms = new MemoryStream();
client.SaveState(cms); cms.Position = 0;
server.SaveState(sms); sms.Position = 0;
var cs = ClientState.Load(cms, DefaultKexFactory.Instance);
var ss = ServerState.Load(sms, DefaultKexFactory.Instance);
Assert.Equal(4, cs.Ratchets.Count);
Assert.Equal(4, ss.Ratchets.Count);
}
public void ClientInitialization2ProcessTest()
{
BouncyCastleServices clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
BouncyCastleServices serverServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var client = new MicroRatchetContext(clientServices, true);
var server = new MicroRatchetContext(serverServices, false);
var clientInitPacket = client.InitiateInitialization();
var responsePacket = server.Receive(clientInitPacket).ToSendBack;
var cs = client.SaveStateAsByteArray();
var ss = server.SaveStateAsByteArray();
ClientState clientState = ClientState.Load(cs, DefaultKexFactory.Instance);
ServerState serverState = ServerState.Load(ss, DefaultKexFactory.Instance);
}
public void ClientInitialization1MessageTest()
{
BouncyCastleServices clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var client = new MicroRatchetContext(clientServices, true);
var clientInitPacket = client.InitiateInitialization();
var sb = client.SaveStateAsByteArray();
ClientState clientState = ClientState.Load(sb, DefaultKexFactory.Instance);
Assert.NotNull(clientState.LocalEcdhForInit);
Assert.NotNull(clientState.InitializationNonce);
Assert.Equal(MicroRatchetContext.InitializationNonceSize, clientState.InitializationNonce.Length);
}
public void ClientInitializationRetransmitThrowsTest()
{
// this test makes sure that during the initialization process
// any retransmitted packet will cause an exception. However,
// the initialization process will not be affected and a client
// and server can still process non-repeated messages.
BouncyCastleServices clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
BouncyCastleServices serverServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var client = new MicroRatchetContext(clientServices, true);
var server = new MicroRatchetContext(serverServices, false);
var clientInitPacket = client.InitiateInitialization();
var responsePacket = server.Receive(clientInitPacket.ToArray()).ToSendBack;
Assert.Throws <InvalidOperationException>(() => server.Receive(clientInitPacket.ToArray()));
var firstPacket = client.Receive(responsePacket.ToArray()).ToSendBack;
Assert.Throws <InvalidOperationException>(() => client.Receive(responsePacket.ToArray()));
var firstResponse = server.Receive(firstPacket.ToArray()).ToSendBack;
Assert.Throws <InvalidOperationException>(() => server.Receive(firstPacket.ToArray()));
var lastResult = client.Receive(firstResponse.ToArray()).ToSendBack;
Assert.Throws <InvalidOperationException>(() => client.Receive(firstResponse.ToArray()));
var cs = client.SaveStateAsByteArray();
var ss = server.SaveStateAsByteArray();
ClientState clientState = ClientState.Load(cs, DefaultKexFactory.Instance);
ServerState serverState = ServerState.Load(ss, DefaultKexFactory.Instance);
var rng = new RandomNumberGenerator();
byte[] message1 = rng.Generate(32);
byte[] message2 = rng.Generate(32);
var m1 = client.Send(message1);
var p1 = server.Receive(m1).Payload;
var m2 = server.Send(message2);
var p2 = client.Receive(m2).Payload;
Assert.Equal(message1, p1);
Assert.Equal(message2, p2);
}
public void SendSomeMessagesBothDirectionsWithEcdhMultiTest()
{
var(client, server) = Common.CreateAndInitialize();
RandomNumberGenerator rng = new RandomNumberGenerator();
byte[] cmessage1 = rng.Generate(32);
byte[] cmessage2 = rng.Generate(32);
byte[] cmessage3 = rng.Generate(32);
byte[] cmessage4 = rng.Generate(32);
byte[] cmessage5 = rng.Generate(32);
byte[] cmessage6 = rng.Generate(32);
byte[] smessage1 = rng.Generate(32);
byte[] smessage2 = rng.Generate(32);
byte[] smessage3 = rng.Generate(32);
byte[] smessage4 = rng.Generate(32);
byte[] smessage5 = rng.Generate(32);
byte[] smessage6 = rng.Generate(32);
var cp1 = client.Send(cmessage1);
var cp2 = client.Send(cmessage2);
var sr1 = server.Receive(cp1).Payload;
var sr2 = server.Receive(cp2).Payload;
Assert.Equal(cmessage1, sr1);
Assert.Equal(cmessage2, sr2);
var sp1 = server.Send(smessage1);
var sp2 = server.Send(smessage2);
var cr1 = client.Receive(sp1).Payload;
var cr2 = client.Receive(sp2).Payload;
Assert.Equal(smessage1, cr1);
Assert.Equal(smessage2, cr2);
var cp3 = client.Send(cmessage3);
var cp4 = client.Send(cmessage4);
var sr3 = server.Receive(cp3).Payload;
var sr4 = server.Receive(cp4).Payload;
Assert.Equal(cmessage3, sr3);
Assert.Equal(cmessage4, sr4);
var sp3 = server.Send(smessage3);
var sp4 = server.Send(smessage4);
var cr3 = client.Receive(sp3).Payload;
var cr4 = client.Receive(sp4).Payload;
Assert.Equal(smessage3, cr3);
Assert.Equal(smessage4, cr4);
var cp5 = client.Send(cmessage5);
var cp6 = client.Send(cmessage6);
var sr5 = server.Receive(cp5).Payload;
var sr6 = server.Receive(cp6).Payload;
Assert.Equal(cmessage5, sr5);
Assert.Equal(cmessage6, sr6);
var sp5 = server.Send(smessage5);
var sp6 = server.Send(smessage6);
var cr5 = client.Receive(sp5).Payload;
var cr6 = client.Receive(sp6).Payload;
Assert.Equal(smessage5, cr5);
Assert.Equal(smessage6, cr6);
var css = client.SaveStateAsByteArray();
var sss = server.SaveStateAsByteArray();
var cs = ClientState.Load(css, DefaultKexFactory.Instance);
var ss = ServerState.Load(sss, DefaultKexFactory.Instance);
Assert.Equal(4, cs.Ratchets.Count);
Assert.Equal(4, ss.Ratchets.Count);
}
public void ClientInitStateTest()
{
var clientServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
var serverServices = new BouncyCastleServices(KeyGeneration.GeneratePrivateKey());
byte[] cs, ss;
RandomNumberGenerator rng = new RandomNumberGenerator();
byte[] message1 = rng.Generate(64);
byte[] message2 = rng.Generate(64);
byte[] message3 = rng.Generate(64);
var client = new MicroRatchetContext(clientServices, true);
var kex = clientServices.KeyAgreementFactory;
var clientInitPacket = client.InitiateInitialization();
cs = client.SaveStateAsByteArray();
{
var ts = ClientState.Load(cs, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, cs);
}
var server = new MicroRatchetContext(serverServices, false);
var responsePacket = server.Receive(clientInitPacket).ToSendBack;
ss = server.SaveStateAsByteArray();
{
var ts = ServerState.Load(ss, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, ss);
}
client = new MicroRatchetContext(clientServices, true, stateBytes: cs);
var firstPacket = client.Receive(responsePacket).ToSendBack;
cs = client.SaveStateAsByteArray();
{
var ts = ClientState.Load(cs, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, cs);
}
server = new MicroRatchetContext(serverServices, false, stateBytes: ss);
var firstResponse = server.Receive(firstPacket).ToSendBack;
ss = server.SaveStateAsByteArray();
{
var ts = ServerState.Load(ss, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, ss);
}
client = new MicroRatchetContext(clientServices, true, stateBytes: cs);
var lastResult = client.Receive(firstResponse).ToSendBack;
cs = client.SaveStateAsByteArray();
{
var ts = ClientState.Load(cs, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, cs);
}
client = new MicroRatchetContext(clientServices, true, 80, stateBytes: cs);
var pl1 = client.Send(message1);
cs = client.SaveStateAsByteArray();
{
var ts = ClientState.Load(cs, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, cs);
}
client = new MicroRatchetContext(clientServices, true, 80, stateBytes: cs);
var pl2 = client.Send(message2);
cs = client.SaveStateAsByteArray();
{
var ts = ClientState.Load(cs, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, cs);
}
client = new MicroRatchetContext(clientServices, true, 80, stateBytes: cs);
var pl3 = client.Send(message3);
cs = client.SaveStateAsByteArray();
{
var ts = ClientState.Load(cs, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, cs);
}
server = new MicroRatchetContext(serverServices, false, 80, stateBytes: ss);
var r1 = server.Receive(pl1).Payload;
ss = server.SaveStateAsByteArray();
{
var ts = ServerState.Load(ss, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, ss);
}
server = new MicroRatchetContext(serverServices, false, 80, stateBytes: ss);
var r2 = server.Receive(pl2).Payload;
ss = server.SaveStateAsByteArray();
{
var ts = ServerState.Load(ss, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, ss);
}
server = new MicroRatchetContext(serverServices, false, 80, stateBytes: ss);
var r3 = server.Receive(pl3).Payload;
ss = server.SaveStateAsByteArray();
{
var ts = ServerState.Load(ss, kex, ks).StoreAsByteArray(5);
Assert.Equal(ts, ss);
}
Assert.Equal(message1, r1);
Assert.Equal(message2, r2);
Assert.Equal(message3, r3);
Assert.Null(lastResult);
}
