CAS单点登录系统的实现

本是古典何须时尚 2023-09-30 20:52 8阅读 0赞

#### CAS单点登录系统的实现 ####

*  前言
 *  一、CAS思路
 *  二、代码实现
 *   *  环境准备
     *  代码实现
     *   *  2.1 MTV系统前端判断是否登录，依据前端cookie是否存在用户信息
         *  2.2 MTV系统前端判断链接是否携带临时票据，如果携带则发送校验请求，如果不存在证明用户从未登录，则跳转登录页面
         *  2.3 SSO登录接口，判断cookie中是否包含用户全局令牌，存在证明用户登录过，颁发临时令牌并会跳，如果不存在则跳转登录
         *  2.4 SSO统一登录接口
         *  2.5 SSO验证临时票据方法
         *  2.6 注销方法
         *  2.7 完整的controller

## 前言 ##

单点登录(Single Sign On.简称SSo)是目前比较流行的服务于企业业务整合的解决方案之  
一，使得在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。

SSO的实现机制不尽相同，大体分为Cookie机制和Session机制两大类。

Session是一种服务器端机制，当客户端访问服务器时，服务器为客户端创建一个惟一的  
SessionID,以使在整个交互过程中始终保持状态，而交互的信息则可由应用自行指定，因此用  
Session方式实现SSO,不能在多个浏览器之间实现单点登录，但却可以跨域。

Cookie是一种客户端机制，它存储的内容主要包括：名称、值、过期时间、路径和域，路径与  
域合在一起就构成了Cookie的作用范围，因此用Cookie方式可实现SSO,但域名必须相同。

目前大部分SSO产品采用的是Cookie机制，最好的开源单点登录产品CAS也是采用Cookie机  
制。

## 一、CAS思路 ##

我们先来看一张图，域名不同实现单点登录该如何实现呢？  
![在这里插入图片描述][254b59a0708f444c9b44a4afee3bd82f.png]

如上图所示，多个系统之间的登录会通过一个独立的登录系统去做  
验证，它就相当于是一个中介公司，整合了所有人，你要看房经过  
中介允许拿钥匙就行，实现了统一的登录。那么这个就称之为CAS  
系统，CAS全称为Central Authentication Servicel即中央认证服务，  
是一个单点登录的解决方案，可以用于不同顶级域名之间的单点登  
录。那么在咱们课程中呢目前的项目结构源码不需要去破坏，我们  
只需要构建两个静态站点来测试使用即可。

在CAS中的具体的流程参考如下时序图：

![在这里插入图片描述][17c6530b5fb1444f958247664348ef3a.png]  
**流程分析：**

1.  用户访问MTV系统的受保护资源，MTV系统发现用户未登录，跳转至SSO认证中心，并将自己的地址作为参数
2.  SSO认证中心发现用户未登录，跳转至登录页面
3.  用户输入用户名密码提交登录申请
4.  SSO认证中心校验用户信息，创建用户与SSO认证中心之间的全局会话，全局令牌(和用户全局会话ID绑定，代表用户在SSO登录偶)和临时令牌(用于验证子系统身份)
5.  SSO认证中心携带令牌跳转MTV系统最初的请求地址
6.  MTV系统拿到令牌，去SSO认证中心校验令牌是否有效
7.  SSO认证中心校验令牌，回传用户全局会话
8.  MTV系统保存用户的全局会话
9.  用户浏览器显示登录成功

**再次登录流程图：**  
![在这里插入图片描述][1e6d95f928044206ac7909af6cd87e44.png]  
**流程分析：**

1.  用户访问MUSIC系统的受保护资源
2.  MUSIC系统发现用户未登录，跳转至SSO认证中心，并将自己的地址作为参数
3.  SSO认证中心发现用户已登录，跳转回MUSIC系统的地址，并附上令牌
4.  MUSIC系统拿到令牌，去SSO认证中心校验令牌是否有效
5.  SSO认证中心校验令牌，返回用户全局会话
6.  MUSIC系统保存用户全局会话
7.  用户浏览器显示登录成功

