键盘作为计算机的主要输入设备，是大部分输入信息的主要来源，但是我们每天从键盘输入的信息安全吗？随着互联网的普及，各种网络应用也是层出不穷，电子购物，网上聊天等等等等，每天我们都会在各种程序上输入各式各样得分密码啊用户名啊银行卡号啊，你认为这些秘密安全吗？那位同学要说了：”没事啊，不都是有保护措施吗，像什么QQ的号称无懈可击的nprotect技术，网银也有各种安全插件，没事的！” “呵呵，真的像他们说的那摩安全吗，那可不一定，没有什么是绝对的”，下面我们就来看看键盘的秘密，看看黑客们是如何记录你的键盘操作的，以及我们该如何抵御这些猥琐的攻击方式。

一.键盘的硬件模型

其实键盘应该算是计算机中最简单的设备了，在我们使用的普通的计算机系统中，与键盘有关的硬件说白了也就是两个芯片，i8048和i8042 。i8042也就是intel8042,位于主板上,CPU通过IO端口与i8042通信,i8042负责读取键盘按键的扫描吗或是发送个中键盘命令.i8048,它是位于键盘中的,是将键盘上的按键转换成所谓的扫描码的，然后传送给i8042。呵呵，就是这末简单个东西。上面说的都是比较老的计算机的结构了，现在这些芯片都集成到南桥芯片组里面去了，不过原理还是这样的。

当我们按下一个键与抬起的时候都会触发键盘的中断，在老早的计算机中都是采用两片i8259A芯片级联来管理中断的，键盘挂在主片的IRQ1引脚上，当有按键按下或抬起是会引发硬件中断，然后会调用相应的中断处理程序进行处理.

在实模式与保护模式下对于中断的处理是不同的。在实模式下我就不说了，也记不的了，自己看看微机原理。在保护模式下是采用IDT对中断进行管理的，在IDT中是各种各样的门啊，啥中断门，陷阱门，调用门啊等等等等，对于键盘中断在XP下对应的是0X31号中断服务，但也有的XP对应的事0x93，原因我也不太明白，反正在我的系统上是0x31号。

好了既然都已经都调用中断处理程序了，那么在经过一系列复杂的处理最终我们就可以在应用层上舒舒服服的用WORD打字了。

好了，硬件这块就说到这，下面用到了相关的我们在说。

二.猥琐的键盘记录器

对于那些盗号的所谓的黑客我是很不齿的，这里我们要探讨一些窃取键盘信息的方法并不是围了写个键盘记录的盗号程序，我们只是站在攻防对立统一的角度来看各式盗号手段，并给出相关的防御措施.

我知道的一些盗号的手段也不多，而且都是一些比较普遍的手法，有些也都是爷爷辈的技术了，不过现在还是很好用，好多盗号的还是用这些土枪土炮打打打打劫…

WINDOWS系统是分为应用层与内核层的，从CPU的角度看就是RING3与RING0。应用层是受管制的，不可进行端口IO，不可执行特权指令，限制多多。内核就不说了，想干嘛就干吧。

我也是按照应用层与内核两个层面进行讨论的。好了废话太多了，进入正题吧.

1.爷爷辈的WM_GETTEXT消息获取密码

用过MFC的都知道密码框吧，就那个******的框子，他其实是个文本框只不过是加了密码属性而已，本质上还是文本框。对于文本框我们就可以通过对其发送ＷＭ＿ＧＥＴＴＥＸＴ消息来获取密码的。不过还有点问题，在WIN98系列中这样就OK了，但是NT后，你要就是对着密码框大喊WM_GETTEXT是没用的，密码框会说:“你又不是我们家里的，我凭啥把密码告你啊“.其实这是跟操作系统有关的，在WIN98下所用的进程是共享一个4GB的虚拟内存的，那个就没什么你的我的了，所有的都是大家共有的，所以一个进程对另一个进程发送一个WM_GETEXT消息，应为大家都是自己人所以密码就告你了。但是到了NT后各个进程就闹分家了，每个进程独享4GB的虚拟内存，各个进程之间是互相隔离的，所以就没人理你了。

我们要采用些特殊的手段才能成功。也就是要把你的那段发送WM_GETTEXT消息的代码移到目标进程中去执行，方法还是有的，我使用的远程线程技术，也就是将一个功能模块诸如到目标进程中然后执行，这样就OK了。对于如何进行线程注入，方法很多，google一下就可以了。

原理就是这样很简单，问题就在怎样在目标进程中去执行代码，这种方法就说到这把。

2.屠夫的钩子

呵呵，玩过dota吗，对就是屠夫用的钩子，在windows中同样有钩子，而且也是相当的犀利。

使用钩子相当的简单，就一个API函数 SetWindowsHookEx，不过内涵很丰富，在windows下存在各式各样的钩子，消息钩子，鼠标钩子，键盘钩子，日志钩子，等等，具体的看看MSDN，这些钩子各有各的用途，对于黑客们来说主要会用到消息钩子，键盘钩子与日志钩子，这些钩子都可以用来监控键盘，下面分别来说.

(1)往日黄花—键盘钩子

不要迷恋哥，哥只是个传说。

                                         ------一脑残儿童说

键盘钩子在当年可是相当的辉煌，在那个Rootkit还不是很盛行的年代，各种盗号软件

几乎总是和他联系在一起的，只不过这几年由于所谓的主动防御杀软的出现，这种技术才慢慢的消失.

键盘钩子分为全局钩子与局部钩子。键盘钩子安装之后可以截获所进程的键盘信息。局部钩子只可以截获安装线程的键盘信息。既然要盗号吗，当然是IC卡，IQ卡统统告诉我密码，要大面积撒网，就要安装全局钩子。

键盘钩子也分为两种：普通的键盘钩子与低级键盘钩子。对于这两种钩子的区别我自己在编程中总结的是：低级键盘钩子可以截获一些系统按键，比如Windows健，但是普通的就不行了。我曾经写了个玩Dota时屏蔽Windows健的用的是低级钩子，普通的不行.如果只是拦截个一般的按键两种钩子无所谓了.

具体的编程很简单:调用SetWindwosHookEx函数,参数就填入 WH_KEYBORAD（普通钩子）或者WH_KEYBOARD_LL（低级钩子），然后写个钩子的回调函数，在回调函数里面就可以获取按键的虚拟键码了，在讲虚拟键码经过处理就得到我们想要的了.

再提一点就是关于SHIFT键状态与Caps与Num状态的检测，只要调用GetKeyState函数就可以了，具体的不说了，自己看MSDN吧。

（2）竹林蹊径—日志钩子

日志钩子是用来拦截输入到系统消息队列中的输入消息的钩子，键盘消息既然属于输入消息，那就勾住吧。

用法也是so easy，调用SetWindwosHookEx函数传递WH_JOURNALRECORD参数给他,在他的回调函数里面有个指向EVENTMSG的指针，结构如下：

typedef struct {

    UINT message;

    UINT paramL;

    UINT paramH;

    DWORD time;

    HWND hwnd;

} EVENTMSG, *PEVENTMSG;

我们只拦截message ==WM_KEYDOWN的消息，就是按键按下的消息啦，然后paramL&0x000000FF的值就是虚拟键码，剩下的和键盘钩子就一样了，不说了，下一节吧。

（3）完美的世界---中英文记录的消息钩子

到目前为止我们记录到得都只是些 abc123这些的字母数字，那位小朋友要说了，我要知道他在网上的聊天内容，行吗？消息钩子就站出来了,”no problem,记录中文俺拿手啊

消息钩子，见名知意，肯定是用来过滤消息的。我们先来了解一个概念”IME””.

　IME 是输入法编辑器(Input Method Editor) 的英文缩写(IME)，它是一种专门的应用程序，用来输入代表东亚地区书面语言文字的不同字符。

说白了,我们平时输入汉字时其实都是跟这个IME打交道的。IME也是会发出很多的消息的，如

WM_IME_CHAR                    WM_IME_COMPOSITION

WM_IME_COMPOSITIONFULL       WM_IME_CONTROL

WM_IME_ENDCOMPOSITION        WM_IME_KEYDOWN

WM_IME_KEYUP                   WM_IME_NOTIFY

WM_IME_REQUEST                 WM_IME_SELECT

WM_IME_SETCONTEXT             WM_IME_STARTCOMPOSITION

我们现在主要关心一个消息WM_IME_COMPOSITION，就是当要拼出一个字的时候会发出这个消息.，并且副参数为GCS_RESULTSTR的时候，就说明输入完了，可以将拼出的句子读出来了，这就得到了汉字了.,下面为参考代码:

/* this code from ZWELL 获得输入法处理后的字符串 */

