mirror of
https://github.com/reactos/wine.git
synced 2024-12-08 03:47:09 +00:00
7060 lines
223 KiB
C
7060 lines
223 KiB
C
/*
|
|
* Copyright 2008 Juan Lang
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdarg.h>
|
|
|
|
#define COBJMACROS
|
|
#define NONAMELESSUNION
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winnls.h"
|
|
#include "winuser.h"
|
|
#include "softpub.h"
|
|
#include "wingdi.h"
|
|
#include "richedit.h"
|
|
#include "ole2.h"
|
|
#include "richole.h"
|
|
#include "commdlg.h"
|
|
#include "commctrl.h"
|
|
#include "cryptuiapi.h"
|
|
#include "cryptuires.h"
|
|
#include "urlmon.h"
|
|
#include "hlink.h"
|
|
#include "winreg.h"
|
|
#include "wine/debug.h"
|
|
#include "wine/unicode.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(cryptui);
|
|
|
|
static HINSTANCE hInstance;
|
|
|
|
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
|
|
{
|
|
TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
|
|
|
|
switch (fdwReason)
|
|
{
|
|
case DLL_WINE_PREATTACH:
|
|
return FALSE; /* prefer native version */
|
|
case DLL_PROCESS_ATTACH:
|
|
hInstance = hinstDLL;
|
|
DisableThreadLibraryCalls(hinstDLL);
|
|
break;
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#define MAX_STRING_LEN 512
|
|
|
|
static void add_cert_columns(HWND hwnd)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
RECT rc;
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
LVCOLUMNW column;
|
|
|
|
SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
|
|
GetWindowRect(lv, &rc);
|
|
LoadStringW(hInstance, IDS_SUBJECT_COLUMN, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
column.mask = LVCF_WIDTH | LVCF_TEXT;
|
|
column.cx = (rc.right - rc.left) * 29 / 100 - 2;
|
|
column.pszText = buf;
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
|
|
LoadStringW(hInstance, IDS_ISSUER_COLUMN, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
|
|
column.cx = (rc.right - rc.left) * 16 / 100 - 2;
|
|
LoadStringW(hInstance, IDS_EXPIRATION_COLUMN, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 2, (LPARAM)&column);
|
|
column.cx = (rc.right - rc.left) * 23 / 100 - 1;
|
|
LoadStringW(hInstance, IDS_FRIENDLY_NAME_COLUMN, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 3, (LPARAM)&column);
|
|
}
|
|
|
|
static void add_cert_to_view(HWND lv, PCCERT_CONTEXT cert, DWORD *allocatedLen,
|
|
LPWSTR *str)
|
|
{
|
|
DWORD len;
|
|
LVITEMW item;
|
|
WCHAR dateFmt[80]; /* sufficient for LOCALE_SSHORTDATE */
|
|
WCHAR date[80];
|
|
SYSTEMTIME sysTime;
|
|
LPWSTR none;
|
|
|
|
item.mask = LVIF_IMAGE | LVIF_PARAM | LVIF_TEXT;
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
item.iImage = 0;
|
|
item.lParam = (LPARAM)CertDuplicateCertificateContext(cert);
|
|
len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
|
|
NULL, 0);
|
|
if (len > *allocatedLen)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *str);
|
|
*str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (*str)
|
|
*allocatedLen = len;
|
|
}
|
|
if (*str)
|
|
{
|
|
CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
|
|
*str, len);
|
|
item.pszText = *str;
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
}
|
|
|
|
item.mask = LVIF_TEXT;
|
|
len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
|
|
CERT_NAME_ISSUER_FLAG, NULL, NULL, 0);
|
|
if (len > *allocatedLen)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *str);
|
|
*str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (*str)
|
|
*allocatedLen = len;
|
|
}
|
|
if (*str)
|
|
{
|
|
CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
|
|
CERT_NAME_ISSUER_FLAG, NULL, *str, len);
|
|
item.pszText = *str;
|
|
item.iSubItem = 1;
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
}
|
|
|
|
GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
|
|
sizeof(dateFmt) / sizeof(dateFmt[0]));
|
|
FileTimeToSystemTime(&cert->pCertInfo->NotAfter, &sysTime);
|
|
GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
|
|
sizeof(date) / sizeof(date[0]));
|
|
item.pszText = date;
|
|
item.iSubItem = 2;
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
|
|
if (!CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID,
|
|
NULL, &len))
|
|
len = LoadStringW(hInstance, IDS_FRIENDLY_NAME_NONE, (LPWSTR)&none, 0);
|
|
if (len > *allocatedLen)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *str);
|
|
*str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (*str)
|
|
*allocatedLen = len;
|
|
}
|
|
if (*str)
|
|
{
|
|
if (!CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID,
|
|
*str, &len))
|
|
item.pszText = none;
|
|
else
|
|
item.pszText = *str;
|
|
item.iSubItem = 3;
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
}
|
|
}
|
|
|
|
static LPSTR get_cert_mgr_usages(void)
|
|
{
|
|
static const WCHAR keyName[] = { 'S','o','f','t','w','a','r','e','\\','M',
|
|
'i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g','r','a',
|
|
'p','h','y','\\','U','I','\\','C','e','r','t','m','g','r','\\','P','u',
|
|
'r','p','o','s','e',0 };
|
|
LPSTR str = NULL;
|
|
HKEY key;
|
|
|
|
if (!RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, NULL, 0, KEY_READ,
|
|
NULL, &key, NULL))
|
|
{
|
|
LONG rc;
|
|
DWORD type, size;
|
|
|
|
rc = RegQueryValueExA(key, "Purpose", NULL, &type, NULL, &size);
|
|
if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
|
|
{
|
|
str = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (str)
|
|
{
|
|
rc = RegQueryValueExA(key, "Purpose", NULL, NULL, (LPBYTE)str,
|
|
&size);
|
|
if (rc)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
str = NULL;
|
|
}
|
|
}
|
|
}
|
|
RegCloseKey(key);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
typedef enum {
|
|
PurposeFilterShowAll = 0,
|
|
PurposeFilterShowAdvanced = 1,
|
|
PurposeFilterShowOID = 2
|
|
} PurposeFilter;
|
|
|
|
static void initialize_purpose_selection(HWND hwnd)
|
|
{
|
|
HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
LPSTR usages;
|
|
int index;
|
|
|
|
LoadStringW(hInstance, IDS_PURPOSE_ALL, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
|
|
SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)PurposeFilterShowAll);
|
|
LoadStringW(hInstance, IDS_PURPOSE_ADVANCED, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
|
|
SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)PurposeFilterShowAdvanced);
|
|
SendMessageW(cb, CB_SETCURSEL, 0, 0);
|
|
if ((usages = get_cert_mgr_usages()))
|
|
{
|
|
LPSTR ptr, comma;
|
|
|
|
for (ptr = usages, comma = strchr(ptr, ','); ptr && *ptr;
|
|
ptr = comma ? comma + 1 : NULL,
|
|
comma = ptr ? strchr(ptr, ',') : NULL)
|
|
{
|
|
PCCRYPT_OID_INFO info;
|
|
|
|
if (comma)
|
|
*comma = 0;
|
|
if ((info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, ptr, 0)))
|
|
{
|
|
index = SendMessageW(cb, CB_INSERTSTRING, 0,
|
|
(LPARAM)info->pwszName);
|
|
SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)info);
|
|
}
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, usages);
|
|
}
|
|
}
|
|
|
|
extern BOOL WINAPI WTHelperGetKnownUsages(DWORD action,
|
|
PCCRYPT_OID_INFO **usages);
|
|
|
|
static CERT_ENHKEY_USAGE *add_oid_to_usage(CERT_ENHKEY_USAGE *usage, LPSTR oid)
|
|
{
|
|
if (!usage->cUsageIdentifier)
|
|
usage->rgpszUsageIdentifier = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(LPSTR));
|
|
else
|
|
usage->rgpszUsageIdentifier = HeapReAlloc(GetProcessHeap(), 0,
|
|
usage->rgpszUsageIdentifier,
|
|
(usage->cUsageIdentifier + 1) * sizeof(LPSTR));
|
|
if (usage->rgpszUsageIdentifier)
|
|
usage->rgpszUsageIdentifier[usage->cUsageIdentifier++] = oid;
|
|
else
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
usage = NULL;
|
|
}
|
|
return usage;
|
|
}
|
|
|
|
static CERT_ENHKEY_USAGE *convert_usages_str_to_usage(LPSTR usageStr)
|
|
{
|
|
CERT_ENHKEY_USAGE *usage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(CERT_ENHKEY_USAGE));
|
|
|
|
if (usage)
|
|
{
|
|
LPSTR ptr, comma;
|
|
|
|
for (ptr = usageStr, comma = strchr(ptr, ','); usage && ptr && *ptr;
|
|
ptr = comma ? comma + 1 : NULL,
|
|
comma = ptr ? strchr(ptr, ',') : NULL)
|
|
{
|
|
if (comma)
|
|
*comma = 0;
|
|
add_oid_to_usage(usage, ptr);
|
|
}
|
|
}
|
|
return usage;
|
|
}
|
|
|
|
static CERT_ENHKEY_USAGE *create_advanced_filter(void)
|
|
{
|
|
CERT_ENHKEY_USAGE *advancedUsage = HeapAlloc(GetProcessHeap(),
|
|
HEAP_ZERO_MEMORY, sizeof(CERT_ENHKEY_USAGE));
|
|
|
|
if (advancedUsage)
|
|
{
|
|
PCCRYPT_OID_INFO *usages;
|
|
|
|
if (WTHelperGetKnownUsages(1, &usages))
|
|
{
|
|
LPSTR disabledUsagesStr;
|
|
|
|
if ((disabledUsagesStr = get_cert_mgr_usages()))
|
|
{
|
|
CERT_ENHKEY_USAGE *disabledUsages =
|
|
convert_usages_str_to_usage(disabledUsagesStr);
|
|
|
|
if (disabledUsages)
|
|
{
|
|
PCCRYPT_OID_INFO *ptr;
|
|
|
|
for (ptr = usages; *ptr; ptr++)
|
|
{
|
|
DWORD i;
|
|
BOOL disabled = FALSE;
|
|
|
|
for (i = 0; !disabled &&
|
|
i < disabledUsages->cUsageIdentifier; i++)
|
|
if (!strcmp(disabledUsages->rgpszUsageIdentifier[i],
|
|
(*ptr)->pszOID))
|
|
disabled = TRUE;
|
|
if (!disabled)
|
|
add_oid_to_usage(advancedUsage,
|
|
(LPSTR)(*ptr)->pszOID);
|
|
}
|
|
/* The individual strings are pointers to disabledUsagesStr,
|
|
* so they're freed when it is.
|
|
*/
|
|
HeapFree(GetProcessHeap(), 0,
|
|
disabledUsages->rgpszUsageIdentifier);
|
|
HeapFree(GetProcessHeap(), 0, disabledUsages);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, disabledUsagesStr);
|
|
}
|
|
WTHelperGetKnownUsages(2, &usages);
|
|
}
|
|
}
|
|
return advancedUsage;
|
|
}
|
|
|
|
static int CALLBACK cert_mgr_sort_by_subject(LPARAM lp1, LPARAM lp2, LPARAM lp);
|
|
|
|
static void show_store_certs(HWND hwnd, HCERTSTORE store)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
|
|
PCCERT_CONTEXT cert = NULL;
|
|
DWORD allocatedLen = 0;
|
|
LPWSTR str = NULL;
|
|
int index;
|
|
PurposeFilter filter = PurposeFilterShowAll;
|
|
LPCSTR oid = NULL;
|
|
CERT_ENHKEY_USAGE *advanced = NULL;
|
|
|
|
index = SendMessageW(cb, CB_GETCURSEL, 0, 0);
|
|
if (index >= 0)
|
|
{
|
|
INT_PTR data = SendMessageW(cb, CB_GETITEMDATA, index, 0);
|
|
|
|
if (!HIWORD(data))
|
|
filter = data;
|
|
else
|
|
{
|
|
PCCRYPT_OID_INFO info = (PCCRYPT_OID_INFO)data;
|
|
|
|
filter = PurposeFilterShowOID;
|
|
oid = info->pszOID;
|
|
}
|
|
}
|
|
if (filter == PurposeFilterShowAdvanced)
|
|
advanced = create_advanced_filter();
|
|
do {
|
|
cert = CertEnumCertificatesInStore(store, cert);
|
|
if (cert)
|
|
{
|
|
BOOL show = FALSE;
|
|
|
|
if (filter == PurposeFilterShowAll)
|
|
show = TRUE;
|
|
else
|
|
{
|
|
int numOIDs;
|
|
DWORD cbOIDs = 0;
|
|
|
|
if (CertGetValidUsages(1, &cert, &numOIDs, NULL, &cbOIDs))
|
|
{
|
|
if (numOIDs == -1)
|
|
{
|
|
/* -1 implies all usages are valid */
|
|
show = TRUE;
|
|
}
|
|
else
|
|
{
|
|
LPSTR *oids = HeapAlloc(GetProcessHeap(), 0, cbOIDs);
|
|
|
|
if (oids)
|
|
{
|
|
if (CertGetValidUsages(1, &cert, &numOIDs, oids,
|
|
&cbOIDs))
|
|
{
|
|
int i;
|
|
|
|
if (filter == PurposeFilterShowOID)
|
|
{
|
|
for (i = 0; !show && i < numOIDs; i++)
|
|
if (!strcmp(oids[i], oid))
|
|
show = TRUE;
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; !show && i < numOIDs; i++)
|
|
{
|
|
DWORD j;
|
|
|
|
for (j = 0; !show &&
|
|
j < advanced->cUsageIdentifier; j++)
|
|
if (!strcmp(oids[i],
|
|
advanced->rgpszUsageIdentifier[j]))
|
|
show = TRUE;
|
|
}
|
|
}
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, oids);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (show)
|
|
add_cert_to_view(lv, cert, &allocatedLen, &str);
|
|
}
|
|
} while (cert);
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
if (advanced)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, advanced->rgpszUsageIdentifier);
|
|
HeapFree(GetProcessHeap(), 0, advanced);
|
|
}
|
|
SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
|
|
(LPARAM)cert_mgr_sort_by_subject);
|
|
}
|
|
|
|
static const WCHAR my[] = { 'M','y',0 };
|
|
static const WCHAR addressBook[] = {
|
|
'A','d','d','r','e','s','s','B','o','o','k',0 };
|
|
static const WCHAR ca[] = { 'C','A',0 };
|
|
static const WCHAR root[] = { 'R','o','o','t',0 };
|
|
static const WCHAR trustedPublisher[] = {
|
|
'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0 };
|
|
static const WCHAR disallowed[] = { 'D','i','s','a','l','l','o','w','e','d',0 };
|
|
|
|
struct CertMgrStoreInfo
|
|
{
|
|
LPCWSTR name;
|
|
int removeWarning;
|
|
int removePluralWarning;
|
|
};
|
|
|
|
static const struct CertMgrStoreInfo defaultStoreList[] = {
|
|
{ my, IDS_WARN_REMOVE_MY, IDS_WARN_REMOVE_PLURAL_MY },
|
|
{ addressBook, IDS_WARN_REMOVE_ADDRESSBOOK,
|
|
IDS_WARN_REMOVE_PLURAL_ADDRESSBOOK },
|
|
{ ca, IDS_WARN_REMOVE_CA, IDS_WARN_REMOVE_PLURAL_CA },
|
|
{ root, IDS_WARN_REMOVE_ROOT, IDS_WARN_REMOVE_PLURAL_ROOT },
|
|
{ trustedPublisher, IDS_WARN_REMOVE_TRUSTEDPUBLISHER,
|
|
IDS_WARN_REMOVE_PLURAL_TRUSTEDPUBLISHER },
|
|
{ disallowed, IDS_WARN_REMOVE_DEFAULT },
|
|
};
|
|
|
|
static const struct CertMgrStoreInfo publisherStoreList[] = {
|
|
{ root, IDS_WARN_REMOVE_ROOT, IDS_WARN_REMOVE_PLURAL_ROOT },
|
|
{ trustedPublisher, IDS_WARN_REMOVE_TRUSTEDPUBLISHER,
|
|
IDS_WARN_REMOVE_PLURAL_TRUSTEDPUBLISHER },
|
|
{ disallowed, IDS_WARN_REMOVE_PLURAL_DEFAULT },
|
|
};
|
|
|
|
struct CertMgrData
|
|
{
|
|
HIMAGELIST imageList;
|
|
LPCWSTR title;
|
|
DWORD nStores;
|
|
const struct CertMgrStoreInfo *stores;
|
|
};
|
|
|
|
static void show_cert_stores(HWND hwnd, DWORD dwFlags, struct CertMgrData *data)
|
|
{
|
|
const struct CertMgrStoreInfo *storeList;
|
|
int cStores, i;
|
|
HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
|
|
|
|
if (dwFlags & CRYPTUI_CERT_MGR_PUBLISHER_TAB)
|
|
{
|
|
storeList = publisherStoreList;
|
|
cStores = sizeof(publisherStoreList) / sizeof(publisherStoreList[0]);
|
|
}
|
|
else
|
|
{
|
|
storeList = defaultStoreList;
|
|
cStores = sizeof(defaultStoreList) / sizeof(defaultStoreList[0]);
|
|
}
|
|
if (dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
|
|
cStores = 1;
|
|
data->nStores = cStores;
|
|
data->stores = storeList;
|
|
for (i = 0; i < cStores; i++)
|
|
{
|
|
LPCWSTR name;
|
|
TCITEMW item;
|
|
HCERTSTORE store;
|
|
|
|
if (!(name = CryptFindLocalizedName(storeList[i].name)))
|
|
name = storeList[i].name;
|
|
store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
|
|
CERT_SYSTEM_STORE_CURRENT_USER, storeList[i].name);
|
|
item.mask = TCIF_TEXT | TCIF_PARAM;
|
|
item.pszText = (LPWSTR)name;
|
|
item.lParam = (LPARAM)store;
|
|
SendMessageW(tab, TCM_INSERTITEMW, i, (LPARAM)&item);
|
|
}
|
|
}
|
|
|
|
static void free_certs(HWND lv)
|
|
{
|
|
LVITEMW item;
|
|
int items = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
|
|
|
|
for (i = 0; i < items; i++)
|
|
{
|
|
item.mask = LVIF_PARAM;
|
|
item.iItem = i;
|
|
item.iSubItem = 0;
|
|
SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
|
|
CertFreeCertificateContext((PCCERT_CONTEXT)item.lParam);
|
|
}
|
|
}
|
|
|
|
static HCERTSTORE cert_mgr_index_to_store(HWND tab, int index)
|
|
{
|
|
TCITEMW item;
|
|
|
|
item.mask = TCIF_PARAM;
|
|
SendMessageW(tab, TCM_GETITEMW, index, (LPARAM)&item);
|
|
return (HCERTSTORE)item.lParam;
|
|
}
|
|
|
|
static HCERTSTORE cert_mgr_current_store(HWND hwnd)
|
|
{
|
|
HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
|
|
|
|
return cert_mgr_index_to_store(tab, SendMessageW(tab, TCM_GETCURSEL, 0, 0));
|
|
}
|
|
|
|
static void close_stores(HWND tab)
|
|
{
|
|
int i, tabs = SendMessageW(tab, TCM_GETITEMCOUNT, 0, 0);
|
|
|
|
for (i = 0; i < tabs; i++)
|
|
CertCloseStore(cert_mgr_index_to_store(tab, i), 0);
|
|
}
|
|
|
|
static void refresh_store_certs(HWND hwnd)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
|
|
free_certs(lv);
|
|
SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
|
|
show_store_certs(hwnd, cert_mgr_current_store(hwnd));
|
|
}
|
|
|
|
typedef enum {
|
|
CheckBitmapIndexUnchecked = 1,
|
|
CheckBitmapIndexChecked = 2,
|
|
CheckBitmapIndexDisabledUnchecked = 3,
|
|
CheckBitmapIndexDisabledChecked = 4
|
|
} CheckBitmapIndex;
|
|
|
|
static void add_known_usage(HWND lv, PCCRYPT_OID_INFO info,
|
|
CheckBitmapIndex state)
|
|
{
|
|
LVITEMW item;
|
|
|
|
item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
|
|
item.state = INDEXTOSTATEIMAGEMASK(state);
|
|
item.stateMask = LVIS_STATEIMAGEMASK;
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
item.lParam = (LPARAM)info;
|
|
item.pszText = (LPWSTR)info->pwszName;
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
}
|
|
|
|
static void add_known_usages_to_list(HWND lv, CheckBitmapIndex state)
|
|
{
|
|
PCCRYPT_OID_INFO *usages;
|
|
|
|
if (WTHelperGetKnownUsages(1, &usages))
|
|
{
|
|
PCCRYPT_OID_INFO *ptr;
|
|
|
|
for (ptr = usages; *ptr; ptr++)
|
|
add_known_usage(lv, *ptr, state);
|
|
WTHelperGetKnownUsages(2, &usages);
|
|
}
|
|
}
|
|
|
|
static void toggle_usage(HWND hwnd, int iItem)
|
|
{
|
|
LVITEMW item;
|
|
int res;
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
|
|
item.mask = LVIF_STATE;
|
|
item.iItem = iItem;
|
|
item.iSubItem = 0;
|
|
item.stateMask = LVIS_STATEIMAGEMASK;
|
|
res = SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
|
|
if (res)
|
|
{
|
|
int state = item.state >> 12;
|
|
|
|
item.state = INDEXTOSTATEIMAGEMASK(
|
|
state == CheckBitmapIndexChecked ? CheckBitmapIndexUnchecked :
|
|
CheckBitmapIndexChecked);
|
|
SendMessageW(lv, LVM_SETITEMSTATE, iItem, (LPARAM)&item);
|
|
}
|
|
}
|
|
|
|
static LONG_PTR find_oid_in_list(HWND lv, LPCSTR oid)
|
|
{
|
|
PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
|
|
(void *)oid, CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
|
|
LONG_PTR ret;
|
|
|
|
if (oidInfo)
|
|
{
|
|
LVFINDINFOW findInfo;
|
|
|
|
findInfo.flags = LVFI_PARAM;
|
|
findInfo.lParam = (LPARAM)oidInfo;
|
|
ret = SendMessageW(lv, LVM_FINDITEMW, -1, (LPARAM)&findInfo);
|
|
}
|
|
else
|
|
{
|
|
LVFINDINFOA findInfo;
|
|
|
|
findInfo.flags = LVFI_STRING;
|
|
findInfo.psz = oid;
|
|
ret = SendMessageW(lv, LVM_FINDITEMA, -1, (LPARAM)&findInfo);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void save_cert_mgr_usages(HWND hwnd)
|
|
{
|
|
static const WCHAR keyName[] = { 'S','o','f','t','w','a','r','e','\\','M',
|
|
'i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g','r','a',
|
|
'p','h','y','\\','U','I','\\','C','e','r','t','m','g','r','\\','P','u',
|
|
'r','p','o','s','e',0 };
|
|
HKEY key;
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
|
|
LVITEMW item;
|
|
LPSTR str = NULL;
|
|
|
|
item.mask = LVIF_STATE | LVIF_PARAM;
|
|
item.iSubItem = 0;
|
|
item.stateMask = LVIS_STATEIMAGEMASK;
|
|
for (i = 0; i < purposes; i++)
|
|
{
|
|
item.iItem = i;
|
|
if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
|
|
{
|
|
int state = item.state >> 12;
|
|
|
|
if (state == CheckBitmapIndexUnchecked)
|
|
{
|
|
CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
|
|
BOOL firstString = TRUE;
|
|
|
|
if (!str)
|
|
str = HeapAlloc(GetProcessHeap(), 0,
|
|
strlen(info->pszOID) + 1);
|
|
else
|
|
{
|
|
str = HeapReAlloc(GetProcessHeap(), 0, str,
|
|
strlen(str) + 1 + strlen(info->pszOID) + 1);
|
|
firstString = FALSE;
|
|
}
|
|
if (str)
|
|
{
|
|
LPSTR ptr = firstString ? str : str + strlen(str);
|
|
|
|
if (!firstString)
|
|
*ptr++ = ',';
|
|
strcpy(ptr, info->pszOID);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, NULL, 0, KEY_ALL_ACCESS,
|
|
NULL, &key, NULL))
|
|
{
|
|
if (str)
|
|
RegSetValueExA(key, "Purpose", 0, REG_SZ, (const BYTE *)str,
|
|
strlen(str) + 1);
|
|
else
|
|
RegDeleteValueA(key, "Purpose");
|
|
RegCloseKey(key);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
}
|
|
|
|
static LRESULT CALLBACK cert_mgr_advanced_dlg_proc(HWND hwnd, UINT msg,
|
|
WPARAM wp, LPARAM lp)
|
|
{
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
RECT rc;
|
|
LVCOLUMNW column;
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
HIMAGELIST imageList;
|
|
LPSTR disabledUsages;
|
|
|
|
GetWindowRect(lv, &rc);
|
|
column.mask = LVCF_WIDTH;
|
|
column.cx = rc.right - rc.left;
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
|
|
imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 4, 0);
|
|
if (imageList)
|
|
{
|
|
HBITMAP bmp;
|
|
COLORREF backColor = RGB(255, 0, 255);
|
|
|
|
bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
|
|
ImageList_AddMasked(imageList, bmp, backColor);
|
|
DeleteObject(bmp);
|
|
ImageList_SetBkColor(imageList, CLR_NONE);
|
|
SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)imageList);
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)imageList);
|
|
}
|
|
add_known_usages_to_list(lv, CheckBitmapIndexChecked);
|
|
if ((disabledUsages = get_cert_mgr_usages()))
|
|
{
|
|
LPSTR ptr, comma;
|
|
|
|
for (ptr = disabledUsages, comma = strchr(ptr, ','); ptr && *ptr;
|
|
ptr = comma ? comma + 1 : NULL,
|
|
comma = ptr ? strchr(ptr, ',') : NULL)
|
|
{
|
|
LONG_PTR index;
|
|
|
|
if (comma)
|
|
*comma = 0;
|
|
if ((index = find_oid_in_list(lv, ptr)) != -1)
|
|
toggle_usage(hwnd, index);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, disabledUsages);
|
|
}
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
NMITEMACTIVATE *nm;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case NM_CLICK:
|
|
nm = (NMITEMACTIVATE *)lp;
|
|
toggle_usage(hwnd, nm->iItem);
|
|
SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDOK:
|
|
save_cert_mgr_usages(hwnd);
|
|
ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
|
|
EndDialog(hwnd, IDOK);
|
|
break;
|
|
case IDCANCEL:
|
|
ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
|
|
EndDialog(hwnd, IDCANCEL);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void cert_mgr_clear_cert_selection(HWND hwnd)
|
|
{
|
|
WCHAR empty[] = { 0 };
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_MGR_EXPORT), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_MGR_REMOVE), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_MGR_VIEW), FALSE);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_MGR_PURPOSES), WM_SETTEXT, 0,
|
|
(LPARAM)empty);
|
|
refresh_store_certs(hwnd);
|
|
}
|
|
|
|
static PCCERT_CONTEXT cert_mgr_index_to_cert(HWND hwnd, int index)
|
|
{
|
|
PCCERT_CONTEXT cert = NULL;
|
|
LVITEMW item;
|
|
|
|
item.mask = LVIF_PARAM;
|
|
item.iItem = index;
|
|
item.iSubItem = 0;
|
|
if (SendMessageW(GetDlgItem(hwnd, IDC_MGR_CERTS), LVM_GETITEMW, 0,
|
|
(LPARAM)&item))
|
|
cert = (PCCERT_CONTEXT)item.lParam;
|
|
return cert;
|
|
}
|
|
|
|
static void show_selected_cert(HWND hwnd, int index)
|
|
{
|
|
PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, index);
|
|
|
|
if (cert)
|
|
{
|
|
CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
|
|
|
|
memset(&viewInfo, 0, sizeof(viewInfo));
|
|
viewInfo.dwSize = sizeof(viewInfo);
|
|
viewInfo.hwndParent = hwnd;
|
|
viewInfo.pCertContext = cert;
|
|
/* FIXME: this should be modal */
|
|
CryptUIDlgViewCertificateW(&viewInfo, NULL);
|
|
}
|
|
}
|
|
|
|
static void cert_mgr_show_cert_usages(HWND hwnd, int index)
|
|
{
|
|
HWND text = GetDlgItem(hwnd, IDC_MGR_PURPOSES);
|
|
PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, index);
|
|
PCERT_ENHKEY_USAGE usage;
|
|
DWORD size;
|
|
|
|
/* Get enhanced key usage. Have to check for a property and an extension
|
|
* separately, because CertGetEnhancedKeyUsage will succeed and return an
|
|
* empty usage if neither is set. Unfortunately an empty usage implies
|
|
* no usage is allowed, so we have to distinguish between the two cases.
|
|
*/
|
|
if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
|
|
NULL, &size))
|
|
{
|
|
usage = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!CertGetEnhancedKeyUsage(cert,
|
|
CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
usage = NULL;
|
|
}
|
|
}
|
|
else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
|
|
NULL, &size))
|
|
{
|
|
usage = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!CertGetEnhancedKeyUsage(cert,
|
|
CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
usage = NULL;
|
|
}
|
|
}
|
|
else
|
|
usage = NULL;
|
|
if (usage)
|
|
{
|
|
if (usage->cUsageIdentifier)
|
|
{
|
|
static const WCHAR commaSpace[] = { ',',' ',0 };
|
|
DWORD i, len = 1;
|
|
LPWSTR str, ptr;
|
|
|
|
for (i = 0; i < usage->cUsageIdentifier; i++)
|
|
{
|
|
PCCRYPT_OID_INFO info =
|
|
CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
|
|
usage->rgpszUsageIdentifier[i],
|
|
CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
|
|
|
|
if (info)
|
|
len += strlenW(info->pwszName);
|
|
else
|
|
len += strlen(usage->rgpszUsageIdentifier[i]);
|
|
if (i < usage->cUsageIdentifier - 1)
|
|
len += strlenW(commaSpace);
|
|
}
|
|
str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (str)
|
|
{
|
|
for (i = 0, ptr = str; i < usage->cUsageIdentifier; i++)
|
|
{
|
|
PCCRYPT_OID_INFO info =
|
|
CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
|
|
usage->rgpszUsageIdentifier[i],
|
|
CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
|
|
|
|
if (info)
|
|
{
|
|
strcpyW(ptr, info->pwszName);
|
|
ptr += strlenW(info->pwszName);
|
|
}
|
|
else
|
|
{
|
|
LPCSTR src = usage->rgpszUsageIdentifier[i];
|
|
|
|
for (; *src; ptr++, src++)
|
|
*ptr = *src;
|
|
*ptr = 0;
|
|
}
|
|
if (i < usage->cUsageIdentifier - 1)
|
|
{
|
|
strcpyW(ptr, commaSpace);
|
|
ptr += strlenW(commaSpace);
|
|
}
|
|
}
|
|
*ptr = 0;
|
|
SendMessageW(text, WM_SETTEXT, 0, (LPARAM)str);
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
}
|
|
else
|
|
{
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, IDS_ALLOWED_PURPOSE_NONE, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
SendMessageW(text, WM_SETTEXT, 0, (LPARAM)buf);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, IDS_ALLOWED_PURPOSE_ALL, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
SendMessageW(text, WM_SETTEXT, 0, (LPARAM)buf);
|
|
}
|
|
}
|
|
|
|
static void cert_mgr_do_remove(HWND hwnd)
|
|
{
|
|
int tabIndex = SendMessageW(GetDlgItem(hwnd, IDC_MGR_STORES),
|
|
TCM_GETCURSEL, 0, 0);
|
|
struct CertMgrData *data =
|
|
(struct CertMgrData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
|
|
if (tabIndex < data->nStores)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
WCHAR warning[MAX_STRING_LEN], title[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
int warningID;
|
|
|
|
if (SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0) > 1)
|
|
warningID = data->stores[tabIndex].removePluralWarning;
|
|
else
|
|
warningID = data->stores[tabIndex].removeWarning;
|
|
if (data->title)
|
|
pTitle = data->title;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_CERT_MGR, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, warningID, warning,
|
|
sizeof(warning) / sizeof(warning[0]));
|
|
if (MessageBoxW(hwnd, warning, pTitle, MB_YESNO) == IDYES)
|
|
{
|
|
int selection = -1;
|
|
|
|
do {
|
|
selection = SendMessageW(lv, LVM_GETNEXTITEM, selection,
|
|
LVNI_SELECTED);
|
|
if (selection >= 0)
|
|
{
|
|
PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd,
|
|
selection);
|
|
|
|
CertDeleteCertificateFromStore(cert);
|
|
}
|
|
} while (selection >= 0);
|
|
cert_mgr_clear_cert_selection(hwnd);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void cert_mgr_do_export(HWND hwnd)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
int selectionCount = SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0);
|
|
|
|
if (selectionCount == 1)
|
|
{
|
|
int selection = SendMessageW(lv, LVM_GETNEXTITEM, -1,
|
|
LVNI_SELECTED);
|
|
|
|
if (selection >= 0)
|
|
{
|
|
PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, selection);
|
|
|
|
if (cert)
|
|
{
|
|
CRYPTUI_WIZ_EXPORT_INFO info;
|
|
|
|
info.dwSize = sizeof(info);
|
|
info.pwszExportFileName = NULL;
|
|
info.dwSubjectChoice = CRYPTUI_WIZ_EXPORT_CERT_CONTEXT;
|
|
info.u.pCertContext = cert;
|
|
info.cStores = 0;
|
|
CryptUIWizExport(0, hwnd, NULL, &info, NULL);
|
|
}
|
|
}
|
|
}
|
|
else if (selectionCount > 1)
|
|
{
|
|
HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
|
|
CERT_STORE_CREATE_NEW_FLAG, NULL);
|
|
|
|
if (store)
|
|
{
|
|
CRYPTUI_WIZ_EXPORT_INFO info;
|
|
int selection = -1;
|
|
|
|
info.dwSize = sizeof(info);
|
|
info.pwszExportFileName = NULL;
|
|
info.dwSubjectChoice =
|
|
CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY;
|
|
info.u.hCertStore = store;
|
|
info.cStores = 0;
|
|
do {
|
|
selection = SendMessageW(lv, LVM_GETNEXTITEM, selection,
|
|
LVNI_SELECTED);
|
|
if (selection >= 0)
|
|
{
|
|
PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd,
|
|
selection);
|
|
|
|
CertAddCertificateContextToStore(store, cert,
|
|
CERT_STORE_ADD_ALWAYS, NULL);
|
|
}
|
|
} while (selection >= 0);
|
|
CryptUIWizExport(0, hwnd, NULL, &info, NULL);
|
|
CertCloseStore(store, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int cert_mgr_sort_by_text(HWND lv, int col, int index1, int index2)
|
|
{
|
|
LVITEMW item;
|
|
WCHAR buf1[MAX_STRING_LEN];
|
|
WCHAR buf2[MAX_STRING_LEN];
|
|
|
|
item.cchTextMax = sizeof(buf1) / sizeof(buf1[0]);
|
|
item.mask = LVIF_TEXT;
|
|
item.pszText = buf1;
|
|
item.iItem = index1;
|
|
item.iSubItem = col;
|
|
SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
|
|
item.pszText = buf2;
|
|
item.iItem = index2;
|
|
SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
|
|
return strcmpW(buf1, buf2);
|
|
}
|
|
|
|
static int CALLBACK cert_mgr_sort_by_subject(LPARAM lp1, LPARAM lp2, LPARAM lp)
|
|
{
|
|
return cert_mgr_sort_by_text((HWND)lp, 0, lp1, lp2);
|
|
}
|
|
|
|
static int CALLBACK cert_mgr_sort_by_issuer(LPARAM lp1, LPARAM lp2, LPARAM lp)
|
|
{
|
|
return cert_mgr_sort_by_text((HWND)lp, 1, lp1, lp2);
|
|
}
|
|
|
|
static int CALLBACK cert_mgr_sort_by_date(LPARAM lp1, LPARAM lp2, LPARAM lp)
|
|
{
|
|
PCCERT_CONTEXT cert1 = (PCCERT_CONTEXT)lp1;
|
|
PCCERT_CONTEXT cert2 = (PCCERT_CONTEXT)lp2;
|
|
return CompareFileTime(&cert1->pCertInfo->NotAfter,
|
|
&cert2->pCertInfo->NotAfter);
|
|
}
|
|
|
|
static int CALLBACK cert_mgr_sort_by_friendly_name(LPARAM lp1, LPARAM lp2,
|
|
LPARAM lp)
|
|
{
|
|
return cert_mgr_sort_by_text((HWND)lp, 3, lp1, lp2);
|
|
}
|
|
|
|
static LRESULT CALLBACK cert_mgr_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
struct CertMgrData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr =
|
|
(PCCRYPTUI_CERT_MGR_STRUCT)lp;
|
|
HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
|
|
|
|
data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CertMgrData));
|
|
if (!data)
|
|
return 0;
|
|
data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
|
|
if (data->imageList)
|
|
{
|
|
HBITMAP bmp;
|
|
COLORREF backColor = RGB(255, 0, 255);
|
|
|
|
bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
|
|
ImageList_AddMasked(data->imageList, bmp, backColor);
|
|
DeleteObject(bmp);
|
|
ImageList_SetBkColor(data->imageList, CLR_NONE);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_MGR_CERTS), LVM_SETIMAGELIST,
|
|
LVSIL_SMALL, (LPARAM)data->imageList);
|
|
}
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
data->title = pCryptUICertMgr->pwszTitle;
|
|
|
|
initialize_purpose_selection(hwnd);
|
|
add_cert_columns(hwnd);
|
|
if (pCryptUICertMgr->pwszTitle)
|
|
SendMessageW(hwnd, WM_SETTEXT, 0,
|
|
(LPARAM)pCryptUICertMgr->pwszTitle);
|
|
show_cert_stores(hwnd, pCryptUICertMgr->dwFlags, data);
|
|
show_store_certs(hwnd, cert_mgr_index_to_store(tab, 0));
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case TCN_SELCHANGE:
|
|
cert_mgr_clear_cert_selection(hwnd);
|
|
break;
|
|
case LVN_ITEMCHANGED:
|
|
{
|
|
WCHAR empty[] = { 0 };
|
|
NMITEMACTIVATE *nm = (NMITEMACTIVATE*)lp;
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
int numSelected = SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0);
|
|
|
|
EnableWindow(GetDlgItem(hwnd, IDC_MGR_EXPORT), numSelected > 0);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_MGR_REMOVE), numSelected > 0);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_MGR_VIEW), numSelected == 1);
|
|
if (numSelected == 1)
|
|
cert_mgr_show_cert_usages(hwnd, nm->iItem);
|
|
else
|
|
SendMessageW(GetDlgItem(hwnd, IDC_MGR_PURPOSES), WM_SETTEXT, 0,
|
|
(LPARAM)empty);
|
|
break;
|
|
}
|
|
case NM_DBLCLK:
|
|
show_selected_cert(hwnd, ((NMITEMACTIVATE *)lp)->iItem);
|
|
break;
|
|
case LVN_KEYDOWN:
|
|
{
|
|
NMLVKEYDOWN *lvk = (NMLVKEYDOWN *)lp;
|
|
|
|
if (lvk->wVKey == VK_DELETE)
|
|
cert_mgr_do_remove(hwnd);
|
|
break;
|
|
}
|
|
case LVN_COLUMNCLICK:
|
|
{
|
|
NMLISTVIEW *nmlv = (NMLISTVIEW *)lp;
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
|
|
/* FIXME: doesn't support swapping sort order between ascending
|
|
* and descending.
|
|
*/
|
|
switch (nmlv->iSubItem)
|
|
{
|
|
case 0:
|
|
SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
|
|
(LPARAM)cert_mgr_sort_by_subject);
|
|
break;
|
|
case 1:
|
|
SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
|
|
(LPARAM)cert_mgr_sort_by_issuer);
|
|
break;
|
|
case 2:
|
|
SendMessageW(lv, LVM_SORTITEMS, 0,
|
|
(LPARAM)cert_mgr_sort_by_date);
|
|
break;
|
|
case 3:
|
|
SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
|
|
(LPARAM)cert_mgr_sort_by_friendly_name);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case ((CBN_SELCHANGE << 16) | IDC_MGR_PURPOSE_SELECTION):
|
|
cert_mgr_clear_cert_selection(hwnd);
|
|
break;
|
|
case IDC_MGR_IMPORT:
|
|
if (CryptUIWizImport(0, hwnd, NULL, NULL,
|
|
cert_mgr_current_store(hwnd)))
|
|
refresh_store_certs(hwnd);
|
|
break;
|
|
case IDC_MGR_ADVANCED:
|
|
if (DialogBoxW(hInstance, MAKEINTRESOURCEW(IDD_CERT_MGR_ADVANCED),
|
|
hwnd, cert_mgr_advanced_dlg_proc) == IDOK)
|
|
{
|
|
HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
|
|
int index, len;
|
|
LPWSTR curString = NULL;
|
|
|
|
index = SendMessageW(cb, CB_GETCURSEL, 0, 0);
|
|
if (index >= 0)
|
|
{
|
|
len = SendMessageW(cb, CB_GETLBTEXTLEN, index, 0);
|
|
curString = HeapAlloc(GetProcessHeap(), 0,
|
|
(len + 1) * sizeof(WCHAR));
|
|
SendMessageW(cb, CB_GETLBTEXT, index, (LPARAM)curString);
|
|
}
|
|
SendMessageW(cb, CB_RESETCONTENT, 0, 0);
|
|
initialize_purpose_selection(hwnd);
|
|
if (curString)
|
|
{
|
|
index = SendMessageW(cb, CB_FINDSTRINGEXACT, -1,
|
|
(LPARAM)curString);
|
|
if (index >= 0)
|
|
SendMessageW(cb, CB_SETCURSEL, index, 0);
|
|
HeapFree(GetProcessHeap(), 0, curString);
|
|
}
|
|
refresh_store_certs(hwnd);
|
|
}
|
|
break;
|
|
case IDC_MGR_VIEW:
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
|
|
int selection = SendMessageW(lv, LVM_GETNEXTITEM, -1,
|
|
LVNI_SELECTED);
|
|
|
|
if (selection >= 0)
|
|
show_selected_cert(hwnd, selection);
|
|
break;
|
|
}
|
|
case IDC_MGR_EXPORT:
|
|
cert_mgr_do_export(hwnd);
|
|
break;
|
|
case IDC_MGR_REMOVE:
|
|
cert_mgr_do_remove(hwnd);
|
|
break;
|
|
case IDCANCEL:
|
|
free_certs(GetDlgItem(hwnd, IDC_MGR_CERTS));
|
|
close_stores(GetDlgItem(hwnd, IDC_MGR_STORES));
|
|
data = (struct CertMgrData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
ImageList_Destroy(data->imageList);
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
EndDialog(hwnd, IDCANCEL);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* CryptUIDlgCertMgr (CRYPTUI.@)
|
|
*/
|
|
BOOL WINAPI CryptUIDlgCertMgr(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
|
|
{
|
|
TRACE("(%p)\n", pCryptUICertMgr);
|
|
|
|
if (pCryptUICertMgr->dwSize != sizeof(CRYPTUI_CERT_MGR_STRUCT))
|
|
{
|
|
WARN("unexpected size %d\n", pCryptUICertMgr->dwSize);
|
|
SetLastError(E_INVALIDARG);
|
|
return FALSE;
|
|
}
|
|
DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_CERT_MGR),
|
|
pCryptUICertMgr->hwndParent, cert_mgr_dlg_proc, (LPARAM)pCryptUICertMgr);
|
|
return TRUE;
|
|
}
|
|
|
|
/* FIXME: real names are unknown, functions are undocumented */
|
|
typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS
|
|
{
|
|
DWORD dwFlags;
|
|
void *pvSystemStoreLocationPara;
|
|
} CRYPTUI_ENUM_SYSTEM_STORE_ARGS, *PCRYPTUI_ENUM_SYSTEM_STORE_ARGS;
|
|
|
|
typedef struct _CRYPTUI_ENUM_DATA
|
|
{
|
|
DWORD cStores;
|
|
HCERTSTORE *rghStore;
|
|
DWORD cEnumArgs;
|
|
PCRYPTUI_ENUM_SYSTEM_STORE_ARGS rgEnumArgs;
|
|
} CRYPTUI_ENUM_DATA, *PCRYPTUI_ENUM_DATA;
|
|
|
|
typedef BOOL (WINAPI *PFN_SELECTED_STORE_CB)(HCERTSTORE store, HWND hwnd,
|
|
void *pvArg);
|
|
|
|
/* Values for dwFlags */
|
|
#define CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE 0x00000001
|
|
|
|
typedef struct _CRYPTUI_SELECTSTORE_INFO_A
|
|
{
|
|
DWORD dwSize;
|
|
HWND parent;
|
|
DWORD dwFlags;
|
|
LPSTR pszTitle;
|
|
LPSTR pszText;
|
|
CRYPTUI_ENUM_DATA *pEnumData;
|
|
PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
|
|
void *pvArg;
|
|
} CRYPTUI_SELECTSTORE_INFO_A, *PCRYPTUI_SELECTSTORE_INFO_A;
|
|
|
|
typedef struct _CRYPTUI_SELECTSTORE_INFO_W
|
|
{
|
|
DWORD dwSize;
|
|
HWND parent;
|
|
DWORD dwFlags;
|
|
LPWSTR pwszTitle;
|
|
LPWSTR pwszText;
|
|
CRYPTUI_ENUM_DATA *pEnumData;
|
|
PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
|
|
void *pvArg;
|
|
} CRYPTUI_SELECTSTORE_INFO_W, *PCRYPTUI_SELECTSTORE_INFO_W;
|
|
|
|
struct StoreInfo
|
|
{
|
|
enum {
|
|
StoreHandle,
|
|
SystemStore
|
|
} type;
|
|
union {
|
|
HCERTSTORE store;
|
|
LPWSTR name;
|
|
} DUMMYUNIONNAME;
|
|
};
|
|
|
|
static BOOL WINAPI enum_store_callback(const void *pvSystemStore,
|
|
DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved,
|
|
void *pvArg)
|
|
{
|
|
HWND tree = GetDlgItem(pvArg, IDC_STORE_LIST);
|
|
TVINSERTSTRUCTW tvis;
|
|
LPCWSTR localizedName;
|
|
BOOL ret = TRUE;
|
|
|
|
tvis.hParent = NULL;
|
|
tvis.hInsertAfter = TVI_LAST;
|
|
tvis.u.item.mask = TVIF_TEXT;
|
|
if ((localizedName = CryptFindLocalizedName(pvSystemStore)))
|
|
{
|
|
struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(struct StoreInfo));
|
|
|
|
if (storeInfo)
|
|
{
|
|
storeInfo->type = SystemStore;
|
|
storeInfo->u.name = HeapAlloc(GetProcessHeap(), 0,
|
|
(strlenW(pvSystemStore) + 1) * sizeof(WCHAR));
|
|
if (storeInfo->u.name)
|
|
{
|
|
tvis.u.item.mask |= TVIF_PARAM;
|
|
tvis.u.item.lParam = (LPARAM)storeInfo;
|
|
strcpyW(storeInfo->u.name, pvSystemStore);
|
|
}
|
|
else
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, storeInfo);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
tvis.u.item.pszText = (LPWSTR)localizedName;
|
|
}
|
|
else
|
|
tvis.u.item.pszText = (LPWSTR)pvSystemStore;
|
|
/* FIXME: need a folder icon for the store too */
|
|
if (ret)
|
|
SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
|
|
return ret;
|
|
}
|
|
|
|
static void enumerate_stores(HWND hwnd, CRYPTUI_ENUM_DATA *pEnumData)
|
|
{
|
|
DWORD i;
|
|
HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
|
|
|
|
for (i = 0; i < pEnumData->cEnumArgs; i++)
|
|
CertEnumSystemStore(pEnumData->rgEnumArgs[i].dwFlags,
|
|
pEnumData->rgEnumArgs[i].pvSystemStoreLocationPara,
|
|
hwnd, enum_store_callback);
|
|
for (i = 0; i < pEnumData->cStores; i++)
|
|
{
|
|
DWORD size;
|
|
|
|
if (CertGetStoreProperty(pEnumData->rghStore[i],
|
|
CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, &size))
|
|
{
|
|
LPWSTR name = HeapAlloc(GetProcessHeap(), 0, size);
|
|
|
|
if (name)
|
|
{
|
|
if (CertGetStoreProperty(pEnumData->rghStore[i],
|
|
CERT_STORE_LOCALIZED_NAME_PROP_ID, name, &size))
|
|
{
|
|
struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(),
|
|
0, sizeof(struct StoreInfo));
|
|
|
|
if (storeInfo)
|
|
{
|
|
TVINSERTSTRUCTW tvis;
|
|
|
|
storeInfo->type = StoreHandle;
|
|
storeInfo->u.store = pEnumData->rghStore[i];
|
|
tvis.hParent = NULL;
|
|
tvis.hInsertAfter = TVI_LAST;
|
|
tvis.u.item.mask = TVIF_TEXT | TVIF_PARAM;
|
|
tvis.u.item.pszText = name;
|
|
tvis.u.item.lParam = (LPARAM)storeInfo;
|
|
SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
|
|
}
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void free_store_info(HWND tree)
|
|
{
|
|
HTREEITEM next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CHILD,
|
|
0);
|
|
|
|
while (next)
|
|
{
|
|
TVITEMW item;
|
|
|
|
memset(&item, 0, sizeof(item));
|
|
item.mask = TVIF_HANDLE | TVIF_PARAM;
|
|
item.hItem = next;
|
|
SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
|
|
if (item.lParam)
|
|
{
|
|
struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
|
|
|
|
if (storeInfo->type == SystemStore)
|
|
HeapFree(GetProcessHeap(), 0, storeInfo->u.name);
|
|
HeapFree(GetProcessHeap(), 0, storeInfo);
|
|
}
|
|
next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_NEXT,
|
|
(LPARAM)next);
|
|
}
|
|
}
|
|
|
|
static HCERTSTORE selected_item_to_store(HWND tree, HTREEITEM hItem)
|
|
{
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
TVITEMW item;
|
|
HCERTSTORE store;
|
|
|
|
memset(&item, 0, sizeof(item));
|
|
item.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT;
|
|
item.hItem = hItem;
|
|
item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
|
|
item.pszText = buf;
|
|
SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
|
|
if (item.lParam)
|
|
{
|
|
struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
|
|
|
|
if (storeInfo->type == StoreHandle)
|
|
store = storeInfo->u.store;
|
|
else
|
|
store = CertOpenSystemStoreW(0, storeInfo->u.name);
|
|
}
|
|
else
|
|
{
|
|
/* It's implicitly a system store */
|
|
store = CertOpenSystemStoreW(0, buf);
|
|
}
|
|
return store;
|
|
}
|
|
|
|
struct SelectStoreInfo
|
|
{
|
|
PCRYPTUI_SELECTSTORE_INFO_W info;
|
|
HCERTSTORE store;
|
|
};
|
|
|
|
static LRESULT CALLBACK select_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
struct SelectStoreInfo *selectInfo;
|
|
LRESULT ret = 0;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
selectInfo = (struct SelectStoreInfo *)lp;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, lp);
|
|
if (selectInfo->info->pwszTitle)
|
|
SendMessageW(hwnd, WM_SETTEXT, 0,
|
|
(LPARAM)selectInfo->info->pwszTitle);
|
|
if (selectInfo->info->pwszText)
|
|
SendMessageW(GetDlgItem(hwnd, IDC_STORE_TEXT), WM_SETTEXT, 0,
|
|
(LPARAM)selectInfo->info->pwszText);
|
|
if (!(selectInfo->info->dwFlags & CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE))
|
|
ShowWindow(GetDlgItem(hwnd, IDC_SHOW_PHYSICAL_STORES), FALSE);
|
|
enumerate_stores(hwnd, selectInfo->info->pEnumData);
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDOK:
|
|
{
|
|
HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
|
|
HTREEITEM selection = (HTREEITEM)SendMessageW(tree,
|
|
TVM_GETNEXTITEM, TVGN_CARET, 0);
|
|
|
|
selectInfo = (struct SelectStoreInfo *)GetWindowLongPtrW(hwnd,
|
|
DWLP_USER);
|
|
if (!selection)
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN], *pTitle;
|
|
|
|
if (selectInfo->info->pwszTitle)
|
|
pTitle = selectInfo->info->pwszTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_SELECT_STORE_TITLE, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_SELECT_STORE, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
MessageBoxW(hwnd, error, pTitle, MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
else
|
|
{
|
|
HCERTSTORE store = selected_item_to_store(tree, selection);
|
|
|
|
if (!selectInfo->info->pfnSelectedStoreCallback ||
|
|
selectInfo->info->pfnSelectedStoreCallback(store, hwnd,
|
|
selectInfo->info->pvArg))
|
|
{
|
|
selectInfo->store = store;
|
|
free_store_info(tree);
|
|
EndDialog(hwnd, IDOK);
|
|
}
|
|
else
|
|
CertCloseStore(store, 0);
|
|
}
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
case IDCANCEL:
|
|
free_store_info(GetDlgItem(hwnd, IDC_STORE_LIST));
|
|
EndDialog(hwnd, IDCANCEL);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* CryptUIDlgSelectStoreW (CRYPTUI.@)
|
|
*/
|
|
HCERTSTORE WINAPI CryptUIDlgSelectStoreW(PCRYPTUI_SELECTSTORE_INFO_W info)
|
|
{
|
|
struct SelectStoreInfo selectInfo = { info, NULL };
|
|
|
|
TRACE("(%p)\n", info);
|
|
|
|
if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_W))
|
|
{
|
|
WARN("unexpected size %d\n", info->dwSize);
|
|
SetLastError(E_INVALIDARG);
|
|
return NULL;
|
|
}
|
|
DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_SELECT_STORE), info->parent,
|
|
select_store_dlg_proc, (LPARAM)&selectInfo);
|
|
return selectInfo.store;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* CryptUIDlgSelectStoreA (CRYPTUI.@)
|
|
*/
|
|
HCERTSTORE WINAPI CryptUIDlgSelectStoreA(PCRYPTUI_SELECTSTORE_INFO_A info)
|
|
{
|
|
CRYPTUI_SELECTSTORE_INFO_W infoW;
|
|
HCERTSTORE ret;
|
|
int len;
|
|
|
|
TRACE("(%p)\n", info);
|
|
|
|
if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_A))
|
|
{
|
|
WARN("unexpected size %d\n", info->dwSize);
|
|
SetLastError(E_INVALIDARG);
|
|
return NULL;
|
|
}
|
|
memcpy(&infoW, info, sizeof(*info));
|
|
if (info->pszTitle)
|
|
{
|
|
len = MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, NULL, 0);
|
|
infoW.pwszTitle = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, infoW.pwszTitle,
|
|
len);
|
|
}
|
|
if (info->pszText)
|
|
{
|
|
len = MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, NULL, 0);
|
|
infoW.pwszText = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, infoW.pwszText, len);
|
|
}
|
|
ret = CryptUIDlgSelectStoreW(&infoW);
|
|
HeapFree(GetProcessHeap(), 0, infoW.pwszText);
|
|
HeapFree(GetProcessHeap(), 0, infoW.pwszTitle);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* CryptUIDlgViewCertificateA (CRYPTUI.@)
|
|
*/
|
|
BOOL WINAPI CryptUIDlgViewCertificateA(
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
|
|
{
|
|
CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
|
|
LPWSTR title = NULL;
|
|
BOOL ret;
|
|
|
|
TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
|
|
|
|
memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
|
|
if (pCertViewInfo->szTitle)
|
|
{
|
|
int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
|
|
NULL, 0);
|
|
|
|
title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (title)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
|
|
len);
|
|
viewInfo.szTitle = title;
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
goto error;
|
|
}
|
|
}
|
|
if (pCertViewInfo->cPropSheetPages)
|
|
{
|
|
FIXME("ignoring additional prop sheet pages\n");
|
|
viewInfo.cPropSheetPages = 0;
|
|
}
|
|
ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
|
|
HeapFree(GetProcessHeap(), 0, title);
|
|
error:
|
|
return ret;
|
|
}
|
|
|
|
struct ReadStringStruct
|
|
{
|
|
LPCWSTR buf;
|
|
LONG pos;
|
|
LONG len;
|
|
};
|
|
|
|
static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
|
|
LONG cb, LONG *pcb)
|
|
{
|
|
struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
|
|
LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
|
|
|
|
TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
|
|
|
|
memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
|
|
string->pos += cch;
|
|
*pcb = cch * sizeof(WCHAR);
|
|
return 0;
|
|
}
|
|
|
|
static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
|
|
{
|
|
struct ReadStringStruct string;
|
|
EDITSTREAM editstream;
|
|
|
|
TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
|
|
|
|
string.buf = text;
|
|
string.pos = 0;
|
|
string.len = len;
|
|
editstream.dwCookie = (DWORD_PTR)&string;
|
|
editstream.dwError = 0;
|
|
editstream.pfnCallback = read_text_callback;
|
|
SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
|
|
(LPARAM)&editstream);
|
|
}
|
|
|
|
static void add_string_resource_to_control(HWND hwnd, int id)
|
|
{
|
|
LPWSTR str;
|
|
LONG len;
|
|
|
|
len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
|
|
add_unformatted_text_to_control(hwnd, str, len);
|
|
}
|
|
|
|
static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
|
|
LONG len, const PARAFORMAT2 *fmt)
|
|
{
|
|
add_unformatted_text_to_control(hwnd, text, len);
|
|
SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
|
|
}
|
|
|
|
static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
|
|
const PARAFORMAT2 *fmt)
|
|
{
|
|
LPWSTR str;
|
|
LONG len;
|
|
|
|
len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
|
|
add_text_with_paraformat_to_control(hwnd, str, len, fmt);
|
|
}
|
|
|
|
static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
|
|
DWORD dwFlags)
|
|
{
|
|
LPWSTR buf = NULL;
|
|
DWORD len;
|
|
|
|
len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
|
|
if (len)
|
|
{
|
|
buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (buf)
|
|
CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
|
|
DWORD dwType, DWORD dwFlags)
|
|
{
|
|
LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
|
|
|
|
if (name)
|
|
{
|
|
/* Don't include NULL-terminator in output */
|
|
DWORD len = lstrlenW(name);
|
|
|
|
add_unformatted_text_to_control(hwnd, name, len);
|
|
HeapFree(GetProcessHeap(), 0, name);
|
|
}
|
|
}
|
|
|
|
static void add_icon_to_control(HWND hwnd, int id)
|
|
{
|
|
HRESULT hr;
|
|
LPRICHEDITOLE richEditOle = NULL;
|
|
LPOLEOBJECT object = NULL;
|
|
CLSID clsid;
|
|
LPOLECACHE oleCache = NULL;
|
|
FORMATETC formatEtc;
|
|
DWORD conn;
|
|
LPDATAOBJECT dataObject = NULL;
|
|
HBITMAP bitmap = NULL;
|
|
RECT rect;
|
|
STGMEDIUM stgm;
|
|
LPOLECLIENTSITE clientSite = NULL;
|
|
REOBJECT reObject;
|
|
|
|
TRACE("(%p, %d)\n", hwnd, id);
|
|
|
|
SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
|
|
if (!richEditOle)
|
|
goto end;
|
|
hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
|
|
(void**)&object);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
hr = IOleObject_GetUserClassID(object, &clsid);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
formatEtc.cfFormat = CF_BITMAP;
|
|
formatEtc.ptd = NULL;
|
|
formatEtc.dwAspect = DVASPECT_CONTENT;
|
|
formatEtc.lindex = -1;
|
|
formatEtc.tymed = TYMED_GDI;
|
|
hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
hr = IOleObject_QueryInterface(object, &IID_IDataObject,
|
|
(void**)&dataObject);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
hr = IRichEditOle_GetClientSite(richEditOle, &clientSite);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
|
|
LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
|
|
if (!bitmap)
|
|
goto end;
|
|
rect.left = rect.top = 0;
|
|
rect.right = GetSystemMetrics(SM_CXICON);
|
|
rect.bottom = GetSystemMetrics(SM_CYICON);
|
|
stgm.tymed = TYMED_GDI;
|
|
stgm.u.hBitmap = bitmap;
|
|
stgm.pUnkForRelease = NULL;
|
|
hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
|
|
if (FAILED(hr))
|
|
goto end;
|
|
|
|
reObject.cbStruct = sizeof(reObject);
|
|
reObject.cp = REO_CP_SELECTION;
|
|
reObject.clsid = clsid;
|
|
reObject.poleobj = object;
|
|
reObject.pstg = NULL;
|
|
reObject.polesite = clientSite;
|
|
reObject.sizel.cx = reObject.sizel.cy = 0;
|
|
reObject.dvaspect = DVASPECT_CONTENT;
|
|
reObject.dwFlags = 0;
|
|
reObject.dwUser = 0;
|
|
|
|
IRichEditOle_InsertObject(richEditOle, &reObject);
|
|
|
|
end:
|
|
if (clientSite)
|
|
IOleClientSite_Release(clientSite);
|
|
if (dataObject)
|
|
IDataObject_Release(dataObject);
|
|
if (oleCache)
|
|
IOleCache_Release(oleCache);
|
|
if (object)
|
|
IOleObject_Release(object);
|
|
if (richEditOle)
|
|
IRichEditOle_Release(richEditOle);
|
|
}
|
|
|
|
#define MY_INDENT 200
|
|
|
|
static void add_oid_text_to_control(HWND hwnd, char *oid)
|
|
{
|
|
WCHAR nl = '\n';
|
|
PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
|
|
PARAFORMAT2 parFmt;
|
|
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT * 3;
|
|
if (oidInfo)
|
|
{
|
|
add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
|
|
lstrlenW(oidInfo->pwszName), &parFmt);
|
|
add_unformatted_text_to_control(hwnd, &nl, 1);
|
|
}
|
|
}
|
|
|
|
struct OIDToString
|
|
{
|
|
LPCSTR oid;
|
|
int id;
|
|
};
|
|
|
|
/* The following list MUST be lexicographically sorted by OID */
|
|
static struct OIDToString oidMap[] = {
|
|
/* 1.3.6.1.4.1.311.10.3.1 */
|
|
{ szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
|
|
/* 1.3.6.1.4.1.311.10.3.4 */
|
|
{ szOID_KP_EFS, IDS_PURPOSE_EFS },
|
|
/* 1.3.6.1.4.1.311.10.3.4.1 */
|
|
{ szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
|
|
/* 1.3.6.1.4.1.311.10.3.5 */
|
|
{ szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
|
|
/* 1.3.6.1.4.1.311.10.3.6 */
|
|
{ szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
|
|
/* 1.3.6.1.4.1.311.10.3.7 */
|
|
{ szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
|
|
/* 1.3.6.1.4.1.311.10.3.8 */
|
|
{ szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
|
|
/* 1.3.6.1.4.1.311.10.3.9 */
|
|
{ szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
|
|
/* 1.3.6.1.4.1.311.10.3.10 */
|
|
{ szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
|
|
/* 1.3.6.1.4.1.311.10.3.11 */
|
|
{ szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
|
|
/* 1.3.6.1.4.1.311.10.3.12 */
|
|
{ szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
|
|
/* 1.3.6.1.4.1.311.10.3.13 */
|
|
{ szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
|
|
/* 1.3.6.1.4.1.311.10.5.1 */
|
|
{ szOID_DRM, IDS_PURPOSE_DRM },
|
|
/* 1.3.6.1.4.1.311.10.6.1 */
|
|
{ szOID_LICENSES, IDS_PURPOSE_LICENSES },
|
|
/* 1.3.6.1.4.1.311.10.6.2 */
|
|
{ szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
|
|
/* 1.3.6.1.4.1.311.20.2.1 */
|
|
{ szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
|
|
/* 1.3.6.1.4.1.311.20.2.2 */
|
|
{ szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
|
|
/* 1.3.6.1.4.1.311.21.5 */
|
|
{ szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
|
|
/* 1.3.6.1.4.1.311.21.6 */
|
|
{ szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
|
|
/* 1.3.6.1.4.1.311.21.19 */
|
|
{ szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
|
|
/* 1.3.6.1.5.5.7.3.1 */
|
|
{ szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
|
|
/* 1.3.6.1.5.5.7.3.2 */
|
|
{ szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
|
|
/* 1.3.6.1.5.5.7.3.3 */
|
|
{ szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
|
|
/* 1.3.6.1.5.5.7.3.4 */
|
|
{ szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
|
|
/* 1.3.6.1.5.5.7.3.5 */
|
|
{ szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
|
|
/* 1.3.6.1.5.5.7.3.6 */
|
|
{ szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
|
|
/* 1.3.6.1.5.5.7.3.7 */
|
|
{ szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
|
|
/* 1.3.6.1.5.5.7.3.8 */
|
|
{ szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
|
|
};
|
|
|
|
static struct OIDToString *findSupportedOID(LPCSTR oid)
|
|
{
|
|
int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0;
|
|
|
|
while (indexLow <= indexHigh)
|
|
{
|
|
int cmp, i = (indexLow + indexHigh) / 2;
|
|
if (!(cmp = strcmp(oid, oidMap[i].oid)))
|
|
return &oidMap[i];
|
|
if (cmp > 0)
|
|
indexLow = i + 1;
|
|
else
|
|
indexHigh = i - 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
|
|
{
|
|
struct OIDToString *entry;
|
|
WCHAR nl = '\n';
|
|
PARAFORMAT2 parFmt;
|
|
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT * 3;
|
|
if ((entry = findSupportedOID(oid)))
|
|
{
|
|
WCHAR *str, *linebreak, *ptr;
|
|
BOOL multiline = FALSE;
|
|
int len;
|
|
|
|
len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
|
|
ptr = str;
|
|
do {
|
|
if ((linebreak = memchrW(ptr, '\n', len)))
|
|
{
|
|
WCHAR copy[MAX_STRING_LEN];
|
|
|
|
multiline = TRUE;
|
|
/* The source string contains a newline, which the richedit
|
|
* control won't find since it's interpreted as a paragraph
|
|
* break. Therefore copy up to the newline. lstrcpynW always
|
|
* NULL-terminates, so pass one more than the length of the
|
|
* source line so the copy includes the entire line and the
|
|
* NULL-terminator.
|
|
*/
|
|
lstrcpynW(copy, ptr, linebreak - ptr + 1);
|
|
add_text_with_paraformat_to_control(text, copy,
|
|
linebreak - ptr, &parFmt);
|
|
ptr = linebreak + 1;
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
}
|
|
else if (multiline && *ptr)
|
|
{
|
|
/* Add the last line */
|
|
add_text_with_paraformat_to_control(text, ptr,
|
|
len - (ptr - str), &parFmt);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
}
|
|
} while (linebreak);
|
|
if (!multiline)
|
|
{
|
|
add_text_with_paraformat_to_control(text, str, len, &parFmt);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
|
|
(strlen(oid) + 1) * sizeof(WCHAR));
|
|
|
|
if (oidW)
|
|
{
|
|
LPCSTR src;
|
|
WCHAR *dst;
|
|
|
|
for (src = oid, dst = oidW; *src; src++, dst++)
|
|
*dst = *src;
|
|
*dst = 0;
|
|
add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
|
|
&parFmt);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
HeapFree(GetProcessHeap(), 0, oidW);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
|
|
BOOL *anyUsageAdded)
|
|
{
|
|
static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
|
|
WCHAR nl = '\n';
|
|
CHARFORMATW charFmt;
|
|
PCERT_EXTENSION policyExt;
|
|
if (!*anyUsageAdded)
|
|
{
|
|
PARAFORMAT2 parFmt;
|
|
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT;
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_PURPOSES, &parFmt);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
*anyUsageAdded = TRUE;
|
|
}
|
|
memset(&charFmt, 0, sizeof(charFmt));
|
|
charFmt.cbSize = sizeof(charFmt);
|
|
charFmt.dwMask = CFM_BOLD;
|
|
charFmt.dwEffects = 0;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
|
|
cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
|
|
{
|
|
CERT_POLICIES_INFO *policies;
|
|
DWORD size;
|
|
|
|
if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
|
|
policyExt->Value.pbData, policyExt->Value.cbData,
|
|
CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
|
|
{
|
|
DWORD i;
|
|
|
|
for (i = 0; i < policies->cPolicyInfo; i++)
|
|
{
|
|
DWORD j;
|
|
|
|
for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
|
|
add_local_oid_text_to_control(text,
|
|
policies->rgPolicyInfo[i].rgPolicyQualifier[j].
|
|
pszPolicyQualifierId);
|
|
}
|
|
LocalFree(policies);
|
|
}
|
|
}
|
|
else
|
|
add_oid_text_to_control(text, any_app_policy);
|
|
}
|
|
|
|
static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
|
|
BOOL *anyUsageAdded)
|
|
{
|
|
WCHAR nl = '\n';
|
|
DWORD size;
|
|
BOOL badUsages = FALSE;
|
|
|
|
if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
|
|
{
|
|
CHARFORMATW charFmt;
|
|
static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
|
|
PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
|
|
|
|
if (usage)
|
|
{
|
|
if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
|
|
{
|
|
DWORD i;
|
|
|
|
if (!*anyUsageAdded)
|
|
{
|
|
PARAFORMAT2 parFmt;
|
|
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT;
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_PURPOSES, &parFmt);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
*anyUsageAdded = TRUE;
|
|
}
|
|
memset(&charFmt, 0, sizeof(charFmt));
|
|
charFmt.cbSize = sizeof(charFmt);
|
|
charFmt.dwMask = CFM_BOLD;
|
|
charFmt.dwEffects = 0;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
|
|
(LPARAM)&charFmt);
|
|
if (!usage->cUsageIdentifier)
|
|
add_oid_text_to_control(text, any_cert_policy);
|
|
else
|
|
for (i = 0; i < usage->cUsageIdentifier; i++)
|
|
add_local_oid_text_to_control(text,
|
|
usage->rgpszUsageIdentifier[i]);
|
|
}
|
|
else
|
|
badUsages = TRUE;
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
}
|
|
else
|
|
badUsages = TRUE;
|
|
}
|
|
else
|
|
badUsages = TRUE;
|
|
return badUsages;
|
|
}
|
|
|
|
static void set_policy_text(HWND text,
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
|
|
{
|
|
BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
|
|
BOOL badUsages = FALSE, anyUsageAdded = FALSE;
|
|
|
|
if (pCertViewInfo->cPurposes)
|
|
{
|
|
DWORD i;
|
|
|
|
for (i = 0; i < pCertViewInfo->cPurposes; i++)
|
|
{
|
|
if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
|
|
includeCertUsages = TRUE;
|
|
else if (!strcmp(pCertViewInfo->rgszPurposes[i],
|
|
szOID_ANY_APPLICATION_POLICY))
|
|
includeAppUsages = TRUE;
|
|
else
|
|
badUsages = TRUE;
|
|
}
|
|
}
|
|
else
|
|
includeAppUsages = includeCertUsages = TRUE;
|
|
if (includeAppUsages)
|
|
display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
|
|
if (includeCertUsages)
|
|
badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
|
|
&anyUsageAdded);
|
|
if (badUsages)
|
|
{
|
|
PARAFORMAT2 parFmt;
|
|
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT;
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
|
|
}
|
|
}
|
|
|
|
static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
|
|
LPCSTR policyOid)
|
|
{
|
|
CRYPT_OBJID_BLOB *ret = NULL;
|
|
DWORD i;
|
|
|
|
for (i = 0; !ret && i < policies->cPolicyInfo; i++)
|
|
{
|
|
DWORD j;
|
|
|
|
for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
|
|
if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
|
|
pszPolicyQualifierId, policyOid))
|
|
ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
|
|
Qualifier;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static WCHAR *get_cps_str_from_qualifier(const CRYPT_OBJID_BLOB *qualifier)
|
|
{
|
|
LPWSTR qualifierStr = NULL;
|
|
CERT_NAME_VALUE *qualifierValue;
|
|
DWORD size;
|
|
|
|
if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
|
|
qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
|
|
&qualifierValue, &size))
|
|
{
|
|
size = CertRDNValueToStrW(qualifierValue->dwValueType,
|
|
&qualifierValue->Value, NULL, 0);
|
|
qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
|
|
if (qualifierStr)
|
|
CertRDNValueToStrW(qualifierValue->dwValueType,
|
|
&qualifierValue->Value, qualifierStr, size);
|
|
LocalFree(qualifierValue);
|
|
}
|
|
return qualifierStr;
|
|
}
|
|
|
|
static WCHAR *get_user_notice_from_qualifier(const CRYPT_OBJID_BLOB *qualifier)
|
|
{
|
|
LPWSTR str = NULL;
|
|
CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
|
|
DWORD size;
|
|
|
|
if (CryptDecodeObjectEx(X509_ASN_ENCODING,
|
|
X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
|
|
qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
|
|
&qualifierValue, &size))
|
|
{
|
|
str = HeapAlloc(GetProcessHeap(), 0,
|
|
(strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
|
|
if (str)
|
|
strcpyW(str, qualifierValue->pszDisplayText);
|
|
LocalFree(qualifierValue);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
struct IssuerStatement
|
|
{
|
|
LPWSTR cps;
|
|
LPWSTR userNotice;
|
|
};
|
|
|
|
static void set_issuer_statement(HWND hwnd,
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
|
|
{
|
|
PCERT_EXTENSION policyExt;
|
|
|
|
if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
|
|
(policyExt = CertFindExtension(szOID_CERT_POLICIES,
|
|
pCertViewInfo->pCertContext->pCertInfo->cExtension,
|
|
pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
|
|
{
|
|
CERT_POLICIES_INFO *policies;
|
|
DWORD size;
|
|
|
|
if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
|
|
policyExt->Value.pbData, policyExt->Value.cbData,
|
|
CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
|
|
{
|
|
CRYPT_OBJID_BLOB *qualifier;
|
|
LPWSTR cps = NULL, userNotice = NULL;
|
|
|
|
if ((qualifier = find_policy_qualifier(policies,
|
|
szOID_PKIX_POLICY_QUALIFIER_CPS)))
|
|
cps = get_cps_str_from_qualifier(qualifier);
|
|
if ((qualifier = find_policy_qualifier(policies,
|
|
szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
|
|
userNotice = get_user_notice_from_qualifier(qualifier);
|
|
if (cps || userNotice)
|
|
{
|
|
struct IssuerStatement *issuerStatement =
|
|
HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
|
|
|
|
if (issuerStatement)
|
|
{
|
|
issuerStatement->cps = cps;
|
|
issuerStatement->userNotice = userNotice;
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
|
|
SetWindowLongPtrW(hwnd, DWLP_USER,
|
|
(ULONG_PTR)issuerStatement);
|
|
}
|
|
}
|
|
LocalFree(policies);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void set_cert_info(HWND hwnd,
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
|
|
{
|
|
CHARFORMATW charFmt;
|
|
PARAFORMAT2 parFmt;
|
|
HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
|
|
HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
|
|
CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
|
|
pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
|
|
pCertViewInfo->idxCounterSigner);
|
|
CRYPT_PROVIDER_CERT *root =
|
|
&provSigner->pasCertChain[provSigner->csCertChain - 1];
|
|
|
|
if (!provSigner->pChainContext ||
|
|
(provSigner->pChainContext->TrustStatus.dwErrorStatus &
|
|
CERT_TRUST_IS_PARTIAL_CHAIN))
|
|
add_icon_to_control(icon, IDB_CERT_WARNING);
|
|
else if (!root->fTrustedRoot)
|
|
add_icon_to_control(icon, IDB_CERT_ERROR);
|
|
else
|
|
add_icon_to_control(icon, IDB_CERT);
|
|
|
|
memset(&charFmt, 0, sizeof(charFmt));
|
|
charFmt.cbSize = sizeof(charFmt);
|
|
charFmt.dwMask = CFM_BOLD;
|
|
charFmt.dwEffects = CFE_BOLD;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
/* FIXME: vertically center text */
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT;
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERTIFICATEINFORMATION, &parFmt);
|
|
|
|
text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_BAD_SIG, &parFmt);
|
|
else if (!provSigner->pChainContext ||
|
|
(provSigner->pChainContext->TrustStatus.dwErrorStatus &
|
|
CERT_TRUST_IS_PARTIAL_CHAIN))
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
|
|
else if (!root->fTrustedRoot)
|
|
{
|
|
if (provSigner->csCertChain == 1 && root->fSelfSigned)
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
|
|
else
|
|
add_string_resource_with_paraformat_to_control(text,
|
|
IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
|
|
}
|
|
else
|
|
{
|
|
set_policy_text(text, pCertViewInfo);
|
|
set_issuer_statement(hwnd, pCertViewInfo);
|
|
}
|
|
}
|
|
|
|
static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
|
|
DWORD nameFlags, int heading)
|
|
{
|
|
WCHAR nl = '\n';
|
|
HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
|
|
CHARFORMATW charFmt;
|
|
PARAFORMAT2 parFmt;
|
|
|
|
memset(&charFmt, 0, sizeof(charFmt));
|
|
charFmt.cbSize = sizeof(charFmt);
|
|
charFmt.dwMask = CFM_BOLD;
|
|
charFmt.dwEffects = CFE_BOLD;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT * 3;
|
|
add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
|
|
charFmt.dwEffects = 0;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
|
|
nameFlags);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
|
|
}
|
|
|
|
static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
|
|
{
|
|
WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
|
|
WCHAR date[80];
|
|
SYSTEMTIME sysTime;
|
|
|
|
GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
|
|
sizeof(dateFmt) / sizeof(dateFmt[0]));
|
|
FileTimeToSystemTime(fileTime, &sysTime);
|
|
GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
|
|
sizeof(date) / sizeof(date[0]));
|
|
add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
|
|
}
|
|
|
|
static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
|
|
{
|
|
WCHAR nl = '\n';
|
|
HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
|
|
CHARFORMATW charFmt;
|
|
PARAFORMAT2 parFmt;
|
|
|
|
memset(&charFmt, 0, sizeof(charFmt));
|
|
charFmt.cbSize = sizeof(charFmt);
|
|
charFmt.dwMask = CFM_BOLD;
|
|
charFmt.dwEffects = CFE_BOLD;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
parFmt.cbSize = sizeof(parFmt);
|
|
parFmt.dwMask = PFM_STARTINDENT;
|
|
parFmt.dxStartIndent = MY_INDENT * 3;
|
|
add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
|
|
&parFmt);
|
|
charFmt.dwEffects = 0;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
|
|
charFmt.dwEffects = CFE_BOLD;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
add_string_resource_to_control(text, IDS_VALID_TO);
|
|
charFmt.dwEffects = 0;
|
|
SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
|
|
add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
|
|
add_unformatted_text_to_control(text, &nl, 1);
|
|
}
|
|
|
|
static void set_general_info(HWND hwnd,
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
|
|
{
|
|
set_cert_info(hwnd, pCertViewInfo);
|
|
set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
|
|
IDS_SUBJECT_HEADING);
|
|
set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
|
|
CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
|
|
set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
|
|
}
|
|
|
|
static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
HWND text;
|
|
struct IssuerStatement *issuerStatement;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
text = GetDlgItem(hwnd, IDC_USERNOTICE);
|
|
issuerStatement = (struct IssuerStatement *)lp;
|
|
add_unformatted_text_to_control(text, issuerStatement->userNotice,
|
|
strlenW(issuerStatement->userNotice));
|
|
if (issuerStatement->cps)
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
|
|
else
|
|
EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
|
|
break;
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDOK:
|
|
EndDialog(hwnd, IDOK);
|
|
ret = TRUE;
|
|
break;
|
|
case IDC_CPS:
|
|
{
|
|
IBindCtx *bctx = NULL;
|
|
LPWSTR cps;
|
|
|
|
CreateBindCtx(0, &bctx);
|
|
cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
|
|
HLNF_OPENINNEWWINDOW, 0);
|
|
IBindCtx_Release(bctx);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
|
|
{
|
|
DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
|
|
user_notice_dlg_proc, (LPARAM)issuerStatement);
|
|
}
|
|
|
|
static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
PROPSHEETPAGEW *page;
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
|
|
|
|
TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
page = (PROPSHEETPAGEW *)lp;
|
|
pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
|
|
if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
|
|
ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
|
|
set_general_info(hwnd, pCertViewInfo);
|
|
break;
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDC_ADDTOSTORE:
|
|
CryptUIWizImport(0, hwnd, NULL, NULL, NULL);
|
|
break;
|
|
case IDC_ISSUERSTATEMENT:
|
|
{
|
|
struct IssuerStatement *issuerStatement =
|
|
(struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
|
|
if (issuerStatement)
|
|
{
|
|
if (issuerStatement->userNotice)
|
|
show_user_notice(hwnd, issuerStatement);
|
|
else if (issuerStatement->cps)
|
|
{
|
|
IBindCtx *bctx = NULL;
|
|
|
|
CreateBindCtx(0, &bctx);
|
|
HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
|
|
NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
|
|
IBindCtx_Release(bctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
|
|
PROPSHEETPAGEW *page)
|
|
{
|
|
struct IssuerStatement *issuerStatement;
|
|
|
|
switch (msg)
|
|
{
|
|
case PSPCB_RELEASE:
|
|
issuerStatement =
|
|
(struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (issuerStatement)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
|
|
HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
|
|
HeapFree(GetProcessHeap(), 0, issuerStatement);
|
|
}
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
|
|
PROPSHEETPAGEW *page)
|
|
{
|
|
memset(page, 0, sizeof(PROPSHEETPAGEW));
|
|
page->dwSize = sizeof(PROPSHEETPAGEW);
|
|
page->dwFlags = PSP_USECALLBACK;
|
|
page->pfnCallback = general_callback_proc;
|
|
page->hInstance = hInstance;
|
|
page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
|
|
page->pfnDlgProc = general_dlg_proc;
|
|
page->lParam = (LPARAM)pCertViewInfo;
|
|
}
|
|
|
|
typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
|
|
|
|
static WCHAR *field_format_version(PCCERT_CONTEXT cert)
|
|
{
|
|
static const WCHAR fmt[] = { 'V','%','d',0 };
|
|
WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
|
|
|
|
if (buf)
|
|
sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
|
|
return buf;
|
|
}
|
|
|
|
static WCHAR *format_hex_string(void *pb, DWORD cb)
|
|
{
|
|
WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
|
|
|
|
if (buf)
|
|
{
|
|
static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
|
|
DWORD i;
|
|
WCHAR *ptr;
|
|
|
|
for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
|
|
sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
|
|
{
|
|
return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
|
|
cert->pCertInfo->SerialNumber.cbData);
|
|
}
|
|
|
|
static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
|
|
{
|
|
return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
|
|
CERT_NAME_ISSUER_FLAG);
|
|
}
|
|
|
|
static WCHAR *field_format_detailed_cert_name(PCERT_NAME_BLOB name)
|
|
{
|
|
WCHAR *str = NULL;
|
|
DWORD len = CertNameToStrW(X509_ASN_ENCODING, name,
|
|
CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, NULL, 0);
|
|
|
|
if (len)
|
|
{
|
|
str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (str)
|
|
CertNameToStrW(X509_ASN_ENCODING, name,
|
|
CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, str, len);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static WCHAR *field_format_detailed_issuer(PCCERT_CONTEXT cert, void *param)
|
|
{
|
|
return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
|
|
}
|
|
|
|
static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
|
|
{
|
|
return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
|
|
}
|
|
|
|
static WCHAR *field_format_detailed_subject(PCCERT_CONTEXT cert, void *param)
|
|
{
|
|
return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
|
|
}
|
|
|
|
static WCHAR *format_long_date(const FILETIME *fileTime)
|
|
{
|
|
WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
|
|
DWORD len;
|
|
WCHAR *buf = NULL;
|
|
SYSTEMTIME sysTime;
|
|
|
|
/* FIXME: format isn't quite right, want time too */
|
|
GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
|
|
sizeof(dateFmt) / sizeof(dateFmt[0]));
|
|
FileTimeToSystemTime(fileTime, &sysTime);
|
|
len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
|
|
if (len)
|
|
{
|
|
buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
|
|
if (buf)
|
|
GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
|
|
len);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
|
|
{
|
|
return format_long_date(&cert->pCertInfo->NotBefore);
|
|
}
|
|
|
|
static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
|
|
{
|
|
return format_long_date(&cert->pCertInfo->NotAfter);
|
|
}
|
|
|
|
static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
|
|
{
|
|
PCCRYPT_OID_INFO oidInfo;
|
|
WCHAR *buf = NULL;
|
|
|
|
oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
|
|
cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
|
|
if (oidInfo)
|
|
{
|
|
WCHAR fmt[MAX_STRING_LEN];
|
|
|
|
if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
|
|
sizeof(fmt) / sizeof(fmt[0])))
|
|
{
|
|
DWORD len;
|
|
|
|
/* Allocate the output buffer. Use the number of bytes in the
|
|
* public key as a conservative (high) estimate for the number of
|
|
* digits in its output.
|
|
* The output is of the form (in English)
|
|
* "<public key algorithm> (<public key bit length> bits)".
|
|
* Ordinarily having two positional parameters in a string is not a
|
|
* good idea, but as this isn't a sentence fragment, it shouldn't
|
|
* be word-order dependent.
|
|
*/
|
|
len = strlenW(fmt) + strlenW(oidInfo->pwszName) +
|
|
cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8;
|
|
buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*buf));
|
|
if (buf)
|
|
{
|
|
DWORD_PTR args[2];
|
|
args[0] = (DWORD_PTR)oidInfo->pwszName;
|
|
args[1] = CertGetPublicKeyLength(X509_ASN_ENCODING,
|
|
&cert->pCertInfo->SubjectPublicKeyInfo);
|
|
FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
fmt, 0, 0, buf, len, (__ms_va_list*)args);
|
|
}
|
|
}
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
static WCHAR *field_format_detailed_public_key(PCCERT_CONTEXT cert, void *param)
|
|
{
|
|
return format_hex_string(
|
|
cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
|
|
cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
|
|
}
|
|
|
|
struct field_value_data;
|
|
struct detail_data
|
|
{
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
|
|
BOOL *pfPropertiesChanged;
|
|
int cFields;
|
|
struct field_value_data *fields;
|
|
};
|
|
|
|
typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
|
|
|
|
typedef WCHAR *(*create_detailed_value_func)(PCCERT_CONTEXT cert, void *param);
|
|
|
|
struct field_value_data
|
|
{
|
|
create_detailed_value_func create;
|
|
LPWSTR detailed_value;
|
|
void *param;
|
|
};
|
|
|
|
static void add_field_value_data(struct detail_data *data,
|
|
create_detailed_value_func create, void *param)
|
|
{
|
|
if (data->cFields)
|
|
data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
|
|
(data->cFields + 1) * sizeof(struct field_value_data));
|
|
else
|
|
data->fields = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(struct field_value_data));
|
|
if (data->fields)
|
|
{
|
|
data->fields[data->cFields].create = create;
|
|
data->fields[data->cFields].detailed_value = NULL;
|
|
data->fields[data->cFields].param = param;
|
|
data->cFields++;
|
|
}
|
|
}
|
|
|
|
static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
|
|
LPWSTR field, LPWSTR value, create_detailed_value_func create, void *param)
|
|
{
|
|
LVITEMW item;
|
|
int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
|
|
|
|
item.mask = LVIF_TEXT | LVIF_PARAM;
|
|
item.iItem = iItem;
|
|
item.iSubItem = 0;
|
|
item.pszText = field;
|
|
item.lParam = (LPARAM)data;
|
|
SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
if (value)
|
|
{
|
|
item.pszText = value;
|
|
item.iSubItem = 1;
|
|
SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
|
|
}
|
|
add_field_value_data(data, create, param);
|
|
}
|
|
|
|
static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
|
|
int id, LPWSTR value, create_detailed_value_func create, void *param)
|
|
{
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
|
|
add_field_and_value_to_list(hwnd, data, buf, value, create, param);
|
|
}
|
|
|
|
struct v1_field
|
|
{
|
|
int id;
|
|
field_format_func format;
|
|
create_detailed_value_func create_detailed_value;
|
|
};
|
|
|
|
static void add_v1_field(HWND hwnd, struct detail_data *data,
|
|
const struct v1_field *field)
|
|
{
|
|
WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
|
|
|
|
if (val)
|
|
{
|
|
add_string_id_and_value_to_list(hwnd, data, field->id, val,
|
|
field->create_detailed_value, NULL);
|
|
HeapFree(GetProcessHeap(), 0, val);
|
|
}
|
|
}
|
|
|
|
static const struct v1_field v1_fields[] = {
|
|
{ IDS_FIELD_VERSION, field_format_version, NULL },
|
|
{ IDS_FIELD_SERIAL_NUMBER, field_format_serial_number, NULL },
|
|
{ IDS_FIELD_ISSUER, field_format_issuer, field_format_detailed_issuer },
|
|
{ IDS_FIELD_VALID_FROM, field_format_from_date, NULL },
|
|
{ IDS_FIELD_VALID_TO, field_format_to_date, NULL },
|
|
{ IDS_FIELD_SUBJECT, field_format_subject, field_format_detailed_subject },
|
|
{ IDS_FIELD_PUBLIC_KEY, field_format_public_key,
|
|
field_format_detailed_public_key }
|
|
};
|
|
|
|
static void add_v1_fields(HWND hwnd, struct detail_data *data)
|
|
{
|
|
int i;
|
|
PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
|
|
|
|
/* The last item in v1_fields is the public key, which is not in the loop
|
|
* because it's a special case.
|
|
*/
|
|
for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
|
|
add_v1_field(hwnd, data, &v1_fields[i]);
|
|
if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
|
|
add_v1_field(hwnd, data, &v1_fields[i]);
|
|
}
|
|
|
|
static WCHAR *crypt_format_extension(const CERT_EXTENSION *ext, DWORD formatStrType)
|
|
{
|
|
WCHAR *str = NULL;
|
|
DWORD size;
|
|
|
|
if (CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
|
|
ext->pszObjId, ext->Value.pbData, ext->Value.cbData, NULL, &size))
|
|
{
|
|
str = HeapAlloc(GetProcessHeap(), 0, size);
|
|
CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
|
|
ext->pszObjId, ext->Value.pbData, ext->Value.cbData, str, &size);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static WCHAR *field_format_extension_hex_with_ascii(const CERT_EXTENSION *ext)
|
|
{
|
|
WCHAR *str = NULL;
|
|
|
|
if (ext->Value.cbData)
|
|
{
|
|
/* The output is formatted as:
|
|
* <hex bytes> <ascii bytes>\n
|
|
* where <hex bytes> is a string of up to 8 bytes, output as %02x,
|
|
* and <ascii bytes> is the ASCII equivalent of each byte, or '.' if
|
|
* the byte is not printable.
|
|
* So, for example, the extension value consisting of the following
|
|
* bytes:
|
|
* 0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,
|
|
* 0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67
|
|
* is output as:
|
|
* 30 14 31 12 30 10 06 03 0.1.0...
|
|
* 55 04 03 13 09 4a 75 61 U....Jua
|
|
* 6e 20 4c 61 6e 67 n Lang
|
|
* The allocation size therefore requires:
|
|
* - 4 characters per character in an 8-byte line
|
|
* (2 for the hex format, one for the space, one for the ASCII value)
|
|
* - 3 more characters per 8-byte line (two spaces and a newline)
|
|
* - 1 character for the terminating nul
|
|
* FIXME: should use a fixed-width font for this
|
|
*/
|
|
DWORD lines = (ext->Value.cbData + 7) / 8;
|
|
|
|
str = HeapAlloc(GetProcessHeap(), 0,
|
|
(lines * 8 * 4 + lines * 3 + 1) * sizeof(WCHAR));
|
|
if (str)
|
|
{
|
|
static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
|
|
DWORD i, j;
|
|
WCHAR *ptr;
|
|
|
|
for (i = 0, ptr = str; i < ext->Value.cbData; i += 8)
|
|
{
|
|
/* Output as hex bytes first */
|
|
for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr += 3)
|
|
sprintfW(ptr, fmt, ext->Value.pbData[j]);
|
|
/* Pad the hex output with spaces for alignment */
|
|
if (j == ext->Value.cbData && j % 8)
|
|
{
|
|
static const WCHAR pad[] = { ' ',' ',' ' };
|
|
|
|
for (; j % 8; j++, ptr += sizeof(pad) / sizeof(pad[0]))
|
|
memcpy(ptr, pad, sizeof(pad));
|
|
}
|
|
/* The last sprintfW included a space, so just insert one
|
|
* more space between the hex bytes and the ASCII output
|
|
*/
|
|
*ptr++ = ' ';
|
|
/* Output as ASCII bytes */
|
|
for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr++)
|
|
{
|
|
if (isprintW(ext->Value.pbData[j]) &&
|
|
!isspaceW(ext->Value.pbData[j]))
|
|
*ptr = ext->Value.pbData[j];
|
|
else
|
|
*ptr = '.';
|
|
}
|
|
*ptr++ = '\n';
|
|
}
|
|
*ptr++ = '\0';
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static WCHAR *field_format_detailed_extension(PCCERT_CONTEXT cert, void *param)
|
|
{
|
|
PCERT_EXTENSION ext = param;
|
|
LPWSTR str = crypt_format_extension(ext,
|
|
CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX);
|
|
|
|
if (!str)
|
|
str = field_format_extension_hex_with_ascii(ext);
|
|
return str;
|
|
}
|
|
|
|
static void add_cert_extension_detail(HWND hwnd, struct detail_data *data,
|
|
PCERT_EXTENSION ext)
|
|
{
|
|
PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
|
|
ext->pszObjId, 0);
|
|
LPWSTR val = crypt_format_extension(ext, 0);
|
|
|
|
if (oidInfo)
|
|
add_field_and_value_to_list(hwnd, data, (LPWSTR)oidInfo->pwszName,
|
|
val, field_format_detailed_extension, ext);
|
|
else
|
|
{
|
|
DWORD len = strlen(ext->pszObjId);
|
|
LPWSTR oidW = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
|
|
|
|
if (oidW)
|
|
{
|
|
DWORD i;
|
|
|
|
for (i = 0; i <= len; i++)
|
|
oidW[i] = ext->pszObjId[i];
|
|
add_field_and_value_to_list(hwnd, data, oidW, val,
|
|
field_format_detailed_extension, ext);
|
|
HeapFree(GetProcessHeap(), 0, oidW);
|
|
}
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, val);
|
|
}
|
|
|
|
static void add_all_extensions(HWND hwnd, struct detail_data *data)
|
|
{
|
|
DWORD i;
|
|
PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
|
|
|
|
for (i = 0; i < cert->pCertInfo->cExtension; i++)
|
|
add_cert_extension_detail(hwnd, data, &cert->pCertInfo->rgExtension[i]);
|
|
}
|
|
|
|
static void add_critical_extensions(HWND hwnd, struct detail_data *data)
|
|
{
|
|
DWORD i;
|
|
PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
|
|
|
|
for (i = 0; i < cert->pCertInfo->cExtension; i++)
|
|
if (cert->pCertInfo->rgExtension[i].fCritical)
|
|
add_cert_extension_detail(hwnd, data,
|
|
&cert->pCertInfo->rgExtension[i]);
|
|
}
|
|
|
|
typedef WCHAR * (*prop_to_value_func)(void *pb, DWORD cb);
|
|
|
|
struct prop_id_to_string_id
|
|
{
|
|
DWORD prop;
|
|
int id;
|
|
BOOL prop_is_string;
|
|
prop_to_value_func prop_to_value;
|
|
};
|
|
|
|
static WCHAR *format_enhanced_key_usage_value(void *pb, DWORD cb)
|
|
{
|
|
CERT_EXTENSION ext;
|
|
|
|
ext.pszObjId = (LPSTR)X509_ENHANCED_KEY_USAGE;
|
|
ext.fCritical = FALSE;
|
|
ext.Value.pbData = pb;
|
|
ext.Value.cbData = cb;
|
|
return crypt_format_extension(&ext, 0);
|
|
}
|
|
|
|
/* Logically the access state should also be checked, and IDC_EDITPROPERTIES
|
|
* disabled for read-only certificates, but native doesn't appear to do that.
|
|
*/
|
|
static const struct prop_id_to_string_id prop_id_map[] = {
|
|
{ CERT_HASH_PROP_ID, IDS_PROP_HASH, FALSE, format_hex_string },
|
|
{ CERT_FRIENDLY_NAME_PROP_ID, IDS_PROP_FRIENDLY_NAME, TRUE, NULL },
|
|
{ CERT_DESCRIPTION_PROP_ID, IDS_PROP_DESCRIPTION, TRUE, NULL },
|
|
{ CERT_ENHKEY_USAGE_PROP_ID, IDS_PROP_ENHKEY_USAGE, FALSE,
|
|
format_enhanced_key_usage_value },
|
|
};
|
|
|
|
static void add_properties(HWND hwnd, struct detail_data *data)
|
|
{
|
|
DWORD i;
|
|
PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
|
|
|
|
for (i = 0; i < sizeof(prop_id_map) / sizeof(prop_id_map[0]); i++)
|
|
{
|
|
DWORD cb;
|
|
|
|
if (CertGetCertificateContextProperty(cert, prop_id_map[i].prop, NULL,
|
|
&cb))
|
|
{
|
|
BYTE *pb;
|
|
WCHAR *val = NULL;
|
|
|
|
/* FIXME: MS adds a separate value for the signature hash
|
|
* algorithm.
|
|
*/
|
|
pb = HeapAlloc(GetProcessHeap(), 0, cb);
|
|
if (pb)
|
|
{
|
|
if (CertGetCertificateContextProperty(cert,
|
|
prop_id_map[i].prop, pb, &cb))
|
|
{
|
|
if (prop_id_map[i].prop_is_string)
|
|
{
|
|
val = (LPWSTR)pb;
|
|
/* Don't double-free pb */
|
|
pb = NULL;
|
|
}
|
|
else
|
|
val = prop_id_map[i].prop_to_value(pb, cb);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, pb);
|
|
}
|
|
add_string_id_and_value_to_list(hwnd, data, prop_id_map[i].id, val,
|
|
NULL, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void add_all_fields(HWND hwnd, struct detail_data *data)
|
|
{
|
|
add_v1_fields(hwnd, data);
|
|
add_all_extensions(hwnd, data);
|
|
add_properties(hwnd, data);
|
|
}
|
|
|
|
struct selection_list_item
|
|
{
|
|
int id;
|
|
add_fields_func add;
|
|
};
|
|
|
|
static const struct selection_list_item listItems[] = {
|
|
{ IDS_FIELDS_ALL, add_all_fields },
|
|
{ IDS_FIELDS_V1, add_v1_fields },
|
|
{ IDS_FIELDS_EXTENSIONS, add_all_extensions },
|
|
{ IDS_FIELDS_CRITICAL_EXTENSIONS, add_critical_extensions },
|
|
{ IDS_FIELDS_PROPERTIES, add_properties },
|
|
};
|
|
|
|
static void create_show_list(HWND hwnd, struct detail_data *data)
|
|
{
|
|
HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
int i;
|
|
|
|
for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
|
|
{
|
|
int index;
|
|
|
|
LoadStringW(hInstance, listItems[i].id, buf,
|
|
sizeof(buf) / sizeof(buf[0]));
|
|
index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
|
|
SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
|
|
}
|
|
SendMessageW(cb, CB_SETCURSEL, 0, 0);
|
|
}
|
|
|
|
static void create_listview_columns(HWND hwnd)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
|
|
RECT rc;
|
|
WCHAR buf[MAX_STRING_LEN];
|
|
LVCOLUMNW column;
|
|
|
|
SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
|
|
GetWindowRect(lv, &rc);
|
|
LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
|
|
column.mask = LVCF_WIDTH | LVCF_TEXT;
|
|
column.cx = (rc.right - rc.left) / 2 - 2;
|
|
column.pszText = buf;
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
|
|
LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
|
|
}
|
|
|
|
static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
|
|
{
|
|
HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
|
|
|
|
if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
|
|
{
|
|
SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
|
|
listItems[sel].add(list, data);
|
|
}
|
|
}
|
|
|
|
static void create_cert_details_list(HWND hwnd, struct detail_data *data)
|
|
{
|
|
create_show_list(hwnd, data);
|
|
create_listview_columns(hwnd);
|
|
set_fields_selection(hwnd, data, 0);
|
|
}
|
|
|
|
static void add_purpose(HWND hwnd, LPCSTR oid)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
PCRYPT_OID_INFO info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
|
|
sizeof(CRYPT_OID_INFO));
|
|
|
|
if (info)
|
|
{
|
|
char *oidCopy = HeapAlloc(GetProcessHeap(), 0, strlen(oid) + 1);
|
|
|
|
if (oidCopy)
|
|
{
|
|
LVITEMA item;
|
|
|
|
strcpy(oidCopy, oid);
|
|
info->cbSize = sizeof(CRYPT_OID_INFO);
|
|
info->pszOID = oidCopy;
|
|
item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
|
|
item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexChecked);
|
|
item.stateMask = LVIS_STATEIMAGEMASK;
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
item.lParam = (LPARAM)info;
|
|
item.pszText = oidCopy;
|
|
SendMessageA(lv, LVM_INSERTITEMA, 0, (LPARAM)&item);
|
|
}
|
|
else
|
|
HeapFree(GetProcessHeap(), 0, info);
|
|
}
|
|
}
|
|
|
|
static BOOL is_valid_oid(LPCSTR oid)
|
|
{
|
|
BOOL ret;
|
|
|
|
if (oid[0] != '0' && oid[0] != '1' && oid[0] != '2')
|
|
ret = FALSE;
|
|
else if (oid[1] != '.')
|
|
ret = FALSE;
|
|
else if (!oid[2])
|
|
ret = FALSE;
|
|
else
|
|
{
|
|
const char *ptr;
|
|
BOOL expectNum = TRUE;
|
|
|
|
for (ptr = oid + 2, ret = TRUE; ret && *ptr; ptr++)
|
|
{
|
|
if (expectNum)
|
|
{
|
|
if (!isdigit(*ptr))
|
|
ret = FALSE;
|
|
else if (*(ptr + 1) == '.')
|
|
expectNum = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (*ptr != '.')
|
|
ret = FALSE;
|
|
else if (!(*(ptr + 1)))
|
|
ret = FALSE;
|
|
else
|
|
expectNum = TRUE;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BOOL is_oid_in_list(HWND hwnd, LPCSTR oid)
|
|
{
|
|
return find_oid_in_list(GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES), oid)
|
|
!= -1;
|
|
}
|
|
|
|
#define MAX_PURPOSE 255
|
|
|
|
static LRESULT CALLBACK add_purpose_dlg_proc(HWND hwnd, UINT msg,
|
|
WPARAM wp, LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
char buf[MAX_PURPOSE + 1];
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SendMessageW(GetDlgItem(hwnd, IDC_NEW_PURPOSE), EM_SETLIMITTEXT,
|
|
MAX_PURPOSE, 0);
|
|
ShowScrollBar(GetDlgItem(hwnd, IDC_NEW_PURPOSE), SB_VERT, FALSE);
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, lp);
|
|
break;
|
|
case WM_COMMAND:
|
|
switch (HIWORD(wp))
|
|
{
|
|
case EN_CHANGE:
|
|
if (LOWORD(wp) == IDC_NEW_PURPOSE)
|
|
{
|
|
/* Show/hide scroll bar on description depending on how much
|
|
* text it has.
|
|
*/
|
|
HWND description = GetDlgItem(hwnd, IDC_NEW_PURPOSE);
|
|
int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
|
|
|
|
ShowScrollBar(description, SB_VERT, lines > 1);
|
|
}
|
|
break;
|
|
case BN_CLICKED:
|
|
switch (LOWORD(wp))
|
|
{
|
|
case IDOK:
|
|
SendMessageA(GetDlgItem(hwnd, IDC_NEW_PURPOSE), WM_GETTEXT,
|
|
sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
|
|
if (!buf[0])
|
|
{
|
|
/* An empty purpose is the same as cancelling */
|
|
EndDialog(hwnd, IDCANCEL);
|
|
ret = TRUE;
|
|
}
|
|
else if (!is_valid_oid(buf))
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_ERROR, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
MessageBoxW(hwnd, error, title, MB_ICONERROR | MB_OK);
|
|
}
|
|
else if (is_oid_in_list(
|
|
(HWND)GetWindowLongPtrW(hwnd, DWLP_USER), buf))
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_EXISTS,
|
|
error, sizeof(error) / sizeof(error[0]));
|
|
LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
MessageBoxW(hwnd, error, title, MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
else
|
|
{
|
|
HWND parent = (HWND)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
|
|
add_purpose(parent, buf);
|
|
EndDialog(hwnd, wp);
|
|
ret = TRUE;
|
|
}
|
|
break;
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, wp);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static WCHAR *get_cert_property_as_string(PCCERT_CONTEXT cert, DWORD prop)
|
|
{
|
|
WCHAR *name = NULL;
|
|
DWORD cb;
|
|
|
|
if (CertGetCertificateContextProperty(cert, prop, NULL, &cb))
|
|
{
|
|
name = HeapAlloc(GetProcessHeap(), 0, cb);
|
|
if (name)
|
|
{
|
|
if (!CertGetCertificateContextProperty(cert, prop, name, &cb))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, name);
|
|
name = NULL;
|
|
}
|
|
}
|
|
}
|
|
return name;
|
|
}
|
|
|
|
static void redraw_states(HWND list, BOOL enabled)
|
|
{
|
|
int items = SendMessageW(list, LVM_GETITEMCOUNT, 0, 0), i;
|
|
|
|
for (i = 0; i < items; i++)
|
|
{
|
|
BOOL change = FALSE;
|
|
int state;
|
|
|
|
state = SendMessageW(list, LVM_GETITEMSTATE, i, LVIS_STATEIMAGEMASK);
|
|
/* This reverses the INDEXTOSTATEIMAGEMASK shift. There doesn't appear
|
|
* to be a handy macro for it.
|
|
*/
|
|
state >>= 12;
|
|
if (enabled)
|
|
{
|
|
if (state == CheckBitmapIndexDisabledChecked)
|
|
{
|
|
state = CheckBitmapIndexChecked;
|
|
change = TRUE;
|
|
}
|
|
if (state == CheckBitmapIndexDisabledUnchecked)
|
|
{
|
|
state = CheckBitmapIndexUnchecked;
|
|
change = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (state == CheckBitmapIndexChecked)
|
|
{
|
|
state = CheckBitmapIndexDisabledChecked;
|
|
change = TRUE;
|
|
}
|
|
if (state == CheckBitmapIndexUnchecked)
|
|
{
|
|
state = CheckBitmapIndexDisabledUnchecked;
|
|
change = TRUE;
|
|
}
|
|
}
|
|
if (change)
|
|
{
|
|
LVITEMW item;
|
|
|
|
item.state = INDEXTOSTATEIMAGEMASK(state);
|
|
item.stateMask = LVIS_STATEIMAGEMASK;
|
|
SendMessageW(list, LVM_SETITEMSTATE, i, (LPARAM)&item);
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef enum {
|
|
PurposeEnableAll = 0,
|
|
PurposeDisableAll,
|
|
PurposeEnableSelected
|
|
} PurposeSelection;
|
|
|
|
static void select_purposes(HWND hwnd, PurposeSelection selection)
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
|
|
switch (selection)
|
|
{
|
|
case PurposeEnableAll:
|
|
case PurposeDisableAll:
|
|
EnableWindow(lv, FALSE);
|
|
redraw_states(lv, FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), FALSE);
|
|
break;
|
|
case PurposeEnableSelected:
|
|
EnableWindow(lv, TRUE);
|
|
redraw_states(lv, TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), TRUE);
|
|
}
|
|
}
|
|
|
|
struct edit_cert_data
|
|
{
|
|
PCCERT_CONTEXT cert;
|
|
BOOL *pfPropertiesChanged;
|
|
HIMAGELIST imageList;
|
|
};
|
|
|
|
static void show_cert_usages(HWND hwnd, struct edit_cert_data *data)
|
|
{
|
|
PCCERT_CONTEXT cert = data->cert;
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
PCERT_ENHKEY_USAGE usage;
|
|
DWORD size;
|
|
RECT rc;
|
|
LVCOLUMNW column;
|
|
PurposeSelection purposeSelection = PurposeEnableAll;
|
|
|
|
GetWindowRect(lv, &rc);
|
|
column.mask = LVCF_WIDTH;
|
|
column.cx = rc.right - rc.left;
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
|
|
SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)data->imageList);
|
|
|
|
/* Get enhanced key usage. Have to check for a property and an extension
|
|
* separately, because CertGetEnhancedKeyUsage will succeed and return an
|
|
* empty usage if neither is set. Unfortunately an empty usage implies
|
|
* no usage is allowed, so we have to distinguish between the two cases.
|
|
*/
|
|
if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
|
|
NULL, &size))
|
|
{
|
|
usage = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!CertGetEnhancedKeyUsage(cert,
|
|
CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
usage = NULL;
|
|
}
|
|
else if (usage->cUsageIdentifier)
|
|
purposeSelection = PurposeEnableSelected;
|
|
else
|
|
purposeSelection = PurposeDisableAll;
|
|
}
|
|
else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
|
|
NULL, &size))
|
|
{
|
|
usage = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!CertGetEnhancedKeyUsage(cert,
|
|
CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
usage = NULL;
|
|
}
|
|
else if (usage->cUsageIdentifier)
|
|
purposeSelection = PurposeEnableAll;
|
|
else
|
|
purposeSelection = PurposeDisableAll;
|
|
}
|
|
else
|
|
{
|
|
purposeSelection = PurposeEnableAll;
|
|
usage = NULL;
|
|
}
|
|
if (usage)
|
|
{
|
|
DWORD i;
|
|
|
|
for (i = 0; i < usage->cUsageIdentifier; i++)
|
|
{
|
|
PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
|
|
usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
|
|
|
|
if (info)
|
|
add_known_usage(lv, info, CheckBitmapIndexDisabledChecked);
|
|
else
|
|
add_purpose(hwnd, usage->rgpszUsageIdentifier[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, usage);
|
|
}
|
|
else
|
|
add_known_usages_to_list(lv, CheckBitmapIndexDisabledChecked);
|
|
select_purposes(hwnd, purposeSelection);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_ENABLE_ALL_PURPOSES + purposeSelection),
|
|
BM_CLICK, 0, 0);
|
|
}
|
|
|
|
static void set_general_cert_properties(HWND hwnd, struct edit_cert_data *data)
|
|
{
|
|
PCCERT_CONTEXT cert = data->cert;
|
|
WCHAR *str;
|
|
|
|
if ((str = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID)))
|
|
{
|
|
SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_SETTEXT, 0,
|
|
(LPARAM)str);
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
}
|
|
if ((str = get_cert_property_as_string(cert, CERT_DESCRIPTION_PROP_ID)))
|
|
{
|
|
SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_SETTEXT, 0,
|
|
(LPARAM)str);
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
}
|
|
show_cert_usages(hwnd, data);
|
|
}
|
|
|
|
static void set_cert_string_property(PCCERT_CONTEXT cert, DWORD prop,
|
|
LPWSTR str)
|
|
{
|
|
if (str && strlenW(str))
|
|
{
|
|
CRYPT_DATA_BLOB blob;
|
|
|
|
blob.pbData = (BYTE *)str;
|
|
blob.cbData = (strlenW(str) + 1) * sizeof(WCHAR);
|
|
CertSetCertificateContextProperty(cert, prop, 0, &blob);
|
|
}
|
|
else
|
|
CertSetCertificateContextProperty(cert, prop, 0, NULL);
|
|
}
|
|
|
|
#define WM_REFRESH_VIEW WM_USER + 0
|
|
|
|
static BOOL CALLBACK refresh_propsheet_pages(HWND hwnd, LPARAM lParam)
|
|
{
|
|
if ((GetClassLongW(hwnd, GCW_ATOM) == WC_DIALOG))
|
|
SendMessageW(hwnd, WM_REFRESH_VIEW, 0, 0);
|
|
return TRUE;
|
|
}
|
|
|
|
#define MAX_FRIENDLY_NAME 40
|
|
#define MAX_DESCRIPTION 255
|
|
|
|
static void apply_general_changes(HWND hwnd)
|
|
{
|
|
WCHAR buf[MAX_DESCRIPTION + 1];
|
|
struct edit_cert_data *data =
|
|
(struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
|
|
SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_GETTEXT,
|
|
sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
|
|
set_cert_string_property(data->cert, CERT_FRIENDLY_NAME_PROP_ID, buf);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_GETTEXT,
|
|
sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
|
|
set_cert_string_property(data->cert, CERT_DESCRIPTION_PROP_ID, buf);
|
|
if (IsDlgButtonChecked(hwnd, IDC_ENABLE_ALL_PURPOSES))
|
|
{
|
|
/* Setting a NULL usage removes the enhanced key usage property. */
|
|
CertSetEnhancedKeyUsage(data->cert, NULL);
|
|
}
|
|
else if (IsDlgButtonChecked(hwnd, IDC_DISABLE_ALL_PURPOSES))
|
|
{
|
|
CERT_ENHKEY_USAGE usage = { 0, NULL };
|
|
|
|
CertSetEnhancedKeyUsage(data->cert, &usage);
|
|
}
|
|
else if (IsDlgButtonChecked(hwnd, IDC_ENABLE_SELECTED_PURPOSES))
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
CERT_ENHKEY_USAGE usage = { 0, NULL };
|
|
int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
|
|
LVITEMW item;
|
|
|
|
item.mask = LVIF_STATE | LVIF_PARAM;
|
|
item.iSubItem = 0;
|
|
item.stateMask = LVIS_STATEIMAGEMASK;
|
|
for (i = 0; i < purposes; i++)
|
|
{
|
|
item.iItem = i;
|
|
if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
|
|
{
|
|
int state = item.state >> 12;
|
|
|
|
if (state == CheckBitmapIndexChecked)
|
|
{
|
|
CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
|
|
|
|
if (usage.cUsageIdentifier)
|
|
usage.rgpszUsageIdentifier =
|
|
HeapReAlloc(GetProcessHeap(), 0,
|
|
usage.rgpszUsageIdentifier,
|
|
(usage.cUsageIdentifier + 1) * sizeof(LPSTR));
|
|
else
|
|
usage.rgpszUsageIdentifier =
|
|
HeapAlloc(GetProcessHeap(), 0, sizeof(LPSTR));
|
|
if (usage.rgpszUsageIdentifier)
|
|
usage.rgpszUsageIdentifier[usage.cUsageIdentifier++] =
|
|
(LPSTR)info->pszOID;
|
|
}
|
|
}
|
|
}
|
|
CertSetEnhancedKeyUsage(data->cert, &usage);
|
|
HeapFree(GetProcessHeap(), 0, usage.rgpszUsageIdentifier);
|
|
}
|
|
EnumChildWindows(GetParent(GetParent(hwnd)), refresh_propsheet_pages, 0);
|
|
if (data->pfPropertiesChanged)
|
|
*data->pfPropertiesChanged = TRUE;
|
|
}
|
|
|
|
static LRESULT CALLBACK cert_properties_general_dlg_proc(HWND hwnd, UINT msg,
|
|
WPARAM wp, LPARAM lp)
|
|
{
|
|
PROPSHEETPAGEW *page;
|
|
|
|
TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
|
|
struct detail_data *detailData;
|
|
struct edit_cert_data *editData;
|
|
|
|
page = (PROPSHEETPAGEW *)lp;
|
|
detailData = (struct detail_data *)page->lParam;
|
|
SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), EM_SETLIMITTEXT,
|
|
MAX_FRIENDLY_NAME, 0);
|
|
SendMessageW(description, EM_SETLIMITTEXT, MAX_DESCRIPTION, 0);
|
|
ShowScrollBar(description, SB_VERT, FALSE);
|
|
editData = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(struct edit_cert_data));
|
|
if (editData)
|
|
{
|
|
editData->imageList = ImageList_Create(16, 16,
|
|
ILC_COLOR4 | ILC_MASK, 4, 0);
|
|
if (editData->imageList)
|
|
{
|
|
HBITMAP bmp;
|
|
COLORREF backColor = RGB(255, 0, 255);
|
|
|
|
bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
|
|
ImageList_AddMasked(editData->imageList, bmp, backColor);
|
|
DeleteObject(bmp);
|
|
ImageList_SetBkColor(editData->imageList, CLR_NONE);
|
|
}
|
|
editData->cert = detailData->pCertViewInfo->pCertContext;
|
|
editData->pfPropertiesChanged = detailData->pfPropertiesChanged;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)editData);
|
|
set_general_cert_properties(hwnd, editData);
|
|
}
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
NMITEMACTIVATE *nm;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case NM_CLICK:
|
|
nm = (NMITEMACTIVATE *)lp;
|
|
toggle_usage(hwnd, nm->iItem);
|
|
SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
|
|
break;
|
|
case PSN_APPLY:
|
|
apply_general_changes(hwnd);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (HIWORD(wp))
|
|
{
|
|
case EN_CHANGE:
|
|
SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
|
|
if (LOWORD(wp) == IDC_DESCRIPTION)
|
|
{
|
|
/* Show/hide scroll bar on description depending on how much
|
|
* text it has.
|
|
*/
|
|
HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
|
|
int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
|
|
|
|
ShowScrollBar(description, SB_VERT, lines > 1);
|
|
}
|
|
break;
|
|
case BN_CLICKED:
|
|
switch (LOWORD(wp))
|
|
{
|
|
case IDC_ADD_PURPOSE:
|
|
if (DialogBoxParamW(hInstance,
|
|
MAKEINTRESOURCEW(IDD_ADD_CERT_PURPOSE), hwnd,
|
|
add_purpose_dlg_proc, (LPARAM)hwnd) == IDOK)
|
|
SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
|
|
break;
|
|
case IDC_ENABLE_ALL_PURPOSES:
|
|
case IDC_DISABLE_ALL_PURPOSES:
|
|
case IDC_ENABLE_SELECTED_PURPOSES:
|
|
SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
|
|
select_purposes(hwnd, LOWORD(wp) - IDC_ENABLE_ALL_PURPOSES);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static UINT CALLBACK cert_properties_general_callback(HWND hwnd, UINT msg,
|
|
PROPSHEETPAGEW *page)
|
|
{
|
|
HWND lv;
|
|
int cItem, i;
|
|
struct edit_cert_data *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case PSPCB_RELEASE:
|
|
lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
|
|
cItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
for (i = 0; i < cItem; i++)
|
|
{
|
|
LVITEMW item;
|
|
|
|
item.mask = LVIF_PARAM;
|
|
item.iItem = i;
|
|
item.iSubItem = 0;
|
|
if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item) && item.lParam)
|
|
{
|
|
PCRYPT_OID_INFO info = (PCRYPT_OID_INFO)item.lParam;
|
|
|
|
if (info->cbSize == sizeof(CRYPT_OID_INFO) && !info->dwGroupId)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, (LPSTR)info->pszOID);
|
|
HeapFree(GetProcessHeap(), 0, info);
|
|
}
|
|
}
|
|
}
|
|
data = (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (data)
|
|
{
|
|
ImageList_Destroy(data->imageList);
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
}
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void show_edit_cert_properties_dialog(HWND parent,
|
|
struct detail_data *data)
|
|
{
|
|
PROPSHEETHEADERW hdr;
|
|
PROPSHEETPAGEW page; /* FIXME: need to add a cross-certificate page */
|
|
|
|
TRACE("(%p)\n", data);
|
|
|
|
memset(&page, 0, sizeof(PROPSHEETPAGEW));
|
|
page.dwSize = sizeof(page);
|
|
page.dwFlags = PSP_USECALLBACK;
|
|
page.pfnCallback = cert_properties_general_callback;
|
|
page.hInstance = hInstance;
|
|
page.u.pszTemplate = MAKEINTRESOURCEW(IDD_CERT_PROPERTIES_GENERAL);
|
|
page.pfnDlgProc = cert_properties_general_dlg_proc;
|
|
page.lParam = (LPARAM)data;
|
|
|
|
memset(&hdr, 0, sizeof(hdr));
|
|
hdr.dwSize = sizeof(hdr);
|
|
hdr.hwndParent = parent;
|
|
hdr.dwFlags = PSH_PROPSHEETPAGE;
|
|
hdr.hInstance = hInstance;
|
|
hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE_PROPERTIES);
|
|
hdr.u3.ppsp = &page;
|
|
hdr.nPages = 1;
|
|
PropertySheetW(&hdr);
|
|
}
|
|
|
|
static void free_detail_fields(struct detail_data *data)
|
|
{
|
|
DWORD i;
|
|
|
|
for (i = 0; i < data->cFields; i++)
|
|
HeapFree(GetProcessHeap(), 0, data->fields[i].detailed_value);
|
|
HeapFree(GetProcessHeap(), 0, data->fields);
|
|
data->fields = NULL;
|
|
data->cFields = 0;
|
|
}
|
|
|
|
static void refresh_details_view(HWND hwnd)
|
|
{
|
|
HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
|
|
int curSel;
|
|
struct detail_data *data;
|
|
|
|
curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
|
|
/* Actually, any index will do, since they all store the same data value */
|
|
data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
|
|
free_detail_fields(data);
|
|
set_fields_selection(hwnd, data, curSel);
|
|
}
|
|
|
|
static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
PROPSHEETPAGEW *page;
|
|
struct detail_data *data;
|
|
|
|
TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
page = (PROPSHEETPAGEW *)lp;
|
|
data = (struct detail_data *)page->lParam;
|
|
create_cert_details_list(hwnd, data);
|
|
if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
|
|
if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
|
|
break;
|
|
case WM_NOTIFY:
|
|
{
|
|
NMITEMACTIVATE *nm;
|
|
HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
|
|
|
|
nm = (NMITEMACTIVATE*)lp;
|
|
if (nm->hdr.hwndFrom == list && nm->uNewState & LVN_ITEMACTIVATE
|
|
&& nm->hdr.code == LVN_ITEMCHANGED)
|
|
{
|
|
data = (struct detail_data *)nm->lParam;
|
|
if (nm->iItem >= 0 && data && nm->iItem < data->cFields)
|
|
{
|
|
WCHAR buf[MAX_STRING_LEN], *val = NULL;
|
|
HWND valueCtl = GetDlgItem(hwnd, IDC_DETAIL_VALUE);
|
|
|
|
if (data->fields[nm->iItem].create)
|
|
val = data->fields[nm->iItem].create(
|
|
data->pCertViewInfo->pCertContext,
|
|
data->fields[nm->iItem].param);
|
|
else
|
|
{
|
|
LVITEMW item;
|
|
int res;
|
|
|
|
item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
|
|
item.mask = LVIF_TEXT;
|
|
item.pszText = buf;
|
|
item.iItem = nm->iItem;
|
|
item.iSubItem = 1;
|
|
res = SendMessageW(list, LVM_GETITEMW, 0, (LPARAM)&item);
|
|
if (res)
|
|
val = buf;
|
|
}
|
|
/* Select all the text in the control, the next update will
|
|
* replace it
|
|
*/
|
|
SendMessageW(valueCtl, EM_SETSEL, 0, -1);
|
|
add_unformatted_text_to_control(valueCtl, val,
|
|
val ? strlenW(val) : 0);
|
|
if (val != buf)
|
|
HeapFree(GetProcessHeap(), 0, val);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDC_EXPORT:
|
|
{
|
|
HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
|
|
CRYPTUI_WIZ_EXPORT_INFO info;
|
|
|
|
data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, 0, 0);
|
|
info.dwSize = sizeof(info);
|
|
info.pwszExportFileName = NULL;
|
|
info.dwSubjectChoice = CRYPTUI_WIZ_EXPORT_CERT_CONTEXT;
|
|
info.u.pCertContext = data->pCertViewInfo->pCertContext;
|
|
info.cStores = 0;
|
|
CryptUIWizExport(0, hwnd, NULL, &info, NULL);
|
|
break;
|
|
}
|
|
case IDC_EDITPROPERTIES:
|
|
{
|
|
HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
|
|
int curSel;
|
|
|
|
curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
|
|
/* Actually, any index will do, since they all store the same
|
|
* data value
|
|
*/
|
|
data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA,
|
|
curSel, 0);
|
|
show_edit_cert_properties_dialog(GetParent(hwnd), data);
|
|
break;
|
|
}
|
|
case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
|
|
refresh_details_view(hwnd);
|
|
break;
|
|
}
|
|
break;
|
|
case WM_REFRESH_VIEW:
|
|
refresh_details_view(hwnd);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static UINT CALLBACK detail_callback(HWND hwnd, UINT msg,
|
|
PROPSHEETPAGEW *page)
|
|
{
|
|
struct detail_data *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case PSPCB_RELEASE:
|
|
data = (struct detail_data *)page->lParam;
|
|
free_detail_fields(data);
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
|
|
BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
|
|
{
|
|
BOOL ret;
|
|
struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(struct detail_data));
|
|
|
|
if (data)
|
|
{
|
|
data->pCertViewInfo = pCertViewInfo;
|
|
data->pfPropertiesChanged = pfPropertiesChanged;
|
|
data->cFields = 0;
|
|
data->fields = NULL;
|
|
memset(page, 0, sizeof(PROPSHEETPAGEW));
|
|
page->dwSize = sizeof(PROPSHEETPAGEW);
|
|
page->dwFlags = PSP_USECALLBACK;
|
|
page->pfnCallback = detail_callback;
|
|
page->hInstance = hInstance;
|
|
page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
|
|
page->pfnDlgProc = detail_dlg_proc;
|
|
page->lParam = (LPARAM)data;
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
return ret;
|
|
}
|
|
|
|
struct hierarchy_data
|
|
{
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
|
|
HIMAGELIST imageList;
|
|
DWORD selectedCert;
|
|
};
|
|
|
|
static LPARAM index_to_lparam(struct hierarchy_data *data, DWORD index)
|
|
{
|
|
CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
|
|
data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
|
|
data->pCertViewInfo->idxCounterSigner);
|
|
|
|
/* Takes advantage of the fact that a pointer is 32-bit aligned, and
|
|
* therefore always even.
|
|
*/
|
|
if (index == provSigner->csCertChain - 1)
|
|
return (LPARAM)data;
|
|
return index << 1 | 1;
|
|
}
|
|
|
|
static inline DWORD lparam_to_index(struct hierarchy_data *data, LPARAM lp)
|
|
{
|
|
CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
|
|
data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
|
|
data->pCertViewInfo->idxCounterSigner);
|
|
|
|
if (!(lp & 1))
|
|
return provSigner->csCertChain - 1;
|
|
return lp >> 1;
|
|
}
|
|
|
|
static struct hierarchy_data *get_hierarchy_data_from_tree_item(HWND tree,
|
|
HTREEITEM hItem)
|
|
{
|
|
struct hierarchy_data *data = NULL;
|
|
HTREEITEM root = NULL;
|
|
|
|
do {
|
|
HTREEITEM parent = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM,
|
|
TVGN_PARENT, (LPARAM)hItem);
|
|
|
|
if (!parent)
|
|
root = hItem;
|
|
hItem = parent;
|
|
} while (hItem);
|
|
if (root)
|
|
{
|
|
TVITEMW item;
|
|
|
|
item.mask = TVIF_PARAM;
|
|
item.hItem = root;
|
|
SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
|
|
data = (struct hierarchy_data *)item.lParam;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
static WCHAR *get_cert_display_name(PCCERT_CONTEXT cert)
|
|
{
|
|
WCHAR *name = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID);
|
|
|
|
if (!name)
|
|
name = get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
|
|
return name;
|
|
}
|
|
|
|
static void show_cert_chain(HWND hwnd, struct hierarchy_data *data)
|
|
{
|
|
HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
|
|
CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
|
|
data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
|
|
data->pCertViewInfo->idxCounterSigner);
|
|
DWORD i;
|
|
HTREEITEM parent = NULL;
|
|
|
|
SendMessageW(tree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)data->imageList);
|
|
for (i = provSigner->csCertChain; i; i--)
|
|
{
|
|
LPWSTR name;
|
|
|
|
name = get_cert_display_name(provSigner->pasCertChain[i - 1].pCert);
|
|
if (name)
|
|
{
|
|
TVINSERTSTRUCTW tvis;
|
|
|
|
tvis.hParent = parent;
|
|
tvis.hInsertAfter = TVI_LAST;
|
|
tvis.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE |
|
|
TVIF_SELECTEDIMAGE | TVIF_PARAM;
|
|
tvis.u.item.pszText = name;
|
|
tvis.u.item.state = TVIS_EXPANDED;
|
|
tvis.u.item.stateMask = TVIS_EXPANDED;
|
|
if (i == 1 && (!provSigner->pChainContext ||
|
|
provSigner->pChainContext->TrustStatus.dwErrorStatus &
|
|
CERT_TRUST_IS_PARTIAL_CHAIN))
|
|
{
|
|
/* The root of the chain has a special case: if the chain is
|
|
* a partial chain, the icon is a warning icon rather than an
|
|
* error icon.
|
|
*/
|
|
tvis.u.item.iImage = 2;
|
|
}
|
|
else if (provSigner->pasCertChain[i - 1].pChainElement->TrustStatus.
|
|
dwErrorStatus == 0)
|
|
tvis.u.item.iImage = 0;
|
|
else
|
|
tvis.u.item.iImage = 1;
|
|
tvis.u.item.iSelectedImage = tvis.u.item.iImage;
|
|
tvis.u.item.lParam = index_to_lparam(data, i - 1);
|
|
parent = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0,
|
|
(LPARAM)&tvis);
|
|
HeapFree(GetProcessHeap(), 0, name);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void set_certificate_status(HWND hwnd, const CRYPT_PROVIDER_CERT *cert)
|
|
{
|
|
/* Select all the text in the control, the next update will replace it */
|
|
SendMessageW(hwnd, EM_SETSEL, 0, -1);
|
|
/* Set the highest priority error messages first. */
|
|
if (!(cert->dwConfidence & CERT_CONFIDENCE_SIG))
|
|
add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_SIGNATURE);
|
|
else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIME))
|
|
add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIME);
|
|
else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIMENEST))
|
|
add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIMENEST);
|
|
else if (cert->dwRevokedReason)
|
|
add_string_resource_to_control(hwnd, IDS_CERTIFICATE_REVOKED);
|
|
else
|
|
add_string_resource_to_control(hwnd, IDS_CERTIFICATE_VALID);
|
|
}
|
|
|
|
static void set_certificate_status_for_end_cert(HWND hwnd,
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
|
|
{
|
|
HWND status = GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT);
|
|
CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
|
|
pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
|
|
pCertViewInfo->idxCounterSigner);
|
|
CRYPT_PROVIDER_CERT *provCert = WTHelperGetProvCertFromChain(provSigner,
|
|
pCertViewInfo->idxCert);
|
|
|
|
set_certificate_status(status, provCert);
|
|
}
|
|
|
|
static void show_cert_hierarchy(HWND hwnd, struct hierarchy_data *data)
|
|
{
|
|
/* Disable view certificate button until a certificate is selected */
|
|
EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), FALSE);
|
|
show_cert_chain(hwnd, data);
|
|
set_certificate_status_for_end_cert(hwnd, data->pCertViewInfo);
|
|
}
|
|
|
|
static void show_dialog_for_selected_cert(HWND hwnd)
|
|
{
|
|
HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
|
|
TVITEMW item;
|
|
struct hierarchy_data *data;
|
|
DWORD selection;
|
|
|
|
memset(&item, 0, sizeof(item));
|
|
item.mask = TVIF_HANDLE | TVIF_PARAM;
|
|
item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CARET, 0);
|
|
SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
|
|
data = get_hierarchy_data_from_tree_item(tree, item.hItem);
|
|
selection = lparam_to_index(data, item.lParam);
|
|
if (selection != 0)
|
|
{
|
|
CRYPT_PROVIDER_SGNR *provSigner;
|
|
CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
|
|
BOOL changed = FALSE;
|
|
|
|
provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
|
|
data->pCertViewInfo->idxSigner,
|
|
data->pCertViewInfo->fCounterSigner,
|
|
data->pCertViewInfo->idxCounterSigner);
|
|
memset(&viewInfo, 0, sizeof(viewInfo));
|
|
viewInfo.dwSize = sizeof(viewInfo);
|
|
viewInfo.dwFlags = data->pCertViewInfo->dwFlags;
|
|
viewInfo.szTitle = data->pCertViewInfo->szTitle;
|
|
viewInfo.pCertContext = provSigner->pasCertChain[selection].pCert;
|
|
viewInfo.cStores = data->pCertViewInfo->cStores;
|
|
viewInfo.rghStores = data->pCertViewInfo->rghStores;
|
|
viewInfo.cPropSheetPages = data->pCertViewInfo->cPropSheetPages;
|
|
viewInfo.rgPropSheetPages = data->pCertViewInfo->rgPropSheetPages;
|
|
viewInfo.nStartPage = data->pCertViewInfo->nStartPage;
|
|
CryptUIDlgViewCertificateW(&viewInfo, &changed);
|
|
if (changed)
|
|
{
|
|
/* Delete the contents of the tree */
|
|
SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
|
|
/* Reinitialize the tree */
|
|
show_cert_hierarchy(hwnd, data);
|
|
}
|
|
}
|
|
}
|
|
|
|
static LRESULT CALLBACK hierarchy_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
PROPSHEETPAGEW *page;
|
|
struct hierarchy_data *data;
|
|
LRESULT ret = 0;
|
|
HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
|
|
|
|
TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
page = (PROPSHEETPAGEW *)lp;
|
|
data = (struct hierarchy_data *)page->lParam;
|
|
show_cert_hierarchy(hwnd, data);
|
|
break;
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr;
|
|
|
|
hdr = (NMHDR *)lp;
|
|
switch (hdr->code)
|
|
{
|
|
case TVN_SELCHANGEDW:
|
|
{
|
|
NMTREEVIEWW *nm = (NMTREEVIEWW*)lp;
|
|
DWORD selection;
|
|
CRYPT_PROVIDER_SGNR *provSigner;
|
|
|
|
data = get_hierarchy_data_from_tree_item(tree, nm->itemNew.hItem);
|
|
selection = lparam_to_index(data, nm->itemNew.lParam);
|
|
provSigner = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
|
|
data->pCertViewInfo->idxSigner,
|
|
data->pCertViewInfo->fCounterSigner,
|
|
data->pCertViewInfo->idxCounterSigner);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), selection != 0);
|
|
set_certificate_status(GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT),
|
|
&provSigner->pasCertChain[selection]);
|
|
break;
|
|
}
|
|
case NM_DBLCLK:
|
|
show_dialog_for_selected_cert(hwnd);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDC_VIEWCERTIFICATE:
|
|
show_dialog_for_selected_cert(hwnd);
|
|
break;
|
|
}
|
|
break;
|
|
case WM_REFRESH_VIEW:
|
|
{
|
|
TVITEMW item;
|
|
|
|
/* Get hierarchy data */
|
|
memset(&item, 0, sizeof(item));
|
|
item.mask = TVIF_HANDLE | TVIF_PARAM;
|
|
item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_ROOT,
|
|
0);
|
|
data = get_hierarchy_data_from_tree_item(tree, item.hItem);
|
|
/* Delete the contents of the tree */
|
|
SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
|
|
/* Reinitialize the tree */
|
|
show_cert_hierarchy(hwnd, data);
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static UINT CALLBACK hierarchy_callback(HWND hwnd, UINT msg,
|
|
PROPSHEETPAGEW *page)
|
|
{
|
|
struct hierarchy_data *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case PSPCB_RELEASE:
|
|
data = (struct hierarchy_data *)page->lParam;
|
|
ImageList_Destroy(data->imageList);
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static BOOL init_hierarchy_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
|
|
PROPSHEETPAGEW *page)
|
|
{
|
|
struct hierarchy_data *data = HeapAlloc(GetProcessHeap(), 0,
|
|
sizeof(struct hierarchy_data));
|
|
BOOL ret = FALSE;
|
|
|
|
if (data)
|
|
{
|
|
data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
|
|
if (data->imageList)
|
|
{
|
|
HBITMAP bmp;
|
|
COLORREF backColor = RGB(255, 0, 255);
|
|
|
|
data->pCertViewInfo = pCertViewInfo;
|
|
data->selectedCert = 0xffffffff;
|
|
|
|
bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
|
|
ImageList_AddMasked(data->imageList, bmp, backColor);
|
|
DeleteObject(bmp);
|
|
ImageList_SetBkColor(data->imageList, CLR_NONE);
|
|
|
|
memset(page, 0, sizeof(PROPSHEETPAGEW));
|
|
page->dwSize = sizeof(PROPSHEETPAGEW);
|
|
page->dwFlags = PSP_USECALLBACK;
|
|
page->hInstance = hInstance;
|
|
page->u.pszTemplate = MAKEINTRESOURCEW(IDD_HIERARCHY);
|
|
page->pfnDlgProc = hierarchy_dlg_proc;
|
|
page->lParam = (LPARAM)data;
|
|
page->pfnCallback = hierarchy_callback;
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
HeapFree(GetProcessHeap(), 0, data);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
|
|
{
|
|
RECT rc;
|
|
|
|
TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
|
|
|
|
switch (msg)
|
|
{
|
|
case PSCB_INITIALIZED:
|
|
/* Get cancel button's position.. */
|
|
GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
|
|
MapWindowPoints( 0, hwnd, (POINT *)&rc, 2 );
|
|
/* hide the cancel button.. */
|
|
ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
|
|
/* and move the OK button to the cancel button's original position. */
|
|
SetWindowPos(GetDlgItem(hwnd, IDOK), 0, rc.left, rc.top, 0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW );
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
|
|
CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
|
|
{
|
|
static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
|
|
DWORD nPages;
|
|
PROPSHEETPAGEW *pages;
|
|
BOOL ret = FALSE;
|
|
HMODULE lib = LoadLibraryW(riched);
|
|
|
|
nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
|
|
if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
|
|
nPages++;
|
|
if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
|
|
nPages++;
|
|
pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
|
|
if (pages)
|
|
{
|
|
PROPSHEETHEADERW hdr;
|
|
CRYPTUI_INITDIALOG_STRUCT *init = NULL;
|
|
DWORD i;
|
|
|
|
memset(&hdr, 0, sizeof(hdr));
|
|
hdr.dwSize = sizeof(hdr);
|
|
hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
|
|
hdr.hInstance = hInstance;
|
|
if (pCertViewInfo->szTitle)
|
|
hdr.pszCaption = pCertViewInfo->szTitle;
|
|
else
|
|
hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
|
|
init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
|
|
if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
|
|
{
|
|
if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
|
|
&pages[hdr.nPages]))
|
|
hdr.nPages++;
|
|
}
|
|
if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
|
|
{
|
|
if (init_hierarchy_page(pCertViewInfo, &pages[hdr.nPages]))
|
|
hdr.nPages++;
|
|
}
|
|
/* Copy each additional page, and create the init dialog struct for it
|
|
*/
|
|
if (pCertViewInfo->cPropSheetPages)
|
|
{
|
|
init = HeapAlloc(GetProcessHeap(), 0,
|
|
pCertViewInfo->cPropSheetPages *
|
|
sizeof(CRYPTUI_INITDIALOG_STRUCT));
|
|
if (init)
|
|
{
|
|
for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
|
|
{
|
|
memcpy(&pages[hdr.nPages + i],
|
|
&pCertViewInfo->rgPropSheetPages[i],
|
|
sizeof(PROPSHEETPAGEW));
|
|
init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
|
|
init[i].pCertContext = pCertViewInfo->pCertContext;
|
|
pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
|
|
}
|
|
if (pCertViewInfo->nStartPage & 0x8000)
|
|
{
|
|
/* Start page index is relative to the number of default
|
|
* pages
|
|
*/
|
|
hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
|
|
}
|
|
else
|
|
hdr.u2.nStartPage = pCertViewInfo->nStartPage;
|
|
hdr.nPages = nPages;
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
}
|
|
else
|
|
{
|
|
/* Ignore the relative flag if there aren't any additional pages */
|
|
hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
|
|
ret = TRUE;
|
|
}
|
|
if (ret)
|
|
{
|
|
INT_PTR l;
|
|
|
|
hdr.u3.ppsp = pages;
|
|
hdr.pfnCallback = cert_prop_sheet_proc;
|
|
l = PropertySheetW(&hdr);
|
|
if (l == 0)
|
|
{
|
|
SetLastError(ERROR_CANCELLED);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, init);
|
|
HeapFree(GetProcessHeap(), 0, pages);
|
|
}
|
|
else
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
FreeLibrary(lib);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* CryptUIDlgViewCertificateW (CRYPTUI.@)
|
|
*/
|
|
BOOL WINAPI CryptUIDlgViewCertificateW(
|
|
PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
|
|
{
|
|
static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
|
|
CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
|
|
WINTRUST_DATA wvt;
|
|
WINTRUST_CERT_INFO cert;
|
|
BOOL ret = FALSE;
|
|
CRYPT_PROVIDER_SGNR *signer;
|
|
CRYPT_PROVIDER_CERT *provCert = NULL;
|
|
|
|
TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
|
|
|
|
if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
/* Make a local copy in case we have to call WinVerifyTrust ourselves */
|
|
memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
|
|
if (!pCertViewInfo->u.hWVTStateData)
|
|
{
|
|
memset(&wvt, 0, sizeof(wvt));
|
|
wvt.cbStruct = sizeof(wvt);
|
|
wvt.dwUIChoice = WTD_UI_NONE;
|
|
if (viewInfo.dwFlags &
|
|
CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
|
|
wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
|
|
if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
|
|
wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
|
|
if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
|
|
wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
|
|
wvt.dwUnionChoice = WTD_CHOICE_CERT;
|
|
memset(&cert, 0, sizeof(cert));
|
|
cert.cbStruct = sizeof(cert);
|
|
cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
|
|
cert.chStores = viewInfo.cStores;
|
|
cert.pahStores = viewInfo.rghStores;
|
|
wvt.u.pCert = &cert;
|
|
wvt.dwStateAction = WTD_STATEACTION_VERIFY;
|
|
WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
|
|
viewInfo.u.pCryptProviderData =
|
|
WTHelperProvDataFromStateData(wvt.hWVTStateData);
|
|
signer = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
|
|
provCert = WTHelperGetProvCertFromChain(signer, 0);
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
{
|
|
viewInfo.u.pCryptProviderData =
|
|
WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
|
|
signer = WTHelperGetProvSignerFromChain(
|
|
(CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
|
|
viewInfo.idxSigner, viewInfo.fCounterSigner,
|
|
viewInfo.idxCounterSigner);
|
|
provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
|
|
ret = TRUE;
|
|
}
|
|
if (ret)
|
|
{
|
|
ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
|
|
if (!pCertViewInfo->u.hWVTStateData)
|
|
{
|
|
wvt.dwStateAction = WTD_STATEACTION_CLOSE;
|
|
WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* CryptUIDlgViewContext (CRYPTUI.@)
|
|
*/
|
|
BOOL WINAPI CryptUIDlgViewContext(DWORD dwContextType, LPVOID pvContext,
|
|
HWND hwnd, LPCWSTR pwszTitle, DWORD dwFlags, LPVOID pvReserved)
|
|
{
|
|
BOOL ret;
|
|
|
|
TRACE("(%d, %p, %p, %s, %08x, %p)\n", dwContextType, pvContext, hwnd,
|
|
debugstr_w(pwszTitle), dwFlags, pvReserved);
|
|
|
|
switch (dwContextType)
|
|
{
|
|
case CERT_STORE_CERTIFICATE_CONTEXT:
|
|
{
|
|
CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
|
|
|
|
memset(&viewInfo, 0, sizeof(viewInfo));
|
|
viewInfo.dwSize = sizeof(viewInfo);
|
|
viewInfo.hwndParent = hwnd;
|
|
viewInfo.szTitle = pwszTitle;
|
|
viewInfo.pCertContext = pvContext;
|
|
ret = CryptUIDlgViewCertificateW(&viewInfo, NULL);
|
|
break;
|
|
}
|
|
default:
|
|
FIXME("unimplemented for context type %d\n", dwContextType);
|
|
SetLastError(E_INVALIDARG);
|
|
ret = FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
|
|
* or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
|
|
* should be a CA. If neither extension is present, returns
|
|
* defaultIfNotSpecified.
|
|
*/
|
|
static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
|
|
{
|
|
BOOL isCA = defaultIfNotSpecified;
|
|
PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
|
|
cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
|
|
|
|
if (ext)
|
|
{
|
|
CERT_BASIC_CONSTRAINTS_INFO *info;
|
|
DWORD size = 0;
|
|
|
|
if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
|
|
ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
|
|
NULL, &info, &size))
|
|
{
|
|
if (info->SubjectType.cbData == 1)
|
|
isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
|
|
LocalFree(info);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
|
|
cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
|
|
if (ext)
|
|
{
|
|
CERT_BASIC_CONSTRAINTS2_INFO info;
|
|
DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
|
|
|
|
if (CryptDecodeObjectEx(X509_ASN_ENCODING,
|
|
szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
|
|
0, NULL, &info, &size))
|
|
isCA = info.fCA;
|
|
}
|
|
}
|
|
return isCA;
|
|
}
|
|
|
|
static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
|
|
{
|
|
LPCWSTR storeName;
|
|
|
|
if (is_ca_cert(cert, TRUE))
|
|
storeName = ca;
|
|
else
|
|
storeName = addressBook;
|
|
return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
|
|
CERT_SYSTEM_STORE_CURRENT_USER, storeName);
|
|
}
|
|
|
|
static BOOL import_cert(PCCERT_CONTEXT cert, HCERTSTORE hDestCertStore)
|
|
{
|
|
HCERTSTORE store;
|
|
BOOL ret;
|
|
|
|
if (!cert)
|
|
{
|
|
SetLastError(E_INVALIDARG);
|
|
return FALSE;
|
|
}
|
|
if (hDestCertStore) store = hDestCertStore;
|
|
else
|
|
{
|
|
if (!(store = choose_store_for_cert(cert)))
|
|
{
|
|
WARN("unable to open certificate store\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
ret = CertAddCertificateContextToStore(store, cert,
|
|
CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
|
|
if (!hDestCertStore) CertCloseStore(store, 0);
|
|
return ret;
|
|
}
|
|
|
|
static BOOL import_crl(PCCRL_CONTEXT crl, HCERTSTORE hDestCertStore)
|
|
{
|
|
HCERTSTORE store;
|
|
BOOL ret;
|
|
|
|
if (!crl)
|
|
{
|
|
SetLastError(E_INVALIDARG);
|
|
return FALSE;
|
|
}
|
|
if (hDestCertStore) store = hDestCertStore;
|
|
else
|
|
{
|
|
if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
|
|
CERT_SYSTEM_STORE_CURRENT_USER, ca)))
|
|
{
|
|
WARN("unable to open certificate store\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
ret = CertAddCRLContextToStore(store, crl,
|
|
CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
|
|
if (!hDestCertStore) CertCloseStore(store, 0);
|
|
return ret;
|
|
}
|
|
|
|
static BOOL import_ctl(PCCTL_CONTEXT ctl, HCERTSTORE hDestCertStore)
|
|
{
|
|
HCERTSTORE store;
|
|
BOOL ret;
|
|
|
|
if (!ctl)
|
|
{
|
|
SetLastError(E_INVALIDARG);
|
|
return FALSE;
|
|
}
|
|
if (hDestCertStore) store = hDestCertStore;
|
|
else
|
|
{
|
|
static const WCHAR trust[] = { 'T','r','u','s','t',0 };
|
|
|
|
if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
|
|
CERT_SYSTEM_STORE_CURRENT_USER, trust)))
|
|
{
|
|
WARN("unable to open certificate store\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
ret = CertAddCTLContextToStore(store, ctl,
|
|
CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
|
|
if (!hDestCertStore) CertCloseStore(store, 0);
|
|
return ret;
|
|
}
|
|
|
|
/* Checks type, a type such as CERT_QUERY_CONTENT_CERT returned by
|
|
* CryptQueryObject, against the allowed types. Returns TRUE if the
|
|
* type is allowed, FALSE otherwise.
|
|
*/
|
|
static BOOL check_context_type(DWORD dwFlags, DWORD type)
|
|
{
|
|
BOOL ret;
|
|
|
|
if (dwFlags &
|
|
(CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
|
|
CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
|
|
{
|
|
switch (type)
|
|
{
|
|
case CERT_QUERY_CONTENT_CERT:
|
|
case CERT_QUERY_CONTENT_SERIALIZED_CERT:
|
|
ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT;
|
|
break;
|
|
case CERT_QUERY_CONTENT_CRL:
|
|
case CERT_QUERY_CONTENT_SERIALIZED_CRL:
|
|
ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL;
|
|
break;
|
|
case CERT_QUERY_CONTENT_CTL:
|
|
case CERT_QUERY_CONTENT_SERIALIZED_CTL:
|
|
ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL;
|
|
break;
|
|
default:
|
|
/* The remaining types contain more than one type, so allow
|
|
* any combination.
|
|
*/
|
|
ret = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* No allowed types specified, so any type is allowed */
|
|
ret = TRUE;
|
|
}
|
|
if (!ret)
|
|
SetLastError(E_INVALIDARG);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void import_warning(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
|
|
int warningID)
|
|
{
|
|
if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
|
|
if (szTitle)
|
|
pTitle = szTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, warningID, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
|
|
}
|
|
}
|
|
|
|
static void import_warn_type_mismatch(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle)
|
|
{
|
|
import_warning(dwFlags, hwnd, szTitle, IDS_IMPORT_TYPE_MISMATCH);
|
|
}
|
|
|
|
static BOOL check_store_context_type(DWORD dwFlags, HCERTSTORE store)
|
|
{
|
|
BOOL ret;
|
|
|
|
if (dwFlags &
|
|
(CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
|
|
CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
|
|
{
|
|
PCCERT_CONTEXT cert;
|
|
PCCRL_CONTEXT crl;
|
|
PCCTL_CONTEXT ctl;
|
|
|
|
ret = TRUE;
|
|
if ((cert = CertEnumCertificatesInStore(store, NULL)))
|
|
{
|
|
CertFreeCertificateContext(cert);
|
|
if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT))
|
|
ret = FALSE;
|
|
}
|
|
if (ret && (crl = CertEnumCRLsInStore(store, NULL)))
|
|
{
|
|
CertFreeCRLContext(crl);
|
|
if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL))
|
|
ret = FALSE;
|
|
}
|
|
if (ret && (ctl = CertEnumCTLsInStore(store, NULL)))
|
|
{
|
|
CertFreeCTLContext(ctl);
|
|
if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
else
|
|
ret = TRUE;
|
|
if (!ret)
|
|
SetLastError(E_INVALIDARG);
|
|
return ret;
|
|
}
|
|
|
|
static BOOL import_store(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
|
|
HCERTSTORE source, HCERTSTORE dest)
|
|
{
|
|
BOOL ret;
|
|
|
|
if ((ret = check_store_context_type(dwFlags, source)))
|
|
{
|
|
PCCERT_CONTEXT cert = NULL;
|
|
PCCRL_CONTEXT crl = NULL;
|
|
PCCTL_CONTEXT ctl = NULL;
|
|
|
|
do {
|
|
cert = CertEnumCertificatesInStore(source, cert);
|
|
if (cert)
|
|
ret = import_cert(cert, dest);
|
|
} while (ret && cert);
|
|
do {
|
|
crl = CertEnumCRLsInStore(source, crl);
|
|
if (crl)
|
|
ret = import_crl(crl, dest);
|
|
} while (ret && crl);
|
|
do {
|
|
ctl = CertEnumCTLsInStore(source, ctl);
|
|
if (ctl)
|
|
ret = import_ctl(ctl, dest);
|
|
} while (ret && ctl);
|
|
}
|
|
else
|
|
import_warn_type_mismatch(dwFlags, hwnd, szTitle);
|
|
return ret;
|
|
}
|
|
|
|
static HCERTSTORE open_store_from_file(DWORD dwFlags, LPCWSTR fileName,
|
|
DWORD *pContentType)
|
|
{
|
|
HCERTSTORE store = NULL;
|
|
DWORD contentType = 0, expectedContentTypeFlags;
|
|
|
|
if (dwFlags &
|
|
(CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
|
|
CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
|
|
{
|
|
expectedContentTypeFlags =
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
|
|
CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
|
|
CERT_QUERY_CONTENT_FLAG_PFX;
|
|
if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT)
|
|
expectedContentTypeFlags |=
|
|
CERT_QUERY_CONTENT_FLAG_CERT |
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT;
|
|
if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL)
|
|
expectedContentTypeFlags |=
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
|
|
CERT_QUERY_CONTENT_FLAG_CRL;
|
|
if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL)
|
|
expectedContentTypeFlags |=
|
|
CERT_QUERY_CONTENT_FLAG_CTL |
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL;
|
|
}
|
|
else
|
|
expectedContentTypeFlags =
|
|
CERT_QUERY_CONTENT_FLAG_CERT |
|
|
CERT_QUERY_CONTENT_FLAG_CTL |
|
|
CERT_QUERY_CONTENT_FLAG_CRL |
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT |
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL |
|
|
CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
|
|
CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
|
|
CERT_QUERY_CONTENT_FLAG_PFX;
|
|
|
|
CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
|
|
expectedContentTypeFlags, CERT_QUERY_FORMAT_FLAG_ALL, 0, NULL,
|
|
&contentType, NULL, &store, NULL, NULL);
|
|
if (pContentType)
|
|
*pContentType = contentType;
|
|
return store;
|
|
}
|
|
|
|
static BOOL import_file(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
|
|
LPCWSTR fileName, HCERTSTORE dest)
|
|
{
|
|
HCERTSTORE source;
|
|
BOOL ret;
|
|
|
|
if ((source = open_store_from_file(dwFlags, fileName, NULL)))
|
|
{
|
|
ret = import_store(dwFlags, hwnd, szTitle, source, dest);
|
|
CertCloseStore(source, 0);
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
return ret;
|
|
}
|
|
|
|
struct ImportWizData
|
|
{
|
|
HFONT titleFont;
|
|
DWORD dwFlags;
|
|
LPCWSTR pwszWizardTitle;
|
|
CRYPTUI_WIZ_IMPORT_SRC_INFO importSrc;
|
|
LPWSTR fileName;
|
|
DWORD contentType;
|
|
BOOL freeSource;
|
|
HCERTSTORE hDestCertStore;
|
|
BOOL freeDest;
|
|
BOOL autoDest;
|
|
BOOL success;
|
|
};
|
|
|
|
static LRESULT CALLBACK import_welcome_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
struct ImportWizData *data;
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
WCHAR fontFace[MAX_STRING_LEN];
|
|
HDC hDC = GetDC(hwnd);
|
|
int height;
|
|
|
|
data = (struct ImportWizData *)page->lParam;
|
|
LoadStringW(hInstance, IDS_WIZARD_TITLE_FONT, fontFace,
|
|
sizeof(fontFace) / sizeof(fontFace[0]));
|
|
height = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
|
|
data->titleFont = CreateFontW(height, 0, 0, 0, FW_BOLD, 0, 0, 0,
|
|
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
|
|
DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontFace);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_TITLE), WM_SETFONT,
|
|
(WPARAM)data->titleFont, TRUE);
|
|
ReleaseDC(hwnd, hDC);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const WCHAR filter_cert[] = { '*','.','c','e','r',';','*','.',
|
|
'c','r','t',0 };
|
|
static const WCHAR filter_pfx[] = { '*','.','p','f','x',';','*','.',
|
|
'p','1','2',0 };
|
|
static const WCHAR filter_crl[] = { '*','.','c','r','l',0 };
|
|
static const WCHAR filter_ctl[] = { '*','.','s','t','l',0 };
|
|
static const WCHAR filter_serialized_store[] = { '*','.','s','s','t',0 };
|
|
static const WCHAR filter_cms[] = { '*','.','s','p','c',';','*','.',
|
|
'p','7','b',0 };
|
|
static const WCHAR filter_all[] = { '*','.','*',0 };
|
|
|
|
static struct StringToFilter
|
|
{
|
|
int id;
|
|
DWORD allowFlags;
|
|
LPCWSTR filter;
|
|
} import_filters[] = {
|
|
{ IDS_IMPORT_FILTER_CERT, CRYPTUI_WIZ_IMPORT_ALLOW_CERT, filter_cert },
|
|
{ IDS_IMPORT_FILTER_PFX, 0, filter_pfx },
|
|
{ IDS_IMPORT_FILTER_CRL, CRYPTUI_WIZ_IMPORT_ALLOW_CRL, filter_crl },
|
|
{ IDS_IMPORT_FILTER_CTL, CRYPTUI_WIZ_IMPORT_ALLOW_CTL, filter_ctl },
|
|
{ IDS_IMPORT_FILTER_SERIALIZED_STORE, 0, filter_serialized_store },
|
|
{ IDS_IMPORT_FILTER_CMS, 0, filter_cms },
|
|
{ IDS_IMPORT_FILTER_ALL, 0, filter_all },
|
|
};
|
|
|
|
static WCHAR *make_import_file_filter(DWORD dwFlags)
|
|
{
|
|
DWORD i;
|
|
int len, totalLen = 2;
|
|
LPWSTR filter = NULL, str;
|
|
|
|
for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
|
|
{
|
|
if (!import_filters[i].allowFlags || !dwFlags ||
|
|
(dwFlags & import_filters[i].allowFlags))
|
|
{
|
|
len = LoadStringW(hInstance, import_filters[i].id, (LPWSTR)&str, 0);
|
|
totalLen += len + strlenW(import_filters[i].filter) + 2;
|
|
}
|
|
}
|
|
filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
|
|
if (filter)
|
|
{
|
|
LPWSTR ptr;
|
|
|
|
ptr = filter;
|
|
for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
|
|
{
|
|
if (!import_filters[i].allowFlags || !dwFlags ||
|
|
(dwFlags & import_filters[i].allowFlags))
|
|
{
|
|
len = LoadStringW(hInstance, import_filters[i].id,
|
|
(LPWSTR)&str, 0);
|
|
memcpy(ptr, str, len * sizeof(WCHAR));
|
|
ptr += len;
|
|
*ptr++ = 0;
|
|
strcpyW(ptr, import_filters[i].filter);
|
|
ptr += strlenW(import_filters[i].filter) + 1;
|
|
}
|
|
}
|
|
*ptr++ = 0;
|
|
}
|
|
return filter;
|
|
}
|
|
|
|
static BOOL import_validate_filename(HWND hwnd, struct ImportWizData *data,
|
|
LPCWSTR fileName)
|
|
{
|
|
HANDLE file;
|
|
BOOL ret = FALSE;
|
|
|
|
file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
|
|
OPEN_EXISTING, 0, NULL);
|
|
if (file != INVALID_HANDLE_VALUE)
|
|
{
|
|
HCERTSTORE source = open_store_from_file(data->dwFlags, fileName,
|
|
&data->contentType);
|
|
int warningID = 0;
|
|
|
|
if (!source)
|
|
warningID = IDS_IMPORT_BAD_FORMAT;
|
|
else if (!check_store_context_type(data->dwFlags, source))
|
|
warningID = IDS_IMPORT_TYPE_MISMATCH;
|
|
else
|
|
{
|
|
data->importSrc.dwSubjectChoice =
|
|
CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE;
|
|
data->importSrc.u.hCertStore = source;
|
|
data->freeSource = TRUE;
|
|
ret = TRUE;
|
|
}
|
|
if (warningID)
|
|
{
|
|
import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
|
|
warningID);
|
|
}
|
|
CloseHandle(file);
|
|
}
|
|
else
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
LPWSTR msgBuf, fullError;
|
|
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
FormatMessageW(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
|
|
GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
|
|
fullError = HeapAlloc(GetProcessHeap(), 0,
|
|
(strlenW(error) + strlenW(fileName) + strlenW(msgBuf) + 3)
|
|
* sizeof(WCHAR));
|
|
if (fullError)
|
|
{
|
|
LPWSTR ptr = fullError;
|
|
|
|
strcpyW(ptr, error);
|
|
ptr += strlenW(error);
|
|
strcpyW(ptr, fileName);
|
|
ptr += strlenW(fileName);
|
|
*ptr++ = ':';
|
|
*ptr++ = '\n';
|
|
strcpyW(ptr, msgBuf);
|
|
MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
|
|
HeapFree(GetProcessHeap(), 0, fullError);
|
|
}
|
|
LocalFree(msgBuf);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LRESULT CALLBACK import_file_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ImportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
|
|
data = (struct ImportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
if (data->fileName)
|
|
{
|
|
HWND fileNameEdit = GetDlgItem(hwnd, IDC_IMPORT_FILENAME);
|
|
|
|
SendMessageW(fileNameEdit, WM_SETTEXT, 0, (LPARAM)data->fileName);
|
|
}
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
case PSN_WIZNEXT:
|
|
{
|
|
HWND fileNameEdit = GetDlgItem(hwnd, IDC_IMPORT_FILENAME);
|
|
DWORD len = SendMessageW(fileNameEdit, WM_GETTEXTLENGTH, 0, 0);
|
|
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (!len)
|
|
{
|
|
import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
|
|
IDS_IMPORT_EMPTY_FILE);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
LPWSTR fileName = HeapAlloc(GetProcessHeap(), 0,
|
|
(len + 1) * sizeof(WCHAR));
|
|
|
|
if (fileName)
|
|
{
|
|
SendMessageW(fileNameEdit, WM_GETTEXT, len + 1,
|
|
(LPARAM)fileName);
|
|
if (!import_validate_filename(hwnd, data, fileName))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, fileName);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
else
|
|
data->fileName = fileName;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDC_IMPORT_BROWSE_FILE:
|
|
{
|
|
OPENFILENAMEW ofn;
|
|
WCHAR fileBuf[MAX_PATH];
|
|
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
memset(&ofn, 0, sizeof(ofn));
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = hwnd;
|
|
ofn.lpstrFilter = make_import_file_filter(data->dwFlags);
|
|
ofn.lpstrFile = fileBuf;
|
|
ofn.nMaxFile = sizeof(fileBuf) / sizeof(fileBuf[0]);
|
|
fileBuf[0] = 0;
|
|
if (GetOpenFileNameW(&ofn))
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_FILENAME), WM_SETTEXT,
|
|
0, (LPARAM)ofn.lpstrFile);
|
|
HeapFree(GetProcessHeap(), 0, (LPWSTR)ofn.lpstrFilter);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LRESULT CALLBACK import_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ImportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
|
|
data = (struct ImportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
if (!data->hDestCertStore)
|
|
{
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_AUTO_STORE), BM_CLICK,
|
|
0, 0);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE), FALSE);
|
|
}
|
|
else
|
|
{
|
|
WCHAR storeTitle[MAX_STRING_LEN];
|
|
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE), BM_CLICK,
|
|
0, 0);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE),
|
|
!(data->dwFlags & CRYPTUI_WIZ_IMPORT_NO_CHANGE_DEST_STORE));
|
|
LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED,
|
|
storeTitle, sizeof(storeTitle) / sizeof(storeTitle[0]));
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_STORE), WM_SETTEXT,
|
|
0, (LPARAM)storeTitle);
|
|
}
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
case PSN_WIZNEXT:
|
|
{
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (IsDlgButtonChecked(hwnd, IDC_IMPORT_SPECIFY_STORE) &&
|
|
!data->hDestCertStore)
|
|
{
|
|
import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
|
|
IDS_IMPORT_SELECT_STORE);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDC_IMPORT_AUTO_STORE:
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
data->autoDest = TRUE;
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), FALSE);
|
|
break;
|
|
case IDC_IMPORT_SPECIFY_STORE:
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
data->autoDest = FALSE;
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), TRUE);
|
|
break;
|
|
case IDC_IMPORT_BROWSE_STORE:
|
|
{
|
|
CRYPTUI_ENUM_SYSTEM_STORE_ARGS enumArgs = {
|
|
CERT_SYSTEM_STORE_CURRENT_USER, NULL };
|
|
CRYPTUI_ENUM_DATA enumData = { 0, NULL, 1, &enumArgs };
|
|
CRYPTUI_SELECTSTORE_INFO_W selectInfo;
|
|
HCERTSTORE store;
|
|
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
selectInfo.dwSize = sizeof(selectInfo);
|
|
selectInfo.parent = hwnd;
|
|
selectInfo.dwFlags = CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE;
|
|
selectInfo.pwszTitle = NULL;
|
|
selectInfo.pwszText = NULL;
|
|
selectInfo.pEnumData = &enumData;
|
|
selectInfo.pfnSelectedStoreCallback = NULL;
|
|
if ((store = CryptUIDlgSelectStoreW(&selectInfo)))
|
|
{
|
|
WCHAR storeTitle[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED,
|
|
storeTitle, sizeof(storeTitle) / sizeof(storeTitle[0]));
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_STORE), WM_SETTEXT,
|
|
0, (LPARAM)storeTitle);
|
|
data->hDestCertStore = store;
|
|
data->freeDest = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void show_import_details(HWND lv, struct ImportWizData *data)
|
|
{
|
|
WCHAR text[MAX_STRING_LEN];
|
|
LVITEMW item;
|
|
int contentID;
|
|
|
|
item.mask = LVIF_TEXT;
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_IMPORT_STORE_SELECTION, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
item.pszText = text;
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
item.iSubItem = 1;
|
|
if (data->autoDest)
|
|
LoadStringW(hInstance, IDS_IMPORT_DEST_AUTOMATIC, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
else
|
|
LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_IMPORT_CONTENT, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
switch (data->contentType)
|
|
{
|
|
case CERT_QUERY_CONTENT_CERT:
|
|
case CERT_QUERY_CONTENT_SERIALIZED_CERT:
|
|
contentID = IDS_IMPORT_CONTENT_CERT;
|
|
break;
|
|
case CERT_QUERY_CONTENT_CRL:
|
|
case CERT_QUERY_CONTENT_SERIALIZED_CRL:
|
|
contentID = IDS_IMPORT_CONTENT_CRL;
|
|
break;
|
|
case CERT_QUERY_CONTENT_CTL:
|
|
case CERT_QUERY_CONTENT_SERIALIZED_CTL:
|
|
contentID = IDS_IMPORT_CONTENT_CTL;
|
|
break;
|
|
case CERT_QUERY_CONTENT_PKCS7_SIGNED:
|
|
contentID = IDS_IMPORT_CONTENT_CMS;
|
|
break;
|
|
case CERT_QUERY_CONTENT_FLAG_PFX:
|
|
contentID = IDS_IMPORT_CONTENT_PFX;
|
|
break;
|
|
default:
|
|
contentID = IDS_IMPORT_CONTENT_STORE;
|
|
break;
|
|
}
|
|
LoadStringW(hInstance, contentID, text, sizeof(text)/ sizeof(text[0]));
|
|
item.iSubItem = 1;
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
if (data->fileName)
|
|
{
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_IMPORT_FILE, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
item.iSubItem = 1;
|
|
item.pszText = data->fileName;
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
}
|
|
}
|
|
|
|
static BOOL do_import(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
|
|
PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
|
|
{
|
|
BOOL ret;
|
|
|
|
switch (pImportSrc->dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
|
|
ret = import_file(dwFlags, hwndParent, pwszWizardTitle,
|
|
pImportSrc->u.pwszFileName, hDestCertStore);
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
|
|
if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CERT)))
|
|
ret = import_cert(pImportSrc->u.pCertContext, hDestCertStore);
|
|
else
|
|
import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
|
|
if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CRL)))
|
|
ret = import_crl(pImportSrc->u.pCRLContext, hDestCertStore);
|
|
else
|
|
import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
|
|
if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CTL)))
|
|
ret = import_ctl(pImportSrc->u.pCTLContext, hDestCertStore);
|
|
else
|
|
import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
|
|
ret = import_store(dwFlags, hwndParent, pwszWizardTitle,
|
|
pImportSrc->u.hCertStore, hDestCertStore);
|
|
break;
|
|
default:
|
|
WARN("unknown source type: %u\n", pImportSrc->dwSubjectChoice);
|
|
SetLastError(E_INVALIDARG);
|
|
ret = FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LRESULT CALLBACK import_finish_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ImportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
HWND lv = GetDlgItem(hwnd, IDC_IMPORT_SETTINGS);
|
|
RECT rc;
|
|
LVCOLUMNW column;
|
|
|
|
data = (struct ImportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_TITLE), WM_SETFONT,
|
|
(WPARAM)data->titleFont, TRUE);
|
|
GetWindowRect(lv, &rc);
|
|
column.mask = LVCF_WIDTH;
|
|
column.cx = (rc.right - rc.left) / 2 - 2;
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
|
|
show_import_details(lv, data);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_IMPORT_SETTINGS);
|
|
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
|
|
show_import_details(lv, data);
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_FINISH);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
case PSN_WIZFINISH:
|
|
{
|
|
data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if ((data->success = do_import(data->dwFlags, hwnd,
|
|
data->pwszWizardTitle, &data->importSrc, data->hDestCertStore)))
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], message[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_IMPORT_SUCCEEDED, message,
|
|
sizeof(message) / sizeof(message[0]));
|
|
MessageBoxW(hwnd, message, pTitle, MB_OK);
|
|
}
|
|
else
|
|
import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
|
|
IDS_IMPORT_FAILED);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BOOL show_import_ui(DWORD dwFlags, HWND hwndParent,
|
|
LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc,
|
|
HCERTSTORE hDestCertStore)
|
|
{
|
|
PROPSHEETHEADERW hdr;
|
|
PROPSHEETPAGEW pages[4];
|
|
struct ImportWizData data;
|
|
int nPages = 0;
|
|
|
|
data.dwFlags = dwFlags;
|
|
data.pwszWizardTitle = pwszWizardTitle;
|
|
if (pImportSrc)
|
|
{
|
|
memcpy(&data.importSrc, pImportSrc, sizeof(data.importSrc));
|
|
data.fileName = (LPWSTR)pImportSrc->u.pwszFileName;
|
|
}
|
|
else
|
|
{
|
|
memset(&data.importSrc, 0, sizeof(data.importSrc));
|
|
data.fileName = NULL;
|
|
}
|
|
data.freeSource = FALSE;
|
|
data.hDestCertStore = hDestCertStore;
|
|
data.freeDest = FALSE;
|
|
data.autoDest = TRUE;
|
|
data.success = TRUE;
|
|
|
|
memset(pages, 0, sizeof(pages));
|
|
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_WELCOME);
|
|
pages[nPages].pfnDlgProc = import_welcome_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_HIDEHEADER;
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
|
|
if (!pImportSrc ||
|
|
pImportSrc->dwSubjectChoice == CRYPTUI_WIZ_IMPORT_SUBJECT_FILE)
|
|
{
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FILE);
|
|
pages[nPages].pfnDlgProc = import_file_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
|
|
pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_FILE_TITLE);
|
|
pages[nPages].pszHeaderSubTitle =
|
|
MAKEINTRESOURCEW(IDS_IMPORT_FILE_SUBTITLE);
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
}
|
|
else
|
|
{
|
|
switch (pImportSrc->dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
|
|
data.contentType = CERT_QUERY_CONTENT_CERT;
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
|
|
data.contentType = CERT_QUERY_CONTENT_CRL;
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
|
|
data.contentType = CERT_QUERY_CONTENT_CTL;
|
|
break;
|
|
case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
|
|
data.contentType = CERT_QUERY_CONTENT_SERIALIZED_STORE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_STORE);
|
|
pages[nPages].pfnDlgProc = import_store_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
|
|
pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_STORE_TITLE);
|
|
pages[nPages].pszHeaderSubTitle =
|
|
MAKEINTRESOURCEW(IDS_IMPORT_STORE_SUBTITLE);
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FINISH);
|
|
pages[nPages].pfnDlgProc = import_finish_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_HIDEHEADER;
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
|
|
memset(&hdr, 0, sizeof(hdr));
|
|
hdr.dwSize = sizeof(hdr);
|
|
hdr.hwndParent = hwndParent;
|
|
hdr.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD97_NEW | PSH_HEADER |
|
|
PSH_WATERMARK;
|
|
hdr.hInstance = hInstance;
|
|
if (pwszWizardTitle)
|
|
hdr.pszCaption = pwszWizardTitle;
|
|
else
|
|
hdr.pszCaption = MAKEINTRESOURCEW(IDS_IMPORT_WIZARD);
|
|
hdr.u3.ppsp = pages;
|
|
hdr.nPages = nPages;
|
|
hdr.u4.pszbmWatermark = MAKEINTRESOURCEW(IDB_CERT_WATERMARK);
|
|
hdr.u5.pszbmHeader = MAKEINTRESOURCEW(IDB_CERT_HEADER);
|
|
PropertySheetW(&hdr);
|
|
if (data.fileName != data.importSrc.u.pwszFileName)
|
|
HeapFree(GetProcessHeap(), 0, data.fileName);
|
|
if (data.freeSource &&
|
|
data.importSrc.dwSubjectChoice == CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE)
|
|
CertCloseStore(data.importSrc.u.hCertStore, 0);
|
|
DeleteObject(data.titleFont);
|
|
return data.success;
|
|
}
|
|
|
|
BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
|
|
PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
|
|
{
|
|
BOOL ret;
|
|
|
|
TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
|
|
pImportSrc, hDestCertStore);
|
|
|
|
if (pImportSrc &&
|
|
pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
|
|
{
|
|
SetLastError(E_INVALIDARG);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
|
|
ret = show_import_ui(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
|
|
hDestCertStore);
|
|
else if (pImportSrc)
|
|
ret = do_import(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
|
|
hDestCertStore);
|
|
else
|
|
{
|
|
/* Can't have no UI without specifying source */
|
|
SetLastError(E_INVALIDARG);
|
|
ret = FALSE;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
struct ExportWizData
|
|
{
|
|
HFONT titleFont;
|
|
DWORD dwFlags;
|
|
LPCWSTR pwszWizardTitle;
|
|
CRYPTUI_WIZ_EXPORT_INFO exportInfo;
|
|
CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO contextInfo;
|
|
BOOL freePassword;
|
|
PCRYPT_KEY_PROV_INFO keyProvInfo;
|
|
BOOL deleteKeys;
|
|
LPWSTR fileName;
|
|
HANDLE file;
|
|
BOOL success;
|
|
};
|
|
|
|
static LRESULT CALLBACK export_welcome_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
struct ExportWizData *data;
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
WCHAR fontFace[MAX_STRING_LEN];
|
|
HDC hDC = GetDC(hwnd);
|
|
int height;
|
|
|
|
data = (struct ExportWizData *)page->lParam;
|
|
LoadStringW(hInstance, IDS_WIZARD_TITLE_FONT, fontFace,
|
|
sizeof(fontFace) / sizeof(fontFace[0]));
|
|
height = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
|
|
data->titleFont = CreateFontW(height, 0, 0, 0, FW_BOLD, 0, 0, 0,
|
|
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
|
|
DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontFace);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_TITLE), WM_SETFONT,
|
|
(WPARAM)data->titleFont, TRUE);
|
|
ReleaseDC(hwnd, hDC);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static PCRYPT_KEY_PROV_INFO export_get_private_key_info(PCCERT_CONTEXT cert)
|
|
{
|
|
PCRYPT_KEY_PROV_INFO info = NULL;
|
|
DWORD size;
|
|
|
|
if (CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID,
|
|
NULL, &size))
|
|
{
|
|
info = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (info)
|
|
{
|
|
if (!CertGetCertificateContextProperty(cert,
|
|
CERT_KEY_PROV_INFO_PROP_ID, info, &size))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, info);
|
|
info = NULL;
|
|
}
|
|
}
|
|
}
|
|
return info;
|
|
}
|
|
|
|
static BOOL export_acquire_private_key(const CRYPT_KEY_PROV_INFO *info,
|
|
HCRYPTPROV *phProv)
|
|
{
|
|
BOOL ret;
|
|
|
|
ret = CryptAcquireContextW(phProv, info->pwszContainerName,
|
|
info->pwszProvName, info->dwProvType, 0);
|
|
if (ret)
|
|
{
|
|
DWORD i;
|
|
|
|
for (i = 0; i < info->cProvParam; i++)
|
|
CryptSetProvParam(*phProv, info->rgProvParam[i].dwParam,
|
|
info->rgProvParam[i].pbData, info->rgProvParam[i].dwFlags);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BOOL export_is_key_exportable(HCRYPTPROV hProv, DWORD keySpec)
|
|
{
|
|
BOOL ret;
|
|
HCRYPTKEY key;
|
|
|
|
if ((ret = CryptGetUserKey(hProv, keySpec, &key)))
|
|
{
|
|
DWORD permissions, size = sizeof(permissions);
|
|
|
|
if ((ret = CryptGetKeyParam(key, KP_PERMISSIONS, (BYTE *)&permissions,
|
|
&size, 0)) && !(permissions & CRYPT_EXPORT))
|
|
ret = FALSE;
|
|
CryptDestroyKey(key);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LRESULT CALLBACK export_private_key_dlg_proc(HWND hwnd, UINT msg,
|
|
WPARAM wp, LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ExportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
PCRYPT_KEY_PROV_INFO info;
|
|
HCRYPTPROV hProv = 0;
|
|
int errorID = 0;
|
|
|
|
data = (struct ExportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
/* Get enough information about a key to see whether it's exportable.
|
|
*/
|
|
if (!(info = export_get_private_key_info(
|
|
data->exportInfo.u.pCertContext)))
|
|
errorID = IDS_EXPORT_PRIVATE_KEY_UNAVAILABLE;
|
|
else if (!export_acquire_private_key(info, &hProv))
|
|
errorID = IDS_EXPORT_PRIVATE_KEY_UNAVAILABLE;
|
|
else if (!export_is_key_exportable(hProv, info->dwKeySpec))
|
|
errorID = IDS_EXPORT_PRIVATE_KEY_NON_EXPORTABLE;
|
|
|
|
if (errorID)
|
|
{
|
|
WCHAR error[MAX_STRING_LEN];
|
|
|
|
LoadStringW(hInstance, errorID, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_PRIVATE_KEY_UNAVAILABLE),
|
|
WM_SETTEXT, 0, (LPARAM)error);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PRIVATE_KEY_YES), FALSE);
|
|
}
|
|
else
|
|
data->keyProvInfo = info;
|
|
if (hProv)
|
|
CryptReleaseContext(hProv, 0);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_PRIVATE_KEY_NO), BM_CLICK,
|
|
0, 0);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
case PSN_WIZNEXT:
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PRIVATE_KEY_NO))
|
|
{
|
|
data->contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_DER;
|
|
data->contextInfo.fExportPrivateKeys = FALSE;
|
|
}
|
|
else
|
|
{
|
|
data->contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_PFX;
|
|
data->contextInfo.fExportPrivateKeys = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BOOL export_info_has_private_key(PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
if (pExportInfo->dwSubjectChoice == CRYPTUI_WIZ_EXPORT_CERT_CONTEXT)
|
|
{
|
|
DWORD size;
|
|
|
|
/* If there's a CRYPT_KEY_PROV_INFO set for this cert, assume the
|
|
* cert has a private key.
|
|
*/
|
|
if (CertGetCertificateContextProperty(pExportInfo->u.pCertContext,
|
|
CERT_KEY_PROV_INFO_PROP_ID, NULL, &size))
|
|
ret = TRUE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void export_format_enable_controls(HWND hwnd, const struct ExportWizData *data)
|
|
{
|
|
int defaultFormatID;
|
|
|
|
switch (data->contextInfo.dwExportFormat)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
|
|
defaultFormatID = IDC_EXPORT_FORMAT_BASE64;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
|
|
defaultFormatID = IDC_EXPORT_FORMAT_CMS;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
|
|
defaultFormatID = IDC_EXPORT_FORMAT_PFX;
|
|
break;
|
|
default:
|
|
defaultFormatID = IDC_EXPORT_FORMAT_DER;
|
|
}
|
|
SendMessageW(GetDlgItem(hwnd, defaultFormatID), BM_CLICK, 0, 0);
|
|
if (defaultFormatID == IDC_EXPORT_FORMAT_PFX)
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_DER), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_BASE64), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_CMS), FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_PFX), TRUE);
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_DER), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_BASE64), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_CMS), TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_PFX), FALSE);
|
|
}
|
|
}
|
|
|
|
static LRESULT CALLBACK export_format_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ExportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
|
|
data = (struct ExportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
export_format_enable_controls(hwnd, data);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_NEXT);
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
export_format_enable_controls(hwnd, data);
|
|
ret = TRUE;
|
|
break;
|
|
case PSN_WIZNEXT:
|
|
{
|
|
BOOL skipPasswordPage = TRUE;
|
|
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (IsDlgButtonChecked(hwnd, IDC_EXPORT_FORMAT_DER))
|
|
data->contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_DER;
|
|
else if (IsDlgButtonChecked(hwnd, IDC_EXPORT_FORMAT_BASE64))
|
|
data->contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_BASE64;
|
|
else if (IsDlgButtonChecked(hwnd, IDC_EXPORT_FORMAT_CMS))
|
|
{
|
|
data->contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
|
|
if (IsDlgButtonChecked(hwnd, IDC_EXPORT_CMS_INCLUDE_CHAIN))
|
|
data->contextInfo.fExportChain =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
|
|
}
|
|
else
|
|
{
|
|
data->contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_PFX;
|
|
if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PFX_INCLUDE_CHAIN))
|
|
data->contextInfo.fExportChain = TRUE;
|
|
if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PFX_STRONG_ENCRYPTION))
|
|
data->contextInfo.fStrongEncryption = TRUE;
|
|
if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PFX_DELETE_PRIVATE_KEY))
|
|
data->deleteKeys = TRUE;
|
|
skipPasswordPage = FALSE;
|
|
}
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT,
|
|
skipPasswordPage ? IDD_EXPORT_FILE : 0);
|
|
ret = 1;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (HIWORD(wp))
|
|
{
|
|
case BN_CLICKED:
|
|
switch (LOWORD(wp))
|
|
{
|
|
case IDC_EXPORT_FORMAT_DER:
|
|
case IDC_EXPORT_FORMAT_BASE64:
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_CMS_INCLUDE_CHAIN),
|
|
FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_INCLUDE_CHAIN),
|
|
FALSE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_STRONG_ENCRYPTION),
|
|
FALSE);
|
|
EnableWindow(GetDlgItem(hwnd,
|
|
IDC_EXPORT_PFX_DELETE_PRIVATE_KEY), FALSE);
|
|
break;
|
|
case IDC_EXPORT_FORMAT_CMS:
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_CMS_INCLUDE_CHAIN),
|
|
TRUE);
|
|
break;
|
|
case IDC_EXPORT_FORMAT_PFX:
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_INCLUDE_CHAIN),
|
|
TRUE);
|
|
EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_STRONG_ENCRYPTION),
|
|
TRUE);
|
|
EnableWindow(GetDlgItem(hwnd,
|
|
IDC_EXPORT_PFX_DELETE_PRIVATE_KEY), TRUE);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void export_password_mismatch(HWND hwnd, const struct ExportWizData *data)
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_EXPORT_PASSWORD_MISMATCH, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
|
|
SetFocus(GetDlgItem(hwnd, IDC_EXPORT_PASSWORD));
|
|
}
|
|
|
|
static LRESULT CALLBACK export_password_dlg_proc(HWND hwnd, UINT msg,
|
|
WPARAM wp, LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ExportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
|
|
data = (struct ExportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
case PSN_WIZNEXT:
|
|
{
|
|
HWND passwordEdit = GetDlgItem(hwnd, IDC_EXPORT_PASSWORD);
|
|
HWND passwordConfirmEdit = GetDlgItem(hwnd,
|
|
IDC_EXPORT_PASSWORD_CONFIRM);
|
|
DWORD passwordLen = SendMessageW(passwordEdit, WM_GETTEXTLENGTH,
|
|
0, 0);
|
|
DWORD passwordConfirmLen = SendMessageW(passwordConfirmEdit,
|
|
WM_GETTEXTLENGTH, 0, 0);
|
|
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (!passwordLen && !passwordConfirmLen)
|
|
data->contextInfo.pwszPassword = NULL;
|
|
else if (passwordLen != passwordConfirmLen)
|
|
{
|
|
export_password_mismatch(hwnd, data);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
LPWSTR password = HeapAlloc(GetProcessHeap(), 0,
|
|
(passwordLen + 1) * sizeof(WCHAR));
|
|
LPWSTR passwordConfirm = HeapAlloc(GetProcessHeap(), 0,
|
|
(passwordConfirmLen + 1) * sizeof(WCHAR));
|
|
BOOL freePassword = TRUE;
|
|
|
|
if (password && passwordConfirm)
|
|
{
|
|
SendMessageW(passwordEdit, WM_GETTEXT, passwordLen + 1,
|
|
(LPARAM)password);
|
|
SendMessageW(passwordConfirmEdit, WM_GETTEXT,
|
|
passwordConfirmLen + 1, (LPARAM)passwordConfirm);
|
|
if (strcmpW(password, passwordConfirm))
|
|
{
|
|
export_password_mismatch(hwnd, data);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
data->contextInfo.pwszPassword = password;
|
|
freePassword = FALSE;
|
|
data->freePassword = TRUE;
|
|
}
|
|
}
|
|
if (freePassword)
|
|
HeapFree(GetProcessHeap(), 0, password);
|
|
HeapFree(GetProcessHeap(), 0, passwordConfirm);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LPWSTR export_append_extension(const struct ExportWizData *data,
|
|
LPWSTR fileName)
|
|
{
|
|
static const WCHAR cer[] = { '.','c','e','r',0 };
|
|
static const WCHAR crl[] = { '.','c','r','l',0 };
|
|
static const WCHAR ctl[] = { '.','c','t','l',0 };
|
|
static const WCHAR p7b[] = { '.','p','7','b',0 };
|
|
static const WCHAR pfx[] = { '.','p','f','x',0 };
|
|
static const WCHAR sst[] = { '.','s','s','t',0 };
|
|
LPCWSTR extension;
|
|
LPWSTR dot;
|
|
BOOL appendExtension;
|
|
|
|
switch (data->contextInfo.dwExportFormat)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
|
|
extension = p7b;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
|
|
extension = pfx;
|
|
break;
|
|
default:
|
|
switch (data->exportInfo.dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
|
|
extension = crl;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
|
|
extension = ctl;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE:
|
|
extension = sst;
|
|
break;
|
|
default:
|
|
extension = cer;
|
|
}
|
|
}
|
|
dot = strrchrW(fileName, '.');
|
|
if (dot)
|
|
appendExtension = strcmpiW(dot, extension) != 0;
|
|
else
|
|
appendExtension = TRUE;
|
|
if (appendExtension)
|
|
{
|
|
fileName = HeapReAlloc(GetProcessHeap(), 0, fileName,
|
|
(strlenW(fileName) + strlenW(extension) + 1) * sizeof(WCHAR));
|
|
if (fileName)
|
|
strcatW(fileName, extension);
|
|
}
|
|
return fileName;
|
|
}
|
|
|
|
static BOOL export_validate_filename(HWND hwnd, struct ExportWizData *data,
|
|
LPCWSTR fileName)
|
|
{
|
|
HANDLE file;
|
|
BOOL tryCreate = TRUE, forceCreate = FALSE, ret = FALSE;
|
|
|
|
file = CreateFileW(fileName, GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
|
|
if (file != INVALID_HANDLE_VALUE)
|
|
{
|
|
WCHAR warning[MAX_STRING_LEN], title[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_EXPORT_FILE_EXISTS, warning,
|
|
sizeof(warning) / sizeof(warning[0]));
|
|
if (MessageBoxW(hwnd, warning, pTitle, MB_YESNO) == IDYES)
|
|
forceCreate = TRUE;
|
|
else
|
|
tryCreate = FALSE;
|
|
CloseHandle(file);
|
|
}
|
|
if (tryCreate)
|
|
{
|
|
file = CreateFileW(fileName, GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
forceCreate ? CREATE_ALWAYS : CREATE_NEW,
|
|
0, NULL);
|
|
if (file != INVALID_HANDLE_VALUE)
|
|
{
|
|
data->file = file;
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
LPWSTR msgBuf, fullError;
|
|
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
FormatMessageW(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
|
|
GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
|
|
fullError = HeapAlloc(GetProcessHeap(), 0,
|
|
(strlenW(error) + strlenW(fileName) + strlenW(msgBuf) + 3)
|
|
* sizeof(WCHAR));
|
|
if (fullError)
|
|
{
|
|
LPWSTR ptr = fullError;
|
|
|
|
strcpyW(ptr, error);
|
|
ptr += strlenW(error);
|
|
strcpyW(ptr, fileName);
|
|
ptr += strlenW(fileName);
|
|
*ptr++ = ':';
|
|
*ptr++ = '\n';
|
|
strcpyW(ptr, msgBuf);
|
|
MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
|
|
HeapFree(GetProcessHeap(), 0, fullError);
|
|
}
|
|
LocalFree(msgBuf);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static const WCHAR export_filter_cert[] = { '*','.','c','e','r',0 };
|
|
static const WCHAR export_filter_crl[] = { '*','.','c','r','l',0 };
|
|
static const WCHAR export_filter_ctl[] = { '*','.','s','t','l',0 };
|
|
static const WCHAR export_filter_cms[] = { '*','.','p','7','b',0 };
|
|
static const WCHAR export_filter_pfx[] = { '*','.','p','f','x',0 };
|
|
static const WCHAR export_filter_sst[] = { '*','.','s','s','t',0 };
|
|
|
|
static WCHAR *make_export_file_filter(DWORD exportFormat, DWORD subjectChoice)
|
|
{
|
|
int baseLen, allLen, totalLen = 2, baseID;
|
|
LPWSTR filter = NULL, baseFilter, all;
|
|
LPCWSTR filterStr;
|
|
|
|
switch (exportFormat)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
|
|
baseID = IDS_EXPORT_FILTER_BASE64_CERT;
|
|
filterStr = export_filter_cert;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
|
|
baseID = IDS_EXPORT_FILTER_PFX;
|
|
filterStr = export_filter_pfx;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
|
|
baseID = IDS_EXPORT_FILTER_CMS;
|
|
filterStr = export_filter_cms;
|
|
break;
|
|
default:
|
|
switch (subjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
|
|
baseID = IDS_EXPORT_FILTER_CRL;
|
|
filterStr = export_filter_crl;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
|
|
baseID = IDS_EXPORT_FILTER_CTL;
|
|
filterStr = export_filter_ctl;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE:
|
|
baseID = IDS_EXPORT_FILTER_SERIALIZED_CERT_STORE;
|
|
filterStr = export_filter_sst;
|
|
break;
|
|
default:
|
|
baseID = IDS_EXPORT_FILTER_CERT;
|
|
filterStr = export_filter_cert;
|
|
break;
|
|
}
|
|
}
|
|
baseLen = LoadStringW(hInstance, baseID, (LPWSTR)&baseFilter, 0);
|
|
totalLen += baseLen + strlenW(filterStr) + 2;
|
|
allLen = LoadStringW(hInstance, IDS_IMPORT_FILTER_ALL, (LPWSTR)&all, 0);
|
|
totalLen += allLen + strlenW(filter_all) + 2;
|
|
filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
|
|
if (filter)
|
|
{
|
|
LPWSTR ptr;
|
|
|
|
ptr = filter;
|
|
memcpy(ptr, baseFilter, baseLen * sizeof(WCHAR));
|
|
ptr += baseLen;
|
|
*ptr++ = 0;
|
|
strcpyW(ptr, filterStr);
|
|
ptr += strlenW(filterStr) + 1;
|
|
memcpy(ptr, all, allLen * sizeof(WCHAR));
|
|
ptr += allLen;
|
|
*ptr++ = 0;
|
|
strcpyW(ptr, filter_all);
|
|
ptr += strlenW(filter_all) + 1;
|
|
*ptr++ = 0;
|
|
}
|
|
return filter;
|
|
}
|
|
|
|
static LRESULT CALLBACK export_file_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ExportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
|
|
data = (struct ExportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
if (data->exportInfo.pwszExportFileName)
|
|
SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_FILENAME), WM_SETTEXT, 0,
|
|
(LPARAM)data->exportInfo.pwszExportFileName);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_WIZBACK:
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (data->contextInfo.dwExportFormat !=
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_PFX)
|
|
{
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, IDD_EXPORT_FORMAT);
|
|
ret = 1;
|
|
}
|
|
break;
|
|
case PSN_WIZNEXT:
|
|
{
|
|
HWND fileNameEdit = GetDlgItem(hwnd, IDC_EXPORT_FILENAME);
|
|
DWORD len = SendMessageW(fileNameEdit, WM_GETTEXTLENGTH, 0, 0);
|
|
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if (!len)
|
|
{
|
|
WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, IDS_IMPORT_EMPTY_FILE, error,
|
|
sizeof(error) / sizeof(error[0]));
|
|
MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
LPWSTR fileName = HeapAlloc(GetProcessHeap(), 0,
|
|
(len + 1) * sizeof(WCHAR));
|
|
|
|
if (fileName)
|
|
{
|
|
SendMessageW(fileNameEdit, WM_GETTEXT, len + 1,
|
|
(LPARAM)fileName);
|
|
fileName = export_append_extension(data, fileName);
|
|
if (!export_validate_filename(hwnd, data, fileName))
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, fileName);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
|
|
ret = 1;
|
|
}
|
|
else
|
|
data->fileName = fileName;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case PSN_SETACTIVE:
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_NEXT);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case WM_COMMAND:
|
|
switch (wp)
|
|
{
|
|
case IDC_EXPORT_BROWSE_FILE:
|
|
{
|
|
OPENFILENAMEW ofn;
|
|
WCHAR fileBuf[MAX_PATH];
|
|
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
memset(&ofn, 0, sizeof(ofn));
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hwndOwner = hwnd;
|
|
ofn.lpstrFilter = make_export_file_filter(
|
|
data->contextInfo.dwExportFormat,
|
|
data->exportInfo.dwSubjectChoice);
|
|
ofn.lpstrFile = fileBuf;
|
|
ofn.nMaxFile = sizeof(fileBuf) / sizeof(fileBuf[0]);
|
|
fileBuf[0] = 0;
|
|
if (GetSaveFileNameW(&ofn))
|
|
SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_FILENAME), WM_SETTEXT,
|
|
0, (LPARAM)ofn.lpstrFile);
|
|
HeapFree(GetProcessHeap(), 0, (LPWSTR)ofn.lpstrFilter);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void show_export_details(HWND lv, const struct ExportWizData *data)
|
|
{
|
|
WCHAR text[MAX_STRING_LEN];
|
|
LVITEMW item;
|
|
int contentID;
|
|
|
|
item.mask = LVIF_TEXT;
|
|
if (data->fileName)
|
|
{
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_IMPORT_FILE, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
item.pszText = text;
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
item.iSubItem = 1;
|
|
item.pszText = data->fileName;
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
}
|
|
|
|
item.pszText = text;
|
|
switch (data->exportInfo.dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
|
|
case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE:
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY:
|
|
/* do nothing */
|
|
break;
|
|
default:
|
|
{
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_EXPORT_INCLUDE_CHAIN, text,
|
|
sizeof(text) / sizeof(text[0]));
|
|
SendMessageW(lv, LVM_INSERTITEMW, item.iItem, (LPARAM)&item);
|
|
item.iSubItem = 1;
|
|
LoadStringW(hInstance,
|
|
data->contextInfo.fExportChain ? IDS_YES : IDS_NO, text,
|
|
sizeof(text) / sizeof(text[0]));
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_EXPORT_KEYS, text,
|
|
sizeof(text) / sizeof(text[0]));
|
|
SendMessageW(lv, LVM_INSERTITEMW, item.iItem, (LPARAM)&item);
|
|
item.iSubItem = 1;
|
|
LoadStringW(hInstance,
|
|
data->contextInfo.fExportPrivateKeys ? IDS_YES : IDS_NO, text,
|
|
sizeof(text) / sizeof(text[0]));
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
}
|
|
}
|
|
|
|
item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
|
|
item.iSubItem = 0;
|
|
LoadStringW(hInstance, IDS_EXPORT_FORMAT, text,
|
|
sizeof(text)/ sizeof(text[0]));
|
|
SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
|
|
|
|
item.iSubItem = 1;
|
|
switch (data->exportInfo.dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
|
|
contentID = IDS_EXPORT_FILTER_CRL;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
|
|
contentID = IDS_EXPORT_FILTER_CTL;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE:
|
|
contentID = IDS_EXPORT_FILTER_SERIALIZED_CERT_STORE;
|
|
break;
|
|
default:
|
|
switch (data->contextInfo.dwExportFormat)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
|
|
contentID = IDS_EXPORT_FILTER_BASE64_CERT;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
|
|
contentID = IDS_EXPORT_FILTER_CMS;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
|
|
contentID = IDS_EXPORT_FILTER_PFX;
|
|
break;
|
|
default:
|
|
contentID = IDS_EXPORT_FILTER_CERT;
|
|
}
|
|
}
|
|
LoadStringW(hInstance, contentID, text, sizeof(text) / sizeof(text[0]));
|
|
SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
|
|
}
|
|
|
|
static inline BOOL save_der(HANDLE file, const BYTE *pb, DWORD cb)
|
|
{
|
|
DWORD bytesWritten;
|
|
|
|
return WriteFile(file, pb, cb, &bytesWritten, NULL);
|
|
}
|
|
|
|
static BOOL save_base64(HANDLE file, const BYTE *pb, DWORD cb)
|
|
{
|
|
BOOL ret;
|
|
DWORD size = 0;
|
|
|
|
if ((ret = CryptBinaryToStringA(pb, cb, CRYPT_STRING_BASE64, NULL, &size)))
|
|
{
|
|
LPSTR buf = HeapAlloc(GetProcessHeap(), 0, size);
|
|
|
|
if (buf)
|
|
{
|
|
if ((ret = CryptBinaryToStringA(pb, cb, CRYPT_STRING_BASE64, buf,
|
|
&size)))
|
|
ret = WriteFile(file, buf, size, &size, NULL);
|
|
HeapFree(GetProcessHeap(), 0, buf);
|
|
}
|
|
else
|
|
{
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static inline BOOL save_store_as_cms(HANDLE file, HCERTSTORE store)
|
|
{
|
|
return CertSaveStore(store, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
|
|
CERT_STORE_SAVE_AS_PKCS7, CERT_STORE_SAVE_TO_FILE, file, 0);
|
|
}
|
|
|
|
static BOOL save_cert_as_cms(HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo,
|
|
BOOL includeChain)
|
|
{
|
|
BOOL ret;
|
|
HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
|
|
CERT_STORE_CREATE_NEW_FLAG, NULL);
|
|
|
|
if (store)
|
|
{
|
|
if (includeChain)
|
|
{
|
|
HCERTSTORE addlStore = CertOpenStore(CERT_STORE_PROV_COLLECTION,
|
|
0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL);
|
|
|
|
if (addlStore)
|
|
{
|
|
DWORD i;
|
|
|
|
ret = TRUE;
|
|
for (i = 0; ret && i < pExportInfo->cStores; i++)
|
|
ret = CertAddStoreToCollection(addlStore,
|
|
pExportInfo->rghStores, 0, 0);
|
|
if (ret)
|
|
{
|
|
PCCERT_CHAIN_CONTEXT chain;
|
|
|
|
ret = CertGetCertificateChain(NULL,
|
|
pExportInfo->u.pCertContext, NULL, addlStore, NULL, 0,
|
|
NULL, &chain);
|
|
if (ret)
|
|
{
|
|
DWORD j;
|
|
|
|
for (i = 0; ret && i < chain->cChain; i++)
|
|
for (j = 0; ret && j < chain->rgpChain[i]->cElement;
|
|
j++)
|
|
ret = CertAddCertificateContextToStore(store,
|
|
chain->rgpChain[i]->rgpElement[j]->pCertContext,
|
|
CERT_STORE_ADD_ALWAYS, NULL);
|
|
CertFreeCertificateChain(chain);
|
|
}
|
|
else
|
|
{
|
|
/* No chain could be created, just add the individual
|
|
* cert to the message.
|
|
*/
|
|
ret = CertAddCertificateContextToStore(store,
|
|
pExportInfo->u.pCertContext, CERT_STORE_ADD_ALWAYS,
|
|
NULL);
|
|
}
|
|
}
|
|
CertCloseStore(addlStore, 0);
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
}
|
|
else
|
|
ret = CertAddCertificateContextToStore(store,
|
|
pExportInfo->u.pCertContext, CERT_STORE_ADD_ALWAYS, NULL);
|
|
if (ret)
|
|
ret = save_store_as_cms(file, store);
|
|
CertCloseStore(store, 0);
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
return ret;
|
|
}
|
|
|
|
static BOOL save_serialized_store(HANDLE file, HCERTSTORE store)
|
|
{
|
|
return CertSaveStore(store, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
|
|
CERT_STORE_SAVE_AS_STORE, CERT_STORE_SAVE_TO_FILE, file, 0);
|
|
}
|
|
|
|
static BOOL save_pfx(HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo,
|
|
PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO pContextInfo,
|
|
PCRYPT_KEY_PROV_INFO keyProvInfo, BOOL deleteKeys)
|
|
{
|
|
HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, X509_ASN_ENCODING,
|
|
0, CERT_STORE_CREATE_NEW_FLAG, NULL);
|
|
BOOL ret = FALSE;
|
|
|
|
if (store)
|
|
{
|
|
CRYPT_DATA_BLOB pfxBlob = { 0, NULL };
|
|
PCCERT_CONTEXT cert = NULL;
|
|
BOOL freeKeyProvInfo = FALSE;
|
|
|
|
if (pContextInfo->fExportChain)
|
|
{
|
|
HCERTCHAINENGINE engine = NULL;
|
|
|
|
if (pExportInfo->cStores)
|
|
{
|
|
CERT_CHAIN_ENGINE_CONFIG config;
|
|
|
|
memset(&config, 0, sizeof(config));
|
|
config.cbSize = sizeof(config);
|
|
config.cAdditionalStore = pExportInfo->cStores;
|
|
config.rghAdditionalStore = pExportInfo->rghStores;
|
|
ret = CertCreateCertificateChainEngine(&config, &engine);
|
|
}
|
|
else
|
|
ret = TRUE;
|
|
if (ret)
|
|
{
|
|
CERT_CHAIN_PARA chainPara;
|
|
PCCERT_CHAIN_CONTEXT chain;
|
|
|
|
memset(&chainPara, 0, sizeof(chainPara));
|
|
chainPara.cbSize = sizeof(chainPara);
|
|
ret = CertGetCertificateChain(engine,
|
|
pExportInfo->u.pCertContext, NULL, NULL, &chainPara, 0, NULL,
|
|
&chain);
|
|
if (ret)
|
|
{
|
|
DWORD i, j;
|
|
|
|
for (i = 0; ret && i < chain->cChain; i++)
|
|
for (j = 0; ret && j < chain->rgpChain[i]->cElement;
|
|
j++)
|
|
{
|
|
if (i == 0 && j == 0)
|
|
ret = CertAddCertificateContextToStore(store,
|
|
chain->rgpChain[i]->rgpElement[j]->pCertContext,
|
|
CERT_STORE_ADD_ALWAYS, &cert);
|
|
else
|
|
ret = CertAddCertificateContextToStore(store,
|
|
chain->rgpChain[i]->rgpElement[j]->pCertContext,
|
|
CERT_STORE_ADD_ALWAYS, NULL);
|
|
}
|
|
CertFreeCertificateChain(chain);
|
|
}
|
|
}
|
|
if (engine)
|
|
CertFreeCertificateChainEngine(engine);
|
|
}
|
|
else
|
|
ret = CertAddCertificateContextToStore(store,
|
|
pExportInfo->u.pCertContext, CERT_STORE_ADD_ALWAYS, &cert);
|
|
/* Copy private key info to newly created cert, so it'll get exported
|
|
* along with the cert.
|
|
*/
|
|
if (ret && pContextInfo->fExportPrivateKeys)
|
|
{
|
|
if (keyProvInfo)
|
|
ret = CertSetCertificateContextProperty(cert,
|
|
CERT_KEY_PROV_INFO_PROP_ID, 0, keyProvInfo);
|
|
else
|
|
{
|
|
if (!(keyProvInfo = export_get_private_key_info(cert)))
|
|
ret = FALSE;
|
|
else
|
|
{
|
|
ret = CertSetCertificateContextProperty(cert,
|
|
CERT_KEY_PROV_INFO_PROP_ID, 0, keyProvInfo);
|
|
freeKeyProvInfo = TRUE;
|
|
}
|
|
}
|
|
}
|
|
if (ret)
|
|
{
|
|
DWORD exportFlags =
|
|
REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY | EXPORT_PRIVATE_KEYS;
|
|
|
|
ret = PFXExportCertStore(store, &pfxBlob,
|
|
pContextInfo->pwszPassword, exportFlags);
|
|
if (ret)
|
|
{
|
|
pfxBlob.pbData = HeapAlloc(GetProcessHeap(), 0, pfxBlob.cbData);
|
|
if (pfxBlob.pbData)
|
|
{
|
|
ret = PFXExportCertStore(store, &pfxBlob,
|
|
pContextInfo->pwszPassword, exportFlags);
|
|
if (ret)
|
|
{
|
|
DWORD bytesWritten;
|
|
|
|
ret = WriteFile(file, pfxBlob.pbData, pfxBlob.cbData,
|
|
&bytesWritten, NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
}
|
|
if (ret && deleteKeys)
|
|
{
|
|
HCRYPTPROV prov;
|
|
|
|
CryptAcquireContextW(&prov, keyProvInfo->pwszContainerName,
|
|
keyProvInfo->pwszProvName, keyProvInfo->dwProvType,
|
|
CRYPT_DELETEKEYSET);
|
|
}
|
|
if (freeKeyProvInfo)
|
|
HeapFree(GetProcessHeap(), 0, keyProvInfo);
|
|
CertFreeCertificateContext(cert);
|
|
CertCloseStore(store, 0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BOOL do_export(HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo,
|
|
PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO pContextInfo,
|
|
PCRYPT_KEY_PROV_INFO keyProvInfo, BOOL deleteKeys)
|
|
{
|
|
BOOL ret;
|
|
|
|
if (pContextInfo->dwSize != sizeof(CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO))
|
|
{
|
|
SetLastError(E_INVALIDARG);
|
|
return FALSE;
|
|
}
|
|
switch (pExportInfo->dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
|
|
ret = save_der(file,
|
|
pExportInfo->u.pCRLContext->pbCrlEncoded,
|
|
pExportInfo->u.pCRLContext->cbCrlEncoded);
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
|
|
ret = save_der(file,
|
|
pExportInfo->u.pCTLContext->pbCtlEncoded,
|
|
pExportInfo->u.pCTLContext->cbCtlEncoded);
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE:
|
|
ret = save_serialized_store(file, pExportInfo->u.hCertStore);
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY:
|
|
ret = save_store_as_cms(file, pExportInfo->u.hCertStore);
|
|
break;
|
|
default:
|
|
switch (pContextInfo->dwExportFormat)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_DER:
|
|
ret = save_der(file, pExportInfo->u.pCertContext->pbCertEncoded,
|
|
pExportInfo->u.pCertContext->cbCertEncoded);
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
|
|
ret = save_base64(file,
|
|
pExportInfo->u.pCertContext->pbCertEncoded,
|
|
pExportInfo->u.pCertContext->cbCertEncoded);
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
|
|
ret = save_cert_as_cms(file, pExportInfo,
|
|
pContextInfo->fExportChain);
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
|
|
ret = save_pfx(file, pExportInfo, pContextInfo, keyProvInfo,
|
|
deleteKeys);
|
|
break;
|
|
default:
|
|
SetLastError(E_FAIL);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static LRESULT CALLBACK export_finish_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
|
|
LPARAM lp)
|
|
{
|
|
LRESULT ret = 0;
|
|
struct ExportWizData *data;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
|
|
HWND lv = GetDlgItem(hwnd, IDC_EXPORT_SETTINGS);
|
|
RECT rc;
|
|
LVCOLUMNW column;
|
|
|
|
data = (struct ExportWizData *)page->lParam;
|
|
SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
|
|
SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_TITLE), WM_SETFONT,
|
|
(WPARAM)data->titleFont, TRUE);
|
|
GetWindowRect(lv, &rc);
|
|
column.mask = LVCF_WIDTH;
|
|
column.cx = (rc.right - rc.left) / 2 - 2;
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
|
|
SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
|
|
show_export_details(lv, data);
|
|
break;
|
|
}
|
|
case WM_NOTIFY:
|
|
{
|
|
NMHDR *hdr = (NMHDR *)lp;
|
|
|
|
switch (hdr->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
{
|
|
HWND lv = GetDlgItem(hwnd, IDC_EXPORT_SETTINGS);
|
|
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
|
|
show_export_details(lv, data);
|
|
PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
|
|
PSWIZB_BACK | PSWIZB_FINISH);
|
|
ret = TRUE;
|
|
break;
|
|
}
|
|
case PSN_WIZFINISH:
|
|
{
|
|
int messageID;
|
|
WCHAR title[MAX_STRING_LEN], message[MAX_STRING_LEN];
|
|
LPCWSTR pTitle;
|
|
DWORD mbFlags;
|
|
|
|
data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
|
|
if ((data->success = do_export(data->file, &data->exportInfo,
|
|
&data->contextInfo, data->keyProvInfo, data->deleteKeys)))
|
|
{
|
|
messageID = IDS_EXPORT_SUCCEEDED;
|
|
mbFlags = MB_OK;
|
|
}
|
|
else
|
|
{
|
|
messageID = IDS_EXPORT_FAILED;
|
|
mbFlags = MB_OK | MB_ICONERROR;
|
|
}
|
|
if (data->pwszWizardTitle)
|
|
pTitle = data->pwszWizardTitle;
|
|
else
|
|
{
|
|
LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
|
|
sizeof(title) / sizeof(title[0]));
|
|
pTitle = title;
|
|
}
|
|
LoadStringW(hInstance, messageID, message,
|
|
sizeof(message) / sizeof(message[0]));
|
|
MessageBoxW(hwnd, message, pTitle, mbFlags);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static BOOL show_export_ui(DWORD dwFlags, HWND hwndParent,
|
|
LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, const void *pvoid)
|
|
{
|
|
PROPSHEETHEADERW hdr;
|
|
PROPSHEETPAGEW pages[6];
|
|
struct ExportWizData data;
|
|
int nPages = 0;
|
|
BOOL hasPrivateKey, showFormatPage = TRUE;
|
|
INT_PTR l;
|
|
|
|
data.dwFlags = dwFlags;
|
|
data.pwszWizardTitle = pwszWizardTitle;
|
|
memset(&data.exportInfo, 0, sizeof(data.exportInfo));
|
|
memcpy(&data.exportInfo, pExportInfo,
|
|
min(sizeof(data.exportInfo), pExportInfo->dwSize));
|
|
if (pExportInfo->dwSize > sizeof(data.exportInfo))
|
|
data.exportInfo.dwSize = sizeof(data.exportInfo);
|
|
data.contextInfo.dwSize = sizeof(data.contextInfo);
|
|
data.contextInfo.dwExportFormat = CRYPTUI_WIZ_EXPORT_FORMAT_DER;
|
|
data.contextInfo.fExportChain = FALSE;
|
|
data.contextInfo.fStrongEncryption = FALSE;
|
|
data.contextInfo.fExportPrivateKeys = FALSE;
|
|
data.contextInfo.pwszPassword = NULL;
|
|
data.freePassword = FALSE;
|
|
if (pExportInfo->dwSubjectChoice == CRYPTUI_WIZ_EXPORT_CERT_CONTEXT &&
|
|
pvoid)
|
|
memcpy(&data.contextInfo, pvoid,
|
|
min(((PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO)pvoid)->dwSize,
|
|
sizeof(data.contextInfo)));
|
|
data.keyProvInfo = NULL;
|
|
data.deleteKeys = FALSE;
|
|
data.fileName = NULL;
|
|
data.file = INVALID_HANDLE_VALUE;
|
|
data.success = FALSE;
|
|
|
|
memset(pages, 0, sizeof(pages));
|
|
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_WELCOME);
|
|
pages[nPages].pfnDlgProc = export_welcome_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_HIDEHEADER;
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
|
|
hasPrivateKey = export_info_has_private_key(pExportInfo);
|
|
switch (pExportInfo->dwSubjectChoice)
|
|
{
|
|
case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
|
|
case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
|
|
showFormatPage = FALSE;
|
|
data.contextInfo.dwExportFormat = CRYPTUI_WIZ_EXPORT_FORMAT_DER;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE:
|
|
showFormatPage = FALSE;
|
|
data.contextInfo.dwExportFormat =
|
|
CRYPTUI_WIZ_EXPORT_FORMAT_SERIALIZED_CERT_STORE;
|
|
break;
|
|
case CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY:
|
|
showFormatPage = FALSE;
|
|
data.contextInfo.dwExportFormat = CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
|
|
break;
|
|
}
|
|
|
|
if (hasPrivateKey && showFormatPage)
|
|
{
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_PRIVATE_KEY);
|
|
pages[nPages].pfnDlgProc = export_private_key_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
|
|
pages[nPages].pszHeaderTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_PRIVATE_KEY_TITLE);
|
|
pages[nPages].pszHeaderSubTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_PRIVATE_KEY_SUBTITLE);
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
}
|
|
if (showFormatPage)
|
|
{
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_FORMAT);
|
|
pages[nPages].pfnDlgProc = export_format_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
|
|
pages[nPages].pszHeaderTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_FORMAT_TITLE);
|
|
pages[nPages].pszHeaderSubTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_FORMAT_SUBTITLE);
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
}
|
|
if (hasPrivateKey && showFormatPage)
|
|
{
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_PASSWORD);
|
|
pages[nPages].pfnDlgProc = export_password_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
|
|
pages[nPages].pszHeaderTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_PASSWORD_TITLE);
|
|
pages[nPages].pszHeaderSubTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_PASSWORD_SUBTITLE);
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
}
|
|
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_FILE);
|
|
pages[nPages].pfnDlgProc = export_file_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
|
|
pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_EXPORT_FILE_TITLE);
|
|
pages[nPages].pszHeaderSubTitle =
|
|
MAKEINTRESOURCEW(IDS_EXPORT_FILE_SUBTITLE);
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
|
|
pages[nPages].dwSize = sizeof(pages[0]);
|
|
pages[nPages].hInstance = hInstance;
|
|
pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_FINISH);
|
|
pages[nPages].pfnDlgProc = export_finish_dlg_proc;
|
|
pages[nPages].dwFlags = PSP_HIDEHEADER;
|
|
pages[nPages].lParam = (LPARAM)&data;
|
|
nPages++;
|
|
|
|
memset(&hdr, 0, sizeof(hdr));
|
|
hdr.dwSize = sizeof(hdr);
|
|
hdr.hwndParent = hwndParent;
|
|
hdr.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD97_NEW | PSH_HEADER |
|
|
PSH_WATERMARK;
|
|
hdr.hInstance = hInstance;
|
|
if (pwszWizardTitle)
|
|
hdr.pszCaption = pwszWizardTitle;
|
|
else
|
|
hdr.pszCaption = MAKEINTRESOURCEW(IDS_EXPORT_WIZARD);
|
|
hdr.u3.ppsp = pages;
|
|
hdr.nPages = nPages;
|
|
hdr.u4.pszbmWatermark = MAKEINTRESOURCEW(IDB_CERT_WATERMARK);
|
|
hdr.u5.pszbmHeader = MAKEINTRESOURCEW(IDB_CERT_HEADER);
|
|
l = PropertySheetW(&hdr);
|
|
DeleteObject(data.titleFont);
|
|
if (data.freePassword)
|
|
HeapFree(GetProcessHeap(), 0,
|
|
(LPWSTR)data.contextInfo.pwszPassword);
|
|
HeapFree(GetProcessHeap(), 0, data.keyProvInfo);
|
|
CloseHandle(data.file);
|
|
HeapFree(GetProcessHeap(), 0, data.fileName);
|
|
if (l == 0)
|
|
{
|
|
SetLastError(ERROR_CANCELLED);
|
|
return FALSE;
|
|
}
|
|
else
|
|
return data.success;
|
|
}
|
|
|
|
BOOL WINAPI CryptUIWizExport(DWORD dwFlags, HWND hwndParent,
|
|
LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, void *pvoid)
|
|
{
|
|
BOOL ret;
|
|
|
|
TRACE("(%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent,
|
|
debugstr_w(pwszWizardTitle), pExportInfo, pvoid);
|
|
|
|
if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
|
|
ret = show_export_ui(dwFlags, hwndParent, pwszWizardTitle, pExportInfo,
|
|
pvoid);
|
|
else
|
|
{
|
|
HANDLE file = CreateFileW(pExportInfo->pwszExportFileName,
|
|
GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
CREATE_ALWAYS, 0, NULL);
|
|
|
|
if (file != INVALID_HANDLE_VALUE)
|
|
{
|
|
ret = do_export(file, pExportInfo, pvoid, NULL, FALSE);
|
|
CloseHandle(file);
|
|
}
|
|
else
|
|
ret = FALSE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
BOOL WINAPI CryptUIDlgViewSignerInfoA(CRYPTUI_VIEWSIGNERINFO_STRUCTA *pcvsi)
|
|
{
|
|
FIXME("%p: stub\n", pcvsi);
|
|
return FALSE;
|
|
}
|
|
|
|
PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateW(PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc)
|
|
{
|
|
FIXME("%p: stub\n", pcsc);
|
|
return NULL;
|
|
}
|
|
|
|
PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateA(PCCRYPTUI_SELECTCERTIFICATE_STRUCTA pcsc)
|
|
{
|
|
FIXME("%p: stub\n", pcsc);
|
|
return NULL;
|
|
}
|