public override SymmetricAlgorithm Unwrap(byte[] wrapped,
GostKeyWrapMethod method)
{
GostWrappedKeyObject gwk = new GostWrappedKeyObject();
gwk.SetByXmlWrappedKey(wrapped);
if (method == GostKeyWrapMethod.CryptoProKeyWrap)
{
return(CryptoProUnwrap(wrapped, GostConstants.CALG_PRO_EXPORT));
}
else if (method == GostKeyWrapMethod.CryptoPro12KeyWrap)
{
// В случае с гостом 2012 мы не уверны, был ли экспорт на ProExport или ProExport12
// из-за обратной совместимости (раньше шифровали на ProExport, теперь только на ProExport12). Попробуем оба варианата
return(CryptoProUnwrap(wrapped));
}
else if (method == GostKeyWrapMethod.GostKeyWrap)
{
return(GostUnwrap(wrapped));
}
else
{
throw new ArgumentOutOfRangeException("method");
}
}
/// <summary>
/// Восстановления по данным обмена симметричного ключа
/// на основе <a href="http://www.ietf.org/rfc/rfc4490">ГОСТ Р 34.10
/// транспорта</a>.
/// </summary>
///
/// <param name="transport"> Зашифрованные данные обмена
/// ключами.</param>
/// <param name="keyWrapMethod">Алгоритм симметричного экспорта</param>
///
/// <returns>Симметричный ключ.</returns>
///
/// <argnull name="transport" />
public SymmetricAlgorithm DecryptKeyExchange(
GostKeyTransport transport,
GostKeyWrapMethod keyWrapMethod = GostKeyWrapMethod.CryptoPro12KeyWrap)
{
GostSharedSecretAlgorithm agree;
switch (_gostAlgorithmType)
{
case CspAlgorithmType.Gost2001:
{
agree = ((Gost3410)_gostKey).CreateAgree(transport.TransportParameters);
break;
}
case CspAlgorithmType.Gost2012_256:
{
agree = ((Gost3410_2012_256)_gostKey).CreateAgree(transport.TransportParameters);
break;
}
case CspAlgorithmType.Gost2012_512:
{
agree = ((Gost3410_2012_512)_gostKey).CreateAgree(transport.TransportParameters);
break;
}
default:
{
throw new NotSupportedException();
}
}
return(agree.Unwrap(transport.SessionEncryptedKey.GetXmlWrappedKey(),
keyWrapMethod));
}
/// <summary>
/// Вспомогательный метод, работающий для всех GOST3410
/// </summary>
/// <param name="createAgree"></param>
/// <param name="exportParameters"></param>
/// <param name="senderParameters"></param>
/// <param name="alg"></param>
/// <param name="keyWrapMethod"></param>
/// <returns></returns>
private GostKeyTransport GetGostTransport(
Func <Gost3410Parameters, GostSharedSecretAlgorithm> createAgree,
Func <bool, Gost3410Parameters> exportParameters,
Gost3410Parameters senderParameters,
SymmetricAlgorithm alg,
GostKeyWrapMethod keyWrapMethod)
{
GostKeyTransportObject transport = new GostKeyTransportObject();
byte[] wrapped_data;
using (GostSharedSecretAlgorithm agree = createAgree(
senderParameters))
{
// Зашифровываем симметричный ключ.
wrapped_data = agree.Wrap(alg,
keyWrapMethod);
}
GostWrappedKeyObject wrapped = new GostWrappedKeyObject();
wrapped.SetByXmlWrappedKey(wrapped_data);
transport.sessionEncryptedKey_ = wrapped;
transport.transportParameters_ = new Gost3410CspObject();
transport.transportParameters_.Parameters = exportParameters(false);
return(transport.Transport);
}
/// <summary>
/// Импортирует (дешифрует) секретный ключ.
/// </summary>
/// <param name="wrapped">Зашифрованный секретный ключ.</param>
/// <param name="method">Алгоритм экспорта ключа.</param>
public override SymmetricAlgorithm Unwrap(byte[] wrapped, GostKeyWrapMethod method)
{
GostWrappedKeyObject gwk = new GostWrappedKeyObject();
gwk.SetByXmlWrappedKey(wrapped);
int calg = GostConstants.CALG_SIMPLE_EXPORT;
if (method == GostKeyWrapMethod.CryptoProKeyWrap)
{
calg = GostConstants.CALG_PRO_EXPORT;
}
else if (method == GostKeyWrapMethod.CryptoPro12KeyWrap)
{
calg = GostConstants.CALG_PRO12_EXPORT;
}
else if (method != GostKeyWrapMethod.GostKeyWrap)
{
throw new ArgumentOutOfRangeException("method");
}
SymmetricAlgorithm ret = null;
// Сохраняем состояние algid GOST12147
using (SafeKeyHandle hExpKey = CapiHelper.DuplicateKey(SafeKeyHandle.DangerousGetHandle()))
{
CapiHelper.SetKeyParamDw(hExpKey, GostConstants.KP_ALGID, calg);
SafeKeyHandle simmKey = SafeKeyHandle.InvalidHandle;
CapiHelper.AcquireCsp(_parameters, out SafeProvHandle hProv);
CapiHelper.ImportSessionWrappedKey(
hProv, CspProviderFlags.NoFlags,
gwk, hExpKey, ref simmKey);
ret = new Gost28147CryptoServiceProvider(simmKey, hProv);
}
return(ret);
}
/// <summary>
/// Экспортирует (шифрует) секретный ключ.
/// </summary>
/// <param name="prov">Шифруемый ключ.</param>
/// <param name="method">Алгоритм экспорта ключа.</param>
/// <returns>Зашифрованный симметричный ключ</returns>
public override byte[] Wrap(Gost28147 prov, GostKeyWrapMethod method)
{
SafeKeyHandle hSimmKey = ((Gost28147CryptoServiceProvider)prov).SafeKeyHandle;
int calg = GostConstants.CALG_SIMPLE_EXPORT;
if (method == GostKeyWrapMethod.CryptoProKeyWrap)
{
calg = GostConstants.CALG_PRO_EXPORT;
}
else if (method == GostKeyWrapMethod.CryptoPro12KeyWrap)
{
calg = GostConstants.CALG_PRO12_EXPORT;
}
else if (method != GostKeyWrapMethod.GostKeyWrap)
{
throw new ArgumentOutOfRangeException("method");
}
byte[] ret = null;
// Сохраняем состояние algid GOST12147
using (SafeKeyHandle hExpKey = CapiHelper.DuplicateKey(
SafeKeyHandle.DangerousGetHandle(),
SafeProvHandle))
{
CapiHelper.SetKeyParameter(hExpKey, GostConstants.KP_ALGID, calg);
CapiHelper.SetKeyParameter(hExpKey, GostConstants.KP_IV, IV);
GostWrappedKeyObject wrappedKey = new GostWrappedKeyObject();
CapiHelper.ExportSessionWrapedKey(hSimmKey,
hExpKey, wrappedKey);
ret = wrappedKey.GetXmlWrappedKey();
}
return(ret);
}
/// <summary>
/// Экспортирует (шифрует) секретный ключ.
/// </summary>
/// <param name="prov">Шифруемый ключ.</param>
/// <param name="method">Алгоритм экспорта ключа.</param>
/// <returns>Зашифрованный симметричный ключ</returns>
public override byte[] Wrap(Gost28147 prov, GostKeyWrapMethod method)
{
throw new NotImplementedException();
//SafeKeyHandle hSimmKey = ((Gost28147CryptoServiceProvider)prov).SafeKeyHandle;
//int calg = GostConstants.CALG_SIMPLE_EXPORT;
//if (method == GostKeyWrapMethod.CryptoProKeyWrap)
// calg = GostConstants.CALG_PRO_EXPORT;
//else if (method == GostKeyWrapMethod.CryptoPro12KeyWrap)
// calg = GostConstants.CALG_PRO12_EXPORT;
//else if (method != GostKeyWrapMethod.GostKeyWrap)
// throw new ArgumentOutOfRangeException("method");
//byte[] ret = null;
//// Сохраняем состояние algid GOST12147
//using (SafeKeyHandle hExpKey = CapiHelper.DuplicateKey(SafeKeyHandle.DangerousGetHandle())
//{
// CapiHelper.SetKeyParameter(hExpKey, GostConstants.KP_ALGID, calg);
// CapiHelper.SetKeyParameter(hExpKey, GostConstants.KP_IV, IV);
// GostWrappedKeyObject wrappedKey = new GostWrappedKeyObject();
// CapiHelper.ExportSessionWrapedKey(hSimmKey,
// hExpKey, wrappedKey);
// ret = wrappedKey.GetXmlWrappedKey();
//}
//return ret;
}
private void TestKeyWrap(GostKeyWrapMethod keyWrapMethod)
{
using (Gost28147 gost = new Gost28147CryptoServiceProvider())
{
using (Gost28147 keyToWrap = new Gost28147CryptoServiceProvider())
{
var data = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 };
var encryptedData = GostEncrypt(keyToWrap, data);
var wrappedKey = gost.Wrap(keyToWrap, keyWrapMethod);
var unwrappedKey = gost.Unwrap(wrappedKey, keyWrapMethod) as Gost28147;
var iv = keyToWrap.IV;
var decryptedData = GostDecrypt(unwrappedKey, encryptedData, iv);
Assert.Equal(data, decryptedData);
}
}
}
/// <summary>
/// Формирование данных обмена, на основе симметричного
/// ключа шифрования сообщения ГОСТ 28147.
/// </summary>
///
/// <param name="alg">Симметричный ключ ГОСТ 28147.</param>
/// <param name="wrapMethod">Алгоритм экпорта</param>
/// <returns>Зашифрованные данные для отправки стороне
/// получателю.</returns>
///
/// <argnull name="alg" />
public GostKeyTransport CreateKeyExchange(SymmetricAlgorithm alg, GostKeyWrapMethod wrapMethod)
{
if (alg == null)
{
throw new ArgumentNullException("alg");
}
if (wrapMethod != GostKeyWrapMethod.CryptoProKeyWrap && wrapMethod != GostKeyWrapMethod.CryptoPro12KeyWrap)
{
throw new CryptographicException(
string.Format(Properties.Resources.Cryptography_UnsupportedWrapMethod, wrapMethod));
}
// Получаем параметры получателя.
Gost3410Parameters senderParameters = gostKey_.ExportParameters(
false);
GostKeyTransportObject transport = new GostKeyTransportObject();
// Создаем эфимерный ключ с параметрами получателя.
using (Gost3410_2012_512EphemeralCryptoServiceProvider sender = new Gost3410_2012_512EphemeralCryptoServiceProvider(
senderParameters))
{
// Создаем распределенный секрет.
byte[] wrapped_data;
using (GostSharedSecretAlgorithm agree = sender.CreateAgree(
senderParameters))
{
// Зашифровываем симметричный ключ.
wrapped_data = agree.Wrap(alg,
wrapMethod);
}
GostWrappedKeyObject wrapped = new GostWrappedKeyObject();
wrapped.SetByXmlWrappedKey(wrapped_data);
transport.sessionEncryptedKey_ = wrapped;
transport.transportParameters_ = new Gost3410CspObject();
transport.transportParameters_.Parameters = sender.ExportParameters(false);
}
return(transport.Transport);
}
/// <summary>
/// Wrap ключа Gost28147CryptoServiceProvider на agree.
/// </summary>
///
/// <param name="prov">Шифруемый ключ</param>
/// <param name="method">Метод зашифрования ключа.</param>
///
/// <returns>Зашифрованный симметричный ключ</returns>
private byte[] Wrap(Gost28147CryptoServiceProvider prov,
GostKeyWrapMethod method)
{
if (method == GostKeyWrapMethod.CryptoProKeyWrap)
{
return(CryptoProWrap(prov));
}
else if (method == GostKeyWrapMethod.CryptoPro12KeyWrap)
{
return(CryptoProWrap(prov, GostConstants.CALG_PRO12_EXPORT));
}
else if (method == GostKeyWrapMethod.GostKeyWrap)
{
return(GostWrap(prov));
}
else
{
throw new ArgumentOutOfRangeException("method");
}
}
/// <summary>
/// Зашифрование (экспорт) симметричного ключа.
/// </summary>
///
/// <remarks><para>Формат зашифрованного ключа зависит от метода
/// зашифрования; для <see cref="GostKeyWrapMethod.GostKeyWrap"/> и
/// <see cref="GostKeyWrapMethod.CryptoProKeyWrap"/>
/// формат зашифрованного ключа определяется функцией
/// <see cref="GostWrappedKey.GetXmlWrappedKey"/>.</para>
///
/// <para>При зашифровании ключа используется синхропосылка
/// заданная <see cref="SymmetricAlgorithm.IV"/></para>
/// </remarks>
///
/// <param name="alg">Объект класса <see cref="SymmetricAlgorithm"/>,
/// содержащий симметричный ключ.</param>
/// <param name="method">Алгоритм экспорта ключа.</param>
///
/// <returns>Зашифрованный симметричный ключ.</returns>
///
/// <seealso cref="GostWrappedKey"/>
/// <seealso cref="GostSharedSecretCryptoServiceProvider.Unwrap"/>
public override byte[] Wrap(SymmetricAlgorithm alg,
GostKeyWrapMethod method)
{
Gost28147 gost = alg as Gost28147;
if (gost == null)
{
throw new ArgumentException(nameof(alg));
}
Gost28147CryptoServiceProvider prov = gost as
Gost28147CryptoServiceProvider;
if (prov == null)
{
using (Gost28147CryptoServiceProvider p =
new Gost28147CryptoServiceProvider())
{
return(p.Wrap(prov, method));
}
}
return(Wrap(prov, method));
}
public override byte[] Wrap(Gost28147 keyExchangeAlgorithm, GostKeyWrapMethod method)
{
throw null;
}
/// <summary> /// Экспортирует (шифрует) секретный ключ. /// </summary> /// <param name="prov">Шифруемый ключ.</param> /// <param name="method">Алгоритм экспорта ключа.</param> /// <returns>Зашифрованный симметричный ключ</returns> public abstract byte[] Wrap(Gost28147 prov, GostKeyWrapMethod method);
public override SymmetricAlgorithm Unwrap(byte[] wrapped, GostKeyWrapMethod method)
{
throw null;
}
/// <summary>
/// Формирование данных обмена, на основе симметричного
/// ключа шифрования сообщения ГОСТ 28147.
/// </summary>
///
/// <param name="alg">Симметричный ключ ГОСТ 28147.</param>
/// <param name="wrapMethod">Алгоритм экпорта</param>
/// <returns>Зашифрованные данные для отправки стороне
/// получателю.</returns>
///
/// <argnull name="alg" />
public byte[] CreateKeyExchangeData(SymmetricAlgorithm alg, GostKeyWrapMethod wrapMethod)
{
GostKeyTransport transport = CreateKeyExchange(alg, wrapMethod);
return(transport.Encode());
}
/// <summary>
/// Расшифровывает секретный ключ.
/// </summary>
///
/// <param name="wrapped">Зашифрованный ключ.</param>
/// <param name="method">Метод зашифрования ключа.</param>
///
/// <returns>Объкт класса <see cref="SymmetricAlgorithm"/>, содержащий
/// секретный ключ.</returns>
public abstract SymmetricAlgorithm Unwrap(byte[] wrapped,
GostKeyWrapMethod method);
/// <summary>
/// Шифрует секретный ключ.
/// </summary>
///
/// <param name="alg">Объект класса <see cref="SymmetricAlgorithm"/>,
/// содержащий секретный ключ. </param>
/// <param name="method">Метод зашифрования ключа.</param>
///
/// <returns>Зашифрованный ключ.</returns>
public abstract byte[] Wrap(SymmetricAlgorithm alg,
GostKeyWrapMethod method);
/// <summary>
/// Формирование данных обмена, на основе симметричного
/// ключа шифрования сообщения ГОСТ 28147.
/// </summary>
///
/// <param name="alg">Симметричный ключ ГОСТ 28147.</param>
/// <param name="keyWrapMethod">Алгоритм симметричного экспорта</param>
///
/// <returns>Зашифрованные данные для отправки стороне
/// получателю.</returns>
///
/// <argnull name="alg" />
public GostKeyTransport CreateKeyExchange(
SymmetricAlgorithm alg,
GostKeyWrapMethod keyWrapMethod = GostKeyWrapMethod.CryptoPro12KeyWrap)
{
if (alg == null)
{
throw new ArgumentNullException("alg");
}
// Получаем параметры получателя.
Gost3410Parameters senderParameters;
switch (_gostAlgorithmType)
{
case CspAlgorithmType.Gost2001:
{
senderParameters = ((Gost3410)_gostKey).ExportParameters(false);
using (Gost3410EphemeralCryptoServiceProvider sender =
new Gost3410EphemeralCryptoServiceProvider(senderParameters))
{
return(GetGostTransport(
sender.CreateAgree,
sender.ExportParameters,
senderParameters,
alg,
keyWrapMethod));
}
}
case CspAlgorithmType.Gost2012_256:
{
senderParameters = ((Gost3410_2012_256)_gostKey).ExportParameters(false);
using (Gost3410_2012_256EphemeralCryptoServiceProvider sender =
new Gost3410_2012_256EphemeralCryptoServiceProvider(senderParameters))
{
return(GetGostTransport(
sender.CreateAgree,
sender.ExportParameters,
senderParameters,
alg,
keyWrapMethod));
}
}
case CspAlgorithmType.Gost2012_512:
{
senderParameters = ((Gost3410_2012_512)_gostKey).ExportParameters(false);
using (Gost3410_2012_512EphemeralCryptoServiceProvider sender =
new Gost3410_2012_512EphemeralCryptoServiceProvider(senderParameters))
{
return(GetGostTransport(
sender.CreateAgree,
sender.ExportParameters,
senderParameters,
alg,
keyWrapMethod));
}
}
default:
{
throw new NotSupportedException();
}
}
}
/// <summary>
/// Импортирует (дешифрует) секретный ключ.
/// </summary>
/// <param name="wrapped">Зашифрованный секретный ключ.</param>
/// <param name="method">Алгоритм экспорта ключа.</param>
public override SymmetricAlgorithm Unwrap(byte[] wrapped, GostKeyWrapMethod method)
{
throw new NotImplementedException();
}
