CAS登出原理-源码分析

最新推荐文章于 2024-03-08 15:46:51 发布
最新推荐文章于 2024-03-08 15:46:51 发布
阅读量1.6k 收藏 6
点赞数 3
分类专栏： JAVA相关 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cccfire/article/details/113978448
版权

CAS-server登出如何保证客户端登出的？

大致流程描述：server端登出会根据在webflow scope中存储的TGT信息查询ticket即st，然后根据st携带应用信息向客户端发送登出POST请求。客户端需要配置SingleSignOutFilter拦截器，在拦截器中将客户端的session失效。

源码分析server端cas源码5.3.3

TerminateSessionAction类

    public Event doExecute(final RequestContext requestContext) {
        boolean terminateSession = true;
        if (logoutProperties.isConfirmLogout()) {
            terminateSession = isLogoutRequestConfirmed(requestContext);
        }
        if (terminateSession) {
            //确认登出
            return terminate(requestContext);
        }
        return this.eventFactorySupport.event(this, CasWebflowConstants.STATE_ID_WARN);
    }

 public Event terminate(final RequestContext context) {
        final HttpServletRequest request = WebUtils.getHttpServletRequestFromExternalWebflowContext(context);
        final HttpServletResponse response = WebUtils.getHttpServletResponseFromExternalWebflowContext(context);
		//从上下文中获取tgt
        String tgtId = WebUtils.getTicketGrantingTicketId(context);
        //如果上下文中拿不到tgt尝试从cookie中获取tgt
        if (StringUtils.isBlank(tgtId)) {
            tgtId = this.ticketGrantingTicketCookieGenerator.retrieveCookieValue(request);
        }
        if (StringUtils.isNotBlank(tgtId)) {
            LOGGER.debug("Destroying SSO session linked to ticket-granting ticket [{}]", tgtId);     
            //构造登出请求到发送到客户端
            final List<LogoutRequest> logoutRequests = this.centralAuthenticationService.destroyTicketGrantingTicket(tgtId);
            WebUtils.putLogoutRequests(context, logoutRequests);
        }
        LOGGER.debug("Removing CAS cookies");
        this.ticketGrantingTicketCookieGenerator.removeCookie(response);
        this.warnCookieGenerator.removeCookie(response);

        destroyApplicationSession(request, response);
        LOGGER.debug("Terminated all CAS sessions successfully.");

        if (StringUtils.isNotBlank(logoutProperties.getRedirectUrl())) {
            WebUtils.putLogoutRedirectUrl(context, logoutProperties.getRedirectUrl());
            return this.eventFactorySupport.event(this, CasWebflowConstants.STATE_ID_REDIRECT);
        }

        return this.eventFactorySupport.success(this);
    }

DefaultCentralAuthenticationService 类

public List<LogoutRequest> destroyTicketGrantingTicket(final String ticketGrantingTicketId) {
        try {
            //根据tgtId获取tgt对象，对象中存储了客户端信息
            final TicketGrantingTicket ticket = getTicket(ticketGrantingTicketId, TicketGrantingTicket.class);
AuthenticationCredentialsThreadLocalBinder.bindCurrent(ticket.getAuthentication());
			//根据ticket对象构造客户端请求信息
            final List<LogoutRequest> logoutRequests = this.logoutManager.performLogout(ticket);
            //删除tgt，让server端登出
            deleteTicket(ticketGrantingTicketId);
			//发送tgt销毁时间
            doPublishEvent(new CasTicketGrantingTicketDestroyedEvent(this, ticket));

            return logoutRequests;
        } catch (final InvalidTicketException e) {
            LOGGER.debug("TicketGrantingTicket [{}] cannot be found in the ticket registry.", ticketGrantingTicketId);
        }
        return new ArrayList<>(0);
    }

DefaultLogoutManager 类

 public List<LogoutRequest> performLogout(final TicketGrantingTicket ticket) {
        LOGGER.info("Performing logout operations for [{}]", ticket.getId());
        //客户端登出是否开启未开启不执行
        if (this.singleLogoutCallbacksDisabled) {
            return new ArrayList<>(0);
        }
        //根据ticker对象构造客户端登出
        final List<LogoutRequest> logoutRequests = performLogoutForTicket(ticket);
        //客户端登出之后要invoke响应的handle做一些操作，比如删除ticket信息
        this.logoutExecutionPlan.getLogoutHandlers().forEach(h -> {
            h.handle(ticket);
        });
        return logoutRequests;
    }

