跟我学ASP.NET MVC之十：SportsStrore安全

 摘要：

在之前的文章中，我给SportsStore应用程序添加了产品管理功能，这样一旦我发布了网站，任何人都可能修改产品信息，而这是你必须考虑的。他们只需要知道你的网站有这个功能，以及功能的访问路径是/Admin/Index。我将向你介绍如何通过对Admin控制器实现密码保护来防止任意的人员使用管理功能。

创建基本安全策略

我将从配置表单身份验证开始，它是用户在ASP.NET应用程序身份验证的一种方式。修改Web.config文件的System.Web节，添加authentication子节点。

  <system.web>
    <compilation debug="true" targetFramework="4.5.1" />
    <httpRuntime targetFramework="4.5.1" />
    <authentication mode="Forms">
      <forms loginUrl="~/Account/Login" timeout="2880" >
      </forms>
    </authentication>
  </system.web>

该配置表示，使用表单验证。如果表单验证失败，则网页定向到/Account/Login页面，验证有效期时间是2880分钟（48小时）。

还有其他的身份验证方式，另一个常用的是Windows方式验证。它使用User Group或者Active Directory验证。这里不打算介绍它。读者可以在网上搜索这方面的知识。

还可以给该表单验证配置添加credential。

  <system.web>
    <compilation debug="true" targetFramework="4.5.1" />
    <httpRuntime targetFramework="4.5.1" />
    <authentication mode="Forms">
      <forms loginUrl="~/Account/Login" timeout="2880" >
        <credentials passwordFormat="Clear">
          <user name="user" password="123"/>
        </credentials>
      </forms>
    </authentication>
  </system.web>

该credentials配置表示，在配置文件中使用密码明文（不推荐），登录用户名是user，密码是123。

使用过滤器应用表单验证

MVC框架有一个强大的名叫过滤器的功能。他们是你可以运用在Action方法或者控制器类上的.NET特性，当一个请求发送过来将改变MVC框架行为的时候，引入额外的业务逻辑。

这里我将把它修饰AdminController控制器类，它将给该控制器内的所有Action方法添加这个过滤器。

    [Authorize]
    public class AdminController : Controller
    {
        private IProductRepository repository;

        public AdminController(IProductRepository productRepository)
        {
            repository = productRepository;
        }

如果将该过滤器应用到Action方法里，则只对这个Action起作用。

创建表单验证方法

有了表单验证配置和表单验证过滤器之后，还需要定义表单验证的逻辑方法。

 首先定义一个接口IAuthProvider。

namespace SportsStore.Infrastructure.Abstract
{
    public interface IAuthProvider
    {
        bool Authenticate(string userName, string password);
    }
}

该接口只定义了一个接口方法Authenticate，根据传入的用户名和密码，返回验证是否成功的布尔值。

然后，实现接口IAuthProvider的类FormsAuthProvider 。

using SportsStore.Infrastructure.Abstract;
using System.Web.Security;

namespace SportsStore.WebUI.Infrastructure.Concrete
{
    public class FormsAuthProvider : IAuthProvider
    {
        public bool Authenticate(string userName, string password)
        {
            bool result = FormsAuthentication.Authenticate(userName, password);
            if (result)
            {
                FormsAuthentication.SetAuthCookie(userName, false);
            }
            return result;
        }
    }
}

这里将调用静态函数FormsAuthentication.Authenticate进行表单验证。如果Web.config文件中定义了credentials配置，则使用配置文件中定义的用户名和密码进行验证。

如果验证成功，则调用另一个静态函数FormsAuthentication.SetAuthCookie向客户端写入用户名userName字符串的cookie。

还需要将实现类FormsAuthProvider绑定到接口IAuthProvider。

修改类NinjectDependencyResolver的方法AddBindings，添加Ninject绑定。

        private void AddBindings()
        {
            kernel.Bind<IProductRepository>().To<EFProductRepository>();

            EmailSettings emailSettings = new EmailSettings
            {
                WriteAsFile = bool.Parse(System.Configuration.ConfigurationManager.AppSettings["Email.WriteAsFile"] ?? "false")
            };
            kernel.Bind<IOrderProcessor>().To<EmailOrderProcessor>().WithConstructorArgument("settings", emailSettings);

            kernel.Bind<IAuthProvider>().To<FormsAuthProvider>();
        }

定义LoginViewModel

using System.ComponentModel.DataAnnotations;

namespace SportsStore.WebUI.Models
{
    public class LoginViewModel
    {
        [Display(Name = "User Name")]
        [Required(ErrorMessage = "Please enter a user name")]
        public string UserName { get; set; }
        [Required(ErrorMessage = "Please enter a password")]
        [DataType(DataType.Password)]
        public string Password { get; set; }
    }
}

这个视图模型类只有用户名和密码属性。它们都加了Required验证特性。Password属性加了DataType特性，这样自动生成的表单password输入框元素将是一个password输入框（输入的文本内容不可见）。

创建Account控制器

using SportsStore.Infrastructure.Abstract;
using SportsStore.WebUI.Models;
using System.Web.Mvc;

namespace SportsStore.Controllers
{
    public class AccountController : Controller
    {
        IAuthProvider authProvider;

        public AccountController(IAuthProvider authProvidor)
        {
            authProvider = authProvidor;
        }

        public ActionResult Login()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                if (authProvider.Authenticate(model.UserName, model.Password))
                {
                    return Redirect(returnUrl ?? Url.Action("Index", "Admin"));
                }
                else
                {
                    ModelState.AddModelError("", "Incorrect username or password");
                    return View();
                }
            }
            else
            {
                return View();
            }
        }
    }
}

