浅析windows安全策略

理论：
本篇我们将通过一个例子，来大致了解下windows的安全策略。

实现windows安全性的安全组件和数据库有：
1。安全引用监视器Security reference monitor (简称SRM)   如图，这是位于核心态windows执行体中的一个组件。它负责：
1）定义访问令牌数据结构来表示一个安全环境。
2）执行对象的安全访问检查
3）管理特权（用户权限)
4) 生成所有的结果安全审计消息。

2。本地安全权威子系统Local security authority subsystem (简称Lsass) 这是一个运行/windows/system32/Lsass.exe文件的用户模式进程。它负责：
    1）本地系统安全策略（比如：允许哪些用户登录到本地机器上，口令策略，授予用户和用户组的特权，以及系统安全审计设置
    2）用户认证
    3）发送安全审计消息到事件日志。

在此进程加载了4个策略相关的dll模块，他们是：
netlogon.dll
ntdsapi.dll
samsrv.dll
lsasrv.dll
这四个模块对应于上图中的Netlogon ,Active Directory , LSA server,SAM server.

Netlogon （网络登陆服务），这是一个windows服务，它建立起与域控制器之间的安全通道，对用户和服务进行身份验证。它将用户的凭然后返回用户据传递给域控制器，的域安全标识符和用户权 限。这通常称为 pass-through 身份验证。

Active Directory （活动目录），包括两个方面：目录和与目录相关的服务。目录是存储各种对象的一个物理上的容器，从静态的角度来理解这活动目录与我们以前所结识的“目录”和“文 件夹”没有本质区别，仅仅是一个对象，是一实体；而目录服务是使目录中所有信息和资源发挥作用的服务，活动目录是一个分布式的目录服务，信息可以分散在多 台不同的计算机上，保证用户能够快速访问，因为多台机上有相同的信息，所以在信息容氏方面具有很强的控制能力，正因如此，不管用户从何处访问或信息处在何 处，都对用户提供统一的视图。域是由一组计算机和与他们相关联的安全组构成的，每个安全组被当作单个实体来管理。活动目录存储了有关该域中的对象的信息，这样的对象包括用户、组和计算机。域用户和组的口令信息和特权也被存储在活动目录中。关于活动目录的介绍祥见 http://windows.chinaitlab.com/domain/37480.html

