防止多次登录

Question

我试图阻止在我的应用程序中使用同一用户的多个登录。
我的想法是在用户登录时更新安全戳，并将其作为声明添加，然后在每个请求中将cookie中的戳与数据库中的戳进行比较。我是这样实现的:

        public virtual async Task<ActionResult> Login([Bind(Include = "Email,Password,RememberMe")] LoginViewModel model, string returnUrl)
    {
        if (!ModelState.IsValid)
        {
            return View(model);
        }
        SignInStatus result =
            await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false);
        switch (result)
        {
            case SignInStatus.Success:
                var user = UserManager.FindByEmail(model.Email);
                var id = user.Id;
                UserManager.UpdateSecurityStamp(user.Id);
                var securityStamp = UserManager.FindByEmail(model.Email).SecurityStamp;
                UserManager.AddClaim(id, new Claim("SecurityStamp", securityStamp));

然后在认证配置中我添加了

        app.UseCookieAuthentication(new CookieAuthenticationOptions
        {
            AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
            LoginPath = new PathString("/Account/Login"),
            Provider = new CookieAuthenticationProvider
            {
                OnValidateIdentity = ctx =>
                {
                    var ret = Task.Run(() =>
                    {
                        Claim claim = ctx.Identity.FindFirst("SecurityStamp");
                        if (claim != null)
                        {
                            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
                            var user = userManager.FindById(ctx.Identity.GetUserId());
                            // invalidate session, if SecurityStamp has changed
                            if (user != null && user.SecurityStamp != null && user.SecurityStamp != claim.Value)
                            {
                                ctx.RejectIdentity();
                            }
                        }
                    });
                    return ret;
                }
            }
        });

正如它所示，我已经尝试将cookie中的声明与数据库中的声明进行比较，如果它们不相同，则拒绝该身份。
现在，每次用户在安全戳中签名都会更新，但用户cookie中的值不同，我不知道为什么?我怀疑也许它的新更新的安全戳没有被存储在用户的cookie?

Answer 1

解决方案比您开始实现的要简单一些。但原理是一样的:每次用户登录时，更改他们的安全戳。这将使所有其他登录会话无效。这将教导用户不要共享他们的密码。

我刚刚从标准VS2013模板创建了一个新的MVC5应用程序，并成功地实现了你想要做的事情。

登录方法。您需要在创建验证cookie之前更改安全戳，因为在cookie设置之后，您不能轻松地更新值:

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
    if (!ModelState.IsValid)
    {
        return View(model);
    }

    // check if username/password pair match.
    var loggedinUser = await UserManager.FindAsync(model.Email, model.Password);
    if (loggedinUser != null)
    {
        // change the security stamp only on correct username/password
        await UserManager.UpdateSecurityStampAsync(loggedinUser.Id);
    }
     // do sign-in
    var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
    switch (result)
    {
        case SignInStatus.Success:
            return RedirectToLocal(returnUrl);
        case SignInStatus.LockedOut:
            return View("Lockout");
        case SignInStatus.RequiresVerification:
            return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
        case SignInStatus.Failure:
        default:
            ModelState.AddModelError("", "Invalid login attempt.");
            return View(model);
    }
}

这样，每次登录都会用新的安全戳更新用户记录。更新安全戳只是await UserManager.UpdateSecurityStampAsync(user.Id);的问题——比你想象的要简单得多。

下一步是检查每个请求上的安全戳。你已经在Startup.Auth.cs中找到了最好的钩点，但是你又过于复杂了。框架已经做了你需要做的，你需要稍微调整一下:

app.UseCookieAuthentication(new CookieAuthenticationOptions
{
    // other stuff
    AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
    LoginPath = new PathString("/Account/Login"),
    Provider = new CookieAuthenticationProvider
    {
        OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
            validateInterval: TimeSpan.FromMinutes(0), // <-- Note the timer is set for zero
            regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
    }
});            

时间间隔设置为0 -意味着框架在每次请求时都会将用户的安全戳与数据库进行比较。如果cookie中的戳记与数据库中的戳记不匹配，则抛出用户的auth-cookie，要求用户注销。

但是，请注意，对于来自用户的每个HTTP请求，这将对数据库产生额外的请求。在一个大的用户基础上，这可能是昂贵的，你可以把检查间隔增加到几分钟——这将减少对数据库的请求，但仍然会传递关于不共享登录详细信息的消息。

---

github中的完整源代码

---

博客中的更多信息

Answer 2

在过去，我使用IAuthorizationFilter和静态登录用户集合来实现这一点:

public static class WebAppData
{
     public static ConcurrentDictionary<string, AppUser> Users = new ConcurrentDictionary<string, AppUser>();
}
public class AuthorisationAttribute : FilterAttribute, IAuthorizationFilter {
    public void OnAuthorization(AuthorizationContext filterContext){
            ...
            Handle claims authentication
            ...
            AppUser id = WebAppData.Users.Where(u=>u.Key ==userName).Select(u=>u.Value).FirstOrDefault();
            if (id == null){
                id = new AppUser {...} ;
                id.SessionId = filterContext.HttpContext.Session.SessionID;
                WebAppData.Users.TryAdd(userName, id);
            }
            else
            {
                if (id.SessionId != filterContext.HttpContext.Session.SessionID)
                {
                        FormsAuthentication.SignOut();
                        ...
                        return appropriate error response depending is it ajax request or not
                        ...

                }
            } 
     }
}

注销:

WebAppData.Users.TryRemove(userName, out user)