Exemple #1
0
 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);
     }
 }
Exemple #2
0
        /**
         * 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));
        }
Exemple #3
0
        /// <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);
        }
Exemple #4
0
 protected Gost34310KeyParameters(
     bool isPrivate,
     Gost3410Parameters parameters)
     : base(isPrivate)
 {
     this.parameters = parameters;
 }
Exemple #5
0
        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));
        }
Exemple #6
0
        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));
        }
Exemple #7
0
        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)));
        }
Exemple #8
0
        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));
        }
Exemple #11
0
 protected Gost34310KeyParameters(
     bool isPrivate,
     DerObjectIdentifier publicKeyParamSet)
     : base(isPrivate)
 {
     this.parameters        = LookupParameters(publicKeyParamSet);
     this.publicKeyParamSet = publicKeyParamSet;
 }
Exemple #12
0
 protected bool Equals(Gost3410Parameters other)
 {
     if (p.Equals(other.p) && q.Equals(other.q))
     {
         return(a.Equals(other.a));
     }
     return(false);
 }
Exemple #13
0
 /// <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;
 }
Exemple #15
0
        // Шифрование тестового файла.
        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;
 }
Exemple #17
0
        /// <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());
        }
Exemple #18
0
        /// <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);
        }
Exemple #19
0
        // Расшифрование тестового файла.
        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);
                        }
                    }
                }
            }
        }
Exemple #20
0
        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);
                        }
                    }
                }
            }
        }
Exemple #21
0
    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)));
        }
Exemple #23
0
        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);
        }
Exemple #25
0
        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 });
        }
Exemple #26
0
        /**
         * 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)));
    }
Exemple #28
0
        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
            });
        }
Exemple #29
0
        /// <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));
        }