SAM (安全帐户管理器服务），它负责管理一个数据库，该数据库包含了本地机器上定义的用户名和组。

LSA （本地安全权威服务），它实现了Lsass子系统的绝大部分功能。

SRM使用一个称为令牌的对象来标识一个进程或线程地安全环境。安全环境中包括的信息描述了与该进程或者线程相关联的特权、帐户和组。
lkd> dt _token
nt!_TOKEN
   +0x000 TokenSource      : _TOKEN_SOURCE
   +0x010 TokenId          : _LUID
   +0x018 AuthenticationId : _LUID
   +0x020 ParentTokenId    : _LUID
   +0x028 ExpirationTime   : _LARGE_INTEGER
   +0x030 TokenLock        : Ptr32 _ERESOURCE
   +0x038 AuditPolicy      : _SEP_AUDIT_POLICY
   +0x040 ModifiedId       : _LUID
   +0x048 SessionId        : Uint4B
   +0x04c UserAndGroupCount : Uint4B
   +0x050 RestrictedSidCount : Uint4B
+0x054 PrivilegeCount   : Uint4B
   +0x058 VariableLength   : Uint4B
   +0x05c DynamicCharged   : Uint4B
   +0x060 DynamicAvailable : Uint4B
   +0x064 DefaultOwnerIndex : Uint4B
   +0x068 UserAndGroups    : Ptr32 _SID_AND_ATTRIBUTES
   +0x06c RestrictedSids   : Ptr32 _SID_AND_ATTRIBUTES
   +0x070 PrimaryGroup     : Ptr32 Void
   +0x074 Privileges       : Ptr32 _LUID_AND_ATTRIBUTES
   +0x078 DynamicPart      : Ptr32 Uint4B
   +0x07c DefaultDacl      : Ptr32 _ACL
   +0x080 TokenType        : _TOKEN_TYPE
   +0x084 ImpersonationLevel : _SECURITY_IMPERSONATION_LEVEL
   +0x088 TokenFlags       : Uint4B
   +0x08c TokenInUse       : UChar
   +0x090 ProxyData        : Ptr32 _SECURITY_TOKEN_PROXY_DATA
   +0x094 AuditData        : Ptr32 _SECURITY_TOKEN_AUDIT_DATA
   +0x098 OriginatingLogonSession : _LUID
   +0x0a0 VariablePart     : Uint4B

SRM运行在内核模式下，而Lsass运行在用户模式下，他们利用LPC进行通讯。在系统初始化过程中，SRM创建了一个名为SeRmCommandPort的端口，Lsass连接到此端口上。当Lsass进程启动的时候，它创建一个名为SeLsaCommandPort的LPC端口。SRM连接到此端口上，从而建立起两者之间的私有通讯。
SRM创建了一个共享内存区，用于传递超过256字节长的消息，他在连接调用中把该共享内存区的句柄传递过去。在系统初始化过程中，一旦SRM与Lsass相互连接起来，他们就不再监听各自的连接端口，因此，后来的用户进程无法连接到这些端口，从而避免一些恶意的破坏。


3. 在SDK中，我们使用下面的三个函数来打开令牌，修改权限。
OpenProcessToken，LookupPrivilegeValue，AdjustTokenPrivileges。
每一个进程，线程都有自己的令牌，线程的令牌通常跟所属进程一样。
前面我们讲过 SRM使用一个称为令牌的对象来标识一个进程或线程地安全环境，令牌中的Privileges决定该令牌的线程或进程可以做哪些事情。 如果想让一个进程有更大的权限去做一些事情，我们就可以通过给进程提权的方式来做到。

步骤如下：

1）首先要获得进程访问令牌的句柄，这可以通过OpenProcessToken得到，函数的原型如下：
BOOL    OpenProcessToken(
          HANDLE    ProcessHandle,    //要修改访问权限的进程句柄
          DWORD    DesiredAccess,        //指定你要进行的操作类型
          PHANDLE    TokenHandle       //返回的访问令牌指针
    )；
通过这个函数我们就可以得到当前进程的访问令牌的句柄（指定函数的第一个参数为GetCurrentProcess()就可以了）。

2）获取权限对应的LUID
根据权限结构体，如下所示:
lkd> dt _LUID_AND_ATTRIBUTES
ntdll!_LUID_AND_ATTRIBUTES
   +0x000 Luid             : _LUID
   +0x008 Attributes       : Uint4B

从上面令牌对象的结构，我们看到。
+0x074 Privileges       : Ptr32 _LUID_AND_ATTRIBUTES   表示一个权限数组。
+0x054 PrivilegeCount   : Uint4B                                        表示了权限数组元素的个数。

对应于SDK中的定义是这样的。
typedef struct _TOKEN_PRIVILEGES {
    DWORD PrivilegeCount;
    LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY];
} TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;

这里把令牌对象中关于权限的两个成员PrivilegeCount和 Privileges合并到了一个结构体TOKEN_PRIVILEGES中。
要对一个任意进程（包括系统安全进程和服务进程）进行指定了写相关的访问权的OpenProcess操作，只要当前进程具有SeDeDebug权限就可以 了。要是一个用户是Administrator或是被给予了相应的权限，就可以具有该权限。可是，就算我们用Administrator帐号对一个系统安 全进程执行OpenProcess(PROCESS_ALL_ACCESS,FALSE,       dwProcessID)还是会遇到“访问拒绝”的错误。什么原因呢？原来在默认的情况下进程的一些访问权限是没有被使能（Enabled）的，所以我们 要做的首先是使能这些权限。例如：我们要给当前进程具有SeDeDebug权限，只要找到Privileges 数组中对应的SeDeDebug权限的那个元素，然后让它使能就可以了。Privileges 数组中的每个元素对应一个结构体如下
typedef struct _LUID_AND_ATTRIBUTES {
    LUID Luid;
    DWORD Attributes;
    } LUID_AND_ATTRIBUTES, * PLUID_AND_ATTRIBUTES;

在windows中权限不是用名称来标识的，而是使用一个LUID来标识的。LUID就是指locally unique identifier，我想GUID大家是比较熟悉的，和GUID的要求保证全局唯一不同，LUID只要保证局部唯一，就是指在系统的每一次运行期间保证 是唯一的就可以了。另外和GUID相同的一点，LUID也是一个64位的值，相信大家都看过GUID那一大串的值，我们要怎么样才能知道一个权限对应的 LUID值是多少呢？这就要用到另外一个API函数LookupPrivilegevalue，其原形如下：
BOOL LookupPrivilegevalue(
LPCTSTR lpSystemName, // system name
LPCTSTR lpName, // privilege name
PLUID lpLuid // locally unique identifier
);
第一个参数是系统的名称，如果是本地系统只要指明为NULL就可以了，第三个参数就是返回LUID的指针，第二个参数就是指明了权限的名称，如“SeDebugPrivilege”。


