Hazelcast简介

是Hazelcast公司开源的一款分布式内存数据库产品，提供弹性可扩展、高性能的分布式内存计算。基于Apache v2许可证发布，可用于实现分布式数据存储、数据缓存、消息代理器以及分布式计算平台。Hazelcast强调高速访问分布式数据（通常是分布式的缓存）、分布式计算和分布式消息。
Github地址：https://github.com/hazelcast/hazelcast
官方网站：https://hazelcast.org/
API文档：https://docs.hazelcast.org/docs/latest/manual/html-single/index.html

Hazelcast特性：

1.强大的分布式计算：允许任意业务逻辑执行位置引用，并支持跨集群的分布式扩展。作为完全内存数据存储，Hazelcast IMDG可以在几微秒内转换和提取数据，提供吞吐量和查询。在Hazelcast里所有的数据结构都是分布式的，把多个节点当作一个节点使用，最常用的是map，其它的有Queue（队列），MultiMap，Set，List，跟java里的是一样的，因为实现了java里的泛型接口。
2.支持多种语言：Java, C++, .NET/C#, Python, Scala, and NodeJs
3.持久化：Hazelcast主要是解决访问分布式数据和进行分布式计算时保持低延迟。默认情况下，Hazelcast不涉及磁盘或其它持久化的存储。
4.简易性： Hazelcast 功能只需引用一个jar包，除此之外，不依赖任何第三方包。因此可以非常便捷高效的将其嵌入到各种应用服务器中，而不必担心带来额外的问题（jar包冲突、类型冲突等等）。他仅仅提供一系列分布式功能，而不需要绑定任何框架来使用，因此适用于任何场景。扩展，故障处理和恢复都是自动化的，以便于操作管理
5.自治集群（无中心化）：Hazelcast 没有任何中心节点，在运行的过程中，它自己选定集群中的某个节点作为中心点来管理所有的节点

Hazelcast客户端(管理中心)下载

下载地址：https://hazelcast.org/download/

 

下载完解压即可，双击start.bat即可启动

 

这个是管理中心的登录URL

需要先设置账户密码，密码需要字母大小写还有数字

 

登录页面

与springboot进行集成

SpringBoot官方明确表示支持Hazelcast

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-hazelcast.html
引入依赖

<dependency>
       <groupId>com.hazelcast</groupId>
       <artifactId>hazelcast</artifactId>
       <version>3.11</version>
</dependency>

引入Hazelcast.xml配置文件

模板可以在Github上找的：https://github.com/hazelcast/hazelcast/blob/master/hazelcast/src/main/resources/hazelcast-default.xml

