Springboot集成CSRF防攻擊過程

更新時(shí)間：2025年11月07日 16:16:39 作者：hao_kkkkk

本文介紹了Springboot集成CSRF防攻擊的方法,通過設(shè)置域名或路徑白名單來過濾未知鏈接,從而達(dá)到防護(hù)目的,主要涉及兩個類：CSRFFilterConfigUtils防護(hù)配置工具類和CsrfFilter防護(hù)過濾類

Springboot集成CSRF防攻擊

CSRF 就是跨域請求偽造，是一種常見的web攻擊方式，解決思路也非常簡單，主要是設(shè)置域名或路徑白名單，對于未知的鏈接予以過濾，從而達(dá)到防護(hù)目的。

總共兩個類：

一個CSRFFilterConfigUtils防護(hù)配置工具類，主要作用是配置防護(hù)開關(guān)、請求路徑白名單以及請求域名白名單；
一個是CsrfFilter防護(hù)過濾類，該類實(shí)質(zhì)是一個攔截器，攔截所有用戶請求，匹配路徑和域名，符合條件的通過，不符合條件的攔截掉；

以下為實(shí)際代碼：

CSRFFilterConfigUtils 防護(hù)配置工具類

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @Auther: GMY
 * @Date: 2022/09/16/9:54
 * @Description: CSRF防護(hù)配置工具類
 */
@Component
public class CSRFFilterConfigUtils {

    /**
     * 跨站點(diǎn)請求路徑白名單，通過英文逗號分隔。在application.properties配置
     */
    public static String csrfWhitePaths;

    /**
     * 跨站點(diǎn)請求域名白名單，通過英文逗號分隔。在application.properties配置
     */
    public static String csrfWhiteDomains;

    /**
     * csrf攻擊防護(hù)開關(guān)配置
     */
    public static Boolean openCsrfProtect;

    /**
     * @param
     * @return java.lang.Boolean
     * @author GMY
     * @date 2022/9/16 10:13
     * @description csrf攻擊防護(hù)開關(guān)配置，默認(rèn)為開啟
     */
    public static Boolean getOpenCsrfProtect() {
        return openCsrfProtect == null ? true : openCsrfProtect;
    }

    /**
     * @param
     * @return java.lang.String[]
     * @author GMY
     * @date 2022/9/16 10:07
     * @description 獲取請求路徑白名單
     */
    public static String[] getCsrfWhitePaths() {
        if (StringUtils.isNotEmpty(csrfWhitePaths)) {
            return csrfWhitePaths.split(",");
        }
        return null;
    }

    /**
     * @param
     * @return java.lang.String[]
     * @author GMY
     * @date 2022/9/16 10:09
     * @description 獲取請求域名白名單
     */
    public static String[] getCsrfWhiteDomains() {
        if (StringUtils.isNotEmpty(csrfWhiteDomains)) {
            return csrfWhiteDomains.split(",");
        }
        return null;
    }


    @Value("${csrf.white.paths}")
    public static void setCsrfWhitePaths(String csrfWhitePaths) {
        CSRFFilterConfigUtils.csrfWhitePaths = csrfWhitePaths;
    }

    @Value("${csrf.white.domains}")
    public static void setCsrfWhiteDomains(String csrfWhiteDomains) {
        CSRFFilterConfigUtils.csrfWhiteDomains = csrfWhiteDomains;
    }

    @Value("${open.csrf.protect}")
    public void setOpenCsrfProtect(Boolean openCsrfProtect) {
        CSRFFilterConfigUtils.openCsrfProtect = openCsrfProtect;
    }
}

CsrfFilter 防護(hù)過濾類

import cn.hutool.json.JSONUtil;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URL;

/**
 * @Auther: GMY
 * @Date: 2022/09/15/19:54
 * @Description:
 */
@WebFilter(urlPatterns = "/*",filterName = "csrfFilter")
@Configuration
public class CsrfFilter implements Filter {

