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

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的函数

摘自:http://www.lihuasoft.net/article/show.php?id=755

http://www.cnblogs.com/lzjsky/archive/2010/11/24/1886696.html

时间: 06-26

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

《连载 | 物联网框架ServerSuperIO教程》- 10持续传输大块数据流的两种方式(如:文件)

1.C#跨平台物联网通讯框架ServerSuperIO(SSIO)介绍 <连载 | 物联网框架ServerSuperIO教程>1.4种通讯模式机制. <连载 | 物联网框架ServerSuperIO教程>2.服务实例的配置参数说明 <连载 | 物联网框架ServerSuperIO教程>- 3.设备驱动介绍 <连载 | 物联网框架ServerSuperIO教程>-4.如开发一套设备驱动,同时支持串口和网络通讯. <连载 | 物联网框架ServerSupe

Linux用户态程序计时方式详解

前言 良好的计时器可帮助程序开发人员确定程序的性能瓶颈,或对不同算法进行性能比较.但要精确测量程序的运行时间并不容易,因为进程切换.中断.共享的多用户.网络流量.高速缓存访问及转移预测等因素都会对程序计时产生影响. 本文将不考虑这些影响因素(相关资料可参考<深入理解计算机系统>一书),而仅仅关注Linux系统中用户态程序执行时间的计算方式.除本文所述计时方式外,还可借助外部工具统计耗时,如<Linux调试分析诊断利器——strace>一文中介绍的strace. 本文示例代码的运行环

JDBC-ODBC桥连接方式操纵SQL数据库

/**  * 功能:演示使用JDBC-ODBC桥连接方式操纵SQL数据库  * 作者:徐守威  * 操作步骤:  * 1.配置数据源  * 2.在程序中连接数据源  * 3.操作数据  */ package com.jasxu; //引入sql包 import java.sql.*; public class T1 { /**   * @param args   */  public static void main(String[] args) {   // TODO Auto-generat

《连载 | 物联网框架ServerSuperIO教程》- 10.持续传输大块数据流的两种方式(如:文件)

感谢唯笑志在分享 原博主原地址:http://www.cnblogs.com/lsjwq/ 目       录 10.持续传输大块数据流的两种方式(如:文件)... 2 10.1        概述... 2 10.2        大块数据流的两种传输方式... 2 10.2.1       协议数据包的方式... 2 10.2.2       请求长度.确认的方式... 3 10.3        实现持续传输大块数据... 4 10.3.1       设计请求发送数据协议... 4 10

开发Web应用程序的方式

开发应用程序的方式包括:文件系统.HTTP和FTP. 一.文件系统: 该方式是默认的.其可以把网站创建到当前物理文件系统上任何可以访问的地方,它可以是本机或网络上的机器.当选择文件系统时,VS将使用内置的Web服务器,而不是使用IIS运行Web应用程序,也不为Web应用程序创建持久的虚拟目录,IIS不再是该过程的一部分.实际上,甚至不需要在开发机器上安装IIS.当然,IIS对于部署服务器来说是必需的. 使用文件系统作为项目存储位置的缺点是,通过该方式创建的Web页面不能在浏览器中运行,而只能通过

黑马程序员——JAVA学习笔记十一(文件操作File)

为了很方便的代表文件的概念,以及存储一些对于文件的基本操作,在java.io包中设计了一个专门的类——File类. 在File类中包含了大部分和文件操作的功能方法,该类的对象可以代表一个具体的文件或文件夹,所以以前曾有人建议将该类的类名修改成FilePath,因为该类也可以代表一个文件夹,更准确的说是可以代表一个文件路径. 1.创建文件 1)boolean java.io.File.createNewFile() throws IOException用来创建文件,如果文件存在,创建失败,返回fa

JAVA之IO技术-将java程序的异常信息保存在文件中

package ioTest.io2; import java.io.FileNotFoundException; import java.io.PrintStream; import java.util.Properties; /* * 将应用程序的异常信息输出到指定的log文件中 */ public class ExceptionToFile { public static void main(String[] args) throws FileNotFoundException { int

spring 以Ant Build方式运行build.xml文件,报warning: &#39;includeantruntime&#39; was not set, defaulting to build.sysclasspath=last; set to false for repeatable builds 的解决办法

Buildfile: F:\experience\spring_pdf\sourcecode\example1\build.xml compile: [javac] F:\experience\spring_pdf\sourcecode\example1\build.xml:25: warning: 'includeantruntime' was not set, defaulting to build.sysclasspath=last; set to false for repeatable

【黑马程序员】————#include 和 多文件团队开发

一.      #include 1.      预处理指令 2.      #include的作用 纯粹是文件拷贝 3.      #include <stdio.h> stdio.h中有什么?链接的时候做了什么事情 <>和””的区别: 自定义的文件用"",系统自带的文件用<> 4.      #include的路径问题 默认是同路径. 二.      .h文件和.c文件的分工 1.单文件的坏处 1>一个文件的内容太多,不利于阅读.调试 2&