able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/adsi/router/cadssec.cxx

1798 lines
44 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: cadssec.cxx
//
// Contents: This file contains the support ADsSecurityUtility class
// implementation and the support routines it requires. The
// default interface for the ADsSecurityClassUtility class
// is IADsSecurityUtility.
//
// History: 10-11-00 AjayR Created.
//
//----------------------------------------------------------------------------
#include "oleds.hxx"
//
// Helper functions.
//
//+---------------------------------------------------------------------------
// Function: GetServerAndResource - Helper routine.
//
// Synopsis: Splits the string into a serverName piece and rest piece.
// This is used for fileshare paths like \\Computer\share to return
// \\computer and share. In the case of registry a string like
// \\Computer\HKLM\Microsoft will be split into \\Computer and
// HKLM\Microsoft. if there is no computer name specified, then
// the serverName will be NULL.
//
// Arguments: pszName - Name to be split.
// ppszServer - Return value for server name.
// ppszResource - Return value for rest of string.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: ppSD and pdwLength on success.
//
//----------------------------------------------------------------------------
HRESULT
GetServerAndResource(
LPWSTR pszName,
LPWSTR *ppszServer,
LPWSTR *ppszResource
)
{
HRESULT hr = S_OK;
DWORD dwLength = wcslen(pszName);
LPWSTR pszTemp = pszName;
LPWSTR pszServer = NULL;
LPWSTR pszResource = NULL;
DWORD dwLen = 0;
BOOL fNoServer = FALSE;
*ppszServer = NULL;
*ppszResource = NULL;
//
// If we have just 1 \ or no \'s there is no server name.
//
if ((dwLength < 2)
|| (pszName[0] != L'\\')
|| (pszName[1] != L'\\')
) {
fNoServer = TRUE;
}
if (fNoServer) {
//
// Name is the entire string passed in.
//
pszResource = AllocADsStr(pszName);
if (!pszResource) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
*ppszResource = pszResource;
RRETURN(hr);
}
//
// Make sure that the first 2 chars are \\
//
if (pszTemp[0] != L'\\'
|| pszTemp[1] != L'\\' )
{
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
pszTemp += 2;
while (pszTemp && *pszTemp != L'\\') {
dwLen++;
pszTemp++;
}
if (!pszTemp
|| !*pszTemp
|| !dwLen
) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
dwLen += 2; // the 2 \\ in the serverName
//
// Advance past the \ in \\testShare\FileShare.
//
pszTemp++;
if (!pszTemp || !*pszTemp) {
BAIL_ON_FAILURE(hr = E_INVALIDARG)
}
//
// If we get here we have valid server and share names.
//
pszServer = (LPWSTR) AllocADsMem((dwLen+1) * sizeof(WCHAR));
if (!pszServer) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
wcsncpy(pszServer, pszName, dwLen);
pszResource = AllocADsStr(pszTemp);
if (!pszResource) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
*ppszServer = pszServer;
*ppszResource = pszResource;
error:
if (FAILED(hr)) {
if (pszResource) {
FreeADsMem(pszResource);
}
if (pszServer) {
FreeADsMem(pszServer);
}
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: GetKeyRootAndSubKey - Helper routine.
//
// Synopsis: Gets the root (such as HKLM) from the registry key path. This
// is needed when we open a handle to the key. The rest of the path
// constitutes the SubKey name.
//
// Arguments: pszKeyName - Name of the key we need to open.
// ppszSubKey - Return value for the subKey
// phKey - Return value for key root to open.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: phKey, NULL on failure and one of
// HKEY_USERS, HKEY_CURRENT_USER, HKEY_CURRENT_CONFIG,
// HKEY_LOCAL_MACHINE, HKEY_CLASSES_ROOT
// or HKEY_PERFORMANCE_DATA on success.
//
//----------------------------------------------------------------------------
HRESULT
GetKeyRootAndSubKey(
LPWSTR pszKeyName,
LPWSTR * ppszSubKey,
HKEY * phKey
)
{
HRESULT hr = S_OK;
HKEY hKey = NULL;
LPWSTR pszRoot = NULL;
LPWSTR pszTemp = pszKeyName;
LPWSTR pszSubKey = NULL;
DWORD dwLen = 0;
*phKey = NULL;
*ppszSubKey = NULL;
while (pszTemp
&& *pszTemp
&& *pszTemp != L'\\') {
dwLen++;
pszTemp++;
}
//
// If the length is less than 3 something is wrong.
//
if ((dwLen < 3)
|| !pszTemp
|| !*pszTemp
) {
BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
}
//
// To get the subkey, we need to move past the \.
//
pszTemp++;
if (pszTemp && *pszTemp) {
pszSubKey = AllocADsStr(pszTemp);
if (!pszSubKey) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
}
pszRoot = (LPWSTR) AllocADsMem((dwLen+1) * sizeof(WCHAR));
if (!pszRoot) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// Copy over the root so we can use it in the subsequent comparisions.
//
wcsncpy(pszRoot, pszKeyName, dwLen);
if (_wcsicmp( pszRoot, L"HKEY_CLASSES_ROOT") == 0
|| _wcsicmp( pszRoot, L"HKCR") == 0
) {
hKey = HKEY_CLASSES_ROOT;
}
else if (_wcsicmp( pszRoot, L"HKEY_LOCAL_MACHINE") == 0
|| _wcsicmp( pszRoot, L"HKLM") == 0
) {
hKey = HKEY_LOCAL_MACHINE;
}
else if (_wcsicmp(pszRoot, L"HKEY_CURRENT_CONFIG") == 0
|| _wcsicmp(pszRoot, L"HKCC") == 0
) {
hKey = HKEY_CURRENT_CONFIG;
}
else if (_wcsicmp(pszRoot, L"HKEY_CURRENT_USER" ) == 0
|| _wcsicmp( pszRoot, L"HKCU") == 0
) {
hKey = HKEY_CURRENT_USER;
}
else if (_wcsicmp(pszRoot, L"HKEY_USERS") == 0
|| _wcsicmp(pszRoot, L"HKU")
) {
hKey = HKEY_USERS;
}
else if ( _wcsicmp(pszRoot, L"HKEY_PERFORMANCE_DATA") == 0) {
hKey = HKEY_PERFORMANCE_DATA;
}
else {
//
// Has to be one of the above.
//
BAIL_ON_FAILURE(hr = E_FAIL);
}
*phKey = hKey;
*ppszSubKey = pszSubKey;
error:
if (pszRoot) {
FreeADsStr(pszRoot);
}
if (FAILED(hr) && pszSubKey) {
FreeADsStr(pszSubKey);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertRawSDToBinary - Helper routine.
//
// Synopsis: Converts the binary SD to a VT_UI1 | VT_ARRAY.
//
// Arguments: pSecurityDescriptor - Binary sd to convert.
// dwLength - Length of SD.
// pVariant - Return value.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: pVariant to point to IID_IADsSecurityDescriptor on success.
//
//----------------------------------------------------------------------------
HRESULT
ConvertRawSDToBinary(
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD dwLength,
VARIANT *pVariant
)
{
HRESULT hr = S_OK;
SAFEARRAY * aList = NULL;
SAFEARRAYBOUND aBound;
CHAR HUGEP *pArray = NULL;
aBound.lLbound = 0;
aBound.cElements = dwLength;
aList = SafeArrayCreate( VT_UI1, 1, &aBound );
if (!aList) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
hr = SafeArrayAccessData( aList, (void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( pArray, pSecurityDescriptor, aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(pVariant) = VT_ARRAY | VT_UI1;
V_ARRAY(pVariant) = aList;
RRETURN(hr);
error:
if ( aList ) {
SafeArrayDestroy( aList );
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertRawSDToHexString - Helper routine.
//
// Synopsis: Converts the binary SD to a VT_BSTR in hex string format.
//
// Arguments: pSecurityDescriptor - Binary sd to convert.
// dwLength - Length of SD.
// pVariant - Return value for VT_BSTR.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: pVariant to point to IID_IADsSecurityDescriptor on success.
//
//----------------------------------------------------------------------------
HRESULT
ConvertRawSDToHexString(
PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD dwLength,
VARIANT *pVariant
)
{
HRESULT hr = S_OK;
LPWSTR pszHexStr = NULL;
BSTR bstrHexSD = NULL;
WCHAR szSmallStr[10];
pszHexStr = (LPWSTR) AllocADsMem((dwLength+1) * 2 * sizeof(WCHAR));
if (!pszHexStr) {
BAIL_ON_FAILURE(hr);
}
for (DWORD dwCtr = 0; dwCtr < dwLength; dwCtr++) {
wsprintf(
szSmallStr,
L"%02x",
((BYTE*)pSecurityDescriptor)[dwCtr]
);
wcscat(pszHexStr, szSmallStr);
}
hr = ADsAllocString(pszHexStr, &bstrHexSD);
if (SUCCEEDED(hr)) {
pVariant->vt = VT_BSTR;
pVariant->bstrVal = bstrHexSD;
}
error:
if (pszHexStr) {
FreeADsMem(pszHexStr);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertHexSDToRawSD - Helper routine.
//
// Synopsis: Converts the hex string SD to a binary SD.
//
// Arguments: pVarHexSD - Variant with hex string.
// ppSecurityDescriptor - Return value for binary SD
// pdwLength - Return value for length of SD.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: ppSecurityDescriptor and pdwLength updated accordingly.
//
//----------------------------------------------------------------------------
HRESULT
ConvertHexSDToRawSD(
PVARIANT pVarHexSD,
PSECURITY_DESCRIPTOR *ppSecurityDescriptor,
DWORD *pdwLength
)
{
HRESULT hr = S_OK;
LPWSTR pszHexSD = V_BSTR(pVarHexSD);
DWORD dwLen;
LPBYTE lpByte = NULL;
*ppSecurityDescriptor = NULL;
*pdwLength = 0;
if (!pszHexSD
|| ((dwLen = wcslen(pszHexSD)) == 0)
) {
//
// NULL SD.
//
RRETURN(S_OK);
}
dwLen = wcslen(pszHexSD);
//
// Length has to be even.
//
if (((dwLen/2) * 2) != dwLen) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
dwLen /= 2;
if (dwLen) {
lpByte = (LPBYTE) AllocADsMem(dwLen);
if (!lpByte) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
//
// Go through and read one 2 hex chars at a time.
//
for (
DWORD dwCtr = 0;
(dwCtr < dwLen) && (pszHexSD && *pszHexSD);
dwCtr++ ) {
DWORD dwCount, dwHexVal;
dwCount = swscanf(pszHexSD, L"%02x", &dwHexVal);
//
// The read has to be successful and the data valid.
//
if (dwCount != 1) {
BAIL_ON_FAILURE(hr = E_FAIL);
}
//
// Make sure that the value is in the correct range.
//
if (dwHexVal & (0xFFFFFF00)) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
lpByte[dwCtr] = (BYTE) dwHexVal;
pszHexSD++;
if (!pszHexSD) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
pszHexSD++;
} // for loop
//
// The sd translation was succesful.
//
*ppSecurityDescriptor = (PSECURITY_DESCRIPTOR)(LPVOID) lpByte;
*pdwLength = dwLen;
} // if the string had any data in it.
error:
if (FAILED(hr) && lpByte) {
FreeADsMem(lpByte);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: ConvertBinarySDToRawSD - Helper routine.
//
// Synopsis: Converts a VT_UI1 | VT_ARRAY to a binary SD.
//
// Arguments: pvVarBinSD - The input variant array to convert.
// ppSecurityDescriptor - Return value for binary sd.
// pdwLength - Return value for length of binary sd.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: ppSecurityDescriptor and pdwLength modified appropriately.
//
//----------------------------------------------------------------------------
HRESULT
ConvertBinarySDToRawSD(
PVARIANT pvVarBinSD,
PSECURITY_DESCRIPTOR *ppSecurityDescriptor,
DWORD *pdwLength
)
{
HRESULT hr = S_OK;
LPVOID lpMem = NULL;
long lBoundLower = -1;
long lBoundUpper = -1;
CHAR HUGEP *pArray = NULL;
*ppSecurityDescriptor = NULL;
*pdwLength = 0;
//
// Make sure we have an array and then get length.
//
if( pvVarBinSD->vt != (VT_ARRAY | VT_UI1)) {
RRETURN(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
hr = SafeArrayGetLBound(
V_ARRAY(pvVarBinSD),
1,
&lBoundLower
);
BAIL_ON_FAILURE(hr);
hr = SafeArrayGetUBound(
V_ARRAY(pvVarBinSD),
1,
&lBoundUpper
);
BAIL_ON_FAILURE(hr);
if ((lBoundUpper == -1)
&& (lBoundLower == -1)
) {
//
// Nothing further to do in this case.
//
;
}
else {
long lLength;
lLength = (lBoundUpper - lBoundLower) + 1;
lpMem = AllocADsMem(lLength);
if (!lpMem) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
hr = SafeArrayAccessData(
V_ARRAY(pvVarBinSD),
(void HUGEP * FAR *) &pArray
);
BAIL_ON_FAILURE(hr);
memcpy(lpMem, pArray, lLength);
SafeArrayUnaccessData(V_ARRAY(pvVarBinSD));
*ppSecurityDescriptor = (PSECURITY_DESCRIPTOR) lpMem;
*pdwLength = (DWORD) lLength;
}
error:
if (FAILED(hr) && lpMem) {
FreeADsMem(lpMem);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: GetRawSDFromFile - Helper routine.
//
// Synopsis: Gets the security descriptor from the file in binary format.
//
// Arguments: pszFileName - Name of file to get sd from.
// secInfo - Security mask to use for the operation.
// ppSD - Return value for the SD.
// pdwLength - Return value for the lenght of the SD.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: ppSD and pdwLength on success.
//
//----------------------------------------------------------------------------
HRESULT
GetRawSDFromFile(
LPWSTR pszFileName,
SECURITY_INFORMATION secInfo,
PSECURITY_DESCRIPTOR *ppSD,
PDWORD pdwLength
)
{
HRESULT hr = S_OK;
DWORD dwLength = 0;
PSECURITY_DESCRIPTOR pSD = NULL;
*ppSD = NULL;
*pdwLength = 0;
//
// Get the length of the SD.
//
if (!GetFileSecurity(
pszFileName,
secInfo,
NULL,
0,
&dwLength
)
&& (dwLength == 0)
) {
//
// There was an error.
//
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(GetLastError()));
}
if (dwLength == 0) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(GetLastError()));
}
pSD = (PSECURITY_DESCRIPTOR) AllocADsMem(dwLength);
if (!pSD) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
if (!GetFileSecurity(
pszFileName,
secInfo,
pSD,
dwLength,
&dwLength
)
) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(GetLastError()));
}
*pdwLength = dwLength;
*ppSD = pSD;
error:
if (FAILED(hr) && pSD) {
FreeADsMem(pSD);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: SetRawSDToFile - Helper routine.
//
// Synopsis: Sets the binary security descriptor on the file.
//
// Arguments: pszFileName - Name of file to set sd on.
// secInfo - Security mask to use for the operation.
// pSD - Value of SD to set.
// dwLength - Length of the sd.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT
SetRawSDToFile(
LPWSTR pszFileName,
SECURITY_INFORMATION secInfo,
PSECURITY_DESCRIPTOR pSD
)
{
HRESULT hr = S_OK;
if (!SetFileSecurity(
pszFileName,
secInfo,
pSD
)
) {
RRETURN(HRESULT_FROM_WIN32(GetLastError()));
}
else {
RRETURN(S_OK);
}
}
//+---------------------------------------------------------------------------
// Function: GetRawSDFromFileShare - Helper routine.
//
// Synopsis: Gets the security descriptor from the fileshare in bin format.
//
// Arguments: pszFileShareName - Name of fileshare to get sd from.
// ppSD - Return value for the SD.
// pdwLength - Return value for the lenght of the SD.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: ppSD and pdwLength on success.
//
//----------------------------------------------------------------------------
HRESULT
GetRawSDFromFileShare(
LPWSTR pszFileShareName,
PSECURITY_DESCRIPTOR *ppSD,
PDWORD pdwLength
)
{
HRESULT hr = S_OK;
LPWSTR pszServerName = NULL;
LPWSTR pszShareName = NULL;
DWORD dwLength = 0;
PSECURITY_DESCRIPTOR pSD = NULL;
SHARE_INFO_502 * pShareInfo502 = NULL;
NET_API_STATUS nasStatus = NERR_Success;
*ppSD = NULL;
*pdwLength = 0;
//
// We need to split the name into serverName and shareName
//
hr = GetServerAndResource(
pszFileShareName,
&pszServerName,
&pszShareName
);
BAIL_ON_FAILURE(hr);
//
// Only 502 level call returns the SD Info.
//
nasStatus = NetShareGetInfo(
pszServerName,
pszShareName,
502,
(LPBYTE *)&pShareInfo502
);
if (nasStatus != NERR_Success) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(nasStatus));
}
//
// If the SD is non NULL process the SD.
//
if (pShareInfo502->shi502_security_descriptor) {
//
// Get the length of the SD, it should not be 0.
//
SetLastError(0);
dwLength = GetSecurityDescriptorLength(
pShareInfo502->shi502_security_descriptor
);
//
// The return length should not be zero.
//
if (dwLength == 0) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(GetLastError()));
}
pSD = (PSECURITY_DESCRIPTOR) AllocADsMem(dwLength);
if (!pSD) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
memcpy(pSD, pShareInfo502->shi502_security_descriptor, dwLength);
*ppSD = pSD;
*pdwLength = dwLength;
}
else {
//
// The SD was NULL the ret values are set correctly
//
;
}
error:
if (pszServerName) {
FreeADsStr(pszServerName);
}
if (pszShareName) {
FreeADsStr(pszShareName);
}
if (pShareInfo502) {
NetApiBufferFree(pShareInfo502);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: SetRawSDToFileShare - Helper routine.
//
// Synopsis: Sets the binary SD on the fileshare.
//
// Arguments: pszFileShare - Name of fileshare to set sd on.
// pSD - The SD to set.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT
SetRawSDToFileShare(
LPWSTR pszFileShare,
PSECURITY_DESCRIPTOR pSD
)
{
HRESULT hr = S_OK;
LPWSTR pszServerName = NULL;
LPWSTR pszShareName = NULL;
SHARE_INFO_502 * pShareInfo502 = NULL;
NET_API_STATUS nasStatus = NERR_Success;
PSECURITY_DESCRIPTOR pTempSD = NULL;
//
// We need to split the name into serverName and shareName
//
hr = GetServerAndResource(
pszFileShare,
&pszServerName,
&pszShareName
);
BAIL_ON_FAILURE(hr);
//
// Ideally we should use 1501 level but that is only on Win2k. So
// we need to read the info, update SD and then set it.
//
nasStatus = NetShareGetInfo(
pszServerName,
pszShareName,
502,
(LPBYTE *) &pShareInfo502
);
if (nasStatus != NERR_Success) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(nasStatus));
}
//
// Store away the SD so we restore before free.
//
pTempSD = pShareInfo502->shi502_security_descriptor;
pShareInfo502->shi502_security_descriptor = pSD;
nasStatus = NetShareSetInfo(
pszServerName,
pszShareName,
502,
(LPBYTE) pShareInfo502,
NULL
);
pShareInfo502->shi502_security_descriptor = pTempSD;
if (nasStatus != NERR_Success) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(nasStatus));
}
error:
if (pShareInfo502) {
NetApiBufferFree(pShareInfo502);
}
if (pszServerName) {
FreeADsStr(pszServerName);
}
if (pszShareName) {
FreeADsStr(pszShareName);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: GetRawSDFromRegistry - Helper routine.
//
// Synopsis: Gets the security descriptor from the registry in bin format.
//
// Arguments: pszFileRegKeyName - Name of fileshare to get sd from.
// secInfo - Security mask to use for the operation.
// ppSD - Return value for the SD.
// pdwLength - Return value for the lenght of the SD.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: ppSD and pdwLength on success.
//
//----------------------------------------------------------------------------
HRESULT
GetRawSDFromRegistry(
LPWSTR pszFileRegKeyName,
SECURITY_INFORMATION secInfo,
PSECURITY_DESCRIPTOR *ppSD,
PDWORD pdwLength
)
{
HRESULT hr;
LPWSTR pszServerName = NULL;
LPWSTR pszKeyName = NULL;
LPWSTR pszSubKey = NULL;
DWORD dwLength = 0;
DWORD dwErr;
PSECURITY_DESCRIPTOR pSD = NULL;
HKEY hKey = NULL;
HKEY hKeyRoot = NULL;
HKEY hKeyMachine = NULL;
*ppSD = NULL;
*pdwLength = 0;
//
// We need to split the name into serverName and shareName
//
hr = GetServerAndResource(
pszFileRegKeyName,
&pszServerName,
&pszKeyName
);
BAIL_ON_FAILURE(hr);
//
// pszKeyName has to have a valid string. We need to process it
// to find out which key set we need to open (such as HKLM).
//
hr = GetKeyRootAndSubKey(pszKeyName, &pszSubKey, &hKeyRoot);
BAIL_ON_FAILURE(hr);
//
// Need to open the hKeyRoot on the appropriate machine.
// If the serverName is NULL it will be local machine.
//
dwErr = RegConnectRegistry(
pszServerName,
hKeyRoot,
&hKeyMachine
);
if (dwErr) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
//
// Open the key and try and read the security descriptor
//
dwErr = RegOpenKeyEx(
hKeyMachine,
pszSubKey,
0,
KEY_READ,
&hKey
);
if (dwErr) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
dwErr = RegGetKeySecurity(
hKey,
secInfo,
pSD,
&dwLength
);
if (dwLength == 0) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
pSD = (PSECURITY_DESCRIPTOR) AllocADsMem(dwLength);
if (!pSD) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
dwErr = RegGetKeySecurity(
hKey,
secInfo,
pSD,
&dwLength
);
if (dwErr) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
*ppSD = pSD;
*pdwLength = dwLength;
error:
if (pszServerName) {
FreeADsStr(pszServerName);
}
if (pszKeyName) {
FreeADsStr(pszKeyName);
}
if (pszSubKey) {
FreeADsStr(pszSubKey);
}
if (hKey) {
RegCloseKey(hKey);
}
if (hKeyMachine) {
RegCloseKey(hKeyMachine);
}
if (FAILED(hr) && pSD) {
FreeADsMem(pSD);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: SetRawSDToRegistry - Helper routine.
//
// Synopsis: Sets the security descriptor to the specified key.
//
// Arguments: pszFileRegKeyName - Name of fileshare to set sd on.
// secInfo - Security mask to use for the operation.
// pSD - SD to set on the reg key.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
HRESULT
SetRawSDToRegistry(
LPWSTR pszFileRegKeyName,
SECURITY_INFORMATION secInfo,
PSECURITY_DESCRIPTOR pSD
)
{
HRESULT hr;
LPWSTR pszServerName = NULL;
LPWSTR pszKeyName = NULL;
LPWSTR pszSubKey = NULL;
DWORD dwErr;
HKEY hKey = NULL;
HKEY hKeyRoot = NULL;
HKEY hKeyMachine = NULL;
//
// We need to split the name into serverName and shareName
//
hr = GetServerAndResource(
pszFileRegKeyName,
&pszServerName,
&pszKeyName
);
BAIL_ON_FAILURE(hr);
//
// pszKeyName has to have a valid string. We need to process it
// to find out which key set we need to open (such as HKLM).
//
hr = GetKeyRootAndSubKey(pszKeyName, &pszSubKey, &hKeyRoot);
BAIL_ON_FAILURE(hr);
//
// Need to open the hKeyRoot on the appropriate machine.
// If the serverName is NULL it will be local machine.
//
dwErr = RegConnectRegistry(
pszServerName,
hKeyRoot,
&hKeyMachine
);
if (dwErr) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
//
// Open the key and try and read the security descriptor
//
dwErr = RegOpenKeyEx(
hKeyMachine,
pszSubKey,
0,
KEY_WRITE,
&hKey
);
if (dwErr) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
dwErr = RegSetKeySecurity(
hKey,
secInfo,
pSD
);
if (dwErr) {
BAIL_ON_FAILURE(hr = HRESULT_FROM_WIN32(dwErr));
}
error:
if (pszServerName) {
FreeADsStr(pszServerName);
}
if (pszKeyName) {
FreeADsStr(pszKeyName);
}
if (pszSubKey) {
FreeADsStr(pszSubKey);
}
if (hKey) {
RegCloseKey(hKey);
}
if (hKeyMachine) {
RegCloseKey(hKeyMachine);
}
RRETURN(hr);
}
/****************************************************************************/
//
// CADsSecurityUtility Class.
//
/****************************************************************************/
DEFINE_IDispatch_Implementation(CADsSecurityUtility)
//+---------------------------------------------------------------------------
// Function: CSecurity::CSecurityDescriptor - Constructor.
//
// Synopsis: Standard constructor.
//
// Arguments: N/A.
//
// Returns: N/A.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
CADsSecurityUtility::CADsSecurityUtility():
_secInfo( DACL_SECURITY_INFORMATION
| GROUP_SECURITY_INFORMATION
| OWNER_SECURITY_INFORMATION
),
_pDispMgr(NULL)
{
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::~CADsSecurityUtility - Destructor.
//
// Synopsis: Standard destructor.
//
// Arguments: N/A.
//
// Returns: N/A.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
CADsSecurityUtility::~CADsSecurityUtility()
{
//
// Only the dispmgr needs to be cleaned up.
//
delete _pDispMgr;
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::AllocateADsSecurityUtilityObject -
// Static helper method.
//
// Synopsis: Standard static allocation routine.
//
// Arguments: ppADsSecurityUtil - Return ptr.
//
// Returns: S_OK on success or appropriate error code on failure.
//
// Modifies: *ppADsSecurity.
//
//----------------------------------------------------------------------------
HRESULT
CADsSecurityUtility::AllocateADsSecurityUtilityObject(
CADsSecurityUtility **ppADsSecurityUtil
)
{
HRESULT hr = S_OK;
CADsSecurityUtility FAR * pADsSecurityUtil = NULL;
CDispatchMgr FAR * pDispMgr = NULL;
pADsSecurityUtil = new CADsSecurityUtility();
if (!pADsSecurityUtil) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
pDispMgr = new CDispatchMgr;
if (!pDispMgr) {
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
}
hr = LoadTypeInfoEntry(
pDispMgr,
LIBID_ADs,
IID_IADsSecurityUtility,
(IADsSecurityUtility *)pADsSecurityUtil,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
pADsSecurityUtil->_pDispMgr = pDispMgr;
*ppADsSecurityUtil = pADsSecurityUtil;
RRETURN(hr);
error:
delete pADsSecurityUtil;
delete pDispMgr;
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::CreateADsSecurityUtility - Static
// helper method.
//
// Synopsis: Standard static class factor helper method.
//
// Arguments: riid - IID needed on returned object.
// ppvObj - Return ptr.
//
// Returns: S_OK on success or appropriate error code on failure.
//
// Modifies: *ppvObj is suitably modified.
//
//----------------------------------------------------------------------------
HRESULT
CADsSecurityUtility::CreateADsSecurityUtility(
REFIID riid,
void **ppvObj
)
{
CADsSecurityUtility FAR * pADsSecurityUtil = NULL;
HRESULT hr = S_OK;
hr = AllocateADsSecurityUtilityObject(&pADsSecurityUtil);
BAIL_ON_FAILURE(hr);
hr = pADsSecurityUtil->QueryInterface(riid, ppvObj);
BAIL_ON_FAILURE(hr);
pADsSecurityUtil->Release();
RRETURN(hr);
error:
delete pADsSecurityUtil;
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::QueryInterface --- IUnknown support.
//
// Synopsis: Standard query interface method.
//
// Arguments: iid - Interface requested.
// ppInterface - Return pointer to interface requested.
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: *ppInterface to return interface pointer.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CADsSecurityUtility::QueryInterface(
REFIID iid,
LPVOID *ppInterface
)
{
HRESULT hr = S_OK;
if (!ppInterface) {
RRETURN(E_INVALIDARG);
}
if (IsEqualIID(iid, IID_IUnknown)) {
*ppInterface = (IADsSecurityUtility *) this;
}
else if (IsEqualIID(iid, IID_IDispatch)) {
*ppInterface = (IADsSecurityUtility *) this;
}
else if (IsEqualIID(iid, IID_IADsSecurityUtility)) {
*ppInterface = (IADsSecurityUtility *) this;
}
else if (IsEqualIID(iid, IID_ISupportErrorInfo)) {
*ppInterface = (ISupportErrorInfo *) this;
}
else {
RRETURN(E_NOINTERFACE);
}
AddRef();
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::InterfaceSupportserrorInfo
// ISupportErrorInfo support.
//
// Synopsis: N/A.
//
// Arguments: riid - Interface being tested..
//
// Returns: S_OK or S_FALSE on failure.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CADsSecurityUtility::InterfaceSupportsErrorInfo(THIS_ REFIID riid)
{
if (IsEqualIID(riid, IID_IADsSecurityUtility)) {
return S_OK;
} else {
return S_FALSE;
}
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::GetSecurityDescriptor -
// IADsSecurityUtility support.
//
// Synopsis: Gets the security descriptor from the named object.
//
// Arguments: varPath - Path of object to get SD from.
// lPathFormat - Specifies type of object path.
// Only ADS_PATH_FILE, ADS_PATH_FILESHARE
// and ADS_PATH_REGISTRY are supported.
// lOutFormat - Specifies output SD format.
// pVariant - Return value for SD.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: pVariant is update appropriately.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CADsSecurityUtility::GetSecurityDescriptor(
IN VARIANT varPath,
IN long lPathFormat,
IN OPTIONAL long lOutFormat,
OUT VARIANT *pVariant
)
{
HRESULT hr = S_OK;
PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
DWORD dwLength = 0;
VARIANT *pvPath = NULL;
//
// Make sure the params are correct.
//
if (!pVariant) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
VariantInit(pVariant);
if (lPathFormat < ADS_PATH_FILE
|| lPathFormat > ADS_PATH_REGISTRY
) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
//
// Make sure we handle byRef params correctly.
//
pvPath = &varPath;
if (V_VT(pvPath) == (VT_BYREF|VT_VARIANT)) {
pvPath = V_VARIANTREF(&varPath);
}
//
// For the path to be valid for now, it has to be a string.
//
if (pvPath->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
if (pvPath->bstrVal == NULL) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
if (lOutFormat < ADS_SD_FORMAT_IID
|| lOutFormat > ADS_SD_FORMAT_HEXSTRING
) {
BAIL_ON_FAILURE(hr);
}
//
// Time to get the raw sd from the source.
//
switch (lPathFormat) {
case ADS_PATH_FILE:
hr = GetRawSDFromFile(
pvPath->bstrVal,
_secInfo,
&pSecurityDescriptor,
&dwLength
);
break;
case ADS_PATH_FILESHARE:
hr = GetRawSDFromFileShare(
pvPath->bstrVal,
&pSecurityDescriptor,
&dwLength
);
break;
case ADS_PATH_REGISTRY:
hr = GetRawSDFromRegistry(
pvPath->bstrVal,
_secInfo,
&pSecurityDescriptor,
&dwLength
);
break;
default:
hr = E_INVALIDARG;
break;
} // end of case to read sd.
BAIL_ON_FAILURE(hr);
//
// Now convert the sd to the required format.
//
switch (lOutFormat) {
case ADS_SD_FORMAT_IID:
hr = BinarySDToSecurityDescriptor(
pSecurityDescriptor,
pVariant,
NULL,
NULL,
NULL,
0
);
break;
case ADS_SD_FORMAT_RAW:
hr = ConvertRawSDToBinary(
pSecurityDescriptor,
dwLength,
pVariant
);
break;
case ADS_SD_FORMAT_HEXSTRING:
hr = ConvertRawSDToHexString(
pSecurityDescriptor,
dwLength,
pVariant
);
break;
default:
hr = E_INVALIDARG;
} // end of case for output format.
error:
if (pSecurityDescriptor) {
FreeADsMem(pSecurityDescriptor);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::SetSecurityDescriptor -
// IADsSecurityUtility support.
//
// Synopsis: Sets the security descriptor from the named object.
//
// Arguments: varPath - Path of object to set SD on.
// lPathFormat - Format of path.
// varData - Variant with SD to set.
// lDataFormat - Format of the SD data.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: N/A.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CADsSecurityUtility::SetSecurityDescriptor(
IN VARIANT varPath,
IN long lPathFormat,
IN VARIANT varData,
IN long lDataFormat
)
{
HRESULT hr = E_INVALIDARG;
VARIANT *pvPath = NULL;
VARIANT *pvData = NULL;
PSECURITY_DESCRIPTOR pSD = NULL;
DWORD dwLength = 0;
if ((lPathFormat < ADS_PATH_FILE)
|| (lPathFormat > ADS_PATH_REGISTRY)
|| (lDataFormat < ADS_SD_FORMAT_IID)
|| (lDataFormat > ADS_SD_FORMAT_HEXSTRING)
) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
//
// Make sure we handle byRef params correctly.
//
pvPath = &varPath;
if (V_VT(pvPath) == (VT_BYREF | VT_VARIANT)) {
pvPath = V_VARIANTREF(&varPath);
}
pvData = &varData;
if (V_VT(pvData) == (VT_BYREF | VT_VARIANT)) {
pvData = V_VARIANTREF(&varData);
}
//
// Find out what format the SD is in and convert to raw binary
// format as that is what we need to set.
//
switch (lDataFormat) {
case ADS_SD_FORMAT_IID:
hr = SecurityDescriptorToBinarySD(
*pvData,
&pSD,
&dwLength,
NULL,
NULL,
NULL,
0
);
break;
case ADS_SD_FORMAT_HEXSTRING:
if (V_VT(pvData) == VT_BSTR) {
hr = ConvertHexSDToRawSD(
pvData,
&pSD,
&dwLength
);
}
break;
case ADS_SD_FORMAT_RAW:
if (V_VT(pvData) == (VT_UI1 | VT_ARRAY)) {
hr = ConvertBinarySDToRawSD(
pvData,
&pSD,
&dwLength
);
}
default:
hr = E_INVALIDARG;
break;
} // end switch type of input data.
//
// This will catch conversion failures as well as bad params.
//
BAIL_ON_FAILURE(hr);
//
// For now the path has to be a string.
//
if (pvPath->vt != VT_BSTR) {
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
switch (lPathFormat) {
case ADS_PATH_FILE:
hr = SetRawSDToFile(
pvPath->bstrVal,
_secInfo,
pSD
);
break;
case ADS_PATH_FILESHARE:
hr = SetRawSDToFileShare(
pvPath->bstrVal,
pSD
);
break;
case ADS_PATH_REGISTRY:
hr = SetRawSDToRegistry(
pvPath->bstrVal,
_secInfo,
pSD
);
break;
default:
hr = E_INVALIDARG;
break;
}
BAIL_ON_FAILURE(hr);
error:
if (pSD) {
FreeADsMem(pSD);
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
// Function: CADsSecurityUtility::ConvertSecurityDescriptor -
// IADsSecurityUtility method.
//
// Synopsis: Converts the input SD to the appropriate format requested.
//
// Arguments: varData - Input SD to convert.
// lDataFormat - Input SD format.
// loutFormat - Format of output SD.
// pvResult - Return value.
//
// Returns: S_OK or any appropriate error code.
//
// Modifies: pvResult with appropriate value.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CADsSecurityUtility::ConvertSecurityDescriptor(
IN VARIANT varData,
IN long lDataFormat,
IN long lOutFormat,
OUT VARIANT *pvResult
)
{
HRESULT hr;
PSECURITY_DESCRIPTOR pSD = NULL;
DWORD dwLenSD;
VARIANT *pVarData = &varData;
if (!pvResult) {
BAIL_ON_FAILURE(hr= E_INVALIDARG);
}
if (V_VT(pVarData) == (VT_BYREF | VT_VARIANT)) {
pVarData = V_VARIANTREF(&varData);
}
//
// We will convert to binary format and then to
// the requested format.
//
switch (lDataFormat) {
case ADS_SD_FORMAT_IID:
hr = SecurityDescriptorToBinarySD(
*pVarData,
&pSD,
&dwLenSD,
NULL,
NULL,
NULL,
0
);
break;
case ADS_SD_FORMAT_RAW :
hr = ConvertBinarySDToRawSD(
pVarData,
&pSD,
&dwLenSD
);
break;
case ADS_SD_FORMAT_HEXSTRING:
hr = ConvertHexSDToRawSD(
pVarData,
&pSD,
&dwLenSD
);
break;
default:
hr = E_INVALIDARG;
break;
}
BAIL_ON_FAILURE(hr);
//
// Convert to the requested format.
//
switch (lOutFormat) {
case ADS_SD_FORMAT_IID:
hr = BinarySDToSecurityDescriptor(
pSD,
pvResult,
NULL,
NULL,
NULL,
0
);
break;
case ADS_SD_FORMAT_RAW:
hr = ConvertRawSDToBinary(
pSD,
dwLenSD,
pvResult
);
break;
case ADS_SD_FORMAT_HEXSTRING:
hr = ConvertRawSDToHexString(
pSD,
dwLenSD,
pvResult
);
break;
default:
hr = E_INVALIDARG;
break;
}
error:
if (pSD) {
FreeADsMem(pSD);
}
RRETURN(hr);
}
STDMETHODIMP
CADsSecurityUtility::put_SecurityMask(
long lSecurityMask
)
{
_secInfo = (SECURITY_INFORMATION) lSecurityMask;
RRETURN(S_OK);
}
STDMETHODIMP
CADsSecurityUtility::get_SecurityMask(
long *plSecurityMask
)
{
if (!plSecurityMask) {
RRETURN(E_INVALIDARG);
}
*plSecurityMask = (long) _secInfo;
RRETURN(S_OK);
}
Reference in a new issue Copy permalink