Aho-Corasick算法、多模正则匹配、Snort入门学习

希望解决的问题

. 在一些高流量、高IO的WAF中，是如何对规则库(POST、GET)中的字符串进行多正则匹配的，是单条轮询执行，还是多模式并发执行
. Snort是怎么组织、匹配高达上千条的正则规则库的，怎样保证效率和准确性的平衡
. 状态机、Aho-Corasick算法的核心思想
. 怎么进行多模正则匹配的编程实现

相关学习资料

http://zh.wikipedia.org/wiki/%E7%A1%AE%E5%AE%9A%E6%9C%89%E9%99%90%E7%8A%B6%E6%80%81%E8%87%AA%E5%8A%A8%E6%9C%BA
http://zh.wikipedia.org/wiki/%E9%9D%9E%E7%A1%AE%E5%AE%9A%E6%9C%89%E9%99%90%E7%8A%B6%E6%80%81%E8%87%AA%E5%8A%A8%E6%9C%BA
http://stblog.baidu-tech.com/?p=418
http://blog.csdn.net/beta2/article/details/5698171
http://www.cnblogs.com/xudong-bupt/p/3433506.html
http://blog.csdn.net/sealyao/article/details/4560427
http://www.cppblog.com/yefeng/archive/2009/12/06/102671.html
http://www.wanghd.com/blog/2012/09/27/aho-corasicksuan-fa/
http://en.wikipedia.org/wiki/Aho-Corasick
http://yzmduncan.iteye.com/blog/1217014
http://www.openfoundry.org/tw/tech-column/8265--snort-
http://www.freebuf.com/articles/system/37507.htm

目录

. 状态机简介
. 多模匹配算法简介
. Aho-Corasick算法学习
. 多模正则匹配的编程学习
. Snort高速规则匹配原理学习

1. 状态机简介

状态机的概念非常复杂，我们着重理解其中的一些核心知识概念

0x1: 确定有限状态自动机

在计算理论中，"确定有限状态自动机"或"确定有限自动机"(deterministic finite automaton, DFA)是一个能实现状态转移的自动机。
对于一个给定的属于该自动机的状态(往往是初始状态)和一个属于该自动机字母表的字符(输入参数)，它都能根据事先给定的转移函数转移到下一个状态(这个状态可以是先前那个状态，即状态自循
环)

"确定有限状态自动机"的数学定义:

组成
. 非空有限的"状态集合": Q
. 输入字母表: A(非空有限的字符集合)
. 转移函数: F
它接收两个参数:
    ) 当前状态: q
    ) 输入字母: a
返回一个结果: 一个新的状态: p
. 一个开始状态(初始状态): i
. 一个接收状态的集合: S
这个所谓的"接收状态的集合"可以这么理解，当所有的输入字母表都输入完毕后，状态机停留在最后一个状态的位置，这个状态位置是否达到了我们的要求(即是否接收)
(结合一下正则匹配的过程来理解，正则匹配最后输出的匹配位置其实就是一种状态机的"终点转移位置")

它们一起组成状态机的5元组
{Q、A、F、i、S}

"确定有限状态自动机"的工作方式

确定有限状态自动机从起始状态开始，一个字符接一个字符地读入一个字符串string，并根据给定的转移函数一步一步地转移至下一个状态。在读完该字符串后，如果该自动机停在一个属于S的接受
状态，那么它就接受该字符串，反之则拒绝该字符串
看到这里，我们可以很自然地想到这个理论的利用场景:
　　) 正则的匹配(思考状态机的逐字符读取、以及最终状态的判定)
　　) 目标字符串的搜索

0x2: 非确定有限状态自动机

在计算理论中，非确定有限状态自动机或非确定有限自动机(NFA)是对每个状态和输入符号对可以有多个可能的下一个状态的有限状态自动机。这区别于确定有限状态自动机(DFA)，它的下一个可能
状态是唯一确定的。
非确定有限自动机有时被称为有限类型的子移位(subshift)。非确定有限状态自动机可推广为概率自动机，它为每个状态转移指派概率。

"非确定有限状态自动机"的性质

机器开始于任意初始状态并"逐个读取"来自它的符号表的符号的字符串。
自动机使用状态转移函数:F来使用当前状态: q，和刚读入的符号:a或空串: null来确定下一个状态: p
如果在自动机完成读取的时候，它处于接受状态，则称 NFA 接受了这个字符串，否则称为它拒绝了这个字符串

0x3: 有限状态自动机的原理性伪码表示

关于确定有限状态自动机、非确定有限状态自动机，除了数学上的定义理解，我们还可以从伪代码的角度去理解

while(读取输入字母表的下一个字符: a)
{
    curState: q = 状态转移函数F(p, a);
    lastState: p = curState: q;
}

function 状态转移函数F(p, a)
{
    if(condition_1)
    {}
    else if(condition_2)
    {}
    else if
    ...
    else
    {}
    //condition_x: 状态和字符的笛卡儿积关系，以矩阵的形式表示了映射关系
}

这两张状态转移图很形象地说明了状态机的逻辑意义，我们可以很容易地将这个概念思想应用到编程实践中

2. 多模匹配算法简介

了解了状态机的基本概念之后，我们可以继续学习多模匹配算法的基本概念了

多模式匹配在这里指的是在"一个字符串"中寻找"多个模式字符字串"的问题。
一般来说，给出一个长字串和很多短模式字符串，如何最快最省的求出哪些模式字符串出现在长字串中是我们需要思考的(因为基本上大多数情况下是在给定的长字串中出现我们给的模式字串的其中
几个)
该算法的应用领域有很多，例如:
    ) 关键字过滤
    ) 入侵检测
    ) 病毒检测
    ) 分词等
多模匹配算法是一个概念性的称呼，它的具体实现有很多，例如:
    ) Trie树
    ) AC算法
    ) WM算法 

简单来说，多模匹配就是要我们实现下面的功能，用demo代码进行演示

<?php
    public function CheckSql($db_string)
    {

        $express_1 = "/([A-Za-z])?(where)(.)*?(concat|char|(chr.*){4,}|case|floor|#.*|--)/i";
        $express_2 = "/([A-Za-z])?(where).*(union)(\s)*(all)?(\s)*select(\s)*((\d|null),(\s)*){2,}/i";
        $express_3 = "/[^0-9a-z@\._-]{1,}(sleep|benchmark|load_file|outfile|(user\(\).*){1,})[^0-9a-z@\.-]{1,}/i";
        $express_4 = "/([A-Za-z])?(where)(.|\s)*?(or|and|like)('\d'(=|>|<|like)'\d')/i";
        if (preg_match($express_1, $db_string) || preg_match($express_2, $db_string) || preg_match($express_3, $db_string) || 
preg_match($express_4, $db_string))
        {
            //die("detected!!!");
            return ;
        }
        else
        {
            //die("good");
            return ;
        }
    }
?>

文章 介绍了多模算法的基本原理，以及一种算法的实现: dictmatch

3. Aho-Corasick算法学习

0x1: Aho-Corasick(AC)算法的总体流程

. 建立树过程
    ) 根据关键字(即待搜索模式集合)建立起一颗Tire树
    ) 设置第一层的不匹配的转移节点
    ) 设置其余的不匹配转移节点
    ) 设置Tire树的各个节点的输出字符(即当到达某个状态时表明某个模式匹配成功，需要输出对应的字符串)
    ) 初始化状态到根节点

. 查找过程
    ) 逐个输入待搜索字符串
    ) 根据状态机的转移结果判断是否有模式匹配成功

关于算法的原理、流程可以参阅文章头部给出的链接，我就不做重复的引用了。在这里，我想依托一个PHP的AC算法的DEMO，一边分析源代码，一边解析AC算法的流程

