XSS跨站攻击注入漏洞解决方案

最新推荐文章于 2024-09-13 09:25:18 发布

William.Wangmy

最新推荐文章于 2024-09-13 09:25:18 发布

阅读量1.2k

点赞数

一跨网站脚本

跨网站脚本（Cross-site scripting，通常简称为XSS或跨站脚本或跨站脚本攻击）是一种网站应用程序的安全漏洞攻击，是代码注入的一种。它允许恶意用户将代码注入到网页上，其他用户在观看网页时就会受到影响。这类攻击通常包含了HTML以及用户端脚本语言。

XSS攻击通常指的是通过利用网页开发时留下的漏洞，通过巧妙的方法注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序。这些恶意网页程序通常是JavaScript，但实际上也可以包括Java， VBScript， ActiveX， Flash 或者甚至是普通的HTML。攻击成功后，攻击者可能得到包括但不限于更高的权限（如执行一些操作）、私密网页内容、会话和cookie等各种内容。
二常用的XSS攻击手段和目的
盗用 cookie ，获取敏感信息。
利用植入 Flash ，通过 crossdomain 权限设置进一步获取更高权限；或者利用Java等得到类似的操作。
利用 iframe、frame、XMLHttpRequest或上述Flash等方式，以（被攻击）用户的身份执行一些管理动作，或执行一些一般的如发微博、加好友、发私信等操作。
利用可被攻击的域受到其他域信任的特点，以受信任来源的身份请求一些平时不允许的操作，如进行不当的投票活动。
在访问量极大的一些页面上的XSS可以攻击一些小型网站，实现DDoS攻击的效果。
三漏洞的防御和利用
避免XSS的方法之一主要是将用户所提供的内容进行过滤，许多语言都有提供对HTML的过滤：

    PHP的htmlentities()或是htmlspecialchars()。
    Python的cgi.escape()。
    ASP的Server.HTMLEncode()。
    ASP.NET的Server.HtmlEncode()或功能更强的Microsoft Anti-Cross Site Scripting Library
    Java的xssprotect(Open Source Library)。

Node.js的node-validator。

四解决方案

我碰到的问题解决方案主要是对request请求的parameter 参数做过滤与字符转义

web.xml配置：

[html]view plain copy 
   
 <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
   
   <filter>  
      <filter-name>XssSqlFilter</filter-name>  
      <filter-class>framework.corenew.XssFilter</filter-class>  
   </filter>  
     <filter-mapping>  
      <filter-name>XssSqlFilter</filter-name>  
      <url-pattern>/*</url-pattern>  
      <dispatcher>REQUEST</dispatcher>  
   </filter-mapping>  
       
 </web-app>  

XssFilter：

[java]view plain copy 
   
 package framework.corenew;  
   
 import java.io.IOException;  
 import java.util.Enumeration;  
 import java.util.regex.Pattern;  
   
 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 business.sysinfo.model.User;  
   
 /** 
  * <code>{@link CharLimitFilter}</code> 
  * 
  * 拦截防止sql注入 
  * 
  * @author Administrator 
  */  
 public class XssFilter implements Filter {  
   
     FilterConfig filterConfig = null;  
   
     public void init(FilterConfig filterConfig) throws ServletException {  
         this.filterConfig = filterConfig;  
     }  
   
     public void destroy() {  
         this.filterConfig = null;  
     }  
   
     public void doFilter(ServletRequest request, ServletResponse response,  
             FilterChain chain) throws IOException, ServletException {  
           
   
         chain.doFilter(new XssHttpServletRequestWrapperNew(  
                     (HttpServletRequest) request), response);  
    
   
     }  
   
       
   
   
   
 }  

XssHttpServletRequestWrapperNew：