if(pmsg->message==WM_IME_COMPOSITION){

               DWORD dwSize;

               char lpstr[128];

               if(pmsg->lParam & GCS_RESULTSTR){

                      //先获取当前正在输入的窗口的输入法句柄

                      hIMC = ImmGetContext(hWnd);

                      if(!hIMC) return 0;

                      // 先将ImmGetCompositionString的获取长度设为0来获取字符串大小.

                      dwSize = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);

                      // 缓冲区大小要加上字符串的NULL结束符大小,

                      // 考虑到UNICODE

                      dwSize += sizeof(WCHAR);

                      memset(lpstr, 0, sizeof(lpstr));

                      // 再调用一次.ImmGetCompositionString获取字符串

                      ImmGetCompositionString(hIMC, GCS_RESULTSTR, lpstr, dwSize);

                      //现在lpstr里面即是输入的汉字了。你可以处理lpstr,当然也可以保存为文件...

                      //MessageBox(NULL, lpstr, lpstr, MB_OK);

其实在输入汉字的时候也是会发出WM_CHAR与WM_KEYDOWN这些消息的，只不过WM_CHAR的参数与输入英文是是不同的。汉字的输入实际上是两个WM_CHAR，用内码就可以判断是否输入的是否是汉字字符。如果是，汉字两个字节的最高位都是1，连续两次判断就可以做到。即每次的CHAR字符的最高位是否是1，如果是，记住这个字符，然后当下CHAR字符来到是，如果最高位还是1，就可以将这两个字符合成汉字。这样就可以记录一个汉字了。

至于WM_KEYDOWN可以用来记录非ASCII的按键，像F1—F12，TAB，ENTER等等。

这样就是中英文完美的键盘记录了.

(4)用泥巴胡个墙吧.---应用层的抗击

应用层键盘记录的小伎俩就说这几种吧（呵呵，俺也就会这几种）,既然要攻防统一，那我们就来谈谈如何来防御吧。在应用层防御个人感觉很是鸡肋的，实现也很是麻烦，效果也不好，不过还是说说吧，

首先说说全局键盘钩子吧，全局键盘钩子是不能独立存在的，他必须附加一个动态链接库文件，因为全局钩子是要监控所有的进程的，所以这个模块就要注入到其他的进程的地址空间中去，所以要写一个单独的模块。

我们知道在Windows下加载一个模块时使用的API是LoadLibrary函数，这个函数内部又会调用LoadLibraryEx函数，windows底层是UINCODE的，所以应该调用的是LoadLibraryExW。如果我们写的正常程序，如果调用了LoadLibrary那摩LoadLibraryExW函数的返回地址应该位于Kernel32.dll中，或者我们就是直接调用了LoadLibraryExW那摩返回地址应该位于我们的程序中。但是如果是被装了钩子后，当你按下一个健后，系统会下按键焦点程序的地址空间中加载黑客写的键盘记录模块，调用的是LoadLibraryExW，那摩这个函数的返回地址就不是以上的两种情况了，经我是实验是位于user32.dll中。哈哈，根据这一点我们就可以判断一个模块是否为非法加载模块了.

原理就是这样啦。具体的实现要用到APIHook技术了。在《Windwos核心编程》中有简绍的。可以HOOKIAT也可以InLineHook，我用的是InLineHokk，在自己写的HOOk函数中首先获取[ESP]的值，这个就是返回值了，具体为什么应该都明白吧，不明白就找本汇编书好好补补吧。那摩就拿这个返回值去比较就可以了。简单吧。。

当然对于HOOKAPI你也可以用微软的那个Hook库，那就更简单了。

只能检测是不够的，太被动了，我们应该主动出击。

Windows下的钩子逻辑上是一个链状的，一个系统中可以安装很多的钩子，这些钩子会形成一个钩子链，先装的钩子在最前头，前面的钩子通过调用CallNextHookEx函数将信息传给后面的钩子，如不不调用这个函数那摩链子就断了，后面的钩子永远互惠获取信息。

好了，聪明的你一定想到了。对，我们不往下传递信息，我们自己处理，让下面的钩子瞪着眼着急去吧。

具体做法为：我们在我们的程序中装上局部钩子，在局部钩子的回调函数中我们截获按键消息，我们自己存起来，然后再给密码框发个假消息，比如按下了A健，我们用我们的局部钩子截获了A健消息，我们保存起来，然后我们给密码框发个假消息，，就说我们接受到了个B健，然后让不调用那个CallNextHookEx函数，而是直接返回1，这样下面的钩子就game over 了.

好了，应用层的键盘监控与反监控就说这些吧，由于杀毒软件的发展，特别是所谓的牛X主动防御的出现，这些都已进了历史的垃圾堆了，现在是RootKit的时代，打劫也要讲与时俱进，下面我们就来看看ring0下的键盘记录的手段吧。

3.新的战场，新的战斗—rootkit的疯狂

人都是属驴的，不打不逼是不会走的.

                                 ----------俺的一位老师说的

在ring3下猥琐黑客们的安逸被被杀软打破了，生存还是死亡。当然是要生存下去了，怎没办？”TMD,反了，我们要和杀软对着干”。游戏规则被改变了。。黑客软件不在是只做老鼠被杀软这只大猫到处撵这跑，老鼠要吃猫啦。

4.中规中矩----键盘过滤驱动

既然到了内核的领地，那我们就来看看在内核中是如何处理按键消息的，我们从按下一个健到我们在WORD看到这个字母，究竟发生了什么,下面是网上说的:

/*引用自: http://hi.baidu.com/buzztiger/blog/item/a851712b3739c924d52af170.html */

写过windows程序的人都知道，win32程序是基于消息驱动的，其中就有键盘消息，这个消息其实是csrss.exe这个进程发送给应用程序的，而在应用程序中我们可以使用setWindowsHook的方法来获得键盘消息，从而实现改键啊，捕捉用户按键内容。那么csrss.exe这个进程的键盘消息是怎么来的呢？原来csrss.exe中有个win32!RawInputThread这个线程，这个线程通过一个GUID，即GUID_CLASS_KEYBOARD（DEFINE_GUID(GUID_CLASS_KEYBOARD, 0x884b96c3, 0x56ef, 0x11d1, 0xbc, 0x8c, 0x00, 0xa0, 0xc9, 0x14, 0x05, 0xdd)来获得键盘设备栈中PDO的符号链接名。win32!RawInputThread执行到win32k!openDevice，调用zwCreateFile打开设备，然后调用zwReadFile与键盘驱动通信了。它会创建一个IRP_MJREAD的IRP发送给键盘驱动，而键盘驱动通常使这个IRP Pending，这样它就会一直被放在那里等待，等来来自键盘的数据，即win32!RawInputThread这个线程也会一直等待，等待这个读操作的完成。当键盘有键按下时这个IRP将会完成，win32!RawInputThread将对得到的数据进行处理，分发给合适的进程（通常是获得焦点的进程）这时win32!RawInputThread又会立即再调用nt!ZwReadFile要求读入数据，又开始了下一个等待，周而复始

/*引用结束*/

键盘的驱动栈从上到下依次为:kbdclass.sys---ài8042port.sys---àacpi.sys

其中kbdclass.sys为键盘的类驱动，不管是PS/2键盘还是USB键盘都要通过这一层驱动，所以在这一层进行过滤可以有和好的兼容性。

I8042port.sys为PS/2键盘的端口驱动，这个只对PS/2键盘好用，USB键盘他管不了的。

对于键盘的过滤驱动，我选择是在kbdclass.sys进行过滤.

具体做法：

1.使用ObReferenceObjectByName获取”\\Driver\\Kbdclass”所对应的驱动对象。

2.枚举这个驱动对象下的所有设备，并创建一个过滤设备附加上去.

3.主要处理IRP_MJ_READ这个IRP。首先设置一个完成函数，然后向下转发此IRP。

4.在完成函数中就可以获取此次的案件的扫描码了。

5.对于IRP_MJ_POWER, IRP_MJ_PNP也要进行处理.

呵呵，很简单吧，驱动入门级的Hello Wolrd。

5.乾坤大挪移----HOOKIDT与操纵APIC

在前面我们讲到在按下一个键与抬起的时候会触发一个硬件中断，XP下，操作系统回去调用 0x31或0x93中断处理程序区处理。那么我们可不可以自己写一个ISR去接管键盘中断呢,？当然，别忘了，我们是在内核中现在，我们无所不能 。

我们知道在保护模式下是采用IDT进行中断管理的，IDT是有许多门组成的。每个闷得结构如下:

typedef struct IDTEntry

{

HB_U16 LowOffset ;//偏移的低16位

HB_U16 Selector ;//选择子

HB_U8 Count:5; //参数的双字计数

HB_U8 Reserve:3 ;//保留为0

HB_U8 Type:4 ;//类型

HB_U8 DT0:1; //DT=0,系统段描述符

HB_U8 DPL:2; //DLP

HB_U8 P:1; //P位

HB_U16 HightOffset;//偏移的高16位

}IDTEntry,*PIDTEntry;

其中Lowoffset与HighOffset就构成了实际的中断处理程序的地址.。我们如果自己写一个中断处理程序，然后修改Lowoffset与HighOffset，让其指向我们自己的写的那个函数不久可以了吗..

在我们自己的键盘中断处理函数中我们可以直接将数据从i8042的端口读出，存储起来，然后再调用原先的系统默认的函数，这样就神不知鬼不觉的达到的不可告人的目的.

还有一种方法使用的手段于此相似，也是替换，不过这次是将键盘的IRQ1中断的处理函数的中断向量更改，不在是指向0x31或是0x93了，而是指向另一个向量.这个向量包含我们自己的处理程序.，这就是APIC机制.。不过我的这个破笔记本比较老了，没有这个机制，

所以只能纸上谈兵了.,还是先简绍一下APIC吧.

APIC是可以用于多个核心的CPU的新型中断控制器,APIC的作用相当于当一个IRQ发生时，这个硬件决定将IRQ发个呢个CPU核心,以及一何种形式发送等。APIC是可编程的，也可以将PS/2键盘的硬件中断请求发给某个CPU核心，让该核心的IDT中的某个中断号对应的中断服务程序来处理.

Windows将APIC的系列寄存器映射到了地址0xFEC00000和0xFEC00010的位置。

也就是说我们可以通过编程来进行中断的重定位，具体操作看着APIC的说明添添数据就可以了，其实和HOOKIDT一样的。就不多说了.

6.返璞归真—轮询i8042

有时候其实一个问题的解决方法并不是月复杂就越强悍，有时候简单的土的掉渣的技术反而是最稳固的

轮询，这种古老的技术，虽然由于效率低下已经早已被淘汰，但是我们需要的正是这个。

键盘是可以通过编程关闭中断的，但是当我们按下一个健的时候，键盘的输出缓冲区中仍然会有扫描码填充，只是中断关闭了，操作系统并不知道。

我们的做法是：首先关闭键盘的中断，然后通过轮询的方法读取输出端口的案件扫描码，自己进行一些处理，然后打开键盘中断，再将此按键重放，这样操作系统会获取这个按键，然后在关闭中断，一直这样循环下去。

原理就是这样，简单也很可靠，我最终的密码保护就是采用这个方案的。

我的程序分了三个层次:

因为在Ring3下无法读写端口的，所以自己写了个驱动，负责读写端口，RING3上载写个DLL通过DeviceIoControl与内核进行通信，传递端口地址与设置的值等信息,并对上面的应用程序提供简单的如READ_PORT(ULONG port),这样的接口。

在应用程序中，在要保护的密码框获取焦点时(处理WM_SETFOCUS消息),则关闭键盘中断进行轮询,在市区焦点时则打开键盘中断.在获取按键后你可以在程序中记录下来，再在密码框中填充个假的密码。

由于是不间断的轮询所以保证在第一时间获取扫描码，在上层的如过滤驱动，HOOKIDT等

还有应用层得到钩子啥的，统统失效，实践证明还是很可靠的，只不过还不是很完善，目前只支持PS/2键盘，USB的还不行.

7.我们都OUT了----硬件键盘记录器

日防夜防，家贼难防啊，要是硬件上做了手脚，那就这能55555555555……

看看这个猥琐的家伙吧…高科技哦

好了，该结尾了，呵呵，现在你还信你的键盘吗？

指令可用于特权级 3 的用户代码调用特权级 0 的系统内核代码，而 SYSEXIT 指令则用于特权级 0 的系统代码返回用户空间中。sysenter 指

令可以在 3，2，1 这三个特权级别调用（Linux 中只用到了特权级 3），而 SYSEXIT 指令只能从特权级 0 调用。

执行 sysenter 指令的系统必须满足两个条件：1.目标 Ring 0 代码段必须是平坦模式（Flat Mode）的 4GB 的可读可执行的非一致代码段。

2.目标 RING0 堆栈段必须是平坦模式（Flat Mode）的 4GB 的可读可写向上扩展的栈段。

在 Intel 的手册中，还提到了 sysenter/sysexit 和 int n/iret 指令的一个区别，那就是 sysenter/sysexit 指令并不成对，sysenter 指

令并不会把 SYSEXIT 所需的返回地址压栈，sysexit 返回的地址并不一定是 sysenter 指令的下一个指令地址。调用 sysenter/sysexit 指令

地址的跳转是通过设置一组特殊寄存器实现的。这些寄存器包括：

SYSENTER_CS_MSR － 用于指定要执行的 Ring 0 代码的代码段选择符，由它还能得出目标 Ring 0 所用堆栈段的段选择符；

SYSENTER_EIP_MSR － 用于指定要执行的 Ring 0 代码的起始地址；

SYSENTER_ESP_MSR－用于指定要执行的Ring 0代码所使用的栈指针

这些寄存器可以通过 wrmsr 指令来设置，执行 wrmsr 指令时，通过寄存器 edx、eax 指定设置的值，edx 指定值的高 32 位，eax 指定值的

低 32 位，在设置上述寄存器时，edx 都是 0，通过寄存器 ecx 指定填充的 MSR 寄存器，sysenter_CS_MSR、sysenter_ESP_MSR、

sysenter_EIP_MSR 寄存器分别对应 0x174、0x175、0x176，需要注意的是，wrmsr 指令只能在 Ring 0 执行。

这里还要介绍一个特性，就是 Ring0、Ring3 的代码段描述符和堆栈段描述符在全局描述符表 GDT 中是顺序排列的，这样只需知道

SYSENTER_CS_MSR 中指定的 Ring0 的代码段描述符，就可以推算出 Ring0 的堆栈段描述符以及 Ring3 的代码段描述符和堆栈段描述符。

在 Ring3 的代码调用了 sysenter 指令之后，CPU 会做出如下的操作：

1． 将 SYSENTER_CS_MSR 的值装载到 cs 寄存器

2． 将 SYSENTER_EIP_MSR 的值装载到 eip 寄存器

3． 将 SYSENTER_CS_MSR 的值加 8（Ring0 的堆栈段描述符）装载到 ss 寄存器。

4． 将 SYSENTER_ESP_MSR 的值装载到 esp 寄存器

5． 将特权级切换到 Ring0

6． 如果 EFLAGS 寄存器的 VM 标志被置位，则清除该标志

7． 开始执行指定的 Ring0 代码

在 Ring0 代码执行完毕，调用 SYSEXIT 指令退回 Ring3 时，CPU 会做出如下操作：

1． 将 SYSENTER_CS_MSR 的值加 16（Ring3 的代码段描述符）装载到 cs 寄存器

2． 将寄存器 edx 的值装载到 eip 寄存器

3． 将 SYSENTER_CS_MSR 的值加 24（Ring3 的堆栈段描述符）装载到 ss 寄存器

4． 将寄存器 ecx 的值装载到 esp 寄存器

5． 将特权级切换到 Ring3

6． 继续执行 Ring3 的代码

由此可知，在调用 SYSENTER 进入 Ring0 之前，一定需要通过 wrmsr 指令设置好 Ring0 代码的相关信息，在调用 SYSEXIT 之前，还要保证

寄存器edx、ecx 的正确性。

根据 Intel 的 CPU 手册，我们可以通过 CPUID 指令来查看 CPU 是否支持 sysenter/sysexit 指令，做法是将 EAX 寄存器赋值 1，调用

CPUID 指令，寄存器 edx 中第 11 位（这一位名称为 SEP）就表示是否支持。在调用 CPUID 指令之后，还需要查看 CPU 的 Family、Model、

Stepping 属性来确认，因为据称 Pentium Pro 处理器会报告 SEP 但是却不支持 sysenter/sysexit 指令。只有 Family 大于等于 6，Model

大于等于 3，Stepping 大于等于 3 的时候，才能确认 CPU 支持 sysenter/sysexit 指令。

/=============================================================================
//在WINDBG中对NTDLL.dll中的NtCreateFile函数的调试信息
ntdll!NtCreateFile:
7c92d682 b825000000      mov     eax,25h
7c92d687 ba0003fe7f      mov     edx,offset SharedUserData!SystemCallStub (7ffe0300)
7c92d68c ff12            call    dword ptr [edx]
7c92d68e c22c00          ret     2Ch

lkd> dd 7ffe0300
7ffe0300  7c92eb8b 7c92eb94 00000000 00000000

lkd> u 7c92eb8b
ntdll!KiFastSystemCall:
7c92eb8b 8bd4            mov     edx,esp
7c92eb8d 0f34            sysenter

/**************************************************************/
 
SYSENTER简介及相关例子
 
 
文章作者：wowocock1/CVC.GB

;众所周知微软自XP后引进了FASTCALL SYSENTER，SYSEXIT来代替WIN2K下INT2E系统服务调用
;其优点是快速而且没有保留堆栈的开销，为了便于大家理解我写下面一个在WIN98下的例子
;来说明一下这2条指令的用法。ITNEL的手册上关于他们介绍的很详细，我简要说明一下
;SYSENTER是INTEL自P2后引进的快速从RING3~RING0的FASTCALL，从FAMILY 6，MODEL 3，
;STEP 3也就是从PII300以后引进的，这也是为什么WINXP需要PII300以上的原因。在使用SYSENTER
;之前必须定义好RING0 CS EIP ESP，通过设置相应MSR寄存器,由WRMSR指令来设定（必须在RING0层执行）;
;通过将相应的寄存器地址号放入ECX中，WRMSR可以设置这些MSR寄存器,对应关系如下
;SYSENTER_CS_MSR 174H SYSENTER_ESP_MSR 175H SYSENTER_EIP_MSR 176H
;执行SYSENTER指令的系统必须满足 1：转换后的RING0代码段必须是FLAT，4GB的可读可执行
;的非一致代码段.2:转换后的RING0堆栈段必须是FLAT，4GB的可读可写向上扩展的数据段
;由于FASTCALL不保存任何返回的地址，所以在调用前你必须自己设定好，RING0代码段SELECTOR
;RING0堆栈段SELECTOR，RING3代码段SELECTOR，RING3堆栈段SELECTOR，必须在GDT中连续的排列
;所以在XP下相应的SELECTOR，必然是8H，10H，1BH，23H，必须将返回至RING3 EIP,ESP通过寄存器
;传递进RING0以便SYSEXIT返回使用，在SYSEXIT返回之前，EDX为RING3 EIP，ECX为RING3 ESP
;而相应的CS，SS，则由RING0 CS加上10H，18H来返回
;RING3~RING0
;1. 装载SYSENTER_CS_MSR 到CS 寄存器.
;2. 装载SYSENTER_EIP_MSR到 EIP寄存器。
;3. SYSENTER_CS_MSR+8 装载到SS寄存器
;4.装载SYSENTER_ESP_MSR 到ESP寄存器。
;5. 切换RING0.
;6. 清除 EFLAGS的 VM标志
;7. 执行RING0例程
;RING0~RING3
;1。SYSENTER_CS_MSR+16装载到 CS寄存器
;2. 将EDX的值送入EIP
;3. SYSENTER_CS_MSR+24 装载到SS寄存器
;4. 将ECX的值送入ESP
;5.切换回RING3
;6. 执行EIP处的RING3指令
;下面的例子在示范的基础上加了个小TRICK，就是在通过CALLGATE进RING0设置MSR寄存器的同时
;关掉了你机器上的缓存，然后你可以看看在没有缓存的情况下你的感觉如何，然后点击一下
;对话框，则经由SYSENTER指令进入RING0设定好的地址处恢复你CPU缓存，所以别担心，还有
;没有缓存的时候你的动作最好慢一点，不然会让你等的发疯的，呵呵。
.686p
.model flat,stdcall
option casemap:none

include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc

includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib

sysenter macro
db 0fh,34h
endm

sysexit macro
db 0fh,35h
endm

CR0_CD EQU 040000000h ; Cache Disable bit of CR0
CR0_NW EQU 020000000h ; Not Write-through bit of CR0
.data
Ring0Cs dw 0ffffh,0,09b00h,0cfh
Ring0Ss dw 0ffffh,0,09300h,0cfh
Ring3Cs dw 0ffffh,0,0fb00h,0cfh
Ring3Ss dw 0ffffh,0,0f300h,0cfh

trR dw ?
tssRing0Esp dd ?
GdtLimit dw ?
GdtAddr dd ?

Callgt dq 0 ;call gate’s selff
tmpCs dw ?
szTitle db "CPU info",0
msg db 100 dup (?)
Nightmare db "切换到其他窗口，尝尝没CACHE的滋味!",0

.code
Start:
mov ax,ds
test ax,4
jz Exit;winnt
xor eax,eax
cpuid
lea edi,msg
xchg eax,ebx
stosd
xchg eax,edx
stosd
xchg eax,ecx
stosd
invoke MessageBoxA,0,addr msg,addr szTitle,0
mov eax,1
cpuid
test edx,800h
jz Exit
mov eax,2
cpuid
SetSel:
sgdt GdtLimit
str word ptr trR ;存储任务寄存器
;-----------------------
; get the tr mes
;-----------------------
movzx esi,trR
add esi,GdtAddr   ;ESi指向GDT中TSS描述副
mov eax,[esi+2]
and eax,0ffffffh
mov ebx,[esi+4]
and ebx,0ff000000h
or eax,ebx    ;eax中保存TSS的基地址

push dword ptr[eax+4]
pop dword ptr [tssRing0Esp] ;保存RING0使用的堆栈地址

movzx eax,GdtLimit ;在GDT的最后选取四个表目将预设的4个描述符存入
test al,1
jz @f
inc eax
@@:
sub eax,4*8
mov tmpCs,ax
add eax,GdtAddr
lea esi,Ring0Cs
mov edi,eax
mov ecx,4*8
rep movsb

SetMsr:
;-------------------------------------
; 在GDT中寻找空白表项来制造调用门
;-------------------------------------
mov esi,GdtAddr
movzx eax,GdtLimit
call Search_XDT
;esi==gdt Base
mov esi,dword ptr GdtAddr
push offset Ring0_SetMsr
pop word ptr [esi+eax+0]
pop word ptr [esi+eax+6] ;Offset

mov word ptr [esi+eax+2],28h
mov word ptr [esi+eax+4],0EC00h ;sel=28h and attribute ->386 call gate!

and dword ptr Callgt,0

mov word ptr [Callgt+4],ax
pushad
call fword ptr [Callgt] ;Ring0!
popad
mov dword ptr [esi+eax+0],0
mov dword ptr [esi+eax+4],0

invoke MessageBoxA,0,addr Nightmare,addr Nightmare,0
lea edx,Exit
mov ecx,esp
sysenter

Exit:
push 00000000h ; Exit program
call ExitProcess

;----------------------------------------------------------------------

Ring0_SetMsr:
mov ecx,174h
movzx eax,tmpCs
wrmsr
inc ecx
mov eax,tssRing0Esp
wrmsr
inc ecx
lea eax,Ring0Ip
wrmsr

mov eax,cr0 ; read CR0
or eax,CR0_CD ; set CD but not NW bit of CR0
mov cr0,eax ; cache is now disabled
wbinvd ; flush and invalidate cache

; the cache is effectively disabled at this point, but memory
; consistency will be maintained. To completely disable cache,
; the following two lines may used as well:

or eax,CR0_NW ; now set the NW bit
mov cr0,eax ; turn off the cache entirely

retf

;----------------------------------------------------------------------
Ring0Ip:
pushad

pushf ; save the flags
cli ; disable interrupts while we do this
mov eax,cr0 ; read CR0
and eax,0dfffffffh ; now set the NW bit
mov cr0,eax ; turn on the cache entirely

and eax,0bfffffffh ; set CD but not NW bit of CR0
mov cr0,eax ; cache is now Ensabled

popf ; restore the flags

mov eax,cr0
mov [esp+4*7],eax
popad
sysexit

;----------------------------------------------------------------------

Search_XDT proc near
;entry esi==Base of Ldt or GDT ;Eax==Limit

pushad
mov ebx,eax
mov eax,8 ; skipping null selector
@@1:
cmp dword ptr [esi+eax+0],0
jnz @@2
cmp dword ptr [esi+eax+4],0
jz @@3
@@2:
add eax,8
cmp eax,ebx
jb @@1 ;if we haven’t found any free GDT entry,
;lets use the last two entries
mov eax,ebx
sub eax,7
@@3:
mov [esp+4*7],eax ; return off in eax
popad
ret
Search_XDT endp
end Start

;=======================================================================================================
1   【原创】rootkit hook之[六] -- sysenter Hook    

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

标 题: 【原创】rootkit hook之[六] -- sysenter Hook
作 者: combojiang
时 间: 2008-02-26,12:25
链 接: http://bbs.pediy.com/showthread.php?t=60247

呵呵，今天这篇内容少，比较简单。

SYSENETER是一条汇编指令，它是在Pentium? II 处理器及以上处理器中提供的，是快速系统调用的一部分。SYSENTER/SYSEXIT这对指令专门用于实现快速调用。在这之前是采用INT 0x2E来实现的。INT 0x2E在系统调用的时候，需要进行栈切换的工作。由于Interrupt/Exception Handler的调用都是通过 call/trap/task这一类的gate来实现的，这种方式会进行栈切换，并且系统栈的地址等信息由TSS提供。这种方式可能会引起多次内存访问 （来获取这些切换信息），因此，从PentiumII开始，IA-32引入了新指令：SYSENTER/SYSEXIT。 有了这两条指令，
从用户级到特权级的堆栈以及指令指针的转换，可以通过这一条指令来实现，并且，需要切换到的新堆栈的地址，以及相应过程的第一条指令的位置，都有一组特殊寄存器来实现，这类特殊寄存器在IA-32中称为MSR(Model Specific Register)。这里牵涉到3个特殊寄存器：
SYSENTER_CS_MSR: New code segment selector   0x174
SYSENTER_ESP_MSR: New Stack Pointer                0x175
SYSENTER_EIP_MSR: New Instruction Pointer        0x176
这里标出的3个16进制数分别对应这3个寄存器的地址，该地址用于Kernel debug时，通过rdmsr/wrmsr指令来读/写这3个寄存器。步骤如下：
10.JPG
1. 装载SYSENTER_CS_MSR 到CS 寄存器，设置目标代码段
2. 装载SYSENTER_EIP_MSR到 EIP寄存器，设置目标指令
3. SYSENTER_CS_MSR+8 装载到SS寄存器 ，设置栈段
4. 装载SYSENTER_ESP_MSR 到ESP寄存器，设置栈帧
5. 切换RING0.
6. 清除 EFLAGS的 VM标志
7. 执行RING0例程

11.JPG
1. SYSENTER_CS_MSR+16装载到 CS寄存器
2. 将EDX的值送入EIP
3. SYSENTER_CS_MSR+24 装载到SS寄存器
4. 将ECX的值送入ESP
5. 切换回RING3
6. 执行EIP处的RING3指令

我们在windbg中可以看看这个三个寄存器的情况，这个是我机器里的情况。
lkd> rdmsr 176
msr[176] = 00000000`8053dad0
lkd> rdmsr 175
msr[175] = 00000000`ba4e0000
lkd> rdmsr 174
msr[174] = 00000000`00000008

可以看到，我的机器里面当前SYSENTER_EIP_MSR，SYSENTER_ESP_MSR，SYSENTER_CS_MSR这三个寄存器的值。

我们在微软公开的内核WRK中发现关于这三个寄存器的设置，其中SYSENTER_EIP_MSR设置的值是KiFastCallEntry。
代码如下：
VOID
KiLoadFastSyscallMachineSpecificRegisters(
    IN PLONG Context
    )

/*++

Routine Description:

    Load MSRs used to support Fast Syscall/return.  This routine is
    run on all processors.

Arguments:

    None.

Return Value:

    None.

--*/

{
    PKPRCB Prcb;

    UNREFERENCED_PARAMETER (Context);

    if (KiFastSystemCallIsIA32) {

        Prcb = KeGetCurrentPrcb();

        //
        // Use Intel defined way of doing this.
        //

        WRMSR(MSR_SYSENTER_CS,  KGDT_R0_CODE);
        WRMSR(MSR_SYSENTER_EIP, (ULONGLONG)(ULONG)KiFastCallEntry);
        WRMSR(MSR_SYSENTER_ESP, (ULONGLONG)(ULONG)Prcb->DpcStack);

    }
}

看看我电脑的情况如下：
lkd> rdmsr 176
msr[176] = 00000000`8053dad0
lkd> u 8053dad0
nt!KiFastCallEntry:
8053dad0 b923000000      mov     ecx,23h
8053dad5 6a30            push    30h
8053dad7 0fa1            pop     fs
8053dad9 8ed9            mov     ds,cx
8053dadb 8ec1            mov     es,cx
8053dadd 8b0d40f0dfff    mov     ecx,dword ptr ds:[0FFDFF040h]
8053dae3 8b6104          mov     esp,dword ptr [ecx+4]
8053dae6 6a23            push    23h

下面是rootkit.com上的一个例子，这个例子有点不厚道，在你卸载的时候会bsod.我简单修改了下，贴代码如下：
#include "ntddk.h"

ULONG d_origKiFastCallEntry; // Original value of ntoskrnl!KiFastCallEntry

VOID OnUnload( IN PDRIVER_OBJECT DriverObject )
{
    _asm
    {
          mov ecx, 0x176
        xor edx,edx
        mov eax, d_origKiFastCallEntry     // Hook function address
        wrmsr                        // Write to the IA32_SYSENTER_EIP register
      }
}

// Hook function
__declspec(naked) MyKiFastCallEntry()
{
  __asm {
    jmp [d_origKiFastCallEntry]
  }
}

NTSTATUS DriverEntry( IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING theRegistryPath )
{
  theDriverObject->DriverUnload  = OnUnload;

  __asm {
            mov ecx, 0x176
        rdmsr                 // read the value of the IA32_SYSENTER_EIP register
        mov d_origKiFastCallEntry, eax
        mov eax, MyKiFastCallEntry     // Hook function address
        wrmsr                        // Write to the IA32_SYSENTER_EIP register
  }

  return STATUS_SUCCESS;
}

注意一点，大家用windbg的时候，配置symbol path,如图：
9.JPG

后面贴上一篇堕落天才写的文章链接：http://bbs.pediy.com/showthread.php?t=42705，
他inline hook 了KiFastCallEntry，采用detour方式,写得很不错。

上传的附件 SysEnterHook.rar (973 字节, 743 次下载) 
 
;=====================================================================================================================
   【原创】另一种sysenter hook方法(绕过绝大多数的rootkit检测工具的检测)   

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

标 题: 【原创】另一种sysenter hook方法(绕过绝大多数的rootkit检测工具的检测)
作 者: 堕落天才
时 间: 2007-04-14,11:09
链 接: http://bbs.pediy.com/showthread.php?t=42705

*****************************************************************************
*标题:【原创】另一种sysenter hook方法(绕过绝大多数的rootkit检测工具的检测)  *
*作者:堕落天才                                                              *
*日期:2007年4月14号                                                         *
*****************************************************************************

    先废话,当初是为了绕开NP对sysenter保护而想出来的,后来发现连RootkitUnhooker都绕了.

    什么是sysenter hook我也不罗唆了,一般的拦截方法就是通过rdmsr wrmsr 两个指令把原来的sysenter地址改成自己的sysenter地址来实现的.这种方法使用方便,但检测也很容易.
    这里介绍的另外一种方法不改变sysenter地址,而是通过直接在原来sysenter地址里面写跳转代码来实现的,这实际上跟一般的函数头inline hook一样.这样rootkit检测工具就不会认为sysenter已经改变(实际上也是没变).
    一般的rootkit检测工具检测函数inline hook是通过检测长跳转指令0xE9的来判断跳转距离是不是超出函数所在的模块范围来确定的.但是实现跳转我们也可以借助寄存器或变量(用变量跳转需要涉及重定位问题,麻烦.所以一般用寄存器),这样跳转指令就不是0xE9了而是0xFF,这个绝大多数rootkit检测工具是检测不到的(包括著名的RootkitUnhooker,VICE).

    由于我们已经改变了KiFastCall函数头,所以我们只能把原来的函数头代码放到另外一个地方执行(动态分配内存,当然如果不考虑兼容性硬编码也没问题),然后再跳转回来.这里使用了"三级跳",大概是这个样子.
    sysenter->KiFastCall
             JMP -> MyKiFastCall(这里进行拦截或什么的)
                    JMP -> KiFastCall head code (这里执行原来KiFastCall函数头代码)
                           JMP -> KiFastCall + N(已经执行指令长度)
/////////////////////////////////////////////////////////////////////////////////////////////////// 
//堕落天才
//2007年4月14日
#include<ntddk.h>
#include "OpCodeSize.h"

ULONG uSysenter;           //sysenter地址
UCHAR uOrigSysenterHead[8];//保存原来的八个字节函数头
PUCHAR pMovedSysenterCode; //把原来的KiFastCall函数头保存在这里
ULONG i;                   //记录服务ID
__declspec(naked) void MyKiFastCallEntry(void)
{
  __asm{
            pop  edi     //因为用到了edi来跳转 这里恢复
             mov  i, eax  //得到服务ID
  }
  __asm{ 
           pushad
           push fs
             push 0x30
            pop fs
  }
 
  DbgPrint("sysenter was hooked! Get service ID:%X",i); //证明自己存在

  __asm{
             pop fs
             popad   
    jmp pMovedSysenterCode //第二跳,跳转到原来的函数头代码
  }
 
}
//////////////////////////////////////////////////////
VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{   
  __asm{
    cli
             mov  eax,cr0
    and  eax,not 10000h
    mov  cr0,eax
  }

  memcpy((PVOID)uSysenter,uOrigSysenterHead,8);//把原来函数头的八个字节恢复

  __asm{
    mov  eax,cr0
            or   eax,10000h
    mov  cr0,eax
    sti
  }
  ExFreePool(pMovedSysenterCode); // 释放分配的内存
  DbgPrint("Unload sysenterHook");
}
////////////////////////////////////////////////////////

VOID HookSysenter()
{
  UCHAR  cHookCode[8] = { 0x57,          //push edi       第一跳,从KiFastCall跳到MyKiFastCallEntry.并绕过rootkit检测工具检测
                          0xBF,0,0,0,0,  //mov  edi,0000
                          0xFF,0xE7};    //jmp  edi

  UCHAR  JmpCode[]={0xE9,0,0,0,0};       //jmp 0000 第三跳,从KiFastCall函数头代码跳转到原来KiFastCall+N

  int    nCopyLen = 0;
  int    nPos = 0;

  __asm{
          mov ecx,0x176
            rdmsr
    mov uSysenter,eax  //得到KiFastCallEntry地址
  }
  DbgPrint("sysenter:0x%08X",uSysenter);

  nPos = uSysenter;
   while(nCopyLen<8){ //我们要改写的函数头至少需要8字节 这里计算实际需要COPY的代码长度 因为我们不能把一条完整的指令打断
    nCopyLen += GetOpCodeSize((PVOID)nPos);  //参考1
    nPos = uSysenter + nCopyLen;
  }
 
  DbgPrint("copy code lenght:%d",nCopyLen);

  pMovedSysenterCode = ExAllocatePool(NonPagedPool,20);

  memcpy(uOrigSysenterHead,(PVOID)uSysenter,8);//备份原来8字节代码

  *((ULONG*)(JmpCode+1)) = (uSysenter + nCopyLen) - ((ULONG)pMovedSysenterCode + nCopyLen)- 5;//计算跳转地址

  memcpy(pMovedSysenterCode,(PVOID)uSysenter,nCopyLen); //把原来的函数头放到新分配的内存
  memcpy((PVOID)(pMovedSysenterCode + nCopyLen),JmpCode,5); //把跳转代码COPY上去

  *((ULONG*)(cHookCode+2)) = (ULONG)MyKiFastCallEntry; //HOOK地址
 
  DbgPrint("Saved sysenter code:0x%08X",pMovedSysenterCode);
  DbgPrint("MyKiFastCallEntry:0x%08X",MyKiFastCallEntry);

  __asm{
    cli
            mov  eax,cr0
    and  eax,not 10000h
    mov  cr0,eax
  }

  memcpy((PVOID)uSysenter,cHookCode,8);//把改写原来函数头

  __asm{
    mov  eax,cr0
            or   eax,10000h
    mov  cr0,eax
    sti
  }

}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,PUNICODE_STRING RegistryPath)
{

  DbgPrint("Welcome to sysenterhook.sys");
  DriverObject->DriverUnload = OnUnload;
  HookSysenter();
  return STATUS_SUCCESS;
}   
///////////////////////////////////////////////////////////////////////////////////////////////////
以上代码在 XP SP2中文 + RootkitUnhooker下测试通过

