SpringBoot针对富文本和非富文本添加xss过滤

最新推荐文章于 2023-05-12 17:12:17 发布
最新推荐文章于 2023-05-12 17:12:17 发布
阅读量3.3k 收藏 20
点赞数 1
分类专栏： springboot 文章标签： java xss
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChOLg/article/details/119949942
版权

一、SpringBoot针对富文本和非富文本添加xss过滤（如果富文本字段是唯一，这里的唯一是不跟非富文本字段同名，实际写一个HttpServletRequestWrapper就行）

1.xss过滤器

package com.doctortech.tmc.filter;

import com.doctortech.tmc.support.xss.XssHttpServletRequestWrapper;
import com.doctortech.tmc.support.xss.XssRichTextHttpServletRequestWrapper;
import org.springframework.stereotype.Component;

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

/**
 * @author zxb
 * @version 1.0
 * @date 2021/08/10 11:43
 * @description xss过滤器
 */
@WebFilter
@Component
public class XssFilter implements Filter {

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

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //获取请求数据
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        //获取请求的url路径
        String path = ((HttpServletRequest) servletRequest).getServletPath();
        //声明要被忽略请求的数组
        String[] exclusionsUrls = {"/fileUpload/upload","/fileUpload/upload/img"};
        //声明带有富文本的接口数组
        String[] richTextUrls = {"/admin/adminArticle/add", "/admin/adminArticle/update", "/admin/adminPolicy/add"};
        //第一种xss过滤
        XssRichTextHttpServletRequestWrapper xssAndSqlHttpServletRequestWrapper = new XssRichTextHttpServletRequestWrapper(req);
        //遍历忽略的请求数组，若该接口url为忽略的就调用原本的过滤器，不走xss过滤
        for (String str : exclusionsUrls) {
            if (path.contains(str)) {
                filterChain.doFilter(servletRequest, servletResponse);
                return;
            }
        }
        //若为带有富文本的接口，走富文本xss过滤
        for (String rtu : richTextUrls) {
            if (path.contains(rtu)) {
                filterChain.doFilter(xssAndSqlHttpServletRequestWrapper, servletResponse);
                return;
            }
        }
        //将请求放入XSS请求包装器中，返回过滤后的值
        XssHttpServletRequestWrapper xssRequestWrapper = new XssHttpServletRequestWrapper(req);
        filterChain.doFilter(xssRequestWrapper, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

2.针对富文本接口进行过滤

package com.doctortech.tmc.support.xss;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;

/**
 * @author zxb
 * @version 1.0
 * @date 2021/08/10 10:58
 * @description XSS过滤(针对含富文本变量的接口进行过滤)
 */
public class XssRichTextHttpServletRequestWrapper extends HttpServletRequestWrapper {
    /**
     * 声明sql注入的关键词key
     */
    private static String sqlKey = "and|exec|insert|select|delete|update|count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+";
    /**
     * 声明富文本字段，多个请用”|“分隔开
     */
    private static String richTextKey = "content";
    private static Set<String> notAllowedKeyWords = new HashSet<>(0);
    private static Set<String> richTextKeySet = new HashSet<>(0);

    /**
     * 初始化sql注入关键词
     */
    static {
        String[] keyStr = sqlKey.split("\\|");
        //将key添加到Set集合中
        for (String str : keyStr) {
            notAllowedKeyWords.add(str);
        }
    }

    /**
     * 初始化富文本字段
     */
    static {
        String[] keyStr = richTextKey.split("\\|");
        //将key添加到Set集合中
        for (String str : keyStr) {
            richTextKeySet.add(str);
        }
    }

    /**
     * 构造函数
     * @param request
     */
    public XssRichTextHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    /**
     * 重写getParameter
     * @param name
     * @return
     */
    @Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        if (!StringUtils.isEmpty(value)) {
            value = cleanXSS(value);
            value = cleanSqlKeyWords(value);
        }
        return value;
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] parameterValues = super.getParameterValues(name);
        if (parameterValues == null) {
            return null;
        }
        for (int i = 0; i < parameterValues.length; i++) {
            String value = parameterValues[i];
            parameterValues[i] = cleanXSS(value);
            parameterValues[i] = cleanSqlKeyWords(parameterValues[i]);
        }
        return parameterValues;
    }