DefaultLogoutManager类
private List<LogoutRequest> performLogoutForTicket(final TicketGrantingTicket ticketToBeLoggedOut) {
        //获取这个tgt下发的st和授权的service
		val streamServices = Stream.concat(Stream.of(ticketToBeLoggedOut.getServices()),
				Stream.of(ticketToBeLoggedOut.getProxyGrantingTickets()));
		//将map转换成list并且筛选掉不是WebApplicationService的应用
		val logoutServices = streamServices.map(Map::entrySet).flatMap(Set::stream)
				.filter(entry -> entry.getValue() instanceof WebApplicationService).filter(Objects::nonNull)
				.map(entry -> Pair.of(entry.getKey(), (WebApplicationService) entry.getValue()))
				.collect(Collectors.toList());
		//删除需要登出的oauth token
		destroyOAuth20Tokens(ticketToBeLoggedOut);

		val sloHandlers = logoutExecutionPlan.getSingleLogoutServiceMessageHandlers();
		return logoutServices.stream().map(
				entry -> sloHandlers.stream().filter(handler -> handler.supports(entry.getValue())).map(handler -> {
					val service = entry.getValue();
					log.debug("Handling single logout callback for [{}]", service.getId());
					return handler.handle(service, entry.getKey(), ticketToBeLoggedOut);
				}).flatMap(Collection::stream).filter(Objects::nonNull).collect(Collectors.toList()))
				.flatMap(Collection::stream).distinct().collect(Collectors.toList());
	}

BaseSingleLogoutServiceMessageHandler 类
public Collection<LogoutRequest> handle(final WebApplicationService singleLogoutService, final String ticketId,
			final TicketGrantingTicket ticketGrantingTicket) {
		if (singleLogoutService.isLoggedOutAlready()) {
			return new ArrayList<>(0);
		}
		//根据应用类型获取service主要兼容ouath对接的应用
		val selectedService = (WebApplicationService) this.authenticationRequestServiceSelectionStrategies
				.resolveService(singleLogoutService);
	   //根据service查询判断注册应用的有效期等等
		val registeredService = this.servicesManager.findServiceBy(selectedService);
				selectedService.getId(), registeredService.getName());
		//获取配置的登出路径
		val logoutUrls = this.singleLogoutServiceLogoutUrlBuilder.determineLogoutUrl(registeredService,
				selectedService);
		if (logoutUrls == null || logoutUrls.isEmpty()) {
			return new ArrayList<>(0);
		}
		return createLogoutRequests(ticketId, selectedService, registeredService, logoutUrls, ticketGrantingTicket);
	}

BaseSingleLogoutServiceMessageHandler 类
protected Collection<LogoutRequest> createLogoutRequests(final String ticketId,
			final WebApplicationService selectedService, final RegisteredService registeredService,
			final Collection<URL> logoutUrls, final TicketGrantingTicket ticketGrantingTicket) {
		return logoutUrls.stream().map(
		        // 获取到登出的应用地址，循环进行登出
				url -> createLogoutRequest(ticketId, selectedService, registeredService, url, ticketGrantingTicket))
				.filter(Objects::nonNull).collect(Collectors.toList());
	}

BaseSingleLogoutServiceMessageHandler 类
	private LogoutRequest createLogoutRequest(final String ticketId, final WebApplicationService selectedService,
			final RegisteredService registeredService, final URL logoutUrl,
			final TicketGrantingTicket ticketGrantingTicket) {
		//build请求对象
		val logoutRequest = DefaultSingleLogoutRequest.builder().ticketId(ticketId).service(selectedService)
				.logoutUrl(logoutUrl).logoutType(registeredService.getLogoutType()).registeredService(registeredService)
				.ticketGrantingTicket(ticketGrantingTicket).build();
		final RegisteredService.LogoutType type = registeredService.getLogoutType() == null
				? RegisteredService.LogoutType.BACK_CHANNEL
				: registeredService.getLogoutType();
		
		if (type == RegisteredService.LogoutType.BACK_CHANNEL) {
		   //cas一般是后端登出，即后台往应用地址发送请求
			if (performBackChannelLogout(logoutRequest)) {
				logoutRequest.setStatus(LogoutRequestStatus.SUCCESS);
			} else {
				logoutRequest.setStatus(LogoutRequestStatus.FAILURE);
				
			}
		} else {
			
					selectedService, type);
			logoutRequest.setStatus(LogoutRequestStatus.NOT_ATTEMPTED);
		}
		return logoutRequest;
	}

