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

一 跨网站脚本

跨网站脚本（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

1. <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
4.   
5.   <filter>  
6.      <filter-name>XssSqlFilter</filter-name>  
7.      <filter-class>framework.corenew.XssFilter</filter-class>  
8.   </filter>  
9.     <filter-mapping>  
10.      <filter-name>XssSqlFilter</filter-name>  
11.      <url-pattern>/*</url-pattern>  
12.      <dispatcher>REQUEST</dispatcher>  
13.   </filter-mapping>  
14.       
15. </web-app>  

XssFilter：

[java]  view plain  copy

1. package framework.corenew;  
2.   
3. import java.io.IOException;  
4. import java.util.Enumeration;  
5. import java.util.regex.Pattern;  
6.   
7. import javax.servlet.Filter;  
8. import javax.servlet.FilterChain;  
9. import javax.servlet.FilterConfig;  
10. import javax.servlet.ServletException;  
11. import javax.servlet.ServletRequest;  
12. import javax.servlet.ServletResponse;  
13. import javax.servlet.http.HttpServletRequest;  
14.   
15. import business.sysinfo.model.User;  
16.   
17. /** 
18.  * <code>{@link CharLimitFilter}</code> 
19.  * 
20.  * 拦截防止sql注入 
21.  * 
22.  * @author Administrator 
23.  */  
24. public class XssFilter implements Filter {  
25.   
26.     FilterConfig filterConfig = null;  
27.   
28.     public void init(FilterConfig filterConfig) throws ServletException {  
29.         this.filterConfig = filterConfig;  
30.     }  
31.   
32.     public void destroy() {  
33.         this.filterConfig = null;  
34.     }  
35.   
36.     public void doFilter(ServletRequest request, ServletResponse response,  
37.             FilterChain chain) throws IOException, ServletException {  
38.           
39.   
40.         chain.doFilter(new XssHttpServletRequestWrapperNew(  
41.                     (HttpServletRequest) request), response);  
42.    
43.   
44.     }  
45.   
46.       
47.   
48.   
49.   
50. }  

XssHttpServletRequestWrapperNew：

[java]  view plain  copy

