springboot 防止xss 和sql 注入 改写 http 请求 getParameter，getParameterValues，getHeader等方法 有点东西

最新推荐文章于 2023-01-08 16:20:00 发布
最新推荐文章于 2023-01-08 16:20:00 发布
阅读量1.8k 收藏 1
点赞数 4
文章标签： xss 攻击 sql注入 xss攻击 安全过滤器 防攻击方注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42749765/article/details/106709588
版权

 

 目录

1.springboot 启动类 引入 过滤器配置

2.过滤器

3.XssAndSqlHttpServletRequestWrapper包装器 包装类

4.修改验证登录代码 这里只写了基础的 了解意思即可 

5.测试内容 

6.测试结果

7.反黑客小介绍（黑客大哥们好小弟这没啥大用O(∩_∩)O~，但是对待小白黑客还好）

1.springboot 启动类 引入 过滤器配置

package com.superman;

import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.BasicConfigurator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;

import com.superman.conf.filter.XssAndSqlFilter;
import com.superman.tonifi.InitInfo;

/**
 * 项目启动类
 * 
 * @author yushen
 *
 */
@SpringBootApplication
public class Provider_App {

	/**
	 * 项目启动入口
	 * 
	 * @param args
	 */
	public static void main(String[] args) {

		SpringApplication.run(Provider_App.class, args);
		
		InitInfo.Info(); //初始化内容
		
		// 自动快速地使用缺省Log4j环境。
		BasicConfigurator.configure();

	}

	/**
	 * 防止xss 和 sql 注入 
	 * 
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	@Bean
	public FilterRegistrationBean xssFilterRegistrationBean() {
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
		filterRegistrationBean.setFilter(new XssAndSqlFilter());
		filterRegistrationBean.setOrder(1);
		filterRegistrationBean.setEnabled(true);
		filterRegistrationBean.addUrlPatterns("/*");
		filterRegistrationBean.setName("XssAndSqlFilter");
		Map<String, String> initParameters = new HashMap();
		initParameters.put("excludes", "/favicon.ico,/img/*,/js/*,/css/*");
		initParameters.put("isIncludeRichText", "true");
		filterRegistrationBean.setInitParameters(initParameters);
		return filterRegistrationBean;
	}
 
	
}
  • 这个可以注册到的的地方除了springbootappliaction 以外别的 配置也可以注册更具自己选择，最好方springbootappliaction 中 方便省事

     

2.过滤器

package com.superman.conf.filter;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;

/**
 * 防止
 * xss 和 sql 注入漏洞
 * @author yushen
 * 20200611
 *
 */
public class XssAndSqlFilter implements Filter {

	/**
	 * TODO 这个可以注册到的的地方除了springbootappliaction 以外别的 配置也可以注册更具自己选择，最好方springbootappliaction 中 方便省事
	 *
	 * @Bean
	public FilterRegistrationBean xssFilterRegistrationBean() {
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
		filterRegistrationBean.setFilter(new XssAndSqlFilter());
		filterRegistrationBean.setOrder(1);
		filterRegistrationBean.setEnabled(true);
		filterRegistrationBean.addUrlPatterns("/*");
		filterRegistrationBean.setName("XssAndSqlFilter");
		Map<String, String> initParameters = new HashMap();
		initParameters.put("excludes", "/favicon.ico,/img/*,/js/*,/css/*");
		initParameters.put("isIncludeRichText", "true");
		filterRegistrationBean.setInitParameters(initParameters);
		return filterRegistrationBean;
	}
	 */
    @Override
    public void destroy() {
        // TODO Auto-generated method stub

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        String method = "GET";
        String param = "";
        XssAndSqlHttpServletRequestWrapper xssRequest = null;
        if (request instanceof HttpServletRequest) {
            method = ((HttpServletRequest) request).getMethod();
            xssRequest = new XssAndSqlHttpServletRequestWrapper((HttpServletRequest) request);
        }
        if ("POST".equalsIgnoreCase(method)) {
            param = this.getBodyString(xssRequest.getReader());
            if(StringUtils.isNotBlank(param)){
                if(xssRequest.checkXSSAndSql(param)){
                    response.setCharacterEncoding("UTF-8");
                    response.setContentType("application/json;charset=UTF-8");
                    PrintWriter out = response.getWriter();
//                    out.write(JSONResponseUtil.getWrappedERRString("您所访问的页面请求中有违反安全规则元素存在，拒绝访问!"));
                      out.write("您所访问的页面请求中有违反安全规则元素存在，拒绝访问!");
                    return;
                }
            }
        }
        if (xssRequest.checkParameter()) {
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json;charset=UTF-8");
            PrintWriter out = response.getWriter();
//            out.write(JSONResponseUtil.getWrappedERRString("您所访问的页面请求中有违反安全规则元素存在，拒绝访问!"));
            out.write("您所访问的页面请求中有违反安全规则元素存在，拒绝访问!");
            return;
        }
        chain.doFilter(xssRequest, response);
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
        // TODO Auto-generated method stub

    }

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

    }

}