同理 IDT hook也可以用这种方法实现,HOOK的实质是改变程序流程,无论在哪里改变
*************************************************************************************************
参考1, 海风月影,【分享】西裤哥的 Hook Api Lib 0.2 For C 

;http://bbs.pediy.com/showthread.php?p=420864
 
 

【一】.在 __asm block中使用汇编语言

1.关键字__asm调用内联汇编语句
有三种方式可用
（1）__asm block 形式
例子：
// asm_overview.cpp
// processor: x86
void __declspec(naked) main()
{
    // Naked functions must provide their own prolog...
    __asm {
        push ebp
        mov ebp, esp
        sub esp, __LOCAL_SIZE
    }
   
    // ... and epilog
    __asm {
        pop ebp
        ret
    }
}

（2）将__asm放在每句汇编指令的开头
例子：
__asm push ebp
__asm mov  ebp, esp
__asm sub  esp, __LOCAL_SIZE

（3）应为__asm 也是一个语句分隔符，所以可以将汇编指令放在同一行上
例子：
__asm push ebp   __asm mov  ebp, esp   __asm sub  esp, __LOCAL_SIZE

2.内联汇编指令集
VC++编译器支持Pentium 4 和 AMD Athlon的所有指令，额外的被其他目标处理器支持的指令
能够被创造用_emit 伪指令。
附：_emit 伪指令说明
_emit伪指令的MASM的DB指令相似，你能够使用_emit在代码段（text segment）的当前位置
去定义一个字节的立即数。_emit 一次只能定义一个字节，并且仅仅能够再代码段（text segment）
内定义。

