首先要知道Ring3层调用OpenProcess的流程

//当Ring3调用OpenProcess
//1从自己的模块(.exe)的导入表中取值

//2Ntdll.dll模块的导出表中执行ZwOpenProcess(取索引 进入Ring0层)

//3进入Ring0 从Ntoskernel.exe模块的导出表中执行ZwOpenProcess(取索引 获得SSDT服务地址)

//4通过索引在SSDT表中取值(NtOpenProcess的地址)

//5真正调用NtOpenProcess函数

我们可以通过在第4部通过索引将NtOpenProcess 换成 Base[索引] = FakeNtOpenProcess;

1.我们要获取SSDT的结构信息

XP 32位的SSDT在Ntos模块导出表中有

  1.  //SSDT表的基地址32位(4Bytes)64位(8Bytes)
  2.  //XP 32位Ntos模块导出表中有   Win7 64 Ntos模块导出表中无
  3.  BOOLEAN GetSSDTAddressInWinXP_X86(ULONG32* SSDTAddress)
  4.  {
  5.      //从NtosKernel.exe 模块中的导出表获得该导出变量  KeServiceDescriptorTable
  6.  
  7.      /*
  8.      kd> dd KeServiceDescriptorTable
  9.      80563520  804e58a0 00000000 0000011c 805120bc
  10.      */
  11.      *SSDTAddress = NULL;
  12.      *SSDTAddress = (ULONG32)GetExportVariableAddressFormNtosExportTableByVariableName(L"KeServiceDescriptorTable");
  13.  
  14.      if (*SSDTAddress!=NULL)
  15.      {
  16.          return TRUE;
  17.      }
  18.  
  19.      return FALSE;
  20.  }

获取SSDT的地址32

win7 64位没有被导出 但可以通过读取制定的msr得出

// 来自 作者：胡文亮

Msr 的中文全称是就是“特别模块寄存器” （model specific
register） ，它控制 CPU 的工作环境和标示 CPU 的工作状态等信息（例如倍频、最大 TDP、
危险警报温度） ，它能够读取，也能够写入，但是无论读取还是写入，都只能在 Ring 0 下
进行。我们通过读取 C0000082 寄存器，能够得到 KiSystemCall64 的地址，然后从
KiSystemCall64 的地址开始，往下搜索 0x500 字节左右（特征码是 4c8d15） ，就能得到
KeServiceDescriptorTable 的地址了。同理，我们换一下特征码（4c8d1d） ，就能获得
KeServiceDescriptorTableShadow 的地址了。

  1.  BOOLEAN GetSSDTAddressInWin7_X64(ULONG64* SSDTAddress)
  2.  {
  3.  
  4.      /*
  5.      kd> rdmsr c0000082
  6.      msr[c0000082] = fffff800`03ecf640
  7.      kd> u fffff800`03ecf640 l 50
  8.      nt!KiSystemCall64:
  9.      fffff800`03ecf640 0f01f8          swapgs
  10.      fffff800`03ecf643 654889242510000000 mov   qword ptr gs:[10h],rsp
  11.      fffff800`03ecf64c 65488b2425a8010000 mov   rsp,qword ptr gs:[1A8h]
  12.      fffff800`03ecf655 6a2b            push    2Bh
  13.      fffff800`03ecf657 65ff342510000000 push    qword ptr gs:[10h]
  14.      fffff800`03ecf65f 4153            push    r11
  15.      fffff800`03ecf661 6a33            push    33h
  16.      fffff800`03ecf663 51              push    rcx
  17.      fffff800`03ecf664 498bca          mov     rcx,r10
  18.      fffff800`03ecf667 4883ec08        sub     rsp,8
  19.      fffff800`03ecf66b 55              push    rbp
  20.      fffff800`03ecf66c 4881ec58010000  sub     rsp,158h
  21.      fffff800`03ecf673 488dac2480000000 lea     rbp,[rsp+80h]
  22.      fffff800`03ecf67b 48899dc0000000  mov     qword ptr [rbp+0C0h],rbx
  23.      fffff800`03ecf682 4889bdc8000000  mov     qword ptr [rbp+0C8h],rdi
  24.      fffff800`03ecf689 4889b5d0000000  mov     qword ptr [rbp+0D0h],rsi
  25.      fffff800`03ecf690 c645ab02        mov     byte ptr [rbp-55h],2
  26.      fffff800`03ecf694 65488b1c2588010000 mov   rbx,qword ptr gs:[188h]
  27.      fffff800`03ecf69d 0f0d8bd8010000  prefetchw [rbx+1D8h]
  28.      fffff800`03ecf6a4 0fae5dac        stmxcsr dword ptr [rbp-54h]
  29.      fffff800`03ecf6a8 650fae142580010000 ldmxcsr dword ptr gs:[180h]
  30.      fffff800`03ecf6b1 807b0300        cmp     byte ptr [rbx+3],0
  31.      fffff800`03ecf6b5 66c785800000000000 mov   word ptr [rbp+80h],0
  32.      fffff800`03ecf6be 0f848c000000    je      nt!KiSystemCall64+0x110 (fffff800`03ecf750)
  33.      fffff800`03ecf6c4 488945b0        mov     qword ptr [rbp-50h],rax
  34.      fffff800`03ecf6c8 48894db8        mov     qword ptr [rbp-48h],rcx
  35.      fffff800`03ecf6cc 488955c0        mov     qword ptr [rbp-40h],rdx
  36.      fffff800`03ecf6d0 f6430303        test    byte ptr [rbx+3],3
  37.      fffff800`03ecf6d4 4c8945c8        mov     qword ptr [rbp-38h],r8
  38.      fffff800`03ecf6d8 4c894dd0        mov     qword ptr [rbp-30h],r9
  39.      fffff800`03ecf6dc 7405            je      nt!KiSystemCall64+0xa3 (fffff800`03ecf6e3)
  40.      fffff800`03ecf6de e80d140000      call    nt!KiSaveDebugRegisterState (fffff800`03ed0af0)
  41.      fffff800`03ecf6e3 f6430380        test    byte ptr [rbx+3],80h
  42.      fffff800`03ecf6e7 7442            je      nt!KiSystemCall64+0xeb (fffff800`03ecf72b)
  43.      fffff800`03ecf6e9 b9020100c0      mov     ecx,0C0000102h
  44.      fffff800`03ecf6ee 0f32            rdmsr
  45.      fffff800`03ecf6f0 48c1e220        shl     rdx,20h
  46.      fffff800`03ecf6f4 480bc2          or      rax,rdx
  47.      fffff800`03ecf6f7 483983b8000000  cmp     qword ptr [rbx+0B8h],rax
  48.      fffff800`03ecf6fe 742b            je      nt!KiSystemCall64+0xeb (fffff800`03ecf72b)
  49.      fffff800`03ecf700 483983b0010000  cmp     qword ptr [rbx+1B0h],rax
  50.      fffff800`03ecf707 7422            je      nt!KiSystemCall64+0xeb (fffff800`03ecf72b)
  51.      fffff800`03ecf709 488b93b8010000  mov     rdx,qword ptr [rbx+1B8h]
  52.      fffff800`03ecf710 0fba6b4c0b      bts     dword ptr [rbx+4Ch],0Bh
  53.      fffff800`03ecf715 66ff8bc4010000  dec     word ptr [rbx+1C4h]
  54.      fffff800`03ecf71c 48898280000000  mov     qword ptr [rdx+80h],rax
  55.      fffff800`03ecf723 fb              sti
  56.      fffff800`03ecf724 e8170b0000      call    nt!KiUmsCallEntry (fffff800`03ed0240)
  57.      fffff800`03ecf729 eb0f            jmp     nt!KiSystemCall64+0xfa (fffff800`03ecf73a)
  58.      fffff800`03ecf72b f6430340        test    byte ptr [rbx+3],40h
  59.      fffff800`03ecf72f 7409            je      nt!KiSystemCall64+0xfa (fffff800`03ecf73a)
  60.      fffff800`03ecf731 f00fbaab0001000008 lock bts dword ptr [rbx+100h],8
  61.      fffff800`03ecf73a 488b45b0        mov     rax,qword ptr [rbp-50h]
  62.      fffff800`03ecf73e 488b4db8        mov     rcx,qword ptr [rbp-48h]
  63.      fffff800`03ecf742 488b55c0        mov     rdx,qword ptr [rbp-40h]
  64.      fffff800`03ecf746 4c8b45c8        mov     r8,qword ptr [rbp-38h]
  65.      fffff800`03ecf74a 4c8b4dd0        mov     r9,qword ptr [rbp-30h]
  66.      fffff800`03ecf74e 6690            xchg    ax,ax
  67.      fffff800`03ecf750 fb              sti
  68.      fffff800`03ecf751 48898be0010000  mov     qword ptr [rbx+1E0h],rcx
  69.      fffff800`03ecf758 8983f8010000    mov     dword ptr [rbx+1F8h],eax
  70.      nt!KiSystemServiceStart:
  71.      fffff800`03ecf75e 4889a3d8010000  mov     qword ptr [rbx+1D8h],rsp
  72.      fffff800`03ecf765 8bf8            mov     edi,eax
  73.      fffff800`03ecf767 c1ef07          shr     edi,7
  74.      fffff800`03ecf76a 83e720          and     edi,20h
  75.      fffff800`03ecf76d 25ff0f0000      and     eax,0FFFh
  76.      nt!KiSystemServiceRepeat:
  77.      fffff800`03ecf772 4c8d15c7202300  lea     r10,[nt!KeServiceDescriptorTable (fffff800`04101840)]
  78.  
  79.      fffff800`03ecf772 + 002320c7 + 7  = fffff800`04101840
  80.      */
  81.  
  82.      PUCHAR StartSearchAddress = (PUCHAR)__readmsr(0xC0000082);   //fffff800`03ecf640
  83.      PUCHAR EndSearchAddress = StartSearchAddress + 0x500;
  84.      PUCHAR i = NULL;
  85.      UCHAR   v1=,v2=,v3=;
  86.      INT64   iOffset = ;    //002320c7
  87.      ULONG64 VariableAddress = ;
  88.      *SSDTAddress = NULL;
  89.      for(i=StartSearchAddress;i<EndSearchAddress;i++)
  90.      {
  91.          if( MmIsAddressValid(i) && MmIsAddressValid(i+) && MmIsAddressValid(i+) )
  92.          {
  93.              v1=*i;
  94.              v2=*(i+);
  95.              v3=*(i+);
  96.              if(v1==0x4c && v2==0x8d && v3==0x15 )
  97.              {
  98.                  memcpy(&iOffset,i+,);
  99.                  *SSDTAddress = iOffset + (ULONG64)i + ;
  100.  
  101.                  break;
  102.              }
  103.          }
  104.      }
  105.  
  106.      if (*SSDTAddress==NULL)
  107.      {
  108.          return FALSE;
  109.      }
  110.  
  111.      /*
  112.      kd> dq fffff800`04101840
  113.      fffff800`04101840  fffff800`03ed1300 00000000`00000000
  114.      fffff800`04101850  00000000`00000191 fffff800`03ed1f8c
  115.  
  116.      */
  117.      return TRUE;
  118.  }