3.XssAndSqlHttpServletRequestWrapper包装器 包装类

package com.superman.conf.filter;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.regex.Pattern;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import org.springframework.util.StreamUtils;

/**
 * 过滤器相关
 * @author yushen
 * 20200611
 *	创建XssAndSqlHttpServletRequestWrapper包装器，这是实现XSS过滤的关键，
 *	在其内重写了getParameter，getParameterValues，getHeader等方法，对http请求内的参数进行了过滤
 *
 */
public class XssAndSqlHttpServletRequestWrapper extends HttpServletRequestWrapper {

    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());
    }

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

    /**
     * 覆盖getParameter方法，将参数名和参数值都做xss & 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 & 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 & sql漏洞的半角字符直接替换成全角字符
     * 
     * @param s
     * @return
     */
    private static 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
     */
    public static HttpServletRequest getOrgRequest(HttpServletRequest req) {
        if (req instanceof XssAndSqlHttpServletRequestWrapper) {
            return ((XssAndSqlHttpServletRequestWrapper) req).getOrgRequest();
        }

        return req;
    }

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

    public static 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(
                    "<[\r\n| | ]*script[\r\n| | ]*>(.*?)</[\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 </script> 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 onload= expressions
            scriptPattern = Pattern.compile("onload(.*?)=",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
        }
        return value;
    }

    public static 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 onload= expressions
            scriptPattern = Pattern.compile("onload(.*?)=",
                    Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            flag = scriptPattern.matcher(value).find();
            if (flag) {
                return flag;
            }
        }
        return flag;
    }

    public final boolean checkParameter() {
        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  
                  
            }    
        };    
    }

}

4.修改验证登录代码 这里只写了基础的 了解意思即可 

//2.校验手机号和token号 
			String sql = "select * from userlogin where phonenum='"+phonenum+"' and token='"+tokennum+"' ";
			//3.不准确退回从新输入登录
			try {
				int resttokenjy = aed.queryApiInfo(sql).size();
				if(resttokenjy != 1){
					return new AsyncResult<>("验证码不正确！");
				}
			} catch (Exception e) {
				log.error(e.toString());
				return new AsyncResult<>("验证码不正确！");
			}
  • 重点是加上try 如果发生异常 也好吧信息异步返回 回去
  • 更具业务需求，返回自己特殊更多的内容，有需要进行其他安全设施的也可以像安全记录中进行记录数据
  • 如发现危险用户 恶意攻击系统等

 

5.测试内容 

