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

最新推荐文章于 2024-09-17 20:00:16 发布

luckylion

最新推荐文章于 2024-09-17 20:00:16 发布

阅读量508

点赞数

文章标签： descriptor security windows api null access

Windows NT/2K/XP版本的操作系统都支持NTFS格式的文件系统，这是一个有安全性质的文件系统，你可以通过Windows的资源管理器来设置对每个目录和文件的用户访问权限。这里我就不对NTFS的安全性进行讲述了，我默认你对NTFS的文件目录的安全设置有了一定的了解。在这里，我将向你介绍使用 Windows的API函数来操纵NTFS的文件权限。

一、理论和术语

在Windows NT/2K?XP下的对象，不一定是文件系统，还有其它的一些对象，如：进程、命名管道、打印机、网络共享、或是注册表等等，都可以设置用户访问权限。在 Windows系统中，其是用一个安全描述符（Security Descriptors）的结构来保存其权限的设置信息，简称为SD，其在Windows SDK中的结构名是“SECURITY_DESCRIPTOR”，这是包括了安全设置信息的结构体。一个安全描述符包含以下信息：

一个安全标识符(Security identifiers)，其标识了该信息是哪个对象的，也就是用于记录安全对象的ID。简称为：SID。
一个DACL（Discretionary Access Control List），其指出了允许和拒绝某用户或用户组的存取控制列表。当一个进程需要访问安全对象，系统就会检查DACL来决定进程的访问权。如果一个对象没有DACL，那么就是说这个对象是任何人都可以拥有完全的访问权限。
一个SACL（System Access Control List），其指出了在该对象上的一组存取方式（如，读、写、运行等）的存取控制权限细节的列表。
还有其自身的一些控制位。
DACL和SACL构成了整个存取控制列表Access Control List，简称ACL，ACL中的每一项，我们叫做ACE（Access Control Entry），ACL中的每一个ACE。

我们的程序不用直接维护SD这个结构，这个结构由系统维护。我们只用使用Windows 提供的相关的API函数来取得并设置SD中的信息就行了。不过这些API函数只有Windows NT/2K/XP才支持。

安全对象Securable Object是拥有SD的Windows的对象。所有的被命名的Windows的对象都是安全对象。一些没有命名的对象是安全对象，如：进程和线程，也有安全描述符SD。在对大多数的创建安全对象的操作中都需要你传递一个SD的参数，如：CreateFile和CreateProcess函数。另外，Windows还提供了一系列有关安全对象的安全信息的存取函数，以供你取得对象上的安全设置，或修改对象上的安全设置。如：GetNamedSecurityInfo, SetNamedSecurityInfo，GetSecurityInfo, SetSecurityInfo。

下图说明了，安全对象和DACL以及访问者之间的联系（来源于MSDN）。注意，DACL表中的每个ACE的顺序是有意义的，如果前面的Allow（或denied）ACE通过了，那么，系统就不会检查后面的ACE了。
系统会按照顺序依次检查所有的ACE规则，如下面的条件满足，则退出：

1、如果一个Access-Denied的ACE明显地拒绝了请求者。

2、如果某Access-Allowed的ACE明显地同意了请求者。

3、全部的ACE都检查完了，但是没有一条ACE明显地允许或是拒绝请求者，那么系统将使用默认值，拒绝请求者的访问。

更多的理论和描述，请参看MSDN。

二、实践与例程

1、例程一：创建一个有权限设置的目录

#include <windows.h>

void main(void)

{

   SECURITY_ATTRIBUTES sa;   //和文件有关的安全结构

   SECURITY_DESCRIPTOR sd;   //声明一个SD

   BYTE aclBuffer[1024];

   PACL pacl=(PACL)&aclBuffer; //声明一个ACL，长度是1024

   BYTE sidBuffer[100];

   PSID psid=(PSID) &sidBuffer;   //声明一个SID，长度是100

   DWORD sidBufferSize = 100;

   char domainBuffer[80];

   DWORD domainBufferSize = 80;

   SID_NAME_USE snu;

   HANDLE file;

   //初始化一个SD

   InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
   //初始化一个ACL

   InitializeAcl(pacl, 1024, ACL_REVISION);
   //查找一个用户hchen，并取该用户的SID

   LookupAccountName(0, "hchen", psid,

           &sidBufferSize, domainBuffer,

           &domainBufferSize, &snu);
   //设置该用户的Access-Allowed的ACE，其权限为“所有权限”

   AddAccessAllowedAce(pacl, ACL_REVISION, GENERIC_ALL, psid);

   //把ACL设置到SD中

   SetSecurityDescriptorDacl(&sd, TRUE, pacl, FALSE);


   //把SD放到文件安全结构SA中

   sa.nLength = sizeof(SECURITY_ATTRIBUTES);

   sa.bInheritHandle = FALSE;

   sa.lpSecurityDescriptor = &sd;


   //创建文件

   file = CreateFile("c:/testfile",

       0, 0, &sa, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);

   CloseHandle(file);
}

这个例子我是从网上找来的，改了改。其中使用到的关键的API函数，我都把其加粗了。从程序中我们可以看到，我们先初始化了一个SD和一个ACL，然后调用LookupAccountName取得用户的SID，然后通过这个SID，对ACL中加入一个有允许访问权限的ACE，然后再把整个ACL设置到SD 中。最后，组织文件安全描述的SA结构，并调用CreateFile创建文件。如果你的操作系统是NTFS，那么，你可以看到你创建出来的文件的安全属性的样子：
这个程序旨在说明如何生成一个新的SD和ACL的用法，其有四个地方的不足和不清：

1、对于ACL和SID的声明采用了硬编码的方式指定其长度。

2、对于API函数，没有出错处理。

3、没有说明如何修改已有文件或目录的安全设置。

4、没有说明安全设置的继承性。

对于这些我将在下个例程中讲述。

2、例程二、为目录增加一个安全设置项

在我把这个例程序例出来以前，请允许我多说一下。

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，我做了一点点修改，并把自己的理解加在注释中，所以，请注意代码中的注释：

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

//使用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) {

  // 声明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;
  BOOL           fAPISuccess;

  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)))
              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
     //
     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;
}

--------------------------------------------------------------------------------

int _tmain(int argc, TCHAR *argv[]) {

  if (argc < 3) {
     _tprintf(TEXT("usage: /"%s/" <FileName> <AccountName>/n"), argv[0]);
     return 1;
  }

  // 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;
  }
}

三、一些相关的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。