Spring全家桶-Spring Security之跨域与CORS与防护

最新推荐文章于 2024-08-07 16:42:39 发布
最新推荐文章于 2024-08-07 16:42:39 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： Spring Security 文章标签： spring java 后端 Spring Security 跨域及跨站攻击
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qian1314520hu/article/details/125009874
版权

Spring全家桶-Spring Security之跨域与CORS

Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC（控制反转），DI（依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。

文章目录

前言

在项目的开发中，我们和前端联调的时候，经常会遇到跨域的问题，那跨域是什么？Spring Security是怎么实现的呢？怎么去解决跨域的问题呢？

一、跨域是什么？

跨域是浏览器的同源策略，是浏览器限制脚本的跨域访问。在通常情况下请求是可以正常发起的，后端也进行相关的处理。只是在返回相应的数据的时候被浏览器拦截了，导致相应的内容不可使用。其中的一个场景就是CSRF攻击。

二、跨域产生的条件？

在进行跨域处理的时候，跨域的产生条件是什么呢？
不仅不同站点间的访问存在跨域问题， 同站点间的访问可能也会遇到跨域问题， 只要请求的URL与所在页面的URL首部不同即产生跨域。

  • 请求的协议不同，如在http协议下访问https协议的资源时，会产生跨域问题
  • 不同的域名访问会产生主机跨域
  • 相同的域名，但是不同的端口会产生端口跨域
    上面的三种情况都会产生跨域问题

三、如何解决跨域问题？

我们解决跨域问题有如下几种方式：

  • 使用jsonp
  • 使用nginx等网络代理进行转发请求
  • CROS处理等

四、JSONP处理及其原理

JSONP(JSON With Padding) 是一种非官方的解决方案。 由于浏览器允许一些带src属性的标签跨域， 例如， iframe、 script、 img等， 所以JSONP利用script标签可以实现跨域.

加入我们有如下场景：我们访问user/list的时候，后台返回的json对象的数组如下：

{
	"code":"0000",
	"message":"请求成功",
	"success":true,
	"data":[
		{
			"username":"tony",
			"password":"asdfacasdradxx"
		},
		{
			"username":"tony2",
			"password":"asdfacasdradxx"
		}
	]
}

以上是获取用户的列表接口返回的结果。但在跨域的情况下，浏览器的同源策略导致用户请求无法响应信息，此时通过script标签去加载响应的接口

<script src="user/list?callback=jsonp"></script>

这样便可以成功获取响应信息了， 只是得到的JSON数据无法直接在JavaScript中使用。 如果后端介入， 那么在返回浏览器之前应将响应信息包装成JSONP的形式,如下：

jsonp({
	"code":"0000",
	"message":"请求成功",
	"success":true,
	"data":[
		{
			"username":"tony",
			"password":"asdfacasdradxx"
		},
		{
			"username":"tony2",
			"password":"asdfacasdradxx"
		}
	]
})

之后我们就可以通过调用JSONP的方法进行返回值的处理了.就像调用javascript函数一样调用。
?callback=jsonp相当于请求之后调用回调方法jsonp，jsonp方法直接这样处理

window.jsonp = function(data){
	console.log(data);
}

其中的data就是后台返回的相关数据。
注意：JSONP只支持GET请求。

五、使用CORS解决跨域问题

CORS(Cross-Origin Resource Sharing)的规范中有一组新增的HTTP首部字段，允许服务器声明其提供的资源允许哪些站点跨域使用。通常情况下，跨域请求即便在不被支持的情况下， 服务器也会接收并进行处理， 在CORS的规范中则避免了这个问题。 浏览器首先会发起一个请求方法为OPTIONS 的预检请求， 用于确认服务器是否允许跨域， 只有在得到许可后才会发出实际请求。 此外， 预检请求还允许服务器通知浏览器跨域携带身份凭证。
CORS新增的HTTP首部字段由服务器控制， 下面我们来看看常用的几个首部字段：

  • Access-Control-Allow-Origin：允许取值为<origin>或*
    • <origin>:指被允许的站点，使用URL首部匹配原则
    • *:匹配所有站点， 表示允许来自所有域的请求。如果需要浏览器在发起请求时携带凭证信息， 则不允许设置为*。如果设置了具体的站点信息， 则响应头中的 Vary字段还需要携带Origin属性，因为服务器对不同的域会返回不同的内容。
    • Vary:Accept-Encoding,Origin
  • Access-Control-Allow-Methods:字段仅在预检请求的响应中指定有效，用于表明服务器允许跨域的HTTP方法， 多个方法之间用逗号隔开.
  • Access-Control-Allow-Headers:字段仅在预检请求的响应中指定有效， 用于表明服务器允许携带的首部字段。 多个首部字段之间用逗号隔开。
  • Access-Control-Max-Age:字段用于指明本次预检请求的有效期， 单位为秒。 在有效期内， 预检请求不需要再次发起
  • Access-Control-Allow-Credentials:true|false
    • 当Access-Control-Allow-Credentials字段取值为true时， 浏览器会在接下来的真实请求中携带用户凭证信息(cookie等)，服务器也可以使用Set-Cookie向用户浏览器写入新的cookie。注意，使用AccessControl-Allow-Credentials时， Access-Control-Allow-Origin不应该设置为*
      注意:CORS不支持IE8以下版本的浏览器