    // 后臺日志打印
    private Logger log = LoggerFactory.getLogger(CsrfFilter.class);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    /**
     * @param servletRequest
     * @param servletResponse
     * @param filterChain
     * @return void
     * @author GMY
     * @date 2022/9/16 9:51
     * @description 執(zhí)行CRSF過濾操作
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        HttpServletResponse res = (HttpServletResponse) servletResponse;
        // 判斷CSRF防護(hù)是否開啟，如果沒開啟則直接略過過濾操作
        if (!CSRFFilterConfigUtils.getOpenCsrfProtect()) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            String referer = req.getHeader("Referer");
            if (!StringUtils.isBlank(referer)) {
                // 獲取Referer參數(shù)中的地址和端口
                String refererHostAndPort = getHostAndPort(req,referer);
                // 獲取RequestURL參數(shù)中的地址和端口
                String requestHostAndPort = getHostAndPort(req,null);
                // 同域名和同端口，即同一個域的系統(tǒng)，通過
                if (requestHostAndPort.equalsIgnoreCase(refererHostAndPort)) {
                    filterChain.doFilter(servletRequest, servletResponse);
                }else {
                    // 如果不同域名或端口，繼續(xù)判斷域名是否在白名單中，如果在白名單中則通過
                    if(isCsrfWhiteDomains(refererHostAndPort)) {
                        filterChain.doFilter(servletRequest, servletResponse);
                        return;
                    }
                    // 獲取RequestURL參數(shù)中的路徑信息
                    String path = new URL(req.getRequestURL().toString()).getPath();
                    log.info("request請求路徑 path = " + path);
                    // 將路徑中的域名去除，只保留具體路徑
                    String actionPath = path.replaceAll(servletRequest.getServletContext().getContextPath(), "");
                    // 判斷路徑是否在訪問路徑白名單中，如果在白名單中，則通過，繼續(xù)后續(xù)執(zhí)行
                    if(isCsrfWhitePaths(actionPath)) {
                        filterChain.doFilter(servletRequest, servletResponse);
                        return;
                    }
                    log.warn("csrf跨站點(diǎn)偽造請求已經(jīng)被攔截：");
                    log.warn("requestURL = " + req.getRequestURL().toString());
                    log.warn("referer = " + referer);
                    res.sendRedirect(req.getContextPath() + "/illegal");
                    return;
                }
            }else{
                filterChain.doFilter(servletRequest, servletResponse);
            }
        }
    }

    /**
     * @param request
     * @param referer
     * @return java.lang.String
     * @author GMY
     * @date 2022/9/16 9:34
     * @description 獲取請求地址和端口
     */
    protected String getHostAndPort(HttpServletRequest request, String referer) throws IOException {
        URL url;
        if (StringUtils.isNotEmpty(referer)) {
            url = new URL(referer);
        } else {
            url = new URL(request.getRequestURL().toString());
        }
        String requestHostAndPort;
        if(url.getPort() == -1) {
            requestHostAndPort = url.getHost();
        }else {
            requestHostAndPort = url.getHost() + ":" + url.getPort();
        }
        return requestHostAndPort;

    }

    @Override
    public void destroy() {

    }

    /**
     * @param path
     * @return boolean
     * @author GMY
     * @date 2022/9/16 9:52
     * @description 判斷請求路徑是否在路徑白名單中
     */
    private boolean isCsrfWhitePaths(String path) {

        if(CSRFFilterConfigUtils.getCsrfWhitePaths() != null && CSRFFilterConfigUtils.getCsrfWhitePaths().length > 0) {
            for (String csrfWhitePath : CSRFFilterConfigUtils.getCsrfWhitePaths()) {
                if(!StringUtils.isBlank(csrfWhitePath)) {
                    if(csrfWhitePath.equals(path)) {
                        log.info("跨站點(diǎn)請求所有路徑白名單：csrfWhitePaths = " + JSONUtil.toJsonStr(CSRFFilterConfigUtils.getCsrfWhitePaths()));
                        log.info("符合跨站點(diǎn)請求路徑白名單：path = " + path);
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * @param refererHostAndPort
     * @return boolean
     * @author GMY
     * @date 2022/9/16 9:52
     * @description 判斷請求域名是否在域名白名單中
     */
    private boolean isCsrfWhiteDomains(String refererHostAndPort) {

        if(CSRFFilterConfigUtils.getCsrfWhiteDomains() != null && CSRFFilterConfigUtils.getCsrfWhiteDomains().length > 0) {
            for (String csrfWhiteDomain : CSRFFilterConfigUtils.getCsrfWhiteDomains()) {
                if(!StringUtils.isBlank(csrfWhiteDomain)) {
                    if(csrfWhiteDomain.equals(refererHostAndPort)) {
                        log.info("跨站點(diǎn)請求所有【域名】]白名單：csrfWhiteDomains = " + JSONUtil.toJsonStr(CSRFFilterConfigUtils.getCsrfWhiteDomains()));
                        log.info("符合跨站點(diǎn)請求【域名】白名單：refererHost = " + refererHostAndPort);
                        return true;
                    }
                }
            }
            log.info("跨站點(diǎn)請求非法【域名】：refererHost = " + refererHostAndPort);
        }
        return false;
    }
}