public boolean performBackChannelLogout(final LogoutRequest request) {
		try {
			//封装请求参数，即post请求的表单信息
			val logoutRequest = createSingleLogoutMessage(request);
			final WebApplicationService logoutService = request.getService();
			logoutService.setLoggedOutAlready(true);
			final LogoutHttpMessage msg = new LogoutHttpMessage(request.getLogoutUrl(), logoutRequest.getPayload(),
					this.asynchronous);
			//向应用发出登出请求
			return this.httpClient.sendMessageToEndPoint(msg);
		} catch (final Exception e) {
			log.error(e.getMessage(), e);
		}
		return false;
	}

public SingleLogoutMessage createSingleLogoutMessage(final LogoutRequest logoutRequest) {
		return this.logoutMessageBuilder.create(logoutRequest);
	}

DefaultSingleLogoutMessageCreator 类
//客户端会根据这个xml判断是不是登出请求
private static final String LOGOUT_REQUEST_TEMPLATE = "<samlp:LogoutRequest xmlns:samlp=\"urn:oasis:names:tc:SAML:2.0:protocol\" ID=\"%s\" Version=\"2.0\" "
			+ "IssueInstant=\"%s\"><saml:NameID xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\">%s"
			+ "</saml:NameID><samlp:SessionIndex>%s</samlp:SessionIndex></samlp:LogoutRequest>";

	@SuppressWarnings("rawtypes")
	@Override
	public SingleLogoutMessage create(final LogoutRequest request) {
		val logoutRequest = String.format(LOGOUT_REQUEST_TEMPLATE, GENERATOR.getNewTicketId("LR"),
				new ISOStandardDateFormat().getCurrentDateAndTime(),
				request.getTicketGrantingTicket().getAuthentication().getPrincipal().getId(), request.getTicketId());

		val builder = SingleLogoutMessage.builder();
		if (request.getLogoutType() == RegisteredService.LogoutType.FRONT_CHANNEL) {
			log.trace("Attempting to deflate the logout message [{}]", logoutRequest);
			return builder.payload(CompressionUtils.deflate(logoutRequest)).build();
		}
       //返回请求体
		return builder.payload(logoutRequest).build();
	}

源码分析client端cas源码5.3.3

客户端配置登出拦截器，一般要放在第一个。

    @Bean
    public FilterRegistrationBean<SingleSignOutFilter> filterSingleRegistration() {
    	FilterRegistrationBean<SingleSignOutFilter> registration = new FilterRegistrationBean<SingleSignOutFilter>();
    	registration.setFilter(new SingleSignOutFilter());
    	Map<String,String> initParameters = new HashMap<>();
    	initParameters.put("casServerUrlPrefix",CAS_SERVER_URL_PREFIX );
    	registration.setInitParameters(initParameters);
    	//set mapping url
    	registration.addUrlPatterns("/*");
    	//set loading sequence
    	registration.setOrder(1);
    	return registration;
    }

当收到server端发送的请求，会进入SingleSignOutFilter拦截器，看代码

