在文件上传中防止Xss注入

已于 2023-01-03 18:57:54 修改
阅读量4.3k 收藏 12
点赞数 3
文章标签： xss java stream
于 2022-12-24 18:02:13 首次发布
欢迎流通 功德无量
本文链接：https://blog.csdn.net/fxtxz2/article/details/128429365
版权

问题

之前在《Xss过滤器（Java）》使用OWASP库了，不过当时只能防止一般rest接口，对于上传流就有点搞不定了。这里继续使用OWASP库来防止xss注入。

步骤

Maven

<properties>
	<esapi.version>2.5.1.0</esapi.version>
    <antisamy.version>1.7.2</antisamy.version>
</properties>


<dependency>
    <groupId>org.owasp.esapi</groupId>
    <artifactId>esapi</artifactId>
    <version>${esapi.version}</version>
</dependency>

<dependency>
    <groupId>org.owasp.antisamy</groupId>
    <artifactId>antisamy</artifactId>
    <version>${antisamy.version}</version>
</dependency>

Spring

过滤器

ReplaceRequestBodyFilter.java

import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class ReplaceRequestBodyFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String contentType = request.getContentType();
        if (null != contentType && contentType.contains("multipart/")) {//说明是文件上传
            XSSCommonsMultipartResolver commonsMultipartResolver = new XSSCommonsMultipartResolver();
            XSSMultipartHttpServletRequest resolveMultipart = (XSSMultipartHttpServletRequest) commonsMultipartResolver.resolveMultipart(request);
            filterChain.doFilter(resolveMultipart, response);
        } else {
            filterChain.doFilter(request, response);
        }
    }
}

XSSCommonsMultipartResolver.java

import org.springframework.util.Assert;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import javax.servlet.http.HttpServletRequest;

public class XSSCommonsMultipartResolver extends CommonsMultipartResolver {
    private boolean resolveLazily = false;
    public XSSCommonsMultipartResolver() {
        super();
    }

    @Override
    public void setResolveLazily(boolean resolveLazily) {
        this.resolveLazily = resolveLazily;
    }

    @Override
    public MultipartHttpServletRequest resolveMultipart(final HttpServletRequest request) throws MultipartException {
        Assert.notNull(request, "Request must not be null");
        if (this.resolveLazily) {
            return new XSSMultipartHttpServletRequest(request) {
                @Override
                protected void initializeMultipart() {
                    MultipartParsingResult parsingResult = parseRequest(request);
                    setMultipartFiles(parsingResult.getMultipartFiles());
                    setMultipartParameters(parsingResult.getMultipartParameters());
                    setMultipartParameterContentTypes(parsingResult.getMultipartParameterContentTypes());
                }
            };
        } else {
            MultipartParsingResult parsingResult = parseRequest(request);
            return new XSSMultipartHttpServletRequest(request, parsingResult.getMultipartFiles(),
                    parsingResult.getMultipartParameters(), parsingResult.getMultipartParameterContentTypes());
        }
    }
}

XSSMultipartHttpServletRequest.java

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.owasp.esapi.ESAPI;
import org.springframework.util.MultiValueMap;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

@Slf4j
public class XSSMultipartHttpServletRequest extends DefaultMultipartHttpServletRequest {
    public XSSMultipartHttpServletRequest(HttpServletRequest request, MultiValueMap<String, MultipartFile> mpFiles, Map<String, String[]> mpParams, Map<String, String> mpParamContentTypes) {
        super(request);
        setMultipartFiles(mpFiles);
        setMultipartParameters(mpParams);
        setMultipartParameterContentTypes(mpParamContentTypes);
    }

    public XSSMultipartHttpServletRequest(HttpServletRequest request) {
        super(request);
    }

