OAuthBase.cs

using System;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Text;
using System.Web;

namespace OAuth
{
    public class OAuthBase
    {
        /// <summary>
        /// Provides a predefined set of algorithms that are supported officially by the protocol
        /// </summary>
        public enum SignatureTypes
        {
            HMACSHA1,
            PLAINTEXT,
            RSASHA1
        }

        /// <summary>
        /// Provides an internal structure to sort the query parameter
        /// </summary>
        protected class QueryParameter
        {
            private string name = null;
            private string value = null;

            public QueryParameter( string name, string value )
            {
                this.name = name;
                this.value = value;
            }

            public string Name
            {
                get { return name; }
            }

            public string Value
            {
                get { return value; }
            }
        }

        /// <summary>
        /// Comparer class used to perform the sorting of the query parameters
        /// </summary>
        protected class QueryParameterComparer : IComparer<QueryParameter>
        {

            #region IComparer<QueryParameter> Members

            public int Compare( QueryParameter x, QueryParameter y )
            {
                if ( x.Name == y.Name )
                {
                    return string.Compare( x.Value, y.Value );
                }
                else
                {
                    return string.Compare( x.Name, y.Name );
                }
            }

            #endregion
        }

        protected const string OAuthVersion = "1.0";
        protected const string OAuthParameterPrefix = "oauth_";

        //
        // List of know and used oauth parameters' names
        //        
        protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
        protected const string OAuthCallbackKey = "oauth_callback";
        protected const string OAuthVersionKey = "oauth_version";
        protected const string OAuthSignatureMethodKey = "oauth_signature_method";
        protected const string OAuthSignatureKey = "oauth_signature";
        protected const string OAuthTimestampKey = "oauth_timestamp";
        protected const string OAuthNonceKey = "oauth_nonce";
        protected const string OAuthTokenKey = "oauth_token";
        protected const string OAuthTokenSecretKey = "oauth_token_secret";

        protected const string HMACSHA1SignatureType = "HMAC-SHA1";
        protected const string PlainTextSignatureType = "PLAINTEXT";
        protected const string RSASHA1SignatureType = "RSA-SHA1";

        protected Random random = new Random();

        protected string unreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";

        /// <summary>
        /// Helper function to compute a hash value
        /// </summary>
        /// <param name="hashAlgorithm">The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function</param>
        /// <param name="data">The data to hash</param>
        /// <returns>a Base64 string of the hash value</returns>
        private string ComputeHash( HashAlgorithm hashAlgorithm, string data )
        {
            if ( hashAlgorithm == null )
            {
                throw new ArgumentNullException( "hashAlgorithm" );
            }

            if ( string.IsNullOrEmpty( data ) )
            {
                throw new ArgumentNullException( "data" );
            }

            byte[] dataBuffer = System.Text.Encoding.ASCII.GetBytes( data );
            byte[] hashBytes = hashAlgorithm.ComputeHash( dataBuffer );

            return Convert.ToBase64String( hashBytes );
        }

