private static async Task MainAsync() { var client = new HttpClient(); var discoveryResponse = await client.GetDiscoveryDocumentAsync(Authority); if (discoveryResponse.IsError) { throw new ApplicationException(discoveryResponse.Error); } Console.WriteLine("Successful endpoint discovery"); // request token var tokenRequest = new PasswordTokenRequest { Address = discoveryResponse.TokenEndpoint, ClientId = ClientId, ClientSecret = ClientSecret, Scope = ClientScope, UserName = UserName, Password = UserPassword }; var tokenResponse = await client.RequestPasswordTokenAsync(tokenRequest); if (tokenResponse.IsError) { throw new ApplicationException(tokenResponse.Error); } Console.WriteLine($"Identity Response Code: {(int)tokenResponse.HttpStatusCode} {tokenResponse.HttpStatusCode}"); Console.WriteLine($"Token Response:\n{tokenResponse.Json}\n\n"); // request userInfo var userInfoRequest = new UserInfoRequest { Address = discoveryResponse.UserInfoEndpoint, Token = tokenResponse.AccessToken }; var userInfoResponse = await client.GetUserInfoAsync(userInfoRequest); Console.WriteLine($"UserInfo Response Code: {(int)userInfoResponse.HttpStatusCode} {userInfoResponse.HttpStatusCode}"); if (userInfoResponse.IsError) { Console.WriteLine($"UserInfo Error Response: {userInfoResponse.Error}"); throw new Exception(userInfoResponse.Error); } Console.WriteLine("User Claims:"); foreach (var claim in userInfoResponse.Claims) { Console.WriteLine($"{claim.Type}: {claim.Value}"); } }
private PasswordTokenRequest CreatePasswordTokenRequest(string address, string userName, string password) { var request = new PasswordTokenRequest() { Address = address, ClientCredentialStyle = ClientCredentialStyle.AuthorizationHeader, ClientId = this._option.ClientId, ClientSecret = this._option.ClientSecret, UserName = userName, Password = password, Scope = string.Join(" ", this._option.Scopes), }; return(request); }
protected virtual Task <PasswordTokenRequest> CreatePasswordTokenRequestAsync(DiscoveryDocumentResponse discoveryResponse, IdentityClientConfiguration configuration) { var request = new PasswordTokenRequest { Address = discoveryResponse.TokenEndpoint, Scope = configuration.Scope, ClientId = configuration.ClientId, ClientSecret = configuration.ClientSecret, UserName = configuration.UserName, Password = configuration.UserPassword }; AddParametersToRequestAsync(configuration, request); return(Task.FromResult(request)); }
public static TokenResponse LoginUsingIdentityServer(string is4ip, string clientId, string clientSecret, string scope, string username, string password) { var client = new HttpClient(); PasswordTokenRequest tokenRequest = new PasswordTokenRequest() { Address = is4ip, ClientId = clientId, ClientSecret = clientSecret, UserName = username, Password = password, Scope = scope }; return(client.RequestPasswordTokenAsync(tokenRequest).Result); }
async Task <TokenResponse> GetAccessTokenUsingUsernameAndPassword(DiscoveryDocumentResponse disco) { var tokenClient = new HttpClient(); var pwdReq = new PasswordTokenRequest { ClientId = "consoleApp", ClientSecret = "Console_App", Address = disco.TokenEndpoint, UserName = "******", Password = "******", Scope = "accountApi" }; return(await tokenClient.RequestPasswordTokenAsync(pwdReq)); }
public async Task <TokenStore> GetToken(string userName, string password) { if (_currentToken == null || string.IsNullOrWhiteSpace(_currentToken.RefreshToken)) { _logger.LogDebug("Token does not exist or is invalid"); var request = new PasswordTokenRequest { Address = TokenUrl, GrantType = OidcConstants.GrantTypes.Password, Scope = Scope, UserName = userName, Password = password }; request.Headers.Add(AuthHeaderName, BasicAuthHeader); var client = _clientFactory.CreateClient(Constants.TokenServiceClientName); var result = await client.RequestPasswordTokenAsync(request); var tokenStore = new TokenStore(result); _store.AddOrUpdate(tokenStore); _currentToken = tokenStore; } else if (_currentToken.Expired) { _logger.LogDebug("Token has expired, requesting new token from refresh token"); var refreshRequest = new RefreshTokenRequest { Address = TokenUrl, GrantType = OidcConstants.GrantTypes.RefreshToken, Scope = RefreshTokenScope, RefreshToken = _currentToken.RefreshToken }; refreshRequest.Headers.Add(AuthHeaderName, BasicAuthHeader); var client = _clientFactory.CreateClient(Constants.TokenServiceClientName); var refreshResult = await client.RequestRefreshTokenAsync(refreshRequest); var tokenStore = new TokenStore(refreshResult); _store.AddOrUpdate(tokenStore); _currentToken = tokenStore; } return(_currentToken); }
private async Task <TokenResponse> LoginGetAccesstoken(HttpClient client, string clientid, string ClientSecret, string UserName, string Password, string TokenEndpoint) { var ptr = new PasswordTokenRequest(); ptr.Address = TokenEndpoint; ptr.ClientId = clientid; ptr.ClientSecret = ClientSecret; ptr.UserName = UserName; ptr.Password = Password; var tokenResponse = await client.RequestPasswordTokenAsync(ptr); return(tokenResponse); }
static async Task <TokenResponse> GetUserToken() { var client = new HttpClient(); var passwordTokenRequest = new PasswordTokenRequest { Address = "http://localhost:5000/connect/token", ClientId = "carbon", ClientSecret = "21B5F798-BE55-42BC-8AA8-0025B903DC3B", UserName = "******", Password = "******", Scope = "api1" }; var response = await client.RequestPasswordTokenAsync(passwordTokenRequest); return(response); }
public static void Main(string[] args) { var passwordRequest = new PasswordTokenRequest { Address = "http://bnu-vtec012:7600/auth/realms/master/protocol/openid-connect/token", ClientId = "producer-api", ClientSecret = "54835680-02b3-4477-a5bc-a5b3cafe223d", UserName = "******", Password = "******", Scope = "openid profile email updated_at groups", }; var passwordResponse = _client.RequestPasswordTokenAsync(passwordRequest).Result; var random = new Random(); try { for (int index = 0; index < 10000; ++index) { var request = new { Url = "http://localhost:5004/api/contabilizacao", Body = new { RequestID = Guid.NewGuid(), IDEmpresa = $"{random.Next(0, 10_000)}-msg_index:{index}", IDFilial = random.Next(0, 10_000), DataEmissao = new DateTime(1980, 1, 1).AddDays(random.Next(0, 11_000)), DataEntrada = new DateTime(1980, 1, 1).AddDays(random.Next(0, 11_000)), TipoRegistro = random.Next(0, 10_000), //Tag = "sucesso" //Tag = "erro-aleatorio-de-infra" Tag = "erro-msg-invalida" }, }; _client.SetBearerToken(passwordResponse.AccessToken); var httpResponse = _client.PostAsync(request.Url, ContentHelper.GetStringContent(request.Body)).Result; Console.WriteLine($"Mensagem {request.Body.RequestID} Ãndice {index} enviada com sucesso"); } } catch (Exception exception) { Console.WriteLine(exception); } }
public async Task <IActionResult> ResourceOwnerPasswordLogin([FromBody][Required] LoginModel model) { try { var configuration = await _oidcOptions.ConfigurationManager.GetConfigurationAsync(default(CancellationToken)); var client = _httpClientFactory.CreateClient(); var request = new PasswordTokenRequest { Address = configuration.TokenEndpoint, ClientId = _oidcOptions.ClientId, ClientSecret = _oidcOptions.ClientSecret, UserName = model.UserName, Password = model.Password, Scope = OpenIdConnectDefaults.AuthenticationScheme }; request.Parameters.Add("resource", _oidcOptions.ClientId); var response = await client.RequestPasswordTokenAsync(request); if (response.IsError) { _logger.LogWarning($"Error RequestPasswordTokenAsync: {response.Error}, {response.ErrorDescription} "); return(StatusCode(StatusCodes.Status401Unauthorized)); } var properties = new AuthenticationProperties(); if (_oidcOptions.SaveTokens) { properties.UpdateTokenValue("access_token", response.AccessToken); properties.UpdateTokenValue("refresh_token", response.RefreshToken); DateTime newExpiresAt = DateTime.UtcNow + TimeSpan.FromSeconds(response.ExpiresIn); properties.UpdateTokenValue("expires_at", newExpiresAt.ToString("o", CultureInfo.InvariantCulture)); } var principal = ValidateAndDecode(response.AccessToken, configuration.SigningKeys, configuration.Issuer, _oidcOptions.ClientId); await HttpContext.SignInAsync(principal, properties); return(StatusCode(StatusCodes.Status200OK)); } catch (Exception ex) { _logger.LogWarning("Error ResourceOwnerPasswordLogin: {error}", ex); return(StatusCode(StatusCodes.Status401Unauthorized)); } }
public async Task <bool> CreateClient(ClientApiDto clientApi) { // discover endpoints from metadata var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync(IdentityEndpoint.Discovery); if (disco.IsError) { return(false); } // request token var req = new PasswordTokenRequest { Address = disco.TokenEndpoint, ClientId = IdentityEndpoint.ClientID, ClientSecret = IdentityEndpoint.Secret, Scope = IdentityEndpoint.Scopes, UserName = IdentityEndpoint.UserName, Password = IdentityEndpoint.Password }; var tokenResponse = await client.RequestPasswordTokenAsync(req); if (tokenResponse.IsError) { return(false); } var apiClient = new HttpClient(); apiClient.SetBearerToken(tokenResponse.AccessToken); var dataJson = JsonSerializer.Serialize(clientApi); var stringContent = new StringContent(dataJson, Encoding.UTF8, "application/json"); var response = await apiClient.PostAsync(IdentityEndpoint.ClientUri, stringContent); if (response.IsSuccessStatusCode) { var resDeserialize = await JsonHelper.Deserialize <ClientApiDto>(response, defaultOptions); clientApi.Id = resDeserialize.Id; } return(response.IsSuccessStatusCode); }
/// <summary> /// Makes an object that represents a requestUrl, to an Identity Server, for access by this /// API on behalf of a User, as identified by the User's username/password credentials. /// </summary> /// <param name="tokenEndpoint">The URI of the target Identity Server's Token EndPoint.</param> /// <param name="username">The Username of the requesting User.</param> /// <param name="password">the Password of the requesting User.</param> /// <returns>A new requestUrl object.</returns> /// private PasswordTokenRequest MakeApiAccessTokenRequest(string tokenEndpoint, string username, string password) { var request = new PasswordTokenRequest { Address = tokenEndpoint, ClientId = "AccountsCli.ro", ClientSecret = _clientSecret, Scope = $"{ApplicationScopes.USER_MANAGEMENT_API } {ApplicationScopes.ACCOUNTS_API} offline_access openid profile", UserName = username, Password = password }; return(request); }
protected virtual Task <PasswordTokenRequest> CreatePasswordTokenRequestAsync(string tokenEndpoint, IdentityClientConfiguration configuration) { var request = new PasswordTokenRequest { Address = tokenEndpoint, Scope = configuration.Scope, ClientId = configuration.ClientId, ClientSecret = configuration.ClientSecret, UserName = configuration.UserName, Password = configuration.UserPassword }; IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage?.Invoke(request); AddParametersToRequestAsync(configuration, request); return(Task.FromResult(request)); }
private async Task <TokenResponse> RequestPasswordTokenAsync() { var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync(AppSettings.Authority); var passwordTokenRequest = new PasswordTokenRequest { Address = disco.TokenEndpoint, ClientId = AppSettings.ClientId, ClientSecret = AppSettings.ClientSecret, Scope = AppSettings.Scope, UserName = AppSettings.UserUsername, Password = AppSettings.UserPassword }; return(await client.RequestPasswordTokenAsync(passwordTokenRequest)); }
public async Task <APIToken> GetIdentityToken(LoginViewModel user) { string tokenEndPoint = await GetTokenEndPoint(); var req = new PasswordTokenRequest { Address = tokenEndPoint, ClientId = "identity.client", ClientSecret = "anothersecret", Scope = "IdentityServerApi", UserName = user.UserName, Password = user.Password }; return(await GetToken(req)); }
private static async Task <string> GetTokenAsync() { using (var httpClient = new HttpClient { BaseAddress = new Uri("http://localhost:44362") }) { var document = await httpClient.GetDiscoveryDocumentAsync(); if (!document.IsError) { var tokenEndpoint = document.TokenEndpoint; //Task<TokenResponse> RequestAuthorizationCodeTokenAsync(AuthorizationCodeTokenRequest) //Task<TokenResponse> RequestClientCredentialsTokenAsync(ClientCredentialsTokenRequest) //Task<TokenResponse> RequestDeviceTokenAsync(DeviceTokenRequest) //Task<TokenResponse> RequestPasswordTokenAsync(PasswordTokenRequest) //Task<TokenResponse> RequestRefreshTokenAsync(RefreshTokenRequest) //Task<TokenResponse> RequestTokenAsync(TokenRequest) var request = new PasswordTokenRequest { RequestUri = new Uri(tokenEndpoint), ClientId = "EmergencyResponseService_App", UserName = "******", Password = "******" }; request.Headers.Add("__tenant", "39fe0e34-6c58-c5d7-ed25-0b0c9275a1f0"); var tokenResponse = await httpClient.RequestPasswordTokenAsync(request); if (!tokenResponse.IsError) { ValidToken(tokenResponse.AccessToken); Console.WriteLine(tokenResponse); return($"{tokenResponse.TokenType} {tokenResponse.AccessToken}"); } } } return(""); }
public async Task User_authenticated() { var discoveryDocument = await _client.GetDiscoveryDocumentAsync(); Assert.False(discoveryDocument.IsError); using var request = new PasswordTokenRequest() { Address = discoveryDocument.TokenEndpoint, ClientId = "PublicApi", UserName = "******", Password = "******" }; var response = await _client.RequestPasswordTokenAsync(request); Assert.False(response.IsError, response.Error); Assert.NotNull(response.AccessToken); }
public async Task <TokenResponse> GetToken() { Console.WriteLine("Getting access token"); var request = new PasswordTokenRequest { Address = IdentityServerUrl, GrantType = "Password", ClientId = MessagingClientId, ClientSecret = MessagingClientSecret, Scope = MessagingApiId, UserName = _username, Password = _password }; return(await _client.RequestPasswordTokenAsync(request)); }
public async Task GivenAnUserIsLoggedInWithUsernameAndPassword(Table table) { var discoveryAddress = Configuration.GetValue <string>("DiscoveryAddress"); using var client = new HttpClient(); using var discoveryDocumentRequest = new DiscoveryDocumentRequest { Policy = new DiscoveryPolicy { RequireHttps = false }, Address = discoveryAddress, }; var discoveryDocument = await client.GetDiscoveryDocumentAsync(discoveryDocumentRequest); if (discoveryDocument.IsError) { Console.WriteLine(discoveryDocument.Error); return; } var user = table.CreateSet <UserTable>().First(); using var passwordTokenRequest = new PasswordTokenRequest { Address = discoveryDocument.TokenEndpoint, ClientId = "PasswordClient", ClientSecret = "PasswordSecret", UserName = user.Username, Password = user.Password, Scope = user.Scope, }; TokenResponse tokenResponse = await client.RequestPasswordTokenAsync(passwordTokenRequest); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); return; } context[ScenarioContextKeys.AccessToken] = tokenResponse.AccessToken; }
static async Task MainAsync(string[] args) { /* Discover endpoints from metadata */ using (var client = new HttpClient()) { var disco = await client.GetDiscoveryDocumentAsync("http://localhost:18000"); if (disco.IsError) { Console.WriteLine(disco.Error); } else { Console.WriteLine("Discovery document it was successfully."); } /* Create request */ var tokenRequest = new PasswordTokenRequest { Address = disco.TokenEndpoint, ClientId = "onlinestoreclient", ClientSecret = "onlinestoreclientsecret1", UserName = "******", Password = "******" }; var tokenResponse = await client.RequestPasswordTokenAsync(tokenRequest); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); } else { Console.WriteLine("Connection for '{0}' user was successfully.", tokenRequest.UserName); } } Console.ReadLine(); }
static async Task Main(string[] args) { var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000"); if (disco.IsError) { throw new Exception(disco.Error); } //ClientCredentialsTokenRequest tokenRequest = new ClientCredentialsTokenRequest //{ // Address=disco.TokenEndpoint, // ClientId= "client", // ClientSecret= "Secret", // Scope= "api1" //}; //TokenResponse tokenResponse = await client.RequestClientCredentialsTokenAsync(tokenRequest); PasswordTokenRequest tokenRequest = new PasswordTokenRequest { Address = disco.TokenEndpoint, ClientId = "pwd_client", ClientSecret = "Secret", Scope = "api1", UserName = "******", Password = "******" }; TokenResponse tokenResponse = await client.RequestPasswordTokenAsync(tokenRequest); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); } client.SetBearerToken(tokenResponse.AccessToken); string result = await client.GetStringAsync("http://localhost:5001/api/values"); Console.WriteLine(result); Console.WriteLine("Hello World!"); Console.ReadKey(); }
protected virtual async Task <PasswordTokenRequest> CreatePasswordTokenRequestAsync(IdentityClientConfiguration configuration) { var discoveryResponse = await GetDiscoveryResponse(configuration); var request = new PasswordTokenRequest { Address = discoveryResponse.TokenEndpoint, Scope = configuration.Scope, ClientId = configuration.ClientId, ClientSecret = configuration.ClientSecret, UserName = configuration.UserName, Password = configuration.UserPassword }; IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage?.Invoke(request); await AddParametersToRequestAsync(configuration, request); return(request); }
public async Task <APIToken> GetAPIToken(LoginViewModel user) { string tokenEndPoint = await GetTokenEndPoint(); var req = new PasswordTokenRequest { Address = tokenEndPoint, ClientId = "api.client", ClientSecret = "secret", Scope = "api1", UserName = user.UserName, Password = user.Password, }; APIToken token = await GetToken(req); _context.HttpContext.Response.Cookies.Append("UserName", user.UserName); return(token); }
public static async Task <TokenResponse> GetMastpenCustomerTokenAsync(string userName, string password) { using (var client = new HttpClient()) { var settings = ClientSettingsMocker.GetMastpenIdentityClientSettings(userName, password); var disco = await client.GetDiscoveryDocumentAsync(settings.Url); var req = new PasswordTokenRequest { Address = disco.TokenEndpoint, ClientId = settings.ClientId, ClientSecret = settings.ClientSecret, UserName = settings.UserName, Password = settings.Password }; var vv = await client.RequestPasswordTokenAsync(req); return(vv); } }
private async Task <TokenResponse> RequestTokenAsync(string userName, string password) { var httpClient = _httpClientFactory.CreateClient(_options.AuthorityHttpClientName); var tokenEndpoint = await _options.GetTokenEndpointAsync(httpClient).ConfigureAwait(false); var tokenRequest = new PasswordTokenRequest { Address = tokenEndpoint, GrantType = _options.GrantType, ClientId = _options.ClientId, ClientSecret = _options.ClientSecret, Scope = _options.Scope, UserName = userName, Password = password }; tokenRequest.Parameters.AddRange(_options.ExtraTokenParameters); var tokenResponse = await httpClient.RequestPasswordTokenAsync(tokenRequest).ConfigureAwait(false); return(tokenResponse); }
public async Task <bool> UpdateResource(ApiResourceApiDto resourceApiDto) { // discover endpoints from metadata var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync(IdentityEndpoint.Discovery); if (disco.IsError) { return(false); } // request token var req = new PasswordTokenRequest { Address = disco.TokenEndpoint, ClientId = IdentityEndpoint.ClientID, ClientSecret = IdentityEndpoint.Secret, Scope = IdentityEndpoint.Scopes, UserName = IdentityEndpoint.UserName, Password = IdentityEndpoint.Password }; var tokenResponse = await client.RequestPasswordTokenAsync(req); if (tokenResponse.IsError) { return(false); } var apiClient = new HttpClient(); apiClient.SetBearerToken(tokenResponse.AccessToken); var dataJson = JsonSerializer.Serialize(resourceApiDto); var stringContent = new StringContent(dataJson, Encoding.UTF8, "application/json"); var response = await apiClient.PutAsync(IdentityEndpoint.ResourceUri, stringContent); return(response.IsSuccessStatusCode); }
public static async Task <System.Net.Http.HttpClient> CreateAuthClientAsync(this WebApplicationFactory <Startup> factory) { var apiClient = factory.CreateClient(); // auth to STS var srvConfiguration = (IConfiguration)factory.Server.Host.Services.GetService(typeof(IConfiguration)); var srvIdentityUrl = srvConfiguration["IdentityServiceUrl"]; using (var identityClient = new System.Net.Http.HttpClient()) { identityClient.BaseAddress = new Uri(srvIdentityUrl); var discoveryResponse = await identityClient.GetDiscoveryDocumentAsync(); if (discoveryResponse.IsError) { throw new Exception($"Identity service at {srvIdentityUrl} failed or not running. {discoveryResponse.Error}", discoveryResponse.Exception); } // use custom local account password for testing purpose var request = new PasswordTokenRequest(); request.Address = discoveryResponse.TokenEndpoint; request.ClientCredentialStyle = ClientCredentialStyle.PostBody; request.Scope = "data"; request.ClientId = "api.client.test"; request.ClientSecret = srvConfiguration["TestUser:ClientSecret"]; request.UserName = srvConfiguration["TestUser:Name"]; request.Password = srvConfiguration["TestUser:Password"]; var tokenResponse = await identityClient.RequestPasswordTokenAsync(request); if (tokenResponse.IsError) { throw new Exception($"Authentication failed! {tokenResponse.Error} {tokenResponse.ErrorDescription}", tokenResponse.Exception); } apiClient.SetBearerToken(tokenResponse.AccessToken); } return(apiClient); }
/// <summary> /// Obtains an Access Token from an Identity Server using username/password credentials that were /// known or obtained by the client. To be used by native clients only. /// </summary> /// <param name="request">Represents the user's login credentials.</param> /// <returns> /// A <c>TokenResponse</c> instance containing the user's Access Token and (if supported by /// this Identity Server for this Client) a Refresh Token. /// </returns> /// private async Task <TokenResponse> RequestAccessTokenAsync(PasswordTokenRequest request) { TokenResponse tokenResponse; using (var client = new HttpClient()) { // Use this requestUrl for clients that cannot host a login page and must obtain (or just know) the credentials themselves. tokenResponse = await client.RequestPasswordTokenAsync(request); } // if (tokenResponse.IsError) // { // Console.WriteLine(tokenResponse.Error); // } // else // { // Console.WriteLine(tokenResponse.Json); // Console.WriteLine("\n\n"); // } return(tokenResponse); }
public async Task <ActionResult> GetTokenForMobileAppAsync(String username, String password) { Boolean isDoctor = false; AspNetUsers user = _context.AspNetUsers.Where(a => a.UserName == username).FirstOrDefault(); //Get userID first. if (user != null) { isDoctor = true; } // Call API to get the token var apiClientCredentials = new PasswordTokenRequest { Address = Messages.AUTH_IP_ADDRESS_URL + "/connect/token", ClientId = "ro.client", ClientSecret = "secret", // This is the scope our Protected API requires. Scope = "openid email profile doctalk_auth_api", UserName = username, Password = password }; var client = new HttpClient(); // 1. Authenticates and get an access token from Identity Server var tokenResponse = await client.RequestPasswordTokenAsync(apiClientCredentials); var result_token = tokenResponse.Json; result_token.Add("isDoctor", isDoctor); if (tokenResponse.IsError) { Console.WriteLine("Cannot get the data"); return(StatusCode(500)); } return(Ok(result_token)); }
/// <summary> /// Request the resource owner credentials. /// </summary> /// <param name="userName">Contains the user name.</param> /// <param name="password">Contains the user password.</param> /// <param name="scopes">Contains the scopes.</param> /// <param name="cancellationToken">Contains a cancellation token.</param> /// <returns>Returns a <see cref="TokenResponse"/> object.</returns> protected async Task <TokenResponse> RequestResourceOwnerPasswordAsync(string userName, string password, string scopes, CancellationToken cancellationToken) { TokenResponse result; using (HttpClient client = new HttpClient()) { var config = new PasswordTokenRequest { Address = this.TokenEndpoint, ClientId = this.Config.ClientId, Scope = scopes, ClientSecret = this.Config.ClientSecret, UserName = userName, Password = password }; result = await client.RequestPasswordTokenAsync(config, cancellationToken) .ConfigureAwait(false); } return(result); }