《Java实战开发》利用spring-security解决CSRF问题，通过重写CsrfFilter 过滤掉指定方法

最新推荐文章于 2024-06-05 14:33:28 发布
最新推荐文章于 2024-06-05 14:33:28 发布
阅读量8.3k 收藏 10
点赞数
分类专栏： Java开发实战 文章标签： java spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39338799/article/details/85274706
版权

最近项目渗透测试检测出一些安全问题其中一项为csrf攻击隐患，然后开始修复

csrf简介

CSRF（Cross-site request forgery）跨站请求伪造，也被称为“One Click Attack”或者Session Riding，通常缩写为CSRF或者XSRF，是一种对网站的恶意利用。尽管听起来像跨站脚本（XSS），但它与XSS非常不同，XSS利用站点内的信任用户，而CSRF则通过伪装成受信任用户的请求来利用受信任的网站。与XSS攻击相比，CSRF攻击往往不大流行（因此对其进行防范的资源也相当稀少）和难以防范，所以被认为比XSS更具危险性。——百度百科

详细介绍：浅谈CSRF攻击方式 - hyddd - 博客园

一、maven pom.xml 引入jar包

        <dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>5.0.6.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>5.0.6.RELEASE</version>
		</dependency>

二、web.xml配置filter

mgmtCsrfFilter是我重写的csrfFilter名称

<!-- CSRF filter -->
	<filter>
		<filter-name>mgmtCsrfFilter</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>mgmtCsrfFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

 三、spring-application.xml配置

<bean id="mgmtCsrfFilter" class="com.haha.sps.mgmt.core.filter.MgmtCsrfFilter">
		<constructor-arg>
			<bean class="org.springframework.security.web.csrf.HttpSessionCsrfTokenRepository" />
		</constructor-arg>
	</bean>
	<bean id="requestDataValueProcessor" class="org.springframework.security.web.servlet.support.csrf.CsrfRequestDataValueProcessor"></bean>

四、重写csrffilter

重写后的csrfFilter为MgmtCsrfFilter代码如下：

package com.haha.sps.mgmt.core.filter;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.access.AccessDeniedHandlerImpl;
import org.springframework.security.web.csrf.CsrfToken;
import org.springframework.security.web.csrf.CsrfTokenRepository;
import org.springframework.security.web.csrf.InvalidCsrfTokenException;
import org.springframework.security.web.csrf.MissingCsrfTokenException;
import org.springframework.security.web.util.UrlUtils;
import org.springframework.security.web.util.matcher.RegexRequestMatcher;
import org.springframework.security.web.util.matcher.RequestMatcher;
import org.springframework.util.Assert;
import org.springframework.web.filter.OncePerRequestFilter;

/**
 * Rewrite  org.springframework.security.web.csrf.CsrfFilter 
 * exclude user/doLogion method filter
 *
 * @author Pente
 */
public final class MgmtCsrfFilter extends OncePerRequestFilter {
	/**
	 * The default {@link RequestMatcher} that indicates if CSRF protection is required or
	 * not. The default is to ignore GET, HEAD, TRACE, OPTIONS and process all other
	 * requests.
	 */
	public static final RequestMatcher DEFAULT_CSRF_MATCHER = new CsrfSecurityRequestMatcher();

	private final Log logger = LogFactory.getLog(getClass());
	private final CsrfTokenRepository tokenRepository;
	private RequestMatcher requireCsrfProtectionMatcher = DEFAULT_CSRF_MATCHER;
	private AccessDeniedHandler accessDeniedHandler = new AccessDeniedHandlerImpl();