<?xml version="1.0" encoding="UTF-8"?>
<hazelcast xmlns="http://www.hazelcast.com/schema/config"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.hazelcast.com/schema/config
           http://www.hazelcast.com/schema/config/hazelcast-config-3.11.xsd">

    <group>
        <name>dev</name>
        <password>dev-pass</password>
    </group>
    <management-center enabled="true">http://localhost:8080/hazelcast-mancenter</management-center>
    <network>
        <port auto-increment="true" port-count="100">5701</port>
        <outbound-ports>
            <ports>0</ports>
        </outbound-ports>
        <join>
            <multicast enabled="true">
                <multicast-group>224.2.2.3</multicast-group>
                <multicast-port>54327</multicast-port>
            </multicast>
            <tcp-ip enabled="false">
                <interface>127.0.0.1</interface>
                <member-list>
                    <member>127.0.0.1</member>
                </member-list>
            </tcp-ip>
            <aws enabled="false">
                <access-key>my-access-key</access-key>
                <secret-key>my-secret-key</secret-key>
                <region>us-west-1</region>
                <host-header>ec2.amazonaws.com</host-header>
                <security-group-name>hazelcast-sg</security-group-name>
                <tag-key>type</tag-key>
                <tag-value>hz-nodes</tag-value>
            </aws>
            <gcp enabled="false">
                <zones>us-east1-b,us-east1-c</zones>
            </gcp>
            <azure enabled="false">
                <client-id>CLIENT_ID</client-id>
                <client-secret>CLIENT_SECRET</client-secret>
                <tenant-id>TENANT_ID</tenant-id>
                <subscription-id>SUB_ID</subscription-id>
                <cluster-id>HZLCAST001</cluster-id>
                <group-name>GROUP-NAME</group-name>
            </azure>
            <kubernetes enabled="false">
                <namespace>MY-KUBERNETES-NAMESPACE</namespace>
                <service-name>MY-SERVICE-NAME</service-name>
                <service-label-name>MY-SERVICE-LABEL-NAME</service-label-name>
                <service-label-value>MY-SERVICE-LABEL-VALUE</service-label-value>
            </kubernetes>
            <eureka enabled="false">
                <self-registration>true</self-registration>
                <namespace>hazelcast</namespace>
            </eureka>
            <discovery-strategies>
            </discovery-strategies>
        </join>
        <interfaces enabled="false">
            <interface>10.10.1.*</interface>
        </interfaces>
        <ssl enabled="false"/>
        <socket-interceptor enabled="false"/>
        <symmetric-encryption enabled="false">
            <algorithm>PBEWithMD5AndDES</algorithm>
            <salt>thesalt</salt>
            <password>thepass</password>
            <iteration-count>19</iteration-count>
        </symmetric-encryption>
        <failure-detector>
            <icmp enabled="false"/>
        </failure-detector>
    </network>
    <partition-group enabled="false"/>
    <executor-service name="default">
        <pool-size>16</pool-size>
        <queue-capacity>0</queue-capacity>
    </executor-service>
    <security>
        <client-block-unmapped-actions>true</client-block-unmapped-actions>
    </security>
    <queue name="default">
        <max-size>0</max-size>
        <backup-count>1</backup-count>
        <async-backup-count>0</async-backup-count>
        <empty-queue-ttl>-1</empty-queue-ttl>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </queue>
    <map name="default">
        <in-memory-format>BINARY</in-memory-format>
        <backup-count>1</backup-count>
        <async-backup-count>0</async-backup-count>
        <time-to-live-seconds>0</time-to-live-seconds>
        <max-idle-seconds>0</max-idle-seconds>
        <eviction-policy>NONE</eviction-policy>
        <max-size policy="PER_NODE">0</max-size>
        <eviction-percentage>25</eviction-percentage>
        <min-eviction-check-millis>100</min-eviction-check-millis>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
        <cache-deserialized-values>INDEX-ONLY</cache-deserialized-values>
    </map>
    <event-journal enabled="false">
        <mapName>mapName</mapName>
        <capacity>10000</capacity>
        <time-to-live-seconds>0</time-to-live-seconds>
    </event-journal>

    <event-journal enabled="false">
        <cacheName>cacheName</cacheName>
        <capacity>10000</capacity>
        <time-to-live-seconds>0</time-to-live-seconds>
    </event-journal>
    <merkle-tree enabled="false">
        <mapName>mapName</mapName>
        <depth>10</depth>
    </merkle-tree>

    <multimap name="default">
        <backup-count>1</backup-count>
        <value-collection-type>SET</value-collection-type>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </multimap>

    <replicatedmap name="default">
        <in-memory-format>OBJECT</in-memory-format>
        <async-fillup>true</async-fillup>
        <statistics-enabled>true</statistics-enabled>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </replicatedmap>

    <list name="default">
        <backup-count>1</backup-count>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </list>

    <set name="default">
        <backup-count>1</backup-count>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </set>

    <jobtracker name="default">
        <max-thread-size>0</max-thread-size>
        <!-- Queue size 0 means number of partitions * 2 -->
        <queue-size>0</queue-size>
        <retry-count>0</retry-count>
        <chunk-size>1000</chunk-size>
        <communicate-stats>true</communicate-stats>
        <topology-changed-strategy>CANCEL_RUNNING_OPERATION</topology-changed-strategy>
    </jobtracker>

    <semaphore name="default">
        <initial-permits>0</initial-permits>
        <backup-count>1</backup-count>
        <async-backup-count>0</async-backup-count>
    </semaphore>

    <reliable-topic name="default">
        <read-batch-size>10</read-batch-size>
        <topic-overload-policy>BLOCK</topic-overload-policy>
        <statistics-enabled>true</statistics-enabled>
    </reliable-topic>

    <ringbuffer name="default">
        <capacity>10000</capacity>
        <backup-count>1</backup-count>
        <async-backup-count>0</async-backup-count>
        <time-to-live-seconds>0</time-to-live-seconds>
        <in-memory-format>BINARY</in-memory-format>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </ringbuffer>

    <flake-id-generator name="default">
        <prefetch-count>100</prefetch-count>
        <prefetch-validity-millis>600000</prefetch-validity-millis>
        <id-offset>0</id-offset>
        <node-id-offset>0</node-id-offset>
        <statistics-enabled>true</statistics-enabled>
    </flake-id-generator>

    <atomic-long name="default">
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </atomic-long>

    <atomic-reference name="default">
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </atomic-reference>

    <count-down-latch name="default"/>

    <serialization>
        <portable-version>0</portable-version>
    </serialization>

    <services enable-defaults="true"/>

    <lite-member enabled="false"/>

    <cardinality-estimator name="default">
        <backup-count>1</backup-count>
        <async-backup-count>0</async-backup-count>
        <merge-policy batch-size="100">HyperLogLogMergePolicy</merge-policy>
    </cardinality-estimator>

    <scheduled-executor-service name="default">
        <capacity>100</capacity>
        <durability>1</durability>
        <pool-size>16</pool-size>
        <merge-policy batch-size="100">com.hazelcast.spi.merge.PutIfAbsentMergePolicy</merge-policy>
    </scheduled-executor-service>

    <crdt-replication>
        <replication-period-millis>1000</replication-period-millis>
        <max-concurrent-replication-targets>1</max-concurrent-replication-targets>
    </crdt-replication>

    <pn-counter name="default">
        <replica-count>2147483647</replica-count>
        <statistics-enabled>true</statistics-enabled>
    </pn-counter>
