springboot防止XSS攻击&&SQL防注入

最新推荐文章于 2024-05-23 14:50:28 发布
最新推荐文章于 2024-05-23 14:50:28 发布
阅读量1.1k 收藏 4
点赞数
文章标签： spring boot xss sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41798504/article/details/130157919
版权

一.结构：

XssAndSqlHttpServletRequestWrapper      请求过滤类

CrosXssFilterConfigUtil                               注入防护开关工具类

CrosXssFilterConfig                                    sql xss过滤器

二.代码 

1. 创建请求过滤类XssAndSqlHttpServletRequestWrapper

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StreamUtils;

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.util.*;
import java.util.regex.Pattern;

/**
 * @Description 请求过滤类
 */
public class XssAndSqlHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final Logger logger = LoggerFactory.getLogger(XssAndSqlHttpServletRequestWrapper.class);

    private String key = "and|exec|insert|select|delete|update|count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+";
    private Set<String> notAllowedKeyWords = new HashSet<String>(0);

    HttpServletRequest orgRequest = null;
    private Map<String, String[]> parameterMap;
    private final byte[] body; //用于保存读取body中数据

    public XssAndSqlHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        orgRequest = request;
        parameterMap = request.getParameterMap();
        body = StreamUtils.copyToByteArray(request.getInputStream());

        String keyStr[] = key.split("\\|");
        for (String str : keyStr) {
            notAllowedKeyWords.add(str);
        }

    }

    // 重写几个HttpServletRequestWrapper中的方法
    /**
     * 获取所有参数名
     *
     * @return 返回所有参数名
     */
    @Override
    public Enumeration<String> getParameterNames() {
        Vector<String> vector = new Vector<String>(parameterMap.keySet());
        return vector.elements();
    }

    /**
     * 覆盖getParameter方法，将参数名和参数值都做xss &amp; sql过滤。<br>
     * 如果需要获得原始的值，则通过super.getParameterValues(name)来获取<br>
     * getParameterNames,getParameterValues和getParameterMap也可能需要覆盖
     */
    @Override
    public String getParameter(String name) {
        String[] results = parameterMap.get(name);
        if (results == null || results.length == 0)
            return null;
        else {
            String value = results[0];
            if (value != null) {
                value = xssEncode(value);
            }
            return value;
        }
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        Map<String,String[]> values = super.getParameterMap();
        if(null == values){
            return null;
        }
        Map<String,String[]> result = new HashMap<>();
        for (String key : values.keySet()) {
            String encodedKey = xssEncode(key);
            int count = values.get(key).length;
            String[] encodedValues = new String[count];
            for(int i = 0;i < count;i++){
                encodedValues[i] = xssEncode(values.get(key)[i]);
            }
            result.put(encodedKey,encodedValues);
        }
        return result;
    }

    /**
     * 获取指定参数名的所有值的数组，如：checkbox的所有数据 接收数组变量 ，如checkobx类型
     */
    @Override
    public String[] getParameterValues(String name) {
        String[] results = parameterMap.get(name);
        if (results == null || results.length == 0)
            return null;
        else {
            int length = results.length;
            for (int i = 0; i < length; i++) {
                results[i] = xssEncode(results[i]);
            }
            return results;
        }
    }

    /**
     * 覆盖getHeader方法，将参数名和参数值都做xss &amp; sql过滤。<br>
     * 如果需要获得原始的值，则通过super.getHeaders(name)来获取<br>
     * getHeaderNames 也可能需要覆盖
     */
    @Override
    public String getHeader(String name) {
        String value = super.getHeader(xssEncode(name));
        if (value != null) {
            value = xssEncode(value);
        }
        return value;
    }

    /**
     * 将容易引起xss &amp; sql漏洞的半角字符直接替换成全角字符
     *
     * @param s
     * @return
     */
    private String xssEncode(String s) {
        if (s == null || s.isEmpty()) {
            return s;
        } else {
            s = stripXSSAndSql(s);
        }
        StringBuilder sb = new StringBuilder(s.length() + 16);
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            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;
                default:
                    sb.append(c);
                    break;
            }
        }

        return sb.toString();
    }

    /**
     * 获取最原始的request
     *
     * @return
     */
    public HttpServletRequest getOrgRequest() {
        return orgRequest;
    }

    /**
     * 获取最原始的request的静态方法
     *
     * @return
     */
    @SuppressWarnings("unused")
    public HttpServletRequest getOrgRequest(HttpServletRequest req) {
        if (req instanceof XssAndSqlHttpServletRequestWrapper) {
            return ((XssAndSqlHttpServletRequestWrapper) req).getOrgRequest();
        }
        return req;
    }

    /**
     *
     * 防止xss跨脚本攻击(替换，根据实际情况调整)
     */

    public String stripXSSAndSql(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(
                    "&lt;[\r\n| | ]*script[\r\n| | ]*&gt;(.*?)<!--[\r\n| | ]*script[\r\n| | ]*-->", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid anything in a
            // src="http://www.yihaomen.com/article/java/..." type of
            // e-xpression
            scriptPattern = Pattern.compile("src[\r\n| | ]*=[\r\n| | ]*[\\\"|\\\'](.*?)[\\\"|\\\']",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            // Remove any lonesome  tag
            scriptPattern = Pattern.compile("<!--[\r\n| | ]*script[\r\n| | ]*-->", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Remove any lonesome <script ...> tag
            scriptPattern = Pattern.compile("<[\r\n| | ]*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 e-xpression(...) expressions
            scriptPattern = Pattern.compile("e-xpression\\((.*?)\\)",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid javascript:... expressions
            scriptPattern = Pattern.compile("javascript[\r\n| | ]*:[\r\n| | ]*", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid vbscript:... expressions
            scriptPattern = Pattern.compile("vbscript[\r\n| | ]*:[\r\n| | ]*", 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;
    }

    public boolean checkXSSAndSql(String value) {
        boolean flag = false;
        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(
                    "<[\r\n| | ]*script[\r\n| | ]*>(.*?)</[\r\n| | ]*script[\r\n| | ]*>", Pattern.CASE_INSENSITIVE);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Avoid anything in a
            // src="http://www.yihaomen.com/article/java/..." type of
            // e-xpression
            scriptPattern = Pattern.compile("src[\r\n| | ]*=[\r\n| | ]*[\\\"|\\\'](.*?)[\\\"|\\\']",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Remove any lonesome </script> tag
            scriptPattern = Pattern.compile("<!--[\r\n| | ]*script[\r\n| | ]*-->", Pattern.CASE_INSENSITIVE);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Remove any lonesome <script ...> tag
            scriptPattern = Pattern.compile("<[\r\n| | ]*script(.*?)>",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Avoid eval(...) expressions
            scriptPattern = Pattern.compile("eval\\((.*?)\\)",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Avoid e-xpression(...) expressions
            scriptPattern = Pattern.compile("e-xpression\\((.*?)\\)",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Avoid javascript:... expressions
            scriptPattern = Pattern.compile("javascript[\r\n| | ]*:[\r\n| | ]*", Pattern.CASE_INSENSITIVE);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Avoid vbscript:... expressions
            scriptPattern = Pattern.compile("vbscript[\r\n| | ]*:[\r\n| | ]*", Pattern.CASE_INSENSITIVE);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
            // Avoid οnlοad= expressions
            scriptPattern = Pattern.compile("onload(.*?)=",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }

            flag = checkSqlKeyWords(value);
        }
        return flag;
    }

    public boolean checkSqlKeyWords(String value){
        String paramValue = value;
        for (String keyword : notAllowedKeyWords) {
            if (paramValue.length() > keyword.length() + 4
                    && (paramValue.contains(" "+keyword)||paramValue.contains(keyword+" ")||paramValue.contains(" "+keyword+" "))) {

                logger.error(this.getRequestURI()+ "参数中包含不允许sql的关键词(" + keyword
                        + ")");
                return true;
            }
        }
        return false;
    }

    public final boolean checkParameter() {
        @SuppressWarnings({ "unchecked", "rawtypes" })
        Map<String, String[]> submitParams = new HashMap(parameterMap);

        Set<String> submitNames = submitParams.keySet();
        for (String submitName : submitNames) {
            Object submitValues = submitParams.get(submitName);
            if ((submitValues instanceof String)) {
                if (checkXSSAndSql((String) submitValues)) {
                    return true;
                }
            } else if ((submitValues instanceof String[])) {
                for (String submitValue : (String[])submitValues){
                    if (checkXSSAndSql(submitValue)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return bais.read();
            }

            @Override
            public boolean isFinished() {
                // TODO Auto-generated method stub
                return false;
            }

            @Override
            public boolean isReady() {
                // TODO Auto-generated method stub
                return false;
            }

            @Override
            public void setReadListener(ReadListener arg0) {
                // TODO Auto-generated method stub
            }
        };
    }

}

2. 创建防注入开关工具类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @Description: 注入防护开关工具类
 */
@Component
public class CrosXssFilterConfigUtil {

    /**
     * 注入防护开关配置
     */
    public static Boolean openFilter;

    /**
     * 注入防护开关配置，默认为开启
     */
    public static Boolean getOpenFilterProtect() {
        return openFilter == null ? true : openFilter;
    }

    @Value("${api.filter}")
    public void setOpenFilter(Boolean openFilter) {
        CrosXssFilterConfigUtil.openFilter = openFilter;
    }

}

yml配置：

api:
    filter: true

3. 把请求过滤类XssAndSqlHttpServletRequestWrapper添加到Filter中，注入容器

import com.example.util.CrosXssFilterConfigUtil;
import com.example.wrapper.XssAndSqlHttpServletRequestWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

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

/**
 *  SQL && XSS过滤器
 */
@WebFilter
@Component
public class CrosXssFilterConfig implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) servletRequest;
        ServletResponse response = servletResponse;


        // 如果防注入关闭，则不执行后续校验操作
        if(!CrosXssFilterConfigUtil.getOpenFilterProtect()) {
            filterChain.doFilter(request,response);
        }else{
            XssAndSqlHttpServletRequestWrapper xssRequest = new XssAndSqlHttpServletRequestWrapper(request);
            String method = ((HttpServletRequest) request).getMethod();

            String param = "";

            if ("POST".equalsIgnoreCase(method)) {
                param = this.getBodyString(xssRequest.getReader());
                if(StringUtils.isNotBlank(param)){
                    if(xssRequest.checkXSSAndSql(param)){
                        servletResponse.setCharacterEncoding("UTF-8");
                        servletResponse.setContentType("application/json;charset=UTF-8");
                        PrintWriter out = servletResponse.getWriter();
                        out.write("param is invalid");
                        return;
                    }
                }
            }

            if (xssRequest.checkParameter()) {
                servletResponse.setCharacterEncoding("UTF-8");
                servletResponse.setContentType("application/json;charset=UTF-8");
                PrintWriter out = servletResponse.getWriter();
                out.write("param is invalid");
                return;
            }

            filterChain.doFilter(xssRequest, servletResponse);
        }
    }


    // 获取request请求body中参数
    public String getBodyString(BufferedReader br) {
        String inputLine;
        String str = "";
        try {
            while ((inputLine = br.readLine()) != null) {
                str += inputLine;
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }

    @Override
    public void destroy() {

    }

}

 完成！

我该牡丹花下死
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot 防止XSS攻击和SQL攻击拦截器
weixin_47107856的博客
01-05 724
什么是SQL攻击、什么是XSS攻击 SQL 攻击:把SQL命令插入到Web表单并提交,欺骗服务器执行恶意的SQL命令。 XSS攻击:向有XSS漏洞的网站中输入(传入)恶意的HTML代码，当其它用户浏览该网站时，这段HTML代码会自动执行，从而达到攻击的目的。 创建拦截器第一步： 创建XssAndSqlHttpServletRequestWrapper包装器，这是实现XSS和SQL过滤的关键，在其内重写了getParameter，getParameterValues，getHeader等方法，对...
防XSS攻击和SQL注入手段
Java_Mrsun的博客
06-28 1124
       XSS攻击全称跨站脚本攻击，是为不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆，故将跨站脚本攻击缩写为XSS，XSS是一种在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。XSS漏洞和著名的SQL注入漏洞一样，都是利用了Web页面的编写不完善，所以每一个漏洞所利用和针对的弱点都不尽相同。       这里我...
springboot项目防止XSS攻击和sql注入
yy1209357299的博客
02-07 3575
springboot项目防止XSS攻击和sql注入
过滤器实现全局防SQL注入
ACGkaka的博客
10-28 4358
目录SqlInjectFilter.javaMyRequestWrapper.java 场景： 公司渗透测试，发现了输入框有SQL注入风险，于是进行修改。 解决方案： 增加全局过滤器，对请求参数中存在SQL过滤器的参数进行提示，主要增加了两个类： SqlInjectFilter，过滤器； MyRequestWrapper，用于过滤器中获取POST请求参数。 SqlInjectFilter.java import com.alibaba.fastjson.JSONObject; import com.
SpringBoot中如何防止XSS攻击和sql注入
最新发布
2302_77596945的博客
05-23 593
***自定义过滤注解*/⑤自定义拦截器配置类@Override最后最后！！！一定要在启动类添加扫描@ServletComponentScan(basePackages ="全限定名")以上仅供参考。
【SpringBoot应用篇】SpringBoot集成AntiSamy防御XSS(跨站脚本攻击)--过滤器实现
输入技术、输出想法
12-29 1584
XSS：跨站脚本攻击(Cross Site Scripting)，为不和 CSS混淆，故将跨站脚本攻击缩写为XSS。XSS是指恶意攻击者往Web页面里插入恶意Script代码，当用户浏览该页时，嵌入其中Web里面的Script代码会被执行，从而达到恶意攻击用户的目的。有点类似于sql注入。XSS攻击原理：HTML是一种超文本标记语言，通过将一些字符特殊地对待来区别文本和标记，例如，小于符号（
防止 SQL 注入
洪晓鸿
04-26 2436
防止 SQL 注入是在使用 Spring Boot 开发 Web 应用程序时必须关注的重要安全问题。通过遵循以下四个步骤，我们可以有效地预防 SQL使用参数化查询。使用 JPA 或其他 ORM 框架。验证和过滤用户输入。设置最小权限原则。结合这些方法，我们可以确保我们的应用程序在面对 SQL 注入攻击时能够保持数据安全。
Web安全问题：Xss攻击及解决方法
weixin_45650737的博客
04-23 443
转自：https://blog.csdn.net/qq_38892496/article/details/91582868 作者：y_mk 什么是Xss攻击？ 首先，这个词实际上是CSS（Cross Site Scripting），但它与CSS同名。所以名字是XSS。 ——摘自百度百科 https://baijiahao.baidu.com/sid=1618267672561552800&wfr=spider&for=pc 其实就是使用Javascript脚本
SpringBoot 防止XSS攻击和SQL攻击拦截器(Filter)
zhouzhiwengang的专栏
03-24 3352
什么是SQL攻击、什么是XSS攻击 SQL 攻击:把SQL命令插入到Web表单并提交,欺骗服务器执行恶意的SQL命令。 XSS 攻击:向有XSS漏洞的网站中输入(传入)恶意的HTML代码，当其它用户浏览该网站时，这段HTML代码会自动执行，从而达到攻击的目的。 创建拦截器第一步： 创建XssAndSqlHttpServletRequestWrapper包装器，这是实现XSS和SQL过滤的关键，在其内重写了getParameter，getParameterValues，getHeader等方法，对ht
预防XSS攻击和SQL注入XssFilter
05-19
一、什么是XSS攻击 XSS是一种经常出现在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。比如这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如...
XSS & SQL注入
10-30
XSS & SQL 注入 XSS（Cross-Site Scripting，跨站脚本）和 SQL 注入是两种常见的 Web 安全漏洞。下面将详细介绍 XSS 和 SQL 注入的概念、原理和应用。 什么是 XSS？ XSS，或者称为 CSS，代表着跨站脚本。基本上，...
SpringBoot +esapi 实现防止xss攻击 实战代码
11-25
在网络安全领域，XSS（Cross-Site Scripting）攻击是一种常见的威胁，它允许攻击者通过注入恶意脚本到网页上，来劫持用户会话、窃取敏感信息或执行其他恶意操作。SpringBoot是一个流行的Java框架，用于快速开发高效...
SpringBoot整合XssFilter，Jsoup等实现请求参数的过滤，处理Xss攻击及sql注入.zip
02-09
原理过程 Springboot中会使用FilterRegistrationBean来注册Filter，Filter是Servlet规范里面的，属于容器范围，Springboot中没有web.xml，那Springboot中，不用管Filter是如何交给Ser......处理Xss攻击及sql注入.zip
防sql注入和xss攻击， springmv拦截器
07-24
防sql注入和xss攻击， springmv拦截器，可自由调整需要拦截的字符
Springboot使用CrosXssFilter防止sql注入xss攻击cros跨域等
冰之杍的博客
12-07 1247
Springboot使用CrosXssFilter防止sql注入xss攻击cros跨域等1.编写CrosXssFilter.java，代码如下2.在springbooot的启动类中加入注解@ServletComponentScan 现在的web系统对安全性要求越来越高，常常需要通过第三方的渗透测试才能进行验收，其中就有关于sql注入、xss攻击相关的，此文记录如果在springbooot中进行非侵入的改造，达到能通过sql注入及xss攻击测试的目的。 1.编写CrosXssFilter.java，代码如下
防止常见XSS 过滤 SQL注入 JAVA过滤器filter
热门推荐
hithedy的专栏
02-03 2万+
1、首先配置web.xml，添加如下配置信息： xssAndSqlFilter com.cup.cms.web.framework.filter.XssAndSqlFilter xssAndSqlFilter * 2、编写过滤器   /** * */ package com.cup.cms.web.framework.filter; import java.io.I
springboot自带filter实现sql防注入过滤器
leveretz的博客
12-29 2461
springboot自带filter实现sql防注入过滤器
HttpServletRequestWrapper通过filter做XSS
小松鼠米老鼠
06-26 3417
XSS的具体解释这里不多说，XSS简单的防注入其实就是字符的替换和屏蔽。这就需要我们在服务器接受数据对数据进行处理。Filter能在request到达servlet的服务方法之前拦截HttpServletRequest对象，而在服务方法转移控制后又能拦截HttpServletResponse对象。但是不能修改HttpServletRequest对象，我们可以用HttpServletRequestW...
基于springboot实现SQL注入过滤器
zhangbeizhen18的博客
06-11 2752
记录：273 场景：以过滤器(Filter)的方式，对所有http请求的入参拦截，使用正则表达式匹配入参中的字符串。存在SQL注入风险的参数，中断请求，并立即返回提示信息。不存在SQL注入风险的参数，校验通过后，放入过滤器链，继续后续业务。......
springboot如何实现使用过滤器防止xss攻击和sql注入
06-09
Spring Boot可以通过使用过滤器（Filter）来防止XSS攻击和SQL注入。 1. 防止XSS攻击：可以使用过滤器对请求参数进行过滤，将其中的特殊字符进行转义，从而避免XSS攻击。例如，可以使用Jsoup库中的`clean`方法来过滤...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值