954 lines
29 KiB
C++
954 lines
29 KiB
C++
//+--------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1994 - 1998.
|
|
//
|
|
// File: Sigs.cpp
|
|
//
|
|
// Contents: Digital Signatures property page
|
|
//
|
|
// Classes: CSignatures
|
|
//
|
|
// History: 07-10-2000 stevebl Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
#include "precomp.hxx"
|
|
#ifdef DIGITAL_SIGNATURES
|
|
|
|
#include "wincrypt.h"
|
|
#include "cryptui.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSignatures property page
|
|
|
|
IMPLEMENT_DYNCREATE(CSignatures, CPropertyPage)
|
|
|
|
CSignatures::CSignatures() : CPropertyPage(CSignatures::IDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CSignatures)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
m_fAllow = FALSE;
|
|
m_fIgnoreForAdmins = FALSE;
|
|
m_pIClassAdmin = NULL;
|
|
m_nSortedColumn = 0;
|
|
}
|
|
|
|
CSignatures::~CSignatures()
|
|
{
|
|
*m_ppThis = NULL;
|
|
if (m_pIClassAdmin)
|
|
{
|
|
m_pIClassAdmin->Release();
|
|
}
|
|
// delete temporary stores
|
|
m_list1.DeleteAllItems();
|
|
m_list2.DeleteAllItems();
|
|
|
|
DeleteFile(m_szTempInstallableStore);
|
|
DeleteFile(m_szTempNonInstallableStore);
|
|
}
|
|
|
|
void CSignatures::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPage::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CSignatures)
|
|
DDX_Check(pDX, IDC_CHECK1, m_fAllow);
|
|
DDX_Check(pDX, IDC_CHECK2, m_fIgnoreForAdmins);
|
|
DDX_Control(pDX, IDC_LIST1, m_list1);
|
|
DDX_Control(pDX, IDC_LIST2, m_list2);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CSignatures, CPropertyPage)
|
|
//{{AFX_MSG_MAP(CSignatures)
|
|
ON_BN_CLICKED(IDC_BUTTON1, OnAddAllow)
|
|
ON_BN_CLICKED(IDC_BUTTON2, OnDeleteAllow)
|
|
ON_BN_CLICKED(IDC_BUTTON3, OnPropertiesAllow)
|
|
ON_BN_CLICKED(IDC_BUTTON4, OnAddDisallow)
|
|
ON_BN_CLICKED(IDC_BUTTON5, OnDeleteDisallow)
|
|
ON_BN_CLICKED(IDC_BUTTON6, OnPropertiesDisallow)
|
|
ON_BN_CLICKED(IDC_CHECK1, OnAllowChanged)
|
|
ON_BN_CLICKED(IDC_CHECK2, OnIgnoreChanged)
|
|
ON_WM_CONTEXTMENU()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSignatures message handlers
|
|
|
|
void CSignatures::RemoveCertificate(CString &szStore, CListCtrl &List)
|
|
{
|
|
int nItem = -1;
|
|
|
|
for (;;)
|
|
{
|
|
nItem = List.GetNextItem(nItem, LVNI_SELECTED);
|
|
if (-1 == nItem)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Open the certificate store
|
|
//
|
|
|
|
PCCERT_CONTEXT pcLocalCert = NULL;
|
|
PCCERT_CONTEXT pcItemCert = (PCCERT_CONTEXT) List.GetItemData(nItem);
|
|
HCERTSTORE hCertStore = CertOpenStore( CERT_STORE_PROV_FILENAME,
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
NULL,
|
|
CERT_FILE_STORE_COMMIT_ENABLE_FLAG,
|
|
szStore);
|
|
|
|
if (hCertStore)
|
|
{
|
|
//
|
|
// Enumerate the cert store looking for the match
|
|
//
|
|
|
|
int i = 0;
|
|
|
|
for (;;) {
|
|
pcLocalCert = CertEnumCertificatesInStore(hCertStore, pcLocalCert);
|
|
|
|
if (!pcLocalCert) {
|
|
if (GetLastError() != CRYPT_E_NOT_FOUND )
|
|
{
|
|
DebugMsg((DM_WARNING, TEXT("CSignatures::RemoveCertificate: Failed to find certificate to delete.")));
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (CertCompareCertificate(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
pcLocalCert->pCertInfo ,
|
|
pcItemCert->pCertInfo))
|
|
{
|
|
CertDeleteCertificateFromStore(pcLocalCert);
|
|
break;
|
|
}
|
|
|
|
//pcLocalCert should get deleted when it is repassed into CertEnumCerti..
|
|
}
|
|
CertCloseStore(hCertStore, 0);
|
|
}
|
|
}
|
|
|
|
RefreshData();
|
|
SetModified();
|
|
}
|
|
|
|
void CSignatures::CertificateProperties(CString &szStore, CListCtrl &List)
|
|
{
|
|
int nItem = -1;
|
|
|
|
for (;;)
|
|
{
|
|
nItem = List.GetNextItem(nItem, LVNI_SELECTED);
|
|
if (-1 == nItem)
|
|
{
|
|
break;
|
|
}
|
|
|
|
PCCERT_CONTEXT pcc = (PCCERT_CONTEXT) List.GetItemData(nItem);
|
|
|
|
// display the property sheet for this item
|
|
CRYPTUI_VIEWCERTIFICATE_STRUCT cvs;
|
|
memset(&cvs, 0, sizeof(cvs));
|
|
cvs.dwSize = sizeof(cvs);
|
|
cvs.hwndParent = m_hWnd;
|
|
cvs.pCertContext = pcc;
|
|
cvs.dwFlags = CRYPTUI_DISABLE_EDITPROPERTIES |
|
|
CRYPTUI_DISABLE_ADDTOSTORE;
|
|
|
|
BOOL fChanged = FALSE;
|
|
CryptUIDlgViewCertificate(&cvs, &fChanged);
|
|
}
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Member: CSignatures::ReportFailure
|
|
//
|
|
// Synopsis: General failure reporting mechanism.
|
|
//
|
|
// Arguments: [dwMessage] - resource ID of the root message string
|
|
// [hr] - HRESULT encountered
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// Derivation:
|
|
//
|
|
// History: 07-26-2000 stevebl Created
|
|
//
|
|
// Notes: Builds an error message with a line of text determined by
|
|
// dwMessage, and followed by text returned by Format Message
|
|
// string.
|
|
// The error message is then displayed in a message box.
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void CSignatures::ReportFailure(DWORD dwMessage, HRESULT hr)
|
|
{
|
|
CString szMessage;
|
|
szMessage.LoadString(dwMessage);
|
|
szMessage += TEXT("\n");
|
|
TCHAR szBuffer[256];
|
|
DWORD dw = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
hr,
|
|
0,
|
|
szBuffer,
|
|
sizeof(szBuffer) / sizeof(szBuffer[0]),
|
|
NULL);
|
|
if (0 == dw)
|
|
{
|
|
// FormatMessage failed.
|
|
// We'll have to come up with some sort of reasonable message.
|
|
wsprintf(szBuffer, TEXT("(HRESULT: 0x%lX)"), hr);
|
|
|
|
}
|
|
szMessage += szBuffer;
|
|
MessageBox(szMessage,
|
|
NULL,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: AddMSIToCertStore
|
|
//
|
|
// Synopsis: Gets a certificate from an MSI file and adds it to the
|
|
// certificate store.
|
|
//
|
|
// Arguments: [lpFileName] - path to the MSI file
|
|
// [lpFileStore] - path to the certificate store
|
|
//
|
|
// Returns:
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 07-26-2000 stevebl Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
HRESULT CSignatures::AddMSIToCertStore(LPWSTR lpFileName, LPWSTR lpFileStore)
|
|
{
|
|
PCCERT_CONTEXT pcc = NULL;
|
|
HCERTSTORE hCertStore = NULL;
|
|
BOOL bRet;
|
|
HRESULT hrRet = MsiGetFileSignatureInformation(lpFileName,
|
|
0,
|
|
&pcc,
|
|
NULL,
|
|
NULL);
|
|
if (SUCCEEDED(hrRet))
|
|
{
|
|
//
|
|
// Open the certificate store
|
|
//
|
|
hCertStore = CertOpenStore( CERT_STORE_PROV_FILENAME,
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
NULL,
|
|
CERT_FILE_STORE_COMMIT_ENABLE_FLAG,
|
|
lpFileStore);
|
|
|
|
if (hCertStore == NULL) {
|
|
DebugMsg((DM_WARNING, L"AddMSIToCertStore: CertOpenStore failed with %u",GetLastError()));
|
|
hrRet = HRESULT_FROM_WIN32(GetLastError());
|
|
goto Exit;
|
|
}
|
|
|
|
|
|
//
|
|
// add the given certificate to the store
|
|
//
|
|
|
|
bRet = CertAddCertificateContextToStore(hCertStore,
|
|
pcc,
|
|
CERT_STORE_ADD_NEW,
|
|
NULL);
|
|
|
|
if (!bRet) {
|
|
DebugMsg((DM_WARNING, L"AddToCertStore: CertAddCertificateContextToStore failed with %u", GetLastError()));
|
|
hrRet = HRESULT_FROM_WIN32(GetLastError());
|
|
goto Exit;
|
|
}
|
|
|
|
|
|
//
|
|
// Save the store
|
|
//
|
|
|
|
bRet = CertCloseStore(hCertStore, 0);
|
|
hCertStore = NULL; // Make the store handle NULL, Nothing more we can do
|
|
|
|
if (!bRet) {
|
|
DebugMsg((DM_WARNING, L"AddToCertStore: CertCloseStore failed with %u", GetLastError()));
|
|
hrRet = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
hrRet = S_OK;
|
|
|
|
|
|
Exit:
|
|
|
|
if (hCertStore) {
|
|
|
|
//
|
|
// No need to get the error code
|
|
//
|
|
|
|
CertCloseStore(hCertStore, 0);
|
|
}
|
|
CertFreeCertificateContext(pcc);
|
|
if (FAILED(hrRet))
|
|
{
|
|
ReportFailure(IDS_ADDCERTFAILED, hrRet);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReportFailure(IDS_CERTFROMMSIFAILED, hrRet);
|
|
DebugMsg((DM_WARNING, L"AddMSIToCertStore: MsiGetFileSignatureInformation failed with 0x%x", hrRet));
|
|
}
|
|
|
|
return hrRet;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
// AddToCertStore
|
|
//
|
|
// Purpose:
|
|
// Adds the certificate from the given filename to the certificate store
|
|
// and saves it to the given location
|
|
//
|
|
//
|
|
// Parameters
|
|
// lpFIleName - Location of the certificate file
|
|
// lpFileStore - Location where the resultant cetrtficate path should
|
|
// be stored
|
|
//
|
|
//
|
|
// Return Value:
|
|
// S_OK if successful or the corresponding error code
|
|
//
|
|
// Comments: Shamefully stolen from Shaji's code.
|
|
//+-------------------------------------------------------------------------
|
|
|
|
|
|
HRESULT CSignatures::AddToCertStore(LPWSTR lpFileName, LPWSTR lpFileStore)
|
|
{
|
|
CRYPTUI_WIZ_IMPORT_SRC_INFO cui_src;
|
|
HCERTSTORE hCertStore = NULL;
|
|
BOOL bRet = FALSE;
|
|
HRESULT hrRet = S_OK;
|
|
|
|
|
|
//
|
|
// Need to make the store usable and saveable from
|
|
// multiple admin consoles..
|
|
//
|
|
// For that the file has to be saved and kept on a temp file
|
|
// and then modified..
|
|
//
|
|
|
|
if (!lpFileName || !lpFileName[0] || !lpFileStore || !lpFileStore[0]) {
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
//
|
|
// Open the certificate store
|
|
//
|
|
|
|
hCertStore = CertOpenStore( CERT_STORE_PROV_FILENAME,
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
NULL,
|
|
CERT_FILE_STORE_COMMIT_ENABLE_FLAG,
|
|
lpFileStore);
|
|
|
|
if (hCertStore == NULL) {
|
|
DebugMsg((DM_WARNING, L"AddToCertStore: CertOpenStore failed with %u",GetLastError()));
|
|
hrRet = HRESULT_FROM_WIN32(GetLastError());
|
|
goto Exit;
|
|
}
|
|
|
|
|
|
//
|
|
// add the given certificate to the store
|
|
//
|
|
|
|
cui_src.dwFlags = 0;
|
|
cui_src.dwSize = sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO);
|
|
cui_src.dwSubjectChoice = CRYPTUI_WIZ_IMPORT_SUBJECT_FILE;
|
|
cui_src.pwszFileName = lpFileName;
|
|
cui_src.pwszPassword = NULL;
|
|
|
|
bRet = CryptUIWizImport(CRYPTUI_WIZ_NO_UI, NULL, NULL, &cui_src, hCertStore);
|
|
|
|
if (!bRet) {
|
|
DebugMsg((DM_WARNING, L"AddToCertStore: CryptUIWizImport failed with %u", GetLastError()));
|
|
hrRet = HRESULT_FROM_WIN32(GetLastError());
|
|
goto Exit;
|
|
}
|
|
|
|
|
|
//
|
|
// Save the store
|
|
//
|
|
|
|
bRet = CertCloseStore(hCertStore, 0);
|
|
hCertStore = NULL; // Make the store handle NULL, Nothing more we can do
|
|
|
|
if (!bRet) {
|
|
DebugMsg((DM_WARNING, L"AddToCertStore: CertCloseStore failed with %u", GetLastError()));
|
|
hrRet = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
hrRet = S_OK;
|
|
|
|
|
|
Exit:
|
|
|
|
if (hCertStore) {
|
|
|
|
//
|
|
// No need to get the error code
|
|
//
|
|
|
|
CertCloseStore(hCertStore, 0);
|
|
}
|
|
|
|
if (FAILED(hrRet))
|
|
{
|
|
ReportFailure(IDS_ADDCERTFAILED, hrRet);
|
|
}
|
|
return hrRet;
|
|
}
|
|
|
|
|
|
void CSignatures::AddCertificate(CString &szStore)
|
|
{
|
|
CString szExtension;
|
|
CString szFilter;
|
|
szExtension.LoadString(IDS_CERT_DEF_EXT);
|
|
szFilter.LoadString(IDS_CERT_EXT_FILT);
|
|
OPENFILENAME ofn;
|
|
memset(&ofn, 0, sizeof(ofn));
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = m_hWnd;
|
|
ofn.hInstance = ghInstance;
|
|
TCHAR lpstrFilter[MAX_PATH];
|
|
wcsncpy(lpstrFilter, szFilter, MAX_PATH);
|
|
ofn.lpstrFilter = lpstrFilter;
|
|
TCHAR szFileTitle[MAX_PATH];
|
|
TCHAR szFile[MAX_PATH];
|
|
szFile[0] = NULL;
|
|
ofn.lpstrFile = szFile;
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.lpstrFileTitle = szFileTitle;
|
|
ofn.nMaxFileTitle = MAX_PATH;
|
|
ofn.lpstrInitialDir = m_pScopePane->m_ToolDefaults.szStartPath;
|
|
ofn.Flags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_FILEMUSTEXIST | OFN_EXPLORER;
|
|
ofn.lpstrDefExt = szExtension;
|
|
int iBreak = 0;
|
|
while (lpstrFilter[iBreak])
|
|
{
|
|
if (lpstrFilter[iBreak] == TEXT('|'))
|
|
{
|
|
lpstrFilter[iBreak] = 0;
|
|
}
|
|
iBreak++;
|
|
}
|
|
if (GetOpenFileName(&ofn))
|
|
{
|
|
CHourglass hourglass;
|
|
CString szPackagePath;
|
|
HRESULT hr = E_FAIL;
|
|
if ((ofn.nFileExtension > 0) &&
|
|
(0 == _wcsicmp(ofn.lpstrFile + ofn.nFileExtension, L"msi")))
|
|
{
|
|
// this is an MSI package
|
|
|
|
HRESULT hr = AddMSIToCertStore(ofn.lpstrFile, (LPWSTR)((LPCWSTR)szStore));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
RefreshData();
|
|
SetModified();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// this is a simple certificate
|
|
HRESULT hr = AddToCertStore(ofn.lpstrFile, (LPWSTR)((LPCWSTR)szStore));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
RefreshData();
|
|
SetModified();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSignatures::OnAddAllow()
|
|
{
|
|
AddCertificate(m_szTempInstallableStore);
|
|
}
|
|
|
|
void CSignatures::OnDeleteAllow()
|
|
{
|
|
RemoveCertificate(m_szTempInstallableStore, m_list1);
|
|
}
|
|
|
|
void CSignatures::OnPropertiesAllow()
|
|
{
|
|
CertificateProperties(m_szTempInstallableStore, m_list1);
|
|
}
|
|
|
|
void CSignatures::OnAddDisallow()
|
|
{
|
|
AddCertificate(m_szTempNonInstallableStore);
|
|
}
|
|
|
|
void CSignatures::OnDeleteDisallow()
|
|
{
|
|
RemoveCertificate(m_szTempNonInstallableStore, m_list2);
|
|
}
|
|
|
|
void CSignatures::OnPropertiesDisallow()
|
|
{
|
|
CertificateProperties(m_szTempNonInstallableStore, m_list2);
|
|
}
|
|
|
|
void CSignatures::OnAllowChanged()
|
|
{
|
|
BOOL fAllow = IsDlgButtonChecked(IDC_CHECK1);
|
|
if (m_fAllow != fAllow)
|
|
{
|
|
SetModified();
|
|
}
|
|
m_fAllow = fAllow;
|
|
GetDlgItem(IDC_BUTTON1)->EnableWindow(m_fAllow);
|
|
GetDlgItem(IDC_BUTTON2)->EnableWindow(m_fAllow);
|
|
GetDlgItem(IDC_BUTTON3)->EnableWindow(m_fAllow);
|
|
GetDlgItem(IDC_LIST1)->EnableWindow(m_fAllow);
|
|
}
|
|
void CSignatures::OnIgnoreChanged()
|
|
{
|
|
BOOL fIgnoreForAdmins = IsDlgButtonChecked(IDC_CHECK2);
|
|
if (m_fIgnoreForAdmins != fIgnoreForAdmins)
|
|
{
|
|
SetModified();
|
|
}
|
|
m_fIgnoreForAdmins = fIgnoreForAdmins;
|
|
}
|
|
|
|
BOOL CSignatures::OnInitDialog()
|
|
{
|
|
// create temporary store files
|
|
BOOL fFilesCreated = FALSE;
|
|
TCHAR szTempPath[MAX_PATH];
|
|
if (GetTempPath(MAX_PATH, szTempPath))
|
|
{
|
|
TCHAR szTempFile[MAX_PATH];
|
|
if (GetTempFileName(szTempPath,
|
|
NULL,
|
|
0,
|
|
szTempFile))
|
|
{
|
|
m_szTempInstallableStore = szTempFile;
|
|
if (GetTempFileName(szTempPath,
|
|
NULL,
|
|
0,
|
|
szTempFile))
|
|
{
|
|
m_szTempNonInstallableStore = szTempFile;
|
|
fFilesCreated = TRUE;
|
|
}
|
|
}
|
|
}
|
|
if (fFilesCreated)
|
|
{
|
|
CString szPath = m_pScopePane->m_szGPT_Path;
|
|
szPath += TEXT("\\msi_installable_certs");
|
|
CopyFile(szPath, m_szTempInstallableStore, FALSE);
|
|
szPath = m_pScopePane->m_szGPT_Path;
|
|
szPath += TEXT("\\msi_non_installable_certs");
|
|
CopyFile(szPath, m_szTempNonInstallableStore, FALSE);
|
|
}
|
|
else
|
|
{
|
|
DebugMsg((DM_WARNING, TEXT("CSignatures::OnInitDialog : Failed to create temporary certificate stores.")));
|
|
}
|
|
|
|
CPropertyPage::OnInitDialog();
|
|
|
|
// add columns to the lists
|
|
RECT rect;
|
|
m_list1.GetClientRect(&rect);
|
|
|
|
CString szTemp;
|
|
szTemp.LoadString(IDS_SIGS_COL1);
|
|
m_list1.InsertColumn(0, szTemp, LVCFMT_LEFT, (rect.right - rect.left) * 0.35);
|
|
m_list2.InsertColumn(0, szTemp, LVCFMT_LEFT, (rect.right - rect.left) * 0.35);
|
|
szTemp.LoadString(IDS_SIGS_COL2);
|
|
m_list1.InsertColumn(1, szTemp, LVCFMT_LEFT, (rect.right - rect.left) * 0.35);
|
|
m_list2.InsertColumn(1, szTemp, LVCFMT_LEFT, (rect.right - rect.left) * 0.35);
|
|
szTemp.LoadString(IDS_SIGS_COL3);
|
|
m_list1.InsertColumn(2, szTemp, LVCFMT_LEFT, (rect.right - rect.left) * 0.25);
|
|
m_list2.InsertColumn(2, szTemp, LVCFMT_LEFT, (rect.right - rect.left) * 0.25);
|
|
|
|
// add image lists
|
|
CImageList * pil = NULL;
|
|
pil = new CImageList;
|
|
if (pil)
|
|
{
|
|
pil->Create(IDB_CERTIFICATE, 16, 0, RGB(255, 0, 255));
|
|
m_list1.SetImageList(pil, LVSIL_SMALL);
|
|
}
|
|
|
|
pil = new CImageList;
|
|
if (pil)
|
|
{
|
|
pil->Create(IDB_CERTIFICATE, 16, 0, RGB(255, 0, 255));
|
|
m_list2.SetImageList(pil, LVSIL_SMALL);
|
|
}
|
|
|
|
// retrieve initial registry key setting
|
|
HKEY hKey;
|
|
HRESULT hr = m_pIGPEInformation->GetRegistryKey(m_pScopePane->m_fMachine ?
|
|
GPO_SECTION_MACHINE :
|
|
GPO_SECTION_USER, &hKey);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
HKEY hSubKey;
|
|
if(ERROR_SUCCESS == RegOpenKeyEx(hKey,
|
|
TEXT("Microsoft\\Windows\\Installer"),
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hSubKey))
|
|
{
|
|
DWORD dw;
|
|
DWORD dwSize = sizeof(DWORD);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hSubKey,
|
|
TEXT("InstallKnownPackagesOnly"),
|
|
NULL,
|
|
NULL,
|
|
(BYTE *)&dw,
|
|
&dwSize))
|
|
{
|
|
m_fAllow = (dw == 1) ? TRUE : FALSE;
|
|
CheckDlgButton(IDC_CHECK1, m_fAllow);
|
|
}
|
|
dwSize = sizeof(DWORD);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hSubKey,
|
|
TEXT("IgnoreSignaturePolicyForAdmins"),
|
|
NULL,
|
|
NULL,
|
|
(BYTE *)&dw,
|
|
&dwSize))
|
|
{
|
|
m_fIgnoreForAdmins = (dw == 1) ? TRUE : FALSE;
|
|
CheckDlgButton(IDC_CHECK2, m_fIgnoreForAdmins);
|
|
}
|
|
RegCloseKey(hSubKey);
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
RefreshData();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
BOOL CSignatures::OnApply()
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
HKEY hKey;
|
|
hr = m_pIGPEInformation->GetRegistryKey(m_pScopePane->m_fMachine ?
|
|
GPO_SECTION_MACHINE :
|
|
GPO_SECTION_USER, &hKey);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = E_FAIL;
|
|
HKEY hSubKey;
|
|
if(ERROR_SUCCESS == RegCreateKeyEx(hKey,
|
|
TEXT("Microsoft\\Windows\\Installer"),
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hSubKey,
|
|
NULL))
|
|
{
|
|
DWORD dw = m_fAllow ? 1 : 0;
|
|
DWORD dwSize = sizeof(DWORD);
|
|
if (ERROR_SUCCESS == RegSetValueEx(hSubKey,
|
|
TEXT("InstallKnownPackagesOnly"),
|
|
0,
|
|
REG_DWORD,
|
|
(BYTE *)&dw,
|
|
dwSize))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
dw = m_fIgnoreForAdmins ? 1 : 0;
|
|
dwSize = sizeof(DWORD);
|
|
if (ERROR_SUCCESS == RegSetValueEx(hSubKey,
|
|
TEXT("IgnoreSignaturePolicyForAdmins"),
|
|
0,
|
|
REG_DWORD,
|
|
(BYTE *)&dw,
|
|
dwSize))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
RegCloseKey(hSubKey);
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
// copy back the certificate stores
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_list1.DeleteAllItems();
|
|
m_list2.DeleteAllItems();
|
|
|
|
CString szPath = m_pScopePane->m_szGPT_Path;
|
|
szPath += TEXT("\\msi_installable_certs");
|
|
CopyFile(m_szTempInstallableStore, szPath, FALSE);
|
|
szPath = m_pScopePane->m_szGPT_Path;
|
|
szPath += TEXT("\\msi_non_installable_certs");
|
|
CopyFile(m_szTempNonInstallableStore, szPath, FALSE);
|
|
|
|
RefreshData();
|
|
}
|
|
if (FAILED(hr))
|
|
{
|
|
CString sz;
|
|
sz.LoadString(IDS_CHANGEFAILED);
|
|
ReportGeneralPropertySheetError(m_hWnd, sz, hr);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
GUID guid = REGISTRY_EXTENSION_GUID;
|
|
if (FAILED(m_pIGPEInformation->PolicyChanged(m_pScopePane->m_fMachine,
|
|
TRUE,
|
|
&guid,
|
|
m_pScopePane->m_fMachine ? &guidMachSnapin
|
|
: &guidUserSnapin)))
|
|
{
|
|
ReportPolicyChangedError(m_hWnd);
|
|
}
|
|
// need to call PolicyChanged for Shaji's extension too.
|
|
|
|
// REMOVE THIS LINE WHEN SHAJI CHECKS IN HIS GUID
|
|
#define GUID_MSICERT_CSE { 0x000c10f4, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 }
|
|
|
|
GUID guid2 = GUID_MSICERT_CSE;
|
|
if (FAILED(m_pIGPEInformation->PolicyChanged(m_pScopePane->m_fMachine,
|
|
TRUE,
|
|
&guid2,
|
|
m_pScopePane->m_fMachine ? &guidMachSnapin
|
|
: &guidUserSnapin)))
|
|
{
|
|
ReportPolicyChangedError(m_hWnd);
|
|
}
|
|
}
|
|
return CPropertyPage::OnApply();
|
|
}
|
|
|
|
|
|
LRESULT CSignatures::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (message)
|
|
{
|
|
case WM_HELP:
|
|
StandardHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, IDD);
|
|
return 0;
|
|
case WM_USER_REFRESH:
|
|
RefreshData();
|
|
return 0;
|
|
case WM_USER_CLOSE:
|
|
return GetOwner()->SendMessage(WM_CLOSE);
|
|
case WM_NOTIFY:
|
|
{
|
|
LPNMLISTVIEW pnmh = (LPNMLISTVIEW) lParam;
|
|
if (pnmh->hdr.code == LVN_DELETEITEM)
|
|
{
|
|
switch(wParam)
|
|
{
|
|
case IDC_LIST1:
|
|
CertFreeCertificateContext((PCCERT_CONTEXT)m_list1.GetItemData(pnmh->iItem));
|
|
break;
|
|
case IDC_LIST2:
|
|
CertFreeCertificateContext((PCCERT_CONTEXT)m_list2.GetItemData(pnmh->iItem));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return CPropertyPage::WindowProc(message, wParam, lParam);
|
|
default:
|
|
return CPropertyPage::WindowProc(message, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
void CSignatures::RefreshData(void)
|
|
{
|
|
// populate the listview controls
|
|
|
|
m_list1.DeleteAllItems();
|
|
m_list2.DeleteAllItems();
|
|
|
|
HCERTSTORE hCertStore = NULL;;
|
|
PCCERT_CONTEXT pcLocalCert = NULL;
|
|
|
|
//
|
|
// open the local cert store
|
|
//
|
|
|
|
hCertStore = CertOpenStore( CERT_STORE_PROV_FILENAME,
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
NULL,
|
|
// CERT_FILE_STORE_COMMIT_ENABLE_FLAG,
|
|
CERT_STORE_READONLY_FLAG,
|
|
m_szTempInstallableStore);
|
|
|
|
if (hCertStore)
|
|
{
|
|
//
|
|
// Enumerate the cert store
|
|
//
|
|
|
|
int i = 0;
|
|
|
|
for (;;) {
|
|
pcLocalCert = CertEnumCertificatesInStore(hCertStore, pcLocalCert);
|
|
|
|
if (!pcLocalCert) {
|
|
if (GetLastError() != CRYPT_E_NOT_FOUND )
|
|
{
|
|
DebugMsg((DM_WARNING, TEXT("CSignatures::RefreshData : Failed to enumerate certificate store.")));
|
|
}
|
|
break;
|
|
}
|
|
|
|
TCHAR szCertName[1024];
|
|
TCHAR szIssuerName[1024];
|
|
// crack open the returned certificate and display the data
|
|
CertGetNameString(pcLocalCert,
|
|
CERT_NAME_FRIENDLY_DISPLAY_TYPE,
|
|
0,
|
|
NULL,
|
|
szCertName,
|
|
sizeof(szCertName) / sizeof(szCertName[0]));
|
|
|
|
CertGetNameString(pcLocalCert,
|
|
CERT_NAME_FRIENDLY_DISPLAY_TYPE,
|
|
CERT_NAME_ISSUER_FLAG,
|
|
NULL,
|
|
szIssuerName,
|
|
sizeof(szCertName) / sizeof(szCertName[0]));
|
|
|
|
CTime tExpires(pcLocalCert->pCertInfo->NotAfter);
|
|
CString szExpires = tExpires.Format(TEXT("%x"));
|
|
|
|
i = m_list1.InsertItem(i, szCertName, 0);
|
|
m_list1.SetItem(i, 1, LVIF_TEXT, szIssuerName, 0, 0, 0, 0);
|
|
m_list1.SetItem(i, 2, LVIF_TEXT, szExpires, 0, 0, 0, 0);
|
|
m_list1.SetItemData(i, (DWORD_PTR)CertDuplicateCertificateContext(pcLocalCert));
|
|
|
|
//pcLocalCert should get deleted when it is repassed into CertEnumCerti..
|
|
}
|
|
CertCloseStore(hCertStore, 0);
|
|
}
|
|
|
|
//
|
|
// open the local cert store
|
|
//
|
|
|
|
hCertStore = CertOpenStore( CERT_STORE_PROV_FILENAME,
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
NULL,
|
|
// CERT_FILE_STORE_COMMIT_ENABLE_FLAG,
|
|
CERT_STORE_READONLY_FLAG,
|
|
m_szTempNonInstallableStore);
|
|
|
|
if (hCertStore)
|
|
{
|
|
//
|
|
// Enumerate the cert store
|
|
//
|
|
|
|
int i = 0;
|
|
|
|
for (;;) {
|
|
pcLocalCert = CertEnumCertificatesInStore(hCertStore, pcLocalCert);
|
|
|
|
if (!pcLocalCert) {
|
|
if (GetLastError() != CRYPT_E_NOT_FOUND )
|
|
{
|
|
DebugMsg((DM_WARNING, TEXT("CSignatures::RefreshData : Failed to enumerate certificate store.")));
|
|
}
|
|
break;
|
|
}
|
|
|
|
TCHAR szCertName[1024];
|
|
TCHAR szIssuerName[1024];
|
|
// crack open the returned certificate and display the data
|
|
CertGetNameString(pcLocalCert,
|
|
CERT_NAME_FRIENDLY_DISPLAY_TYPE,
|
|
0,
|
|
NULL,
|
|
szCertName,
|
|
sizeof(szCertName) / sizeof(szCertName[0]));
|
|
|
|
CertGetNameString(pcLocalCert,
|
|
CERT_NAME_FRIENDLY_DISPLAY_TYPE,
|
|
CERT_NAME_ISSUER_FLAG,
|
|
NULL,
|
|
szIssuerName,
|
|
sizeof(szCertName) / sizeof(szCertName[0]));
|
|
|
|
CTime tExpires(pcLocalCert->pCertInfo->NotAfter);
|
|
CString szExpires = tExpires.Format(TEXT("%x"));
|
|
|
|
i = m_list2.InsertItem(i, szCertName, 0);
|
|
m_list2.SetItem(i, 1, LVIF_TEXT, szIssuerName, 0, 0, 0, 0);
|
|
m_list2.SetItem(i, 2, LVIF_TEXT, szExpires, 0, 0, 0, 0);
|
|
m_list2.SetItemData(i, (DWORD_PTR)CertDuplicateCertificateContext(pcLocalCert));
|
|
|
|
//pcLocalCert should get deleted when it is repassed into CertEnumCerti..
|
|
}
|
|
CertCloseStore(hCertStore, 0);
|
|
}
|
|
|
|
OnAllowChanged();
|
|
|
|
SetModified(FALSE);
|
|
}
|
|
|
|
|
|
void CSignatures::OnContextMenu(CWnd* pWnd, CPoint point)
|
|
{
|
|
StandardContextMenu(pWnd->m_hWnd, IDD_FILE_EXT);
|
|
}
|
|
#endif // DIGITAL_SIGNATURES
|