</hazelcast>

<management-center>中enabled属性需要设置为true才能开启Hazelcast管理中心，默认为false
<outbound-ports>表示允许连接到其他节点的端口范围。 0或*表示使用系统提供的端口。
<network>是非常重要的元素，指定Hazelcast的网络环境。
<port>指定Hazelcast将用于在集群成员之间进行通信的端口。
<multicast >组播，不建议将生成多播机制用于生产，因为UDP通常在生产环境中被阻止，而其他发现机制更明确。
<tcp-ip>TCP / IP群集
<queue name="default">队列名
<max-size>队列的最大大小。当JVM的本地队列大小达到最大值时，所有put / offer操作都将被阻塞，直到JVM的队列大小低于最大值。 0到Integer.MAX_VALUE之间的任何整数。
<backup-count>备份数量。例如，如果将1设置为备份计数，则映射的所有条目都将复制到另一个JVM以实现故障安全。 0表示没有备份
<async-backup-count>异步备份的数量。 0表示没有备份
具体的配置说明可以参考：

https://docs.hazelcast.org/docs/latest/manual/html-single/#understanding-configuration

测试代码

@Component
public class HazelcastGetStartServerMaster {
    private HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance();

    @PostConstruct
    public void put(){
        Map map = hazelcastInstance.getMap("hello");
        map.put("hello","world");
    }
}

启动测试之前需要先启动Hazelcast管理中心

 

启动成功会显示管理中心的URL

在管理中心可以看到

 

来源：https://www.jianshu.com/p/f32a24771d17

之前公司有接了一个国土的项目，虽然是内部小项目，但是可能是zhengfu项目竟然找软件测试公司大概测了一下。。。然后出现了以下三种问题：sql注入，XSS攻击，接口访问频率。下面是解决XSS攻击。

研究：

一开始的想法是，弄个过滤器把那些关键字过滤掉不就好了，例如script、eval、document等等，确实网上也有这些例子。可参考此博客https://www.cnblogs.com/myyBlog/p/8890365.html

但是人家可是请专业的软件测试工程师测试的，我这么混过去肯定是不行滴，上面的主要只是简单地过滤掉用户的输入参数，而且过滤得非常的不全面，可能还有很多方面的攻击呢？然后继续的百度找找有没有此方面的开源项目。结果真的找到了一个，就是AntiSamy，OWASP的一个开源项目，通过对用户输入的 HTML / CSS / JavaScript 等内容进行检验和清理，确保输入符合应用规范。AntiSamy被广泛应用于Web服务对存储型和反射型XSS的防御中。这个就相当的强大了啊。

方案：

参考上面的博客的做法：弄一个过滤器XSSFilter，拦截所有路径。再使用HttpServletRequestWrapper来装饰一下HttpServletRequest，已达到XSS清洗来防御XSS攻击。嗯，就这么大概了，网友真强大~

开工：

1、引入Maven依赖：

<!-- OWASP AntiSamy 防止XSS攻击-->
<dependency>
<groupId>org.owasp.antisamy</groupId>
<artifactId>antisamy</artifactId>
<version>1.5.5</version>
</dependency>
2、策略文件：