    @Override
    protected MultiValueMap<String, MultipartFile> getMultipartFiles() {
        MultiValueMap<String, MultipartFile> result = super.getMultipartFiles();
        Set<String> keySet = result.keySet();
        for (String key : keySet) {
            List<MultipartFile> fileList = result.get(key);
            List<MultipartFile> multipartFiles = new ArrayList<>();
            for (MultipartFile file : fileList) {

                if (file!= null && file.getOriginalFilename()!= null && !file.getContentType().contains("image")) {
                    String fileName = file.getOriginalFilename();
                    try {
                        InputStream inputStream = file.getInputStream();
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
                        FileItem fileItem = new DiskFileItemFactory().createItem("file", file.getContentType(), false, fileName);
                        OutputStream os = fileItem.getOutputStream();
                        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));
                        while (bufferedReader.ready()){
                            String line = bufferedReader.readLine();
                            writer.write(stripXSS(line));
                            writer.newLine();
                        }
                        writer.flush();
                        CommonsMultipartFile commonsMultipartFile = new CommonsMultipartFile(fileItem);
                        multipartFiles.add(commonsMultipartFile);

                    } catch (IOException e) {
                        log.error("修改请求流时错误：", e);
                    }
                } else if (file!= null && file.getOriginalFilename()!= null && file.getContentType().startsWith("image")) {
                    try {
                        InputStream inputStream = file.getInputStream();
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
                        while (bufferedReader.ready()){
                            String line = bufferedReader.readLine();
                            if (StringUtils.hasText(line) && !validatorXSS(line)) {
                                throw new BaseException("无效图片，请换一张");
                            }
                        }
                        multipartFiles.add(file);

                    } catch (IOException e) {
                        log.error("修改请求流时错误：", e);
                    }
                } else {
                    multipartFiles.add(file);
                }
            }