1. package com.csnt.ecs.core.security.filter;  
2.   
3. import java.text.CharacterIterator;  
4. import java.text.StringCharacterIterator;  
5. import java.util.regex.Pattern;  
6.   
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletRequestWrapper;  
9.   
10. public class XssHttpServletRequestWrapperNew extends HttpServletRequestWrapper {  
11.   
12.     HttpServletRequest orgRequest = null;  
13.   
14.     public XssHttpServletRequestWrapperNew(HttpServletRequest request) {  
15.         super(request);  
16.         orgRequest = request;  
17.     }  
18.   
19.     /** 
20.      * 覆盖getParameter方法，将参数名和参数值都做xss过滤。 
21.      * 如果需要获得原始的值，则通过super.getParameterValues(name)来获取 
22.      * getParameterNames,getParameterValues和getParameterMap也可能需要覆盖 
23.      */  
24.     @Override  
25.     public String getParameter(String name) {  
26.         String value = super.getParameter(xssEncode(name));  
27.         if (value != null) {  
28.             value = xssEncode(value);  
29.             value = HTMLEncode(value);  
30.         }  
31.         return value;  
32.     }  
33.   
34.     /** 
35.      * 对一些特殊字符进行转义 
36.      *  
37.      *  
38.      */  
39.     public static String HTMLEncode(String aText) {  
40.         final StringBuilder result = new StringBuilder();  
41.         final StringCharacterIterator iterator = new StringCharacterIterator(  
42.                 aText);  
43.         char character = iterator.current();  
44.         while (character != CharacterIterator.DONE) {  
45.             if (character == '<') {  
46.                 result.append("<");  
47.             } else if (character == '>') {  
48.                 result.append(">");  
49.             } else if (character == '&') {  
50.                 result.append("&");  
51.             } else if (character == '\"') {  
52.                 result.append(""");  
53.             } else {  
54.                 // the char is not a special one  
55.                 // add it to the result as is  
56.                 result.append(character);  
57.             }  
58.             character = iterator.next();  
59.         }  
60.         return result.toString();  
61.     }  
62.   
63.     /** 
64.      * 覆盖getHeader方法，将参数名和参数值都做xss过滤。 如果需要获得原始的值，则通过super.getHeaders(name)来获取 
65.      * getHeaderNames 也可能需要覆盖 
66.      */  
67.     @Override  
68.     public String getHeader(String name) {  
69.   
70.         String value = super.getHeader(xssEncode(name));  
71.         if (value != null) {  
72.             value = xssEncode(value);  
73.         }  
74.         return value;  
75.     }  
76.   
77.     /** 
78.      * 将容易引起xss漏洞的半角字符直接替换成全角字符 
79.      * 目前xssProject对注入代码要求是必须开始标签和结束标签(如<script></script>)正确匹配才能解析，否则报错；因此只能替换调xssProject换为自定义实现 
80.      * @param s 
81.      * @return 
82.      */  
83.     private static String xssEncode(String s) {  
84.         //  
85.         // if (s == null || s.isEmpty()) {  
86.         // return s;  
87.         // }  
88.         //  
89.         // StringReader reader = new StringReader(s);  
90.         // StringWriter writer = new StringWriter();  
91.         // try {  
92.         // HTMLParser.process(reader, writer, new XSSFilter(), true);  
93.         //  
94.         // String result = writer.toString();  
95.         //  
96.         // System.out.println("xssEncode-------------------------" + s + " = "  
97.         // + result);  
98.         //  
99.         // return result;  
100.         // } catch (NullPointerException e) {  
101.         // return s;  
102.         // } catch (Exception ex) {  
103.         // ex.printStackTrace();  
104.         // }  
105.         //  
106.         // return null;  
107.         if (s == null || s.isEmpty()) {  
108.             return s;  
109.         }  
110.   
111.         String result = stripXSS(s);  
112.         if (null != result) {  
113.             result = escape(result);  
114.         }  
115.   
116.         return result;  
117.   
118.     }  
119.   
120.     public static String escape(String s) {  
121.         StringBuilder sb = new StringBuilder(s.length() + 16);  
122.         for (int i = 0; i < s.length(); i++) {  
123.             char c = s.charAt(i);  
124.             switch (c) {  
125.             case '>':  
126.                 sb.append('＞');// 全角大于号  
127.                 break;  
128.             case '<':  
129.                 sb.append('＜');// 全角小于号  
130.                 break;  
131.             case '\'':  
132.                 sb.append('‘');// 全角单引号  
133.                 break;  
134.             case '\"':  
135.                 sb.append('“');// 全角双引号  
136.                 break;  
137.             case '\\':  
138.                 sb.append('＼');// 全角斜线  
139.                 break;  
140.             case '%':  
141.                 sb.append('％'); // 全角冒号  
142.                 break;  
143.             default:  
144.                 sb.append(c);  
145.                 break;  
146.             }  
147.   
148.         }  
149.         return sb.toString();  
150.     }  
151.   
152.     private static String stripXSS(String value) {  
153.         if (value != null) {  
154.             // NOTE: It's highly recommended to use the ESAPI library and  
155.             // uncomment the following line to  
156.             // avoid encoded attacks.  
157.             // value = ESAPI.encoder().canonicalize(value);  
158.             // Avoid null characters  
159.             value = value.replaceAll("", "");  
160.             // Avoid anything between script tags  
161.             Pattern scriptPattern = Pattern.compile("<script>(.*?)</script>",  
162.                     Pattern.CASE_INSENSITIVE);  
163.             value = scriptPattern.matcher(value).replaceAll("");  
164.             // Avoid anything in a src='...' type of expression  
165.             scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'",  
166.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
167.                             | Pattern.DOTALL);  
168.             value = scriptPattern.matcher(value).replaceAll("");  
169.             scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"",  
170.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
171.                             | Pattern.DOTALL);  
172.             value = scriptPattern.matcher(value).replaceAll("");  
173.             // Remove any lonesome </script> tag  
174.             scriptPattern = Pattern.compile("</script>",  
175.                     Pattern.CASE_INSENSITIVE);  
176.             value = scriptPattern.matcher(value).replaceAll("");  
177.             // Remove any lonesome <script ...> tag  
178.             scriptPattern = Pattern.compile("<script(.*?)>",  
179.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
180.                             | Pattern.DOTALL);  
181.             value = scriptPattern.matcher(value).replaceAll("");  
182.             // Avoid eval(...) expressions  
183.             scriptPattern = Pattern.compile("eval\\((.*?)\\)",  
184.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
185.                             | Pattern.DOTALL);  
186.             value = scriptPattern.matcher(value).replaceAll("");  
187.             // Avoid expression(...) expressions  
188.             scriptPattern = Pattern.compile("expression\\((.*?)\\)",  
189.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
190.                             | Pattern.DOTALL);  
191.             value = scriptPattern.matcher(value).replaceAll("");  
192.             // Avoid javascript:... expressions  
193.             scriptPattern = Pattern.compile("javascript:",  
194.                     Pattern.CASE_INSENSITIVE);  
195.             value = scriptPattern.matcher(value).replaceAll("");  
196.             // Avoid vbscript:... expressions  
197.             scriptPattern = Pattern.compile("vbscript:",  
198.                     Pattern.CASE_INSENSITIVE);  
199.             value = scriptPattern.matcher(value).replaceAll("");  
200.             // Avoid οnlοad= expressions  
201.             scriptPattern = Pattern.compile("onload(.*?)=",  
202.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
203.                             | Pattern.DOTALL);  
204.             value = scriptPattern.matcher(value).replaceAll("");  
205.   
206.             scriptPattern = Pattern.compile("<iframe>(.*?)</iframe>",  
207.                     Pattern.CASE_INSENSITIVE);  
208.             value = scriptPattern.matcher(value).replaceAll("");  
209.   
210.             scriptPattern = Pattern.compile("</iframe>",  
211.                     Pattern.CASE_INSENSITIVE);  
212.             value = scriptPattern.matcher(value).replaceAll("");  
213.             // Remove any lonesome <script ...> tag  
214.             scriptPattern = Pattern.compile("<iframe(.*?)>",  
215.                     Pattern.CASE_INSENSITIVE | Pattern.MULTILINE  
216.                             | Pattern.DOTALL);  
217.             value = scriptPattern.matcher(value).replaceAll("");  
218.         }  
219.         return value;  
220.     }  
221.   
222.     /** 
223.      * 获取最原始的request 
224.      *  
225.      * @return 
226.      */  
227.     public HttpServletRequest getOrgRequest() {  
228.         return orgRequest;  
229.     }  
230.   
231.     /** 
232.      * 获取最原始的request的静态方法 
233.      *  
234.      * @return 
235.      */  
236.     public static HttpServletRequest getOrgRequest(HttpServletRequest req) {  
237.         if (req instanceof XssHttpServletRequestWrapperNew) {  
238.             return ((XssHttpServletRequestWrapperNew) req).getOrgRequest();  
239.         }  
240.   
241.         return req;  
242.     }  
243.   
244. }  

原博： http://blog.csdn.net/a364726306/article/details/51917204