3) 修改权限，即：将2步骤找到的权限项使能。调用AdjustTokenPrivileges对这个访问令牌进行修改。
AdjustTokenPrivileges的原型如下：
BOOL AdjustTokenPrivileges(
HANDLE TokenHandle, // handle to token
BOOL DisableAllPrivileges, // disabling option
PTOKEN_PRIVILEGES NewState, // privilege information
DWORD BufferLength, // size of buffer
PTOKEN_PRIVILEGES PreviousState, // original state buffer
PDWORD ReturnLength // required buffer size
);
第一个参数是访问令牌的句柄；第二个参数决定是进行权限修改还是Disable所有权限；第三个参数指明要修改的权限，是一个指向 TOKEN_PRIVILEGES结构的指针，该结构包含一个数组，数据组的每个项指明了权限的类型和要进行的操作; 第四个参数是结构PreviousState的长度，如果PreviousState为空，该参数应为NULL；第五个参数也是一个指向 TOKEN_PRIVILEGES结构的指针，存放修改前的访问权限的信息，可空；最后一个参数为实际PreviousState结构返回的大小。

ring3下的这几个函数的访问流程如下：
1）OpenProcessToken -〉NtOpenProcessToken ->NtOpenProcessTokenEx->ObOpenObjectByPointer 得到进程的Taken对象

2）LookupPrivilegeValueA-〉LookupPrivilegeValueW-〉LsaOpenPolicy-〉LsaLookupPrivilegeValue-〉NdrClientCall2 -〉通过LPC与SRM通讯，返回LUID。。。。

3）AdjustTokenPrivileges-〉NtAdjustPrivilegesToken-〉修改Taken对象中相关的值。。。

代码：见光盘test ，直接用了鸡蛋壳转载的代码，相关链接http://bbs.pediy.com/showthread.php?t=70540

#include <Windows.h>
#include <Ntsecapi.h>
#include <Aclapi.h>
#include <tlhelp32.h>
#pragma comment (lib,"Kernel32.lib")
#pragma comment (lib,"Advapi32.lib")
#pragma comment(linker, "/ENTRY:main")

