ASP.NET Core v1.1: Login
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 integrate with my app15 minutes
I want to explore a sample app2 minutes
Get a sample configured with your account settings or check it out on Github.
How it works
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:
- Client ID
- Client Secret
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
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.
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.
To integrate Auth0 with ASP.NET Core you will use the Cookie and OpenID Connect (OIDC) Middleware. Add the
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
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
Add Login and Logout Methods
Next, you will need to add
Logout actions to the
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
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
Login actions of the
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
- The user clicks on the Login link and is directed to the
- This returns a
ChallengeResultwhich instructs the ASP.NET Authentication middleware to issue a challenge to the Authentication middleware which is registered with the
Auth0. (When we created the instance of
Startupclass 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).
- At this point the OIDC middleware is challenged, and it will redirect the user to the Auth0
/authorizeendpoint, which will display Lock and require the user to log in - whether it be with username/password, social provider or any other Identity Provider.
- Once the user has logged in, Auth0 will call back to the
/callbackendpoint in your application and pass along an authorization code.
- The OIDC middleware will "listen" for any request made to the
/callbackpath and intercept it. It will look for the authorization code which Auth0 sent in the query string and then call the
/oauth/tokenendpoint to exchange the authorization code for an ID Token and Access Token.
- The OIDC middleware will look at the ID Token and extract the user information from the claims on the token.
- 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
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
For general information on using APIs with web applications, please read Authorization Code Flow.