例子：
#define randasm __asm _emit 0x4A __asm _emit 0x43 __asm _emit 0x4B
 .
 .
 .
__asm {
     randasm
     }

3.再内联汇编中的MASM表达式
内联汇编能够使用任何的MASM的表达式，能够使任何操作数和操作码的组合。

4.内联汇编中的数据指令和操作
尽管__asm block能够引用C/C++的数据类型和对象(object)，但是他不能定义数据对象用MASM的指令和操作,尤其，不能使用

DB,DW,DD,DQ,DT,DF 或者DUP,THIS。MASM中结构体和记录类型也是不可用的，内联汇编不接受STRUC,RECORD,WIDTH,MASK操作.

5.EVEN 和 ALIGN 指令
尽管内联汇编不支持大多数MASM的指令，但是支持EVEN 和 ALIGN 指令，这两个指令填充NOP在汇编代码中去对其数据和指定的边界,这样能够

CUP的数据访问更加高效.

6.内联汇编中的MASM宏指令
内联汇编不支持MAsm中的宏指令（MACRO, REPT, IRC, IRP, ENDM）或者宏操作符(<>, !, &, %, .TYPE)。

7.内联汇编中的段引用
再内联汇编中指定一个段只能通过寄存器，而不能通过名字（例如，段名_TEXT是不可用的），段超越必须显式的使用寄存器，如ES:[BX].

