第4章 进程(3)

4.5 管理员以标准用户权限运行时

4.5.1访问控制模型ACM(Access Control Model)



（1）进（线）程在访问对象时，系统会根据线程的访问令牌与需要访问的对象所持有的“安全描述符”进行匹配认证，来决定是否被允许访问。

（2）访问令牌属进（线程）范围的，相当于进（线）程的身份证（即用户SID，可理解为一把有具有ID的钥匙）。

（3）“安全描述符”属被访问对象的，相当于给对象加把锁。要访问该对象时，只有经过身份认证并且持有正确钥匙的进（线）程才有成功访问该对象。

4.5.2 访问令牌与进（线）程权限

（1）访问令牌（Token）的数据结构



　　①访问令牌一般由两个部分：一个是令牌所表示的用户（包括会话ID、用户及其所属的组），这些信息告诉Token属于哪个用户的；另一部分是“特权列表”(Privilege)，这用来告诉进程能够进行特定的系统操作，如关闭系统、修改系统时间、加载设备驱动等，拥有的特权越多当然就越牛B！

　　②从vista开始,当使用高特权的管理员帐号登录时，系统会同时创建两个访问令牌，其中一个是完全的管理员访问令牌，另一个是经过“过滤”的标准用户访问令牌(filtered token)，并把后者Shell进程(explorer.exe)，以后系统启动的所有新进程关联都会继承这个被“筛选令牌”，权限受限制的进程无法访问需要更高权限才能访问的安全资源。注意，虽然以管理员登录，但应用程序默认是以标准用户权限的运行。

　　③每个进程都有一个Token（被称为主令牌）。可以从父进程处继承（也可以修改，但其最高权限不会超过登录账户的最高权限。即只能在进程的边界上提升权限！要获得更多的权限，就要以管理员的身份运行！）

　　④线程默认下会使用进程的令牌来访问对象。但它也可以拥有自己的访问令牌（被称为模仿令牌（ImperonaitonToken），但该令牌不是必须的，线程可以不拥有模仿令牌。模仿令牌的用处，如当一个线程要找开一个文件，但该文件只有User2才能打开，而主令牌属于User1，这时线程就可以模仿一个User2令牌来打开这个文件。

（2）访问令牌的特权





管理员身份运行（未筛选的令牌） 以标准用户权限运行（筛选令牌）

　　①以上实验是同一程序在相同登录帐号下，以管理员身份和直接运行时的权限比较。

　　②从两图可以得到：管理员身份运行下，应用程序的权限一般要比直接运行的要多。

　　③所谓的应用程序提权，有两种情况：

　　　　A、获得更多种的权限，如管理员身份运行下，有23种。而直接运行则只有5种。比如管理身份运行下有SeSystemEnvironmentPrivilege等权限，在直接运行(标准用户权限)时没有。

　　　　B、第2种情况是上面两种图，都有多种特权在默认下是没开启的，可以通过AdjustTokenPrivileges（或SetTokenInformation）来开启。如上图的“筛选令牌”中还有4种没开启。

　　④一个Token中的特权列表中，已经指明该Token可以拥有哪些特权。但不并是所有特权都开启的，如果要使用该特权，需要使用SetTokenInformation修改。注意，特权列表中没有的特权，是不能开启的。比如在直接运行下，其Token中有SeShutdownPrivilege的特权，所以是可以开启的，列表中没有SeSecurityPrivilege特权，所以是不能开启的，即只能在进程的边界上提升权限。（当然你非要添加的话还是有办法的)！

　　⑤特权列表：用TOKEN_PRIVILEGES结构体表示

字段	描述
DWORD PrivilegeCount	特权数量（数组的长度)
LUID_AND_ATTRIBUTES privilegs	特权数组。元素类型表示一种特权：由两部分组成 ①Luid：局部唯一标识符，代表某特权的值 ②Attributes：特权的属性，其值如下 SE_PRIVILEGE_ENABLED表示启用该特权 SE_PRIVILEGE_ENABLED_BY_DEFAULT表示使特权默认有效 SE_PRIVILEGE_REMOVED：表示禁用特权 SE_PRIVILEGE_USED_FOR_ACCESS：取得对象或服务的访问权

