C# RSACryptoServiceProvider.SignHash方法代码示例

        private void Sign(string filename)
        {
            try
            {
                string p = @"<RSAKeyValue><Modulus>wJqUfZ3Iry4fV6p1bjO817u2/HE1zCmsnguE0Of+1Dzzcc+L3psx1PsDmXlxcLU9E4+ndbIacC2XMWlrIaLSikIJgfMwuvBej18HrrNATpKHwprUpRMU3P9ug5iemz0pyHA3Nr+keCU/b/HsFmido6R1cuBSDd6RYtlK1Xx+KlU=</Modulus><Exponent>AQAB</Exponent><P>+37HaPakQZN5GKh7Jf8a4b/3kqHIynsd0CYVNN0ax3qqRneEdyhfC2CzJGjv6UPOyAXZHn/T8kWpcSfLbqMlqw==</P><Q>xA3Byhq3RTP4YJYBdri/AZMBpRTiV+xSKi1XLz9m0QsNE5ctuwhbD3wY3YlMdIAbOAVewrxjTJg336z2JHPv/w==</Q><DP>VPgKa14ZNMacfUY/BSFhdbAj9viOHEroUbDsLUYejBLXgKNUr+WF5xQusjh6BfeQ32eKaZGKjCoZC1AEnUalrQ==</DP><DQ>BDAnC6I2eAv8KlQKA/c+XVI+nsArdaVeu/fr/N5l2+FYjiqUl4I+L75+6XydXX+/FRtIQvCzTleSGf0f5Pd1EQ==</DQ><InverseQ>xwGNcideNnj6XrDwLFSv3y7CMq2vMzuYxaObaNTU9sh1PTKVMRpiwdKWKpwnstXmDaSduBVw4EvfNlaz+SzUuw==</InverseQ><D>AJc4x13ZhLgGfpVWQN1Fwf+gYwvR12t1TRLJ+H4NqQb61CmHy0n8kCOo8iqOL4NOyaWSJOlD7X4mTY9+NZ8zOBn2Wij0r606Omw+/rlU986lwcxdBiw3y/LND3gowf1gR3Ei9K0eYsHTZZ9Ry9pmqowXi1DG916MBWSuwAbiOw0=</D></RSAKeyValue>";
                RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
                rsa.FromXmlString(p);

                FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite, FileShare.None);

                SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
                byte[] hash = sha1.ComputeHash(fs);

                byte[] b = rsa.SignHash(hash, CryptoConfig.MapNameToOID("SHA1"));
                fs.Close();

                FileInfo fi = new FileInfo(filename);
                fi.CopyTo(filename + ".p1s", true);
                FileStream fo = new FileStream(filename + ".p1s", FileMode.Append, FileAccess.Write, FileShare.None);
                fo.Write(b, 0, b.Length);
                fo.Close();

                MessageBox.Show(filename + ".p1s is successfully created.");
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }

        private readonly static RSAParameters PrivateParams = Rsa.ExportParameters(true); //Complete key pairs.

        /// <summary>
        /// Encrypt an input string 
        /// </summary>
        /// <param name="input">the input string to be encrpty</param>
        /// <param name="signature">the private key signature</param>
        /// <returns>A Base 64 encrypted string or empty if can't encrpyt</returns>
        public static string Encrpyt(string input, out byte[] signature)
        {
            signature = null;
            try
            {
                if (string.IsNullOrEmpty(input)) return string.Empty;
                var provider = new RSACryptoServiceProvider(new CspParameters { Flags = CspProviderFlags.UseMachineKeyStore });
                provider.ImportParameters(PublicParams);

                var buffer = Encoding.ASCII.GetBytes(input);
                var encryptedbuffer = provider.Encrypt(buffer, false);

                var hash = new SHA1Managed();
                provider.ImportParameters(PrivateParams);
                var hashedData = hash.ComputeHash(encryptedbuffer);
                signature = provider.SignHash(hashedData, CryptoConfig.MapNameToOID("SHA1"));

                var stringBuilder = new StringBuilder();
                stringBuilder.Append(Convert.ToBase64String(encryptedbuffer));

                return stringBuilder.ToString();
            }
            catch
            {
                return string.Empty;
            }
        }

 // Hash and sign the data
 public byte[] HashAndSign(byte[] encryptedData)
 {
     RSACryptoServiceProvider rsaCSP = new RSACryptoServiceProvider();
     rsaCSP.ImportParameters(PrivateKeyInfo);
     SHA1Managed hash = new SHA1Managed();
     byte[] hashedData = hash.ComputeHash(encryptedData);
     return rsaCSP.SignHash(hashedData, CryptoConfig.MapNameToOID("SHA1"));
 }

 /// <summary>
 /// Sings a string with the full (private) RSA key provided as XML.
 /// </summary>
 public static string Sign(string inputString, string keyXml)
 {
     byte[] hash = generateHash(inputString);
     using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
     {
         rsa.FromXmlString(keyXml);
         byte[] sig = rsa.SignHash(hash, CryptoConfig.MapNameToOID("SHA1"));
         return byteArrayToHexString(sig);
     }
 }

 /// <summary>
 ///     Takes a string and creates a signed hash of it
 /// </summary>
 /// <param name="input">Input string</param>
 /// <param name="key">Key to encrypt/sign with</param>
 /// <param name="hash">This will be filled with the unsigned hash</param>
 /// <param name="encodingUsing">Encoding that the input is using (defaults to UTF8)</param>
 /// <returns>A signed hash of the input (64bit string)</returns>
 public static string SignHash(string input, string key, out string hash, Encoding encodingUsing = null)
 {
     Guard.NotEmpty(input, "input");
     Guard.NotEmpty(key, "key");
     using (var rsa = new RSACryptoServiceProvider())
     {
         rsa.FromXmlString(key);
         byte[] hashBytes = input.ToByteArray(encodingUsing).Hash();
         byte[] signedHash = rsa.SignHash(hashBytes, CryptoConfig.MapNameToOID("SHA1"));
         rsa.Clear();
         hash = hashBytes.ToBase64String();
         return signedHash.ToBase64String();
     }
 }

        public void AllowUpdateIfIDontRequireChecksum()
        {
            const string NauUpdateFeed =
                @"<?xml version=""1.0"" encoding=""utf-8""?>
            <Feed RSASignature=""SIGNATURE"">
              <Title>My application</Title>
              <Link>http://myapp.com/</Link>
              <Tasks>
            <FileUpdateTask sha256-checksum=""invalidhashButWeCanNotKnowThatNow"" localPath=""test.dll"" updateTo=""remoteFile.dll"" hotswap=""true"">
              <Description>update details</Description>
            </FileUpdateTask>
            <RegistryTask keyName=""asdf"" keyValue=""zsdfgafsdg"" valueKind=""String"">
            </RegistryTask>
              </Tasks>
            </Feed>";
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(NauUpdateFeed);

            // Support for different feed versions
            XmlNode root = doc.SelectSingleNode(@"/Feed[version=""1.0""] | /Feed") ?? doc;

            SHA512Managed sha = new SHA512Managed();
            var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(root.InnerXml));

            RSACryptoServiceProvider provider = new RSACryptoServiceProvider(1024);
            provider.PersistKeyInCsp = false;
            var pubKey = provider.ToXmlString(false);

            var sigBytes = provider.SignHash(hash, "sha512");
            var sig = Convert.ToBase64String(sigBytes);

            var update = NauUpdateFeed.Replace("SIGNATURE", sig);

            bool isVerified = provider.VerifyHash(hash, "sha512", Convert.FromBase64String(sig));
            Assert.IsTrue(isVerified);

            var reader = new NAppUpdate.Framework.FeedReaders.NauXmlFeedReaderSigned();
            reader.PublicKeys = new string[] { pubKey };

            IList<IUpdateTask> updates = reader.Read(update);
            Assert.IsTrue(updates != null && updates.Count == 2);
        }

    /// <summary>Create a new revocation message.</summary>
    public UserRevocationMessage(RSACryptoServiceProvider private_key, string username)
    {
      Username = username;
      int signature_length = private_key.KeySize / 8;
      byte[] data = null;

      using(MemoryStream ms = new MemoryStream()) {
        AdrConverter.Serialize(Username, ms);
        Random rand = new Random();
        NumberSerializer.WriteInt(rand.Next(), ms);
        NumberSerializer.WriteLong(DateTime.UtcNow.Ticks, ms);
        data = new byte[ms.Length + signature_length];
        ms.Position = 0;
        ms.Read(data, 0, (int) ms.Length);
      }

      SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
      Hash = sha1.ComputeHash(data, 0, data.Length - signature_length);
      Signature = private_key.SignHash(Hash, CryptoConfig.MapNameToOID("SHA1"));
      Signature.CopyTo(data, data.Length - signature_length);
      _data = MemBlock.Reference(data);
    }

        static public Byte[] RSASign(Byte[] hash, String private_key)
        {
            try
            {
                byte[] signed;
                // Erstellen einer Instanz des CryptoServiceProviders
                using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
                {
                    // Importieren der Schlüssel
                    RSA.FromXmlString(private_key);

                    // Verschlüsseln.
                    signed = RSA.SignHash(hash, CryptoConfig.MapNameToOID("SHA1"));
                }
                return signed;
            }
            catch (CryptographicException e)
            {
                Console.WriteLine(e.ToString());
                return null;
            }
        }

        public static string CreateCertificateSignature(HttpWebRequest request, DigiUser user)
        {
            var s = request.Method.ToUpper() + "\n" +
                    request.RequestUri.AbsolutePath.ToLower() + "\n" +
                    "content-md5: " + request.Headers["Content-MD5"] + "\n" +
                    "date: " + request.Date.ToUniversalTime().ToString("r") + "\n" +
                    "x-digipost-userid: " + request.Headers["X-Digipost-UserId"] + "\n" +
                    HttpUtility.UrlEncode(request.RequestUri.Query).ToLower() + "\n";

            var rsa = user.Certificate.PrivateKey as RSACryptoServiceProvider;

            if (rsa == null) return null;

            var privateKeyBlob = rsa.ExportCspBlob(true);
            var rsa2 = new RSACryptoServiceProvider();
            rsa2.ImportCspBlob(privateKeyBlob);

            var sha = SHA256.Create();
            var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(s));
            var signature = rsa2.SignHash(hash, CryptoConfig.MapNameToOID("SHA256"));

            return Convert.ToBase64String(signature);
        }

        /// <summary>
        /// Signs given hash with provided key.
        /// </summary>
        /// <param name="hash">hash to sign</param>
        /// <param name="privateKey">private key</param>
        /// <returns>Signed hash (string in base64 form)</returns>
        public string SignHash(byte[] hash, byte[] privateKey)
        {
            byte[] signedBytes;

            using (var RSA = new RSACryptoServiceProvider())
            {
                // do not store key info into persistent storage of CSP
                RSA.PersistKeyInCsp = false;

                try
                {
                    RSA.ImportCspBlob(privateKey);
                    signedBytes = RSA.SignHash(hash, CryptoConfig.MapNameToOID("SHA256"));
                }
                catch (CryptographicException e)
                {
                    Debug.Fail(e.Message);
                    return null;
                }
                finally
                {
                    RSA.PersistKeyInCsp = false;
                }
            }
            return Convert.ToBase64String(signedBytes);
        }

 /// <summary>
 /// Takes a string and creates a signed hash of it
 /// </summary>
 /// <param name="Input">Input string</param>
 /// <param name="Key">Key to encrypt/sign with</param>
 /// <param name="Hash">This will be filled with the unsigned hash</param>
 /// <param name="EncodingUsing">Encoding that the input is using (defaults to UTF8)</param>
 /// <returns>A signed hash of the input (64bit string)</returns>
 public override string SignHash(string Input, string Key, out string Hash, Encoding EncodingUsing = null)
 {
     Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(Key), "Key");
     Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(Input), "Input");
     using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
     {
         RSA.FromXmlString(Key);
         byte[] HashBytes = Input.ToByteArray(EncodingUsing).Hash();
         byte[] SignedHash = RSA.SignHash(HashBytes, CryptoConfig.MapNameToOID("SHA1"));
         RSA.Clear();
         Hash = HashBytes.ToString(Base64FormattingOptions.None);
         return SignedHash.ToString(Base64FormattingOptions.None);
     }
 }

 /// <summary>
 /// Takes a string and creates a signed hash of it
 /// </summary>
 /// <param name="Input">Input string</param>
 /// <param name="Key">Key to encrypt/sign with</param>
 /// <param name="Hash">This will be filled with the unsigned hash</param>
 /// <param name="EncodingUsing">Encoding that the input is using (defaults to UTF8)</param>
 /// <returns>A signed hash of the input (64bit string)</returns>
 public static string SignHash(string Input, string Key, out string Hash, Encoding EncodingUsing = null)
 {
     Input.ThrowIfNullOrEmpty("Input");
     Key.ThrowIfNullOrEmpty("Key");
     using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
     {
         RSA.FromXmlString(Key);
         byte[] HashBytes = Input.ToByteArray(EncodingUsing).Hash();
         byte[] SignedHash = RSA.SignHash(HashBytes, CryptoConfig.MapNameToOID("SHA1"));
         RSA.Clear();
         Hash = HashBytes.ToBase64String();
         return SignedHash.ToBase64String();
     }
 }

        public MFTestResults RsaTest_Signature()
        {
            bool testResult = false;

            try
            {
                using (RSACryptoServiceProvider csp = new RSACryptoServiceProvider())
                {
                    string dataToSign = "This is a simple message to be encrypted";

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

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

                    testResult = csp.VerifyData(data, null, signature);

                    HashAlgorithm sha = new HashAlgorithm(HashAlgorithmType.SHA1, csp.Session);

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

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

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

 /// <summary>
 ///		Sign with only public key
 /// </summary>
 private static void CspSignPublic()
 {
     using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
     {
         rsa.KeyPair = CryptoKey.CreateObject(rsa.Session, m_importKeyPublic) as CryptoKey;
         rsa.SignHash(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, Cryptoki.MechanismType.SHA_1);
     }
     return;
 }

 /// <summary>
 ///		Sign null hash
 /// </summary>
 private static void CspSignNullHash()
 {
     using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
     {
         rsa.SignHash((byte[])null, Cryptoki.MechanismType.SHA_1);
     }
 }