Skip to content

anonymous /OAuthBase.cs

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
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();
}
}
}
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;
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.