6.CSRF和CORS

Spring Security是一个强大且高度可定制的框架，用于保护基于Spring的应用程序。在Web应用程序开发中，CSRF（跨站请求伪造）和CORS（跨域资源共享）是两个需要特别注意的安全问题。本文将深入探讨Spring Security中如何处理CSRF和CORS，详细介绍它们的概念、实现机制、配置方法及实际应用。

一、CSRF（跨站请求伪造）

1.1 CSRF的概念

CSRF（Cross-Site Request Forgery）是一种攻击方式，攻击者通过伪造用户的请求，使用户在未察觉的情况下执行恶意操作。例如，用户登录银行网站后，攻击者诱使用户访问一个恶意网站，该网站向银行发送转账请求，利用用户的身份完成转账操作。

1.2 CSRF攻击的原理

CSRF攻击利用了用户的身份认证信息，例如会话Cookie。攻击者通过在第三方网站上植入恶意代码，诱使用户在已认证的情况下执行未授权的操作。常见的攻击方式包括：

  1. GET请求：通过在恶意网站中嵌入图片或脚本，向受害者网站发送GET请求。
  2. POST请求：通过表单提交或AJAX请求，向受害者网站发送POST请求。

1.3 防御CSRF攻击的基本方法

防御CSRF攻击的常见方法包括：

  1. 使用CSRF Token：在每个敏感操作请求中添加一个唯一的CSRF Token，服务器验证该Token以确认请求的合法性。
  2. 检查Referer或Origin头：验证请求的Referer或Origin头，确保请求来源合法。
  3. SameSite Cookie属性：设置Cookie的SameSite属性为Strict或Lax，限制第三方网站发送跨站请求时携带Cookie。

1.4 Spring Security中的CSRF保护

Spring Security默认启用了CSRF保护机制。以下是Spring Security中CSRF保护的配置和实现。

示例代码：默认启用CSRF保护

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf()
                .and()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }
}

示例代码：禁用CSRF保护

在某些情况下（如开发环境或某些API端点），可能需要禁用CSRF保护。可以通过以下配置禁用CSRF保护：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }
}

1.5 自定义CSRF Token存储和验证

Spring Security提供了灵活的配置选项，可以自定义CSRF Token的生成、存储和验证方式。

示例代码：自定义CSRF Token存储

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.csrf.CsrfFilter;
import org.springframework.security.web.csrf.CsrfTokenRepository;
import org.springframework.security.web.csrf.HttpSessionCsrfTokenRepository;

public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf()
                .csrfTokenRepository(customCsrfTokenRepository())
                .and()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    private CsrfTokenRepository customCsrfTokenRepository() {
        HttpSessionCsrfTokenRepository repository = new HttpSessionCsrfTokenRepository();
        repository.setSessionAttributeName("_csrf_custom");
        return repository;
    }
}

1.6 CSRF保护的实际应用

在实际应用中，可以在表单提交、AJAX请求等场景中使用CSRF Token，确保请求的安全性。

示例代码：表单提交中使用CSRF Token

1
2
3
4
5
<form method="post" action="/submit">
    <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>
    <!-- 其他表单字段 -->
    <input type="submit" value="Submit"/>
</form>

示例代码：AJAX请求中使用CSRF Token

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$(document).ready(function() {
    var token = $("meta[name='_csrf']").attr("content");
    var header = $("meta[name='_csrf_header']").attr("content");

    $(document).ajaxSend(function(e, xhr, options) {
        xhr.setRequestHeader(header, token);
    });
});

$.ajax({
    url: '/submit',
    type: 'POST',
    data: { /* 数据 */ },
    success: function(response) {
        console.log('Request successful');
    }
});

二、CORS（跨域资源共享）

2.1 CORS的概念

CORS（Cross-Origin Resource Sharing）是一种机制，通过使用额外的HTTP头，允许浏览器服务器跨域访问受限制的资源。CORS是一种安全特性，用于防止恶意网站从不同源的服务器获取数据。

2.2 CORS的工作原理

CORS通过在请求和响应中添加特定的HTTP头来实现跨域资源共享。CORS请求主要分为两类：

  1. 简单请求：满足特定条件的请求，可以直接发起。
  2. 预检请求：不满足简单请求条件的请求，浏览器会先发起OPTIONS预检请求，确认服务器允许跨域访问后，再发起实际请求。

CORS请求的关键HTTP头包括：

  1. Origin：请求的来源。
  2. Access-Control-Allow-Origin：服务器允许访问的来源。
  3. Access-Control-Allow-Methods：服务器允许的HTTP方法。
  4. Access-Control-Allow-Headers：服务器允许的请求头。

