JAVA：URL存在跨站漏洞,注入漏洞解决方案

跨网站脚本介绍
一 跨网站脚本
跨网站脚本（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配置：

<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：

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：

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 onload= 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;  
    }  

}