【系统安全】防止SQL注入、XSS攻击、CSRF/CROS恶意访问解决方案

迷南。 2022-10-23 04:00 30阅读 0赞

### 文章目录 ###

*  一、SQL注入问题
 *   *  （1）什么是SQL注入
     *  （2）防止SQL注入
 *  二、XSS攻击问题
 *   *  （1）什么是XSS攻击
     *  （2）防止XSS攻击
 *  三、CSRF/CROS恶意访问
 *   *  （1）什么是CSRF/CROS恶意访问
     *  （2）解决办法
 *  四、解决方案
 *  微信公众号

# 一、SQL注入问题 #

## （1）什么是SQL注入 ##

SQL注入即是指web应用程序对用户输入数据的合法性没有判断或过滤不严，攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句，在管理员不知情的情况下实现非法操作，以此来实现欺骗数据库服务器执行非授权的任意查询，从而进一步得到相应的数据信息。

简单来说，就是将部分SQL语句当参数传入系统中，从而获取系统中的数据。下面简单举例说明

系统中有这样一条SQL语句执行，分页查询所有用户，每页查询20条，并且根据指定字段进行排序，也就是说排序字段也是参数传递过来的

select * from user_info order by ${fieldName} desc limit ${page}, ${limit};
    
    # 正常执行的SQL
    select * from user_info order by id desc limit 0, 20;

假如说，懂行的人恶意将排序参数修改为以下格式

select * from user_info order by id; select 1 -- desc limit 0, 20;

SQL注入问题分析：

*  攻击者注入了类似这样的参数：`-1; 锁表语句--`
 *  其中`;`前面的语句先执行了
 *  由于`--`后面的语句会被注释掉，接下来只会执行锁表语句，把表锁住
 *  正常业务请求从数据库获得连接之后，尝试获取锁表，但是一直获取不到，直到超时
 *  数据库连接池不够用，没有空闲连接
 *  新的业务请求获取不到数据库连接，报错数据库连接过多异常

这样很简单的一句SQL，就可以把系统搞炸掉，这种方式可以实现删库跑路

-1; delete  from  user; --

以上语句会把整个test数据库所有内容都删掉

## （2）防止SQL注入 ##

*  使用预编译机制

尽量用预编译机制，少用字符串拼接的方式传参，它是sql注入问题的根源。

*  要对特殊字符转义

有些特殊字符，比如：%作为like语句中的参数时，要对其进行转义处理。

*  要捕获异常

需要对所有的异常情况进行捕获，切记接口直接返回异常信息，因为有些异常信息中包含了sql信息，包括：库名，表名，字段名等。攻击者拿着这些信息，就能通过sql注入随心所欲的攻击你的数据库了。目前比较主流的做法是，有个专门的网关服务，它统一暴露对外接口。用户请求接口时先经过它，再由它将请求转发给业务服务。这样做的好处是：能统一封装返回数据的返回体，并且如果出现异常，能返回统一的异常信息，隐藏敏感信息。此外还能做限流和权限控制。

*  使用代码检测工具

使用sqlMap等代码检测工具，它能检测sql注入漏洞。

*  要有监控

需要对数据库sql的执行情况进行监控，有异常情况，及时邮件或短信提醒。

*  数据库账号需控制权限

对生产环境的数据库建立单独的账号，只分配DML相关权限，且不能访问系统表。切勿在程序中直接使用管理员账号。

*  代码review

建立代码review机制，能找出部分隐藏的问题，提升代码质量。

*  使用其他手段处理

对于不能使用预编译传参时，要么开启druid的filter防火墙，要么自己写代码逻辑过滤掉所有可能的注入关键字。

# 二、XSS攻击问题 #

## （1）什么是XSS攻击 ##

XSS攻击通常指的是通过利用网页开发时留下的漏洞，通过巧妙的方法注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript，但实际上也可以包括Java、 VBScript、ActiveX、 Flash 或者甚至是普通的HTML。攻击成功后，攻击者可能得到包括但不限于更高的权限（如执行一些操作）、私密网页内容、会话和cookie等各种内容。

通常情况下，被用来盗用Cookie、破坏页面结构、重定向到其他网站等

## （2）防止XSS攻击 ##

对用户输入的表单信息进行检测过滤

# 三、CSRF/CROS恶意访问 #

## （1）什么是CSRF/CROS恶意访问 ##

CSRF - Cross-Site Request Forgery - 跨站请求伪造:

攻击可以在受害者毫不知情的情况下以受害者名义伪造请求发送给受攻击站点，从而在未授权的情况下执行在权限保护之下的操作，CORS - Cross Origin Resourse-Sharing - 跨站资源共享，恶意访问内网敏感资源。