Maven下载下来的依赖里面是带有策略文件，之前试过前一点的版本例如1.5.3好像是没有的。下面我使用的策略文件将是antisamy-ebay.xml，毕竟eBay 是当下最流行的在线拍卖网站之一，防御策略肯定是非常好的。关于AntiSamy的策略文件的详解大家可以去搜一下，毕竟可能以后要改里面的处理规则呢。

3、怎么使用AntiSamy：

想当的简单，首先要指定策略文件生成Policy，然后新建AntiSamy，再对需要进行XSS清洗的内容进行扫面即可。

String xsshtml = "hyf<script>alert(1)</script>";
Policy policy = Policy.getInstance("antiSamyPath");
AntiSamy antiSamy = new AntiSamy();
CleanRequests cr = antiSamy.scan(xsshtml,policy);
xsshtml = cr.getCleanHTML(); //清洗完的
4、创建XssFilter实现Filter接口然后重新doFilter方法：

因为我们对用户的每次请求都进行拦截清洗，清洗完才能真正地调用Controller的方法，所以我们用到的是过滤器而不是拦截器。因为Filter是一个典型的过滤链，可以用来对 HttpServletRequest 进行预处理，或者是对 HttpServlerResponse 进行后处理。

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
*
*@author howinfun
*@date 2018/10/23
*@company DM
*@version 1.0
*/
public class XssFilter implements Filter {

private FilterConfig filterConfig;

@Override
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
}

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)servletRequest;
/* filterChain.doFilter(new XssHttpServletRequestWrapper2(request),servletResponse);*/
filterChain.doFilter(new XssHttpServletRequestWrapper(request),servletResponse); //包装request，在里头进行XSS清洗
}

@Override
public void destroy() {
this.filterConfig = null;
}
}
5、新建一个自定义 HttpServletRequest 包装类 XssHttpServletRequestWrapper ，继承 HttpServletRequestWrapper 类：

对getParameter( String param)、getParameterValues( String param)以及 getHeader( String param) 等方法进行重写，在重写里头都进行一遍全方位清洗。

import org.apache.commons.lang.StringEscapeUtils;
import org.jeecgframework.web.appconfig.util.StringUtils;
import org.owasp.validator.html.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.Iterator;
import java.util.Map;

/**
* @desc 基于AntiSamy的XSS防御
* @author howinfun
* @date 2018/10/23
* @company DM
* @version 1.0
*/
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {

//AntiSamy使用的策略文件
private static Policy policy = null;
static {
//指定策略文件，策略文件记得放在classpath下
String antiSamyPath = XssHttpServletRequestWrapper.class.getClassLoader().getResource("antisamy-ebay.xml").getFile();
System.out.println("policy_filepath:"+antiSamyPath);
if(antiSamyPath.startsWith("file")){
antiSamyPath = antiSamyPath.substring(6);
}
try {
policy = Policy.getInstance(antiSamyPath);
} catch (PolicyException e) {
e.printStackTrace();
}
}

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

/**
* @desc Header为空直接返回，不然进行XSS清洗
* @author howinfun
* @date 2018/10/24
*
*/
@Override
public String getHeader(String name) {
String value = super.getHeader(name);
if(StringUtils.isEmpty(value)){
return value;
}
else{
String newValue = cleanXSS(value);
return newValue;
}

}

/**
* @desc Parameter为空直接返回，不然进行XSS清洗
* @author howinfun
* @date 2018/10/24
*
*/
@Override
public String getParameter(String name) {
String value = super.getParameter(name);
if(StringUtils.isEmpty(value)){
return value;
}
else{
value = cleanXSS(value);
return value;
}
}

/**
* @desc 对用户输入的参数值进行XSS清洗
* @author howinfun
* @date 2018/10/24
*
*/
@Override
public String[] getParameterValues(String name) {
String[] values = super.getParameterValues(name);
if (values != null) {
int length = values.length;
String[] escapseValues = new String[length];
for (int i = 0; i < length; i++) {
escapseValues[i] = cleanXSS(values[i]);
}
return escapseValues;
}
return super.getParameterValues(name);
}

@SuppressWarnings("rawtypes")
public Map<String,String[]> getParameterMap(){
Map<String,String[]> request_map = super.getParameterMap();
Iterator iterator = request_map.entrySet().iterator();
System.out.println("request_map"+request_map.size());
while(iterator.hasNext()){
Map.Entry me = (Map.Entry)iterator.next();
//System.out.println(me.getKey()+":");
String[] values = (String[])me.getValue();
for(int i = 0 ; i < values.length ; i++){
System.out.println(values[i]);
values[i] = cleanXSS(values[i]);
}
}
return request_map;
}

/**
* @desc AntiSamy清洗数据
* @author howinfun
* @date 2018/10/24
*
*/
private String cleanXSS(String taintedHTML) {
try{
AntiSamy antiSamy = new AntiSamy();
CleanResults cr = antiSamy.scan(taintedHTML, policy);
taintedHTML = cr.getCleanHTML();
return taintedHTML ;

}catch( ScanException e) {
e.printStackTrace();
}catch( PolicyException e) {
e.printStackTrace();
}
return taintedHTML;
}
}
6、在web.xml对新建的Filter进行注册。