//------------------ 数据类型声明开始 --------------------//
typedef struct _PROCESS_BASIC_INFORMATION {
     NTSTATUS ExitStatus;
     ULONG PebBaseAddress;
     ULONG_PTR AffinityMask;
     LONG BasePriority;
     ULONG_PTR UniqueProcessId;
     ULONG_PTR InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION;

typedef PROCESS_BASIC_INFORMATION *PPROCESS_BASIC_INFORMATION;

typedef struct _SYSTEM_HANDLE_INFORMATION
{
     ULONG             ProcessId;
     UCHAR             ObjectTypeNumber;
     UCHAR             Flags;
     USHORT             Handle;
     PVOID             Object;
     ACCESS_MASK         GrantedAccess;
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;

typedef struct _SYSTEM_MODULE_INFORMATION
{
    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 _OBJECT_ATTRIBUTES
{
    ULONG Length;
    HANDLE RootDirectory;
    PUNICODE_STRING ObjectName;
    ULONG Attributes;
    PVOID SecurityDescriptor;
    PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;

typedef enum _SECTION_INHERIT
{
    ViewShare = 1,
    ViewUnmap = 2
} SECTION_INHERIT;

typedef struct _MY_PROCESS_INFO
{
    ULONG PID;
    ULONG KPEB;
    ULONG CR3;
    CHAR Name[16];
    ULONG Reserved;
} MY_PROCESS_INFO, *PMY_PROCESS_INFO;

typedef struct _CLIENT_ID
{
     HANDLE UniqueProcess;
     HANDLE UniqueThread;
} CLIENT_ID;
typedef CLIENT_ID *PCLIENT_ID;

typedef long NTSTATUS;

//------------------ 数据类型声明结束 --------------------//

//--------------------- 预定义开始 -----------------------//
#define NT_SUCCESS(Status)         ((NTSTATUS)(Status) >= 0)
#define STATUS_SUCCESS              0x00000000
#define STATUS_UNSUCCESSFUL         0xC0000001
#define STATUS_NOT_IMPLEMENTED      0xC0000002
#define STATUS_INFO_LENGTH_MISMATCH 0xC0000004
#define STATUS_INVALID_PARAMETER    0xC000000D
#define STATUS_ACCESS_DENIED        0xC0000022
#define STATUS_BUFFER_TOO_SMALL     0xC0000023
#define OBJ_KERNEL_HANDLE           0x00000200
#define SystemModuleInformation     11
#define SystemHandleInformation     0x10

#define InitializeObjectAttributes( p, n, a, r, s ) { (p)->Length = sizeof( OBJECT_ATTRIBUTES );(p)->RootDirectory = r;                 (p)->Attributes = a;                     (p)->ObjectName = n;                       (p)->SecurityDescriptor = s;                 (p)->SecurityQualityOfService = NULL;         }
//--------------------- 预定义结束 -----------------------//

//------------------ Native API声明开始 ------------------//

typedef DWORD (_stdcall *XXXZwQuerySystemInformation)(
                ULONG SystemInformationClass,
                PVOID SystemInformation,
                ULONG SystemInformationLength,
                PULONG ReturnLength
                );

typedef DWORD (_stdcall *XXXZwOpenProcess)(
              OUT PHANDLE             ProcessHandle,
              IN ACCESS_MASK           AccessMask,
              IN POBJECT_ATTRIBUTES   ObjectAttributes,
              IN PCLIENT_ID           ClientId
              );

typedef DWORD (_stdcall *XXXZwAllocateVirtualMemory)(
               IN HANDLE               ProcessHandle,
               IN OUT PVOID             *BaseAddress,
               IN ULONG                 ZeroBits,
               IN OUT PULONG           RegionSize,
               IN ULONG                 AllocationType,
               IN ULONG                 Protect
               );

typedef DWORD (_stdcall *XXXZwDuplicateObject)(
               IN HANDLE               SourceProcessHandle,
               IN PHANDLE               SourceHandle,
               IN HANDLE               TargetProcessHandle,
               OUT PHANDLE             TargetHandle,
               IN ACCESS_MASK           DesiredAccess OPTIONAL,
               IN BOOLEAN               InheritHandle,
               IN ULONG                 Options
               );

typedef DWORD (_stdcall *XXXZwQueryInformationProcess)(
                 IN HANDLE               ProcessHandle,
                 IN PVOID          ProcessInformationClass,
                 OUT PVOID               ProcessInformation,
                 IN ULONG                 ProcessInformationLength,
                 OUT PULONG               ReturnLength
                 );

typedef DWORD (_stdcall *XXXZwProtectVirtualMemory)(
            
              IN HANDLE               ProcessHandle,
              IN OUT PVOID             *BaseAddress,
              IN OUT PULONG           NumberOfBytesToProtect,
              IN ULONG                 NewAccessProtection,
              OUT PULONG               OldAccessProtection
              );

typedef DWORD (_stdcall *XXXZwWriteVirtualMemory)(
               IN HANDLE               ProcessHandle,
               IN PVOID                 BaseAddress,
               IN PVOID                 Buffer,
               IN ULONG                 NumberOfBytesToWrite,
               OUT PULONG               NumberOfBytesWritten OPTIONAL
               );

typedef DWORD (_stdcall *XXXZwClose)(
           IN HANDLE               ObjectHandle
           );

typedef DWORD (_stdcall *XXXZwFreeVirtualMemory)(
            
              IN HANDLE               ProcessHandle,
              IN PVOID                 *BaseAddress,
              IN OUT PULONG           RegionSize,
              IN ULONG                 FreeType
              );

//------------------ Native API声明结束 ------------------//

//------------------ 程序正式开始 ------------------//

DWORD GetPidByName(char *szName)
{
    HANDLE hProcessSnap = INVALID_HANDLE_VALUE;
    PROCESSENTRY32 pe32={0};
    DWORD dwRet=0;

    hProcessSnap =CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if(hProcessSnap == INVALID_HANDLE_VALUE)return 0;

    pe32.dwSize = sizeof(PROCESSENTRY32);
    if(Process32First(hProcessSnap, &pe32))
    {
       do
       {
            if(lstrcmpi(szName,pe32.szExeFile)==0)
            {
                dwRet=pe32.th32ProcessID;
                break;
            }
       }while (Process32Next(hProcessSnap,&pe32));
    }
    else
        return 0;

    if(hProcessSnap !=INVALID_HANDLE_VALUE)
        CloseHandle(hProcessSnap);
       
    return dwRet;
}

void KillIce(ULONG dwProcessId)
{
    HMODULE hNTDLL = LoadLibrary ("ntdll.dll");
    HANDLE      ph, h_dup;
    ULONG      bytesIO;
    PVOID      buf;
    ULONG         i;
    CLIENT_ID     cid1;
    OBJECT_ATTRIBUTES     attr;
    HANDLE         csrss_id;
    //   HANDLE     SnapShotHandle;
    PROCESS_BASIC_INFORMATION     pbi;
    PVOID         p0, p1;
    ULONG         sz, oldp;
    ULONG         NumOfHandle;
    PSYSTEM_HANDLE_INFORMATION     h_info;

    csrss_id = (HANDLE)GetPidByName("csrss.exe");
    attr.Length = sizeof(OBJECT_ATTRIBUTES);
    attr.RootDirectory = 0;
    attr.ObjectName = 0;
    attr.Attributes = 0;
    attr.SecurityDescriptor = 0;
    attr.SecurityQualityOfService = 0;

    cid1.UniqueProcess = csrss_id;
    cid1.UniqueThread = 0;
    XXXZwOpenProcess ZwOpenProcess;
    ZwOpenProcess = (XXXZwOpenProcess)GetProcAddress( GetModuleHandle("ntdll.dll"), "ZwOpenProcess");
    ZwOpenProcess(&ph, PROCESS_ALL_ACCESS, &attr, &cid1);

    bytesIO = 0x400000;
    buf = 0;
    XXXZwAllocateVirtualMemory ZwAllocateVirtualMemory;
    ZwAllocateVirtualMemory = (XXXZwAllocateVirtualMemory)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwAllocateVirtualMemory");
    ZwAllocateVirtualMemory(GetCurrentProcess(), &buf, 0, &bytesIO, MEM_COMMIT, PAGE_READWRITE);

    XXXZwQuerySystemInformation ZwQuerySystemInformation;
    ZwQuerySystemInformation = (XXXZwQuerySystemInformation)GetProcAddress( GetModuleHandle("ntdll.dll"), "ZwQuerySystemInformation");
    ZwQuerySystemInformation(SystemHandleInformation, buf, 0x400000, &bytesIO);
    NumOfHandle = (ULONG)buf;
    h_info = ( PSYSTEM_HANDLE_INFORMATION )((ULONG)buf+4);

    for (i= 0 ; i<NumOfHandle; i++, h_info++)
    {  
       if ((h_info->ProcessId == (ULONG)csrss_id)&&(h_info->ObjectTypeNumber == 5))
       {
            XXXZwDuplicateObject ZwDuplicateObject;
            ZwDuplicateObject = (XXXZwDuplicateObject)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwDuplicateObject");
            XXXZwQueryInformationProcess ZwQueryInformationProcess;
            ZwQueryInformationProcess = (XXXZwQueryInformationProcess)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwQueryInformationProcess");
            if (ZwDuplicateObject(ph, (PHANDLE)h_info->Handle, (HANDLE)-1, &h_dup,
                                       0, 0, DUPLICATE_SAME_ACCESS) == STATUS_SUCCESS)
                 ZwQueryInformationProcess(h_dup, 0, &pbi, sizeof(pbi), &bytesIO);
            if (pbi.UniqueProcessId == dwProcessId)
            {
                MessageBox(0, "目标已确定!", "OK", MB_OK);
                XXXZwProtectVirtualMemory ZwProtectVirtualMemory;
                ZwProtectVirtualMemory = (XXXZwProtectVirtualMemory)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwProtectVirtualMemory");
                XXXZwWriteVirtualMemory ZwWriteVirtualMemory;
                ZwWriteVirtualMemory = (XXXZwWriteVirtualMemory)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwWriteVirtualMemory");
                XXXZwClose ZwClose;
                ZwClose = (XXXZwClose)GetProcAddress(GetModuleHandle("ZwClose"), "ZwClose");
                for (i = 0x1000; i<0x80000000; i = i + 0x1000)
                {
                    p0 = (PVOID)i;
                    p1 = p0;
                    sz = 0x1000;
                    if (ZwProtectVirtualMemory(h_dup, &p1, &sz, PAGE_EXECUTE_READWRITE, &oldp) == STATUS_SUCCESS)
                    {             
                           ZwWriteVirtualMemory(h_dup, p0, buf, 0x1000, &oldp);
                    }         
                }
                MessageBox(0, "任务已完成！","OK", 0);
                ZwClose(h_dup);    
                break;
            }
       }
    }

    bytesIO = 0;
    XXXZwFreeVirtualMemory ZwFreeVirtualMemory;
    ZwFreeVirtualMemory = (XXXZwFreeVirtualMemory)GetProcAddress(GetModuleHandle("ntdll.dll"),   "ZwFreeVirtualMemory");
    ZwFreeVirtualMemory(GetCurrentProcess(), &buf, &bytesIO, MEM_RELEASE);

    FreeLibrary(hNTDLL);  

}

BOOL EnablePrivilege(HANDLE hToken,LPCTSTR szPrivName,BOOL fEnable)
{
    TOKEN_PRIVILEGES tp;
    tp.PrivilegeCount = 1;
    LookupPrivilegeValue(NULL,szPrivName,&tp.Privileges[0].Luid);

    tp.Privileges[0].Attributes = fEnable ? SE_PRIVILEGE_ENABLED:0;
    AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL);
    return((GetLastError() == ERROR_SUCCESS));
}

void main()
{   
     ULONG Pid;
     HANDLE hToken;
     OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&hToken);
     EnablePrivilege(hToken,SE_DEBUG_NAME,TRUE);
     if (Pid = GetPidByName("calc.exe"))
     {
         KillIce(Pid);
     }    
     ExitProcess(0);
}

分析： 以下是windows NT中定义的权限：
#define SE_CREATE_TOKEN_NAME              TEXT("SeCreateTokenPrivilege")
#define SE_ASSIGNPRIMARYTOKEN_NAME        TEXT("SeAssignPrimaryTokenPrivilege")
#define SE_LOCK_MEMORY_NAME               TEXT("SeLockMemoryPrivilege")
#define SE_INCREASE_QUOTA_NAME            TEXT("SeIncreaseQuotaPrivilege")
#define SE_UNSOLICITED_INPUT_NAME         TEXT("SeUnsolicitedInputPrivilege")
#define SE_MACHINE_ACCOUNT_NAME           TEXT("SeMachineAccountPrivilege")
#define SE_TCB_NAME                       TEXT("SeTcbPrivilege")
#define SE_SECURITY_NAME                  TEXT("SeSecurityPrivilege")
#define SE_TAKE_OWNERSHIP_NAME            TEXT("SeTakeOwnershipPrivilege")
#define SE_LOAD_DRIVER_NAME               TEXT("SeLoadDriverPrivilege")
#define SE_SYSTEM_PROFILE_NAME            TEXT("SeSystemProfilePrivilege")
#define SE_SYSTEMTIME_NAME                TEXT("SeSystemtimePrivilege")
#define SE_PROF_SINGLE_PROCESS_NAME       TEXT("SeProfileSingleProcessPrivilege")
#define SE_INC_BASE_PRIORITY_NAME         TEXT("SeIncreaseBasePriorityPrivilege")
#define SE_CREATE_PAGEFILE_NAME           TEXT("SeCreatePagefilePrivilege")
#define SE_CREATE_PERMANENT_NAME          TEXT("SeCreatePermanentPrivilege")
#define SE_BACKUP_NAME                    TEXT("SeBackupPrivilege")
#define SE_RESTORE_NAME                   TEXT("SeRestorePrivilege")
#define SE_SHUTDOWN_NAME                  TEXT("SeShutdownPrivilege")
#define SE_DEBUG_NAME                     TEXT("SeDebugPrivilege")
#define SE_AUDIT_NAME                     TEXT("SeAuditPrivilege")
#define SE_SYSTEM_ENVIRONMENT_NAME        TEXT("SeSystemEnvironmentPrivilege")
#define SE_CHANGE_NOTIFY_NAME             TEXT("SeChangeNotifyPrivilege")
#define SE_REMOTE_SHUTDOWN_NAME           TEXT("SeRemoteShutdownPrivilege")
#define SE_UNDOCK_NAME                    TEXT("SeUndockPrivilege")
#define SE_SYNC_AGENT_NAME                TEXT("SeSyncAgentPrivilege")
#define SE_ENABLE_DELEGATION_NAME         TEXT("SeEnableDelegationPrivilege")
#define SE_MANAGE_VOLUME_NAME             TEXT("SeManageVolumePrivilege")
#define SE_IMPERSONATE_NAME               TEXT("SeImpersonatePrivilege")
#define SE_CREATE_GLOBAL_NAME             TEXT("SeCreateGlobalPrivilege")

其中的SE_DEBUG_NAME 权限是这样描述的，如果调用者有这个特权的话，则进程管理器允许通过NtOpenProcess访问任何一个进程，而不考虑该进程的安全描述符是否允许。
代码如下：
     OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&hToken);
     EnablePrivilege(hToken,SE_DEBUG_NAME,TRUE);

其中：EnablePrivilege函数实现了提权。
BOOL EnablePrivilege(HANDLE hToken,LPCTSTR szPrivName,BOOL fEnable)
{
    TOKEN_PRIVILEGES tp;
    //设置特权数组的元素个数
    tp.PrivilegeCount = 1;

    // 取得szPrivName对应的[LUID](本地唯一的标识符)值
    LookupPrivilegeValue(NULL,szPrivName,&tp.Privileges[0].Luid);

    //设置[LUID]的属性值
    tp.Privileges[0].Attributes = fEnable ? SE_PRIVILEGE_ENABLED:0;

    // 为当前进程取得关闭系统的特权
    AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL);
    return((GetLastError() == ERROR_SUCCESS));
}