8.内联汇编中的类型和变量尺寸问题
LENGTH, SIZE 和 TYPE 操作符有一个限定的意义再内联汇编中，他们不能被使用和DUP一起(因为再内联汇编中不能使用DUP命令),但是能够使

用他们去得到C/C++变量的尺寸和类型.
*LENGTH 操作符返回一个数组的元素数目，非数组变量返回1.
*Size 操作符返回C/C++变量的尺寸，一个变量的尺寸是LENGTH与TYPE相乘的结果.
*TYPE 操作符返回C/C++类型或变量的尺寸，如果是一个数组变量返回数组中单个元素的TYPE.

例子：
int arr[8];
__asm                   C                        Size 
LENGTH arr       sizeof(arr)/sizeof(arr[0])      8
SIZE arr         sizeof(arr)                    32
TYPE arr         sizeof(arr[0])                 4

9.内联汇编的注释问题
再__asm block 中可以使用汇编语言的注释
例子：
__asm mov ax, offset buff ; Load address of buff

【二】.再__asm block 中使用C/C++
概述：应为内联汇编能够与C/C++语句混合使用，他梦能够使用C/C++的变量通过名字,还有C/C++语言的其他元素.
*符号，包括标号，变量，函数名.
*常量，包括符号常量和枚举（enum）
*宏，预处理命令
*注释（包括 /**/和//）
*类型名称
*typedef名称，一般都和PTR和TYPE一起使用或者去指定结构体或联合成员