2.3 Spring Security中的CORS配置

Spring Security提供了灵活的CORS配置选项，可以在安全配置中添加CORS支持。

示例代码：基本的CORS配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().and()
            .csrf().disable()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }
}

示例代码：自定义CORS配置

通过自定义CORS配置，可以设置允许的来源、方法、头等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().configurationSource(corsConfigurationSource()).and()
            .csrf().disable()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("http://example.com");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }

    private CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("http://example.com");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return source;
    }
}

2.4 实际应用中的CORS配置

在实际应用中，可以根据具体需求配置CORS，以确保安全性和功能性。

示例代码：多来源CORS配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsConfigurationSource;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().configurationSource(corsConfigurationSource()).and()
            .csrf().disable()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("http://example.com");
        config.addAllowedOrigin("http://another-example.com");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return source;
    }
}

三、CSRF和CORS综合应用

3.1 配置CSRF和CORS

在实际应用中，通常需要同时配置CSRF和CORS，以确保应用的安全性和跨域访问。

示例代码：综合配置CSRF和CORS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsConfigurationSource;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().configurationSource(corsConfigurationSource()).and()
            .csrf().csrfTokenRepository(csrfTokenRepository()).and()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("http://example.com");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return source;
    }

    @Bean
    public CsrfTokenRepository csrfTokenRepository() {
        HttpSessionCsrfTokenRepository repository = new HttpSessionCsrfTokenRepository();
        repository.setSessionAttributeName("_csrf_custom");
        return repository;
    }
}

3.2 RESTful API的CSRF和CORS配置

对于RESTful API，可以禁用CSRF保护，同时配置CORS，以确保API的安全性和跨域访问。

示例代码：RESTful API的CSRF和CORS配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsConfigurationSource;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().configurationSource(corsConfigurationSource()).and()
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/api/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return source;
    }
}

四、CSRF和CORS在不同框架中的应用

4.1 Spring Boot中的应用

Spring Boot简化了Spring应用的配置，可以更方便地配置CSRF和CORS。

示例代码：Spring Boot中配置CSRF和CORS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsConfigurationSource;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().configurationSource(corsConfigurationSource()).and()
            .csrf().csrfTokenRepository(csrfTokenRepository()).and()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("http://example.com");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return source;
    }

    @Bean
    public CsrfTokenRepository csrfTokenRepository() {
        HttpSessionCsrfTokenRepository repository = new HttpSessionCsrfTokenRepository();
        repository.setSessionAttributeName("_csrf_custom");
        return repository;
    }
}

4.2 Spring Cloud中的应用

在Spring Cloud微服务架构中，需要在每个微服务中配置CSRF和CORS。

示例代码：Spring Cloud中配置CSRF和CORS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.cors.reactive.CorsConfigurationSource;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().configurationSource(corsConfigurationSource()).and()
            .csrf().csrfTokenRepository(csrfTokenRepository()).and()
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .and()
            .httpBasic();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("http://example.com");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return source;
    }

    @Bean
    public CsrfTokenRepository csrfTokenRepository() {
        HttpSessionCsrfTokenRepository repository = new HttpSessionCsrfTokenRepository();
        repository.setSessionAttributeName("_csrf_custom");
        return repository;
    }
}

五、最佳实践和常见问题

5.1 最佳实践

  1. 启用CSRF保护：默认启用CSRF保护，确保每个敏感操作请求包含CSRF Token。
  2. 配置CORS：根据应用需求配置CORS，确保跨域请求的安全性和功能性。
  3. 使用连接池：通过连接池管理数据库连接，减少资源泄漏和性能问题。
  4. 优化SQL语句：通过优化SQL语句，提高查询效率。

5.2 常见问题及解决方案

  1. CSRF Token丢失：确保每个敏感操作请求都包含CSRF Token，使用表单或AJAX请求时添加CSRF Token。
  2. 跨域请求失败：检查CORS配置，确保服务器允许跨域请求，配置允许的来源、方法和头。
  3. 资源泄漏：确保及时关闭数据库连接、Statement、ResultSet等资源，避免资源泄漏。
  4. 性能问题：在高并发环境下，使用连接池、批处理等技术，提高性能。

六、总结

Spring Security提供了强大的CSRF和CORS保护机制，通过合理配置和使用，可以有效防御CSRF攻击和支持跨域资源共享。本文详细介绍了CSRF和CORS的概念、实现机制、配置方法及实际应用，并提供了丰富的示例代码，希望读者能够全面掌握Spring Security中的CSRF和CORS配置，编写出安全、稳定、可靠的Web应用程序。