使用antisamy防止xss注入

最新推荐文章于 2024-07-05 19:37:58 发布
最新推荐文章于 2024-07-05 19:37:58 发布
阅读量452 收藏 1
点赞数
文章标签： 测试 python java
原文链接：https://my.oschina.net/u/2558232/blog/3060079
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

  1. 添加maven依赖

    	<dependency>
		<groupId>org.owasp.antisamy</groupId>
		<artifactId>antisamy</artifactId>
		<version>1.5.3</version>
	</dependency>

  2. 根据antisamy api编写相关工具类

    	import java.io.IOException;

	import org.owasp.esapi.ESAPI;
	import org.owasp.validator.html.AntiSamy;
	import org.owasp.validator.html.CleanResults;
	import org.owasp.validator.html.Policy;
	import org.owasp.validator.html.PolicyException;
	import org.owasp.validator.html.ScanException;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;
	import org.springframework.core.io.DefaultResourceLoader;
	import org.springframework.core.io.Resource;
	import org.springframework.core.io.ResourceLoader;

	public class XssUtils {

		private final static Logger logger = LoggerFactory.getLogger(XssUtils.class);

		private static Policy policy = null; 

		static{ 
			ResourceLoader resourceLoader = new DefaultResourceLoader();
			Resource resource = resourceLoader.getResource("classpath:/antisamy.xml"); 
			 try { 
				policy = Policy.getInstance(resource.getURL().getPath()); 
			} catch (PolicyException e) { 
				e.printStackTrace(); 
			} catch (IOException e) {
				e.printStackTrace();
			} 
		} 

		public static String encode(String value){
			if(value == null || value.length() == 0) {
				return value;
			}
			value = ESAPI.encoder().canonicalize(value);
			return ESAPI.encoder().encodeForHTML(value);
		}

		public static String[] encode(String[] values){
			if(values == null || values.length == 0){
				return values;
			}
			int len = values.length;
			String[] _values = new String[len];
			for(int i = 0; i < len; i++){
				_values[i] = encode(values[i]);
			}
			return _values;
		}

		public static String clean(String value){
			AntiSamy antiSamy = new AntiSamy(); 
			try { 
				final CleanResults cr = antiSamy.scan(value, policy); 
				return cr.getCleanHTML(); 
			} catch (ScanException | PolicyException e) { 
				logger.error("invoke xss clean error", e);
			} 
			return value;
		}

		public static String[] clean(String[] values){
			if(values == null || values.length == 0){
				return values;
			}
			int len = values.length;
			String[] _values = new String[len];
			for(int i = 0; i < len; i++){
				_values[i] = clean(values[i]);
			}
			return _values;
		}

	}

  3. 使用filter处理HttpServletRequest，依次编写以下代码

    1. 自定义HttpServletRequestWrapper

      	import java.util.HashMap;
	import java.util.Map;

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

	import com.sw.busi.utils.XssUtils;

	public class XssCleanHttpServletRequestWrapper extends HttpServletRequestWrapper {

		public XssCleanHttpServletRequestWrapper(HttpServletRequest request) {
			super(request);
		}

		public String getQueryString() {
			String value = super.getQueryString();
			if (value != null) {
				value = XssUtils.clean(value);
			}
			return value;
		}

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

		public String[] getParameterValues(String name) {
			String[]parameters=super.getParameterValues(name);
			if (parameters==null||parameters.length == 0) {
				return null;
			}
			for (int i = 0; i < parameters.length; i++) {
				parameters[i] = XssUtils.clean(parameters[i]);
			}
			return parameters;
		}

		public Map<String, String[]> getParameterMap() {
			Map<String, String[]> params = super.getParameterMap();
			if (params==null || params.size() == 0) {
				return params;
			}
			int capacity = (int) ((float) params.size() / 0.75F + 1.0F);
			Map<String, String[]> _params = new HashMap<String, String[]>(capacity);
			for (Map.Entry<String, String[]> e : params.entrySet()) {
				String key = e.getKey();
				String[] values = e.getValue();
				for (int i = 0; i < values.length; i++) {
					values[i] = XssUtils.clean(values[i]);
				}
				_params.put(key, values);
			}
			return _params;
		}

		/**
		 * 覆盖getHeader方法，将参数名和参数值都做xss过滤。<br/>
		 * 如果需要获得原始的值，则通过super.getHeaders(name)来获取<br/> getHeaderNames 也可能需要覆盖
		 */
		public String getHeader(String name) {

			String value = super.getHeader(XssUtils.clean(name));
			if (value != null) {
				value = XssUtils.clean(value);
			}
			return value;
		}

	}

    2. 自定义filter

      	import java.io.IOException;

	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;

	public class XssFilter implements Filter {

		protected 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 XssCleanHttpServletRequestWrapper((HttpServletRequest) request), response);
		}
	}

  4. 若使用spring mvc，且使用了@RequestBody的方式绑定参数（spring内部封装了httpservletrequest的装配器，使用了getInputStream的方式获取请求体，并转换为对应的实体），通过filter的方式就无法满足了，笔者对spring mvc的序列化与反序列化进行了修改，这里以jackson为示例，编写代码。

    1. 为MappingJackson2HttpMessageConverter的objectMapper注入自定义的实例对象
    2. 编写自定义ObjectMapper的实现 
      	import com.fasterxml.jackson.databind.ObjectMapper;
	import com.fasterxml.jackson.databind.module.SimpleModule;
	import com.sw.busi.json.jackson.databind.deser.StringDeserializer;
	import com.sw.busi.json.jackson.databind.ser.StringSerializer;

	public class CustomObjectMapper extends ObjectMapper {
		private static final long serialVersionUID = -8543006375974774016L;

		public CustomObjectMapper(){
			SimpleModule simpleModule = new SimpleModule();
			//序列化与反序列化字符串，使用了xss clean
			simpleModule.addSerializer(String.class, StringSerializer.instance);
			simpleModule.addDeserializer(String.class, StringDeserializer.instance);

			this.registerModule(simpleModule);
		}
	}
    3. 编写自定义StringSerializer 
      	import java.io.IOException;
	import java.lang.reflect.Type;

	import com.fasterxml.jackson.core.*;

	import com.fasterxml.jackson.databind.JavaType;
	import com.fasterxml.jackson.databind.JsonMappingException;
	import com.fasterxml.jackson.databind.JsonNode;
	import com.fasterxml.jackson.databind.SerializerProvider;
	import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
	import com.fasterxml.jackson.databind.ser.std.NonTypedScalarSerializerBase;
	import com.sw.busi.utils.XssUtils;

	/**
	 * This is the special serializer for regular {@link java.lang.String}s.
	 *<p>
	 * Since this is one of "native" types, no type information is ever
	 * included on serialization (unlike for most scalar types as of 1.5)
	 */
	public final class StringSerializer extends NonTypedScalarSerializerBase<String> {
		private static final long serialVersionUID = 1L;

		public static final StringSerializer instance = new StringSerializer();

		public StringSerializer() {
			super(String.class);
		}

		/**
		 * For Strings, both null and Empty String qualify for emptiness.
		 */
		@Override
		@Deprecated
		public boolean isEmpty(String value) {
			return (value == null) || (value.length() == 0);
		}

		@Override
		public boolean isEmpty(SerializerProvider prov, String value) {
			return (value == null) || (value.length() == 0);
		}

		@Override
		public void serialize(String value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
			jgen.writeString(XssUtils.clean(value));
		}

		@Override
		public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
			return createSchemaNode("string", true);
		}

		@Override
		public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
				throws JsonMappingException {
			if (visitor != null)
				visitor.expectStringFormat(typeHint);
		}
	}
    4. 编写StringDeserializer 
      	import java.io.IOException;

	import com.fasterxml.jackson.core.Base64Variants;
	import com.fasterxml.jackson.core.JsonParser;
	import com.fasterxml.jackson.core.JsonToken;
	import com.fasterxml.jackson.databind.DeserializationContext;
	import com.fasterxml.jackson.databind.DeserializationFeature;
	import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer;
	import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;

	import com.sw.busi.utils.XssUtils;

	//去掉注解，防止自定义反序列化器被认为是标准实现，从而反序列化String[] collection<String> Map<*, String> 无效
	// com.fasterxml.jackson.databind.util.ClassUtil.isJacksonStdImpl(Object)
	//@JacksonStdImpl
	public class StringDeserializer extends StdScalarDeserializer<String> {
		private static final long serialVersionUID = 1L;

		public final static StringDeserializer instance = new StringDeserializer();

		public StringDeserializer() {
			super(String.class);
		}

		// since 2.6, slightly faster lookups for this very common type
		@Override
		public boolean isCachable() {
			return true;
		}

		public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
			JsonToken curr = jp.getCurrentToken();
			if (curr == JsonToken.VALUE_STRING) {
				return XssUtils.clean(jp.getText());
			}

			// Issue#381
			if (curr == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {
				jp.nextToken();
				final String parsed = _parseString(jp, ctxt);
				if (jp.nextToken() != JsonToken.END_ARRAY) {
					throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY,
							"Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array");
				}
				return XssUtils.clean(parsed);
			}
			// [JACKSON-330]: need to gracefully handle byte[] data, as base64
			if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) {
				Object ob = jp.getEmbeddedObject();
				if (ob == null) {
					return null;
				}
				if (ob instanceof byte[]) {
					return XssUtils.clean(Base64Variants.getDefaultVariant().encode((byte[]) ob, false));
				}
				// otherwise, try conversion using toString()...
				return XssUtils.clean(ob.toString());
			}
			// allow coercions for other scalar types
			String text = jp.getValueAsString();
			if (text != null) {
				return XssUtils.clean(text);
			}
			throw ctxt.mappingException(_valueClass, curr);
		}

		// Since we can never have type info ("natural type"; String, Boolean,
		// Integer, Double):
		// (is it an error to even call this version?)
		@Override
		public String deserializeWithType(JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer)
				throws IOException {
			return deserialize(p, ctxt);
		}
	}

