[Spring Cloud] (9)XSS拦截器

简述

本文涉及代码已开源

本文网关gateway，微服务，vue已开源到gitee
杉极简 / gateway网关阶段学习
https://gitee.com/dong-puen/gateway-stages

Fir Cloud 完整项目

该内容完整项目如下
Fir Cloud v1.0.0
https://gitee.com/dong-puen/fir-cloud
https://github.com/firLucky/fir-cloud

防XSS攻击

XSS攻击是一种常见的网络攻击手段，它允许攻击者将恶意脚本注入到其他用户会浏览的页面中。谁也不想，被注入一段代码，然后在客户的浏览器上被执行，然后造成重大损失，然后被领导叫去喝茶吧。。。

必要性：

1. 保护用户隐私：XSS攻击可以盗取用户的敏感信息，如登录凭据、个人数据和Cookies。
2. 维护数据完整性：攻击者可能会利用XSS攻击来修改网页内容，破坏数据的准确性和完整性。
3. 防止会话劫持：XSS攻击常常被用来窃取用户的会话Cookies，从而允许攻击者冒充用户进行操作。

作用：

1. 防止恶意脚本执行：通过输入清理、输出编码等措施，防止恶意脚本在用户浏览器中执行。
2. 防止敏感信息泄露：减少攻击者盗取用户敏感信息的机会，保护用户隐私。
3. 保护Web应用安全：加强Web应用的整体安全性，使其不易受到XSS攻击。
4. 防止网页篡改：防止攻击者通过XSS攻击修改网页内容。
5. 减少安全漏洞：通过实施XSS防御措施，减少Web应用的安全漏洞。

整体效果

前端传递一个攻击代码字符串给后端时，后端将其过滤掉，效果如下：

后端

增加拦截器开关配置

  # xss拦截
  xss: true

GlobalConfig增加

    /**
     * 防xss
     */
    private boolean xss;

pom中增加jsoup依赖

jsoup 是一款基于 Java 的HTML解析器

        <!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.17.2</version>
        </dependency>

添加JSON处理工具类

package com.fir.gateway.utils;

import com.alibaba.fastjson.JSONObject;
import org.springframework.util.StringUtils;

/**
 * JSON处理工具类
 *
 * @author fir
 */
public enum JsonUtils {

    /**
     * 实例
     */
    INSTANCE;

    /**
     * json对象字符串开始标记
     */
    private final static String JSON_OBJECT_START = "{";

    /**
     * json对象字符串结束标记
     */
    private final static String JSON_OBJECT_END = "}";

    /**
     * json数组字符串开始标记
     */
    private final static String JSON_ARRAY_START = "[";

    /**
     * json数组字符串结束标记
     */
    private final static String JSON_ARRAY_END = "]";


