ASP.NET Core v1.1: Login

View on Github

ASP.NET Core v1.1: Login

Gravatar for
By Damien Guard

This tutorial demonstrates how to add user login to an ASP.NET Core 1.x application. We recommend you to Log in to follow this quickstart with examples configured for your account.

I want to explore a sample app

2 minutes

Get a sample configured with your account settings or check it out on Github.

View on Github
System requirements: .NET Core SDK 1.1.0 | ASP.NET Core 1.1.1 | Microsoft Visual Studio 2017 Update 3 or .NET core command line tools

How it works

Configure Auth0

How to implement it

Get Your Application Keys

When you signed up for Auth0, a new application was created for you, or you could have created a new one.

You will need some details about that application to communicate with Auth0. You can get these details from the Application Settings section in the Auth0 dashboard.

You need the following information:

  • Domain
  • Client ID
  • Client Secret

If you download the sample from the top of this page these details are filled out for you.

If you have more than one application in your account, the sample comes with the values for your Default App.

App Dashboard

Keep reading

Configure Callback URLs

The Callback URL of your application is the URL where Auth0 will redirect to after the user has authenticated in order for the OpenID Connect middleware to complete the authentication process.

You will need to add this URL to the list of Allowed URLs for your application. The Callback URL for the seed project is http://localhost:3000/callback, so be sure to add this to the Allowed Callback URLs section of your application.

If you deploy your application to a different URL you will also need to ensure to add that URL to the Allowed Callback URLs. For ASP.NET Core this URL will take the format http://YOUR_APPLICATION_URL/callback.

Configure Logout URLs

A logout URL is a URL in your application that Auth0 can return to after the user has been logged out of the authorization server. This is specified in the returnTo query parameter.

The logout URL for your app must be whitelisted in the Allowed Logout URLs field in your Application Settings. If this field is not set, users will be unable to log out from the application and will get an error.

If you are following along with the sample project you downloaded from the top of this page, the logout URL you need to whitelist in the Allowed Logout URLs field is http://localhost:3000.

Configure JSON Web Token Signature Algorithm

The ASP.NET Core OpenID Connect (OIDC) middleware which will be used to authenticate the user, requires that the JSON Web Token (JWT) be signed with an asymmetric key. To configure this go to the settings for your application in the Auth0 Dashboard, scroll down and click on Show Advanced Settings. Go to the OAuth tab and set the JsonWebToken Signature Algorithm to RS256.

Save your changes.

Configure your application to use Auth0

Universal Login is the easiest way to set up authentication in your application. We recommend using it for the best experience, best security and the fullest array of features. This guide will use it to provide a way for your users to log in to your ASP.NET Core application.

You can also create a custom login for prompting the user for their username and password. To learn how to do this in your application, follow the Custom Login sample.

Install dependencies

To integrate Auth0 with ASP.NET Core you will use the Cookie and OpenID Connect (OIDC) Middleware. Add the Microsoft.AspNetCore.Authentication.Cookies and Microsoft.AspNetCore.Authentication.OpenIdConnect packages to your application.

Configure the OpenID Connect middleware

The easiest way to enable authentication with Auth0 in your ASP.NET Core application is to use the OpenID Connect middleware. First, go to the ConfigureServices method of your Startup class and add the authentication services by calling the AddAuthentication method:

Next, in the Configure method of the Startup class add the cookie middleware and the OpenID Connect middleware. Middleware executes in the order they are registered so it is important to register the cookie middleware first, and then the OIDC middleware.

Both of these middleware should be registered before your MVC middleware in order for your controllers to be protected. The OIDC middleware is required in order to authenticate the user with Auth0. Once the user has authenticated they will be signed into the Cookie middleware which will be used to authenticate all subsequent requests.

Also note above that the list of scopes is cleared and only the openid scope is requested. By default the OIDC middleware will request both the openid and the profile scopes and can result in a large ID Token being returned. It is suggested that you be more explicit about the scopes you want to be returned and not ask for the entire profile to be returned. Requesting additional scopes is discussed later in the User Profile step.

Obtaining an Access Token for calling an API

You may want to call an API from your MVC application, in which case you need to obtain an Access Token which was issued for the particular API you want to call. In this case you will need to pass an extra audience parameter containing the API Identifier to the Auth0 authorization endpoint.