SingleSignOutFilter 类
 public void doFilter(final ServletRequest servletRequest, final ServletResponse servletResponse,
            final FilterChain filterChain) throws IOException, ServletException {
        final HttpServletRequest request = (HttpServletRequest) servletRequest;
        final HttpServletResponse response = (HttpServletResponse) servletResponse;
        if (!this.handlerInitialized.getAndSet(true)) {
            HANDLER.init();
        }
		//拦截器处理请求
        if (HANDLER.process(request, response)) {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    }

public boolean process(final HttpServletRequest request, final HttpServletResponse response) {
        if (isTokenRequest(request)) {
            logger.trace("Received a token request");
            recordSession(request);
            return true;
        } 
        //拦截器判断是不是登出请求
        if (isLogoutRequest(request)) {
            logger.trace("Received a logout request");
            destroySession(request);
            return false;
        } 
        logger.trace("Ignoring URI for logout: {}", request.getRequestURI());
        return true;
    }

  private boolean isLogoutRequest(final HttpServletRequest request) {
        if ("POST".equalsIgnoreCase(request.getMethod())) {
            return !isMultipartRequest(request)
                    //通过这个判断，就是看看请求参数有没有默认值logoutRequest，参见server端有个xml："<samlp:LogoutRequest xmlns:samlp=\"urn:oasis:names:tc:SAML:2.0:protocol\" ID=\"%s\" Version=\"2.0\" "
//			+ "IssueInstant=\"%s\"><saml:NameID xmlns:saml=\"urn:oasis:names:tc:SAML:2.0:assertion\">%s"
//			+ "</saml:NameID><samlp:SessionIndex>%s</samlp:SessionIndex></samlp:LogoutRequest>"
                    && CommonUtils.isNotBlank(CommonUtils.safeGetParameter(request, this.logoutParameterName,
                    this.safeParameters));
        }
        if ("GET".equalsIgnoreCase(request.getMethod())) {
            return CommonUtils.isNotBlank(CommonUtils.safeGetParameter(request, this.logoutParameterName, this.safeParameters));
        }
        return false;
    }

如果拦截器拦截到请求是登出请求,就把客户端sesssion失效
private void destroySession(final HttpServletRequest request) {
        String logoutMessage = CommonUtils.safeGetParameter(request, this.logoutParameterName, this.safeParameters);
        if (CommonUtils.isBlank(logoutMessage)) {
            return;
        }
        if (!logoutMessage.contains("SessionIndex")) {
            logoutMessage = uncompressLogoutMessage(logoutMessage);
        }
        logger.trace("Logout request:\n{}", logoutMessage);
        //从xml中获取应用的st
        final String token = XmlUtils.getTextForElement(logoutMessage, "SessionIndex");
        if (CommonUtils.isNotBlank(token)) {
        	//客户端移除st和session的关系
            final HttpSession session = this.sessionMappingStorage.removeSessionByMappingId(token);
            if (session != null) {
                try {
                // session失效，客户端登出
                    session.invalidate();
                } catch (final IllegalStateException e) {
                    logger.debug("Error invalidating session.", e);
                }
                this.logoutStrategy.logout(request);
            }
        }
    }
CAS实现SSO单点登录原理
hongbinchen的专栏
09-04 3万+
yale cas可以百度一下，这是学习cas后的一点总结，以备日后使用！ 安全性： 用户只须在cas录入用户名和密码，之后通过ticket绑定用户，在cas客户端与cas校验是通过ticket，并不会在网上传输密码，所以可以保证安全性，密码不被窃取 原理：１个cookie+
CAS单点登入登出原理
FromZeroJiYuan的博客
11-25 1006
CAS 集中式认证服务(Central Authentication Service，CAS)，单点登录协议，允许一个用户访问多个应用程序，而只需要提供一次凭证。 具体实现框架有：OAuth2，Shiro等。 普通CAS1.0 登入详细流程 流程解析： (1-2) 用户第一次通过浏览器Browser访问受保护的应用系统app1，应用系统app1发现访问请求中没有JSESSIONID or ST(service ticket) ，要求Browser重定向去CAS service获取ST； 在每个受
CAS单点登录原理
weixin_43911286的博客
03-03 816
转载地址：转载博客 1、基于Cookie的单点登录的回顾 基于Cookie的单点登录核心原理： 将用户名密码加密之后存于Cookie中，之后访问网站时在过滤器（filter）中校验用户权限，如果没有权限则从Cookie中取出用户名密码进行登录，让用户从某种意义上觉得只登录了一次。 该方式缺点就是多次传送用户名密码，增加被盗风险，以及不能跨域。同时www.qiandu.com与mail.qiandu.com同时拥有登录逻辑的代码，如果涉及到修改操作，则需要修改两处。 2、统一认证中心方案原理 在生活中我们
cas单点才登出原理
04-18
cas单点才登出原理cas单点才登出原理
CAS 4.1.x 单点登出（退出登录）的原理解析
weixin_33738982的博客
07-19 1922
2019独角兽企业重金招聘Python工程师标准>>> ...
CAS原理（源码例子解析）
qq_41566772的博客
08-17 270
通过Unsafe保证原子性 Unsafe 是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，基于该类可以直接操作特定内存的数据。（注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务） 变量valueOffset，表示该变量在内存中的偏移地址，因为Unsafe就是根据内存偏...
CAS登陆原理
qq_38949960的博客
11-12 126
超详细的演示！ https://www.cnblogs.com/lihuidu/p/6495247.html
cas-server-4.0.0-release.rar
04-12
8. **源码分析**：对于开发者而言，源码提供了深入理解CAS工作原理的机会，便于自定义和调试，也可以学习到基于Spring框架的Web应用开发。 9. **国际化与本地化**：CAS 4.0.0支持多语言环境，方便不同地区的用户...
CAS源码浅析
DramaLifes的博客
05-16 347
文章目录CAS源码浅析compareAndSwapIntresolveresolve_implis_jweakresolve_jweakjweak_refguard_valueindex_oop_from_field_offset_longcmpxchg__sync_val_compare_and_swapplan9汇编 CAS源码浅析 学过Java的对下面的一定不是很陌生，我来做一个源码浅析，以compareAndSwapInt为例 compareAndSwapInt public final nativ
CAS-SSO源码包（两个版本）
12-27
CAS（Central ...同时，如果你正在进行CAS的二次开发或者想要定制化CAS以适应特定环境，源码分析是必不可少的步骤。通过对源码的学习，你可以深入理解其内部工作原理，从而更好地利用和调整CAS以满足需求。
Cas登出
qq_36956015的博客
03-02 580
https://www.2cto.com/kf/201403/289366.html http://www.360doc.com/content/14/0831/01/834950_405939079.shtml https://blog.csdn.net/nmsbq/article/details/73511269
cas实现单点登录,登出(java和php客户端)
05-29
NULL 博文链接：https://zxs19861202.iteye.com/blog/855856
cas系列-cas登出(四)
weixin_34005042的博客
12-01 438
跟登陆一样,登出操作也很重要.由于是多应用间操作,状态保持也是一个要点,根据登出的影响范围,可以将登出操作分为两类: 单应用登出 单点登出(多应用登出) 顾名思义,单应用登出即登出只影响被操作的应用会话,其他应用和CAS会话状态不受影响.这也就需要你退出每一个应用,如果应用数量较多,每次退出可能都是件力气活.单点登出是结束SSO会话,所有建立在SSO会话上的的应用会话都会进行登出.使...
CAS 登出方案
最新发布
atarik@163.com
03-08 524
添加配置cas.logout.followServiceRedirects:true，使支持 CAS 退出时支持输入 service 参数为跳转路径。1) 直接在客户端调用http请求/cas/logout去注销不能携带cookie信息, 无法完成注销。2)cas登录登出ip保持一致,使用localhost或127.0.0.1应统一。
CAS 单点登录/登出 系统
Thor_Selen_Liu的博客
07-26 3157
前言：     在我们的实际开发中，更多的是采用分布式系统。那么问题来了，对于分布式系统的登录问题，我们如何解决呢？     如果说我们在每一个系统中都要进行一次登录，那么用户体验度也就差的没法用了。以京东商城为例，如果用户在登录京东商城的时候需要登录一次，在查询商品的时候还有在登录一次，加入购物车是还要重新登录，...(注意，每跳过一个页面都是进入了一个新的系统，请看他的url 地址的变化)...
一文了解CAS以及源码分析
一直AC丶
11-20 889
声明：尊重他人劳动成果，转载请附带原文链接！学习交流,仅供参考! 文章目录一、什么CAS?1、CAS简介2、CAS的三个操作数2、用处二、应用场景及源码分析三、等价代码实现1、等价代码实现四、CAS中的缺点(ABA问题),怎么解决?1、什么是ABA问题?2、自旋时间长 一、什么CAS? 1、CAS简介 CAS 是compareAndSwap的简称,用中文表达则为比较并更新,简单的说,预期原值A和从某一内存中取得的值V两者相比较,如果预期原值A和内存值V相等,那么我们就把新值B更新到内存,如果不相等,那.
CAS单点登出，调整CAS源码，实现前后端分离单点登出、清除redis、shiro登录状态
左疼右疼的专栏
05-27 2711
单点登出，调整CAS源码，实现清除redis、shiro登录状态。
CAS登录登出
海贼懒懒
08-01 1394
CAS实现 CAS理论 CAS：中央认证服务，解决sso单点登录问题 登录： 登出： A系统结束本地Session，然后通知CAS结束Session，CAS通知各个子系统结束Session ...
java cas logout无效_CAS 单点登出失效的问题（源码跟踪）
weixin_32126843的博客
02-16 1092
一、环境说明服务端：cas-server-3.5.2客户端：cas-client-3.2.1+spring mvc说明：服务端与客户端均是走的Https客户端配置文件:applicationContext-cas.xmlhttp://www.springframework.org/schema/context http://www.springframework.org/schema/contex...
CAS学习笔记四：CAS单点登出流程
拾级而上
01-18 2392
CAS 的登出包含两种情况，一种是CAS客户端登出，另一种是CAS单点登出，使用流程图说明这两者的不同。（一图胜千言） 总结自官方文档 CAS客户端登出流程 如图，客户端的登出仅仅是过期当前用户与客户端之间的会话，并未过期用户浏览器与CAS服务端建立的会话（没有处理TGC），此时如果用户再访问客户端的接口，无需输入账号密码立即登录成功。 全局单点登出流程 如图，用户访问CAS服务端单点登出接口（由客户端提供），CAS服务端根据请求携带的TGC，不仅过期了服务内TGT与ST，还向该TGC对应的客户端服
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值