4.5.3 安全描述符（SecurityDescriptor）——是访问控制模型的灵魂，每个内核对象中都一个SecurityDescriptor结构体的指针，指向一个SD，该SD的结构体如下

（1）安全描述符的数据结构：



　　①SD中描述了该对象的拥有者Owner、用户Sid、SACL和DACL等信息。

　　②SACL：系统访问控制列表，用来记录某个安全对象被访问的情况，一般不用关心。

　　③DACL：自主访问控制列表，记录了哪些用户可以(/不可以)以何种方式访问该对象（重要）。

（2）ACE及安全访问机制



　　①DACL中包括访问控制项列表(AccessControl Entries，ACE) ，每个ACE指明哪个用户或组可以对该对象能否操作及何种操作。如上图的Tom用户不能读、写、执行。（注意SD上说的权限是指访问该对象的能力，而Token中所说的权限是指特权，如关机等系统操作）

　　②当打开一个对象时，会从线程所拥有的Token中(如果存在模仿令牌则使用模仿令牌，否则使用主令牌)获取用户名和用户所在组列表，与对象的安全描述符中的DACL比较，其匹配算法如下：

　　A、如果被访问对象的DACL为NULL，则线程拥有完全的访问权限。

　　B、对象的DACL不为NULL，但是AceCount ==0（ACE,访问控制项），则拒绝任何线程访问。

　　C、遍历DACL，找到与Token中用户或组一致的ACE，如果该ACE没有提供线程要访问的那项权限（如Group1组的用户要求写入时），则直接退出安全检查函数，并拒绝该线程访问。

　　D、遍历DACL，没找到跟令牌中用户或组一致的ACE，并拒绝该线程访问。

　　E、遍历DACL，找到与令牌中用户或组一致的ACE，如果该ACE中进（线）程要求的访问权限（如读写操作），结束安全检查，并允许该线程访问。

　　★注意：以上列表中的ACE排列顺序很重要，在匹配时会从列表的第1项开始，一旦匹配，就不再检查后面的ACE项。比如线程1要求写入该对象时，由于第1项列表指明不能写，所以该线程是不可访问这个对象，尽管Tom1用户属Group1用户组的（该组是允许写的），当然，如果将ACE中的第2项Group1移动到第1项时，Tom也是可写该对象的。

4.5.4 与访问令牌Token操作相关API

（1）API参数中对Token可能进行的操作——以下值一般作为API参数被传入

值	描述
TOKEN_ADJUST_DEFAULT	修改令牌所有者、主组或访问控制列表DACL
TOKEN_ADJUST_GROUPS	修改令牌的组属性
TOKEN_ADJUST_PRIVILEGES	Enable或Disable令牌的特权
TOKEN_ADJUST_SESSIONID	调整令牌的Session ID。进程需要 SE_TCB_NAME 特权。
TOKEN_ASSIGN_PRIMARY	为进程分配主令牌。需要 SE_ASSIGNPRIMARYTOKEN_NAME特权。
TOKEN_DUPLICATE	复制令牌
TOKEN_EXECUTE	合并 STANDARD_RIGHTS_EXECUTE 和 TOKEN_IMPERSONATE
TOKEN_IMPERSONATE	附加一个模拟令牌到进程
TOKEN_QUERY	查询令牌
TOKEN_QUERY_SOURCE	查询令牌源
TOKEN_READ	合并STANDARD_RIGHTS_READ 和TOKEN_QUERY
TOKEN_WRITE	合并 STANDARD_RIGHTS_WRITE, TOKEN_ADJUST_PRIVILEGES, TOKEN_ADJUST_GROUPS, 和 TOKEN_ADJUST_DEFAULT
TOKEN_ALL_ACCESS	合并所以可能的操作

（2）操作Token的API

　　①OpenProcessToken、OpenThreadToken

　　②AdjustTokenPrivileges、AdjustTokenGroups

　　③GetTokenInformation、SetTokenInformation

　　④LookupPrivilegeValue、PrivilegeCheck

　　④LookupPrivilegeDisplayName、LookupPrivilegeName