## 二、代码实现 ##

我们按上面时序图一步一步实现代码

为了方便测试，我将本地host文件配置添加为域名访问，之后代码均以域名访问，  
host文件目录：`C:\Windows\System32\drivers\etc`，供参考

192.168.31.156 www.music.com
    192.168.31.156 www.mtv.com
    192.168.31.156 www.sso.com

### 环境准备 ###

**前端**  
这里我们创建了两个前端工程，分别是sso-mtv和sso-music  
![在这里插入图片描述][ad9151b64204425a80150bd19b18d8b0.png]  
使用本地nginx做了部署

### 代码实现 ###

#### 2.1 MTV系统前端判断是否登录，依据前端cookie是否存在用户信息 ####

// 通过cookie判断用户是否登录
    judgeUserLoginStatus() {
        
    	var userCookie = app.getCookie("user");
    	if (
    		userCookie != null &&
    		userCookie != undefined &&
    		userCookie != ""
    	) {
        
    		var userInfoStr = decodeURIComponent(userCookie);
    		// console.log(userInfo);
    		if (
    			userInfoStr != null &&
    			userInfoStr != undefined &&
    			userInfoStr != ""
    		) {
        
    			var userInfo = JSON.parse(userInfoStr);
                            // 判断是否是一个对象
                            if ( typeof(userInfo)  == "object" ) {
        
                                this.userIsLogin = true;
                                // console.log(userInfo);
                                this.userInfo = userInfo;
                            } else {
        
                                this.userIsLogin = false;
                                this.userInfo = {
        };
                            }
    		}
    	} else {
        
    		this.userIsLogin = false;
    		this.userInfo = {
        };
    	}
    }

#### 2.2 MTV系统前端判断链接是否携带临时票据，如果携带则发送校验请求，如果不存在证明用户从未登录，则跳转登录页面 ####

// 判断用户是否登录
    var userIsLogin = this.userIsLogin;
    if (!userIsLogin) {
        
    	// 如果没有登录，判断一下是否存在tmpTicket临时票据
    	var tmpTicket = app.getUrlParam("tmpTicket");
    	console.log("tmpTicket: " + tmpTicket);
    	if (tmpTicket != null && tmpTicket != "" && tmpTicket != undefined) {
        
    		// 如果有tmpTicket临时票据，就携带临时票据发起请求到cas验证获取用户会话
    		var serverUrl = app.serverUrl;
    		axios.defaults.withCredentials = true;
    		axios.post('http://www.sso.com:8090/verifyTmpTicket?tmpTicket=' + tmpTicket)
    			.then(res => {
        
    				if (res.data.status == 200) {
        
    					var userInfo = res.data.data;
    					console.log(res.data.data);
    					this.userInfo = userInfo;
    					this.userIsLogin = true;
    					app.setCookie("user",  JSON.stringify(userInfo));
    					window.location.href = "http://www.mtv.com:8080/mtv/index.html";
    				} else {
        
    					alert(res.data.msg);
    					console.log(res.data.msg);
    				}
    			});
    	} else {
        
    		// 如果没有tmpTicket临时票据，说明用户从没登录过，那么就可以跳转至cas做统一登录认证了
    		window.location.href = app.SSOServerUrl + "/login?returnUrl=http://www.mtv.com:8080/mtv/index.html";
    	}
    
    	console.log(app.SSOServerUrl + "/login?returnUrl=" + window.location);
    }

#### 2.3 SSO登录接口，判断cookie中是否包含用户全局令牌，存在证明用户登录过，颁发临时令牌并会跳，如果不存在则跳转登录 ####