6.测试结果

Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.
2020-06-12 10:02:22.045 INFO  com.alibaba.druid.pool.DruidDataSource - {dataSource-1} inited
2020-06-12 10:02:22.192 ERROR com.superman.global.service.usercheck.UserLoginCheckService - org.springframework.jdbc.BadSqlGrammarException: 
### Error querying database.  Cause: java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '＃'' at line 1
### The error may exist in file [D:\eclipseworks_2020\superporject\super_portal\target\classes\mybatis\mapper\ds1\ApiOneDao.xml]
### The error may involve com.superman.globaldao.ds1.ApiOneDao.queryApiInfo-Inline
### The error occurred while setting parameters
### SQL: select id from userlogin where phonenum='15600000000' and token='' or 1=1 ＃'
### Cause: java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '＃'' at line 1
; bad SQL grammar []; nested exception is java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '＃'' at line 1

7.反黑客小介绍（黑客大哥们好小弟这没啥大用O(∩_∩)O~，但是对待小白黑客还好）

  • ok 我们这里可以看到 原本 半角代码 # 已经变成全角代码＃ 如此以来就可以完全防止sql 和xss 注入了，当然，还有有高手
  • 攻击破解系统，这时候就是继续再加点过滤器和系统安全防护策略，还有安全校验来实现，
  • 总体来讲
  • 要向防止系统被攻破
  • 就要自己多方几堵墙 阻挡破解的墙越多，黑客发现这么多阻挡，由于利益的权衡后发现，破解你的系统有些亏，大部分就
  • 去破解别的系统去了^_^ , 这说法仅当参考哈，还是你们想和黑客战斗的大哥们去战斗比试比试吧，
  • pk 下谁更牛 棒棒哒   O(∩_∩)O   

 

ok

 

 