4.5.5 与安全描述符有关API

（1）安全标识符SID

①SID的组成

A、简访为S-R-I-S-S........

B、S表示数字系列、R表示修订级、I表示标识符权限值，后面S为子权限值。

C、SID实际上包含两个值：发行SID的机构的值，一个32位的相对标识符（RID）。RID指明了用户和组的信息。

如：S-1-5-21-310440588-250036847-580389505-500

我们来先分析这个重要的SID。第一项S表示该字符串是SID；第二项是SID的版本号，对于2000来说，这个就是1；然后是标志符的颁发机构（identifier authority），对于2000内的帐户，颁发机构就是NT，值是5。然后表示一系列的子颁发机构，前面几项是标志域的，最后一个标志着域内的帐户和组

②操作SID的相关API

A、AllocateAndInitializeSid、FreeSid

B、CopySid

C、EqualSid、EqualPrefixSid

D、GetLengthSid、GetSidLengthRequired

E、 GetSidIdentifierAuthority、GetSidSubAuthority、GetSidSubAuthorityCount

F、InitializeSid、IsValidSid

G、LookupAccountName、LookUpAccountSid

（2）安全描述符SD

①SD的格式

A、绝对格式：可用InitializeSecurityDescriptor得到

　　B、相对格式：SECURITE_DESCRIPTOR定义的

　　C、将绝对格式转为相对格式：MakeSelfRelativeSD

　　②创建SD的方法

　　　　//"D:(D;;GR;;;WD)(A;;GW;;;WD)" 的意思是: DACL添加Everyone用户，拒绝读，允许写权限

　　InitSecurityDescriptor( sa, TEXT("D:(D;;GR;;;WD)(A;;GW;;;WD)") );

　　//D:(A;;GA;;;WD) 的意思是: DACL添加Everyone用户，并让其拥有全部权限

　　InitSecurityDescriptor( sa, TEXT("D:(A;;GA;;;WD)") );

（3）操作ACL的API

　　①GetAclInformation、SetAclInformation

　　②GetSecurityDescriptorDacl、SetSecurityDescriptorDacl

　　③GetSecurityDescriptorSacl、SetSecurityDescriptorSacl

　　④InitializeAcl、IsValidAcl

【TokenInfo程序】显示访问令牌信息 (直接运行和以管理员身份运行时，会出现不同的结果！)

/********************************************************
显示本进程访问令牌（Token）的信息
*********************************************************/
#include <windows.h>
#include <tchar.h>
#include <sddl.h>
#include <stdio.h>

#define CheckAndLocalFree(ptr)    \
if (ptr != NULL)    \
{                    \
LocalFree(ptr); \
ptr = NULL;        \
}

//获取指定项目的令牌信息
LPVOID RetrieveTokenInfomationClass(
HANDLE  hToken,
TOKEN_INFORMATION_CLASS InfoClass,
LPDWORD pdwSize)
{
LPVOID pInfo = NULL;
BOOL  fSuccess = FALSE;
*pdwSize = 0;

__try
{
//第1次调用，获得返回令牌信息的所需的内存大小
GetTokenInformation(hToken, InfoClass, NULL, 0, pdwSize);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
_tprintf(_T("调用GetTokenInformation函数失败,错误代码：%d\n"), GetLastError());
__leave;
}

//分配内存，以获取指定项目的令牌信息
pInfo = LocalAlloc(LPTR, *pdwSize);
if (pInfo == NULL)
{
_tprintf(_T("调用LocaAlloc失败,错误代码：%d\n"), GetLastError());
__leave;
}

if (!GetTokenInformation(hToken, InfoClass, pInfo, *pdwSize, pdwSize))
{
_tprintf(_T("调用GetTokenInformation函数失败,错误代码：%d\n"), GetLastError());
__leave;
}

fSuccess = TRUE;
}
__finally
{
if (fSuccess == FALSE)
{
CheckAndLocalFree(pInfo);
}
}
return pInfo;
}