@GetMapping("/login")
    public String login(String returnUrl,
                         Model model,
                         HttpServletRequest request,
                         HttpServletResponse response) {
        
    
         model.addAttribute("returnUrl", returnUrl);
    
         // 1. 获取userTicket门票，如果cookie中能够获取到，证明用户登录过，此时签发一个一次性的临时票据并且回跳
         String userTicket = getCookie(request, COOKIE_USER_TICKET);
    
         boolean isVerified = verifyUserTicket(userTicket);
         if (isVerified) {
        
             String tmpTicket = createTmpTicket();
             return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
         }
    
         // 2. 用户从未登录过，第一次进入则跳转到CAS的统一登录页面
         return "login";
     }

#### 2.4 SSO统一登录接口 ####

/**
     * CAS的统一登录接口
     *      目的：
     *          1. 登录后创建用户的全局会话                 ->  uniqueToken
     *          2. 创建用户全局门票，用以表示在CAS端是否登录  ->  userTicket
     *          3. 创建用户的临时票据，用于回跳回传          ->  tmpTicket
     */
    @PostMapping("/doLogin")
    public String doLogin(String username,
                          String password,
                          String returnUrl,
                          Model model,
                          HttpServletRequest request,
                          HttpServletResponse response) throws Exception {
        
    
        model.addAttribute("returnUrl", returnUrl);
    
        // 0. 判断用户名和密码必须不为空
        if (StringUtils.isBlank(username) ||
                StringUtils.isBlank(password)) {
        
            model.addAttribute("errmsg", "用户名或密码不能为空");
            return "login";
        }
    
        // 1. 实现登录
        Users userResult = userService.queryUserForLogin(username,
                MD5Utils.getMD5Str(password));
        if (userResult == null) {
        
            model.addAttribute("errmsg", "用户名或密码不正确");
            return "login";
        }
    
        // 2. 实现用户的redis会话
        String uniqueToken = UUID.randomUUID().toString().trim();
        UsersVO usersVO = new UsersVO();
        BeanUtils.copyProperties(userResult, usersVO);
        usersVO.setUserUniqueToken(uniqueToken);
        redisOperator.set(REDIS_USER_TOKEN + ":" + userResult.getId(),
                JsonUtils.objectToJson(usersVO));
    
        // 3. 生成ticket门票，全局门票，代表用户在CAS端登录过
        String userTicket = UUID.randomUUID().toString().trim();
    
        // 3.1 用户全局门票需要放入CAS端的cookie中
        setCookie(COOKIE_USER_TICKET, userTicket, response);
    
        // 4. userTicket关联用户id，并且放入到redis中，代表这个用户有门票了，可以在各个景区游玩
        redisOperator.set(REDIS_USER_TICKET + ":" + userTicket, userResult.getId());
    
        // 5. 生成临时票据，回跳到调用端网站，是由CAS端所签发的一个一次性的临时ticket
        String tmpTicket = createTmpTicket();
    
        /**
         * userTicket: 用于表示用户在CAS端的一个登录状态：已经登录
         * tmpTicket: 用于颁发给用户进行一次性的验证的票据，有时效性
         */
    
        /**
         * 举例：
         *      我们去动物园玩耍，大门口买了一张统一的门票，这个就是CAS系统的全局门票和用户全局会话。
         *      动物园里有一些小的景点，需要凭你的门票去领取一次性的票据，有了这张票据以后就能去一些小的景点游玩了。
         *      这样的一个个的小景点其实就是我们这里所对应的一个个的站点。
         *      当我们使用完毕这张临时票据以后，就需要销毁。
         */
    
    //        return "login";
    
        return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
    }

#### 2.5 SSO验证临时票据方法 ####

