WCF技术实现基于角色的访问控制

第一次写，小紧张！

即将毕业了，现在将我毕业设计中用到的小的编程技术以及自己的一些理解分享出来，希望可以做点小贡献。

首先要感谢网上各路大神无私的分享，没有你们，就没有我的收获。

在大四之前，对于编程只是学习过简单的C语言，从来没有接触过工程实践。最后的毕业设计肯定要开发程序，于是认真学习了一段时间。

我的毕业设计是开发一个信息管理系统，希望简单实现对学生信息的管理。系统的前端决定使用MVC模式（当下比较流行，但是好难学！），后台的管理用到了WCF技术，体现一种SOA思想。

今天主要讲讲WCF技术如何实现基于角色的访问控制，这里只是涉及基本原理，高手勿喷！

一、基于角色访问控制原理

（1）用户

用户是指系统的使用者，是一个能够对系统进行访问和操作的实体。

（2）角色

角色是整个RBAC模型中的关键，角色是用户和系统权限中间的媒介，将用户和系统权限相分离，起桥梁及纽带的作用。角色可以被分配给用户，进而和用户建立关联；角色也可以被分配权限，进而和访问权限建立关联。

在实际的系统中，用户可以根据需要被分配多个角色，比如一个人既是单位的董事长又是单位的足球队长；角色也可以根据需要被分配多个权限，比如部门经理角色可以被分配人事任免权和决策权。

（3）权限

权限是指系统使用者对系统资源进行访问和操作的能力，在RBAC中，用户通过被分配相应的角色而间接获得了所需的权限。

（4）会话

会话在访问控制中起标记作用，用户和角色通过建立持续一段时间的会话来进行关联。一个用户在一次操作周期中，可以通过一个会话关联多个不同的角色，当然也可以通过多个不同的会话关联更多的角色。而用户的权限就是这些关联的角色的权限之和。

（5）角色等级

角色等级RH（Role Hierarchy）在现实的系统中可以直接体现出使用该系统的企业或单位的权力等级和责任划分，在程序设计中也方便通过继承进行授权。

二、访问控制服务功能模块设计

该服务按照功能可以划分为如下几个部分：用户管理模块、角色管理模块、授权管理模块和权限判定模块。

三、授权管理流程设计

四、访问控制流程设计

五、数据库设计

下图是VS中LINQ to SQL类的设计图，这个类用于连接SQL Server数据库，好用，推荐！

六、WCF契约设计

在下文的数据契约中，权限中有Controller和Action两个变量，这是因为我的这个WCF访问控制后台是和MVC前端结合的，大家在用的时候，需要根据自己的程序来设计权限中的变量。

[ServiceContract]
    public interface IServiceAuthenticate 
    {
        //用户注册，输入用户信息和会话信息进行用户注册
        [OperationContract]
        string Register(UserInfos userinfo, SessionInfos sessioninfo);
        //用户删除，输入用户信息进行用户删除
        [OperationContract]
        string DeleteUser(UserInfos userinfo);
        //用户登录，输入用户信息和会话信息进行用户登录
        [OperationContract]
        string Login(UserInfos userinfo, SessionInfos sessioninfo);
        //用户登出，输入会话信息进行用户登出
        [OperationContract]
        string Logout(SessionInfos sessioninfo);
        //状态查询，输入会话信息查询当前用户的登录和操作状态
        [OperationContract]
        string StateQuery(SessionInfos sessioninfo);
        //创建角色，输入角色信息进行角色创建
        [OperationContract]
        string CreateRole(Role role);
        //删除角色，输入角色信息进行角色删除
        [OperationContract]
        string DeleteRole(Role role);
        //用户角色分配，输入用户信息和角色信息为用户分配角色
        [OperationContract]
        string CreateUserRole(UserInfos userinfo, Role role);
        //删除用户角色分配，输入用户信息和角色信息删除特定的用户角色关系
        [OperationContract]
        string DeleteUserRole(UserInfos userinfo, Role role);
        //角色权限分配，输入角色信息和权限信息为特定角色分配权限
        [OperationContract]
        string CreateRoleAuthority(Role role, Authority authority);
        //删除角色权限分配，输入角色信息和权限信息删除特定的角色权限关系
        [OperationContract]
        string DeleteRoleAuthority(Role role, Authority authority);
        //权限判定，输入会话信息和权限信息判定当前用户有无相应的权限
        [OperationContract]
        bool AuthorityJudge(SessionInfos sessioninfo, Authority authority);

    }

    //再定义几个常用的数据契约
    [DataContract]
    public class UserInfos
    {
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public string HashPWD { get; set; }
    }
    [DataContract]
    public class SessionInfos
    {
        [DataMember]
        public string IP { get; set; }
        [DataMember]
        public string Browser { get; set; }

    }
    [DataContract]
    public class Role
    {
        [DataMember]
        public string RoleName { get; set; }
        [DataMember]
        public string Father { get; set; }
        [DataMember]
        public int RoleLevel { get; set; }
    }
    [DataContract]
    public class Authority
    {
        [DataMember]
        public string ActionName { get; set; }
        [DataMember]
        public string ControllerName { get; set; }
    }