//显示用户SID
BOOL DisplayUserInfo(HANDLE hToken)
{
PTOKEN_USER pUserInfo = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;

//从令牌获取用户信息
pUserInfo = (PTOKEN_USER)RetrieveTokenInfomationClass(hToken, TokenUser, &dwSize);
if (NULL == pUserInfo)
return FALSE;

ConvertSidToStringSid(pUserInfo->User.Sid, &pName);

if (NULL == pName)
{
CheckAndLocalFree(pUserInfo);
return FALSE;
}

_tprintf(_T("User:\t\t%s\n"), pName);

CheckAndLocalFree(pUserInfo);
CheckAndLocalFree(pName);
return TRUE;
}

//显示所有者信息
BOOL DisplayOwnerInfo(HANDLE hToken)
{
PTOKEN_OWNER pOwnerInfo = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;

//从令牌获取所有者信息
pOwnerInfo = (PTOKEN_OWNER)RetrieveTokenInfomationClass(hToken, TokenOwner, &dwSize);
if (NULL == pOwnerInfo)
return FALSE;

ConvertSidToStringSid(pOwnerInfo->Owner, &pName);

if (NULL == pName)
{
CheckAndLocalFree(pOwnerInfo);
return FALSE;
}

_tprintf(_T("Owner:\t\t%s\n"), pName);

CheckAndLocalFree(pOwnerInfo);
CheckAndLocalFree(pName);
return TRUE;
}

//显示主用户组信息
BOOL DisplayPrimaryGroupInfo(HANDLE hToken)
{
PTOKEN_PRIMARY_GROUP ptgr = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;

//从令牌获取所有者信息
ptgr = (PTOKEN_PRIMARY_GROUP)RetrieveTokenInfomationClass(hToken, TokenPrimaryGroup, &dwSize);
if (NULL == ptgr)
return FALSE;

ConvertSidToStringSid(ptgr->PrimaryGroup, &pName);

if (NULL == pName)
{
CheckAndLocalFree(ptgr);
return FALSE;
}

_tprintf(_T("PrimaryGroup:\t%s\n"), pName);

CheckAndLocalFree(ptgr);
CheckAndLocalFree(pName);
return TRUE;
}

//显示源信息
BOOL DisplaySource(HANDLE hToken)
{
PTOKEN_SOURCE pSrc = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;

//从令牌获取源的信息
pSrc = (PTOKEN_SOURCE)RetrieveTokenInfomationClass(hToken, TokenSource, &dwSize);
if (NULL == pSrc)
return FALSE;

printf(("Source:\t\t%s\tSourceIdentifier:%08X%08X\n"), pSrc->SourceName,
pSrc->SourceIdentifier.HighPart, pSrc->SourceIdentifier.LowPart);

CheckAndLocalFree(pSrc);
CheckAndLocalFree(pName);
return TRUE;
}

//DisplayStatistics
BOOL DisplayStatistice(HANDLE hToken)
{
PTOKEN_STATISTICS pst = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;

//从令牌获取统计的信息
pst = (PTOKEN_STATISTICS)RetrieveTokenInfomationClass(hToken, TokenStatistics, &dwSize);
if (NULL == pst)
return FALSE;

//列出统计信息
printf("TokenID:\t%08X%08X\n", pst->TokenId.HighPart, pst->TokenId.LowPart);
printf("GroupCount:\t%d\n", pst->GroupCount);
printf("PrivilegeCount:\t%d\n", pst->PrivilegeCount);
printf("ImpersonationLevel:%d\n", pst->ImpersonationLevel);

if (pst->TokenType == TokenPrimary)
{
printf("TokenType:\tTokenPrimary\n");
}
else
printf("TokenType:\tTokenImpersonation\n");

CheckAndLocalFree(pst);
CheckAndLocalFree(pName);
return TRUE;
}