将下列文件放置在web目录下，即可运行

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAk4AAABxCAIAAACsiLvzAAAY8klEQVR4nO2dS08j17bH/WUitfIFIo8ySjdRexQyRj2IkRKpATG0oSMlEh5Ex7ESpDBBDjCIDrIDXMvqUoGh1X24V+IcYXXrDJAA0+fhzLoDfoPL1h2UH/tZe9tUuU3x/8kDu7z2o8pV+19r7fJeAQsAQHB90/zQXbgX4DiPhvt2nGX7GxhxPwAYc5r3a2T4YOA4j4b7dpxl+wupAwAA4HMgdQAAAHwOpA4AAIDPgdQBAADwOZA6AAAAPgdSBwAAwOdA6gAAAPgcSB0AAACfw0rd9U3z+d//85f0PxfXj/HCCy+88MJrbF9/Sf/z+d//o7MiDCt1vx++zR79+12p0QIAAADGmHelRvbo378fvh1Y6r7/7XW9QSnkCzn7+/u7u7vKNgAAAAAvqDea3//2WmnGSt3i+nGr1SK3vHjxwmo2LavZalmtltVut9rtlmU12+3W0dGRaZrmrulmxwEAAAA9Wq3W4vqx0kwtdQcHB83mDa927Xbr8PCwVqsZhpHL5dzsOwAAAKCBa1KXy+Vubq6FameapmEYhmGYpsqxy4QDwfjJgPvgBh+sYQDAmFE0Yk+TecmX+WTMKJIf5aZgjHBN6vb29m6uGzc317+n0xvr62trv66trW1sbGxvb7fbrT+KxbcXF5A64H+KRuxpB2IMzCc726hx0t4sGCqLRow1JUfgXm1cUaWNrEW5Qa8ivvvSDosPgosQDfSb4CSqv0Fo70A+KdnVntJ13kDqvEB1/lBH3TZO5i3Hc9U1qTNN87pRf//+3dzc3PLPP6V+nH6+HF5eXp6dnb28/NN27wzDULQDqQN3G+Kenx5newPkU3LwjSWTAgeiaMRisRg71haNWMwoWlbRiHVK9CvTsnFo0XIwkI760g4LD4K7dHfUIo+us9Tx9pSdgl4LtNJB6jxAff4QR526CMhzlbk6XJM6wzAa9Vrh/Hxqaurr8JNXPzyMf/PpdPirqampi4sLSB24fxC607/mmGtXcCnbxTiBESkOu03HRik+rIFS6iQdJr90KD0cVLXdpvWkTr5H/RuEHnS4UuAza3i84BaIz5+u1OWT9GEnf1nmbHBN6rLZbL1WOzs7C4VCjyc+m574ODf/0ZPQJ6FQqFAo2PN22WxWVHkmHCDoK05/e3dbJhwIxjPxYCAQCATCmb4JIVNkbeEM29ZJPBgIZ/o2XYtMOBCMx8P0VpkxADoQ1yMdyiQuTtHo3A2MDaxiOjZDSZ0oUkg4ScIOMwfBZTyROl7raKXrxXaJ2uDVeYv4+OaTT5N5gXtO/LLsyeCa1GUymVq1enZ2Ojk5+fjzR999+WDxiwcTjx5OTk4WCoWW1Wy1rEyG14pMmJCQTLinWqSbZUtO5/vOZluA7JK978kK2Lr7VVECRxQkarPrkBkDoKZ31THXnKPUUW4DM8qykxPcNIaOzRBSR33R3yV254T6oRH8HA5pAJNDJ4Apqlb4KZmMJfOUIkLqvER2/nRuv0Q3dp7P1e3s7NQqlbPT00gkMjMz02tufn6+UDi3rKZlNXd2dtiKmcBh7yPt6XUFjrQWvWfDkH0NlGwhRZRU1r7UiYwBUMBOIOhJHfmBMpPPWEjjNUIbBzstA6dgKD8q8VOJ7kGqmvwQiB9LcRRfcjaO8ZkNo8iHOCF1nuFw/thHnTu36d+MLu+a1KXT6Wq5fHx8vLW1tbKy8kuXzc3NN29e239CSKfTbMUOUieYOxtC6phaIHXAc9hL1Em1yI8ipySZ58vQTXWq1rERdYBHX+qkHRYcBJcRTuHoBjAVyFwGqxvhFE3UYbLOXZzPn+4NRtGIsQ86Ez8C9ck1qUulUpVS6WB/f3FhIRqJRKORhWh0IRr99tmzVy9f2n+5S6VSXM1kWPAkHiQDmGRgsxdmdJQ6PoDZ1ywiJkm1x9dMSZ3IGAAZwugYMQRrPyQinXUgHAuiMR0bRYsSg3ySVC82gCntsMfD/gikTvInEHh1nqM+f5gnMMWhBY+8utXV1XKpVCmVquVytVKpVSv1arVeqzXq9etGw/7L3erqqqBu8umTODNDJ3p4xEnqLDr0ScoU4aiF+QdN5F6dwBgACez9Pjn4M+Mn6xLxQ2hfxfgHS5hCOjaqFqUG/H8CnaVOdhDcxBOp63ScGkS5+wRInddonD/cnEDHii5K/TCuSV0ikShfXZVLV121K9NqV7+5biQSicH22X0GCkIiYgk+PDpPdnj29Mc9oaPx0odxnhLuLKTubuKa1C0tLZUuL3tqVxGp3dLSkpt9HwZIHbhbQOkAcAHXpC6ih5t9HwZIHQAA3DtckzoAAABgPBlS6mJ/fV2qXnvTJQAAAMBNStXr2F8HT836P//3L+Mf/603mt6nSgcAAACGp95oGv/47/b//mtgqas1btJ/e/v9b68X14/xwgsvvPDCa2xf3//2Ov23t7XGzcBSBwAAAPgMtdS9kLO/v7+7uzuCXgIAAABDoyV1VrNpWc1Wy7JT9rTbLctqttuto6Mj0zTNXVUKcgAAAODDoZa6g4MDe01nRu3a7dbh4WGtVjMMI5fLjaCvAAAAwBCopS6Xy9lrOvNqZ5qmYRiGYZimvmPnp7TgftoXAHyP44rYdLZWLAzmM9RSt7e3Z6/p/Hs6vbG+vrb269ra2sbGxvb2drvd+qNYfHtxAakD/ke00LJoyeT+ZvEK+vwyt1QaVIcVmx1tZC3KDRzSXUo7LD4ILkKtTE1mcdDIV6fTJelaaz2l67yB1HmA8pQTZCFO5nUKKlFLnWma1436+/fv5ubmln/+KfXj9PPl8PLy8uzs7OXln7Z7ZxiGdot+kgc/7Qtwhrjnp8dZYtV/YvCNJZMCB6JoxGIxLndAd3H+/pLDfE4vRxuHFi0HA40VNpkOCw+Cu0izkKszGwjSMgjTl4uW1ycTt9pvIHUeoDzlmCQ+ZBbkXsHhMiaqpc4wjEa9Vjg/n5qa+jr85NUPD+PffDod/mpqauri4gJS55d9AfoQuiPONM5/7BfjrnbR5c8lytawGTg1q3LckXSY/NKh9HBQ1Xab1k3iI9sjPm8BE64U+My39SKAAG2pY/OQkwWHu8tSS102m63XamdnZ6FQ6PHEZ9MTH+fmP3oS+iQUChUKBXveLpvNcuXsJZUzXFK4TNhOX0dtlRkz9fHfkjnxTlT2slaUrbu9L+BuQ1yP0kTJotG5GxgbWMV0bIaSOlGkkHCShB1mDoLLeCJ1vNbRSteL7RK1wavzAMEpxxkk8wL3XJrQWBu11GUymVq1enZ2Ojk5+fjzR999+WDxiwcTjx5OTk4WCoWW1Wy1rExGJk2EKPTTgnffMjnEBcZEbWEyRWu/KolXJbSXtaLRupv7Au42vauOy+rtIHWU28CMsuzkhCibq9JmCKmjvmCzkEs7LNpZF5EGMDl0ApiiaoWfkslYMk8pIqTOS2S/VUcLRTd2ns/V7ezs1CqVs9PTSCQyMzPTa25+fr5QOLespmU1d3Z2uHJMopzeR3lacIExVyPpKanCh5xfJ2tF2br7+wLuKOwEgp7UkR8oM4n6UOEbHRsHOy0Dp2Aor2rDTZboQaqa/BCIH0txHALJ2TjGZzaMIlKzjhrxzZJ91Llzm7Ye6vxTS106na6Wy8fHx1tbWysrK7902dzcfPPmtf0nhHQ6zZVzVR5O4sGeAyesSdA4Zw+pA7eDvcScVIv8KHJKknm+DN1Up2odG1EHePSlTtphwUFwGeEUoG4AU4HMZbC6EU7RRB0m67zBSeo6Z6D0PnKYmIJa6lKpVKVUOtjfX1xYiEYi0WhkIRpdiEa/ffbs1cuX9l/uUqkUV+4kHqRnw/pBP7E8CIx7UUGiEF1VP1AYj5+o7GVdUrXuyr6Au40w4kIMwdoPiUhnHQjHgmhMx0bRosQgnyTViw1gSjvs8bA/AqmT/AkEXp3niE451oK6pxKHFjzy6lZXV8ulUqVUqpbL1UqlVq3Uq9V6rdao168bDfsvd6urq1y5k3gwEA7zD2fIPSHemJ0ACwQCgWA4HKSVpF9EYS/rklbrt90XcKdh7/fJwZ8ZP1mXiB9C+yrGP1jCFNKxUbUoNeD/E+gsdbKD4CaeSF2n49Qgyt0nQOpGgORvqOT3tC/XsaRPvWF+GLXUJRKJ8tVVuXTVVbsyrXb1m+tGIpHgyg0UuBtNlE/WirL1MdwXcOfRicJ49vTHPaGj8dKHcZ4S7iykzteopW5paal0edlTu4pI7ZaWlrhyYygPkDowPkDpABgdaqmL6MGVG0N5gNQBAMB9BKlZAQAA+BxIHQAAAJ8DqQMAAOBzIHUAAAB8DqQOAACAz1FL3Qs5+/v7u7u7I+glAAAAMDRaUmc1m5bVbLUsO2VPu92yrGa73To6OjJN09zVT0EOAAAAjBq11B0cHNhrOjNq1263Dg8Pa7WaYRi5XG4EfQUAAACGQC11uVzOXtOZVzvTNA3DMAzDNPUdO2TuHhk41ACQOK6ITWdrxcJgPkMtdXt7e/aazr+n0xvr62trv66trW1sbGxvb7fbrT+KxbcXF5C6sQSH2lVECy1L16+llmVnK2EX+6LSoDqs2OxoI2txuC7JkmH2D4JHK5ZRK1OTWRw08tXpaJN0rbWe0nXeQOq8QHX+CLIQJ/PWaFKzmqZ53ai/f/9ubm5u+eefUj9OP18OLy8vz87OXl7+abt3hmFotzj+468rK3t5tDzYQNWO/6G+QxD3/PQ4S6z6Twy+sWRS4EAUjVgsxuUO6C7O319ymM9S4mjj0KKlMhB3yRJrAtGmV8tzSrOQqzMbCNIyCNOXi9IzkIlb7TeQOvdRnz9MEh8yC3LPfLiMiWqpMwyjUa8Vzs+npqa+Dj959cPD+DefToe/mpqauri4gNR5Wcktqx3/Q31HIXRHnGmc/9gvxl3jEk1ho2lKm2FSs0q6JGmSTUXreRKfboO6SXxk+svnLWDClQKf+bZeBODQOH+6UsfmsyOLKk90IWqpy2az9Vrt7OwsFAo9nvhseuLj3PxHT0KfhEKhQqFgz9tls1munD0oZ7i8bZlwIBiPh+mtMmOmPv7bfhF6UJdVSGzvFGBq6H8MBDvJXh3thX1jKsmEA8F4pmMTzvS/J/rMV0sdKFHfPDvUQAFxPUoTJYtG525gbGAV07EZQur4LjFuKhMXdMq67haeSB2vdbTS9WK7RG3w6lxH4/zJJ58m8wL3XJrQWBu11GUymVq1enZ2Ojk5+fjzR999+WDxiwcTjx5OTk4WCoWW1Wy1rExGJk3EqEukDidSpZKZVHljorZwd3Cnq5K4LbIK6e1sbtV+glc696vKXtA3shJCKW2JYU2E1UoPFCdO7h5qoKB31XFZvR2kjnIbmFGWnZwQZXNV2gwudaIuiVKz0nFEKq2rt1LHNMyiE8AUVSv8lEzGknlKESF1rqNx/nRusIShc6/n6nZ2dmqVytnpaSQSmZmZ6TU3Pz9fKJxbVtOymjs7O1w5ZlAmR3BJ5m6BMVcj4ztJ43OyCunthJtEOEus1KnsRX1jpS5IiCH3XlytzoHy6lADGewEgp7UkR90XCMqfKNj42AnMZB2SQDxPfEUjpEcashRQKqa/BCIH0tx7A85G8f4zIZRRGrW0aA6f+yjzp3b9G821GSdWurS6XS1XD4+Pt7a2lpZWfmly+bm5ps3r+0/IaTTaa6cq+PvSTzY0xVhTbqtc9IlqMFR6nh7Yd8GlTpBNyB1Ywd7iTmpFvlR5JQk83wZuinC0VLZiDrAo9UljYZ6G72QAuEUjm4AU4HMZbC6EU7RRB0m67xBfP50t5IOYGc78SMM80yUWupSqVSlVDrY319cWIhGItFoZCEaXYhGv3327NXLl/Zf7lKpFFfuJB6kp8jEwToiqsYb98JuRCG6qr6cxDsza44VsiM7Fb/LhHkbDXtx3waROnE3VEKl3tlBDjVQIIyOEUOw9kMi0lkHwrEgGtOxUbQ4QJf6leaT5JNw6plCtxiB1En+cQGvboTIzh/mCUxx4MEjr251dbVcKlVKpWq5XK1UatVKvVqt12qNev260bD/cre6usqVO4kHA+Ew//SDfATnjdkZpkAgEAiGw+xUWq8IM6claF3sLwqMAuRjKc724r4RlSilTlit8EAR1ap3dpBDDZxh7/dJtWLGT9Zh4ofQvq7wD5YwhXRsVC0O1iVRrLLI1eOZn+OJ1HV2hRpEufsESJ3nqM8fbk6gY0pff8P8MGqpSyQS5aurcumqq3ZlWu3qN9eNRCLBlRsoMuZ6GO1exeU+7KEGQ6LjGHnmPN0TOmOrcGjsfNd78AVS52vUUre0tFS6vOypXUWkdktLS1w5SN3IgNTdRaB0AIwOtdRF9ODKQepGBqQOAACcQGpWAAAAPgdSBwAAwOdA6gAAAPgcSB0AAACfA6kDAADgc9RS90LO/v7+7u7uCHoJAAAADI2W1FnNpmU1Wy3LTtnTbrcsq9lut46OjkzTNHf1U5ADAAAAo0YtdQcHB/aazozatdutw8PDWq1mGEYulxtBXwEAAIAhUEtdLpez13Tm1c40TcMwDMMwTX3HzgepsYfbBR/sOAB3GscVselsrVgYzGeopW5vb89e0/n3dHpjfX1t7de1tbWNjY3t7e12u/VHsfj24gJS51kpMDaIFloWLorc2yxeQZ9f65ZKkuqwYrOjjTJXKmegle6S7bBkf12DWpmazOKgka9OR5uka631lK7zBlJ3e/hzUnwRUSXYLMTJvKV5rjqiljrTNK8b9ffv383NzS3//FPqx+nny+Hl5eXZ2dnLyz9t984wDO0WfTDiQ+ruIcQ9Pz3O9vN9koNvLJkUOBBFIxaLccmAuovz95cc5rOUONo4tGg5GGissMl0WLi/7iLNQq7ObCDIsyRMX07Ta4FWOkjd7RCecsKLiIJJ4kNmQe4VHe7UU0udYRiNeq1wfj41NfV1+MmrHx7Gv/l0OvzV1NTUxcUFpM7jUmAMIXRHnNab/9gvxgmMSHG4RNkaNgPnq1NKHdthp/11CyopT7dp3SQ+sj3i8xYw4UqBz3xbLwJYjieJOPtSV+rYJInkLzvcmaeWumw2W6/Vzs7OQqHQ44nPpic+zs1/9CT0SSgUKhQK9rxdNpvlytnLCme4xGiZcCAYj4fprTJjpj7+234RRkZE5iJjSf65Tmc6dkxB4S54tuNg7CCuR2miZNHo3A2MDaxiOjZDSZ0oUkg4SUyHnfbXLTyROl7raKXrBdqI2uDVuYDDOemQhVzgnksTGmujlrpMJlOrVs/OTicnJx9//ui7Lx8sfvFg4tHDycnJQqHQspqtlpXJyKSJGOeJ1OFEpm4y8ypvTNQWJhKaElWJHSXB8v1MntJuLldBtXRnBK0Id8GjHQdjR++qY645R6mj3AZmlGUnJ0SpU5U2t8lCTkcK2Z3T21+3kAYwOXQCmKJqhZ+SyVgyTykipM4FNBLfc9uFfvQo5up2dnZqlcrZ6WkkEpmZmek1Nz8/XyicW1bTspo7OztcOUZteh/lqbEFxlyNpPPjFBG0/STi677jxDp2nF9Hty5oRZwf3LsdB+MDO4GgJ3XkB8pMPmOhjNewIZ5bSJ1zMHTkXh0/pGk+luLYHXI2jvGZDaOI1KyeID7lHCbb7KPOndv0bzbUZJ1a6tLpdLVcPj4+3traWllZ+aXL5ubmmzev7T8hpNNprpyrI/5JPNgTJ2FNYmwV6wcdWWNhtZA6IIG9xJxUi/wockqSeb4M3ZRogkxiI+oAj77USTqso9K3RTiFoxvAVCBzGaxuhFM0UYfJulsgOEmcdap7g1E0YuyDzvRjwAP/JGqpS6VSlVLpYH9/cWEhGolEo5GFaHQhGv322bNXL1/af7lLpVJcuZN4kJ7+6sfxxCO+wLgX6CMK0VX1Y3/x+Enf/iQepybeGGMrE2bVh6iW0RuuFeEuMDHJW+44GDuE0THiStZ+SEQ660A4FkRjOjaKFiUG+ST5rBsbwFR12KsE6SOQOsmfQODVuY/g/s/512KewBTHQjzy6lZXV8ulUqVUqpbL1UqlVq3Uq9V6rdao168bDfsvd6urq1y5k3gwEA7zz1vInRvemJ3TCgQCgWA4HKTFoV+EmDkTPOkheQKFq1bsUxLl1FJ32x0H4wZ7v08O/sz4ybpE/BDaVzH+wRKmkI6NqkWpAf8fOYXUCffXXTyRus6OUoMod58AqXMT0Sknu4gIuBh5x4ouOswPo5a6RCJRvroql666alem1a5+c91IJBJcuYFicX4K3N3bHQeDoeMXeeU73Rc6A670YZynhDsLqfM1aqlbWloqXV721K4iUrulpSWu3L0d8e/tjoOBgNIBMDrUUhfRgyt3b0f8e7vjAAAwpiA1KwAAAJ8DqQMAAOBzIHUAAAB8DqQOAACAz4HUAQAA8DmQOgAAAD4HUgcAAMDnQOoAAAD4HEgdAAAAnwOpAwAA4HMgdQAAAHwOpA4AAIDPgdQBAADwOZA6AAAAPgdSBwAAwOdA6gAAAPgcSB0AAACfA6kDAADgcyB1AAAAfA6kDgAAgM+B1AEAAPA5kDoAAAA+5/8B+lVMKQoiZy8AAAAASUVORK5CYII=" alt="" />

0x2: Aho-Corasick(AC)代码分析

demo.php

<?php
/*
    这个AC算法小程序的架构如下:
    1) demo.php: UI显示层
    2) php.ac.app.php: 业务实现层，封装了实现逻辑
    3) php.ac.search.php: AC多模式匹配的搜索查找算法的实现逻辑
    4) php.ac.pretreatment.php: AC算法的预处理(生成树)的实现逻辑
*/

//引入文件
include("php.ac.app.php");
$obj = new ACAppClass(); 

echo "<br>=================<br>";
$words2 = array("microsome", "cytochrome", "cytochrome P450 activity", "gibberellic acid biosynthesis", "GA3", "cytochrome P450", "oxygen binding", 
"AT5G25900.1", "protein", "RNA", "gibberellin", "Arabidopsis", "ent-kaurene oxidase activity", "inflorescence", "tissue");
$text2 = "The ga3 mutant of Arabidopsis is a gibberellin-responsive dwarf. We present data showing that the ga3-1 mutant is deficient in ent-kaurene
oxidase activity, the first cytochrome P450-mediated step in the gibberellin biosynthetic pathway. By using a combination of conventional map-based 
cloning and random sequencing we identified a putative cytochrome P450 gene mapping to the same location as GA3. Relative to the progenitor line, 
two ga3 mutant alleles contained single base changes generating in-frame stop codons in the predicted amino acid sequence of the P450. A genomic 
clone spanning the P450 locus complemented the ga3-2 mutant. The deduced GA3 protein defines an additional class of cytochrome P450 enzymes. The 
GA3 gene was expressed in all tissues examined, RNA abundance being highest in inflorescence tissue.";
$res2 = $obj->findWordsInArray($words2, $text2);
var_dump($res2);
?>

php.ac.app.php

<?php 

// 引入文件
include("php.ac.search.php");

class ACAppClass
{
    private $showtimeFlag;    // 是否显示运行时间，false：不显示；true：显示，默认为false

    /**
     * @function 构造函数
     * @param
     * @return
     */
    public function ACAppClass()
    {
        $this->showtimeFlag = false;
    }