获取SSDT

2从Ntdll模块中的导出表获得要Hook的函数索引

  1.  BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWinXP_X86(CHAR* szFindFunctionName,ULONG32* SSDTFunctionIndex)
  2.  {
  3.      /*
  4.      0:001> u zwopenprocess
  5.      ntdll!ZwOpenProcess:
  6.      7c92d5e0 b87a000000      mov     eax,7Ah
  7.      7c92d5e5 ba0003fe7f      mov     edx,offset SharedUserData!SystemCallStub (7ffe0300)
  8.      7c92d5ea ff12            call    dword ptr [edx]
  9.      7c92d5ec c21000          ret     10h
  10.      7c92d5ef 90              nop
  11.      */
  12.  
  13.      ULONG32     ulOffset_SSDTFunctionIndex = ;
  14.  
  15.      //从Ntdll模块的导出表中获得7c92d5e0
  16.      //使用内存映射将Ntdll模块映射到System进程的内存空间进行查找(Ntdll.dll模块的导出表中进行搜索)
  17.      ULONG   i;
  18.      BOOLEAN  bOk = FALSE;
  19.      WCHAR    wzFileFullPath[] = L"\\SystemRoot\\System32\\ntdll.dll";
  20.      SIZE_T  MappingViewSize   = ;
  21.      PVOID    MappingBaseAddress = NULL;
  22.      PIMAGE_NT_HEADERS  NtHeader = NULL;
  23.      PIMAGE_EXPORT_DIRECTORY ExportDirectory = NULL;
  24.      ULONG32*  AddressOfFunctions    = NULL;
  25.      ULONG32*  AddressOfNames        = NULL;
  26.      USHORT* AddressOfNameOrdinals = NULL;
  27.      CHAR*   szFunctionName        = NULL;
  28.      ULONG32 ulFunctionOrdinal     = ;
  29.      ULONG32 ulFunctionAddress     = ;
  30.  
  31.      *SSDTFunctionIndex = -;
  32.  
  33.      //将Ntdll.dll 当前的空间中
  34.      bOk = MappingPEFileInRing0Space(wzFileFullPath,&MappingBaseAddress, &MappingViewSize);
  35.      if (bOk==FALSE)
  36.      {
  37.          return FALSE;
  38.      }
  39.      else
  40.      {
  41.          __try{
  42.              NtHeader = RtlImageNtHeader(MappingBaseAddress);
  43.              if (NtHeader && NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  44.              {
  45.                  ExportDirectory =(IMAGE_EXPORT_DIRECTORY*)((ULONG32)MappingBaseAddress + NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  46.  
  47.                  AddressOfFunctions = (ULONG32*)((ULONG32)MappingBaseAddress + ExportDirectory->AddressOfFunctions);
  48.                  AddressOfNames = (ULONG32*)((ULONG32)MappingBaseAddress + ExportDirectory->AddressOfNames);
  49.                  AddressOfNameOrdinals = (USHORT*)((ULONG32)MappingBaseAddress + ExportDirectory->AddressOfNameOrdinals);
  50.                  for(i = ; i < ExportDirectory->NumberOfNames; i++)
  51.                  {
  52.                      szFunctionName = (char*)((ULONG32)MappingBaseAddress + AddressOfNames[i]);   //获得函数名称
  53.                      if (_stricmp(szFunctionName, szFindFunctionName) == )
  54.                      {
  55.                          ulFunctionOrdinal = AddressOfNameOrdinals[i];
  56.                          ulFunctionAddress = (ULONG32)((ULONG32)MappingBaseAddress + AddressOfFunctions[ulFunctionOrdinal]);
  57.  
  58.                          *SSDTFunctionIndex = *(ULONG32*)(ulFunctionAddress+ulOffset_SSDTFunctionIndex);
  59.                          break;
  60.                      }
  61.                  }
  62.              }
  63.          }__except(EXCEPTION_EXECUTE_HANDLER)
  64.          {
  65.              ;
  66.          }
  67.      }
  68.  
  69.      ZwUnmapViewOfSection(NtCurrentProcess(), MappingBaseAddress);
  70.  
  71.      if (*SSDTFunctionIndex==-)
  72.      {
  73.          return FALSE;
  74.      }
  75.  
  76.      return TRUE;
  77.  }

获取函数索引32

  1.  BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWin7_X64(CHAR* szFindFunctionName,ULONG32* SSDTFunctionIndex)
  2.  {
  3.      /*
  4.      0:004> u zwopenprocess
  5.      ntdll!NtOpenProcess:
  6.      00000000`774ddc10 4c8bd1          mov     r10,rcx
  7.      00000000`774ddc13 b823000000      mov     eax,23h
  8.      00000000`774ddc18 0f05            syscall
  9.      00000000`774ddc1a c3              ret
  10.      00000000`774ddc1b 0f1f440000      nop     dword ptr [rax+rax]
  11.      */
  12.  
  13.      ULONG32     ulOffset_SSDTFunctionIndex = ;
  14.  
  15.      ULONG   i;
  16.      BOOLEAN  bOk = FALSE;
  17.      WCHAR    wzFileFullPath[] = L"\\SystemRoot\\System32\\ntdll.dll";
  18.      SIZE_T   MappingViewSize   = ;
  19.      PVOID    MappingBaseAddress = NULL;
  20.      PIMAGE_NT_HEADERS  NtHeader = NULL;
  21.      PIMAGE_EXPORT_DIRECTORY ExportDirectory = NULL;
  22.      ULONG32*  AddressOfFunctions    = NULL;
  23.      ULONG32*  AddressOfNames        = NULL;
  24.      USHORT*   AddressOfNameOrdinals = NULL;
  25.      CHAR*     szFunctionName        = NULL;
  26.      ULONG32   ulFunctionOrdinal     = ;
  27.      ULONG64   ulFunctionAddress     = ;
  28.  
  29.      *SSDTFunctionIndex = -;
  30.  
  31.      //将Ntdll.dll 当前的空间中
  32.      bOk = MappingPEFileInRing0Space(wzFileFullPath,&MappingBaseAddress, &MappingViewSize);
  33.      if (bOk==FALSE)
  34.      {
  35.          return FALSE;
  36.      }
  37.      else
  38.      {
  39.          __try{
  40.              NtHeader = RtlImageNtHeader(MappingBaseAddress);
  41.              if (NtHeader && NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  42.              {
  43.                  ExportDirectory =(IMAGE_EXPORT_DIRECTORY*)((ULONG64)MappingBaseAddress + NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  44.  
  45.                  AddressOfFunctions = (ULONG32*)((ULONG64)MappingBaseAddress + ExportDirectory->AddressOfFunctions);
  46.                  AddressOfNames = (ULONG32*)((ULONG64)MappingBaseAddress + ExportDirectory->AddressOfNames);
  47.                  AddressOfNameOrdinals = (USHORT*)((ULONG64)MappingBaseAddress + ExportDirectory->AddressOfNameOrdinals);
  48.                  for(i = ; i < ExportDirectory->NumberOfNames; i++)
  49.                  {
  50.                      szFunctionName = (char*)((ULONG64)MappingBaseAddress + AddressOfNames[i]);   //获得函数名称
  51.                      if (_stricmp(szFunctionName, szFindFunctionName) == )
  52.                      {
  53.                          ulFunctionOrdinal = AddressOfNameOrdinals[i];
  54.                          ulFunctionAddress = (ULONG64)((ULONG64)MappingBaseAddress + AddressOfFunctions[ulFunctionOrdinal]);
  55.  
  56.                          *SSDTFunctionIndex = *(ULONG32*)(ulFunctionAddress+ulOffset_SSDTFunctionIndex);
  57.                          break;
  58.                      }
  59.                  }
  60.              }
  61.          }__except(EXCEPTION_EXECUTE_HANDLER)
  62.          {
  63.              ;
  64.          }
  65.      }
  66.  
  67.      ZwUnmapViewOfSection(NtCurrentProcess(), MappingBaseAddress);
  68.  
  69.      if (*SSDTFunctionIndex==-)
  70.      {
  71.          return FALSE;
  72.      }
  73.  
  74.      return TRUE;
  75.  }

获取函数索引64

3.保存原先函数的地址

64位与32位不同 64为中存放的并不是SSDT函数的完整地址而是其相对于

ServiceTableBase[Index]>>4 的数据（称它为偏移地址）

4.在32位中换掉Base中索引里的数据 NtOpenProcess    Base[索引] == FakeNtOpenProcess  -->HookSSDT

在32位中 直接替换就可以了但是......................

/* 一系列的说明 作者：胡文亮 */

HOOK SSDT 就很简单了，首先获得待 HOOK 函数的序号
Index，然后通过公式把自己的代理函数的地址转化为偏移地址，然后把偏移地
址的数据填入 ServiceTableBase[Index]。也许有些读者看到这里，已经觉得胜
利在望了，我当时也是如此。但实际上我在这里栽了个大跟头，整整郁闷了很长
时间！因为我低估了设计这套算法的工程师的智商，我没有考虑一个问题，为什
么 WIN64 的 SSDT 表存放地址的形式这么奇怪？只存放偏移地址，而不存放完整
地址？难道是为了节省内存？这肯定是不可能的，要知道现在内存白菜价。那么
不是为了节省内存，唯一的可能性就是要给试图挂钩 SSDT 的人制造麻烦！要知
道，WIN64 内核里每个驱动都 不在同一个 B 4GB 里，而 4 字节的整数只能表示 4GB
的范围！所以无论你怎么修改这个值，都跳不出 ntoskrnl 的手掌心。如果你想
通过修改这个值来跳转到你的代理函数， 那是绝对不可能的。 因为你的驱动的地
址不 可能跟 l ntoskrnl 在同一个 B 4GB 里。然而，这位工程师也低估了我们中国人
的智商， 在中国有两句成语， 这位工程师一定没听过， 叫 “明修栈道， 暗渡陈仓”
以及“上有政策，下有对策” 。虽然不能直接用 4 字节来表示自己的代理函数所
在的地址， 但是还是可以修改这个值的。 要知道， ntoskrnl 虽然有很多地方的代
码通常是不会被执行的， 比如 KeBugCheckEx。 所以我的办法是： 修改这个偏移地
址的值，使之跳转到 KeBugCheckEx ，然后在 x KeBugCheckEx 的头部写一个 2 12 字
节的 mov - - jmp ， 这是一个可以跨越 4GB B ！ 的跳转， 跳到我们的函数里！

  1.  VOID HookSSDTWin7_X64(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG64 ulFakeVariable)
  2.  {
  3.      //寻找一个内核不常用的函数(KeBugCheckEx) 进行InlineHook使其跳转到Fake_NtOpenProcess函数
  4.      ULONG32  ulVariable = ;
  5.  
  6.      WPOFF();
  7.      InlineHook(KeBugCheckEx,ulFakeVariable,szOldKeBugCheckExCode,);
  8.      WPON();
  9.  
  10.      //寻找一个内核不常用的函数(KeBugCheckEx) 计算SSDT中的偏移 进行置换
  11.  
  12.      ulVariable = CalcFunctionOffsetInSSDT(KeBugCheckEx,);
  13.  
  14.      WPOFF();
  15.      ServiceTableBase[ulSSDTFunctionIndex] = (ULONG32)ulVariable;
  16.      WPON();
  17.  }

HookSSDT64

  1.  VOID HookSSDTWinXP_X86(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulFakeVariable)
  2.  {
  3.      WPOFF();
  4.      ServiceTableBase[ulSSDTFunctionIndex] = (ULONG32)ulFakeVariable;
  5.      WPON();
  6.  }

HookSSDT32

完整代码

  1.  #ifndef CXX_HOOKSSDT_H
  2.  #    include "HookSSDT.h"
  3.  #endif
  4.  
  5.  //1获得SSDT表的结构信息     Base
  6.  //2从Ntdll模块中的导出表获得要Hook的函数索引
  7.  //3换掉Base中索引里的数据 NtOpenProcess    Base[索引] == FakeNtOpenProcess      --->HookSSDT
  8.  
  9.  PULONG32  ServiceTableBase            = NULL;
  10.  ULONG32   SSDT_NtOpenProcessIndex     = ;
  11.  pfnNtOpenProcess  Old_NtOpenProcess  = NULL;
  12.  ULONG32           Old_NtOpenProcessOffset = ;    //针对Win7 x64
  13.  
  14.  UCHAR             szOldKeBugCheckExCode[] = {};
  15.  NTSTATUS  DriverEntry(PDRIVER_OBJECT  DriverObject,PUNICODE_STRING RegisterPath)
  16.  {
  17.  
  18.  #ifdef _WIN64
  19.      ULONG64   SSDTAddress = NULL;
  20.      ULONG32   ulVariable  = ;
  21.  
  22.      CHAR      szFindFunctionName[] = "ZwOpenProcess";
  23.  
  24.      if (GetSSDTAddressInWin7_X64(&SSDTAddress)==FALSE)
  25.      {
  26.          return STATUS_UNSUCCESSFUL;
  27.      }
  28.  
  29.      DbgPrint("Win7x64 SSDT:%p\r\n",SSDTAddress);
  30.      DbgPrint("Win7x64 SSDTBase:%p\r\n",((PSYSTEM_SERVICE_TABLE)SSDTAddress)->ServiceTableBase);
  31.  
  32.      /*
  33.      kd> dd FFFFF80003E8B300 l 200
  34.      fffff800`03e8b300  040d9a00 02f55c00 fff6ea00 02e87805
  35.      fffff800`03e8b310  031a4a06 03116a05 02bb9901 02b4f200
  36.      fffff800`03e8b320  0312cc40 03dd7400 02c84700 02e7d100
  37.      fffff800`03e8b330  02f68100 02e02301 02dd0601 02d96100
  38.      fffff800`03e8b340  02df4602 02f18600 02ad0500 02cefe01
  39.      fffff800`03e8b350  02d01d02 02f69902 03101101 0323ca01
  40.      fffff800`03e8b360  0455c305 02ed29c0 02b2e703 ffec1d00
  41.      fffff800`03e8b370  043c2800 02f51040 02c52c01 03126c00
  42.      fffff800`03e8b380  02d96302 02d30380 02ec7301 02d1fec0(NtOpenProcess Offset)
  43.  
  44.      */
  45.  
  46.      /*
  47.      kd> u NtOpenProcess
  48.      nt!NtOpenProcess:
  49.      fffff800`0415d2ec 4883ec38        sub     rsp,38h
  50.      fffff800`0415d2f0 65488b042588010000 mov   rax,qword ptr gs:[188h]
  51.      fffff800`0415d2f9 448a90f6010000  mov     r10b,byte ptr [rax+1F6h]
  52.      fffff800`0415d300 4488542428      mov     byte ptr [rsp+28h],r10b
  53.      fffff800`0415d305 4488542420      mov     byte ptr [rsp+20h],r10b
  54.      fffff800`0415d30a e851fcffff      call    nt!PsOpenProcess (fffff800`0415cf60)
  55.      fffff800`0415d30f 4883c438        add     rsp,38h
  56.      fffff800`0415d313 c3              ret
  57.  
  58.      */
  59.  
  60.      //fffff8000415d2ec - FFFFF80003E8B300 = 2D1FEC<<4 = 2D1FEC0
  61.      DbgPrint("Win7x64 SSDTNumberOfService:%d\r\n",((PSYSTEM_SERVICE_TABLE)SSDTAddress)->NumberOfServices);
  62.  
  63.      if (GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWin7_X64(szFindFunctionName,&SSDT_NtOpenProcessIndex)==FALSE)
  64.      {
  65.          return STATUS_UNSUCCESSFUL;
  66.      }
  67.  
  68.      DbgPrint("Win7x64 SSDT_NtOpenProcessIndex:%d\r\n",SSDT_NtOpenProcessIndex);
  69.  
  70.      ServiceTableBase   = (PULONG32)((PSYSTEM_SERVICE_TABLE)SSDTAddress)->ServiceTableBase;
  71.      Old_NtOpenProcessOffset  = (ULONG32)(ServiceTableBase[SSDT_NtOpenProcessIndex]);
  72.      ulVariable = Old_NtOpenProcessOffset>>;
  73.      Old_NtOpenProcess = (ULONG64)((PSYSTEM_SERVICE_TABLE)SSDTAddress)->ServiceTableBase + ulVariable;
  74.      DbgPrint("Win7x64 Old_NtOpenProcess:%p\r\n",ulVariable);
  75.  
  76.      /*
  77.      kd> u FFFFF8000415D2EC
  78.      nt!NtOpenProcess:
  79.      fffff800`0415d2ec 4883ec38        sub     rsp,38h
  80.      fffff800`0415d2f0 65488b042588010000 mov   rax,qword ptr gs:[188h]
  81.      fffff800`0415d2f9 448a90f6010000  mov     r10b,byte ptr [rax+1F6h]
  82.      fffff800`0415d300 4488542428      mov     byte ptr [rsp+28h],r10b
  83.      fffff800`0415d305 4488542420      mov     byte ptr [rsp+20h],r10b
  84.      fffff800`0415d30a e851fcffff      call    nt!PsOpenProcess (fffff800`0415cf60)
  85.      fffff800`0415d30f 4883c438        add     rsp,38h
  86.      fffff800`0415d313 c3              ret
  87.      */
  88.  
  89.      HookSSDTWin7_X64(ServiceTableBase,SSDT_NtOpenProcessIndex,(ULONG64)Fake_NtOpenProcess);
  90.  #else
  91.      ULONG32   SSDTAddress      = NULL;
  92.      CHAR      szFindFunctionName[] = "ZwOpenProcess";
  93.  
  94.      if (GetSSDTAddressInWinXP_X86(&SSDTAddress)==FALSE)
  95.      {
  96.          return STATUS_UNSUCCESSFUL;
  97.      }
  98.      DbgPrint("WinXPx86 SSDT:%p\r\n",SSDTAddress);
  99.      DbgPrint("WinXPx86 SSDTBase:%p\r\n",((PSYSTEM_SERVICE_TABLE)SSDTAddress)->ServiceTableBase);
  100.      /*
  101.      kd> dd 804E58A0 l 200   SSDTBase
  102.      804e58a0  80591bfb 80585356 805e1f35 805dbc47
  103.      804e58b0  805e1fbc 80640cc2 80642e4b 80642e94
  104.      804e58c0  805835b2 80650bbb 8064047d 805e1787
  105.      804e58d0  8063878a 80586fa1 805e08e8 8062f432
  106.      804e58e0  805d9781 80571d45 805e8258 805e939e
  107.      804e58f0  804e5eb4 80650ba7 805cd537 804ed812
  108.      804e5900  805719b7 80570af2 805e1b65 80656cec
  109.      804e5910  805e0ff3 805887b7 80656f5b 80586563
  110.      804e5920  804e221d 8066239e 805aa76b 8057dd2d
  111.      804e5930  8065120c 8057d330 805db662 805d6cd6
  112.      804e5940  80638c31 80578925 805d7e7f 805803c0
  113.      804e5950  80589caa 805b5823 8059a02a 805b1470
  114.      804e5960  8058c7cd 8065182d 8056eb66 8057b9e4
  115.      804e5970  805e7e56 80587c43 80598cb2 805a7ada
  116.      804e5980  805ab552 80663519 80663673 8056fb07
  117.      804e5990  805ddc8b 80650ba7 805d64ac 80594334
  118.      804e59a0  80642eef 80592f8b 805899a6 805b6cd8
  119.      804e59b0  8058221e 80584451 80650bbb 80579e1c
  120.      804e59c0  80650b93 80588691 8062e3f1 805cf473
  121.      804e59d0  805e36f2 80586ceb 80588bf9 805da3bb
  122.      804e59e0  805e9ab6 8062fc8f 8062f7e5 805723df
  123.      804e59f0  805813f3 80636711 80634be3 8059c497
  124.      804e5a00  8054070f 80599bde 805e0d66 8058968d
  125.      804e5a10  805aad25 806349af 80638ae7 80634bca
  126.      804e5a20  805aab94 805a9f96 805cf7e5 805cf944
  127.      804e5a30  805de058 805cece7 805c8155 805af0d5
  128.      804e5a40  805e804c 805e8113 8062ea8e 8062eee7
  129.      804e5a50  8057f371 80650ba7 805de2ef 805e318f
  130.      804e5a60  805e2fa1 8058b0b6 8058aa51 806512fd
  131.      804e5a70  8057d4a4 806220ab 80638e89 80573bfc
  132.      804e5a80  8058046e 805ea252 8058270a(NtOpenProcess) 80578308
  133.  
  134.      */
  135.      DbgPrint("WinXPx86 SSDTNumberOfService:%d\r\n",((PSYSTEM_SERVICE_TABLE)SSDTAddress)->NumberOfServices);
  136.  
  137.      if (GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWinXP_X86(szFindFunctionName,&SSDT_NtOpenProcessIndex)==FALSE)
  138.      {
  139.          return STATUS_UNSUCCESSFUL;
  140.      }
  141.      DbgPrint("WinXPx86 SSDT_NtOpenProcessIndex:%d\r\n",SSDT_NtOpenProcessIndex);
  142.  
  143.      //先保存原先的函数地址
  144.      ServiceTableBase   = (PULONG32)((PSYSTEM_SERVICE_TABLE)SSDTAddress)->ServiceTableBase;
  145.      Old_NtOpenProcess  = (pfnNtOpenProcess)(ServiceTableBase[SSDT_NtOpenProcessIndex]);
  146.      DbgPrint("WinXPx86 Old_NtOpenProcess:%p\r\n",Old_NtOpenProcess);
  147.  
  148.      /*
  149.      kd> u 8058270A
  150.      nt!NtOpenProcess:
  151.      8058270a 68c4000000      push    0C4h
  152.      8058270f 68d8524f80      push    offset nt!ObWatchHandles+0x25c (804f52d8)
  153.      80582714 e85a17f6ff      call    nt!_SEH_prolog (804e3e73)
  154.      80582719 33f6            xor     esi,esi
  155.      8058271b 8975d4          mov     dword ptr [ebp-2Ch],esi
  156.      8058271e 33c0            xor     eax,eax
  157.      80582720 8d7dd8          lea     edi,[ebp-28h]
  158.      80582723 ab              stos    dword ptr es:[edi]
  159.  
  160.      */
  161.      HookSSDTWinXP_X86(ServiceTableBase,SSDT_NtOpenProcessIndex,(ULONG32)Fake_NtOpenProcess);
  162.  
  163.  #endif
  164.  
  165.      DriverObject->DriverUnload = UnloadDriver;
  166.  
  167.      return  STATUS_SUCCESS;
  168.  }
  169.  
  170.  //SSDT表的基地址32位(4Bytes)64位(8Bytes)
  171.  //XP 32位Ntos模块导出表中有   Win7 64 Ntos模块导出表中无
  172.  BOOLEAN GetSSDTAddressInWinXP_X86(ULONG32* SSDTAddress)
  173.  {
  174.      //从NtosKernel.exe 模块中的导出表获得该导出变量  KeServiceDescriptorTable
  175.  
  176.      /*
  177.      kd> dd KeServiceDescriptorTable
  178.      80563520  804e58a0 00000000 0000011c 805120bc
  179.      */
  180.      *SSDTAddress = NULL;
  181.      *SSDTAddress = (ULONG32)GetExportVariableAddressFormNtosExportTableByVariableName(L"KeServiceDescriptorTable");
  182.  
  183.      if (*SSDTAddress!=NULL)
  184.      {
  185.          return TRUE;
  186.      }
  187.  
  188.      return FALSE;
  189.  }
  190.  
  191.  BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWinXP_X86(CHAR* szFindFunctionName,ULONG32* SSDTFunctionIndex)
  192.  {
  193.      /*
  194.      0:001> u zwopenprocess
  195.      ntdll!ZwOpenProcess:
  196.      7c92d5e0 b87a000000      mov     eax,7Ah
  197.      7c92d5e5 ba0003fe7f      mov     edx,offset SharedUserData!SystemCallStub (7ffe0300)
  198.      7c92d5ea ff12            call    dword ptr [edx]
  199.      7c92d5ec c21000          ret     10h
  200.      7c92d5ef 90              nop
  201.      */
  202.  
  203.      ULONG32     ulOffset_SSDTFunctionIndex = ;
  204.  
  205.      //从Ntdll模块的导出表中获得7c92d5e0
  206.      //使用内存映射将Ntdll模块映射到System进程的内存空间进行查找(Ntdll.dll模块的导出表中进行搜索)
  207.      ULONG   i;
  208.      BOOLEAN  bOk = FALSE;
  209.      WCHAR    wzFileFullPath[] = L"\\SystemRoot\\System32\\ntdll.dll";
  210.      SIZE_T  MappingViewSize   = ;
  211.      PVOID    MappingBaseAddress = NULL;
  212.      PIMAGE_NT_HEADERS  NtHeader = NULL;
  213.      PIMAGE_EXPORT_DIRECTORY ExportDirectory = NULL;
  214.      ULONG32*  AddressOfFunctions    = NULL;
  215.      ULONG32*  AddressOfNames        = NULL;
  216.      USHORT* AddressOfNameOrdinals = NULL;
  217.      CHAR*   szFunctionName        = NULL;
  218.      ULONG32 ulFunctionOrdinal     = ;
  219.      ULONG32 ulFunctionAddress     = ;
  220.  
  221.      *SSDTFunctionIndex = -;
  222.  
  223.      //将Ntdll.dll 当前的空间中
  224.      bOk = MappingPEFileInRing0Space(wzFileFullPath,&MappingBaseAddress, &MappingViewSize);
  225.      if (bOk==FALSE)
  226.      {
  227.          return FALSE;
  228.      }
  229.      else
  230.      {
  231.          __try{
  232.              NtHeader = RtlImageNtHeader(MappingBaseAddress);
  233.              if (NtHeader && NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  234.              {
  235.                  ExportDirectory =(IMAGE_EXPORT_DIRECTORY*)((ULONG32)MappingBaseAddress + NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  236.  
  237.                  AddressOfFunctions = (ULONG32*)((ULONG32)MappingBaseAddress + ExportDirectory->AddressOfFunctions);
  238.                  AddressOfNames = (ULONG32*)((ULONG32)MappingBaseAddress + ExportDirectory->AddressOfNames);
  239.                  AddressOfNameOrdinals = (USHORT*)((ULONG32)MappingBaseAddress + ExportDirectory->AddressOfNameOrdinals);
  240.                  for(i = ; i < ExportDirectory->NumberOfNames; i++)
  241.                  {
  242.                      szFunctionName = (char*)((ULONG32)MappingBaseAddress + AddressOfNames[i]);   //获得函数名称
  243.                      if (_stricmp(szFunctionName, szFindFunctionName) == )
  244.                      {
  245.                          ulFunctionOrdinal = AddressOfNameOrdinals[i];
  246.                          ulFunctionAddress = (ULONG32)((ULONG32)MappingBaseAddress + AddressOfFunctions[ulFunctionOrdinal]);
  247.  
  248.                          *SSDTFunctionIndex = *(ULONG32*)(ulFunctionAddress+ulOffset_SSDTFunctionIndex);
  249.                          break;
  250.                      }
  251.                  }
  252.              }
  253.          }__except(EXCEPTION_EXECUTE_HANDLER)
  254.          {
  255.              ;
  256.          }
  257.      }
  258.  
  259.      ZwUnmapViewOfSection(NtCurrentProcess(), MappingBaseAddress);
  260.  
  261.      if (*SSDTFunctionIndex==-)
  262.      {
  263.          return FALSE;
  264.      }
  265.  
  266.      return TRUE;
  267.  }
  268.  
  269.  BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWin7_X64(CHAR* szFindFunctionName,ULONG32* SSDTFunctionIndex)
  270.  {
  271.      /*
  272.      0:004> u zwopenprocess
  273.      ntdll!NtOpenProcess:
  274.      00000000`774ddc10 4c8bd1          mov     r10,rcx
  275.      00000000`774ddc13 b823000000      mov     eax,23h
  276.      00000000`774ddc18 0f05            syscall
  277.      00000000`774ddc1a c3              ret
  278.      00000000`774ddc1b 0f1f440000      nop     dword ptr [rax+rax]
  279.      */
  280.  
  281.      ULONG32     ulOffset_SSDTFunctionIndex = ;
  282.  
  283.      ULONG   i;
  284.      BOOLEAN  bOk = FALSE;
  285.      WCHAR    wzFileFullPath[] = L"\\SystemRoot\\System32\\ntdll.dll";
  286.      SIZE_T   MappingViewSize   = ;
  287.      PVOID    MappingBaseAddress = NULL;
  288.      PIMAGE_NT_HEADERS  NtHeader = NULL;
  289.      PIMAGE_EXPORT_DIRECTORY ExportDirectory = NULL;
  290.      ULONG32*  AddressOfFunctions    = NULL;
  291.      ULONG32*  AddressOfNames        = NULL;
  292.      USHORT*   AddressOfNameOrdinals = NULL;
  293.      CHAR*     szFunctionName        = NULL;
  294.      ULONG32   ulFunctionOrdinal     = ;
  295.      ULONG64   ulFunctionAddress     = ;
  296.  
  297.      *SSDTFunctionIndex = -;
  298.  
  299.      //将Ntdll.dll 当前的空间中
  300.      bOk = MappingPEFileInRing0Space(wzFileFullPath,&MappingBaseAddress, &MappingViewSize);
  301.      if (bOk==FALSE)
  302.      {
  303.          return FALSE;
  304.      }
  305.      else
  306.      {
  307.          __try{
  308.              NtHeader = RtlImageNtHeader(MappingBaseAddress);
  309.              if (NtHeader && NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  310.              {
  311.                  ExportDirectory =(IMAGE_EXPORT_DIRECTORY*)((ULONG64)MappingBaseAddress + NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  312.  
  313.                  AddressOfFunctions = (ULONG32*)((ULONG64)MappingBaseAddress + ExportDirectory->AddressOfFunctions);
  314.                  AddressOfNames = (ULONG32*)((ULONG64)MappingBaseAddress + ExportDirectory->AddressOfNames);
  315.                  AddressOfNameOrdinals = (USHORT*)((ULONG64)MappingBaseAddress + ExportDirectory->AddressOfNameOrdinals);
  316.                  for(i = ; i < ExportDirectory->NumberOfNames; i++)
  317.                  {
  318.                      szFunctionName = (char*)((ULONG64)MappingBaseAddress + AddressOfNames[i]);   //获得函数名称
  319.                      if (_stricmp(szFunctionName, szFindFunctionName) == )
  320.                      {
  321.                          ulFunctionOrdinal = AddressOfNameOrdinals[i];
  322.                          ulFunctionAddress = (ULONG64)((ULONG64)MappingBaseAddress + AddressOfFunctions[ulFunctionOrdinal]);
  323.  
  324.                          *SSDTFunctionIndex = *(ULONG32*)(ulFunctionAddress+ulOffset_SSDTFunctionIndex);
  325.                          break;
  326.                      }
  327.                  }
  328.              }
  329.          }__except(EXCEPTION_EXECUTE_HANDLER)
  330.          {
  331.              ;
  332.          }
  333.      }
  334.  
  335.      ZwUnmapViewOfSection(NtCurrentProcess(), MappingBaseAddress);
  336.  
  337.      if (*SSDTFunctionIndex==-)
  338.      {
  339.          return FALSE;
  340.      }
  341.  
  342.      return TRUE;
  343.  }
  344.  
  345.  BOOLEAN GetSSDTAddressInWin7_X64(ULONG64* SSDTAddress)
  346.  {
  347.  
  348.      /*
  349.      kd> rdmsr c0000082
  350.      msr[c0000082] = fffff800`03ecf640
  351.      kd> u fffff800`03ecf640 l 50
  352.      nt!KiSystemCall64:
  353.      fffff800`03ecf640 0f01f8          swapgs
  354.      fffff800`03ecf643 654889242510000000 mov   qword ptr gs:[10h],rsp
  355.      fffff800`03ecf64c 65488b2425a8010000 mov   rsp,qword ptr gs:[1A8h]
  356.      fffff800`03ecf655 6a2b            push    2Bh
  357.      fffff800`03ecf657 65ff342510000000 push    qword ptr gs:[10h]
  358.      fffff800`03ecf65f 4153            push    r11
  359.      fffff800`03ecf661 6a33            push    33h
  360.      fffff800`03ecf663 51              push    rcx
  361.      fffff800`03ecf664 498bca          mov     rcx,r10
  362.      fffff800`03ecf667 4883ec08        sub     rsp,8
  363.      fffff800`03ecf66b 55              push    rbp
  364.      fffff800`03ecf66c 4881ec58010000  sub     rsp,158h
  365.      fffff800`03ecf673 488dac2480000000 lea     rbp,[rsp+80h]
  366.      fffff800`03ecf67b 48899dc0000000  mov     qword ptr [rbp+0C0h],rbx
  367.      fffff800`03ecf682 4889bdc8000000  mov     qword ptr [rbp+0C8h],rdi
  368.      fffff800`03ecf689 4889b5d0000000  mov     qword ptr [rbp+0D0h],rsi
  369.      fffff800`03ecf690 c645ab02        mov     byte ptr [rbp-55h],2
  370.      fffff800`03ecf694 65488b1c2588010000 mov   rbx,qword ptr gs:[188h]
  371.      fffff800`03ecf69d 0f0d8bd8010000  prefetchw [rbx+1D8h]
  372.      fffff800`03ecf6a4 0fae5dac        stmxcsr dword ptr [rbp-54h]
  373.      fffff800`03ecf6a8 650fae142580010000 ldmxcsr dword ptr gs:[180h]
  374.      fffff800`03ecf6b1 807b0300        cmp     byte ptr [rbx+3],0
  375.      fffff800`03ecf6b5 66c785800000000000 mov   word ptr [rbp+80h],0
  376.      fffff800`03ecf6be 0f848c000000    je      nt!KiSystemCall64+0x110 (fffff800`03ecf750)
  377.      fffff800`03ecf6c4 488945b0        mov     qword ptr [rbp-50h],rax
  378.      fffff800`03ecf6c8 48894db8        mov     qword ptr [rbp-48h],rcx
  379.      fffff800`03ecf6cc 488955c0        mov     qword ptr [rbp-40h],rdx
  380.      fffff800`03ecf6d0 f6430303        test    byte ptr [rbx+3],3
  381.      fffff800`03ecf6d4 4c8945c8        mov     qword ptr [rbp-38h],r8
  382.      fffff800`03ecf6d8 4c894dd0        mov     qword ptr [rbp-30h],r9
  383.      fffff800`03ecf6dc 7405            je      nt!KiSystemCall64+0xa3 (fffff800`03ecf6e3)
  384.      fffff800`03ecf6de e80d140000      call    nt!KiSaveDebugRegisterState (fffff800`03ed0af0)
  385.      fffff800`03ecf6e3 f6430380        test    byte ptr [rbx+3],80h
  386.      fffff800`03ecf6e7 7442            je      nt!KiSystemCall64+0xeb (fffff800`03ecf72b)
  387.      fffff800`03ecf6e9 b9020100c0      mov     ecx,0C0000102h
  388.      fffff800`03ecf6ee 0f32            rdmsr
  389.      fffff800`03ecf6f0 48c1e220        shl     rdx,20h
  390.      fffff800`03ecf6f4 480bc2          or      rax,rdx
  391.      fffff800`03ecf6f7 483983b8000000  cmp     qword ptr [rbx+0B8h],rax
  392.      fffff800`03ecf6fe 742b            je      nt!KiSystemCall64+0xeb (fffff800`03ecf72b)
  393.      fffff800`03ecf700 483983b0010000  cmp     qword ptr [rbx+1B0h],rax
  394.      fffff800`03ecf707 7422            je      nt!KiSystemCall64+0xeb (fffff800`03ecf72b)
  395.      fffff800`03ecf709 488b93b8010000  mov     rdx,qword ptr [rbx+1B8h]
  396.      fffff800`03ecf710 0fba6b4c0b      bts     dword ptr [rbx+4Ch],0Bh
  397.      fffff800`03ecf715 66ff8bc4010000  dec     word ptr [rbx+1C4h]
  398.      fffff800`03ecf71c 48898280000000  mov     qword ptr [rdx+80h],rax
  399.      fffff800`03ecf723 fb              sti
  400.      fffff800`03ecf724 e8170b0000      call    nt!KiUmsCallEntry (fffff800`03ed0240)
  401.      fffff800`03ecf729 eb0f            jmp     nt!KiSystemCall64+0xfa (fffff800`03ecf73a)
  402.      fffff800`03ecf72b f6430340        test    byte ptr [rbx+3],40h
  403.      fffff800`03ecf72f 7409            je      nt!KiSystemCall64+0xfa (fffff800`03ecf73a)
  404.      fffff800`03ecf731 f00fbaab0001000008 lock bts dword ptr [rbx+100h],8
  405.      fffff800`03ecf73a 488b45b0        mov     rax,qword ptr [rbp-50h]
  406.      fffff800`03ecf73e 488b4db8        mov     rcx,qword ptr [rbp-48h]
  407.      fffff800`03ecf742 488b55c0        mov     rdx,qword ptr [rbp-40h]
  408.      fffff800`03ecf746 4c8b45c8        mov     r8,qword ptr [rbp-38h]
  409.      fffff800`03ecf74a 4c8b4dd0        mov     r9,qword ptr [rbp-30h]
  410.      fffff800`03ecf74e 6690            xchg    ax,ax
  411.      fffff800`03ecf750 fb              sti
  412.      fffff800`03ecf751 48898be0010000  mov     qword ptr [rbx+1E0h],rcx
  413.      fffff800`03ecf758 8983f8010000    mov     dword ptr [rbx+1F8h],eax
  414.      nt!KiSystemServiceStart:
  415.      fffff800`03ecf75e 4889a3d8010000  mov     qword ptr [rbx+1D8h],rsp
  416.      fffff800`03ecf765 8bf8            mov     edi,eax
  417.      fffff800`03ecf767 c1ef07          shr     edi,7
  418.      fffff800`03ecf76a 83e720          and     edi,20h
  419.      fffff800`03ecf76d 25ff0f0000      and     eax,0FFFh
  420.      nt!KiSystemServiceRepeat:
  421.      fffff800`03ecf772 4c8d15c7202300  lea     r10,[nt!KeServiceDescriptorTable (fffff800`04101840)]
  422.  
  423.      fffff800`03ecf772 + 002320c7 + 7  = fffff800`04101840
  424.      */
  425.  
  426.      PUCHAR StartSearchAddress = (PUCHAR)__readmsr(0xC0000082);   //fffff800`03ecf640
  427.      PUCHAR EndSearchAddress = StartSearchAddress + 0x500;
  428.      PUCHAR i = NULL;
  429.      UCHAR   v1=,v2=,v3=;
  430.      INT64   iOffset = ;    //002320c7
  431.      ULONG64 VariableAddress = ;
  432.      *SSDTAddress = NULL;
  433.      for(i=StartSearchAddress;i<EndSearchAddress;i++)
  434.      {
  435.          if( MmIsAddressValid(i) && MmIsAddressValid(i+) && MmIsAddressValid(i+) )
  436.          {
  437.              v1=*i;
  438.              v2=*(i+);
  439.              v3=*(i+);
  440.              if(v1==0x4c && v2==0x8d && v3==0x15 )
  441.              {
  442.                  memcpy(&iOffset,i+,);
  443.                  *SSDTAddress = iOffset + (ULONG64)i + ;
  444.  
  445.                  break;
  446.              }
  447.          }
  448.      }
  449.  
  450.      if (*SSDTAddress==NULL)
  451.      {
  452.          return FALSE;
  453.      }
  454.  
  455.      /*
  456.      kd> dq fffff800`04101840
  457.      fffff800`04101840  fffff800`03ed1300 00000000`00000000
  458.      fffff800`04101850  00000000`00000191 fffff800`03ed1f8c
  459.  
  460.      */
  461.      return TRUE;
  462.  }
  463.  
  464.  PVOID
  465.  GetExportVariableAddressFormNtosExportTableByVariableName(WCHAR *wzVariableName)
  466.  {
  467.      UNICODE_STRING uniVariableName;
  468.      PVOID VariableAddress = NULL;
  469.  
  470.      if (wzVariableName && wcslen(wzVariableName) > )
  471.      {
  472.          RtlInitUnicodeString(&uniVariableName, wzVariableName);  
  473.  
  474.          //从Ntos模块的导出表中获得一个导出变量的地址
  475.          VariableAddress = MmGetSystemRoutineAddress(&uniVariableName);
  476.      }
  477.  
  478.      return VariableAddress;
  479.  }
  480.  
  481.  VOID  UnloadDriver(PDRIVER_OBJECT DriverObject)
  482.  {
  483.  
  484.  #ifdef _WIN64
  485.      UnHookSSDTWin7_X64(ServiceTableBase,SSDT_NtOpenProcessIndex,(ULONG32)Old_NtOpenProcessOffset);
  486.  #else
  487.      UnHookSSDTWinXP_X86(ServiceTableBase,SSDT_NtOpenProcessIndex,(ULONG32)Old_NtOpenProcess);
  488.  #endif
  489.  
  490.  }
  491.  
  492.  VOID HookSSDTWin7_X64(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG64 ulFakeVariable)
  493.  {
  494.      //寻找一个内核不常用的函数(KeBugCheckEx) 进行InlineHook使其跳转到Fake_NtOpenProcess函数
  495.      ULONG32  ulVariable = ;
  496.  
  497.      WPOFF();
  498.      InlineHook(KeBugCheckEx,ulFakeVariable,szOldKeBugCheckExCode,);
  499.      WPON();
  500.  
  501.      //寻找一个内核不常用的函数(KeBugCheckEx) 计算SSDT中的偏移 进行置换
  502.  
  503.      ulVariable = CalcFunctionOffsetInSSDT(KeBugCheckEx,);
  504.  
  505.      WPOFF();
  506.      ServiceTableBase[ulSSDTFunctionIndex] = (ULONG32)ulVariable;
  507.      WPON();
  508.  }
  509.  
  510.  VOID HookSSDTWinXP_X86(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulFakeVariable)
  511.  {
  512.      WPOFF();
  513.      ServiceTableBase[ulSSDTFunctionIndex] = (ULONG32)ulFakeVariable;
  514.      WPON();
  515.  }
  516.  
  517.  VOID
  518.  UnHookSSDTWin7_X64(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulOldVariable)
  519.  {
  520.  
  521.      WPOFF();
  522.      UnInlineHook(KeBugCheckEx,szOldKeBugCheckExCode,);
  523.      WPON();
  524.  
  525.      WPOFF();
  526.      ServiceTableBase[ulSSDTFunctionIndex] = (ULONG32)ulOldVariable;
  527.      WPON();
  528.  }
  529.  
  530.  VOID
  531.  UnHookSSDTWinXP_X86(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulOldVariable)
  532.  {
  533.      WPOFF();
  534.      ServiceTableBase[ulSSDTFunctionIndex] = (ULONG32)ulOldVariable;
  535.      WPON();
  536.  }
  537.  
  538.  //将Ntdll.dll 模块映射到System.exe进程空间中
  539.  BOOLEAN
  540.  MappingPEFileInRing0Space(WCHAR* wzFileFullPath,OUT PVOID* MappingBaseAddress,PSIZE_T MappingViewSize)
  541.  {
  542.      UNICODE_STRING    uniFileFullPath;
  543.      OBJECT_ATTRIBUTES oa;
  544.      NTSTATUS          Status;
  545.      IO_STATUS_BLOCK   Iosb;
  546.  
  547.      HANDLE   hFile = NULL;
  548.      HANDLE   hSection = NULL;
  549.  
  550.      if (!wzFileFullPath || !MappingBaseAddress){
  551.          return FALSE;
  552.      }
  553.  
  554.      RtlInitUnicodeString(&uniFileFullPath, wzFileFullPath);
  555.      InitializeObjectAttributes(&oa,
  556.          &uniFileFullPath,
  557.          OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
  558.          NULL,
  559.          NULL
  560.          );
  561.  
  562.      //获得文件句柄
  563.      Status = IoCreateFile(&hFile,
  564.          GENERIC_READ | SYNCHRONIZE,
  565.          &oa,   //文件绝对路径
  566.          &Iosb,
  567.          NULL,
  568.          FILE_ATTRIBUTE_NORMAL,
  569.          FILE_SHARE_READ,
  570.          FILE_OPEN,
  571.          FILE_SYNCHRONOUS_IO_NONALERT,
  572.          NULL,
  573.          ,
  574.          CreateFileTypeNone,
  575.          NULL,
  576.          IO_NO_PARAMETER_CHECKING
  577.          );
  578.      if (!NT_SUCCESS(Status))
  579.      {
  580.  
  581.          return FALSE;
  582.      }
  583.  
  584.      oa.ObjectName = NULL;
  585.      Status = ZwCreateSection(&hSection,
  586.          SECTION_QUERY | SECTION_MAP_READ,
  587.          &oa,
  588.          NULL,
  589.          PAGE_WRITECOPY,
  590.          SEC_IMAGE,  //??  指示内存对齐
  591.          hFile
  592.          );
  593.      ZwClose(hFile);
  594.      if (!NT_SUCCESS(Status))
  595.      {
  596.  
  597.          return FALSE;
  598.      }
  599.      Status = ZwMapViewOfSection(hSection,
  600.          NtCurrentProcess(),    //映射到当前进程的内存空间中
  601.          MappingBaseAddress,
  602.          ,
  603.          ,
  604.          ,
  605.          MappingViewSize,
  606.          ViewUnmap,
  607.          ,
  608.          PAGE_WRITECOPY
  609.          );
  610.      ZwClose(hSection);
  611.      if (!NT_SUCCESS(Status))
  612.      {
  613.          return FALSE;
  614.      }
  615.  
  616.      return TRUE;
  617.  }
  618.  
  619.  VOID WPOFF()
  620.  {
  621.      //选择性编译，是给编译器看的
  622.  #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
  623.      _disable();
  624.      __writecr0(__readcr0() & (~(0x10000)));
  625.  #else
  626.      __asm
  627.      {
  628.          CLI  ;
  629.          MOV    EAX, CR0;
  630.          AND    EAX, NOT 10000H;
  631.          MOV    CR0, EAX;
  632.      }
  633.  #endif
  634.  }
  635.  VOID WPON()
  636.  {
  637.  #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
  638.      __writecr0(__readcr0() ^ 0x10000);
  639.      _enable();
  640.  #else
  641.      __asm
  642.      {
  643.          MOV    EAX, CR0;
  644.          OR     EAX, 10000H;
  645.          MOV    CR0, EAX;
  646.          STI;
  647.      }
  648.  #endif
  649.  }
  650.  
  651.  NTSTATUS Fake_NtOpenProcess(
  652.      PHANDLE ProcessHandle,
  653.      ACCESS_MASK DesiredAccess,
  654.      POBJECT_ATTRIBUTES ObjectAttributes,PCLIENT_ID ClientId)
  655.  {
  656.      PEPROCESS  EProcess = PsGetCurrentProcess();    //进程上下背景文
  657.      if (EProcess!=NULL)
  658.      {
  659.          //通过EProcess 获得进程名称 
  660.  
  661.          char *szProcessImageName = PsGetProcessImageFileName(EProcess);
  662.  
  663.          if (strstr(szProcessImageName,"EnumProcess")!=)
  664.          {
  665.  
  666.              return STATUS_ACCESS_DENIED;
  667.          }
  668.      }
  669.  
  670.      Old_NtOpenProcess(ProcessHandle,DesiredAccess,ObjectAttributes,ClientId);
  671.  }
  672.  
  673.  ULONG32 CalcFunctionOffsetInSSDT(ULONG64 ulFunctionAddress,ULONG32 ulParamCount)
  674.  {
  675.  
  676.      /*
  677.      kd> rdmsr c0000082
  678.      msr[c0000082] = fffff800`03edd640
  679.  
  680.      kd>u fffff800`03edd640
  681.      fffff800`03edd751 48898be0010000  mov     qword ptr [rbx+1E0h],rcx
  682.      fffff800`03edd758 8983f8010000    mov     dword ptr [rbx+1F8h],eax
  683.      nt!KiSystemServiceStart:
  684.      fffff800`03edd75e 4889a3d8010000  mov     qword ptr [rbx+1D8h],rsp
  685.      fffff800`03edd765 8bf8            mov     edi,eax
  686.      fffff800`03edd767 c1ef07          shr     edi,7
  687.      fffff800`03edd76a 83e720          and     edi,20h
  688.      fffff800`03edd76d 25ff0f0000      and     eax,0FFFh
  689.      nt!KiSystemServiceRepeat:
  690.      fffff800`03edd772 4c8d15c7202300  lea     r10,[nt!KeServiceDescriptorTable (fffff800`0410f840)]
  691.  
  692.      kd> dq fffff800`0410f840
  693.      fffff800`0410f840  fffff800`03edf300 00000000`00000000
  694.      fffff800`0410f850  00000000`00000191 fffff800`03edff8c
  695.      fffff800`0410f860  00000000`00000000 00000000`00000000
  696.      fffff800`0410f870  00000000`00000000 00000000`00000000
  697.  
  698.      kd> dd fffff800`03edf300
  699.      fffff800`03edf300  040d9a00 02f55c00 fff6ea00 02e87805
  700.      fffff800`03edf310  031a4a06 03116a05 02bb9901 02b4f200
  701.  
  702.      fffff800`03edf300 + (02e87805>>4) = FFFFF800041C7A80
  703.  
  704.      kd> u FFFFF800041C7A80
  705.      nt!NtReadFile:
  706.      fffff800`041c7a80 4c8bdc          mov     r11,rsp
  707.      fffff800`041c7a83 4d894b20        mov     qword ptr [r11+20h],r9
  708.      fffff800`041c7a87 4d894318        mov     qword ptr [r11+18h],r8
  709.      fffff800`041c7a8b 49895310        mov     qword ptr [r11+10h],rdx
  710.      fffff800`041c7a8f 53              push    rbx
  711.  
  712.      5 --->9
  713.      6 --->10
  714.  
  715.      如果一个函数的参数个数小于等于4  就是0
  716.  
  717.      */
  718.  
  719.      ULONG32 ulVariable = ,i;
  720.      CHAR v1 = ;
  721.  
  722.      CHAR   szBits[] = {};
  723.  
  724.      ulVariable = (ULONG32)(ulFunctionAddress-(ULONG64)ServiceTableBase);
  725.      ulVariable = ulVariable<<;
  726.  
  727.      if(ulParamCount>)
  728.      {
  729.          ulParamCount = ulParamCount-;     //NtReadFile  9个参数
  730.      }
  731.      else
  732.      {
  733.          ulParamCount = ;
  734.      }
  735.  
  736.      //处理低四位，填写参数个数   如果一个函数的参数为5 那么dwTemp的低4位就是 0001  如果参数是6 就是0002 因为 6要减4 
  737.  
  738.  #define SETBIT(x,y) x|=(1<<y)         //将X的第Y位置1
  739.  #define CLRBIT(x,y) x&=~(1<<y)        //将X的第Y位清0
  740.  #define GETBIT(x,y) (x & (1 << y))    //取X的第Y位，返回0或非0
  741.  
  742.      for(i=;i<;i++)    //一个16进制 4个二进制      0000
  743.      {
  744.          szBits[i]=GETBIT(ulParamCount,i);
  745.          if(szBits[i])
  746.          {
  747.              SETBIT(v1,i);
  748.          }
  749.          else
  750.          {
  751.              CLRBIT(v1,i);
  752.          }
  753.      }
  754.      /*
  755.      ulParamCount    i        szBits[i]    b       i       b
  756.      0101            0         1          0000     0      0001   set
  757.      0101            1         0          0001     1      0001   clr
  758.      0101            2         1          0001     2      0101   set
  759.      0101            3         0          0101     3      0101   clr
  760.  
  761.      */
  762.  
  763.      //把数据复制回去
  764.      memcpy(&ulVariable,&v1,);
  765.      return ulVariable;
  766.  }
  767.  
  768.  VOID InlineHook(ULONG64 ulOldVariable,ULONG64 ulFakeVariable,UCHAR* szOldCode,ULONG32 ulOldeCodeLength)
  769.  {
  770.  
  771.      ULONG64  ulVariable = ;
  772.      UCHAR szNewCode[]="\xFF\x25\x00\x00\x00\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF";   //InlineHook
  773.  
  774.      ulVariable = ulFakeVariable;
  775.      memcpy(szOldCode,(PVOID)ulOldVariable,ulOldeCodeLength);
  776.      memcpy(szNewCode+,&ulVariable,);  
  777.  
  778.      memset((PVOID)ulOldVariable,0x90,ulOldeCodeLength);
  779.      memcpy((PVOID)ulOldVariable,szNewCode,);
  780.  }
  781.  
  782.  VOID  UnInlineHook(ULONG64 ulOldVariable,UCHAR* szOldCode,ULONG32 ulOldCodeLength)
  783.  {
  784.      memcpy((PVOID)ulOldVariable,szOldCode,ulOldCodeLength);
  785.  }

.c

  1.  #ifndef CXX_HOOKSSDT_H
  2.  #define CXX_HOOKSSDT_H
  3.  
  4.  #include <ntifs.h>
  5.  #include <ntimage.h>
  6.  
  7.  #define SEC_IMAGE  0x01000000
  8.  
  9.  //定义SSDT表的结构
  10.  typedef struct _SYSTEM_SERVICE_TABLE_X64{
  11.      PVOID          ServiceTableBase;
  12.      PVOID          ServiceCounterTableBase;
  13.      ULONG64      NumberOfServices;                     //SSDT表中的函数个数   0x191
  14.      PVOID          ParamTableBase;
  15.  } SYSTEM_SERVICE_TABLE_X64, *PSYSTEM_SERVICE_TABLE_X64;
  16.  
  17.  typedef struct _SYSTEM_SERVICE_TABLE_X86 {
  18.      PVOID   ServiceTableBase;
  19.      PVOID   ServiceCounterTableBase;
  20.      ULONG32 NumberOfServices;                         //SSDT表中的函数个数   0x11c
  21.      PVOID   ParamTableBase;
  22.  } SYSTEM_SERVICE_TABLE_X86, *PSYSTEM_SERVICE_TABLE_X86;
  23.  
  24.  #ifdef _WIN64
  25.  #define PSYSTEM_SERVICE_TABLE PSYSTEM_SERVICE_TABLE_X64
  26.  #else
  27.  #define PSYSTEM_SERVICE_TABLE PSYSTEM_SERVICE_TABLE_X86
  28.  #endif
  29.  
  30.  /*
  31.  ServiceTableBase  [][][][][][][][]
  32.  */
  33.  extern
  34.      char* PsGetProcessImageFileName(PEPROCESS EProcess);
  35.  
  36.  extern
  37.      PIMAGE_NT_HEADERS
  38.      NTAPI
  39.      RtlImageNtHeader(PVOID BaseAddress);
  40.  
  41.  typedef
  42.      NTSTATUS
  43.      (*pfnNtOpenProcess)(
  44.      PHANDLE ProcessHandle,
  45.      ACCESS_MASK DesiredAccess,
  46.      POBJECT_ATTRIBUTES ObjectAttributes,PCLIENT_ID ClientId);
  47.  
  48.  NTSTATUS Fake_NtOpenProcess(
  49.      PHANDLE ProcessHandle,
  50.      ACCESS_MASK DesiredAccess,
  51.      POBJECT_ATTRIBUTES ObjectAttributes,PCLIENT_ID ClientId);
  52.  
  53.  VOID  UnloadDriver(PDRIVER_OBJECT DriverObject);
  54.  
  55.  BOOLEAN GetSSDTAddressInWinXP_X86(ULONG32* SSDTAddress);
  56.  BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWinXP_X86(CHAR* szFindFunctionName,ULONG32* SSDTFunctionIndex);
  57.  
  58.  BOOLEAN GetSSDTAddressInWin7_X64(ULONG64* SSDTAddress);
  59.  BOOLEAN GetSSDTFunctionIndexFromNtdllExportTableByFunctionNameInWin7_X64(CHAR* szFindFunctionName,ULONG32* SSDTFunctionIndex);
  60.  ULONG32 CalcFunctionOffsetInSSDT(ULONG64 ulFunctionAddress,ULONG32 ulParamCount);
  61.  VOID  InlineHook(ULONG64 ulOldVariable,ULONG64 ulFakeVariable,UCHAR* szOldCode,ULONG32 ulOldeCodeLength);
  62.  VOID  UnInlineHook(ULONG64 ulOldVariable,UCHAR* szOldCode,ULONG32 ulOldCodeLength);
  63.  
  64.  PVOID GetExportVariableAddressFormNtosExportTableByVariableName(WCHAR *wzVariableName);
  65.  
  66.  BOOLEAN MappingPEFileInRing0Space(WCHAR* wzFileFullPath,OUT PVOID* MappingBaseAddress,PSIZE_T MappingViewSize);
  67.  
  68.  VOID WPOFF();
  69.  VOID WPON();
  70.  VOID HookSSDTWinXP_X86(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulFakeVariable);
  71.  VOID HookSSDTWin7_X64(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG64 ulFakeVariable);
  72.  
  73.  VOID UnHookSSDTWinXP_X86(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulOldVariable);
  74.  VOID UnHookSSDTWin7_X64(PULONG32 ServiceTableBase,ULONG32 ulSSDTFunctionIndex,ULONG32 ulOldVariable);
  75.  #endif

.h

HookSSDT 通过HookOpenProcess函数阻止暴力枚举进程的更多相关文章

  1. 教你用免费的hihttps开源WEB应用防火墙阻止暴力破解密码

    教你用免费的hihttps开源WEB应用防火墙阻止暴力破解密码 很多企业都有自己的网站,需要用户登录后才能访问,但有大量的黑客攻击软件可以暴力破解网站密码,即使破解不了也非常恶心.有没有免费的解决办法 ...

  2. ZwQueryVirtualMemory暴力枚举进程模块

    0x01 前言 同学问过我进程体中EPROCESS的三条链断了怎么枚举模块,这也是也腾讯面试题.我当时听到也是懵逼的. 后来在网上看到了一些内存暴力枚举的方法ZwQueryVirtualMemory. ...

  3. ring0 暴力枚举进程

    原理:遍历进程ID,然后openprocess,能打开的都枚举出来 ring0 : #include "EnumProcessByForce.h" extern char* PsG ...

  4. addevent兼容函数 && 阻止默认行为 && 阻止传播

    function addEvent(a, b, c, d) { a.addEventListener ? a.addEventListener(b, c, d) : a.attachEvent(&qu ...

  5. Fail2ban 阻止暴力破解

    简介: Fail2ban 能够监控系统日志,匹配日志中的错误信息(使用正则表达式),执行相应的屏蔽动作(支持多种,一般为调用 iptables ),是一款很实用.强大的软件. 如:攻击者不断尝试穷举 ...

  6. DVWA Brute Force：暴力破解篇

    DVWA Brute Force:暴力破解篇 前言 暴力破解是破解用户名密码的常用手段,主要是利用信息搜集得到有用信息来构造有针对性的弱口令字典,对网站进行爆破,以获取到用户的账号信息,有可能利用其权 ...

  7. 增强VPS SSH账号安全:改端口,禁用Root,密钥登录,Denyhosts防暴力攻击

    VPS SSH账号是我们日常管理VPS的主要登入方式,尤其是Root账号,对Linux系统安全至关重要.以前好多站长喜欢用Putty中文版,这实际是别人修改官方Putty汉化而来,这些软件被植入了后门 ...

  8. gohook 一个支持运行时替换 golang 函数的库实现

    运行时替换函数对 golang 这类静态语言来说并不是件容易的事情,语言层面的不支持导致只能从机器码层面做些奇怪 hack,往往艰难,但如能成功,那挣脱牢笼带来的成就感,想想就让人兴奋. gohook ...

  9. Nowcoder 挑战赛23 B 游戏 ( NIM博弈、SG函数打表 )

    题目链接 题意 : 中文题.点链接 分析 : 前置技能是 SG 函数.NIM博弈变形 每次可取石子是约数的情况下.那么就要打出 SG 函数 才可以去通过异或操作判断一个局面的胜负 打 SG 函数的时候 ...

随机推荐

  1. 表单美化-原生javascript和jQuery下拉列表（兼容IE6）

    效果: 思想:用其他标签配合脚本和隐藏的input并通过传值模拟表单元素中的select <!DOCTYPE HTML> <html lang="en-US"&g ...

  2. 常用sql(转）

    1增 1.1[插入单行]insert [into] <表名> (列名) values (列值)例:insert into Strdents (姓名,性别,出生日期) values ('开心 ...

  3. Switch用法

    package com.cz.test; public class SwitchExample1 { /** * @param args */ public static void main(Stri ...

  4. js输出26个字母两种方法(js fromCharCode的使用)

    方法一 var character = new Array("A","B","C","D","E", ...

  5. ajax 、ajax的交互模型、如何解决跨域问题

    1.ajax是什么? — AJAX全称为“AsynchronousJavaScript and XML”(异步JavaScript和XML),是一种创建交互式网页应用的网页开发技术. — 不是一种新技 ...

  6. js获取select字段值的方法

    var index = obj.selectedIndex; // 选中索引 var value = obj.options[index].value; // 选中值 var schoolName = ...

  7. Python学习（16）File(文件)方法

    Python File(文件) 方法 file 对象使用 open 函数来创建,下表列出了 file 对象常用的函数: 序号 方法及描述 1 file.close() 关闭文件.关闭后文件不能再进行读 ...

  8. Android 基于google Zxing实现二维码、条形码扫描，仿微信二维码扫描效果

      Android 高手进阶(21)  版权声明:本文为博主原创文章,未经博主允许不得转载. 转载请注明出处:http://blog.csdn.net/xiaanming/article/detail ...

  9. python语法笔记（一）

    1. python中多个函数或者类定义可以放在一个.py 文件中,视为一个模块.模块的.py文件中,一般要写 if __name__ == '__mian__' 用来单独执行该模块内的某些函数. 2. ...

  10. OpenCV3编程入门笔记（6）自我验证各函数程序代码

    // asw.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include <opencv2/opencv.hpp> usi ...