How do I enforce 2FA in .Net Core Identity?

user_12597575 0
Viewed 665

Question: How can I enforce existing users to set up 2FA in .Net Core 3.1 Identity?

I have seen a couple of answers here already, but I have issues with them as follows:

  1. Redirect user to set up 2FA page on login if they do not have it set up. Problem with this is that the user can simply jump to a different url to avoid this, therefore it is not actually enforced.

  2. Have some on executing filter that checks if the user has 2FA enbaled or not and if not redirect them to MFA set up page. The issue I have with this is that on every single navigation the server must go to the database to check whether the user has this field enabled, thus creating a significant performance hit on each request. I know one trip to the database may not sound like much but I have worked with applications where this was the norm and other things used this method, causing a pile up of pre action db queries. I want to avoid this kind of behavior unless absolutely necessary.

My current idea is to on login:

  1. Check the users credentials but NOT log them in

    userManager.CheckPasswordAsync(....)

  2. If the credentials pass, check if the user has 2FA enabled or not. If they do, continue through login flow, if not:

  3. Generate a user token:

    userManager.GenerateUserTokenAsync(.......)

and store this along with the username in a server side cache. Then pass a key to the cached items with a redirect to the 2FA setup page, which will not have the [authorize] attribute set, allowing users not logged in to access it.

  1. Before doing anything on the 2FA set up page, retrieve the cached items with the provied key andverify the token and username:

    userManager.VerifyUserTokenAsync(......)

  2. If this doesn't pass, return Unauthorized otherwise continue and get the current user from the supplied UserName in the url that was passed via a cache key. Also dump the cached items and key so that should the url be snatched by a dodgy browser extension it can't be used again.

  3. Continue to pass a new cache key to new user tokens and usernames to each 2FA page to authenticate the user as they navigate.

Is this an appropriate use of user tokens? And is this approach secure enough? I'm concerned that having the user not logged in presents security issues, but I think it is necessary in order to avoid the previously mention problem of going to the database on every request to check 2FA, as with this method trying to navigate away will just redirect to login.

asp.net-core-identity asp.net-core authentication
2 Answers

I implemented this via a Filter Method

I have a BasePageModel which all my pages inherit

public override async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
    if (!User.Identity.IsAuthenticated)
    {
        await next.Invoke();

        return;
    }

    var user = await UserManager.GetUserAsync(User);

    var allowedPages = new List<string>
    {
        "Areas_Identity_Pages_Account_ConfirmEmail",
        "Areas_Identity_Pages_Account_ConfirmEmailChange",
        "Areas_Identity_Pages_Account_Logout",
        "Areas_Identity_Pages_Account_Manage_EnableAuthenticator",
        "Areas_Identity_Pages_Account_ResetPassword",
        "Pages_AllowedPageX",
        "Pages_AllowedPageY",
        "Pages_Privacy"
    };

    var page = context.ActionDescriptor.PageTypeInfo.Name;

    if (!user.TwoFactorEnabled && allowedPages.All(p => p != page))
    {
        context.Result = RedirectToPage("/Account/Manage/EnableAuthenticator", new { area = "Identity" });
    }
    else
    {
        await next.Invoke();
    }
}

I then changed both the Disable2fa and ResetAuthenticator pages to redirect to the main 2fa page

public IActionResult OnGet() => RedirectToPage("./TwoFactorAuthentication");

And removed the reset/disable links from that page

user_2431890

I chose to implement a more modern and OAuth friendly solution (which is inline with .Net Core Identity).

Firstly, I created a custom claims principal factory that extends UserClaimsPrincipalFactory.

This allows us to add claims to the user when the runtime user object is built (I'm sorry I don't know the official name for this, but its the same thing as the User property you see on controllers).

In here I added a claim 'amr' (which is the standard name for authentication method as described in RFC 8176). That will either be set to pwd or mfa depending on whether they simply used a password or are set up with mfa.

Next, I added a custom authorize attribute that checks for this claim. If the claim is set to pwd, the authorization handler fails. This attribute is then set on all controllers that aren't to do with MFA, that way the user can still get in to set up MFA, but nothing else.

The only downside with this technique is the dev needs to remember to add that attribute to every non MFA controller, but aside from that, it works quite well as the claims are stored in the users' cookie (which isn't modifiable), so the performance hit is very small.

Hope this helps someone else, and this is what I read as a base for my solution: https://damienbod.com/2019/12/16/force-asp-net-core-openid-connect-client-to-require-mfa/ https://docs.microsoft.com/en-us/aspnet/core/security/authentication/mfa?view=aspnetcore-5.0#force-aspnet-core-openid-connect-client-to-require-mfa

user_125975750
Related