1.在 __asm block 中使用操作符
再 __asm block 中不能使用 C/C++特有的操作符，例如<<。C/C++与汇编共用的操作符，如*，是被解释为汇编操作符。
举个例子来说，[]操作符在C语言里被解释为数组的下标， C能够自动的转换数组元素的尺寸,解释为首地址+单个元素的长度*方括号内的值.
但是再__asm block中，他被看做 MASM索引操作符(index operator),解释为首地址+方括号中的值.
下面的实例显示了他们的不同。
int array[10];

__asm mov array[6], bx ;  Store BX at array+6 (not scaled)

array[6] = 0;         /* Store 0 at array+24 (scaled) */

能够使用TYPE操作符去达到和C同样的效果
__asm mov array[6 * TYPE int], 0 ; Store 0 at array + 24

array[6] = 0;                   /* Store 0 at array + 24 */

2.使用C/C++符号在__asm block 中
__asm块能够引用 C/C++在作用域中的符号（包括变量名，函数名，标号,不能调用C++的成员函数）

在使用C/C++符号时有一些限制:
*每条汇编语句仅仅能够包含一个C/C++的符号。在LENGTH, TYPE, 和 SIZE表达式中则可以使用多个C/C++符号。
*在__asm block中函数引用必须先声明。否则编译器不能区别在__asm block 中的标号与函数名.
*不能使用与MASM保留字相同的符号名称（无论大小写）。
*结构体和联合类型不能别识别在__asm block中.

3.访问C/C++数据在__asm block中
在内联汇编中通过名称访问C/C++变量是十分方便的。在__asm block中能访问任何在作用域中符号。
例如，在其作用域中有一个C变量 var， __asm MOV EAX,var 存储var的值在EAX中。

如果一个类，结构体或者联合结构的成员是唯一的，在__asm block中引用他仅仅使用成员变量名，
而不用使用变量名或者typedef名在.操作符之前。如果成员名不是唯一的，无论如何，必须放置变量名或者typedef名在.操作符之前。
例子：
// InlineAssembler_Accessing_C_asm_Blocks.cpp
// processor: x86
#include <stdio.h>
struct first_type
{
   char *weasel;
   int same_name;
};
struct second_type
{
   int wonton;
   long same_name;
};
int main()
{
   struct first_type hal;
   struct second_type oat;
   __asm
   {
      lea ebx, hal
      mov ecx, [ebx]hal.same_name ; Must use 'hal'
      mov esi, [ebx].weasel       ; Can omit 'hal'
   }
   return 0;
}

在 __asm block中能够访问C++ 的数据成员而不用去遵守访问限制，但是不能调用C++的成员函数.

4.使用内联汇编写函数
略。没啥好讲的，直接看例子
int power2( int num, int power )
{
   __asm
   {
      mov eax, num    ; Get first argument
      mov ecx, power  ; Get second argument
      shl eax, cl     ; EAX = EAX * ( 2 to the power of CL )
   }
   // Return with result in EAX
}

5.使用和保存寄存器在内联汇编中
一般来说，不应该假设寄存器将会有一个指定的值在__asm blok块开始时，寄存器的值不保证在离开了一个__asm block后被保存,如果你离开

了一个asm块并开始了另一个asm块，不应该应用在上一个块中保存寄存器的值。An __asm block inherits whatever register values result

from the normal flow of control.
如果使用__fastcall调用约定，编译器传递参数使用寄存器而不是堆栈，这可能产生一个问题在应用了__asm block的函数中，因为函数无法知

道那个参数是在寄存器中。如果一个函数接受参数在EAX中，但是过后别立刻用来存储其他的值，那摩这个原始的参数就丢失了。并且，在

__fastcall约定中，必须保存ECX寄存器的值。
去避免如此的寄存器冲突，不要使用__fastcall调用约定为那些包含__asm block的函数,如果使用/Gr编译器选项指定了全局的__fastcall约定

，那摩定义每个包含__asm block的函数用_stdcall或__cdecl。
当使用__asm去写汇编语句在C/C++中，不需要去保存EAX,EBX,ECX,EDX,ESI,EDI。在使用EBX,ESI,EDI时，你强迫编译器去保存并回复这些寄存

器的值在函数的序言与结尾处.
也应该保存使用的其他寄存器（如DS,SS,SP,BP,EFLAGS）对于这个__asm block的作用域.
也应该保存ESP和EBP除非你有其他的改变他们的原因。（例如，堆栈转换）

下面这段不太好翻译，自己看吧：
Some SSE types require eight-byte stack alignment, forcing the compiler to emit dynamic stack-alignment code. To be able to

access both the local variables and the function parameters after the alignment, the compiler maintains two frame pointers.

If the compiler performs frame pointer omission (FPO), it will use EBP and ESP. If the compiler does not perform FPO, it will

use EBX and EBP. To ensure code runs correctly, do not modify EBX in asm code if the function requires dynamic stack

alignment as it could modify the frame pointer. Either move the eight-byte aligned types out of the function, or avoid using

EBX.
注意:如果在__asm block中改变了方向标志，通过STD,CLD，那摩就要保存这些标志的原始值.

6.在内联汇编中跳转到指定标号
像一般的 C/C++标号，在__asm block有函数作用域（在整个函数中可见，而不仅仅是在定义的__asm block中）,汇编指令与goto语句都能跳到

标号处.
定义在__asm block中的标号不是大小写敏感的，goto语句与汇编指令能够引用整个标号而不用考虑大小写。但是C/C++代码中的标号是大小写

敏感的当使用goto语句时,使用汇编语句不用考虑大小写问题.
例子：
void func( void )
{
   goto C_Dest;  /* Legal: correct case   */
   goto c_dest;  /* Error: incorrect case */

   goto A_Dest;  /* Legal: correct case   */
   goto a_dest;  /* Legal: incorrect case */

   __asm
   {
      jmp C_Dest ; Legal: correct case
      jmp c_dest ; Legal: incorrect case

      jmp A_Dest ; Legal: correct case
      jmp a_dest ; Legal: incorrect case

      a_dest:    ; __asm label
   }

   C_Dest:       /* C label */
   return;
}
int main()
{
}

在__asm block中不要使用C库的函数名作为标号名称。
 BAD TECHNIQUE: using library function name as label
jne exit
   .
   .
   .
exit:
   ; More __asm code follows

在MASM中（$）符号作为当前的地址计数（current location counter）。他是当前正在被编译的指令的标号.在__asm block 中他的主要作用

是去作为一个长的条件跳转.
jne $+5 ; next instruction is 5 bytes long
jmp farlabel
; $+5
   .
   .
   .
farlabel:

【三】.在内联汇编中调用C函数
一个__asm block能够调用C函数，包括C库函数。下面是调用printf的例子：
// InlineAssembler_Calling_C_Functions_in_Inline_Assembly.cpp
// processor: x86
#include <stdio.h>

char format[] = "%s %s\n";
char hello[] = "Hello";
char world[] = "world";
int main( void )
{
   __asm
   {
      mov  eax, offset world
      push eax
      mov  eax, offset hello
      push eax
      mov  eax, offset format
      push eax
      call printf
      //clean up the stack so that main can exit cleanly
      //use the unused register ebx to do the cleanup
      pop  ebx
      pop  ebx
      pop  ebx
   }
}

