C# DSACryptoServiceProvider.SignHash方法代码示例

        void Sign(String[] args)
        {
            if (args.Length != 1)
            {
                Usage();
                return;
            }

            try
            {
                String productCode = args[0];
                byte[] pcode = StringUtils.Str2Bytes(productCode);
                for (int i = 0; i < 1; ++i)
                {
                    DSAParameters dsap = CryptographyParams.DSAP;
                    dsap.X = X;
                    DSACryptoServiceProvider dsa = new DSACryptoServiceProvider(512);
                    dsa.ImportParameters(dsap);
                    String oid = CryptoConfig.MapNameToOID(LicensingStrings.SHA1);
                    byte[] acode = dsa.SignHash(pcode, oid);
                    String activationCode = StringUtils.Bytes2Str(acode);
                    System.Console.Out.WriteLine(activationCode);
                }
            }
            catch (Exception e)
            {
                System.Console.Out.WriteLine("Error: {0}\n", e.Message);
            }
        }

        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>
 ///		Sign with wrong hash count
 /// </summary>
 private static void CSPSignBadHashCount()
 {
     using (DSACryptoServiceProvider dsa = new DSACryptoServiceProvider())
     {
         dsa.SignHash(new byte[0], MechanismType.SHA_1); // "SHA1");
     }
 }

 /// <summary>
 ///		Sign null hash
 /// </summary>
 private static void CSPSignNullHash()
 {
     using (DSACryptoServiceProvider dsa = new DSACryptoServiceProvider())
     {
         dsa.SignHash(null, MechanismType.SHA_1);
     }
 }

        //Формируем цифровую подпись
        private void button8_Click(object sender, EventArgs e)
        {
            // создаем объект выбранного заказа
            // как и в примере из предыдущего раздела
	        // В результате имеем заполненный объект класса Заказ с именем с
            // определяем, какой заказ следует сериализовать
            // код создания объекта (Zakaz c) аналогичен предыдущему примеру

            // определяем, какой заказ выбран для генерации документа
            if (dataGridView1.SelectedRows.Count == 0)
                return;
            //получение номера текущего выбранного заказа
            nom = (int)dataGridView1.SelectedRows[0].Cells["НомерЗаказа"].Value;
            //получение даты текущего выбранного заказа
            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["Стоимость"]);
            
            // хэшировать будем по двоичному коду объекта класса Zakaz  
            // проводим бинарную сериализацию объекта 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);

            // получаем цифровую подпись с помощью алгоритма DSA
             DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();
            // цифровая подпись – это также набор байт. 
            // Второй параметр метода – своеобразный ключ
            byte[] signature = dsa.SignHash(hashMessage, "1.3.14.3.2.26");

            // сохраняем параметры ключа в виде структурированной строки
            string key = dsa.ToXmlString(true);
            
            // сохраним подпись данного документа в бинарном файле, 
            // имя которого зависит от номера Заказа
            BinaryWriter br = new BinaryWriter(new FileStream("Zakaz"+c.НомерЗаказа+".dat", FileMode.Create));
            // сохраняем ключ в созданный файл
            br.Write(key);
            // сохраняем в файл цифровую подпись
            // сначала количество байт
            br.Write(signature.Length);
            // затем саму подпись
            br.Write(signature);
            // закрываем файл с подписью
            br.Close();
            MessageBox.Show("Создана цифровая подпись!");
        }

        // -------------------------------------------------------------------------------
        /// <summary>
        /// SignedEncrypts the plaintext.
        /// </summary>
        /// <param name="plaintext">The plaintext to be encrypted.</param>
        /// <param name="compressStreamWriter">A StreamWriter for the compressing the stream</param>
        /// <returns>The encrypted plaintext (-> ciphertext).</returns>
        private byte[] SignedEncrypt(byte[] plaintext, CompressStreamWriterDelegate compressStreamWriter)
        {
            byte[] ciphertext = null;

            MemoryStream memoryStream = new MemoryStream();
            byte[] IV = new byte[16];

            //Creates the default implementation, which is RijndaelManaged.
            SymmetricAlgorithm rijn = SymmetricAlgorithm.Create();

            //RNGCryptoServiceProvider is an implementation of a random number generator.
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            // The array is now filled with cryptographically strong random bytes, and none are zero.
            rng.GetNonZeroBytes(IV);

            // creates a symmetric encryptor object with the specified Key and initialization vector (IV).
            ICryptoTransform encryptor = rijn.CreateEncryptor(this.key, IV);

            // write the unencrypted initialization vector
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(memoryStream, IV);

            // write the digital signature and the DSA parameters
            SHA1 sha1Provider = new SHA1CryptoServiceProvider();
            DSACryptoServiceProvider dsaProvider = new DSACryptoServiceProvider();
            byte[] hashbytes = sha1Provider.ComputeHash(plaintext);
            byte[] signature = dsaProvider.SignHash(hashbytes, CryptoConfig.MapNameToOID(SHA1));
            formatter.Serialize(memoryStream, signature);

            // very important !!!!
            // only the public key is serialized -> false as argument to ExportParameters.
            formatter.Serialize(memoryStream, dsaProvider.ExportParameters(false));

            if (compressStreamWriter != null)
            {
                // write plaintext into compressed and encrypted stream
                MemoryStream compressedStream = new MemoryStream();
                using (Stream sw = compressStreamWriter(compressedStream))
                {
                    sw.Write(plaintext, 0, plaintext.Length);
                    sw.Flush();
                    sw.Close();
                }

                using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                {
                    cryptoStream.Write(compressedStream.ToArray(), 0, compressedStream.ToArray().Length);
                    cryptoStream.Flush();
                    cryptoStream.Close();
                }
            }
            else
            {
                // write plaintext into encrypted stream
                using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                {
                    cryptoStream.Write(plaintext, 0, plaintext.Length);
                    cryptoStream.Flush();
                    cryptoStream.Close();
                }
            }

            ciphertext = memoryStream.ToArray();

            return ciphertext;
        }