            result.put(key, multipartFiles);

        }
        return result;
    }

   private String stripXSS(String value) {
        if (value != null) {
            // NOTE: It's highly recommended to use the ESAPI library and uncomment the following line to
            // avoid encoded attacks.
             value = ESAPI.encoder().canonicalize(value);

            // Avoid null characters
            value = value.replaceAll("", "");

            // Avoid anything between script tags
            Pattern scriptPattern = Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid anything between pdf script tags
            scriptPattern = Pattern.compile("javascript", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid anything in a src='...' type of expression
            scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");

            scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");

            // Remove any lonesome </script> tag
            scriptPattern = Pattern.compile("</script>", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");

            // Remove any lonesome <script ...> tag
            scriptPattern = Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid eval(...) expressions
            scriptPattern = Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid expression(...) expressions
            scriptPattern = Pattern.compile("expression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid javascript:... expressions
            scriptPattern = Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid vbscript:... expressions
            scriptPattern = Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid php:... expressions
            scriptPattern = Pattern.compile("<\\?php(.*?)\\?>", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");

            // Avoid οnlοad= expressions
            scriptPattern = Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
        }
        return value;
    }

    private boolean validatorXSS(String value) {
        value = ESAPI.encoder().canonicalize(value);

        // Avoid anything between script tags
        Pattern scriptPattern = Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE);
        Matcher matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid anything between pdf script tags
        scriptPattern = Pattern.compile("javascript", Pattern.CASE_INSENSITIVE);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid anything in a src='...' type of expression
        scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Remove any lonesome </script> tag
        scriptPattern = Pattern.compile("</script>", Pattern.CASE_INSENSITIVE);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Remove any lonesome <script ...> tag
        scriptPattern = Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid eval(...) expressions
        scriptPattern = Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid expression(...) expressions
        scriptPattern = Pattern.compile("expression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid javascript:... expressions
        scriptPattern = Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid vbscript:... expressions
        scriptPattern = Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }
        // Avoid php:... expressions
        scriptPattern = Pattern.compile("<\\?php(.*?)\\?>", Pattern.CASE_INSENSITIVE);
        matcher = scriptPattern.matcher(value);
        if (matcher.find()){
            return false;
        }

        // Avoid οnlοad= expressions
        scriptPattern = Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
        matcher = scriptPattern.matcher(value);
        return !matcher.find();
    }
}

这个类，才是防xss的关键。

esapi需要的配置文件

https://github.com/ESAPI/esapi-java-legacy/releases
这个页面下载esapi-2.5.1.0-configuration.jar文件，从中可以找到antisamy-esapi.xml，ESAPI.properties，esapi-java-logging.properties，validation.properties。这四个配置文件，复制到自己工程即可。

总结

到这里上传文件流防xss攻击，只需要3个类。主要是利用Spring过滤器机制来覆盖掉请求体对象。注意，一定要新建一个对象进行覆盖，而且不能关流。

参考：

亚林瓜子
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
vue xss 存在_防止XSS脚本注入-前端vue、后端springboot
weixin_35952534的博客
01-15 1752
防止XSS脚本注入-前端、后端作者时间雨中星辰2020-09-10xss是什么跨站脚本攻击(XSS)，是目前最普遍的Web应用安全漏洞。这类漏洞能够使得攻击者嵌入恶意脚本代码到正常用户会访问到的页面中，当正常用户访问该页面时，则可导致嵌入的恶意脚本代码的执行，从而达到恶意攻击用户的目的。xss脚本注入演示通过表单，先添加一个数据，其中一条数据为脚本插入数据刷新页面刷新页面从截图看，注入的脚本已经执...
关于pdf文件xss攻击问题，配置xssFilter方法
12-21
在SpringBoot应用中配置XSSFilter，可以确保传入和传出的数据都经过安全处理，防止XSS攻击的发生。 配置XSSFilter通常涉及以下几个步骤： 1. 添加依赖：确保项目中已经包含了Spring Security或者类似的过滤器库，...
Java防止xss攻击附相关文件下载
08-25
首先说一下思路，防止这种类似于注入攻击，就是使用拦截器（Filter）处理特殊字符或过滤特殊字符 今天介绍一个方法，利用覆盖Servlet的getParameter方法达到处理特殊字符的目的来解决（防止）Xss攻击 web.xml,需要的朋友可以参考下
ESAPI自定义配置文件路径
最新发布
青春不打烊的博客
07-05 1339
文章目录 前言一、pom依赖 <dependency> <groupId>org.owasp.esapi</groupId> <artifactId>esapi</artifactId> <version>2.2.3.0</version> <!-- 如果项目中没有引入其他日志框架，可以不排除 -->
【PDF-XSS攻击】Java项目-上传文件-解决PDF文件XSS攻击
起而行动，方能平定心中的惶恐
04-07 4806
Java项目-上传文件-解决PDF文件XSS攻击
防止XSS（Cross Site Scripting）攻击，防止在提交表单时注入Script
08-10 765
1.概念 XSS攻击全称跨站脚本攻击，是为不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆，故将跨站脚本攻击缩写为XSS，XSS是一种在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。 2.故事的起源...
文件上传（xss）
weixin_50446974的博客
05-22 2869
我们平时在拿webshell的时候 最为常见的就是找到上传点进行文件上传 一句话木马或者说是用图片马 然后用websell管理工具进行连接（菜刀，蚁剑等等） 当然拿webshell的方式方法有许多 我这里以文件上传为例，好吧 通常一般的网站，都是以白名单，因为白名单比黑名单更加安全。这是肯定的。但是不乏有以黑名单的网站 这个不是绝对的，这是相对的 在目标网站后台文件上传点，假如说是以黑名单的方式 除了我们知道的绕过方式 像前端进行校验，我们通过burp进行抓包改后缀名.还可以通过文件.
技术分享：如何利用文件上传执行XSS
Fly_鹏程万里
12-17 4206
利用文件上传实现XSS攻击是一个Hacking Web应用的很好机会，特别是无处不在的用户头像上传案例中，这就给予我们很多发现开发者错误的机会。基本的文件上传 XSS 攻击有以下几种。 1) 文件名 文件名本身可能就是网页的一部分可以造成反射，所以可以通过将 XSS 语句插入文件名中来触发反射。 尽管不是有意为之，但是这个 XSS 可以实践在 W3Schools。 2) 元数据 使用...
SpringBoot +esapi 实现防止xss攻击 实战代码
11-25
在实际项目中，你可能还需要根据具体需求进行调整，例如添加对JSON响应的编码、处理文件上传时的输入验证等。同时，不要忘记定期更新ESAPI库，以获取最新的安全修复和改进。 通过这种方式，我们可以确保用户输入被...
springmvc4配置防止XSS攻击的方法
04-05
在Spring MVC中防止XSS攻击的基本方法之一是通过实现过滤器来包装HttpServletRequest对象。具体地，需要创建一个包装类XssHttpServletRequestWrapper，用于覆盖HttpServletRequest的方法，对所有进入的请求数据进行...
.net core xss攻击防御的方法
10-18
在.NET Core框架中，防御XSS攻击通常会用到HtmlSanitizer库，这是一个帮助开发者清理HTML内容，防止XSS攻击的工具。HtmlSanitizer通过配置白名单的方式来允许特定的标签、属性或CSS样式，从而有效地过滤掉潜在的XSS...
通过文件上传的 XSS
黑剑
09-19 826
我们可以在标准配置的 Jetty 服务器上实现 XSS，不仅可以上传众所周知的 .html 或 .svg 文件，还可以上传其他扩展名不太流行的文件。
[风一样的创作]防XSS注入攻击
fyydrs的博客
12-29 1748
一.首先大概理解下什么是XSS注入攻击 XSS注入攻击本质上就是通过你服务本身的接口把一些HTML,CSS,JS,SQL语句等内容存储进你的服务里面，一般是数据库里面，这时候就可以通过这些存储进去的内容拿取到一些你的数据库隐藏内容或者破坏你的页面排版，比如乱弹窗。 二.解决的方法 首先声明，解决方案不止这一种，这只是最简单的一种 1.使用拦截器拦截所有请求，一定要在最顶层 import org.springframework.boot.web.servlet.ServletComponentScan; im
XSS姿势——文件上传XSS
haha1314的博客
04-22 3850
XSS姿势——文件上传XSS 文件上传xss，一般都是上传html文件导致存储或者反射xss，一般文件内容都是html。 1、把以下代码写入文件，后缀改成图片格式。 <html> <body> <img src=1 onerror=alert(1)> </body> </html> 2、或者将后缀名改为htm...
防止XSS注入的一种实现方式
a64540339的专栏
11-13 1572
xss表示Cross Site Scripting(跨站脚本攻击)，它与SQL注入攻击类似，SQL注入攻击中以SQL语句作为用户输入，从而达到查询/修改/删除数据的目的，而在xss攻击中，通过插入恶意脚本，实现对用户游览器的控制。   比如说在表单input里输入&lt;script&gt;alert("xss")&lt;/script&gt; 然后提交，就会在页面弹出窗口，所以我们就要过...
web安全之文件上传漏洞攻击与防范方法
热门推荐
u014609111的博客
09-29 5万+
一、 文件上传漏洞与WebShell的关系 文件上传漏洞是指网络攻击者上传了一个可执行的文件到服务器并执行。这里上传的文件可以是木马，病毒，恶意脚本或者WebShell等。这种攻击方式是最为直接和有效的，部分文件上传漏洞的利用技术门槛非常的低，对于攻击者来说很容易实施。 文件上传漏洞本身就是一个危害巨大的漏洞，WebShell更是将这种漏洞的利用无限扩大。大多数的上传漏洞被利用后攻击者都会留下
java实现xss防注入
夏微凉秋微暖的博客
01-17 945
1.在web.xml添加一个filter XssFilter com.upload.filter.XssFilter XssFilter /* REQUEST 2.新建一个filter package com.upload.filte
文件上传漏洞攻击与防范方法
留白空间
08-29 3668
https://blog.csdn.net/m0_38103658/article/details/100162185 文件上传漏洞攻击与防范方法 文件上传漏洞简介： 文件上传漏洞是web安全中经常用到的一种漏洞形式。是对数据与代码分离原则的一种攻击。上传漏洞顾名思义，就是攻击者上传了一个可执行文件如木马，病毒，恶意脚本，WebShell等到服务器执行，并最终获得网站控制权限的高危漏洞。 文件上传漏洞危害： 上传漏洞与SQL注入或 XSS相比 , 其风险更大 , 如果 Web应用程序存在上传漏洞 , 攻击者
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值