CORS控制场景

  • 简单请求
    在CORS中，并非所有的跨域访问都会触发预检请求。例如，不携带自定义请求头信息的GET请求、HEAD请求，以及Content-Type为application/x-www-form-urlencoded、multipart/form-data或text/plain的POST请求， 这类请求被称为简单请求。
    浏览器在发起请求时，会在请求头中自动添加一个Origin属性， 值为当前页面的 URL 首部。当服务器返回响应时，若存在跨域访问控制属性，则浏览器会通过这些属性判断本次请求是否被允许。如果允许，则跨域成功
  • 预检请求
    预检请求它会发送一个OPTIONS请求到目标站点，以查明该请求是否安全，防止请求对目标站点的数据造成破坏。若是请求以GET、HEAD、POST以外的方法发起；或者使用POST方法，但请求数据为application/x-www-form-urlencoded、multipart/form-data和text/plain以外的数据类型；再或者，使用了自定义请求头，则都会被当成预检请求类型处理。
  • 带凭证请求
    带凭证的请求就是携带了用户cookie等信息的请求.
    指定了withCredentials为true。浏览器在实际发出请求时， 将同时向服务器发送 cookie，并期待在服务器返回的响应信息中指明 Access-Control-AllowCredentials为true，否则浏览器会拦截，并抛出错误

Spring Security中CORS支持

在Spring Security中提供cors的支持也很简单，只需要调整响应的配置类，创建相应的bean即可。下面就一起来看看。

创建项目spring-security-cors

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

创建配置类WebSecurityConfig

@Override
 protected void configure(HttpSecurity http) throws Exception {
     http.authorizeRequests().antMatchers("/user/**").hasAnyRole("USER","ADMIN")
             .antMatchers("/books/**").hasAnyRole("ADMIN")
             .antMatchers("/").permitAll()
             .and()
             .formLogin()
             .loginPage("/login.html")
             .permitAll()
             .and()
             //启用
             .cors();
 }

创建CorsConfigurationSource bean

@Bean
public CorsConfigurationSource corsConfigurationSource(){
    CorsConfiguration configuration = new CorsConfiguration();
    //允许google站点跨域
    configuration.setAllowedOrigins(Arrays.asList("www.google.com"));
    //允许跨域的防范
    configuration.setAllowedMethods(Arrays.asList("GET","POST"));
    //是否允许携带凭证
    configuration.setAllowCredentials(true);
    UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
    //对所有的url开放
    urlBasedCorsConfigurationSource.registerCorsConfiguration("/**",configuration);
    return urlBasedCorsConfigurationSource;
}

以上是Spring Security实现CORS实现，是不是相当简单。

Spring Security支持Cors实现细节

我们看到在http配置中，我们添加了一个cors()方法进行处理。我们可以看看详细的细节。一起来看看。

public CorsConfigurer<HttpSecurity> cors() throws Exception {
        return (CorsConfigurer)this.getOrApply(new CorsConfigurer());
    }

由上面可以看出，会去获取一个CorsConfigurer类去进行处理。
我们来进入CorsConfigurer看看。
CorsConfigurer.class:

public class CorsConfigurer<H extends HttpSecurityBuilder<H>> extends AbstractHttpConfigurer<CorsConfigurer<H>, H> {
    public CorsConfigurer<H> configurationSource(CorsConfigurationSource configurationSource) {
        this.configurationSource = configurationSource;
        return this;
    }
    public void configure(H http) {
        ApplicationContext context = (ApplicationContext)http.getSharedObject(ApplicationContext.class);
        //获取corsFilter过滤器
        CorsFilter corsFilter = this.getCorsFilter(context);
        //请配置corsFilter bean或corsConfigurationSourcebean
        Assert.state(corsFilter != null, () -> {
            return "Please configure either a corsFilter bean or a corsConfigurationSourcebean.";
        });
        http.addFilter(corsFilter);
    }
    //获取CorsFilter的处理逻辑
    private CorsFilter getCorsFilter(ApplicationContext context) {
    	//configurationSource不为空
        if (this.configurationSource != null) {
      		//创建CorsFilter
            return new CorsFilter(this.configurationSource);
        } else {
            boolean containsCorsFilter = context.containsBeanDefinition("corsFilter");
            //如果包含corsFilter的bean，就直接返回
            if (containsCorsFilter) {
                return (CorsFilter)context.getBean("corsFilter", CorsFilter.class);
            } else {
            	//否则就新建一个
                boolean containsCorsSource = context.containsBean("corsConfigurationSource");
                if (containsCorsSource) {
                    CorsConfigurationSource configurationSource = (CorsConfigurationSource)context.getBean("corsConfigurationSource", CorsConfigurationSource.class);
                    return new CorsFilter(configurationSource);
                } else {
                    boolean mvcPresent = ClassUtils.isPresent("org.springframework.web.servlet.handler.HandlerMappingIntrospector", context.getClassLoader());
                    return mvcPresent ? CorsConfigurer.MvcCorsFilter.getMvcCorsFilter(context) : null;
                }
            }
        }
    }

    static class MvcCorsFilter {
        private static final String HANDLER_MAPPING_INTROSPECTOR_BEAN_NAME = "mvcHandlerMappingIntrospector";

        MvcCorsFilter() {
        }

        private static CorsFilter getMvcCorsFilter(ApplicationContext context) {
            if (!context.containsBean("mvcHandlerMappingIntrospector")) {
                throw new NoSuchBeanDefinitionException("mvcHandlerMappingIntrospector", "A Bean named mvcHandlerMappingIntrospector of type " + HandlerMappingIntrospector.class.getName() + " is required to use MvcRequestMatcher. Please ensure Spring Security & Spring MVC are configured in a shared ApplicationContext.");
            } else {
                HandlerMappingIntrospector mappingIntrospector = (HandlerMappingIntrospector)context.getBean("mvcHandlerMappingIntrospector", HandlerMappingIntrospector.class);
                return new CorsFilter(mappingIntrospector);
            }
        }
    }
}

上面可以看出是通过过滤器进行处理，之后将过滤器添加到Spring Security的过滤器链路中。
CorsFilter.class:

private final CorsConfigurationSource configSource;
	//DefaultCorsProcessor处理cors
    private CorsProcessor processor = new DefaultCorsProcessor();
    public CorsFilter(CorsConfigurationSource configSource) {
        Assert.notNull(configSource, "CorsConfigurationSource must not be null");
        this.configSource = configSource;
    }
    public void setCorsProcessor(CorsProcessor processor) {
        Assert.notNull(processor, "CorsProcessor must not be null");
        this.processor = processor;
    }

