public ActionResult Twitter(string method)
{
try
{
if (Session["Twitter:AccessToken"] == null)
{
throw new Exception(Test.Resources.Strings.SessionIsDead);
}
string url = "https://api.twitter.com/1.1/followers/ids.json";
if (method == "user_timeline")
{
url = "https://api.twitter.com/1.1/statuses/user_timeline.json";
}
var auth = new OAuthAuthorization();
auth["oauth_consumer_key"] = ConfigurationManager.AppSettings["oauth:twitter:id"];
auth["oauth_signature_method"] = SignatureMethods.HMACSHA1;
auth["oauth_nonce"] = OAuthUtility.GetRandomKey();
auth["oauth_timestamp"] = OAuthUtility.GetTimeStamp();
auth["oauth_token_secret"] = Session["Twitter:TokenSecret"].ToString();
auth["oauth_token"] = Session["Twitter:AccessToken"].ToString();
auth["oauth_version"] = "1.0";
auth.SetSignature("GET", new Uri(url), ConfigurationManager.AppSettings["oauth:twitter:key"], Session["Twitter:TokenSecret"].ToString(), null);
var result = OAuthUtility.ExecuteRequest("GET", url, authorization: auth.ToString());
return(Content(Regex.Unescape(result.ToString()), "text/plain"));
}
catch (Exception ex)
{
return(Content(ex.ToString(), "text/plain"));
}
}
public async Task WhenExistingAuthIsOk_TryLoadExistingAuthorizationAsyncReturnsAuthorization()
{
var tokenResponse = new TokenResponse()
{
RefreshToken = "rt",
Scope = "email one two"
};
var adapter = new Mock <IAuthAdapter>();
adapter.Setup(a => a.GetStoredRefreshTokenAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(tokenResponse));
adapter.Setup(a => a.IsRefreshTokenValid(tokenResponse))
.Returns(true);
adapter.SetupGet(a => a.Scopes)
.Returns(new[] { "one", "two", "email" });
var authz = await OAuthAuthorization.TryLoadExistingAuthorizationAsync(
adapter.Object,
CancellationToken.None);
Assert.IsNotNull(authz);
adapter.Verify(a => a.AuthorizeUsingRefreshToken(tokenResponse), Times.Once);
adapter.Verify(a => a.QueryUserInfoAsync(
It.IsAny <ICredential>(),
It.IsAny <CancellationToken>()), Times.Once);
}
public void Signature_Common()
{
string httpMethod = "GET";
string url = "https://localhost/test";
NameValueCollection param = null;
var auth = new OAuthAuthorization();
auth.ConsumerKey = "12345";
auth.ConsumerSecret = "1234567890";
auth.TokenSecret = "abc";
auth.Token = "xyz";
auth.Nonce = "000000";
auth.SignatureMethod = "HMAC-SHA1";
auth.Timestamp = "1111111111";
auth.Version = "1.0";
string b = OAuthAuthorization.GetSignatureBaseString(httpMethod, url, param, auth);
var singn = new OAuthSignature
(
auth.SignatureMethod,
String.Format("{0}&{1}", auth.ConsumerSecret, auth.TokenSecret),
OAuthAuthorization.GetSignatureBaseString(httpMethod, url, param, auth)
).ToString();
if (singn != "vYE8cEP5ynznQRDqTxx307kc6rY=")
{
Assert.Fail();
}
else
{
Console.WriteLine("OK");
}
}
public async Task WhenExistingAuthLacksScopes_TryLoadExistingAuthorizationAsyncReturnsNullAndExistingAuthzIsDeleted()
{
var tokenResponse = new TokenResponse()
{
RefreshToken = "rt",
Scope = "one two"
};
var adapter = new Mock <IAuthAdapter>();
adapter.Setup(a => a.GetStoredRefreshTokenAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(tokenResponse));
adapter.Setup(a => a.IsRefreshTokenValid(tokenResponse))
.Returns(true);
adapter.SetupGet(a => a.Scopes)
.Returns(new[] { "one", "two", "email" });
var authz = await OAuthAuthorization.TryLoadExistingAuthorizationAsync(
adapter.Object,
CancellationToken.None);
Assert.IsNull(authz);
adapter.Verify(a => a.DeleteStoredRefreshToken(), Times.Once);
}
public void BodyHash()
{
NameValueCollection param = null;
string httpMethod = "GET";
string url = "https://localhost/test";
var sha1 = new System.Security.Cryptography.SHA1CryptoServiceProvider();
var auth = new OAuthAuthorization();
auth.ConsumerKey = "123123123";
auth.ConsumerSecret = "111111111111";
auth.SignatureMethod = "HMAC-SHA1";
auth.Nonce = "10098421";
auth.Timestamp = "1423300052";
auth.Version = "1.0";
auth["oauth_body_hash"] = Convert.ToBase64String(sha1.ComputeHash(new byte[] { }));
string b = OAuthAuthorization.GetSignatureBaseString(httpMethod, url, param, auth);
var singn = new OAuthSignature
(
auth.SignatureMethod,
String.Format("{0}&{1}", auth.ConsumerSecret, auth.TokenSecret),
OAuthAuthorization.GetSignatureBaseString(httpMethod, url, param, auth)
).ToString();
Assert.Equal("0dMQJB8HJSDse2/P4C0icvIbHfU=", singn);
}
/// <summary>
/// Wraps an API request - if the request is unauthorized it will refresh the Auth token and re-issue the request
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="func"></param>
/// <returns></returns>
private async Task <IApiResponse> WrapApiRequestAsync(OAuthAuthorization authResponse, Func <OAuthAuthorization, Task <IApiResponse> > func)
{
try
{
return(await func(authResponse));
}
catch (DigikeyUnauthorizedException ex)
{
// get refresh token, retry
_oAuth2Service.ClientSettings.RefreshToken = ex.Authorization.RefreshToken;
var token = await _oAuth2Service.RefreshTokenAsync();
var refreshTokenResponse = new OAuthAuthorization(nameof(DigikeyApi), _oAuth2Service.ClientSettings.ClientId, _httpContextAccessor.HttpContext.Request.Headers["Referer"].ToString())
{
AccessToken = token.AccessToken,
RefreshToken = token.RefreshToken,
CreatedUtc = DateTime.UtcNow,
ExpiresUtc = DateTime.UtcNow.Add(TimeSpan.FromSeconds(token.ExpiresIn)),
AuthorizationReceived = true,
};
var contextKey = $"{nameof(DigikeyApi)}-{_httpContextAccessor.HttpContext.User.Identity.Name}";
ServerContext.Set(contextKey, refreshTokenResponse);
if (refreshTokenResponse.IsAuthorized)
{
// save the credential
await _credentialService.SaveOAuthCredentialAsync(new Common.Models.OAuthCredential
{
Provider = contextKey,
AccessToken = refreshTokenResponse.AccessToken,
RefreshToken = refreshTokenResponse.RefreshToken,
DateCreatedUtc = refreshTokenResponse.CreatedUtc,
DateExpiresUtc = refreshTokenResponse.ExpiresUtc,
});
try
{
// call the API again using the refresh token
return(await func(refreshTokenResponse));
}
catch (DigikeyUnauthorizedException)
{
// refresh token failed, restart access token retrieval process
await ForgetAuthenticationTokens();
var freshResponse = await AuthorizeAsync();
if (freshResponse.MustAuthorize)
{
return(ApiResponse.Create(true, freshResponse.AuthorizationUrl, $"User must authorize", nameof(DigikeyApi)));
}
// call the API again
return(await func(freshResponse));
}
}
throw new UnauthorizedAccessException("Unable to authenticate with Digikey!");
}
}
private static void AppendOAuth2(OpenApiSecurityScheme scheme, OAuthAuthorization oAuth2)
{
Debug.Assert(scheme != null);
Debug.Assert(oAuth2 != null);
scheme.Flows = new OpenApiOAuthFlows();
OpenApiOAuthFlow flow = null;
switch (oAuth2.OAuth2Type)
{
case OAuth2Type.AuthCode: // AuthCode
OAuth2AuthCode authCode = (OAuth2AuthCode)oAuth2;
flow = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri(authCode.AuthorizationUrl),
TokenUrl = new Uri(authCode.TokenUrl)
};
scheme.Flows.AuthorizationCode = flow;
break;
case OAuth2Type.Pasword: // Password
OAuth2Password password = (OAuth2Password)oAuth2;
flow = new OpenApiOAuthFlow
{
TokenUrl = new Uri(password.TokenUrl)
};
scheme.Flows.Password = flow;
break;
case OAuth2Type.Implicit: // Implicit
OAuth2Implicit @implicit = (OAuth2Implicit)oAuth2;
flow = new OpenApiOAuthFlow
{
AuthorizationUrl = new Uri(@implicit.AuthorizationUrl)
};
scheme.Flows.Implicit = flow;
break;
case OAuth2Type.ClientCredentials: // ClientCredentials
OAuth2ClientCredentials credentials = (OAuth2ClientCredentials)oAuth2;
flow = new OpenApiOAuthFlow
{
TokenUrl = new Uri(credentials.TokenUrl)
};
scheme.Flows.ClientCredentials = flow;
break;
}
Debug.Assert(flow != null);
flow.RefreshUrl = new Uri(oAuth2.RefreshUrl);
if (oAuth2.Scopes != null)
{
flow.Scopes = oAuth2.Scopes.ToDictionary(s => s.Scope, s => s.Description);
}
}
private HttpRequestMessage CreateRequest(OAuthAuthorization authResponse, HttpMethod method, Uri uri)
{
var message = new HttpRequestMessage(method, uri);
message.Headers.Add("X-DIGIKEY-Client-Id", authResponse.ClientId);
message.Headers.Add("Authorization", $"Bearer {authResponse.AccessToken}");
message.Headers.Add("X-DIGIKEY-Locale-Site", "CA");
message.Headers.Add("X-DIGIKEY-Locale-Language", "en");
message.Headers.Add("X-DIGIKEY-Locale-Currency", "CAD");
return(message);
}
private OAuthAuthorization GetAuth()
{
var auth = new OAuthAuthorization();
auth.ConsumerKey = this.ConsumerKey;
auth.ConsumerSecret = this.ConsumerSecret;
auth.SignatureMethod = SignatureMethods.HMACSHA1;
auth.Token = Properties.Settings.Default.AccessToken;
auth.TokenSecret = Properties.Settings.Default.TokenSecret;
return(auth);
}
public static IAuthorization getAuth(AuthType aType)
{
if (aType == AuthType.OAuth)
{
currentAuth = OAuthAuthorization.getInstance();
return(currentAuth);
}
else
{
return(null);
}
}
public async Task WhenNoExistingAuthPresent_TryLoadExistingAuthorizationAsyncReturnsNull()
{
var adapter = new Mock <IAuthAdapter>();
adapter.Setup(a => a.GetStoredRefreshTokenAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <TokenResponse>(null));
var authz = await OAuthAuthorization.TryLoadExistingAuthorizationAsync(
adapter.Object,
CancellationToken.None);
Assert.IsNull(authz);
}
private async Task <OAuthAuthorization> AuthorizeAsync()
{
var contextKey = $"{nameof(DigikeyApi)}-{_httpContextAccessor.HttpContext.User.Identity.Name}";
// check if we have an in-memory auth credential
var getAuth = ServerContext.Get <OAuthAuthorization>(contextKey);
if (getAuth != null && getAuth.IsAuthorized)
{
return(getAuth);
}
// check if we have a saved to disk auth credential
OAuthAuthorization authRequest;
var credential = await _credentialService.GetOAuthCredentialAsync(contextKey);
if (credential != null)
{
// reuse a saved oAuth credential
authRequest = new OAuthAuthorization(nameof(DigikeyApi), _oAuth2Service.ClientSettings.ClientId, _httpContextAccessor.HttpContext.Request.Headers["Referer"].ToString())
{
AccessToken = credential.AccessToken,
RefreshToken = credential.RefreshToken,
CreatedUtc = credential.DateCreatedUtc,
ExpiresUtc = credential.DateExpiresUtc,
AuthorizationReceived = true,
};
// also store it in memory
ServerContext.Set(contextKey, authRequest);
return(authRequest);
}
// user must authorize
// request a token if we don't already have one
var scopes = "";
var authUrl = _oAuth2Service.GenerateAuthUrl(scopes);
// OpenBrowser(authUrl);
authRequest = new OAuthAuthorization(nameof(DigikeyApi), _oAuth2Service.ClientSettings.ClientId, _httpContextAccessor.HttpContext.Request.Headers["Referer"].ToString());
ServerContext.Set(contextKey, authRequest);
return(new OAuthAuthorization(nameof(DigikeyApi), true, authUrl));
}
public ModifyResult UpdateOAuthUserAuthorization(Stream input, int id)
{
/*StreamReader reader = new StreamReader(input);
* String content = reader.ReadToEnd();*/
XmlSerializer xmlSerializer = new XmlSerializer(typeof(OAuthAuthorization));
OAuthAuthorization auth = (OAuthAuthorization)xmlSerializer.Deserialize(input);
// Create the mapper
Arena.Custom.HDC.WebService.Contracts.OAuthAuthorizationMapper mapper =
new Arena.Custom.HDC.WebService.Contracts.OAuthAuthorizationMapper();
if (auth.AuthorizationId > 0)
{
return(mapper.Update(auth));
}
else
{
return(mapper.Create(auth));
}
}
public ModifyResult UpdateOAuthUserAuthorization(String clientApiKey, OAuthAuthorization auth)
{
Arena.Custom.SECC.OAuth.Client client = new Arena.Custom.SECC.OAuth.Client(new Guid(clientApiKey));
if (auth.ClientId != client.ClientId)
{
throw new ResourceNotFoundException("Client API Key mismatch.");
}
// Create the mapper
Arena.Custom.HDC.WebService.Contracts.OAuthAuthorizationMapper mapper =
new Arena.Custom.HDC.WebService.Contracts.OAuthAuthorizationMapper();
if (auth.AuthorizationId > 0)
{
return(mapper.Update(auth));
}
else
{
return(mapper.Create(auth));
}
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
// Assigning controls
Button button = FindViewById <Button> (Resource.Id.myButton);
EditText username = FindViewById <EditText> (Resource.Id.editText1);
EditText password = FindViewById <EditText> (Resource.Id.editText2);
// Twitter configuration part
ConfigurationBuilder TwitterConfig = new ConfigurationBuilder();
TwitterConfig.SetOAuthConsumerKey("_replace_wit_your_app_consumer_key_");
TwitterConfig.SetOAuthConsumerSecret("_replace_wit_your_app_consumer_secret_");
IConfiguration twiConfigInterface = TwitterConfig.Build();
TwitterFactory factory = new TwitterFactory(twiConfigInterface);
OAuthAuthorization oath = new OAuthAuthorization(twiConfigInterface);
AccessToken ascTkn = oath.GetOAuthAccessToken(username.Text, password.Text);
ITwitter twitter = factory.GetInstance(ascTkn);
button.Click += delegate {
ThreadPool.QueueUserWorkItem(state =>
{
try
{
twitter.UpdateStatus("Hello world, Xamarin is exciting.. boom..");
}
catch (Exception ed)
{
Console.WriteLine(ed.Message);
}
}
);
};
}
public ActionResult Twitter(string method)
{
try
{
if (Session["Twitter:AccessToken"] == null)
{
throw new Exception(DemoOAuth.Strings.SessionIsDead);
}
var token = (OAuthAccessToken)Session["Twitter:AccessToken"];
string url = "https://api.twitter.com/1.1/followers/ids.json";
if (method == "user_timeline")
{
url = "https://api.twitter.com/1.1/statuses/user_timeline.json";
}
var auth = new OAuthAuthorization();
auth.ConsumerKey = ConfigurationManager.AppSettings["oauth:twitter:id"];
auth.ConsumerSecret = ConfigurationManager.AppSettings["oauth:twitter:key"];
auth.TokenSecret = token.TokenSecret;
auth.SignatureMethod = SignatureMethods.HMACSHA1;
auth.Nonce = OAuthUtility.GetRandomKey();
auth.Timestamp = OAuthUtility.GetTimeStamp();
auth.Token = token.Value;
auth.Version = "1.0";
var result = OAuthUtility.ExecuteRequest("GET", url, authorization: auth);
return(Content(result.ToString(), "text/plain"));
}
catch (Exception ex)
{
return(Content(ex.ToString(), "text/plain"));
}
}
public static IAuthorization Authorize(
Control parent,
ClientSecrets clientSecrets,
string[] scopes,
IDataStore dataStore)
{
// N.B. Do not dispose the adapter (and embedded GoogleAuthorizationCodeFlow)
// as it might be needed for token refreshes later.
var oauthAdapter = new GoogleAuthAdapter(
new GoogleAuthorizationCodeFlow.Initializer
{
ClientSecrets = clientSecrets,
Scopes = scopes,
DataStore = dataStore
},
Resources.AuthorizationSuccessful);
Exception caughtException = null;
using (var dialog = new AuthorizeDialog())
{
Task.Run(async() =>
{
try
{
// Try to authorize using OAuth.
dialog.authorization = await OAuthAuthorization.TryLoadExistingAuthorizationAsync(
oauthAdapter,
CancellationToken.None)
.ConfigureAwait(true);
if (dialog.authorization != null)
{
// We have existing credentials, there is no need to even
// show the "Sign In" button.
parent.BeginInvoke((Action)(() => dialog.Close()));
}
else
{
// No valid credentials present, request user to authroize
// by showing the "Sign In" button.
parent.BeginInvoke((Action)(() => dialog.ToggleSignInButton()));
}
}
catch (Exception)
{
// Something went wrong trying to load existing credentials.
parent.BeginInvoke((Action)(() => dialog.ToggleSignInButton()));
}
});
dialog.signInButton.Click += async(sender, args) =>
{
// Switch to showing spinner so that a user cannot click twice.
dialog.ToggleSignInButton();
try
{
dialog.authorization = await OAuthAuthorization.CreateAuthorizationAsync(
oauthAdapter,
CancellationToken.None)
.ConfigureAwait(true);
}
catch (Exception e)
{
caughtException = e;
}
dialog.Close();
};
dialog.ShowDialog(parent);
#pragma warning disable CA1508 // Avoid dead conditional code
if (caughtException != null)
{
throw caughtException;
}
else
{
return(dialog.authorization);
}
#pragma warning restore CA1508 // Avoid dead conditional code
}
}
public DigikeyUnauthorizedException(OAuthAuthorization authorization)
{
Authorization = authorization;
}
protected override void OnValidSuccess(AuthorizationContext filterContext, ServerAccessGrant accessGrant)
{
OAuthAuthorization.AppendRequestData(filterContext.RequestContext, "userId", accessGrant.UserId);
OAuthAuthorization.AppendRequestData(filterContext.RequestContext, "appId", accessGrant.ClientId);
}