【四】.定义__asm block作为宏
C语言的宏提供了一个简便的方式去插汇编代码进入源代码。但是那需要额外的小心因为宏被扩展到一个单独的逻辑行上（a single logical

line），去创建无错误的宏，应遵守下列规则:
*用{}包围__asm block
*放__asm 关键字在每条汇编指令的开头
*使用老式的注释(/**/)代替汇编中的注释(;)和单行注释(//).

例子:
#define PORTIO __asm      \
/* Port output */         \
{                         \
   __asm mov al, 2        \
   __asm mov dx, 0xD007   \
   __asm out dx, al       \
}

一个__asm block写的宏能够带参数，但是不能返回值，因此不要使用这样的宏在C/C++表达式中.

【五】.内联汇编的优化问题
__asm block的存在会对优化产生一些影响。首先，编译器不会尝试去优化__asm block中的指令。第二，__asm block会对寄存器变量的存储产

生影响，编译器会避免去登记穿越__asm block的那些寄存器会被修改的变量.

今天在网上看了一篇关于C++虚函数表的文章，让我对C++又有了更深了的理解，文章链接：http://www.51cto.com/art/200712/62673_2.htm

在这篇文章中讲到了通过虚函数表访问私有的虚函数的问题，问题就出在C++在虚函数表中保存了虚函数的地址，而这个地址又很方便查找。
在每个C++对象实例的开头存储这这个对象的虚函数表的指针，通过这个指针可找到虚函数表，在虚函数表中就存着虚函数指针，这样我们就可以骗过编译器访问私有的虚函数了。

 1class base
 2{
 3private:
 4    virtual    void f(){cout<<"base_f()"<<endl;}
 5};
 6class child:public base
 7{
 8private:
 9    virtual void f(){cout<<"child_f()"<<endl;};
10    void g(){cout<<"base_g()"<<endl;}
11    
12};
13void main()
14{
15    typedef void(*Fun)(void);
16    child b;
17    Fun pFun;
18    pFun = (Fun)*((int*)*(int*)(&b));
19    pFun();
20}

Bill Joy, 前任Sun的首席科学家，当年在Berkeley时主持开发了最早版本的BSD。他还是vi和csh的作者。当然，Csh Programming Considered Harmful 是另一个话题乐。据说他想看看自己能不能写个操作系统，就在三天里写了个自己的Unix, 也就是BSD的前身。当然是传说了，但足见他的功力。另一个传说是，1980年初的时候，DARPA让BBN在Berkley Unix里加上BBN开发的TCP/IP代码。但当时还是研究生的B伯伯怒了，拒绝把BBNTCP/IP加入BSD，因为他觉得BBN的TCP/IP写得 不好。于是B伯伯出手了，端的是一箭封喉，很快就写出了高性能的伯克利版TCP/IP。当时BBN和DARPA签了巨额合同开发TCP/IPStack， 谁知他们的代码还不如一个研究生的好。于是他们开会。只见当时B伯伯穿个T-shirt出现在会议室(当时穿T-shirt不象现在，还是相当散漫的 哈)。只见BBN问：你怎么写出来的？而B伯伯答：简单，你读协议，然后编程就行了。最令偶晕倒的是，B伯伯硕士毕业 后决定到工业界发展，于是就到了当时只有一间办公室的Sun, 然后他就把Sparc设计出 来乐。。。象这种软硬通吃的牛人，想不佩服都不行的说。据Bill Joy的同事说，一般开会的时候B伯伯总是拿一堆杂志漫不经心地读。但往往在关键之处，B伯伯发言，直切要害，提出 漂亮的构想，让同事们彻底崩溃。对了，他还是Java Spec和JINI的主要作者之一。

John Carmack John Carmack，id Software的founder和Lead Programmer。上个月和一个搞图形的师兄聊天，他竟然不知道John Carmack, 也让偶大大地晕了一把。不过也许搞研究的和搞实战的多少有些隔吧。想必喜欢第一人称射击游戏的都知道J哥哥。90年代初只要能在PC上搞个小动画都能让人 惊叹一番的时候，J哥哥就推出了石破天惊的Castle Wolfstein, 然后再接再励，doom, doomII, Quake...每次都把3-D技术推到极致。J哥哥的简历上说自己的专长是"Exhaust 3-D technology"，真是牛人之言不我欺的说。做J哥哥这样的人是很幸福的，因为各大图形卡厂家一有了新产品就要向他“进贡” ，不然如果他的游戏不支持哪种卡，哪种卡基本就会夭折乐。当初MS的Direct3D也得听取 他的意见，修改了不少API。当然，J哥哥在结婚前十数年如一日地每天编程14小时以上， 也是偶们凡人望尘莫及的。对了，J哥哥高中肆业(？)，可以说是自学成才。不过呢，谁要用这个例子来为自己学习不好辩护，就大错特错了。那 Leonardo Da Vinci还是自学成才呢(人是私生子，不能上学)。普通人和天才还是有区别的。对了，其实偶们叫“达分奇”是相当不对的，因为Vinci是地名，而Da Vinci就是从Vinci来的人的意思。换句话说，Leonardo Da Vinci就是“从Vinci来的Leonardo”的意思。叫别人“Da Vinci”就不知所谓乐。嗯，扯远了，打住。

David Cutler David Cutler，VMS和Windows NT的首席设计师，去微软前号称硅谷最牛的kernel开发员。当初他和他的手下在微软一周内把一个具备基本功能的bootable kernel写出来，然后说：“who can't write an OS in a week?"，也是牛气冲天的说。顺便说一句，D爷爷到NT3.5时，管理1500名开发员，自己还兼做设计和编程，不改coder本色啊。D爷爷天生脾 气火爆，和人争论时喜欢双手猛击桌子以壮声势。:-) 日常交谈F-word不离口。他面试秘书时必问："what do you think of the word '****'?" ，让无数美女刹羽而归。终于有一天，一个同样火爆的女面对这个问题脱口而出："That's my favorite word"。于是她被录取乐，为D爷爷工作到NT3.5发布。

Donald E. Knuth Don Knuth。高爷爷其实用不着偶多说。学编程的不知道他就好像学物理的不知道牛顿，学数学的不知道欧拉，学音乐的不知道莫扎特，学Delphi的不知到 Anders Hejlsberg，或者学Linux不知道Linus Torvalds一样，不可原谅啊。:-)为了让文章完整，就再罗唆几句吧。高爷爷本科时就开始给行行色色的公司写各种稀奇古怪的编译器挣外快了。他卖给 别人时收一两千美元，那些公司拿了code，加工一下卖出去就是上万上十万。不过也没见高爷爷不爽过，学者本色的说。想想那可是60年代初啊， 高爷爷写编译器写多了，顺带就搞出了个Attribute Grammar和LR(k)，大大地造福后人啊。至于高爷爷在CalTech的编程比赛(有Alan Kay得众多高高手参加)总是第一，写的Tex到86年就code freeze，还附带2^n美分奖励等等都是耳熟能详，偶就不饶舌乐。顺便说一下，高老大爷是无可争议的写作高手。他给Concrete Mathematics 写的前言可谓字字铿锵，堪为前言的典范。他的技术文章也是一绝，文风细致，解释精当，而且没有学究气，不失轻快跳脱。记得几年前读Concrete Mathematics，时不时开怀大笑，让老妈极其郁闷，觉得我nerdy到家，不可救药。其实呢，子非鱼，安知鱼之乐，更不知那完全是高爷爷的功劳。 说到写作高手，不能不提Stephen A. Cook。他的文章当年就被我们的写作老师极力推荐，号称典雅文风的样本。库爷爷一头银发，身材颀长，总是面带谦和的微笑，颇有仙风道骨，正好和他的仙文 相配的说。高爷爷其实还是开源运动的先驱。虽然他没有象Richard Stallman那样八方奔走，但他捐献了好多作品，都可以在网上看到，比如著名的Mathematical Writing，MMIXWare，The Tex Book等，更不用说足以让他流芳百世的Tex乐。

Ken Thompson Ken Thompson，C语言前身B语言的作者，Unix的发明人之一(另一个是Dennis M. Riche老大，被尊为DMR)，Belle(一个厉害的国际象棋程序)的作者之一, 操作系统Plan 9的主要作者(另一个是大牛人Rob Pike, 前不久被google挖走了)。Ken爷爷也算是计算机历史上开天辟地的人物了。1969年还是计算机史前时代，普通人都认为只有大型机才能运行通用的操 作系统，小型机只有高山仰止的份儿。至于用高级语言来写操作系统，更是笑谈。Ken爷爷自然不是池中物 ，于是他和DMR怒了，在1969年到1970间用汇编在PDP-7上写出了UNIX的第一个版本。他们并不知道，一场轰轰烈烈的UNIX传奇由此拉开了 序幕。Ken爷爷在1971年又把Unix用C重写，于是C在随后20年成就了不知多少豪杰的梦想和光荣。Ken爷爷还有段佳话： 装了UNIX的PDP-11最早被安装在Bell Lab里供大家日常使用。很快大家就发现Ken爷爷总能进入他们的帐户，获得最高权限。Bell Lab里的科学家都心比天高，当然被搞得郁闷无比。于是有高手怒了，跳出来分析了UNIX代码，找到后门，修改代码，然后重新编译了整个UNIX。就在大 家都以为“这个世界清净了”的时候，他们发现Ken爷爷还是轻而易举地拿到他们的帐户权限，百思不解后 ，只好继续郁闷。谁知道这一郁闷，就郁闷了14年，直到Ken爷爷道出个中缘由。原来，代码里的确有后门，但后门不在Unix代码里，而在编译Unix代 码的C编译器里。每次C编译器编译UNIX的代码，就自动生成后门代码。而整个Bell Lab的人，都是用Ken爷爷的C编译器。