<!-- 防止XSS攻击 -->
<filter>
<filter-name>XSSFilter</filter-name>
<filter-class>org.jeecgframework.core.filter.XssFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>XSSFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
7、接下来进行测试：

简单的测试是否能过滤掉script标签及里面的内容。这个上传的gif不动的，我就不放了，结果肯定是可以过滤掉滴。

8、继续测试：

我继续测试其他接口，测试了一个之前自己做的通用API，发现传回来的JSON数据出现了问题，原来的双引号被转换为&quot。还测试到&nbsp;被转成乱码了。。。所以我们必须在清洗完后进行进一步处理，将这两个问题给自己解决掉。

/**
* @desc AntiSamy清洗数据
* @author howinfun
* @date 2018/10/24
*
*/
private String cleanXSS(String taintedHTML) {
try{
AntiSamy antiSamy = new AntiSamy();
final CleanResults cr = antiSamy.scan(taintedHTML,policy);
//AntiSamy会把“&nbsp;”转换成乱码，把双引号转换成"&quot;" 先将&nbsp;的乱码替换为空，双引号的乱码替换为双引号
String str = StringEscapeUtils.unescapeHtml(cr.getCleanHTML());
str = str.replaceAll(antiSamy.scan("&nbsp;",policy).getCleanHTML(),"");
str = str.replaceAll(antiSamy.scan("\"",policy).getCleanHTML(),"\"");
return str;

}catch( ScanException e) {
e.printStackTrace();
}catch( PolicyException e) {
e.printStackTrace();
}
return taintedHTML;
}

原文链接：https://blog.csdn.net/Howinfun/article/details/83414262

1 前言

Antisamy是OWASP（open web application security project）的一个开源项目，其能够对用户输入的html/css/javascript 脚本进行过滤，确保输入满足规范，无法提交恶意脚本。Antisamy被应用在web服务中对存储型和反射性的xss防御，尤其是在存在富文本输入的场景，antisamy能够很好的解决用户输入体验和安全要求之间的冲突。

• Antisamy的对包含非法字符的用户输入的过滤依赖于策略文件，策略文件规定了antisamy对各个标签、属性的处理方法。策略文件定义的严格与否，决定了antisamy对xss漏洞的防御效果。
• OWASP中antisamy有java和.net两个项目，这篇文档中仅对java项目进行介绍。从安装、使用及策略文件的定制几个方面讲解如何将antisamy应用到实际项目当中。

2 工具安装

•  Antisamy的官方下载路径:++https://code.google.com/archive/p/owaspantisamy/downloads++。下载列表中包含antisamy的jar包，同时也包含了几个常用的策略文件。官方下载的链接需要翻墙，为方便使用，将最新版本的antisamy和策略文件放到文档的附件中（见附件1）。

• Antisamy直接导入到java的工程即可，但是其运行依赖另外三个库：

xercesImpl.jar    http://xerces.apache.org/mirrors.cgi#binary

batik.jar              http://xmlgraphics.apache.org/batik/download.cgi

nekohtml.jar       http://sourceforge.net/projects/nekohtml/

• 可以通过链接下载，也可以从marven中直接下载。测试过程中使用的是从marven中下载，使用的版本信息如下：

 <orderEntry type=”library” name=”xerces:xercesImpl:2.11.0″ level=”project” />

<orderEntry type=”library” name=”com.nrinaudo:kantan.xpath-nekohtml_2.12:0.1.9″ level=”project” />

<orderEntry type=”library” name=”org.apache.xmlgraphics:batik-script:1.8″ level=”project” />

