DWORD
SetNamedValueSD (
HKEY RootKey,
LPTSTR KeyName,
LPTSTR ValueName,
SECURITY_DESCRIPTOR *SD
)
{
DWORD returnValue;
DWORD disposition;
HKEY registryKey;
//
// Create new key or open existing key
//
returnValue = RegCreateKeyEx (RootKey, KeyName, 0, TEXT(""), 0, KEY_ALL_ACCESS, NULL, ®istryKey, &disposition);
if (returnValue != ERROR_SUCCESS)
return returnValue;
//
// Write the security descriptor
//
returnValue = RegSetValueEx (registryKey, ValueName, 0, REG_BINARY, (LPBYTE) SD, GetSecurityDescriptorLength (SD));
if (returnValue != ERROR_SUCCESS)
return returnValue;
RegCloseKey (registryKey);
return ERROR_SUCCESS;
}
static NTSTATUS SetSecurity(FSP_FILE_SYSTEM *FileSystem,
FSP_FSCTL_TRANSACT_REQ *Request,
PVOID FileNode0,
SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor)
{
MEMFS_FILE_NODE *FileNode = (MEMFS_FILE_NODE *)FileNode0;
PSECURITY_DESCRIPTOR NewSecurityDescriptor, FileSecurity;
SIZE_T FileSecuritySize;
NTSTATUS Result;
Result = FspSetSecurityDescriptor(FileSystem, Request, FileNode->FileSecurity,
&NewSecurityDescriptor);
if (!NT_SUCCESS(Result))
return Result;
FileSecuritySize = GetSecurityDescriptorLength(NewSecurityDescriptor);
FileSecurity = (PSECURITY_DESCRIPTOR)malloc(FileSecuritySize);
if (0 == FileSecurity)
{
FspDeleteSecurityDescriptor(NewSecurityDescriptor, (NTSTATUS (*)())FspSetSecurityDescriptor);
return STATUS_INSUFFICIENT_RESOURCES;
}
memcpy(FileSecurity, NewSecurityDescriptor, FileSecuritySize);
FspDeleteSecurityDescriptor(NewSecurityDescriptor, (NTSTATUS (*)())FspSetSecurityDescriptor);
free(FileNode->FileSecurity);
FileNode->FileSecuritySize = FileSecuritySize;
FileNode->FileSecurity = FileSecurity;
return STATUS_SUCCESS;
}
void DumpSD(PSECURITY_DESCRIPTOR pSD)
{
DWORD dwSize = GetSecurityDescriptorLength(pSD);
printf("\nSecurity Descriptor is of size %d", dwSize);
BOOL DaclPresent, DaclDefaulted;
PACL pDacl;
if(GetSecurityDescriptorDacl(pSD, &DaclPresent,
&pDacl, &DaclDefaulted) && DaclPresent)
{
// Dump the aces
ACL_SIZE_INFORMATION inf;
DWORD dwNumAces;
if(GetAclInformation(
pDacl,
&inf,
sizeof(ACL_SIZE_INFORMATION),
AclSizeInformation
))
{
dwNumAces = inf.AceCount;
printf("\nThe DACL has %d ACEs", dwNumAces);
for(DWORD dwCnt = 0; dwCnt < dwNumAces; dwCnt++)
{
ACCESS_ALLOWED_ACE * pAce;
if(GetAce(pDacl, dwCnt, (LPVOID *)&pAce))
DumpAce(pAce);
}
}
}
}
STDMETHODIMP
CObjSecurity::GetSecurity(SECURITY_INFORMATION si,
PSECURITY_DESCRIPTOR *ppSD,
BOOL fDefault)
{
DWORD dwLength = 0;
DWORD dwErr = 0;
*ppSD = NULL;
if (fDefault)
return E_NOTIMPL;
#ifdef _DEBUG
TCHAR szDbgInfo[128];
wsprintf(szDbgInfo, _T("CObjSecurity::GetSecurity(0x%08X,%i)\n"), si, fDefault);
OutputDebugString(szDbgInfo);
#endif
if (mpsz_KeyForInherit)
{
dwErr = GetNamedSecurityInfo(mpsz_KeyForInherit, SE_REGISTRY_KEY,
si, NULL, NULL, NULL, NULL, ppSD);
}
else
{
// Просто отдадим копию
dwLength = GetSecurityDescriptorLength(m_pOrigSD);
if (dwLength)
{
*ppSD = (PSECURITY_DESCRIPTOR)LocalAlloc(LPTR, dwLength);
if (*ppSD)
memmove(*ppSD, m_pOrigSD, dwLength);
}
}
////
//// Assume that required privileges have already been enabled
////
//GetPrivateObjectSecurity(*m_ppSD, si, NULL, 0, &dwLength);
//if (dwLength)
//{
// *ppSD = (PSECURITY_DESCRIPTOR)LocalAlloc(LPTR, dwLength);
// if (*ppSD &&
// !GetPrivateObjectSecurity(*m_ppSD, si, *ppSD, dwLength, &dwLength))
// {
// dwErr = GetLastError();
// LocalFree(*ppSD);
// *ppSD = NULL;
// }
//}
//else
// dwErr = GetLastError();
return HRESULT_FROM_WIN32(dwErr);
}
/*---------------------------------------------------------------------------*\
* NAME: SetNamedValueSD
* --------------------------------------------------------------------------*
* DESCRIPTION: Copies the supplied security descriptor to the registry.
\*---------------------------------------------------------------------------*/
DWORD SetNamedValueSD (
HKEY hkeyRoot,
LPTSTR tszKeyName,
LPTSTR tszValueName,
SECURITY_DESCRIPTOR *pSecurityDesc
)
{
DWORD dwReturnValue = ERROR_SUCCESS;
DWORD dwDisposition = 0;
HKEY hkeyReg = NULL;
// Create new key or open existing key
dwReturnValue = RegCreateKeyEx (hkeyRoot, tszKeyName, 0, _T(""), 0, KEY_ALL_ACCESS, NULL, &hkeyReg, &dwDisposition);
if (dwReturnValue != ERROR_SUCCESS)
{
goto CLEANUP;
}
// Write the security descriptor
dwReturnValue = RegSetValueEx (hkeyReg, tszValueName, 0, REG_BINARY, (LPBYTE) pSecurityDesc, GetSecurityDescriptorLength (pSecurityDesc));
if (dwReturnValue != ERROR_SUCCESS)
{
goto CLEANUP;
}
CLEANUP:
if(hkeyReg) RegCloseKey (hkeyReg);
return dwReturnValue;
}
static NTSTATUS Create(FSP_FILE_SYSTEM *FileSystem,
FSP_FSCTL_TRANSACT_REQ *Request,
PWSTR FileName, BOOLEAN CaseSensitive, UINT32 CreateOptions,
UINT32 FileAttributes, PSECURITY_DESCRIPTOR SecurityDescriptor, UINT64 AllocationSize,
PVOID *PFileNode, FSP_FSCTL_FILE_INFO *FileInfo)
{
MEMFS *Memfs = (MEMFS *)FileSystem->UserContext;
MEMFS_FILE_NODE *FileNode;
NTSTATUS Result;
BOOLEAN Inserted;
if (CreateOptions & FILE_DIRECTORY_FILE)
AllocationSize = 0;
FileNode = MemfsFileNodeMapGet(Memfs->FileNodeMap, FileName);
if (0 != FileNode)
return STATUS_OBJECT_NAME_COLLISION;
if (!MemfsFileNodeMapGetParent(Memfs->FileNodeMap, FileName, &Result))
return Result;
if (MemfsFileNodeMapCount(Memfs->FileNodeMap) >= Memfs->MaxFileNodes)
return STATUS_CANNOT_MAKE;
if (AllocationSize > Memfs->MaxFileSize)
return STATUS_DISK_FULL;
Result = MemfsFileNodeCreate(FileName, &FileNode);
if (!NT_SUCCESS(Result))
return Result;
FileNode->FileInfo.FileAttributes = (FileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
FileAttributes : FileAttributes | FILE_ATTRIBUTE_ARCHIVE;
if (0 != SecurityDescriptor)
{
FileNode->FileSecuritySize = GetSecurityDescriptorLength(SecurityDescriptor);
FileNode->FileSecurity = (PSECURITY_DESCRIPTOR)malloc(FileNode->FileSecuritySize);
if (0 == FileNode->FileSecurity)
{
MemfsFileNodeDelete(FileNode);
return STATUS_INSUFFICIENT_RESOURCES;
}
memcpy(FileNode->FileSecurity, SecurityDescriptor, FileNode->FileSecuritySize);
}
FileNode->FileInfo.AllocationSize = AllocationSize;
if (0 != FileNode->FileInfo.AllocationSize)
{
FileNode->FileData = malloc((size_t)FileNode->FileInfo.AllocationSize);
if (0 == FileNode->FileData)
{
MemfsFileNodeDelete(FileNode);
return STATUS_INSUFFICIENT_RESOURCES;
}
}
Result = MemfsFileNodeMapInsert(Memfs->FileNodeMap, FileNode, &Inserted);
if (!NT_SUCCESS(Result) || !Inserted)
{
MemfsFileNodeDelete(FileNode);
if (NT_SUCCESS(Result))
Result = STATUS_OBJECT_NAME_COLLISION; /* should not happen! */
return Result;
}
FileNode->RefCount++;
*PFileNode = FileNode;
*FileInfo = FileNode->FileInfo;
return STATUS_SUCCESS;
}
BOOL SecurityGet(
char *resource,
PVOLUMECAPS VolumeCaps,
unsigned char *buffer,
DWORD *cbBuffer
)
{
HANDLE hFile;
DWORD dwDesiredAccess;
DWORD dwFlags;
PSECURITY_DESCRIPTOR sd = (PSECURITY_DESCRIPTOR)buffer;
SECURITY_INFORMATION RequestedInfo;
BOOL bBackupPrivilege = FALSE;
BOOL bSaclPrivilege = FALSE;
BOOL bSuccess = FALSE;
DWORD cchResourceLen;
if(!bZipInitialized) if(!Initialize()) return FALSE;
/* see if we are dealing with a directory */
/* rely on the fact resource has a trailing [back]slash, rather
than calling expensive GetFileAttributes() */
cchResourceLen = lstrlenA(resource);
if(resource[cchResourceLen-1] == '/' || resource[cchResourceLen-1] == '\\')
VolumeCaps->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
/* setup privilege usage based on if told we can use privileges, and if so,
what privileges we have */
if(VolumeCaps->bUsePrivileges) {
if(VolumeCaps->bRemote) {
/* use remotely determined privileges */
if(VolumeCaps->dwRemotePrivileges & OVERRIDE_BACKUP)
bBackupPrivilege = TRUE;
if(VolumeCaps->dwRemotePrivileges & OVERRIDE_SACL)
bSaclPrivilege = TRUE;
} else {
/* use local privileges */
bBackupPrivilege = g_bBackupPrivilege;
bSaclPrivilege = g_bZipSaclPrivilege;
}
}
/* always try to read the basic security information: Dacl, Owner, Group */
dwDesiredAccess = READ_CONTROL;
RequestedInfo = OWNER_SECURITY_INFORMATION |
GROUP_SECURITY_INFORMATION |
DACL_SECURITY_INFORMATION;
/* if we have the SeBackupPrivilege or SeSystemSecurityPrivilege, read
the Sacl, too */
if(bBackupPrivilege || bSaclPrivilege) {
dwDesiredAccess |= ACCESS_SYSTEM_SECURITY;
RequestedInfo |= SACL_SECURITY_INFORMATION;
}
dwFlags = 0;
/* if we have the backup privilege, specify that */
/* opening a directory requires FILE_FLAG_BACKUP_SEMANTICS */
if(bBackupPrivilege || (VolumeCaps->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
dwFlags |= FILE_FLAG_BACKUP_SEMANTICS;
hFile = CreateFileA(
resource,
dwDesiredAccess,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, /* maximum sharing */
NULL,
OPEN_EXISTING,
dwFlags,
NULL
);
if(hFile == INVALID_HANDLE_VALUE) return FALSE;
if(GetKernelObjectSecurity(hFile, RequestedInfo, sd, *cbBuffer, cbBuffer)) {
*cbBuffer = GetSecurityDescriptorLength( sd );
bSuccess = TRUE;
}
CloseHandle(hFile);
return bSuccess;
}
// @object PyADSVALUE|A tuple:
// @tupleitem 0|object|value|The value as a Python object.
// @tupleitem 1|int|type|The AD type of the value.
PyObject *PyADSIObject_FromADSVALUE(ADSVALUE &v)
{
PyObject *ob = NULL;
switch (v.dwType) {
case ADSTYPE_DN_STRING:
ob = PyWinObject_FromWCHAR(v.DNString);
break;
case ADSTYPE_CASE_EXACT_STRING:
ob = PyWinObject_FromWCHAR(v.CaseExactString);
break;
case ADSTYPE_CASE_IGNORE_STRING:
ob = PyWinObject_FromWCHAR(v.CaseIgnoreString);
break;
case ADSTYPE_PRINTABLE_STRING:
ob = PyWinObject_FromWCHAR(v.PrintableString);
break;
case ADSTYPE_NUMERIC_STRING:
ob = PyWinObject_FromWCHAR(v.NumericString);
break;
case ADSTYPE_BOOLEAN:
ob = v.Boolean ? Py_True : Py_False;
Py_INCREF(ob);
break;
case ADSTYPE_INTEGER:
ob = PyInt_FromLong(v.Integer);
break;
case ADSTYPE_OCTET_STRING:
{
void *buf;
DWORD bufSize = v.OctetString.dwLength;
if (!(ob=PyBuffer_New(bufSize)))
return NULL;
if (!PyWinObject_AsWriteBuffer(ob, &buf, &bufSize)){
Py_DECREF(ob);
return NULL;
}
memcpy(buf, v.OctetString.lpValue, bufSize);
}
break;
case ADSTYPE_UTC_TIME:
ob = PyWinObject_FromSYSTEMTIME(v.UTCTime);
break;
case ADSTYPE_LARGE_INTEGER:
ob = PyWinObject_FromLARGE_INTEGER(v.LargeInteger);
break;
case ADSTYPE_OBJECT_CLASS:
ob = PyWinObject_FromWCHAR(v.ClassName);
break;
case ADSTYPE_PROV_SPECIFIC:
{
void *buf;
DWORD bufSize = v.ProviderSpecific.dwLength;
if (!(ob=PyBuffer_New(bufSize)))
return NULL;
if (!PyWinObject_AsWriteBuffer(ob, &buf, &bufSize)){
Py_DECREF(ob);
return NULL;
}
memcpy(buf, v.ProviderSpecific.lpValue, bufSize);
break;
}
case ADSTYPE_NT_SECURITY_DESCRIPTOR:
{
// Get a pointer to the security descriptor.
PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR)(v.SecurityDescriptor.lpValue);
DWORD SDSize = v.SecurityDescriptor.dwLength;
// eeek - we don't pass the length - pywintypes relies on
// GetSecurityDescriptorLength - make noise if this may bite us.
if (SDSize != GetSecurityDescriptorLength(pSD))
PyErr_Warn(PyExc_RuntimeWarning, "Security-descriptor size mis-match");
ob = PyWinObject_FromSECURITY_DESCRIPTOR(pSD);
break;
}
default:
{
char msg[100];
sprintf(msg, "Unknown ADS type code 0x%x - None will be returned", v.dwType);
PyErr_Warn(PyExc_RuntimeWarning, msg);
ob = Py_None;
Py_INCREF(ob);
}
}
if (ob==NULL)
return NULL;
PyObject *ret = Py_BuildValue("Oi", ob, (int)v.dwType);
Py_DECREF(ob);
return ret;
}
bool StoreSD(IWbemServices * pSession, PSECURITY_DESCRIPTOR pSD)
{
bool bRet = false;
HRESULT hr;
if (!IsValidSecurityDescriptor(pSD))
return false;
// Get the class object
IWbemClassObject * pClass = NULL;
_bstr_t InstPath(L"__systemsecurity=@");
_bstr_t ClassPath(L"__systemsecurity");
hr = pSession->GetObject(ClassPath, 0, NULL, &pClass, NULL);
if(FAILED(hr))
return false;
// Get the input parameter class
_bstr_t MethName(L"SetSD");
IWbemClassObject * pInClassSig = NULL;
hr = pClass->GetMethod(MethName,0, &pInClassSig, NULL);
pClass->Release();
if(FAILED(hr))
return false;
// spawn an instance of the input parameter class
IWbemClassObject * pInArg = NULL;
pInClassSig->SpawnInstance(0, &pInArg);
pInClassSig->Release();
if(FAILED(hr))
return false;
// move the SD into a variant.
SAFEARRAY FAR* psa;
SAFEARRAYBOUND rgsabound[1]; rgsabound[0].lLbound = 0;
long lSize = GetSecurityDescriptorLength(pSD);
rgsabound[0].cElements = lSize;
psa = SafeArrayCreate( VT_UI1, 1 , rgsabound );
if(psa == NULL)
{
pInArg->Release();
return false;
}
char * pData = NULL;
hr = SafeArrayAccessData(psa, (void HUGEP* FAR*)&pData);
if(FAILED(hr))
{
pInArg->Release();
return false;
}
memcpy(pData, pSD, lSize);
SafeArrayUnaccessData(psa);
_variant_t var;
var.vt = VT_I4|VT_ARRAY;
var.parray = psa;
// put the property
hr = pInArg->Put(L"SD" , 0, &var, 0);
if(FAILED(hr))
{
pInArg->Release();
return false;
}
// Execute the method
IWbemClassObject * pOutParams = NULL;
hr = pSession->ExecMethod(InstPath,
MethName,
0,
NULL, pInArg,
NULL, NULL);
if(FAILED(hr))
printf("\nPut failed, returned 0x%x",hr);
return bRet;
}
