小小程序

CPUID被禁止取序列号之后

Hercules Space — Wed, 10 May 2006 04:50:00 GMT

今天在写工作文档时，有网上好友问我关于CPUID被禁止取序列号后该怎么办？于是立即由single-core变为duo-core，呵呵，大脑不用升级就可自动完成，且无新成本发生。

网上其实也说到了禁止取序列号的代码：应该是下面这几句：

MOV ECX, 119H

RDMSR

OR EAX, 0020 0000H

WRMSR

我简单说明这几句，第二和第四分别是读写MSR寄存器的指令，第一句则表明了要访问的MSR的地址。119H对应该的MSR寄存器叫做BBL_CR_CTL MSR寄存器；第三句则是对第21位置1。在BBL_CR_CTL的bit21被置以后，processor number这一功能会被禁止，直至系统reset。要说明的是此bit21是write-once属性的，即仅可以在reset后被写入一次，这是在硬件上就做好的，所以一旦此位被修改，再写就不可能了。

对一些软件为什么要去置此位就不说了，大多也是安全或加密什么的。但是至少有一点，用户也许要使用processor number，这样就无法去读取了。

最简单的方法是不让修改此位的软件运行，更简单说就是检查一下当前正在运行的程序，看其执行文件中是否包含了相应代码的机器码，当然了，如果必要还要检查其加载的模块。下面是相应的机器码（注意，此代码不一定与“干这事的那个人”的代码完全相符。）：

B9 19 01 00 00 mov ecx,119h

0F 32 rdmsr

0D 00 00 20 00 or eax,200000h

0F 30 wrmsr

小例子:检测占用DMA通道的设备

HERCULES BLOG — Wed, 22 Jun 2005 07:52:00 GMT

平时写的代码一半不是在windows下运行的,有朋友突然问希望在windows下看到占用DMA通道的设备。呵呵，差点死脑筋去写驱动！看了一下MSDN，发现其实这类小应用写起来也可以很简单的，原因很简单，MS为你提供了很多API。下面这段例子代码就是这个作用，还可以用它举一反做其它的事^_^：

// Author Hercules Zeng
FindDMAChannelOccupants()

