private NetworkClientBase SetupNetworkClient(int readSize, int blockSize)
{
Mock <NetworkClientBase> mockedClient = new Mock <NetworkClientBase>();
ICryptoServiceProvider encryptProvider = Mock.Of <ICryptoServiceProvider>();
Mock <ICryptoServiceProvider> decryptProvider = new Mock <ICryptoServiceProvider>();
int[] intRef = new int[1];
//Setup the client to produce incrementing values in the byte array
mockedClient.Setup(o => o.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns((byte[] buffer, int start, int count, CancellationToken token) =>
{
for (int i = 0; i < count; i++)
{
buffer[i + start] = (byte)intRef[0];
intRef[0] = intRef[0] + 1;
}
return(Task.FromResult(readSize));
});
decryptProvider.Setup(o => o.Crypt(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns((byte[] bytes, int offset, int count) =>
{
for (int i = 0; i < count; i++)
{
bytes[i + offset] = (byte)(bytes[i + offset] * 2);
}
return(bytes);
});
return(new NetworkClientFixedBlockSizeCryptoDecorator(mockedClient.Object, encryptProvider, decryptProvider.Object, blockSize));
}
/// <summary>
/// Creates a new crypto decorator for the <see cref="NetworkClientBase"/>.
/// Extends the <see cref="ReadAsync"/> and <see cref="WriteAsync"/> implementations to pass
/// all bytes through the corresponding incoming and outgoing ciphers.
/// </summary>
/// <param name="decoratedClient">The client to decorate.</param>
/// <param name="encryptionServiceProvider">The encryption service.</param>
/// <param name="decryptionServiceProvider">The decryption service.</param>
public NetworkClientFixedBlockSizeCryptoDecorator(NetworkClientBase decoratedClient, ICryptoServiceProvider encryptionServiceProvider, ICryptoServiceProvider decryptionServiceProvider, int blockSize, int cryptoBufferSize = 30000)
{
if (decoratedClient == null)
{
throw new ArgumentNullException(nameof(decoratedClient));
}
if (encryptionServiceProvider == null)
{
throw new ArgumentNullException(nameof(encryptionServiceProvider));
}
if (decryptionServiceProvider == null)
{
throw new ArgumentNullException(nameof(decryptionServiceProvider));
}
if (blockSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(blockSize));
}
DecoratedClient = decoratedClient;
EncryptionServiceProvider = encryptionServiceProvider;
DecryptionServiceProvider = decryptionServiceProvider;
BlockSize = blockSize;
//One of the lobby packets is 14,000 bytes. We may even need bigger.
ReadBuffer = new AsyncLockableBuffer(cryptoBufferSize);
WriteBuffer = new AsyncLockableBuffer(cryptoBufferSize);
CryptoBlockOverflow = new byte[Math.Max(blockSize - 1, 0)]; //we only need
CryptoBlockOverflowReadIndex = CryptoBlockOverflow.Length; //set this to last index to indicate empty initially
}
/// <summary>
/// Processes a block of bytes through an RC4 cipher in place.
/// </summary>
/// <param name="provider">The crypto provider.</param>
/// <param name="input">The input buffer.</param>
/// <param name="inOff">The offset to start at in the input buffer.</param>
/// <exception cref="ArgumentNullException">Throws if any buffer is null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Throws if any offset or length is less than 0.</exception>
public static byte[] ProcessBytesToNewBuffer(this ICryptoServiceProvider provider, [NotNull] byte[] input, int inOff)
{
byte[] outputBuffer = new byte[input.Length - inOff];
provider.ProcessBytes(input, inOff, input.Length - inOff, outputBuffer, inOff);
return(outputBuffer);
}
/// <inheritdoc />
public void Initialize(TVectorType key)
{
InitializationVector = key;
//Once the key is initialized we can create the CryptoProvider
//by calling value whic creates it
ICryptoServiceProvider provider = CryptoProvider.Value;
}
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);
}
// Internal method for unit testing.
internal static byte[] Unprotect(ICryptoServiceProvider cryptoServiceProvider, byte[] protectedData, string[] purposes)
{
// If the user is calling this method, we want to use the ICryptoServiceProvider
// regardless of whether or not it's the default provider.
Purpose derivedPurpose = Purpose.User_MachineKey_Protect.AppendSpecificPurposes(purposes);
ICryptoService cryptoService = cryptoServiceProvider.GetCryptoService(derivedPurpose);
return(cryptoService.Unprotect(protectedData));
}
/// <summary>
/// Creates a new crypto decorator for the <see cref="NetworkClientBase"/>.
/// Extends the <see cref="ReadAsync"/> and <see cref="WriteAsync"/> implementations to pass
/// all bytes through the corresponding incoming and outgoing ciphers.
/// </summary>
/// <param name="decoratedClient">The client to decorate.</param>
/// <param name="encryptionServiceProvider">The encryption service.</param>
/// <param name="decryptionServiceProvider">The decryption service.</param>
public NetworkClientBlocklessCryptoDecorator(NetworkClientBase decoratedClient, ICryptoServiceProvider encryptionServiceProvider, ICryptoServiceProvider decryptionServiceProvider)
{
if (decoratedClient == null)
{
throw new ArgumentNullException(nameof(decoratedClient));
}
if (encryptionServiceProvider == null)
{
throw new ArgumentNullException(nameof(encryptionServiceProvider));
}
if (decryptionServiceProvider == null)
{
throw new ArgumentNullException(nameof(decryptionServiceProvider));
}
DecoratedClient = decoratedClient;
EncryptionServiceProvider = encryptionServiceProvider;
DecryptionServiceProvider = decryptionServiceProvider;
}
/// <summary>
/// Processes a block of bytes through an RC4 cipher in place.
/// </summary>
/// <param name="provider">The crypto provider.</param>
/// <param name="input">The input buffer.</param>
/// <param name="inOff">The offset to start at in the input buffer.</param>
/// <exception cref="ArgumentNullException">Throws if any buffer is null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Throws if any offset or length is less than 0.</exception>
public static byte[] ProcessBytes(this ICryptoServiceProvider provider, [NotNull] byte[] input, int inOff)
{
provider.ProcessBytes(input, inOff, input.Length, input, inOff);
return(input);
}
// Internal method for unit testing.
internal static byte[] Unprotect(ICryptoServiceProvider cryptoServiceProvider, byte[] protectedData, string[] purposes) {
// If the user is calling this method, we want to use the ICryptoServiceProvider
// regardless of whether or not it's the default provider.
Purpose derivedPurpose = Purpose.User_MachineKey_Protect.AppendSpecificPurposes(purposes);
ICryptoService cryptoService = cryptoServiceProvider.GetCryptoService(derivedPurpose);
return cryptoService.Unprotect(protectedData);
}
public MapperService()
{
_cryptoServiceProvider = DependencyService.Resolve <ICryptoServiceProvider>();
_cryptoService = DependencyService.Resolve <ICryptoService>();
}
/// <summary>
/// Enables crypt handling for the client.
/// </summary>
/// <typeparam name="TNetworkClientType">The client type.</typeparam>
/// <param name="client">The client to add crypt handling to.</param>
/// <param name="encryptionService">The service used to encrypt.</param>
/// <param name="decryptionService">The service used to decrypt.</param>
/// <returns>A client with crypto handling functionality.</returns>
public static NetworkClientBase AddCryptHandling <TNetworkClientType>(this TNetworkClientType client, ICryptoServiceProvider encryptionService, ICryptoServiceProvider decryptionService)
where TNetworkClientType : NetworkClientBase
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (encryptionService == null)
{
throw new ArgumentNullException(nameof(encryptionService));
}
if (decryptionService == null)
{
throw new ArgumentNullException(nameof(decryptionService));
}
//TODO: Check the blocksize for both. We don't support different blocksizes yet
if (encryptionService.BlockSize != 0 && encryptionService.BlockSize != 1)
{
return(new NetworkClientFixedBlockSizeCryptoDecorator(client, encryptionService, decryptionService, encryptionService.BlockSize));
}
return(new NetworkClientBlocklessCryptoDecorator(client, encryptionService, decryptionService));
}
public RngHashService(ICryptoServiceProvider cryptoServiceProvider, IDeriveBytes deriveBytesProvider)
{
_cryptoServiceProvider = cryptoServiceProvider;
_deriveBytesProvider = deriveBytesProvider;
}