    /**
     * @function 从字符串中查找单个关键词
     * @param string word 关键词
     * @param string text 被查找的字符串
     * @return Array
     */
    public function findSingleWord($word, $text)
    {
        try
        {
            if(strlen(trim($word))==)
            {
                throw new Exception("Key word's content is empty.");
            }
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            return;
        }
        //复用了从字符串中查找多个字符串的代码逻辑(单个是多个的一种特殊情况)
        $arr = array(trim($word));
        return $this->findWordsInArray($arr, $text);
    }

    /**
     * @function 从字符串中查找多个关键词
     * @param Array words 关键词数组
     * @param string text 被查找的字符串
     * @return Array
     */
    public function findWordsInArray($words, $text)
    {
        $len = count($words);
        try
        {
            if($len==)
            {
                throw new Exception("Array of keywords is empty.");
            }
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            return;
        }
        if($this->showtimeFlag)
        {
            $starttime = $this->getmicrotime();
        }
        /*
            构造AC算法"搜索关键词字典树"，主要有两个主要步骤
                1) 状态转移树的建立(将需要查找的关键字模式转换为一个树的形式)
                2) 失效转移树的建立(在状态转移树的基础上进行完善添加当出现转移失败时，状态应该跳转到的下一个状态)
                3) 状态输出的建立(在到达某个状态的时候，可以表明某个模式匹配成功，可以输出某个字符串)
        */
        $tree = new AhoCorasick();
        try
        {
            for ($i=; $i<$len; $i++)
            {
                if(trim($words[$i])=="")
                {
                    throw new Exception("Key word's content is empty.");
                }
                /*
                添加搜索词
                将搜索词(待匹配的模式)转化到状态转移树的形式中
                */
                $tree->add(trim($words[$i]));
            }
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            return;
        }
        //向状态转移Tire树中添加"失效转移"部分
        $tree->prepare();
        //状态转移Tire树准备完毕
        $res = array();

        /*
        开始在目标字符串中进行多模式搜索
        本质上来说: 搜索的过程是以目标字符串为输入参数，逐个输入来使状态在Tire树中进行状态转移，最终得到输出字符串
        */
        $obj = $tree->search($text);
        while($obj->hasNext())
        {
            $result = $obj->next();
            $res = array_unique(array_merge($res, $result->getOutputs()));
        }
        if($this->showtimeFlag)
        {
            $endtime = $this->getmicrotime();
            echo "<br>run time is: ".($endtime-$starttime)."ms<br>";
        }
        return $res;
    }

    /**
     * @function 从文件中查找关键词
     * @param string $keyfile 关键词所在的文件名称及路径
     * @param string $textfile 被查找的内容所在的文件名称及路径
     * @return Array
     */
    public function findWordsInFile($keyfile, $textfile){
        try{
            if(!is_file($keyfile) || !is_file($textfile)){
                throw new Exception("Can not find the file.");
            }
        }catch(Exception $e){
            echo $e->getMessage();
            return;
        }
        // 搜索词所在的文件内容为空时，抛出异常
        try{
            if(strlen(trim(file_get_contents($keyfile)))==){
                throw new Exception("File's content is empty.");
            }
        }catch(Exception $e){
            echo $e->getMessage();
            return;
        }
        // 打开文件
        $handle1 = fopen($keyfile, "r");
        $handle2 = fopen($textfile, "r");
        $arr = array();
        $contents = "";
        try{
            while (!feof($handle1)) {
                $line = trim(fgets($handle1));
                if(strlen($line)!=){
                    $arr[] = $line;
                }
            }

            while (!feof($handle2)) {
               $line = trim(fgets($handle2));
                if(strlen($line)!=){
                    $contents .= $line;
                }
            }
        }catch(Excption $e){
            echo $e->getMessage();
            return;
        }
        // 关闭文件
        fclose($handle1);
        fclose($handle2);
        return $this->findWordsInArray($arr, $contents);
    }
    /**
     * @function 获取时间戳，单位为毫秒
     * @param
     * @return float
     */
    function getmicrotime(){
        list($usec, $sec) = explode(" ",microtime());
        $value = (float)$usec*+(float)$sec;
        return round($value, );
    }
}
?>

php.ac.search.php

<?php
/**
 * @author: jessica.yang
 * @date: 2011-10-24
 * @filename: php.ac.search.php
 * @description: Aho Corasick多模式匹配算法，简称AC算法，包含两个阶段，第一个是预处理阶段，即字典树的生成；第二个是搜索查找阶段，该文件完成第二阶段的搜索查找功能
 */
// 引入文件
include("php.ac.pretreatment.php");
/**
 * @classname: AhoCorasick
 * @description: 用于实现AC多模式匹配的搜索查找算法
 */
class AhoCorasick
{
    private $root;        // State对象，表示根节点
    private $prepared;    // boolean类型，表示搜索词是否装载完成。如果为true，则表示加载完成，并且不能再加载搜索词
    private $arr_keys;    // Array对象，存放第一级的搜索词

    /**
     * @function 构造函数
     * @param
     * @return
     */
    public function AhoCorasick()
    {
        $this->root = new State();                //构造字典树的单个状态节点
        $this->root->setFail($this->root);        //设置根节点的失效值，对于根节点来说，它的失效转移节点就是它自己本身
        $this->prepared = false;                //搜索词还未装载完成
        $this->arr_keys = array();                //存放第一级搜索词
    }

    /**
     * @function 获取根节点对象
     * @param
     * @return State
     */
    public function getRoot()
    {
        return $this->root;
    }

    /**
     *@function 添加搜索词
     *@param string $keywords 要查找的搜索词
     *@return
    **/
    public function add($keywords="")
    {
        // 如果装载标志为true，则禁止再加载搜索词
        try
        {
            if ($this->prepared)
            {
                throw new Exception("can't add keywords after prepare() is called.");
            }
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            return;
        }

        // 如果搜索词不是字符串类型，或者内容为空，则返回
        try
        {
            if(!is_string($keywords) || strlen(trim($keywords)) == )
            {
                throw new Exception("Added keywords is not string type, or content is empty.");
            }
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            return;
        }
        $keywords = trim($keywords);
        $words = $this->str_split_utf8($keywords);                                // 把搜索词按字符为单位转换成单字符数组(因为Tire树的每个节点必须是单字符)
        $this->arr_keys = array_unique(array_merge($this->arr_keys, $words));    // 设置第一层级的搜索字符 

        /*
        将搜索词的单字符数组逐个"压入"状态转移Tire树中
        同时接收函数返回的: 添加完搜索词之后的最后一个State值(这个State代表某个模式匹配成功，可以输出对应的字符串)
        */
        $lastState = $this->root->extendAll($words); 

        /*
        向最后一个State值中添加输出内容
        这里要着重理解: lastState代表某个匹配模式匹配成功到了最后，即表示匹配成功，则对应的这个状态即为状态机中的"可接受状态"，这时可输出对应的搜索字符串
        */
        $lastState->addOutput($keywords);
    }

    /**
     *@function 加载搜索词add()完成之后调用
     *@param
     *@return
    **/
    public function prepare()
    {
        $this->prepareFailTransitions();
        //进行失效转移处理之后就不允许继续增加节点了，如果需要再次增加节点，则需要重头构建这个Tire树
        $this->prepared = true;
    }

    /**
     *@function 设置字典树中每个State节点的失效值
     *@param
     *@return
    **/
    private function prepareFailTransitions()
    {
        $q = array();    //存放第一层级的所有搜索词
        foreach($this->arr_keys as $value)
        {
            if(is_null($this->root->get($value)))
            {
                // 如果搜索词不存在于第一层级，则添加，并且设置失效值为根节点State对象
                $this->root->put($value, $this->root);
            }
            else
            {
                // 设置第一层级的失效值为根节点State对象，并且把搜索词对应的State值添加到$q数组中
                $this->root->get($value)->setFail($this->root);
                array_push($q, $this->root->get($value));
            }
        }
        die(var_dump($q));
        // 设置所有State节点的失效值
        while(!is_null($q))
        {
            $state = array_shift($q);            // 将数组$q第一个State值移出该数组，并返回移出的State值
            if(is_null($state))                    // 如果取出的$state内容为空，则结束循环
            {
                break;
            }
            $keys = $state->keys();                // 获取$state值对应的下一级所有搜索词
            $cnt_keys = count($keys);
            for($i=; $i<$cnt_keys; $i++)
            {
                $r = $state;
                $a = $keys[$i];
                $s = $r->get($a);
                array_push($q, $s);
                $r = $r->getFail();
                /*
                递归查找失效值，直到根节点为止
                这里要重点理解一下: 类似KMP算法，同样采用实效实效函数推进的方法，假设当前状态为s，s的一个孩子结点的根结点根节点
                t状态，如果当前的失效函数已知为f(s)，则显然地，f(t)必定是f(s)的孩子结点状态，所要做的就是在状态f(s)处寻找接受字
                符同s->t下一个状态，如果能找到，那就是f(t)，否则说明到s处匹配串的前缀长度太长，需缩减，所以需要找到更短的后缀，
                于是就到f(s)处继续，如果仍然找不到，则转到f(f(s))处，形成状态的递归转移
                */
                while(is_null($r->get($a)))
                {
                    //这是一个递归的过程，从根节点到当前节点，逐个向下，减少字符长度，并同时回溯查中啊是否有能够包含这个字符串的子节点
                    $r = $r->getFail();
                }
                $s->setFail($r->get($a));
                $s->setOutputs(array_unique(array_merge($s->getOutputs(), $r->get($a)->getOutputs())));
            }
        }
    }

    /**
     *@function 查找函数
     *@param string words 被查找的字符串
     *@return Searcher
    **/
    public function search($words)
    {
        return new Searcher($this, $this->startSearch($words));
    }
    /**
     *@function 查找函数
     *@param string words 被查找的字符串
     *@return SearchResult
    **/
    public function startSearch($words)
    {
        // 加载未完成时，不允许进行搜索查找
        try
        {
            if (!$this->prepared)
            {
                throw new Exception("Can't start search until prepare().");
            }
        }
        catch(Exception $e)
        {
            echo $e->getMessage();
            return;
        }
        // 转换被查找的"字符串"为"单字符数组"。因为我们知道，AC搜索算法的过程是将被查找的字符串逐个的输入状态转换树，并根据转移状态结果进行判断
        $arr_words = $this->str_split_utf8($words);
        // 搜索查找后结果集
        $res = $this->continueSearch(new SearchResult($this->root, $arr_words, ));
        return $res;
    }

    /**
     *@function 真正的查找函数
     *@param SearchResult lastResult SearchResult对象
     *@return SearchResult or NULL
    **/
    public function continueSearch($lastResult)
    {
        // 如果lastResult搜索结果对象为null，则返回
        if(is_null($lastResult))
        {
            return NULL;
        }

        $words = $lastResult->words;            // 被查找的字符数组
        $state = $lastResult->lastMatchedState;    // 开始查找的State值
        $start = $lastResult->lastIndex;        // 开始查找的位置
        $len = count($words);
        for($i=$start; $i<$len; $i++)
        {
            $word = $words[$i];                    // 获取单个字符
            // 如果获取的搜索词不存在，则递归转向失效值进行搜索，直到根节点为止
            while (is_null($state->get($word)))
            {
                $state = $state->getFail();
                if($state===$this->root)
                {
                    break;
                }
            }

            if(!is_null($state->get($word)))
            {
                // 获取搜索词对应的State值，如果有输出内容，则输出
                $state = $state->get($word);
                if (count($state->getOutputs())>)
                {
                    return new SearchResult($state, $words, $i+);
                }
            }
        }
        return NULL;
    }

    /**
     *@function 字符串转换成字符数组，单位是字符
     *@param string str 转换的字符串内容
     *@return Array
    **/
    function str_split_utf8($str)
    {
        $split=;
        $array = array();
        for($i=; $i < strlen($str); )
        {
            $value = ord($str[$i]);
            /*
            处理宽字节的情况
            http://zh.wikipedia.org/wiki/UTF-8
            1) 对于UTF-8编码中的任意字节B，如果B的第一位为0，则B为ASCII码，并且B独立的表示一个字符;
            2) 如果B的第一位为1，第二位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的一个字节，并且不为字符的第一个字节编码;
            3) 如果B的前两位为1，第三位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的第一个字节，并且该字符由两个字节表示;
            4) 如果B的前三位为1，第四位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的第一个字节，并且该字符由三个字节表示;
            5) 如果B的前四位为1，第五位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的第一个字节，并且该字符由四个字节表示;
            */
            if($value > )
            {
                if($value >=  && $value <= )
                {//双字节
                    $split=;
                }
                else if($value >=  && $value <= )
                {//三字节
                    $split=;
                }
                else if($value >=  && $value <= )
                {//四字节
                    $split=;
                }
            }
            else
            {//单字节
                $split=;
            }

            $key = NULL;
            //根据当前字节长度来生成相应的单字符
            for($j = ; $j < $split; $j++, $i++ )
            {
                $key .= $str[$i];
            }
            //http://www.w3school.com.cn/php/func_array_push.asp
            array_push( $array, $key );
        }
        return $array;
    }
}

///////////////////////////////////////
/**
 * @classname: SearchResult
 * @description: 搜索结果类，用于存储搜索查找后的结果集
 */
class SearchResult {
    var $lastMatchedState;// State对象，最后匹配的State值
    var $words;// Array对象，被搜索的内容
    var $lastIndex;// int类型，最后出现的位置
    /**
     * @function 构造函数
     * @param State state State对象
     * @param Array words 被查找的字符串
     * @param int index 查找位置
     * @return
     */
    public function SearchResult($state, $words=array(), $index=) {
        $this->lastMatchedState = $state;
        $this->words = $words;
        $this->lastIndex = $index;
    }
    /**
     * @function 获取输出的内容
     * @param
     * @return Array
     */
    public function getOutputs() {
        return $this->lastMatchedState->getOutputs();
    }
    /**
     * @function 获取查找的位置
     * @param
     * @return int
     */
    public function getLastIndex() {
        return $this->lastIndex;
    }
}

////////////////////////////
/**
 * @classname: Searcher
 * @description: 搜索类
 */
class Searcher
{
    private $tree;// AhoCorasick对象
    private $currentResult;// SearchResult对象
    /**
     * @function 构造函数
     * @param AhoCorasick tree AhoCorasick对象
     * @param SearchResult result SearchResult对象
     */
    public function Searcher($tree, $result) {
        $this->tree = $tree;
        $this->currentResult = $result;
    }
    /**
     * @function hasNext 用于判断是否还有值存在
     * @param
     * @param boolean true表示有值  false表示无值
     */
    public function hasNext() {
        return !is_null($this->currentResult);
    }
    /**
     * @function next 获取下一个值
     * @param
     * @param 如果有值则返回SearchResult对象，否则返回NULL
     */
    public function next() {
        if (!$this->hasNext()){
            return NULL;
        }
        $result = $this->currentResult;
        $this->currentResult = $this->tree->continueSearch($this->currentResult);
        return $result;
    }
}

?>