宇神城主_蒋浩宇
关注
SpringBoot整合XssFilter，Jsoup等实现请求参数的过滤，处理Xss攻击及sql注入
阿啄debugIT
02-09 2162
前言 SpringBoot整合XssFilter，Jsoup等实现请求参数的过滤，处理Xss攻击及sql注入，以下是涉及的主要类： 原理过程 Springboot中会使用FilterRegistrationBean来注册Filter，Filter是Servlet规范里面的，属于容器范围，Springboot中没有web.xml，那Springboot中，不用管Filter是如何交给Ser...
SpringBoot 防止XSS攻击和SQL攻击拦截器
weixin_47107856的博客
01-05 753
什么是SQL攻击、什么是XSS攻击 SQL 攻击:把SQL命令插入到Web表单并提交,欺骗服务器执行恶意的SQL命令。 XSS攻击:向有XSS漏洞的网站中输入(传入)恶意的HTML代码，当其它用户浏览该网站时，这段HTML代码会自动执行，从而达到攻击的目的。 创建拦截器第一步： 创建XssAndSqlHttpServletRequestWrapper包装器，这是实现XSS和SQL过滤的关键，在其内重写了getParameter，getParameterValues，getHeader等方法，对...
Request的getHeader()和getParameter()的区别
weixin_30653023的博客
08-31 2906
区别是：一个是获得HTTP头信息,一个是获得表单参数值。 转载于:https://www.cnblogs.com/pxffly/p/7460514.html
使用Servlet Filter来防止SQL注入的方法
felixsyan的专栏
08-28 331
SQL注入是比较常见的网络攻击方式之一，它不是利用操作系统的BUG来实现攻击，而是针对程序员编程时的疏忽，通过SQL语句，实现无帐号登录，甚至篡改数据库。 filter功能.它使用户可以改变一个 request和修改一个response. Filter 不是一个servlet,它不能产生一个response,它能够 在一个request到达servlet之前预处理request,也可以...
servlet过滤器防xss,sql注入.filter里修改parameter参数
凉粉
12-10 3230
这中间起到最关键作用的就是HttpServletRequestWrapper 首先创建一个类继承HttpServletRequestWrapper。然后重写getAttribute,getParameter,getParameterValues,getParameterMap这几个方法。 public class OpRequestWrap extends HttpServletRequest
request和response常用的方法
weixin_42044486的博客
11-20 3058
（1）request简介 request对象主要用于存储“客户端发送给服务器端的请求信息”，因此可以通过request对象来获取用户发送的相关数据，request常用的方法：  1. setAttribute()在Request域中存储数据  2. setCharacterEncoding()设置请求参数的编码方式,只对post请求有效  3. getMethod()获取请求类型  4. g...
JavaWeb——request和response常用方法
innovation的博客
11-05 351
request getRequestURL() 浏览器发出请求时的完整URL，包括协议 主机名 端口(如果有)" getRequestURI() 浏览器发出请求的资源名部分，去掉了协议和主机名" getQueryString() 请求行中的参数部分，只能显示以get方式发出的参数，post方式的看不到 getRemoteAddr() 浏览器所处于的客户机的IP地址 getRemoteHost() ...
springboot-防止sql注入，xss攻击，cros恶意访问
热门推荐
2010yhh
11-25 4万+
springboot-防止sql注入，xss攻击，cros恶意访问 文章目录springboot-防止sql注入，xss攻击，cros恶意访问1.sql注入2.xss攻击3.csrf/cros 完整代码下载链接： https://github.com/2010yhh/springBoot-demos.git 环境 idea2018，jdk1.8， springboot版本：springboot1...
java 防止Xss、SQL注入攻击
湖人•总冠军
01-17 1万+
前言： 1.XSS简介 跨站脚本（cross site script）简称为XSS，是一种经常出现在web应用中的计算机安全漏洞，也是web中最主流的攻击方式。 XSS是指恶意攻击者利用网站没有对用户提交数据进行转义处理或者过滤不足的缺点，进而添加一些代码，嵌入到web页面中去，使别的用户访问都会执行相应的嵌入代码。  1.1.XSS攻击的危害      1、盗取用户资料，比如：登录帐号、...
springboot中防止sql注入 & 防止sql攻击
jancislo的博客
06-28 1万+
1.编写  XssHttpServletRequestWrapperimport javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; public class XssHttpServletRequestWrapper extends HttpServletReque...
预防XSS攻击和SQL注入XssFilter
07-23
一、什么是XSS攻击 XSS是一种经常出现在web应用中的计算机安全漏洞，它允许恶意web用户将代码植入到提供给其它用户使用的页面中。比如这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin policy)。这种类型的漏洞由于被黑客用来编写危害性更大的网络钓鱼(Phishing)攻击而变得广为人知。对于跨站脚本攻击，黑客界共识是：跨站脚本攻击是新型的“缓冲区溢出攻击“，而JavaScript是新型的“ShellCode”。 二、XSS漏洞的危害 （1）网络钓鱼，包括盗取各类用户账号； （2）窃取用户cookies资料，从而获取用户隐私信息，或利用用户身份进一步对网站执行操作； （3）劫持用户（浏览器）会话，从而执行任意操作，例如进行非法转账、强制发表日志、发送电子邮件等； （4）强制弹出广告页面、刷流量等； （5）网页挂马； （6）进行恶意操作，例如任意篡改页面信息、删除文章等； （7）进行大量的客户端攻击，如DDoS攻击； （8）获取客户端信息，例如用户的浏览历史、真实IP、开放端口等； （9）控制受害者机器向其他网站发起攻击； （10）结合其他漏洞，如CSRF漏洞，实施进一步作恶； （11）提升用户权限，包括进一步渗透网站； （12）传播跨站脚本蠕虫等； 三、过滤器配置 web.xml配置 XssFilter com.xxx.Filter.XssFilter XssFilter /*
XSS攻击 header(‘Location: ‘.$_GET[‘x‘])； 笔记
hello world
02-17 849
前言 笔记来于 《web前端黑客技术揭秘》 第三章 书上原话： 第二个：http://www.foo.com/xss/re-flect2.php的代码如下。 <?php header('Location: '.$_GET['x']); ?> 输入x的值作为响应头部的Location字段值输出，意味着会发生跳转，触发XSS的其中一种方式如下 http://www.foo.com/book/reflect2.php?x=data:text/html;base64,PHNjcmlwd
SpringBoot配置 Filter 对常见漏铜进行捕捉
石磊的博客
11-22 436
SpringBoot配置 Filter 对常见漏铜进行捕捉
request对象的介绍和获取请求头信息
weixin_46178977的博客
08-10 697
#request对象的介绍和获取请求头信息 ##request对象介绍 作用：request对象中封存了当前请求的所有请求信息 使用： 获取请求头数据 获取请求行数据 获取用户数据 注意： request对象有tomcat服务器创建，并作为实参传递给处理请求的servlet的service方法 下面是代码示例（部分） @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws Se
SpringBoot 防止XSS攻击和SQL攻击拦截器(Filter)
zhouzhiwengang的专栏
03-24 3513
什么是SQL攻击、什么是XSS攻击 SQL 攻击:把SQL命令插入到Web表单并提交,欺骗服务器执行恶意的SQL命令。 XSS 攻击:向有XSS漏洞的网站中输入(传入)恶意的HTML代码，当其它用户浏览该网站时，这段HTML代码会自动执行，从而达到攻击的目的。 创建拦截器第一步： 创建XssAndSqlHttpServletRequestWrapper包装器，这是实现XSS和SQL过滤的关键，在其内重写了getParameter，getParameterValues，getHeader等方法，对ht
配置拦截器防xss和sql注入
香菇猫的博客
11-19 6519
web项目防sql注入
spring boot——请求与参数校验——request获取请求参数数据示例——get方法和post方法通用——getParameter(String name)&getParameterValue...
小白龙白龙马的博客
01-08 2640
getParameter(String name) getParameterValues (String name) getParameterNames() getParameterMap() 代码： package org.example.controller; import org.springframework.web.bind.annot...
springboot 添加或修改之后 获取参数为空 再获取一遍就好了
x1778161229的博客
09-23 485
最近做了一个项目 部署到linux服务器上 只要修改或者添加删除后 (post put delete)请求，再查询一下参数获取不到了，第二次查询参数就有了，一直没处理成功，后来发现querystring里面有数据 getParameter里面没有数据，最后没办法的情况下 用以下方式解决 将querystring数据拿出来重新赋值给getParameter； import javax.servlet.http.HttpServletRequest; import javax.servlet.http.
request.getParameter() 、request.getInputStream()和request.getReader()三者的区别
zyz的博客
07-30 4318
一.我们经常用servlet和jsp, 经常用request.getParameter() 来得到数据。 request.getParameter() request.getInputStream() request.getReader() 这三个方法都是从request对象中得到提交的数据，但是用途不同。 要根据<form>表单提交数据的编码方式选择不同的方法。 HTML中的form表单的一个关键属性 enctype： 1.enctype=application/x- www-for.
springboot如何实现使用过滤器防止xss攻击和sql注入
最新发布
06-09
Spring Boot可以通过使用过滤器（Filter）来防止XSS攻击和SQL注入。 1. 防止XSS攻击：可以使用过滤器对请求参数进行过滤，将其中的特殊字符进行转义，从而避免XSS攻击。例如，可以使用Jsoup库中的`clean`方法来过滤HTML标签。 2. 防止SQL注入：可以使用过滤器对请求参数进行过滤，将其中的特殊字符进行转义，从而避免SQL注入。例如，可以使用`org.springframework.web.util.HtmlUtils.htmlEscape`方法对请求参数进行转义。 以下是一个示例过滤器的代码： ```java @Component @Order(Ordered.HIGHEST_PRECEDENCE) public class XssSqlFilter implements Filter { @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest req = (HttpServletRequest) request; // XSS过滤 XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper(req); // SQL注入过滤 SqlFilterRequestWrapper sqlRequest = new SqlFilterRequestWrapper(xssRequest); chain.doFilter(sqlRequest, response); } } ``` 其中，`XssHttpServletRequestWrapper`和`SqlFilterRequestWrapper`分别是对`HttpServletRequest`的包装类，用于在请求中过滤XSS和SQL注入。 需要注意的是，过滤器的执行顺序可以通过实现`Ordered`接口来指定，从而保证过滤器的正确执行顺序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值