@PostMapping("/verifyTmpTicket")
    @ResponseBody
    public IMOOCJSONResult verifyTmpTicket(String tmpTicket,
                        HttpServletRequest request,
                        HttpServletResponse response) throws Exception {
        
    
        // 使用一次性临时票据来验证用户是否登录，如果登录过，把用户会话信息返回给站点
        // 使用完毕后，需要销毁临时票据
        String tmpTicketValue = redisOperator.get(REDIS_TMP_TICKET + ":" + tmpTicket);
        if (StringUtils.isBlank(tmpTicketValue)) {
        
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }
    
        // 0. 如果临时票据OK，则需要销毁，并且拿到CAS端cookie中的全局userTicket，以此再获取用户会话
        if (!tmpTicketValue.equals(MD5Utils.getMD5Str(tmpTicket))) {
        
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        } else {
        
            // 销毁临时票据
            redisOperator.del(REDIS_TMP_TICKET + ":" + tmpTicket);
        }
    
        // 1. 验证并且获取用户的userTicket
        String userTicket = getCookie(request, COOKIE_USER_TICKET);
        String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
        if (StringUtils.isBlank(userId)) {
        
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }
    
        // 2. 验证门票对应的user会话是否存在
        String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
        if (StringUtils.isBlank(userRedis)) {
        
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }
    
        // 验证成功，返回OK，携带用户会话
        return IMOOCJSONResult.ok(JsonUtils.jsonToPojo(userRedis, UsersVO.class));
    }

#### 2.6 注销方法 ####

@PostMapping("/logout")
    @ResponseBody
    public IMOOCJSONResult logout(String userId,
                                HttpServletRequest request,
                                HttpServletResponse response) throws Exception {
        
    
         // 0. 获取CAS中的用户门票
         String userTicket = getCookie(request, COOKIE_USER_TICKET);
    
         // 1. 清除userTicket票据，redis/cookie
         deleteCookie(COOKIE_USER_TICKET, response);
         redisOperator.del(REDIS_USER_TICKET + ":" + userTicket);
    
         // 2. 清除用户全局会话（分布式会话）
         redisOperator.del(REDIS_USER_TOKEN + ":" + userId);
    
         return IMOOCJSONResult.ok();
     }

#### 2.7 完整的controller ####

