|
|
//+---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 2000-2001.
//
// File: SaferEntry.cpp
//
// Contents: Implementation of CSaferEntry
//
//----------------------------------------------------------------------------
#include "stdafx.h"
#include <gpedit.h>
#include "SaferEntry.h"
#include "PolicyKey.h"
#include "SaferLevel.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;#endif
extern HKEY g_hkeyLastSaferRegistryScope;const DWORD AUTHZ_UNKNOWN_LEVEL = 0xFFFFFFFF;extern GUID g_guidExtension;extern GUID g_guidRegExt;extern GUID g_guidSnapin;extern PCWSTR pcszNEWLINE;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CSaferEntry::CSaferEntry ( SAFER_ENTRY_TYPE saferEntryType, bool bIsMachine, PCWSTR pszMachineName, PCWSTR pszObjectName, PSAFER_IDENTIFICATION_HEADER pAuthzInfo, DWORD dwLevelID, IGPEInformation* pGPEInformation, CCertificate* pCertificate, CSaferEntries* pSaferEntries, CRSOPObjectArray& rRSOPArray, PCWSTR pszRSOPRegistryKey): CCertMgrCookie (bIsMachine ? CERTMGR_SAFER_COMPUTER_ENTRY : CERTMGR_SAFER_USER_ENTRY, pszMachineName, pszObjectName), m_pAuthzInfo (pAuthzInfo), m_dwLevelID (dwLevelID), m_dwOriginalLevelID (dwLevelID), m_pCertificate (pCertificate), m_pSaferEntries (pSaferEntries), m_pGPEInformation (pGPEInformation), m_saferEntryType (saferEntryType), m_dwFlags (0), m_bDeleted (false), m_cbFileHash (0), m_UrlZoneId (0), m_szRSOPRegistryKey (pszRSOPRegistryKey), m_hashAlgid (0), m_bIsComputer (bIsMachine){ ::ZeroMemory (&m_nHashFileSize, sizeof (__int64)); ::ZeroMemory (m_rgbFileHash, SAFER_MAX_HASH_SIZE);
m_szDisplayName = pszObjectName;
if ( m_pCertificate ) m_pCertificate->AddRef ();
if ( m_pSaferEntries ) m_pSaferEntries->AddRef ();
if ( m_pGPEInformation ) { m_pGPEInformation->AddRef ();
CPolicyKey policyKey (m_pGPEInformation, SAFER_HKLM_REGBASE, bIsMachine);
if ( AUTHZ_UNKNOWN_LEVEL == m_dwLevelID ) { // Bug 264556 Set better Security level defaults for new Safer rules
m_dwLevelID = CSaferLevel::ReturnDefaultLevel ( m_pGPEInformation, m_bIsComputer, rRSOPArray); if ( SAFER_LEVELID_FULLYTRUSTED == m_dwLevelID ) m_dwLevelID = SAFER_LEVELID_DISALLOWED; else m_dwLevelID = SAFER_LEVELID_FULLYTRUSTED; } m_szLevelFriendlyName = SaferGetLevelFriendlyName (m_dwLevelID, policyKey.GetKey (), m_bIsComputer); } else { m_szLevelFriendlyName = SaferGetLevelFriendlyName (m_dwLevelID, 0, m_bIsComputer); }
if ( SAFER_ENTRY_TYPE_URLZONE == m_saferEntryType ) { if ( m_pAuthzInfo ) { ASSERT (SaferIdentityTypeUrlZone == m_pAuthzInfo->dwIdentificationType); PSAFER_URLZONE_IDENTIFICATION pURLEntry = reinterpret_cast <PSAFER_URLZONE_IDENTIFICATION> (m_pAuthzInfo); ASSERT (pURLEntry->header.cbStructSize == sizeof (SAFER_URLZONE_IDENTIFICATION)); m_UrlZoneId = pURLEntry->UrlZoneId; } else { // This is a new entry
m_UrlZoneId = URLZONE_TRUSTED; } }}
CSaferEntry::~CSaferEntry(){ if ( m_pAuthzInfo ) LocalFree (m_pAuthzInfo); if ( m_pCertificate ) m_pCertificate->Release (); if ( m_pSaferEntries ) m_pSaferEntries->Release (); if ( m_pGPEInformation ) m_pGPEInformation->Release ();}
CString CSaferEntry::GetDescription(){ AFX_MANAGE_STATE(AfxGetStaticModuleState()); CString szDescription;
if ( SAFER_ENTRY_TYPE_URLZONE == m_saferEntryType ) { switch (m_UrlZoneId) { case URLZONE_LOCAL_MACHINE: VERIFY (szDescription.LoadString (IDS_URLZONE_LOCAL_MACHINE_DESCRIPTION)); break;
case URLZONE_INTRANET: VERIFY (szDescription.LoadString (IDS_URLZONE_INTRANET_DESCRIPTION)); break;
case URLZONE_TRUSTED: VERIFY (szDescription.LoadString (IDS_URLZONE_TRUSTED_DESCRIPTION)); break;
case URLZONE_INTERNET: VERIFY (szDescription.LoadString (IDS_URLZONE_INTERNET_DESCRIPTION)); break;
case URLZONE_UNTRUSTED: VERIFY (szDescription.LoadString (IDS_URLZONE_UNTRUSTED_DESCRIPTION)); break;
default: ASSERT (0); break; } } else if ( m_pAuthzInfo ) { switch (m_pAuthzInfo->dwIdentificationType) { case SaferIdentityTypeImageName: { PSAFER_PATHNAME_IDENTIFICATION pNameEntry = (PSAFER_PATHNAME_IDENTIFICATION) m_pAuthzInfo; ASSERT (pNameEntry->header.cbStructSize >= sizeof (SAFER_PATHNAME_IDENTIFICATION)); szDescription = pNameEntry->Description; } break;
case SaferIdentityTypeImageHash: { PSAFER_HASH_IDENTIFICATION pHashEntry = (PSAFER_HASH_IDENTIFICATION) m_pAuthzInfo; ASSERT (pHashEntry->header.cbStructSize == sizeof (SAFER_HASH_IDENTIFICATION)); szDescription = pHashEntry->Description; } break;
case SaferIdentityTypeUrlZone: ASSERT (0); break;
default: ASSERT (0); break; } } else if ( m_pCertificate ) { // Is certificate
szDescription = m_pCertificate->GetDescription (); }
m_szDescription = szDescription; return szDescription;}
SAFER_ENTRY_TYPE CSaferEntry::GetType () const{ return m_saferEntryType;}
CString CSaferEntry::GetTypeString() const{ AFX_MANAGE_STATE(AfxGetStaticModuleState()); CString szType; switch (m_saferEntryType) { case SAFER_ENTRY_TYPE_PATH: VERIFY (szType.LoadString (IDS_CodeIdentityType_ImageName)); break;
case SAFER_ENTRY_TYPE_HASH: VERIFY (szType.LoadString (IDS_CodeIdentityType_ImageHash)); break;
case SAFER_ENTRY_TYPE_URLZONE: VERIFY (szType.LoadString (IDS_CodeIdentityType_UrlZone)); break;
case SAFER_ENTRY_TYPE_CERT: VERIFY (szType.LoadString (IDS_CodeIdentityType_Certificate)); break;
default: ASSERT (0); break; }
return szType;}
CString CSaferEntry::GetLevelFriendlyName() const{ return m_szLevelFriendlyName;}
CString CSaferEntry::GetShortLastModified() const{ CString szDate;
if ( m_pAuthzInfo ) { VERIFY (SUCCEEDED (FormatDate (m_pAuthzInfo->lastModified, szDate, DATE_SHORTDATE, true)) ); } else if ( m_pCertificate ) { szDate = m_pCertificate->GetShortLastModified (); }
return szDate;}
CString CSaferEntry::GetLongLastModified() const{ CString szDate;
if ( m_pAuthzInfo ) { VERIFY (SUCCEEDED (FormatDate (m_pAuthzInfo->lastModified, szDate, DATE_LONGDATE, true)) ); } else if ( m_pCertificate ) { szDate = m_pCertificate->GetLongLastModified (); }
return szDate;}
HRESULT CSaferEntry::GetCertificate(CCertificate **ppCert){ ASSERT (ppCert); if ( !ppCert ) return E_POINTER;
if ( !m_pCertificate ) return E_NOTIMPL;
*ppCert = m_pCertificate; m_pCertificate->AddRef ();
return S_OK;}
HRESULT CSaferEntry::SetCertificate(CCertificate *pCert){ ASSERT (m_pSaferEntries); if ( !m_pSaferEntries ) return E_FAIL;
HRESULT hr = S_OK; CCertStore* pStore = 0;
switch (m_dwLevelID) { case SAFER_LEVELID_FULLYTRUSTED: hr = m_pSaferEntries->GetTrustedPublishersStore (&pStore); break;
case SAFER_LEVELID_DISALLOWED: hr = m_pSaferEntries->GetDisallowedStore (&pStore); break;
default: hr = E_FAIL; break; }
if ( SUCCEEDED (hr) ) { if ( m_pCertificate ) { m_pCertificate->DeleteFromStore (false); m_pCertificate->Release (); m_pCertificate = 0; }
if ( pCert ) { m_pCertificate = pCert; m_pCertificate->AddRef (); hr = pStore->AddCertificateContext (m_pCertificate->GetCertContext (), 0, false); if ( SUCCEEDED (hr) ) { m_pCertificate->GetNewCertContext (); } } }
return hr;}
void CSaferEntry::SetDescription(const CString& szDescription){ m_szDescription = szDescription;}
HRESULT CSaferEntry::GetSaferEntriesNode(CSaferEntries **ppSaferEntries){ if ( !ppSaferEntries ) return E_POINTER;
if ( !m_pSaferEntries ) return E_NOTIMPL;
m_pSaferEntries->AddRef (); *ppSaferEntries = m_pSaferEntries;
return S_OK;}
DWORD CSaferEntry::GetLevel() const{ return m_dwLevelID;}
HRESULT CSaferEntry::SetLevel(DWORD dwLevelID){ HRESULT hr = S_OK; if ( m_dwLevelID != dwLevelID ) { m_dwLevelID = dwLevelID;
// Get the new "friendly name"
if ( m_pGPEInformation ) { CPolicyKey policyKey (m_pGPEInformation, SAFER_HKLM_REGBASE, m_bIsComputer); m_szLevelFriendlyName = SaferGetLevelFriendlyName (dwLevelID, policyKey.GetKey (), m_bIsComputer); } else { m_szLevelFriendlyName = SaferGetLevelFriendlyName (dwLevelID, 0, m_bIsComputer); } }
return hr;}
CString CSaferEntry::GetPath(){ CString szPath;
if ( m_pAuthzInfo ) { if ( SaferIdentityTypeImageName == m_pAuthzInfo->dwIdentificationType ) { PSAFER_PATHNAME_IDENTIFICATION pNameEntry = (PSAFER_PATHNAME_IDENTIFICATION) m_pAuthzInfo; ASSERT (pNameEntry->header.cbStructSize >= sizeof (SAFER_PATHNAME_IDENTIFICATION)); ASSERT (SaferIdentityTypeImageName == m_pAuthzInfo->dwIdentificationType); szPath = pNameEntry->ImageName; } }
m_szPath = szPath; return szPath;}
void CSaferEntry::SetPath(const CString &szPath){ m_szPath = szPath;}
HRESULT CSaferEntry::Save(){ _TRACE (1, L"Entering CSaferEntry::Save\n"); HRESULT hr = S_OK;
ASSERT (!m_bDeleted); if ( m_bDeleted ) return E_FAIL;
if ( m_pCertificate ) { hr = m_pCertificate->SetDescription (m_szDescription); if ( SUCCEEDED (hr) ) { hr = m_pCertificate->SetLastModified (); if ( SUCCEEDED (hr) ) { // If the level has changed, then the cert must be removed
// from the current level store added to the new one.
if ( m_dwOriginalLevelID != m_dwLevelID ) { CCertStore* pStore = 0; switch (m_dwLevelID) { case SAFER_LEVELID_FULLYTRUSTED: hr = m_pSaferEntries->GetTrustedPublishersStore (&pStore); break;
case SAFER_LEVELID_DISALLOWED: hr = m_pSaferEntries->GetDisallowedStore (&pStore); break;
default: hr = E_FAIL; break; }
if ( SUCCEEDED (hr) ) { m_pCertificate->DeleteFromStore (true); hr = pStore->AddCertificateContext (m_pCertificate->GetCertContext (), 0, false); if ( SUCCEEDED (hr) ) { m_pCertificate->SetStore (pStore); hr = PolicyChanged (); } } }
if ( SUCCEEDED (hr) ) m_szDisplayName = m_pCertificate->GetSubjectName (); } } } else if ( m_pGPEInformation ) { BOOL bRVal = TRUE; CPolicyKey policyKey (m_pGPEInformation, SAFER_HKLM_REGBASE, m_bIsComputer); hr = SetRegistryScope (policyKey.GetKey (), m_bIsComputer); if ( SUCCEEDED (hr) ) {
DWORD dwInBufferSize = 0; switch (m_saferEntryType) { case SAFER_ENTRY_TYPE_PATH: dwInBufferSize = sizeof (SAFER_PATHNAME_IDENTIFICATION); break;
case SAFER_ENTRY_TYPE_HASH: dwInBufferSize = sizeof (SAFER_HASH_IDENTIFICATION); break;
case SAFER_ENTRY_TYPE_URLZONE: dwInBufferSize = sizeof (SAFER_URLZONE_IDENTIFICATION); break;
default: ASSERT (0); break; }
SAFER_LEVEL_HANDLE hLevel = 0;
// If this entry is not being created for the first time
// and the level has changed, delete this object from its original
// level.
if ( m_pAuthzInfo && AUTHZ_UNKNOWN_LEVEL != m_dwOriginalLevelID && m_dwOriginalLevelID != m_dwLevelID ) { bRVal = SaferCreateLevel(SAFER_SCOPEID_REGISTRY, m_dwOriginalLevelID, SAFER_LEVEL_OPEN, &hLevel, policyKey.GetKey ()); ASSERT (bRVal); if ( bRVal ) { SAFER_IDENTIFICATION_TYPES dwIdentificationType = m_pAuthzInfo->dwIdentificationType; m_pAuthzInfo->dwIdentificationType = (SAFER_IDENTIFICATION_TYPES) 0; // 0 will cause deletion
bRVal = SaferSetLevelInformation(hLevel, SaferObjectSingleIdentification, m_pAuthzInfo, m_pAuthzInfo->cbStructSize); ASSERT (bRVal); if ( !bRVal ) { DWORD dwErr = GetLastError (); _TRACE (0, L"Attempt to delete entry using SaferSetLevelInformation(SaferObjectSingleIdentification) failed: %d\n", dwErr); hr = HRESULT_FROM_WIN32 (dwErr); } m_pAuthzInfo->dwIdentificationType = dwIdentificationType; // restore type
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", m_dwOriginalLevelID, dwErr); } }
if ( SUCCEEDED (hr) ) { // If this is new, create and initialize a new info structure
if ( !m_pAuthzInfo ) { // generate guid
GUID guid; hr = CoCreateGuid (&guid); if ( SUCCEEDED (hr) ) { m_pAuthzInfo = (PSAFER_IDENTIFICATION_HEADER) ::LocalAlloc (LPTR, dwInBufferSize); if ( m_pAuthzInfo ) { m_pAuthzInfo->cbStructSize = dwInBufferSize; memcpy (&m_pAuthzInfo->IdentificationGuid, &guid, sizeof (GUID)); } else hr = E_OUTOFMEMORY; } }
if ( SUCCEEDED (hr) ) { switch (m_saferEntryType) { case SAFER_ENTRY_TYPE_PATH: { m_pAuthzInfo->dwIdentificationType = SaferIdentityTypeImageName; PSAFER_PATHNAME_IDENTIFICATION pNameEntry = reinterpret_cast<PSAFER_PATHNAME_IDENTIFICATION> (m_pAuthzInfo); ASSERT (pNameEntry->header.cbStructSize >= sizeof (SAFER_PATHNAME_IDENTIFICATION)); wcsncpy (pNameEntry->Description, m_szDescription, SAFER_MAX_DESCRIPTION_SIZE-1); pNameEntry->ImageName = const_cast <PWCHAR>((PCWSTR) m_szPath); pNameEntry->dwSaferFlags = m_dwFlags; } break;
case SAFER_ENTRY_TYPE_HASH: { m_pAuthzInfo->dwIdentificationType = SaferIdentityTypeImageHash; PSAFER_HASH_IDENTIFICATION pHashEntry = reinterpret_cast<PSAFER_HASH_IDENTIFICATION>(m_pAuthzInfo); ASSERT (pHashEntry->header.cbStructSize == sizeof (SAFER_HASH_IDENTIFICATION));
wcsncpy (pHashEntry->FriendlyName, m_szHashFriendlyName, SAFER_MAX_FRIENDLYNAME_SIZE-1);
wcsncpy (pHashEntry->Description, m_szDescription, SAFER_MAX_DESCRIPTION_SIZE-1); pHashEntry->dwSaferFlags = m_dwFlags; memcpy (pHashEntry->ImageHash, m_rgbFileHash, SAFER_MAX_HASH_SIZE); pHashEntry->HashSize = m_cbFileHash; memcpy (&pHashEntry->ImageSize, &m_nHashFileSize, sizeof (__int64)); pHashEntry->HashAlgorithm = m_hashAlgid; } break;
case SAFER_ENTRY_TYPE_URLZONE: { m_pAuthzInfo->dwIdentificationType = SaferIdentityTypeUrlZone; PSAFER_URLZONE_IDENTIFICATION pURLEntry = reinterpret_cast <PSAFER_URLZONE_IDENTIFICATION> (m_pAuthzInfo); ASSERT (pURLEntry->header.cbStructSize == sizeof (SAFER_URLZONE_IDENTIFICATION)); pURLEntry->dwSaferFlags = m_dwFlags; pURLEntry->UrlZoneId = m_UrlZoneId; } break; }
bRVal = SaferCreateLevel(SAFER_SCOPEID_REGISTRY, m_dwLevelID, SAFER_LEVEL_OPEN, &hLevel, policyKey.GetKey ()); ASSERT (bRVal); if ( bRVal ) { bRVal = SaferSetLevelInformation(hLevel, SaferObjectSingleIdentification, m_pAuthzInfo, m_pAuthzInfo->cbStructSize); if ( bRVal ) { switch ( m_saferEntryType ) { case SAFER_ENTRY_TYPE_HASH: m_szDisplayName = m_szHashFriendlyName; m_szDisplayName.Replace (pcszNEWLINE, L" "); break;
case SAFER_ENTRY_TYPE_PATH: m_szDisplayName = m_szPath; break;
case SAFER_ENTRY_TYPE_URLZONE: m_szDisplayName = GetURLZoneFriendlyName (m_UrlZoneId); break;
default: ASSERT (0); break; }
hr = PolicyChanged (); if ( SUCCEEDED (hr) ) { m_dwOriginalLevelID = m_dwLevelID; } } else { DWORD dwErr = GetLastError (); _TRACE (0, L"SaferSetLevelInformation(SaferObjectSingleIdentification) failed: %d\n", dwErr); hr = HRESULT_FROM_WIN32 (dwErr); } VERIFY (SaferCloseLevel(hLevel)); } else { DWORD dwErr = GetLastError (); hr = HRESULT_FROM_WIN32 (dwErr); _TRACE (0, L"SaferCreateLevel(AUTHZSCOPID_REGISTRY, 0x%x, SAFER_LEVEL_OPEN) failed: %d\n", m_dwLevelID, dwErr); } } } } } else hr = E_FAIL;
_TRACE (-1, L"Leaving CSaferEntry::Save: 0x%x\n", hr); return hr;}
HRESULT CSaferEntry::PolicyChanged(){ _TRACE (1, L"Entering CSaferEntry::PolicyChanged\n"); HRESULT hr = E_FAIL;
if ( m_pGPEInformation ) { hr = m_pGPEInformation->PolicyChanged ( m_bIsComputer ? TRUE : FALSE, TRUE, &g_guidExtension, &g_guidSnapin); hr = m_pGPEInformation->PolicyChanged ( m_bIsComputer ? TRUE : FALSE, TRUE, &g_guidRegExt, &g_guidSnapin); }
_TRACE (-1, L"Leaving CSaferEntry::PolicyChanged\n"); return hr;}
void CSaferEntry::SetFlags(DWORD dwFlags){ m_dwFlags = dwFlags;}
HRESULT CSaferEntry::GetFlags(DWORD &dwFlags){ HRESULT hr = S_OK;
if ( m_pAuthzInfo ) { switch (m_saferEntryType) { case SAFER_ENTRY_TYPE_PATH: { m_pAuthzInfo->dwIdentificationType = SaferIdentityTypeImageName; PSAFER_PATHNAME_IDENTIFICATION pNameEntry = reinterpret_cast<PSAFER_PATHNAME_IDENTIFICATION>(m_pAuthzInfo); ASSERT (pNameEntry->header.cbStructSize >= sizeof (SAFER_PATHNAME_IDENTIFICATION)); dwFlags = pNameEntry->dwSaferFlags; } break;
case SAFER_ENTRY_TYPE_HASH: { m_pAuthzInfo->dwIdentificationType = SaferIdentityTypeImageHash; PSAFER_HASH_IDENTIFICATION pHashEntry = reinterpret_cast<PSAFER_HASH_IDENTIFICATION>(m_pAuthzInfo); ASSERT (pHashEntry->header.cbStructSize == sizeof (SAFER_HASH_IDENTIFICATION)); dwFlags = pHashEntry->dwSaferFlags; } break;
case SAFER_ENTRY_TYPE_URLZONE: { m_pAuthzInfo->dwIdentificationType = SaferIdentityTypeUrlZone; PSAFER_URLZONE_IDENTIFICATION pURLEntry = reinterpret_cast<PSAFER_URLZONE_IDENTIFICATION>(m_pAuthzInfo); ASSERT (pURLEntry->header.cbStructSize == sizeof (SAFER_URLZONE_IDENTIFICATION)); dwFlags = pURLEntry->dwSaferFlags; } break;
default: hr = E_FAIL; break; } } else if ( m_pCertificate ) { hr = E_NOTIMPL; }
return hr;}
HRESULT CSaferEntry::Delete(bool bCommit){ _TRACE (1, L"Entering CSaferEntry::Delete\n"); HRESULT hr = S_OK; ASSERT (!m_bDeleted); if ( m_bDeleted ) return E_FAIL;
if ( m_pCertificate ) { BOOL bRVal = m_pCertificate->DeleteFromStore (bCommit); if ( bRVal ) { m_bDeleted = true; } else { DWORD dwErr = GetLastError (); hr = HRESULT_FROM_WIN32 (dwErr); } } else if ( m_pGPEInformation ) { BOOL bRVal = TRUE; CPolicyKey policyKey (m_pGPEInformation, SAFER_HKLM_REGBASE, m_bIsComputer); hr = SetRegistryScope (policyKey.GetKey (), m_bIsComputer); if ( SUCCEEDED (hr) ) { DWORD dwInBufferSize = 0; switch (m_saferEntryType) { case SAFER_ENTRY_TYPE_PATH: dwInBufferSize = sizeof (SAFER_PATHNAME_IDENTIFICATION); break;
case SAFER_ENTRY_TYPE_HASH: dwInBufferSize = sizeof (SAFER_HASH_IDENTIFICATION); break;
case SAFER_ENTRY_TYPE_URLZONE: dwInBufferSize = sizeof (SAFER_URLZONE_IDENTIFICATION); break;
default: ASSERT (0); break; }
SAFER_LEVEL_HANDLE hLevel = 0;
if ( m_pAuthzInfo ) { bRVal = SaferCreateLevel(SAFER_SCOPEID_REGISTRY, m_dwOriginalLevelID, SAFER_LEVEL_OPEN, &hLevel, policyKey.GetKey ()); ASSERT (bRVal); if ( bRVal ) { SAFER_IDENTIFICATION_TYPES dwIdentificationType = m_pAuthzInfo->dwIdentificationType; m_pAuthzInfo->dwIdentificationType = (SAFER_IDENTIFICATION_TYPES) 0; // 0 will cause deletion
bRVal = SaferSetLevelInformation(hLevel, SaferObjectSingleIdentification, m_pAuthzInfo, m_pAuthzInfo->cbStructSize); ASSERT (bRVal); if ( bRVal ) { m_bDeleted = true; if ( bCommit ) { hr = m_pGPEInformation->PolicyChanged ( m_bIsComputer ? TRUE : FALSE, TRUE, &g_guidExtension, &g_guidSnapin); hr = m_pGPEInformation->PolicyChanged ( m_bIsComputer ? TRUE : FALSE, TRUE, &g_guidRegExt, &g_guidSnapin); } } else { DWORD dwErr = GetLastError (); _TRACE (0, L"Attempt to delete entry using SaferSetLevelInformation(SaferObjectSingleIdentification) failed: %d\n", dwErr); hr = HRESULT_FROM_WIN32 (dwErr); } m_pAuthzInfo->dwIdentificationType = dwIdentificationType; VERIFY (SaferCloseLevel(hLevel)); // restore type
} else { DWORD dwErr = GetLastError (); hr = HRESULT_FROM_WIN32 (dwErr); _TRACE (0, L"SaferCreateLevel(AUTHZSCOPID_REGISTRY, 0x%x, SAFER_LEVEL_OPEN) failed: %d\n", m_dwOriginalLevelID, dwErr); } } } } else hr = E_FAIL;
_TRACE (-1, L"Leaving CSaferEntry::Delete: 0x%x\n", hr); return hr;}
HRESULT CSaferEntry::GetHash(BYTE rgbFileHash[], DWORD& cbFileHash, __int64& nFileSize, ALG_ID& algId) const{ HRESULT hr = S_OK;
if ( m_pAuthzInfo ) { if ( SAFER_ENTRY_TYPE_HASH == m_saferEntryType ) { PSAFER_HASH_IDENTIFICATION pHashEntry = reinterpret_cast<PSAFER_HASH_IDENTIFICATION>(m_pAuthzInfo); ASSERT (pHashEntry->header.cbStructSize == sizeof (SAFER_HASH_IDENTIFICATION)); memcpy (rgbFileHash, pHashEntry->ImageHash, SAFER_MAX_HASH_SIZE); cbFileHash = pHashEntry->HashSize; memcpy (&nFileSize, &pHashEntry->ImageSize, sizeof (__int64)); algId = pHashEntry->HashAlgorithm; } else hr = E_NOTIMPL; } else hr = E_FAIL;
return hr;}
HRESULT CSaferEntry::SetHash ( BYTE rgbFileHash[], DWORD cbFileHash, __int64 nFileSize, ALG_ID hashAlgid){ ASSERT (cbFileHash <= SAFER_MAX_HASH_SIZE); if ( cbFileHash > SAFER_MAX_HASH_SIZE ) return E_FAIL;
ASSERT (rgbFileHash); if ( !rgbFileHash ) return E_POINTER;
m_nHashFileSize = nFileSize; m_cbFileHash = cbFileHash; ::ZeroMemory (m_rgbFileHash, SAFER_MAX_HASH_SIZE); memcpy (m_rgbFileHash, rgbFileHash, cbFileHash); m_hashAlgid = hashAlgid;
return S_OK;}
DWORD CSaferEntry::GetURLZoneID() const{ return m_UrlZoneId;}
void CSaferEntry::SetURLZoneID(DWORD dwURLZoneID){ m_UrlZoneId = dwURLZoneID;}
CString CSaferEntry::GetHashFriendlyName(){ CString szFriendlyName;
if ( m_szHashFriendlyName.IsEmpty () ) { if ( m_pAuthzInfo ) { if ( SaferIdentityTypeImageHash == m_pAuthzInfo->dwIdentificationType ) { PSAFER_HASH_IDENTIFICATION pHashEntry = (PSAFER_HASH_IDENTIFICATION) m_pAuthzInfo; ASSERT (pHashEntry->header.cbStructSize == sizeof (SAFER_HASH_IDENTIFICATION)); m_szHashFriendlyName = pHashEntry->FriendlyName; } } } return m_szHashFriendlyName;}
void CSaferEntry::SetHashFriendlyName(const CString &szFriendlyName){ m_szHashFriendlyName = szFriendlyName;}
int CSaferEntry::CompareLastModified (const CSaferEntry& saferEntry) const{ int compVal = 0;
FILETIME thisFt; FILETIME inFt;
if ( m_pAuthzInfo ) thisFt = m_pAuthzInfo->lastModified; else if ( m_pCertificate ) { if ( FAILED (m_pCertificate->GetLastModifiedFileTime (thisFt)) ) return 0; } else { ASSERT (0); return 0; }
if ( saferEntry.m_pAuthzInfo ) inFt = saferEntry.m_pAuthzInfo->lastModified; else if ( saferEntry.m_pCertificate ) { if ( FAILED (saferEntry.m_pCertificate->GetLastModifiedFileTime (inFt)) ) return 0; } else { ASSERT (0); return 0; }
compVal = ::CompareFileTime (&thisFt, &inFt);
return compVal;}
CString CSaferEntry::GetRSOPRegistryKey () const{ CString szRegistryKey; if ( m_pCertificate ) { if ( SAFER_LEVELID_FULLYTRUSTED == m_dwLevelID ) szRegistryKey = CERT_TRUST_PUB_SAFER_GROUP_POLICY_TRUSTED_PUBLISHER_STORE_REGPATH; else szRegistryKey = CERT_TRUST_PUB_SAFER_GROUP_POLICY_DISALLOWED_STORE_REGPATH;
szRegistryKey += STR_REGKEY_CERTIFICATES; szRegistryKey += L"\\"; //szRegistryKey += m_pCertificate->GetMD5Hash ();
szRegistryKey += m_pCertificate->GetSHAHash (); } else szRegistryKey = m_szRSOPRegistryKey;
ASSERT (!szRegistryKey.IsEmpty ()); return szRegistryKey;}
void CSaferEntry::Refresh(){ _TRACE (1, L"Entering CSaferEntry::Refresh ()\n"); if ( m_pAuthzInfo ) { if ( m_pGPEInformation ) { SAFER_LEVEL_HANDLE hLevel = 0; CPolicyKey policyKey (m_pGPEInformation, SAFER_HKLM_REGBASE, m_bIsComputer); BOOL bRVal = SaferCreateLevel(SAFER_SCOPEID_REGISTRY, m_dwLevelID, SAFER_LEVEL_OPEN, &hLevel, policyKey.GetKey ()); if ( bRVal ) { DWORD dwBufferSize = sizeof (SAFER_IDENTIFICATION_HEADER); bRVal = SaferGetLevelInformation (hLevel, SaferObjectSingleIdentification, m_pAuthzInfo, dwBufferSize, &dwBufferSize); if ( !bRVal && ERROR_INSUFFICIENT_BUFFER == GetLastError () ) { PBYTE pBytes = (PBYTE) LocalAlloc (LPTR, dwBufferSize); if ( pBytes ) { PSAFER_IDENTIFICATION_HEADER pCommon = (PSAFER_IDENTIFICATION_HEADER) pBytes; pCommon->cbStructSize = dwBufferSize; memcpy (&pCommon->IdentificationGuid, &m_pAuthzInfo->IdentificationGuid, sizeof (GUID));
bRVal = SaferGetLevelInformation (hLevel, SaferObjectSingleIdentification, pBytes, dwBufferSize, &dwBufferSize); ASSERT (bRVal); if ( bRVal ) { LocalFree (m_pAuthzInfo); m_pAuthzInfo = (PSAFER_IDENTIFICATION_HEADER) pBytes; } else { _TRACE (0, L"SaferGetLevelInformation () failed: %d\n", GetLastError ()); } } }
VERIFY (SaferCloseLevel(hLevel)); } else { _TRACE (0, L"SaferCreateLevel() failed: %d\n", GetLastError ()); } } else { // Is RSOP
} } _TRACE (-1, L"Leaving CSaferEntry::Refresh ()\n");}
|
