要学就学透彻！Spring Security 中 CSRF 防护源码解析

时间  2020-07-09
标签 透彻 spring security csrf 防护 源码 解析 栏目 Spring 繁體版
原文   原文链接

上篇文章松哥和你们聊了什么是 CSRF 攻击，以及 CSRF 攻击要如何防护。主要和你们聊了 Spring Security 中处理该问题的几种办法。html

今天松哥来和你们简单的看一下 Spring Security 中，CSRF 防护源码。前端

本文是本系列第 19 篇，阅读本系列前面文章有助于更好的理解本文：java

  1. 挖一个大坑，Spring Security 开搞！
  2. 松哥手把手带你入门 Spring Security，别再问密码怎么解密了
  3. 手把手教你定制 Spring Security 中的表单登陆
  4. Spring Security 作先后端分离，咱就别作页面跳转了！通通 JSON 交互
  5. Spring Security 中的受权操做原来这么简单
  6. Spring Security 如何将用户数据存入数据库？
  7. Spring Security+Spring Data Jpa 强强联手，安全管理只有更简单！
  8. Spring Boot + Spring Security 实现自动登陆功能
  9. Spring Boot 自动登陆，安全风险要怎么控制？
  10. 在微服务项目中，Spring Security 比 Shiro 强在哪？
  11. SpringSecurity 自定义认证逻辑的两种方式(高级玩法)
  12. Spring Security 中如何快速查看登陆用户 IP 地址等信息？
  13. Spring Security 自动踢掉前一个登陆用户，一个配置搞定！
  14. Spring Boot + Vue 先后端分离项目，如何踢掉已登陆用户？
  15. Spring Security 自带防火墙！你都不知道本身的系统有多安全！
  16. 什么是会话固定攻击？Spring Boot 中要如何防护会话固定攻击？
  17. 集群化部署，Spring Security 要如何处理 session 共享？
  18. 松哥手把手教你在 SpringBoot 中防护 CSRF 攻击！so easy！

本文主要从两个方面来和你们讲解：数据库

  1. 返回给前端的 _csrf 参数是如何生成的。
  2. 前端传来的 _csrf 参数是如何校验的。

1.随机字符串生成

咱们先来看一下 Spring Security 中的 csrf 参数是如何生成的。后端

首先，Spring Security 中提供了一个保存 csrf 参数的规范，就是 CsrfToken：安全

public interface CsrfToken extends Serializable {
    String getHeaderName();
    String getParameterName();
    String getToken();

}

这里三个方法都好理解，前两个是获取 _csrf 参数的 key，第三个是获取 _csrf 参数的 value。cookie

CsrfToken 有两个实现类，以下：session

默认状况下使用的是 DefaultCsrfToken，咱们来稍微看下 DefaultCsrfToken：前后端分离

public final class DefaultCsrfToken implements CsrfToken {
    private final String token;
    private final String parameterName;
    private final String headerName;
    public DefaultCsrfToken(String headerName, String parameterName, String token) {
        this.headerName = headerName;
        this.parameterName = parameterName;
        this.token = token;
    }
    public String getHeaderName() {
        return this.headerName;
    }
    public String getParameterName() {
        return this.parameterName;
    }
    public String getToken() {
        return this.token;
    }
}

这段实现很简单，几乎没有添加额外的方法，就是接口方法的实现。dom

CsrfToken 至关于就是 _csrf 参数的载体。那么参数是如何生成和保存的呢？这涉及到另一个类：

public interface CsrfTokenRepository {
    CsrfToken generateToken(HttpServletRequest request);
    void saveToken(CsrfToken token, HttpServletRequest request,
            HttpServletResponse response);
    CsrfToken loadToken(HttpServletRequest request);
}

这里三个方法：

  1. generateToken 方法就是 CsrfToken 的生成过程。
  2. saveToken 方法就是保存 CsrfToken。
  3. loadToken 则是如何加载 CsrfToken。

CsrfTokenRepository 有四个实现类，在上篇文章中，咱们用到了其中两个：HttpSessionCsrfTokenRepository 和 CookieCsrfTokenRepository，其中 HttpSessionCsrfTokenRepository 是默认的方案。

咱们先来看下 HttpSessionCsrfTokenRepository 的实现：