• 在导入完成后，在java工程中新建一个类，输入如下代码进行测试，确认安装是否正确。
  1. public class AntiSamyApplication {
  2.     public static void main(String[] args)
  3.     {
  4.         AntiSamy as = new AntiSamy();
  5.         try{
  6.             Policy policy = Policy.getInstance("\\antisamy\\antisamy-tinymce-1.4.4.xml");
  7.             CleanResults cr = as.scan("<div>wwwww<script>alert（1）</script></div>", policy);
  8.             System.out.print(cr.getCleanHTML());
  9.         }
  10.         catch(Exception ex) {
  11.         } ;
  12.     }
  13. }

如果输出结果如下结果，说明安装正确，可以正常使用antisamy了。

1. "C:\Program Files (x86)\Java\jdk1.8.0_121\bin\java"
2.   <div>wwwwwdddd</div>
3.   Process finished with exit code 0

3 使用方法

Antisamy存在两种使用方法，一种是从系统层面，重写request处理相关的功能函数，对用户输入的每一个参数均作过滤验证；另外一种是仅对富文本使用过滤验证；

4 策略文件

4.1 策略文件结构

一个简易的Antisamy的策略文件主体结构如所示:

Antisamy的策略文件为xml格式的，除去xml文件头外，可以为7个部分，下面对各个部分的功能做简单的介绍。

1. <directives>
2.     <directive name="omitXmlDeclaration" value="true" />
3.     <directive name="omitDoctypeDeclaration" value="true" />
4. </directives>

对应上图中标注为1的部分，主要为全局性配置，对antisamy的过滤验证规则、输入及输出的格式进行全局性的控制。具体字段的意义在后面继续文档中详细介绍。

1. <common-regexps>
3.     <regexp name="htmlTitle" value="[a-zA-Z0-9\s\-_',:\[\]!\./\\\(\)&amp;]*" />
5.     <regexp name="onsiteURL" value="([\p{L}\p{N}\p{Zs}/\.\?=&amp;\-~])+" />
7.     <regexp name="offsiteURL" value="(\s)*((ht|f)tp(s?)://|mailto:)[A-Za-z0-9]+[~a-zA-Z0-9-_\.@\#\$%&amp;;:,\?=/\+!\(\)]*(\s)*" />
9. </common-regexps>

对应上图中标注为2的部分，将规则文件中需要使用到的正则表达式相同的部分归总到这，会在后续中需要正则的时候通过name直接引用；

1. <common-attributes>
3.     <attribute name="title" description="The 'title' attribute provides text that shows up in a 'tooltip' when a user hovers their mouse over the element">
5.         <regexp-list>
7.         <regexp name="htmlTitle" />
9.         </regexp-list>
11.     </attribute>
13. </common-attributes>

对应上图中标注为3的部分，这部分定义了通用的属性需要满足的输入规则，其中包括了标签和css的属性；在后续的tag和css的处理规则中会引用到上述定义的属性。

1. <global-tag-attributes>
3.     <attribute name="title" />
5. </global-tag-attributes>

对应上图中标注为4的部分，这部分定义了所有标签的默认属性需要遵守的规则；需要验证如果标签中为validate，有属性但是不全的场景

1. <tags-to-encode>
3.    <tag>g</tag>
5.    <tag>grin</tag>
7. </tags-to-encode>

对应上图中标注为5的部分，这部分定义了需要进行编码处理的标签；

1. <tag-rules>
3.    <!--  Remove  -->
5.    <tag name="script" action="remove" />
7.    <!--  Truncate  -->
9.    <tag name="br" action="truncate" />
11.    <!--  Validate -->
13.    <tag name="p" action="validate">
15.    <attribute name="align" />
17.    </tag>
19. </tag-rules>

对应上图中标注为6的部分，这部分定义了tag的处理规则，共有三种处理方式：

remove：对应的标签直接删除如script标签处理规则为删除，当输入为：

<div><script>alert(1);</script></div>

输出为：

<div>ddd</div>

truncate：对应的标签进行缩短处理，直接删除所有属性，只保留标签和值；如标签dd处理规则为truncate，当输入为：

<dd id='dd00001' align='left'>test</test>

validate：对应的标签的属性进行验证，如果tag中定义了属性的验证规则，按照tag中的规则执行；如果标签中未定义属性，则按照 \<global-tag-attributes\> 中定义的处理；

1. <css-rules>
2.     <property name="text-decoration" default="none" description="">
3.         <category-list>
4.             <category value="visual" />
5.         </category-list>
6.         <literal-list>
7.             <literal value="underline" />
8.             <literal value="overline" />
9.             <literal value="line-through" />
10.         </literal-list>
11.     </property>
12. </css-rules>

