private string NextToken(char[] delimiters) { var str = ""; var currentPos = _currentPos; while (Array.IndexOf(delimiters, _chars[(int)((IntPtr)_currentPos)], 0, delimiters.Length) != -1) { if ((_currentPos += 1L) == _chars.Length) { _currentPos = currentPos; throw ExceptionUtility.ArgumentOutOfRange("delimiters"); } } while (Array.IndexOf(delimiters, _chars[(int)((IntPtr)_currentPos)], 0, delimiters.Length) == -1) { str = str + _chars[(int)((IntPtr)_currentPos)]; if ((_currentPos += 1L) == _chars.Length) { return(str); } } return(str); }
private bool VerifyHash(byte[] hash, byte[] signature) { if (hash == null) { throw ExceptionUtility.ArgumentNull("hash"); } if (signature == null) { throw ExceptionUtility.ArgumentNull("signature"); } if (hash.Length != 64) { throw ExceptionUtility.ArgumentOutOfRange("InvalidHashSize"); } bool res = false; UsingKey(h => { res = CryptoApiHelper.VerifySign(_providerHandle, h, hash, signature, GostAlgorithmType.Gost2012_512); }); return(res); }
private byte[] SignHash(byte[] hash) { if (hash == null) { throw ExceptionUtility.ArgumentNull("hash"); } if (hash.Length != 32) { throw ExceptionUtility.ArgumentOutOfRange("hash", Resources.InvalidHashSize); } if (IsPublicKeyOnly) { throw ExceptionUtility.CryptographicException(Resources.NoPrivateKey); } GetKeyPair(); if (!CspKeyContainerInfo.RandomlyGenerated) { var keyContainerPermission = new KeyContainerPermission(KeyContainerPermissionFlags.NoFlags); var keyContainerAccessEntry = new KeyContainerPermissionAccessEntry(_providerParameters, KeyContainerPermissionFlags.Sign); keyContainerPermission.AccessEntries.Add(keyContainerAccessEntry); keyContainerPermission.Demand(); } return(CryptoApiHelper.SignValue(_providerHandle, _providerParameters.KeyNumber, hash)); }
public static Gost_28147_89_SymmetricAlgorithm CreateFromPassword(HashAlgorithm hashAlgorithm, byte[] password) { if (hashAlgorithm == null) { throw ExceptionUtility.ArgumentNull(nameof(hashAlgorithm)); } if (!(hashAlgorithm is IGostAlgorithm gostHashAlgorithm)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(hashAlgorithm)); } if (!(hashAlgorithm is ISafeHandleProvider <SafeHashHandleImpl> hashHandleProvider)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(hashAlgorithm)); } if (password == null) { throw ExceptionUtility.ArgumentNull(nameof(password)); } hashAlgorithm.TransformBlock(password, 0, password.Length, password, 0); var providerType = gostHashAlgorithm.ProviderType; var providerHandle = CryptoApiHelper.GetProviderHandle(providerType); var symKeyHandle = CryptoApiHelper.DeriveSymKey(providerHandle, hashHandleProvider.SafeHandle); return(new Gost_28147_89_SymmetricAlgorithm(providerType, providerHandle, symKeyHandle)); }
public static unsafe void HashData(SafeHashHandleImpl hashHandle, byte[] data, int dataOffset, int dataLength) { if (data == null) { throw ExceptionUtility.ArgumentNull(nameof(data)); } if (dataOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataOffset)); } if (dataLength < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataLength)); } if (data.Length < dataOffset + dataLength) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataLength)); } if (dataLength > 0) { fixed(byte *dataRef = data) { var dataOffsetRef = dataRef + dataOffset; if (!CryptoApi.CryptHashData(hashHandle, dataOffsetRef, (uint)dataLength, 0)) { throw CreateWin32Error(); } } } }
public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { if (inputBuffer == null) { throw ExceptionUtility.ArgumentNull(nameof(inputBuffer)); } if (inputOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(inputOffset)); } if ((inputCount < 0) || (inputCount > inputBuffer.Length)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(inputOffset), Resources.InvalidDataOffset); } if ((inputBuffer.Length - inputCount) < inputOffset) { throw ExceptionUtility.ArgumentOutOfRange(nameof(inputOffset), Resources.InvalidDataOffset); } byte[] buffer = null; if (_transformMode == Gost_28147_89_CryptoTransformMode.Encrypt) { CryptoApiHelper.EncryptData(_providerType, _keyHandle, inputBuffer, inputOffset, inputCount, ref buffer, 0, _paddingValue, true, _isStreamModeValue); Reset(); return(buffer); } if (_isStreamModeValue) { CryptoApiHelper.DecryptData(_keyHandle, inputBuffer, inputOffset, inputCount, ref buffer, 0, _paddingValue, true); Reset(); return(buffer); } if ((inputCount % InputBlockSize) != 0) { throw ExceptionUtility.CryptographicException(Resources.DecryptInvalidDataSize); } if (_dataBuffer == null) { CryptoApiHelper.DecryptData(_keyHandle, inputBuffer, inputOffset, inputCount, ref buffer, 0, _paddingValue, true); Reset(); return(buffer); } var destinationArray = new byte[_dataBuffer.Length + inputCount]; Array.Copy(_dataBuffer, 0, destinationArray, 0, _dataBuffer.Length); Array.Copy(inputBuffer, inputOffset, destinationArray, _dataBuffer.Length, inputCount); CryptoApiHelper.DecryptData(_keyHandle, destinationArray, 0, destinationArray.Length, ref buffer, 0, _paddingValue, true); Reset(); return(buffer); }
/// <inheritdoc /> protected override void ValidateHashParameter(byte[] hash) { if (hash == null) { throw ExceptionUtility.ArgumentNull(nameof(hash)); } if (hash.Length != Gost_R3411_2012_256_HashAlgorithm.DefaultHashSizeValue / 8) { throw ExceptionUtility.ArgumentOutOfRange(nameof(hash), Resources.InvalidHashSize, Gost_R3411_2012_256_HashAlgorithm.DefaultHashSizeValue / 8); } }
private byte[] EncodeKeyExchangeInternal(Gost28147SymmetricAlgorithm keyExchangeAlgorithm, GostKeyExchangeExportMethod keyExchangeExportMethod) { switch (keyExchangeExportMethod) { case GostKeyExchangeExportMethod.GostKeyExport: return(EncodeKeyExchangeInternal(keyExchangeAlgorithm, Constants.CALG_SIMPLE_EXPORT)); case GostKeyExchangeExportMethod.CryptoProKeyExport: return(EncodeKeyExchangeInternal(keyExchangeAlgorithm, Constants.CALG_PRO_EXPORT)); } throw ExceptionUtility.ArgumentOutOfRange("keyExchangeExportMethod"); }
protected static int ParseInt(string str, IntHolder off, int len) { if ((off.Value + len) > str.Length) { throw ExceptionUtility.ArgumentOutOfRange("off"); } var mValue = off.Value; off.Value += len; return(int.Parse(str.Substring(mValue, len))); }
public override SymmetricAlgorithm DecodeKeyExchange(byte[] encodedKeyExchangeData, GostKeyExchangeExportMethod keyExchangeExportMethod) { switch (keyExchangeExportMethod) { case GostKeyExchangeExportMethod.GostKeyExport: return(DecodeKeyExchangeInternal(encodedKeyExchangeData, Constants.CALG_SIMPLE_EXPORT)); case GostKeyExchangeExportMethod.CryptoProKeyExport: return(DecodeKeyExchangeInternal(encodedKeyExchangeData, Constants.CALG_PRO_EXPORT)); } throw ExceptionUtility.ArgumentOutOfRange(nameof(keyExchangeExportMethod)); }
/// <inheritdoc /> public override void SetKey(AsymmetricAlgorithm privateKey) { if (privateKey == null) { throw ExceptionUtility.ArgumentNull(nameof(privateKey)); } if (!(privateKey is GostAsymmetricAlgorithm gostPrivateKey)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(privateKey), Resources.ShouldSupportGost3410); } _privateKey = gostPrivateKey; }
/// <inheritdoc /> public override void SetKey(AsymmetricAlgorithm publicKey) { if (publicKey == null) { throw ExceptionUtility.ArgumentNull(nameof(publicKey)); } if (!(publicKey is Gost_R3410_AsymmetricAlgorithmBase <TKeyParams, TKeyAlgorithm> gostPublicKey)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(publicKey), Resources.ShouldSupportGost3410); } _publicKey = gostPublicKey; }
/// <summary> /// Устанавливает открытый ключ для проверки цифрововй подписи. /// </summary> /// <param name="publicKey">Открытый ключ для проверки цифровой подписи.</param> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentNullException"></exception> public override void SetKey(AsymmetricAlgorithm publicKey) { if (publicKey == null) { throw ExceptionUtility.ArgumentNull("publicKey"); } if (!(publicKey is Gost3410AsymmetricAlgorithmBase)) { throw ExceptionUtility.ArgumentOutOfRange("publicKey", Resources.ShouldSupportGost3410); } _publicKey = (Gost3410AsymmetricAlgorithmBase)publicKey; }
private byte[] SignHash(byte[] hash) { if (hash == null) { throw ExceptionUtility.ArgumentNull("hash"); } if (hash.Length != 64) { throw ExceptionUtility.ArgumentOutOfRange("hash", "InvalidHashSize"); } var res = CryptoApiHelper.SignValue(_providerHandle, _providerParameters.KeyNumber, hash, GostAlgorithmType.Gost2012_512); return(res); }
/// <inheritdoc /> public override void SetKey(AsymmetricAlgorithm publicKey) { if (publicKey == null) { throw ExceptionUtility.ArgumentNull(nameof(publicKey)); } if (!(publicKey is GostAsymmetricAlgorithm gostPublicKey)) { if (publicKey.SignatureAlgorithm.IndexOf("gost", StringComparison.OrdinalIgnoreCase) < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(publicKey), Resources.ShouldSupportGost3410); } gostPublicKey = new GostExternalAsymmetricAlgorithm(publicKey); } _publicKey = gostPublicKey; }
public Gost_28147_89_SymmetricAlgorithmBase DeriveKey(int position) { if ((position % _hmac.HashSize) != 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(position)); } var keyIndex = position / _hmac.HashSize; if (keyIndex < _keyIndex) { throw ExceptionUtility.ArgumentOutOfRange(nameof(position)); } while (keyIndex > _keyIndex) { DeriveKey().Clear(); } return(DeriveKey()); }
public Gost28147 DeriveKey(int position) { if ((position % 256) != 0) { throw ExceptionUtility.ArgumentOutOfRange("position"); } var keyIndex = position / 256; if (keyIndex < _keyIndex) { throw ExceptionUtility.ArgumentOutOfRange("position"); } while (keyIndex > _keyIndex) { DeriveKey().Clear(); } return(DeriveKey()); }
public string NextToken(string delimiters) { _delimiters = delimiters; var array = delimiters.ToCharArray(); if (_currentPos == _chars.Length) { throw ExceptionUtility.ArgumentOutOfRange("delimiters"); } if ((Array.IndexOf(array, _chars[(int)((IntPtr)_currentPos)], 0, array.Length) != -1) && _includeDelims) { long num; _currentPos = (num = _currentPos) + 1L; return("" + _chars[(int)((IntPtr)num)]); } return(NextToken(delimiters.ToCharArray())); }
private bool VerifyHash(byte[] hash, byte[] signature) { if (hash == null) { throw ExceptionUtility.ArgumentNull("hash"); } if (signature == null) { throw ExceptionUtility.ArgumentNull("signature"); } if (hash.Length != 32) { throw ExceptionUtility.ArgumentOutOfRange(Resources.InvalidHashSize); } GetKeyPair(); return(CryptoApiHelper.VerifySign(_providerHandle, _keyHandle, hash, signature)); }
public override SymmetricAlgorithm DecodePrivateKey(byte[] encodedKeyExchangeData, GostKeyExchangeExportMethod keyExchangeExportMethod) { if (encodedKeyExchangeData == null) { throw ExceptionUtility.ArgumentNull("encodedKeyExchangeData"); } int keyExchangeExportAlgId; if (keyExchangeExportMethod == GostKeyExchangeExportMethod.GostKeyExport) { keyExchangeExportAlgId = Constants.CALG_SIMPLE_EXPORT; } else if (keyExchangeExportMethod == GostKeyExchangeExportMethod.CryptoProKeyExport) { keyExchangeExportAlgId = Constants.CALG_PRO_EXPORT; } else { throw ExceptionUtility.ArgumentOutOfRange("keyExchangeExportMethod"); } var providerHandle = CryptoApiHelper.ProviderHandle; var keyExchangeInfo = new GostKeyExchangeInfo(); keyExchangeInfo.Decode(encodedKeyExchangeData); using (var keyHandle = CryptoApiHelper.DuplicateKey(InternalKeyHandle)) { CryptoApiHelper.SetKeyParameterInt32(keyHandle, Constants.KP_ALGID, keyExchangeExportAlgId); var keyExchangeHandle = CryptoApiHelper.ImportKeyExchange(providerHandle, keyExchangeInfo, keyHandle); return(new Gost28147SymmetricAlgorithm(providerHandle, keyExchangeHandle)); } }
public override SymmetricAlgorithm DecodePrivateKey(byte[] encodedKeyExchangeData, GostKeyExchangeExportMethod keyExchangeExportMethod) { if (encodedKeyExchangeData == null) { throw ExceptionUtility.ArgumentNull(nameof(encodedKeyExchangeData)); } int keyExchangeExportAlgId; if (keyExchangeExportMethod == GostKeyExchangeExportMethod.GostKeyExport) { keyExchangeExportAlgId = Constants.CALG_SIMPLE_EXPORT; } else if (keyExchangeExportMethod == GostKeyExchangeExportMethod.CryptoProKeyExport) { keyExchangeExportAlgId = Constants.CALG_PRO_EXPORT; } else { throw ExceptionUtility.ArgumentOutOfRange(nameof(keyExchangeExportMethod)); } var providerHandle = CryptoApiHelper.GetProviderHandle(ProviderType); var keyExchangeInfo = new Gost_28147_89_KeyExchangeInfo(); keyExchangeInfo.Decode(encodedKeyExchangeData); using (var keyHandle = CryptoApiHelper.DuplicateKey(this.GetSafeHandle())) { CryptoApiHelper.SetKeyExchangeExportAlgId(ProviderType, keyHandle, keyExchangeExportAlgId); var keyExchangeHandle = CryptoApiHelper.ImportKeyExchange(providerHandle, keyExchangeInfo, keyHandle); return(new Gost_28147_89_SymmetricAlgorithm(ProviderType, providerHandle, keyExchangeHandle)); } }
public override byte[] EncodePrivateKey(Gost28147 keyExchangeAlgorithm, GostKeyExchangeExportMethod keyExchangeExportMethod) { if (keyExchangeAlgorithm == null) { throw ExceptionUtility.ArgumentNull("keyExchangeAlgorithm"); } int keyExchangeExportAlgId; if (keyExchangeExportMethod == GostKeyExchangeExportMethod.GostKeyExport) { keyExchangeExportAlgId = Constants.CALG_SIMPLE_EXPORT; } else if (keyExchangeExportMethod == GostKeyExchangeExportMethod.CryptoProKeyExport) { keyExchangeExportAlgId = Constants.CALG_PRO_EXPORT; } else { throw ExceptionUtility.ArgumentOutOfRange("keyExchangeExportMethod"); } var currentSessionKey = keyExchangeAlgorithm as Gost28147SymmetricAlgorithm; if (currentSessionKey == null) { using (var derivedSessinKey = new Gost28147SymmetricAlgorithm()) { derivedSessinKey.Key = keyExchangeAlgorithm.Key; return(EncodePrivateKeyInternal(derivedSessinKey, keyExchangeExportAlgId)); } } return(EncodePrivateKeyInternal(currentSessionKey, keyExchangeExportAlgId)); }
/// <inheritdoc /> public override byte[] CreateKeyExchange(byte[] keyExchangeData, Type keyExchangeAlgorithmType) { if (keyExchangeData == null) { throw ExceptionUtility.ArgumentNull(nameof(keyExchangeData)); } if (keyExchangeAlgorithmType == null) { throw ExceptionUtility.ArgumentNull(nameof(keyExchangeAlgorithmType)); } if (!typeof(GostSymmetricAlgorithm).IsAssignableFrom(keyExchangeAlgorithmType)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(keyExchangeAlgorithmType)); } GostSymmetricAlgorithm keyExchangeAlgorithm; if (_publicKey != null) { var constructorInfo = keyExchangeAlgorithmType.GetConstructor(new[] { typeof(ProviderType) }); keyExchangeAlgorithm = (GostSymmetricAlgorithm)constructorInfo.Invoke(new object[] { _publicKey.ProviderType }); } else { keyExchangeAlgorithm = (GostSymmetricAlgorithm)Activator.CreateInstance(keyExchangeAlgorithmType); } using (keyExchangeAlgorithm) { keyExchangeAlgorithm.Key = keyExchangeData; return(CreateKeyExchangeData(keyExchangeAlgorithm)); } }
public static int EncryptData(ProviderType providerType, SafeKeyHandleImpl symKeyHandle, byte[] data, int dataOffset, int dataLength, ref byte[] encryptedData, int encryptedDataOffset, PaddingMode paddingMode, bool isDone, bool isStream) { if (dataOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataOffset)); } if (dataLength < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataLength)); } if (dataOffset > data.Length) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataOffset), Resources.InvalidDataOffset); } var length = dataLength; if (isDone) { length += 8; } // Выровненные данные var dataAlignLength = (uint)dataLength; var dataAlignArray = new byte[length]; Array.Clear(dataAlignArray, 0, length); Array.Copy(data, dataOffset, dataAlignArray, 0, dataLength); if (isDone) { var dataPadding = dataLength & 7; var dataPaddingSize = (byte)(8 - dataPadding); // Добпаление дополнения данных в зависимости от настроек switch (paddingMode) { case PaddingMode.None: if ((dataPadding != 0) && !isStream) { throw ExceptionUtility.CryptographicException(Resources.EncryptInvalidDataSize); } break; case PaddingMode.Zeros: if (dataPadding != 0) { dataAlignLength += dataPaddingSize; // Дополнение заполняется нулевыми байтами } break; case PaddingMode.PKCS7: { dataAlignLength += dataPaddingSize; var paddingIndex = dataLength; // Дополнение заполняется байтами, в каждый из которых записывается размер дополнения while (paddingIndex < dataAlignLength) { dataAlignArray[paddingIndex++] = dataPaddingSize; } } break; case PaddingMode.ANSIX923: { dataAlignLength += dataPaddingSize; // Дополнение заполняется нулевыми, кроме последнего - в него записывается размер дополнения dataAlignArray[(int)((IntPtr)(dataAlignLength - 1))] = dataPaddingSize; } break; case PaddingMode.ISO10126: { dataAlignLength += dataPaddingSize; // Дополнение заполняется случайными байтами, кроме последнего - в него записывается размер дополнения var randomPadding = new byte[dataPaddingSize - 1]; GetRandomNumberGenerator(providerType).GetBytes(randomPadding); randomPadding.CopyTo(dataAlignArray, dataLength); dataAlignArray[(int)((IntPtr)(dataAlignLength - 1))] = dataPaddingSize; } break; default: throw ExceptionUtility.Argument(nameof(paddingMode), Resources.InvalidPaddingMode); } } // Шифрование данных if (!CryptoApi.CryptEncrypt(symKeyHandle, SafeHashHandleImpl.InvalidHandle, false, 0, dataAlignArray, ref dataAlignLength, (uint)length)) { throw CreateWin32Error(); } // Копирование результата шифрования данных if (encryptedData == null) { encryptedData = new byte[dataAlignLength]; Array.Copy(dataAlignArray, 0L, encryptedData, 0L, dataAlignLength); } else { if (encryptedDataOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(encryptedDataOffset)); } if ((encryptedData.Length < dataAlignLength) || ((encryptedData.Length - dataAlignLength) < encryptedDataOffset)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(encryptedDataOffset), Resources.InvalidDataOffset); } Array.Copy(dataAlignArray, 0L, encryptedData, encryptedDataOffset, dataAlignLength); } return((int)dataAlignLength); }
public static int DecryptData(SafeKeyHandleImpl symKeyHandle, byte[] data, int dataOffset, int dataLength, ref byte[] decryptedData, int decryptedDataOffset, PaddingMode paddingMode, bool isDone) { if (dataOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataOffset)); } if (dataLength < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataLength)); } if ((dataOffset > data.Length) || ((dataOffset + dataLength) > data.Length)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(dataOffset), Resources.InvalidDataOffset); } // Выровненные данные var dataAlignLength = (uint)dataLength; var dataAlign = new byte[dataAlignLength]; Array.Copy(data, dataOffset, dataAlign, 0L, dataAlignLength); // Расшифровка данных if (!CryptoApi.CryptDecrypt(symKeyHandle, SafeHashHandleImpl.InvalidHandle, false, 0, dataAlign, ref dataAlignLength)) { throw CreateWin32Error(); } var length = (int)dataAlignLength; if (isDone) { byte dataPaddingSize = 0; // Удаление дополнения данных в зависимости от настроек if (((paddingMode == PaddingMode.PKCS7) || (paddingMode == PaddingMode.ANSIX923)) || (paddingMode == PaddingMode.ISO10126)) { if (dataAlignLength < 8) { throw ExceptionUtility.CryptographicException(Constants.NTE_BAD_DATA); } // Размер дополнения находится в последнем байте dataPaddingSize = dataAlign[(int)((IntPtr)(dataAlignLength - 1))]; if (dataPaddingSize > 8) { throw ExceptionUtility.CryptographicException(Constants.NTE_BAD_DATA); } // Проверка корректности дополнения данных if (paddingMode == PaddingMode.PKCS7) { for (var paddingIndex = dataAlignLength - dataPaddingSize; paddingIndex < (dataAlignLength - 1); paddingIndex++) { if (dataAlign[paddingIndex] != dataPaddingSize) { throw ExceptionUtility.CryptographicException(Constants.NTE_BAD_DATA); } } } else if (paddingMode == PaddingMode.ANSIX923) { for (var paddingIndex = dataAlignLength - dataPaddingSize; paddingIndex < (dataAlignLength - 1); paddingIndex++) { if (dataAlign[paddingIndex] != 0) { throw ExceptionUtility.CryptographicException(Constants.NTE_BAD_DATA); } } } } else if ((paddingMode != PaddingMode.None) && (paddingMode != PaddingMode.Zeros)) { throw ExceptionUtility.Argument(nameof(paddingMode), Resources.InvalidPaddingMode); } length -= dataPaddingSize; } if (decryptedData == null) { decryptedData = new byte[length]; Array.Copy(dataAlign, 0, decryptedData, 0, length); } else { if (decryptedDataOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(decryptedDataOffset)); } if ((decryptedData.Length < length) || ((decryptedData.Length - length) < decryptedDataOffset)) { throw ExceptionUtility.ArgumentOutOfRange(nameof(decryptedData), Resources.InvalidDataOffset); } Array.Copy(dataAlign, 0, decryptedData, decryptedDataOffset, length); } return(length); }
public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) { if (inputBuffer == null) { throw ExceptionUtility.ArgumentNull(nameof(inputBuffer)); } if (outputBuffer == null) { throw ExceptionUtility.ArgumentNull(nameof(outputBuffer)); } if (inputOffset < 0) { throw ExceptionUtility.ArgumentOutOfRange(nameof(inputOffset)); } if ((inputCount <= 0) || ((inputCount % InputBlockSize) != 0) || (inputCount > inputBuffer.Length)) { throw ExceptionUtility.Argument(nameof(inputOffset), Resources.InvalidDataOffset); } if ((inputBuffer.Length - inputCount) < inputOffset) { throw ExceptionUtility.Argument(nameof(inputOffset), Resources.InvalidDataOffset); } if (_transformMode == Gost_28147_89_CryptoTransformMode.Encrypt) { return(CryptoApiHelper.EncryptData(_providerType, _keyHandle, inputBuffer, inputOffset, inputCount, ref outputBuffer, outputOffset, _paddingValue, false, _isStreamModeValue)); } if ((_paddingValue == PaddingMode.Zeros) || (_paddingValue == PaddingMode.None)) { return(CryptoApiHelper.DecryptData(_keyHandle, inputBuffer, inputOffset, inputCount, ref outputBuffer, outputOffset, _paddingValue, false)); } int dectyptDataLength; if (_dataBuffer == null) { _dataBuffer = new byte[InputBlockSize]; var length = inputCount - InputBlockSize; Array.Copy(inputBuffer, inputOffset + length, _dataBuffer, 0, InputBlockSize); dectyptDataLength = CryptoApiHelper.DecryptData(_keyHandle, inputBuffer, inputOffset, length, ref outputBuffer, outputOffset, _paddingValue, false); } else { CryptoApiHelper.DecryptData(_keyHandle, _dataBuffer, 0, _dataBuffer.Length, ref outputBuffer, outputOffset, _paddingValue, false); outputOffset += OutputBlockSize; var length = inputCount - InputBlockSize; Array.Copy(inputBuffer, inputOffset + length, _dataBuffer, 0, InputBlockSize); dectyptDataLength = OutputBlockSize + CryptoApiHelper.DecryptData(_keyHandle, inputBuffer, inputOffset, length, ref outputBuffer, outputOffset, _paddingValue, false); } return(dectyptDataLength); }