以程序的方式操纵NTFS的文件权限

本篇文章内容主要参考了 陈皓 《以程序的方式操纵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。