Rob Pike Rob Pike, AT&T Bell Lab前Member of Technical Staff ，现在google研究操作系统。罗伯伯是Unix的先驱，是贝尔实验室最早和Ken Thompson以及Dennis M. Ritche开发Unix的猛人，UTF-8的设计人。他还在美国名嘴David Letterman的晚间节目上露了一小脸，一脸憨厚地帮一胖子吹牛搞怪。让偶佩服不已的是，罗伯伯还是1980年奥运会射箭的银牌得主。他也是个颇为厉 害的业余天文学家，设计的珈玛射线望远镜差点被NASA用在航天飞机上。他还是两本经典，The Unix Programming Environment 和 The Practice of Programming 的作者之一。如果初学者想在编程方面精益求精，实在该好好读读这两本书。它们都有中文版的说。罗伯伯还写出了Unix下第一个基于位图的窗口系统，并且是 著名的blit 终端的作者。当然了，罗伯伯还是号称锐意革新的操作系统，Plan9，的主要作者。可惜的是，Plan9并没有引起多少人的注意。罗伯伯一怒之下，写出了 振聋发聩的雄文 Systems Software Research is Irrelevant，痛斥当下系统开发不思进取，固步自封的弊病。虽然这篇文章是罗伯伯含忿出手，颇有偏激之词，但确实道出了系统开发的无奈：开发周期 越来越长，代价越来越大，用户被统一到少数几个系统上，结果越来越多的活动是测量和修补，而真正的革新 越来越少。就在罗伯伯郁闷之极的时候，google登门求贤来乐。如果说现在还有一家大众公司在不遗余力地把系统开发推向极致的话，也就是google 乐。随便看看google的成果就知道了。具有超强容错和负载平衡能力的分布式文件系统GFS (现在能够用100,000台廉价PC搭起一个巨型分布系统，并且高效便宜地进行管理的系统也不多哈)，大规模机器学习系统(拼写检查，广告匹配，拼音搜 寻。。。哪个都很牛的说)，更不用说处理海量并行计算的各式google服务了。Rob在System Software Research is Irrelevant里萧瑟地说现在没有人再关心系统研究的前沿成果了。想不到他错了，因为google关心。google网络了大批功成名就的牛人，还 有大量初生牛犊般博士做开发，显然不是没事耍酷，而是因为它们的开发总是试图吸取系统研究的最新成果。 想必Rob Pike在google很幸福。愿他做出更棒的系统。

Dennis M. Ritchie 既然Ken Thompson是我的偶像，新闻组上人称DMR的Dennis M. Ritchie自然也是，毕竟两人共同缔造了UNIX，而Dennis几乎独力把C搞大(当然，C的前身是B，而B是Ken Thompson一手做出来的)。J 两人1983年分享图灵奖，是有史以来少数几个因工程项目得奖的工程师(本来是唯一的一对儿，但Alan Kay才因为SmallTalk得奖，所以就成了唯二的乐) 。一个人一生能做出一个卓越的系统已经不易，DMR的C和UNIX长盛不衰近30年，至今生机勃勃，DMR此生可以无憾的说。D爷爷也算有家学渊源：他老 爸在AT&T贝尔实验室工作了一辈子，并在电路设计方面卓有成就，还出了本颇有影响的书The Design of Switching Circuits，据说在交换理论和逻辑设计方面有独到的论述。当然，D爷爷和他老爸是不同时代的人：他老爸的研究成形于晶体管发明之前，而D爷爷的工作 离了晶体管就玩儿不转乐。:-D不要看D爷爷搞出了C，其实他最爱的编程语言是Alef，在Plan9上运行，支持并行编程。Alef的语法和C相似，但 数据类型和执行方式都和C大大不同。说到语言，D爷爷对后来人有非常中肯的建议：抱着学习的目的来开发你自己的语言，不要冀望于它被 众人接受。这个建议不光对语言开发有用，也适用于其它大型系统的开发。别的不说，DMR后来领导自己的团队在1995年和1996分别推出了Plan9和 Inferno操作系统，又用多少人知道呢？其实，D爷爷当初也没想过C会风行世界。他开发C的初衷和 Eric S. Raymond在Cathedral and Bazaar里阐述的一样，就是要消除自己对现有工具的不爽之处。谁知D爷爷无心插柳，C竟然受到众多程序员的狂热拥戴，连D爷爷自己都大惑不解。在一次 采访中D爷爷说大概那是因为C的抽象程度碰巧既满足了程序员的要求, 又容易实现。当然C一度是Unix上的通用语言也是原因。但不管怎么说，D爷爷对编程语言出色的审美意识奠定了C广为流传的基础。最后八卦一下。D爷爷的 业余爱好和NBA大牛Karl Malone一样：开卡车。不过D爷爷更喜欢开NASCAR，而KM独爱巨无霸。J D爷爷自称心中不供偶像，如果一定要说一个，那就是Ken Thompson了。现在Ken爷爷退休当飞机教练去了，而D爷爷当了贝尔实验室系统开发部的头，整日忙于开支票。他俩合作20年，屡屡创造历史。这段令 人神往的佳话，也就长留你我心中乐。P.S., 很多人都以为Brian W. Kernighan是C的作者。其实BWK只是写了那本经典K&R C。据D爷爷说，他，Ken, 和Kernighan三人中，Kernighan最能写文章，他次之，而Ken写得最少；但说到编程，Ken爷爷才是当之无愧的老大。

Edsger Wybe Dijkstra 对，就是E.W. Dijkstra. 一提到EWD，很多人就会想起找最短路径的Dijkstra Algorithm，就好像一提到Sir. Tony Hoare，就想起Quick Sort一样。其实这些个算法不过是两个牛人在他们职业生涯中最琐碎的贡献。比如Dijkstra算法，无非是戴爷爷在1956年为了展示新计算机 ARMAC的计算能力，初试身手的成果，属于他的算法处女作。据戴爷爷自述，他搞出最短路径算法的时候连纸笔 都没用。当时他和他老婆在阿姆斯特丹一家咖啡厅的阳台上晒太阳喝咖啡，突然就把这个算法想出来乐。而且当时的算法研究还比较原始，牛人们忙着用计算机搞数 值计算，对离散算法不屑一顾。那时连一个象样的专注于离散算法的专业期刊都没有。戴爷爷于是推迟发表这 个算法。直到1959年，他才把这个算法发表在Numerische Mathematik的创刊号上，权为捧场。:-) EWD在多个领域牛气冲天，端的是理论和编程两手硬的高手。只不过他的很多工作比较深刻，学校的老先生们觉得本科生接受不了，不给本科生讲而已。戴爷爷大 概因为最短路径算法一战成名，于是有人请他参加另一台计算机X1的设计工作，并且把设计实时中断系统的 任务派给了他。现在看来实时中断也许不算什么，但要知到，X1前根本就没有实时中断的概念。实现它简直就是一场豪赌。戴爷爷起初还不情愿，但经不住项目负 责人Bram和Carel的轮番“吹捧”：我们知道实时中断让您工作变得非常困难，但象您这样的牛人肯 定能做出来的说。结果戴爷爷被糖衣炮弹彻底击穿，接下了这个烫手山芋。两三年后，他不仅搞出了实时中断，还围绕这个写出了自己的博士论文，顺利戴上博士 帽。让戴爷爷真正成名立万的还是在X1上开发的Algo60，最早的高级语言之一。戴爷爷没日没夜地工作 了8个月，就搞出了Algo60，也因此获得了1972年的图灵奖。因为Algo60，戴爷爷发表了一篇石破天惊的文章：Recursive Programming，于是人们才知道，原来高级语言也可以高效地实现递归，原来从此以后，所有程序员都不可避免地和戴爷爷发明的一个词(应该说是概 念)打交道：堆栈。而且Algo60还让戴爷爷深入地思考多道程序设计的问题，最终发明了每个系统程序员 都绕不开的概念：semaphore。当然，戴爷爷总是把他发明的概念严格形式化，极具科学家本色的说。和这些成就想比，他提出的吃饭的哲学家问题，也就 没什么好说的了。说来好笑，当时的大学(忘了哪所了)还是觉得戴爷爷没有受过正统的数学训练，也不是专 门搞数值分析的，所以最后不太情愿地给了他一个教职。这种小挫折并不能妨碍象戴爷爷这样的牛人创造历史。他一边教数值分析(:-D) ，一边开始开发一个新的操作系统，并培养计算机科学家。几年后，THE Multiprogramming System横空出世。THE是第一个支持松散耦合，显式同步的进程并由此使得严格证明系统没有死锁变得容易的操作系统。可惜戴爷爷任职的系不识货，还强 行解散了他的研究小组(1972年戴爷爷给他的系主任说他得了图灵奖，系主任的第一反应是你们搞计算机 就喜欢乱发奖)。这让戴爷爷相当郁闷，得了抑郁症。在极度郁闷之中，戴爷爷决定用写作来治疗自己的抑郁症。于是经典就诞生乐：Notes on Structured Programming。戴爷爷从此被尊为结构化编程的奠基人，而且他的抑郁症也被治好乐。EWD太牛，结果他的故事也太多。先到这里吧。1973起，他 的故事就在美国发生了。

Anders Hejlsberg，微软.NET的首席架构师，编程语言设计和实现的顶尖高手。他一手做出了Turbo Pascal, 也是Delphi,J++(尤其是WFC)，C#,和.NET的主要作者。这些作品的名字足以为他立传。作为一个程序员，我在这样的大师面前实在无语。生 子当如Anders的说。李维的<<Borland传奇>>里已详细讲述了Anders的传奇故事，我就不用费舌了：