C# DSACryptoServiceProvider.VerifyHash方法代码示例

        public static Boolean Test(Session session)
        {
            Boolean bRes = true;
            //String xml1, xml2, xml3;
            //String sign1, sign2, sign3;
            byte[] hashval = new byte[20];
            for (int i = 0; i < hashval.Length; i++) hashval[i] = (Byte)i;

            DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider(session);
            DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider(session);
            //DSACryptoServiceProvider dsa3 = new DSACryptoServiceProvider(session);

            DSAParameters dsaParams = dsa1.ExportParameters(true);

            byte[] sig1 = dsa1.SignHash(hashval, MechanismType.SHA_1);

            //sign1 = (Convert.ToBase64String(sig1));

            //xml1 = dsa1.ToXmlString(true);


            dsa2.ImportParameters(dsaParams);
            //dsa2.FromXmlString(xml1);

            //xml2 = (dsa2.ToXmlString(true));
            //xml3 = (dsa3.ToXmlString(true));

            byte[] sig2 = dsa2.SignHash(hashval, MechanismType.SHA_1);
            //sign2 = (Convert.ToBase64String(sig2));

            //dsa3.HashAlgorithm = MechanismType.SHA_1;
            //byte[] sig3 = dsa3.SignHash(hashval);
            //sign3 = (Convert.ToBase64String(sig3));

            //if ((xml1 != xml2) || (xml2 != xml3))
            //{
            //    Log.Comment("WRONG : ToXmlString results are different");
            //    Log.Comment("XML1:\n" + xml1);
            //    Log.Comment("XML2:\n" + xml2);
            //    Log.Comment("XML3:\n" + xml3);
            //    bRes = false;
            //}

            //Log.Comment(xml1);

            /*        if ( (sign1!=sign2) || (sign2!=sign3) ) {
                        Log.Comment("WRONG : signatures are different");
                        Log.Comment("First: " + sign1);
                        Log.Comment("Second: " + sign2);
                        Log.Comment("Third: " + sign3);
        	
                        bRes = false;
                    } */

            //Log.Comment("\n" + sign1);

            if (!dsa1.VerifyHash(hashval, MechanismType.SHA_1, sig2))
            {
                Log.Comment("WRONG : Signature check (1) failed");
                bRes = false;
            }
            if (!dsa2.VerifyHash(hashval, MechanismType.SHA_1, sig1))
            {
                Log.Comment("WRONG : Signature check (1) failed");
                bRes = false;
            }
            //if (!dsa3.VerifyHash(hashval, sig1))
            //{
            //    Log.Comment("WRONG : Signature check (1) failed");
            //    bRes = false;
            //}

            return bRes;
        }

        MFTestResults TestSignature(DSACryptoServiceProvider csp, HashAlgorithm hashAlg)
        {
            bool testResult = false;

            try
            {
                string dataToSign = "This is a simple message to be encrypted";

                byte[] data = System.Text.UTF8Encoding.UTF8.GetBytes(dataToSign);

                byte[] signature = csp.SignData(data);

                testResult = csp.VerifyData(data, signature);

                byte[] hash = hashAlg.ComputeHash(data);

                signature = csp.SignHash(hash, hashAlg.HashType);
                testResult &= csp.VerifyHash(hash, hashAlg.HashType, signature);
            }
            catch (Exception ex)
            {
                Log.Exception("Unexpected Exception", ex);
                testResult = false;
            }

            return (testResult ? MFTestResults.Pass : MFTestResults.Fail);
        }

 /// <summary>
 ///		Verify signature of bad hash
 /// </summary>
 private static void CSPVerifyBadHash()
 {
     using (DSACryptoServiceProvider dsa = new DSACryptoServiceProvider())
     {
         dsa.VerifyHash(new byte[0], MechanismType.SHA_1, new byte[] { 0, 1, 2, 3, 4, 5 });
     }
 }

 /// <summary>
 ///		Verify null hash
 /// </summary>
 private static void CSPVerifyNullHash()
 {
     using (DSACryptoServiceProvider dsa = new DSACryptoServiceProvider())
     {
         dsa.VerifyHash(null, MechanismType.SHA_1, new byte[] { 0, 1, 2 });
     }
 }

        //Верифицируем - проверяем документ
        private void button7_Click(object sender, EventArgs e)
        {
            // создаем объект выбранного заказа
            // определяем, выбран ли хотя бы один заказ
            if (dataGridView1.SelectedRows.Count == 0)
                return;
            else
            {

                //получение номера текущего выбранного заказа
                nom = (int)dataGridView1.SelectedRows[0].Cells["НомерЗаказа"].Value;
                // проверка, имеется ли цифровая подпись выбранного чека, 
                // т.е. имеется ли соответствующий файл
                if (!File.Exists("Zakaz" + nom + ".dat"))
                {
                    MessageBox.Show("Ещё не создана цифровая подпись!");
                    return;
                }
                else
                {
                    // создаем объект выбранного заказа аналогично предыдущей функции 
                    // (объект с класса Zakaz)
                    MessageBox.Show(nom.ToString());
                    //получение номера текущего выбранного заказа
                    date = (DateTime)dataGridView1.SelectedRows[0].Cells["ДатаЗаказа"].Value;
                    // поиск заказа по ключу
                    DataRow dr = ds.Tables["Заказы"].Rows.Find(new object[] { (object)nom, (object)date });
                    // создаем объект заказа для последующей сериализации
                    Zakaz c = new Zakaz((int)dr["IDЗаказчика"], (int)dr["IDИсполнителя"], (int)dr["НомерЗаказа"], (DateTime)dr["ДатаЗаказа"], (string)dr["Предмет/Тема"], (int)dr["Стоимость"]);

                    // проводим генерацию хэш-значения для объекта c
                    // бинарная сериализация объекта для формирования цифровой подписи
                    BinaryFormatter ser = new BinaryFormatter();
                    // создаем поток для сериализации объекта в оперативной памяти
                    MemoryStream ms = new MemoryStream();
                    ser.Serialize(ms, c);

                    // получаем массив байт, определяющий объект чека
                    byte[] message = new byte[ms.Length];
                    ms.Read(message, 0, (int)ms.Length);

                    // создаем провайдер для хэширования
                    SHA1 sha1 = new SHA1CryptoServiceProvider();
                    // проводим хэширование
                    byte[] hashMessage = sha1.ComputeHash(message);

                    // работа с цифровой подписью - считываем подпись и 
                    // ключ из файла и осуществляем верификацию
                    // читаем данные из файла-подписи
                    BinaryReader br = new BinaryReader(new FileStream("Zakaz" + nom + ".dat", FileMode.Open));

                    // читаем ключ для шифрования
                    string key = br.ReadString();
                    // читаем данные подписи
                    int n_sign = br.ReadInt32();
                    byte[] b_sign = br.ReadBytes(n_sign);
                    br.Close();

                    // импортируем параметры в провайдер шифрования
                    DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
                    dsa.FromXmlString(key);

                    // проводим верификацию подписей
                    // первый параметр - сгенерированный хэш объекта
                    // второй параметр - ключ
                    // третий параметр - цифровая подпись
                    if (dsa.VerifyHash(hashMessage, "1.3.14.3.2.26", b_sign))
                    {
                        MessageBox.Show("Успешная верификация!");
                    }
                    else
                    {
                        MessageBox.Show("Заказ был изменен. Ошибка верификации!");
                    }
                }
            }
        }

        // -------------------------------------------------------------------------------
        /// <summary>
        /// SignedDecrypt the ciphertext.
        /// </summary>
        /// <param name="ciphertext">The ciphertext to be decrypted.</param>
        /// <param name="compressStreamReader">A StreamReader for the uncompressing the stream</param>
        /// <returns>The decrypted ciphertext (-> plaintext).</returns>
        private byte[] SignedDecrypt(byte[] ciphertext, CompressStreamReaderDelegate compressStreamReader)
        {
            byte[] plaintext = null;

            MemoryStream memoryStream = new MemoryStream(ciphertext);

            // get the initialization vector
            BinaryFormatter formatter = new BinaryFormatter();
            byte[] IV = formatter.Deserialize(memoryStream) as byte[];

            // get signature and DSA parameters
            byte[] signature = formatter.Deserialize(memoryStream) as byte[];
            DSAParameters dsaParameters = (DSAParameters) formatter.Deserialize(memoryStream);
            DSACryptoServiceProvider dsaVerifier = new DSACryptoServiceProvider();
            dsaVerifier.ImportParameters(dsaParameters);

            //Creates the default implementation, which is RijndaelManaged.
            SymmetricAlgorithm rijn = SymmetricAlgorithm.Create();
            // creates a symmetric decryptor object with the specified Key and initialization vector (IV).
            ICryptoTransform decryptor = rijn.CreateDecryptor(this.key, IV);

            // prepare the Crypto Stream
            CryptoStream encryptedData = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);

            MemoryStream plainData = null;

            if (compressStreamReader != null)
            {
                // decrypt ciphertext
                MemoryStream decryptedData = this.GetBytes(encryptedData);
                decryptedData.Position = 0;

                // decompress ciphertext
                using (Stream sr = compressStreamReader(decryptedData))
                {
                    plainData = this.GetBytes(sr);
                    sr.Close();
                }
                plainData.Position = 0;
            }
            else
            {
                // decrypt ciphertext
                plainData = this.GetBytes(encryptedData);
                plainData.Position = 0;
            }

            // Check Digital signature
            SHA1 sha1Provider = new SHA1CryptoServiceProvider();
            byte[] hashbytes = sha1Provider.ComputeHash(plainData);
            if(!dsaVerifier.VerifyHash(hashbytes, CryptoConfig.MapNameToOID(SHA1), signature))
            {
                throw new Exception("OlympCryptography.SignedDecrypt: Invalid digital signature - data manipulated!");
            }

            plaintext = plainData.ToArray();

            return plaintext;
        }