SpringBoot 该如何预防 XSS 攻击

这篇具有很好参考价值的文章主要介绍了SpringBoot 该如何预防 XSS 攻击。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

XSS 漏洞到底是什么,说实话我讲不太清楚。但是可以通过遇到的现象了解一下。在前端Form表单的输入框中,用户没有正常输入,而是输入了一段代码:</input><img src=1 onerror=alert1> 这个正常保存没有问题。问题出在了列表查询的时候,上面的代码就生效了,由于图片的地址乱写的,所以这个alert就起作用了来看图。

SpringBoot 该如何预防 XSS 攻击,spring,java,设计,spring boot,xss,后端

 

那根据这个原理,实际上如果没有做任何的限制,有心人就可以为所欲为了。可以在里面嵌入一些关键代码,把你的信息拿走。确实是个很严重的问题。

解决思路

既然是因为输入框中输入了不该输入的东西,那自然就萌生一些想法:

  • 校验输入内容,不允许用户输入特殊字符,特殊标签

  • 允许用户输入,但是保存的时候将特殊的字符直接替换为空串

  • 允许用户输入,将特殊字符转译保存。

第一种方法,特殊字符过滤。既然要过滤特殊字符,那就得自己把所有的特殊字符列出来进行匹配,比较麻烦,而且要定义好什么才是特殊字符?况且用户本身不知道什么是特殊字符。突如其来的报错,会让用户有点摸不着头脑,不是很友好。

第二种方法,特殊字符替换为空串。未免有点太暴力。万一真的需要输入一点特殊的字符,保存完查出来发现少了好多东西,人家以为我们的BUG呢。也不是很好的办法。

第三种办法,特殊字符转译。这个办法不但用户数据不丢失,而且浏览器也不会执行代码。比较符合预期。

那办法确定了,怎么做呢?前端来做还是后端来做?想了想还是要后端来做。毕竟使用切面或者Filter可以一劳永逸。

心路历程

经过抄袭,我发现了一些问题,也渐渐的有了一些理解。下面再说几句废话:

查到的预防XSS攻击的,大多数的流程是:

  • 拦截请求

  • 重新包装请求

  • 重写HttpServletRequest中的获取参数的方法

  • 将获得的参数进行XSS处理

  • 拦截器放行

于是我就逮住一个抄了一下。抄袭完毕例行测试,发现我用@RequestBody接受的参数,并不能过滤掉特殊字符。怎么肥四?大家明明都这么写。为什么我的不好使?

这个时候突然一个想法萌生。SpringMVC在处理@RequestBody类型的参数的时候,是不是使用的我重写的这些方法呢?(getQueryString()getParameter(String name)getParameterValues(String name)getParameterMap())。打了个日志,发现还真不是这些方法。

于是搜索了一下Springboot拦截器获取@RequestBody参数,碰到了这篇文章。首先的新发现是Spring MVC 在获取@RequestBody参数的时候使用的是getInputStream()方法。嗯?(斜眼笑)那我是不是可以重写这个方法获取到输入流的字符串,然后直接处理一下?

说干就干,一顿操作。进行测试。发现直接JSON 转换的报错了。脑裂。估计是获得的字符串在转换的时候把不该转的东西转译了,导致不能序列化了。眼看就要成功了,一测回到解放前。

该怎么办呢?其实思路是没错的,就是在获取到流之后进行处理。但是错就错在处理的位置。果然处理的时间点很重要。(就像伴侣一样,某人出现的时间点很重要)。那既然不能在现在处理,那就等他序列化完毕之后再处理就好了。那怎么办呢?难道要写一个AOP 拦截到所有的请求?用JAVA反射处理?

正在迷茫的时候,看到了一篇文章,知识增加了。原来可以在序列化和反序列化的时候进行处理。

最终实现

看一下最终的代码实现(有些导入的包被我删了)

重新包装Request的代码
import org.apache.commons.text.StringEscapeUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Map;

/**
 * 重新包装一下Request。重写一些获取参数的方法,将每个参数都进行过滤
 */
