基于ASP.NET Core Identity对接遗留数据库实现自定义登录的方案咨询

方案一：自定义PasswordHasher<TUser>（优先推荐） #

这种方式适配你提到的「部分用户同时存在于Identity数据库与遗留库，身份统一在Identity中管理」的场景，核心是让Identity的密码验证逻辑兼容双源：

1. 先尝试用Identity默认哈希规则校验密码；
2. 若校验失败，再调用遗留数据库的密码验证逻辑；
3. 可选：遗留库验证成功后自动将密码迁移到Identity数据库，避免后续重复访问遗留系统。

代码示例片段：

public class DualSourcePasswordHasher<TUser> : PasswordHasher<TUser> where TUser : class
{
    private readonly ILegacyPasswordValidator _legacyValidator;
    private readonly UserManager<TUser> _userManager;

    public DualSourcePasswordHasher(ILegacyPasswordValidator legacyValidator, UserManager<TUser> userManager)
    {
        _legacyValidator = legacyValidator;
        _userManager = userManager;
    }

    public override PasswordVerificationResult VerifyHashedPassword(TUser user, string hashedPassword, string providedPassword)
    {
        // 优先走Identity默认验证
        var identityResult = base.VerifyHashedPassword(user, hashedPassword, providedPassword);
        if (identityResult != PasswordVerificationResult.Failed)
        {
            return identityResult;
        }

        // 尝试遗留库密码验证
        var userId = _userManager.GetUserId(user);
        if (_legacyValidator.Validate(userId, providedPassword))
        {
            // 自动迁移密码到Identity（可选）
            var newHashedPassword = base.HashPassword(user, providedPassword);
            _userManager.UpdateAsync(user, new IdentityUserUpdateInfo { PasswordHash = newHashedPassword }).Wait();
            
            return PasswordVerificationResult.SuccessRehashNeeded;
        }

        return PasswordVerificationResult.Failed;
    }
}

在Program.cs中替换默认实现：

builder.Services.AddIdentityCore<CustomUser>()
    .AddEntityFrameworkStores<AppDbContext>()
    .AddPasswordHasher<DualSourcePasswordHasher<CustomUser>>();

该方案优势：

• 完全复用现有SignInManager.CheckPasswordSignInAsync流程，无需修改登录逻辑；
• 前端无需额外传参，对业务层侵入极小；
• 支持密码自动迁移，逐步淘汰遗留系统依赖。

方案二：自定义AuthenticationHandler<AuthenticationSchemeOptions>（场景适配） #

这种方式适合「用户身份完全分属两个独立系统，需明确区分登录来源」的场景，比如用户可选择用内部账号或纯遗留系统账号登录。

核心流程：

1. 扩展登录请求，增加必填provider参数；
2. 注册自定义认证方案（如LegacySystem）；
3. 登录逻辑中根据provider分支处理：调用Identity默认验证或触发自定义认证流程。

代码示例片段（自定义Handler）：

public class LegacyAuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    private readonly ILegacyUserService _legacyUserService;

    public LegacyAuthHandler(IOptionsMonitor<AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, ILegacyUserService legacyUserService)
        : base(options, logger, encoder, clock)
    {
        _legacyUserService = legacyUserService;
    }

    protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        // 从请求获取凭证（示例用Basic Auth，可替换为登录请求参数）
        var authHeader = Request.Headers["Authorization"].FirstOrDefault();
        if (string.IsNullOrEmpty(authHeader) || !authHeader.StartsWith("Basic "))
        {
            return AuthenticateResult.Fail("无效凭证");
        }

        var credentials = Encoding.UTF8.GetString(Convert.FromBase64String(authHeader.Substring(6))).Split(':');
        var legacyUser = await _legacyUserService.Validate(credentials[0], credentials[1]);
        if (legacyUser == null)
        {
            return AuthenticateResult.Fail("用户名或密码错误");
        }

        // 生成Claims凭证
        var claims = new List<Claim>
        {
            new Claim(ClaimTypes.NameIdentifier, legacyUser.Id.ToString()),
            new Claim(ClaimTypes.Name, legacyUser.Username)
        };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var ticket = new AuthenticationTicket(new ClaimsPrincipal(identity), Scheme.Name);

        return AuthenticateResult.Success(ticket);
    }
}

注册自定义认证方案：

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => { /* JWT配置 */ })
    .AddScheme<AuthenticationSchemeOptions, LegacyAuthHandler>("LegacySystem", _ => { });

登录接口分支处理：

[HttpPost("login")]
public async Task<IActionResult> Login([FromBody] LoginRequest request)
{
    if (request.Provider == "internal")
    {
        var user = await _userManager.FindByNameAsync(request.Username);
        var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
        if (result.Succeeded)
        {
            // 生成JWT返回
        }
    }
    else if (request.Provider == "legacySystem")
    {
        var authResult = await HttpContext.AuthenticateAsync("LegacySystem");
        if (authResult.Succeeded)
        {
            // 基于遗留用户信息生成JWT返回
        }
    }

    return Unauthorized();
}

该方案优势：

• 完全隔离不同系统的认证逻辑，适合身份源独立的场景；
• 可针对不同认证源定制校验规则与凭证生成逻辑。

总结建议 #

结合你的业务场景，优先选择自定义PasswordHasher<TUser>：

1. 无需修改前端请求与现有登录流程，开发成本更低；
2. 身份统一在Identity中管理，避免多源身份同步问题；
3. 支持密码自动迁移，逐步降低对遗留系统的依赖。

若未来需要支持「仅存在于遗留库的独立用户」，再考虑引入自定义AuthenticationHandler方案。

内容的提问来源于stack exchange，提问作者Robin