Custom User and Claims Stores but no claims get set on Controller.User - asp.net-core-identity

Question

// ASP.NET Identity
serviceRegistry.For<IPasswordHasher<User>>().Add<CustomPasswordHasher>();
serviceRegistry.For<CustomDbContext>()
.Use(s => new DesignTimeDbContextFactory().CreateDbContext(Array.Empty<string>()))
.Scoped();
serviceRegistry.AddTransient<IUserStore<User>, CustomUserStore>();
serviceRegistry.AddTransient<IUserClaimStore<User>, CustomUserStore>();
serviceRegistry.AddIdentityCore<User>();
serviceRegistry.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = IdentityConstants.ApplicationScheme;
options.DefaultChallengeScheme = IdentityConstants.ApplicationScheme;
options.DefaultSignInScheme = IdentityConstants.ExternalScheme;
}).AddIdentityCookies();
I then sign in using the following in my controller action...
var result = await mSignInManager.PasswordSignInAsync(user.Username, model.Password, false, false );
.. and I see UserClaimsPrincipalFactory.GenerateClaimsAsync calling my custom claims store and receiving the expected list of claims.
I have set a break point just beyond the PasswordSignInAsync call but when I look at the User property on the controller there are no claims on there.
Would seem either my config is up the creek, I am missing some code or the order of what I am doing is incorrect or all of the previous! :-(
(All code is work in progress and by no means production ready!)
EDIT:
// I am using Lamar so this is the same as Startup.ConfigureContainer
public static void Configure(ServiceRegistry serviceRegistry, IConfiguration configuration)
{
var clients = ClientHelper.GetClients(configuration);
var tenants = new TenantFactory().CreateTenants(clients);
serviceRegistry.AddHttpContextAccessor();
serviceRegistry.ConfigureOptions<ConfigureMvcOptions>();
serviceRegistry.ConfigureOptions<ConfigureMvcViewOptions>();
serviceRegistry.ConfigureOptions<ConfigureRazorViewOptions>();
serviceRegistry.ConfigureOptions<ConfigureSessionOptions>();
serviceRegistry.ConfigureOptions<ConfigureAntiforgeryOptions>();
serviceRegistry.AddDistributedMemoryCache();
serviceRegistry.AddSession();
serviceRegistry.AddMvc()
.AddNewtonsoftJson(options =>
{
options.SerializerSettings.ContractResolver = new DefaultContractResolver();
});
serviceRegistry.AddAntiforgery(opts => opts.FormFieldName = "__RequestVerificationToken");
serviceRegistry.AddRouteAnalyzer();
// ASP.NET Identity
serviceRegistry.For<CustomDbContext>()
.Use(s => new DesignTimeDbContextFactory().CreateDbContext(Array.Empty<string>()))
.Scoped();
serviceRegistry.For<IPasswordHasher<User>>().Add<AtsPasswordHasher>();
serviceRegistry.AddTransient<IUserStore<User>, CustomUserStore>();
serviceRegistry.AddTransient<IUserClaimStore<User>, CustomUserStore>();
serviceRegistry.AddIdentityCore<User>()
.AddSignInManager()
.AddDefaultTokenProviders();
serviceRegistry.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = IdentityConstants.ApplicationScheme;
options.DefaultChallengeScheme = IdentityConstants.ApplicationScheme;
options.DefaultSignInScheme = IdentityConstants.ExternalScheme;
}).AddIdentityCookies(o => { });
}
Edit 2:
Controller Action - result.Succeeded is true
[AllowAnonymous]
[HttpPost]
[ResponseCache(NoStore = true, Location = ResponseCacheLocation.None)]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Logon(LogonViewModel model)
{
if (ModelState.IsValid)
{
var user = await mUserManager.FindByNameAsync(model.Username);
var result = await mSignInManager.PasswordSignInAsync(user.Username, model.Password, false, false );
if (result.Succeeded)
{
mLogger.LogInformation(1, "User logged in.");
try
{
var sessionState = CreateSessionState(user.Username, mUserStateManager.ClientIpAddress);
var sessionData = CreateSessionData(sessionState, user);
mSessionWrapper.Session = sessionData;
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return RedirectToAction("SessionCreated",
new
{
returnUrl = string.IsNullOrEmpty(model.ReturnUrl)
? Request.Query["ReturnUrl"].ToString()
: model.ReturnUrl,
username = model.Username,
currentpassword = model.ResetToken
});
//return RedirectToLocal(returnUrl);
}
if (result.RequiresTwoFactor)
{
//return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
}
if (result.IsLockedOut)
{
mLogger.LogWarning(2, "User account locked out.");
//return View("Lockout");
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return View(model);
}
}
// Default to returning the original view once more
return View("Logon", model);
}
User Store and Claims Store - FindByNameAsync and GetClaimsAsync work
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using Core.Auth.Model;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
namespace Core.Auth.Identity.EFCore
{
public class CustomUserStore : IUserStore<User>, IUserClaimStore<User>, IUserPasswordStore<User>
{
private bool mDisposed;
private CustomUserStore() { }
public CustomUserStore(CustomDbContext context)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
}
public virtual CustomDbContext Context { get; private set; }
private DbSet<User> Users => Context.Set<User>();
#region IUserStore<User> implementation
public void Dispose()
{
mDisposed = true;
}
public async Task<string> GetUserIdAsync(User user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
var foundUser = await FindUserById(user, cancellationToken);
return foundUser?.UserId.ToString();
}
public async Task<string> GetUserNameAsync(User user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
var foundUser = await FindUserById(user, cancellationToken);
return foundUser?.Username;
}
public Task SetUserNameAsync(User user, string userName, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<string> GetNormalizedUserNameAsync(User user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task SetNormalizedUserNameAsync(User user, string normalizedName, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<IdentityResult> CreateAsync(User user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<IdentityResult> UpdateAsync(User user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<IdentityResult> DeleteAsync(User user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public async Task<User> FindByIdAsync(string userId, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
return await Users.FirstOrDefaultAsync(x => x.UserId.ToString() == userId, cancellationToken: cancellationToken);
}
public Task<User> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
return Users.FirstOrDefaultAsync(u => u.Username == normalizedUserName, cancellationToken);
}
#endregion
#region IUserClaimStore<User> implementation
public async Task<IList<Claim>> GetClaimsAsync(User user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
// Data model is a little "odd" so having to this in a mechanical fashion for now
var securityRoleIdsForUser = await Context
.UserToSecurityRoles
.Where(x => x.UserId == user.UserId)
.Select(x => x.SecurityRoleId)
.ToArrayAsync( cancellationToken);
var securityRoles = await Context
.SecurityRoles
.Where(x => securityRoleIdsForUser.Contains(x.SecurityRoleId))
.Select(x => x.SecurityRoleName)
.ToArrayAsync(cancellationToken);
var claims = securityRoles.Select(securityRole => new Claim(ClaimTypes.Role, securityRole)).ToList();
return claims;
}
public Task AddClaimsAsync(User user, IEnumerable<Claim> claims, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task ReplaceClaimAsync(User user, Claim claim, Claim newClaim, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task RemoveClaimsAsync(User user, IEnumerable<Claim> claims, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public Task<IList<User>> GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
#endregion
#region IUserPasswordStore<User> implementation
public Task SetPasswordHashAsync(User user, string passwordHash, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public async Task<string> GetPasswordHashAsync(User user, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
var foundUser = await FindUserById(user, cancellationToken);
return foundUser.Rfc2898PasswordHash;
}
public Task<bool> HasPasswordAsync(User user, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
#endregion
/// <summary>
/// Throws if this class has been disposed.
/// </summary>
protected void ThrowIfDisposed()
{
if (mDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
}
private async Task<User> FindUserById(User user, CancellationToken cancellationToken)
{
var foundUser = await Users.FirstOrDefaultAsync(x => x.UserId == user.UserId, cancellationToken: cancellationToken);
return foundUser;
}
}
}