转载于:https://my.oschina.net/u/2558232/blog/3060079

weixin_34148456
关注
antisamy的配置以及使用实现XSS防御
ru_li的专栏
07-07 9996
一、antisamy介绍： 二、所需的相关文件： 三、antisamy在eclipse的配置      maven的使用： 整体截图： pom.xml代码： 4.0.0 webTest webTest 0.0.1-SNAPSHOT war src src
XSS 防御之 AntiSamy
chongdanshi5995的博客
06-19 430
1.前言 传统xss 防御的方式，可以是在前端或服务端进行手动特殊字符过滤，用户根据需要添加需要被处理的字符。这种方式的优点是方便简单，但缺点是，开发者很难穷举需要被过滤的特殊字符。所以有了 AntiSamy。 2.AntiSamy 简介 AntiSamy 是 OWASP 的一个开...
AntiSamy Xss攻击过滤封装WebService源码
11-08
将开源的 AntiSamy Xss 防跨站脚本攻击工具封装为 Java WebService，可以运行在 Tomcat 下。 压缩包里是源码及所有依赖的dll，开发环境是 eclipse jdk 6.0。 如使用 asp.net 开发，可简单部署一个 TOMCAT 服务器，使用WebService调用接口做XSS（跨站脚本攻击）过滤。
AntiSamy：防 XSS 攻击的一种解决方案使用教程
华仔仔的博客
07-05 3095
XSS 是跨站脚本攻击(Cross Site Scripting) 的简称，为不和 CSS(Cascading Style Sheets) 混淆，故将跨站脚本攻击缩写为 XSS. XSS 是指恶意攻击者往 Web 页面里插入恶意 Script 代码，当用户浏览该页时，嵌入其中 Web 里面的 Script 代码会被执行，从而达到恶意攻击用户的目的。有点类似于 SQL 注入。当网站攻击者发现这个漏洞，并攻击成功后，攻击者可能得到包括但不限于更高的权限（如执行一些操作）、私密网页内容、会话和 cookie 等各
ESAPI自定义配置文件路径
最新发布
青春不打烊的博客
07-05 1523
文章目录 前言一、pom依赖 <dependency> <groupId>org.owasp.esapi</groupId> <artifactId>esapi</artifactId> <version>2.2.3.0</version> <!-- 如果项目中没有引入其他日志框架，可以不排除 -->
XSS攻击及AntiSamy防御
有一只柴犬的专栏
10-20 990
什么是xss xss：跨站脚本攻击（Cross Site Scripting），因为跟样式css混淆，所以习惯缩写为xss。通过一些方法注入恶意指令代码到网页，使其加载并执行攻击者恶意的网页程序。 xss类型 1、反射型xss：通过get或者post等方式，向服务端输入数据。如果服务端不进行处理（过滤，验证，编码等），直接将信息呈现出来，可能会造成反射型xss。 2、存储型xss：服务端对注入的恶意脚本没有经过验证存入数据库，每次调用数据库都会将其渲染在浏览器上。则可能为存储型xss。 AntiSamy防御
XSS防御-使用AntiSamy
热门推荐
张张张小胜的博客
07-11 1万+
AntiSamy是OWASP的一个开源项目，被广泛应用于Web服务对存储型和反射型XSS的防御中
xss注入框架antisamy
for justice
06-19 1758
首先在依赖中加入 <dependency> <groupId>org.owasp.antisamy</groupId> <artifactId>antisamy</artifactId> <version>1.5.3</vers...
防止MultipartFile XSS注入
09-21
防止MultipartFile的XSS注入可以使用OWASP库来实现。首先，你需要在pom.xml文件中添加以下依赖项： ``` <esapi.version>2.5.1.0 <antisamy.version>1.7.2</antisamy.version> <groupId>org.owasp.esapi ...
XSS跨域攻击在web项目中的防范，基于antisamy技术
07-10
XSS（Cross-Site Scripting）跨站脚本攻击是一种常见的网络安全漏洞，它允许恶意用户在Web应用程序中注入可执行的脚本代码。这些注入的脚本可能在其他用户的浏览器中执行，导致敏感数据泄露、会话劫持、钓鱼攻击等...
Springboot-XSS.zip
09-03
3. **使用Spring Data JPA的`@Query`注解**：在自定义查询时，确保使用占位符来防止SQL注入。 4. **使用Spring Security的`SqlInjectionFilter`**：这是一个可选的过滤器，可以在请求进入数据库之前检查并阻止潜在的...
antisamy 策略文件
01-10
比较全的策略文件，antisamy是owasp组织的一个开源库，是一个可确保用户输入的HTML/CSS符合应用规范的API，参考：http://blog.csdn.net/raychiu757374816/article/details/79016101
antisamy xml
09-29
XML简介参考 http://blog.csdn.net/zhoubiyin/article/details/78136096
常用antisamy策略文件
12-20
常用antisamy策略文件：antisamy-slashdot.xml 、antisamy-ebay.xml、antisamy-myspace.xml、antisamy-anythinggoes.xml、antisamy-tinymce.xml等。 详细介绍参见此文：http://blog.csdn.net/softwave/article/details/53761796
antisamy策略文件
06-14
1分 antisamy策略文件antisamy.xml，antisamy-anythinggoes.xml，antisamy-ebay.xml，antisamy-myspace.xml，antisamy-slashdot.xml，antisamy-tinymce.xml
antisamy的jar包
03-21
XSS攻击是一种常见的网络攻击方式，攻击者通过在网页上注入恶意脚本，使得用户在不知情的情况下执行这些脚本，从而窃取用户的敏感信息或破坏网站功能。antisamy.jar是专门为防止这类攻击而设计的库，由OWASP（开放...
springMVC使用Antisamy防御XSS配置（包括请求黑白名单）
Abdulaziz的博客
01-07 1153
AntiSamy是OWASP的一个开源项目，通过对用户输入的 HTML / CSS / JavaScript 等内容进行检验和清理，确保输入符合应用规范。AntiSamy被广泛应用于Web服务对存储型和反射型XSS的防御中。 1、maven依赖 <dependency> <groupId>org.owasp.antisamy</groupId> <artifactId>antisamy</artifactId> <version
AntiSamy：XSS防护与HTML清理框架
antisamy是OWASP（开放式网络应用安全项目）开发的一个用于防止XSS攻击的框架。它通过解析并净化用户提交的HTML、CSS和JavaScript代码，确保它们遵循预定义的策略文件规则，以此来避免恶意代码被执行。antisamy并不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值