    @Override
    public String getHeader(String name) {
        //过滤xss攻击
        String value = cleanXSS(super.getHeader(name));
        if (value == null){
            return null;
        }
        //过滤sql注入
        return cleanSqlKeyWords(value);
    }

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

    /**
     * 过滤json数据中xss攻击
     * @return
     * @throws IOException
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        //调用方法将流数据return为String
        String bodyStr = getRequestBody(super.getInputStream());
        //如果bodyStr为""，则返回0
        if ("".equals(bodyStr)) {
            return new ServletInputStream() {
                @Override
                public int read() throws IOException {
                    return 0;
                }

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

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

                @Override
                public void setReadListener(ReadListener readListener) {

                }
            };
        }

        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bodyStr.getBytes());
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }

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

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }

        };
    }

    /**
     * 获取json数据
     * @param stream
     * @return
     */
    private String getRequestBody(InputStream stream) {
        String line = "";
        StringBuilder body = new StringBuilder();
        int counter = 0;
        // 读取POST提交的数据内容
        BufferedReader reader = new BufferedReader(new InputStreamReader(stream, Charset.forName("UTF-8")));
        try {
            while ((line = reader.readLine()) != null) {
                //拼接读取到的数据
                body.append(line);
                counter++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (body == null) {
            return "";
        }
        //最后返回数据
        String data = transJsonNode(body.toString());
        return data;
    }

    /**
     * xss过滤
     * @param valueP
     * @return
     */
    private String cleanXSS(String valueP) {
        if (StringUtils.isBlank(valueP)) {
            return "";
        }
        String value = valueP.replaceAll("<[\\s]*?script[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?script[\\s]*?>", "");
        value = value.replaceAll("<[\\s]*?javascript[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?javascript[\\s]*?>", "");
        value = value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
        value = value.replaceAll("eval\\((.*)\\)", "");
        value = value.replaceAll("alert", "");
        value = cleanSqlKeyWords(value);
        return value;
    }

    /**
     * 过滤富文本中的xss
     * @param valueP
     * @return
     */
    private String cleanRichTextXSS(String valueP) {
        if (StringUtils.isBlank(valueP)) {
            return "";
        }
        String value = valueP.replaceAll("eval\\((.*)\\)", "");
        value = value.replaceAll("<[\\s]*?script[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?script[\\s]*?>", "");
        value = value.replaceAll("<[\\s]*?javascript[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?javascript[\\s]*?>", "");
        value = value.replaceAll("alert", "");
        value = cleanSqlKeyWords(value);
        return value;
    }

    /**
     * 过滤sql关键字，避免sql注入
     * @param value
     * @return
     */
    private String cleanSqlKeyWords(String value) {
        String paramValue = value;
        //暂时不过滤sql关键字
//        for (String keyword : notAllowedKeyWords) {
//            if (paramValue.length() > keyword.length() + 4
//                    && (paramValue.contains(" "+keyword)||paramValue.contains(keyword+" ")||paramValue.contains(" "+keyword+" "))) {
//                paramValue = StringUtils.replace(paramValue, keyword, replacedString);
//            }
//        }
        return paramValue;
    }

    /**
     * 将json字符串数据转成json树，再深度遍历去除xss
     * @param jsonStr json字符串
     * @return
     */
    private String transJsonNode(String jsonStr) {
        String str = "";
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readTree(jsonStr);
            str = objectMapper.writeValueAsString(cleanJsonNodeXSS(jsonNode));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 对json树深度遍历去除xss
     * @param jsonNode json树
     * @return
     */
    private Object cleanJsonNodeXSS(JsonNode jsonNode) {
        Iterator<Map.Entry<String, JsonNode>> fields = jsonNode.fields();
        if (!fields.hasNext()) {
            String value = jsonNode.asText();
            return cleanXSS(value);
        }
        Map<String, Object> map = new HashMap<>();
        while(fields.hasNext()) {
            Map.Entry<String, JsonNode> next = fields.next();
            if (next.getValue().isTextual()) {
                String value = next.getValue().asText();
                String key = next.getKey();
                //如果key=富文本字段名，进行特殊过滤
                String str = "";
                if (richTextKeySet.contains(key)) {
                    str = cleanRichTextXSS(value);
                } else {
                    str = cleanXSS(value);
                }
                map.put(next.getKey(),str);
            }else if (next.getValue().isObject()){
                map.put(next.getKey(),cleanJsonNodeXSS(next.getValue()));
            }else if(next.getValue().isArray()) {
                List<Object> elementList = new ArrayList<>();
                Iterator<JsonNode> elements = next.getValue().elements();
                while (elements.hasNext()) {
                    JsonNode childrenNext = elements.next();
                    Object nodeMap = cleanJsonNodeXSS(childrenNext);
                    elementList.add(nodeMap);
                }
                map.put(next.getKey(),elementList);
            }else {
                map.put(next.getKey(),next.getValue());
            }
        }
        return map;
    }
}

2.针对非富文本接口过滤

package com.doctortech.tmc.support.xss;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;

/**
 * @author zxb
 * @version 1.0
 * @date 2021/08/10 11:29
 * @description xss过滤(针对不含富文本变量的接口进行过滤)
 */
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper  {
    private static String key = "and|exec|insert|select|delete|update|count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+";
    private static Set<String> notAllowedKeyWords = new HashSet<String>(0);

    /**
     * 初始化sql注入关键词
     */
    static {
        String[] keyStr = key.split("\\|");
        for (String str : keyStr) {
            notAllowedKeyWords.add(str);
        }
    }

    /**
     * 构造函数
     * @param servletRequest
     * @throws IOException
     */
    public XssHttpServletRequestWrapper(HttpServletRequest servletRequest) throws IOException {
        super(servletRequest);
    }

    /**
     * 重写getInputStream方法，过滤json数据
     * @return
     * @throws IOException
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        String bodyStr = getRequestBody(super.getInputStream());
        if ("".equals(bodyStr)) {
            return new ServletInputStream() {
                @Override
                public int read() throws IOException {
                    return 0;
                }

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

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

                @Override
                public void setReadListener(ReadListener readListener) {

                }
            };
        }
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bodyStr.getBytes());
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }

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

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }

        };
    }

    /**
     * 获取json数据
     * @param stream
     * @return
     */
    private String getRequestBody(InputStream stream) {
        String line = "";
        StringBuilder body = new StringBuilder();
        // 读取POST提交的数据内容
        BufferedReader reader = new BufferedReader(new InputStreamReader(stream, Charset.forName("UTF-8")));
        try {
            while ((line = reader.readLine()) != null) {
                //拼接读取到的数据
                body.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (body == null) {
            return "";
        }
        //最后返回数据
        String data = transJsonNode(body.toString());
        return data;
    }

    /**
     * 将容易引起xss漏洞的半角字符替换成全角字符
     * @param s
     * @param type
     * @return
     */
    private static String xssEncode(String s, int type) {
        if (s == null || s.isEmpty()) {
            return s;
        }
        StringBuilder sb = new StringBuilder(s.length() + 16);
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (type == 0) {
                switch (c) {
                    case '\'':
                        // 全角单引号
                        sb.append('‘');
                        break;
                    case '\"':
                        // 全角双引号
                        sb.append('“');
                        break;
                    case '>':
                        // 全角大于号
                        sb.append('＞');
                        break;
                    case '<':
                        // 全角小于号
                        sb.append('＜');
                        break;
                    case '&':
                        // 全角&符号
                        sb.append('＆');
                        break;
                    case '\\':
                        // 全角斜线
                        sb.append('＼');
                        break;
                    case '#':
                        // 全角井号
                        sb.append('＃');
                        break;
                    // < 字符的 URL 编码形式表示的 ASCII 字符（十六进制格式） 是: %3c
                    case '%':
                        processUrlEncoder(sb, s, i);
                        break;
                    default:
                        sb.append(c);
                        break;
                }
            } else {
                switch (c) {
                    case '>':
                        // 全角大于号
                        sb.append('＞');
                        break;
                    case '<':
                        // 全角小于号
                        sb.append('＜');
                        break;
                    case '&':
                        // 全角&符号
                        sb.append('＆');
                        break;
                    case '#':
                        // 全角井号
                        sb.append('＃');
                        break;
                    // < 字符的 URL 编码形式表示的 ASCII 字符（十六进制格式） 是: %3c
                    case '%':
                        processUrlEncoder(sb, s, i);
                        break;
                    default:
                        sb.append(c);
                        break;
                }
            }

        }
        return sb.toString();
    }

    /**
     * 针对特殊字符的编码进行处理
     * @param sb
     * @param s
     * @param index
     */
    public static void processUrlEncoder(StringBuilder sb, String s, int index) {
        if (s.length() >= index + 2) {
            // %3c, %3C
            if (s.charAt(index + 1) == '3' && (s.charAt(index + 2) == 'c' || s.charAt(index + 2) == 'C')) {
                sb.append('＜');
                return;
            }
            // %3c (0x3c=60)
            if (s.charAt(index + 1) == '6' && s.charAt(index + 2) == '0') {
                sb.append('＜');
                return;
            }
            // %3e, %3E
            if (s.charAt(index + 1) == '3' && (s.charAt(index + 2) == 'e' || s.charAt(index + 2) == 'E')) {
                sb.append('＞');
                return;
            }
            // %3e (0x3e=62)
            if (s.charAt(index + 1) == '6' && s.charAt(index + 2) == '2') {
                sb.append('＞');
                return;
            }
        }
        sb.append(s.charAt(index));
    }

    /**
     * 重写getParameter，对参数进行xss过滤
     * @param parameter
     * @return
     */
    @Override
    public String getParameter(String parameter) {
        String value = super.getParameter(parameter);
        if (value == null) {
            return null;
        }
        return cleanXSS(value);
    }

    /**
     * 重写getParameterValues，对参数进行xss过滤
     * @param parameter
     * @return
     */
    @Override
    public String[] getParameterValues(String parameter) {
        String[] values = super.getParameterValues(parameter);
        if (values == null) {
            return null;
        }
        int count = values.length;
        String[] encodedValues = new String[count];
        for (int i = 0; i < count; i++) {
            encodedValues[i] = cleanXSS(values[i]);
        }
        return encodedValues;
    }

    /**
     * 重写getParameterMap，对参数进行xss过滤
     * @return
     */
    @Override
    public Map<String, String[]> getParameterMap(){
        Map<String, String[]> values = super.getParameterMap();
        if (values == null) {
            return null;
        }
        Map<String, String[]> result = new HashMap<>();
        for(String key:values.keySet()){
            String encodedKey = cleanXSS(key);
            int count = values.get(key).length;
            String[] encodedValues = new String[count];
            for (int i = 0; i < count; i++){
                encodedValues[i] = cleanXSS(values.get(key)[i]);
            }
            result.put(encodedKey,encodedValues);
        }
        return result;
    }

    /**
     * 重写getHeader，对参数进行xss过滤
     * @param name
     * @return
     */
    @Override
    public String getHeader(String name) {
        String value = super.getHeader(name);
        if (value == null) {
            return null;
        }
        return cleanXSS(value);
    }

    /**
     * xss过滤
     * @param valueP 内容
     * @return
     */
    private String cleanXSS(String valueP) {
        String value = valueP.replaceAll("<[\\s]*?script[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?script[\\s]*?>", "");
        value = value.replaceAll("<[\\s]*?javascript[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?javascript[\\s]*?>", "");
        value = value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
        value = value.replaceAll("<", "& lt;").replaceAll(">", "& gt;");
        value = value.replaceAll("eval\\((.*)\\)", "");
        value = value.replaceAll("alert", "");
        value = cleanSqlKeyWords(value);
        return value;
    }

    /**
     * sql注入过滤
     * @param value 内容
     * @return
     */
    private String cleanSqlKeyWords(String value) {
        String paramValue = value;
        //暂时
//        for (String keyword : notAllowedKeyWords) {
//            if (paramValue.length() > keyword.length() + 3
//                    && (paramValue.contains(" "+keyword)||paramValue.contains(keyword+" ")||paramValue.contains(" "+keyword+" "))) {
//                paramValue = StringUtils.replace(paramValue, keyword, replacedString);
//                System.out.println(this.currentUrl + "已被过滤，因为参数中包含不允许sql的关键词(" + keyword
//                        + ")"+";参数："+value+";过滤后的参数："+paramValue);
//            }
//        }
        return paramValue;
    }

    /**
     * 将json字符串数据转成json树，再深度遍历去除xss
     * @param jsonStr json字符串
     * @return
     */
    private String transJsonNode(String jsonStr) {
        String str = "";
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readTree(jsonStr);
            str = objectMapper.writeValueAsString(cleanJsonNodeXSS(jsonNode));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return str;
    }

    /**
     * 对json树深度遍历去除xss
     * @param jsonNode json树
     * @return
     */
    private Object cleanJsonNodeXSS(JsonNode jsonNode) {
        Iterator<Map.Entry<String, JsonNode>> fields = jsonNode.fields();
        if (!fields.hasNext()) {
            String value = jsonNode.asText();
            return cleanXSS(value);
        }
        Map<String, Object> map = new HashMap<>();
        while(fields.hasNext()) {
            Map.Entry<String, JsonNode> next = fields.next();
            if (next.getValue().isTextual()) {
                String value = next.getValue().asText();
                String str = cleanXSS(value);
                map.put(next.getKey(),str);
            }else if (next.getValue().isObject()){
                map.put(next.getKey(),cleanJsonNodeXSS(next.getValue()));
            }else if(next.getValue().isArray()) {
                List<Object> elementList = new ArrayList<>();
                Iterator<JsonNode> elements = next.getValue().elements();
                while (elements.hasNext()) {
                    JsonNode childrenNext = elements.next();
                    Object nodeMap = cleanJsonNodeXSS(childrenNext);
                    elementList.add(nodeMap);
                }
                map.put(next.getKey(),elementList);
            }
            else {
                map.put(next.getKey(),next.getValue());
            }

        }
        return map;
    }
}
ACodeBird
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合XssFilter，Jsoup等实现请求参数的过滤，处理Xss攻击及sql注入.zip
02-09
原理过程 Springboot中会使用FilterRegistrationBean来注册Filter，Filter是Servlet规范里面的，属于容器范围，Springboot中没有web.xml，那Springboot中，不用管Filter是如何交给Ser...SpringBoot整合XssFilter，Jsoup等实现请求参数的过滤，处理Xss攻击及sql注入.zip
Springboot配置XSS过滤器XssFilter.zip
12-31
直接可以运行，包含测试类，对HTML和SQL进行过滤，方便扩展。并且可以配置不拦截的路径，包含注释，方便学习。 博客地址：https://blog.csdn.net/u011974797/article/details/121792680
新增富文本单元格和XSS过滤器
qq_57278020的博客
10-19 520
皕杰设计器新增了单元格富文本类型，我们在一些网站编辑文章的时候经常可以看到富文本和markdown等编辑器，其中以Word为例，输入文字后，选择不同的功能（通常是通过点击某个图标），例如加粗或者调整字体大小，处理后的效果直接显示在屏幕上，与打印出来的效果相同。为了解决由于编码问题而导致的找不到模板文件以及解决安全扫描中XSS注入风险问题，皕杰报表web端新增了两个过滤器供选择，一个是字符编码过滤器（CharacterEncodingFilter），一个是XSS过滤器（XssRequestFilter）。
spring boot XSS 攻击 富文本框
mlc19860417的专栏
08-27 1018
2个类 import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; import org.apache.commons.lang3.StringEscapeUtils; public class XssHttpServletRequestWrappe...
Springboot项目，前端上传富文本内容给后台，后台接收到的内容有标签丢失。
m0_57485150的博客
11-26 1849
Springboot项目，前端上传富文本内容给后台，后台接收到的内容有标签丢失。
SpringBoot项目XSS攻击过滤防御实现
weixin_45818787的博客
09-02 2903
一、先来个简介# 什么是XSS? 百度百科的解释: XSS又叫CSS (Cross Site Script) ，跨站脚本攻击。它指的是恶意攻击者往Web页面里插入恶意html代码，当用户浏览该页之时，嵌入其中Web里面的html代码会被执行，从而达到恶意用户的特殊目的。 它与SQL注入攻击类似，SQL注入攻击中以SQL语句作为用户输入，从而达到查询/修改/删除数据的目的，而在xss攻击中，通过插入恶意脚本，实现对用户游览器的控制，获取用户的一些信息。 二、XSS分类# xss攻击可以分成两种类型： 1.非
富文本输出如何避免XSS
最新发布
jimmyleeee的专栏
05-12 2584
有时网站为了美观，会允许用户输入一些富文本，这样在显示的时候，就可以显示的更友好。虽然在输入富文本的时候在客户端进行了控制，但是，仍然难易避免一些攻击者通过抓包篡改数据绕过客户端的控制。因此，在服务器端收到富文本的数据之后，还是要进行净化处理。
springboot 处理xss攻击的方法
健康平安的活着的专栏
06-23 4107
一 xss 1.1 介绍 xss：cross site script ：跨脚本攻击，XSS是一种在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。 如： 在任何一个表单内，你输入一段简单的js代码：<script>for(var i=0;i<1000;i++){alert("弹死你"+i);}</script>，将其存入数据库； 然后在页面中，通过一个div将其显示出来。 1.2 解决办法 应对XSS攻击的其中一个方式..
Spring boot 过滤器实现防XSS攻击
李先生的博客
03-18 1312
文章目录背景参考资料上代码过滤器配置可配置不过滤地址主要过滤器代码xss具体过滤规则注意扫描该包（或者加starter也行）关于富文本框gitee代码仓库 背景 框架中添加xss攻击过滤器类，防止脚本攻击，能够做到引入包即可使用。 参考资料 这里主要参考renren-fast官方提供的开源项目的xss攻击进行改造。 参考io/renren/common/xss包下面类 三方包 hutool-http，参考博客api里面提供了xss所需的标签替换等功能 上代码 过滤器配置 /** * Filter配置
SpringBoot 使用Filter 解决Xss攻击 HTML标签转义
binglong180
07-03 2791
XSS攻击通常指的是通过利用网页开发时留下的漏洞，通过巧妙的方法注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript，但实际上也可以包括Java、 VBScript、ActiveX、 Flash 或者甚至是普通的HTML。攻击成功后，攻击者可能得到包括但不限于更高的权限（如执行一些操作）、私密网页内容、会话和cookie等各种内容。 XSSFilter import javax.servlet.*; import javax.servlet.htt.
， 富文本编辑器插件txt
08-05
https://ckeditor.com/docs/ckeditor5/latest/builds/guides/whats-new.html ， 富文本编辑器插件，需要的同学可以借鉴一下， 本人还未使用过。
SpringBoot +esapi 实现防止xss攻击 实战代码
11-25
SpringBoot +esapi springSecurity 过滤器链集成 实现防止xss攻击 实战代码
springboot整合XSS
03-20
springboot 整合预防xss攻击
前端Vue使用国密sm2、sm4与后端使用工具类
ACodeBird
08-26 8567
一、后端（SpringBoot） 1.后端导入国密支持 <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.68</version> </dependency> 2.国密工具类（sm1算法不公开，这里涉及、sm2是非对称加密、sm3是信息摘要，类似MD5加密、
springboot项目部署到服务器后无法发送邮件的问题
ACodeBird
12-29 1872
一、问题：本地环境项目可以发送邮件，部署到服务器后无法发送邮件 二、原因：我使用的是阿里云服务器，由于阿里云因为安全考虑不开发邮件默认发送端口25，所以导致本地可以发送邮件，服务器上不能发送邮件 三、解决方法：使用端口465以及ssl加密方式发送邮件，我的项目是springboot,所以直接在配置文件中加入下面的配置 # Use port 465 instead of the default po...
springboot报错would dispatch back to the current handler URL [/order/test] again.
ACodeBird
11-08 1049
错误提示：Circular view path [test]: would dispatch back to the current handler URL [/order/test] again. Check your ViewResolver setup! (Hint: This may be the result of an unspecified view, due to default ...
springboot项目打包jar后部署到服务器以及远程调试服务器项目
ACodeBird
12-29 943
一、pom.xml中打包的配置如下(booking表示打包后文件的名字，0.0.1-SNAPSHOT表示打包文件的版本，jar表示打包文件为jar包) <groupId>com</groupId> <artifactId>booking</artifactId> <version>0.0.1-SNAPSHOT</version...
springboot如何处理富文本
03-27
Spring Boot 本身并不提供处理富文本的功能，但可以通过一些第三方组件来实现。 1. 使用 CKEditor CKEditor 是一个开源的富文本编辑器，可以轻松集成到 Spring Boot 项目中。可以使用 CKEditor 提供的 JavaScript API 将富文本内容保存到数据库中，再从数据库中提取内容并展示到页面上。 2. 使用 Froala Editor Froala Editor 是另一个开源的富文本编辑器，它提供了丰富的功能和易于使用的 API。与 CKEditor 类似，可以使用 Froala Editor 提供的 API 将富文本内容保存到数据库中，并展示到页面上。 3. 使用富文本转换器 可以使用一些开源的富文本转换器，如 Pandoc，将富文本内容转换为 Markdown 或 HTML 格式进行存储和展示。这种方法需要编写一些额外的代码来处理转换和展示。 无论使用哪种方法，都需要注意富文本内容的安全性，防止恶意代码注入和 XSS 攻击。建议使用富文本编辑器提供的安全措施，如过滤和验证输入内容。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值