	public MgmtCsrfFilter(CsrfTokenRepository csrfTokenRepository) {
		Assert.notNull(csrfTokenRepository, "csrfTokenRepository cannot be null");
		this.tokenRepository = csrfTokenRepository;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * org.springframework.web.filter.OncePerRequestFilter#doFilterInternal(javax.servlet
	 * .http.HttpServletRequest, javax.servlet.http.HttpServletResponse,
	 * javax.servlet.FilterChain)
	 */
	@Override
	protected void doFilterInternal(HttpServletRequest request,
			HttpServletResponse response, FilterChain filterChain)
					throws ServletException, IOException {
		request.setAttribute(HttpServletResponse.class.getName(), response);

		CsrfToken csrfToken = this.tokenRepository.loadToken(request);
		final boolean missingToken = csrfToken == null;
		if (missingToken) {
			csrfToken = this.tokenRepository.generateToken(request);
			this.tokenRepository.saveToken(csrfToken, request, response);
		}
		request.setAttribute(CsrfToken.class.getName(), csrfToken);
		request.setAttribute(csrfToken.getParameterName(), csrfToken);

		if (!this.requireCsrfProtectionMatcher.matches(request)) {
			filterChain.doFilter(request, response);
			return;
		}

		String actualToken = request.getHeader(csrfToken.getHeaderName());
		if (actualToken == null) {
			actualToken = request.getParameter(csrfToken.getParameterName());
		}
		if (!csrfToken.getToken().equals(actualToken)) {
			if (this.logger.isDebugEnabled()) {
				this.logger.debug("Invalid CSRF token found for "
						+ UrlUtils.buildFullRequestUrl(request));
			}
			if (missingToken) {
				this.accessDeniedHandler.handle(request, response,
						new MissingCsrfTokenException(actualToken));
			}
			else {
				this.accessDeniedHandler.handle(request, response,
						new InvalidCsrfTokenException(csrfToken, actualToken));
			}
			return;
		}

		filterChain.doFilter(request, response);
	}

	/**
	 * Specifies a {@link RequestMatcher} that is used to determine if CSRF protection
	 * should be applied. If the {@link RequestMatcher} returns true for a given request,
	 * then CSRF protection is applied.
	 *
	 * <p>
	 * The default is to apply CSRF protection for any HTTP method other than GET, HEAD,
	 * TRACE, OPTIONS.
	 * </p>
	 *
	 * @param requireCsrfProtectionMatcher the {@link RequestMatcher} used to determine if
	 * CSRF protection should be applied.
	 */
	public void setRequireCsrfProtectionMatcher(
			RequestMatcher requireCsrfProtectionMatcher) {
		Assert.notNull(requireCsrfProtectionMatcher,
				"requireCsrfProtectionMatcher cannot be null");
		this.requireCsrfProtectionMatcher = requireCsrfProtectionMatcher;
	}

	/**
	 * Specifies a {@link AccessDeniedHandler} that should be used when CSRF protection
	 * fails.
	 *
	 * <p>
	 * The default is to use AccessDeniedHandlerImpl with no arguments.
	 * </p>
	 *
	 * @param accessDeniedHandler the {@link AccessDeniedHandler} to use
	 */
	public void setAccessDeniedHandler(AccessDeniedHandler accessDeniedHandler) {
		Assert.notNull(accessDeniedHandler, "accessDeniedHandler cannot be null");
		this.accessDeniedHandler = accessDeniedHandler;
	}

	/*
	 * exclude "user/doLogion"  "GET", "HEAD", "TRACE", "OPTIONS"
	 */
	private static final class CsrfSecurityRequestMatcher implements RequestMatcher {
	    private RegexRequestMatcher unprotectedMatcher = new RegexRequestMatcher("^/user/doLogin", null);

		private final HashSet<String> allowedMethods = new HashSet<String>(
				Arrays.asList("GET", "HEAD", "TRACE", "OPTIONS"));

		/*
		 * (non-Javadoc)
		 * @see
		 * org.springframework.security.web.util.matcher.RequestMatcher#matches(javax.
		 * servlet.http.HttpServletRequest)
		 */
		@Override
		public boolean matches(HttpServletRequest request) {
			  if(this.allowedMethods.contains(request.getMethod())){
		            return false;
		        }
		        return !unprotectedMatcher.matches(request);
		}
		
	}
}

 实现自定义过滤掉登录方法，主要是重写csrfFilter里的DefaultRequiresCsrfMatcher替换成自己写的CsrfSecurityRequestMatcher ，如下：