七、各个功能模块实现

我在开发时使用的SQL Server 2016，数据库连接使用的是LINQ to SQL，因此在程序开头需要定义连接：

UserDataClassesDataContext db = new UserDataClassesDataContext();

1、用户管理功能实现

        //用户注册
        public string  Register(UserInfos userinfos,SessionInfos sessioninfos)
        {
            if (db.UserInfo.Where(m => m.Name == userinfos.Name).Count() > 0)
                return "User Existed";
            else
            {
                UserInfo rec=new UserInfo();
              
                rec.Name = userinfos.Name;
                rec.HashPWD = userinfos.HashPWD;
                rec.RegDateTime = DateTime.Now;
                rec.RegBrowser = sessioninfos.Browser;
                rec.RegIP = sessioninfos.IP;

                db.UserInfo.InsertOnSubmit(rec);
                db.SubmitChanges();
                
                return "Welcome new user:" + userinfos.Name;
                
            }
        }

        //用户删除
        public string DeleteUser(UserInfos userinfos)
        {
            var rec = db.UserInfo.FirstOrDefault(m => m.Name == userinfos.Name);
            if (rec != null)
            {
                db.UserInfo.DeleteOnSubmit(rec);
                db.SubmitChanges();
                return "Delete Success";
            }
            else
                return "User not Exist";
        }

2、角色管理功能实现

//创建角色        
public string CreateRole(Role role)
        {
            if (db.RoleInfo.Where(m => m.RoleName == role.RoleName).Count() > 0)
                return "Role Existed";
            else
            {
                RoleInfo rec = new RoleInfo();
                rec.RoleName = role.RoleName;
                rec.CreateTime = System.DateTime.Now;
                rec.Father = role.Father;
                rec.RoleLevel = role.RoleLevel;

                db.RoleInfo.InsertOnSubmit(rec);
                db.SubmitChanges();
                return "Create Success";
            }
        }
//删除角色
        public string DeleteRole(Role role)
        {
            var rec = db.RoleInfo.FirstOrDefault(m => m.RoleName == role.RoleName);
            if(rec!=null)
            {
                db.RoleInfo.DeleteOnSubmit(rec);
                db.SubmitChanges();
                return "Delete Success";
            }
            else
            {
                return "Role not Exist";
            }
        }

3、授权管理功能实现

//创建用户-角色规则        
public string CreateUserRole(UserInfos userinfo, Role role)
        {
//先判断用户名是否存在
            if (db.UserInfo.Where(m => m.Name == userinfo.Name).Count() > 0)
            {
//再判断角色名是否存在
                if(db.RoleInfo.Where(m => m.RoleName == role.RoleName).Count() > 0)
                {
//再判断想要添加的规则是否存在
                    if (db.UserRole.Where(m => m.UserName == userinfo.Name && m.RoleName == role.RoleName).Count() > 0)
                        return "Rule Exist";
                    else
                    {
//写入想要添加的用户-角色规则
                        UserRole rec = new UserRole();
                        rec.UserName = userinfo.Name;
                        rec.RoleName = role.RoleName;
                        rec.CreateTime = System.DateTime.Now;

                        db.UserRole.InsertOnSubmit(rec);
                        db.SubmitChanges();
//根据权限继承原理，将角色的子角色也赋给用户
                        List < RoleInfo> userrolelist= db.RoleInfo.Where(m => m.Father == role.RoleName).ToList();
                        for(int i = 0; i < userrolelist.Count; i++)
                        {
                            UserRole rec2 = new UserRole();
                            rec2.UserName = userinfo.Name;
                            rec2.RoleName = userrolelist[i].RoleName;
                            rec2.CreateTime = System.DateTime.Now;
                            db.UserRole.InsertOnSubmit(rec2);
                            db.SubmitChanges();
                        }
                        return "Create Success";
                    }
                }
                else
                {
                    return "Role not Exist";
                }
            }
            else
            {
                return "User not Exist";
            }
        }
//删除用户-角色规则
        public string DeleteUserRole(UserInfos userinfo, Role role)
        {
            if(db.UserInfo.Where(m=>m.Name==userinfo.Name).Count()>0
                &&db.RoleInfo.Where(m=>m.RoleName==role.RoleName).Count()>0)
            {
                var rec = db.UserRole.FirstOrDefault(m => m.UserName == userinfo.Name && m.RoleName == role.RoleName);
                if(rec!=null)
                {
                    db.UserRole.DeleteOnSubmit(rec);
                    db.SubmitChanges();
                    return "Delete Suceess";
                }
                else
                {
                    return "Rule not Exist";
                }
            }
            else
            {
                return "Delete Fail";
            }
        }
