public ActionResult OAuthCallback(string oauth_token, string oauth_verifier) { RequestTokenModel model = new RequestTokenModel(); RequestTokenModel sessionModel = Session["endpoints"] as RequestTokenModel; model = sessionModel; OAuthKeyConfiguration oauthConfiguration = OAuthKeyConfiguration.GetInstance(); if (string.IsNullOrEmpty(oauth_verifier)) { throw new Exception("Expected a non-empty verifier value"); } OAuthClient oauthClient = new OAuthClient(sessionModel.EndpointModel, TestSite.MvcApplication.GetTokenManager(sessionModel.ConsumerKey, sessionModel.ConsumerSecret)); if (oauthClient != null) { IOAuthToken oauthToken = oauthClient.ExchangeRequestTokenForAccessToken(oauth_verifier); if (oauthToken != null) { model.Token = oauthToken.Token; model.Secret = oauthToken.Secret; } } return(View(model)); }
public void GetRequestToken(string consumerKey, string consumerSecret, string callbackUrl, string serviceUri, string requestTokenUri, string authorizationUri, string accessTokenUri) { RequestTokenModel model = new RequestTokenModel(); model.ConsumerKey = consumerKey; model.ConsumerSecret = consumerSecret; EndpointModel endpointModel = new EndpointModel(); endpointModel.ServiceUri = serviceUri; endpointModel.RequestTokenUri = requestTokenUri; endpointModel.AuthorizationUri = authorizationUri; endpointModel.AccessTokenUri = accessTokenUri; model.EndpointModel = endpointModel; OAuthClientBase oauthClient = OAuthClient.CreateClient(consumerKey, consumerSecret, endpointModel); if (oauthClient != null) { IOAuthToken requestToken = oauthClient.GetRequestToken(this.GenerateRealm(TestUserId, "*****@*****.**"), callbackUrl); model.Token = requestToken.Token; model.Secret = requestToken.Secret; } Session[model.Token] = model; string authorizationUrl = oauthClient.GetUserAuthorizationUrl(model); this.Response.Redirect(authorizationUrl, false); }
public ActionResult GetInlineOAuthToken(string consumerKey, string consumerSecret, string callbackUrl, string serviceUri, string requestTokenUri, string authorizationUri, string accessTokenUri) { RequestTokenModel model = new RequestTokenModel(); model.ConsumerKey = consumerKey; model.ConsumerSecret = consumerSecret; EndpointModel endpointModel = new EndpointModel(); endpointModel.ServiceUri = serviceUri; endpointModel.RequestTokenUri = requestTokenUri; endpointModel.AuthorizationUri = authorizationUri; endpointModel.AccessTokenUri = accessTokenUri; model.EndpointModel = endpointModel; OAuthClient oauthClient = new OAuthClient(model.ConsumerKey, model.ConsumerSecret, model.EndpointModel); try { IOAuthToken accessToken = oauthClient.GetInlineAccessToken(Realm.GetDefault()); model.Token = accessToken.Token; model.Secret = accessToken.Secret; } catch (OAuthException authEx) { Session["problem"] = authEx.Report; Response.Redirect("AccessDenied.aspx"); } return(View("OauthCallback", model)); }
/// <summary> /// Authorize a request token /// </summary> /// <param name="oauthToken">The request token</param> /// <returns>An object containing a response elements (verifier code and granted)</returns> private TokenVerification InlineAuthorize(IOAuthToken oauthToken) { TokenVerification retVal = null; if (oauthToken != null) { RestClient restClient = new RestClient(this.OAuthEndpoints.ServiceUri); RestRequest request = new RestRequest(this.OAuthEndpoints.AuthorizationUri, Method.GET); request.AddParameter(Constants.TokenParameter, oauthToken.Token); var response = restClient.Execute(request); var qs = HttpUtility.ParseQueryString(response.Content); string verifierCode = qs[Constants.VerifierCodeParameter]; string grantedAccessParameter = qs[Constants.GrantedAccessParameter]; bool grantedAccess = false; if (!string.IsNullOrWhiteSpace(grantedAccessParameter)) { grantedAccess = bool.Parse(grantedAccessParameter); } if (!string.IsNullOrEmpty(verifierCode)) { retVal = new TokenVerification(); retVal.VerifierCode = verifierCode; retVal.Granted = grantedAccess; } } return(retVal); }
/// <summary> /// Merges the properties from the <see cref="entity" /> into this entity /// </summary> /// <param name="entity">The entity to merge</param> public override void Merge(KeyedEntity entity) { Guard.NotNull(() => entity, entity); var mergeEntity = entity as OAuthTokenEntity; if (mergeEntity == null) { return; } IOAuthToken thisDto = ToDto(); IOAuthToken mergeDto = mergeEntity.ToDto(); // Compare to see if we need to update changed values (null) values are ignored in persistence thisDto.Username = mergeDto.Username.HasValue() ? mergeDto.Username : thisDto.Username; thisDto.AccessToken = mergeDto.AccessToken.HasValue() ? mergeDto.AccessToken : thisDto.AccessToken; thisDto.RefreshToken = mergeDto.RefreshToken.HasValue() ? mergeDto.RefreshToken : thisDto.RefreshToken; thisDto.ExpiresOnUtc = mergeDto.ExpiresOnUtc.HasValue() ? mergeDto.ExpiresOnUtc : thisDto.ExpiresOnUtc; thisDto.IssuedOnUtc = mergeDto.IssuedOnUtc.HasValue() ? mergeDto.IssuedOnUtc : thisDto.IssuedOnUtc; //Convert back to entity OAuthTokenEntity thisEntity = FromDto(thisDto); Username = thisEntity.Username; AccessToken = thisEntity.AccessToken; RefreshToken = thisEntity.RefreshToken; ExpiresOnUtc = thisEntity.ExpiresOnUtc; IssuedOnUtc = thisEntity.IssuedOnUtc; }
public new void SetUp() { testServer = new RainyTestServer (); testServer.Start (); accessToken = testServer.GetAccessToken (); this.syncServer = new WebSyncServer (testServer.ListenUrl, accessToken); }
public new void SetUp() { testServer = new RainyTestServer(); testServer.Start(); accessToken = testServer.GetAccessToken(); this.syncServer = new WebSyncServer(testServer.ListenUrl, accessToken); }
/// <summary> /// Initializes a new instance of the <see cref="Tomboy.Sync.Web.WebSyncServer"/> class. /// </summary> /// <param name="serverUrl">Server URL (without the api/1.0 part).</param> /// <param name="accessToken">An pre-obtained access token for OAuth. /// Use <see cref="PerformTokenExchange"/> or <see cref="PerformNonInteractiveTokenExchange"/>. /// </param> public WebSyncServer(string serverUrl, IOAuthToken accessToken) { rootApiUrl = serverUrl + "/api/1.0"; this.accessToken = accessToken; this.DeletedServerNotes = new List<string> (); this.UploadedNotes = new List<Note> (); }
public RequestToken GetRequestToken(string callback) { var requestPath = string.Format("{0}?{1}={2}", this.RequestTokenPath, OAuthParameter.OAUTH_CALLBACK, callback); IOAuthToken ioAuthToken = this.TokenRequest(this.HttpMethod, requestPath); return(new RequestToken(this, ioAuthToken, ((OAuthToken)ioAuthToken).CallbackConfirmed)); }
public WebTokenCreator( IUnityFactory <ITemporaryCredentials> applicationCredentialsUnityFactory, IOAuthWebRequestGenerator oAuthWebRequestGenerator, IOAuthToken oAuthToken) { _applicationCredentialsUnityFactory = applicationCredentialsUnityFactory; _oAuthWebRequestGenerator = oAuthWebRequestGenerator; _oAuthToken = oAuthToken; }
public SampleStream( IStreamResultGenerator streamResultGenerator, IJsonObjectConverter jsonObjectConverter, IJObjectStaticWrapper jObjectStaticWrapper, ITweetFactory tweetFactory, IOAuthToken oAuthToken) : base(streamResultGenerator, jsonObjectConverter, jObjectStaticWrapper, tweetFactory, oAuthToken) { }
public void OAuthFullTokenExchange() { // the actual unit under test is GetAccessToken, but we // need it so often so it is its own method IOAuthToken access_token = testServer.GetAccessToken(); Assert.That(access_token.Token.Length > 14); Assert.That(access_token.Secret.Length > 14); }
/// <summary> /// Authorize a request token /// </summary> /// <param name="oauthToken">The request token</param> public void Authorize(IOAuthToken oauthToken) { if (oauthToken != null) { RestClient restClient = new RestClient(this.OAuthEndpoints.ServiceUri); RestRequest request = new RestRequest(this.OAuthEndpoints.AuthorizationUri); request.AddParameter(Constants.TokenParameter, oauthToken.Token); var url = restClient.BuildUri(request).ToString(); Process.Start(url); } }
public CredentialsCreator( IOAuthToken oAuthToken, ICredentialsFactory credentialsFactory, IOAuthWebRequestGenerator oAuthWebRequestGenerator, IUnityFactory <ITemporaryCredentials> applicationCredentialsUnityFactory) { _oAuthToken = oAuthToken; _credentialsFactory = credentialsFactory; _oAuthWebRequestGenerator = oAuthWebRequestGenerator; _applicationCredentialsUnityFactory = applicationCredentialsUnityFactory; }
public TweetStream( IStreamResultGenerator streamResultGenerator, IJsonObjectConverter jsonObjectConverter, IJObjectStaticWrapper jObjectStaticWrapper, ITweetFactory tweetFactory, IOAuthToken oAuthToken) : base(streamResultGenerator, jsonObjectConverter, jObjectStaticWrapper) { _tweetFactory = tweetFactory; _oAuthToken = oAuthToken; }
public User GetEntity(IOAuthToken oauthToken, string targetAction) { User retVal = null; if (this.OAuthClient != null) { string response = this.OAuthClient.ExecuteAuthorizedRequest(this.OAuthClient.OAuthEndpoints.ServiceUri, targetAction, oauthToken); retVal = this.DeserializeUser(response); } return(retVal); }
public IList <User> GetCollection(IOAuthToken oauthToken, string targetAction) { IList <User> retVal = null; if (this.OAuthClient != null) { string response = this.OAuthClient.ExecuteAuthorizedRequest(this.OAuthClient.OAuthEndpoints.ServiceUri, targetAction, oauthToken); retVal = this.DeserializeUserList(response); } return(retVal); }
/// <summary> /// Gets an entity from the <see cref="IOAuthToken" />. /// </summary> public static OAuthTokenEntity FromDto(IOAuthToken dto) { Guard.NotNull(() => dto, dto); return(new OAuthTokenEntity { Id = EntityHelper.SerializeForStorage(dto.Id), Username = EntityHelper.SerializeForStorage(dto.Username), AccessToken = EntityHelper.SerializeForStorage(dto.AccessToken), RefreshToken = EntityHelper.SerializeForStorage(dto.RefreshToken), ExpiresOnUtc = EntityHelper.SerializeForStorage(dto.ExpiresOnUtc), IssuedOnUtc = EntityHelper.SerializeForStorage(dto.IssuedOnUtc), }); }
public override string BuildSignature(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken) { if (consumer == null) { throw new ArgumentNullException(ERROR_CONSUMER_NULL); } if (ioAuthToken == null) { throw new ArgumentNullException(ERROR_TOKEN_NULL); } var result = string.Format(FORMAT_PARAMETER, OAuthParameter.UrlEncode(consumer.ConsumerSecret), OAuthParameter.UrlEncode(ioAuthToken.TokenSecret)); return result; }
public TrackedStream( IStreamTrackManager <ITweet> streamTrackManager, IJsonObjectConverter jsonObjectConverter, IJObjectStaticWrapper jObjectStaticWrapper, IStreamResultGenerator streamResultGenerator, ITweetFactory tweetFactory, IOAuthToken oAuthToken) : base(streamResultGenerator, jsonObjectConverter, jObjectStaticWrapper) { _streamTrackManager = streamTrackManager; _jsonObjectConverter = jsonObjectConverter; _tweetFactory = tweetFactory; _oAuthToken = oAuthToken; }
public WebRequest SignRequest(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken, NameValueCollection additionalParameters, out string oAuthQueryString) { oAuthQueryString = string.Empty; var requestUri = string.Format("{0}://{1}{2}", webRequest.RequestUri.Scheme, webRequest.RequestUri.Authority, webRequest.RequestUri.AbsolutePath); var signatureMethod = GetSignatureMethod(consumer.OAuthSignatureMethod); //add querystring var query = HttpUtility.ParseQueryString(webRequest.RequestUri.Query); signatureMethod.RequestParameters.Add(query); if (!string.IsNullOrEmpty(ioAuthToken.Openid)) { var openidParms = new NameValueCollection(); openidParms.Add(OAuthParameter.OPENID,ioAuthToken.Openid); signatureMethod.RequestParameters.Add(openidParms); } //add body content signatureMethod.RequestParameters.Add(additionalParameters); var signature = signatureMethod.BuildSignature(webRequest, consumer, ioAuthToken); signatureMethod.RequestParameters[OAuthParameter.OAUTH_SIGNATURE] = signature; switch (consumer.Scheme) { case AuthorizationSchemeType.Header: var oauthHeader = signatureMethod.ToOAuthHeader(); var request1 = WebRequest.Create(requestUri); request1.ContentType = webRequest.ContentType; request1.Headers.Add(OAuthConstants.AUTHORIZATION_HEADER, oauthHeader); request1.Method = webRequest.Method; return request1; case AuthorizationSchemeType.QueryString: oAuthQueryString = signatureMethod.ToOAuthQueryString(); var request2 = WebRequest.Create(requestUri + "?" + oAuthQueryString); request2.ContentType = webRequest.ContentType; request2.Method = webRequest.Method; return request2; case AuthorizationSchemeType.Body: throw new UnSupportedHttpMethodException(webRequest.Method); default: throw new ArgumentOutOfRangeException(ARG_SCHEME); } }
/// <summary> /// Exchange an request token for an access token /// </summary> /// <param name="token">The request token</param> /// <param name="verifierCode">The verifier code</param> /// <returns>An access token and secret</returns> public override IOAuthToken ExchangeRequestTokenForAccessToken(IOAuthToken token, string verifierCode) { DefaultOAuthToken retVal = null; if (token != null && !string.IsNullOrEmpty(verifierCode)) { RestClient restClient = new RestClient(this.OAuthEndpoints.ServiceUri); RestRequest request = new RestRequest(this.OAuthEndpoints.AccessTokenUri); restClient.Authenticator = OAuth1Authenticator.ForAccessToken(this.ConsumerKey, this.ConsumerSecret, token.Token, token.Secret, verifierCode); var response = restClient.Execute(request); var qs = HttpUtility.ParseQueryString(response.Content); retVal = new DefaultOAuthToken(); retVal.Token = qs[Constants.TokenParameter]; retVal.Secret = qs[Constants.TokenSecretParameter]; } return(retVal); }
public override string BuildSignature(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken) { if (consumer == null) { throw new ArgumentNullException(ERROR_CONSUMER_NULL); } if (ioAuthToken == null) { throw new ArgumentNullException(ERROR_TOKEN_NULL); } var key = string.Format(FORMAT_PARAMETER, OAuthParameter.UrlEncode(consumer.ConsumerSecret), OAuthParameter.UrlEncode(ioAuthToken.TokenSecret)); HashAlgorithm hashAlgorithm = new HMACSHA1(Encoding.UTF8.GetBytes(key)); var encoded = Encoding.UTF8.GetBytes(this.GetCanonicalString(webRequest, consumer, ioAuthToken)); var result = Convert.ToBase64String(hashAlgorithm.ComputeHash(encoded)); return result; }
// Constructor public FilteredStream( IStreamTrackManager <ITweet> streamTrackManager, IJsonObjectConverter jsonObjectConverter, IJObjectStaticWrapper jObjectStaticWrapper, IStreamResultGenerator streamResultGenerator, ITweetFactory tweetFactory, IOAuthToken oAuthToken) : base( streamTrackManager, jsonObjectConverter, jObjectStaticWrapper, streamResultGenerator, tweetFactory, oAuthToken) { _followingUserIds = new Dictionary <long?, Action <ITweet> >(); _locations = new Dictionary <ILocation, Action <ITweet> >(); }
// helper extension method to sign each JSON request with OAuth public static void SetAccessToken(this JsonServiceClient client, IOAuthToken access_token) { // we use a request filter to add the required OAuth header client.LocalHttpWebRequestFilter += webservice_request => { RequestMethod method = RequestMethod.GET; switch (webservice_request.Method) { case "GET": method = RequestMethod.GET; break; case "POST": method = RequestMethod.POST; break; case "DELETE": method = RequestMethod.DELETE; break; case "PUT": method = RequestMethod.PUT; break; } var auth_header = OAuthConnection.GenerateAuthorizationHeader (access_token, webservice_request.RequestUri, method, null); webservice_request.Headers ["Authorization"] = auth_header; }; }
public UserStream( IStreamResultGenerator streamResultGenerator, ITweetFactory tweetFactory, IMessageFactory messageFactory, IUserFactory userFactory, ITweetListFactory tweetListFactory, IJObjectStaticWrapper jObjectWrapper, IJsonObjectConverter jsonObjectConverter, IExceptionHandler exceptionHandler, IOAuthToken oAuthToken, IStreamTrackManager <ITweet> streamTrackManager) : base(streamTrackManager, jsonObjectConverter, jObjectWrapper, streamResultGenerator, tweetFactory, oAuthToken) { _messageFactory = messageFactory; _userFactory = userFactory; _tweetListFactory = tweetListFactory; _jObjectWrapper = jObjectWrapper; _exceptionHandler = exceptionHandler; _events = new SortedDictionary <string, Action <JObject> >(); InitializeEvents(); }
public override string BuildSignature(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken) { if (consumer == null) { throw new ArgumentNullException(ERROR_CONSUMER_NULL); } if (ioAuthToken == null) { throw new ArgumentNullException(ERROR_TOKEN_NULL); } var requestUri = string.Format("{0}://{1}{2}", webRequest.RequestUri.Scheme, webRequest.RequestUri.Authority, webRequest.RequestUri.AbsolutePath); var request = WebRequest.Create(requestUri); request.Method = webRequest.Method; var key = string.Format(FORMAT_PARAMETER, OAuthParameter.UrlEncode(consumer.ConsumerSecret), OAuthParameter.UrlEncode(ioAuthToken.TokenSecret)); HashAlgorithm hashAlgorithm = new HMACSHA1(Encoding.UTF8.GetBytes(key)); var canonicalString = this.GetCanonicalString(request, consumer, ioAuthToken); var encoded = Encoding.UTF8.GetBytes(canonicalString); var result = Convert.ToBase64String(hashAlgorithm.ComputeHash(encoded)); return result; }
/// <summary> /// Generate the url used to authorize the request token /// </summary> /// <param name="requestToken">The request token to authorize</param> /// <param name="callbackUrl">The callback url</param> /// <returns>The ful authorize url</returns> public string GetUserAuthorizationUrl(IOAuthToken requestToken) { return(string.Format("{0}{1}?{2}={3}", this.OAuthEndpoints.ServiceUri, this.OAuthEndpoints.AuthorizationUri, Constants.TokenParameter, requestToken.Token)); }
public abstract string BuildSignature(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken);
public DeveloperServiceClient(string serverUrl, IOAuthToken accessToken) { serverBaseUrl = serverUrl; this.accessToken = accessToken; }
/// <summary> /// Generates a signature using the specified signature type. /// </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, pass null or an empty string.</param> /// <param name="verifier">The callback verifier, if available. If not, 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> private string GenerateSignature(Uri url, string consumerKey, string consumerSecret, IOAuthToken token, string verifier, RequestMethod method, TimeSpan timeStamp, string nonce, SignatureType signatureType, string callbackUrl, out string normalizedUrl, out List<IQueryParameter<string>> parameters) { normalizedUrl = null; parameters = null; switch (signatureType) { case SignatureType.PLAINTEXT: var signature = UrlEncode (string.Format ("{0}&{1}", consumerSecret, token.Secret)); GenerateSignatureBase (url, consumerKey, token, verifier, method, timeStamp, nonce, SignatureType.PLAINTEXT, callbackUrl, out normalizedUrl, out parameters); return signature; case SignatureType.HMACSHA1: // string signatureBase = GenerateSignatureBase (url, consumerKey, token, verifier, method, // timeStamp, nonce, SignatureType.HMACSHA1, callbackUrl, // out normalizedUrl, out parameters); // // var hmacsha1 = new HMACSHA1 (); // hmacsha1.Key = Encoding.ASCII.GetBytes (string.Format ("{0}&{1}", // UrlEncode (consumerSecret), // string.IsNullOrEmpty (token.Secret) ? "" : UrlEncode(token.Secret))); // // var hashedSignature = GenerateSignatureUsingHash (signatureBase, hmacsha1); // //// log.LogDebug ("HMAC-SHA1 encoded signature {0} of consumer secret and token secret.", hashedSignature); // return hashedSignature; throw new NotImplementedException (); case SignatureType.RSASHA1: throw new NotImplementedException (); default: throw new ArgumentException ("Unknown signature type", "signatureType"); } }
/// <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, pass null or an empty string.</param> /// <param name="verifier">The callback verifier, if available. If not, pass null or an empty string.</param> /// <param name="httpMethod">The HTTP method used. Must be valid HTTP method verb (POST, GET, PUT, etc).</param> /// <returns>A Base64 string of the hash value.</returns> protected string GenerateSignature(Uri url, string consumerKey, string consumerSecret, IOAuthToken token, string verifier, RequestMethod method, TimeSpan timeStamp, string nonce, string callbackUrl, out string normalizedUrl, out List<IQueryParameter<string>> parameters) { // TODO use HMACSHA1 instead of PLAINTEXT // for non-ssl connection. return GenerateSignature (url, consumerKey, consumerSecret, token, verifier, method, timeStamp, nonce, SignatureType.PLAINTEXT, callbackUrl, out normalizedUrl, out parameters); }
public static string GenerateAuthorizationHeader(IOAuthToken accessToken, Uri uri, RequestMethod method, string postData) { var oauth = new OAuthConnection (uri.ToString()); oauth.AccessToken = accessToken; return oauth.GenerateAuthorizationHeader (uri, method, postData); }
public AccessToken(IOAuthConsumer ioAuthConsumer, IOAuthToken ioAuthToken,string openId) : base(ioAuthConsumer, ioAuthToken.TokenKey,ioAuthToken.TokenSecret,openId) { this.TokenType = OAuthTokenType.AccessToken; }
protected string GetCanonicalString(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken) { if (string.IsNullOrEmpty(webRequest.Method)) { throw new ArgumentNullException(ERROR_HTTP_METHOD); } var stringToSign = new StringBuilder(); stringToSign.Append(webRequest.Method.ToUpper().Trim()); stringToSign.Append(OAuthParameter.QUERYSTRING_SEPERATOR); stringToSign.Append(OAuthParameter.UrlEncode(webRequest.RequestUri.AbsoluteUri)); stringToSign.Append(OAuthParameter.QUERYSTRING_SEPERATOR); if (RequestParameters[OAuthParameter.OAUTH_REALM] != null) RequestParameters.Remove(OAuthParameter.OAUTH_REALM); if (RequestParameters[OAuthParameter.OAUTH_SIGNATURE] != null) RequestParameters.Remove(OAuthParameter.OAUTH_SIGNATURE); if (RequestParameters[OAuthParameter.OAUTH_SIGNATURE_METHOD] == null) RequestParameters.Add(OAuthParameter.OAUTH_SIGNATURE_METHOD, GeneralUtil.SignatureMethodTypeToString(consumer.OAuthSignatureMethod)); if (RequestParameters[OAuthParameter.OAUTH_CONSUMER_KEY] == null) RequestParameters.Add(OAuthParameter.OAUTH_CONSUMER_KEY, consumer.ConsumerKey); if (RequestParameters[OAuthParameter.OAUTH_VERSION] == null) RequestParameters.Add(OAuthParameter.OAUTH_VERSION, GeneralUtil.OAuthVersionTypeToString(consumer.OAuthVersion)); if (RequestParameters[OAuthParameter.OAUTH_TIMESTAMP] == null) RequestParameters.Add(OAuthParameter.OAUTH_TIMESTAMP, GenerateTimeStamp()); if (RequestParameters[OAuthParameter.OAUTH_NONCE] == null) RequestParameters.Add(OAuthParameter.OAUTH_NONCE, GenerateNonce()); if (RequestParameters[OAuthParameter.OAUTH_TOKEN] == null && !string.IsNullOrEmpty(ioAuthToken.TokenKey)) RequestParameters.Add(OAuthParameter.OAUTH_TOKEN, ioAuthToken.TokenKey); stringToSign.Append(OAuthParameter.UrlEncode(GetNormalizedParameterString(RequestParameters).Trim())); return stringToSign.ToString(); }
//public RequestToken(IOAuthConsumer ioAuthConsumer, IOAuthToken ioAuthToken) // : this(ioAuthConsumer, ioAuthToken,null) //{ //} public RequestToken(IOAuthConsumer ioAuthConsumer, IOAuthToken ioAuthToken, string openId) : this(ioAuthConsumer, ioAuthToken,openId, null) { }
public WebRequest SignRequest(WebRequest webRequest, IOAuthConsumer consumer, IOAuthToken ioAuthToken) { return this.SignRequest(webRequest, consumer, ioAuthToken); }
public string GetAuthorizationUrl(string callbackUrl) { this.CallbackUrl = callbackUrl; GetRootApiRef (); var response = Post (apiRoot.OAuthRequestTokenUrl, null, string.Empty); if (response.Length == 0) { throw new Exception (); } // Response contains token and token secret. We only need the token until we're authorized. var qs = System.Web.HttpUtility.ParseQueryString (response); if (string.IsNullOrEmpty (qs ["oauth_token"])) { throw new Exception ("Error reading oauth_token"); } this.RequestToken = new OAuthToken { Token = qs ["oauth_token"], Secret = qs ["oauth_token_secret"] }; var link = string.Format ("{0}?oauth_token={1}&oauth_callback={2}", apiRoot.OAuthAuthorizeUrl, RequestToken.Token, Uri.EscapeUriString (CallbackUrl)); return link; }
/// <summary> /// Exchange a request token and its verifier code for an access token /// </summary>y /// <param name="requestToken">The request token</param> /// <param name="verificationCode">The verification code</param> /// <returns>An acces token and its secret</returns> public abstract IOAuthToken ExchangeRequestTokenForAccessToken(IOAuthToken requestToken, string verificationCode);
/// <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="verifier">The callback verifier, 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="SignatureType">SignatureType</see>.</param> /// <returns>The signature base.</returns> private string GenerateSignatureBase(Uri url, string consumerKey, IOAuthToken token, string verifier, RequestMethod method, TimeSpan timeStamp, string nonce, SignatureType signatureType, string callbackUrl, out string normalizedUrl, out List<IQueryParameter<string>> parameters) { token.Token = token.Token ?? string.Empty; token.Secret = token.Secret ?? string.Empty; verifier = verifier ?? String.Empty; if (consumerKey == null) throw new ArgumentNullException ("consumerKey"); var signatureString = string.Empty; switch (signatureType) { case SignatureType.HMACSHA1: signatureString = "HMAC-SHA1"; break; case SignatureType.RSASHA1: signatureString = "RSA-SHA1"; break; case SignatureType.PLAINTEXT: signatureString = SignatureType.PLAINTEXT.ToString (); break; } parameters = GetQueryParameters (url.Query).Concat (new List<IQueryParameter<string>> { new QueryParameter<string> (OAuthVersionKey, OAuthVersion, s => string.IsNullOrEmpty (s)), new QueryParameter<string> (OAuthTimestampKey, ((long)timeStamp.TotalSeconds).ToString (), s => string.IsNullOrEmpty (s)), new QueryParameter<string> (OAuthSignatureMethodKey, signatureString, s => string.IsNullOrEmpty (s)), new QueryParameter<string> (OAuthNonceKey, nonce, s => string.IsNullOrEmpty (s)), new QueryParameter<string> (OAuthConsumerKeyKey, consumerKey, s => string.IsNullOrEmpty (s)) }).ToList (); if (!string.IsNullOrEmpty (token.Token)) parameters.Add (new QueryParameter<string> (OAuthTokenKey, token.Token, s => string.IsNullOrEmpty (s))); if (!string.IsNullOrEmpty (verifier)) parameters.Add (new QueryParameter<string> (OAuthVerifierKey, verifier, s => string.IsNullOrEmpty (s))); if (!string.IsNullOrEmpty (callbackUrl)) parameters.Add (new QueryParameter<string> (OAuthCallbackKey, UrlEncode (callbackUrl), s => string.IsNullOrEmpty (s))); 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; parameters.Sort (); string normalizedRequestParameters = parameters.NormalizeRequestParameters (); var signatureBase = new StringBuilder (); signatureBase.AppendFormat("{0}&", method.ToString ()); signatureBase.AppendFormat("{0}&", UrlEncode (normalizedUrl)); signatureBase.AppendFormat("{0}", UrlEncode (normalizedRequestParameters)); return signatureBase.ToString (); }
public AccessToken(IOAuthConsumer ioAuthConsumer, IOAuthToken ioAuthToken) : this(ioAuthConsumer, ioAuthToken, ioAuthToken.Openid) { }
public RequestToken(IOAuthConsumer ioAuthConsumer, IOAuthToken ioAuthToken,string openId, bool? callbackConfirmed) : base(ioAuthConsumer, ioAuthToken.TokenKey, ioAuthToken.TokenSecret,openId,callbackConfirmed) { this.TokenType = OAuthTokenType.RequestToken; }