/*
	 * exclude "user/doLogion"  "GET", "HEAD", "TRACE", "OPTIONS"
	 */
	private static final class CsrfSecurityRequestMatcher implements RequestMatcher {
	    private RegexRequestMatcher unprotectedMatcher = new RegexRequestMatcher("^/user/doLogin", null);

		private final HashSet<String> allowedMethods = new HashSet<String>(
				Arrays.asList("GET", "HEAD", "TRACE", "OPTIONS"));

		/*
		 * (non-Javadoc)
		 * @see
		 * org.springframework.security.web.util.matcher.RequestMatcher#matches(javax.
		 * servlet.http.HttpServletRequest)
		 */
		@Override
		public boolean matches(HttpServletRequest request) {
			  if(this.allowedMethods.contains(request.getMethod())){
		            return false;
		        }
		        return !unprotectedMatcher.matches(request);
		}
		
	}

五、页面配置

在post请求或ajax请求中会遇到问题，在公用jsp文件中加上，例如每个页面都会引用的头文件top.jsp

<meta name="_csrf" content="${_csrf.token}"/>
<meta name="_csrf_header" content="${_csrf.headerName}"/>
 
<script>
 
    var token = $("meta[name='_csrf']").attr("content");
    var header = $("meta[name='_csrf_header']").attr("content");
    $.ajaxSetup({
        beforeSend: function (xhr) {
            if(header && token ){
                xhr.setRequestHeader(header, token);
            }
        }}
    );
// $(document).ajaxSend(function(e,xhr,opt){
// 	xhr.setRequestHeader(header,token);
// });

</script>

$.ajaxSetup的意思就是给我们所有的请求都加上这个header和token，或者放到form表单中。注意，_csrf这个要与spring security的配置文件中的配置相匹配，默认为_csrf。

六、源码解析

看一下CsrfFilter中的doFilterInternal源码解析就知道我们为什么这么修改了

@Override
	protected void doFilterInternal(HttpServletRequest request,
			HttpServletResponse response, FilterChain filterChain)
					throws ServletException, IOException {
		request.setAttribute(HttpServletResponse.class.getName(), response);
		// 先从tokenRepository中加载token
		CsrfToken csrfToken = this.tokenRepository.loadToken(request);
		final boolean missingToken = csrfToken == null;
		  // 如果为空，则tokenRepository生成新的token，并保存到tokenRepository中
		if (missingToken) {
			csrfToken = this.tokenRepository.generateToken(request);
			this.tokenRepository.saveToken(csrfToken, request, response);
		}
        // 将token写入request的attribute中，方便页面上使用
		request.setAttribute(CsrfToken.class.getName(), csrfToken);
		request.setAttribute(csrfToken.getParameterName(), csrfToken);
		//这个macher就是我们在Spring配置文件中自定义的过滤器，也就是GET，HEAD, TRACE, OPTIONS和我们的rest都不处理

        // 这个macher就是我们在Spring配置文件中自定义的过滤器，
		//如果不需要csrf验证的请求，则直接下传请求（requireCsrfProtectionMatcher是默认的对象，对符合^(GET|HEAD|TRACE|OPTIONS)$的请求和我们自定义的请求不验证）
		if (!this.requireCsrfProtectionMatcher.matches(request)) {
			filterChain.doFilter(request, response);
			return;
		}
        // 从用户请求中获取token信息
		String actualToken = request.getHeader(csrfToken.getHeaderName());
		if (actualToken == null) {
			actualToken = request.getParameter(csrfToken.getParameterName());
		}
        // 验证，如果相同，则下传请求，如果不同，则抛出异常
		if (!csrfToken.getToken().equals(actualToken)) {
			if (this.logger.isDebugEnabled()) {
				this.logger.debug("Invalid CSRF token found for "
						+ UrlUtils.buildFullRequestUrl(request));
			}
			if (missingToken) {
				this.accessDeniedHandler.handle(request, response,
						new MissingCsrfTokenException(actualToken));
			}
			else {
				this.accessDeniedHandler.handle(request, response,
						new InvalidCsrfTokenException(csrfToken, actualToken));
			}
			return;
		}

		filterChain.doFilter(request, response);
	}