php.ac.pretreatment.php

<?php
/**
 * @author: jessica.yang
 * @date: 2011-10-24
 * @filename: php.ac.pretreatment.php
 * @description: Aho Corasick多模式匹配算法，简称AC算法，包含两个阶段，第一个是预处理阶段，即字典树的生成；第二个是搜索查找阶段，该文件完成第一阶段的预处理功能
 */

/**
 * @classname: State
 * @description: 状态类，用于表示字典树中的每一个状态节点
 */
class State
{
    private $depth;        // int类型，表示每一个状态对象的深度，从0开始表示
    private $edgeList;    // 类似于列表，用于包含该状态下所包含的下一级所有State对象
    private $fail;        // State对象，表示状态对象失效之后要跳转的地方
    private $outputs;    // array对象，存放某一状态下可以输出的内容

    /**
     * @function State 构造函数
     * @param int depth 状态所处的深度
     * @return
     */
    public function State($depth)
    {
        $this->depth = $depth;                    //初始化状态当前状态节点的深度 

        /*
        存储State对象下一级对应的所有State内容，以数组形式存储
        这里要着重理解的是: 树是在数据结构是以一种链表的形式存储的，链表中的每个节点都要存储指向它的所有子节点的指针，或者以一种数组的形式存储(只要能达到可寻址的目的即可)
        */
        $this->edgeList = new DenseEdgeList();    

        $this->fail = NULL;                        //初始化当前状态节点发生失效时需要转移到的下一个节点(即失效转移指针)
        $this->outputs = array();                //初始化当前状态节点的输出字符串
    }

    /**
     *@function extend 添加单个搜索词
     *@param char character 单个搜索词，或者一个字母、数字、或者一个汉字等
     *@return State
    **/
    public function extend($character)
    {
        if (!is_null($this->edgeList->get($character)))
        {
            return $this->edgeList->get($character);
        }
        /*
        新建一个新的State节点，作为当前节点的下级State节点
        */
        $nextState = new State($this->depth+);
        $this->edgeList->put($character, $nextState);
        return $nextState;
    } 

    /**
     *@function extendAll 添加搜索词
     *@param array contents 搜索词数组
     *@return State
    **/
    public function extendAll($contents)
    {
        $state = $this;
        $cnt = count($contents);
        /*
        循环遍历搜索词单字符数组，逐个压入Tire树
        */
        for($i=; $i < $cnt; $i++)
        {
            // 如果搜索的关键词存在，则直接返回该关键词所处的State对象，否则添加该关键词
            if(!is_null($state->edgeList->get($contents[$i])))
            {
                //如果搜索词在当前节点中，则返回当前State节点
                $state = $state->edgeList->get($contents[$i]);
            }
            else
            {
                //如果搜索词不在当前节点中，则新建一个新的State节点作为当前节点的下级节点，并返回新的State节点，接下来就继续在新的State节点中插入搜索词
                $state = $state->extend($contents[$i]);
            }
        }
        //完成状态转移树的填充，最终的效果就是所有的搜索词都被填充到了一个层级的树状转移图中
        return $state;
    }

    /**
     * @function 计算搜索词的总长度
     * @param
     * @return int
     */
    public function size() {
        $keys = $this->edgeList->keys();
        $result = ;
        $length = count($keys);
        for ($i=; $i<$length; $i++){
            $result += $this->edgeList->get($keys[$i])->size();
        }
        return $result;
    }
    /**
     * @function 获取单个关键词所处的State对象
     * @param char character
     * @return State
     */
    public function get($character)
    {
        $res = $this->edgeList->get($character);
        return $res;
    }
    /**
     * @function 向State对象中添加下一级的搜索词及对应的State值
     * @param char character
     * @param State state
     * @return
     */
    public function put($character, $state)
    {
        $this->edgeList->put($character, $state);
    }
    /**
     * @function 获取State对象下一级的所有关键词
     * @param
     * @return Array
     */
    public function keys()
    {
        return $this->edgeList->keys();
    }
    /**
     * @function 获取State对象失效时对应的失效值
     * @param
     * @return State
     */
    public function getFail()
    {
        return $this->fail;
    } 

    /**
     * @function 设置State对象失效时对应的失效值(即失效时需要转移到的下一个状态)
     * @param
     * @return
    */
    public function setFail($state)
    {
        $this->fail = $state;
    }

    /**
     * @function 向State对象的outputs中添加输出内容
     * @param
     * @return
     */
    public function addOutput($str)
    {
        array_push($this->outputs, $str);
    }

    /**
     * @function 获取State对象的输出内容
     * @param
     * @return Array
     */
    public function getOutputs() {
        return $this->outputs;
    }
     /**
     * @function 设置State对象的输出内容
     * @param
     * @return
     */
    public function setOutputs($arr=array()){
        $this->outputs = $arr;
    }
}

////////////////////////////////////////////////////////
/**
 * @classname: DenseEdgeList
 * @description: 存储State对象下一级对应的所有State内容，以数组形式存储
 */
class DenseEdgeList
{
    private $array;                // State对象，包含对应的搜索词及State值

    /**
     * 构造函数
     */
    public function DenseEdgeList()
    {
        $this->array = array();
    }

    /**
     * @function 从链表存储形式的内容转为数组存储形式的内容
     * @param SparseEdgeList list
     * @return DenseEdgeList
     */
    public function fromSparse($list)
    {
        $keys = $list->keys();
        $newInstance = new DenseEdgeList();
        for($i=; $i < count($keys); $i++)
        {
            $newInstance->put($keys[$i], $list->get($keys[$i]));
        }
        return $newInstance;
    }
    /**
     * @function 获取搜索词对应的State值
     * @param char word
     * @return 如果存在则返回对应的State对象，否则返回NULL
     */
    public function get($word)
    {
        if(array_key_exists($word, $this->array))
        {
            return $this->array["$word"];
        }
        else
        {
            return NULL;
        }
    }

    /**
     * @function 添加搜索词及对应的State值到数组中
     * @param char word 单个搜索词
     * @param State state 搜索词对应的State对象
     * @return
     */
    public function put($word, $state)
    {
        $this->array["$word"] = $state;
    }

    /**
     * @function 获取所有的搜索词
     * @param
     * @return Array
    */
    public function keys()
    {
        return array_keys($this->array);
    }
}

///////////////////////////////////////
/**
 * @classname: SparseEdgeList
 * @description: 存储State对象下一级对应的所有State内容，以链表形式存储
 */
class SparseEdgeList{
    private $head;// Cons对象
    /**
     * 构造函数
     */
    public function SparseEdgeList() {
        $this->head = NULL;
    }
    /**
     * @function 获取搜索词对应的State值
     * @param char word
     * @return 如果存在则返回对应的State对象，否则返回NULL
     */
    public function get($word) {
        $cons = $this->head;
        while(!is_null($cons)){
            if ($cons->word === $word){
                return $cons->state;
            }
            $cons = $cons->next;
        }
        return NULL;
    }
    /**
     * @function 添加搜索词及对应的State值到链接中
     * @param char word 单个搜索词
     * @param State state 搜索词对应的State对象
     * @return
     */
    public function put($word, $state){
        $this->head = new Cons($word, $state, $this->head);
    }
    /**
     * @function 获取所有的搜索词
     * @param
     * @return Array
     */
    public function keys() {
        $result = array();
        $c = $this->head;
        while(!is_null($c)){
            array_push($result, $c->word);
            $c = $c->next;
        }
        return $result;
    }

}
/**
 * @classname: Cons
 * @description: 用于SparseEdgeList生成链表时表示的节点对象
 */
class Cons {
    var $word;// 单个搜索词
    var $state;// State对象
    var $next;// Cons对象
    /**
     * 构造函数
     */
    public function Cons($word, $state, $next){
        $this->word = $word;
        $this->state = $state;
        $this->next = $next;
    }
}
?>

上面是一个AC算法的PHP实现，为了更加清晰的说明这个算法的思想，我们接下来看几张图来进一步理解一下

下图是多模式he/ she/ his /hers构成的一个确定性有限状态机，做几点说明：

1. 该状态机优先按照实线标注的状态转换路径进行转换，当所有实线标注的状态转换路径条件不能满足时，按照虚线的状态转换路径进行状态转换。如：状态0时，当输入h，则转换到状态1；输入s，则转换到状态3；否则转换到状态0。
2.  匹配过程如下：从状态0开始进行状态转换，主串作为输入。如主串为：ushers，状态转换的过程是这样的：

3. 当状态转移到2，5，7，9等红色状态点时，说明发生了模式匹配。
如主串为：ushers，则在状态5、2、9等状态时发生模式匹配，匹配的模 式串有she、he、hers

0x3: 关于AC算法的注意点

. AC算法是一款非常优秀的算法，在Unix的fgrep中使用的就是这个算法
. 要理解AC算法，我们的重点应该放到它的Tire树的建立上，将搜索词转换为一棵以字母顺序为索引关系的层次树(这里所谓的字母顺序就是转移方向)
. 失效转换的思想和KMP算法的思想很类似，核心的思想是避免不必要的回溯，让搜索始终沿着向前的方向，尽最大可能减小时间复杂度
. 输出字符串的个数和搜索词的数量是一致的，每个搜索词都会对应一条状态转移路径，这条路径的最后一个State状态会包含一个输出字符串
. AC算法的时间复杂度为: O(m+n+z)，是线性的，所以非常高效

4. 多模正则匹配的编程学习

这里还有一些关于多模匹配算法的代码学习资料

http://sourceforge.net/projects/multifast/
http://www.codeproject.com/Articles/12383/Aho-Corasick-string-matching-in-C
http://search.cpan.org/~dankogai/Regexp-Trie-0.02/lib/Regexp/Trie.pm

5. Snort入门学习

我们之前说过，AC算法是一种多模匹配算法，它适用于一次匹配需要同时匹配多个模式的应用场景。我们在有了AC算法的原理基础之后，接下来可以继续深入学习一下Snort高速多规则匹配的原理了

0x1: Snort简介

Snort是一款开源的NIPS(Network Intrusion Prevention System)、NIDS(Network Intrusion Detection System)
http://www.snort.org/

NIDS(Network Intrusion Detection System)的功能点:
) 实时流量分析
) IP数据包Log记录
) 协议分析
) 内容搜索
    4.1) 单模式搜索
    4.2) 多模式搜索
) 对攻击行为的检测
    ) 扫描器探针
    ) 操作系统指纹探测
    ) CGI(common gateway interface)探测
    ) 缓冲区溢出
    ) SMB探测
    ) 端口遍历扫描

Snort的工作模式
) 嗅探模式(Sniffer): 对网络数据进行实时嗅探并显示
) 数据包记录(packet logger): 对捕获到的数据包记录都磁盘上
) 网络入侵检测(Network Intrusion Detection): 对流量进行监控，并应用用户定义的规则进行模式匹配，Snort会根据用户的定义采取相应的相应动作action

0x2: Snort的相关架构

Snort是一种以攻击特征为基础的的入侵检测系统，利用事先建立好的的已知的攻击资料特征码，来比对接收到的封包内容是否含有攻击行为。若符合特征码则触发相对应的动作

Snort是一种以攻击特征为基础的的入侵检测系统，利用事先建立好的的已知的攻击资料特征码，来比对接收到的封包内容是否含有攻击行为。若符合特征码则触发相对应的动作

. Packet Decoder(封包解码器)
当Snort取得原始的网络封包后，第一件事即将封包置入"封包解码器"模组中进行封包解码

. Preprocessors(预处理器)
Snort的预处理器为外挂式程序(plusin)的架构，主要功能在于重新标准化网络流量，如
    ) 重组封包
    ) 分段、重组TCP Stream
    ) 编码的规范化、转换等
以使得网络流量能精确的被侦测引擎(Detection Engine)解析以及匹配特征码

. Detection Engine(侦测模组)
Detection Engine(侦测模组)主要功能在于"规则分析"与"特征侦测"，Detection Engine将Snort的规则文件引入，并按照规则文件中的规则进行比对(单模比对、或者多模比对)。一旦发现
有符合规则文件定义的行为，即触发该规则文件中所定义的处理方式，当所有的规则都不符合时，即会丢弃该封包。
Snort的规则文件分为两个部分:
    ) 规则表头(Rule-Header)
        1.1) 决定封包比对来源范围(例如限定比对哪些范围的IP)
        1.2) 比对成功时的动作(log或者直接丢弃)
    ) 规则选项(Rule-Options)
    利用一至多个关键字设定欲侦测的流量特征，规则选项按照功能可以分为下列4个部分
        2.1) Meta-data: 设定欲显示的相关讯息，如当规则触发时所要产生的讯息
        2.2) Payload: 用来比对封包内容的规则
        2.3) Non-Payload: 用来比对各种协定的栏位值
        2.4) Post-Detection: 当封包内容与规则匹配时，除了在规则表头(Rule-Header)所定义的动作外，另外会触发的动作

Example:

alert tcp any any → any  (msg:"someone access PSQL command:SELECT"; content:"select";)

alert(处理方式):    产生警示的 log
tcp(来源通讯协定):    侦测 TCP 的封包
any(来源 IP):        侦测任何的来源 IP
any(来源 port):        侦测任何的来源端口
any(目的 IP):        侦测任何的目的 IP
(目的 port):    侦测  端口的封包
...(规则匹配內容):        若符合内容含有"select"的字串，则将 msg 后的字串记录起来

0x3: Snort安装、配置

http://linuxmantra.com/2010/10/install-snort-2-9-on-rhel-5.html
http://www.boyunjian.com/do/article/snapshot.do?uid=net.chinaunix.blog%2Fuid-522598-id-1764389.html
. 下载准备环境
yum -y install mysql-bench mysql-devel php-mysql gcc pcre-devel php-gd gd glib2-devel gcc-c++ libpcap-devel
cd /root
mkdir  snort
cd snort
wget http://www.snort.org/downloads/867
wget http://www.snort.org/downloads/860 

. 安装Snort(在安装过程中需要解决依赖库的问题方可正常安装)
tar -zvxf snort-2.9.0.5.tar.gz
cd snort-2.9.0.5
./configure --with-mysql --enable-dynamicplugin
make && make install

遇到报错:
"ERROR!  dnet header not found, go get it from http://code.google.com/p/libdnet/ or use the --with-dnet-* options, if you have it installed in an 
unusual place"
tar -xzvf libdnet-1.12.tgz
cd libdnet-1.12.tgz
./configure
make && make install

如果遇到报错
"ERROR!  daq_static library not found, go get it from  http://www.snort.org/"
cd /root/snort/
tar -xzvf daq-0.5.tar.gz
cd daq-0.5
./configure
make && make install

如果遇到报错:
"ERROR! Libpcap library version >= 1.0.0 not found. Get it from http://www.tcpdump.org"
cd /root/snort/
wget http://www.tcpdump.org/release/libpcap-1.1.1.tar.gz
tar -zvxf libpcap-1.1..tar.gz
cd libpcap-1.1.
./configure -prefix=/usr
make && make install