public class XSSHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private static final Logger logger = LoggerFactory.getLogger(XSSHttpServletRequestWrapper.class);

    private HttpServletRequest request;
    /**
     * 请求体 RequestBody
     */
    private String reqBody;

    /**
     * Constructs a request object wrapping the given request.
     *
     * @param request The request to wrap
     * @throws IllegalArgumentException if the request is null
     */
    public XSSHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        logger.info("---xss XSSHttpServletRequestWrapper created-----");
        this.request = request;
        reqBody = getBodyString();
    }


    @Override
    public String getQueryString() {
        return StringEscapeUtils.escapeHtml4(super.getQueryString());
    }

    /**
     * The default behavior of this method is to return getParameter(String
     * name) on the wrapped request object.
     *
     * @param name
     */
    @Override
    public String getParameter(String name) {
        logger.info("---xss XSSHttpServletRequestWrapper work  getParameter-----");
        String parameter = request.getParameter(name);
        if (StringUtil.isNotBlank(parameter)) {
            logger.info("----filter before--name:{}--value:{}----", name, parameter);
            parameter = StringEscapeUtils.escapeHtml4(parameter);
            logger.info("----filter after--name:{}--value:{}----", name, parameter);
        }
        return parameter;
    }

    /**
     * The default behavior of this method is to return
     * getParameterValues(String name) on the wrapped request object.
     *
     * @param name
     */
    @Override
    public String[] getParameterValues(String name) {
        logger.info("---xss XSSHttpServletRequestWrapper work  getParameterValues-----");
        String[] parameterValues = request.getParameterValues(name);
        if (!CollectionUtil.isEmpty(parameterValues)) {
         // 经 “@Belief_7” 指正 这种方式不能更改parameterValues里面的值,要换成下面👇的写法
            //for (String value : parameterValues) {
            //    logger.info("----filter before--name:{}--value:{}----", name, value);
            //    value = StringEscapeUtils.escapeHtml4(value);
            //    logger.info("----filter after--name:{}--value:{}----", name, value);
            // }
            for (int i = 0; i < parameterValues.length; i++) 
         { 
             parameterValues[i] = StringEscapeUtils.escapeHtml4(parameterValues[i]); 
         } 
        }
        return parameterValues;
    }

    /**
     * The default behavior of this method is to return getParameterMap() on the
     * wrapped request object.
     */
    @Override
    public Map<String, String[]> getParameterMap() {
        logger.info("---xss XSSHttpServletRequestWrapper work  getParameterMap-----");
        Map<String, String[]> map = request.getParameterMap();
        if (map != null && !map.isEmpty()) {
            for (String[] value : map.values()) {
                /*循环所有的value*/
                for (String str : value) {
                    logger.info("----filter before--value:{}----", str, str);
                    str = StringEscapeUtils.escapeHtml4(str);
                    logger.info("----filter after--value:{}----", str, str);
                }
            }
        }
        return map;
    }

    /*重写输入流的方法,因为使用RequestBody的情况下是不会走上面的方法的*/
    /**
     * The default behavior of this method is to return getReader() on the
     * wrapped request object.
     */
    @Override
    public BufferedReader getReader() throws IOException {
        logger.info("---xss XSSHttpServletRequestWrapper work  getReader-----");
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    /**
     * The default behavior of this method is to return getInputStream() on the
     * wrapped request object.
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        logger.info("---xss XSSHttpServletRequestWrapper work  getInputStream-----");
        /*创建字节数组输入流*/
        final ByteArrayInputStream bais = new ByteArrayInputStream(reqBody.getBytes(StandardCharsets.UTF_8));
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener listener) {
            }

            @Override
            public int read() throws IOException {
                return bais.read();
            }
        };
    }


    /**
     * 获取请求体
     *
     * @return 请求体
     */
    private String getBodyString() {
        StringBuilder builder = new StringBuilder();
        InputStream inputStream = null;
        BufferedReader reader = null;

        try {
            inputStream = request.getInputStream();

            reader = new BufferedReader(new InputStreamReader(inputStream));

            String line;

            while ((line = reader.readLine()) != null) {
                builder.append(line);
            }
        } catch (IOException e) {
            logger.error("-----get Body String Error:{}----", e.getMessage(), e);
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    logger.error("-----get Body String Error:{}----", e.getMessage(), e);
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    logger.error("-----get Body String Error:{}----", e.getMessage(), e);
                }
            }
        }
        return builder.toString();
    }
}
定义过滤器
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * Filter 过滤器,拦截请求转换为新的请求
 */
public class XssFilter implements Filter {
    private static final Logger logger = LoggerFactory.getLogger(XssFilter.class);

    /**
     * 初始化方法
     */
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        logger.info("----xss filter start-----");
    }
    /**
     * 过滤方法
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ServletRequest wrapper = null;
        if (request instanceof HttpServletRequest) {
            HttpServletRequest servletRequest = (HttpServletRequest) request;
            wrapper = new XSSHttpServletRequestWrapper(servletRequest);
        }

        if (null == wrapper) {
            chain.doFilter(request, response);
        } else {
            chain.doFilter(wrapper, response);
        }
    }
}
注册过滤器

注册过滤器我了解到的有两种方式。我用的下面的这种

一种通过@WebFilter注解的方式来配置,但这种启动类上要加@ServletComponentScan 注解来指定扫描路径

另外一种就是以Bean 的方式来注入(不知道放哪里,就把Bean放到启动类里面)

/**
 * XSS 的Filter注入
 * 用来处理getParameter的参数
 * @return
 */
