C# RSAPKCS1SignatureDeformatter.SetKey方法代码示例

		public void SetNullKey ()
		{
			RSAPKCS1SignatureDeformatter fmt = new RSAPKCS1SignatureDeformatter ();
			fmt.SetKey (null);
		}

		private RSAPKCS1SignatureDeformatter GetDefaultDeformatter (string hashName) 
		{
			// no need for the private key 
			RSA rsa = RSA.Create ();
			rsa.ImportParameters (AllTests.GetRsaKey (false));

			RSAPKCS1SignatureDeformatter fmt = new RSAPKCS1SignatureDeformatter ();
			fmt.SetKey (rsa);
			fmt.SetHashAlgorithm (hashName);
			return fmt;
		}

		public void SetDSAKey () 
		{
			RSAPKCS1SignatureDeformatter fmt = new RSAPKCS1SignatureDeformatter ();
			fmt.SetKey (dsa);
		}

		public void VerifySignatureNullSignature ()
		{
			RSAPKCS1SignatureDeformatter fmt = new RSAPKCS1SignatureDeformatter ();
			fmt.SetHashAlgorithm ("SHA1");
			fmt.SetKey (rsa);
			byte[] hash = new byte [20];
			fmt.VerifySignature (hash, null);
		}

		public void VerifySignatureWithBadHash () 
		{
			RSAPKCS1SignatureDeformatter fmt = new RSAPKCS1SignatureDeformatter ();
			fmt.SetKey (rsa);
			// no hash algorithm
			byte[] hash = new byte [1];
			byte[] signature = new byte [1];
			fmt.VerifySignature (hash, signature);
		}

		public void VerifySignatureNullHash () 
		{
			RSAPKCS1SignatureDeformatter fmt = new RSAPKCS1SignatureDeformatter ();
			fmt.SetHashAlgorithm ("SHA1");
			fmt.SetKey (rsa);
			byte[] hash = null;
			byte[] signature = new byte [128];
			fmt.VerifySignature (hash, signature);
		}

        private bool verify(byte[] signature, byte[] message)
        {
            if (certificate.PublicKey == null)
            {
                throw new Exception("a public key is required " +
                                    " OAuthConsumer.setProperty when " +
                                    "verifying RSA-SHA1 signatures.");
            }

            using (HashAlgorithm hasher = HashAlgorithm.Create("SHA1"))
            {
                RSAPKCS1SignatureDeformatter signatureDeformatter = new RSAPKCS1SignatureDeformatter(certificate.PrivateKey);
                signatureDeformatter.SetKey(certificate.PublicKey.Key);
                signatureDeformatter.SetHashAlgorithm("SHA1");
                byte[] hash = hasher.ComputeHash(message);
                return signatureDeformatter.VerifySignature(hash, signature);
            }
        }

        /// <summary>
        /// Confirms the validity of the OAuth request signature.
        /// </summary>
        /// <param name="uri">URI of the resource.</param>
        /// <param name="httpMethod">Request method.</param>
        /// <param name="arguments">Request arguments.</param>
        /// <param name="consumerSecret">Consumer secret.</param>
        /// <param name="tokenSecret">Token secret.</param>
        /// <param name="rsaCert">For RSA-SHA1 signing, the X509 certificate containing the public key used to verify the signature.</param>
        /// <returns>True if the signature is valid, false if not.</returns>
        static bool IsValidSignature(Uri uri, string httpMethod, NameValueCollection arguments, string consumerSecret, string tokenSecret, X509Certificate2 rsaCert)
        {
            NameValueCollection args = new NameValueCollection(arguments);
            string receivedsig = args[OAuthArguments.OAuthSignature];
            args.Remove(OAuthArguments.OAuthSignature);
            string sigMethod = args[OAuthArguments.OAuthSignatureMethod];
            args.Remove(Strings.Realm);

            string basestring = OAuthUtility.GenerateBaseString(uri, args, httpMethod);
            if (OAuthUtility.StringToSigMethod(sigMethod) == SignatureMethod.RsaSha1)
            {
                RSAPKCS1SignatureDeformatter verifier = new RSAPKCS1SignatureDeformatter();
                verifier.SetKey(rsaCert.PublicKey.Key);
                verifier.SetHashAlgorithm("SHA1");
                byte[] input = Encoding.UTF8.GetBytes(basestring);
                byte[] hash = SHA1.Create().ComputeHash(input);
                byte[] sig = Convert.FromBase64String(receivedsig);
                return verifier.VerifySignature(hash, sig);
            }
            else
            {
                string calcsig = OAuthUtility.GenerateSignature(basestring, consumerSecret, tokenSecret, null, OAuthUtility.StringToSigMethod(sigMethod));
                if (receivedsig == calcsig) { return true; }
            }
            return false;
        }

		/// <summary>
		/// Validiert einen signierten String
		/// </summary>
		/// <param name="textToValidate">Der unsignierte Text welcher mit der Signatur überprüft werden soll.</param>
		/// <param name="signToValidate">Die Signatur des Textes.</param>
		/// <param name="publicKey">Der öffentliche Schlüssel.</param>
		/// <returns></returns>
		public static bool validateSign(string textToValidate, string signToValidate, string publicKey) {
			//Initialisieren der Provider
			var rsacryptoprov = new RSACryptoServiceProvider();
			var rsaDeFormatter = new RSAPKCS1SignatureDeformatter(rsacryptoprov);
			System.Security.Cryptography.RSA rsa = System.Security.Cryptography.RSA.Create();
			var sha1 = new SHA1Managed();
			var encoding = new ASCIIEncoding();

			//Zuweisen des Hashalgorithmus und des öffentlichen Schlüssels
			rsaDeFormatter.SetHashAlgorithm("SHA1");
			rsa.FromXmlString(publicKey);
			rsaDeFormatter.SetKey(rsa);

			//String nach Byte[]
			byte[] hashed_value = encoding.GetBytes(textToValidate);
			byte[] signed_value = Convert.FromBase64String(signToValidate);

			//Signatur validieren und wert zurückgeben true/false
			return rsaDeFormatter.VerifySignature(sha1.ComputeHash(hashed_value), signed_value);
		}

        /// <summary>
        /// Verify a signature.
        /// Throws only on unexpected failures.
        /// </summary>
        /// <param name="data">Data, utf8</param>
        /// <param name="signature">Signature, base64</param>
        /// <returns>True or false (or throws)</returns>
        public static bool Verify(string data, string signature)
        {
            // Construct the cert
            byte[] certdata = new System.Text.ASCIIEncoding().GetBytes(CERT);
            byte[] rawdata = Encoding.UTF8.GetBytes(data);

            // Compute hash of the raw data.
            SHA1 sha = new SHA1CryptoServiceProvider();
            byte[] contenthash = sha.ComputeHash(rawdata);

            // Base64-decode the signature
            int sl = (signature.Length % 4);
            if(sl>0)
            for (int j = 0; j < 4-sl; j++) { signature += "="; }
            byte[] sigdata = Convert.FromBase64String(signature);

            bool ok = false;
            X509Certificate2 cert = new X509Certificate2(certdata);
            RSAPKCS1SignatureDeformatter RSADeformatter = new RSAPKCS1SignatureDeformatter();
            RSADeformatter.SetHashAlgorithm("SHA1");
            RSADeformatter.SetKey(cert.PublicKey.Key);
            ok=RSADeformatter.VerifySignature(contenthash, sigdata);
            return ok;
        }