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; }