从上面可以看出，是通过DefaultCorsProcessor进行处理
DefaultCorsProcessor.class:

public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request, HttpServletResponse response) throws IOException {
        Collection<String> varyHeaders = response.getHeaders("Vary");
        if (!varyHeaders.contains("Origin")) {
            response.addHeader("Vary", "Origin");
        }

        if (!varyHeaders.contains("Access-Control-Request-Method")) {
            response.addHeader("Vary", "Access-Control-Request-Method");
        }

        if (!varyHeaders.contains("Access-Control-Request-Headers")) {
            response.addHeader("Vary", "Access-Control-Request-Headers");
        }

        if (!CorsUtils.isCorsRequest(request)) {
            return true;
        } else if (response.getHeader("Access-Control-Allow-Origin") != null) {
            logger.trace("Skip: response already contains \"Access-Control-Allow-Origin\"");
            return true;
        } else {
            boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
            if (config == null) {
                if (preFlightRequest) {
                    this.rejectRequest(new ServletServerHttpResponse(response));
                    return false;
                } else {
                    return true;
                }
            } else {
                return this.handleInternal(new ServletServerHttpRequest(request), new ServletServerHttpResponse(response), config, preFlightRequest);
            }
        }
    }
	//拒绝请求
    protected void rejectRequest(ServerHttpResponse response) throws IOException {
        response.setStatusCode(HttpStatus.FORBIDDEN);
        response.getBody().write("Invalid CORS request".getBytes(StandardCharsets.UTF_8));
        response.flush();
    }
	//处理
    protected boolean handleInternal(ServerHttpRequest request, ServerHttpResponse response, CorsConfiguration config, boolean preFlightRequest) throws IOException {
    	//获取Origin
        String requestOrigin = request.getHeaders().getOrigin();
        //获取allowOrigin
        String allowOrigin = this.checkOrigin(config, requestOrigin);
        HttpHeaders responseHeaders = response.getHeaders();
        if (allowOrigin == null) {
            logger.debug("Reject: '" + requestOrigin + "' origin is not allowed");
            this.rejectRequest(response);
            return false;
        } else {
        	//校验请求的方法
            HttpMethod requestMethod = this.getMethodToUse(request, preFlightRequest);
            List<HttpMethod> allowMethods = this.checkMethods(config, requestMethod);
            if (allowMethods == null) {
                logger.debug("Reject: HTTP '" + requestMethod + "' is not allowed");
                this.rejectRequest(response);
                return false;
            } else {
            	//请求中header列表
                List<String> requestHeaders = this.getHeadersToUse(request, preFlightRequest);
                //请求中允许的header列表
                List<String> allowHeaders = this.checkHeaders(config, requestHeaders);
                if (preFlightRequest && allowHeaders == null) {
                    logger.debug("Reject: headers '" + requestHeaders + "' are not allowed");
                    this.rejectRequest(response);
                    return false;
                } else {
                    responseHeaders.setAccessControlAllowOrigin(allowOrigin);
                    if (preFlightRequest) {
                        responseHeaders.setAccessControlAllowMethods(allowMethods);
                    }
                    if (preFlightRequest && !allowHeaders.isEmpty()) {
                        responseHeaders.setAccessControlAllowHeaders(allowHeaders);
                    }
                    if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
                        responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
                    }
                    if (Boolean.TRUE.equals(config.getAllowCredentials())) {
                        responseHeaders.setAccessControlAllowCredentials(true);
                    }
                    if (preFlightRequest && config.getMaxAge() != null) {
                        responseHeaders.setAccessControlMaxAge(config.getMaxAge());
                    }
                    response.flush();
                    return true;
                }
            }
        }
    }

跨域请求伪造CSRF

CSRF的全称是（Cross Site Request Forgery） ， 可译为跨域请求伪造，也被称为 one-click attack 或者 session riding，通常缩写为 CSRF 或者 XSRF。是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比，XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。
CSRF攻击过程：
在这里插入图片描述
CSRF漏洞产生的原因主要是对用户请求缺少更安全的验证机制。防范CSRF漏洞的主要思路就是加强后台对用户及用户请求的验证，而不能仅限于cookie的识别。

跨域请求伪造CSRF防御措施

遇到CRSF我们该如何防御呢？

  1. 使用相关工具进行检查是否存在CSRF漏洞，如CSRFTester等
  2. HTTP Referer
    HTTP Referer是由浏览器添加的一个请求头字段， 用于标识请求来源，通常用在一些统计相关的场景，浏览器端无法轻易篡改该值。 当校验到请求来自其他站点时，可以认为是CSRF攻击，从而拒绝该服务。当然，这种方式简单便捷，但并非完全可靠。因为部分浏览器可以篡改 HTTP Referer，如果用户在浏览器中设置了不被跟踪， 那么HTTP Referer字段就不会自动添加， 当合法用户访问时， 系统会认为是CSRF攻击，从而拒绝访问。
  3. CsrfToken认证
    CSRF是利用用户的登录态进行攻击的，而用户的登录态记录在cookie中。其实攻击者并不知道用户的cookie存放了哪些数据，于是想方设法让用户自身发起请求，这样浏览器便会自行将cookie传送到服务器完成身份校验。
    CsrfToken 的防范思路是添加一些并不存放于 cookie 的验证值，并在每个请求中都进行校验，便可以阻止CSRF攻击。
    具体做法是在用户登录时，由系统发放一个CsrfToken值， 用户携带该CsrfToken值与用户名、密码等参数完成登录。系统记录该会话的 CsrfToken 值，之后在用户的任何请求中，都必须带上该CsrfToken值， 并由系统进行校验。
    这种方法需要与前端配合，包括存储CsrfToken值，以及在任何请求中（ 包括表单和Ajax） 携带CsrfToken值。安全性相较于HTTP Referer提高很多， 但也存在一定的弊端。 例如，在现有的系统中进行改造时， 前端的工作量会非常大， 几乎要对所有请求进行处理。 如果都是XMLHttpRequest，则可以统一添加CsrfToken值； 但如果存在大量的表单和a标签，就会变得非常烦琐。因此建议在系统开发之初考虑如何防御CSRF攻击。

