In .NET Core, the ClaimsIdentity class represents a user in your application. It helps describe who they are and helps manage the list of claims which describe what they can do.  But if you use the wrong constructor on ClaimsIdentity or provide the subtly wrong information to that constructor, you might see some strange behavior.

Two examples of strange ClaimsIdentity behavior:

1. You have what you think is a ClaimsIdentity for an authenticated user but the IsAuthenticated property returns false.  Basically, ClaimsIdentity.IsAuthenticated says that the user isn't authenticated.
2. You've got a ClaimsIdentity for a user but the Name property is always null

When you're coding, ClaimsIdentity usually works as a team with ClaimsPrincipal.  ClaimsPrincipal wraps an instance of ClaimsIdentity and provides helpful methods like IsInRole() to help decide if a user is authorized to perform particular actions.  If you make a mistake with ClaimsIdentity, it's entirely possible that ClaimsPrincipal.IsInRole() starts giving you strange answers, too.

For all of these issues, the place that you're most likely to encounter problems is if you're writing custom ASP.NET Middleware to add custom logic to your ASP.NET app's security.

Let's dive in to the problems and solutions.

BTW, the source code for this blog post is posted on GitHub.

Problem #1: ClaimsIdentity.IsAuthenticated is always False

Let's say that you create an instance of ClaimsIdentity using the default (empty) constructor.

var identity = new ClaimsIdentity();

If you check identity.IsAuthenticated, it's going to say 'false'.  To fix this, you need to call a ClaimsIdentity constructor that takes an authenticationType parameter.  For example, this code:

var identity = new ClaimsIdentity(authenticationType: "test");

As long as you provide a non-null, non-empty value for authenticationType, then ClaimsIdentity.IsAuthenticated will return true.

Problem #2: ClaimsIdentity.Name is always null

Let's say that you create an instance of ClaimsIdentity using one of the constructors that takes a list of Claims.  (Technically, it's an IEnumberable but…shrug.)  You get that instance of ClaimsIdentity and you go to access the Name property and it's null.  Why is it null?  How do you populate the ClaimsIdentity.Name value? Before I answer that, I need to talk a bit about Claims.

A Claim is basically a key/value pair that represents some kind of information about the user. Most people think of claims as permissions that the user has in a system but permissions aren't the ONLY thing that you can use claims for.  Claims can be any kind of information about the user.  Email address.  Birth date.  First name.  Last name.  Username.  Pretty much anything you need to know about a user can be implemented as a claim.

The ClaimsIdentity.Name property is populated using a claim. By default, ClaimsIdentity gets that Name property value from a claim with the claim type of ClaimTypes.Name. If you didn't set that value or you didn't set that value properly in the list of Claims you passed in, then that Name property won't get set.

Here's some sample code that populates the Name claim and the ClaimsIdentity.Name property:

[TestMethod]
public void ClaimsIdentity_AuthenticatedIdentityWithClaims_Name_ValueReadFromClaims()
{
    var claims = new List<Claim>();

    var expected = "bingbong@test.org";

    claims.Add(new Claim(ClaimTypes.Name, expected));

    var identity = new ClaimsIdentity(claims, "test");

    var actual = identity.Name;

    Assert.AreEqual<string>(expected, actual, "Name value was wrong.");            
}

How to Read ClaimsIdentity.Name from a Non-default Claim Type

A variation on that ClaimsIdentity.Name property always being null problem is when you need to read the Name property from a non-default claim.  Let's say that you're integrating with some security system that simply does things in a non-standard way.  How do you handle that?

Well, there's a constructor on ClaimsIdentity that allows you to specify which claim type you'll use for the Name property.  Give it a different value and you're done.

Here's some sample code:

[TestMethod]
public void ClaimsIdentity_AuthenticatedIdentityWithClaims_Name_ReadFromNonDefaultClaims()
{
    var customNameClaimType = "custom-name-claim";

    var claims = new List<Claim>();

    var expected = "bingbong@test.org";

    claims.Add(new Claim(customNameClaimType, expected));

    var identity = new ClaimsIdentity(
        claims: claims,
        authenticationType: "test",
        nameType: customNameClaimType,
        roleType: null);

    var actual = identity.Name;

    Assert.AreEqual<string>(expected, actual, "Name value was wrong.");
}

Problem 3: ClaimsPrincipal.IsInRole() says user is not in any roles

ClaimsPrincipal.IsInRole() checks to see if the ClaimsIdentity has a claim that says the user is a member of a certain role.  For example: "Administrators" or "Authenticated Users".  Let's say that you've created an instance of ClaimsIdentity using a list of claims and then used that instance of identity to create an instance of ClaimsPrincipal.  The list of claims you used have a bunch of roles in them but for some reason, when you call IsInRole() for any role name, it always says "false" -- not in role.

Usually, this is because the claims that are passed in to ClaimsIdentity have the wrong ClaimType value for roles.  By default, the claim type for a role should use the constant value of ClaimTypes.Role. But if you want to use a different value, there's a constructor option on ClaimsIdentity that takes roleType.

Here's some code that populates the default role claims:

[TestMethod]
public void ClaimsPrincipal_AuthenticatedIdentityWithClaims_IsInRole_True()
{
    var roleThatShouldExist = "role123";
    var roleThatShouldNotExist = "roleASDF";

    var claims = new List<Claim>();

    claims.Add(new Claim(ClaimTypes.Role, roleThatShouldExist));

    var identity = new ClaimsIdentity(claims, "test");

    var principal = new ClaimsPrincipal(identity);

    Assert.IsTrue(principal.IsInRole(roleThatShouldExist), "IsInRole should be true");
    Assert.IsFalse(principal.IsInRole(roleThatShouldNotExist), "IsInRole should be false");
}

Here's some sample code that uses a non-default role claim:

[TestMethod]
public void ClaimsPrincipal_AuthenticatedIdentityWithClaimsAndNonDefaultRoleClaimName_IsInRole_True()
{
    var nonDefaultRoleClaimName = "nonDefaultRole";

    var roleThatShouldExist = "role123";
    var roleThatShouldNotExist = "roleASDF";

    var claims = new List<Claim>();

    claims.Add(new Claim(nonDefaultRoleClaimName, roleThatShouldExist));
    claims.Add(new Claim(ClaimTypes.Role, roleThatShouldNotExist));

    var identity = new ClaimsIdentity(
        claims,
        "test",
        ClaimTypes.Name,
        roleType: nonDefaultRoleClaimName);

    var principal = new ClaimsPrincipal(identity);

    Assert.IsTrue(principal.IsInRole(roleThatShouldExist), "IsInRole should be true");
    Assert.IsFalse(principal.IsInRole(roleThatShouldNotExist), "IsInRole should be false");
}

Summary

If you're running into weird problems with ClaimsIdentity property values or if ClaimsPrincipal isn't giving you the answers you'd expect, it's probably something strange with how your code initialized ClaimsIdentity.  Make sure that you're setting an authentication type value.  Make sure that you're using the default ClaimTypes.Name and ClaimTypes.Role values for your claims in ClaimsIdentity.  And remember if you need to change the values for the name claim or the role claim, you can change those values by providing a constructor parameter value for nameType and/or roleType.

Want to see all the sample code that I used to create this blog post?  The source code for this blog post is on posted on GitHub.

I hope this helps.

-Ben