由于本例的作用是采用内存清0的方式关闭目标进程的。所以当前进程需要先有这个权限才行。
下面GetPidByName函数的作用是根据进程文件名，获取进程的ID。这个ID用于后续打开的进程。

DWORD GetPidByName(char *szName)
{
    HANDLE hProcessSnap = INVALID_HANDLE_VALUE;
    PROCESSENTRY32 pe32={0};
    DWORD dwRet=0;

    hProcessSnap =CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if(hProcessSnap == INVALID_HANDLE_VALUE)return 0;

    pe32.dwSize = sizeof(PROCESSENTRY32);
    if(Process32First(hProcessSnap, &pe32))
    {
       do
       {
            if(lstrcmpi(szName,pe32.szExeFile)==0)
            {
                dwRet=pe32.th32ProcessID;
                break;
            }
       }while (Process32Next(hProcessSnap,&pe32));
    }
    else
        return 0;

    if(hProcessSnap !=INVALID_HANDLE_VALUE)
        CloseHandle(hProcessSnap);
       
    return dwRet;
}

这里用到了3个关键的函数：CreateToolhelp32Snapshot()，Process32First()和Process32Next()。下面给出了关于这三个函数的原形和参数说明;

HANDLE WINAPI CreateToolhelp32Snapshot(
DWORD dwFlags, //系统快照要查看的信息类型
DWORD th32ProcessID      //值0表示当前进程
);
BOOL WINAPI Process32First(
HANDLE hSnapshot,        //CreateToolhelp32Snapshot()创建的快照句柄
LPPROCESSENTRY32 lppe //指向进程入口结构
);
BOOL WINAPI Process32Next(
HANDLE hSnapshot,        //这里参数同Process32First
LPPROCESSENTRY32 lppe //同上
);