Spring Security中进行防御CSRF攻击

CSRF 攻击完全是基于浏览器进行的，如果我们的系统前端并非在浏览器中运作，就应当关闭CSRF。
Spring Security通过注册一个CsrfFilter来专门处理CSRF攻击。
在相应的配置类中添加如下代码：

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/user/**").hasAnyRole("USER","ADMIN")
                .antMatchers("/books/**").hasAnyRole("ADMIN")
                .antMatchers("/").permitAll()
                .and()
                .formLogin()
                .loginPage("/login.html")
                .permitAll()
                .and()
                //启用
                .cors()
                .and()
                //开启csrf
                .csrf();
    }
}

csrf()方法：

public CsrfConfigurer<HttpSecurity> csrf() throws Exception {
        ApplicationContext context = this.getContext();
        return (CsrfConfigurer)this.getOrApply(new CsrfConfigurer(context));
    }

从上面可以看出，是通过CsrfConfigurer类进行处理
CsrfConfigurer.class:

public void configure(H http) {
        CsrfFilter filter = new CsrfFilter(this.csrfTokenRepository);
        RequestMatcher requireCsrfProtectionMatcher = this.getRequireCsrfProtectionMatcher();
        if (requireCsrfProtectionMatcher != null) {
            filter.setRequireCsrfProtectionMatcher(requireCsrfProtectionMatcher);
        }

        AccessDeniedHandler accessDeniedHandler = this.createAccessDeniedHandler(http);
        if (accessDeniedHandler != null) {
            filter.setAccessDeniedHandler(accessDeniedHandler);
        }

        LogoutConfigurer<H> logoutConfigurer = (LogoutConfigurer)http.getConfigurer(LogoutConfigurer.class);
        if (logoutConfigurer != null) {
            logoutConfigurer.addLogoutHandler(new CsrfLogoutHandler(this.csrfTokenRepository));
        }

        SessionManagementConfigurer<H> sessionConfigurer = (SessionManagementConfigurer)http.getConfigurer(SessionManagementConfigurer.class);
        if (sessionConfigurer != null) {
            sessionConfigurer.addSessionAuthenticationStrategy(this.getSessionAuthenticationStrategy());
        }

        filter = (CsrfFilter)this.postProcess(filter);
        http.addFilter(filter);
    }

通过上面的类可以了解到，配置使用CsrfFilter过滤器进行处理，并且使用默认的csrfTokenRepository,这个属性值为LazyCsrfTokenRepository

private CsrfTokenRepository csrfTokenRepository = new LazyCsrfTokenRepository(new HttpSessionCsrfTokenRepository());

LazyCsrfTokenRepository.class类：

public final class LazyCsrfTokenRepository implements CsrfTokenRepository {
	//响应属性
    private static final String HTTP_RESPONSE_ATTR = HttpServletResponse.class.getName();
    //代理类
    private final CsrfTokenRepository delegate;
	//构造器
    public LazyCsrfTokenRepository(CsrfTokenRepository delegate) {
        Assert.notNull(delegate, "delegate cannot be null");
        this.delegate = delegate;
    }
	//生产csrfToken
    public CsrfToken generateToken(HttpServletRequest request) {
        return this.wrap(request, this.delegate.generateToken(request));
    }
	//保存csrfToken
    public void saveToken(CsrfToken token, HttpServletRequest request, HttpServletResponse response) {
        if (token == null) {
            this.delegate.saveToken(token, request, response);
        }
    }
	//加载csrfToken
    public CsrfToken loadToken(HttpServletRequest request) {
        return this.delegate.loadToken(request);
    }
	//包含csrfToken
    private CsrfToken wrap(HttpServletRequest request, CsrfToken token) {
        HttpServletResponse response = this.getResponse(request);
        return new LazyCsrfTokenRepository.SaveOnAccessCsrfToken(this.delegate, request, response, token);
    }
    
    private static final class SaveOnAccessCsrfToken implements CsrfToken {
        private transient CsrfTokenRepository tokenRepository;
        private transient HttpServletRequest request;
        private transient HttpServletResponse response;
        private final CsrfToken delegate;

        SaveOnAccessCsrfToken(CsrfTokenRepository tokenRepository, HttpServletRequest request, HttpServletResponse response, CsrfToken delegate) {
            this.tokenRepository = tokenRepository;
            this.request = request;
            this.response = response;
            this.delegate = delegate;
        }

        public String getHeaderName() {
            return this.delegate.getHeaderName();
        }

        public String getParameterName() {
            return this.delegate.getParameterName();
        }

        public String getToken() {
            this.saveTokenIfNecessary();
            return this.delegate.getToken();
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            } else if (obj != null && this.getClass() == obj.getClass()) {
                LazyCsrfTokenRepository.SaveOnAccessCsrfToken other = (LazyCsrfTokenRepository.SaveOnAccessCsrfToken)obj;
                if (this.delegate == null) {
                    if (other.delegate != null) {
                        return false;
                    }
                } else if (!this.delegate.equals(other.delegate)) {
                    return false;
                }

                return true;
            } else {
                return false;
            }
        }

        public int hashCode() {
            int prime = true;
            int result = 1;
            int result = 31 * result + (this.delegate == null ? 0 : this.delegate.hashCode());
            return result;
        }

        public String toString() {
            return "SaveOnAccessCsrfToken [delegate=" + this.delegate + "]";
        }

        private void saveTokenIfNecessary() {
            if (this.tokenRepository != null) {
                synchronized(this) {
                    if (this.tokenRepository != null) {
                        this.tokenRepository.saveToken(this.delegate, this.request, this.response);
                        this.tokenRepository = null;
                        this.request = null;
                        this.response = null;
                    }

                }
            }
        }
    }
}

SaveOnAccessCsrfToken implements CsrfToken
Spring security中CsrfToken是一个用于描述Token值， 以及验证时应当获取哪个请求参数或请求头字段的接口。

public interface CsrfToken extends Serializable {
	//获取header
    String getHeaderName();
    //获取参数名
    String getParameterName();
    //获取CsrfToken
    String getToken();
}

CsrfTokenRepository是实现CsrfToken生成，保存以及加载操作

public interface CsrfTokenRepository {
	//生成
	CsrfToken generateToken(HttpServletRequest request);
	//保存
    void saveToken(CsrfToken token, HttpServletRequest request, HttpServletResponse response);
	//加载
    CsrfToken loadToken(HttpServletRequest request);
}

在默认情况下，Spring Security使用的是HttpSessionCsrfTokenRepository.
HttpSessionCsrfTokenRepository.class类：

public final class HttpSessionCsrfTokenRepository implements CsrfTokenRepository {
	//默认的CSRF参数
    private static final String DEFAULT_CSRF_PARAMETER_NAME = "_csrf";
    //默认的CSRF名
    private static final String DEFAULT_CSRF_HEADER_NAME = "X-CSRF-TOKEN";
    //默认的CSRFToken属性名
    private static final String DEFAULT_CSRF_TOKEN_ATTR_NAME = HttpSessionCsrfTokenRepository.class.getName().concat(".CSRF_TOKEN");
    private String parameterName = "_csrf";
    private String headerName = "X-CSRF-TOKEN";
    private String sessionAttributeName;
    public HttpSessionCsrfTokenRepository() {
        this.sessionAttributeName = DEFAULT_CSRF_TOKEN_ATTR_NAME;
    }
    public void saveToken(CsrfToken token, HttpServletRequest request, HttpServletResponse response) {
        HttpSession session;
        if (token == null) {
            session = request.getSession(false);
            if (session != null) {
                session.removeAttribute(this.sessionAttributeName);
            }
        } else {
            session = request.getSession();
            //将csrfToken与session关联
            session.setAttribute(this.sessionAttributeName, token);
        }
    }
	//加载CsrfToken
    public CsrfToken loadToken(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        //从session中获取
        return session == null ? null : (CsrfToken)session.getAttribute(this.sessionAttributeName);
    }
	//生成CsrfToken
    public CsrfToken generateToken(HttpServletRequest request) {
    	//返回默认的DefaultCsrfToken实例
        return new DefaultCsrfToken(this.headerName, this.parameterName, this.createNewToken());
    }
	//设置参数名
    public void setParameterName(String parameterName) {
        Assert.hasLength(parameterName, "parameterName cannot be null or empty");
        this.parameterName = parameterName;
    }
	//设置header
    public void setHeaderName(String headerName) {
        Assert.hasLength(headerName, "headerName cannot be null or empty");
        this.headerName = headerName;
    }
    //设置session属性名
    public void setSessionAttributeName(String sessionAttributeName) {
        Assert.hasLength(sessionAttributeName, "sessionAttributename cannot be null or empty");
        this.sessionAttributeName = sessionAttributeName;
    }
	//创建新的token
    private String createNewToken() {
        return UUID.randomUUID().toString();
    }
}

HttpSessionCsrfTokenRepository将CsrfToken值存储在HttpSession中，并指定前端把CsrfToken值放在名为_csrf的请求参数或名为X-CSRF-TOKEN的请求头字段里(可以调用相应的设置方法来重新设定)。校验时，通过对比HttpSession内存储的CsrfToken值与前端携带的CsrfToken值是否一致，便能断定本次请求是否为CSRF攻击。
CsrfTokenRepository接口的另外一个实现是基于cookie的。
CookieCsrfTokenRepository.class类：

public final class CookieCsrfTokenRepository implements CsrfTokenRepository {
    static final String DEFAULT_CSRF_COOKIE_NAME = "XSRF-TOKEN";
    static final String DEFAULT_CSRF_PARAMETER_NAME = "_csrf";
    static final String DEFAULT_CSRF_HEADER_NAME = "X-XSRF-TOKEN";
    private String parameterName = "_csrf";
    private String headerName = "X-XSRF-TOKEN";
    private String cookieName = "XSRF-TOKEN";
    private boolean cookieHttpOnly = true;
    private String cookiePath;
    private String cookieDomain;
    private Boolean secure;
    private int cookieMaxAge = -1;

    public CookieCsrfTokenRepository() {
    }

    public CsrfToken generateToken(HttpServletRequest request) {
        return new DefaultCsrfToken(this.headerName, this.parameterName, this.createNewToken());
    }
	//保存CsrfToken
    public void saveToken(CsrfToken token, HttpServletRequest request, HttpServletResponse response) {
        String tokenValue = token != null ? token.getToken() : "";
        //将CsrfToken与cookie关联 以及设置cookie的参数
        Cookie cookie = new Cookie(this.cookieName, tokenValue);
        cookie.setSecure(this.secure != null ? this.secure : request.isSecure());
        cookie.setPath(StringUtils.hasLength(this.cookiePath) ? this.cookiePath : this.getRequestContext(request));
        cookie.setMaxAge(token != null ? this.cookieMaxAge : 0);
        cookie.setHttpOnly(this.cookieHttpOnly);
        if (StringUtils.hasLength(this.cookieDomain)) {
            cookie.setDomain(this.cookieDomain);
        }
        response.addCookie(cookie);
    }
	//加载CsrfToken
    public CsrfToken loadToken(HttpServletRequest request) {
        Cookie cookie = WebUtils.getCookie(request, this.cookieName);
        if (cookie == null) {
            return null;
        } else {
            String token = cookie.getValue();
            return !StringUtils.hasLength(token) ? null : new DefaultCsrfToken(this.headerName, this.parameterName, token);
        }
    }

    public void setParameterName(String parameterName) {
        Assert.notNull(parameterName, "parameterName cannot be null");
        this.parameterName = parameterName;
    }

    public void setHeaderName(String headerName) {
        Assert.notNull(headerName, "headerName cannot be null");
        this.headerName = headerName;
    }

    public void setCookieName(String cookieName) {
        Assert.notNull(cookieName, "cookieName cannot be null");
        this.cookieName = cookieName;
    }

    public void setCookieHttpOnly(boolean cookieHttpOnly) {
        this.cookieHttpOnly = cookieHttpOnly;
    }

    private String getRequestContext(HttpServletRequest request) {
        String contextPath = request.getContextPath();
        return contextPath.length() > 0 ? contextPath : "/";
    }

    public static CookieCsrfTokenRepository withHttpOnlyFalse() {
        CookieCsrfTokenRepository result = new CookieCsrfTokenRepository();
        result.setCookieHttpOnly(false);
        return result;
    }

    private String createNewToken() {
        return UUID.randomUUID().toString();
    }

    public void setCookiePath(String path) {
        this.cookiePath = path;
    }

    public String getCookiePath() {
        return this.cookiePath;
    }

    public void setCookieDomain(String cookieDomain) {
        this.cookieDomain = cookieDomain;
    }

    public void setSecure(Boolean secure) {
        this.secure = secure;
    }

    public void setCookieMaxAge(int cookieMaxAge) {
        Assert.isTrue(cookieMaxAge != 0, "cookieMaxAge cannot be zero");
        this.cookieMaxAge = cookieMaxAge;
    }
}

cookie只有在同域的情况下才能被读取， 所以杜绝了第三方站点跨域获取CsrfToken值的可能。CSRF攻击本身是不知道cookie内容的，只是利用了当请求自动携带cookie时可以通过身份验证的漏洞。但服务器对CsrfToken值的校验并非取自cookie，而是需要前端手动将CsrfToken值作为参数携带在请求里，所以cookie内的CsrfToken值并没有被校验的作用， 仅仅作为一个存储容器使用.
CsrfToken相关的管理已经了解了，我们实现的时候是通过CsrfFilter处理的。
CsrfFilter.class类：

public final class CsrfFilter extends OncePerRequestFilter {
    public static final RequestMatcher DEFAULT_CSRF_MATCHER = new CsrfFilter.DefaultRequiresCsrfMatcher();
    private static final String SHOULD_NOT_FILTER = "SHOULD_NOT_FILTER" + CsrfFilter.class.getName();
    private final Log logger = LogFactory.getLog(this.getClass());
    private final CsrfTokenRepository tokenRepository;
    private RequestMatcher requireCsrfProtectionMatcher;
    private AccessDeniedHandler accessDeniedHandler;

    public CsrfFilter(CsrfTokenRepository csrfTokenRepository) {
        this.requireCsrfProtectionMatcher = DEFAULT_CSRF_MATCHER;
        this.accessDeniedHandler = new AccessDeniedHandlerImpl();
        Assert.notNull(csrfTokenRepository, "csrfTokenRepository cannot be null");
        this.tokenRepository = csrfTokenRepository;
    }

    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        return Boolean.TRUE.equals(request.getAttribute(SHOULD_NOT_FILTER));
    }

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        request.setAttribute(HttpServletResponse.class.getName(), response);
        //加载csrfToken
        CsrfToken csrfToken = this.tokenRepository.loadToken(request);
        boolean missingToken = csrfToken == null;
        if (missingToken) {
        	//如果不存在就生成
            csrfToken = this.tokenRepository.generateToken(request);
            //保存csrfToken
            this.tokenRepository.saveToken(csrfToken, request, response);
        }
		
        request.setAttribute(CsrfToken.class.getName(), csrfToken);
        request.setAttribute(csrfToken.getParameterName(), csrfToken);
        if (!this.requireCsrfProtectionMatcher.matches(request)) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Did not protect against CSRF since request did not match " + this.requireCsrfProtectionMatcher);
            }
            filterChain.doFilter(request, response);
        } else {
            String actualToken = request.getHeader(csrfToken.getHeaderName());
            if (actualToken == null) {
                actualToken = request.getParameter(csrfToken.getParameterName());
            }
            if (!equalsConstantTime(csrfToken.getToken(), actualToken)) {
                this.logger.debug(LogMessage.of(() -> {
                    return "Invalid CSRF token found for " + UrlUtils.buildFullRequestUrl(request);
                }));
                AccessDeniedException exception = !missingToken ? new InvalidCsrfTokenException(csrfToken, actualToken) : new MissingCsrfTokenException(actualToken);
                this.accessDeniedHandler.handle(request, response, (AccessDeniedException)exception);
            } else {
                filterChain.doFilter(request, response);
            }
        }
    }

    public static void skipRequest(HttpServletRequest request) {
        request.setAttribute(SHOULD_NOT_FILTER, Boolean.TRUE);
    }

    public void setRequireCsrfProtectionMatcher(RequestMatcher requireCsrfProtectionMatcher) {
        Assert.notNull(requireCsrfProtectionMatcher, "requireCsrfProtectionMatcher cannot be null");
        this.requireCsrfProtectionMatcher = requireCsrfProtectionMatcher;
    }

    public void setAccessDeniedHandler(AccessDeniedHandler accessDeniedHandler) {
        Assert.notNull(accessDeniedHandler, "accessDeniedHandler cannot be null");
        this.accessDeniedHandler = accessDeniedHandler;
    }

    private static boolean equalsConstantTime(String expected, String actual) {
        if (expected == actual) {
            return true;
        } else if (expected != null && actual != null) {
            byte[] expectedBytes = Utf8.encode(expected);
            byte[] actualBytes = Utf8.encode(actual);
            return MessageDigest.isEqual(expectedBytes, actualBytes);
        } else {
            return false;
        }
    }

    private static final class DefaultRequiresCsrfMatcher implements RequestMatcher {
    	//允许的方法
        private final HashSet<String> allowedMethods;
        private DefaultRequiresCsrfMatcher() {
       	//默认的允许方法
            this.allowedMethods = new HashSet(Arrays.asList("GET", "HEAD", "TRACE", "OPTIONS"));
        }
        public boolean matches(HttpServletRequest request) {
            //方法的校验
            return !this.allowedMethods.contains(request.getMethod());
        }
        public String toString() {
            return "CsrfNotRequired " + this.allowedMethods;
        }
    }
}

CsrfFilter的处理流程很清晰，当一个请求到达时，首先会调用csrfTokenRepository的loadToken方法加载该会话的CsrfToken值。如果加载不到，则证明请求是首次发起的，应该生成并保存一个新的CsrfToken值。如果可以加载到CsrfToken值， 那么先排除部分不需要验证CSRF攻击的请求方法(默认忽略了GET、 HEAD、 TRACE和OPTIONS) 。
Spring Security还提供了一个LazyCsrfTokenRepository，用来延时保存CsrfToken值(允许创建,但只有真正使用时才会被保存)

Tony-devj
关注
专栏目录
Spring Security 跨域与CORS
2012年开始工作，全栈开发老兵，目前已是一个老师，分享这么多年的心得体会
09-18 57
跨域是一种浏览器同源安全策略，即浏览器单方面限制脚本的跨域访问。
解决SpringSecurity权限拦截造成的CORS跨域问题
just
12-07 7028
关于什么是跨域，可以看一下阮一峰的 跨域资源共享 CORS 详解 进入正题 一般我们在开发前后端分离项目时，需要进行跨域配置，但是如果我们集成了SpringSecurity做安全校验，只配置跨域是不行的，还需要配置一下SpringSecurity使其支持CORS。 @Override protected void configure(HttpSecurity http) throws Exception { http // by default uses a Bean by the
爆破专栏丨Spring系列教程解决Spring Security环境中的跨域问题
qq_43444478的博客
10-29 435
上一章节中，一一哥 给各位讲解了同源策略和跨域问题，以及跨域问题的解决方案，在本篇文章中，我会带大家进行代码实现，看看在Spring Security环境中如何解决跨域问题。 一. 启用Spring Security 的CORS支持 1. 创建web接口 我先在SpringBoot环境中，创建一个端口号为8080的web项目，注意这个web项目没有引入Spring Security的依赖包。然后在其中创建一个IndexController，定义两个测试接口以便被ajax进行跨域访问。8080项目的代码
关于Spring Security的CORS
寻码启示
06-11 1549
跨域请求，同源安全策略，报错No 'Access-Control-Allow-Origin' header is present on the requested resource，解决方法，处理方法。
Spring Security 配置 CORS 失效的问题
最新发布
Rverdoser的博客
08-07 473
在Spring Security中，通常需要将CORS配置添加到WebSecurity配置中的http.cors()方法。：如果使用了错误的CORS实现，比如自定义Filter未正确实现CORS相关头的添加，也可能导致配置失效。解决方法：确保使用了正确的CORS实现，如果自定义，确保Filter正确地设置了CORS相关的响应头。：即使配置了CORS，如果没有正确地将CORS策略应用到具体的路径或者请求上，也会导致配置无效。：在某些版本的Spring Security中，CORS配置可能有已知的bug。
Spring Security的CORS与CSRF（三）
致力于不留技术债务cuizb.top
03-31 1792
文章目录跨域JSONPCORSSpring Security启用CORSCSRFCSRF的攻击过程CSRF的防御手段使用Spring Security防御CSRF攻击 跨域 在之前的文章[Spring Boot或Spring MVC前后端分离的项目跨域问题的解决方案]已经介绍过跨域以及跨域的解决方案。 在学习Spring Security的时候发现，Security框架也通过HttpSecurity进行链式配置解决跨域问题，是通过CORS进行解决的，随意还是会重点讲解相关CORS。 JSONP JSONP.
Spring Security(七) ——跨域配置
eyes++的博客
07-26 3920
CORS(Cross-OriginResourceSharing)是由W3C制定的一种基于HTTP头的跨域资源共享技术标准，其目的就是为了解决前端的跨域请求，该机制通过允许服务器标示除了它自己以外的其它origin（域，协议和端口），使得浏览器允许这些origin访问加载自己的资源。在JavaEE开发中，最常见的前端跨域请求解决方案是早期的JSONP，但是JSONP只支持GET请求，这是一个很大的缺陷，而CORS则支持多种HTTP请求方法，也是目前主流的跨域解决方案。...
SpringSecurity学习（六）CORS跨域、异常处理
Huathy的博客
03-12 3614
CORS是W3C的一种跨域资源共享技术标准，目的是为了解决前端跨域请求（浏览器同源策略会对跨域请求进行拦截）。早期方案由JSONP（仅支持GET），而CORS支持多种http请求，目前主流方案。cors中新增了一组 http请求头字段，通过这些字段告诉浏览器，那些网站通过浏览器有权限访问那些资源。
spring-security-ng-cors:使用 spring-security-csrf-token-interceptor 演示 CORS 问题的示例
07-03
在这个项目中，`spring-security-ng-cors-master` 文件夹可能包含了以下内容： 1. `src/main/java`: 存放项目的 Java 源代码，包括 Spring Security 配置类和其他相关服务。 2. `src/main/resources`: 包含配置文件...
【Spring Security系列】跨域与CORS
qq_28248897的博客
07-16 982
跨域是一种浏览器同源安全策略，即浏览器单方面限制脚本的跨域访问。 1.认识跨域 很多人误认为资源跨域时无法请求，实际上，通常情况下请求是可以正常发起的（注意，部分浏 览器存在特例），后端也正常进行了处理，只是在返回时被浏览器拦截，导致响应内容不可使用。可 以论证这一点的著名案例就是CSRF跨站攻击。 此外，我们平常所说的跨域实际上都是在讨论浏览器行为，包括各种WebView容器等（其中，以 XmlHttpRequest 的使用为主）。由于JavaScript 运行在浏览器之上，所以 Ajax的跨域成为
springsecurity之跨域
qq_3316359388的博客
05-31 1050
从协议部分开始到端口部分结束，只要与请求URL不同即被认为跨域，域名与域名对应的IP也不能幸免。 浏览器解决跨域问题的方法有多种，包括JSONP、Nginx转发和CORS等。其中，JSONP和CORS需要后端参与。 CORS（Cross-Origin Resource Sharing） 通常情况下，跨域请求即便在不被支持的情况下，服务器也会接 收并进行处理，在CORS的规范中则避免了这个问题。 浏览器首先会发起一个请求方法为OPTIONS 的预检请求，用于确认服务器是否允许跨域，只有在得到许可后才会发出实际
spring security 跨域请求防护
weixin_43931625的博客
06-04 559
springsecurity跨域请求防护
09 SpringSecurity-跨域与CORS
02-17 5161
一、认识跨域 很多人误认为资源跨域时无法请求，通常情况下时可以正常发起的（部分浏览器存在特例），后端也进行了正常处理，只是在返回时被浏览器拦截，导致响应内容无法使用。可以论证这一点的著名案例就是CSRF跨站攻击。 CSRF跨站攻击 CSRF（Cross Site Request Forgery） 跨站请求伪造。也被称为One Click Attack和Session Riding，通常缩写为CSRF或XSRF。通常来说就是攻击者盗用你的身份，以你的名义发送恶意请求。 注意这是真实的攻击手段： 举
跨域 Spring Security中 cors()函数作用(chatgpt答案)
weixin_41088381的博客
03-22 462
spring Security 跨域cors函数作用
SpringSecurity - CORS测试
风吹草动的博客
02-22 2234
SpringSecurity5 默认有效 CORS. 实装时需要指定允许的站点 CORS设置-有效 服务器端 只需添加依赖，默认有效。 添加SpringSecurity5 依赖compile("org.springframework.boot:spring-boot-starter-security") 客户端 新建Boot工程，指定另外的端口 测试src，参照；Ajax测试CORS/ L...
Spring Security实战（六）—— 跨域与CORS
weixin_49561506的博客
04-24 1370
spring security实战之跨域与CORS
SpringSecurity学习笔记（十一）CSRF攻击以及CORS跨域
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
10-09 1253
什么是CSRFCSRF：跨站请求伪造。也可称为一站式攻击。也可写作XSRF。按照字面意思来理解，跨站请求伪造，意思就是说用户登录了A网站之后，会话没有过期，然后登录了B网站，这个时候B网站中的请求访问了A网站，这个时候A网站就会认为是合法的用户的请求，这个时候用户是无感知的，从而导致用户在A网站的账户出现安全问题。特别是在一些银行之类的网站上如果受到这种攻击，造成的损失是致命的。CSRF防御。
CORS 跨域一篇文章就够了！Spring + Spring Security 配置！！
weixin_52834606的博客
09-06 2586
CORS 详情 ！ spring 跨域解决 + spring security 解决方案 ！
Spring Security 中的 CSRF和CORS
qq_29860591的博客
08-14 1165
Spring Security 中的 CSRF和CORS 使用 Spring Security 提供 CSRF 保护 什么是 CSRF？ 从安全的角度来讲，你可以将 CSRF 理解为一种攻击手段，即攻击者盗用了你的身份，然后以你的名义向第三方网站发送恶意请求。我们可以使用如下所示的流程图来描述 CSRF： 具体流程如下： 用户浏览并登录信任的网站 A，通过用户认证后，会在浏览器中生成针对 ...
spring-security配置跨域
08-31
在Spring Security中配置跨域有多种方法。一种常见的方法是使用@CrossOrigin注解或重写addCorsMappings方法来配置跨域，但是当项目中引入了Spring Security依赖后，这种配置方式可能会失效。 为了解决这个问题，可以使用Spring Security提供的更专业的跨域方案。首先，需要创建一个继承自WebSecurityConfigurerAdapter的配置类，并重写configure方法。在configure方法中，可以通过调用HttpSecurity对象的cors方法来启用跨域配置。 在cors方法中，可以通过CorsConfigurationSource对象的configurationSource方法来配置具体的跨域设置。可以使用CorsConfiguration对象来设置允许的请求头、请求方法和请求来源。此外，还可以设置预检请求的缓存时间。最后，需要将CorsConfiguration对象注册到UrlBasedCorsConfigurationSource对象中。 下面是一个示例的配置类的代码： ```java @Configuration public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .mvcMatchers("/hello1").permitAll() .anyRequest().authenticated() .and() .formLogin() .and() .cors() // 跨域配置 .configurationSource(configurationSource()); } CorsConfigurationSource configurationSource() { CorsConfiguration corsConfiguration = new CorsConfiguration(); corsConfiguration.setAllowedHeaders(Collections.singletonList("*")); corsConfiguration.setAllowedMethods(Collections.singletonList("*")); corsConfiguration.setAllowedOrigins(Collections.singletonList("*")); corsConfiguration.setMaxAge(3600L); UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); source.registerCorsConfiguration("/**", corsConfiguration); return source; } } ``` 通过以上配置，Spring Security会自动应用跨域配置，并且保持其他安全配置不受影响。这种方式可以确保跨域配置在Spring Security过滤器之前生效，避免了跨域配置失效的问题。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Spring Security(七) ——跨域配置](https://blog.csdn.net/tongkongyu/article/details/125982927)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值