public final class HttpSessionCsrfTokenRepository implements CsrfTokenRepository {
    private static final String DEFAULT_CSRF_PARAMETER_NAME = "_csrf";
    private static final String DEFAULT_CSRF_HEADER_NAME = "X-CSRF-TOKEN";
    private static final String DEFAULT_CSRF_TOKEN_ATTR_NAME = HttpSessionCsrfTokenRepository.class
            .getName().concat(".CSRF_TOKEN");
    private String parameterName = DEFAULT_CSRF_PARAMETER_NAME;
    private String headerName = DEFAULT_CSRF_HEADER_NAME;
    private String sessionAttributeName = DEFAULT_CSRF_TOKEN_ATTR_NAME;
    public void saveToken(CsrfToken token, HttpServletRequest request,
            HttpServletResponse response) {
        if (token == null) {
            HttpSession session = request.getSession(false);
            if (session != null) {
                session.removeAttribute(this.sessionAttributeName);
            }
        }
        else {
            HttpSession session = request.getSession();
            session.setAttribute(this.sessionAttributeName, token);
        }
    }
    public CsrfToken loadToken(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session == null) {
            return null;
        }
        return (CsrfToken) session.getAttribute(this.sessionAttributeName);
    }
    public CsrfToken generateToken(HttpServletRequest request) {
        return new DefaultCsrfToken(this.headerName, this.parameterName,
                createNewToken());
    }
    private String createNewToken() {
        return UUID.randomUUID().toString();
    }
}

这段源码其实也很好理解：

  1. saveToken 方法将 CsrfToken 保存在 HttpSession 中，未来再从 HttpSession 中取出和前端传来的参数作笔记。
  2. loadToken 方法固然就是从 HttpSession 中读取 CsrfToken 出来。
  3. generateToken 是生成 CsrfToken 的过程，能够看到，生成的默认载体就是 DefaultCsrfToken，而 CsrfToken 的值则经过 createNewToken 方法生成，是一个 UUID 字符串。
  4. 在构造 DefaultCsrfToken 是还有两个参数 headerName 和 parameterName，这两个参数是前端保存参数的 key。

这是默认的方案，适用于先后端不分的开发，具体用法能够参考上篇文章。

若是想在先后端分离开发中使用，那就须要 CsrfTokenRepository 的另外一个实现类 CookieCsrfTokenRepository ，代码以下：

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 = DEFAULT_CSRF_PARAMETER_NAME;
    private String headerName = DEFAULT_CSRF_HEADER_NAME;
    private String cookieName = DEFAULT_CSRF_COOKIE_NAME;
    private boolean cookieHttpOnly = true;
    private String cookiePath;
    private String cookieDomain;
    public CookieCsrfTokenRepository() {
    }
    @Override
    public CsrfToken generateToken(HttpServletRequest request) {
        return new DefaultCsrfToken(this.headerName, this.parameterName,
                createNewToken());
    }
    @Override
    public void saveToken(CsrfToken token, HttpServletRequest request,
            HttpServletResponse response) {
        String tokenValue = token == null ? "" : token.getToken();
        Cookie cookie = new Cookie(this.cookieName, tokenValue);
        cookie.setSecure(request.isSecure());
        if (this.cookiePath != null && !this.cookiePath.isEmpty()) {
                cookie.setPath(this.cookiePath);
        } else {
                cookie.setPath(this.getRequestContext(request));
        }
        if (token == null) {
            cookie.setMaxAge(0);
        }
        else {
            cookie.setMaxAge(-1);
        }
        cookie.setHttpOnly(cookieHttpOnly);
        if (this.cookieDomain != null && !this.cookieDomain.isEmpty()) {
            cookie.setDomain(this.cookieDomain);
        }

        response.addCookie(cookie);
    }
    @Override
    public CsrfToken loadToken(HttpServletRequest request) {
        Cookie cookie = WebUtils.getCookie(request, this.cookieName);
        if (cookie == null) {
            return null;
        }
        String token = cookie.getValue();
        if (!StringUtils.hasLength(token)) {
            return null;
        }
        return new DefaultCsrfToken(this.headerName, this.parameterName, token);
    }
    public static CookieCsrfTokenRepository withHttpOnlyFalse() {
        CookieCsrfTokenRepository result = new CookieCsrfTokenRepository();
        result.setCookieHttpOnly(false);
        return result;
    }
    private String createNewToken() {
        return UUID.randomUUID().toString();
    }
}

和 HttpSessionCsrfTokenRepository 相比，这里 _csrf 数据保存的时候，都保存到 cookie 中去了，固然读取的时候，也是从 cookie 中读取，其余地方则和 HttpSessionCsrfTokenRepository 是同样的。

OK，这就是咱们整个 _csrf 参数生成的过程。

总结一下，就是生成一个 CsrfToken，这个 Token，本质上就是一个 UUID 字符串，而后将这个 Token 保存到 HttpSession 中，或者保存到 Cookie 中，待请求到来时，从 HttpSession 或者 Cookie 中取出来作校验。

2.参数校验

那接下来就是校验了。

校验主要是经过 CsrfFilter 过滤器来进行，咱们来看下核心的 doFilterInternal 方法：

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);
}

