public byte[] Sign(byte[] data, int certIndex)
{
try
{
if (hash == null)
{
throw new NullReferenceException("Compute hash first");
}
CspParameters cp = new CspParameters();
var privateKey = ClientCertificates[certIndex].PrivateKey as Gost3410_2012_256CryptoServiceProvider;
var uniqueKeyContainerName = privateKey.CspKeyContainerInfo.UniqueKeyContainerName;
cp.KeyContainerName = uniqueKeyContainerName;
cp.ProviderType = 75;
cp.ProviderName = null;
Gost3410_2012_256 gkey = new Gost3410_2012_256CryptoServiceProvider(cp);
Gost3410_2012_256CryptoServiceProvider srcContainer = new Gost3410_2012_256CryptoServiceProvider(cp);
Gost3410Parameters srcPublicKeyParameters = srcContainer.ExportParameters(false);
if (srcContainer == null)
{
throw new Exception("У сертификата нет приватного ключа");
}
signature = srcContainer.CreateSignature(hasher.Hash);
sCert = ClientCertificates[certIndex].Export(X509ContentType.Cert);
sTime = DateTime.Now;
return(Asn1Formatter.CreateSignature(signature, sCert, sTime, data));
}
catch (CryptographicException ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
/**
* return true if the value r and s represent a Gost3410 signature for
* the passed in message for standard Gost3410 the message should be a
* Gost3411 hash of the real message to be verified.
*/
public virtual bool VerifySignature(
byte[] message,
BigInteger r,
BigInteger s)
{
byte[] mRev = Arrays.Reverse(message); // conversion is little-endian
BigInteger m = new BigInteger(1, mRev);
Gost3410Parameters parameters = key.Parameters;
if (r.SignValue < 0 || parameters.Q.CompareTo(r) <= 0)
{
return(false);
}
if (s.SignValue < 0 || parameters.Q.CompareTo(s) <= 0)
{
return(false);
}
BigInteger v = m.ModPow(parameters.Q.Subtract(BigInteger.Two), parameters.Q);
BigInteger z1 = s.Multiply(v).Mod(parameters.Q);
BigInteger z2 = (parameters.Q.Subtract(r)).Multiply(v).Mod(parameters.Q);
z1 = parameters.A.ModPow(z1, parameters.P);
z2 = ((Gost3410PublicKeyParameters)key).Y.ModPow(z2, parameters.P);
BigInteger u = z1.Multiply(z2).Mod(parameters.P).Mod(parameters.Q);
return(u.Equals(r));
}
/// <summary>
/// Дешифровка марканта с помошью ключа согласования
/// </summary>
/// <param name="markant">Маркант для дешифровки</param>
/// <param name="providerInitData">Информация для инициализации контейнера криптопровайдера c закрытым ключом получателя</param>
/// <returns>Дешифрованный сессионный ключ</returns>
public static Gost28147 DecryptMarkantWithKeyAgree(Markant markant, ProviderInitData providerInitData)
{
//Готовим параметры контейнера
CspParameters decrypt_cspParameters = new CspParameters
{
ProviderType = (int)providerInitData.ProviderType,
Flags = CspProviderFlags.NoPrompt,
KeyPassword = providerInitData.ProviderPassword,
KeyContainerName = providerInitData.ProviderContainerName
};
//Открываем контейнер
Gost3410_2012_256CryptoServiceProvider decrypt_gost3410 = new Gost3410_2012_256CryptoServiceProvider(decrypt_cspParameters);
// Читаем открытый ключ
Gost3410Parameters decrypt_gost3410PublicKeyParameters = (Gost3410Parameters)Helper.ByteArrayToObject(markant.PublicKey);
// Создаем agree ключ
GostSharedSecretAlgorithm agree = decrypt_gost3410.CreateAgree(decrypt_gost3410PublicKeyParameters);
// Расшифровываем симметричный ключ на agree
Gost28147 decrypt_gost28147 = (Gost28147)agree.Unwrap(markant.SessionKey, GostKeyWrapMethod.CryptoProKeyWrap);
decrypt_gost28147.IV = markant.IV;
if (decrypt_gost28147 == null)
{
throw new Exception("Invalid decrypted session key");
}
// Устанавливаем синхропосылку.
decrypt_gost28147.IV = markant.IV;
return(decrypt_gost28147);
}
protected Gost34310KeyParameters(
bool isPrivate,
Gost3410Parameters parameters)
: base(isPrivate)
{
this.parameters = parameters;
}
public virtual bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
{
byte[] bytes = new byte[message.Length];
for (int i = 0; i != bytes.Length; i++)
{
bytes[i] = message[(bytes.Length - 1) - i];
}
BigInteger integer = new BigInteger(1, bytes);
Gost3410Parameters parameters = this.key.Parameters;
if ((r.SignValue < 0) || (parameters.Q.CompareTo(r) <= 0))
{
return(false);
}
if ((s.SignValue < 0) || (parameters.Q.CompareTo(s) <= 0))
{
return(false);
}
BigInteger val = integer.ModPow(parameters.Q.Subtract(BigInteger.Two), parameters.Q);
BigInteger e = s.Multiply(val).Mod(parameters.Q);
BigInteger integer4 = parameters.Q.Subtract(r).Multiply(val).Mod(parameters.Q);
e = parameters.A.ModPow(e, parameters.P);
integer4 = ((Gost3410PublicKeyParameters)this.key).Y.ModPow(integer4, parameters.P);
return(e.Multiply(integer4).Mod(parameters.P).Mod(parameters.Q).Equals(r));
}
public virtual bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
{
byte[] array = new byte[message.Length];
for (int i = 0; i != array.Length; i++)
{
array[i] = message[array.Length - 1 - i];
}
BigInteger bigInteger = new BigInteger(1, array);
Gost3410Parameters parameters = key.Parameters;
if (r.SignValue < 0 || parameters.Q.CompareTo(r) <= 0)
{
return(false);
}
if (s.SignValue < 0 || parameters.Q.CompareTo(s) <= 0)
{
return(false);
}
BigInteger val = bigInteger.ModPow(parameters.Q.Subtract(BigInteger.Two), parameters.Q);
BigInteger e = s.Multiply(val).Mod(parameters.Q);
BigInteger e2 = parameters.Q.Subtract(r).Multiply(val).Mod(parameters.Q);
e = parameters.A.ModPow(e, parameters.P);
e2 = ((Gost3410PublicKeyParameters)key).Y.ModPow(e2, parameters.P);
BigInteger bigInteger2 = e.Multiply(e2).Mod(parameters.P).Mod(parameters.Q);
return(bigInteger2.Equals(r));
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters gost3410Params = param.Parameters;
BigInteger q = gost3410Params.Q;
BigInteger x;
do
{
x = new BigInteger(256, random);
}while (x.SignValue < 1 || x.CompareTo(q) >= 0);
BigInteger p = gost3410Params.P;
BigInteger a = gost3410Params.A;
// calculate the public key.
BigInteger y = a.ModPow(x, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet),
new Gost3410PrivateKeyParameters(x, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, gost3410Params),
new Gost3410PrivateKeyParameters(x, gost3410Params)));
}
public void TestGost3410()
{
BigInteger a = BigInteger.ValueOf(1), b = BigInteger.ValueOf(2), c = BigInteger.ValueOf(3);
Gost3410Parameters g1 = new Gost3410Parameters(a, b, c);
Gost3410Parameters g2 = new Gost3410Parameters(a, b, c);
Gost3410Parameters g3 = new Gost3410Parameters(a, c, c);
doTest(g1, g2, g3);
Gost3410ValidationParameters v1 = new Gost3410ValidationParameters(100, 1);
Gost3410ValidationParameters v2 = new Gost3410ValidationParameters(100, 1);
Gost3410ValidationParameters v3 = new Gost3410ValidationParameters(101, 1);
doTest(v1, v2, v3);
v3 = new Gost3410ValidationParameters(100, 2);
doTest(v1, v2, v3);
v1 = new Gost3410ValidationParameters(100L, 1L);
v2 = new Gost3410ValidationParameters(100L, 1L);
v3 = new Gost3410ValidationParameters(101L, 1L);
doTest(v1, v2, v3);
v3 = new Gost3410ValidationParameters(100L, 2L);
doTest(v1, v2, v3);
}
/**
* generate a signature for the given message using the key we were
* initialised with. For conventional Gost3410 the message should be a Gost3411
* hash of the message of interest.
*
* @param message the message that will be verified later.
*/
public virtual BigInteger[] GenerateSignature(
byte[] message)
{
byte[] mRev = new byte[message.Length]; // conversion is little-endian
for (int i = 0; i != mRev.Length; i++)
{
mRev[i] = message[mRev.Length - 1 - i];
}
BigInteger m = new BigInteger(1, mRev);
Gost3410Parameters parameters = key.Parameters;
BigInteger k;
do
{
k = new BigInteger(parameters.Q.BitLength, random);
}while (k.CompareTo(parameters.Q) >= 0);
BigInteger r = parameters.A.ModPow(k, parameters.P).Mod(parameters.Q);
BigInteger s = k.Multiply(m).
Add(((Gost3410PrivateKeyParameters)key).X.Multiply(r)).
Mod(parameters.Q);
return(new BigInteger[] { r, s });
}
public virtual bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
{
byte[] array = new byte[message.Length];
for (int num = 0; num != array.Length; num++)
{
array[num] = message[array.Length - 1 - num];
}
BigInteger bigInteger = new BigInteger(1, array);
Gost3410Parameters parameters = this.key.Parameters;
if (r.SignValue < 0 || parameters.Q.CompareTo(r) <= 0)
{
return(false);
}
if (s.SignValue < 0 || parameters.Q.CompareTo(s) <= 0)
{
return(false);
}
BigInteger val = bigInteger.ModPow(parameters.Q.Subtract(BigInteger.Two), parameters.Q);
BigInteger bigInteger2 = s.Multiply(val).Mod(parameters.Q);
BigInteger bigInteger3 = parameters.Q.Subtract(r).Multiply(val).Mod(parameters.Q);
bigInteger2 = parameters.A.ModPow(bigInteger2, parameters.P);
bigInteger3 = ((Gost3410PublicKeyParameters)this.key).Y.ModPow(bigInteger3, parameters.P);
BigInteger bigInteger4 = bigInteger2.Multiply(bigInteger3).Mod(parameters.P).Mod(parameters.Q);
return(bigInteger4.Equals(r));
}
protected Gost34310KeyParameters(
bool isPrivate,
DerObjectIdentifier publicKeyParamSet)
: base(isPrivate)
{
this.parameters = LookupParameters(publicKeyParamSet);
this.publicKeyParamSet = publicKeyParamSet;
}
protected bool Equals(Gost3410Parameters other)
{
if (p.Equals(other.p) && q.Equals(other.q))
{
return(a.Equals(other.a));
}
return(false);
}
/// <summary>
/// Конструктор объекта класса по параметрам ключа.
/// </summary>
public Gost3410CspObject(Gost3410Parameters parameters)
{
_publicKeyParamSet = parameters.PublicKeyParamSet;
_digestParamSet = parameters.DigestParamSet;
_encryptionParamSet = parameters.EncryptionParamSet;
_publicKey = parameters.PublicKey;
_privateKey = parameters.PrivateKey;
}
public Gost3410PrivateKeyParameters(BigInteger x, Gost3410Parameters parameters)
: base(isPrivate: true, parameters)
{
if (x.SignValue < 1 || x.BitLength > 256 || x.CompareTo(base.Parameters.Q) >= 0)
{
throw new ArgumentException("Invalid x for GOST3410 private key", "x");
}
this.x = x;
}
// Шифрование тестового файла.
static void EncryptTestFile(
Gost3410_2012_512 publicKey,
Gost3410_2012_512CryptoServiceProvider privateKey,
string fileId = "2012_512")
{
// Создаем симметричный ключ.
Gost28147 symmetric = Gost28147.Create();
// Открываем ключ отправителя.
Gost3410Parameters srcPublicKeyParameters = privateKey.ExportParameters(false);
// Создаем agree ключ
GostSharedSecretAlgorithm agree = privateKey.CreateAgree(
publicKey.ExportParameters(false));
// Зашифровываем симметричный ключ на agree ключе.
byte[] WrappedKey = agree.Wrap(symmetric,
GostKeyWrapMethod.CryptoPro12KeyWrap);
// Создаем поток шифратора.
ICryptoTransform transform = symmetric.CreateEncryptor();
// Создаем зашифрованный файл.
using (FileStream ofs = new FileStream(string.Format(EncryptedFileName, fileId), FileMode.Create))
{
BinaryWriter bw = new BinaryWriter(ofs);
// Записываем зашифрованный симметричный ключ.
bw.Write(WrappedKey.Length);
bw.Write(WrappedKey);
// Записываем синхропосылку
bw.Write(symmetric.IV.Length);
bw.Write(symmetric.IV);
// Передаем открытый ключ.
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(ofs, srcPublicKeyParameters);
// Создаем поток шифрования для записи в файл.
using (CryptoStream cs = new CryptoStream(ofs, transform, CryptoStreamMode.Write))
{
byte[] data = new byte[4096];
// Открываем входной файл.
using (FileStream ifs = new FileStream(string.Format(SourceFileName, fileId), FileMode.Open, FileAccess.Read))
{
// и переписываем содержимое в выходной поток.
int length = ifs.Read(data, 0, data.Length);
while (length > 0)
{
cs.Write(data, 0, length);
length = ifs.Read(data, 0, data.Length);
}
}
}
}
}
public Gost3410PublicKeyParameters(BigInteger y, Gost3410Parameters parameters)
: base(isPrivate: false, parameters)
{
if (y.SignValue < 1 || y.CompareTo(base.Parameters.P) >= 0)
{
throw new ArgumentException("Invalid y for GOST3410 public key", "y");
}
this.y = y;
}
/// <summary>
/// Generate key pair.
/// </summary>
/// <returns></returns>
public override AsymmetricCipherKeyPair GenerateKeyPair()
{
Gost3410ParametersGenerator generator2 = new Gost3410ParametersGenerator();
generator2.Init(_keySize, _procedure, Common.ThreadSecureRandom.Value);
Gost3410Parameters parameters2 = generator2.GenerateParameters();
KeyGenerationParameters parameters = new Gost3410KeyGenerationParameters(Common.ThreadSecureRandom.Value, parameters2);
IAsymmetricCipherKeyPairGenerator generator = new Gost3410KeyPairGenerator();
generator.Init(parameters);
return(generator.GenerateKeyPair());
}
/// <summary>
/// Возвращает XML представление подэлемента GostKeyValue.
/// </summary>
///
/// <param name="xmlDocument">XML документ.</param>
///
/// <returns>XML элемент представления.</returns>
internal override XmlElement GetXml(XmlDocument xmlDocument)
{
// Несмотря на то что функция очень похожа на ParamsToXmlString
// не удается их объединить.
// С одной стороны, нет возможности втащить полноценный XML parser
// в cpBase (зависимость только от system), с другой нам необходим
// namespace в именах.
Gost3410Parameters parameters = _key.ExportParameters(false);
XmlElement keyValue = xmlDocument.CreateElement(
"KeyValue", GostConstants.XmlDsigNamespace);
XmlElement gostKeyValue = xmlDocument.CreateElement(
GostConstants.TagKeyValue2001, GostConstants.XmlDsigNamespace);
XmlElement publicKeyParameters = xmlDocument.CreateElement(
GostConstants.TagPublicKeyParameters, GostConstants.XmlDsigNamespace);
XmlElement publicKeyParamSet = xmlDocument.CreateElement(
GostConstants.TagPublicKeyParamSet, GostConstants.XmlDsigNamespace);
publicKeyParamSet.AppendChild(xmlDocument.CreateTextNode("urn:oid:" + parameters.PublicKeyParamSet));
XmlElement digestParamSet = xmlDocument.CreateElement(
GostConstants.TagDigestParamSet, GostConstants.XmlDsigNamespace);
digestParamSet.AppendChild(xmlDocument.CreateTextNode("urn:oid:" + parameters.DigestParamSet));
XmlElement encryptionParamSet = null;
if (parameters.EncryptionParamSet != null)
{
xmlDocument.CreateElement(GostConstants.TagEncryptionParamSet,
GostConstants.XmlDsigNamespace);
encryptionParamSet.AppendChild(xmlDocument.CreateTextNode("urn:oid:" + parameters.EncryptionParamSet));
}
XmlElement publicKey = xmlDocument.CreateElement(
GostConstants.TagPublicKey, GostConstants.XmlDsigNamespace);
publicKey.AppendChild(xmlDocument.CreateTextNode(Convert.ToBase64String(parameters.PublicKey)));
publicKeyParameters.AppendChild(publicKeyParamSet);
publicKeyParameters.AppendChild(digestParamSet);
if (encryptionParamSet != null)
{
publicKeyParameters.AppendChild(encryptionParamSet);
}
gostKeyValue.AppendChild(publicKeyParameters);
gostKeyValue.AppendChild(publicKey);
keyValue.AppendChild(gostKeyValue);
return(keyValue);
}
// Расшифрование тестового файла.
static void DecryptTestFile(Gost3410_2012_512CryptoServiceProvider privateKey, string fileId = "2012_512")
{
// Открываем зашифрованный файл.
using (FileStream ifs = new FileStream(string.Format(EncryptedFileName, fileId), FileMode.Open, FileAccess.Read))
{
// Читаем зашифрованный симметричный ключ.
BinaryReader br = new BinaryReader(ifs);
byte[] cek;
int cekLength = br.ReadInt32();
cek = br.ReadBytes(cekLength);
// Читаем синхропосылку
byte[] iv;
int ivLength = br.ReadInt32();
iv = br.ReadBytes(ivLength);
// Читаем открытый ключ.
BinaryFormatter formatter = new BinaryFormatter();
Gost3410Parameters srcPublicKeyParameters =
(Gost3410Parameters)formatter.Deserialize(ifs);
// Создаем agree ключ
GostSharedSecretAlgorithm agree = privateKey.CreateAgree(
srcPublicKeyParameters);
// Расшифровываем симметричный ключ на agree
SymmetricAlgorithm symmetric = agree.Unwrap(cek,
GostKeyWrapMethod.CryptoPro12KeyWrap);
symmetric.IV = iv;
// Создаем поток разшифрования.
ICryptoTransform transform = symmetric.CreateDecryptor();
// Создаем поток разшифрования из файла.
using (CryptoStream cs = new CryptoStream(ifs, transform, CryptoStreamMode.Read))
{
// Открываем расшифрованный файл
using (FileStream ofs = new FileStream(string.Format(DecryptedFileName, fileId), FileMode.Create))
{
byte[] data = new byte[4096];
// и переписываем содержимое в выходной поток.
int length = cs.Read(data, 0, data.Length);
while (length > 0)
{
ofs.Write(data, 0, length);
length = cs.Read(data, 0, data.Length);
}
}
}
}
}
private static void EncriptFile(X509Certificate2 sert, string sourceFile, string encFile)
{
var publicKey = (Gost3410_2012_256CryptoServiceProvider)sert.PublicKey.Key;
var asymmetricAlg = publicKey as Gost3410_2012_256;
if (asymmetricAlg == null)
{
throw new CryptographicException("Not a gost certificate");
}
var symmetricKey = Gost28147.Create();
Gost3410_2012_256 senderRndKey = Gost3410_2012_256.Create();
Gost3410Parameters senderRndKeyParameters = senderRndKey.ExportParameters(false);
GostSharedSecretAlgorithm agreeKey = senderRndKey.CreateAgree(asymmetricAlg.ExportParameters(false));
var encodedSymmetricKey = agreeKey.Wrap(symmetricKey, GostKeyWrapMethod.CryptoProKeyWrap);
ICryptoTransform transform = symmetricKey.CreateEncryptor();
using (FileStream writer = new FileStream(encFile, FileMode.Create))
{
BinaryWriter binaryWriter = new BinaryWriter(writer);
binaryWriter.Write(encodedSymmetricKey.Length);
binaryWriter.Write(encodedSymmetricKey);
binaryWriter.Write(symmetricKey.IV.Length);
binaryWriter.Write(symmetricKey.IV);
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(writer, senderRndKeyParameters);
using (CryptoStream cryptoStream = new CryptoStream(writer, transform, CryptoStreamMode.Write))
{
var buffer = new byte[100];
using (FileStream reader = new FileStream(sourceFile, FileMode.Open, FileAccess.Read))
{
var length = reader.Read(buffer, 0, buffer.Length);
while (length > 0)
{
cryptoStream.Write(buffer, 0, buffer.Length);
length = reader.Read(buffer, 0, buffer.Length);
}
}
}
}
}
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
Gost3410Parameters gost3410Parameters = obj as Gost3410Parameters;
if (gost3410Parameters == null)
{
return(false);
}
return(Equals(gost3410Parameters));
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters gost3410Params = param.Parameters;
BigInteger q = gost3410Params.Q, x;
int minWeight = 64;
for (;;)
{
x = new BigInteger(256, random);
if (x.SignValue < 1 || x.CompareTo(q) >= 0)
{
continue;
}
/*
* Require a minimum weight of the NAF representation, since low-weight primes may be
* weak against a version of the number-field-sieve for the discrete-logarithm-problem.
*
* See "The number field sieve for integers of low weight", Oliver Schirokauer.
*/
if (WNafUtilities.GetNafWeight(x) < minWeight)
{
continue;
}
break;
}
BigInteger p = gost3410Params.P;
BigInteger a = gost3410Params.A;
// calculate the public key.
BigInteger y = a.ModPow(x, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet),
new Gost3410PrivateKeyParameters(x, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, gost3410Params),
new Gost3410PrivateKeyParameters(x, gost3410Params)));
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters gost3410Params = param.Parameters;
BigInteger q = gost3410Params.Q, x;
int minWeight = 64;
for (;;)
{
x = new BigInteger(256, random);
if (x.SignValue < 1 || x.CompareTo(q) >= 0)
{
continue;
}
if (WNafUtilities.GetNafWeight(x) < minWeight)
{
continue;
}
break;
}
BigInteger p = gost3410Params.P;
BigInteger a = gost3410Params.A;
// calculate the public key.
BigInteger y = a.ModPow(x, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet),
new Gost3410PrivateKeyParameters(x, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, gost3410Params),
new Gost3410PrivateKeyParameters(x, gost3410Params)));
}
/// <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);
}
public virtual BigInteger[] GenerateSignature(byte[] message)
{
BigInteger integer2;
byte[] bytes = new byte[message.Length];
for (int i = 0; i != bytes.Length; i++)
{
bytes[i] = message[(bytes.Length - 1) - i];
}
BigInteger val = new BigInteger(1, bytes);
Gost3410Parameters parameters = this.key.Parameters;
do
{
integer2 = new BigInteger(parameters.Q.BitLength, this.random);
}while (integer2.CompareTo(parameters.Q) >= 0);
BigInteger integer3 = parameters.A.ModPow(integer2, parameters.P).Mod(parameters.Q);
BigInteger integer4 = integer2.Multiply(val).Add(((Gost3410PrivateKeyParameters)this.key).X.Multiply(integer3)).Mod(parameters.Q);
return(new BigInteger[] { integer3, integer4 });
}
/**
* generate a signature for the given message using the key we were
* initialised with. For conventional Gost3410 the message should be a Gost3411
* hash of the message of interest.
*
* @param message the message that will be verified later.
*/
public virtual BigInteger[] GenerateSignature(
byte[] message)
{
byte[] mRev = Arrays.Reverse(message); // conversion is little-endian
BigInteger m = new BigInteger(1, mRev);
Gost3410Parameters parameters = key.Parameters;
BigInteger k;
do
{
k = new BigInteger(parameters.Q.BitLength, random);
}while (k.CompareTo(parameters.Q) >= 0);
BigInteger r = parameters.A.ModPow(k, parameters.P).Mod(parameters.Q);
BigInteger s = k.Multiply(m).
Add(((Gost3410PrivateKeyParameters)key).X.Multiply(r)).
Mod(parameters.Q);
return(new BigInteger[] { r, s });
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters parameters = param.Parameters;
BigInteger q = parameters.Q;
int num = 64;
BigInteger bigInteger;
do
{
bigInteger = new BigInteger(256, random);
}while (bigInteger.SignValue < 1 || bigInteger.CompareTo(q) >= 0 || WNafUtilities.GetNafWeight(bigInteger) < num);
BigInteger p = parameters.P;
BigInteger a = parameters.A;
BigInteger y = a.ModPow(bigInteger, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet), new Gost3410PrivateKeyParameters(bigInteger, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(new Gost3410PublicKeyParameters(y, parameters), new Gost3410PrivateKeyParameters(bigInteger, parameters)));
}
public virtual BigInteger[] GenerateSignature(byte[] message)
{
byte[] array = new byte[message.Length];
for (int i = 0; i != array.Length; i++)
{
array[i] = message[array.Length - 1 - i];
}
BigInteger val = new BigInteger(1, array);
Gost3410Parameters parameters = key.Parameters;
BigInteger bigInteger;
do
{
bigInteger = new BigInteger(parameters.Q.BitLength, (Random)(object)random);
}while (bigInteger.CompareTo(parameters.Q) >= 0);
BigInteger bigInteger2 = parameters.A.ModPow(bigInteger, parameters.P).Mod(parameters.Q);
BigInteger bigInteger3 = bigInteger.Multiply(val).Add(((Gost3410PrivateKeyParameters)key).X.Multiply(bigInteger2)).Mod(parameters.Q);
return(new BigInteger[2] {
bigInteger2, bigInteger3
});
}
/// <summary>
/// Создает маркант с помошью ключа согласования
/// </summary>
/// <param name="gost28147">Сессионный ключ</param>
/// <param name="certFileName">Путь к файлу сертификата получателя</param>
/// <param name="providerInitData">Информация для инициализации контейнера криптопровайдера c закрытым ключом отправителя</param>
/// <returns>Сгенерированный маркант</returns>
public static Markant CreateMarkantWithKeyAgree(Gost28147 gost28147, string certFileName, ProviderInitData providerInitData)
{
// Разбираем сертификат получателя
X509Certificate2 cert = new X509Certificate2(certFileName);
if (!(cert.PublicKey.Key is Gost3410_2012_256 gost3410))
{
throw new CryptographicException("Not a GOST certificate");
}
//Готовим параметры контейнера
CspParameters cspParameters = new CspParameters
{
ProviderType = (int)providerInitData.ProviderType,
Flags = CspProviderFlags.NoPrompt,
KeyPassword = providerInitData.ProviderPassword,
KeyContainerName = providerInitData.ProviderContainerName
};
//Открываем контейнер
Gost3410_2012_256CryptoServiceProvider encrypt_gost3410 = new Gost3410_2012_256CryptoServiceProvider(cspParameters);
Gost3410Parameters encrypt_gost3410PublicKeyParameters = encrypt_gost3410.ExportParameters(false);
// Создаем agree ключ
GostSharedSecretAlgorithm agree = encrypt_gost3410.CreateAgree(gost3410.ExportParameters(false));
// Зашифровываем симметричный ключ на agree ключе.
byte[] wrappedKey = agree.Wrap(gost28147, GostKeyWrapMethod.CryptoProKeyWrap);
//Формируем маркант
Markant m = new Markant
{
Version = 2,
SessionKey = wrappedKey,
IV = gost28147.IV,
PublicKey = Helper.ObjectToByteArray(encrypt_gost3410PublicKeyParameters)
};
return(m);
}
/**
* return true if the value r and s represent a Gost3410 signature for
* the passed in message for standard Gost3410 the message should be a
* Gost3411 hash of the real message to be verified.
*/
public bool VerifySignature(
byte[] message,
BigInteger r,
BigInteger s)
{
byte[] mRev = new byte[message.Length]; // conversion is little-endian
for (int i = 0; i != mRev.Length; i++)
{
mRev[i] = message[mRev.Length - 1 - i];
}
BigInteger m = new BigInteger(1, mRev);
Gost3410Parameters parameters = key.Parameters;
if (r.SignValue < 0 || parameters.Q.CompareTo(r) <= 0)
{
return(false);
}
if (s.SignValue < 0 || parameters.Q.CompareTo(s) <= 0)
{
return(false);
}
BigInteger v = m.ModPow(parameters.Q.Subtract(BigInteger.Two), parameters.Q);
BigInteger z1 = s.Multiply(v).Mod(parameters.Q);
BigInteger z2 = (parameters.Q.Subtract(r)).Multiply(v).Mod(parameters.Q);
z1 = parameters.A.ModPow(z1, parameters.P);
z2 = ((Gost3410PublicKeyParameters)key).Y.ModPow(z2, parameters.P);
BigInteger u = z1.Multiply(z2).Mod(parameters.P).Mod(parameters.Q);
return(u.Equals(r));
}
