public void Test_Can_Construct_Crypto_Decorator_WithNoBufferSize()
{
//arrange
NetworkClientBase mockedClient = Mock.Of <NetworkClientBase>();
ICryptoServiceProvider encryptProvider = Mock.Of <ICryptoServiceProvider>();
ICryptoServiceProvider decryptProvider = Mock.Of <ICryptoServiceProvider>();
NetworkClientFixedBlockSizeCryptoDecorator decorator = new NetworkClientFixedBlockSizeCryptoDecorator(mockedClient, encryptProvider, decryptProvider, 1);
}
public void Test_Can_Read_Correct_EqualSizeChunks_With_Large_Buffer_Size(int blockSize, int readSize)
{
//arrange
NetworkClientBase decorator = SetupNetworkClient(readSize, blockSize);
byte[] readBuffer = new byte[readSize * 500];
//assert
for (int i = 0; i < 100; i = i + 4)
{
int result = decorator.ReadAsync(readBuffer, 0, readSize, CancellationToken.None).Result;
Assert.AreEqual(readSize, result, "Crypto reader didn't read the requested amount of bytes.");
for (int j = 0; j < readSize; j++)
{
Assert.AreEqual((i + j) * 2, readBuffer[j], "Value read from crypto read wasn't the expected value.");
}
}
}
/// <summary>
/// Implementer should build the <see cref="IManagedNetworkClient{TPayloadWriteType,TPayloadReadType}"/>
/// for the outgoing client.
/// </summary>
/// <param name="clientBase">The client base to use.</param>
/// <param name="serializeService">The serializer to use.</param>
/// <returns>The built managed client.</returns>
protected abstract IManagedNetworkClient <TPayloadReadType, TPayloadWriteType> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService);
/// <inheritdoc />
protected override IManagedNetworkClient <AuthenticationClientPayload, AuthenticationServerPayload> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//We need to create an actual client to the server too.
return(clientBase
.AddHeaderlessNetworkMessageReading(serializeService)
.For <AuthenticationServerPayload, AuthenticationClientPayload, IAuthenticationPayload>()
.Build()
.AsManagedSession(Logger));
}
/// <inheritdoc />
protected override IManagedNetworkServerClient <AuthenticationServerPayload, AuthenticationClientPayload> BuildIncomingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//TODO: Are any details actually valuable here?
if (Logger.IsInfoEnabled)
{
Logger.Info($"Client connected to proxy.");
}
//The auth server is encryptionless and 'headerless' so we do not need to support that on the proxy for the auth server
return(clientBase
.AddHeaderlessNetworkMessageReading(serializeService)
.For <AuthenticationClientPayload, AuthenticationServerPayload, IAuthenticationPayload>()
.Build()
.AsManagedSession(Logger));
}
/// <inheritdoc />
protected override IManagedNetworkClient <PSOBBGamePacketPayloadClient, PSOBBGamePacketPayloadServer> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//Copied from the test client project
IManagedNetworkClient <PSOBBGamePacketPayloadClient, PSOBBGamePacketPayloadServer> client = clientBase
.AddCryptHandling(ServerEncryptionService, ServerDecryptionService)
.AddBufferredWrite(4)
.AddHeaderReading <PSOBBPacketHeader>(serializeService, 2)
.AddNetworkMessageReading(serializeService)
.For <PSOBBGamePacketPayloadServer, PSOBBGamePacketPayloadClient, IPacketPayload>(new PSOBBPacketHeaderFactory())
.AddReadBufferClearing()
.Build()
.AsManagedSession();
return(client);
}
/// <inheritdoc />
protected override IManagedNetworkServerClient <PSOBBGamePacketPayloadServer, PSOBBGamePacketPayloadClient> BuildIncomingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
ResetCrypto();
Logger.Info($"Client connecting to Proxy App with Listener: {this.ServerAddress.AddressEndpoint}:{this.ServerAddress.Port}");
IManagedNetworkServerClient <PSOBBGamePacketPayloadServer, PSOBBGamePacketPayloadClient> session = clientBase
.AddCryptHandling(ClientEncryptionService, ClientDecryptionService)
.AddBufferredWrite(4)
.AddHeaderReading <PSOBBPacketHeader>(serializeService, 2)
.AddNetworkMessageReading(serializeService)
.For <PSOBBGamePacketPayloadClient, PSOBBGamePacketPayloadServer, IPacketPayload>(new PSOBBPacketHeaderFactory())
.AddReadBufferClearing()
.Build()
.AsManagedSession();
return(session);
}
/// <inheritdoc />
protected override IManagedNetworkClient <GamePacketPayload, GamePacketPayload> BuildOutgoingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
SRP6SessionKeyStore keyStore = ServiceContainer.Resolve <SRP6SessionKeyStore>();
ICombinedSessionPacketCryptoService cryptoService = BuildOutgoingPacketCryptoService(keyStore);
var wowClientReadServerWrite = new WoWClientWriteServerReadProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>(clientBase, serializeService, cryptoService);
return(new ManagedNetworkServerClient <WoWClientWriteServerReadProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>, GamePacketPayload, GamePacketPayload>(wowClientReadServerWrite, Logger));
}
/// <inheritdoc />
protected override IManagedNetworkServerClient <GamePacketPayload, GamePacketPayload> BuildIncomingSessionManagedClient(NetworkClientBase clientBase, INetworkSerializationService serializeService)
{
//TODO: Are any details actually valuable here?
if (Logger.IsInfoEnabled)
{
Logger.Info($"Client connected to proxy.");
}
SRP6SessionKeyStore keyStore = ServiceContainer.Resolve <SRP6SessionKeyStore>();
ICombinedSessionPacketCryptoService cryptoService = BuildIncomingPacketCryptoService(keyStore);
var wowClientReadServerWrite = new WoWClientReadServerWriteProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>(clientBase, serializeService, cryptoService, Logger);
return(new ManagedNetworkServerClient <WoWClientReadServerWriteProxyPacketPayloadReaderWriterDecorator <NetworkClientBase, GamePacketPayload, GamePacketPayload, IGamePacketPayload>, GamePacketPayload, GamePacketPayload>(wowClientReadServerWrite, Logger));
}
