`

XSS跨站漏洞修复

security正则表达式 
阅读更多
避免XSS跨站漏洞的方法之一主要是将用户所提交的内容输入输出进行过滤，包括请求路径过滤与参数过滤。这里，我写一个过滤器专门处理XSS跨站漏洞，思路是将带有非法字符的请求转发到一个指定页面，将参数的非法字符过滤去除。

过滤器代码如下： 
package com.eshore.itmp.model.web.security;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.regex.Pattern;

import javax.servlet.FilterChain;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.filter.OncePerRequestFilter;

/**
 * XSS漏洞过滤器
 * 
 * @author ahomeeye
 * 
 */
public class XssFilter extends OncePerRequestFilter {
	private static Log logger = LogFactory.getLog(XssFilter.class);
	private String forwardUrl = "/login.jsp";

	@Override
	protected void doFilterInternal(HttpServletRequest req,
			HttpServletResponse res, FilterChain filterChain)
			throws ServletException, IOException {
		String uri = req.getRequestURI();
		logger.info("-------uri=" + uri);

		// 过滤请求的参数名和参数值
		XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper(
				(HttpServletRequest) req);

		if (uri.contains("j_spring_security_check") && isContainSpecialChar(uri)) {// 判断uri是否合法
			logger.info("-------uri包含特殊字符 uri=" + xssRequest.getRequestURI());
			RequestDispatcher dispatcher = xssRequest
					.getRequestDispatcher(forwardUrl);
			dispatcher.forward(xssRequest, res);
		} else {
			filterChain.doFilter(xssRequest, res);// 执行其他过滤操作
		}

	}

	/**
	 * 判断字符串是否包含特殊字符
	 * 
	 * @param strVal
	 * @return
	 */
	public boolean isContainSpecialChar(String value) {
		String strVal = "";
		try {
			strVal = URLDecoder.decode(value, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			logger.error("URL解码错误", e);
		}
		boolean flag = false;
		if (match(".*?<script\\b.*?>*?</script>.*?", strVal)) {// //匹配js脚本字符串
			flag = true;
		} else if (match(".*?<.*?>.*?", strVal)) {// 匹配html标签字符串
			flag = true;
		}
		return flag;
	}

	/**
	 * 匹配正则表达式，大小写不敏感
	 * 
	 * @param regex
	 * @param input
	 * @return
	 */
	public boolean match(String regex, CharSequence input) {
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		return p.matcher(input).matches();
	}

	public String getForwardUrl() {
		return forwardUrl;
	}

	public void setForwardUrl(String forwardUrl) {
		this.forwardUrl = forwardUrl;
	}

}

在xml文件中声明过滤器，配置过滤器链 
	<beans:bean id="xssFilter" class="com.eshore.itmp.model.web.security.XssFilter" p:forwardUrl="/login.jsp">
	</beans:bean>
<beans:bean id="springSecurityFilterChain" class="org.springframework.security.web.FilterChainProxy">
		<filter-chain-map path-type="ant">
			<filter-chain pattern="/kaptcha.validate" filters="none" />
			<filter-chain pattern="/services/**" filters="none" />
			<filter-chain pattern="/media/**" filters="none" />
			<filter-chain pattern="/css/**" filters="none" />
			<filter-chain pattern="/images/**" filters="none" />
			<filter-chain pattern="/js/**" filters="none" />
			<filter-chain pattern="/page/**" filters="none" />
			<filter-chain pattern="/My97DatePicker/**" filters="none" />
			<filter-chain pattern="/login.jsp" filters="none" />
			<filter-chain pattern="/phytopo/**" filters="none" />
			<filter-chain pattern="/relationView/**" filters="none" />
			<!-- add -->
			<filter-chain pattern="/oaLogin.do" filters="none" />
			<filter-chain pattern="/selection/**" filters="none" />
			<filter-chain pattern="/entity/**" filters="none" />
			<filter-chain pattern="/upload/**" filters="none" />

			<filter-chain pattern="/assessmentKpi/getExcelData.do**" filters="none" />

			<!-- add -->
			<filter-chain pattern="/logoutSuccess.jsp" filters="none" />
			<filter-chain pattern="/**" filters="
				xssFilter,
				securityContextPersistenceFilter,
				logoutFilter,
				usernamePasswordAuthenticationFilter,
				anonymousAuthenticationFilter,
				exceptionTranslationFilter,
				itmpCustomInterceptor,
				sysLogFilter" />
		</filter-chain-map>
	</beans:bean>


重写HttpServletRequest，覆盖一些方法 
package com.eshore.itmp.model.web.security;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.regex.Pattern;

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

/**
 * 请求参数过滤器(修复跨站脚本漏洞)
 * 
 * @author ahomeeye
 * 
 */
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {

	HttpServletRequest orgRequest = null;

	public XssHttpServletRequestWrapper(HttpServletRequest request) {
		super(request);
		orgRequest = request;
	}

	/**
	 * 覆盖getParameter方法，将参数名和参数值都做xss过滤。<br/>
	 * 如果需要获得原始的值，则通过super.getParameterValues(name)来获取<br/>
	 * getParameterNames,getParameterValues和getParameterMap也可能需要覆盖
	 */
	@Override
	public String getParameter(String name) {
		String value = super.getParameter(xssEncode(name));
		if (value != null) {
			value = xssEncode(value);
		}

		return value;
	}

	@Override
	public Object getAttribute(String name) {
		Object value = super.getAttribute(xssEncode(name));
		if (value instanceof String) {
			return xssEncode(value.toString());
		}

		return value;
	}

	/**
	 * 覆盖getHeader方法，将参数名和参数值都做xss过滤。<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;
	}

	@Override
	public String getRequestURI() {

		String strVal = "";
		try {
			strVal = URLDecoder.decode(super.getRequestURI(), "UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		String value = xssEncode(strVal);
		if (value != null) {
			value = xssEncode(value);
		}

		return value;
	}

	public 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;
			case ';':
				sb.append('；'); // 全角分号
				break;
			default:
				sb.append(c);
				break;
			}

		}
		return sb.toString();
	}

	/**
	 * 将容易引起xss漏洞的半角字符直接替换成全角字符
	 * 
	 * @param s
	 * @return
	 */
	public String xssEncode(String s) {
		if (s == null || s.isEmpty()) {
			return s;
		}

		String result = stripXSS(s);
		if (null != result) {
			result = escape(result);
		}

		return result;
	}

	private 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("");
			value = value.replace(";", "");
			value = value.replace("<", "");
			value = value.replace(">", "");
		}
		return value;
	}

	/**
	 * 获取最原始的request
	 * 
	 * @return
	 */
	public HttpServletRequest getOrgRequest() {
		return orgRequest;
	}

	@Override
	public HttpServletRequest getRequest() {
		return orgRequest;
	}

	/**
	 * 获取最原始的request的静态方法
	 * 
	 * @return
	 */
	public static HttpServletRequest getOrgRequest(HttpServletRequest req) {
		if (req instanceof XssHttpServletRequestWrapper) {
			return ((XssHttpServletRequestWrapper) req).getOrgRequest();
		}

		return req;
	}

}


最后，给个页面表单例子： 
<script type="text/javascript">
		function setPass(originId,decId){
			var orginName = window.parent.document.getElementById('orginName').value;
			var newName = strEnc(orginName,'itmp','des','encrypt');
			window.parent.document.getElementById('userId').value = newName;
			
			var orginPass = window.parent.document.getElementById(originId).value;
			var newPass = strEnc(orginPass,'itmp','des','encrypt');
			//alert('newPass=' + newPass + ' pass='+strDec(newPass,'itmp','des','encrypt'));
			window.parent.document.getElementById(decId).value = newPass;
		}
	</script>

<form id="form" name="form" action="${ctx}/j_spring_security_check" method="post">
	<table width="100%" border="0" cellspacing="0" cellpadding="0">
 	 <tr>
     	<td width="20%" height="10" class="black14" align="center" valign="middle"></td>
     	<td colspan="2" align="left">
        	<div class="error${param.error==true?'':'hide'}" style="color:red;">
		${sessionScope['SPRING_SECURITY_LAST_EXCEPTION'].message}
		</div>
    	</td>
    </tr>
   <tr>
     <td width="20%" height="35" class="black14">用户名</td>
     <td colspan="2" align="left"><label >
       <input type="text" id="orginName" value="${sessionScope['SPRING_SECURITY_LAST_USERNAME']}" class="input" />
       <input type="hidden" id="userId" name="j_username" value="" class="input"/>
     </label></td>
   </tr>
   <tr>
     <td height="35" class="black14">密&nbsp;&nbsp;&nbsp;码</td>
     <td colspan="2" align="left"><label >
       <input type="password" id="orginPass" class="input" onblur="setPass('orginPass','password');"/>
       <input type="hidden" name="j_password" id="password" class="input"/>
     </label></td>
   </tr>
   <tr>
     <td height="35" class="black14">验证码</td>
     <td width="37%" align="left"><label>
       <input type="text" name="validateCode" class="input2"/>
     </label></td>
     <td width="43%" align="left">
     	<img onclick="this.src='kaptcha.validate'" src="kaptcha.validate" width="77" height="28" />
     </td>
   </tr>
   <tr>
     <td height="93" colspan="3" align="center">
     	<a href="#">
     		<input type="image" src="${ctx}/css/remake/images/button_login.gif" width="111" height="36" border="0" />
     	</a>
     </td>
   </tr>
 </table>
</form>


参考网址：
http://yunjiechao-163-com.iteye.com/blog/1973803
http://www.cnblogs.com/wuhuacong/archive/2013/04/15/3022011.html
分享到：
| JS Date函数整理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    XSS跨站脚本攻击漏洞修复方法

    **XSS跨站脚本攻击漏洞修复方法** XSS（Cross-Site Scripting）跨站脚本攻击是一种常见的网络安全威胁，它允许攻击者在用户的浏览器上执行恶意代码，从而窃取用户敏感信息、操纵用户行为或者对网站进行破坏。本文将...

    SQL+XSS漏洞修复方案

    SQL注入和跨站脚本（XSS）是两种常见的网络安全漏洞，它们对网站的数据安全性和用户隐私构成严重威胁。在本文中，我们将深入探讨这两种漏洞的原理、危害以及如何通过核心代码修复这些问题。 首先，SQL注入是攻击者...

    修复swfupload2.5版存在的XSS跨站攻击漏洞

    2.5版本中发现的安全问题，即XSS（跨站脚本）漏洞，是一个重要的安全关注点，因为它可能允许攻击者注入恶意代码，对网站的用户造成危害。 XSS攻击是网络安全中的常见威胁，它利用了网站没有充分验证和过滤用户输入...

    XSS跨站脚本攻击

    ### XSS跨站脚本攻击详解 #### 一、XSS跨站脚本攻击概述 XSS（Cross-Site Scripting）跨站脚本攻击是一种常见的Web应用安全威胁，其核心在于利用网站对用户输入数据的处理不当，允许攻击者注入恶意脚本到网页中，...

    XSS 跨站脚本攻击及防范

    XSS（Cross Site Scripting）跨站脚本攻击是一种网络安全漏洞，主要针对Web应用程序，让攻击者能够在受害者的浏览器上执行恶意脚本。攻击者通过在网页中插入有害的HTML代码，当用户浏览该页面时，这些代码会被执行，...

    XSS漏洞挖掘与安全防护.pdf

    XSS（Cross Site Scripting，跨站脚本攻击）是一种常见的Web安全漏洞。它允许攻击者在用户的浏览器中执行脚本，从而窃取信息或进行恶意操作。XSS攻击有多种形式，包括反射型（存储型和DOM型）。XSS通常通过网站或...

    web安全技术-实验七、跨站脚本攻击（xss）（反射型）.doc

    【跨站脚本攻击（XSS）概述】 XSS，全称Cross Site Scripting，是一种常见的Web应用程序安全漏洞，攻击者利用此漏洞向网页中注入恶意脚本，当其他用户浏览该页面时，这些脚本会被执行，从而可能窃取用户的敏感信息...

    javaweb配置xssproject，完美解决安全检测报XSS漏洞

    JavaWeb配置XSSProject是为了有效防止XSS（跨站脚本攻击）这一常见的网络安全问题。XSS攻击允许攻击者在用户的浏览器中注入恶意脚本，可能导致数据泄露、用户会话劫持等严重后果。XSSProject是一个专门针对XSS攻击...

    xss漏洞jar.rar

    跨站脚本（Cross site script，简称xss）是一种“HTML注入”，由于攻击的脚本多数时候是跨域的，所以称之为“跨域脚本”。 我们常常听到“注入”...可以通过导入以下两个jar，通过配置实现xss漏洞修复，无需修改代码

    xss.me跨站平台源码 Sae版本

    "XSS.me跨站平台源码 Sae版本"是一个用于测试和研究XSS漏洞的平台，它基于云服务Sina App Engine (Sae)运行。Sae是新浪推出的一个PaaS（Platform as a Service）平台，允许开发者在无需管理服务器基础设施的情况下...

    XSS跨站脚本攻击方法初探

    ### XSS跨站脚本攻击方法初探 #### 摘要 本文主要探讨了XSS（Cross Site Scripting，跨站脚本）攻击的基本概念、原理及其常见的几种攻击手法。XSS攻击是一种针对Web应用程序的安全漏洞，攻击者通过在合法网站上插入...

    xss跨站脚本攻击详解

    ### XSS跨站脚本攻击详解 #### 一、XSS攻击概述 XSS攻击，全称为**跨站脚本攻击**（Cross Site Scripting），是一种常见的网络安全漏洞，它发生在Web应用程序未能正确过滤用户输入的数据时。攻击者可以借此机会将...

    XSS漏洞解决方案实例

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

    第28天：WEB漏洞-XSS跨站之WAF绕过及安全修复1

    WEB 漏洞-XSS 跨站之 WAF 绕过及安全修复#常规 WAF 绕过思路标签语法替换特殊符号干扰提交方式更改垃圾数据溢出加密解密算法结合其他漏洞绕过#自动化

    Input XSS最新漏洞及利用

    而在登录界面，如果系统没有对用户名反馈信息进行过滤，攻击者可以输入恶意脚本，如"&lt;iframe&gt;"，当用户收到错误提示时，恶意代码会在页面中执行，从而实现跨站脚本攻击。 以百度Passport登录页面为例，攻击者可以在...

    解决XSS跨站脚本攻击

    XSS（跨站脚本）攻击是Web应用安全领域的一大威胁，主要表现为攻击者通过注入可执行的HTML代码，利用用户的身份执行恶意操作。这种攻击的根源在于网站对用户输入的处理不当，没有进行充分的过滤和转义，使得攻击者的...

    开发代码安全规范-防SQL注入和XSS跨站攻击代码编写规范.pdf

    【开发代码安全规范-防SQL注入和XSS跨站攻击】是针对互联网应用程序开发中的重要安全问题，旨在提升开发人员的安全编程意识，防止恶意攻击对系统和数据的破坏。SQL注入和XSS跨站脚本攻击是两种常见的网络安全威胁。 ...

    DedeCMS 存储型xss漏洞1

    在本文中，我们将深入探讨一个特定的存储型 XSS（跨站脚本）漏洞，该漏洞存在于DedeCMS 的会员功能组件 `shops_delivery.php` 中的 `des` 参数。 ### 漏洞概述 这个存储型 XSS 漏洞允许攻击者通过注入恶意脚本到 `...

    关于pdf文件xss攻击问题，配置xssFilter方法

    PDF文件XSS攻击问题主要指的是攻击者通过构造恶意的PDF文档，利用其中的脚本语言功能，尝试在用户的浏览器上执行跨站脚本攻击（XSS）。这种攻击方式可能导致敏感信息泄露、用户权限滥用或其他安全风险。在SpringBoot...

    XSS漏洞

    标题 "XSS漏洞" 描述了我们今天要深入探讨的主题——跨站脚本攻击（Cross-Site Scripting，简称XSS）。XSS是一种常见的网络安全漏洞，它允许恶意攻击者通过在网页上注入可执行的脚本来对用户进行攻击。攻击者通常...

Magicbox
Global site tag (gtag.js) - Google Analytics