这个控制器代码很简单。定义了两个Login的Action方法，一个用于接收Get请求，一个用于接收Post请求。

Post请求的Login方法，还接收了一个returnUrl字符串参数。他是过滤器拦截的页面URL。

调用authProvider.Authenticate返回表单验证结果。如果验证成功，则调用Redirect方法，将页面定向到刚才要访问的页面。

创建登录视图

@model SportsStore.WebUI.Models.LoginViewModel

@{
    ViewBag.Title = "Admin: Login";
    Layout = "~/Views/Shared/_AdminLayout.cshtml";
}
<div class="panel">
    <div class="panel-heading">
        <h3>Log In</h3>
        <p class="lead">
            Please log in to access the administration area:
        </p>
    </div>
    <div class="panel-body">
        @using (Html.BeginForm())
        {
            <div class="panel-body">
                @Html.ValidationSummary()
                <div class="form-group">
                    <label>User Name</label>
                    @Html.TextBoxFor(m => m.UserName, new { @class = "form-control" })
                </div>
                <div class="form-group">
                    <label>Password</label>
                    @Html.PasswordFor(m => m.Password, new { @class = "form-control" })
                </div>
                <input type="submit" value="Log in" class="btn btn-primary" />
            </div>
        }
    </div>
</div>        

它是一个简单的用户名密码登录视图。调用Html帮助方法PasswordFor生成密码输入框。

运行程序，当访问/Admin页面的时候，页面将自动跳转到/Account/Login页面，并在URL上添加?ReturnUrl=%2fAdmin后缀。

如果输入用户名user，密码123，点击Log in按钮后，跳转到Admin页面。

 自定义表单验证逻辑

上面的表单验证逻辑在非常简单的网站上是可以使用的。但是在真实的应用系统中，往往需要将用户名和密码记录在数据库表里，通过查询数据库验证用户名和密码是否正确。有时候，还需要在操作的时候，记录执行该操作的当前登录者。在首页上，有时候要显示当前登录者信息。下面将简单介绍这些功能怎样实现。

首先定义数据库实体类User。

namespace SportsStore.Domain.Entities
{
    public class User
    {
        public int UserID { get; set; }
        public string UserName { get; set; }
        public string Password { get; set; }
    }
}

定义继承IIdentity接口的用户类UserIdentity。

using SportsStore.Domain.Entities;
using System.Security.Principal;

namespace SportsStore.Infrastructure.Security
{
    public class UserIdentity : IIdentity
    {
        public string AuthenticationType
        {
            get
            {
                return "Form";
            }
        }

        public bool IsAuthenticated
        {
            get;
            //extend property
            set;
        }

        public string Name
        {
            get
            {
                return User.UserName;
            }
        }

        public User User
        {
            get;set;
        }
    }
}

接口IIdentity的定义如下：

继承的AutenticationType属性返回Form字符串。继承的IsAuthenticated属性，扩展了set访问器，增加了可写访问，让外部程序可以设置它的值。在实现类UserIdentity里增加了实体User类的属性。继承的Name属性返回User属性的属性Name。

定义继承IPrincipal接口的用户类UserProfile。

using System.Security.Principal;
using System.Web;

namespace SportsStore.Infrastructure.Security
{
    public class UserProfile : IPrincipal
    {
        public const string SessionKey = "User";

        private UserIdentity _user;

        public IIdentity Identity
        {
            get
            {
                return _user;
            }
            set //extended property
            {
                _user = (UserIdentity)value;
            }
        }

        public bool IsInRole(string role)
        {
            return true;
        }

        public static UserProfile CurrentLogonUser
        {
            get
            {
                if (HttpContext.Current.Session == null)
                {
                    return null;
                }
                if (HttpContext.Current.Session[SessionKey] == null)
                {
                    return null;
                }
                return HttpContext.Current.Session[SessionKey] as UserProfile;
            }
        }
    }
}