首先使用CreateToolhelp32Snapshot()创建系统快照句柄（hProcessSnap 是我们声明用来保存创建的快照句柄）
hProcessSnap =CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
然后调用Process32First()获得系统快照中的第一个进程信息。
if(Process32First(hProcessSnap, &pe32))
接着用一个循环调用来遍历系统中所有运行的进程。一旦找到就返回进程的ID。
           if(lstrcmpi(szName,pe32.szExeFile)==0)
            {
                dwRet=pe32.th32ProcessID;
                break;
            }


后面的代码工作原理是：
首先了解下内核对象及句柄
内核对象是由系统分配的一块内存，必须有系统来维护和访问。windows 系统内核的对象管理器，管理着所有的内核对象，象进程、线程、文件、文件映射、事件、互斥量、信号量、管道、邮槽等都是内核对象。
内核对象是系统级的，独立于进程。也就是说，任何一个进程创建了一个内核对象，理论上讲，其他进程都应该能访问，只要进程获得该内核对象的句柄。事实上，NT就是通过对句柄的种种 限制，来达到安全的目的。 在windows系统中，每一个进程都维护一内核对象句柄表。对象句柄是一个索引，指向与进程相关的句柄表中的表项。一个进程的句柄表包含了所有已被进程打开的那些对象的指针。

