以程序的方式操纵NTFS的文件权限
2017-04-26 15:33
423 查看
本篇文章内容主要参考了 陈皓 《以程序的方式操纵NTFS的文件权限 》，然后加入了一些自己学习和理解的东西。
在NTFS文件系统出现后，在Windows系统(2K/XP/Vista..)下的对象，包括文件系统，进程、命名管道、打印机、网络共享、或是注册表等等，都可以设置用户访问权限。
在Windows系统中，其是用一个安全描述符（Security Descriptors）的结构来保存其权限的设置信息，简称为SD，其在Windows SDK中的结构名是“SECURITY_DESCRIPTOR”，这是包括了安全设置信息的结构体，其结构体内容定义如下：
typedef struct _SECURITY_DESCRIPTOR {
UCHAR Revision;
UCHAR Sbz1;
SECURITY_DESCRIPTOR_CONTROL Control;
PSID Owner;
PSID Group;
PACL Sacl;
PACL Dacl;
} SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;
一个安全描述符包含以下安全信息：
两个安全标识符(Security identifiers)，简称为SID，分别是OwnerSid和GroupSid. 所谓SID就是每次当我们创建一个用户或一个组的时候，系统会分配给改用户或组一个唯一SID，当你重新安装系统后，也会得到一个唯一的SID。SID是唯一的，不随用户的删除而分配到另外的用户使用。
请记住，SID永远都是唯一的SIF是由计算机名、当前时间、当前用户态线程的CPU耗费时间的总和三个参数决定以保证它的唯一性。
例： S-1-5-21-1763234323-3212657521-1234321321-500
一个DACL（Discretionary Access Control List），其指出了允许和拒绝某用户或用户组的存取控制列表。 当一个进程需要访问安全对象，系统就会检查DACL来决定进程的访问权。如果一个对象没有DACL，那么就是说这个对象是任何人都可以拥有完全的访问权限。
一个SACL（System Access Control List），其指出了在该对象上的一组存取方式（如，读、写、运行等）的存取控制权限细节的列表。
还有其自身的一些控制位。SECURITY_DESCRIPTOR_CONTROL
DACL和SACL构成了整个存取控制列表Access Control List，简称ACL，ACL中的每一项，我们叫做ACE（Access Control Entry），ACL中的每一个ACE。
ACL结构体的内容如下：
typedef struct _ACL {
BYTE AclRevision;
BYTE Sbz1;
WORD AclSize;
WORD AceCount;
WORD Sbz2;
} ACL;
typedef ACL *PACL;
我们的程序不用直接维护SD这个结构，这个结构由系统维护。我们只用使用Windows 提供的相关的API函数来取得并设置SD中的信息就行了。不过这些API函数只有Windows NT/2K/XP才支持。
Windows提供了一系列的安全信息的存取，控制函数，如 GetNamedSecurityInfo, SetNamedSecurityInfo，GetSecurityInfo, SetSecurityInfo等。
下图说明了，安全对象和DACL以及访问者之间的联系（来源于MSDN）。注意，DACL表中的每个ACE的顺序是有意义的，如果 前面的Allow（或denied）ACE通过了，那么，系统就不会检查后面的ACE了。另外"拒绝"权限一般是优先于其他权限的。ACE在DACL中的 顺序非常重要。
系统会按照顺序依次检查所有的ACE规则，如下面的条件满足，则退出：
1、 如果一个Access-Denied的ACE明显地拒绝了请求者。
2、 如果某Access-Allowed的ACE明显地同意了请求者。
3、 全部的ACE都检查完了，但是没有一条ACE明显地允许或是拒绝请求者，那么系统将使用默认值，拒绝请求者的访问。
更多的理论和描述，请参看MSDN。
实例例程
主要实现2个功能，获取目录的安全设置和为目录增加一个安全设置项（该程序来源于MSDN，原作者 陈皓稍作修改，并加入了注解，我也稍作了点修改）
1、 对于文件、目录、命令管道，我们不一定要使用GetNamedSecurityInfo和SetNamedSecurityInfo函数，我们可以使用其专用函数GetFileSecurity和SetFileSecurity函数来取得或设置文件对象的SD，以设置其访问权限。需要使用这两个函数并不容易，正如前面我们所说的，我们还需要处理SD参数，要处理SD，就需要处理DACL和ACE，以及用户的相关SID，于是，一系统列的函数就被这两个函数带出来了。
2、 对于上一个例子中的使用硬编码指定SID的处理方法是。调用LookupAccountName函数时，先把SID，Domain名的参数传为空 NULL，于是LookupAccountName会返回用户的SID的长度和Domain名的长度，于是你可以根据这个长度分配内存，然后再次调用 LookupAccountName函数。于是就可以达到到态分配内存的效果。对于ACL也一样。
3、 对于给文件的ACL中增加一个ACE条目，一般的做法是先取出文件上的ACL，逐条取出ACE，和现需要增加的ACE比较，如果有冲突，则删除已有的 ACE，把新加的ACE添置到最后。这里的最后，应该是非继承而来的ACE的最后。关于ACL继承，NTFS中，你可以设置文件和目录是否继承于其父目录 的设置。在程序中同样可以设置。
还是请看例程，这个程序比较长，来源于MSDN，我做了一点点修改，并把自己的理解加在注释中，所以，请注意代码中的注释：
// SetSD.cpp : コンソール アプリケーションのエントリ ポイントを定義します。
//
#include <stdio.h>
#include <bitset>
#include <tchar.h>
#include <windows.h>
#include <string>
#include <iostream>
using std::bitset;
using std::string;
using std::cout;
using std::endl;
//使用Windows的HeapAlloc函数进行动态内存分配
#define myheapalloc(x) (HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, x))
#define myheapfree(x) (HeapFree(GetProcessHeap(), 0, x))
typedef BOOL (WINAPI *SetSecurityDescriptorControlFnPtr)(
IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
IN SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
IN SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);
typedef BOOL (WINAPI *AddAccessAllowedAceExFnPtr)(
PACL pAcl,
DWORD dwAceRevision,
DWORD AceFlags,
DWORD AccessMask,
PSID pSid
);
//【接口】
// BOOL AddAccessRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, DWORD dwAccessMask)
//【机能概要】
// 为文件(目录)添加一个帐户（组）的权限
//【入力】
// TCHAR *lpszFileName 文件（目录）
// TCHAR *lpszAccountName 帐户（组）
// DWORD dwAccessMask 权限设置(如GENERIC_ALL，GENERIC_READ等)
//【输出】
// 无
//【输入输出】
// 无
//【返回值】
// BOOL
//【例外】
// 无
//---------------------------------------------------------------------------
BOOL AddAccessRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, DWORD dwAccessMask) {
// 声明SID变量
SID_NAME_USE snuType;
// 声明和LookupAccountName相关的变量（注意，全为0，要在程序中动态分配）
TCHAR * szDomain = NULL;
DWORD cbDomain = 0;
LPVOID pUserSID = NULL;
DWORD cbUserSID = 0;
// 和文件相关的安全描述符 SD 的变量
PSECURITY_DESCRIPTOR pFileSD = NULL; // 结构变量
DWORD cbFileSD = 0; // SD的size
// 一个新的SD的变量，用于构造新的ACL（把已有的ACL和需要新加的ACL整合起来）
SECURITY_DESCRIPTOR newSD;
// 和ACL 相关的变量
PACL pACL = NULL;
BOOL fDaclPresent;
BOOL fDaclDefaulted;
ACL_SIZE_INFORMATION AclInfo;
// 一个新的 ACL 变量
PACL pNewACL = NULL; //结构指针变量
DWORD cbNewACL = 0; //ACL的size
// 一个临时使用的 ACE 变量
LPVOID pTempAce = NULL;
UINT CurrentAceIndex = 0; //ACE在ACL中的位置
UINT newAceIndex = 0; //新添的ACE在ACL中的位置
//API函数的返回值，假设所有的函数都返回失败。
BOOL fResult = FALSE;
BOOL fAPISuccess = FALSE;
SECURITY_INFORMATION secInfo = DACL_SECURITY_INFORMATION;
// 下面的两个函数是新的API函数，仅在Windows 2000以上版本的操作系统支持。
// 在此将从Advapi32.dll文件中动态载入。如果你使用VC++ 6.0编译程序，而且你想
// 使用这两个函数的静态链接。则请为你的编译加上：/D_WIN32_WINNT=0x0500
// 的编译参数。并且确保你的SDK的头文件和lib文件是最新的。
SetSecurityDescriptorControlFnPtr _SetSecurityDescriptorControl = NULL;
AddAccessAllowedAceExFnPtr _AddAccessAllowedAceEx = NULL;
__try {
//
// STEP 1: 通过用户名取得SID
// 在这一步中LookupAccountName函数被调用了两次，第一次是取出所需要
// 的内存的大小，然后，进行内存分配。第二次调用才是取得了用户的帐户信息。
// LookupAccountName同样可以取得域用户或是用户组的信息。（请参看MSDN）
//
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
pUserSID = myheapalloc(cbUserSID);
if (!pUserSID) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
szDomain = (TCHAR *) myheapalloc(cbDomain * sizeof(TCHAR));
if (!szDomain) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
if (!fAPISuccess) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 2: 取得文件（目录）相关的安全描述符SD
// 使用GetFileSecurity函数取得一份文件SD的拷贝，同样，这个函数也
// 是被调用两次，第一次同样是取SD的内存长度。注意，SD有两种格式：自相关的
// （self-relative）和 完全的（absolute），GetFileSecurity只能取到“自
// 相关的”，而SetFileSecurity则需要完全的。这就是为什么需要一个新的SD，
// 而不是直接在GetFileSecurity返回的SD上进行修改。因为“自相关的”信息
// 是不完整的。
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, 0, &cbFileSD);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
pFileSD = myheapalloc(cbFileSD);
if (!pFileSD) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, cbFileSD, &cbFileSD);
if (!fAPISuccess) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 3: 初始化一个新的SD
//
if (!InitializeSecurityDescriptor(&newSD,
SECURITY_DESCRIPTOR_REVISION)) {
_tprintf(TEXT("InitializeSecurityDescriptor() failed.")
TEXT("Error %d\n"), GetLastError());
__leave;
}
//
// STEP 4: 从GetFileSecurity 返回的SD中取DACL
//
if (!GetSecurityDescriptorDacl(pFileSD, &fDaclPresent, &pACL,
&fDaclDefaulted)) {
_tprintf(TEXT("GetSecurityDescriptorDacl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 5: 取 DACL的内存size
// GetAclInformation可以提供DACL的内存大小。只传入一个类型为
// ACL_SIZE_INFORMATION的structure的参数，需DACL的信息，是为了
// 方便我们遍历其中的ACE。
AclInfo.AceCount = 0; // Assume NULL DACL.
AclInfo.AclBytesFree = 0;
AclInfo.AclBytesInUse = sizeof(ACL);
if (pACL == NULL)
fDaclPresent = FALSE;
// 如果DACL不为空，则取其信息。（大多数情况下“自关联”的DACL为空）
if (fDaclPresent) {
if (!GetAclInformation(pACL, &AclInfo,
sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
_tprintf(TEXT("GetAclInformation() failed. Error %d\n"),
GetLastError());
__leave;
}
}
//
// STEP 6: 计算新的ACL的size
// 计算的公式是：原有的DACL的size加上需要添加的一个ACE的size，以
// 及加上一个和ACE相关的SID的size，最后减去两个字节以获得精确的大小。
cbNewACL = AclInfo.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE)
+ GetLengthSid(pUserSID) - sizeof(DWORD);
//
// STEP 7: 为新的ACL分配内存
//
pNewACL = (PACL) myheapalloc(cbNewACL);
if (!pNewACL) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
//
// STEP 8: 初始化新的ACL结构
//
if (!InitializeAcl(pNewACL, cbNewACL, ACL_REVISION2)) {
_tprintf(TEXT("InitializeAcl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 9 如果文件（目录） DACL 有数据，拷贝其中的ACE到新的DACL中
//
// 下面的代码假设首先检查指定文件（目录）是否存在的DACL，如果有的话，
// 那么就拷贝所有的ACE到新的DACL结构中，我们可以看到其遍历的方法是采用
// ACL_SIZE_INFORMATION结构中的AceCount成员来完成的。在这个循环中，
// 会按照默认的ACE的顺序来进行拷贝（ACE在ACL中的顺序是很关键的），在拷
// 贝过程中，先拷贝非继承的ACE（我们知道ACE会从上层目录中继承下来）
//
newAceIndex = 0;
if (fDaclPresent && AclInfo.AceCount) {
for (CurrentAceIndex = 0;
CurrentAceIndex < AclInfo.AceCount;
CurrentAceIndex++) {
//
// STEP 10: 从DACL中取ACE
//
if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
_tprintf(TEXT("GetAce() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 11: 检查是否是非继承的ACE
// 如果当前的ACE是一个从父目录继承来的ACE，那么就退出循环。
// 因为，继承的ACE总是在非继承的ACE之后，而我们所要添加的ACE
// 应该在已有的非继承的ACE之后，所有的继承的ACE之前。退出循环
// 正是为了要添加一个新的ACE到新的DACL中，这后，我们再把继承的
// ACE拷贝到新的DACL中。
//
if (((ACCESS_ALLOWED_ACE *)pTempAce)->Header.AceFlags
& INHERITED_ACE)
break;
//
// STEP 12: 检查要拷贝的ACE的SID是否和需要加入的ACE的SID一样，
// 如果一样，那么就应该废掉已存在的ACE，也就是说，同一个用户的存取
// 权限的设置的ACE，在DACL中应该唯一。这在里，跳过对同一用户已设置
// 了的ACE，仅是拷贝其它用户的ACE。
//
if (EqualSid(pUserSID,
&(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
{
ACCESS_ALLOWED_ACE pTempAce2 = *(ACCESS_ALLOWED_ACE *)pTempAce;
ACCESS_DENIED_ACE pTempAce4 = *(ACCESS_DENIED_ACE *)pTempAce;
int a = -1;
if (pTempAce2.Header.AceType == ACCESS_ALLOWED_ACE_TYPE)
{
a = 0;
}
else if (pTempAce2.Header.AceType == ACCESS_DENIED_ACE_TYPE)
{
a = 1;
}
else
a = 2;
continue;
}
//
// STEP 13: 把ACE加入到新的DACL中
// 下面的代码中，注意 AddAce 函数的第三个参数，这个参数的意思是
// ACL中的索引值，意为要把ACE加到某索引位置之后，参数MAXDWORD的
// 意思是确保当前的ACE是被加入到最后的位置。
//
if (!AddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
((PACE_HEADER) pTempAce)->AceSize)) {
_tprintf(TEXT("AddAce() failed. Error %d\n"),
GetLastError());
__leave;
}
newAceIndex++;
}
}
//
// STEP 14: 把一个 access-allowed 的ACE 加入到新的DACL中
// 前面的循环拷贝了所有的非继承且SID为其它用户的ACE，退出循环的第一件事
// 就是加入我们指定的ACE。请注意首先先动态装载了一个AddAccessAllowedAceEx
// 的API函数，如果装载不成功，就调用AddAccessAllowedAce函数。前一个函数仅
// 在Windows 2000以后的版本支持，NT则没有，我们为了使用新版本的函数，我们首
// 先先检查一下当前系统中可不可以装载这个函数，如果可以则就使用。使用动态链接
// 比使用静态链接的好处是，程序运行时不会因为没有这个API函数而报错。
//
// Ex版的函数多出了一个参数AceFlag（第三人参数），用这个参数我们可以来设置一
// 个叫ACE_HEADER的结构，以便让我们所设置的ACE可以被其子目录所继承下去，而
// AddAccessAllowedAce函数不能定制这个参数，在AddAccessAllowedAce函数
// 中，其会把ACE_HEADER这个结构设置成非继承的。
//
_AddAccessAllowedAceEx = (AddAccessAllowedAceExFnPtr)
GetProcAddress(GetModuleHandle(TEXT("advapi32.dll")),
"AddAccessAllowedAceEx");
if (_AddAccessAllowedAceEx) {
if (!_AddAccessAllowedAceEx(pNewACL, ACL_REVISION2,
CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE ,
dwAccessMask, pUserSID)) {
_tprintf(TEXT("AddAccessAllowedAceEx() failed. Error %d\n"),
GetLastError());
__leave;
}
}else{
if (!AddAccessAllowedAce(pNewACL, ACL_REVISION2,
dwAccessMask, pUserSID)) {
_tprintf(TEXT("AddAccessAllowedAce() failed. Error %d\n"),
GetLastError());
__leave;
}
}
//
// STEP 15: 按照已存在的ACE的顺序拷贝从父目录继承而来的ACE
//
bitset<32> bit(dwAccessMask);
if (fDaclPresent && AclInfo.AceCount) {
for (;
CurrentAceIndex < AclInfo.AceCount;
CurrentAceIndex++) {
//
// STEP 16: 从文件（目录）的DACL中继续取ACE
//
if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
_tprintf(TEXT("GetAce() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 17: 把ACE加入到新的DACL中
//
if (!AddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
((PACE_HEADER) pTempAce)->AceSize)) {
_tprintf(TEXT("AddAce() failed. Error %d\n"),
GetLastError());
__leave;
}
}
}
//
// STEP 18: 把新的ACL设置到新的SD中
//
if (!SetSecurityDescriptorDacl(&newSD, TRUE, pNewACL,
FALSE)) {
_tprintf(TEXT("SetSecurityDescriptorDacl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 19: 把老的SD中的控制标记再拷贝到新的SD中，我们使用的是一个叫
// SetSecurityDescriptorControl() 的API函数，这个函数同样只存在于
// Windows 2000以后的版本中，所以我们还是要动态地把其从advapi32.dll
// 中载入，如果系统不支持这个函数，那就不拷贝老的SD的控制标记了。
//
_SetSecurityDescriptorControl =(SetSecurityDescriptorControlFnPtr)
GetProcAddress(GetModuleHandle(TEXT("advapi32.dll")),
"SetSecurityDescriptorControl");
if (_SetSecurityDescriptorControl) {
SECURITY_DESCRIPTOR_CONTROL controlBitsOfInterest = 0;
SECURITY_DESCRIPTOR_CONTROL controlBitsToSet = 0;
SECURITY_DESCRIPTOR_CONTROL oldControlBits = 0;
DWORD dwRevision = 0;
if (!GetSecurityDescriptorControl(pFileSD, &oldControlBits,
&dwRevision)) {
_tprintf(TEXT("GetSecurityDescriptorControl() failed.")
TEXT("Error %d\n"), GetLastError());
__leave;
}
if (oldControlBits & SE_DACL_AUTO_INHERITED) {
controlBitsOfInterest =
SE_DACL_AUTO_INHERIT_REQ |
SE_DACL_AUTO_INHERITED ;
controlBitsToSet = controlBitsOfInterest;
}
else if (oldControlBits & SE_DACL_PROTECTED) {
controlBitsOfInterest = SE_DACL_PROTECTED;
controlBitsToSet = controlBitsOfInterest;
}
if (controlBitsOfInterest) {
if (!_SetSecurityDescriptorControl(&newSD,
controlBitsOfInterest,
controlBitsToSet)) {
_tprintf(TEXT("SetSecurityDescriptorControl() failed.")
TEXT("Error %d\n"), GetLastError());
__leave;
}
}
}
//
// STEP 20: 把新的SD设置设置到文件的安全属性中（千山万水啊，终于到了）
//
if (!SetFileSecurity(lpszFileName, secInfo,
&newSD)) {
_tprintf(TEXT("SetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
fResult = TRUE;
} __finally {
//
// STEP 21: 释放已分配的内存，以免Memory Leak
//
if (pUserSID) myheapfree(pUserSID);
if (szDomain) myheapfree(szDomain);
if (pFileSD) myheapfree(pFileSD);
if (pNewACL) myheapfree(pNewACL);
}
return fResult;
}
//【接口】
// BOOL GetAccountRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, int (&arrRights)[32])
//【机能概要】
// 获取该文件(目录)指定帐户（组）的权限
//【入力】
// TCHAR *lpszFileName 文件（目录）
// TCHAR *lpszAccountName 帐户（组）
// int (&arrRights)[32] 数组引用，要求传入参数必须是32个int数组
//【输出】
// 无
//【输入输出】
// 无
//【返回值】
// BOOL
//【例外】
// 无
//---------------------------------------------------------------------------
BOOL GetAccountRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, int (&arrRights)[32]) {
//将参数arrRights初始化为0
for (int i = 0; i < 32; i++)
{
arrRights[i] = 0;
}
// 声明SID变量
SID_NAME_USE snuType;
// 声明和LookupAccountName相关的变量（注意，全为0，要在程序中动态分配）
TCHAR * szDomain = NULL;
DWORD cbDomain = 0;
LPVOID pUserSID = NULL;
DWORD cbUserSID = 0;
// 和文件相关的安全描述符 SD 的变量
PSECURITY_DESCRIPTOR pFileSD = NULL; // 结构变量
DWORD cbFileSD = 0; // SD的size
// 和ACL 相关的变量
PACL pACL = NULL;
BOOL fDaclPresent;
BOOL fDaclDefaulted;
ACL_SIZE_INFORMATION AclInfo;
// 一个临时使用的 ACE 变量
LPVOID pTempAce = NULL;
UINT CurrentAceIndex = 0; //ACE在ACL中的位置
//API函数的返回值，假设所有的函数都返回失败。
BOOL fResult = FALSE;
BOOL fAPISuccess = FALSE;
SECURITY_INFORMATION secInfo = DACL_SECURITY_INFORMATION;
__try {
//
// STEP 1: 通过用户名取得SID
// 在这一步中LookupAccountName函数被调用了两次，第一次是取出所需要
// 的内存的大小，然后，进行内存分配。第二次调用才是取得了用户的帐户信息。
// LookupAccountName同样可以取得域用户或是用户组的信息。（请参看MSDN）
//
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
pUserSID = myheapalloc(cbUserSID);
if (!pUserSID) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
szDomain = (TCHAR *) myheapalloc(cbDomain * sizeof(TCHAR));
if (!szDomain) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
if (!fAPISuccess) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 2: 取得文件（目录）相关的安全描述符SD
// 使用GetFileSecurity函数取得一份文件SD的拷贝，同样，这个函数也
// 是被调用两次，第一次同样是取SD的内存长度。注意，SD有两种格式：自相关的
// （self-relative）和 完全的（absolute），GetFileSecurity只能取到“自
// 相关的”，而SetFileSecurity则需要完全的。这就是为什么需要一个新的SD，
// 而不是直接在GetFileSecurity返回的SD上进行修改。因为“自相关的”信息
// 是不完整的。
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, 0, &cbFileSD);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
pFileSD = myheapalloc(cbFileSD);
if (!pFileSD) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, cbFileSD, &cbFileSD);
if (!fAPISuccess) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 3: 从GetFileSecurity 返回的SD中取DACL
//
if (!GetSecurityDescriptorDacl(pFileSD, &fDaclPresent, &pACL,
&fDaclDefaulted)) {
_tprintf(TEXT("GetSecurityDescriptorDacl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 4: 取 DACL的内存size
// GetAclInformation可以提供DACL的内存大小。只传入一个类型为
// ACL_SIZE_INFORMATION的structure的参数，需DACL的信息，是为了
// 方便我们遍历其中的ACE。
AclInfo.AceCount = 0; // Assume NULL DACL.
AclInfo.AclBytesFree = 0;
AclInfo.AclBytesInUse = sizeof(ACL);
if (pACL == NULL)
fDaclPresent = FALSE;
// 如果DACL不为空，则取其信息。（大多数情况下“自关联”的DACL为空）
if (fDaclPresent) {
if (!GetAclInformation(pACL, &AclInfo,
sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
_tprintf(TEXT("GetAclInformation() failed. Error %d\n"),
GetLastError());
__leave;
}
}
//
// STEP 5 如果文件（目录） DACL 有数据，将指定帐户的ACE的访问权限转换到整型数组
//
// 下面的代码假设首先检查指定文件（目录）是否存在的DACL，如果有的话，
// 那么就将指定帐户的ACE的访问权限转换到整型数组，我们可以看到其遍历的方法
// 是采用ACL_SIZE_INFORMATION结构中的AceCount成员来完成的。在这个循环中，
// 查找和指定账户相关的ACE
//
if (fDaclPresent && AclInfo.AceCount) {
for (CurrentAceIndex = 0;
CurrentAceIndex < AclInfo.AceCount;
CurrentAceIndex++) {
//
// STEP 10: 从DACL中取ACE
//
if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
_tprintf(TEXT("GetAce() failed. Error %d\n"),
GetLastError());
__leave;
}
//
//
// STEP 6: 检查要拷贝的ACE的SID是否和需要加入的ACE的SID一样，
// 如果一样，那么就将该ACE的访问权限转换到整型数组，
// 否则跳过，进行下一个循环
//
int nAceType = 1;
if (EqualSid(pUserSID,
&(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
{
if(((PACE_HEADER)pTempAce)->AceType == ACCESS_DENIED_ACE_TYPE)
{
nAceType = 2;
}
else
{
nAceType = 1;
}
//bitset类代表的整型数值的顺序是从0到N-1
bitset<32> bitAccessMask(((ACCESS_ALLOWED_ACE*)pTempAce)->Mask);
for (int i = 0; i < 32; i++)
{
if (bitAccessMask[i] != 0 && arrRights[i] != 2)
{
arrRights[i] = nAceType;
}
}
}
else
{
continue;
}
}
}
fResult = TRUE;
} __finally {
//
// STEP 7: 释放已分配的内存，以免Memory Leak
//
if (pUserSID) myheapfree(pUserSID);
if (szDomain) myheapfree(szDomain);
if (pFileSD) myheapfree(pFileSD);
}
return fResult;
}
int _tmain(int argc, TCHAR *argv[])
{
if (argc < 3) {
_tprintf(TEXT("usage: \"%s\" <FileName> <AccountName>\n"), argv[0]);
return 1;
}
//关于ACCESS_MASK中各个位代表的含义请参考MSDN
string filedesc[] = {"FILE_READ_DATA", "FILE_WRITE_DATA", "FILE_APPEND_DATA", "FILE_READ_EA",
"FILE_WRITE_EA", "FILE_EXECUTE", "FILE_DELETE_CHILD", "FILE_READ_ATTRIBUTES",
"FILE_WRITE_ATTRIBUTES", " ", " ", " ",
" ", " ", " ", " ",
"DELETE ", "READ_CONTROL", "WRITE_DAC", "WRITE_OWNER",
"SYNCHRONIZE ", " ", " "," ",
"ACCESS_SYSTEM_SECURITY", "MAXIMUM_ALLOWED", " "," ",
"GENERIC_ALL", "GENERIC_EXECUTE", "GENERIC_WRITE","GENERIC_READ"};
string rights[] = {"Allow", "Deny"};
//获取ACE中的访问权限
//ACE中的访问权限是通过DWORD类型的ACCESS_MASK记录的
//GetAccountRights函数将ACCESS_MASK转为了一个32个元素的整型数组，并传出
int arrRights[32] = {0};
if (!GetAccountRights(argv[1], argv[2], arrRights))
{
_tprintf(TEXT("GetAccountRights() failed.\n"));
}
else
{
_tprintf(TEXT("The access rights of the file is..\n"));
for (int i = 0; i < 32; i++)
{
int nTmpRight = arrRights[i];
if (nTmpRight != 0)
{
cout<<filedesc[i]<<": "<<rights[nTmpRight-1]<<endl;
}
}
}
// argv[1] – 文件（目录）名
// argv[2] – 用户（组）名
// GENERIC_ALL表示所有的权限，其是一系列的NTFS权限的或
// NTFS的文件权限很细，还请参看MSDN。
if (!AddAccessRights(argv[1], argv[2], GENERIC_ALL)) {
_tprintf(TEXT("AddAccessRights() failed.\n"));
return 1;
}
else {
_tprintf(TEXT("AddAccessRights() succeeded.\n"));
return 0;
}
}
函数AddAccessRights实现为文件(目录)添加一个帐户（组）的权限
函数GetAccountRights实现获取该文件(目录)指定帐户（组）的权限
三、 一些相关的API函数
通过以上的示例，相信你已知道如何操作NTFS文件安全属性了，还有一些API函数需要介绍一下。
1、 如果你要加入一个Access-Denied 的ACE，你可以使用AddAccessDeniedAce函数
2、 如果你要删除一个ACE，你可以使用DeleteAce函数
3、 如果你要检查你所设置的ACL是否合法，你可以使用IsValidAcl函数，同样，对于SD的合法也有一个叫IsValidSecurityDescriptor的函数
4、 MakeAbsoluteSD和MakeSelfRelativeSD两个函数可以在两种SD的格式中进行转换。
5、 使用SetSecurityDescriptorDacl 和 SetSecurityDescriptorSacl可以方便地把ACL设置到SD中。
6、 使用GetSecurityDescriptorDacl or GetSecurityDescriptorSacl可以方便地取得SD中的ACL结构。
我们把一干和SD/ACL/ACE相关的API函数叫作Low-Level Security Descriptor Functions，其详细信息还请参看MSDN。
在NTFS文件系统出现后，在Windows系统(2K/XP/Vista..)下的对象，包括文件系统，进程、命名管道、打印机、网络共享、或是注册表等等，都可以设置用户访问权限。
在Windows系统中，其是用一个安全描述符（Security Descriptors）的结构来保存其权限的设置信息，简称为SD，其在Windows SDK中的结构名是“SECURITY_DESCRIPTOR”，这是包括了安全设置信息的结构体，其结构体内容定义如下：
typedef struct _SECURITY_DESCRIPTOR {
UCHAR Revision;
UCHAR Sbz1;
SECURITY_DESCRIPTOR_CONTROL Control;
PSID Owner;
PSID Group;
PACL Sacl;
PACL Dacl;
} SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;
一个安全描述符包含以下安全信息：
两个安全标识符(Security identifiers)，简称为SID，分别是OwnerSid和GroupSid. 所谓SID就是每次当我们创建一个用户或一个组的时候，系统会分配给改用户或组一个唯一SID，当你重新安装系统后，也会得到一个唯一的SID。SID是唯一的，不随用户的删除而分配到另外的用户使用。
请记住，SID永远都是唯一的SIF是由计算机名、当前时间、当前用户态线程的CPU耗费时间的总和三个参数决定以保证它的唯一性。
例： S-1-5-21-1763234323-3212657521-1234321321-500
一个DACL（Discretionary Access Control List），其指出了允许和拒绝某用户或用户组的存取控制列表。 当一个进程需要访问安全对象，系统就会检查DACL来决定进程的访问权。如果一个对象没有DACL，那么就是说这个对象是任何人都可以拥有完全的访问权限。
一个SACL（System Access Control List），其指出了在该对象上的一组存取方式（如，读、写、运行等）的存取控制权限细节的列表。
还有其自身的一些控制位。SECURITY_DESCRIPTOR_CONTROL
DACL和SACL构成了整个存取控制列表Access Control List，简称ACL，ACL中的每一项，我们叫做ACE（Access Control Entry），ACL中的每一个ACE。
ACL结构体的内容如下：
typedef struct _ACL {
BYTE AclRevision;
BYTE Sbz1;
WORD AclSize;
WORD AceCount;
WORD Sbz2;
} ACL;
typedef ACL *PACL;
我们的程序不用直接维护SD这个结构，这个结构由系统维护。我们只用使用Windows 提供的相关的API函数来取得并设置SD中的信息就行了。不过这些API函数只有Windows NT/2K/XP才支持。
Windows提供了一系列的安全信息的存取，控制函数，如 GetNamedSecurityInfo, SetNamedSecurityInfo，GetSecurityInfo, SetSecurityInfo等。
下图说明了，安全对象和DACL以及访问者之间的联系（来源于MSDN）。注意，DACL表中的每个ACE的顺序是有意义的，如果 前面的Allow（或denied）ACE通过了，那么，系统就不会检查后面的ACE了。另外"拒绝"权限一般是优先于其他权限的。ACE在DACL中的 顺序非常重要。
系统会按照顺序依次检查所有的ACE规则，如下面的条件满足，则退出：
1、 如果一个Access-Denied的ACE明显地拒绝了请求者。
2、 如果某Access-Allowed的ACE明显地同意了请求者。
3、 全部的ACE都检查完了，但是没有一条ACE明显地允许或是拒绝请求者，那么系统将使用默认值，拒绝请求者的访问。
更多的理论和描述，请参看MSDN。
实例例程
主要实现2个功能，获取目录的安全设置和为目录增加一个安全设置项（该程序来源于MSDN，原作者 陈皓稍作修改，并加入了注解，我也稍作了点修改）
1、 对于文件、目录、命令管道，我们不一定要使用GetNamedSecurityInfo和SetNamedSecurityInfo函数，我们可以使用其专用函数GetFileSecurity和SetFileSecurity函数来取得或设置文件对象的SD，以设置其访问权限。需要使用这两个函数并不容易，正如前面我们所说的，我们还需要处理SD参数，要处理SD，就需要处理DACL和ACE，以及用户的相关SID，于是，一系统列的函数就被这两个函数带出来了。
2、 对于上一个例子中的使用硬编码指定SID的处理方法是。调用LookupAccountName函数时，先把SID，Domain名的参数传为空 NULL，于是LookupAccountName会返回用户的SID的长度和Domain名的长度，于是你可以根据这个长度分配内存，然后再次调用 LookupAccountName函数。于是就可以达到到态分配内存的效果。对于ACL也一样。
3、 对于给文件的ACL中增加一个ACE条目，一般的做法是先取出文件上的ACL，逐条取出ACE，和现需要增加的ACE比较，如果有冲突，则删除已有的 ACE，把新加的ACE添置到最后。这里的最后，应该是非继承而来的ACE的最后。关于ACL继承，NTFS中，你可以设置文件和目录是否继承于其父目录 的设置。在程序中同样可以设置。
还是请看例程，这个程序比较长，来源于MSDN，我做了一点点修改，并把自己的理解加在注释中，所以，请注意代码中的注释：
// SetSD.cpp : コンソール アプリケーションのエントリ ポイントを定義します。
//
#include <stdio.h>
#include <bitset>
#include <tchar.h>
#include <windows.h>
#include <string>
#include <iostream>
using std::bitset;
using std::string;
using std::cout;
using std::endl;
//使用Windows的HeapAlloc函数进行动态内存分配
#define myheapalloc(x) (HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, x))
#define myheapfree(x) (HeapFree(GetProcessHeap(), 0, x))
typedef BOOL (WINAPI *SetSecurityDescriptorControlFnPtr)(
IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
IN SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
IN SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet);
typedef BOOL (WINAPI *AddAccessAllowedAceExFnPtr)(
PACL pAcl,
DWORD dwAceRevision,
DWORD AceFlags,
DWORD AccessMask,
PSID pSid
);
//【接口】
// BOOL AddAccessRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, DWORD dwAccessMask)
//【机能概要】
// 为文件(目录)添加一个帐户（组）的权限
//【入力】
// TCHAR *lpszFileName 文件（目录）
// TCHAR *lpszAccountName 帐户（组）
// DWORD dwAccessMask 权限设置(如GENERIC_ALL，GENERIC_READ等)
//【输出】
// 无
//【输入输出】
// 无
//【返回值】
// BOOL
//【例外】
// 无
//---------------------------------------------------------------------------
BOOL AddAccessRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, DWORD dwAccessMask) {
// 声明SID变量
SID_NAME_USE snuType;
// 声明和LookupAccountName相关的变量（注意，全为0，要在程序中动态分配）
TCHAR * szDomain = NULL;
DWORD cbDomain = 0;
LPVOID pUserSID = NULL;
DWORD cbUserSID = 0;
// 和文件相关的安全描述符 SD 的变量
PSECURITY_DESCRIPTOR pFileSD = NULL; // 结构变量
DWORD cbFileSD = 0; // SD的size
// 一个新的SD的变量，用于构造新的ACL（把已有的ACL和需要新加的ACL整合起来）
SECURITY_DESCRIPTOR newSD;
// 和ACL 相关的变量
PACL pACL = NULL;
BOOL fDaclPresent;
BOOL fDaclDefaulted;
ACL_SIZE_INFORMATION AclInfo;
// 一个新的 ACL 变量
PACL pNewACL = NULL; //结构指针变量
DWORD cbNewACL = 0; //ACL的size
// 一个临时使用的 ACE 变量
LPVOID pTempAce = NULL;
UINT CurrentAceIndex = 0; //ACE在ACL中的位置
UINT newAceIndex = 0; //新添的ACE在ACL中的位置
//API函数的返回值，假设所有的函数都返回失败。
BOOL fResult = FALSE;
BOOL fAPISuccess = FALSE;
SECURITY_INFORMATION secInfo = DACL_SECURITY_INFORMATION;
// 下面的两个函数是新的API函数，仅在Windows 2000以上版本的操作系统支持。
// 在此将从Advapi32.dll文件中动态载入。如果你使用VC++ 6.0编译程序，而且你想
// 使用这两个函数的静态链接。则请为你的编译加上：/D_WIN32_WINNT=0x0500
// 的编译参数。并且确保你的SDK的头文件和lib文件是最新的。
SetSecurityDescriptorControlFnPtr _SetSecurityDescriptorControl = NULL;
AddAccessAllowedAceExFnPtr _AddAccessAllowedAceEx = NULL;
__try {
//
// STEP 1: 通过用户名取得SID
// 在这一步中LookupAccountName函数被调用了两次，第一次是取出所需要
// 的内存的大小，然后，进行内存分配。第二次调用才是取得了用户的帐户信息。
// LookupAccountName同样可以取得域用户或是用户组的信息。（请参看MSDN）
//
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
pUserSID = myheapalloc(cbUserSID);
if (!pUserSID) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
szDomain = (TCHAR *) myheapalloc(cbDomain * sizeof(TCHAR));
if (!szDomain) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
if (!fAPISuccess) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 2: 取得文件（目录）相关的安全描述符SD
// 使用GetFileSecurity函数取得一份文件SD的拷贝，同样，这个函数也
// 是被调用两次，第一次同样是取SD的内存长度。注意，SD有两种格式：自相关的
// （self-relative）和 完全的（absolute），GetFileSecurity只能取到“自
// 相关的”，而SetFileSecurity则需要完全的。这就是为什么需要一个新的SD，
// 而不是直接在GetFileSecurity返回的SD上进行修改。因为“自相关的”信息
// 是不完整的。
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, 0, &cbFileSD);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
pFileSD = myheapalloc(cbFileSD);
if (!pFileSD) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, cbFileSD, &cbFileSD);
if (!fAPISuccess) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 3: 初始化一个新的SD
//
if (!InitializeSecurityDescriptor(&newSD,
SECURITY_DESCRIPTOR_REVISION)) {
_tprintf(TEXT("InitializeSecurityDescriptor() failed.")
TEXT("Error %d\n"), GetLastError());
__leave;
}
//
// STEP 4: 从GetFileSecurity 返回的SD中取DACL
//
if (!GetSecurityDescriptorDacl(pFileSD, &fDaclPresent, &pACL,
&fDaclDefaulted)) {
_tprintf(TEXT("GetSecurityDescriptorDacl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 5: 取 DACL的内存size
// GetAclInformation可以提供DACL的内存大小。只传入一个类型为
// ACL_SIZE_INFORMATION的structure的参数，需DACL的信息，是为了
// 方便我们遍历其中的ACE。
AclInfo.AceCount = 0; // Assume NULL DACL.
AclInfo.AclBytesFree = 0;
AclInfo.AclBytesInUse = sizeof(ACL);
if (pACL == NULL)
fDaclPresent = FALSE;
// 如果DACL不为空，则取其信息。（大多数情况下“自关联”的DACL为空）
if (fDaclPresent) {
if (!GetAclInformation(pACL, &AclInfo,
sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
_tprintf(TEXT("GetAclInformation() failed. Error %d\n"),
GetLastError());
__leave;
}
}
//
// STEP 6: 计算新的ACL的size
// 计算的公式是：原有的DACL的size加上需要添加的一个ACE的size，以
// 及加上一个和ACE相关的SID的size，最后减去两个字节以获得精确的大小。
cbNewACL = AclInfo.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE)
+ GetLengthSid(pUserSID) - sizeof(DWORD);
//
// STEP 7: 为新的ACL分配内存
//
pNewACL = (PACL) myheapalloc(cbNewACL);
if (!pNewACL) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
//
// STEP 8: 初始化新的ACL结构
//
if (!InitializeAcl(pNewACL, cbNewACL, ACL_REVISION2)) {
_tprintf(TEXT("InitializeAcl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 9 如果文件（目录） DACL 有数据，拷贝其中的ACE到新的DACL中
//
// 下面的代码假设首先检查指定文件（目录）是否存在的DACL，如果有的话，
// 那么就拷贝所有的ACE到新的DACL结构中，我们可以看到其遍历的方法是采用
// ACL_SIZE_INFORMATION结构中的AceCount成员来完成的。在这个循环中，
// 会按照默认的ACE的顺序来进行拷贝（ACE在ACL中的顺序是很关键的），在拷
// 贝过程中，先拷贝非继承的ACE（我们知道ACE会从上层目录中继承下来）
//
newAceIndex = 0;
if (fDaclPresent && AclInfo.AceCount) {
for (CurrentAceIndex = 0;
CurrentAceIndex < AclInfo.AceCount;
CurrentAceIndex++) {
//
// STEP 10: 从DACL中取ACE
//
if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
_tprintf(TEXT("GetAce() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 11: 检查是否是非继承的ACE
// 如果当前的ACE是一个从父目录继承来的ACE，那么就退出循环。
// 因为，继承的ACE总是在非继承的ACE之后，而我们所要添加的ACE
// 应该在已有的非继承的ACE之后，所有的继承的ACE之前。退出循环
// 正是为了要添加一个新的ACE到新的DACL中，这后，我们再把继承的
// ACE拷贝到新的DACL中。
//
if (((ACCESS_ALLOWED_ACE *)pTempAce)->Header.AceFlags
& INHERITED_ACE)
break;
//
// STEP 12: 检查要拷贝的ACE的SID是否和需要加入的ACE的SID一样，
// 如果一样，那么就应该废掉已存在的ACE，也就是说，同一个用户的存取
// 权限的设置的ACE，在DACL中应该唯一。这在里，跳过对同一用户已设置
// 了的ACE，仅是拷贝其它用户的ACE。
//
if (EqualSid(pUserSID,
&(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
{
ACCESS_ALLOWED_ACE pTempAce2 = *(ACCESS_ALLOWED_ACE *)pTempAce;
ACCESS_DENIED_ACE pTempAce4 = *(ACCESS_DENIED_ACE *)pTempAce;
int a = -1;
if (pTempAce2.Header.AceType == ACCESS_ALLOWED_ACE_TYPE)
{
a = 0;
}
else if (pTempAce2.Header.AceType == ACCESS_DENIED_ACE_TYPE)
{
a = 1;
}
else
a = 2;
continue;
}
//
// STEP 13: 把ACE加入到新的DACL中
// 下面的代码中，注意 AddAce 函数的第三个参数，这个参数的意思是
// ACL中的索引值，意为要把ACE加到某索引位置之后，参数MAXDWORD的
// 意思是确保当前的ACE是被加入到最后的位置。
//
if (!AddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
((PACE_HEADER) pTempAce)->AceSize)) {
_tprintf(TEXT("AddAce() failed. Error %d\n"),
GetLastError());
__leave;
}
newAceIndex++;
}
}
//
// STEP 14: 把一个 access-allowed 的ACE 加入到新的DACL中
// 前面的循环拷贝了所有的非继承且SID为其它用户的ACE，退出循环的第一件事
// 就是加入我们指定的ACE。请注意首先先动态装载了一个AddAccessAllowedAceEx
// 的API函数，如果装载不成功，就调用AddAccessAllowedAce函数。前一个函数仅
// 在Windows 2000以后的版本支持，NT则没有，我们为了使用新版本的函数，我们首
// 先先检查一下当前系统中可不可以装载这个函数，如果可以则就使用。使用动态链接
// 比使用静态链接的好处是，程序运行时不会因为没有这个API函数而报错。
//
// Ex版的函数多出了一个参数AceFlag（第三人参数），用这个参数我们可以来设置一
// 个叫ACE_HEADER的结构，以便让我们所设置的ACE可以被其子目录所继承下去，而
// AddAccessAllowedAce函数不能定制这个参数，在AddAccessAllowedAce函数
// 中，其会把ACE_HEADER这个结构设置成非继承的。
//
_AddAccessAllowedAceEx = (AddAccessAllowedAceExFnPtr)
GetProcAddress(GetModuleHandle(TEXT("advapi32.dll")),
"AddAccessAllowedAceEx");
if (_AddAccessAllowedAceEx) {
if (!_AddAccessAllowedAceEx(pNewACL, ACL_REVISION2,
CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE ,
dwAccessMask, pUserSID)) {
_tprintf(TEXT("AddAccessAllowedAceEx() failed. Error %d\n"),
GetLastError());
__leave;
}
}else{
if (!AddAccessAllowedAce(pNewACL, ACL_REVISION2,
dwAccessMask, pUserSID)) {
_tprintf(TEXT("AddAccessAllowedAce() failed. Error %d\n"),
GetLastError());
__leave;
}
}
//
// STEP 15: 按照已存在的ACE的顺序拷贝从父目录继承而来的ACE
//
bitset<32> bit(dwAccessMask);
if (fDaclPresent && AclInfo.AceCount) {
for (;
CurrentAceIndex < AclInfo.AceCount;
CurrentAceIndex++) {
//
// STEP 16: 从文件（目录）的DACL中继续取ACE
//
if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
_tprintf(TEXT("GetAce() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 17: 把ACE加入到新的DACL中
//
if (!AddAce(pNewACL, ACL_REVISION, MAXDWORD, pTempAce,
((PACE_HEADER) pTempAce)->AceSize)) {
_tprintf(TEXT("AddAce() failed. Error %d\n"),
GetLastError());
__leave;
}
}
}
//
// STEP 18: 把新的ACL设置到新的SD中
//
if (!SetSecurityDescriptorDacl(&newSD, TRUE, pNewACL,
FALSE)) {
_tprintf(TEXT("SetSecurityDescriptorDacl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 19: 把老的SD中的控制标记再拷贝到新的SD中，我们使用的是一个叫
// SetSecurityDescriptorControl() 的API函数，这个函数同样只存在于
// Windows 2000以后的版本中，所以我们还是要动态地把其从advapi32.dll
// 中载入，如果系统不支持这个函数，那就不拷贝老的SD的控制标记了。
//
_SetSecurityDescriptorControl =(SetSecurityDescriptorControlFnPtr)
GetProcAddress(GetModuleHandle(TEXT("advapi32.dll")),
"SetSecurityDescriptorControl");
if (_SetSecurityDescriptorControl) {
SECURITY_DESCRIPTOR_CONTROL controlBitsOfInterest = 0;
SECURITY_DESCRIPTOR_CONTROL controlBitsToSet = 0;
SECURITY_DESCRIPTOR_CONTROL oldControlBits = 0;
DWORD dwRevision = 0;
if (!GetSecurityDescriptorControl(pFileSD, &oldControlBits,
&dwRevision)) {
_tprintf(TEXT("GetSecurityDescriptorControl() failed.")
TEXT("Error %d\n"), GetLastError());
__leave;
}
if (oldControlBits & SE_DACL_AUTO_INHERITED) {
controlBitsOfInterest =
SE_DACL_AUTO_INHERIT_REQ |
SE_DACL_AUTO_INHERITED ;
controlBitsToSet = controlBitsOfInterest;
}
else if (oldControlBits & SE_DACL_PROTECTED) {
controlBitsOfInterest = SE_DACL_PROTECTED;
controlBitsToSet = controlBitsOfInterest;
}
if (controlBitsOfInterest) {
if (!_SetSecurityDescriptorControl(&newSD,
controlBitsOfInterest,
controlBitsToSet)) {
_tprintf(TEXT("SetSecurityDescriptorControl() failed.")
TEXT("Error %d\n"), GetLastError());
__leave;
}
}
}
//
// STEP 20: 把新的SD设置设置到文件的安全属性中（千山万水啊，终于到了）
//
if (!SetFileSecurity(lpszFileName, secInfo,
&newSD)) {
_tprintf(TEXT("SetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
fResult = TRUE;
} __finally {
//
// STEP 21: 释放已分配的内存，以免Memory Leak
//
if (pUserSID) myheapfree(pUserSID);
if (szDomain) myheapfree(szDomain);
if (pFileSD) myheapfree(pFileSD);
if (pNewACL) myheapfree(pNewACL);
}
return fResult;
}
//【接口】
// BOOL GetAccountRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, int (&arrRights)[32])
//【机能概要】
// 获取该文件(目录)指定帐户（组）的权限
//【入力】
// TCHAR *lpszFileName 文件（目录）
// TCHAR *lpszAccountName 帐户（组）
// int (&arrRights)[32] 数组引用，要求传入参数必须是32个int数组
//【输出】
// 无
//【输入输出】
// 无
//【返回值】
// BOOL
//【例外】
// 无
//---------------------------------------------------------------------------
BOOL GetAccountRights(TCHAR *lpszFileName, TCHAR *lpszAccountName, int (&arrRights)[32]) {
//将参数arrRights初始化为0
for (int i = 0; i < 32; i++)
{
arrRights[i] = 0;
}
// 声明SID变量
SID_NAME_USE snuType;
// 声明和LookupAccountName相关的变量（注意，全为0，要在程序中动态分配）
TCHAR * szDomain = NULL;
DWORD cbDomain = 0;
LPVOID pUserSID = NULL;
DWORD cbUserSID = 0;
// 和文件相关的安全描述符 SD 的变量
PSECURITY_DESCRIPTOR pFileSD = NULL; // 结构变量
DWORD cbFileSD = 0; // SD的size
// 和ACL 相关的变量
PACL pACL = NULL;
BOOL fDaclPresent;
BOOL fDaclDefaulted;
ACL_SIZE_INFORMATION AclInfo;
// 一个临时使用的 ACE 变量
LPVOID pTempAce = NULL;
UINT CurrentAceIndex = 0; //ACE在ACL中的位置
//API函数的返回值，假设所有的函数都返回失败。
BOOL fResult = FALSE;
BOOL fAPISuccess = FALSE;
SECURITY_INFORMATION secInfo = DACL_SECURITY_INFORMATION;
__try {
//
// STEP 1: 通过用户名取得SID
// 在这一步中LookupAccountName函数被调用了两次，第一次是取出所需要
// 的内存的大小，然后，进行内存分配。第二次调用才是取得了用户的帐户信息。
// LookupAccountName同样可以取得域用户或是用户组的信息。（请参看MSDN）
//
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
pUserSID = myheapalloc(cbUserSID);
if (!pUserSID) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
szDomain = (TCHAR *) myheapalloc(cbDomain * sizeof(TCHAR));
if (!szDomain) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = LookupAccountName(NULL, lpszAccountName,
pUserSID, &cbUserSID, szDomain, &cbDomain, &snuType);
if (!fAPISuccess) {
_tprintf(TEXT("LookupAccountName() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 2: 取得文件（目录）相关的安全描述符SD
// 使用GetFileSecurity函数取得一份文件SD的拷贝，同样，这个函数也
// 是被调用两次，第一次同样是取SD的内存长度。注意，SD有两种格式：自相关的
// （self-relative）和 完全的（absolute），GetFileSecurity只能取到“自
// 相关的”，而SetFileSecurity则需要完全的。这就是为什么需要一个新的SD，
// 而不是直接在GetFileSecurity返回的SD上进行修改。因为“自相关的”信息
// 是不完整的。
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, 0, &cbFileSD);
// 以上调用API会失败，失败原因是内存不足。并把所需要的内存大小传出。
// 下面是处理非内存不足的错误。
if (fAPISuccess)
__leave;
else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
pFileSD = myheapalloc(cbFileSD);
if (!pFileSD) {
_tprintf(TEXT("HeapAlloc() failed. Error %d\n"), GetLastError());
__leave;
}
fAPISuccess = GetFileSecurity(lpszFileName,
secInfo, pFileSD, cbFileSD, &cbFileSD);
if (!fAPISuccess) {
_tprintf(TEXT("GetFileSecurity() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 3: 从GetFileSecurity 返回的SD中取DACL
//
if (!GetSecurityDescriptorDacl(pFileSD, &fDaclPresent, &pACL,
&fDaclDefaulted)) {
_tprintf(TEXT("GetSecurityDescriptorDacl() failed. Error %d\n"),
GetLastError());
__leave;
}
//
// STEP 4: 取 DACL的内存size
// GetAclInformation可以提供DACL的内存大小。只传入一个类型为
// ACL_SIZE_INFORMATION的structure的参数，需DACL的信息，是为了
// 方便我们遍历其中的ACE。
AclInfo.AceCount = 0; // Assume NULL DACL.
AclInfo.AclBytesFree = 0;
AclInfo.AclBytesInUse = sizeof(ACL);
if (pACL == NULL)
fDaclPresent = FALSE;
// 如果DACL不为空，则取其信息。（大多数情况下“自关联”的DACL为空）
if (fDaclPresent) {
if (!GetAclInformation(pACL, &AclInfo,
sizeof(ACL_SIZE_INFORMATION), AclSizeInformation)) {
_tprintf(TEXT("GetAclInformation() failed. Error %d\n"),
GetLastError());
__leave;
}
}
//
// STEP 5 如果文件（目录） DACL 有数据，将指定帐户的ACE的访问权限转换到整型数组
//
// 下面的代码假设首先检查指定文件（目录）是否存在的DACL，如果有的话，
// 那么就将指定帐户的ACE的访问权限转换到整型数组，我们可以看到其遍历的方法
// 是采用ACL_SIZE_INFORMATION结构中的AceCount成员来完成的。在这个循环中，
// 查找和指定账户相关的ACE
//
if (fDaclPresent && AclInfo.AceCount) {
for (CurrentAceIndex = 0;
CurrentAceIndex < AclInfo.AceCount;
CurrentAceIndex++) {
//
// STEP 10: 从DACL中取ACE
//
if (!GetAce(pACL, CurrentAceIndex, &pTempAce)) {
_tprintf(TEXT("GetAce() failed. Error %d\n"),
GetLastError());
__leave;
}
//
//
// STEP 6: 检查要拷贝的ACE的SID是否和需要加入的ACE的SID一样，
// 如果一样，那么就将该ACE的访问权限转换到整型数组，
// 否则跳过，进行下一个循环
//
int nAceType = 1;
if (EqualSid(pUserSID,
&(((ACCESS_ALLOWED_ACE *)pTempAce)->SidStart)))
{
if(((PACE_HEADER)pTempAce)->AceType == ACCESS_DENIED_ACE_TYPE)
{
nAceType = 2;
}
else
{
nAceType = 1;
}
//bitset类代表的整型数值的顺序是从0到N-1
bitset<32> bitAccessMask(((ACCESS_ALLOWED_ACE*)pTempAce)->Mask);
for (int i = 0; i < 32; i++)
{
if (bitAccessMask[i] != 0 && arrRights[i] != 2)
{
arrRights[i] = nAceType;
}
}
}
else
{
continue;
}
}
}
fResult = TRUE;
} __finally {
//
// STEP 7: 释放已分配的内存，以免Memory Leak
//
if (pUserSID) myheapfree(pUserSID);
if (szDomain) myheapfree(szDomain);
if (pFileSD) myheapfree(pFileSD);
}
return fResult;
}
int _tmain(int argc, TCHAR *argv[])
{
if (argc < 3) {
_tprintf(TEXT("usage: \"%s\" <FileName> <AccountName>\n"), argv[0]);
return 1;
}
//关于ACCESS_MASK中各个位代表的含义请参考MSDN
string filedesc[] = {"FILE_READ_DATA", "FILE_WRITE_DATA", "FILE_APPEND_DATA", "FILE_READ_EA",
"FILE_WRITE_EA", "FILE_EXECUTE", "FILE_DELETE_CHILD", "FILE_READ_ATTRIBUTES",
"FILE_WRITE_ATTRIBUTES", " ", " ", " ",
" ", " ", " ", " ",
"DELETE ", "READ_CONTROL", "WRITE_DAC", "WRITE_OWNER",
"SYNCHRONIZE ", " ", " "," ",
"ACCESS_SYSTEM_SECURITY", "MAXIMUM_ALLOWED", " "," ",
"GENERIC_ALL", "GENERIC_EXECUTE", "GENERIC_WRITE","GENERIC_READ"};
string rights[] = {"Allow", "Deny"};
//获取ACE中的访问权限
//ACE中的访问权限是通过DWORD类型的ACCESS_MASK记录的
//GetAccountRights函数将ACCESS_MASK转为了一个32个元素的整型数组，并传出
int arrRights[32] = {0};
if (!GetAccountRights(argv[1], argv[2], arrRights))
{
_tprintf(TEXT("GetAccountRights() failed.\n"));
}
else
{
_tprintf(TEXT("The access rights of the file is..\n"));
for (int i = 0; i < 32; i++)
{
int nTmpRight = arrRights[i];
if (nTmpRight != 0)
{
cout<<filedesc[i]<<": "<<rights[nTmpRight-1]<<endl;
}
}
}
// argv[1] – 文件（目录）名
// argv[2] – 用户（组）名
// GENERIC_ALL表示所有的权限，其是一系列的NTFS权限的或
// NTFS的文件权限很细，还请参看MSDN。
if (!AddAccessRights(argv[1], argv[2], GENERIC_ALL)) {
_tprintf(TEXT("AddAccessRights() failed.\n"));
return 1;
}
else {
_tprintf(TEXT("AddAccessRights() succeeded.\n"));
return 0;
}
}
函数AddAccessRights实现为文件(目录)添加一个帐户（组）的权限
函数GetAccountRights实现获取该文件(目录)指定帐户（组）的权限
三、 一些相关的API函数
通过以上的示例，相信你已知道如何操作NTFS文件安全属性了，还有一些API函数需要介绍一下。
1、 如果你要加入一个Access-Denied 的ACE，你可以使用AddAccessDeniedAce函数
2、 如果你要删除一个ACE，你可以使用DeleteAce函数
3、 如果你要检查你所设置的ACL是否合法，你可以使用IsValidAcl函数，同样，对于SD的合法也有一个叫IsValidSecurityDescriptor的函数
4、 MakeAbsoluteSD和MakeSelfRelativeSD两个函数可以在两种SD的格式中进行转换。
5、 使用SetSecurityDescriptorDacl 和 SetSecurityDescriptorSacl可以方便地把ACL设置到SD中。
6、 使用GetSecurityDescriptorDacl or GetSecurityDescriptorSacl可以方便地取得SD中的ACL结构。
我们把一干和SD/ACL/ACE相关的API函数叫作Low-Level Security Descriptor Functions，其详细信息还请参看MSDN。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 以程序的方式操纵NTFS的文件权限（一）
- 以程序的方式操纵NTFS的文件权限（中）
- 以程序的方式操纵NTFS的文件权限（下）
- 以程序的方式操纵NTFS的文件权限（中）
- 以程序的方式操纵NTFS的文件权限（下）
- 以程序的方式操纵NTFS的文件权限（上）
- 以程序的方式操纵NTFS的文件权限（下）
- 以程序的方式操纵NTFS的文件权限
- 以程序的方式操纵NTFS的文件权限（中）
- 以程序的方式操纵NTFS的文件权限（上）
- 以程序的方式操纵NTFS的文件权限（下）
- 以程序的方式操纵NTFS的文件权限（上）
- 以程序的方式操纵NTFS的文件权限（三）
- 以程序的方式操纵NTFS的文件权限
- 以程序的方式操纵NTFS的文件权限
- 以程序的方式操纵NTFS的文件权限（下）
- 以程序的方式操纵NTFS的文件权限（中）
- 以程序的方式操纵NTFS的文件权限（上）
- 以程序的方式操纵NTFS的文件权限（下）
- 以程序的方式操纵NTFS的文件权限（上） 推荐