@Bean
public FilterRegistrationBean xssFilterRegistrationBean(){
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    filterRegistrationBean.setFilter(new XssFilter());
    filterRegistrationBean.setOrder(1);
    filterRegistrationBean.setDispatcherTypes(DispatcherType.REQUEST);
    filterRegistrationBean.setEnabled(true);
    filterRegistrationBean.addUrlPatterns("/*");
    return filterRegistrationBean;
}

上面配的是使用request.getParameter()的时候生效的,但是当我使用@RequestBody来接收参数的时候是不行的,所以还得有下面的代码:

处理请求中的JSON数据
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import org.apache.commons.text.StringEscapeUtils;
import java.io.IOException;

/**
 * 反序列化,用来处理请求中的JSON数据
 * 处理RequestBody方式接收的参数
 */
public class XssJacksonDeserializer extends JsonDeserializer<String> {

    @Override
    public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        return StringEscapeUtils.escapeHtml4(jp.getText());
    }
}
处理返回值的JSON数据
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.apache.commons.text.StringEscapeUtils;
import java.io.IOException;


/**
 * 处理向前端发送的JSON数据,将数据进行转译后发送
 */
public class XssJacksonSerializer extends JsonSerializer<String> {
    @Override
    public void serialize(String value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeString(StringEscapeUtils.escapeHtml4(value));
    }
}
注册、配置自定义的序列化方法
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
 Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
 ObjectMapper mapper = builder.build();
 /*注入自定义的序列化工具,将RequestBody的参数进行转译后传输*/
    SimpleModule simpleModule = new SimpleModule();
    // XSS序列化
    simpleModule.addSerializer(String.class, new XssJacksonSerializer());
    simpleModule.addDeserializer(String.class, new XssJacksonDeserializer());
    mapper.registerModule(simpleModule);
    converters.add(new MappingJackson2HttpMessageConverter(mapper));
}
测试

所有东西都配置完了,接下来进行愉快的测试阶段了。

我依然在输入框中输入这段代码</input><img src=1 onerror=alert1>并进行保存。来看一下数据库中的保存结果:

SpringBoot 该如何预防 XSS 攻击,spring,java,设计,spring boot,xss,后端

图片

可以看到数据库中保存的数据,已经经过转译了。那查询一下列表是什么样的呢?

SpringBoot 该如何预防 XSS 攻击,spring,java,设计,spring boot,xss,后端

可以看到两条数据,上面的是我们经过转译的,正常的展示出来了。而下面的是没经过转译的,直接空白,并且给我弹了个窗。

总结

  • 就是注意要分情况处理。

  • 拦截器处理一部分,并注意拦截器的注册方式

  • Jackson的方式处理另一部分,也是注意配置方式

补充

代码经过验证后,发现了一个问题。今天来补充一下。问题是这样的:

如果使用@RequestBody的形式接受参数,也就是需要使用自定义的序列化方式。然而有时候,我们的业务需要传递一些JSON串到后端,如{\"username\":\"zx\",\"pwd\":\"123\"}(注意这是个字符串)。但是因为我不管三七二十一直接暴力转译,导致里面的双引号以及其他符号都被转译了。那么当我们拿到这个字符串之后,再自己反序列化的时候就会出错了。

为了解决这个问题,我在自定义的序列化方法中判断了一下这个字段的值是否是JSON形式,如果是JSON形式,那就不做处理,直接返回,以保证能够顺利反序列化。判断是否是JSON的方式,我选择最简单的,判断首尾是否是{ } [ ]的组合。代码如下:

public class XssJacksonDeserializer extends JsonDeserializer<String> {

    @Override
    public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        // 判断一下 值是不是JSON的格式,如果是JSON的话,那就不处理了。
        /*判断JSON,可以用JSON.parse但是所有字段都Parse一下,未免有点太费性能,所以粗浅的认为,不是以{ 或者[ 开头的文本都不是JSON*/
        if (isJson(jp.getText())) {
            return jp.getText();
        }
        return StringEscapeUtils.escapeHtml4(jp.getText());
    }


    /**
     * 判断字符串是不是JSON
     *
     * @param str
     * @return
     */
    private boolean isJson(String str) {
        boolean result = false;
        if (StringUtil.isNotBlank(str)) {
            str = str.trim();
            if (str.startsWith("{") && str.endsWith("}")) {
                result = true;
            } else if (str.startsWith("[") && str.endsWith("]")) {
                result = true;
            }
        }
        return result;
    }
}