文章结构部分参考：利用spring-security解决CSRF问题_Frankenstein的博客-CSDN博客

crazy王
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java技术专家 【安全框架第八篇】SpringSecurity的核心过滤器-CsrfFilter
大壮
12-23 797
java技术专家 【安全框架第八篇】SpringSecurity的核心过滤器-CsrfFilter
java csrf过滤filter
走走停停的小码农的博客
05-18 7728
public class CsrfFilter implements Filter { private static final Logger logger = LogManager.getLogger(CsrfFilter.class); // 白名单 private List whiteUrls; private int _size = 0; public void init(
关于Spring Security的CSRF
最新发布
寻码启示
06-05 429
GET请求是正常的，但是POST请求会报403错误。Spring中POST请求不到。
浅谈CSRF的攻击方式
qq_45335911的博客
09-17 289
一.CSRF是什么？ CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也被称为：one click attack/session riding，缩写为：CSRF/XSRF。 二.CSRF可以做什么？ 你这可以这么理解CSRF攻击：攻击者盗用了你的身份，以你的名义发送恶意请求。CSRF能够做的事情包括：以你名义发送邮件，发消息，盗取你的账号，甚至于购买商品，虚拟货币转账…造成的问题包括：个人隐私泄露以及财产安全。 三.CSRF漏洞现状 CSRF这种攻击方式在
Spring Security之默认的过滤器链的CsrfFilter（九）
欢谷悠扬
07-09 566
1.什么是Csrf CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也被称为：one click attack/session riding，缩写为：CSRF/XSRF。 你这可以这么理解CSRF攻击：攻击者盗用了你的身份，以你的名义发送恶意请求。CSRF能够做的事情包括：以你名义发送邮件，发消息，盗取你的账号，甚至于购买商品，虚拟货币转账…造成的问题包括：个人隐私泄露以及财产安全。 通俗的说，就是你用你浏览器缓存的认证信息和用户信息，通过另外一个钓鱼网站去访问你现
Spring Security CsrfFilter过滤器用法实例
08-25
主要介绍了Spring Security CsrfFilter过滤器用法实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring security 处理CSRF
singkingcho的专栏
12-18 1000
csrf概念 英文全称叫做： cross-site request forgery，翻译过来叫做跨站请求伪造。spring security默认情况下是开启了csrf保护的。所谓的CSRF一般会在用户做了某个动作之后附加了一些额外动作。 csrf工作机制 往往是利用用户在某个系统中已经登录过，其具有一些服务器操作资源的权限，攻击者利用伪造的链接或其它骗用户完成某个操作，而这个操作会偷偷和该用户可操作的系统交互。 一个简单的示例图 如何解决 根本问题在于，我们必须要确定这个行为是不是由本身客户端发出的，而
详解利用spring-security解决CSRF问题
08-27
详解利用Spring Security解决CSRF问题 CSRF（Cross-site request forgery），中文名称：跨站请求伪造，也被称为：one click attack/session riding，缩写为：CSRF/XSRF。CSRF是一种常见的Web攻击方式，它可以在用户...
REST-spring-security.rar_java rest_java security_rest_rest secu
09-24
本项目“REST-spring-security”专注于利用Spring Security来保护基于REST的Web服务，确保数据和API接口的安全。 首先，我们需要理解REST（Representational State Transfer）是一种架构风格，常用于构建可伸缩、高...
spring-security-demo.zip
08-10
Spring Security 是一个强大的、高度可定制的身份验证和访问控制框架，广泛用于构建安全的Java Web应用程序。本示例"spring-security-demo.zip"很可能是为了演示如何在Spring Boot应用中集成和配置Spring Security。...
Spring-Security-Demo-master.zip
07-15
Spring Security 是一个强大的安全框架，常用于Java应用的安全管理，特别是在Spring Boot项目中。这个"Spring-Security-Demo-master.zip"压缩包包含了基于Spring Boot和Spring Security实现的前后端分离登录认证及...
SpringSecurity框架下实现CSRF跨站攻击防御的方法
08-25
CSRF是一种网络攻击方式，也可以说是一种安全漏洞，这种安全漏洞在web开发中广泛存在。这篇文章主要介绍了SpringSecurity框架下实现CSRF跨站攻击防御,需要的朋友可以参考下
spring-security-test:一个测试spring security java config进行token认证的小项目
06-06
Spring Security 是一个强大的Java框架，用于提供安全性解决方案，主要用于Web应用程序。这个名为“spring-security-test”的项目是为了测试Spring Security的Java配置以及基于Token的身份验证机制。让我们深入探讨...
Spring Security Web : HttpSessionCsrfTokenRepository
Details Inside Spring
06-23 3762
概述 介绍 HttpSessionCsrfTokenRepository是一个基于HttpSession保存csrf token的存储库实现。它具有如下能力: saveToken 保存csrf token到http session loadToken 从http session中提取csrf token generateToken 生成csrf token,值为一个随机UUID 继承关系 使...
spring-security中的csrf防御机制
热门推荐
behurry的专栏
07-27 3万+
什么是csrf？
spring security CSRF 问题 Invalid CSRF Token 'null' was found on ......
哎幽的成长
02-13 3万+
1. 问题前面几篇博客 spring security在集成spring boot的微服务框架后，实现了cas认证和权限控制。但是在使用 postman 进行调用的时候出现这个问题HTTP Status 403－Invalid CSRF Token 'null' was found on the request parameter '_csrf' or header 'X-CSRF-TOKEN'.然
spring security认证机制的Invalid CSRF Token问题
weixin_30322405的博客
03-05 1483
spring security在集成spring boot的微服务框架后，进行了cas认证和权限控制。但是在请求过程中，发现了一个问题 1.关于错误 错误指出，请求中出现了不可用的CSRF令牌。 查阅资料后发现这是一个RESTful技术与CSRF(Cross-site request forgery跨站请求伪造)的冲突造成的，CSRF默认支持的方法： GET|HEAD|TRACE|OPTI...
Spring security 重写Filter 实现 json 登录
李昊轩的博客
02-20 2879
在使用SpringSecurity中，大伙都知道默认的登录数据是通过key/value的形式来传递的，默认情况下不支持JSON格式的登录数据，如果有这种需求，就需要自己来解决，本文主要解决此问题： 使用JSON登录 上面演示的是一种原始的登录方案，如果想将用户名密码通过JSON的方式进行传递，则需要自定义相关过滤器，通过分析源码我们发现，默认的用户名密码提取在UsernamePasswordAut...
【深入浅出 Spring Security（八）】前后端分离-使用CSRF漏洞保护详讲
qq_63691275的博客
06-11 3481
前后端分离使用 CSRF 漏洞保护，首先是得从 Cookie 中获取对应的 xsrf（即csrf）令牌信息，享受服务器端的服务需要在请求参数中或者请求头中配置这个令牌信息（这里请求方式不包括GET、HEAD、OPTIONS、TRACE，如果是这四个请求方式，过滤器会直接放行），请求参数中配置名为_csrf，值是令牌信息；请求头的话配置名是X-XSRF-TOKEN，值是令牌信息。这样在一定程度上就提高了系统的安全性，不刻意去搞的话，这种方式很大程度上防御了跨站请求伪造（CSRF）。
websocket配合spring-security使用token认证
05-21
可以通过在Spring Security中配置一个Token认证过滤器来实现基于WebSocket的Token认证。具体步骤如下： 1. 创建一个TokenAuthenticationFilter类，继承自OncePerRequestFilter并实现doFilterInternal方法。该类负责检查请求中是否包含有效的Token，并进行相应的认证处理。 ```java public class TokenAuthenticationFilter extends OncePerRequestFilter { private final TokenProvider tokenProvider; public TokenAuthenticationFilter(TokenProvider tokenProvider) { this.tokenProvider = tokenProvider; } @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String token = getTokenFromRequest(request); if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) { Authentication authentication = tokenProvider.getAuthentication(token); SecurityContextHolder.getContext().setAuthentication(authentication); } filterChain.doFilter(request, response); } private String getTokenFromRequest(HttpServletRequest request) { String bearerToken = request.getHeader("Authorization"); if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) { return bearerToken.substring(7); } return null; } } ``` 2. 创建一个TokenProvider类，用于生成Token和验证Token的有效性，并根据Token获取用户信息。 ```java @Component public class TokenProvider { private static final String SECRET_KEY = "my-secret-key"; private static final long EXPIRATION_TIME = 86400000; // 1 day public String generateToken(Authentication authentication) { UserPrincipal principal = (UserPrincipal) authentication.getPrincipal(); Date expirationDate = new Date(System.currentTimeMillis() + EXPIRATION_TIME); return Jwts.builder() .setSubject(Long.toString(principal.getId())) .setIssuedAt(new Date()) .setExpiration(expirationDate) .signWith(SignatureAlgorithm.HS512, SECRET_KEY) .compact(); } public boolean validateToken(String token) { try { Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token); return true; } catch (Exception e) { return false; } } public Authentication getAuthentication(String token) { Claims claims = Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody(); Long userId = Long.parseLong(claims.getSubject()); UserPrincipal principal = new UserPrincipal(userId); return new UsernamePasswordAuthenticationToken(principal, "", principal.getAuthorities()); } } ``` 3. 在配置类中注册TokenAuthenticationFilter和TokenProvider，并将TokenAuthenticationFilter添加到Spring Security的过滤器链中。 ```java @Configuration @EnableWebSocketMessageBroker public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { @Autowired private TokenProvider tokenProvider; @Override public void configureMessageBroker(MessageBrokerRegistry config) { config.enableSimpleBroker("/topic"); config.setApplicationDestinationPrefixes("/app"); } @Override public void registerStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint("/ws").setAllowedOriginPatterns("*").withSockJS(); } @Override public void configureClientInboundChannel(ChannelRegistration registration) { registration.interceptors(new ChannelInterceptorAdapter() { @Override public Message<?> preSend(Message<?> message, MessageChannel channel) { StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); if (StompCommand.CONNECT.equals(accessor.getCommand())) { String token = accessor.getFirstNativeHeader("Authorization"); if (StringUtils.hasText(token) && token.startsWith("Bearer ")) { token = token.substring(7); TokenAuthenticationFilter filter = new TokenAuthenticationFilter(tokenProvider); SecurityContextHolder.getContext().setAuthentication(filter.getAuthentication(token)); } } return message; } }); } @Override public void configureClientOutboundChannel(ChannelRegistration registration) { } @Override public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) { } @Override public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) { } @Override public boolean configureMessageConverters(List<MessageConverter> messageConverters) { return true; } @Override public void configureWebSocketTransport(WebSocketTransportRegistration registry) { } @Bean public TokenAuthenticationFilter tokenAuthenticationFilter() throws Exception { TokenAuthenticationFilter filter = new TokenAuthenticationFilter(tokenProvider); filter.setAuthenticationManager(authenticationManager()); return filter; } @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable().authorizeRequests() .antMatchers("/api/auth/**").permitAll() .anyRequest().authenticated(); } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService()) .passwordEncoder(passwordEncoder()); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } @Bean @Override public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } @Override @Bean public UserDetailsService userDetailsService() { return new UserDetailsServiceImpl(); } } ``` 在上述代码中，我们通过重写configureClientInboundChannel方法，在连接到WebSocket时获取请求中的Token，并使用TokenAuthenticationFilter进行认证。注意，我们需要将TokenAuthenticationFilter添加到Spring Security的过滤器链中，以便它能够在WebSocket连接期间对请求进行拦截。 最后，我们需要在客户端的连接请求中添加Authorization头部，以便在服务端进行Token认证。例如： ```javascript stompClient.connect({}, function(frame) { console.log('Connected: ' + frame); stompClient.subscribe('/topic/greetings', function(greeting) { showGreeting(JSON.parse(greeting.body).content); }); }, function(error) { console.log('Error: ' + error); }, {"Authorization": "Bearer " + token}); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值