## （2）解决办法 ##

有效的解决办法是通过多种条件屏蔽掉非法的请求，例如HTTP头、参数等：

*  不信任未经身份验证的跨域请求，应该首先验证Session ID或者Cookie
 *  对于请求方来说验证接收的数据有效性，服务方仅暴露最少最必须的功能
 *  通过多种条件屏蔽掉非法的请求，例如HTTP头、参数等
 *  服务端代码跨域设置，设置了nginx转发，也可设置在nginx中

防止大规模的恶意请求，niginx反向代理可以配置请求频率，对ip做限制。nginx可以很方便地做访问控制，特别是一些偶发性的大量恶意请求，需要屏蔽处理。

**屏蔽ip地址**

location /someapi/ { 
    allow ip;  #特定接口只开放给某个ip调用
    deny all;
    }
    
    location /somepage/ { 
    deny ip;   #屏蔽某个ip访问（iptables可以拒绝某个ip连接）
    allow all;
    }

**屏蔽user-agent**

if ($http_user_agent = Mozilla/5.0 ) {  return 403; }   #有些请求头很明显不是用户浏览器
    
    分析nginx日志，找出恶意ip或user-agent
    
    cat /var/log/nginx/access.log | awk -F\" '{A[$(NF-1)]++}END{for(k in A)print A[k],k}' | sort -n |tail
    122 58.144.7.66
    337 106.91.201.75
    2270 122.200.77.170  #显然这个ip不正常，而且这不是nginx所知道的真实ip，而是$http_x_forwarded_for变量

**屏蔽代理ip**

有两种情形会需要屏蔽代理ip：一是代理ip访问，二是负载均衡（real-ip请求负载均衡服务器，再代理给后端server）

vi /etc/nginx/badproxy.rules
    map $http_x_forwarded_for $badproxy { 
            default 0;
            ~*122.200.77.170  1;  #建立映射
    }
    vi /etc/nginx/nginx.conf
    http { 
    include /etc/nginx/badproxy.rules  #这个要在server配置之前
    server { 
        location /somepage/ { 
            if ( $badproxy ) {  return 403; }
        }
    }
    }

# 四、解决方案 #

创建XssAndSqlHttpServletRequestWrapper包装器，这是实现XSS过滤的关键，在其内重写了getParameter，getParameterValues，getHeader等方法，对http请求内的参数进行了过滤

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;
    
    import com.sgcc.uap.utils.stream.StreamUtil;
    
    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 οnlοad= 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 οnlοad= expressions
                scriptPattern = Pattern.compile("onload(.*?)=",
                        Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
                flag = scriptPattern.matcher(value).find();
                if (flag) { 
                    return flag;
                }
               scriptPattern = Pattern.compile("\\b(and|exec|insert|select|drop|grant|alter|delete|update|count|chr|mid|master|truncate|char|declare|or)\\b|(\\*|;|\\+|'|%)",
                        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 
                      
                }    
            };    
        }
    
    }

然后编写过滤器

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;
    
    public class XssAndSqlFilter implements Filter { 
    
        @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(JSONObject.toJSONString("您所访问的页面请求中有违反安全规则元素存在，拒绝访问!"));
                        return;
                    }
                }
            }
            if (xssRequest.checkParameter()) { 
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/json;charset=UTF-8");
                PrintWriter out = response.getWriter();
                out.write(JSONObject.toJSONString("您所访问的页面请求中有违反安全规则元素存在，拒绝访问!"));
                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;
    
        }
    }

注册过滤器XssAndSqlFilter

import java.util.Map;
    
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import com.beust.jcommander.internal.Maps;
    import com.swireproperties.cams.common.filter.XssAndSqlFilter;
    
    /** * web配置 */
    @Configuration
    public class WebConfig { 
    
        @Bean
        public FilterRegistrationBean xssFilterRegistrationBean() { 
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            filterRegistrationBean.setFilter(new XssAndSqlFilter());
            filterRegistrationBean.setOrder(1);
            filterRegistrationBean.setEnabled(true);
            filterRegistrationBean.addUrlPatterns("/*");
            Map<String, String> initParameters = Maps.newHashMap();
            initParameters.put("excludes", "/favicon.ico,/img/*,/js/*,/css/*");
            initParameters.put("isIncludeRichText", "true");
            filterRegistrationBean.setInitParameters(initParameters);
            return filterRegistrationBean;
        }
    
    }

\-excludes用于配置不需要参数过滤的请求url

\-isIncludeRichText默认为true，主要用于设置富文本内容是否需要过滤

# 微信公众号 #

![每天Get一个小技巧][Get]

[Get]: /images/20221022/0083897fe65641f4ae841341d735634c.png