接口IPrincipal的定义如下：

继承类UserProfile，定义了一个私有的UserIdentity类型的_user字段，通过继承的属性Identity返回它的值。继承的属性Identity扩展了它的可写访问器，让外部程序可以设置它的值。继承的方法IsInRole暂时返回true。

在UserProfile类里还定义了一个UserProfile类型的静态属性CurrentLogonUser，他用于在应用程序的任何地方返回当前登录用户的信息。从它的代码看到，我将使用Session存储当前登录用户对象。

修改接口IAuthProvider和类FormsAuthProvider。

using SportsStore.Infrastructure.Security;
using SportsStore.WebUI.Models;

namespace SportsStore.Infrastructure.Abstract
{
    public interface IAuthProvider
    {
        bool Authenticate(LoginViewModel loginModel, out UserProfile userProfile);
    }
}

方法Authenticate增加了一个out修饰的UserProfile参数，用于返回验证成功后的UserProfile类型对象。

using SportsStore.Infrastructure.Abstract;
using SportsStore.Infrastructure.Security;
using SportsStore.WebUI.Models;

namespace SportsStore.WebUI.Infrastructure.Concrete
{
    public class FormsAuthProvider : IAuthProvider
    {
        public bool Authenticate(LoginViewModel loginModel, out UserProfile userProfile)
        {
            //validate user and password from database
            bool result = true;
            userProfile = new UserProfile();
            if (result)
            {
                UserIdentity userIdentity = new UserIdentity();
                userIdentity.IsAuthenticated = true;
                // get user entity from db
                userIdentity.User = new Domain.Entities.User()
                {
                    UserID = 0,
                    UserName = loginModel.UserName,
                    Password = loginModel.Password
                };

                userProfile.Identity = userIdentity;
            }
            return result;
        }
    }
}

方法Authenticate将查询数据库验证用户名和密码，如果验证通过，将数据库读出来的用户信息生成UserProfile对象，用out参数返回。

你可以使用Ninject注册一个IUserRepository到类FormsAuthProvider，再读数据库。

IUserRepository接口：

using SportsStore.Domain.Entities;
using System.Collections.Generic;

namespace SportsStore.Domain.Abstract
{
    public interface IUserRepository
    {
        IEnumerable<User> Users { get; }
    }
}

实现类EFUserRepository：

using SportsStore.Domain.Abstract;
using SportsStore.Domain.Entities;
using System.Collections.Generic;

namespace SportsStore.Domain.Concrete
{
    public class EFUserRepository : IUserRepository
    {
        private EFDbContext context = new EFDbContext();
        public IEnumerable<User> Users
        {
            get
            {
                try
                {
                    return context.Users;
                }
                catch (System.Exception e)
                {
                    return null;
                }
            }
        }
    }
}

EFDbContext：

using SportsStore.Domain.Entities;
using System.Data.Entity;

namespace SportsStore.Domain.Concrete
{
    public class EFDbContext : DbContext
    {
        public DbSet<Product> Products { get; set; }

        public DbSet<User> Users { get; set; }
    }
}

修改后的FormsAuthProvider：

using SportsStore.Domain.Abstract;
using SportsStore.Infrastructure.Abstract;
using SportsStore.Infrastructure.Security;
using SportsStore.WebUI.Models;
using System.Linq;

namespace SportsStore.WebUI.Infrastructure.Concrete
{
    public class FormsAuthProvider : IAuthProvider
    {
        private IUserRepository _userRepository;

        public FormsAuthProvider(IUserRepository userRepository)
        {
            _userRepository = userRepository;
        }

        public bool Authenticate(LoginViewModel loginModel, out UserProfile userProfile)
        {
            //validate user and password from database
            var user = _userRepository.Users.Where(u => u.UserName == loginModel.UserName && u.Password == loginModel.Password).FirstOrDefault();
            bool result = user != null;
            userProfile = new UserProfile();
            if (result)
            {
                UserIdentity userIdentity = new UserIdentity();
                userIdentity.IsAuthenticated = true;
                // get user entity from db
                userIdentity.User = user;

                userProfile.Identity = userIdentity;
            }
            return result;
        }
    }
}

类NinjectDependencyResolver里的AddBindings方法添加绑定：

kernel.Bind<IUserRepository>().To<EFUserRepository>();

还需要添加用户表Users。

里面添加一行数据。

添加继承自AuthorizeAttribute类的自定义Authorize特性类MyAuthorizeAttribute。

using System.Web;
using System.Web.Mvc;