但是经过这样的改动之后,可能又没那么安全了。所以还是要看自己的取舍了。文章来源地址https://www.toymoban.com/news/detail-639516.html

到了这里,关于SpringBoot 该如何预防 XSS 攻击的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 如何预防CSRF攻击

    CSRF(Cross-Site Request Forgery)攻击是一种常见的 Web 攻击,即攻击者在用户不知情的情况下,利用用户已登录的身份,向目标网站发送恶意请求,从而实现攻击目的。本文将介绍 CSRF 攻击的原理和常见的防范措施,以帮助 Web 开发者更好地保护用户信息安全。 CSRF 攻击的原理比较

    2024年02月09日
    浏览(55)
  • 如何预防ssl中间人攻击?

    当我们连上公共WiFi打开网页或邮箱时,殊不知此时可能有人正在监视着我们的各种网络活动。打开账户网页那一瞬间,不法分子可能已经盗取了我们的银行凭证、家庭住址、电子邮件和联系人信息,而这一切我们却毫不知情。这是一种网络上常见的“中间人攻击”,通过拦截

    2024年02月13日
    浏览(35)
  • SpringBoot防Xss攻击

    这几天自己学习了一下SpringBoot项目怎么预防Xss攻击,这里记录一下怎么防止Xss攻击的代码,等以后有需要用到的话,自己可以快速找到。 这里需要注意的是1.5到1.9版本有高危漏洞,需要升级到1.10.0以上版本,这是当前时间最新的版本。 处理非application/json提交方式使用下面二

    2024年02月05日
    浏览(42)
  • SpringBoot 防护XSS攻击

    目录 一、前言 1.1、XSS攻击流程 1.2、XSS攻击分类 1.3、攻击方式 二、解决方案 2.1、SPRINGBOOT XSS过滤插件(MICA-XSS) 2.2、MICA-XSS 配置 三、项目实战 3.1、项目环境 3.2、测试 3.2.1、测试GET请求 3.2.2、测试POST请求 3.2.3、测试POST请求 四、MICA-XSS 原理剖析 4.1、MICA-XSS 源码 XSS攻击 又称

    2024年02月13日
    浏览(56)
  • JAVA-添加HTTP响应头预防XXS攻击

    方案一:在web.config中配置 方案二:自定义filter

    2024年02月11日
    浏览(26)
  • 什么是0day漏洞?如何预防0day攻击?

    0day漏洞,是指已经被发现,但是还未被公开,同时官方还没有相关补丁的漏洞;通俗的讲,就是除了黑客,没人知道他的存在,其往往具有很大的突发性、破坏性、致命性。 0day漏洞之所以称为0day,正是因为其补丁永远晚于攻击。所以攻击者利用0day漏洞攻击的成功率极高,

    2024年02月01日
    浏览(34)
  • 【python】深入探讨flask是如何预防CSRF攻击的

    ✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯,先赞后看哦~🎈🎈 🏆 作者简介:景天科技苑 🏆《头衔》:大厂架构师,华为云开发者社区专家博主,阿里云开发者社区专家博主,CSDN全栈领域优质创作者,掘金优秀博主,51CTO博客专家等。 🏆《博客》:Python全栈,

    2024年04月14日
    浏览(31)
  • 【 安全】什么是CSRF攻击?如何避免?开发的时候怎么预防?

    CSRF定义: 跨站请求伪造(英语:Cross-site request forgery)是一种对网站的恶意利用,也被称为 one-click attack 或者 session riding,通常缩写为 CSRF 或者 XSRF, 是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法。 CSRF跨站点请求伪造(Cross—Site Request Forgery) 跟

    2024年03月14日
    浏览(85)
  • Springboot 实战一个依赖解决XSS攻击

    XSS : Cross Site Scripting,为不和层叠样式表(Cascading Style Sheets, CSS) 的缩写混淆,故将跨站脚本攻击缩写为XSS。 恶意攻击者往Web页面里插入恶意Script代码,当用户浏览该页之时,嵌入其中 Web里面的Script代码会被执行,从而达到恶意攻击用户的目的。 在一开始的时候,这种攻击的

    2024年02月03日
    浏览(42)
  • 安全攻防实战丨如何预防利用中间人攻击进行小程序刷分

    本文分享自华为云社区《【安全攻防】深入浅出实战系列专题-利用中间人攻击进行小程序刷分》,作者: MDKing 。 中间人攻击(Man-in-the-middle attack,简称MITM)是攻击者在进行网络通信的双方中间,分别与两端建立独立的联系,并进行数据嗅探甚至篡改,而通信的双方却对中

    2024年02月08日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包