这个方法我来稍微解释下：

  1. 首先调用 tokenRepository.loadToken 方法读取 CsrfToken 出来，这个 tokenRepository 就是你配置的 CsrfTokenRepository 实例，CsrfToken 存在 HttpSession 中，这里就从 HttpSession 中读取，CsrfToken 存在 Cookie 中，这里就从 Cookie 中读取。
  2. 若是调用 tokenRepository.loadToken 方法没有加载到 CsrfToken，那说明这个请求多是第一次发起，则调用 tokenRepository.generateToken 方法生成 CsrfToken ，并调用 tokenRepository.saveToken 方法保存 CsrfToken。
  3. 你们注意，这里还调用 request.setAttribute 方法存了一些值进去，这就是默认状况下，咱们经过 jsp 或者 thymeleaf 标签渲染 _csrf 的数据来源。
  4. requireCsrfProtectionMatcher.matches 方法则使用用来判断哪些请求方法须要作校验，默认状况下，"GET", "HEAD", "TRACE", "OPTIONS" 方法是不须要校验的。
  5. 接下来获取请求中传递来的 CSRF 参数，先从请求头中获取，获取不到再从请求参数中获取。
  6. 获取到请求传来的 csrf 参数以后，再和一开始加载到的 csrfToken 作比较，若是不一样的话，就抛出异常。

如此以后，就完成了整个校验工做了。

3.LazyCsrfTokenRepository

前面咱们说了 CsrfTokenRepository 有四个实现类，除了咱们介绍的两个以外，还有一个 LazyCsrfTokenRepository，这里松哥也和你们作一个简单介绍。

在前面的 CsrfFilter 中你们发现，对于常见的 GET 请求其实是不须要 CSRF 攻击校验的，可是，每当 GET 请求到来时，下面这段代码都会执行：

if (missingToken) {
    csrfToken = this.tokenRepository.generateToken(request);
    this.tokenRepository.saveToken(csrfToken, request, response);
}

生成 CsrfToken 并保存，但实际上却没什么用，由于 GET 请求不须要 CSRF 攻击校验。

因此，Spring Security 官方又推出了 LazyCsrfTokenRepository。

LazyCsrfTokenRepository 实际上不能算是一个真正的 CsrfTokenRepository，它是一个代理，能够用来加强 HttpSessionCsrfTokenRepository 或者 CookieCsrfTokenRepository 的功能：

public final class LazyCsrfTokenRepository implements CsrfTokenRepository {
    @Override
    public CsrfToken generateToken(HttpServletRequest request) {
        return wrap(request, this.delegate.generateToken(request));
    }
    @Override
    public void saveToken(CsrfToken token, HttpServletRequest request,
            HttpServletResponse response) {
        if (token == null) {
            this.delegate.saveToken(token, request, response);
        }
    }
    @Override
    public CsrfToken loadToken(HttpServletRequest request) {
        return this.delegate.loadToken(request);
    }
    private CsrfToken wrap(HttpServletRequest request, CsrfToken token) {
        HttpServletResponse response = getResponse(request);
        return new 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;
        }
        @Override
        public String getToken() {
            saveTokenIfNecessary();
            return this.delegate.getToken();
        }
        private void saveTokenIfNecessary() {
            if (this.tokenRepository == null) {
                return;
            }

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

    }
}

这里，我说三点：

  1. generateToken 方法，该方法用来生成 CsrfToken，默认 CsrfToken 的载体是 DefaultCsrfToken，如今换成了 SaveOnAccessCsrfToken。
  2. SaveOnAccessCsrfToken 和 DefaultCsrfToken 并无太大区别，主要是 getToken 方法有区别，在 SaveOnAccessCsrfToken 中，当开发者调用 getToken 想要去获取 csrfToken 时，才会去对 csrfToken 作保存操做（调用 HttpSessionCsrfTokenRepository 或者 CookieCsrfTokenRepository 的 saveToken 方法）。
  3. LazyCsrfTokenRepository 本身的 saveToken 则作了修改，至关于放弃了 saveToken 的功能，调用该方法并不会作保存操做。

使用了 LazyCsrfTokenRepository 以后，只有在使用 csrfToken 时才会去存储它，这样就能够节省存储空间了。

LazyCsrfTokenRepository 的配置方式也很简单，在咱们使用 Spring Security 时，若是对 csrf 不作任何配置，默认其实就是 LazyCsrfTokenRepository+HttpSessionCsrfTokenRepository 组合。

固然咱们也能够本身配置，以下：

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests().anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login.html")
            .successHandler((req,resp,authentication)->{
                resp.getWriter().write("success");
            })
            .permitAll()
            .and()
            .csrf().csrfTokenRepository(new LazyCsrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()));
}

4.小结

今天主要和小伙伴聊了一下 Spring Security 中 csrf 防护的原理。

总体来讲，就是两个思路：

  1. 生成 csrfToken 保存在 HttpSession 或者 Cookie 中。
  2. 请求到来时，从请求中提取出来 csrfToken，和保存的 csrfToken 作比较，进而判断出当前请求是否合法。

好啦，不知道小伙伴们有没有 GET 到呢？若是以为有收获，记得点个在看鼓励下松哥哦～

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程