    /**
     * 判断字符串是否json对象字符串
     *
     * @param val 字符串
     * @return true/false
     */
    public boolean isJsonObj(String val) {
        if (StringUtils.hasLength(val)) {
            return false;
        }
        val = val.trim();
        if (val.startsWith(JSON_OBJECT_START) && val.endsWith(JSON_OBJECT_END)) {
            try {
                JSONObject.parseObject(val);
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 判断字符串是否json数组字符串
     *
     * @param val 字符串
     * @return true/false
     */
    public boolean isJsonArr(String val) {
        if (StringUtils.hasLength(val)) {
            return false;
        }
        val = val.trim();
        if (StringUtils.hasLength(val)) {
            return false;
        }
        val = val.trim();
        if (val.startsWith(JSON_ARRAY_START) && val.endsWith(JSON_ARRAY_END)) {
            try {
                JSONObject.parseArray(val);
                return true;
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 判断对象是否是json对象
     *
     * @param obj 待判断对象
     * @return true/false
     */
    public boolean isJsonObj(Object obj) {
        String str = JSONObject.toJSONString(obj);
        return this.isJsonObj(str);
    }

    /**
     * 判断字符串是否json字符串
     *
     * @param str 字符串
     * @return true/false
     */
    public boolean isJson(String str) {
        if (StringUtils.hasLength(str)) {
            return false;
        }
        return this.isJsonObj(str) || this.isJsonArr(str);
    }
}

添加xss拦截工具类

package com.fir.gateway.utils;

import com.alibaba.fastjson.JSONObject;
import lombok.SneakyThrows;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.safety.Safelist;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;


/**
 * xss拦截工具类
 *
 * @author lieber
 */
public enum XssUtils {

    /**
     * 实例
     */
    INSTANCE;

    private final static String RICH_TEXT = "</";

    /**
     * 自定义白名单
     */
    private final static Safelist CUSTOM_WHITELIST = Safelist.relaxed()
//            .addAttributes("video", "width", "height", "controls", "alt", "src")
//            .addAttributes(":all", "style", "class")
            ;

    /**
     * jsoup不格式化代码
     */
    private final static Document.OutputSettings OUTPUT_SETTINGS = new Document.OutputSettings().prettyPrint(false);

    /**
     * 清除json对象中的xss攻击字符
     *
     * @param val json对象字符串
     * @return 清除后的json对象字符串
     */
    private String cleanObj(String val) {
        JSONObject jsonObject = JSONObject.parseObject(val);
        for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
            if (entry.getValue() != null && entry.getValue() instanceof String) {
                String str = (String) entry.getValue();
                str = this.cleanXss(str);
                entry.setValue(str);
            }
        }
        return jsonObject.toJSONString();
    }

    /**
     * 清除json数组中的xss攻击字符
     *
     * @param val json数组字符串
     * @return 清除后的json数组字符串
     */
    private String cleanArr(String val) {
        List<String> list = JSONObject.parseArray(val, String.class);
        List<String> result = new ArrayList<>(list.size());
        for (String str : list) {
            str = this.cleanXss(str);
            result.add(str);
        }
        return JSONObject.toJSONString(result);
    }

    /**
     * 清除xss攻击字符串，此处优化空间较大
     *
     * @param str 字符串
     * @return 清除后无害的字符串
     */
    @SneakyThrows
    public String cleanXss(String str) {
        if (JsonUtils.INSTANCE.isJsonObj(str)) {
            str = this.cleanObj(str);
        } else if (JsonUtils.INSTANCE.isJsonArr(str)) {
            str = this.cleanArr(str);
        } else {
            boolean richText = this.richText(str);
            if (!richText) {
                str = str.trim();
                str = str.replaceAll(" +", " ");
            }
            String afterClean = Jsoup.clean(str, "", CUSTOM_WHITELIST, OUTPUT_SETTINGS);
            if (paramError(richText, afterClean, str)) {
//                throw new BizRunTimeException(ApiCode.PARAM_ERROR, "参数包含特殊字符");
//                throw new Exception("参数包含特殊字符");
                System.out.println("参数包含特殊字符");
            }
            str = richText ? afterClean : this.backSpecialStr(afterClean);
        }
        return str;
    }


    /**
     * 判断是否是富文本
     *
     * @param str 待判断字符串
     * @return true/false
     */
    private boolean richText(String str) {
        return str.contains(RICH_TEXT);
    }

    /**
     * 判断是否参数错误
     *
     * @param richText   是否富文本
     * @param afterClean 清理后字符
     * @param str        原字符串
     * @return true/false
     */
    private boolean paramError(boolean richText, String afterClean, String str) {
        // 如果包含富文本字符，那么不是参数错误
        if (richText) {
            return false;
        }
        // 如果清理后的字符和清理前的字符匹配，那么不是参数错误
        if (Objects.equals(str, afterClean)) {
            return false;
        }
        // 如果仅仅包含可以通过的特殊字符，那么不是参数错误
        if (Objects.equals(str, this.backSpecialStr(afterClean))) {
            return false;
        }
        // 如果还有......
        return true;
    }

    /**
     * 转义回特殊字符
     *
     * @param str 已经通过转义字符
     * @return 转义后特殊字符
     */
    private String backSpecialStr(String str) {
        return str.replaceAll("&amp;", "&");
    }
}

防XSS-请求拦截器

package com.fir.gateway.filter.request;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fir.gateway.config.GlobalConfig;
import com.fir.gateway.config.exception.CustomException;
import com.fir.gateway.config.result.AjaxStatus;
import com.fir.gateway.utils.XssUtils;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpMethod;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;


/**
 * XSS过滤
 *
 * @author lieber
 */
@Data
@Slf4j
@ConfigurationProperties("config.form.xss")
@Component
public class XssFormFilter implements GlobalFilter, Ordered {


    /**
     * 网关参数配置
     */
    @Resource
    private GlobalConfig globalConfig;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("xss攻击验证:start");
        boolean xss = globalConfig.isXss();

        if (xss) {
            // 白名单路由判断
            ServerHttpRequest request = exchange.getRequest();
            String path = request.getPath().toString();
            List<String> whiteUrls = globalConfig.getWhiteUrls();
            if (whiteUrls.contains(path)) {
                log.info("xss攻击验证:true,白名单");
                return chain.filter(exchange);
            }


            ServerHttpRequest req = exchange.getRequest();
            String method = req.getMethodValue();

            ServerHttpRequest builder = req.mutate().build();
            if (HttpMethod.GET.matches(method)) {
                builder = change(exchange, builder);
            } else if (HttpMethod.POST.matches(method)) {
                builder = change(exchange, builder);
            }
            exchange = exchange.mutate().request(builder).build();
            log.info("xss攻击验证:true");
        } else {
            log.info("xss攻击验证:true,验证已关闭");
        }

        return chain.filter(exchange);
    }

    /**
     * 获取请求参数等信息进行过滤处理
     *
     * @param exchange          请求
     * @param serverHttpRequest 请求
     * @return 处理结束的参数
     */
    @SneakyThrows
    private ServerHttpRequest change(ServerWebExchange exchange, ServerHttpRequest serverHttpRequest) {
        // 获取原参数
        URI uri = serverHttpRequest.getURI();
        // 更改参数
        ServerHttpRequest request = exchange.getRequest();
        MultiValueMap<String, String> query = request.getQueryParams();
        String originalQuery = JSONObject.toJSONString(query);


        MultiValueMap<String, String> newQueryParams = new LinkedMultiValueMap<>();
        if (StringUtils.isNoneBlank(originalQuery)) {
            // 执行XSS清理
            log.info("{} - XSS清理,处理前参数：{}", uri.getPath(), originalQuery);
            Set<String> strings = query.keySet();
            for (String key : strings) {
                List<String> v = query.get(key);
                String newV = XssUtils.INSTANCE.cleanXss(JSONObject.toJSONString(v));
                List<String> newVList = JSONArray.parseArray(newV, String.class);
                for (String string:newVList) {
                    String encodedString = URLEncoder.encode(string, StandardCharsets.UTF_8.toString());
                    newQueryParams.add(key, encodedString);
                }
            }
             originalQuery = JSONObject.toJSONString(newQueryParams);
            log.info("{} - XSS清理,处理后参数：{}", uri.getPath(), originalQuery);
        }
        URI newUri = UriComponentsBuilder.fromUri(uri)
                .query(null)
                .queryParams(newQueryParams)
                .build(true)
                .toUri();

        return exchange.getRequest().mutate().uri(newUri).build();
    }


    @Override
    public int getOrder() {
        return -180;
    }
}

前端

身为一个后端程序员，本次终于不用再写前端代码了，难得难得。。。
此次前端无需更改任何内容。