//显示用户组信息
BOOL DisplayGroupsInfo(HANDLE hToken)
{
PTOKEN_GROUPS pgrp = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;

//从令牌获取用户组信息
pgrp = (PTOKEN_GROUPS)RetrieveTokenInfomationClass(hToken, TokenGroups, &dwSize);
if (NULL == pgrp)
return FALSE;
printf("共找到token(0x%08x)的%d个Sid:\n", hToken, pgrp->GroupCount);

for (DWORD dwIndex = 0; dwIndex < pgrp->GroupCount; dwIndex++)
{
ConvertSidToStringSid(pgrp->Groups[dwIndex].Sid, &pName);
_tprintf(_T("  %d SID: %s"), dwIndex, pName);
CheckAndLocalFree(pName);

if ((pgrp->Groups[dwIndex].Attributes & SE_GROUP_LOGON_ID) == SE_GROUP_LOGON_ID)
{
dwSize = GetLengthSid(pgrp->Groups[dwIndex].Sid);
_tprintf(_T("  (This is LogonID)"));
}
_tprintf(_T("\n"));
}
CheckAndLocalFree(pName);
CheckAndLocalFree(pgrp);
return TRUE;
}

//显示特权信息
BOOL DisplayPrivileges(HANDLE hToken)
{
PTOKEN_PRIVILEGES ppv = NULL;
DWORD dwSize = 0;
PTSTR pName = NULL;
TCHAR privilegeName[500] = {};
TCHAR displayName[500] = {};
DWORD privilegeNameSize;
DWORD displayNameSize;
DWORD langID = GetUserDefaultLangID();

//从令牌获取特权信息
ppv = (PTOKEN_PRIVILEGES)RetrieveTokenInfomationClass(hToken, TokenPrivileges, &dwSize);
if (NULL == ppv)
return FALSE;
printf("token(0x%08x)的共有%d种权限:\n", hToken, ppv->PrivilegeCount);

for (DWORD dwIndex = 0; dwIndex < ppv->PrivilegeCount; dwIndex++)
{
privilegeNameSize = sizeof(privilegeName) / sizeof(privilegeName[0]);
displayNameSize = sizeof(displayName) / sizeof(displayName[0]);

LookupPrivilegeName(NULL, &ppv->Privileges[dwIndex].Luid,
privilegeName, &privilegeNameSize);

LookupPrivilegeDisplayName(NULL, privilegeName, displayName, &displayNameSize,
&langID);
_tprintf(_T("%-31s\t"), privilegeName);

if (ppv->Privileges[dwIndex].Attributes &(SE_PRIVILEGE_ENABLED | SE_PRIVILEGE_ENABLED_BY_DEFAULT))
{
_tprintf(_T("Enabled\n"));
}
else
_tprintf(_T("Disabled\n"));
}
CheckAndLocalFree(pName);
CheckAndLocalFree(ppv);
return TRUE;
}

//显示Token的用户名、所有者、主用户组、源、权限及统计信息
BOOL DisplayTokenInformation(HANDLE hToken)
{
//显示用户名
DisplayUserInfo(hToken);

//显示所有者信息
DisplayOwnerInfo(hToken);

//显示主用户组信息
DisplayPrimaryGroupInfo(hToken);

//显示源信息
DisplaySource(hToken);

//用户组信息
DisplayGroupsInfo(hToken);

//用户权限
DisplayPrivileges(hToken);

//显示统计信息
DisplayStatistice(hToken);
return TRUE;
}

//显示进程的访问令牌内容
BOOL DisplayCallerAccessTokenInformation()
{
HANDLE hToken = NULL;
BOOL bResult = FALSE;

//使用OpenThreadToken()函数判断线程运行的状态
bResult = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_QUERY_SOURCE,
TRUE, &hToken);
if (bResult == FALSE && GetLastError() == ERROR_NO_TOKEN)
{
//打开线程访问令牌失败后，尝试使用进程入口标志
bResult = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_QUERY_SOURCE,
&hToken);
}

if (bResult)
{
bResult = DisplayTokenInformation(hToken);
CloseHandle(hToken);
}
else
{
_tprintf(_T("OpenThread/ProcessToken failed with %d\n"), GetLastError());
}

return bResult;
}

int main()
{
DisplayCallerAccessTokenInformation();

_tsystem(_T("PAUSE"));
return 0;
}

【修改Token的特权】 直接运行和以管理员身份运行时，会出现不同的结果！

#include <windows.h>
#include <tchar.h>
#include <locale.h>
#include <sddl.h>
#include <stdio.h>
#include <Shlobj.h>