对应上图中中标注为7的部分，这部分定义了css的处理规则；

4.2 策略文件详解

4.2.1 策略文件指令[<directives></directives>]

策略文件指令包含13个参数，下面对其参数的意义逐一介绍。

1. <directives>
2.     <directive name="useXHTML" value="false"/>
3.     <directive name="omitXMLDeclaration" value="true"/>
4.     <directive name="omitDoctypeDeclaration" value="true"/>
5.     <directive name="formatOutput" value="false"/>
6.     <directive name="maxInputSize" value="100000"/>
7.     <directive name="embedStyleSheets" value="false"/>
8.     <directive name="maxStyleSheetImports" value="1"/>
9.     <directive name="connectionTimeout" value="1000"/>
10.     <directive name="preserveComments" value="false"/>
11.     <directive name="nofollowAnchors" value="false"/>
12.     <directive name="validateParamAsEmbed" value="false"/>
13.     <directive name="preserveSpace" value="false"/>
14.     <directive name="onUnknownTag" value="remove"/>
15. </directives>

下面的介绍中使用到的样例均以antisamy-myspace-1.4.4.xml为基础进行修改

useXHML>

类型：boolean

默认值： false

功能：开启后，antisamy的结果将按照XHTML的格式输出；默认使用HTML；

注：XHTML和HTML的主要区别在于XHMTL格式更加严格，元素必须正确的嵌套，必须闭合，标签名要小写，必须要有根元素；

在测试过程中，发现该参数实际上对输出的结果没什么影响。

omitXMLDeclaration>

类型：boolean

默认值：true
功能：按照文档描述，在开启时antisamy自动添加xml的头

测试时发现该参数对输出没啥影响。

omitDoctypeDeclaration>

类型： boolean

默认值：true

功能：在值为false时，antisamy在输出结果中自动添加html头

当输入为：

<div class='navWrapper'><p>sec_test<script>alert(1);</script></p></div>

输出结果为：

1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
2.                       "http://www.w3.org/TR/html4/strict.dtd">
3. <div class="navWrapper">
4.   <p>sec_test</p>
5. </div>

formatOutput>

类型：boolean

默认值：true

功能：开启后，antisamy会将输出结果格式化，使可读性更好；

默认是开启的，在关闭后，当输入为：

<div class='navWrapper'><p>sec_test<script>alert(1);</script></p></div>

输出结果为：

<div class="navWrapper"><p>sec_test</p></div>

注：可以和omitDoctypeDeclaration的结果对比着看。

maxInputSize>

类型：int
默认值：100000

功能：用于验证的最长字符串长度，单位bytes；

embedStyleSheets>

类型：boolean

默认值：false

功能:在开启css过滤功能后，该指令确认是否将引用的css文件下载下来并导入到用户输入一起作为检查的输入；

maxStyleSheetImports>

类型：int
默认值：1

功能：配合embedStyleSheets使用，指定在输入中可以下载css文件的个数；

connecttionTimeout>

类型：int

默认值：1000

功能：配合embedStyleSheets使用，指定在下载css文件时的超时时长，单位为毫秒；

preserveComments>

类型：boolean

默认值：false

功能：开启后，保留输入中的注释行；

nofollowAnchors>

类型：boolean

默认值：falsle

功能：开启后，在锚点标签（<a>）后添加rel=“nofollow”属性，防止跳转到其他页面

开启后当输入为：

<div><a href='www.baid.com'>click</a></div>

输出结果为：

1. <div>
2.   <a href="www.baid.com" rel="nofollow">click</a></div>

validateParamAsEmbed>

类型：booblean

默认值：false

功能：开启后，antisamy将<embed>标签的属性和嵌入到embed标签内的<param>标签的属性相同的规则处理，主要用于在需要用户输入的视频站点。

preserveSpace>

类型：boolean

默认值：false

功能：开启后，保留输入中的空格；

onUnknowTag>

类型：String

默认值：remove

功能：对未知tag的处理规则，默认为删除，可以修改为encode；

4.2.2 通用正则表达式 [<common-regexps> </common-regexps>]

其定义的格式为：

<regexp name="htmlId" value="[a-zA-Z0-9\:\-_\.]+"/>

htmlId为正则的名称，通过名称被引用

value后面是具体的正则表达式的内容  该部分可以参考antisamy中样例规则文件编写；

如有特殊需要，正则表达式可以参考网上其他资料进行编写。

4.2.3 通用属性 [<common-attributes> </common-attributes>]

通用属性义如下：