[java]view plain copy 
   
 package com.csnt.ecs.core.security.filter;  
   
 import java.text.CharacterIterator;  
 import java.text.StringCharacterIterator;  
 import java.util.regex.Pattern;  
   
 import javax.servlet.http.HttpServletRequest;  
 import javax.servlet.http.HttpServletRequestWrapper;  
   
 public class XssHttpServletRequestWrapperNew extends HttpServletRequestWrapper {  
   
     HttpServletRequest orgRequest = null;  
   
     public XssHttpServletRequestWrapperNew(HttpServletRequest request) {  
         super(request);  
         orgRequest = request;  
     }  
   
     /** 
      * 覆盖getParameter方法，将参数名和参数值都做xss过滤。 
      * 如果需要获得原始的值，则通过super.getParameterValues(name)来获取 
      * getParameterNames,getParameterValues和getParameterMap也可能需要覆盖 
      */  
     @Override  
     public String getParameter(String name) {  
         String value = super.getParameter(xssEncode(name));  
         if (value != null) {  
             value = xssEncode(value);  
             value = HTMLEncode(value);  
         }  
         return value;  
     }  
   
     /** 
      * 对一些特殊字符进行转义 
      *  
      *  
      */  
     public static String HTMLEncode(String aText) {  
         final StringBuilder result = new StringBuilder();  
         final StringCharacterIterator iterator = new StringCharacterIterator(  
                 aText);  
         char character = iterator.current();  
         while (character != CharacterIterator.DONE) {  
             if (character == '<') {  
                 result.append("<");  
             } else if (character == '>') {  
                 result.append(">");  
             } else if (character == '&') {  
                 result.append("&");  
             } else if (character == '\"') {  
                 result.append(""");  
             } else {  
                 // the char is not a special one  
                 // add it to the result as is  
                 result.append(character);  
             }  
             character = iterator.next();  
         }  
         return result.toString();  
     }  
   
     /** 
      * 覆盖getHeader方法，将参数名和参数值都做xss过滤。 如果需要获得原始的值，则通过super.getHeaders(name)来获取 
      * getHeaderNames 也可能需要覆盖 
      */  
     @Override  
     public String getHeader(String name) {  
   
         String value = super.getHeader(xssEncode(name));  
         if (value != null) {  
             value = xssEncode(value);  
         }  
         return value;  
     }  
   
     /** 
      * 将容易引起xss漏洞的半角字符直接替换成全角字符 
      * 目前xssProject对注入代码要求是必须开始标签和结束标签(如<script></script>)正确匹配才能解析，否则报错；因此只能替换调xssProject换为自定义实现 
      * @param s 
      * @return 
      */  
     private static String xssEncode(String s) {  
         //  
         // if (s == null || s.isEmpty()) {  
         // return s;  
         // }  
         //  
         // StringReader reader = new StringReader(s);  
         // StringWriter writer = new StringWriter();  
         // try {  
         // HTMLParser.process(reader, writer, new XSSFilter(), true);  
         //  
         // String result = writer.toString();  
         //  
         // System.out.println("xssEncode-------------------------" + s + " = "  
         // + result);  
         //  
         // return result;  
         // } catch (NullPointerException e) {  
         // return s;  
         // } catch (Exception ex) {  
         // ex.printStackTrace();  
         // }  
         //  
         // return null;  
         if (s == null || s.isEmpty()) {  
             return s;  
         }  
   
         String result = stripXSS(s);  
         if (null != result) {  
             result = escape(result);  
         }  
   
         return result;  
   
     }  
   
     public static String escape(String 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();  
     }  
   
     private static String stripXSS(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("<script>(.*?)</script>",  
                     Pattern.CASE_INSENSITIVE);  
             value = scriptPattern.matcher(value).replaceAll("");  
             // Avoid anything in a src='...' type of expression  
             scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'",  
                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
                             | Pattern.DOTALL);  
             value = scriptPattern.matcher(value).replaceAll("");  
             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("</script>",  
                     Pattern.CASE_INSENSITIVE);  
             value = scriptPattern.matcher(value).replaceAll("");  
             // Remove any lonesome <script ...> tag  
             scriptPattern = Pattern.compile("<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 expression(...) expressions  
             scriptPattern = Pattern.compile("expression\\((.*?)\\)",  
                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
                             | Pattern.DOTALL);  
             value = scriptPattern.matcher(value).replaceAll("");  
             // Avoid javascript:... expressions  
             scriptPattern = Pattern.compile("javascript:",  
                     Pattern.CASE_INSENSITIVE);  
             value = scriptPattern.matcher(value).replaceAll("");  
             // Avoid vbscript:... expressions  
             scriptPattern = Pattern.compile("vbscript:",  
                     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("");  
   
             scriptPattern = Pattern.compile("<iframe>(.*?)</iframe>",  
                     Pattern.CASE_INSENSITIVE);  
             value = scriptPattern.matcher(value).replaceAll("");  
   
             scriptPattern = Pattern.compile("</iframe>",  
                     Pattern.CASE_INSENSITIVE);  
             value = scriptPattern.matcher(value).replaceAll("");  
             // Remove any lonesome <script ...> tag  
             scriptPattern = Pattern.compile("<iframe(.*?)>",  
                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
                             | Pattern.DOTALL);  
             value = scriptPattern.matcher(value).replaceAll("");  
         }  
         return value;  
     }  
   
     /** 
      * 获取最原始的request 
      *  
      * @return 
      */  
     public HttpServletRequest getOrgRequest() {  
         return orgRequest;  
     }  
   
     /** 
      * 获取最原始的request的静态方法 
      *  
      * @return 
      */  
     public static HttpServletRequest getOrgRequest(HttpServletRequest req) {  
         if (req instanceof XssHttpServletRequestWrapperNew) {  
             return ((XssHttpServletRequestWrapperNew) req).getOrgRequest();  
         }  
   
         return req;  
     }  
   
 }  