        /// <summary>
        /// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
        /// </summary>
        /// <param name="parameters">The query string part of the Url</param>
        /// <returns>A list of QueryParameter each containing the parameter name and value</returns>
        private List<QueryParameter> GetQueryParameters( string parameters )
        {
            if ( parameters.StartsWith( "?" ) )
            {
                parameters = parameters.Remove( 0, 1 );
            }

            List<QueryParameter> result = new List<QueryParameter>();

            if ( !string.IsNullOrEmpty( parameters ) )
            {
                string[] p = parameters.Split( '&' );
                foreach ( string s in p )
                {
                    if ( !string.IsNullOrEmpty( s ) && !s.StartsWith( OAuthParameterPrefix ) )
                    {
                        if ( s.IndexOf( '=' ) > -1 )
                        {
                            string[] temp = s.Split( '=' );
                            result.Add( new QueryParameter( temp[ 0 ], temp[ 1 ] ) );
                        }
                        else
                        {
                            result.Add( new QueryParameter( s, string.Empty ) );
                        }
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
        /// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
        /// </summary>
        /// <param name="value">The value to Url encode</param>
        /// <returns>Returns a Url encoded string</returns>
        //protected string UrlEncode( string value )
        //{
        //    StringBuilder result = new StringBuilder();

        //    foreach ( char symbol in value )
        //    {
        //        if ( unreservedChars.IndexOf( symbol ) != -1 )
        //        {
        //            result.Append( symbol );
        //        }
        //        else
        //        {
        //            result.Append( '%' + String.Format( "{0:X2}", (int)symbol ) );
        //        }
        //    }

        //    return result.ToString();
        //}
        public string UrlEncode( string value )
        {
            if ( value == null ) return null;

            var result = new StringBuilder();

            foreach ( char symbol in value )
            {
                if ( unreservedChars.IndexOf( symbol ) != -1 )
                {
                    result.Append( symbol );
                }
                else
                {
                    // This is where I changed
                    var bytesUTF8 = System.Text.Encoding.UTF8.GetBytes( symbol + "" );
                    foreach ( var b in bytesUTF8 )
                    {
                        result.Append( '%' + String.Format( "{0:X2}", b ) );
                    }
                }
            }

            return result.ToString();
        }

        /// <summary>
        /// Normalizes the request parameters according to the spec
        /// </summary>
        /// <param name="parameters">The list of parameters already sorted</param>
        /// <returns>a string representing the normalized parameters</returns>
        protected string NormalizeRequestParameters( IList<QueryParameter> parameters )
        {
            StringBuilder sb = new StringBuilder();
            QueryParameter p = null;
            for ( int i = 0; i < parameters.Count; i++ )
            {
                p = parameters[ i ];
                sb.AppendFormat( "{0}={1}", p.Name, p.Value );

                if ( i < parameters.Count - 1 )
                {
                    sb.Append( "&" );
                }
            }

            return sb.ToString();
        }

        /// <summary>
        /// Generate the signature base that is used to produce the signature
        /// </summary>
        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
        /// <param name="consumerKey">The consumer key</param>        
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuthBase.SignatureTypes">OAuthBase.SignatureTypes</see>.</param>
        /// <returns>The signature base</returns>
        public string GenerateSignatureBase( Uri url, string consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters )
        {
            if ( token == null )
            {
                token = string.Empty;
            }

            if ( tokenSecret == null )
            {
                tokenSecret = string.Empty;
            }

            if ( string.IsNullOrEmpty( consumerKey ) )
            {
                throw new ArgumentNullException( "consumerKey" );
            }

            if ( string.IsNullOrEmpty( httpMethod ) )
            {
                throw new ArgumentNullException( "httpMethod" );
            }

            if ( string.IsNullOrEmpty( signatureType ) )
            {
                throw new ArgumentNullException( "signatureType" );
            }

            normalizedUrl = null;
            normalizedRequestParameters = null;

            List<QueryParameter> parameters = GetQueryParameters( url.Query );
            parameters.Add( new QueryParameter( OAuthVersionKey, OAuthVersion ) );
            parameters.Add( new QueryParameter( OAuthNonceKey, nonce ) );
            parameters.Add( new QueryParameter( OAuthTimestampKey, timeStamp ) );
            parameters.Add( new QueryParameter( OAuthSignatureMethodKey, signatureType ) );
            parameters.Add( new QueryParameter( OAuthConsumerKeyKey, consumerKey ) );

            if ( !string.IsNullOrEmpty( token ) )
            {
                parameters.Add( new QueryParameter( OAuthTokenKey, token ) );
            }

            parameters.Sort( new QueryParameterComparer() );

            normalizedUrl = string.Format( "{0}://{1}", url.Scheme, url.Host );
            if ( !( ( url.Scheme == "http" && url.Port == 80 ) || ( url.Scheme == "https" && url.Port == 443 ) ) )
            {
                normalizedUrl += ":" + url.Port;
            }
            normalizedUrl += url.AbsolutePath;
            normalizedRequestParameters = NormalizeRequestParameters( parameters );

            StringBuilder signatureBase = new StringBuilder();
            signatureBase.AppendFormat( "{0}&", httpMethod.ToUpper() );
            signatureBase.AppendFormat( "{0}&", UrlEncode( normalizedUrl ) );
            signatureBase.AppendFormat( "{0}", UrlEncode( normalizedRequestParameters ) );

            return signatureBase.ToString();
        }

        /// <summary>
        /// Generate the signature value based on the given signature base and hash algorithm
        /// </summary>
        /// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
        /// <param name="hash">The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method</param>
        /// <returns>A base64 string of the hash value</returns>
        public string GenerateSignatureUsingHash( string signatureBase, HashAlgorithm hash )
        {
            return ComputeHash( hash, signatureBase );
        }

        /// <summary>
        /// Generates a signature using the HMAC-SHA1 algorithm
        /// </summary>		
        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
        /// <param name="consumerKey">The consumer key</param>
        /// <param name="consumerSecret">The consumer seceret</param>
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <returns>A base64 string of the hash value</returns>
        public string GenerateSignature( Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters )
        {
            return GenerateSignature( url, consumerKey, consumerSecret, token, tokenSecret, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters );
        }

        /// <summary>
        /// Generates a signature using the specified signatureType 
        /// </summary>		
        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
        /// <param name="consumerKey">The consumer key</param>
        /// <param name="consumerSecret">The consumer seceret</param>
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <param name="signatureType">The type of signature to use</param>
        /// <returns>A base64 string of the hash value</returns>
        public string GenerateSignature( Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters )
        {
            normalizedUrl = null;
            normalizedRequestParameters = null;

            switch ( signatureType )
            {
                //case SignatureTypes.PLAINTEXT:
                //    return HttpUtility.UrlEncode( string.Format( "{0}&{1}", consumerSecret, tokenSecret ) );
                case SignatureTypes.HMACSHA1:
                    string signatureBase = GenerateSignatureBase( url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters );

                    HMACSHA1 hmacsha1 = new HMACSHA1();
                    hmacsha1.Key = Encoding.ASCII.GetBytes( string.Format( "{0}&{1}", UrlEncode( consumerSecret ), string.IsNullOrEmpty( tokenSecret ) ? "" : UrlEncode( tokenSecret ) ) );

                    return GenerateSignatureUsingHash( signatureBase, hmacsha1 );
                case SignatureTypes.RSASHA1:
                    throw new NotImplementedException();
                default:
                    throw new ArgumentException( "Unknown signature type", "signatureType" );
            }
        }

        /// <summary>
        /// Generate the timestamp for the signature        
        /// </summary>
        /// <returns></returns>
        public virtual string GenerateTimeStamp()
        {
            // Default implementation of UNIX time of the current UTC time
            TimeSpan ts = DateTime.UtcNow - new DateTime( 1970, 1, 1, 0, 0, 0, 0 );
            return Convert.ToInt64( ts.TotalSeconds ).ToString();
        }

        /// <summary>
        /// Generate a nonce
        /// </summary>
        /// <returns></returns>
        public virtual string GenerateNonce()
        {
            // Just a simple implementation of a random number between 123400 and 9999999
            return random.Next( 123400, 9999999 ).ToString();
        }

    }
}

testOAuth.WebServer.cs

using System;
using System.Net.Sockets;
using System.Net;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Collections;
using System.Configuration;
using System.Web;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Collections.Specialized;
using OAuth;

namespace testOAuth
{
    public class WebServer
    {
        [STAThread]
        static void Main( string[] args )
        {
            Console.WriteLine( "Starting the server" );

            string defaultPrefix = "http://www.test.com:7677/";

            HttpListener listener = new HttpListener();
            foreach ( var arg in args )
                listener.Prefixes.Add( arg );
            if ( listener.Prefixes.Count == 0 )
                listener.Prefixes.Add( defaultPrefix );

            foreach ( var prefix in listener.Prefixes )
                Console.WriteLine( prefix );

            listener.Start();

            int count = 0;
            while ( true )
            {
                var context = listener.GetContext();
                var request = context.Request;

                // do I need it?
                request.Headers.Add( "Content-Type", "text/html; charset=utf-8" );

                try
                {
                    Console.WriteLine( "Url: " + request.Url );
                    Console.WriteLine( "RawUrl: " + request.RawUrl );
                    Console.WriteLine( "UrlReferrer: " + request.UrlReferrer );
                    Console.WriteLine( "HttpMethod: " + request.HttpMethod );
                    Console.WriteLine( "UserAgent: " + request.UserAgent );
                    Console.WriteLine( "QueryString" );
                    foreach ( var key in request.QueryString.AllKeys )
                        Console.WriteLine( "- {0}:{1}", key, request.QueryString[ key ] );
                    Console.WriteLine( "Headers" );
                    foreach ( var key in request.Headers.AllKeys )
                        Console.WriteLine( "- {0}:{1}", key, request.Headers[ key ] );

                    try
                    {
                        Console.WriteLine( "is valid=" + isValidRequest( context.Request ) + "\n\n" );
                        Console.WriteLine( "is valid2=" + isValidRequest2( context.Request ) + "\n\n" );
                        Console.WriteLine( "is valid3=" + isValidRequest3( context.Request ) + "\n\n" );
                    }
                    catch ( Exception ex )
                    {
                        Console.WriteLine( ex.ToString() );
                    }
                }
                finally
                {
                    context.Response.Close();
                }
                Console.WriteLine( "--------------------------------------------------" );
                Console.WriteLine( "processed #{0}", ++count );
            }
        }

        static Uri CleanUri( Uri uri )
        {
            // this is a fix for OpenSocial platforms sometimes appending an empty query string parameter
            // to their url.

            string originalUrl = uri.OriginalString;
            return originalUrl.EndsWith( "&" ) ? new Uri( originalUrl.Substring( 0, originalUrl.Length - 1 ) ) : uri;
        }

        public static bool isValidRequest( HttpListenerRequest request )
        {
            //If you want to import certificate file directly then uncomment the below line and comment the certificate
            //X509Certificate Cert = X509Certificate.CreateFromCertFile(htp.Request.PhysicalApplicationPath + "/bin/pub.1199819524.-1556113204990931254.cer");

            X509Certificate2 cert = new X509Certificate2();
            cert.Import( Encoding.ASCII.GetBytes(
@"-----BEGIN CERTIFICATE-----
MIICqDCCAhGgAwIBAgIJANDx5Es1s04zMA0GCSqGSIb3DQEBBQUAMG0xCzAJBgNV
BAYTAktSMQowCAYDVQQIDAEgMQowCAYDVQQHDAEgMQwwCgYDVQQKDANOSE4xEjAQ
BgNVBAsMCUNvbW11bml0eTESMBAGA1UEAwwJbmF2ZXIuY29tMRAwDgYJKoZIhvcN
AQkBFgEgMB4XDTEwMDYxNDA1MzAzNVoXDTExMDYxNDA1MzAzNVowbTELMAkGA1UE
BhMCS1IxCjAIBgNVBAgMASAxCjAIBgNVBAcMASAxDDAKBgNVBAoMA05ITjESMBAG
A1UECwwJQ29tbXVuaXR5MRIwEAYDVQQDDAluYXZlci5jb20xEDAOBgkqhkiG9w0B
CQEWASAwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANX++6LgORv6caQ8LCVh
RYTXi2Lko7zn4wPeqvdCqNZsxcry2mNHn/ic+0XbhNgor5L0l048f0iicW/Qu4vw
RvkZy2N8dNE3Tb5dbPLNo+S+cExv/DhbQVFKGiOOvr4vQ+2Lgw7If5g3sh6/S8Gu
ot47cOrUkiLKBKJt614bue9zAgMBAAGjUDBOMB0GA1UdDgQWBBSB1ReDAnl4lRyl
Rfpl0EZ13E5LzzAfBgNVHSMEGDAWgBSB1ReDAnl4lRylRfpl0EZ13E5LzzAMBgNV
HRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAEYdZfQjvk/wvlFP4l3mDqS4NMac
txx1lyYGa0gX4DGhb7aGwBb3qwCdSX7szuYNHHq5Clf9TGQMqc49RFC2TGNRrpSw
BZFRmyzhMsqx/dLcNIBLfz4B+SUw+yiwNKo3krYCJfqgNy0cW8sF121yWI3tPzqr
kD8kEbCa5GvxmsdT
-----END CERTIFICATE-----" ) );

            byte[] buffer = new byte[ 1024 ];
            int read = request.InputStream.Read( buffer, 0, 1024 );
            string postData = Encoding.ASCII.GetString( buffer, 0, read );
            Console.WriteLine( "POSTDATA: \"{0}\"", postData );

            /* RSACryptoServiceProvider Provider = CertUtil.GetCertPublicKey(Cert); // if importing the file directly... */
            RSACryptoServiceProvider Provider = (RSACryptoServiceProvider)cert.PublicKey.Key;
            OAuth.OAuthBase ba = new OAuthBase();

            string signature = request.QueryString[ "oauth_signature" ];

            string normalUrl, normalParam;
            string baseString = ba.GenerateSignatureBase(
                                                         request.Url,
                                                         request.QueryString[ "oauth_consumer_key" ],
                                                         "",
                                                         "",
                                                         request.HttpMethod,
                                                         request.QueryString[ "oauth_timestamp" ],
                                                         request.QueryString[ "oauth_nonce" ],
                                                         "RSA-SHA1",
                                                         out normalUrl, out normalParam );

            Console.WriteLine( "normalUrl=" + normalUrl );
            Console.WriteLine( "normalParam=" + normalParam );
            Console.WriteLine( "baseString=" + baseString );

            byte[] sign = Convert.FromBase64String( signature );
            byte[] bstring = Encoding.UTF8.GetBytes( baseString );

            return Provider.VerifyData( bstring, "SHA1", sign );
        }

        public static bool isValidRequest2( HttpListenerRequest request )
        {
            //System.Web.HttpRequest request; // assuming request is for asp.net
            X509Certificate2 cert = new X509Certificate2();
            //X509Certificate cert = new X509Certificate();
            cert.Import( Encoding.ASCII.GetBytes(
@"-----BEGIN CERTIFICATE-----
MIICqDCCAhGgAwIBAgIJANDx5Es1s04zMA0GCSqGSIb3DQEBBQUAMG0xCzAJBgNV
BAYTAktSMQowCAYDVQQIDAEgMQowCAYDVQQHDAEgMQwwCgYDVQQKDANOSE4xEjAQ
BgNVBAsMCUNvbW11bml0eTESMBAGA1UEAwwJbmF2ZXIuY29tMRAwDgYJKoZIhvcN
AQkBFgEgMB4XDTEwMDYxNDA1MzAzNVoXDTExMDYxNDA1MzAzNVowbTELMAkGA1UE
BhMCS1IxCjAIBgNVBAgMASAxCjAIBgNVBAcMASAxDDAKBgNVBAoMA05ITjESMBAG
A1UECwwJQ29tbXVuaXR5MRIwEAYDVQQDDAluYXZlci5jb20xEDAOBgkqhkiG9w0B
CQEWASAwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANX++6LgORv6caQ8LCVh
RYTXi2Lko7zn4wPeqvdCqNZsxcry2mNHn/ic+0XbhNgor5L0l048f0iicW/Qu4vw
RvkZy2N8dNE3Tb5dbPLNo+S+cExv/DhbQVFKGiOOvr4vQ+2Lgw7If5g3sh6/S8Gu
ot47cOrUkiLKBKJt614bue9zAgMBAAGjUDBOMB0GA1UdDgQWBBSB1ReDAnl4lRyl
Rfpl0EZ13E5LzzAfBgNVHSMEGDAWgBSB1ReDAnl4lRylRfpl0EZ13E5LzzAMBgNV
HRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAEYdZfQjvk/wvlFP4l3mDqS4NMac
txx1lyYGa0gX4DGhb7aGwBb3qwCdSX7szuYNHHq5Clf9TGQMqc49RFC2TGNRrpSw
BZFRmyzhMsqx/dLcNIBLfz4B+SUw+yiwNKo3krYCJfqgNy0cW8sF121yWI3tPzqr
kD8kEbCa5GvxmsdT
-----END CERTIFICATE-----" ) );

            //DevDefined.OAuth.Framework.OAuthContext context = new DevDefined.OAuth.Framework.OAuthContextBuilder().FromHttpRequest(request);
            //DevDefined.OAuth.Framework.OAuthContext context = new DevDefined.OAuth.Framework.OAuthContextBuilder().FromUri( request.HttpMethod, request.Url );
            DevDefined.OAuth.Framework.OAuthContext context = new DevDefined.OAuth.Framework.OAuthContext
            {
                //RawUri = request.Url,
                RawUri = CleanUri( request.Url ),
                Cookies = new NameValueCollection(),
                Headers = request.Headers,
                RequestMethod = request.HttpMethod,
                FormEncodedParameters = new NameValueCollection(),
                QueryParameters = new NameValueCollection( request.QueryString ),
            };
            context.ConsumerKey = request.QueryString[ "oauth_consumer_key" ];
            context.Timestamp = request.QueryString[ "oauth_timestamp" ];
            context.Nonce = request.QueryString[ "oauth_nonce" ];
            //context.Signature = request.QueryString[ "oauth_signature" ];

            var signer = new DevDefined.OAuth.Framework.Signing.OAuthContextSigner();

            DevDefined.OAuth.Framework.SigningContext signingContext = new DevDefined.OAuth.Framework.SigningContext();

            // use context.ConsumerKey to fetch information required for signature validation for this consumer.
            //signingContext.SignatureBase = request.QueryString[ "oauth_signature" ];

            signingContext.Algorithm = cert.PublicKey.Key;
            //signingContext.ConsumerSecret; // if there is a consumer secret

            return ( signer.ValidateSignature( context, signingContext ) );
        }

        public static bool isValidRequest3( HttpListenerRequest request )
        {
            X509Certificate2 cert = new X509Certificate2();
            cert.Import( Encoding.ASCII.GetBytes(
@"-----BEGIN CERTIFICATE-----
MIICqDCCAhGgAwIBAgIJANDx5Es1s04zMA0GCSqGSIb3DQEBBQUAMG0xCzAJBgNV
BAYTAktSMQowCAYDVQQIDAEgMQowCAYDVQQHDAEgMQwwCgYDVQQKDANOSE4xEjAQ
BgNVBAsMCUNvbW11bml0eTESMBAGA1UEAwwJbmF2ZXIuY29tMRAwDgYJKoZIhvcN
AQkBFgEgMB4XDTEwMDYxNDA1MzAzNVoXDTExMDYxNDA1MzAzNVowbTELMAkGA1UE
BhMCS1IxCjAIBgNVBAgMASAxCjAIBgNVBAcMASAxDDAKBgNVBAoMA05ITjESMBAG
A1UECwwJQ29tbXVuaXR5MRIwEAYDVQQDDAluYXZlci5jb20xEDAOBgkqhkiG9w0B
CQEWASAwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANX++6LgORv6caQ8LCVh
RYTXi2Lko7zn4wPeqvdCqNZsxcry2mNHn/ic+0XbhNgor5L0l048f0iicW/Qu4vw
RvkZy2N8dNE3Tb5dbPLNo+S+cExv/DhbQVFKGiOOvr4vQ+2Lgw7If5g3sh6/S8Gu
ot47cOrUkiLKBKJt614bue9zAgMBAAGjUDBOMB0GA1UdDgQWBBSB1ReDAnl4lRyl
Rfpl0EZ13E5LzzAfBgNVHSMEGDAWgBSB1ReDAnl4lRylRfpl0EZ13E5LzzAMBgNV
HRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAEYdZfQjvk/wvlFP4l3mDqS4NMac
txx1lyYGa0gX4DGhb7aGwBb3qwCdSX7szuYNHHq5Clf9TGQMqc49RFC2TGNRrpSw
BZFRmyzhMsqx/dLcNIBLfz4B+SUw+yiwNKo3krYCJfqgNy0cW8sF121yWI3tPzqr
kD8kEbCa5GvxmsdT
-----END CERTIFICATE-----" ) );

            OAuth.Net.Components.RsaSha1SigningProvider provider = new OAuth.Net.Components.RsaSha1SigningProvider();
            provider.Certificate = cert;

            OAuth.OAuthBase ba = new OAuthBase();

            string signature = request.QueryString[ "oauth_signature" ];

            string normalUrl, normalParam;
            string baseString = ba.GenerateSignatureBase(
                                                         request.Url,
                                                         request.QueryString[ "oauth_consumer_key" ],
                                                         "",
                                                         "",
                                                         request.HttpMethod,
                                                         request.QueryString[ "oauth_timestamp" ],
                                                         request.QueryString[ "oauth_nonce" ],
                                                         "RSA-SHA1",
                                                         out normalUrl, out normalParam );

            var computed = provider.ComputeSignature( baseString, null, null );

            Console.WriteLine( "computed={0}", computed );
            Console.WriteLine( "signature={0}", signature );

            return false;
        }
    }
}