1. <attribute name="media">
2.     <regexp-list>
3.         <regexp value="[a-zA-Z0-9,\-\s]+"/>
4.         <regexp name="htmlId"/>
5.     </regexp-list>
6.     <literal-list>
7.         <literal value="screen"/>
8.         <literal value="tty"/>
9.         <literal value="tv"/>
10.     </literal-list>
11. </attribute>

“attribute name”为标签的名称,与html的tag名称保持一致；

“regexp name”为标签需要满足的正则表达式的名称，其在<common-regexps>中定义；

“regexp value”为标签需要满足的正则表达式；

可以通过literal直接指定属性的值；如media的值可以满足上面两个的正则表达式外，也可以为screen、tty、tv中的一个

注：<regexp-list><literal-list>中的值均可以为多个

4.2.4 全局tag属性<global-tag-attributes>

其定义和4.2.3中通用属性的定义无区别，只能功能不同；

具体功能在后面tag的规则介绍（4.2.7）中展示；

4.2.5 编码处理tag<tag-to-encode>

此处标识的tag将在输出中进行编码；

其定义的格式为：

1. <tags-to-encode>
2.    <tag>g</tag>
3.    <tag>grin</tag>
4. </tags-to-encode>

但是实际测试的时候，并未生效。

4.2.6 tag处理规则<tag-rules>

tag-rules的定义规则如下：

1. <tag name="button" action="validate">
2.     <attribute name="name"/>
3.     <attribute name="value">
4.    <regexp-list>
5.    <regexp name="anything"/>
6.    </regexp-list>
7.     </attribute>
8.     <attribute name="type">
9.         <literal-list>
10.             <literal value="submit"/>
11.             <literal value="reset"/>
12.             <literal value="button"/>
13.         </literal-list>
14.     </attribute>
15. </tag>

tagc-rule的action有三种：remove、validate、truncate，各个动作的功能在4.1中介绍过，不再赘述.

其中有一种场景需要注意：

<tag name="h1" action="validate"/>

这种标签中action是validate，但是标签的属性需要遵守的正则却没有标识出来；在这个时候，4.2.4中全局tag属性中定义的属性就起作用了。上面这种类型的标签就需要遵守4.2.4中定义的全局属性；

如：h1标签处理规则如下：

<tag name="h1" action="validate"/>

输入为：

<div><h1 id='h111' align='center'>h1 title</h1></div>

输出为：

1. <div>
2.   <h1 id="h111">h1 title</h1></div>

在global-tag-attribute中有”id”， “style”，”title”,”class”,”lang”这5个标签，不包括align，所以在输出中就被过滤掉了。

4.2.7 css处理规则<css-rules>

css-rules定义如下：

1. <property name="background-color" description="This property sets the background color of an element, either a &lt;color&gt; value or the keyword 'transparent', to make the underlying colors shine through.">
2.     <literal-list>
3.         <literal value="transparent"/>
4.         <literal value="inherit"/>
5.     </literal-list>
6.     <regexp-list>
7.         <regexp name="colorName"/>
8.         <regexp name="colorCode"/>
9.         <regexp name="rgbCode"/>
10.         <regexp name="systemColor"/>
11.     </regexp-list>
12. </property>

从上面可以看出，css过滤规格的定义和tag的基本相同；但是css有一些特殊的字段，如：

1. <property name="background" description="The 'background' property is a shorthand property for setting the individual background properties (i.e., 'background-color', 'background-image', 'background-repeat', 'background-attachment' and 'background-position') at the same place in the style sheet.">
2.     <literal-list>
3.         <literal value="inherit"/>
4.     </literal-list>
5.     <shorthand-list>
6.         <shorthand name="background-color"/>
7.         <shorthand name="background-image"/>
8.         <shorthand name="background-repeat"/>
9.         <shorthand name="background-attachment"/>
10.         <shorthand name="background-position"/>
11.     </shorthand-list>
12. </property>

相比tag的过滤规则，css增加了shorthand-list，为css的自有语法。意味着如果background有多个值，说明使用了css的缩写，同时需要满足shorthand中规定的属性的过滤规则。

4.3 通用策略文件

5 Antisamy代码简介

antisamy对html进行扫描的主要流程如下：

其中

recursiveValidateTag(tmp, currentStackDepth);

为antisamy最终执行扫描的函数，其通过递归调用对html中每一个标签根据规则文件的定义进行处理。

来源：https://blog.csdn.net/RayChiu757374816/article/details/79016101