//提升（修改）权限
BOOL SetPrivilege(HANDLE hToken, LPTSTR pszPrivilege, BOOL bEnablePrivilege)
{
BOOL rv;
TOKEN_PRIVILEGES tp;
//函数查看系统权限的特权值，返回信息到一个LUID结构体里
rv = LookupPrivilegeValue(
NULL,//表示所要查看的系统，本地系统直接用NULL
pszPrivilege,//指向一个以零结尾的字符串，指定特权的名称,此参数可
//指定常数，如宏SE_SHUTDOWN_NAME对应的字符串为"SeShutdownPrivilege"
&tp.Privileges[0].Luid); //用来接收所返回的制定特权名称的信息

if (!rv)
{
_tprintf(_T("LookupPrivilegeValue error:%d\n"), GetLastError());
return FALSE;
}

tp.PrivilegeCount = 1;
if (bEnablePrivilege)
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
else
tp.Privileges[0].Attributes = 0;

//启用或禁止 指定访问令牌的特权
//返回值：ERROR_SUCCESS——成功
//        ERROR_NOT_ALL_ASSIGNED——这个令牌没有参数要修改的那一项或多项的权限。（1个或多个没有修改）
rv = AdjustTokenPrivileges(
hToken,//要修改权限的访问令牌句柄
FALSE, //禁用所有权限标志
&tp, //新特权信息缓冲区的指针(结构体)
sizeof(TOKEN_PRIVILEGES), //缓冲数据大小,以字节为单位
0,    //接收被改变特权当前状态的Buffer
0);   //接收当前状态缓冲区所需的大小
if (!rv)
{
_tprintf(_T("AdjustPrivilegeValue error:%d\n"), GetLastError());
return FALSE;
}

if (ERROR_NOT_ALL_ASSIGNED == GetLastError())
{
wprintf(L"分配指定的特权(%s)失败！\n", pszPrivilege);
return FALSE;
}
return TRUE;
}

LPTSTR g_pPrivileges[] =
{
SE_SHUTDOWN_NAME,
SE_BACKUP_NAME,
SE_DEBUG_NAME,
SE_TIME_ZONE_NAME,
SE_TCB_NAME
};

//用来返回提升类型和指出进程是否正在以管理员身份运行
BOOL GetProcessElevation(TOKEN_ELEVATION_TYPE* pElevationType, BOOL* pIsAdmin)
{
HANDLE hToken = NULL;
BOOL bResult = FALSE;
DWORD dwSize;

if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
return FALSE;

//获取提升权限的类型
//TokenElevationTypeDefault     默认运行用户运行,UAC被禁用
//TokenElevationTypeFull        权限被成功提升, 而且令牌没有被筛选过
//TokenElevationTypeLimited      进程以受限的权限运行, 它对应于一个筛选过的令牌
if (GetTokenInformation(hToken, TokenElevationType,
pElevationType, sizeof(TOKEN_ELEVATION_TYPE),&dwSize))
{
//创建管理员组SID
BYTE adminSID[SECURITY_MAX_SID_SIZE];
dwSize = sizeof(adminSID);
CreateWellKnownSid(WinBuiltinAdministratorsSid, NULL, &adminSID, &dwSize);

//进程是否受限的权限运行, 它对应于一个筛选过的令牌
if (*pElevationType == TokenElevationTypeLimited)
{
//获取链接令牌（未筛选Token？）的句柄
HANDLE hUnfilterToken = NULL;
GetTokenInformation(hToken, TokenLinkedToken, (LPVOID)&hUnfilterToken,
sizeof(HANDLE), &dwSize);

//检测令牌是否包含管理员SID
if (CheckTokenMembership(hUnfilterToken,&adminSID,pIsAdmin))
{
bResult = TRUE;
}
CloseHandle(hUnfilterToken);
}
else
{
//不是受限用户，则判断是否管理员
*pIsAdmin = IsUserAnAdmin(); //须包含Shlobj.h
bResult = TRUE;
}
}

CloseHandle(hToken);
return bResult;
}

