Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1077 lines
38 KiB

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997-2001.
//
// File: cmponent.cpp
//
// Contents: Implementation of CCertMgrComponent
//
//----------------------------------------------------------------------------
#include "stdafx.h"
#include <gpedit.h>
#include "compdata.h" // CCertMgrComponentData
#include "cmponent.h" // CCertMgrComponent
#include "SaferLevel.h"
#include "SaferEntry.h"
#include "storeGPE.h"
#include "SaferUtil.h"
#include "PolicyKey.h"
#ifdef _DEBUG
#ifndef ALPHA
#define new DEBUG_NEW
#endif
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
HKEY g_hkeyLastSaferRegistryScope = 0;
extern PCWSTR pcszNEWLINE;
HRESULT CCertMgrComponent::AddSaferLevels(
bool bIsComputer,
PCWSTR pszServerName,
HKEY hGroupPolicyKey)
{
_TRACE (1, L"Entering CCertMgrComponent::AddSaferLevels ()\n");
HRESULT hr = S_OK;
CWaitCursor cursor;
CCertMgrComponentData& dataRef = QueryComponentDataRef ();
if ( dataRef.m_pdwSaferLevels )
{
for (UINT nIndex = 0;
NO_MORE_SAFER_LEVELS != dataRef.m_pdwSaferLevels[nIndex] && SUCCEEDED (hr);
nIndex++)
{
CString szLevel;
switch (dataRef.m_pdwSaferLevels[nIndex])
{
case SAFER_LEVELID_FULLYTRUSTED:
case SAFER_LEVELID_CONSTRAINED:
case SAFER_LEVELID_DISALLOWED:
case SAFER_LEVELID_NORMALUSER:
case SAFER_LEVELID_UNTRUSTED:
szLevel = SaferGetLevelFriendlyName (dataRef.m_pdwSaferLevels[nIndex],
hGroupPolicyKey, bIsComputer);
hr = AddLevel (szLevel, dataRef.m_pdwSaferLevels[nIndex],
bIsComputer,
pszServerName);
break;
default:
ASSERT (0);
_TRACE (0, L"Unexpected safer level while enumerating levels: 0x%x\n",
dataRef.m_pdwSaferLevels[nIndex]);
break;
}
}
}
else
hr = E_FAIL;
_TRACE (-1, L"Leaving CCertMgrComponent::AddSaferLevels (): 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::AddLevel (
const CString& szLevel,
DWORD dwLevel,
bool fIsMachine,
PCWSTR pszServerName)
{
_TRACE (1, L"Entering CCertMgrComponent::AddLevel ()\n");
HRESULT hr = S_OK;
CCertMgrComponentData& dataRef = QueryComponentDataRef ();
CCookie& rootCookie = dataRef.QueryBaseRootCookie ();
RESULTDATAITEM rdItem;
::ZeroMemory (&rdItem, sizeof (rdItem));
rdItem.mask = RDI_STR | RDI_PARAM | RDI_IMAGE;
rdItem.nCol = 0;
CSaferLevel* pNewLevel = new CSaferLevel (
dwLevel,
fIsMachine,
pszServerName,
szLevel,
dataRef.m_pGPEInformation,
fIsMachine ?
dataRef.m_rsopObjectArrayComputer :
dataRef.m_rsopObjectArrayUser);
if ( pNewLevel )
{
if ( pNewLevel->IsDefault () )
{
rdItem.nImage = iIconDefaultSaferLevel;
dataRef.m_dwDefaultSaferLevel = pNewLevel->GetLevel ();
}
else
rdItem.nImage = iIconSaferLevel;
rootCookie.m_listResultCookieBlocks.AddHead (pNewLevel);
rdItem.str = MMC_TEXTCALLBACK ;
rdItem.lParam = (LPARAM) pNewLevel;
pNewLevel->m_resultDataID = m_pResultData;
hr = m_pResultData->InsertItem (&rdItem);
if ( FAILED (hr) )
{
_TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
}
}
else
{
hr = E_OUTOFMEMORY;
}
_TRACE (-1, L"Leaving CCertMgrComponent::AddLevel () : 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::SaferEnumerateEntries (
bool bIsComputer,
CSaferEntries* pSaferEntries)
{
if ( !pSaferEntries )
return E_POINTER;
_TRACE (1, L"Entering CCertMgrComponent::SaferEnumerateEntries ()\n");
HRESULT hr = S_OK;
CCertMgrComponentData& dataRef = QueryComponentDataRef ();
if ( dataRef.m_pGPEInformation )
{
CPolicyKey policyKey (dataRef.m_pGPEInformation,
SAFER_HKLM_REGBASE,
bIsComputer);
hr = SetRegistryScope (policyKey.GetKey (), bIsComputer);
if ( SUCCEEDED (hr) )
{
hr = SaferEnumerateNonCertEntries (policyKey.GetKey (),
bIsComputer);
hr = SaferEnumerateCertEntries (
bIsComputer,
pSaferEntries);
}
}
else if ( dataRef.m_bIsRSOP )
{
hr = SaferEnumerateRSOPNonCertEntries (bIsComputer, pSaferEntries);
hr = SaferEnumerateCertEntries (bIsComputer,
pSaferEntries);
}
else
hr = E_UNEXPECTED;
_TRACE (-1, L"Leaving CCertMgrComponent::SaferEnumerateEntries () : 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::SaferEnumerateRSOPNonCertEntries (
bool bIsComputer,
CSaferEntries* pSaferEntries)
{
if ( !pSaferEntries )
return E_POINTER;
_TRACE (1, L"Entering CCertMgrComponent::SaferEnumerateRSOPNonCertEntries\n");
HRESULT hr = S_OK;
int nIndex = 0;
CCertMgrComponentData& dataRef = QueryComponentDataRef ();
CString szKeyStart (SAFER_HKLM_REGBASE);
const CRSOPObjectArray* pObjectArray = bIsComputer ?
dataRef.GetRSOPObjectArrayComputer () : dataRef.GetRSOPObjectArrayUser ();
INT_PTR nUpperBound = pObjectArray->GetUpperBound ();
szKeyStart += L"\\";
szKeyStart += SAFER_CODEIDS_REGSUBKEY;
size_t nKeyStartLen = wcslen (szKeyStart);
// Skip the common text and get the level
long dwLevel = 0;
long dwPreviousLevel = 0;
CString szLevel;
CString szType; // hash, url, path
SAFER_ENTRY_TYPE type = SAFER_ENTRY_TYPE_UNKNOWN; // hash, url, path
SAFER_ENTRY_TYPE previousType = SAFER_ENTRY_TYPE_UNKNOWN;
CString szGUID;
GUID guid;
::ZeroMemory (&guid, sizeof (GUID));
bool bCreateNew = false;
PSAFER_IDENTIFICATION_HEADER pCaiCommon = 0;
CString szPreviousKey;
CString szKey;
CRSOPObject* pCurrObject = 0;
while ( nUpperBound >= nIndex )
{
if ( pCurrObject )
szPreviousKey = pCurrObject->GetRegistryKey ();
pCurrObject = pObjectArray->GetAt (nIndex);
if ( pCurrObject )
{
szKey = pCurrObject->GetRegistryKey ();
if ( !wcsncmp (szKey, szKeyStart, nKeyStartLen) )
{
szKey = szKey.Right ((int) (wcslen (szKey) - (nKeyStartLen + 1)));
if ( !szKey.IsEmpty () )
{
// get level
int nPos = szKey.Find (L'\\');
szLevel = szKey.Left (nPos);
dwPreviousLevel = dwLevel;
dwLevel = wcstol(szLevel, 0, 10);
szKey = szKey.Right ((int)(wcslen (szKey) - (nPos + 1)));
// get type
nPos = szKey.Find (L'\\');
szType = szKey.Left (nPos);
if ( SAFER_PATHS_REGSUBKEY == szType )
type = SAFER_ENTRY_TYPE_PATH;
else if ( SAFER_HASHMD5_REGSUBKEY == szType )
type = SAFER_ENTRY_TYPE_HASH;
else if ( SAFER_SOURCEURL_REGSUBKEY == szType )
type = SAFER_ENTRY_TYPE_URLZONE;
else
{
ASSERT (0);
}
if ( SAFER_ENTRY_TYPE_UNKNOWN == previousType )
previousType = type;
szKey = szKey.Right ((int) (wcslen (szKey) - (nPos + 1)));
// get guid
if ( szKey != szGUID )
{
szGUID = szKey;
if ( !GuidFromString (&guid, szGUID) )
continue;
bCreateNew = true;
}
else
bCreateNew = false;
if ( bCreateNew && pCaiCommon )
{
// If we were working on an old one, create the
// CSaferEntry with the available information and add
// it to the result pane
hr = SaferFinishEntryAndAdd (previousType, pCaiCommon,
bIsComputer, dwPreviousLevel, pSaferEntries,
szPreviousKey);
if ( SUCCEEDED (hr) )
{
pCaiCommon = 0;
}
else if ( E_OUTOFMEMORY == hr )
{
::LocalFree (pCaiCommon);
pCaiCommon = 0;
}
previousType = type;
}
switch (type)
{
case SAFER_ENTRY_TYPE_PATH:
if ( bCreateNew )
{
ASSERT (!pCaiCommon);
pCaiCommon = (PSAFER_IDENTIFICATION_HEADER)
::LocalAlloc (LPTR, sizeof (SAFER_PATHNAME_IDENTIFICATION));
if ( pCaiCommon )
{
((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->header.cbStructSize =
sizeof (SAFER_PATHNAME_IDENTIFICATION);
memcpy (&((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->header.IdentificationGuid,
&guid, sizeof (GUID));
((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->header.dwIdentificationType =
SaferIdentityTypeImageName;
}
else
hr = E_OUTOFMEMORY;
}
if ( SUCCEEDED (hr) && pCaiCommon )
{
if ( SAFER_IDS_DESCRIPTION_REGVALUE == pCurrObject->GetValueName () )
{
BSTR bstr = 0;
if ( SUCCEEDED (pCurrObject->GetBSTR (&bstr)) )
{
wcsncpy (((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->Description,
bstr,
SAFER_MAX_DESCRIPTION_SIZE);
SysFreeString (bstr);
}
}
else if ( SAFER_IDS_ITEMDATA_REGVALUE == pCurrObject->GetValueName () )
{
ASSERT ( MAX_PATH * sizeof (WCHAR) >= pCurrObject->GetBlobLength ());
((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->ImageName =
(PWCHAR) pCurrObject->GetBlob ();
}
else if ( SAFER_IDS_LASTMODIFIED_REGVALUE == pCurrObject->GetValueName () )
{
pCurrObject->GetFileTime (
((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->header.lastModified);
}
else if ( SAFER_IDS_SAFERFLAGS_REGVALUE == pCurrObject->GetValueName () )
{
((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->dwSaferFlags =
pCurrObject->GetDWORDValue ();
}
}
break;
case SAFER_ENTRY_TYPE_HASH:
if ( bCreateNew )
{
ASSERT (!pCaiCommon);
pCaiCommon = (PSAFER_IDENTIFICATION_HEADER)
::LocalAlloc (LPTR, sizeof (SAFER_HASH_IDENTIFICATION));
if ( pCaiCommon )
{
((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->header.cbStructSize =
sizeof (SAFER_HASH_IDENTIFICATION);
memcpy (&((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->header.IdentificationGuid,
&guid, sizeof (GUID));
((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->header.dwIdentificationType =
SaferIdentityTypeImageHash;
// NTRAID# 424997 SAFER: File hash not displayed on hash rule property sheets in RSOP mode.
((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->HashSize = 16;
}
else
hr = E_OUTOFMEMORY;
}
if ( SUCCEEDED (hr) && pCaiCommon && !pCurrObject->GetValueName ().IsEmpty () )
{
if ( SAFER_IDS_ITEMDATA_REGVALUE == pCurrObject->GetValueName () )
{
ASSERT (SAFER_MAX_HASH_SIZE >= pCurrObject->GetBlobLength ());
memcpy (&((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->ImageHash,
pCurrObject->GetBlob (),
pCurrObject->GetBlobLength ());
}
else if ( SAFER_IDS_LASTMODIFIED_REGVALUE == pCurrObject->GetValueName () )
{
pCurrObject->GetFileTime (
((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->header.lastModified);
}
else if ( SAFER_IDS_SAFERFLAGS_REGVALUE == pCurrObject->GetValueName () )
{
((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->dwSaferFlags =
pCurrObject->GetDWORDValue ();
}
else if ( SAFER_IDS_FRIENDLYNAME_REGVALUE == pCurrObject->GetValueName () )
{
BSTR bstr = 0;
if ( SUCCEEDED (pCurrObject->GetBSTR (&bstr)) )
{
wcsncpy (((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->FriendlyName,
bstr,
SAFER_MAX_FRIENDLYNAME_SIZE);
SysFreeString (bstr);
}
}
else if ( SAFER_IDS_HASHALG_REGVALUE == pCurrObject->GetValueName () )
{
ASSERT (sizeof (ALG_ID) == pCurrObject->GetBlobLength ()); memcpy (&((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->HashAlgorithm,
pCurrObject->GetBlob (),
pCurrObject->GetBlobLength ());
}
else if ( SAFER_IDS_ITEMSIZE_REGVALUE == pCurrObject->GetValueName () )
{
ASSERT (sizeof (LARGE_INTEGER) == pCurrObject->GetBlobLength ());
memcpy (&((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->ImageSize,
pCurrObject->GetBlob (),
pCurrObject->GetBlobLength ());
}
else if ( SAFER_IDS_DESCRIPTION_REGVALUE == pCurrObject->GetValueName () )
{
BSTR bstr = 0;
if ( SUCCEEDED (pCurrObject->GetBSTR (&bstr)) )
{
wcsncpy (((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->Description,
bstr,
SAFER_MAX_DESCRIPTION_SIZE);
SysFreeString (bstr);
}
}
else if ( SAFER_VALUE_NAME_HASH_SIZE == pCurrObject->GetValueName () )
{
ASSERT (sizeof (LARGE_INTEGER) == pCurrObject->GetBlobLength ());
memcpy (&((SAFER_HASH_IDENTIFICATION*)pCaiCommon)->HashSize,
pCurrObject->GetBlob (),
pCurrObject->GetBlobLength ());
}
}
break;
case SAFER_ENTRY_TYPE_URLZONE:
if ( bCreateNew )
{
ASSERT (!pCaiCommon);
pCaiCommon = (PSAFER_IDENTIFICATION_HEADER)
::LocalAlloc (LPTR, sizeof (SAFER_URLZONE_IDENTIFICATION));
if ( pCaiCommon )
{
((SAFER_URLZONE_IDENTIFICATION*)pCaiCommon)->header.cbStructSize =
sizeof (SAFER_URLZONE_IDENTIFICATION);
memcpy (&((SAFER_URLZONE_IDENTIFICATION*)pCaiCommon)->header.IdentificationGuid,
&guid, sizeof (GUID));
((SAFER_URLZONE_IDENTIFICATION*)pCaiCommon)->header.dwIdentificationType =
SaferIdentityTypeUrlZone;
}
else
hr = E_OUTOFMEMORY;
}
if ( SUCCEEDED (hr) && pCaiCommon )
{
if ( SAFER_IDS_ITEMDATA_REGVALUE == pCurrObject->GetValueName () )
{
memcpy (&((SAFER_URLZONE_IDENTIFICATION*)pCaiCommon)->UrlZoneId,
pCurrObject->GetBlob (),
pCurrObject->GetBlobLength ());
#if DBG
SAFER_URLZONE_IDENTIFICATION* pCaiUrlZone =
(SAFER_URLZONE_IDENTIFICATION*) pCaiCommon;
ASSERT (URLZONE_LOCAL_MACHINE == pCaiUrlZone->UrlZoneId ||
URLZONE_INTRANET == pCaiUrlZone->UrlZoneId ||
URLZONE_TRUSTED == pCaiUrlZone->UrlZoneId ||
URLZONE_INTERNET == pCaiUrlZone->UrlZoneId ||
URLZONE_UNTRUSTED == pCaiUrlZone->UrlZoneId);
#endif DBG
}
else if ( SAFER_IDS_LASTMODIFIED_REGVALUE == pCurrObject->GetValueName () )
{
pCurrObject->GetFileTime (
((SAFER_URLZONE_IDENTIFICATION*)pCaiCommon)->header.lastModified);
}
else if ( SAFER_IDS_SAFERFLAGS_REGVALUE == pCurrObject->GetValueName () )
{
((SAFER_URLZONE_IDENTIFICATION*)pCaiCommon)->dwSaferFlags =
pCurrObject->GetDWORDValue ();
}
}
break;
default:
ASSERT (0);
break;
}
}
}
}
else
break;
nIndex++;
}
if ( pCaiCommon )
{
// If we were working on an old one, create the
// CSaferEntry with the available information and add
// it to the result pane
hr = SaferFinishEntryAndAdd (previousType, pCaiCommon,
bIsComputer, dwLevel, pSaferEntries,
szPreviousKey);
if ( SUCCEEDED (hr) )
{
pCaiCommon = 0;
}
else if ( E_OUTOFMEMORY == hr )
{
::LocalFree (pCaiCommon);
pCaiCommon = 0;
}
}
_TRACE (-1, L"Leaving CCertMgrComponent::SaferEnumerateRSOPNonCertEntries: 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::SaferFinishEntryAndAdd (SAFER_ENTRY_TYPE previousType,
PSAFER_IDENTIFICATION_HEADER pCaiCommon,
bool bIsComputer,
long dwLevel,
CSaferEntries* pSaferEntries,
const CString& szPreviousKey)
{
HRESULT hr = S_OK;
CString szSubjectName;
switch (previousType)
{
case SAFER_ENTRY_TYPE_PATH:
szSubjectName = ((SAFER_PATHNAME_IDENTIFICATION*)pCaiCommon)->ImageName;
break;
case SAFER_ENTRY_TYPE_HASH:
szSubjectName = ((PSAFER_HASH_IDENTIFICATION) (pCaiCommon))->FriendlyName;
szSubjectName.Replace (pcszNEWLINE, L" ");
break;
case SAFER_ENTRY_TYPE_URLZONE:
szSubjectName = GetURLZoneFriendlyName (
((SAFER_URLZONE_IDENTIFICATION*) pCaiCommon)->UrlZoneId);
break;
default:
ASSERT (0);
break;
}
ASSERT (pCaiCommon);
if ( pCaiCommon )
{
hr = InsertNewSaferEntry (
previousType,
bIsComputer,
szSubjectName,
pCaiCommon,
dwLevel,
pSaferEntries,
QueryComponentDataRef ().m_pGPEInformation,
0,
szPreviousKey);
}
return hr;
}
HRESULT CCertMgrComponent::InsertNewSaferEntry (
SAFER_ENTRY_TYPE type,
bool bIsComputer,
PCWSTR pwcszObjectName,
PSAFER_IDENTIFICATION_HEADER pCaiCommon,
DWORD dwLevel,
CSaferEntries* pSaferEntries,
IGPEInformation* pGPEInformation,
CCertificate* pCert,
PCWSTR pszRSOPRegistryKey)
{
_TRACE (1, L"Entering CCertMgrComponent::InsertNewSaferEntry (%s)\n", pwcszObjectName);
HRESULT hr = S_OK;
switch (type)
{
case SAFER_ENTRY_TYPE_PATH:
ASSERT (pCaiCommon &&
SaferIdentityTypeImageName == pCaiCommon->dwIdentificationType);
break;
case SAFER_ENTRY_TYPE_HASH:
ASSERT (pCaiCommon &&
SaferIdentityTypeImageHash == pCaiCommon->dwIdentificationType);
break;
case SAFER_ENTRY_TYPE_URLZONE:
ASSERT (pCaiCommon &&
SaferIdentityTypeUrlZone == pCaiCommon->dwIdentificationType);
break;
case SAFER_ENTRY_TYPE_CERT:
ASSERT (pCert);
break;
default:
ASSERT (0);
break;
}
CSaferEntry* pNewEntry = new CSaferEntry (
type,
bIsComputer,
L"",
pwcszObjectName,
pCaiCommon,
dwLevel,
pGPEInformation,
pCert,
pSaferEntries,
bIsComputer ? QueryComponentDataRef ().m_rsopObjectArrayComputer :
QueryComponentDataRef ().m_rsopObjectArrayUser,
pszRSOPRegistryKey);
if ( pNewEntry )
{
RESULTDATAITEM rdItem;
::ZeroMemory (&rdItem, sizeof (rdItem));
rdItem.mask = RDI_STR | RDI_IMAGE | RDI_PARAM;
switch (type)
{
case SAFER_ENTRY_TYPE_HASH:
rdItem.nImage = iIconSaferHashEntry;
break;
case SAFER_ENTRY_TYPE_PATH:
rdItem.nImage = iIconSaferNameEntry;
break;
case SAFER_ENTRY_TYPE_CERT:
rdItem.nImage = iIconSaferCertEntry;
break;
case SAFER_ENTRY_TYPE_URLZONE:
rdItem.nImage = iIconSaferURLEntry;
break;
default:
ASSERT (0);
break;
}
rdItem.nCol = 0;
rdItem.str = MMC_TEXTCALLBACK;
QueryComponentDataRef ().QueryBaseRootCookie ().m_listResultCookieBlocks.AddHead (pNewEntry);
rdItem.lParam = (LPARAM) pNewEntry;
pNewEntry->m_resultDataID = m_pResultData;
hr = m_pResultData->InsertItem (&rdItem);
if ( FAILED (hr) )
{
_TRACE (0, L"IResultData::InsertItem () failed: 0x%x\n", hr);
}
}
else
hr = E_OUTOFMEMORY;
_TRACE (-1, L"Leaving CCertMgrComponent::InsertNewSaferEntry (%s): 0x%x\n", pwcszObjectName, hr);
return hr;
}
HRESULT CCertMgrComponent::SaferEnumerateNonCertEntries (
HKEY hGroupPolicyKey,
bool bIsComputer)
{
_TRACE (1, L"Entering CCertMgrComponent::SaferEnumerateNonCertEntries ()\n");
ASSERT (0 != g_hkeyLastSaferRegistryScope);
HRESULT hr = S_OK;
DWORD* pdwLevels = 0;
DWORD cbBuffer = 0;
SetRegistryScope (hGroupPolicyKey, bIsComputer);
BOOL bRVal = SaferGetPolicyInformation (
SAFER_SCOPEID_REGISTRY,
SaferPolicyLevelList,
cbBuffer,
pdwLevels,
&cbBuffer,
0);
if ( !bRVal && GetLastError () == ERROR_INSUFFICIENT_BUFFER )
{
DWORD nLevels = cbBuffer/sizeof (DWORD);
pdwLevels = new DWORD[nLevels];
if ( pdwLevels )
{
bRVal = SaferGetPolicyInformation (
SAFER_SCOPEID_REGISTRY,
SaferPolicyLevelList,
cbBuffer,
pdwLevels,
&cbBuffer,
0);
ASSERT (bRVal);
if ( bRVal )
{
for (DWORD dwIndex = 0; dwIndex < nLevels; dwIndex++)
{
hr = SaferEnumerateEntriesAtLevel (
bIsComputer,
hGroupPolicyKey,
pdwLevels[dwIndex]);
}
}
else
{
DWORD dwErr = GetLastError ();
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferGetPolicyInformation (SAFER_SCOPEID_REGISTRY, SaferPolicyLevelList) failed: %d\n",
dwErr);
}
delete [] pdwLevels;
}
else
hr = E_OUTOFMEMORY;
}
else if ( !bRVal )
{
ASSERT (0);
DWORD dwErr = GetLastError ();
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferGetPolicyInformation (SAFER_SCOPEID_REGISTRY, SaferPolicyLevelList) failed: %d\n",
dwErr);
}
_TRACE (-1, L"Leaving CCertMgrComponent::SaferEnumerateNonCertEntries (): 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::SaferEnumerateCertEntries (
bool bIsComputer,
CSaferEntries* pSaferEntries)
{
if ( !pSaferEntries )
return E_POINTER;
_TRACE (1, L"Entering CCertMgrComponent::SaferEnumerateCertEntries ()\n");
HRESULT hr = S_OK;
CCertStore* pTrustedPublisherStore = 0;
hr = pSaferEntries->GetTrustedPublishersStore (&pTrustedPublisherStore);
if ( pTrustedPublisherStore )
{
hr = EnumSaferCertificates (
bIsComputer,
*pTrustedPublisherStore,
pSaferEntries);
if ( SUCCEEDED (hr) )
{
m_currResultNodeType = bIsComputer ?
CERTMGR_SAFER_COMPUTER_ENTRY : CERTMGR_SAFER_USER_ENTRY;
m_pResultData->Sort (m_nSelectedSaferEntryColumn, 0,
(long) m_currResultNodeType);
}
pTrustedPublisherStore->Release ();
}
else
hr = E_OUTOFMEMORY;
CCertStore* pDisallowedStore = 0;
hr = pSaferEntries->GetDisallowedStore (&pDisallowedStore);
if ( pDisallowedStore )
{
hr = EnumSaferCertificates (
bIsComputer,
*pDisallowedStore,
pSaferEntries);
if ( SUCCEEDED (hr) )
{
m_currResultNodeType = bIsComputer ?
CERTMGR_SAFER_COMPUTER_ENTRY : CERTMGR_SAFER_USER_ENTRY;
m_pResultData->Sort (m_nSelectedSaferEntryColumn, 0,
(long) m_currResultNodeType);
}
pDisallowedStore->Release ();
}
else
hr = E_OUTOFMEMORY;
_TRACE (-1, L"Leaving CCertMgrComponent::SaferEnumerateCertEntries (): 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::EnumSaferCertificates (
bool bIsComputer,
CCertStore& rCertStore,
CSaferEntries* pSaferEntries)
{
if ( !pSaferEntries )
return E_POINTER;
_TRACE (1, L"Entering CCertMgrComponent::EnumCertificates\n");
CWaitCursor cursor;
PCCERT_CONTEXT pCertContext = 0;
HRESULT hr = 0;
CCertificate* pCert = 0;
DWORD dwLevelID = SAFER_TRUSTED_PUBLISHER_STORE == rCertStore.GetStoreType () ?
SAFER_LEVELID_FULLYTRUSTED : SAFER_LEVELID_DISALLOWED;
// Iterate through the list of certificates in the system store,
// allocate new certificates with the CERT_CONTEXT returned,
// and store them in the certificate list.
while ( 1 )
{
pCertContext = rCertStore.EnumCertificates (pCertContext);
if ( !pCertContext )
break;
pCert =
new CCertificate (pCertContext, &rCertStore);
if ( pCert )
{
hr = InsertNewSaferEntry (SAFER_ENTRY_TYPE_CERT,
bIsComputer,
pCert->GetSubjectName (),
0,
dwLevelID,
pSaferEntries,
QueryComponentDataRef ().m_pGPEInformation,
pCert);
if ( FAILED (hr) )
break;
pCert->Release ();
}
else
{
hr = E_OUTOFMEMORY;
break;
}
}
rCertStore.Close ();
_TRACE (-1, L"Leaving CCertMgrComponent::EnumCertificates: 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::SaferEnumerateEntriesAtLevel (
bool bIsComputer,
HKEY hGroupPolicyKey,
DWORD dwLevel)
{
_TRACE (1, L"Entering CCertMgrComponent::SaferEnumerateEntriesAtLevel (%d)\n", dwLevel);
SetRegistryScope (hGroupPolicyKey, bIsComputer);
HRESULT hr = S_OK;
SAFER_LEVEL_HANDLE hLevel = 0;
BOOL bRVal = SaferCreateLevel (SAFER_SCOPEID_REGISTRY,
dwLevel,
SAFER_LEVEL_OPEN,
&hLevel,
hGroupPolicyKey);
ASSERT (bRVal);
if ( bRVal )
{
DWORD dwBufferSize = 0;
bRVal = SaferGetLevelInformation(hLevel,
SaferObjectAllIdentificationGuids,
0,
dwBufferSize,
&dwBufferSize);
if ( !bRVal && ERROR_INSUFFICIENT_BUFFER == GetLastError () )
{
DWORD nGuids = dwBufferSize/sizeof (GUID);
GUID* pGuids = new GUID[nGuids];
if ( pGuids )
{
bRVal = SaferGetLevelInformation(hLevel,
SaferObjectAllIdentificationGuids,
pGuids,
dwBufferSize,
&dwBufferSize);
ASSERT (bRVal);
if ( bRVal )
{
for (DWORD dwIndex = 0; dwIndex < nGuids; dwIndex++)
{
hr = SaferGetSingleEntry (bIsComputer, hLevel,
pGuids[dwIndex], dwLevel);
}
}
else
{
DWORD dwErr = GetLastError ();
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferGetLevelInformation (SaferObjectAllIdentificationGuids) failed: %d\n",
dwErr);
}
delete [] pGuids;
}
else
hr = E_OUTOFMEMORY;
}
else if ( !bRVal )
{
DWORD dwErr = GetLastError ();
ASSERT (ERROR_NOT_FOUND == dwErr);
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferGetLevelInformation (SaferObjectAllIdentificationGuids) failed: %d\n",
dwErr);
}
VERIFY (SaferCloseLevel (hLevel));
}
else
{
DWORD dwErr = GetLastError ();
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferCreateLevel (SAFER_SCOPEID_REGISTRY, 0x%x, SAFER_LEVEL_OPEN) failed: %d\n",
dwLevel, dwErr);
}
_TRACE (-1, L"Leaving CCertMgrComponent::SaferEnumerateEntriesAtLevel () : 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::SaferGetSingleEntry(
bool bIsComputer,
SAFER_LEVEL_HANDLE hLevel,
GUID &rEntryGuid,
DWORD dwLevelID)
{
_TRACE (1, L"Entering CCertMgrComponent::SaferGetSingleEntry ()\n");
ASSERT (0 != g_hkeyLastSaferRegistryScope);
HRESULT hr = S_OK;
DWORD dwBufferSize = sizeof (SAFER_IDENTIFICATION_HEADER);
SAFER_IDENTIFICATION_HEADER caiCommon;
::ZeroMemory (&caiCommon, sizeof (SAFER_IDENTIFICATION_HEADER));
caiCommon.cbStructSize = dwBufferSize;
memcpy (&caiCommon.IdentificationGuid, &rEntryGuid, sizeof (GUID));
BOOL bRVal = SaferGetLevelInformation(hLevel,
SaferObjectSingleIdentification,
&caiCommon,
dwBufferSize,
&dwBufferSize);
if ( !bRVal && ERROR_INSUFFICIENT_BUFFER == GetLastError () )
{
PBYTE pBytes = (PBYTE) LocalAlloc (LPTR, dwBufferSize);
if ( pBytes )
{
SAFER_ENTRY_TYPE saferEntryType = SAFER_ENTRY_TYPE_UNKNOWN;
PSAFER_IDENTIFICATION_HEADER pCommon = (PSAFER_IDENTIFICATION_HEADER) pBytes;
pCommon->cbStructSize = dwBufferSize;
memcpy (&pCommon->IdentificationGuid, &rEntryGuid, sizeof (GUID));
bRVal = SaferGetLevelInformation(hLevel,
SaferObjectSingleIdentification,
pBytes,
dwBufferSize,
&dwBufferSize);
ASSERT (bRVal);
if ( bRVal )
{
CString szObjectName;
switch (pCommon->dwIdentificationType)
{
case SaferIdentityTypeImageName:
szObjectName = ((PSAFER_PATHNAME_IDENTIFICATION) (pCommon))->ImageName;
saferEntryType = SAFER_ENTRY_TYPE_PATH;
break;
case SaferIdentityTypeImageHash:
szObjectName = ((PSAFER_HASH_IDENTIFICATION) (pCommon))->FriendlyName;
// replace new-line characters with spaces
szObjectName.Replace (pcszNEWLINE, L" ");
saferEntryType = SAFER_ENTRY_TYPE_HASH;
break;
case SaferIdentityTypeUrlZone:
szObjectName = GetURLZoneFriendlyName (
((PSAFER_URLZONE_IDENTIFICATION) (pCommon))->UrlZoneId);
saferEntryType = SAFER_ENTRY_TYPE_URLZONE;
break;
default:
ASSERT (0);
break;
}
hr = InsertNewSaferEntry (
saferEntryType,
bIsComputer,
szObjectName,
pCommon,
dwLevelID,
0,
QueryComponentDataRef ().m_pGPEInformation,
0);
if ( E_OUTOFMEMORY == hr )
::LocalFree (pBytes);
}
else
{
DWORD dwErr = GetLastError ();
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferGetLevelInformation (SaferObjectSingleIdentification) failed: %d\n",
dwErr);
}
// pBytes is freed in ~CSaferEntry
}
else
hr = E_OUTOFMEMORY;
}
else if ( !bRVal )
{
ASSERT (0);
DWORD dwErr = GetLastError ();
hr = HRESULT_FROM_WIN32 (dwErr);
_TRACE (0, L"SaferGetLevelInformation (SaferObjectSingleIdentification) failed: %d\n",
dwErr);
}
_TRACE (-1, L"Leaving CCertMgrComponent::SaferGetSingleEntry (): 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::DeleteSaferEntryFromResultPane (
CSaferEntry * pSaferEntry,
LPDATAOBJECT pDataObject,
bool bDoCommit)
{
_TRACE (1, L"Entering CCertMgrComponent::DeleteSaferEntryFromResultPane\n");
HRESULT hr = S_OK;
hr = pSaferEntry->Delete (bDoCommit);
if ( SUCCEEDED (hr) )
{
HRESULTITEM itemID = 0;
hr = m_pResultData->FindItemByLParam ( (LPARAM) pSaferEntry, &itemID);
if ( SUCCEEDED (hr) )
{
hr = m_pResultData->DeleteItem (itemID, 0);
}
// If we can't succeed in removing this one item, then update the whole panel.
if ( !SUCCEEDED (hr) )
{
hr = m_pConsole->UpdateAllViews (pDataObject, 0, 0);
}
}
else
{
CString text;
CString caption;
VERIFY (caption.LoadString (IDS_SAFER_WINDOWS_NODE_NAME));
text.FormatMessage (IDS_CANT_DELETE_SAFER_ENTRY, GetSystemMessage (hr));
int iRetVal = 0;
VERIFY (SUCCEEDED (m_pConsole->MessageBox (text, caption,
MB_OK, &iRetVal)));
}
_TRACE (-1, L"Leaving CCertMgrComponent::DeleteSaferEntryFromResultPane: 0x%x\n", hr);
return hr;
}
HRESULT CCertMgrComponent::OnNotifyCanPasteOutOfProc (LPBOOL pbCanHandle)
{
if ( !pbCanHandle )
return E_POINTER;
CCertMgrComponentData& dataRef = QueryComponentDataRef ();
CLSID clsID;
if ( SUCCEEDED (dataRef.GetClassID (&clsID)) )
{
if ( CLSID_SaferWindowsExtension == clsID )
*pbCanHandle = TRUE;
}
return S_OK; // snapins should redefine this
}