我们可以使用ZwQuerySystemInformation函数获取所有核心句柄表，这个句柄表，包含了所有的内核对象的句柄。从遍历出来的结果看，它并不能遍历出所有的进程来。我们通过如下代码，测试输出结果。
由于进程的内核对象类型是5，因此我们可以用这样的过滤条件，打印出所有遍历到的进程信息。

      char bufjiang[100] = {0};
   wsprintf(bufjiang,"ProcessID = %d,ObjectType = %d, handle = %#x, object = %#x/n",
            h_info->ProcessId,h_info->ObjectTypeNumber,h_info->Handle,h_info->Object );
        if(h_info->ObjectTypeNumber == 5)
            OutputDebugString(bufjiang);

所以折中的办法就是，由于csrss.exe是Win32子系统进程，在CSRSS.EXE 进程中保留有一份完整的系统所有进程/线程句柄，因此，我们可以通过csrss.exe中的句柄表，来找出所有运行的进程的句柄来。

于是需要打开CSRSS.EXE 进程，获取其进程ID,
csrss_id = (HANDLE)GetPidByName("csrss.exe");
......
ZwOpenProcess(&ph, PROCESS_ALL_ACCESS, &attr, &cid1);

然后，根据下面的判断过滤内核对象类型是5过滤的情况。