{

GUID guidDevClass = GUID_NULL;

TCHAR tcsDevClassName[MAX_PATH + 1];

BYTE pBuffer[512];

DWORD nRequireSize = 0;

DWORD dwRtn;

BOOL bRtn;

int nIndex = 0;

while(true)

{

dwRtn = CM_Enumerate_Classes(nIndex++, &guidDevClass, NULL);

if(dwRtn == CR_NO_SUCH_VALUE)

{

break;

}

bRtn = SetupDiClassNameFromGuid(&guidDevClass, tcsDevClassName, MAX_PATH, &nRequireSize);

if(!bRtn)

{

continue;

}

HDEVINFO hDevInfo = SetupDiGetClassDevs(&guidDevClass, NULL, NULL, DIGCF_PRESENT);

if(INVALID_HANDLE_VALUE == hDevInfo)

{

continue;

}

//Enumrate

int nMemberIndex = 0;

SP_DEVINFO_DATA devInfo_data;

devInfo_data.cbSize = sizeof(SP_DEVINFO_DATA);

while(true)

{

bRtn = SetupDiEnumDeviceInfo(hDevInfo, nMemberIndex++, &devInfo_data);

if(!bRtn)

{

int nErr = GetLastError();

break;

}

//Valid Device

if(!SetupDiGetDeviceRegistryProperty(hDevInfo, &devInfo_data, 0, 0, pBuffer, MAX_PATH, &nRequireSize))

continue;

// Open configuration

LOG_CONF lcLogConf = 0;

dwRtn = CM_Get_First_Log_Conf(&lcLogConf, devInfo_data.DevInst, ALLOC_LOG_CONF);

if(CR_SUCCESS != dwRtn)

{

if(CR_SUCCESS != CM_Get_First_Log_Conf(&lcLogConf, devInfo_data.DevInst, BOOT_LOG_CONF))

continue;

}

RES_DES rdResDes;

dwRtn = CM_Get_Next_Res_Des(&rdResDes, lcLogConf, ResType_DMA, NULL, NULL);

if(CR_SUCCESS == dwRtn)

{

// check DMA information

if(CR_SUCCESS == CM_Get_Res_Des_Data_Size(&nRequireSize, rdResDes, NULL))

{

PBYTE pTempBuf;

pTempBuf = new BYTE[nRequireSize];

memset(pTempBuf, 0, nRequireSize);

if(CR_SUCCESS == CM_Get_Res_Des_Data(rdResDes, (PVOID)pTempBuf, nRequireSize, NULL))

{

PDMA_DES pDMA = (PDMA_DES)pTempBuf;

// find

                        TCHAR tcsMessage[256];
                        sprintf(tcsMessage, _T("%s [DMA:%d]"), pBuffer, pDMA->DD_Alloc_Chan);
                        MessageBox(tcsMessage);

}

delete pTempBuf;

}

// release resource descriptor

CM_Free_Res_Des_Handle(rdResDes);

}

// Destroy HDEVINFO

SetupDiDestroyDeviceInfoList(hDevInfo);

}

备注: 1 附加链接库: SetupAPI.lib
2 Include文件: cfgmgr32.h
3 所需头文件: cfg.h download

小例子: 对控制台程序重定向

HERCULES BLOG — Sat, 04 Jun 2005 06:29:00 GMT

        近来感觉在VCKBASE上有点手脚不勤，有些惭愧！有人问到关于cmd.exe的问题，希望能够对它的输入命令进行过滤。个人觉得如果从深度考虑还是有些难度的，毕竟在windows下，命令行窗口的消息流是不可访问的。所以也不可以用钩子等类似的机制进行处理。其实对于一般要求不高的实现来说，完全可以通过对cmd.exe的输入输入进行控制，实在对输入进行过滤同时还保留住cmd.exe的大部分功能。今天是周未，睡醒之后，觉得回问题应该用点心，所以花了个把小时写下了下面这段例子代码，顺便改掉手脚不勤的坏习惯^_^！

//=======================================
// Description: A sample to show how to filter cmd.exe
// Author     : Hercules Zeng
// Emailto    : HEXTech@hotmail.com

#include "stdafx.h"
#include <stdio.h>
#include <windows.h>

#define BUFF_SIZE 16384 //16K
HANDLE g_hCmdStdinRead;
HANDLE g_hCmdStdinWrite;
HANDLE g_hCmdStdinWriteDup;
HANDLE g_hChildStdoutRead;
HANDLE g_hChildStdoutWrite;
HANDLE g_hChildStdoutReadDup;
HANDLE g_hInputHandle;
HANDLE g_hBackupStdin;
HANDLE g_hBackupStdout;

//----------------------------------------------------------------------------
void ErrorExit (LPTSTR lpszMessage)
{
fprintf(stderr, "%s\n", lpszMessage);
ExitProcess(0);
}

//----------------------------------------------------------------------------
BOOL CheckCmd(char* pBuffer)
{
if(strcmp(pBuffer, "exit\r\n") == 0)
{
ExitProcess(0);
}
return TRUE;
}

//----------------------------------------------------------------------------
int EnterInfoCMD(void)
{
DWORD dwReadCnt;
DWORD dwWriteCnt;
CHAR cBuffer[BUFF_SIZE];
int nCmdLen;

memset(cBuffer, 0, BUFF_SIZE);
if (! WriteFile(g_hCmdStdinWriteDup, cBuffer, strlen(cBuffer),
  &dwWriteCnt, NULL))
  return -1;
Sleep(300);
if( !ReadFile( g_hChildStdoutReadDup, cBuffer, BUFF_SIZE, &dwReadCnt,
  NULL) || dwReadCnt == 0) return -1;
if (! WriteFile(g_hBackupStdout, cBuffer, dwReadCnt, &dwWriteCnt, NULL))
  return -1;

// Read from a file and write its contents to a pipe.
for (;;)
{
  memset(cBuffer, 0, BUFF_SIZE);
  if (! ReadFile(g_hInputHandle, cBuffer, BUFF_SIZE, &dwReadCnt, NULL) ||
   dwReadCnt == 0)
   break;
  // Add check-method here
  CheckCmd(cBuffer);
  nCmdLen = strlen(cBuffer);
  if (! WriteFile(g_hCmdStdinWriteDup, cBuffer, dwReadCnt,
   &dwWriteCnt, NULL)) break;

  BOOL bStripCmd = TRUE;
  for(;;)
  {
   Sleep(300);
   memset(cBuffer, 0, BUFF_SIZE);
   if( !ReadFile( g_hChildStdoutReadDup, cBuffer, BUFF_SIZE, &dwReadCnt,
    NULL) || dwReadCnt == 0) break;

   if(bStripCmd)
   {
    if (! WriteFile(g_hBackupStdout, cBuffer + nCmdLen, dwReadCnt - nCmdLen, &dwWriteCnt, NULL))
     break;
   }
   else
   {
    if (! WriteFile(g_hBackupStdout, cBuffer, dwReadCnt, &dwWriteCnt, NULL))
     break;
   }
   bStripCmd = FALSE;
   if(cBuffer[dwReadCnt - 1] == '>')
    break;
  }
}

// Close the pipe handle so the child process stops reading.
if (! CloseHandle(g_hCmdStdinWriteDup))
ErrorExit("Close pipe failed\n");

return 0;
}

//----------------------------------------------------------------------------
BOOL CreateCMDProcess()
{
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
BOOL bRtn = FALSE;
ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
siStartInfo.cb = sizeof(STARTUPINFO);

// Create the child process.
TCHAR tcsExename[MAX_PATH];
TCHAR tcsParam[MAX_PATH * 2];
TCHAR tcsCmd[MAX_PATH];
if( 0 == GetModuleFileName(NULL, tcsExename, MAX_PATH)
|| 0 == GetEnvironmentVariable(_T("COMSPEC"), tcsCmd, MAX_PATH))
return FALSE;

// get short filename for command shell program
if( 0 == GetShortPathName(tcsExename, tcsExename, MAX_PATH))
return FALSE;

bRtn = CreateProcess(NULL,
  tcsCmd,       // command line
  NULL,          // process security attributes
  NULL,          // primary thread security attributes
  TRUE,          // handles are inherited
  0,             // creation flags
  NULL,          // use parent's environment
  NULL,          // use parent's current directory
  &siStartInfo, // STARTUPINFO pointer
  &piProcInfo); // receives PROCESS_INFORMATION

if (bRtn == 0)
{
  ErrorExit("CreateProcess failed\n");
  return FALSE;
}
else
{
  CloseHandle(piProcInfo.hProcess);
  CloseHandle(piProcInfo.hThread);
  return bRtn;
}
}

//----------------------------------------------------------------------------
DWORD main()
{
SECURITY_ATTRIBUTES saAttr;
BOOL fSuccess;
// Set the bInheritHandle flag so pipe handles are inherited.
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;

// The steps for redirecting child process's STDOUT:
//     1. Save current STDOUT, to be restored later.
//     2. Create anonymous pipe to be STDOUT for child process.
//     3. Set STDOUT of the parent process to be write handle to
//        the pipe, so it is inherited by the child process.
//     4. Create a noninheritable duplicate of the read handle and
//        close the inheritable read handle.

// Save the handle to the current STDOUT.
g_hBackupStdout = GetStdHandle(STD_OUTPUT_HANDLE);

// Create a pipe for the child process's STDOUT.
if (! CreatePipe(&g_hChildStdoutRead, &g_hChildStdoutWrite, &saAttr, 0))
ErrorExit("Stdout pipe creation failed\n");

// Set a write handle to the pipe to be STDOUT.
if (! SetStdHandle(STD_OUTPUT_HANDLE, g_hChildStdoutWrite))
ErrorExit("Redirecting STDOUT failed");

// Create noninheritable read handle and close the inheritable read
// handle.

fSuccess = DuplicateHandle(GetCurrentProcess(), g_hChildStdoutRead,
  GetCurrentProcess(), &g_hChildStdoutReadDup , 0,
  FALSE,
  DUPLICATE_SAME_ACCESS);
if( !fSuccess )
  ErrorExit("DuplicateHandle failed");
CloseHandle(g_hChildStdoutRead);

// The steps for redirecting child process's STDIN:
//     1. Save current STDIN, to be restored later.
//     2. Create anonymous pipe to be STDIN for child process.
//     3. Set STDIN of the parent to be the read handle to the
//         pipe, so it is inherited by the child process.
//     4. Create a noninheritable duplicate of the write handle,
//         and close the inheritable write handle.

// Save the handle to the current STDIN.
g_hBackupStdin = GetStdHandle(STD_INPUT_HANDLE);

// Create a pipe for the child process's STDIN.
if (! CreatePipe(&g_hCmdStdinRead, &g_hCmdStdinWrite, &saAttr, 0))
ErrorExit("Stdin pipe creation failed\n");

// Set a read handle to the pipe to be STDIN.
if (! SetStdHandle(STD_INPUT_HANDLE, g_hCmdStdinRead))
ErrorExit("Redirecting Stdin failed");

// Duplicate the write handle to the pipe so it is not inherited.
fSuccess = DuplicateHandle(GetCurrentProcess(), g_hCmdStdinWrite,
  GetCurrentProcess(), &g_hCmdStdinWriteDup, 0,
  FALSE,                  // not inherited
  DUPLICATE_SAME_ACCESS);
if (! fSuccess)
  ErrorExit("DuplicateHandle failed");

CloseHandle(g_hCmdStdinWrite);

// Now create the child process.
fSuccess = CreateCMDProcess();
if (! fSuccess)
ErrorExit("Create process failed");

// After process creation, restore the saved STDIN and STDOUT.
if (! SetStdHandle(STD_INPUT_HANDLE, g_hBackupStdin))
ErrorExit("Re-redirecting Stdin failed\n");

if (! SetStdHandle(STD_OUTPUT_HANDLE, g_hBackupStdout))
ErrorExit("Re-redirecting Stdout failed\n");

// Get a handle to the parent's input file.
g_hInputHandle = g_hBackupStdin;

if (g_hInputHandle == INVALID_HANDLE_VALUE)
ErrorExit("no input file\n");

EnterInfoCMD();
return 0;
}

小窍门定制系统弹出的对话框

HERCULES BLOG — Thu, 11 Nov 2004 21:50:00 GMT

查指定用户是否设有密码

HERCULES BLOG — Thu, 11 Nov 2004 20:22:00 GMT

源码:演示如何dump指定文件的符号信息

HERCULES BLOG — Mon, 08 Nov 2004 02:57:00 GMT

如何"借他人之手"实现可执行文件的自我删除

Hercules Blog — Thu, 28 Oct 2004 15:23:00 GMT

可执行文件即EXE文件在运行过程中，由系统管理其打开的句柄。此时对该文件的一些操作是被系统禁止的，比如删除操作。然而在某些场合，可能须要程序有自我删除的功能，也就是程序运行结束后删除自身。基于这个想法，可以有一种很简单的方法来实现这个基本功能。

本方法基于两点来实现删除功能。一是利用windows的command program的删除文件操作；再者就是启动新的进程来执行这个删除操作。下面就仔细说明。

Windows中的command program是一个系统的shell program. 在windows95/98/Me中，其文件名为command.com，而在NT/2000/XP中则是cmd.exe。我们可以通过环境变量COMSPEC得到其全路径名。

假定目前我们所使用的是XP，在命令行中输入:

cmd.exe /?

即得到command shell的使用方法；其中 /c 的含义是：执行字符串指定的命令然后终断，这正是我们所须要的。这样利用command shell删除一个文件的命令如下：

cmd.exe /c del mypro.exe

这里要注意一点，文件名应该是短文件名（文件名不得超过8个字符,后缀不超过3个字符）。如果实际文件是长文件句，那么程序中我们可以用GetShortPathName这个API函数来转换。

接下来我们要做是如何在一新的进程中成功的执行这一指令。起来一个新进程的命令主要有ShellExecute和CreateProcess。

先使用ShellExecute为例。在程序的结束处使用如下语句：

ShellExecute(NULL, "open","cmd.exe", "/c del mypro.exe ", NULL, SW_HIDE);

编译后运行文件发现执行成功，文件运行完后被删除。但是后面做多次实验后，发现有时文件执行完后并不会被删除。通过分析，认为在删除操作执行时，可执行文件还未关闭。也就是说只有在执行文件的进程关闭后，执行删除操作的进程才能完成操作。这样就有了一个问题，系统负责进程和线程的调度执行，我们无法人为规定进程或线程以某种秩序执行。

对此我的解决办法是，建立执行删除操作的进程时设定其为挂起状态，从而为其的设定一个低优先级别，同时提高执行文件的进程级别，然后才正式起动新进程。这样基本可以保证两个进程的先后执行。这样新的解决方法就是用CreateProcess以CREATE_SUSPEND标志来建立新进程，然后用SetPriorityClass来设定相应的优先级，主进程的优先级是HIGH_PRIORITY_CLASS，而执行删除操作的进程的优先级是IDLE_PRIORITY_CLASS。经过数百次的测试，删除操作都是成功的。

下面是一个封装了删除操作的函数,函数内起动一个进程执行command shell的del命令。在程序最后结束处调用它，就可以简单的实现程序的自删除功能。

#include <windows.h>

#include <shellapi.h>

#include <stdio.h>

int DeleteMyExe()

{

TCHAR tcsExename[MAX_PATH];

TCHAR tcsParam[MAX_PATH * 2];

TCHAR tcsCmd[MAX_PATH];

HANDLE hProcess = NULL;

// get exe filename and command shell program

if( 0 == GetModuleFileName(NULL, tcsExename, MAX_PATH)

|| 0 == GetEnvironmentVariable(_T("COMSPEC"), tcsCmd, MAX_PATH))

FAILRET;

// get short filename for command shell program

if( 0 == GetShortPathName(tcsExename, tcsExename, MAX_PATH))

FAILRET;

// create a command process, set its priority, then start it.

STARTUPINFO si;

PROCESS_INFORMATION pi;

ZeroMemory( &si, sizeof(si) );

si.cb = sizeof(si);

si.dwFlags = STARTF_USESHOWWINDOW;

si.wShowWindow = SW_HIDE;

ZeroMemory( &pi, sizeof(pi) );

_stprintf(tcsParam, _T("%s /c del %s"), tcsCmd, tcsExename);

if(!CreateProcess(NULL,

tcsParam,

NULL,

FALSE,

CREATE_SUSPENDED,

NULL,

&si,

&pi))

{

return GetLastError();

}

// heigthen priority of the current process

SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);

// set file attribute to normal

SetFileAttributes(tcsExename, FILE_ATTRIBUTE_NORMAL);

// depress priority of command process, then start it

SetPriorityClass(pi.hProcess, IDLE_PRIORITY_CLASS);

ResumeThread(pi.hThread);

return 0;

}