public override void GenerateKey()
{
_provHandle = CryptoApiHelper.ProviderHandle.DangerousAddRef();
_keyHandle = CryptoApiHelper.GenerateKey(_provHandle, Constants.CALG_G28147, CspProviderFlags.NoFlags);
KeyValue = null;
KeySizeValue = DefaultKeySize;
}
internal Gost28147SymmetricAlgorithm(SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle) : this()
{
_provHandle = provHandle.DangerousAddRef();
_keyHandle = CryptoApiHelper.DuplicateKey(keyHandle);
if (CryptoApiHelper.GetKeyParameterInt32(_keyHandle, Constants.KP_ALGID) != Constants.CALG_G28147)
{
throw ExceptionUtility.Argument("keyHandle", Resources.RequiredGost28147);
}
}
private void GetKeyPairValue(CspParameters providerParams, bool randomKeyContainer, out SafeProvHandleImpl providerHandle, out SafeKeyHandleImpl keyHandle)
{
SafeProvHandleImpl resultProviderHandle = null;
SafeKeyHandleImpl resultKeyHandle = null;
try
{
resultProviderHandle = CreateProviderHandle(providerParams, randomKeyContainer);
if (providerParams.ParentWindowHandle != IntPtr.Zero)
{
CryptoApiHelper.SetProviderParameter(resultProviderHandle, providerParams.KeyNumber, Constants.PP_CLIENT_HWND, providerParams.ParentWindowHandle);
}
else if (providerParams.KeyPassword != null)
{
SetSignatureKeyPassword(resultProviderHandle, providerParams.KeyPassword, providerParams.KeyNumber);
}
try
{
resultKeyHandle = CryptoApiHelper.GetUserKey(resultProviderHandle, providerParams.KeyNumber);
}
catch (Exception exception)
{
var errorCode = Marshal.GetHRForException(exception);
if (errorCode != 0)
{
if (((providerParams.Flags & CspProviderFlags.UseExistingKey) != CspProviderFlags.NoFlags) || (errorCode != Constants.NTE_NO_KEY))
{
throw;
}
resultKeyHandle = CryptoApiHelper.GenerateKey(resultProviderHandle, providerParams.KeyNumber, providerParams.Flags);
}
}
var keyAlgIdInverted = CryptoApiHelper.GetKeyParameter(resultKeyHandle, Constants.KP_ALGID);
var keyAlgId = keyAlgIdInverted[0] | (keyAlgIdInverted[1] << 8) | (keyAlgIdInverted[2] << 16) | (keyAlgIdInverted[3] << 24);
if ((keyAlgId != ExchangeAlgId) && (keyAlgId != SignatureAlgId))
{
throw ExceptionUtility.NotSupported(Resources.KeyAlgorithmNotSupported);
}
}
catch (Exception)
{
resultProviderHandle?.Close();
resultKeyHandle?.Close();
throw;
}
providerHandle = resultProviderHandle;
keyHandle = resultKeyHandle;
}
SafeKeyHandleImpl PrivateKey()
{
SafeKeyHandleImpl keyHandle = SafeKeyHandleImpl.InvalidHandle;
if (!CryptoApi.CryptGetUserKey(_providerHandle, (uint)_providerParameters.KeyNumber, ref keyHandle))
{
throw ExceptionUtility.CryptographicException(Marshal.GetLastWin32Error());
}
return(keyHandle);
}
protected void UsingKey(Action <SafeKeyHandleImpl> operation)
{
if (_keyHandleFunc == null)
{
throw new NullReferenceException("Cannot access key: handle function not found");
}
SafeKeyHandleImpl keyHandle = _keyHandleFunc();
operation(keyHandle);
keyHandle.TryDispose();
}
public void DeriveFromPassword(byte[] password)
{
var provider = CreateFromPassword(password);
_keyHandle.TryDispose();
_provHandle.TryDispose();
_keyHandle = provider._keyHandle;
_provHandle = provider._provHandle;
provider._keyHandle = SafeKeyHandleImpl.InvalidHandle;
provider._provHandle = SafeProvHandleImpl.InvalidHandle;
}
public override void ImportParameters(Asn1.Common.GostKeyExchangeParameters keyParameters)
{
if (keyParameters.PrivateKey != null)
{
throw ExceptionUtility.NotSupported(Resources.UserImportBulkKeyNotSupported);
}
_keyHandle.TryDispose();
_providerHandle = CryptoApiHelper.ProviderHandle;
_keyHandle = CryptoApiHelper.ImportPublicKey(_providerHandle, new Asn1.Common.GostKeyExchangeParameters(keyParameters));
_isPublicKeyOnly = true;
}
private ICryptoTransform CreateCryptoTransform(SafeKeyHandleImpl hKey, byte[] iv, Gost28147CryptoTransformMode transformMode)
{
if (hKey == null)
{
hKey = CryptoApiHelper.GenerateKey(CryptoApiHelper.ProviderHandle, Constants.CALG_G28147, CspProviderFlags.NoFlags);
}
var keyParameters = new Dictionary <int, object>();
if (ModeValue == CipherMode.CTS)
{
throw ExceptionUtility.CryptographicException(Resources.CipherTextSteamingNotSupported);
}
if ((Padding != PaddingMode.None) && ((ModeValue == CipherMode.OFB) || (ModeValue == CipherMode.CFB)))
{
throw ExceptionUtility.CryptographicException(Resources.InvalidPaddingMode);
}
// Установка KP_PADDING
keyParameters.Add(Constants.KP_PADDING, Constants.ZERO_PADDING);
if ((ModeValue == CipherMode.CFB) && (FeedbackSizeValue != DefaultFeedbackSize))
{
throw ExceptionUtility.CryptographicException(Resources.IncorrectFeedbackSize);
}
// Установка KP_MODE
keyParameters.Add(Constants.KP_MODE, ModeValue);
// Установка KP_IV
if (ModeValue != CipherMode.ECB)
{
if (iv == null)
{
iv = new byte[DefaultIvSize];
CryptoApiHelper.RandomNumberGenerator.GetBytes(iv);
}
if (iv.Length < DefaultIvSize)
{
throw ExceptionUtility.CryptographicException(Resources.InvalidIvSize);
}
keyParameters.Add(Constants.KP_IV, iv);
}
return(new Gost28147CryptoTransform(hKey, keyParameters, PaddingValue, ModeValue, BlockSizeValue, transformMode));
}
private void GetKeyPair()
{
if (_keyHandle == null)
{
lock (this)
{
if (_keyHandle == null)
{
GetKeyPairValue(_providerParameters, _isRandomKeyContainer, out var providerHandle, out var keyHandle);
_providerHandle = providerHandle;
_keyHandle = keyHandle;
_isPersistentKey = true;
}
}
}
}
public override void ImportParameters(TKeyParams keyParameters)
{
if (keyParameters.PrivateKey != null)
{
throw ExceptionUtility.NotSupported(Resources.UserImportBulkKeyNotSupported);
}
_keyHandle.TryDispose();
var hProv = CryptoApiHelper.GetProviderHandle(ProviderType);
var importedKeyBytes = CryptoApiHelper.EncodePublicBlob(keyParameters.Clone(), KeySizeValue, SignatureAlgId);
_providerParameters.KeyNumber = CryptoApiHelper.ImportCspBlob(importedKeyBytes, hProv, SafeKeyHandleImpl.InvalidHandle, out var keyHandle);
_providerHandle = hProv;
_keyHandle = keyHandle;
_isPublicKeyOnly = true;
}
public void ImportCspBlob(byte[] importedKeyBytes)
{
if (importedKeyBytes == null)
{
throw ExceptionUtility.ArgumentNull(nameof(importedKeyBytes));
}
if (!IsPublicKeyBlob(importedKeyBytes))
{
throw ExceptionUtility.Argument(nameof(importedKeyBytes), Resources.UserImportBulkBlob);
}
var hProv = CryptoApiHelper.GetProviderHandle(ProviderType);
_providerParameters.KeyNumber = CryptoApiHelper.ImportCspBlob(importedKeyBytes, hProv, SafeKeyHandleImpl.InvalidHandle, out var hKey);
_providerHandle = hProv;
_keyHandle = hKey;
_isPublicKeyOnly = true;
}
private void GetKeyPair()
{
if (_keyHandle == null)
{
lock (this)
{
if (_keyHandle == null)
{
SafeProvHandleImpl providerHandle;
SafeKeyHandleImpl keyHandle;
GetKeyPairValue(_providerParameters, _isRandomKeyContainer, out providerHandle, out keyHandle);
_providerHandle = providerHandle;
_keyHandle = keyHandle;
_isPersistentKey = true;
}
}
}
}
public GostKeyExchangeAlgorithm(SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle, Asn1.Common.GostKeyExchangeParameters keyExchangeParameters)
{
if (provHandle == null)
{
throw ExceptionUtility.ArgumentNull("provHandle");
}
if (keyHandle == null)
{
throw ExceptionUtility.ArgumentNull("keyHandle");
}
if (keyExchangeParameters == null)
{
throw ExceptionUtility.ArgumentNull("keyExchangeParameters");
}
_provHandle = provHandle.DangerousAddRef();
_keyHandle = keyHandle.DangerousAddRef();
_keyExchangeParameters = keyExchangeParameters;
}
private byte[] EncodeKeyExchangeInternal(Gost28147SymmetricAlgorithm keyExchangeAlgorithm, int keyExchangeExportAlgId)
{
GostKeyExchangeInfo keyExchangeInfo;
SafeKeyHandleImpl keyExchangeHandle = null;
try
{
keyExchangeHandle = CryptoApiHelper.ImportAndMakeKeyExchange(_provHandle, _keyExchangeParameters, _keyHandle);
CryptoApiHelper.SetKeyParameterInt32(keyExchangeHandle, Constants.KP_ALGID, keyExchangeExportAlgId);
var symKeyHandle = keyExchangeAlgorithm.InternalKeyHandle;
keyExchangeInfo = CryptoApiHelper.ExportKeyExchange(symKeyHandle, keyExchangeHandle);
}
finally
{
keyExchangeHandle.TryDispose();
}
return(keyExchangeInfo.Encode());
}
private byte[] EncodeKeyExchangeInternal(Gost_28147_89_SymmetricAlgorithm keyExchangeAlgorithm, int keyExchangeExportAlgId)
{
Gost_28147_89_KeyExchangeInfo keyExchangeInfo;
SafeKeyHandleImpl keyExchangeHandle = null;
try
{
var importedKeyBytes = CryptoApiHelper.EncodePublicBlob(_keyExchangeParameters, _keySize, _signatureAlgId);
CryptoApiHelper.ImportCspBlob(importedKeyBytes, _provHandle, _keyHandle, out keyExchangeHandle);
CryptoApiHelper.SetKeyExchangeExportAlgId(ProviderType, keyExchangeHandle, keyExchangeExportAlgId);
var symKeyHandle = keyExchangeAlgorithm.GetSafeHandle();
keyExchangeInfo = CryptoApiHelper.ExportKeyExchange(symKeyHandle, keyExchangeHandle);
}
finally
{
keyExchangeHandle.TryDispose();
}
return(keyExchangeInfo.Encode());
}
public GostSharedSecretAlgorithm(SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle, GostKeyExchangeParameters keyExchangeParameters, GostAlgorithmType algType)
{
if (provHandle == null)
{
throw ExceptionUtility.ArgumentNull("provHandle");
}
if (keyHandle == null)
{
throw ExceptionUtility.ArgumentNull("keyHandle");
}
if (keyExchangeParameters == null)
{
throw ExceptionUtility.ArgumentNull("keyExchangeParameters");
}
_provHandle = provHandle.DangerousAddRef();
_keyHandle = keyHandle.DangerousAddRef();
_keyExchangeParameters = keyExchangeParameters;
_algType = algType;
}
private SymmetricAlgorithm DecodeKeyExchangeInternal(byte[] encodedKeyExchangeData, int keyExchangeExportAlgId)
{
var keyExchangeInfo = new GostKeyExchangeInfo();
keyExchangeInfo.Decode(encodedKeyExchangeData);
SafeKeyHandleImpl symKeyHandle;
SafeKeyHandleImpl keyExchangeHandle = null;
try
{
keyExchangeHandle = CryptoApiHelper.ImportAndMakeKeyExchange(_provHandle, _keyExchangeParameters, _keyHandle);
CryptoApiHelper.SetKeyParameterInt32(keyExchangeHandle, Constants.KP_ALGID, keyExchangeExportAlgId);
symKeyHandle = CryptoApiHelper.ImportKeyExchange(_provHandle, keyExchangeInfo, keyExchangeHandle);
}
finally
{
keyExchangeHandle.TryDispose();
}
return(new Gost28147SymmetricAlgorithm(_provHandle, symKeyHandle));
}
private SymmetricAlgorithm DecodeKeyExchangeInternal(byte[] encodedKeyExchangeData, int keyExchangeExportAlgId)
{
var keyExchangeInfo = new Gost_28147_89_KeyExchangeInfo();
keyExchangeInfo.Decode(encodedKeyExchangeData);
SafeKeyHandleImpl symKeyHandle;
SafeKeyHandleImpl keyExchangeHandle = null;
try
{
var importedKeyBytes = CryptoApiHelper.EncodePublicBlob(_keyExchangeParameters, _keySize, _signatureAlgId);
CryptoApiHelper.ImportCspBlob(importedKeyBytes, _provHandle, _keyHandle, out keyExchangeHandle);
CryptoApiHelper.SetKeyExchangeExportAlgId(ProviderType, keyExchangeHandle, keyExchangeExportAlgId);
symKeyHandle = CryptoApiHelper.ImportKeyExchange(_provHandle, keyExchangeInfo, keyExchangeHandle);
}
finally
{
keyExchangeHandle.TryDispose();
}
return(new Gost_28147_89_SymmetricAlgorithm(ProviderType, _provHandle, symKeyHandle));
}
public Gost_R3410_2001_KeyExchangeAlgorithm(ProviderType providerType, SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle, Gost_R3410_2001_KeyExchangeParams keyExchangeParameters, int keySize, int signatureAlgId)
: base(providerType, provHandle, keyHandle, keyExchangeParameters, keySize, signatureAlgId)
{
}
protected Gost_R3410_KeyExchangeAlgorithm(ProviderType providerType, SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle, Gost_R3410_KeyExchangeParams keyExchangeParameters, int keySize, int signatureAlgId) : base(providerType)
{
if (provHandle == null)
{
throw ExceptionUtility.ArgumentNull(nameof(provHandle));
}
if (keyHandle == null)
{
throw ExceptionUtility.ArgumentNull(nameof(keyHandle));
}
if (keyExchangeParameters == null)
{
throw ExceptionUtility.ArgumentNull(nameof(keyExchangeParameters));
}
_provHandle = provHandle.DangerousAddRef();
_keyHandle = keyHandle.DangerousAddRef();
_keyExchangeParameters = keyExchangeParameters;
_keySize = keySize;
_signatureAlgId = signatureAlgId;
}
protected override SafeHashHandleImpl CreateHashHMAC(ProviderType providerType, SafeProvHandleImpl providerHandle, SafeKeyHandleImpl symKeyHandle)
{
return(CryptoApiHelper.CreateHashHMAC_2012_256(providerType, providerHandle, symKeyHandle));
}
protected override Gost_R3410_2012_256_KeyExchangeAlgorithm CreateKeyExchangeAlgorithm(ProviderType providerType, SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle, Gost_R3410_2012_256_KeyExchangeParams keyExchangeParameters)
{
return(new Gost_R3410_2012_256_KeyExchangeAlgorithm(providerType, provHandle, keyHandle, keyExchangeParameters, KeySizeValue, SignatureAlgId));
}
protected abstract SafeHashHandleImpl CreateHashHMAC(ProviderType providerType, SafeProvHandleImpl providerHandle, SafeKeyHandleImpl symKeyHandle);
protected abstract TKeyAlgorithm CreateKeyExchangeAlgorithm(ProviderType providerType, SafeProvHandleImpl provHandle, SafeKeyHandleImpl keyHandle, TKeyParams keyExchangeParameters);
public Gost_28147_89_CryptoTransform(
ProviderType providerType,
SafeKeyHandleImpl keyHandle,
Dictionary <int, object> keyParameters,
PaddingMode paddingValue,
CipherMode modeValue,
int blockSizeValue,
Gost_28147_89_CryptoTransformMode transformMode)
{
_providerType = providerType;
_keyHandle = keyHandle;
_paddingValue = paddingValue;
_isStreamModeValue = (modeValue == CipherMode.OFB) || (modeValue == CipherMode.CFB);
_blockSizeValue = blockSizeValue;
_transformMode = transformMode;
// Установка параметров ключа
foreach (var keyParameter in keyParameters)
{
var keyParameterId = keyParameter.Key;
var keyParameterValue = keyParameter.Value;
// Копирование значения параметра
if (keyParameterValue is byte[])
{
var keyParamValueBytes = (byte[])keyParameterValue;
var copyKeyParamValueBytes = new byte[keyParamValueBytes.Length];
Array.Copy(keyParamValueBytes, copyKeyParamValueBytes, keyParamValueBytes.Length);
keyParameterValue = copyKeyParamValueBytes;
}
else if (keyParameterValue is int)
{
keyParameterValue = (int)keyParameterValue;
}
else if (keyParameterValue is CipherMode)
{
keyParameterValue = Convert.ToInt32(keyParameterValue);
}
else if (keyParameterValue is PaddingMode)
{
keyParameterValue = Convert.ToInt32(keyParameterValue);
}
// Установка значения параметра
switch (keyParameterId)
{
case Constants.KP_IV:
{
_ivValue = (byte[])keyParameterValue;
var iv = _ivValue;
CryptoApiHelper.SetKeyParameter(_keyHandle, keyParameterId, iv);
}
break;
case Constants.KP_MODE:
{
CryptoApiHelper.SetKeyParameterInt32(_keyHandle, keyParameterId, (int)keyParameterValue);
}
break;
case Constants.KP_PADDING:
{
if (!providerType.IsVipNet())
{
CryptoApiHelper.SetKeyParameterInt32(_keyHandle, keyParameterId, (int)keyParameterValue);
}
}
break;
}
}
}
