Springboot使用CrosXssFilter防止sql注入xss攻击cros跨域等

已于 2023-05-30 23:42:22 修改
阅读量1.2k 收藏 10
点赞数 1
分类专栏： 【Java】 文章标签： spring boot sql xss
于 2021-12-07 08:46:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxlhljh/article/details/121746793
版权

Springboot使用CrosXssFilter防止sql注入xss攻击cros跨域等

现在的web系统对安全性要求越来越高，常常需要通过第三方的渗透测试才能进行验收，其中就有关于sql注入、xss攻击相关的，此文记录如果在springbooot中进行非侵入的改造，达到能通过sql注入及xss攻击测试的目的。

1.编写CrosXssFilter.java，代码如下

网上很多文章是独立编写2个类，我这里结合网上的资料后，融合在一起了，只有一个Java类CrosXssFilter.java即可，其中另一个XssAndSqlHttpServletRequestWrapper采用了内部类的形式，方便直接复制迁移。

package cn.gzsendi.crosxss;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.regex.Pattern;

import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ReadListener;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;

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

@WebFilter(filterName = "xssFilter",urlPatterns = "/*",dispatcherTypes = DispatcherType.REQUEST)
public class CrosXssFilter implements Filter {
	
	private static final Logger logger = LoggerFactory.getLogger(CrosXssFilter.class);
	private static final String xssErrorResponseMessage = "CrosXssFilter error.";
	
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    	
    }
    
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    	
    	HttpServletRequest request = (HttpServletRequest) servletRequest;
    	
    	//跨域设置
    	if(servletResponse instanceof HttpServletResponse){
    		HttpServletResponse httpServletResponse=(HttpServletResponse)servletResponse;
    		//通过在响应 header 中设置 ‘*’ 来允许来自所有域的跨域请求访问。
            httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
    		//通过对 Credentials 参数的设置，就可以保持跨域 Ajax 时的 Cookie
            //设置了Allow-Credentials，Allow-Origin就不能为*,需要指明具体的url域
            //httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
            //请求方式
            httpServletResponse.setHeader("Access-Control-Allow-Methods", "*");
            //（预检请求）的返回结果（即 Access-Control-Allow-Methods 和Access-Control-Allow-Headers 提供的信息） 可以被缓存多久
            httpServletResponse.setHeader("Access-Control-Max-Age", "86400");
            //首部字段用于预检请求的响应。其指明了实际请求中允许携带的首部字段
            httpServletResponse.setHeader("Access-Control-Allow-Headers", "*");
    	}
    	
        XssAndSqlHttpServletRequestWrapper xssRequest=new XssAndSqlHttpServletRequestWrapper(request);
        String method = ((HttpServletRequest) request).getMethod();
        
        String param = "";
        
        if ("POST".equalsIgnoreCase(method)) {
            param = this.getBodyString(xssRequest.getReader());
            if(StringUtils.hasText(param)){
                if(xssRequest.checkXSSAndSql(param)){
                    servletResponse.setCharacterEncoding("UTF-8");
                    servletResponse.setContentType("application/json;charset=UTF-8");
                    PrintWriter out = servletResponse.getWriter();
                    out.write(xssErrorResponseMessage);
                    return;
                }
            }
        }
        
        if (xssRequest.checkParameter()) {
            servletResponse.setCharacterEncoding("UTF-8");
            servletResponse.setContentType("application/json;charset=UTF-8");
            PrintWriter out = servletResponse.getWriter();
            out.write(xssErrorResponseMessage);
            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) {
        	logger.error("IOException: " ,e);
        }
        return str;

    }
    
    
    @Override
    public void destroy() {

    }
    
   
    //内部类，网上的资料一般是独立写一个类，这里为了迁移代码方便，把这个类写在内部类中，这样整个迁移就只有一个CrosXssFilter.java了。
    private class XssAndSqlHttpServletRequestWrapper extends HttpServletRequestWrapper {
    	
    	private final Logger logger = LoggerFactory.getLogger(XssAndSqlHttpServletRequestWrapper.class);
    	
        private String key = "and|exec|insert|select|delete|drop|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;
            }
        }

        /**
         * 获取指定参数名的所有值的数组，如：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.toLowerCase();//转成小写
            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.在springbooot的启动类中加入注解@ServletComponentScan

这里加入@ServletComponentScan的目的是让步骤1中的Filter生效，如果你不加这个注解，经测试也能生效的话就可以不加。但我这边测试时要加上才生效。

package cn.gzsendi;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
@ServletComponentScan
public class Bootstrap {
	
	public static void main(String[] args) {

	    SpringApplication.run(Bootstrap.class, args);

	}

}

然后重启springbooot程序测试即可，加入配置类后，可以通过第三方进行的sql注入和xss的渗透测试要求。

注：本篇有参考此文https://blog.csdn.net/nanruitao10/article/details/96001741中的部分内容

冰之杍
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java springboot sql防注入的6种方式
qq_34874784的博客
08-24 4078
4. 使用ORM框架中提供的查询构造器（Query Builder）：ORM框架通常提供查询构造器或查询构造API，这些API可以帮助我们构建数据库查询语句，而无需手动编写SQL语句。1. 参数绑定：通过使用参数绑定，将用户输入的数据作为参数传递给SQL语句，而不是将其直接拼接到SQL语句中。6. 使用安全的编码方式：在将用户输入插入到SQL语句中时，确保使用合适的编码方式进行转义，例如使用转义函数或参数化查询。5. 输入验证和过滤：对于用户输入的数据，应该进行验证和过滤，确保其符合预期的格式和类型。
springboot项目防止XSS攻击和sql注入
yy1209357299的博客
02-07 3565
springboot项目防止XSS攻击和sql注入
Spring Boot 如何防护 XSS + SQL 注入攻击 ？终于懂了！
最新发布
weixin_44421461的博客
05-16 154
????这是一个或许对你有用的社群????一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事中“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
Springboot集成防sql注入设置
hao_kkkkk的专栏
10-21 3064
sql注入 安全开发 springboot
Springboot 对应XSS漏洞类配置处理
喜欢猪猪
12-08 3252
}}= null) {)\\)");)\\)");)>(.*?)>(.*?)>(.*?)\\)");)\\\"");)\\\"");)>(.*?)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");)\\\"");
springboot防止XSS攻击&&SQL防注入
qq_41798504的博客
04-14 1099
SpringBoot下通过过滤器实现对Xss攻击和Sql注入
预防XSS攻击和SQL注入XssFilter
05-19
XSS是一种经常出现在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。比如这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin...
SpringBoot +esapi 实现防止xss攻击 实战代码
11-25
在网络安全领域，XSS（Cross-Site Scripting）攻击是一种常见的威胁，它允许攻击者通过注入恶意脚本到网页上，来劫持用户会话、窃取敏感信息或执行其他恶意操作。SpringBoot是一个流行的Java框架，用于快速开发高效...
SpringBoot +esapi 实现防止xss攻击 实战代码，满满干货
06-08
以上就是使用SpringBoot和ESAPI防止XSS攻击的基本步骤。通过这些实践，你可以构建一个更加安全的Web应用，有效地防御XSS攻击。在实际开发中，还应关注其他安全方面，比如SQL注入、CSRF攻击等，同时遵循OWASP（开放...
SpringBoot整合XssFilter，Jsoup等实现请求参数的过滤，处理Xss攻击及sql注入.zip
02-09
Springboot中会使用FilterRegistrationBean来注册Filter，Filter是Servlet规范里面的，属于容器范围，Springboot中没有web.xml，那Springboot中，不用管Filter是如何交给Ser...SpringBoot整合XssFilter，Jsoup等实现...
Yii框架防止sql注入，xss攻击与csrf攻击的方法
10-21
主要介绍了Yii框架防止sql注入，xss攻击与csrf攻击的方法,结合实例形式分析了Yii框架针对sql注入，xss攻击与csrf攻击的防范方法与相关函数调用注意事项,需要的朋友可以参考下
7、springboot-防止sql注入
aunt_y的博客
05-25 4452
疫情大数据平台是一个公益的项目，但很可能被网络上大量的扫描器扫描，并有可能收到脚本的攻击，而进行防御就是很重要的，可以有效的避免我们被攻击。 本篇主要讲述防止sql注入部分 sql注入是什么 ​ SQL是操作数据库数据的结构化查询语言，网页的应用数据和后台数据库中的数据进行交互时会采用SQL。 ​ 而SQL注入是将Web页面的原URL、表单域或数据包输入的参数，修改拼接成SQL语句，传递给Web服务器，进而传给数据库服务器以执行数据库命令。 ​ 如Web应用程序的开发人员对用户所输入的数据或cooki
SQL注入原理以及Spring Boot如何防止SQL注入（含详细示例代码）
a342874650的专栏
12-29 3371
SQL注入是一种针对数据库的攻击技术，攻击者通过在应用程序的输入字段中插入或“注入”恶意的SQL代码，从而在数据库服务器上执行非授权的SQL查询。这种攻击可能导致数据泄露、数据篡改、甚至执行任意命令。
基于springboot实现SQL注入过滤器
zhangbeizhen18的博客
06-11 2734
记录：273 场景：以过滤器(Filter)的方式，对所有http请求的入参拦截，使用正则表达式匹配入参中的字符串。存在SQL注入风险的参数，中断请求，并立即返回提示信息。不存在SQL注入风险的参数，校验通过后，放入过滤器链，继续后续业务。......
【Springboot】Xss过滤
xia744510124的专栏
07-17 1014
声明：大部分代码我都是重别人博客里面复制过来的，只是稍稍的修改了一下，能够支持对文件的过滤，话不多说了，直接贴代码了！ 配置文件(application.properties) # 如果不想进行Xss过滤，可以注释掉或者设置为false common.xss-filter-open=true 过滤配置类(XssFilterConfig.java) @Configuration @Cond...
SpringBoot项目防止Sql注入拦截器
qq_29991719的博客
12-08 1526
防止Sql注入拦截器
web.xml配置全局过滤器防止SQL注入
小草的博客
08-23 980
Statement.executeUpdate(sql)，没有使用PreparedStatement.executeUpdate(sql)生产有个老项目使用的是jsp+servlet写的，对安全方面几乎没有，对执行的sql使用的是。2）写sql的时候用PreparedStatement。1）配置全局过滤器，通过关键字匹配来拦截恶意请求。1.在web.xml中加入以下配置。本次使用的是配置全局过滤器。浏览器上直接访问项目。
SpringBoot Web项目案例视频课程
06-11
其设计目标是开发迅速、轻量级、易扩展等核心框架:Spring Framework安全框架:Apache Shiro视图框架:SpringMVC持久层框架:MyBatis定时器:Quartz数据库连接池:Druid日志管理:Logback页面交互:Vue前后端分离:Swagger校验工具类:Hibernate-validator代码生成器:Velocity
springboot如何实现使用过滤器防止xss攻击和sql注入
06-09
Spring Boot可以通过使用过滤器（Filter）来防止XSS攻击和SQL注入。 1. 防止XSS攻击：可以使用过滤器对请求参数进行过滤，将其中的特殊字符进行转义，从而避免XSS攻击。例如，可以使用Jsoup库中的`clean`方法来过滤...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值