namespace SportsStore.Infrastructure.Security
{
    public class MyAuthorizeAttribute : AuthorizeAttribute
    {
        protected override bool AuthorizeCore(HttpContextBase httpContext)
        {
            UserProfile userProfile = null;
            if (httpContext.Session != null)
            {
                userProfile = (UserProfile)httpContext.Session[UserProfile.SessionKey];
            }
            if (userProfile == null)
            {
                return false;
            }
            else
            {
                //some other validate logic here, like intercept IP
                return userProfile.Identity.IsAuthenticated;
            }
        }
    }
}

该类是根据Session对象存储的User对象。拦截控制器方法。

将自定义AuthorizeAttribute特性MyAuthorizeAttribute应用到AdminController控制器。

    [MyAuthorize] 
    public class AdminController : Controller
    {

最后是修改Account控制器的Login方法。

        [HttpPost]
        public ActionResult Login(LoginViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                UserProfile userProfile;
                if (authProvider.Authenticate(model, out userProfile))
                {
                    HttpContext.Session[UserProfile.SessionKey] = userProfile;
                    return Redirect(returnUrl ?? Url.Action("Index", "Admin"));
                }
                else
                {
                    ModelState.AddModelError("", "Incorrect username or password");
                    return View();
                }
            }
            else
            {
                return View();
            }
        }

调用的authProvider.Authenticate方法增加了out参数userProfile。如果userProfile对象写入Session。

在首页上显示当前登录用户

在AdminController控制器里，添加LogonUser方法Action，返回包含当前登录用户对象的PartialViewResult。

        public PartialViewResult LogonUser()
        {
            var user = UserProfile.CurrentLogonUser != null ? UserProfile.CurrentLogonUser.Identity as UserIdentity : null;
            if (user != null)
            {
                return PartialView("LogonUser", user.User);
            }
            return PartialView();
        }

在_AdminLayout.cshtml视图中嵌入这个Action。

<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <link href="~/Content/bootstrap.css" rel="stylesheet" />
    <link href="~/Content/bootstrap-theme.css" rel="stylesheet" />
    <link href="~/Content/ErrorStyles.css" rel="stylesheet" />
    <script src="~/Scripts/jquery-1.9.1.js"></script>
    <script src="~/Scripts/jquery.validate.js"></script>
    <script src="~/Scripts/jquery.validate.unobtrusive.js"></script>
    <title>@ViewBag.Title</title>
    <style>
        .navbar-right {
            float: right !important;
            margin-right: 15px;
            margin-left: 15px;
        }
    </style>
</head>
<body>
    <div class="navbar navbar-inverse" role="navigation">
        <a class="navbar-brand" href="#">
            <span class="hidden-xs">SPORTS STORE</span>
            <div class="visible-xs">SPORTS</div>
            <div class="visible-xs">STORE</div>
        </a>
        <span class="visible-xs">
            @Html.Action("LogonUser", "Admin", new { showPicture = true })
        </span>
        <span class="hidden-xs">
            @Html.Action("LogonUser", "Admin")
        </span>
    </div>
    <div>
        @if (TempData["message"] != null)
        {
            <div class="alert alert-success">@TempData["message"]</div>
        }
        @RenderBody()
    </div>
</body>
</html>

为了支持移动设备，使用了响应式布局。在超小屏幕上，向视图LogonUser传入了一个动态参数showPicture。视图LogonUser将使用这个参数，决定是否显示图片。

LogonUser视图：

@model SportsStore.Domain.Entities.User
@{
    bool showPicture = ((bool)(ViewContext.RouteData.Values["showPicture"] ?? false));
}
@if (!string.IsNullOrEmpty(Model.UserName))
{
    <div class="navbar-brand navbar-right small">
        [<span>@Model.UserName</span>]
         @if (showPicture)
         {
            <a href="@Url.Action("Logout","Account")"><span class="glyphicon glyphicon-hand-right"></span></a>
         }
         else
         {
            @Html.RouteLink("Logout", new { controller = "Account", action = "Logout" }, new { @class = "navbar-link" })
         }
    </div>
}

运行程序，程序运行结果跟之前一样。登录成功后，在首页的右上角显示当前登录用户的用户名。

 超小屏幕上显示的效果是这样的：

最后，还需要添加Action方法Logout。

        public ActionResult Logout()
        {
            FormsAuthentication.SignOut();
            HttpContext.Session.Remove(UserProfile.SessionKey);
            return Redirect(Url.Action("Login"));
        }

Logout方法调用静态函数FormsAuthentication.SignOut，签出表单验证。从Session对象内删除了当前登录用户对象。调用Redirect函数，返回Login页面。

最后，你可以删除Web.config文件中forms节点的credentials子节点。

  <system.web>
    <compilation debug="true" targetFramework="4.5.1" />
    <httpRuntime targetFramework="4.5.1" />
    <authentication mode="Forms">
      <forms loginUrl="~/Account/Login" timeout="2880" >
      </forms>
    </authentication>
  </system.web>