/// <summary> /// Дешифровка марканта с помошью KeyExchangeFormatter /// </summary> /// <param name="markant">Маркант для дешифровки</param> /// <param name="providerInitData">Информация для инициализации контейнера криптопровайдера c закрытым ключом получателя</param> /// <returns>Дешифрованный сессионный ключ</returns> public static Gost28147 DecryptMarkantWithKeyExchangeFormatter(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); // Деформаттер для ключей, зашифрованных на ассиметричном ключе получателя. Gost2012_256KeyExchangeDeformatter decrypt_gostKeyExchangeDeformatter = new Gost2012_256KeyExchangeDeformatter(decrypt_gost3410); // Получаем ГОСТ-овый ключ из GostKeyTransport. GostKeyTransport gostKeyTransport = new GostKeyTransport(); gostKeyTransport.Decode(markant.SessionKey); Gost28147 decrypt_gost28147 = (Gost28147)decrypt_gostKeyExchangeDeformatter.DecryptKeyExchange(gostKeyTransport); if (decrypt_gost28147 == null) { throw new Exception("Invalid decrypted session key"); } // Устанавливаем синхропосылку. decrypt_gost28147.IV = markant.IV; return(decrypt_gost28147); }
/// <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); }
/// <summary> /// Создает маркант с помошью KeyExchangeFormatter /// </summary> /// <param name="gost28147">Сессионный ключ</param> /// <param name="certFileName">Путь к файлу сертификата с открытым ключом получателя</param> /// <returns>Сгенерированный маркант</returns> public static Markant CreateMarkantWithKeyExchangeFormatter(Gost28147 gost28147, string certFileName) { // Разбираем сертификат получателя X509Certificate2 cert = new X509Certificate2(certFileName); if (!(cert.PublicKey.Key is Gost3410_2012_256 gost3410)) { throw new CryptographicException("Not a GOST certificate"); } //Создаем форматтер, шифрующий на ассиметричном ключе получателя Gost2012_256KeyExchangeFormatter formatter = new Gost2012_256KeyExchangeFormatter(gost3410); //GostKeyTransport - формат зашифрованной для безопасной передачи ключевой информации GostKeyTransport gostKeyTransport = ((Gost2012_256KeyExchangeFormatter)formatter).CreateKeyExchange(gost28147); //Формируем маркант Markant m = new Markant { Version = 1, SessionKey = gostKeyTransport.Encode(), IV = gost28147.IV }; return(m); }
public void SetSymmetrKey(byte[] data) { Gost2012_256KeyExchangeDeformatter deformatter = new Gost2012_256KeyExchangeDeformatter(currentCertificate.PrivateKey); GostKeyTransport encKey = new GostKeyTransport(); encKey.Decode(data); symKey = deformatter.DecryptKeyExchange(encKey) as Gost28147; }
// Шифруем байтовый массив byte[] GostEncrypt(Gost28147 key, byte[] sourceBytes) { int currentPosition = 0; byte[] targetBytes = new byte[1024]; int sourceByteLength = sourceBytes.Length; // Создаем шифратор для ГОСТ. ICryptoTransform cryptoTransform = key.CreateEncryptor(); // Размер блока считанных байт. int inputBlockSize = cryptoTransform.InputBlockSize; // Размер выходного блока. int outputBlockSize = cryptoTransform.OutputBlockSize; try { // Если возможна обработка нескольких блоков: if (cryptoTransform.CanTransformMultipleBlocks) { int numBytesRead = 0; while (sourceByteLength - currentPosition >= inputBlockSize) { // Преобразуем байты начиная с currentPosition в массиве // sourceBytes, записывая результат в массив targetBytes. numBytesRead = cryptoTransform.TransformBlock( sourceBytes, currentPosition, inputBlockSize, targetBytes, currentPosition); currentPosition += numBytesRead; } // Преобразуем последний блок. byte[] finalBytes = cryptoTransform.TransformFinalBlock( sourceBytes, currentPosition, sourceByteLength - currentPosition); // Записываем последний зашифрованный блок // в массив targetBytes. finalBytes.CopyTo(targetBytes, currentPosition); currentPosition += finalBytes.Length; } } catch (Exception ex) { Console.WriteLine("Caught unexpected exception:" + ex.ToString()); } // Определяем, может ли CPCryptoAPITransform использоваться повторно. if (!cryptoTransform.CanReuseTransform) { // Освобождаем занятые ресурсы. cryptoTransform.Dispose(); } // Убираем неиспользуемые байты из массива. return(TrimArray(targetBytes, currentPosition)); }
// Шифрование тестового файла. 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); } } } } }
// Действия получателя - расшифровываем полученные сессионный ключ и сообщение. byte[] GostDecrypt(GostKeyTransport encKey, byte[] encBytes, byte[] IV, AsymmetricAlgorithm AssymKey) { // Деформаттер для ключей, зашифрованных на ассиметричном ключе получателя. GostKeyExchangeDeformatter Deformatter = new GostKeyExchangeDeformatter(AssymKey); // Получаем ГОСТ-овый ключ из GostKeyTransport. Gost28147 key = (Gost28147)Deformatter.DecryptKeyExchange(encKey); // Устанавливаем синхропосылку. key.IV = IV; byte[] targetBytes = new byte[1024]; int currentPosition = 0; // Создаем дешифратор для ГОСТ. ICryptoTransform cryptoTransform = key.CreateDecryptor(); int inputBlockSize = cryptoTransform.InputBlockSize; int sourceByteLength = encBytes.Length; try { int numBytesRead = 0; while (sourceByteLength - currentPosition >= inputBlockSize) { // Преобразуем байты начиная с currentPosition в массиве // sourceBytes, записывая результат в массив targetBytes. numBytesRead = cryptoTransform.TransformBlock( encBytes, currentPosition, inputBlockSize, targetBytes, currentPosition); currentPosition += numBytesRead; } // Преобразуем последний блок. byte[] finalBytes = cryptoTransform.TransformFinalBlock( encBytes, currentPosition, sourceByteLength - currentPosition); // Записываем последний расшифрованный блок // в массив targetBytes. finalBytes.CopyTo(targetBytes, currentPosition); currentPosition += finalBytes.Length; } catch (Exception ex) { Console.WriteLine("Caught unexpected exception:" + ex.ToString()); } // Убираем неиспользуемые байты из массива. return(TrimArray(targetBytes, currentPosition)); }
public void TearDown() { try { _sharedKey.Dispose(); } finally { _sharedKey = null; } }
private static XmlDocument EncryptXmlDocument(XmlDocument xmlDocument, Gost28147 sharedKey) { // Создание объекта для шифрации XML var encryptedXml = new GostEncryptedXml(); // Поиск элементов для шифрации var elements = xmlDocument.SelectNodes("//SomeElement[@Encrypt='true']"); if (elements != null) { var elementIndex = 0; foreach (XmlElement element in elements) { // Создание случайного сессионного ключа using (var sessionKey = new Gost28147SymmetricAlgorithm()) { // Шифрация элемента var encryptedData = encryptedXml.EncryptData(element, sessionKey, false); // Шифрация сессионного ключа с использованием общего симметричного ключа var encryptedSessionKeyData = GostEncryptedXml.EncryptKey(sessionKey, sharedKey, GostKeyExchangeExportMethod.CryptoProKeyExport); // Формирование элемента EncryptedData var elementEncryptedData = new EncryptedData(); elementEncryptedData.Id = "EncryptedElement" + elementIndex++; elementEncryptedData.Type = EncryptedXml.XmlEncElementUrl; elementEncryptedData.EncryptionMethod = new EncryptionMethod(GostEncryptedXml.XmlEncGost28147Url); elementEncryptedData.CipherData.CipherValue = encryptedData; elementEncryptedData.KeyInfo = new KeyInfo(); // Формирование информации о зашифрованном сессионном ключе var encryptedSessionKey = new EncryptedKey(); encryptedSessionKey.CipherData = new CipherData(encryptedSessionKeyData); encryptedSessionKey.EncryptionMethod = new EncryptionMethod(GostEncryptedXml.XmlEncGostCryptoProKeyExportUrl); encryptedSessionKey.AddReference(new DataReference { Uri = "#" + elementEncryptedData.Id }); encryptedSessionKey.KeyInfo.AddClause(new KeyInfoName { Value = "SharedKey1" }); // Добавление ссылки на зашифрованный ключ, используемый при шифровании данных elementEncryptedData.KeyInfo.AddClause(new KeyInfoEncryptedKey(encryptedSessionKey)); // Замена элемента его зашифрованным представлением GostEncryptedXml.ReplaceElement(element, elementEncryptedData, false); } } } return(xmlDocument); }
/// <summary> /// Зашифровать симметричный ключ /// </summary> /// <param name="symmKey"></param> /// <param name="recipientName"></param> /// <returns></returns> public byte[] EncryptSymmKey(Gost28147 symmKey, string recipientName) { Log.DssLogger.Debug($"Шифрование симметричного ключа на получателя {recipientName}"); byte[] returnArray; try { X509Certificate2 cert = _certificateService.FindAddressBookCertificateBySubjectName(recipientName) .Result; // Если ничего не нашли - выходим if (cert == null) { return(null); } // Открытый ключ получателя. AsymmetricAlgorithm pk = cert.PublicKey.Key; Gost3410 recipient = pk as Gost3410; if (recipient == null) { throw new CryptographicException("Not a gost certificate"); } GostKeyExchangeFormatter keyFormatter = new GostKeyExchangeFormatter(recipient); byte[] transport = keyFormatter.CreateKeyExchangeData(symmKey); // Создаем зашифрованный файл. using (MemoryStream ms = new MemoryStream()) { // Записываем зашифрованный симметричный ключ в виде транспортного представления. BinaryWriter bw = new BinaryWriter(ms); bw.Write(transport.Length); bw.Write(transport); // Записываем синхропосылку bw.Write(symmKey.IV.Length); bw.Write(symmKey.IV); returnArray = ms.ToArray(); } } catch (Exception exp) { Log.DssLogger.Error($"Ошибка при зашифровании симметричного ключа: {exp}"); returnArray = null; } return(returnArray); }
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); } } } } }
private void bCreateGost28147_Click(object sender, EventArgs e) { currentGost28147 = null; pGost28147Green.Visible = false; pGost28147Red.Visible = true; //Создаем случайный сессионный ключ currentGost28147 = new Gost28147CryptoServiceProvider(); if (currentGost28147 != null) { pGost28147Green.Visible = true; pGost28147Red.Visible = false; } }
// Действия получателя - расшифровываем полученные сессионный ключ и сообщение. byte[] GostDecrypt(Gost28147 key, byte[] encBytes, byte[] IV) { // Устанавливаем синхропосылку. key.IV = IV; byte[] targetBytes = new byte[1024]; int currentPosition = 0; // Создаем дешифратор для ГОСТ. ICryptoTransform cryptoTransform = key.CreateDecryptor(); int inputBlockSize = cryptoTransform.InputBlockSize; int sourceByteLength = encBytes.Length; try { int numBytesRead = 0; while (sourceByteLength - currentPosition >= inputBlockSize) { // Преобразуем байты начиная с currentPosition в массиве // sourceBytes, записывая результат в массив targetBytes. numBytesRead = cryptoTransform.TransformBlock( encBytes, currentPosition, inputBlockSize, targetBytes, currentPosition); currentPosition += numBytesRead; } // Преобразуем последний блок. byte[] finalBytes = cryptoTransform.TransformFinalBlock( encBytes, currentPosition, sourceByteLength - currentPosition); // Записываем последний расшифрованный блок // в массив targetBytes. finalBytes.CopyTo(targetBytes, currentPosition); currentPosition += finalBytes.Length; } catch (Exception ex) { Console.WriteLine("Caught unexpected exception:" + ex.ToString()); } // Убираем неиспользуемые байты из массива. return(TrimArray(targetBytes, currentPosition)); }
public static byte[] EncryptKey(Gost28147 sessionKey, Gost28147 sharedKey, GostKeyExchangeExportMethod exportMethod) { if (sessionKey == null) { throw ExceptionUtility.ArgumentNull("sessionKey"); } if (sharedKey == null) { throw ExceptionUtility.ArgumentNull("sharedKey"); } return(sharedKey.EncodePrivateKey(sessionKey, exportMethod)); }
private static bool VerifyHmacDataStream(Gost28147 sharedKey, Stream imitDataStream) { // Создание объекта для вычисления HMAC using (var imitHash = new Gost3411Hmac(sharedKey)) { // Считывание HMAC из потока данных var imitHashValue = new byte[imitHash.HashSize / 8]; imitDataStream.Read(imitHashValue, 0, imitHashValue.Length); // Вычисление реального значения HMAC для потока данных var expectedImitHashValue = imitHash.ComputeHash(imitDataStream); // Сравнение исходного HMAC с ожидаемым return(imitHashValue.SequenceEqual(expectedImitHashValue)); } }
private static bool VerifyImitDataStream(Gost28147 sharedKey, Stream imitDataStream) { // Создание объекта для вычисления имитовставки using (var imitHash = new Gost28147ImitHashAlgorithm(sharedKey)) { // Считывание имитовставки из потока данных var imitHashValue = new byte[imitHash.HashSize / 8]; imitDataStream.Read(imitHashValue, 0, imitHashValue.Length); // Вычисление реального значения имитовставки для потока данных var expectedImitHashValue = imitHash.ComputeHash(imitDataStream); // Сравнение исходной имитовствки с ожидаемой return(imitHashValue.SequenceEqual(expectedImitHashValue)); } }
public static byte[] EncryptKey(Gost28147 sessionKey, Gost3410 publicKey) { if (sessionKey == null) { throw ExceptionUtility.ArgumentNull("sessionKey"); } if (publicKey == null) { throw ExceptionUtility.ArgumentNull("publicKey"); } var formatter = new GostKeyExchangeFormatter(publicKey); return(formatter.CreateKeyExchangeData(sessionKey)); }
public byte[] GetEncryptedSymKey() { try { symKey = new Gost28147CryptoServiceProvider(); IV = symKey.IV; Gost2012_256KeyExchangeFormatter Formatter = new Gost2012_256KeyExchangeFormatter(serverCert.PublicKey.Key); GostKeyTransport encKey = Formatter.CreateKeyExchange(symKey); byte[] bencKey = encKey.Encode(); return(bencKey); } catch (Exception ex) { Console.WriteLine(ex.Message); return(null); } }
private static Stream CreateImitDataStream(Gost28147 sharedKey, Stream dataStream) { // Создание объекта для вычисления имитовставки using (var imitHash = new Gost28147ImitHashAlgorithm(sharedKey)) { // Вычисление имитовставки для потока данных var imitHashValue = imitHash.ComputeHash(dataStream); // Запись имитовставки в начало выходного потока данных var imitDataStream = new MemoryStream(); imitDataStream.Write(imitHashValue, 0, imitHashValue.Length); // Копирование исходного потока данных в выходной поток dataStream.Position = 0; dataStream.CopyTo(imitDataStream); imitDataStream.Position = 0; return(imitDataStream); } }
/// <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); }
private void bDecryptMarkant_Click(object sender, EventArgs e) { currentGost28147 = null; pGost28147Green.Visible = false; pGost28147Red.Visible = true; if (currentMarkant != null) { try { //Выбираем алгоритм и дешифруем сессионный ключ if (rbKeyAgree.Checked) { currentGost28147 = MarkantManager.DecryptMarkantWithKeyAgree(currentMarkant, new ProviderInitData(cbProviderName.Text, cbProviderPassword.Text)); } else { currentGost28147 = MarkantManager.DecryptMarkantWithKeyExchangeFormatter(currentMarkant, new ProviderInitData(cbProviderName.Text, cbProviderPassword.Text)); } } catch (Exception exc) { MessageBox.Show(exc.Source + ": " + exc.Message, "Дешифровка сессионного ключа текущего марканта"); } } else { MessageBox.Show("Текущий маркант пустой!", "Дешифровка сессионного ключа текущего марканта"); } if (currentGost28147 != null) { pGost28147Red.Visible = false; pGost28147Green.Visible = true; } }
public byte[] DecryptMessage() { X509Certificate2 cert = GetCertificate(); Gost3410_2012_256 assym = cert.PrivateKey as Gost3410_2012_256; var s_parts = encryptedSessionKey.Split(':'); var parts = encryptedSessionKey.Split(':').Select(part => part.Split(' ').Select(e => Convert.ToByte(e, 16)).ToArray()).ToArray(); //0 - Параметры шифрования ключа обмена. Компонент является результатом выполнения CryptGetKeyParam(KP_CIPHEROID). //1 - Эфемерный открытый ключ, который использовался для выработки ключа обмена. Компонент является результатом выполнения CryptExportKey(PUBLICKEYBLOBEX). //2 - Симметричный ключ, зашифрованный на ключе обмена. Компонент является результатом выполнения CryptExportKey(SIMPLEBLOB). // // -=PUBLICKEYBLOB=- // BYTE bPublicKeyBlob[] = // { // 0x06, // bType = PUBLICKEYBLOB // 0x20, // bVersion = 0x20 // 0x00, 0x00, // reserved // 0x23, 0x2E, 0x00, 0x00, // KeyAlg = ALG_SID_GR3410EL // 0x4D, 0x41, 0x47, 0x31, // Magic = GR3410_1_MAGIC // 0x00, 0x02, 0x00, 0x00, // BitLen = 512 // bASN1GostR3410_94_PublicKeyParameters // 0x30, 0x12, // 0x06, 0x07, // 0x2A, 0x85, 0x03, 0x02, 0x02, 0x24, 0x00, // 0x06, 0x07, // 0x2A, 0x85, 0x03, 0x02, 0x02, 0x1E, 0x01, // bPublicKey // 0x2D, 0xC3, 0xFD, 0xF6, 0x9C, 0x91, 0x3D, 0xCC, // 0xB6, 0x53, 0x26, 0x8E, 0x51, 0x2F, 0x5E, 0xDD, // 0xE4, 0x1A, 0x5D, 0xB3, 0x58, 0x3C, 0xDF, 0x60, // 0x68, 0xF2, 0x48, 0xA2, 0xB0, 0xB8, 0xDE, 0x7B, // 0xC9, 0xAA, 0x20, 0xE3, 0xCF, 0x63, 0xDF, 0x5F, // 0x39, 0x55, 0x21, 0xE0, 0xA0, 0xDD, 0x85, 0x3E, // 0x0A, 0xAF, 0x44, 0xFA, 0x49, 0x3C, 0xD5, 0x4C, // 0xA8, 0x04, 0x8D, 0x1D, 0x9C, 0x41, 0x85, 0xFB // }; // // BYTE bEncryptionParamSet[] = { // 0x30, 0x09, // SEQUENCE (размер 0x09) // 0x06, 0x07, // OBJECT IDENTIFIER, (размер 0x07) // 0x2a, 0x85, 0x03, 0x02, 0x02, 0x1f, 0x01 // 1.2.643.2.2.31.1 // }; // -=SIMPLEBLOB=- // BYTE bSimpleBlob[] = // { // 0x01, // bType = SIMPLEBLOB // 0x20, // bVersion = 0x20 // 0x00, 0x00, // reserved // 0x23, 0x2e, 0x00, 0x00, // KeyAlg = ALG_SID_GR3410EL // 0x4d, 0x41, 0x47, 0x31, // Magic = GR3410_1_MAGIC // 0x1e, 0x66, 0x00, 0x00, // EncryptKeyAlgId = CALG_G28147 // 0x76, 0xee, 0xb4, 0x6b, 0x1b, 0x10, 0x36, 0xeb, // bUKM // // pbEncryptedKey // 0x5e, 0x70, 0x73, 0x5f, 0x36, 0x98, 0xb4, 0x35, // 0x5b, 0x45, 0x03, 0x7f, 0xa7, 0xce, 0x00, 0x97, // 0x11, 0x5e, 0x45, 0xc6, 0x58, 0x59, 0x94, 0x72, // 0x66, 0x42, 0x06, 0x3f, 0x72, 0x3a, 0xb4, 0x9e, // 0x8c, 0x86, 0x08, 0x84, // pbMacKey // 0x30, 0x09, 0x06, 0x07, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x1f, 0x01 // bEncryptionParamSet // }; Gost2012_256KeyExchangeDeformatter Deformatter = new Gost2012_256KeyExchangeDeformatter(assym); GostKeyTransport encKey = new GostKeyTransport(); //0- 31 2E 32 2E 36 34 33 2E 37 2E 31 2E 32 2E 35 2E 31 2E 31 00 //1- 0A 20 00 00 49 2E 00 00 4D 41 47 31 00 02 00 00 30 13 06 07 2A 85 03 02 02 24 00 06 08 2A 85 03 07 01 01 02 02 8B FF 19 01 0B CF BB C9 03 59 58 D0 6F 24 C1 3C 5D 1F AC 9B F8 F7 24 7B 48 4E 39 2E 9A 42 B6 66 60 CA D8 0E 62 7E 22 15 CC C9 E5 A6 2E 58 FF 9B 1D FB EA 7B 5E 42 B5 FD 51 97 BD D9 6E 24 16 AC // //0A PUBLICKEYBLOBEX //20 Version //00 00 Reserved //49 2E 00 00 // KeyAlg = ??? //4D 41 47 31 // Magic = GR3410_1_MAGIC //00 02 00 00 // EncryptKeyAlgId //30 ??? //13 Length for Oids //06 07 2A 85 03 02 02 24 00 // OId ??? 1.2.643.2.2.36.0 PublicKeyParamSet //06 08 2A 85 03 07 01 01 02 02 // OId ??? 1.2.643.7.1.1.2.2 DigestParamSet //8B FF 19 01 0B CF BB C9 //PublicKey //03 59 58 D0 6F 24 C1 3C //5D 1F AC 9B F8 F7 24 7B //48 4E 39 2E 9A 42 B6 66 //60 CA D8 0E 62 7E 22 15 //CC C9 E5 A6 2E 58 FF 9B //1D FB EA 7B 5E 42 B5 FD //51 97 BD D9 6E 24 16 AC // //2- 01 20 00 00 1E 66 00 00 FD 51 4A 37 1E 66 00 00 6A 0F 44 24 B6 CB 8B 7C 91 8B D1 55 2D 7D 07 67 6F 03 42 8E DC BE D0 9B 84 BA 8E 04 E7 FA 3A 2A 9B 2C F6 F1 71 86 3D F6 4E 32 52 65 30 09 06 07 2A 85 03 02 02 1F 01" // //01 SIMPLEBLOB //20 Version //00 00 Reserved //1E 66 00 00 KeyAlg //FD 51 4A 37 Magic //1E 66 00 00 EncryptKeyAlgId //6A 0F 44 24 B6 CB 8B 7C UKM //91 8B D1 55 2D 7D 07 67 EncryptedKey //6F 03 42 8E DC BE D0 9B //84 BA 8E 04 E7 FA 3A 2A //9B 2C F6 F1 71 86 3D F6 //4E 32 52 65 MacKey //30 09 06 07 2A 85 03 02 02 1F 01 EncryptionParamSet encKey.SessionEncryptedKey.Ukm = new byte[] { 0x6A, 0x0F, 0x44, 0x24, 0xB6, 0xCB, 0x8B, 0x7C }; encKey.SessionEncryptedKey.EncryptedKey = new byte[] { 0x91, 0x8B, 0xD1, 0x55, 0x2D, 0x7D, 0x07, 0x67, 0x6F, 0x03, 0x42, 0x8E, 0xDC, 0xBE, 0xD0, 0x9B, 0x84, 0xBA, 0x8E, 0x04, 0xE7, 0xFA, 0x3A, 0x2A, 0x9B, 0x2C, 0xF6, 0xF1, 0x71, 0x86, 0x3D, 0xF6 }; encKey.SessionEncryptedKey.Mac = new byte[] { 0x4E, 0x32, 0x52, 0x65 }; encKey.SessionEncryptedKey.EncryptionParamSet = "1.2.643.2.2.31.1"; encKey.TransportParameters.DigestParamSet = "1.2.643.7.1.1.2.2"; encKey.TransportParameters.PublicKey = new byte[] { 0x8B, 0xFF, 0x19, 0x01, 0x0B, 0xCF, 0xBB, 0xC9, 0x03, 0x59, 0x58, 0xD0, 0x6F, 0x24, 0xC1, 0x3C, 0x5D, 0x1F, 0xAC, 0x9B, 0xF8, 0xF7, 0x24, 0x7B, 0x48, 0x4E, 0x39, 0x2E, 0x9A, 0x42, 0xB6, 0x66, 0x60, 0xCA, 0xD8, 0x0E, 0x62, 0x7E, 0x22, 0x15, 0xCC, 0xC9, 0xE5, 0xA6, 0x2E, 0x58, 0xFF, 0x9B, 0x1D, 0xFB, 0xEA, 0x7B, 0x5E, 0x42, 0xB5, 0xFD, 0x51, 0x97, 0xBD, 0xD9, 0x6E, 0x24, 0x16, 0xAC }; encKey.TransportParameters.PublicKeyParamSet = "1.2.643.2.2.36.0"; Gost28147 key = (Gost28147)Deformatter.DecryptKeyExchange(encKey); key.IV = sessionKeyIV.Split(' ').Select(c => Convert.ToByte(c, 16)).ToArray(); //byte[] encBytes = Enumerable.Range(0, dataEncrypted.Length) // .Where(x => x % 2 == 0) // .Select(x => Convert.ToByte(dataEncrypted.Substring(x, 2), 16)) // .ToArray(); byte[] encBytes = Convert.FromBase64String(dataEncrypted); byte[] targetBytes = new byte[1024]; int currentPosition = 0; CPCryptoAPITransform cryptoTransform = (CPCryptoAPITransform)key.CreateDecryptor(); int inputBlockSize = cryptoTransform.InputBlockSize; int sourceByteLength = encBytes.Length; try { int numBytesRead = 0; while (sourceByteLength - currentPosition >= inputBlockSize) { numBytesRead = cryptoTransform.TransformBlock( encBytes, currentPosition, inputBlockSize, targetBytes, currentPosition); currentPosition += numBytesRead; } byte[] finalBytes = cryptoTransform.TransformFinalBlock( encBytes, currentPosition, sourceByteLength - currentPosition); finalBytes.CopyTo(targetBytes, currentPosition); } catch (Exception ex) { Console.WriteLine("Caught unexpected exception:" + ex.ToString()); } byte[] retVal = TrimArray(targetBytes); return(retVal); }
/// <summary> /// Шифрует сессионный ключ с помощью указанного симметричного ключа ГОСТ 28147. /// </summary> /// <param name="sessionKey">Шифруемый сессионный ключ.</param> /// <param name="sharedKey">Общий симметричный ключ ГОСТ 28147 для шифрования сессионного ключа.</param> /// <param name="exportMethod">Алгоритм экспорта сессионного ключа.</param> /// <returns>Массив байт, содержащий зашифрованный сессионный ключ.</returns> /// <remarks>Как правило сессионный ключ используется для шифрования данных и в свою очередь так же шифруется.</remarks> public static byte[] EncryptKey(Gost28147 sessionKey, Gost28147 sharedKey, GostKeyExchangeExportMethod exportMethod = GostKeyExchangeExportMethod.GostKeyExport) { return(GostEncryptedXmlImpl.EncryptKey(sessionKey, sharedKey, exportMethod)); }
public void SetUp() { _sharedKey = new Gost28147SymmetricAlgorithm(); }
private static XmlDocument DecryptXmlDocument(XmlDocument encryptedXmlDocument, Gost28147 sharedKey) { // Создание объекта для дешифрации XML var encryptedXml = new GostEncryptedXml(encryptedXmlDocument); // Добавление ссылки на общий симметричный ключ encryptedXml.AddKeyNameMapping("SharedKey1", sharedKey); // Расшифровка зашифрованных элементов документа encryptedXml.DecryptDocument(); return(encryptedXmlDocument); }
private void bClearGost28147_Click(object sender, EventArgs e) { currentGost28147 = null; pGost28147Green.Visible = false; pGost28147Red.Visible = true; }
private void button1_Click(object sender, EventArgs e) { Gost28147 gost = Gost28147.Create(); Gost3410Parameters public_key = csp.ExportParameters(false); GostSharedSecretAlgorithm agree_key = csp.CreateAgree(sign.ExportParameters(false)); byte[] wrapped_key = agree_key.Wrap(gost, GostKeyWrapMethod.CryptoProKeyWrap); BinaryFormatter bf = new BinaryFormatter(); MemoryStream ms = new MemoryStream(); bf.Serialize(ms, public_key); byte[] public_key_bytes = ms.ToArray(); ms.Close(); MemoryStream memory_stream = new MemoryStream(); CryptoStream cs = new CryptoStream(memory_stream, gost.CreateEncryptor(), CryptoStreamMode.Write); string plain_text = richTextBox1.Text; byte[] plain_text_bytes = Encoding.ASCII.GetBytes(plain_text); cs.Write(plain_text_bytes, 0, plain_text_bytes.Length); cs.FlushFinalBlock(); byte[] cipher_text_bytes = memory_stream.ToArray(); memory_stream.Close(); cs.Close(); BERelement main_seq = new BERelement(0x30); BERelement sign_seq = new BERelement(0x30); sign_seq.AddItem(new BERelement(0x02, wrapped_key)); sign_seq.AddItem(new BERelement(0x02, gost.IV)); sign_seq.AddItem(new BERelement(0x02, public_key_bytes)); sign_seq.AddItem(new BERelement(0x02, cipher_text_bytes)); main_seq.AddItem(sign_seq); byte[] test = main_seq.GetEncodedPacket().ToArray(); //File.WriteAllBytes("asn1", test); /* * sign_seq.AddItem(new BERelement(0x02, signature)); * sign_seq.AddItem(new BERelement(0x02, plain_text_bytes)); * * main_seq.AddItem(sign_seq); * byte[] test = main_seq.GetEncodedPacket().ToArray(); */ //send data try { Int32 port = 9595; TcpClient client = new TcpClient("127.0.0.1", port); NetworkStream stream = client.GetStream(); stream.Write(mode, 0, 1); stream.Write(test, 0, test.Length); //stream.Write(wrapped_key, 0, wrapped_key.Length); //stream.Write(gost.IV, 0, gost.IV.Length); //stream.Write(public_key_bytes, 0, public_key_bytes.Length); //stream.Write(cipher_text_bytes, 0, cipher_text_bytes.Length); stream.Close(); client.Close(); } catch (ArgumentNullException exception) { MessageBox.Show("ArgumentNullException: " + exception); } catch (SocketException exception) { MessageBox.Show("SocketException: " + exception); } }
private void button4_Click(object sender, EventArgs e) { if (checkBox2.Checked && !checkBox1.Checked) { string plain_text = richTextBox1.Text; byte[] plain_text_bytes = Encoding.ASCII.GetBytes(plain_text); Gost3411CryptoServiceProvider hash = new Gost3411CryptoServiceProvider(); byte[] signature = csp.SignData(plain_text_bytes, hash); BERelement main_seq = new BERelement(0x30); BERelement sign_seq = new BERelement(0x30); sign_seq.AddItem(new BERelement(0x0C, cert_name)); sign_seq.AddItem(new BERelement(0x04, signature)); sign_seq.AddItem(new BERelement(0x04, plain_text_bytes)); main_seq.AddItem(sign_seq); byte[] test = main_seq.GetEncodedPacket().ToArray(); File.WriteAllBytes("signature", test); try { Int32 port = 9595; TcpClient client = new TcpClient("127.0.0.1", port); NetworkStream stream = client.GetStream(); stream.Write(mode, 1, 1); stream.Write(test, 0, test.Length); stream.Close(); client.Close(); } catch (ArgumentNullException exception) { MessageBox.Show("ArgumentNullException: " + exception); } catch (SocketException exception) { MessageBox.Show("SocketException: " + exception); } } else if (checkBox1.Checked && !checkBox2.Checked) { Gost28147 gost = Gost28147.Create(); Gost3410Parameters public_key = csp.ExportParameters(false); GostSharedSecretAlgorithm agree_key = csp.CreateAgree(sign.ExportParameters(false)); byte[] wrapped_key = agree_key.Wrap(gost, GostKeyWrapMethod.CryptoProKeyWrap); BinaryFormatter bf = new BinaryFormatter(); MemoryStream ms = new MemoryStream(); bf.Serialize(ms, public_key); byte[] public_key_bytes = ms.ToArray(); ms.Close(); MemoryStream memory_stream = new MemoryStream(); CryptoStream cs = new CryptoStream(memory_stream, gost.CreateEncryptor(), CryptoStreamMode.Write); string plain_text = richTextBox1.Text; byte[] plain_text_bytes = Encoding.ASCII.GetBytes(plain_text); cs.Write(plain_text_bytes, 0, plain_text_bytes.Length); cs.FlushFinalBlock(); byte[] cipher_text_bytes = memory_stream.ToArray(); memory_stream.Close(); cs.Close(); BERelement main_seq = new BERelement(0x30); BERelement sign_seq = new BERelement(0x30); sign_seq.AddItem(new BERelement(0x0C, cert_name)); sign_seq.AddItem(new BERelement(0x04, wrapped_key)); sign_seq.AddItem(new BERelement(0x04, gost.IV)); sign_seq.AddItem(new BERelement(0x04, public_key_bytes)); sign_seq.AddItem(new BERelement(0x04, cipher_text_bytes)); main_seq.AddItem(sign_seq); byte[] test = main_seq.GetEncodedPacket().ToArray(); File.WriteAllBytes("encryption", test); try { Int32 port = 9595; TcpClient client = new TcpClient("127.0.0.1", port); NetworkStream stream = client.GetStream(); stream.Write(mode, 0, 1); stream.Write(test, 0, test.Length); stream.Close(); client.Close(); } catch (ArgumentNullException exception) { MessageBox.Show("ArgumentNullException: " + exception); } catch (SocketException exception) { MessageBox.Show("SocketException: " + exception); } } else if (checkBox2.Checked && checkBox1.Checked) { MessageBox.Show("suka!"); string plain_text = richTextBox1.Text; byte[] plain_text_bytes = Encoding.ASCII.GetBytes(plain_text); Gost3411CryptoServiceProvider hash = new Gost3411CryptoServiceProvider(); byte[] signature = csp.SignData(plain_text_bytes, hash); BERelement main_seq = new BERelement(0x30); BERelement sign_seq = new BERelement(0x30); sign_seq.AddItem(new BERelement(0x0C, cert_name)); sign_seq.AddItem(new BERelement(0x04, signature)); sign_seq.AddItem(new BERelement(0x04, plain_text_bytes)); main_seq.AddItem(sign_seq); byte[] test = main_seq.GetEncodedPacket().ToArray(); File.WriteAllBytes("signature_and_encryption", test); Gost28147 gost = Gost28147.Create(); Gost3410Parameters public_key = csp.ExportParameters(false); GostSharedSecretAlgorithm agree_key = csp.CreateAgree(sign.ExportParameters(false)); byte[] wrapped_key = agree_key.Wrap(gost, GostKeyWrapMethod.CryptoProKeyWrap); BinaryFormatter bf = new BinaryFormatter(); MemoryStream ms = new MemoryStream(); bf.Serialize(ms, public_key); byte[] public_key_bytes = ms.ToArray(); ms.Close(); MemoryStream memory_stream = new MemoryStream(); CryptoStream cs = new CryptoStream(memory_stream, gost.CreateEncryptor(), CryptoStreamMode.Write); //string plain_text = richTextBox1.Text; //byte[] plain_text_bytes = Encoding.ASCII.GetBytes(plain_text); byte[] plain_text_bytes2 = test; cs.Write(plain_text_bytes2, 0, plain_text_bytes2.Length); cs.FlushFinalBlock(); byte[] cipher_text_bytes2 = memory_stream.ToArray(); memory_stream.Close(); cs.Close(); BERelement main_seq2 = new BERelement(0x30); BERelement sign_seq2 = new BERelement(0x30); sign_seq2.AddItem(new BERelement(0x0C, cert_name)); sign_seq2.AddItem(new BERelement(0x04, wrapped_key)); sign_seq2.AddItem(new BERelement(0x04, gost.IV)); sign_seq2.AddItem(new BERelement(0x04, public_key_bytes)); sign_seq2.AddItem(new BERelement(0x04, cipher_text_bytes2)); main_seq2.AddItem(sign_seq2); byte[] test2 = main_seq2.GetEncodedPacket().ToArray(); try { Int32 port = 9595; TcpClient client = new TcpClient("127.0.0.1", port); NetworkStream stream = client.GetStream(); stream.Write(mode, 2, 1); stream.Write(test2, 0, test2.Length); stream.Close(); client.Close(); } catch (ArgumentNullException exception) { MessageBox.Show("ArgumentNullException: " + exception); } catch (SocketException exception) { MessageBox.Show("SocketException: " + exception); } } }
/// <summary> /// Шифрует сессионный ключ с помощью указанного асимметричного ключа ГОСТ Р 34.10. /// </summary> /// <param name="sessionKey">Шифруемый сессионный ключ.</param> /// <param name="publicKey">Открытый ключ ГОСТ Р 34.10 для шифрования сессионного ключа.</param> /// <returns>Массив байт, содержащий зашифрованный сессионный ключ.</returns> /// <remarks>Как правило сессионный ключ используется для шифрования данных и в свою очередь так же шифруется.</remarks> public static byte[] EncryptKey(Gost28147 sessionKey, Gost3410 publicKey) { return(GostEncryptedXmlImpl.EncryptKey(sessionKey, publicKey)); }