if ((h_info->ProcessId == (ULONG)csrss_id)&&(h_info->ObjectTypeNumber == 5))
       {

然后从CSRSS.EXE 进程中的系统进程/线程表中使用ZwDuplicateObject复制出一份找到的进程句柄，
if (ZwDuplicateObject(ph, (PHANDLE)h_info->Handle, (HANDLE)-1, &h_dup,
                                       0, 0, DUPLICATE_SAME_ACCESS) == STATUS_SUCCESS)

然后，有了进程句柄，我们就可以获取进程的信息。
                 ZwQueryInformationProcess(h_dup, 0, &pbi, sizeof(pbi), &bytesIO);
得到的进程信息，对应如下结构。
typedef struct _PROCESS_BASIC_INFORMATION {
     NTSTATUS ExitStatus;
     ULONG PebBaseAddress;
     ULONG_PTR AffinityMask;
     LONG BasePriority;
     ULONG_PTR UniqueProcessId;
     ULONG_PTR InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION;
接下来，我们继续判断这个进程是不是我们要关闭的目标进程。
    if (pbi.UniqueProcessId == dwProcessId)
            {
找到目标进程后，我们就可以用0填充进程的用户内存空间了。
for (i = 0x1000; i<0x80000000; i = i + 0x1000)
                {
                    p0 = (PVOID)i;
                    p1 = p0;
                    sz = 0x1000;
                    if (ZwProtectVirtualMemory(h_dup, &p1, &sz, PAGE_EXECUTE_READWRITE, &oldp) == STATUS_SUCCESS)
                    {             
                           ZwWriteVirtualMemory(h_dup, p0, buf, 0x1000, &oldp);
                    }         
                }

其中 ：    ZwProtectVirtualMemory函数的作用是修改内存块的属性为可读可写可执行。
            ZwWriteVirtualMemory函数的作用是写内存块。这里在内存块中写入0。

最后附上：内核对象类型的定义，上面用到的进程对象类型5 就是OB_TYPE_PROCESS。
#define OB_TYPE_TYPE                    1
#define OB_TYPE_DIRECTORY               2
#define OB_TYPE_SYMBOLIC_LINK           3
#define OB_TYPE_TOKEN                   4
#define OB_TYPE_PROCESS                 5
#define OB_TYPE_THREAD                  6
#define OB_TYPE_EVENT                   7
#define OB_TYPE_EVENT_PAIR              8
#define OB_TYPE_MUTANT                  9
#define OB_TYPE_SEMAPHORE               10
#define OB_TYPE_TIMER                   11
#define OB_TYPE_PROFILE                 12
#define OB_TYPE_WINDOW_STATION          13
#define OB_TYPE_DESKTOP                 14
#define OB_TYPE_SECTION                 15
#define OB_TYPE_KEY                     16
#define OB_TYPE_PORT                    17
#define OB_TYPE_ADAPTER                 18
#define OB_TYPE_CONTROLLER              19
#define OB_TYPE_DEVICE                  20
#define OB_TYPE_DRIVER                  21
#define OB_TYPE_IO_COMPLETION           22
#define OB_TYPE_FILE                    23

文章来源于:http://hi.baidu.com/combojiang/blog/item/7c32ff2dc1ce7932359bf732.html