CAS单点登录系统的实现

企业开发 2023-09-19 08:05:45 阅读次数: 0

CAS单点登录系统的实现

前言

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

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

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

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

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

一、CAS思路

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

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

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

在这里插入图片描述
流程分析：

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

再次登录流程图：
在这里插入图片描述
流程分析：

  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
在这里插入图片描述
使用本地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丢失问题》

猜你喜欢

转载自blog.csdn.net/qq_38055805/article/details/129746303
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022