. 配置Snort
groupadd snort
useradd -g snort snort -s /sbin/nologin
(添加一个不允许登录的虚拟账户)
mkdir /etc/snort
mkdir /etc/snort/rules
mkdir /etc/snort/so_rules
mkdir /var/log/snort
chown snort:snort /var/log/snort
cd /root/snort/snort-2.9.0.5/etc
cp * /etc/snort
cd /root/snort/
tar -xzvf snortrules-snapshot-2.8.tar.gz
cd ./rules
cp * /etc/snort/rules
cp  ../so_rules/precompiled/CentOS-5.0/i386/2.6.1.5/*  /etc/snort/so_rules
wget https://www.snort.org/downloads/893 --no-check-certificate

vim /etc/snort/snort.conf
修改如下
将 RULE_PATH 和 SO_RULE_PATH 改为绝对路径
var RULE_PATH /etc/snort/rules
var SO_RULE_PATH /etc/snort/so_rule 

配置数据库(在同一个文件中)
在配置数据库信息之前先生成相应的数据库
mysql -uroot -p111
create database snort;
use snort;
source /root/snort/snort-2.9.0.5/schemas/create_mysql; 

grant all privileges on snort.* to snort@'localhost' identified by 'snort';
flush privileges; 

(在.conf中添加信息)
vim /etc/snort/snort.conf
output database: log, mysql, user=snort password=snort dbname=snort host=localhost 

4. 启动Snort

1) 监听模式(Sniffer)

监听所有来往的封包，但不做攻击模式的比对
snort -v

aaarticlea/png;base64,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" alt="" />

2) NIDS(网络型入侵检测系统)
让Snort不仅监听所有来往的封包，并会对封包中是否包含攻击模式进行比较
snort -u snort -g snort -c /etc/snort/snort.conf

aaarticlea/png;base64,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" alt="" />

0x3: Snort捕获数据的可视化显示

和我们之前学习Kippo蜜罐的学习中，将捕获到的数据进行可视化展示很重要，对于Snort来说，可以使用BASE(Basic Analysis and Security Engine)进行数据可视化展示

http://freecode.com/projects/base-php

要使用BASE，需要准备一些环境:

) ADOdb(PHP连接数据库的通用接口)
) BASE需要绘图和Email的相关功能
    2.1) Mail
    2.2) Image_Color
    2.3) Image_Canvas
    2.4) Image_Graph

pear list
BASE本质上就是一些PHP文件组成的脚本
http://sourceforge.net/projects/secureideas/

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />

启动Snort的检测模式

snort -u snort -g snort -c /etc/snort/snort.conf

用WVS进行模拟攻击

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAA2sAAAHNCAIAAAAPDXQdAAAgAElEQVR4nO3dTbarOnOAYYaSL+kxFUbCStJOMgAGwjg8uJsGNkilKlWJH29sv8/ajXNsWRICi7IQqPvf//737O+/0r9/5X//rv2JNP/6n+ffv+V//2r5+zf595/FX2P+ZT2/4U/su0/++7+P//uPz/yTG3LJ/tW7Dr0DOfvvVdA7j+e3bml0A688XP/821f7O7wHG3fEmw+2vX/XNuAH/dV6pwv35p9/L9p2tPFF6AAAAAAAAAAAAAAAAAAAAAD8gX6cH4957P+6HgAAADhsmN4S2FUiyHF+vFg1eVMlAQAAdhqmx2YalFf6JOYRSV/UJE1B0PEcwpu7P1e9JZT2OFgTIkgAAHB/w/SYR/HaOGdBkQxqhqkI8GSScW6Nq47n0FxEs140jPXakZoQQQIAgPvbEUEqnyqTDFNbYOXnUI6YbtYRwqVWr6SvVNlH9w8eehFk4CK1tbHhSuapZC5OOwAAAJxiXwQpX1Pjv6axNCcHMSS5DIPqeaxJZcB35hhkNUB2C9o7BjlMIhzUR2qddgAAADhoZwQpXiySNEcttRzUzPSR0YcWWda2o0UeQVYDvUsiSLVNx1kL72vtAAAAcNA1EeQ4twZrtRz0aLSs+TBVL9ieEkFG7vW5JoI0gvK+DCGddgAAADjoQAQprirX5ueF6mHlYARVagRZG3j78DHIyt3gIlx02gEAAOCgq+ZB7qpHy9XbP48g3z4PMnxzEhEkAAC4lnJtVHl6T/u92K1qOTTMg3xXBFl11TzIaAhJBAkAAK4m7msuJ9HJoKYvZzleG0F2xcTKpQpqHpUy8juXh6n1dpN3RJD1SuqP4uQqNgAA+APZFLs0HNHn3hXx5LE5kMEcxG0s6Vv6oxT1K987K+pW0pqmuKZzEwQrKbOpTEc12wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8HFey+CcvypNssDOweUsAQAAPpO+4OCXrAYYXMy7Qb4w+jgTQwIAgF81TPlw2jB9x/ja6RHkMOUZ9uOcL1MOAADwK2QE+Xrp+e91nHJ5ZZjUgcrXy/K95+vzmCfZUrgJtALUCFd+XI0gnxuzJ/KTAaTacgAAAD9Bi4OK15YXxvkZ2/VZeLa+vKbNQrRheszzJMPGJP9IgjyoFCV2ff7CMD0e86xEkGuU2R759UpEev6FcgAAgI+gjqRpl7b1oTstsso/XsR/zxfXl7wExmhiVoLycW1GZzLk2YgIEgAAYBWOIPVgSY+i0uvg6mfTgKyeQA1Rn7MQ+9fnlQQnh3dEkAAAACsrgsxiozQi9D9dRJDKZ5MP1hPoN4wnsyWNEJMIEgAA4CrxeZDqxy8fgzSGGPPCro8glXbiThoAAPCrnHuxrVde3jAPck8IacyDPHAvdnxcFgAA4NvJCDJ/bnaayMpBfGDJIP9sfqu1KMJNoD2jMhu4fMO92M+Pp3egMwAJAAB+kD7FULkJW5+AmMgy0scv05zUS+R2grIIfdAye09d2XD/vdhFIcSPAAAAl3Gv9nI5GAAAABkiSAAAALQhggQAAECcu5y1v941AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPwuZXXu/Xp1PZozc+a+cQAA8LECyxJ+iFMjyK7rum5U1sU+Jl+tm3WxAQDApzs/AnuvD4gghynPsB9nHoQOAAA+mRaBJRdzt8FKLehJRzKnYYuUno/7nsf8yd9FYBZ5LHiWZhq3+C7/sFWKX4SsoRpBPrd0T+QnA8jPj9oBAMCvM6OZcX5M07Zs4DjL2Cx/ZYnDkhTD9JjnSSZJyhomEe6VRcgkRSFONOYW0ZcbMc9KBLlGme2RX69EpOdfKAcAAHijWgSZRVtFJJRN7lMzLkcdk/E4Y6gvyVKLvYrXahGkW0Q5PKhXOxtVbUQECQAAvk51DFLM3tMiIfMa9TApkdiaiZZb95wi2NsFNtQ/UIQSQHanh3dEkAAA4OsciiBFRtn7w6SN2L2K028GzyLR2GzBegRZLcLYIiJIAACAutMiSPmR+hikMf6np62pxJluEW8Zg1RqyJ00AADgs+2NILUhxiKCrM2D9ENINQYN1z9SRHwe5IF7sYtS9NFZAACAj3EggswjquWx2XnG+b3Y+YO1i3uzXy/JQmT0JV5RbgnfquEV8YZ7sZ8f37LkieIAAOAz1dekSd9d73sR0xSXyDPNRoyrPUfa0qctKpGTrId63buaQDzysSzDK0J5HmSZbP+92EUhxI8AAAAGrtUCAACgDREkAAAA2hBBAgAAIC6y3jUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BLP9WrOu9e7V9ejOTFjL/clnfEUpOUO99PrBgAA8Bb6oojH1v3byVzXeze5IPhRylLdVgHj/JjnWbbh2trTNBFBAgCAT9UnUVY/zmvE8wdPEb9/BFnojRKG6fGYhlobnr+xAAAA7xKJINeRs+WV10PG09Ap9ODxLNE0yugrDaqSpGmVnDLSFNNgRJDPjTklPjYiyHF+zGNfjcKJIAEAwAcbJiuCFKHREvOM8zN0tIbfnm8pn85eU2YCZkGVzL64YizLEIUO0+Mxz0oV1yjzhABO2c4uCb6JIAEAwPdLI8jSEnrFhu5k/KeFm8VrW1A1TLIgYzRxC8LKiNeapvgMIY+MQa5RqBZCb1UlggQAAN/PjyCjswpFdFgZr8wLmMdeG9gzPt9vIaQSQHaXz4NcAt0sDOzH+RGaS0oECQAAvoMbQbojlKn8knUgXHplUZZSuWF8KcWej3jx/c5iy/IomwgSAAB8v70RZD/OYjBu7xjkYxrUsU59iNFNcH0EmResR7pqFYggAQDAd9gbQZaBmnYfjBvLbUHV817m/L3mENKYB3nmvdj1DWMMEgAAfL+9EaQIo9TVYMpwrnglC6qKqFSZdJiV+4Z7sdX7ySuBLREkAAD4YsXV1yy4Kac4lgFimsE89uqagrKU4lk8W7lJkfIJPrXrw8rzII1YdvcYZNYYZgyYpsoKirQlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8Pf6cX6YpoEEJCABCUhAAhKQgAS/nQAAAAAAAAAA3uwOQ6MkIAEJSEACEpCABCS4bQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+D79OD8e89j/dT0A4I/QDQJYDBN9gdCP8+PxeDymQX3nY5prmLRtOCHX+7fAR1Ty1w3T4/F4POaxnuz5bVySHt+n9rf7Lz1rdXAD33TYX9oN3m53azn04+wet/gTz15l3WPy/31ygAnLHnUTGEnajla9lE88aXGu1Y3zzc4xrYYpPSDX43V9Kflm+WfxPN/7HzAfUUk8d1RD0pP26S2/3cc38JsO+3vt7iKHa36e4wzFodMnu0/8e+191p7ITWCUMs77johP/9J+ev2vcstzTAOlhxumxzzPxWHfuJkfccB8RCVBBJkigkzda3eXOTAMeVt/E0F23TDtOcy0Az0Z9+6TwZ/yw+lI5jRsFUiu76RDRUX1snEk4wuXpZnGrXnyD1dKuVplK8ItaW+m+n65ibKdRQa1ayvBSqbj1klSo5TseGjWaz+IhukxjyKyLHtGu6FiB0zkmFy3dG8XbDdUoJLrjlhKf32isq3lVpjvr7t1VI6Kht15aSVDLRlLYJURbIdXt5x/N1R2SOFvp/Ptrgh2xaGj3umj0g1MkqanMLOMaGd+sIc5oRv026FsDfHBspUqfZi2u085YNQ+Nnewl8M+1QgyjfNEgLgFRvUERik7f/SYnxrnxzRtYWt5uOWvLIdskmKYHvM8ySRJWcMkvjplETJJUcjf/2wNbIXbku5mio8sDbl9vi93xTzr55i9u3v5xfr6oFqCczy00Du35Wyd10QJlCsNteZiHTCBvbmls3pvT6ChAkf1kmTNK+1kolvxUjT3OL827bmhrxk5reeSKytZfERpSb+PqtbBb4dXL7fuLXuOnbFP3XZo+HYb3K5Y0Jq6tSvuxTcztLudw/68Hmb/WS/QDvUi6uFBYHefd8B4IeShXg67eYdI+nq9R64lCJfSWtuXcc4P1CL/ca4eWcWB/nzx9ZJa3XEWwyHaD6c7RZD+Vrgt6W2mumPF7311SKE1gqxU0hjqazkeWmiR33bmToch04q5DaW/kIjsza2Ge3+dBxoqFkEaFYhvxUo0XVLDpLF39DBXVrILtGQ9gVsHvx2GqTzBGu2k71O3Di3fboPXFZfkJjR2xeX3N7a7/QjypB5m71kv1A71IpwTt7u7Tzxg9G5Wfo4xyHdTB+QvjyD3fruqv8bSSmtflPSaghZiFFu9ZmJ87frkqxA7YR2KIK3blqI5Brai81rS3cxKB/X6l/K+keuu3W2FZk3HQwv9x/G6yckwZFozr6GS/6u7N7Y3T+E1VDCCNHqV9q0oI8gkRHp9LkkU/eJcWcm1qvVDzkwQqIPbDk4vl9H2qV+Hpm+3oaGS+ptNXbHy5Y3ubv+wP6mH2XnWa/kNtS+C9Hb3qQdM4Do2/sDbxiB3BT1ubV8iEaSsUPq+fs3rVVzllnOlz95T/3cIbEXntaS3AfbFr3LibOLyCLL1eGjhRJBJ5vo53vhULVkX3Zun0xoqehVbeT24FeXv3JYIsmHbLqukWlpDgkAdQhFkpZdzX3Tr0PbttjfbrWS1qcNd8ePx8KZQ13ZoW2d+oIfZedZrqd+uCNLd3aceMESQ9/RHV7F3Oi2ClB9xfvhWL6JEC+z++iq2vxXdL41Bxurgq1/FTos/cwwytjevUNT8QAQZ/Gbl+beOQUZdWUmVmyTftPgBfM0YpF+Hd4xBuk0d7oof02D9IorUt7kz39vDfOwY5KkHjHsVG3/iNyJI7dxQRJC1nsTvVEK/Mf82ggx1jX5LVvN42zzISiXLKsgS3OOhhf7jOC9iuZSdFnF8HmQ8hBx336UYaqgjEaS/FWU7vT2CPKGSoS6omqClDpUI8tA8yD0RgfnttrNonJKuNHVLVzwWU6pi36zqYX9mD3PgrBctcF8E6e/uEw8Ydwhyfy+HA34mgsyPreWMnmec3wDYi45lKG8IFN/Q8sgvX8m/Bs8evbbFJ/O3wh3NdTdTNJxs6r5sg133Ylcqme+7fpxlCe7x0EQNIZXRRHkdzGmoVxr7gPH3Zlr0nskjsYbyj2o7OHO3ojw+RTu+IYI8XslQF+Q0tVOH2FXsrJezrwxWQorqIdfw7TZ4XbHf1KGuONtA7UeR/82qHfZn9jB7u8HYKamhiOdVadHT1nf3SQeMfw37QC+HndY2fx0VxQtdp0xmkHuonsD9uE+fTpF2kVmlixdeX5A0G/0MlzaAfitipjiiZU31H/dH2uIE5lZEWrJIqG5m9r4+qyn7cHoasCbPPNsqWMn01edTdeQYZO14aKT9lpA5L8WJpvIaqsxMHjDuMbllsXcMMtBQZiWzN+xK1rciL7/v18NF7vt1Q/uuT48pfysvrGSwJWNNrdch0A5Jnmo3L7PJP9T7ddCbU367QzvD64qdpla3Rem/kts5tFSBb5b93Tzcw5zTDVbbIbS7xTYMZVv7u/v4AROJv/f3csBRteEHfL4dI1LN+fPbFziMrhhSw/V44C/QbX236/cvnRxwArpi5A5NMQLegW7rmylzcQDcEV0xgA+Sz4Ii0vgK+U5lcBC4P7piAAAAAAAAAAAAAAAAAAAAAAAAAAB+m726Y7KKxGlaluUA8AbLF936SuZLKcm+QFlEpMwoScTNzAC+nLq2ktN7VpZue318nLVlD4tirt8+UcdKr37W6uGZixdjARCw9kLTZD17Pl+zWFnB2F9ZKV8baesDAeB7yeBJrKMulhQeZxn8iRVBxjmJQtN+tx/n9YN/8OhaIkjgxxlfc2VhTJnSjSCHqVgcmqdzA/h2Za+6dYbqokZ5iKl+/KQIcr0WPG4XhbcBhbS/rj0PN39PH0191nkbMvWGWrUEyir1IlU+mCtPOlkaTj/AyRp+KIovrxdBlt/lS36UAsCtVEJAY8HhrDd1x/aMCDI8OrcNaj4jtGno8hi0uOgkhlFj9ZznZCCizEG8sqzWt73dF3H1Y57nSq2sSVlrGMrpBzhXOKorAsZ+nJeL4PokHC3A5BIEgK9X9Kprb2j/7k5n+SiThlR7L+skV5iSiDapm1rLYh6SG0E+KmMOakukOSohsRbXRk5f6409bkoALYIRpJKsz2fzyA6BCBLAT1LmQT7/X4sg7YvIlXsd90aQryy16+NGJXsZQjbOg8yz1cvYxkHN69GVq9icXoD3ikSQxoWXelZEkAB+kpwmuPWLsTFILTtjuvpVEaRBBrm7I0jjs2sEaTRU/RQSPFMBOIkbQTZ8Kd2LFESQAL5epVeNzIMM53hRBBmdU3mLMcjWBADOU+0ExFRmT/7lrd5QCABfqtbTufdiuxMEs7wuiSCDIeShCPKEeZDa7efGDE7mQQJXqC8r0BLwFT2C7AH+4IFlAPBuzm/l+vMg++zxj+tLWkR3WQSpdv/l8KlyK/RWHyeC7Ir7YGRs7d6LvUwWEE2nNAj3YgMXsaej1K9Bi1+D/dILioyyGJInigP4csUcQr3Xq6xJswRaeTb6bYxuKU7B05CtP1gsGygLcZ7XmFRimMSLsthOK6IW/D3W50FuWSwnrzQLI57mXmzgVPoTYbMbq6sJykz0LqzoSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBEfcXbsxeJKFbEAXBzS09gfmeTpWncJWf0TLwc0sVvWLQGwDeQS+0N03NJPX0xsKQDtZYDe7x/Ub766t7O2t/7GOt/A7iTtZuaJmUB7C3N1kUoq1oPUxL1aQtpeznka2uLlbYB4AONcxbtPTvb7RUl9toipz4JovpxXj+1xqDvQwQJoM7sB4Yp/y6nvZn+SfkJJ4c8vqxXBgA+QK8GQVn8d2UEuV4LHreLwtt4geies/HN3nyvGCdNt2IbMtVCvywjJUH6/jRoEWQ6JDsN8pySpXl3hA3ACtrKr6pMWX7Z88/4OZT4CQrggwW6sK0f7PVLO0YEGe4ax/kVEz4jtGno8hi0uOAzzmWE549BzskgQJmDeGW5ZrW93efvD9PjMc9zpVbWnKs1DGX4AXgzo5fQfkmPxbdbfDJ7JZBDpFAA+BSRyyj1CDJRXPcJSjriZHZR0r2qHW1RFzeCzMO5vPtWO/M0RyUk1uLaSFS43tjjpgRwqv0RZDYPsh/nx2Oe5wMRJJewAXy2YARpXT7OHYggX/1sUp+1RzZ+qRfhbOM8yDxbvYxtHNS8Hl25is34AnAzByLITt6LnX2oLYLUbsQBgI+S9afivupkXPDyMUgvgjTIIYLdEaTx2TWCNKLY+lUozhLAzRyLICt5NeRAxwDgK+gxoXEnzRZBqjfKXBRBRudU3mIMsjUBgDeq3EnTeqO0SBDLQUynBoDPte9e7PdGkMEQ8lAEecI8SK1NjBmczIME/kT4aT7e0yTKHsPPIXuiJAB8vvL+j+XJZa///X0EqXa95aUg5VboylYUZwDRDnkjBO7FXuZIiSdrKg3CvdjAX6n8zswiwPqEHfmghkgO2rVrrlEA+HhypmH+GB1d+RDy2P02mfST05CtP1gsGygLcZ7XmFQieXl5URartkMt+Husz4PcsljOTWJ1Hw33YgPvpXdklRtlyi7Me1isk4M1nZsIEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4NPVF+++n2JloC9yh31xah2+eWedY1kyxmqfdNmYytKHwRzURJEiAOAjJItwTYPyf2sprnVRPjeBkSTee+olfOpJ8kjE4O2sy3zp6r1fF0F2Xfe1O+uYtROZJmV16q7rnt+m9Z38f6EchumRLlVa5OAWAQCfpjiH9ck5SPw7XS97iyCrCYxSxrmp95QfH6YPXVf6YMRQ3VmX+dKghAjyBxkN3o+zfN3aNeFdJr6bDUUAwGf4mwiy64ap4Uynfjx/JRmRM8Y40xTTsESxyz+f76wfWlMqYwj1YdT8Kla6jfmHd46mBiJIr5KBjVAaKiujnsU6WrMcAK/EYjvthgq3hF2HLXMxkv48JgP7IrAVgZYUiaZxa8rY8bDrqC6b8rkxH/mj61wNQZsRi++NIBuKAIDPUA9KklO7CBC3E2E9gVFK2+9v7+PFFSE5xtnnLwzT4zHNWfftBWduEfIVdcbUxWOQgUpm+uJ9paHmrKGCRSw1Xd/L6xloqKrYvkhbahkA0qroFWRvRaZsybKayoZW67DnqM53VlawHeb+kOPxXzQH/zLLWy4gAMB1whdG0wBRVUtw8PKrdhU7+bQx7rJ9REmgnN5rNXSL6IqoJbIhjU6opFCGoPWGihaxBC3G8RBoqJpgHdZStPCxi0aQ4aE7eURrR3jxWq0O7ma6O0tsB2OQ4S9gJZmXg3EBY29NAOC+1Ktpl0eQjTFEUUnvVP2qTl9JUMROsav5ahFJntVWPB5B2jsrXEnxbj6KVW2oeBEixtfyrB9uppbNHOfHPKvhYxeOIKOVU6a9+R+16+BvprezoIh8Aet7PR6DOsPL7CYAn+5tY5CZxjAqq6SMPiv3gy/bcU4EWS3C2mZljOiyMchgJcsodH3Xbah4O8iJsM5WNZxOm/ZF7YbX6FXsar3NCsT2dD2CrG5m6KiG4O4W92CMf4Ur9+KwjwB8gz+6in2sku6lV1mxgxFk230/VhFaKW2OVrIf50cZfsfHIOPt0BJBdm1xT0sdHtNgnrAPRZBeSx4eg/Q3kzHIHao7XZvM2pZDkVSbx8AOAvAlPjKCDAU+iePzIP2wRYs23htB7mmH1nmQ0fCtEkGGGsrJ20+cPTxFDSIPRZBuS8ZGmmp12BNCGmOu3Iv9Yjd4/bJzJActRznrlbmPAL7IZ0aQSuyk3K1tXp8dynux85jgeQ1RRgS1Ioq7LtQbOJTbkBvO6+7OcipZ3oEkt9K/vddrh6Sm5kYEGqoqsrvLhlJutXH2hb0Vfktq4Vz5SrUOkc2s76wk26XRfz18MToiLdxve5qP8ou07D+CRQDA/aUTuaZBe6HrlBlZ5hMA1QTux+vyj6efHcTDUWQ5ZUyTvye776ykeRyUqKBWxLA++WXLQ9ugrB4NbRHbWW475BXse2UrZcZlkkoR5eTAvQ3lMOuQZL3di603hrkv/K0ItWRx8CvxgnM8OEd1YGdtiX53DNLZn9ak06bjur4rA0UAAD4EAwAAAABoQwQJAACANkSQAAAAiBEzkogiAQAAAAAAAAAAAAAAAAAAAAAAAJjKhaEBAABwhYOrO17veaO6X8nPjyDvsC9OrYO6Kg5WxWJFAIDdkmW45EJ509DZS3E9XiukuQmMJPEeXC/hU0+SJ0QMWYNMQ20F6p3uEFq9wR028/w68JRTXb4w+jj/+a4HgI9XnMP65Bwk/r1GKmvU4iYwShnnpihQfnyYPnSR36MRwzLwl2aXBusnuUNo9QZ32EwiyDcZpmLB8o/sQADgRv4mgiy79LZKlq8kw6fGGGeaYhqWaGwdxss+tKbMa+gX0eXjg+k25h/eNZraa9HBMrZiVlPL3kuQtm2S9lVKso1G9HOooWKqRWyZi5H05yYE9sX6meUjr0+ktQxspWzrcduDseNh11FdNuVzY343ZioPsDv8fgCAz1aNINOeVwSI24mwnsAopa0H9z4+TOLcK8c4+/yFYXo8pjk719bbIVCEfGU5tZ953opcehO1Kgdr3QSikmrYWibLXj6hoapiRaSVK+Ps0L5Ykqy5220hDzC1msqGVuuw56ieZ6WKa5T5qzGTtuMYrAWAg7zIKX29PoZRSxAuJfbxYcpOpca4SzrtqUignN5rNXSL6IqoJbIhLfzPqo2afsxNIF6ozhbQ63NSQ9VEikhL0cLHLhpBhofuZNtqbV28VquDu5nKyG0RdKbb8btjkESQAHAB9Wra5RFkYwxRVNI7Vb+q01cSFGOMsav5ahFJntVWvDaC1GuZzChwE6QFeXNVtfqc1lC2cBFLKfOsho9G/csk4cqJesV+Itl18DdTv/RPYKQgggSAC7xtDDLTGEZllZTRZ+V+8GU7zokgq0VY26yMEV0XQdqXlbf5f/UE6/8jQ1ZWBHlKQ9maijDG5Mz6a0lq79oViO3pegR5/KhG13VEkABwiT+6in2skkXwVz0XHI8g2+77sYrQSjmUWyzBnjHI1/1FrWOQpzVURbgIZzsORZDl4zBPHoP0N5MxyLiD87ABAIqPjCBFJd2T7fF5kH7YokUb50aQekCTPOju9HmQ1ckG+rac1FBOBn7i7Pl/ahB5KIIsKyzbNjSyWqvDnhDSGHP9+Xux9Vv7/qw2APAVPjOCVAI8ZZBhS6DcWC3uxc5jguc1RBkR1Ioo7rpQb+BQbkNuOZPJPJ8ZbLVy70FuvUnZju2sfXpOQ1VFdnd5VCu32jj7wo4zynu5ysvoZThXvlKtQ2QzuRc7KIsheaI4AByTTuSaBu2FrlNmZGnBnJ3A/Xhd/vH0s4N4OIosR5xIs1lr01DGRllJ8zgoUUGtiGF98suWh7ZBWT12nMfsBtEqqdWhlkCsaphUdpt9p6ndKLOzoRxmEcXidWlZSoynbYJ6f5n4cL4FvbqmoGwufQ6B2YxOS8qPP49qczt/fNQtaSriRwDAfswYAwAAQBsiSAAAALQhggQAAECMmJtGFAkAAAAAAAAAAAAAAAAAAAAAAAAAAADgzxxc1fBr/Eg73GEzT62DuuAMPo1cxiqXPqShPHSU1ZjKjIr1kADga6mL1F3Q990hpLiDH2mHO2zm+XXgAaKfau3mpmkyIsh8yfJyAfOud3d/vvY6S28D+AXyXDvOpw+23CGkuIMfaYc7bCYRJErGUZEHf2pKN4IcpmJN9B9fiOpaS10AACAASURBVBzADyh7VdkZLld/Ko/gTocypyH9ePbRHQ/yfn5+HvOs5MfzYoqTxDoIsfTpr9RpLmYO6xXMcbuUuQ1qmM0kKhFrh/pmBLaiq+2LmGodtsynIa3Rs0qRzTyyL8x6TuN2gj+jqWWKaTAiyOfGECt8hobfFWJ3exFk+UW7w+8oALiWGkGml2Oyk+8wyfNlnkCda3SsMx2mxzxPshA7w94YRV1qsb5ZOScUOYzzK8x4xhXT8MowqVLxESXQtasdysHZisC+qArUQQzXLMM3WhW9gvbuC6WayoYea+q+bMh5Vqq4RpnECh8h3BEVB2Q/zstF8Pwnk5m+Y9AawA8oetWkN1TP7OID5RUgv4jWCqrBmN096wHJcrqPDReJHJJtHLZYNklkDFA5l8byxJEcnK0I7IuaYB3WUrTwsYtGkHv3hbp3i9cONbVycKkHYTZGjvsLdkRKsmXofD0AIsckESSAr6fMg1z/r3eC6djbK5l1tVAtormCZabVq0p2BBnt0ssI8vW/ZFvWREZlehl82e0QzcHfCm9f2OJ1WA6SWQ0fu3AEuXNf+Pc01Ovgb6b+64SA4PNFOqLgoZlnRQQJ4CfJeWNJv2h0uEUEKbNrunobqaA70FVOfjOu/9ZKsXMIRJCG4MBYNAdvK8ptip/E4nXozDG5rYqBUelqvc0KxA6mA01thJgEBJ/PPXYavjHZ8UAECeAnNV/vc4OY4lPXjkH24ywmopljkEa13RycCLJ+TV3UQG+H8C0vLRFk13Yaa6nDYxrM0+2hCNLdF0fHIP3NZAzyW1WPTGv+tCE/HpzZ5ADwlWo9nT8PUgsFLogga/Mgyzq2RpBuDl4EGQy+au0QDd8qEWRoXzh5+4mzR5+oQeShCNLfm6FxokNNHZ8Hyb3YH8U+Kuo355W0ibfl9Yad1QSAD+Gc7517b4tbItS7K5R7hOPda3kvdv78NhFRbA/dUfLRC3VzcCNI9RRUhjrVdgjl4ESQgX1R5dWhfHKe8iy9wO4+sC86LZwrXznU1NyL/Z3saTn1a9Di8CrHyZ+JtiQ8URzAlyumhOm9XpZKCwWyfMy7K7xiLM9oI81BC1mS98QqdOW0ujIoMXNIt20akrtv+3KxO9mc+gyAWjtUcvC3IrovHGYdikXbZNsENvPQvkjSyEP31KYuPj4NtViWMcibcw46a2Zs8JBWkxA/AsANcD0IAAAAbYggAQAA0IYIEgAAAHH5DCYmFwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbk9dLuZLHFvM/YZ1+OadFVCsqAQA2C15VM40KP+3Vvtal3FzExhJ6MEv4O3Ny4zKgtFf4OsiyK7rvnZnefLV21m0GgCOK05RfXKKEf9eH+u9PuLbTWCUMs4/OxJyqerevMyXBiVEkN9jmIpV1VmkAACO+ZsIsuzSa9ZhzCXP19ha9vnAk8fTwdBp2Crw/Og85rko1csKSd9Prg9uY67aKcqqQ3wrqgIRpFdEoAqylWQZ9Swie9NtqEhL2HXYMhdD7c9dln9Y3eWBrQjtzPyQGremDNQhVIa3s9IG+dqgqjx+7vDzAAA+Wz3mSHpeESBu57l6AqOUHT348ol19DKt5zCJU2s5xpm/spxWkxTD9JjnSSapjZsu74sipmkLnffUwdsKjxdBthbRF+/35UbM8yw3yy+isjfdhnLFjoe0pZaLnFoVvYLsrciULVlWU9nQah3czXR3VlawHeZ+Om2//OZYLACcKHzd073uU0twxtXV5TRnDOxpwyoy/qudHouT8fNFbTQ2fT/Nc5zLYarsM/U6RLbC47TzjiLKEFRppWSzo0XYe7Nzd5YnWIe1FC187KIRZHjoTh4O2iFVvFarg7uZ7s4S2/G1Y5BEkABwAfVi2eUR5J4QYZjMimmv90XIkN3SowwHFZkkOetl5BfrZRrjvKXXIbwVVdW9uauI/EP61eQtSbwIa28medaPR1PLZo7zY57V8LELR5DRyol6xX5D2XXwN9PbWb+DCBIALvC2McjMnhEmObcyrbDBPkXIU7+e+do4xom8PYI067BrK+wKa3UIFlFGoVkl3QgythXW3jS2qqERmlrSGJPbqhi4il2tt1mB2DSOegRZ3Ux3Z/0OIkgAuMAfXcXewTxbt99m0XWdOIW8awzSrsPOrVAqFJnVaujHWYT3bWOQ8a1oiSC7tvN9Sx0e02AGqIciSK8lD49B+pvJGOTqjHnYAIDcF0SQgZBB+2wRQZ4wD7IWQXp1OCOEdPamW0S5la3zIKNbUYkg3Z0VyNtPnD0gUA0iD0WQbkvGRlZrddgTQhpjrt9+L7Z+a9+f1QYAvsI3RJDKjdPiBF3c8SBvnijvxc4fQdwF7t71I8h6Hdyt8Ll70ylCFDeWa5j4t/fGtqIeQToN5fLqUOxc5RX1lnBRjeqvGqcltXCufKVah8hm1ndWku3S6F87LJfFkDxRHACOSedpTYP2QtcpE67MB/ypCdyPN1VTnVK2kOUU0xyzmuihQFqUUs+siDSHNOtp0F4I1MHdingz2XvTLSKvYN8rsY/MuExSKcLfm7GGcpl1SLLe7sXWGyOrbHpARI7JQEsW3w59qoReB2czlY/rO2tL9N3DcklLED8CAE7CVS0AAAC0IYIEAABAGyJIAAAAxOVz2pgiBQAAAAAAAAAAAAAAAAAAAAAAACCuXBgaAAAAP+m5iIofGn5+BHnGUpy3qoO6Ks7vKNYiAgDsljzHRq6DV6zNJyxPT3QTGEniPbhewo+eA0OyFpuGCx51eYfQ6g3usJnn18FY9v7b5euesy42ABxXnKL65BQj/r0GImtQ4iYwShnnpihQfnyYvn0N372Wgb/1v9esd3yH0OoN7rCZRJDnGKZiPXI6EAA45m8iyLJLb6tk+UrgseD52NxWgSTMSnNRqpcVkr6fXB/chgC1U5RVh/hWVPRadLAMvoS2Ipogbfwk7auUZBuNLTiws6KqRWyZi6H25ybkH1bbYv3M8pHXJ9JahnZm3tbjtgcDdQiVIQ9pNYJ8bszXBlXl8XOHnwcA8NmqEWTa84oAcTvP1RMYpbT14N7Hh0mcWssxzvyV5bSapBimxzxPMklt3LQcBx3nxzRNWSDVWgdvK+oi1+YiW1FPIBpfDVvLZNnLB3eWK1ZEWrkyzg4dokuSNXe7Lbpe2ZmymsqGVuvgbmZfNuQ8K1Vco8wvDaq0/fKbY7EAcKJ6BJm/Xh+iqCUIlxL7+JDFetawioz/aqfH4mT8fFEbjbWqNc7lMFX2mXodIltR5Uc87lZENjN9oTqdQK/PCTvLE2zJtRQtfOyiEWR46E62rdbWxWu1OribqYzcqsf5VbMdboMIEgAuoF4suzyCbAwRikp6Z+JXdYxrl+Umipi0yFkvI79YL9MY562DW2HzIx53KyKbuRbkDZFq9TllZ9W1tOQ4P+ZZDR+N+pdJwpUT9Yr9hrLr4G+mfun/FyMnIkgAuMDbxiAzjSNMWSVl9Fm5H9w+RchTv37D8lqufUG2MYI067BrK4zaNibYtiK0mdvedIasrAjy8M6qayrCGJMz668lqb1rVyA2jaMeQVY30zj8fjFyIoIEgAv80VXsY5XMq9h+m0WZybvGIO067NwKI7eWBHvGIB/T4AZ26k4/Y2c5wkU423Eogiwfh3nyGKS/mYxBrg7OwwYAKD4yghSV9EMG7UxfRJAnzIOsRZBeHU4IIdWAJnkS3unzIKuzEfSdfsLO8oRaMntAoBpEHoogywrLtg2NrNbqsCeENMZcv/1e7KIp6oPHAICAz4wglRhSGWTIorP8BClvnhiKe7F7GR25d+/6EWS9Du5WBCjb9ZBhrrsVTTcp27GdtdMP7yyfV0Sxc5VX1FvCRTXsQKS82au8jF6Gc+Ur1TpENlN+S37xXuyuEzEkTxQHgGPSeVrToL3QdcqEKy2YsxO4H6/LP55+dhDPPpHlFNMcs6z0UCBtAP0+Yj2HNOtp0F4I1MHdiqMt5m1FJIFY1TBpsG32naZ2o0zrzooxiyhWt1N21lYVfRPUG9DEh/Mt6NU1BWVz6XMIzGZ0WlJ+fBpqsew3j0F2XdYSxI8AgJNwVQsAAABtiCABAADQhggSAAAAcfmcNqZIAQAAAAAAAAAAAAAAAAAAAAAAoK5cCBgAAACoeV8EqS7uAQC2bPmfvO8wFlKyV+v0kgDAl8ueYlOsanjzztFejhkAUsp64nIhTdGbGAvSj/Pte0YAeBPtSdofEZx9RCUB3FHv9B/9OJcdoxFVAsBvqkeQyfXi7UKPlt5/HHc+vDkWHbg3/CkvHckMYo8Ff1aV5WeAX+ZFkONc9CH9ONNvAMAmMAY5zo9p2pKNs/VDfJiMyE1eNFqiveQFkecw5UFen78/TI/HPM/iFVnnahjKHT/A77I7sa7rXiOQSgBJrwEAq1gEmXW35s93I4LU0qevqfmleZWTlETIqFZI7fCfISRjCcAPWn9CVi9GW5ew57FP7rkhngTw44JjkGl/2xhBeteLjBmNW8WUALKTl9qVBIwZANAsFznMzkEZgVxenJPHTWjjlADwS66PIM1r2/X314oZxZWTNRVMewegqHRL+g0z41yMO/bjTA8D4Hd9wRikkQAALGavYdxxLSdnd3rnCQA/Q4nvZCB4MIJ0n4FxfB5kPITkXmwAlV7JfKO8bM0YJIAfJ35blx3o0QhSuVVaviL6ZjmT3b0XW5vYpJ0JuBcb+D3qwyCaRiC7rhP9EvMgAaCrrPeVvjEN2gvmLETRucpkRSedva+MESrPgxT5yIpo5wHuxQZ+UvbAWDP0i1ww4VcoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3148zDxMGAAC4UHANmGQ5mbsHZ++LIPty2R0Ae7GeDACcRl+R8OyIZZjCqwiaK2v/LGsNcgAN8mWsx5l+BgAOk1HbMJ38E50I8gAiSOC4Ycq/R/04RzslAIBBidqKmO95Mboco1yvUvciYZLolVsy4GkFRXYEmdWgMcx0K5lcL96GZYsTTOhSe95SYxEAmi2pvD8NZQQZa4dnVTlHAl1XBpD8WAWAE2hdafbaOMuAMA9Nigz6POwZpsc8pwOb9lRCo1sfJhFuiSoFeJVcYrVpC53tIsxzj6zmEu0lLzgt2efvD9PjMc+zeCXSDmuYyTkSUL7sHaP7AHCcGhCtL2p9r/hIIIIsYhk1Wys4U9M2zmQKRZBZOGZU0YwgtfTpa25LluMkImSMt0PwBibgJxBBAsAV6hFkJdIzM1AiyCIPPT7T6mJEcn1bCBkbgxxqCWqVrCS38k8ye/1LeX/71DntAPweIkgAuIIVQU6D9WZ7BKkMhtUDV5GboeEMcHkE6c2r8lrSKC6PII+3A/B7iCABoMk//PHHH3/83fIPAO4r2EnV78W+wzxI/fpum8vHIPWL9V5+TfMg4+3AvdhASn53Gh4xdgkiSAC3tjOCzB+923Wd+P/yfppDFho9L7Yq92KvL4l7jit1SV6Xb3gBm+RU8ngEqdwqLV9xWtK9FzvaDtyLDQhZDPnnk4eJIAHcmt9J6VPr9Luh0/er+czjsD1eMbkpWD7p0KlFUQ+ZqnVY0q5k9tY0dMoL0UrKZEUlnZbUngcp8om0A/diA1Ly3frzn1ZEkABujU4KAG6IzhnArdFJAcAN0TkDuDU6KQC4ITpnALdGJwUAN0TnDODW6KQA4IbonAHcGp0UANwQnTOAW6OTAoAbonMGcGt0UgBwQ3TOAG6NTgoAbojOGcCt0Unhj5gLP0Y+GVlNJ1mY58+XF8EHUNaUsha1WpJevJ4TnTOAW3M7qbVTXU/C6Zp6b1sTLyvULjdNNo99ubJtdpJYVlRcs3LXbwwv8IiA/RHk+ul3FISfYa5yXxjnxzzPRJAAflqokxqmZ3+ZnIbDne2p+nF+LletxATDVK4NLeucdvr2UJYbcxCUHEcEiXuJRpBLR9NwBO5EBAng1sIR5FjGZ6KzzYYJ0/deQ3fTkIzi7ep8lwByKb0ICspAIXtFPT2sGXpZtSYwrNu/FPpqsqxe+XBrWkwS8qaJ8q06VsQqH6sdJlFKJQd/d8sBZXVDnDq+zt9JPa2Tv72zAu2wFfGu4Xb8lWAE+ex8iCAB/Lh4BPmMtl4nWdHZjnN2Bh8mecYd58c0bX2uSB+01kCL/Jyorryibbt4DHL59NoE6YlrmEQoJBtqmB7znAXzS1ur4fS+IuQrS5wl9q6fg7e7W9qwLzJ4tcOaRb+MMCsZGgUFtmJLV4sw8SX651G7/aRQEq2BIxEkgB/XEEHml4nTCFL97S7O2+Ocn6/jc46yj7yyzMPZtcQ9A1F7Eh+OII3zk9ooWeyrbmQxRHioCH2ItzkHb3e3taHMYJjKmM44pvSCIluRFMUY5Pfr86NWPZy214ggAfy4pggyjdvS3rVy4l7/J9Pk3bN+j0oeIohxR3supHVR9FYRpBbpGhFQdkOQ+tnyg0eK6Louv4pdzEnwc6jv7lcVD0aQgXawCgq3A36YPHKyLogIEsCPa4sgkxN3flnUuEoYjiBjlSgimWoPno9S3SyCVGtuxdFpDKd/tqjPkSK03PORGT+HEyLIcrakvJofnMBqRZDN7YBfkx+1g5w9QgQJ4Je1RpBrN3ruGGSoDgonjEtjh5by/iiCVK5Ga0mCY5C7i9DkPxj8HA5GkOWkxpPHIPe2A35K4ELJhUcRESSAW2uPIJ+DfzvmQR6JINWAIb2Q7ddBDaq0+ZR/F0EG4pr4PMgjRRSfTVs3EnwdjCDL1KfPg4yHkNyL/aPqfRRjkAB+3I4Ich0PFPexVuYsdkcjSH1aX1rKa5GIyrBVUSstCnm98TcRpHpndbbx5b3YahB8sIg8YCr2ppdDbHcrd3wXkyW2lMpV7Lm4uq4eUdbO8rdiq1hgwBufTfw2s+/t39ITQQL4ZW4nlV09zsM1carNrvGkfWt69Wd9tkz8IpCowXYvdvbiEqLk15mU/r8XtezN95Q0h9ek0S/Fa2OrZoLneSvNKavAWUWIBi63xcyhYXeru1bJfx775CmT6c3R5p1TkXuznHYQtWQM8vvVDkg91ZVHBREkgFujk/ow1498ALgDOmcAt0Yn9WGIIIHfQOcM4NbopD4MESTwG+icAdwandQHyec4cmMH8M3onAHcGp0UANwQnTOAW6OTAoAb+r7O+Z9v3Cjgd/3DH3/88cffLf8AAAAAAAAAAADwBbKVSCrL3ZhLmQD4YUkPwsMOAOAQY3W4G4Zd2cLKxTK3G21FRgA/L19ifpyJIQHgsHHOYq5+nD8gCOtFrbtuiStvX3EA7zdMxdrqPL0fAA4qYzHxSuRh1/kVZtldn/+87DKCjJ0SnvXk5AH8kKJHWhaAYhgSAI5wI8iMNkSZv7REi0mS4prz8VHOMoc+dF1qjWQ5eQA/Q7tkUevlAAARyohjdYiu7I2zGUZe/q8Xd8VwawRY5LgMKbhz5Z8ZMAYJ/A4iSAC4QnE7jRPbab1xnomcVql01LEhQ8sS5WYfH+fHPM/by309rAXwM4ggAeAKsiftixua81mM7u3a2R0txv3eh+/5ltOYxrmIfftx5hQBgAgSAK6g9aRbfNaPs4jMjFFFK89yDvs5RL7Kxfdh4mo1AO2+Ge6kAYDD6hFk+a6MILVALU1yTQhZPLqnvGytjUFyLzbwg2QvxM9LADiujBHT8TwRqT0jsPIad9IdL7FckZ8cAWiIK+Xd3PoTxbNy9XmQ3IsN/KYshuSJ4gBwiDlHMf91nqZK7ndOLlPPY58nKsuSRTUPS2aTMa3un3uxAeiSLoT4EQAAAAAAAAAA4G3+4Y8//vjj73v/AOAS9C8A8K3o4QFchf4FAL4VPTyAq9C/AMC3oocHcBX6FwD4VvTwAK5C/wIA34oeHsBVLu1fygWyAQBvQwQJ4CpfHUFuS3Xf2EdU8nLJ+kO0Bm5kWZXGXA8rWbRGpDGW75I59Rcf+kSQAK7S3L/o/WLzgoNv8RHB2UdU8m1oDdzD2tFN02R1cMOURH2DTJatqm0mSV7J/3cSIkgAV9nXv8jzfNaT3sdHhCMfUcm3oTVwN+YxWbxRxoyZfpwf8yj/n+V8/vFPBAngKudEkK+X1v85V2bW3/fLR15Xgsqf5871nSzNNI7zK4v8w/ZYaZ6BcRVKreQ2FrtVbcstNJAQqGSgoSrtpGydusH1po7srGyPP6ZBnkojO/OV0Hy3XkSWJj1PA4eYx+TW3yRJK1/9MmCM5HkQESSAq5wWQer9bPUn9fLmOD+jkT7pPIvrOWuq9NPZS8p8JecHvchzGUhtqGSv9PbFdSpXYNShUgehL9pJS5ydyQJN7dYh/4gzc0yppCxGeSNWxBqpMpCJs9SOSfFGLUZURhzVNCdfxiaCBHCV8yLIeFiZvGkMF6n96DgnWWldbfFarXS1r9bHVu0xLe0yVusZIBZBhsfVyu2SJ64i+HOaOlCHyOBKvZJJMdGzteoZQjIGidPY39B09s5y2+BcfnOe5CXspoIOIIIEcJW/jiC1OMKIL/okron9VncuiSoZ5Nfia5XU3g2cJNoqGapDrmwZUasss0BTB+uQ3WDlVXZHBNlaBHCSwM/g1yFZ6Ze8n0A7fnyGEEECuMq5EWRkUE+8qbxuPAZDzNwL/FqvpDLeUiPIalCYnhh2XYKKXsWuvWu0UppCb7lAU4fqYJcXrqRWvaYigEs0DA3Whyujv0RPRQQJ4Cp/Pg/SeMPpTt86BlmPnNbOf+dZ4FAEWT5x07o6v01fzLLym9qtgyqtRbCSWzGxs/X5U8YARfyY3BVA1qYFn4AIEsBVLroXu5LQ+8jzHadLDYVrJ82D9CKnZRiydS5gpJJuHcqN0IOz16vq40OiN45b7aC9ldYiWsk1r8jYsDmDk3mQOFc0gqz8rDW7q3Qm5TWIIAFc5ZwI0gyfdkaQas8qeuHiHmLlFeUG3vyRQ2kR+izGyNjb8xLtznGEeiXrdRBt8oyftIqM82OeJu0U5zd1vQ7lTTa1mZfVStYiyGoReboH92LjPKEIUn+SQ/KmfsVDe04CT/MB8BlOWpOmiCc12eoN7sQ7ceeElkAWZHTSei3LIvITQLCSWz77O36zkpE6pJswj31vBWjWA3CKTEQyvw7D+qAfvSXdSroHTKSIrLaMQeKo0IFvfSuLnPT71dTDnggSwGegfznB7ivYAHAlengAV6F/OW7XQ3wA4HL08ACuQv9yGA+WAXBT9PAArkL/slM5iYlhSAA3Qw8P4Cr/8Mcff/zx971/AAAAAAAAAAAAAAAAAAAAAIBbiK42+4eS260vqOq6fMrNGqF8OtFr7Y3nytr+jefuI9aLBG4RPHQTf6K6llP2TAb1iO+DnUi6vg3PBgPwnfS1vnb0ex8QQb5cV9X7NYKySvbrLDiPXWwNcPcJmWWCQBE8dxNvtIZ+02QeePkPoXGWX5xhSo/j/H+JcSZsBPArlLhnnIkgb5XzTnqYlozDLCfWWqXbByCDRTAMib9gfkmHKf+u9OOcHp/Kca5kxQ8jAD/FiSC36zZJQJBcl7SGMZN+dP3M8pH0GmdSicTOOCx9LPg0yDNCZXvjdagW8cxZtFhrGbGtCOjHWT2dDdNadO8NmOwYgIwWYVUvEbrIDjSwvv7lF83/QSh/aYugEwC+3dZR9uWVm67ruk78+tZGjwLDb0uSNWzo7YHOQGyhVjL5TGW+U2ykUKuDV8QwPeY5aSuZRXHhqywjvBU+sxXTN7TL3HnK9gHIcBHebl7D7XuN7OKTGV9/rTtyLsUUH7H6TwD4Vn4E2SVBpHHxMRZBhseTKuGlxQt20nqEEpZ18IooIsQ8C3WbRJOHt8K3RG5HcnD3wo7dlHJruN6etLsIIHdWBKlfwp7H3rsbBwC+R3ZhtdLnjfNzhM3IJBJBRsONfaFJtri1+fH9EaRXRJFzmoWxSWXUHtsK356B3IzbUEfnfe4aawaOOCWC1PuyZw+55u8O4QPAhwuNQT4Tmif86FXseuaZY6GFHa/aVW2sQ1GEG0EaqgMdu9vhYHjm3uly/FYYIki83fEI0vxSKveM9ePMAQ7ge2kRZBntPbtNq/c8FEH24yx63oOXRxf2CUCp6r465EmqEaQyVT9kd0scu4q98xaa5jK4Qo23qtxJ499qXf/RoxzP9Z/NAPDhtI5SdHzZ5Rg1dDgUQZZBUnMEqWXeFEH6dfCLqEeQgRCyYSt8R0b43jAA2QVGSbkXG2cLP81H/xXdeGMZY5AAvpoXQardovYAIHkTcfjnuIhJn3FDawSZl2iHOPopxK+DX4QTQaqnoKzchq0I2B9CvmMAMlA97sXG6Sq/dbMYUs7o0Q55/WdnpecEgO9hPcxxjWOKGwvT6Xx572nekaMXUj7FJvls3xpFbo8Kyuv/Ys1CTOvp1KFeRLKR9YaSFSkfKGlvRat9gd57BiAjmXAvNk4S6YSUb/HK6kDKrxf3YgP4Ev/wxx9//PH3IX8AcBd0ST+ueRjSnft/xs0BLGkIlOiuAdwIXRIAfAS6awA3QpcEAB+B7hrAjdAlAcBHoLsGcCN0SQDwEeiuAdwIXRIAfAS6awA3QpcEAB+B7hrAjdAlfaVyFW8An47uGsCNvKdLStZrqIc1YmWIP4mB7lCHoz4/grQXl1sXonnv1pUPznwdKNNw1grdxTJ3bhE8OPNcS4ObD0hN+gZlucLAkjR9uCtUEUECuJFgl5RGVfPYyzVhoyprznZd191hmdg71AHeoeIcSJdUpyjxGQ3MY7d+QY6tBV4GqYEizliCHGtkN01me2bHQNHs2aLZZhK5yH3jniOCBHAjkS5J9ITjvHsE6GZhwU3rgO5uh4oepiUDVv2Bb8VTMQAZLIJhyFOZh1bxRhkzZuR+UfZv82FMBAngRgJdUtnNaX1p6Lqv1WOKC8ftF3nWIYSly04v/kUrGahDPYeDdXh9fBqSS11qZJBlB4Nf7gAACEJJREFUMo3jXMT3xiYGi0ivtCVJI8Ml6xXmvJbauJnZkOqOEJk8D6Stolrl0uuK0+Cc72v6cVZLGKa19ksjHRkLrASpThFW9RLnXGT/CWZUl3/PnkkrzR65mlHmWUcECeBGdkWQxfv5Ccw+oV08sLRksBbfJ/1ztJLO9Ds/h2N1GOfHNG3rSpcJZB7mvK3qibBSRD5SMkyPxzy3neaG6THPWTikXQLOSywL8A+VOamo2pKiBrsDPDNCS9+ob2OoDO3jsSK8EHINyhlfd9W+OOKNWoxo7VCZpu2YJIIEcCPRq9h2T6f2gsZEyesjSGOgJVzJhhEIPYdjdZDDTOIco51yjNNQbUMqRagDLW2xl/qB6nCNtgnuoVIGvlkWJ85nXSK3U7KytMcSGbeGydgw6uq/IV9vLbeqzeZ88MDUgj3dHREkgBuJdknWNUnj1Gfca7MzgjTucyxSWzcVNFTSqEM8h2N1kInyT7XEGeFQOM1ULaD1Vg01fbXquyLI/F0ti+yoORCf+ReJjzr62ylwHRtB1X2R34tdOai9HzA7738iggRwIzu6pGRqlh3cNV5aDbwbq5n6u7+hkpUIMpbDsTrUI8iWBjovgmwdH9NbIK9POdfxgghSfGB3iHV1eHb8VhgiyPM0fMnqw5X2/th/MBJBAriRfV1S0nU23aDwRxFkQyUr9/rEcjhWh18YgyyfVXnRGKSw+0LxxVexjwS3SRZcoT5HvBfaFUAeC/aJIAHciNslWUFF+mC0cIf4VxFkYwBoPMsjlMOxOtQjyJZgY1cE+ZZ5kGUR50eQ2l7YHUEeHOGrz0E85Vk8bgW5Fzss2gtVfrOYX9ODt1sRQQK4lVAE6QwZKf2i0Yf+WQQZrmSlDrEcjtXBiSC18MyI8HZGkOIe0n6cT7gXu7y/O99kdc6DcjP11rCBCDIPmA4FaodCyPp90CcMQAaqx73YcaFeqDroa3d+2lTdpr1PBAngRoJjkPkkPqWHlbP8REyiyeMUd4JhTTmtzgxKrASxOlRyOFoH8RRG5QWjpvGmDhaRr7y2dx5k2h7ygEmrOY+98cTJrEXzCDR7UdmKYX2mUrIhBxwJ9CpjkKcMQEYy4V5sj//1zVJUDgbjWLG+m0SQAD4VXRIc59xJ8+Eij/drd+wZPoszRjHxIeiuAdwIXRIcrRHhV0aQV0RqZzQUSxr+FLprADdCl4Sq9sn/XxpBAn+O7hrAjdAlQcqnhDWNu+Uf5b4N4Ex01wBuhC4JAD4C3TWAG6FLAoCPQHcN4EbokgDgI9BdA7iRf/jjjz/++PuQPwAAAAAAUHN0xcJsmZR73uH7XHTiYPUOL+2IHYxVcfBTeq+XsZaJSi2PI7DezVamqRxtr8Vkd2wFANyDtRRXc+92VmB08wDrePVuvoHf7IwVYvCp8vXlldXm84e3Fw+YX7vKaTKePV+u7W4Gkc/l6IkgAXywdEW7fpzXHq35qdFEkG/LATsRQf4uZdVK8U0svpjDZBwu4a+wtV7oEp3yZH4Any0cQWaPks56xfwh06FElf53T4D1zHwe83Jk3x2qQ76dozwFpNVLkqbtZpYRaqguu6C/nGeiYU+oHdahlKXOr4SiDHt3xxoq0NbuZjoJ/CJkI6jn82cpnMt/T348aBGkflQcjSCfwSwRJIAPl5yYRQSZdH3j/BB9bdH3tUR+vchvbz7yc3N2dam+XJ9WB3nZSZnxlFVPniCKy1badjobmH+kPudKE2yHpRZrYfmWuLvbaahAO7ib6SRwi+jLDOZZOZ+vUSYDwz+mCO+8McnAOzm9m1sDRyJIAN8jjSDzl9UTr/KDPXwOti7vHIog1WjNjr5kHbQ6Vc4yZVxlDHHVr52V6Y/FMsF2WAKnfbvba6hIO7ibWU/gFqHseWNaWjJwi9+hfw2zWeFm1+H1UeuvEi2H7dAlggTwPYwIUg/2ZPd3hwiyyNEupnyzmlZWTxldMD7fyxDS38DYacyuYKQd1GSv0uu722moaDv4m2km8IvQfzowDxJd15lH/zDlY5DW9zTYRymD/9nNOkSQAL6HHkEa3WVrBFlOAjw9gnQrX61DrOBXFmVZlbvaa9fKAuU1RT2RdjCT2dVL0jsbEG0HmX19M7MEbhH2/DMiyJ9nHWsX3EmjXBjPZ1YQQQL4EpeNQfbjLH6Nv38M0q1DeAzyMQ1qacFbXpo3sC3uiY9BGmevo2OQ0XaIlasncItgDBKaygzs8rA2+sOmr3B2IOq/fDgkAXyBy+ZBlhm8fx6kX4fQcN9WPfXpIIGzQXUDtcCuPYKMzYM0Ikh/d3sN5beDu5legj0hpDEPknuxf0X91rrykDkhgqx+VRiDBPA9zB5TRkv5o3e3NPLm2eS6Z9qPVpcHOXIVO78HOX8CXKQOZYxRvJJVT51dWIaV/m3I4mFASduqTV3jtUO6HVYe7u72GsprB3cz/XbwiuBebKS0WK5+K539y82e6VF/XoCWTbD6AHBTxdUV7y5F86e5mUX68XnsxSJz1sS2tgmD8jmI8tP1OuhNIc8wSbZJUWkquSn6JWGjlsP6kJ16U+9vh3IuqFpJd3fXGsptB3czY+3gNXW6rdNQ+9nAGOSXs3oY9REFytdGvmnlUOsDrWJO3VAAQCt+0C9oBwAAgCgipwXtAAAAEEXktKAdAAAAIvIJSr97SwTtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPypfpwfpmkgAQlIQAISkIAEJCDBbycAAAAAAAAAgDe7w9AoCUhAAhKQgAQkIAEJbpsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDw/4SREUxiqsO9AAAAAElFTkSuQmCC" alt="" />

后记

. 本篇文章完成了对AC算法、Snort的入门学习
. 我们现在已经知道，Snort、WAF高速正则规则匹配使用的是AC算法
. 下一步准备研究一下Snort的开源源代码，从源代码的角度来深入学习一下Snort的检测原理、入侵检测相关模块，AC算法在产品中的应用

Copyright (c) 2014 LittleHann All rights reserved