package com.imooc.controller;
    
    import com.imooc.pojo.Users;
    import com.imooc.pojo.vo.UsersVO;
    import com.imooc.service.UserService;
    import com.imooc.utils.IMOOCJSONResult;
    import com.imooc.utils.JsonUtils;
    import com.imooc.utils.MD5Utils;
    import com.imooc.utils.RedisOperator;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.BeanUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.UUID;
    
    @Controller
    public class SSOController {
        
    
        @Autowired
        private UserService userService;
    
        @Autowired
        private RedisOperator redisOperator;
    
        public static final String REDIS_USER_TOKEN = "redis_user_token";
        public static final String REDIS_USER_TICKET = "redis_user_ticket";
        public static final String REDIS_TMP_TICKET = "redis_tmp_ticket";
    
        public static final String COOKIE_USER_TICKET = "cookie_user_ticket";
    
        @GetMapping("/login")
        public String login(String returnUrl,
                            Model model,
                            HttpServletRequest request,
                            HttpServletResponse response) {
        
    
            model.addAttribute("returnUrl", returnUrl);
    
            // 1. 获取userTicket门票，如果cookie中能够获取到，证明用户登录过，此时签发一个一次性的临时票据并且回跳
            String userTicket = getCookie(request, COOKIE_USER_TICKET);
    
            boolean isVerified = verifyUserTicket(userTicket);
            if (isVerified) {
        
                String tmpTicket = createTmpTicket();
                return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
            }
    
            // 2. 用户从未登录过，第一次进入则跳转到CAS的统一登录页面
            return "login";
        }
    
        /**
         * 校验CAS全局用户门票
         * @param userTicket
         * @return
         */
        private boolean verifyUserTicket(String userTicket) {
        
    
            // 0. 验证CAS门票不能为空
            if (StringUtils.isBlank(userTicket)) {
        
                return false;
            }
    
            // 1. 验证CAS门票是否有效
            String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
            if (StringUtils.isBlank(userId)) {
        
                return false;
            }
    
            // 2. 验证门票对应的user会话是否存在
            String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
            if (StringUtils.isBlank(userRedis)) {
        
                return false;
            }
    
            return true;
        }
    
        /**
         * CAS的统一登录接口
         *      目的：
         *          1. 登录后创建用户的全局会话                 ->  uniqueToken
         *          2. 创建用户全局门票，用以表示在CAS端是否登录  ->  userTicket
         *          3. 创建用户的临时票据，用于回跳回传          ->  tmpTicket
         */
        @PostMapping("/doLogin")
        public String doLogin(String username,
                              String password,
                              String returnUrl,
                              Model model,
                              HttpServletRequest request,
                              HttpServletResponse response) throws Exception {
        
    
            model.addAttribute("returnUrl", returnUrl);
    
            // 0. 判断用户名和密码必须不为空
            if (StringUtils.isBlank(username) ||
                    StringUtils.isBlank(password)) {
        
                model.addAttribute("errmsg", "用户名或密码不能为空");
                return "login";
            }
    
            // 1. 实现登录
            Users userResult = userService.queryUserForLogin(username,
                    MD5Utils.getMD5Str(password));
            if (userResult == null) {
        
                model.addAttribute("errmsg", "用户名或密码不正确");
                return "login";
            }
    
            // 2. 实现用户的redis会话
            String uniqueToken = UUID.randomUUID().toString().trim();
            UsersVO usersVO = new UsersVO();
            BeanUtils.copyProperties(userResult, usersVO);
            usersVO.setUserUniqueToken(uniqueToken);
            redisOperator.set(REDIS_USER_TOKEN + ":" + userResult.getId(),
                    JsonUtils.objectToJson(usersVO));
    
            // 3. 生成ticket门票，全局门票，代表用户在CAS端登录过
            String userTicket = UUID.randomUUID().toString().trim();
    
            // 3.1 用户全局门票需要放入CAS端的cookie中
            setCookie(COOKIE_USER_TICKET, userTicket, response);
    
            // 4. userTicket关联用户id，并且放入到redis中，代表这个用户有门票了，可以在各个景区游玩
            redisOperator.set(REDIS_USER_TICKET + ":" + userTicket, userResult.getId());
    
            // 5. 生成临时票据，回跳到调用端网站，是由CAS端所签发的一个一次性的临时ticket
            String tmpTicket = createTmpTicket();
    
            /**
             * userTicket: 用于表示用户在CAS端的一个登录状态：已经登录
             * tmpTicket: 用于颁发给用户进行一次性的验证的票据，有时效性
             */
    
            /**
             * 举例：
             *      我们去动物园玩耍，大门口买了一张统一的门票，这个就是CAS系统的全局门票和用户全局会话。
             *      动物园里有一些小的景点，需要凭你的门票去领取一次性的票据，有了这张票据以后就能去一些小的景点游玩了。
             *      这样的一个个的小景点其实就是我们这里所对应的一个个的站点。
             *      当我们使用完毕这张临时票据以后，就需要销毁。
             */
    
    //        return "login";
    
            return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
        }
    
    
        @PostMapping("/verifyTmpTicket")
        @ResponseBody
        public IMOOCJSONResult verifyTmpTicket(String tmpTicket,
                            HttpServletRequest request,
                            HttpServletResponse response) throws Exception {
        
    
            // 使用一次性临时票据来验证用户是否登录，如果登录过，把用户会话信息返回给站点
            // 使用完毕后，需要销毁临时票据
            String tmpTicketValue = redisOperator.get(REDIS_TMP_TICKET + ":" + tmpTicket);
            if (StringUtils.isBlank(tmpTicketValue)) {
        
                return IMOOCJSONResult.errorUserTicket("用户票据异常");
            }
    
            // 0. 如果临时票据OK，则需要销毁，并且拿到CAS端cookie中的全局userTicket，以此再获取用户会话
            if (!tmpTicketValue.equals(MD5Utils.getMD5Str(tmpTicket))) {
        
                return IMOOCJSONResult.errorUserTicket("用户票据异常");
            } else {
        
                // 销毁临时票据
                redisOperator.del(REDIS_TMP_TICKET + ":" + tmpTicket);
            }
    
            // 1. 验证并且获取用户的userTicket
            String userTicket = getCookie(request, COOKIE_USER_TICKET);
            String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
            if (StringUtils.isBlank(userId)) {
        
                return IMOOCJSONResult.errorUserTicket("用户票据异常");
            }
    
            // 2. 验证门票对应的user会话是否存在
            String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
            if (StringUtils.isBlank(userRedis)) {
        
                return IMOOCJSONResult.errorUserTicket("用户票据异常");
            }
    
            // 验证成功，返回OK，携带用户会话
            return IMOOCJSONResult.ok(JsonUtils.jsonToPojo(userRedis, UsersVO.class));
        }
    
        @PostMapping("/logout")
        @ResponseBody
        public IMOOCJSONResult logout(String userId,
                                   HttpServletRequest request,
                                   HttpServletResponse response) throws Exception {
        
    
            // 0. 获取CAS中的用户门票
            String userTicket = getCookie(request, COOKIE_USER_TICKET);
    
            // 1. 清除userTicket票据，redis/cookie
            deleteCookie(COOKIE_USER_TICKET, response);
            redisOperator.del(REDIS_USER_TICKET + ":" + userTicket);
    
            // 2. 清除用户全局会话（分布式会话）
            redisOperator.del(REDIS_USER_TOKEN + ":" + userId);
    
            return IMOOCJSONResult.ok();
        }
    
        /**
         * 创建临时票据
         * @return
         */
        private String createTmpTicket() {
        
            String tmpTicket = UUID.randomUUID().toString().trim();
            try {
        
                redisOperator.set(REDIS_TMP_TICKET + ":" + tmpTicket,
                        MD5Utils.getMD5Str(tmpTicket), 600);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return tmpTicket;
        }
    
        private void setCookie(String key,
                               String val,
                               HttpServletResponse response) {
        
    
            Cookie cookie = new Cookie(key, val);
            cookie.setDomain("sso.com");
            cookie.setPath("/");
            response.addCookie(cookie);
        }
    
        private void deleteCookie(String key,
                               HttpServletResponse response) {
        
    
            Cookie cookie = new Cookie(key, null);
            cookie.setDomain("sso.com");
            cookie.setPath("/");
            cookie.setMaxAge(-1);
            response.addCookie(cookie);
        }
    
        private String getCookie(HttpServletRequest request, String key) {
        
    
            Cookie[] cookieList = request.getCookies();
            if (cookieList == null || StringUtils.isBlank(key)) {
        
                return null;
            }
    
            String cookieValue = null;
            for (int i = 0 ; i < cookieList.length; i ++) {
        
                if (cookieList[i].getName().equals(key)) {
        
                    cookieValue = cookieList[i].getValue();
                    break;
                }
            }
    
            return cookieValue;
        }
    
    
    }

**注：此Demo在新版谷歌浏览器登录过程验证临时票据方法verifyTmpTicket中，会出现前端cookie后端无法获取的情况，具体原因详见[《版本chrome浏览器带来的跨域请求cookie丢失问题》][chrome_cookie]**

[254b59a0708f444c9b44a4afee3bd82f.png]: https://img-blog.csdnimg.cn/254b59a0708f444c9b44a4afee3bd82f.png
[17c6530b5fb1444f958247664348ef3a.png]: https://img-blog.csdnimg.cn/17c6530b5fb1444f958247664348ef3a.png
[1e6d95f928044206ac7909af6cd87e44.png]: https://img-blog.csdnimg.cn/1e6d95f928044206ac7909af6cd87e44.png
[ad9151b64204425a80150bd19b18d8b0.png]: https://img-blog.csdnimg.cn/ad9151b64204425a80150bd19b18d8b0.png
[chrome_cookie]: https://blog.csdn.net/qq_37788558/article/details/104484888