If you want to do this, simply handle the OnRedirectToIdentityProvider event when configuring the OpenIdConnectOptions object, and add the audience parameter to the ProtocolMessage.

Trigger authentication

Add Login and Logout Methods

Next, you will need to add Login and Logout actions to the AccountController.

For the Login, you will need to return a ChallengeResult and specify "Auth0" as the authentication scheme which will be challenged. This will invoke the OIDC middleware you registered in the Configure method.

After the OIDC middleware has signed the user in, the user will automatically be signed into the cookie middleware as well to authenticate them on subsequent requests. So, for the Logout action you will need to sign the user out of both the OIDC and the cookie middleware:

At this point ASP.NET Core will call SignOutAsync for the Auth0 authentication scheme (such as the OIDC middleware), but the OIDC middleware does not know what the actual Logout URL is it should call to log the user out of Auth0. To do this you should handle the OnRedirectToIdentityProviderForSignOut event when registering the OIDC middleware.

So back in the Startup.cs file, update the instantiation of OpenIdConnectOptions with the following code:

This will ensure that when SignOutAsync is called for the OIDC Middleware, that the /v2/logout endpoint of the Auth0 Authentication API is called to log the user out of Auth0.

It will also pass along the Redirect URL (when specified) in the returnTo parameter. You must therefore ensure that you have specified this URL in the Allowed Logout URLs for your application in the Auth0 Dashboard.

Lastly, add Login and Logout links to the navigation bar. To do that, head over to /Views/Shared/_Layout.cshtml and add code to the navigation bar section which displays a Logout link when the user is authenticated, otherwise a Login link. These will link to the Logout and Login actions of the AccountController respectively:

Run the Application

Now, when you run the application you can select the Login link to log into the application. This will challenge the OIDC middleware which will subsequently redirect you to the hosted version of Lock on your Auth0 domain.

Understanding the Login Flow

  1. The user clicks on the Login link and is directed to the Login route.
  2. This returns a ChallengeResult which instructs the ASP.NET Authentication middleware to issue a challenge to the Authentication middleware which is registered with the authenticationScheme of Auth0. (When we created the instance of OpenIdConnectOptions in the Startup class we passed a value of Auth0 to the constructor. This is the authentication scheme, so that is why the authentication middleware knows to challenge this OIDC middleware to authenticate the user).
  3. At this point the OIDC middleware is challenged, and it will redirect the user to the Auth0 /authorize endpoint, which will display Lock and require the user to log in - whether it be with username/password, social provider or any other Identity Provider.
  4. Once the user has logged in, Auth0 will call back to the /callback endpoint in your application and pass along an authorization code.
  5. The OIDC middleware will "listen" for any request made to the /callback path and intercept it. It will look for the authorization code which Auth0 sent in the query string and then call the /oauth/token endpoint to exchange the authorization code for an ID Token and Access Token.
  6. The OIDC middleware will look at the ID Token and extract the user information from the claims on the token.
  7. Finally the OIDC middleware will return a successful authentication response, which will result in a cookie being stored indicating that the user is authenticated, and the cookie will also contain claims with the user's information. This means that on all subsequent requests the cookie middleware will automatically authenticate the user, and no further requests will be made to the OIDC middleware (unless explicitly challenged).

Storing the Tokens

The OIDC middleware in ASP.NET Core will automatically Decode the ID Token returned from Auth0 and will automatically add the claims contained in the ID Token as claims on the ClaimsIdentity. This means that inside any of the actions in your controllers you can simply use User.Claims.FirstOrDefault("<claim type>").Value to obtain the value of a particular claim.

The seed project contains a controller action and view which will display the claims associated with a particular user. Once a user has signed in, you can simply go to /Account/Claims to see these claims.

Sometimes you may want to access the tokens received from Auth0. For example, you may want to get the Access Token to authenticate against API calls. In order to do this, you will need to set the SaveTokens property of OpenIdConnectOptions to true. This will save the tokens to the AuthenticationProperties:

To subsequently retrieve either of the tokens you can call GetAuthenticateInfoAsync to retrieve the AuthenticateInfo. The tokens will be available in the Properties of the AuthenticateInfo object, stored in the format .Token.<token name>:

For general information on using APIs with web applications, please read Authorization Code Flow.

Use Auth0 for FREE