int main()
{
setlocale(LC_ALL, "chs");

HANDLE hToken = NULL;
OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);
int iCnt = sizeof(g_pPrivileges) / sizeof(g_pPrivileges[0]);
for (int i = 0; i < iCnt; i++)
{
if (SetPrivilege(hToken, g_pPrivileges[i], TRUE))
{
wprintf(L"特权%s打开成功！\n", g_pPrivileges[i]);
}
}
TOKEN_ELEVATION_TYPE ElevationType;
BOOL IsAdmin;
GetProcessElevation(&ElevationType, &IsAdmin);

//当前进程权限上下文
wprintf(L"\n");
if (IsAdmin)
wprintf(L"当前是以管理员帐号登录！\n");
else
wprintf(L"当前是以非管理员帐号登录！\n");

if (ElevationType == TokenElevationTypeLimited)
wprintf(L"进程以受限的权限(筛选令牌)运行!\n");
else if (ElevationType == TokenElevationTypeFull)
wprintf(L"进程以完全权限(未筛选令牌)运行!\n");
else
wprintf(L"默认用户运行,UAC被禁用!\n");

_tsystem(_T("PAUSE"));
return 0;
}

4.5.6 以管理员身份运行程序的方法

（1）应用程序→右键→“以管理员身份运行”

（2）自动提升进程的权限——VS2013下

　　①找到工程属性→“配置属性”→“链接器”→“清单文件”

　　②在“生成清单”中选择“是”，启动用户帐户控制（UAC）选“是”，UAC执行级别中选择“requireAdministrator”

　　★如果只是为了在VS中调试程序，可以“管理员身份”运行VS，但这只能在调试中提升权限。生成的应用程序本身并没有被改变过来。

（3）手动提升进程的权限——函数ShellExcuteEx（LPSHELLEXECUTEINFO pExecInfo）

参数	描述
PSHELLEXECUTEINFO pExecInfo	SHELLEXECUTEINFO结构体设置 ①lpVert字段：必须设为TEXT("runas") ②lpFile字段：TEXT("xxx.exe") ③nShow字段：SW_SHOWNORMAL ④lpParameters：用来传递给子进程的命令行参数
返回值	成功——TRUE 失败——FALSE，如果用户拒绝提升权限，GetLastError返回ERROR_CANCELLED

★当以管理员身份运行后，表示进程访问令牌的特权就越多，但很多特权默认是禁用的，所以还得通过AdjustTokenPrivileges等函数来启用这些特权。

4.5.7完整性级别（Integrity levels）

（1）完整性级别简介

①在进行对进程“访问令牌”与“安全描述符”的匹配时，要先进行完整性级别的比较，注意这个比较是在检查DACL之前完成的。所以，即便进程拥有访问资源的权限，但由于进程的完整性级别低于资源所要求的完整性级别，访问仍会被拒绝！

②信任级别

级别	应用程序示例
低	应用程序以低信任级别运行，就无法访问高任信级别的资源，如保护模式下的IE，就是运行在低级别的，目的就是拒绝从网上下载代码修改Windows环境。
中	默认情况下，所有应用程序都以“中”信任级别来启动，并使用一个“筛选令牌”来运行
高	如果应用程序以提升后的权限来启动，则以“高”信任级别来运行
系统	只有以LocalSystem或LocalService身份运行的进程，才能获得这个信任级别。

（2）进程完整性级别

①获取和设置进程完整性级别

　　PTOKEN_MANDATORY_LABEL pTokenInfo;

　　 GetTokenInformation(hToken,TokenIntegrityLevel,pTokenInfo,dwNeededSize,&dwNeededSize));

②LookupAccountSid 函数得到完整性级别的可显示名称

（3）资源完整性级别（Resource integrity levels）

　　①资源的完整性级别存放在安全描述符的系统访问控制表（SACL）中的一个特殊的访问控制项（ACE）中。

　　②看到大多数资源并没有显式地设定其完整性级别。系统将没有显式声明完整性级别的资源看作带有中等完整性级别。

　　③操作的API

　　 A、获取和设置： GetNamedSecurityInfo、SetNamedSecurityInfo——调用的参数LABEL_SECURITY_INFORMATION。

　　 B、增加：InitializeAcl、AddMandatoryAce