//创建角色-权限规则
        public string CreateRoleAuthority(Role role, Authority authority)
        {
//判断角色是否存在           if(db.RoleInfo.Where(m=>m.RoleName==role.RoleName).Count()>0)
            {
//查询角色关联的所有规则，找出是否存在想要添加的规则
                var rec= db.RoleAuthority.FirstOrDefault(m => m.RoleName == role.RoleName
                    && m.ActionName == authority.ActionName && m.ControllerName == authority.ControllerName);

                if(rec!=null)
                {
                    return "Rule Exist";
                }
//规则不存在，则添加
                else
                {
                    RoleAuthority rec2 = new RoleAuthority();
                    rec2.RoleName = role.RoleName;
                    rec2.ActionName = authority.ActionName;
                    rec2.ControllerName = authority.ControllerName;
                    rec2.CreateTime = System.DateTime.Now;

                    db.RoleAuthority.InsertOnSubmit(rec2);
                    db.SubmitChanges();
                    return "Create Success";
                }
            }
            else
            {
                return "Role not Exist";
            }
        }
//删除角色权限规则
        public string DeleteRoleAuthority(Role role, Authority authority)
        {
            var rec = db.RoleAuthority.FirstOrDefault(m => m.RoleName == role.RoleName
                && m.ActionName == authority.ActionName && m.ControllerName == authority.ControllerName);
            if(rec==null)
            {
                return "Rule not Exist";
            }
            else
            {
                db.RoleAuthority.DeleteOnSubmit(rec);
                db.SubmitChanges();
                return "Delete Success";
            }
        }

4、访问控制功能实现

//用户认证        
public string  Login(UserInfos userinfos, SessionInfos sessioninfos)
        {

            if (!(db.UserInfo.Where(m => m.Name == userinfos.Name).Count() > 0))
            {
                return "Please Register Firstly!";
            }
            else
            {
                UserInfo rec = new UserInfo();
                rec = db.UserInfo.Where(m => m.Name == userinfos.Name).First();

                if (rec.HashPWD == userinfos.HashPWD)
                {
                        AuthInfo authrec = new AuthInfo();
                        authrec.Name = userinfos.Name;
                        authrec.IP = sessioninfos.IP;
                        authrec.Browser = sessioninfos.Browser;
                        authrec.AuthTime = DateTime.Now;
                        authrec.LastAuthTime = DateTime.Now;
                        authrec.LogOffTime = null;

                        db.AuthInfo.InsertOnSubmit(authrec);
                        db.SubmitChanges();
                    return "Authenticate Success!";
                }
                else
                {
                    return "Authenticate Fail...";
                }
               
            }
        }
//用户登出
        public string  Logout(SessionInfos sessioninfos)
        {
            AuthInfo authrec = new AuthInfo();
            authrec = db.AuthInfo.Where(m => m.Browser == sessioninfos.Browser && m.IP == sessioninfos.IP
                    &&(m.LastAuthTime>System.DateTime.Now.AddMinutes(-60))
                    && m.LogOffTime == null).First();
           
            authrec.LogOffTime = DateTime.Now;
                
            db.SubmitChanges();
            return "Logout successed";
            
        }
//用户状态查询，便于获取当前用户的信息
        public string  StateQuery(SessionInfos sessioninfos)
        {
            if (db.AuthInfo.Where(m => m.Browser == sessioninfos.Browser && m.IP == sessioninfos.IP
                && (m.LastAuthTime > System.DateTime.Now.AddMinutes(-60))
                &&m.LogOffTime==null).Count() > 0)
            {
                AuthInfo authrec = new AuthInfo();
                authrec = db.AuthInfo.Where(m => m.Browser == sessioninfos.Browser && m.IP == sessioninfos.IP
                    && (m.LastAuthTime>System.DateTime.Now.AddMinutes(-60))
                    && m.LogOffTime == null).First();

                    authrec.LastAuthTime = System.DateTime.Now;
                    db.SubmitChanges();
                    return authrec.Name + ",you has logged in.";
            }
            else
            {
                return "Please login or register";
            }
        }
//用户权限判定，决定是否授权
 public bool AuthorityJudge(SessionInfos sessioninfo, Authority authority)
        {
            bool flag = false;
//抓取当前用户
            var authinforec = db.AuthInfo.FirstOrDefault(m => m.IP == sessioninfo.IP && m.Browser == sessioninfo.Browser
                &&m.LogOffTime==null);
//查询用户的所有角色
            var userrolerec = db.UserRole.Where(m => m.UserName == authinforec.Name).ToArray();
//遍历角色的所有权限，查询是否存在与请求权限相同的权限
            for (int i = 0; i < userrolerec.Length;i++ )
            {
                var roleauthorityrec = db.RoleAuthority.FirstOrDefault(m => m.RoleName == userrolerec[i].RoleName
                    && m.ActionName == authority.ActionName && m.ControllerName == authority.ControllerName);
//如果用户对应的角色存在相应权限，则授权
                if (roleauthorityrec != null)
                {
                    flag = true;
                    break;
                }
                else flag = false;
            }
           
            return flag;
        }