#include <stdarg.h>
#include <wchar.h>
#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 dependency graph for main.c:

Classes
struct	CertMgrStoreInfo

struct	CertMgrData

struct	_CRYPTUI_ENUM_SYSTEM_STORE_ARGS

struct	_CRYPTUI_ENUM_DATA

struct	_CRYPTUI_SELECTSTORE_INFO_A

struct	_CRYPTUI_SELECTSTORE_INFO_W

struct	StoreInfo

struct	SelectStoreInfo

struct	ReadStringStruct

struct	OIDToString

struct	IssuerStatement

struct	detail_data

struct	field_value_data

struct	v1_field

struct	prop_id_to_string_id

struct	selection_list_item

struct	edit_cert_data

struct	hierarchy_data

struct	ImportWizData

struct	ExportWizData

struct	SelectCertData

struct	SortData

struct	SelectCertParam

Macros
#define	COBJMACROS

#define	NONAMELESSUNION

#define	MAX_STRING_LEN 512

#define	CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE 0x00000001

#define	MY_INDENT 200

#define	MAX_PURPOSE 255

#define	WM_REFRESH_VIEW WM_USER + 0

#define	MAX_FRIENDLY_NAME 40

#define	MAX_DESCRIPTION 255

Typedefs
typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS	CRYPTUI_ENUM_SYSTEM_STORE_ARGS

typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS *	PCRYPTUI_ENUM_SYSTEM_STORE_ARGS

typedef struct _CRYPTUI_ENUM_DATA	CRYPTUI_ENUM_DATA

typedef struct _CRYPTUI_ENUM_DATA *	PCRYPTUI_ENUM_DATA

typedef BOOL(WINAPI *	PFN_SELECTED_STORE_CB) (HCERTSTORE store, HWND hwnd, void *pvArg)

typedef struct _CRYPTUI_SELECTSTORE_INFO_A	CRYPTUI_SELECTSTORE_INFO_A

typedef struct _CRYPTUI_SELECTSTORE_INFO_A *	PCRYPTUI_SELECTSTORE_INFO_A

typedef struct _CRYPTUI_SELECTSTORE_INFO_W	CRYPTUI_SELECTSTORE_INFO_W

typedef struct _CRYPTUI_SELECTSTORE_INFO_W *	PCRYPTUI_SELECTSTORE_INFO_W

typedef WCHAR (	field_format_func) (PCCERT_CONTEXT cert)

typedef void(*	add_fields_func) (HWND hwnd, struct detail_data *data)

typedef WCHAR (	create_detailed_value_func) (PCCERT_CONTEXT cert, void *param)

typedef WCHAR (	prop_to_value_func) (void *pb, DWORD cb)

Enumerations
enum	PurposeFilter { PurposeFilterShowAll = 0 , PurposeFilterShowAdvanced = 1 , PurposeFilterShowOID = 2 }

enum	CheckBitmapIndex { CheckBitmapIndexUnchecked = 1 , CheckBitmapIndexChecked = 2 , CheckBitmapIndexDisabledUnchecked = 3 , CheckBitmapIndexDisabledChecked = 4 }

enum	PurposeSelection { PurposeEnableAll = 0 , PurposeDisableAll , PurposeEnableSelected }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (cryptui)

BOOL WINAPI	DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)

static WCHAR *	strdupAtoW (const char *str)

static void	add_cert_columns (HWND hwnd)

static void	add_cert_to_view (HWND lv, PCCERT_CONTEXT cert, DWORD allocatedLen, LPWSTR str)

static LPSTR	get_cert_mgr_usages (void)

static void	initialize_purpose_selection (HWND hwnd)

BOOL WINAPI	WTHelperGetKnownUsages (DWORD action, PCCRYPT_OID_INFO **usages)

static CERT_ENHKEY_USAGE *	add_oid_to_usage (CERT_ENHKEY_USAGE *usage, LPSTR oid)

static CERT_ENHKEY_USAGE *	convert_usages_str_to_usage (LPSTR usageStr)

static CERT_ENHKEY_USAGE *	create_advanced_filter (void)

static int CALLBACK	cert_mgr_sort_by_subject (LPARAM lp1, LPARAM lp2, LPARAM lp)

static void	show_store_certs (HWND hwnd, HCERTSTORE store)

static void	show_cert_stores (HWND hwnd, DWORD dwFlags, struct CertMgrData *data)

static void	free_certs (HWND lv)

static HCERTSTORE	cert_mgr_index_to_store (HWND tab, int index)

static HCERTSTORE	cert_mgr_current_store (HWND hwnd)

static void	close_stores (HWND tab)

static void	refresh_store_certs (HWND hwnd)

static void	add_known_usage (HWND lv, PCCRYPT_OID_INFO info, CheckBitmapIndex state)

static void	add_known_usages_to_list (HWND lv, CheckBitmapIndex state)

static void	toggle_usage (HWND hwnd, int iItem)

static LONG_PTR	find_oid_in_list (HWND lv, LPCSTR oid)

static void	save_cert_mgr_usages (HWND hwnd)

static LRESULT CALLBACK	cert_mgr_advanced_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	cert_mgr_clear_cert_selection (HWND hwnd)

static PCCERT_CONTEXT	cert_mgr_index_to_cert (HWND hwnd, int index)

static void	show_selected_cert (HWND hwnd, int index)

static void	get_cert_usages (PCCERT_CONTEXT cert, LPWSTR *str)

static void	cert_mgr_show_cert_usages (HWND hwnd, int index)

static void	cert_mgr_do_remove (HWND hwnd)

static void	cert_mgr_do_export (HWND hwnd)

static int	cert_mgr_sort_by_text (HWND lv, int col, int index1, int index2)

static int CALLBACK	cert_mgr_sort_by_issuer (LPARAM lp1, LPARAM lp2, LPARAM lp)

static int CALLBACK	cert_mgr_sort_by_date (LPARAM lp1, LPARAM lp2, LPARAM lp)

static int CALLBACK	cert_mgr_sort_by_friendly_name (LPARAM lp1, LPARAM lp2, LPARAM lp)

static LRESULT CALLBACK	cert_mgr_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

BOOL WINAPI	CryptUIDlgCertMgr (PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)

static BOOL WINAPI	enum_store_callback (const void pvSystemStore, DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void pvReserved, void *pvArg)

static void	enumerate_stores (HWND hwnd, CRYPTUI_ENUM_DATA *pEnumData)

static void	free_store_info (HWND tree)

static HCERTSTORE	selected_item_to_store (HWND tree, HTREEITEM hItem)

static LRESULT CALLBACK	select_store_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

HCERTSTORE WINAPI	CryptUIDlgSelectStoreW (PCRYPTUI_SELECTSTORE_INFO_W info)

HCERTSTORE WINAPI	CryptUIDlgSelectStoreA (PCRYPTUI_SELECTSTORE_INFO_A info)

BOOL WINAPI	CryptUIDlgViewCertificateA (PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)

static DWORD CALLBACK	read_text_callback (DWORD_PTR dwCookie, LPBYTE buf, LONG cb, LONG *pcb)

static void	add_unformatted_text_to_control (HWND hwnd, LPCWSTR text, LONG len)

static void	add_string_resource_to_control (HWND hwnd, int id)

static void	add_text_with_paraformat_to_control (HWND hwnd, LPCWSTR text, LONG len, const PARAFORMAT2 *fmt)

static void	add_string_resource_with_paraformat_to_control (HWND hwnd, int id, const PARAFORMAT2 *fmt)

static LPWSTR	get_cert_name_string (PCCERT_CONTEXT pCertContext, DWORD dwType, DWORD dwFlags)

static void	add_cert_string_to_control (HWND hwnd, PCCERT_CONTEXT pCertContext, DWORD dwType, DWORD dwFlags)

static void	add_icon_to_control (HWND hwnd, int id)

static void	add_oid_text_to_control (HWND hwnd, char *oid)

static struct OIDToString *	findSupportedOID (LPCSTR oid)

static void	add_local_oid_text_to_control (HWND text, LPCSTR oid)

static void	display_app_usages (HWND text, PCCERT_CONTEXT cert, BOOL *anyUsageAdded)

static BOOL	display_cert_usages (HWND text, PCCERT_CONTEXT cert, BOOL *anyUsageAdded)

static void	set_policy_text (HWND text, PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)

static CRYPT_OBJID_BLOB *	find_policy_qualifier (CERT_POLICIES_INFO *policies, LPCSTR policyOid)

static WCHAR *	get_cps_str_from_qualifier (const CRYPT_OBJID_BLOB *qualifier)

static WCHAR *	get_user_notice_from_qualifier (const CRYPT_OBJID_BLOB *qualifier)

static void	set_issuer_statement (HWND hwnd, PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)

static void	set_cert_info (HWND hwnd, PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)

static void	set_cert_name_string (HWND hwnd, PCCERT_CONTEXT cert, DWORD nameFlags, int heading)

static void	add_date_string_to_control (HWND hwnd, const FILETIME *fileTime)

static void	set_cert_validity_period (HWND hwnd, PCCERT_CONTEXT cert)

static void	set_general_info (HWND hwnd, PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)

static LRESULT CALLBACK	user_notice_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	show_user_notice (HWND hwnd, struct IssuerStatement *issuerStatement)

static LRESULT CALLBACK	general_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static UINT CALLBACK	general_callback_proc (HWND hwnd, UINT msg, PROPSHEETPAGEW *page)

static void	init_general_page (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, PROPSHEETPAGEW *page)

static WCHAR *	field_format_version (PCCERT_CONTEXT cert)

static WCHAR *	format_hex_string (void *pb, DWORD cb)

static WCHAR *	field_format_serial_number (PCCERT_CONTEXT cert)

static WCHAR *	field_format_issuer (PCCERT_CONTEXT cert)

static WCHAR *	field_format_detailed_cert_name (PCERT_NAME_BLOB name)

static WCHAR *	field_format_detailed_issuer (PCCERT_CONTEXT cert, void *param)

static WCHAR *	field_format_subject (PCCERT_CONTEXT cert)

static WCHAR *	field_format_detailed_subject (PCCERT_CONTEXT cert, void *param)

static WCHAR *	format_long_date (const FILETIME *fileTime)

static WCHAR *	field_format_from_date (PCCERT_CONTEXT cert)

static WCHAR *	field_format_to_date (PCCERT_CONTEXT cert)

static WCHAR *	field_format_public_key (PCCERT_CONTEXT cert)

static WCHAR *	field_format_detailed_public_key (PCCERT_CONTEXT cert, void *param)

static void	add_field_value_data (struct detail_data data, create_detailed_value_func create, void param)

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)

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)

static void	add_v1_field (HWND hwnd, struct detail_data data, const struct v1_field field)

static void	add_v1_fields (HWND hwnd, struct detail_data *data)

static WCHAR *	crypt_format_extension (const CERT_EXTENSION *ext, DWORD formatStrType)

static WCHAR *	field_format_extension_hex_with_ascii (const CERT_EXTENSION *ext)

static WCHAR *	field_format_detailed_extension (PCCERT_CONTEXT cert, void *param)

static void	add_cert_extension_detail (HWND hwnd, struct detail_data *data, PCERT_EXTENSION ext)

static void	add_all_extensions (HWND hwnd, struct detail_data *data)

static void	add_critical_extensions (HWND hwnd, struct detail_data *data)

static WCHAR *	format_enhanced_key_usage_value (void *pb, DWORD cb)

static void	add_properties (HWND hwnd, struct detail_data *data)

static void	add_all_fields (HWND hwnd, struct detail_data *data)

static void	create_show_list (HWND hwnd, struct detail_data *data)

static void	create_listview_columns (HWND hwnd)

static void	set_fields_selection (HWND hwnd, struct detail_data *data, int sel)

static void	create_cert_details_list (HWND hwnd, struct detail_data *data)

static void	add_purpose (HWND hwnd, LPCSTR oid)

static BOOL	is_valid_oid (LPCSTR oid)

static BOOL	is_oid_in_list (HWND hwnd, LPCSTR oid)

static LRESULT CALLBACK	add_purpose_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static WCHAR *	get_cert_property_as_string (PCCERT_CONTEXT cert, DWORD prop)

static void	redraw_states (HWND list, BOOL enabled)

static void	select_purposes (HWND hwnd, PurposeSelection selection)

static void	show_cert_usages (HWND hwnd, struct edit_cert_data *data)

static void	set_general_cert_properties (HWND hwnd, struct edit_cert_data *data)

static void	set_cert_string_property (PCCERT_CONTEXT cert, DWORD prop, LPWSTR str)

static BOOL CALLBACK	refresh_propsheet_pages (HWND hwnd, LPARAM lParam)

static void	apply_general_changes (HWND hwnd)

static LRESULT CALLBACK	cert_properties_general_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static UINT CALLBACK	cert_properties_general_callback (HWND hwnd, UINT msg, PROPSHEETPAGEW *page)

static void	show_edit_cert_properties_dialog (HWND parent, struct detail_data *data)

static void	free_detail_fields (struct detail_data *data)

static void	refresh_details_view (HWND hwnd)

static LRESULT CALLBACK	detail_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static UINT CALLBACK	detail_callback (HWND hwnd, UINT msg, PROPSHEETPAGEW *page)

static BOOL	init_detail_page (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL pfPropertiesChanged, PROPSHEETPAGEW page)

static LPARAM	index_to_lparam (struct hierarchy_data *data, DWORD index)

static DWORD	lparam_to_index (struct hierarchy_data *data, LPARAM lp)

static struct hierarchy_data *	get_hierarchy_data_from_tree_item (HWND tree, HTREEITEM hItem)

static WCHAR *	get_cert_display_name (PCCERT_CONTEXT cert)

static void	show_cert_chain (HWND hwnd, struct hierarchy_data *data)

static void	set_certificate_status (HWND hwnd, const CRYPT_PROVIDER_CERT *cert)

static void	set_certificate_status_for_end_cert (HWND hwnd, PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)

static void	show_cert_hierarchy (HWND hwnd, struct hierarchy_data *data)

static void	show_dialog_for_selected_cert (HWND hwnd)

static LRESULT CALLBACK	hierarchy_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static UINT CALLBACK	hierarchy_callback (HWND hwnd, UINT msg, PROPSHEETPAGEW *page)

static BOOL	init_hierarchy_page (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, PROPSHEETPAGEW *page)

static int CALLBACK	cert_prop_sheet_proc (HWND hwnd, UINT msg, LPARAM lp)

static BOOL	show_cert_dialog (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, CRYPT_PROVIDER_CERT provCert, BOOL pfPropertiesChanged)

BOOL WINAPI	CryptUIDlgViewCertificateW (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)

BOOL WINAPI	CryptUIDlgViewContext (DWORD dwContextType, LPVOID pvContext, HWND hwnd, LPCWSTR pwszTitle, DWORD dwFlags, LPVOID pvReserved)

static BOOL	is_ca_cert (PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)

static HCERTSTORE	choose_store_for_cert (PCCERT_CONTEXT cert)

static BOOL	import_cert (PCCERT_CONTEXT cert, HCERTSTORE hDestCertStore)

static BOOL	import_crl (PCCRL_CONTEXT crl, HCERTSTORE hDestCertStore)

static BOOL	import_ctl (PCCTL_CONTEXT ctl, HCERTSTORE hDestCertStore)

static BOOL	check_context_type (DWORD dwFlags, DWORD type)

static void	import_warning (DWORD dwFlags, HWND hwnd, LPCWSTR szTitle, int warningID)

static void	import_warn_type_mismatch (DWORD dwFlags, HWND hwnd, LPCWSTR szTitle)

static BOOL	check_store_context_type (DWORD dwFlags, HCERTSTORE store)

static BOOL	import_store (DWORD dwFlags, HWND hwnd, LPCWSTR szTitle, HCERTSTORE source, HCERTSTORE dest)

static HCERTSTORE	open_store_from_file (DWORD dwFlags, LPCWSTR fileName, DWORD *pContentType)

static BOOL	import_file (DWORD dwFlags, HWND hwnd, LPCWSTR szTitle, LPCWSTR fileName, HCERTSTORE dest)

static LRESULT CALLBACK	import_welcome_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static WCHAR *	make_import_file_filter (DWORD dwFlags)

static BOOL	import_validate_filename (HWND hwnd, struct ImportWizData *data, LPCWSTR fileName)

static LRESULT CALLBACK	import_file_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static LRESULT CALLBACK	import_store_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	show_import_details (HWND lv, struct ImportWizData *data)

static BOOL	do_import (DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)

static LRESULT CALLBACK	import_finish_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static BOOL	show_import_ui (DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)

BOOL WINAPI	CryptUIWizImport (DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)

static LRESULT CALLBACK	export_welcome_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static PCRYPT_KEY_PROV_INFO	export_get_private_key_info (PCCERT_CONTEXT cert)

static BOOL	export_acquire_private_key (const CRYPT_KEY_PROV_INFO info, HCRYPTPROV phProv)

static BOOL	export_is_key_exportable (HCRYPTPROV hProv, DWORD keySpec)

static LRESULT CALLBACK	export_private_key_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static BOOL	export_info_has_private_key (PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo)

static void	export_format_enable_controls (HWND hwnd, const struct ExportWizData *data)

static LRESULT CALLBACK	export_format_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	export_password_mismatch (HWND hwnd, const struct ExportWizData *data)

static LRESULT CALLBACK	export_password_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static LPWSTR	export_append_extension (const struct ExportWizData *data, LPWSTR fileName)

static BOOL	export_validate_filename (HWND hwnd, struct ExportWizData *data, LPCWSTR fileName)

static WCHAR *	make_export_file_filter (DWORD exportFormat, DWORD subjectChoice)

static LRESULT CALLBACK	export_file_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static void	show_export_details (HWND lv, const struct ExportWizData *data)

static BOOL	save_der (HANDLE file, const BYTE *pb, DWORD cb)

static BOOL	save_base64 (HANDLE file, const BYTE *pb, DWORD cb)

static BOOL	save_store_as_cms (HANDLE file, HCERTSTORE store)

static BOOL	save_cert_as_cms (HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, BOOL includeChain)

static BOOL	save_serialized_store (HANDLE file, HCERTSTORE store)

static BOOL	save_pfx (HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO pContextInfo, PCRYPT_KEY_PROV_INFO keyProvInfo, BOOL deleteKeys)

static BOOL	do_export (HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO pContextInfo, PCRYPT_KEY_PROV_INFO keyProvInfo, BOOL deleteKeys)

static LRESULT CALLBACK	export_finish_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

static BOOL	show_export_ui (DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, const void *pvoid)

BOOL WINAPI	CryptUIWizExport (DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, void *pvoid)

BOOL WINAPI	CryptUIDlgViewSignerInfoA (CRYPTUI_VIEWSIGNERINFO_STRUCTA *pcvsi)

static void	init_columns (HWND lv, DWORD flags)

static void	add_cert_to_list (HWND lv, PCCERT_CONTEXT cert, DWORD flags, DWORD allocatedLen, LPWSTR str)

static void	add_store_certs (HWND lv, HCERTSTORE store, DWORD flags, PFNCFILTERPROC filter, void *callback_data)

static PCCERT_CONTEXT	select_cert_get_selected (HWND hwnd, int selection)

static void	select_cert_update_view_button (HWND hwnd)

static void	select_cert_view (HWND hwnd, PCCERT_CONTEXT cert, struct SelectCertData *data)

static int CALLBACK	select_cert_sort_by_text (LPARAM lp1, LPARAM lp2, LPARAM lp)

static LRESULT CALLBACK	select_cert_dlg_proc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)

PCCERT_CONTEXT WINAPI	CryptUIDlgSelectCertificateW (PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc)

static void	free_prop_sheet_pages (PROPSHEETPAGEW *pages, DWORD num)

static PROPSHEETPAGEW *	prop_sheet_pages_AtoW (LPCPROPSHEETPAGEA pages, DWORD num)

PCCERT_CONTEXT WINAPI	CryptUIDlgSelectCertificateA (PCCRYPTUI_SELECTCERTIFICATE_STRUCTA pcsc)

PCCERT_CONTEXT WINAPI	CryptUIDlgSelectCertificateFromStore (HCERTSTORE hCertStore, HWND hwnd, LPCWSTR pwszTitle, LPCWSTR pwszDisplayString, DWORD dwDontUseColumn, DWORD dwFlags, void *pvReserved)

BOOL WINAPI	CryptUIWizDigitalSign (DWORD flags, HWND parent, LPCWSTR title, PCCRYPTUI_WIZ_DIGITAL_SIGN_INFO info, PCCRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT *context)

Variables
static HINSTANCE	hInstance

static const WCHAR	empty [] = {0}

static const WCHAR	my [] = { 'M','y',0 }

static const WCHAR	addressBook []

static const WCHAR	ca [] = { 'C','A',0 }

static const WCHAR	root [] = { 'R','o','o','t',0 }

static const WCHAR	trustedPublisher []

static const WCHAR	disallowed [] = { 'D','i','s','a','l','l','o','w','e','d',0 }

static const struct CertMgrStoreInfo	defaultStoreList []

static const struct CertMgrStoreInfo	publisherStoreList []

static struct OIDToString	oidMap []

static const struct v1_field	v1_fields []

static const struct prop_id_to_string_id	prop_id_map []

static const struct selection_list_item	listItems []

static const WCHAR	filter_cert []

static const WCHAR	filter_pfx []

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 []

static const WCHAR	filter_all [] = { '','.','',0 }

struct {
int id

DWORD allowFlags

LPCWSTR filter

}	import_filters []

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 }

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file main.c.

◆ CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE

#define CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE 0x00000001

Definition at line 1347 of file main.c.

◆ MAX_DESCRIPTION

#define MAX_DESCRIPTION 255

Definition at line 3536 of file main.c.

◆ MAX_FRIENDLY_NAME

#define MAX_FRIENDLY_NAME 40

Definition at line 3535 of file main.c.

◆ MAX_PURPOSE

#define MAX_PURPOSE 255

Definition at line 3227 of file main.c.

◆ MAX_STRING_LEN

#define MAX_STRING_LEN 512

Definition at line 75 of file main.c.

◆ MY_INDENT

#define MY_INDENT 200

Definition at line 1891 of file main.c.

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 23 of file main.c.

◆ WM_REFRESH_VIEW

#define WM_REFRESH_VIEW WM_USER + 0

Definition at line 3526 of file main.c.

Typedef Documentation

◆ add_fields_func

typedef void(* add_fields_func) (HWND hwnd, struct detail_data *data)

Definition at line 2756 of file main.c.

◆ create_detailed_value_func

typedef WCHAR *(* create_detailed_value_func) (PCCERT_CONTEXT cert, void *param)

Definition at line 2758 of file main.c.

◆ CRYPTUI_ENUM_DATA

typedef struct _CRYPTUI_ENUM_DATA CRYPTUI_ENUM_DATA

◆ CRYPTUI_ENUM_SYSTEM_STORE_ARGS

typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS CRYPTUI_ENUM_SYSTEM_STORE_ARGS

◆ CRYPTUI_SELECTSTORE_INFO_A

typedef struct _CRYPTUI_SELECTSTORE_INFO_A CRYPTUI_SELECTSTORE_INFO_A

◆ CRYPTUI_SELECTSTORE_INFO_W

typedef struct _CRYPTUI_SELECTSTORE_INFO_W CRYPTUI_SELECTSTORE_INFO_W

◆ field_format_func

typedef WCHAR *(* field_format_func) (PCCERT_CONTEXT cert)

Definition at line 2597 of file main.c.

◆ PCRYPTUI_ENUM_DATA

typedef struct _CRYPTUI_ENUM_DATA * PCRYPTUI_ENUM_DATA

◆ PCRYPTUI_ENUM_SYSTEM_STORE_ARGS

typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS * PCRYPTUI_ENUM_SYSTEM_STORE_ARGS

◆ PCRYPTUI_SELECTSTORE_INFO_A

typedef struct _CRYPTUI_SELECTSTORE_INFO_A * PCRYPTUI_SELECTSTORE_INFO_A

◆ PCRYPTUI_SELECTSTORE_INFO_W

typedef struct _CRYPTUI_SELECTSTORE_INFO_W * PCRYPTUI_SELECTSTORE_INFO_W

◆ PFN_SELECTED_STORE_CB

typedef BOOL(WINAPI * PFN_SELECTED_STORE_CB) (HCERTSTORE store, HWND hwnd, void *pvArg)

Definition at line 1343 of file main.c.

◆ prop_to_value_func

typedef WCHAR *(* prop_to_value_func) (void *pb, DWORD cb)

Definition at line 3005 of file main.c.

Enumeration Type Documentation

◆ CheckBitmapIndex

enum CheckBitmapIndex

Enumerator
CheckBitmapIndexUnchecked
CheckBitmapIndexChecked
CheckBitmapIndexDisabledUnchecked
CheckBitmapIndexDisabledChecked

Definition at line 581 of file main.c.

             {
    CheckBitmapIndexUnchecked = 1,
    CheckBitmapIndexChecked = 2,
    CheckBitmapIndexDisabledUnchecked = 3,
    CheckBitmapIndexDisabledChecked = 4
} CheckBitmapIndex;

◆ PurposeFilter

enum PurposeFilter

Enumerator
PurposeFilterShowAll
PurposeFilterShowAdvanced
PurposeFilterShowOID

Definition at line 216 of file main.c.

             {
    PurposeFilterShowAll = 0,
    PurposeFilterShowAdvanced = 1,
    PurposeFilterShowOID = 2
} PurposeFilter;

◆ PurposeSelection

enum PurposeSelection

Enumerator
PurposeEnableAll
PurposeDisableAll
PurposeEnableSelected

Definition at line 3380 of file main.c.

             {
    PurposeEnableAll = 0,
    PurposeDisableAll,
    PurposeEnableSelected
} PurposeSelection;

Function Documentation

◆ add_all_extensions()

static void add_all_extensions	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 2985 of file main.c.

{
    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]);
}

Referenced by add_all_fields().

◆ add_all_fields()

static void add_all_fields	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 3078 of file main.c.

{
    add_v1_fields(hwnd, data);
    add_all_extensions(hwnd, data);
    add_properties(hwnd, data);
}

◆ add_cert_columns()

static void add_cert_columns ( HWND hwnd )

static

Definition at line 77 of file main.c.

{
    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, ARRAY_SIZE(buf));
    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, ARRAY_SIZE(buf));
    SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
    column.cx = (rc.right - rc.left) * 16 / 100 - 2;
    LoadStringW(hInstance, IDS_EXPIRATION_COLUMN, buf, ARRAY_SIZE(buf));
    SendMessageW(lv, LVM_INSERTCOLUMNW, 2, (LPARAM)&column);
    column.cx = (rc.right - rc.left) * 23 / 100 - 1;
    LoadStringW(hInstance, IDS_FRIENDLY_NAME_COLUMN, buf, ARRAY_SIZE(buf));
    SendMessageW(lv, LVM_INSERTCOLUMNW, 3, (LPARAM)&column);
}

Referenced by cert_mgr_dlg_proc().

◆ add_cert_extension_detail()

static void add_cert_extension_detail	(	HWND	hwnd,
		struct detail_data *	data,
		PCERT_EXTENSION	ext
	)

static

Definition at line 2956 of file main.c.

{
    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);
}

Referenced by add_all_extensions(), and add_critical_extensions().

◆ add_cert_string_to_control()

static void add_cert_string_to_control	(	HWND	hwnd,
		PCCERT_CONTEXT	pCertContext,
		DWORD	dwType,
		DWORD	dwFlags
	)

static

Definition at line 1794 of file main.c.

{
    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);
    }
}

Referenced by set_cert_name_string().

◆ add_cert_to_list()

static void add_cert_to_list	(	HWND	lv,
		PCCERT_CONTEXT	cert,
		DWORD	flags,
		DWORD *	allocatedLen,
		LPWSTR *	str
	)

static

Definition at line 7066 of file main.c.

{
    DWORD len;
    LVITEMW item;
    WCHAR dateFmt[80]; /* sufficient for LOCALE_SSHORTDATE */
    WCHAR buf[80];
    SYSTEMTIME sysTime;
    LPWSTR none, usages;
 
    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);
    if (!item.iItem)
    {
        item.mask |= LVIF_STATE;
        item.state = LVIS_SELECTED;
        item.stateMask = -1;
    }
    if (!(flags & CRYPTUI_SELECT_ISSUEDTO_COLUMN))
    {
        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;
        ++item.iSubItem;
    }
    if (!(flags & CRYPTUI_SELECT_ISSUEDBY_COLUMN))
    {
        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;
            if (!item.iSubItem)
                SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
            else
                SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
        }
        item.mask = LVIF_TEXT;
        ++item.iSubItem;
    }
    if (!(flags & CRYPTUI_SELECT_INTENDEDUSE_COLUMN))
    {
        get_cert_usages(cert, &usages);
        if (usages)
        {
            item.pszText = usages;
            if (!item.iSubItem)
                SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
            else
                SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
            HeapFree(GetProcessHeap(), 0, usages);
        }
        item.mask = LVIF_TEXT;
        ++item.iSubItem;
    }
    if (!(flags & CRYPTUI_SELECT_FRIENDLYNAME_COLUMN))
    {
        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;
            if (!item.iSubItem)
                SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
            else
                SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
        }
        item.mask = LVIF_TEXT;
        ++item.iSubItem;
    }
    if (!(flags & CRYPTUI_SELECT_EXPIRATION_COLUMN))
    {
        GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt, ARRAY_SIZE(dateFmt));
        FileTimeToSystemTime(&cert->pCertInfo->NotAfter, &sysTime);
        GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf, ARRAY_SIZE(buf));
        item.pszText = buf;
        if (!item.iSubItem)
            SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
        else
            SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
        item.mask = LVIF_TEXT;
        ++item.iSubItem;
    }
    if (!(flags & CRYPTUI_SELECT_LOCATION_COLUMN))
    {
        static int show_fixme;
        if (!show_fixme++)
            FIXME("showing location is not implemented\n");
        LoadStringW(hInstance, IDS_NO_IMPL, buf, ARRAY_SIZE(buf));
        if (!item.iSubItem)
            SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
        else
            SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
    }
}

Referenced by add_store_certs().

◆ add_cert_to_view()

static void add_cert_to_view	(	HWND	lv,
		PCCERT_CONTEXT	cert,
		DWORD *	allocatedLen,
		LPWSTR *	str
	)

static

Definition at line 101 of file main.c.

{
    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, ARRAY_SIZE(dateFmt));
    FileTimeToSystemTime(&cert->pCertInfo->NotAfter, &sysTime);
    GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date, ARRAY_SIZE(date));
    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);
    }
}

Referenced by show_store_certs().

◆ add_critical_extensions()

static void add_critical_extensions	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 2994 of file main.c.

{
    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]);
}

◆ add_date_string_to_control()

static void add_date_string_to_control	(	HWND	hwnd,
		const FILETIME *	fileTime
	)

static

Definition at line 2411 of file main.c.

{
    WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
    WCHAR date[80];
    SYSTEMTIME sysTime;
 
    GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt, ARRAY_SIZE(dateFmt));
    FileTimeToSystemTime(fileTime, &sysTime);
    GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date, ARRAY_SIZE(date));
    add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
}

Referenced by set_cert_validity_period().

◆ add_field_and_value_to_list()

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
	)

static

Definition at line 2785 of file main.c.

{
    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);
}

Referenced by add_cert_extension_detail(), and add_string_id_and_value_to_list().

◆ add_field_value_data()

static void add_field_value_data	(	struct detail_data *	data,
		create_detailed_value_func	create,
		void *	param
	)

static

Definition at line 2767 of file main.c.

{
    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++;
    }
}

Referenced by add_field_and_value_to_list().

◆ add_icon_to_control()

static void add_icon_to_control	(	HWND	hwnd,
		int	id
	)

static

Definition at line 1809 of file main.c.

{
    HRESULT hr;
    IRichEditOle *richEditOle = NULL;
    IOleObject *object = NULL;
    CLSID clsid;
    LPOLECACHE oleCache = NULL;
    FORMATETC formatEtc;
    DWORD conn;
    IDataObject *dataObject = NULL;
    HBITMAP bitmap = NULL;
    STGMEDIUM stgm;
    IOleClientSite *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;
    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);
}

Referenced by set_cert_info().

◆ add_known_usage()

static void add_known_usage	(	HWND	lv,
		PCCRYPT_OID_INFO	info,
		CheckBitmapIndex	state
	)

static

Definition at line 588 of file main.c.

{
    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);
}

Referenced by add_known_usages_to_list(), and show_cert_usages().

◆ add_known_usages_to_list()

static void add_known_usages_to_list	(	HWND	lv,
		CheckBitmapIndex	state
	)

static

Definition at line 603 of file main.c.

{
    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);
    }
}

Referenced by cert_mgr_advanced_dlg_proc(), and show_cert_usages().

◆ add_local_oid_text_to_control()

static void add_local_oid_text_to_control	(	HWND	text,
		LPCSTR	oid
	)

static

Definition at line 1993 of file main.c.

{
    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 = wmemchr(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);
        }
    }
}

Referenced by display_app_usages(), and display_cert_usages().

◆ add_oid_text_to_control()

static void add_oid_text_to_control	(	HWND	hwnd,
		char *	oid
	)

static

Definition at line 1893 of file main.c.

{
    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);
    }
}

Referenced by display_app_usages(), and display_cert_usages().

◆ add_oid_to_usage()

static CERT_ENHKEY_USAGE * add_oid_to_usage	(	CERT_ENHKEY_USAGE *	usage,
		LPSTR	oid
	)

static

Definition at line 262 of file main.c.

{
    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;
}

Referenced by convert_usages_str_to_usage(), and create_advanced_filter().

◆ add_properties()

static void add_properties	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 3037 of file main.c.

{
    DWORD i;
    PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
 
    for (i = 0; i < ARRAY_SIZE(prop_id_map); 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);
        }
    }
}

Referenced by add_all_fields().

◆ add_purpose()

static void add_purpose	(	HWND	hwnd,
		LPCSTR	oid
	)

static

Definition at line 3152 of file main.c.

{
    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);
    }
}

Referenced by add_purpose_dlg_proc(), and show_cert_usages().

◆ add_purpose_dlg_proc()

static LRESULT CALLBACK add_purpose_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 3229 of file main.c.

{
    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, ARRAY_SIZE(buf),
                 (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, ARRAY_SIZE(error));
                    LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title, ARRAY_SIZE(title));
                    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,
                     ARRAY_SIZE(error));
                    LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title, ARRAY_SIZE(title));
                    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;
}

Referenced by cert_properties_general_dlg_proc().

◆ add_store_certs()

static void add_store_certs	(	HWND	lv,
		HCERTSTORE	store,
		DWORD	flags,
		PFNCFILTERPROC	filter,
		void *	callback_data
	)

static

Definition at line 7196 of file main.c.

{
    PCCERT_CONTEXT cert = NULL;
    BOOL select = FALSE;
    DWORD allocatedLen = 0;
    LPWSTR str = NULL;
 
    do {
        cert = CertEnumCertificatesInStore(store, cert);
        if (cert && (!filter || filter(cert, &select, callback_data)))
            add_cert_to_list(lv, cert, flags, &allocatedLen, &str);
    } while (cert);
    HeapFree(GetProcessHeap(), 0, str);
}

Referenced by select_cert_dlg_proc().

◆ add_string_id_and_value_to_list()

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
	)

static

Definition at line 2806 of file main.c.

{
    WCHAR buf[MAX_STRING_LEN];
 
    LoadStringW(hInstance, id, buf, ARRAY_SIZE(buf));
    add_field_and_value_to_list(hwnd, data, buf, value, create, param);
}

Referenced by add_properties(), and add_v1_field().

◆ add_string_resource_to_control()

static void add_string_resource_to_control	(	HWND	hwnd,
		int	id
	)

static

Definition at line 1752 of file main.c.

{
    LPWSTR str;
    LONG len;
 
    len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
    add_unformatted_text_to_control(hwnd, str, len);
}

Referenced by set_cert_validity_period(), and set_certificate_status().

◆ add_string_resource_with_paraformat_to_control()

static void add_string_resource_with_paraformat_to_control	(	HWND	hwnd,
		int	id,
		const PARAFORMAT2 *	fmt
	)

static

Definition at line 1768 of file main.c.

{
    LPWSTR str;
    LONG len;
 
    len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
    add_text_with_paraformat_to_control(hwnd, str, len, fmt);
}

Referenced by display_app_usages(), display_cert_usages(), set_cert_info(), set_cert_name_string(), set_cert_validity_period(), and set_policy_text().

◆ add_text_with_paraformat_to_control()

static void add_text_with_paraformat_to_control	(	HWND	hwnd,
		LPCWSTR	text,
		LONG	len,
		const PARAFORMAT2 *	fmt
	)

static

Definition at line 1761 of file main.c.

{
    add_unformatted_text_to_control(hwnd, text, len);
    SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
}

Referenced by add_local_oid_text_to_control(), add_oid_text_to_control(), and add_string_resource_with_paraformat_to_control().

◆ add_unformatted_text_to_control()

static void add_unformatted_text_to_control	(	HWND	hwnd,
		LPCWSTR	text,
		LONG	len
	)

static

Definition at line 1735 of file main.c.

{
    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);
}

Referenced by add_cert_string_to_control(), add_date_string_to_control(), add_local_oid_text_to_control(), add_oid_text_to_control(), add_string_resource_to_control(), add_text_with_paraformat_to_control(), detail_dlg_proc(), display_app_usages(), display_cert_usages(), set_cert_name_string(), set_cert_validity_period(), and user_notice_dlg_proc().

◆ add_v1_field()

static void add_v1_field	(	HWND	hwnd,
		struct detail_data *	data,
		const struct v1_field *	field
	)

static

Definition at line 2822 of file main.c.

{
    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);
    }
}

Referenced by add_v1_fields().

◆ add_v1_fields()

static void add_v1_fields	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 2846 of file main.c.

{
    unsigned 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 < ARRAY_SIZE(v1_fields) - 1; i++)
        add_v1_field(hwnd, data, &v1_fields[i]);
    if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
        add_v1_field(hwnd, data, &v1_fields[i]);
}

Referenced by add_all_fields().

◆ apply_general_changes()

static void apply_general_changes ( HWND hwnd )

static

Definition at line 3538 of file main.c.

{
    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, ARRAY_SIZE(buf), (LPARAM)buf);
    set_cert_string_property(data->cert, CERT_FRIENDLY_NAME_PROP_ID, buf);
    SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_GETTEXT, ARRAY_SIZE(buf), (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;
}

Referenced by cert_properties_general_dlg_proc().

◆ cert_mgr_advanced_dlg_proc()

static LRESULT CALLBACK cert_mgr_advanced_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 724 of file main.c.

{
    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);
#ifndef __REACTOS__
            ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
#endif
            EndDialog(hwnd, IDOK);
            break;
        case IDCANCEL:
#ifndef __REACTOS__
            ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
#endif
            EndDialog(hwnd, IDCANCEL);
            break;
        }
        break;
    }
    return 0;
}

Referenced by cert_mgr_dlg_proc().

◆ cert_mgr_clear_cert_selection()

static void cert_mgr_clear_cert_selection ( HWND hwnd )

static

Definition at line 811 of file main.c.

{
    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);
}

Referenced by cert_mgr_dlg_proc(), and cert_mgr_do_remove().

◆ cert_mgr_current_store()

static HCERTSTORE cert_mgr_current_store ( HWND hwnd )

static

Definition at line 557 of file main.c.

{
    HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
 
    return cert_mgr_index_to_store(tab, SendMessageW(tab, TCM_GETCURSEL, 0, 0));
}

Referenced by cert_mgr_dlg_proc(), and refresh_store_certs().

◆ cert_mgr_dlg_proc()

static LRESULT CALLBACK cert_mgr_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 1121 of file main.c.

{
    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;
    }
#ifdef __REACTOS__
    case WM_DESTROY:
        free_certs(GetDlgItem(hwnd, IDC_MGR_CERTS));
        close_stores(GetDlgItem(hwnd, IDC_MGR_STORES));
        data = (struct CertMgrData *)GetWindowLongPtrW(hwnd, DWLP_USER);
        HeapFree(GetProcessHeap(), 0, data);
        break;
#endif
    case WM_NOTIFY:
    {
        NMHDR *hdr = (NMHDR *)lp;
 
        switch (hdr->code)
        {
        case TCN_SELCHANGE:
            cert_mgr_clear_cert_selection(hwnd);
            break;
        case LVN_ITEMCHANGED:
        {
            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:
#ifndef __REACTOS__
            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);
#endif
            EndDialog(hwnd, IDCANCEL);
            break;
        }
        break;
    }
    return 0;
}

Referenced by CryptUIDlgCertMgr().

◆ cert_mgr_do_export()

static void cert_mgr_do_export ( HWND hwnd )

static

Definition at line 1018 of file main.c.

{
    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);
        }
    }
}

Referenced by cert_mgr_dlg_proc().

◆ cert_mgr_do_remove()

static void cert_mgr_do_remove ( HWND hwnd )

static

Definition at line 972 of file main.c.

{
    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, ARRAY_SIZE(title));
            pTitle = title;
        }
        LoadStringW(hInstance, warningID, warning, ARRAY_SIZE(warning));
        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);
        }
    }
}

Referenced by cert_mgr_dlg_proc().

◆ cert_mgr_index_to_cert()

static PCCERT_CONTEXT cert_mgr_index_to_cert	(	HWND	hwnd,
		int	index
	)

static

Definition at line 821 of file main.c.

{
    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;
}

Referenced by cert_mgr_do_export(), cert_mgr_do_remove(), cert_mgr_show_cert_usages(), and show_selected_cert().

◆ cert_mgr_index_to_store()

static HCERTSTORE cert_mgr_index_to_store	(	HWND	tab,
		int	index
	)

static

Definition at line 548 of file main.c.

{
    TCITEMW item;
 
    item.mask = TCIF_PARAM;
    SendMessageW(tab, TCM_GETITEMW, index, (LPARAM)&item);
    return (HCERTSTORE)item.lParam;
}

Referenced by cert_mgr_current_store(), cert_mgr_dlg_proc(), and close_stores().

◆ cert_mgr_show_cert_usages()

static void cert_mgr_show_cert_usages	(	HWND	hwnd,
		int	index
	)

static

Definition at line 958 of file main.c.

{
    HWND text = GetDlgItem(hwnd, IDC_MGR_PURPOSES);
    PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, index);
    LPWSTR str = NULL;
 
    get_cert_usages(cert, &str);
    if (str)
    {
        SendMessageW(text, WM_SETTEXT, 0, (LPARAM)str);
        HeapFree(GetProcessHeap(), 0, str);
    }
}

Referenced by cert_mgr_dlg_proc().

◆ cert_mgr_sort_by_date()

static int CALLBACK cert_mgr_sort_by_date	(	LPARAM	lp1,
		LPARAM	lp2,
		LPARAM	lp
	)

static

Definition at line 1107 of file main.c.

{
    PCCERT_CONTEXT cert1 = (PCCERT_CONTEXT)lp1;
    PCCERT_CONTEXT cert2 = (PCCERT_CONTEXT)lp2;
    return CompareFileTime(&cert1->pCertInfo->NotAfter,
     &cert2->pCertInfo->NotAfter);
}

Referenced by cert_mgr_dlg_proc(), and select_cert_dlg_proc().

◆ cert_mgr_sort_by_friendly_name()

static int CALLBACK cert_mgr_sort_by_friendly_name	(	LPARAM	lp1,
		LPARAM	lp2,
		LPARAM	lp
	)

static

Definition at line 1115 of file main.c.

{
    return cert_mgr_sort_by_text((HWND)lp, 3, lp1, lp2);
}

Referenced by cert_mgr_dlg_proc().

◆ cert_mgr_sort_by_issuer()

static int CALLBACK cert_mgr_sort_by_issuer	(	LPARAM	lp1,
		LPARAM	lp2,
		LPARAM	lp
	)

static

Definition at line 1102 of file main.c.

{
    return cert_mgr_sort_by_text((HWND)lp, 1, lp1, lp2);
}

Referenced by cert_mgr_dlg_proc().

◆ cert_mgr_sort_by_subject()

static int CALLBACK cert_mgr_sort_by_subject	(	LPARAM	lp1,
		LPARAM	lp2,
		LPARAM	lp
	)

static

Definition at line 1097 of file main.c.

{
    return cert_mgr_sort_by_text((HWND)lp, 0, lp1, lp2);
}

Referenced by cert_mgr_dlg_proc(), and show_store_certs().

◆ cert_mgr_sort_by_text()

static int cert_mgr_sort_by_text	(	HWND	lv,
		int	col,
		int	index1,
		int	index2
	)

static

Definition at line 1079 of file main.c.

{
    LVITEMW item;
    WCHAR buf1[MAX_STRING_LEN];
    WCHAR buf2[MAX_STRING_LEN];
 
    item.cchTextMax = ARRAY_SIZE(buf1);
    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 lstrcmpW(buf1, buf2);
}

Referenced by cert_mgr_sort_by_friendly_name(), cert_mgr_sort_by_issuer(), cert_mgr_sort_by_subject(), and select_cert_sort_by_text().

◆ cert_prop_sheet_proc()

static int CALLBACK cert_prop_sheet_proc	(	HWND	hwnd,
		UINT	msg,
		LPARAM	lp
	)

static

Definition at line 4288 of file main.c.

{
    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;
}

Referenced by show_cert_dialog().

◆ cert_properties_general_callback()

static UINT CALLBACK cert_properties_general_callback	(	HWND	hwnd,
		UINT	msg,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 3703 of file main.c.

{
    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)
        {
#ifndef __REACTOS__
            ImageList_Destroy(data->imageList);
#endif
            HeapFree(GetProcessHeap(), 0, data);
        }
        break;
    }
    return 1;
}

Referenced by show_edit_cert_properties_dialog().

◆ cert_properties_general_dlg_proc()

static LRESULT CALLBACK cert_properties_general_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 3602 of file main.c.

{
    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;
}

Referenced by show_edit_cert_properties_dialog().

◆ check_context_type()

static BOOL check_context_type	(	DWORD	dwFlags,
		DWORD	type
	)

static

Definition at line 4657 of file main.c.

{
    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;
}

Referenced by do_import().

◆ check_store_context_type()

static BOOL check_store_context_type	(	DWORD	dwFlags,
		HCERTSTORE	store
	)

static

Definition at line 4722 of file main.c.

{
    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;
}

Referenced by import_store(), and import_validate_filename().

◆ choose_store_for_cert()

static HCERTSTORE choose_store_for_cert ( PCCERT_CONTEXT cert )

static

Definition at line 4562 of file main.c.

{
    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);
}

Referenced by import_cert().

◆ close_stores()

static void close_stores ( HWND tab )

static

Definition at line 564 of file main.c.

{
    int i, tabs = SendMessageW(tab, TCM_GETITEMCOUNT, 0, 0);
 
    for (i = 0; i < tabs; i++)
        CertCloseStore(cert_mgr_index_to_store(tab, i), 0);
}

Referenced by cert_mgr_dlg_proc().

◆ convert_usages_str_to_usage()

static CERT_ENHKEY_USAGE * convert_usages_str_to_usage ( LPSTR usageStr )

static

Definition at line 281 of file main.c.

{
    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;
            usage = add_oid_to_usage(usage, ptr);
        }
    }
    return usage;
}

Referenced by create_advanced_filter().

◆ create_advanced_filter()

static CERT_ENHKEY_USAGE * create_advanced_filter ( void )

static

Definition at line 302 of file main.c.

{
    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; advancedUsage && *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)
                            advancedUsage = 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;
}

Referenced by show_store_certs().

◆ create_cert_details_list()

static void create_cert_details_list	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 3145 of file main.c.

{
    create_show_list(hwnd, data);
    create_listview_columns(hwnd);
    set_fields_selection(hwnd, data, 0);
}

Referenced by detail_dlg_proc().

◆ create_listview_columns()

static void create_listview_columns ( HWND hwnd )

static

Definition at line 3116 of file main.c.

{
    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, ARRAY_SIZE(buf));
    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, ARRAY_SIZE(buf));
    SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
}

Referenced by create_cert_details_list().

◆ create_show_list()

static void create_show_list	(	HWND	hwnd,
		struct detail_data *	data
	)

static

Definition at line 3099 of file main.c.

{
    HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
    WCHAR buf[MAX_STRING_LEN];
    int i;
 
    for (i = 0; i < ARRAY_SIZE(listItems); i++)
    {
        int index;
 
        LoadStringW(hInstance, listItems[i].id, buf, ARRAY_SIZE(buf));
        index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
        SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
    }
    SendMessageW(cb, CB_SETCURSEL, 0, 0);
}

Referenced by create_cert_details_list().

◆ crypt_format_extension()

static WCHAR * crypt_format_extension	(	const CERT_EXTENSION *	ext,
		DWORD	formatStrType
	)

static

Definition at line 2860 of file main.c.

{
    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;
}

Referenced by add_cert_extension_detail(), field_format_detailed_extension(), and format_enhanced_key_usage_value().

◆ CryptUIDlgCertMgr()

BOOL WINAPI CryptUIDlgCertMgr ( PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr )

Definition at line 1313 of file main.c.

{
    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;
}

Referenced by display_cert_manager(), and OpenPersonalTrustDBDialog().

◆ CryptUIDlgSelectCertificateA()

PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateA ( PCCRYPTUI_SELECTCERTIFICATE_STRUCTA pcsc )

Definition at line 7539 of file main.c.

{
    PCCERT_CONTEXT cert = NULL;
    CRYPTUI_SELECTCERTIFICATE_STRUCTW selCertInfo;
    LPWSTR title = NULL, display_str = NULL;
    PROPSHEETPAGEW *pages = NULL;
 
    TRACE("%p\n", pcsc);
 
    if (pcsc->dwSize != sizeof(*pcsc) && pcsc->dwSize != sizeof(*pcsc) - sizeof(HCERTSTORE))
    {
        WARN("unexpected size %d\n", pcsc->dwSize);
        SetLastError(E_INVALIDARG);
        return NULL;
    }
    memcpy(&selCertInfo, pcsc, pcsc->dwSize);
    if (pcsc->szTitle)
    {
        if (!(title = strdupAtoW( pcsc->szTitle ))) goto error;
        selCertInfo.szTitle = title;
    }
    if (pcsc->szDisplayString)
    {
        if (!(display_str = strdupAtoW( pcsc->szDisplayString ))) goto error;
        selCertInfo.szDisplayString = display_str;
    }
    if (pcsc->cPropSheetPages)
    {
        pages = prop_sheet_pages_AtoW(pcsc->rgPropSheetPages, pcsc->cPropSheetPages);
        if (!pages)
            goto error;
        selCertInfo.rgPropSheetPages = pages;
    }
    cert = CryptUIDlgSelectCertificateW(&selCertInfo);
error:
    HeapFree(GetProcessHeap(), 0, title);
    HeapFree(GetProcessHeap(), 0, display_str);
    if (pcsc->cPropSheetPages)
        free_prop_sheet_pages(pages, pcsc->cPropSheetPages);
    return cert;
}

◆ CryptUIDlgSelectCertificateFromStore()

PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateFromStore	(	HCERTSTORE	hCertStore,
		HWND	hwnd,
		LPCWSTR	pwszTitle,
		LPCWSTR	pwszDisplayString,
		DWORD	dwDontUseColumn,
		DWORD	dwFlags,
		void *	pvReserved
	)

Definition at line 7581 of file main.c.

{
    CRYPTUI_SELECTCERTIFICATE_STRUCTW sc;
 
    TRACE("%p %p %s %s %x %x %p\n", hCertStore, hwnd, debugstr_w(pwszTitle), debugstr_w(pwszDisplayString), dwDontUseColumn, dwFlags, pvReserved);
 
    memset(&sc, 0, sizeof(sc));
 
    sc.dwSize = sizeof(sc);
    sc.hwndParent = hwnd;
    sc.dwFlags = dwFlags;
    sc.szTitle = pwszTitle;
    sc.szDisplayString = pwszDisplayString;
    sc.dwDontUseColumn = dwDontUseColumn;
    sc.cDisplayStores = 1;
    sc.rghDisplayStores = &hCertStore;
    return CryptUIDlgSelectCertificateW(&sc);
}

◆ CryptUIDlgSelectCertificateW()

PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateW ( PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc )

Definition at line 7440 of file main.c.

{
    struct SelectCertParam param;
 
    TRACE("%p\n", pcsc);
 
    if (pcsc->dwSize != sizeof(*pcsc) && pcsc->dwSize != sizeof(*pcsc) - sizeof(HCERTSTORE))
    {
        WARN("unexpected size %d\n", pcsc->dwSize);
        SetLastError(E_INVALIDARG);
        return NULL;
    }
    if (pcsc->dwFlags & CRYPTUI_SELECTCERT_MULTISELECT)
        FIXME("ignoring CRYPTUI_SELECTCERT_MULTISELECT\n");
    param.pcsc = pcsc;
    param.cert = NULL;
    DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_SELECT_CERT), pcsc->hwndParent,
     select_cert_dlg_proc, (LPARAM)&param);
    return param.cert;
}

Referenced by CryptUIDlgSelectCertificateA(), and CryptUIDlgSelectCertificateFromStore().

◆ CryptUIDlgSelectStoreA()

HCERTSTORE WINAPI CryptUIDlgSelectStoreA ( PCRYPTUI_SELECTSTORE_INFO_A info )

Definition at line 1638 of file main.c.

{
    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;
}

◆ CryptUIDlgSelectStoreW()

HCERTSTORE WINAPI CryptUIDlgSelectStoreW ( PCRYPTUI_SELECTSTORE_INFO_W info )

Definition at line 1618 of file main.c.

{
    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;
}

Referenced by CryptUIDlgSelectStoreA(), and import_store_dlg_proc().

◆ CryptUIDlgViewCertificateA()

BOOL WINAPI CryptUIDlgViewCertificateA	(	PCCRYPTUI_VIEWCERTIFICATE_STRUCTA	pCertViewInfo,
		BOOL *	pfPropertiesChanged
	)

Definition at line 1675 of file main.c.

{
    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;
}

◆ CryptUIDlgViewCertificateW()

BOOL WINAPI CryptUIDlgViewCertificateW	(	PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo,
		BOOL *	pfPropertiesChanged
	)

Definition at line 4415 of file main.c.

{
    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;
}

Referenced by CertViewPropertiesW(), CryptExtOpenCERW(), CryptUIDlgViewCertificateA(), CryptUIDlgViewContext(), select_cert_view(), show_dialog_for_selected_cert(), show_selected_cert(), and ShowX509EncodedCertificate().

◆ CryptUIDlgViewContext()

BOOL WINAPI CryptUIDlgViewContext	(	DWORD	dwContextType,
		LPVOID	pvContext,
		HWND	hwnd,
		LPCWSTR	pwszTitle,
		DWORD	dwFlags,
		LPVOID	pvReserved
	)

Definition at line 4489 of file main.c.

{
    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;
}

◆ CryptUIDlgViewSignerInfoA()

BOOL WINAPI CryptUIDlgViewSignerInfoA ( CRYPTUI_VIEWSIGNERINFO_STRUCTA * pcvsi )

Definition at line 7018 of file main.c.

{
    FIXME("%p: stub\n", pcvsi);
    return FALSE;
}

◆ CryptUIWizDigitalSign()

BOOL WINAPI CryptUIWizDigitalSign	(	DWORD	flags,
		HWND	parent,
		LPCWSTR	title,
		PCCRYPTUI_WIZ_DIGITAL_SIGN_INFO	info,
		PCCRYPTUI_WIZ_DIGITAL_SIGN_CONTEXT *	context
	)

Definition at line 7602 of file main.c.

{
    FIXME("%d %p %s %p %p: stub\n", flags, parent, debugstr_w(title), info, context);
    return FALSE;
}

◆ CryptUIWizExport()

BOOL WINAPI CryptUIWizExport	(	DWORD	dwFlags,
		HWND	hwndParent,
		LPCWSTR	pwszWizardTitle,
		PCCRYPTUI_WIZ_EXPORT_INFO	pExportInfo,
		void *	pvoid
	)

Definition at line 6990 of file main.c.

{
    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;
}

Referenced by cert_mgr_do_export(), and detail_dlg_proc().

◆ CryptUIWizImport()

BOOL WINAPI CryptUIWizImport	(	DWORD	dwFlags,
		HWND	hwndParent,
		LPCWSTR	pwszWizardTitle,
		PCCRYPTUI_WIZ_IMPORT_SRC_INFO	pImportSrc,
		HCERTSTORE	hDestCertStore
	)

Definition at line 5559 of file main.c.

{
    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;
}

Referenced by cert_mgr_dlg_proc(), and general_dlg_proc().

◆ detail_callback()

static UINT CALLBACK detail_callback	(	HWND	hwnd,
		UINT	msg,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 3905 of file main.c.

{
    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;
}

Referenced by init_detail_page().

◆ detail_dlg_proc()

static LRESULT CALLBACK detail_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 3798 of file main.c.

{
    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 = ARRAY_SIZE(buf);
                    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 ? lstrlenW(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;
}

Referenced by init_detail_page().

◆ display_app_usages()

static void display_app_usages	(	HWND	text,
		PCCERT_CONTEXT	cert,
		BOOL *	anyUsageAdded
	)

static

Definition at line 2064 of file main.c.

{
    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);
}

Referenced by set_policy_text().

◆ display_cert_usages()

static BOOL display_cert_usages	(	HWND	text,
		PCCERT_CONTEXT	cert,
		BOOL *	anyUsageAdded
	)

static

Definition at line 2116 of file main.c.

{
    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;
}

Referenced by set_policy_text().

◆ DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	lpvReserved
	)

Definition at line 49 of file main.c.

{
    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
 
    switch (fdwReason)
    {
#ifndef __REACTOS__
        case DLL_WINE_PREATTACH:
            return FALSE;    /* prefer native version */
#endif
        case DLL_PROCESS_ATTACH:
            hInstance = hinstDLL;
            DisableThreadLibraryCalls(hinstDLL);
            break;
    }
    return TRUE;
}

◆ do_export()

static BOOL do_export	(	HANDLE	file,
		PCCRYPTUI_WIZ_EXPORT_INFO	pExportInfo,
		PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO	pContextInfo,
		PCRYPT_KEY_PROV_INFO	keyProvInfo,
		BOOL	deleteKeys
	)

static

Definition at line 6694 of file main.c.

{
    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;
}

Referenced by CryptUIWizExport(), and export_finish_dlg_proc().

◆ do_import()

static BOOL do_import	(	DWORD	dwFlags,
		HWND	hwndParent,
		LPCWSTR	pwszWizardTitle,
		PCCRYPTUI_WIZ_IMPORT_SRC_INFO	pImportSrc,
		HCERTSTORE	hDestCertStore
	)

static

Definition at line 5329 of file main.c.

{
    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;
}

Referenced by CryptUIWizImport(), and import_finish_dlg_proc().

◆ enum_store_callback()

static BOOL WINAPI enum_store_callback	(	const void *	pvSystemStore,
		DWORD	dwFlags,
		PCERT_SYSTEM_STORE_INFO	pStoreInfo,
		void *	pvReserved,
		void *	pvArg
	)

static

Definition at line 1385 of file main.c.

{
    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,
             (lstrlenW(pvSystemStore) + 1) * sizeof(WCHAR));
            if (storeInfo->u.name)
            {
                tvis.u.item.mask |= TVIF_PARAM;
                tvis.u.item.lParam = (LPARAM)storeInfo;
                lstrcpyW(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;
}

Referenced by enumerate_stores().

◆ enumerate_stores()

static void enumerate_stores	(	HWND	hwnd,
		CRYPTUI_ENUM_DATA *	pEnumData
	)

static

Definition at line 1431 of file main.c.

{
    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);
            }
        }
    }
}

Referenced by select_store_dlg_proc().

◆ export_acquire_private_key()

static BOOL export_acquire_private_key	(	const CRYPT_KEY_PROV_INFO *	info,
		HCRYPTPROV *	phProv
	)

static

Definition at line 5670 of file main.c.

{
    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;
}

Referenced by export_private_key_dlg_proc().

◆ export_append_extension()

static LPWSTR export_append_extension	(	const struct ExportWizData *	data,
		LPWSTR	fileName
	)

static

Definition at line 6044 of file main.c.

{
    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 = wcsrchr(fileName, '.');
    if (dot)
        appendExtension = wcsicmp(dot, extension) != 0;
    else
        appendExtension = TRUE;
    if (appendExtension)
    {
        fileName = HeapReAlloc(GetProcessHeap(), 0, fileName,
         (lstrlenW(fileName) + lstrlenW(extension) + 1) * sizeof(WCHAR));
        if (fileName)
            lstrcatW(fileName, extension);
    }
    return fileName;
}

Referenced by export_file_dlg_proc().

◆ export_file_dlg_proc()

static LRESULT CALLBACK export_file_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 6247 of file main.c.

{
    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, ARRAY_SIZE(title));
                    pTitle = title;
                }
                LoadStringW(hInstance, IDS_IMPORT_EMPTY_FILE, error, ARRAY_SIZE(error));
                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 = ARRAY_SIZE(fileBuf);
            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;
}

Referenced by show_export_ui().

◆ export_finish_dlg_proc()

static LRESULT CALLBACK export_finish_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 6751 of file main.c.

{
    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, ARRAY_SIZE(title));
                pTitle = title;
            }
            LoadStringW(hInstance, messageID, message, ARRAY_SIZE(message));
            MessageBoxW(hwnd, message, pTitle, mbFlags);
            break;
        }
        }
        break;
    }
    }
    return ret;
}

Referenced by show_export_ui().

◆ export_format_dlg_proc()

static LRESULT CALLBACK export_format_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5835 of file main.c.

{
    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;
}

Referenced by show_export_ui().

◆ export_format_enable_controls()

static void export_format_enable_controls	(	HWND	hwnd,
		const struct ExportWizData *	data
	)

static

Definition at line 5800 of file main.c.

{
    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);
    }
}

Referenced by export_format_dlg_proc().

◆ export_get_private_key_info()

static PCRYPT_KEY_PROV_INFO export_get_private_key_info ( PCCERT_CONTEXT cert )

static

Definition at line 5648 of file main.c.

{
    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;
}

Referenced by export_private_key_dlg_proc(), and save_pfx().

◆ export_info_has_private_key()

static BOOL export_info_has_private_key ( PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo )

static

Definition at line 5782 of file main.c.

{
    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;
}

Referenced by show_export_ui().

◆ export_is_key_exportable()

static BOOL export_is_key_exportable	(	HCRYPTPROV	hProv,
		DWORD	keySpec
	)

static

Definition at line 5688 of file main.c.

{
    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;
}

Referenced by export_private_key_dlg_proc().

◆ export_password_dlg_proc()

static LRESULT CALLBACK export_password_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5958 of file main.c.

{
    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 (lstrcmpW(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;
}

Referenced by show_export_ui().

◆ export_password_mismatch()

static void export_password_mismatch	(	HWND	hwnd,
		const struct ExportWizData *	data
	)

static

Definition at line 5941 of file main.c.

{
    WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
    LPCWSTR pTitle;
 
    if (data->pwszWizardTitle)
        pTitle = data->pwszWizardTitle;
    else
    {
        LoadStringW(hInstance, IDS_EXPORT_WIZARD, title, ARRAY_SIZE(title));
        pTitle = title;
    }
    LoadStringW(hInstance, IDS_EXPORT_PASSWORD_MISMATCH, error, ARRAY_SIZE(error));
    MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
    SetFocus(GetDlgItem(hwnd, IDC_EXPORT_PASSWORD));
}

Referenced by export_password_dlg_proc().

◆ export_private_key_dlg_proc()

static LRESULT CALLBACK export_private_key_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5705 of file main.c.

{
    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, ARRAY_SIZE(error));
            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;
}

Referenced by show_export_ui().

◆ export_validate_filename()

static BOOL export_validate_filename	(	HWND	hwnd,
		struct ExportWizData *	data,
		LPCWSTR	fileName
	)

static

Definition at line 6096 of file main.c.

{
    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, ARRAY_SIZE(title));
            pTitle = title;
        }
        LoadStringW(hInstance, IDS_EXPORT_FILE_EXISTS, warning, ARRAY_SIZE(warning));
        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, ARRAY_SIZE(title));
                pTitle = title;
            }
            LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error, ARRAY_SIZE(error));
            FormatMessageW(
             FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
             GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
            fullError = HeapAlloc(GetProcessHeap(), 0,
             (lstrlenW(error) + lstrlenW(fileName) + lstrlenW(msgBuf) + 3)
             * sizeof(WCHAR));
            if (fullError)
            {
                LPWSTR ptr = fullError;
 
                lstrcpyW(ptr, error);
                ptr += lstrlenW(error);
                lstrcpyW(ptr, fileName);
                ptr += lstrlenW(fileName);
                *ptr++ = ':';
                *ptr++ = '\n';
                lstrcpyW(ptr, msgBuf);
                MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
                HeapFree(GetProcessHeap(), 0, fullError);
            }
            LocalFree(msgBuf);
        }
    }
    return ret;
}

Referenced by export_file_dlg_proc().

◆ export_welcome_dlg_proc()

static LRESULT CALLBACK export_welcome_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5605 of file main.c.

{
    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, ARRAY_SIZE(fontFace));
        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;
}

Referenced by show_export_ui().

◆ field_format_detailed_cert_name()

static WCHAR * field_format_detailed_cert_name ( PCERT_NAME_BLOB name )

static

Definition at line 2637 of file main.c.

{
    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;
}

Referenced by field_format_detailed_issuer(), and field_format_detailed_subject().

◆ field_format_detailed_extension()

static WCHAR * field_format_detailed_extension	(	PCCERT_CONTEXT	cert,
		void *	param
	)

static

Definition at line 2945 of file main.c.

{
    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;
}

Referenced by add_cert_extension_detail().

◆ field_format_detailed_issuer()

static WCHAR * field_format_detailed_issuer	(	PCCERT_CONTEXT	cert,
		void *	param
	)

static

Definition at line 2653 of file main.c.

{
    return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
}

◆ field_format_detailed_public_key()

static WCHAR * field_format_detailed_public_key	(	PCCERT_CONTEXT	cert,
		void *	param
	)

static

Definition at line 2740 of file main.c.

{
    return format_hex_string(
     cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
     cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
}

◆ field_format_detailed_subject()

static WCHAR * field_format_detailed_subject	(	PCCERT_CONTEXT	cert,
		void *	param
	)

static

Definition at line 2663 of file main.c.

{
    return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
}

◆ field_format_extension_hex_with_ascii()

static WCHAR * field_format_extension_hex_with_ascii ( const CERT_EXTENSION * ext )

static

Definition at line 2875 of file main.c.

{
    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)
                    swprintf(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 += ARRAY_SIZE(pad))
                        memcpy(ptr, pad, sizeof(pad));
                }
                /* The last swprintf 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 (iswprint(ext->Value.pbData[j]) &&
                     !iswspace(ext->Value.pbData[j]))
                        *ptr = ext->Value.pbData[j];
                    else
                        *ptr = '.';
                }
                *ptr++ = '\n';
            }
            *ptr++ = '\0';
        }
    }
    return str;
}

Referenced by field_format_detailed_extension().

◆ field_format_from_date()

static WCHAR * field_format_from_date ( PCCERT_CONTEXT cert )

static

Definition at line 2689 of file main.c.

{
    return format_long_date(&cert->pCertInfo->NotBefore);
}

◆ field_format_issuer()

static WCHAR * field_format_issuer ( PCCERT_CONTEXT cert )

static

Definition at line 2631 of file main.c.

{
    return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
     CERT_NAME_ISSUER_FLAG);
}

◆ field_format_public_key()

static WCHAR * field_format_public_key ( PCCERT_CONTEXT cert )

static

Definition at line 2699 of file main.c.

{
    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, ARRAY_SIZE(fmt)))
        {
            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 = lstrlenW(fmt) + lstrlenW(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;
}

◆ field_format_serial_number()

static WCHAR * field_format_serial_number ( PCCERT_CONTEXT cert )

static

Definition at line 2625 of file main.c.

{
    return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
     cert->pCertInfo->SerialNumber.cbData);
}

◆ field_format_subject()

static WCHAR * field_format_subject ( PCCERT_CONTEXT cert )

static

Definition at line 2658 of file main.c.

{
    return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
}

◆ field_format_to_date()

static WCHAR * field_format_to_date ( PCCERT_CONTEXT cert )

static

Definition at line 2694 of file main.c.

{
    return format_long_date(&cert->pCertInfo->NotAfter);
}

◆ field_format_version()

static WCHAR * field_format_version ( PCCERT_CONTEXT cert )

static

Definition at line 2599 of file main.c.

{
    static const WCHAR fmt[] = { 'V','%','d',0 };
    WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
 
    if (buf)
        swprintf(buf, fmt, cert->pCertInfo->dwVersion);
    return buf;
}

◆ find_oid_in_list()

static LONG_PTR find_oid_in_list	(	HWND	lv,
		LPCSTR	oid
	)

static

Definition at line 639 of file main.c.

{
    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;
}

Referenced by cert_mgr_advanced_dlg_proc(), and is_oid_in_list().

◆ find_policy_qualifier()

static CRYPT_OBJID_BLOB * find_policy_qualifier	(	CERT_POLICIES_INFO *	policies,
		LPCSTR	policyOid
	)

static

Definition at line 2212 of file main.c.

{
    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;
}

Referenced by set_issuer_statement().

◆ findSupportedOID()

static struct OIDToString * findSupportedOID ( LPCSTR oid )

static

Definition at line 1976 of file main.c.

{
    int indexHigh = ARRAY_SIZE(oidMap) - 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;
}

Referenced by add_local_oid_text_to_control().

◆ format_enhanced_key_usage_value()

static WCHAR * format_enhanced_key_usage_value	(	void *	pb,
		DWORD	cb
	)

static

Definition at line 3015 of file main.c.

{
    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);
}

◆ format_hex_string()

static WCHAR * format_hex_string	(	void *	pb,
		DWORD	cb
	)

static

Definition at line 2609 of file main.c.

{
    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)
            swprintf(ptr, fmt, ((BYTE *)pb)[i]);
    }
    return buf;
}

Referenced by field_format_detailed_public_key(), and field_format_serial_number().

◆ format_long_date()

static WCHAR * format_long_date ( const FILETIME * fileTime )

static

Definition at line 2668 of file main.c.

{
    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, ARRAY_SIZE(dateFmt));
    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;
}

Referenced by field_format_from_date(), and field_format_to_date().

◆ free_certs()

static void free_certs ( HWND lv )

static

Definition at line 533 of file main.c.

{
    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);
    }
}

Referenced by cert_mgr_dlg_proc(), refresh_store_certs(), and select_cert_dlg_proc().

◆ free_detail_fields()

static void free_detail_fields ( struct detail_data * data )

static

Definition at line 3774 of file main.c.

{
    int 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;
}

Referenced by detail_callback(), and refresh_details_view().

◆ free_prop_sheet_pages()

static void free_prop_sheet_pages	(	PROPSHEETPAGEW *	pages,
		DWORD	num
	)

static

Definition at line 7461 of file main.c.

{
    DWORD i;
 
    for (i = 0; i < num; i++)
    {
        if (!(pages[i].dwFlags & PSP_DLGINDIRECT) && !IS_INTRESOURCE(pages[i].u.pszTemplate))
            HeapFree(GetProcessHeap(), 0, (void *)pages[i].u.pszTemplate);
        if ((pages[i].dwFlags & PSP_USEICONID) && !IS_INTRESOURCE(pages[i].u2.pszIcon))
            HeapFree(GetProcessHeap(), 0, (void *)pages[i].u2.pszIcon);
        if ((pages[i].dwFlags & PSP_USETITLE) && !IS_INTRESOURCE(pages[i].pszTitle))
            HeapFree(GetProcessHeap(), 0, (void *)pages[i].pszTitle);
        if ((pages[i].dwFlags & PSP_USEHEADERTITLE) && !IS_INTRESOURCE(pages[i].pszHeaderTitle))
            HeapFree(GetProcessHeap(), 0, (void *)pages[i].pszHeaderTitle);
        if ((pages[i].dwFlags & PSP_USEHEADERSUBTITLE) &&
         !IS_INTRESOURCE(pages[i].pszHeaderSubTitle))
            HeapFree(GetProcessHeap(), 0, (void *)pages[i].pszHeaderSubTitle);
    }
    HeapFree(GetProcessHeap(), 0, pages);
}

Referenced by CryptUIDlgSelectCertificateA(), and prop_sheet_pages_AtoW().

◆ free_store_info()

static void free_store_info ( HWND tree )

static

Definition at line 1477 of file main.c.

{
    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);
    }
}

Referenced by select_store_dlg_proc().

◆ general_callback_proc()

static UINT CALLBACK general_callback_proc	(	HWND	hwnd,
		UINT	msg,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 2563 of file main.c.

{
    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;
}

Referenced by init_general_page().

◆ general_dlg_proc()

static LRESULT CALLBACK general_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 2512 of file main.c.

{
    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;
}

Referenced by init_general_page().

◆ get_cert_display_name()

static WCHAR * get_cert_display_name ( PCCERT_CONTEXT cert )

static

Definition at line 4009 of file main.c.

{
    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;
}

Referenced by show_cert_chain().

◆ get_cert_mgr_usages()

static LPSTR get_cert_mgr_usages ( void )

static

Definition at line 181 of file main.c.

{
    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;
}

Referenced by cert_mgr_advanced_dlg_proc(), create_advanced_filter(), and initialize_purpose_selection().

◆ get_cert_name_string()

static LPWSTR get_cert_name_string	(	PCCERT_CONTEXT	pCertContext,
		DWORD	dwType,
		DWORD	dwFlags
	)

static

Definition at line 1778 of file main.c.

{
    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;
}

Referenced by add_cert_string_to_control(), field_format_issuer(), field_format_subject(), and get_cert_display_name().

◆ get_cert_property_as_string()

static WCHAR * get_cert_property_as_string	(	PCCERT_CONTEXT	cert,
		DWORD	prop
	)

static

Definition at line 3309 of file main.c.

{
    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;
}

Referenced by get_cert_display_name(), and set_general_cert_properties().

◆ get_cert_usages()

static void get_cert_usages	(	PCCERT_CONTEXT	cert,
		LPWSTR *	str
	)

static

Definition at line 852 of file main.c.

{
    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 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 += lstrlenW(info->pwszName);
                else
                    len += strlen(usage->rgpszUsageIdentifier[i]);
                if (i < usage->cUsageIdentifier - 1)
                    len += lstrlenW(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)
                    {
                        lstrcpyW(ptr, info->pwszName);
                        ptr += lstrlenW(info->pwszName);
                    }
                    else
                    {
                        LPCSTR src = usage->rgpszUsageIdentifier[i];
 
                        for (; *src; ptr++, src++)
                            *ptr = *src;
                        *ptr = 0;
                    }
                    if (i < usage->cUsageIdentifier - 1)
                    {
                        lstrcpyW(ptr, commaSpace);
                        ptr += lstrlenW(commaSpace);
                    }
                }
                *ptr = 0;
            }
            HeapFree(GetProcessHeap(), 0, usage);
        }
        else
        {
            size = MAX_STRING_LEN * sizeof(WCHAR);
            *str = HeapAlloc(GetProcessHeap(), 0, size);
            if (*str)
                LoadStringW(hInstance, IDS_ALLOWED_PURPOSE_NONE, *str, size);
        }
    }
    else
    {
        size = MAX_STRING_LEN * sizeof(WCHAR);
        *str = HeapAlloc(GetProcessHeap(), 0, size);
        if (*str)
            LoadStringW(hInstance, IDS_ALLOWED_PURPOSE_ALL, *str, size);
    }
}

Referenced by add_cert_to_list(), and cert_mgr_show_cert_usages().

◆ get_cps_str_from_qualifier()

static WCHAR * get_cps_str_from_qualifier ( const CRYPT_OBJID_BLOB * qualifier )

static

Definition at line 2231 of file main.c.

{
    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;
}

Referenced by set_issuer_statement().

◆ get_hierarchy_data_from_tree_item()

static struct hierarchy_data * get_hierarchy_data_from_tree_item	(	HWND	tree,
		HTREEITEM	hItem
	)

static

Definition at line 3983 of file main.c.

{
    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;
}

Referenced by hierarchy_dlg_proc(), and show_dialog_for_selected_cert().

◆ get_user_notice_from_qualifier()

static WCHAR * get_user_notice_from_qualifier ( const CRYPT_OBJID_BLOB * qualifier )

static

Definition at line 2252 of file main.c.

{
    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,
         (lstrlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
        if (str)
            lstrcpyW(str, qualifierValue->pszDisplayText);
        LocalFree(qualifierValue);
    }
    return str;
}

Referenced by set_issuer_statement().

◆ hierarchy_callback()

static UINT CALLBACK hierarchy_callback	(	HWND	hwnd,
		UINT	msg,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 4231 of file main.c.

{
    struct hierarchy_data *data;
 
    switch (msg)
    {
    case PSPCB_RELEASE:
        data = (struct hierarchy_data *)page->lParam;
#ifndef __REACTOS__
        ImageList_Destroy(data->imageList);
#endif
        HeapFree(GetProcessHeap(), 0, data);
        break;
    }
    return 0;
}

Referenced by init_hierarchy_page().

◆ hierarchy_dlg_proc()

static LRESULT CALLBACK hierarchy_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 4153 of file main.c.

{
    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;
}

Referenced by init_hierarchy_page().

◆ import_cert()

static BOOL import_cert	(	PCCERT_CONTEXT	cert,
		HCERTSTORE	hDestCertStore
	)

static

Definition at line 4574 of file main.c.

{
    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;
}

Referenced by do_import(), and import_store().

◆ import_crl()

static BOOL import_crl	(	PCCRL_CONTEXT	crl,
		HCERTSTORE	hDestCertStore
	)

static

Definition at line 4599 of file main.c.

{
    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;
}

Referenced by do_import(), and import_store().

◆ import_ctl()

static BOOL import_ctl	(	PCCTL_CONTEXT	ctl,
		HCERTSTORE	hDestCertStore
	)

static

Definition at line 4625 of file main.c.

{
    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;
}

Referenced by do_import(), and import_store().

◆ import_file()

static BOOL import_file	(	DWORD	dwFlags,
		HWND	hwnd,
		LPCWSTR	szTitle,
		LPCWSTR	fileName,
		HCERTSTORE	dest
	)

static

Definition at line 4840 of file main.c.

{
    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;
}

Referenced by do_import().

◆ import_file_dlg_proc()

static LRESULT CALLBACK import_file_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5052 of file main.c.

{
    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 = ARRAY_SIZE(fileBuf);
#ifdef __REACTOS__
            ofn.Flags = OFN_EXPLORER;
#endif
            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;
}

Referenced by show_import_ui().

◆ import_finish_dlg_proc()

static LRESULT CALLBACK import_finish_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5370 of file main.c.

{
    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, ARRAY_SIZE(title));
                    pTitle = title;
                }
                LoadStringW(hInstance, IDS_IMPORT_SUCCEEDED, message, ARRAY_SIZE(message));
                MessageBoxW(hwnd, message, pTitle, MB_OK);
            }
            else
                import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
                 IDS_IMPORT_FAILED);
            break;
        }
        }
        break;
    }
    }
    return ret;
}

Referenced by show_import_ui().

◆ import_store()

static BOOL import_store	(	DWORD	dwFlags,
		HWND	hwnd,
		LPCWSTR	szTitle,
		HCERTSTORE	source,
		HCERTSTORE	dest
	)

static

Definition at line 4761 of file main.c.

{
    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;
}

Referenced by do_import(), and import_file().

◆ import_store_dlg_proc()

static LRESULT CALLBACK import_store_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 5153 of file main.c.

{
    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, ARRAY_SIZE(storeTitle));
            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,
                 ARRAY_SIZE(storeTitle));
                SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_STORE), WM_SETTEXT,
                 0, (LPARAM)storeTitle);
                data->hDestCertStore = store;
                data->freeDest = TRUE;
            }
            break;
        }
        }
        break;
    }
    return ret;
}

Referenced by show_import_ui().

◆ import_validate_filename()

static BOOL import_validate_filename	(	HWND	hwnd,
		struct ImportWizData *	data,
		LPCWSTR	fileName
	)

static

Definition at line 4980 of file main.c.

{
    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, ARRAY_SIZE(title));
            pTitle = title;
        }
        LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error, ARRAY_SIZE(error));
        FormatMessageW(
         FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
         GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
        fullError = HeapAlloc(GetProcessHeap(), 0,
         (lstrlenW(error) + lstrlenW(fileName) + lstrlenW(msgBuf) + 3)
         * sizeof(WCHAR));
        if (fullError)
        {
            LPWSTR ptr = fullError;
 
            lstrcpyW(ptr, error);
            ptr += lstrlenW(error);
            lstrcpyW(ptr, fileName);
            ptr += lstrlenW(fileName);
            *ptr++ = ':';
            *ptr++ = '\n';
            lstrcpyW(ptr, msgBuf);
            MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
            HeapFree(GetProcessHeap(), 0, fullError);
        }
        LocalFree(msgBuf);
    }
    return ret;
}

Referenced by import_file_dlg_proc().

◆ import_warn_type_mismatch()

static void import_warn_type_mismatch	(	DWORD	dwFlags,
		HWND	hwnd,
		LPCWSTR	szTitle
	)

static

Definition at line 4717 of file main.c.

{
    import_warning(dwFlags, hwnd, szTitle, IDS_IMPORT_TYPE_MISMATCH);
}

Referenced by do_import(), and import_store().

◆ import_warning()

static void import_warning	(	DWORD	dwFlags,
		HWND	hwnd,
		LPCWSTR	szTitle,
		int	warningID
	)

static

Definition at line 4697 of file main.c.

{
    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, ARRAY_SIZE(title));
            pTitle = title;
        }
        LoadStringW(hInstance, warningID, error, ARRAY_SIZE(error));
        MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
    }
}

Referenced by import_file_dlg_proc(), import_finish_dlg_proc(), import_store_dlg_proc(), import_validate_filename(), and import_warn_type_mismatch().

◆ import_welcome_dlg_proc()

static LRESULT CALLBACK import_welcome_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 4871 of file main.c.

{
    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, ARRAY_SIZE(fontFace));
        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;
}

Referenced by show_import_ui().

◆ index_to_lparam()

static LPARAM index_to_lparam	(	struct hierarchy_data *	data,
		DWORD	index
	)

static

Definition at line 3956 of file main.c.

{
    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;
}

Referenced by show_cert_chain().

◆ init_columns()

static void init_columns	(	HWND	lv,
		DWORD	flags
	)

static

Definition at line 7024 of file main.c.

{
    WCHAR buf[MAX_STRING_LEN];
    LVCOLUMNW column;
    DWORD i = 0;
 
    SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
    column.mask = LVCF_WIDTH | LVCF_TEXT;
    column.cx = 90;
    column.pszText = buf;
    if (!(flags & CRYPTUI_SELECT_ISSUEDTO_COLUMN))
    {
        LoadStringW(hInstance, IDS_SUBJECT_COLUMN, buf, ARRAY_SIZE(buf));
        SendMessageW(lv, LVM_INSERTCOLUMNW, i++, (LPARAM)&column);
    }
    if (!(flags & CRYPTUI_SELECT_ISSUEDBY_COLUMN))
    {
        LoadStringW(hInstance, IDS_ISSUER_COLUMN, buf, ARRAY_SIZE(buf));
        SendMessageW(lv, LVM_INSERTCOLUMNW, i++, (LPARAM)&column);
    }
    if (!(flags & CRYPTUI_SELECT_INTENDEDUSE_COLUMN))
    {
        LoadStringW(hInstance, IDS_INTENDED_USE_COLUMN, buf, ARRAY_SIZE(buf));
        SendMessageW(lv, LVM_INSERTCOLUMNW, i++, (LPARAM)&column);
    }
    if (!(flags & CRYPTUI_SELECT_FRIENDLYNAME_COLUMN))
    {
        LoadStringW(hInstance, IDS_FRIENDLY_NAME_COLUMN, buf, ARRAY_SIZE(buf));
        SendMessageW(lv, LVM_INSERTCOLUMNW, i++, (LPARAM)&column);
    }
    if (!(flags & CRYPTUI_SELECT_EXPIRATION_COLUMN))
    {
        LoadStringW(hInstance, IDS_EXPIRATION_COLUMN, buf, ARRAY_SIZE(buf));
        SendMessageW(lv, LVM_INSERTCOLUMNW, i++, (LPARAM)&column);
    }
    if (!(flags & CRYPTUI_SELECT_LOCATION_COLUMN))
    {
        LoadStringW(hInstance, IDS_LOCATION_COLUMN, buf, ARRAY_SIZE(buf));
        SendMessageW(lv, LVM_INSERTCOLUMNW, i++, (LPARAM)&column);
    }
}

Referenced by select_cert_dlg_proc().

◆ init_detail_page()

static BOOL init_detail_page	(	PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo,
		BOOL *	pfPropertiesChanged,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 3921 of file main.c.

{
    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;
}

Referenced by show_cert_dialog().

◆ init_general_page()

static void init_general_page	(	PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 2584 of file main.c.

{
    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;
}

Referenced by show_cert_dialog().

◆ init_hierarchy_page()

static BOOL init_hierarchy_page	(	PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo,
		PROPSHEETPAGEW *	page
	)

static

Definition at line 4249 of file main.c.

{
    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;
}

Referenced by show_cert_dialog().

◆ initialize_purpose_selection()

static void initialize_purpose_selection ( HWND hwnd )

static

Definition at line 222 of file main.c.

{
    HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
    WCHAR buf[MAX_STRING_LEN];
    LPSTR usages;
    int index;
 
    LoadStringW(hInstance, IDS_PURPOSE_ALL, buf, ARRAY_SIZE(buf));
    index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
    SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)PurposeFilterShowAll);
    LoadStringW(hInstance, IDS_PURPOSE_ADVANCED, buf, ARRAY_SIZE(buf));
    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);
    }
}

Referenced by cert_mgr_dlg_proc().

◆ is_ca_cert()

static BOOL is_ca_cert	(	PCCERT_CONTEXT	cert,
		BOOL	defaultIfNotSpecified
	)

static

Definition at line 4524 of file main.c.

{
    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;
}

Referenced by choose_store_for_cert().

◆ is_oid_in_list()

static BOOL is_oid_in_list	(	HWND	hwnd,
		LPCSTR	oid
	)

static

Definition at line 3221 of file main.c.

{
    return find_oid_in_list(GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES), oid)
     != -1;
}

Referenced by add_purpose_dlg_proc().

◆ is_valid_oid()

static BOOL is_valid_oid ( LPCSTR oid )

static

Definition at line 3183 of file main.c.

{
    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;
}

Referenced by add_purpose_dlg_proc().

◆ lparam_to_index()

static DWORD lparam_to_index	(	struct hierarchy_data *	data,
		LPARAM	lp
	)

inlinestatic

Definition at line 3971 of file main.c.

{
    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;
}

Referenced by hierarchy_dlg_proc(), and show_dialog_for_selected_cert().

◆ make_export_file_filter()

static WCHAR * make_export_file_filter	(	DWORD	exportFormat,
		DWORD	subjectChoice
	)

static

Definition at line 6181 of file main.c.

{
    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 + lstrlenW(filterStr) + 2;
    allLen = LoadStringW(hInstance, IDS_IMPORT_FILTER_ALL, (LPWSTR)&all, 0);
    totalLen += allLen + lstrlenW(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;
        lstrcpyW(ptr, filterStr);
        ptr += lstrlenW(filterStr) + 1;
        memcpy(ptr, all, allLen * sizeof(WCHAR));
        ptr += allLen;
        *ptr++ = 0;
        lstrcpyW(ptr, filter_all);
        ptr += lstrlenW(filter_all) + 1;
        *ptr++ = 0;
    }
    return filter;
}

Referenced by export_file_dlg_proc().

◆ make_import_file_filter()

static WCHAR * make_import_file_filter ( DWORD dwFlags )

static

Definition at line 4940 of file main.c.

{
    DWORD i;
    int len, totalLen = 2;
    LPWSTR filter = NULL, str;
 
    for (i = 0; i < ARRAY_SIZE(import_filters); i++)
    {
        if (!import_filters[i].allowFlags || !dwFlags ||
         (dwFlags & import_filters[i].allowFlags))
        {
            len = LoadStringW(hInstance, import_filters[i].id, (LPWSTR)&str, 0);
            totalLen += len + lstrlenW(import_filters[i].filter) + 2;
        }
    }
    filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
    if (filter)
    {
        LPWSTR ptr;
 
        ptr = filter;
        for (i = 0; i < ARRAY_SIZE(import_filters); 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;
                lstrcpyW(ptr, import_filters[i].filter);
                ptr += lstrlenW(import_filters[i].filter) + 1;
            }
        }
        *ptr++ = 0;
    }
    return filter;
}

Referenced by import_file_dlg_proc().

◆ open_store_from_file()

static HCERTSTORE open_store_from_file	(	DWORD	dwFlags,
		LPCWSTR	fileName,
		DWORD *	pContentType
	)

static

Definition at line 4793 of file main.c.

{
    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;
}

Referenced by import_file(), and import_validate_filename().

◆ prop_sheet_pages_AtoW()

static PROPSHEETPAGEW * prop_sheet_pages_AtoW	(	LPCPROPSHEETPAGEA	pages,
		DWORD	num
	)

static

Definition at line 7482 of file main.c.

{
    PROPSHEETPAGEW *psp;
    DWORD i, size = sizeof(*psp) * num;
 
    psp = HeapAlloc(GetProcessHeap(), 0, size);
    if (!psp)
        return NULL;
    memcpy(psp, pages, size);
    for (i = 0; i < num; i++)
    {
        if (!(pages[i].dwFlags & PSP_DLGINDIRECT) && !IS_INTRESOURCE(pages[i].u.pszTemplate))
            psp[i].u.pszTemplate = NULL;
        if ((pages[i].dwFlags & PSP_USEICONID) && !IS_INTRESOURCE(pages[i].u2.pszIcon))
            psp[i].u2.pszIcon = NULL;
        if ((pages[i].dwFlags & PSP_USETITLE) && !IS_INTRESOURCE(pages[i].pszTitle))
            psp[i].pszTitle = NULL;
        if (pages[i].dwFlags & PSP_USECALLBACK)
            psp[i].pfnCallback = NULL;
        if ((pages[i].dwFlags & PSP_USEHEADERTITLE) && !IS_INTRESOURCE(pages[i].pszHeaderTitle))
            psp[i].pszHeaderTitle = NULL;
        if ((pages[i].dwFlags & PSP_USEHEADERSUBTITLE) &&
         !IS_INTRESOURCE(pages[i].pszHeaderSubTitle))
            psp[i].pszHeaderSubTitle = NULL;
    }
    for (i = 0; i < num; i++)
    {
        if (!(pages[i].dwFlags & PSP_DLGINDIRECT) && !IS_INTRESOURCE(pages[i].u.pszTemplate))
        {
            if (!(psp[i].u.pszTemplate = strdupAtoW( pages[i].u.pszTemplate ))) goto error;
        }
        if ((pages[i].dwFlags & PSP_USEICONID) && !IS_INTRESOURCE(pages[i].u2.pszIcon))
        {
            if (!(psp[i].u2.pszIcon = strdupAtoW( pages[i].u2.pszIcon ))) goto error;
        }
        if ((pages[i].dwFlags & PSP_USETITLE) && !IS_INTRESOURCE(pages[i].pszTitle))
        {
            if (!(psp[i].pszTitle = strdupAtoW( pages[i].pszTitle ))) goto error;
        }
        if (pages[i].dwFlags & PSP_USECALLBACK)
            FIXME("ignoring pfnCallback\n");
        if ((pages[i].dwFlags & PSP_USEHEADERTITLE) && !IS_INTRESOURCE(pages[i].pszHeaderTitle))
        {
            if (!(psp[i].pszHeaderTitle = strdupAtoW( pages[i].pszHeaderTitle ))) goto error;
        }
        if ((pages[i].dwFlags & PSP_USEHEADERSUBTITLE) &&
         !IS_INTRESOURCE(pages[i].pszHeaderSubTitle))
        {
            if (!(psp[i].pszHeaderSubTitle = strdupAtoW( pages[i].pszHeaderSubTitle ))) goto error;
        }
    }
    return psp;
error:
    free_prop_sheet_pages(psp, num);
    return NULL;
}

Referenced by CryptUIDlgSelectCertificateA().

◆ read_text_callback()

static DWORD CALLBACK read_text_callback	(	DWORD_PTR	dwCookie,
		LPBYTE	buf,
		LONG	cb,
		LONG *	pcb
	)

static

Definition at line 1721 of file main.c.

{
    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;
}

Referenced by add_unformatted_text_to_control().

◆ redraw_states()

static void redraw_states	(	HWND	list,
		BOOL	enabled
	)

static

Definition at line 3329 of file main.c.

{
    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);
        }
    }
}

Referenced by select_purposes().

◆ refresh_details_view()

static void refresh_details_view ( HWND hwnd )

static

Definition at line 3785 of file main.c.

{
    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);
}

Referenced by detail_dlg_proc().

◆ refresh_propsheet_pages()

static BOOL CALLBACK refresh_propsheet_pages	(	HWND	hwnd,
		LPARAM	lParam
	)

static

Definition at line 3528 of file main.c.

{
    if ((GetClassLongW(hwnd, GCW_ATOM) == WC_DIALOG))
        SendMessageW(hwnd, WM_REFRESH_VIEW, 0, 0);
    return TRUE;
}

Referenced by apply_general_changes().

◆ refresh_store_certs()

static void refresh_store_certs ( HWND hwnd )

static

Definition at line 572 of file main.c.

{
    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));
}

Referenced by cert_mgr_clear_cert_selection(), and cert_mgr_dlg_proc().

◆ save_base64()

static BOOL save_base64	(	HANDLE	file,
		const BYTE *	pb,
		DWORD	cb
	)

static

Definition at line 6458 of file main.c.

{
    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;
}

Referenced by do_export().

◆ save_cert_as_cms()

static BOOL save_cert_as_cms	(	HANDLE	file,
		PCCRYPTUI_WIZ_EXPORT_INFO	pExportInfo,
		BOOL	includeChain
	)

static

Definition at line 6489 of file main.c.

{
    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;
}

Referenced by do_export().

◆ save_cert_mgr_usages()

static void save_cert_mgr_usages ( HWND hwnd )

static

Definition at line 664 of file main.c.

{
    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);
}

Referenced by cert_mgr_advanced_dlg_proc().

◆ save_der()

static BOOL save_der	(	HANDLE	file,
		const BYTE *	pb,
		DWORD	cb
	)

inlinestatic

Definition at line 6451 of file main.c.

{
    DWORD bytesWritten;
 
    return WriteFile(file, pb, cb, &bytesWritten, NULL);
}

Referenced by do_export().

◆ save_pfx()

static BOOL save_pfx	(	HANDLE	file,
		PCCRYPTUI_WIZ_EXPORT_INFO	pExportInfo,
		PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO	pContextInfo,
		PCRYPT_KEY_PROV_INFO	keyProvInfo,
		BOOL	deleteKeys
	)

static

Definition at line 6563 of file main.c.

{
    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;
}

Referenced by do_export().

◆ save_serialized_store()

static BOOL save_serialized_store	(	HANDLE	file,
		HCERTSTORE	store
	)

static

Definition at line 6557 of file main.c.

{
    return CertSaveStore(store, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
     CERT_STORE_SAVE_AS_STORE, CERT_STORE_SAVE_TO_FILE, file, 0);
}

Referenced by do_export().

◆ save_store_as_cms()

static BOOL save_store_as_cms	(	HANDLE	file,
		HCERTSTORE	store
	)

inlinestatic

Definition at line 6483 of file main.c.

{
    return CertSaveStore(store, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
     CERT_STORE_SAVE_AS_PKCS7, CERT_STORE_SAVE_TO_FILE, file, 0);
}

Referenced by do_export(), and save_cert_as_cms().

◆ select_cert_dlg_proc()

static LRESULT CALLBACK select_cert_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 7288 of file main.c.

{
    struct SelectCertData *data;
 
    switch (msg)
    {
    case WM_INITDIALOG:
    {
        struct SelectCertParam *param = (struct SelectCertParam *)lp;
        PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc = param->pcsc;
        HWND lv = GetDlgItem(hwnd, IDC_SELECT_CERTS);
        DWORD i = 0;
 
        data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
        if (!data)
            return 0;
        data->cert = &param->cert;
        data->dateColumn = 4 -
         ((pcsc->dwDontUseColumn & CRYPTUI_SELECT_ISSUEDTO_COLUMN) ? 1 : 0) -
         ((pcsc->dwDontUseColumn & CRYPTUI_SELECT_ISSUEDBY_COLUMN) ? 1 : 0) -
         ((pcsc->dwDontUseColumn & CRYPTUI_SELECT_INTENDEDUSE_COLUMN) ? 1 : 0) -
         ((pcsc->dwDontUseColumn & CRYPTUI_SELECT_FRIENDLYNAME_COLUMN) ? 1 : 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_SELECT_CERTS), LVM_SETIMAGELIST, LVSIL_SMALL,
             (LPARAM)data->imageList);
        }
        data->title = pcsc->szTitle;
        data->cStores = pcsc->cStores;
        data->rghStores = pcsc->rghStores;
        data->cPropSheetPages = pcsc->cPropSheetPages;
        data->rgPropSheetPages = pcsc->rgPropSheetPages;
        data->displayProc = pcsc->pDisplayCallback;
        data->callbackData = pcsc->pvCallbackData;
        SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
 
        if (pcsc->szTitle)
            SendMessageW(hwnd, WM_SETTEXT, 0, (LPARAM)pcsc->szTitle);
        if (pcsc->szDisplayString)
            SendMessageW(GetDlgItem(hwnd, IDC_SELECT_DISPLAY_STRING), WM_SETTEXT, 0,
             (LPARAM)pcsc->szDisplayString);
        init_columns(lv, pcsc->dwDontUseColumn);
        while (i < pcsc->cDisplayStores)
            add_store_certs(lv, pcsc->rghDisplayStores[i++], pcsc->dwDontUseColumn,
             pcsc->pFilterCallback, pcsc->pvCallbackData);
        select_cert_update_view_button(hwnd);
        break;
    }
#ifdef __REACTOS__
    case WM_DESTROY:
        free_certs(GetDlgItem(hwnd, IDC_SELECT_CERTS));
        data = (struct SelectCertData *)GetWindowLongPtrW(hwnd, DWLP_USER);
        HeapFree(GetProcessHeap(), 0, data);
        break;
#endif
    case WM_NOTIFY:
    {
        NMHDR *hdr = (NMHDR *)lp;
 
        switch (hdr->code)
        {
        case NM_DBLCLK:
        {
            PCCERT_CONTEXT cert = select_cert_get_selected(hwnd, ((NMITEMACTIVATE *)lp)->iItem);
 
            data = (struct SelectCertData *)GetWindowLongPtrW(hwnd, DWLP_USER);
            if (cert)
                select_cert_view(hwnd, cert, data);
            break;
        }
        case LVN_COLUMNCLICK:
        {
            NMLISTVIEW *nmlv = (NMLISTVIEW *)lp;
            HWND lv = GetDlgItem(hwnd, IDC_SELECT_CERTS);
 
            /* FIXME: doesn't support swapping sort order between ascending and descending. */
            data = (struct SelectCertData *)GetWindowLongPtrW(hwnd, DWLP_USER);
            if (nmlv->iSubItem == data->dateColumn)
                SendMessageW(lv, LVM_SORTITEMS, 0, (LPARAM)cert_mgr_sort_by_date);
            else
            {
                struct SortData sortData;
 
                sortData.hwnd = lv;
                sortData.column = nmlv->iSubItem;
                SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)&sortData,
                 (LPARAM)select_cert_sort_by_text);
            }
            break;
        }
        }
        break;
    }
    case WM_COMMAND:
        switch (wp)
        {
        case IDOK:
        {
            PCCERT_CONTEXT cert = select_cert_get_selected(hwnd, -1);
 
            data = (struct SelectCertData *)GetWindowLongPtrW(hwnd, DWLP_USER);
            if (!cert)
            {
                WCHAR buf[40], title[40];
 
                LoadStringW(hInstance, IDS_SELECT_CERT, buf, ARRAY_SIZE(buf));
                if (!data->title)
                    LoadStringW(hInstance, IDS_SELECT_CERT_TITLE, title, ARRAY_SIZE(title));
                MessageBoxW(hwnd, buf, data->title ? data->title : title, MB_OK | MB_ICONWARNING);
                break;
            }
            *data->cert = CertDuplicateCertificateContext(cert);
#ifndef __REACTOS__
            free_certs(GetDlgItem(hwnd, IDC_SELECT_CERTS));
            ImageList_Destroy(data->imageList);
            HeapFree(GetProcessHeap(), 0, data);
#endif
            EndDialog(hwnd, IDOK);
            break;
        }
        case IDCANCEL:
#ifndef __REACTOS__
            data = (struct SelectCertData *)GetWindowLongPtrW(hwnd, DWLP_USER);
            free_certs(GetDlgItem(hwnd, IDC_SELECT_CERTS));
            ImageList_Destroy(data->imageList);
            HeapFree(GetProcessHeap(), 0, data);
#endif
            EndDialog(hwnd, IDCANCEL);
            break;
        case IDC_SELECT_VIEW_CERT:
        {
            PCCERT_CONTEXT cert = select_cert_get_selected(hwnd, -1);
 
            data = (struct SelectCertData *)GetWindowLongPtrW(hwnd, DWLP_USER);
            if (cert)
                select_cert_view(hwnd, cert, data);
            break;
        }
        }
        break;
    }
    return 0;
}

Referenced by CryptUIDlgSelectCertificateW().

◆ select_cert_get_selected()

static PCCERT_CONTEXT select_cert_get_selected	(	HWND	hwnd,
		int	selection
	)

static

Definition at line 7212 of file main.c.

{
    HWND lv = GetDlgItem(hwnd, IDC_SELECT_CERTS);
    PCCERT_CONTEXT cert = NULL;
    LVITEMW item;
 
    if (selection < 0)
        selection = SendMessageW(lv, LVM_GETNEXTITEM, -1, LVNI_SELECTED);
    if (selection < 0)
        return NULL;
    item.mask = LVIF_PARAM;
    item.iItem = selection;
    item.iSubItem = 0;
    if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
        cert = (PCCERT_CONTEXT)item.lParam;
    return cert;
}

Referenced by select_cert_dlg_proc().

◆ select_cert_sort_by_text()

static int CALLBACK select_cert_sort_by_text	(	LPARAM	lp1,
		LPARAM	lp2,
		LPARAM	lp
	)

static

Definition at line 7276 of file main.c.

{
    struct SortData *data = (struct SortData *)lp;
    return cert_mgr_sort_by_text(data->hwnd, data->column, lp1, lp2);
}

Referenced by select_cert_dlg_proc().

◆ select_cert_update_view_button()

static void select_cert_update_view_button ( HWND hwnd )

static

Definition at line 7230 of file main.c.

{
    HWND lv = GetDlgItem(hwnd, IDC_SELECT_CERTS);
    int numSelected = SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0);
 
    EnableWindow(GetDlgItem(hwnd, IDC_SELECT_VIEW_CERT), numSelected == 1);
}

Referenced by select_cert_dlg_proc().

◆ select_cert_view()

static void select_cert_view	(	HWND	hwnd,
		PCCERT_CONTEXT	cert,
		struct SelectCertData *	data
	)

static

Definition at line 7252 of file main.c.

{
    CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
 
    if (data->displayProc && data->displayProc(cert, hwnd, data->callbackData))
        return;
    memset(&viewInfo, 0, sizeof(viewInfo));
    viewInfo.dwSize = sizeof(viewInfo);
    viewInfo.hwndParent = hwnd;
    viewInfo.pCertContext = cert;
    viewInfo.cStores = data->cStores;
    viewInfo.rghStores = data->rghStores;
    viewInfo.cPropSheetPages = data->cPropSheetPages;
    viewInfo.rgPropSheetPages = data->rgPropSheetPages;
    /* FIXME: this should be modal */
    CryptUIDlgViewCertificateW(&viewInfo, NULL);
}

Referenced by select_cert_dlg_proc().

◆ select_purposes()

static void select_purposes	(	HWND	hwnd,
		PurposeSelection	selection
	)

static

Definition at line 3386 of file main.c.

{
    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);
    }
}

Referenced by cert_properties_general_dlg_proc(), and show_cert_usages().

◆ select_store_dlg_proc()

static LRESULT CALLBACK select_store_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 1538 of file main.c.

{
    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, ARRAY_SIZE(title));
                    pTitle = title;
                }
                LoadStringW(hInstance, IDS_SELECT_STORE, error, ARRAY_SIZE(error));
                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;
}

Referenced by CryptUIDlgSelectStoreW().

◆ selected_item_to_store()

static HCERTSTORE selected_item_to_store	(	HWND	tree,
		HTREEITEM	hItem
	)

static

Definition at line 1503 of file main.c.

{
    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 = ARRAY_SIZE(buf);
    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;
}

Referenced by select_store_dlg_proc().

◆ set_cert_info()

static void set_cert_info	(	HWND	hwnd,
		PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo
	)

static

Definition at line 2323 of file main.c.

{
    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);
    }
}

Referenced by set_general_info().

◆ set_cert_name_string()

static void set_cert_name_string	(	HWND	hwnd,
		PCCERT_CONTEXT	cert,
		DWORD	nameFlags,
		int	heading
	)

static

Definition at line 2384 of file main.c.

{
    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);
 
}

Referenced by set_general_info().

◆ set_cert_string_property()

static void set_cert_string_property	(	PCCERT_CONTEXT	cert,
		DWORD	prop,
		LPWSTR	str
	)

static

Definition at line 3511 of file main.c.

{
    if (str && *str)
    {
        CRYPT_DATA_BLOB blob;
 
        blob.pbData = (BYTE *)str;
        blob.cbData = (lstrlenW(str) + 1) * sizeof(WCHAR);
        CertSetCertificateContextProperty(cert, prop, 0, &blob);
    }
    else
        CertSetCertificateContextProperty(cert, prop, 0, NULL);
}

Referenced by apply_general_changes().

◆ set_cert_validity_period()

static void set_cert_validity_period	(	HWND	hwnd,
		PCCERT_CONTEXT	cert
	)

static

Definition at line 2423 of file main.c.

{
    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);
}

Referenced by set_general_info().

◆ set_certificate_status()

static void set_certificate_status	(	HWND	hwnd,
		const CRYPT_PROVIDER_CERT *	cert
	)

static

Definition at line 4069 of file main.c.

{
    /* 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);
}

Referenced by hierarchy_dlg_proc(), and set_certificate_status_for_end_cert().

◆ set_certificate_status_for_end_cert()

static void set_certificate_status_for_end_cert	(	HWND	hwnd,
		PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo
	)

static

Definition at line 4086 of file main.c.

{
    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);
}

Referenced by show_cert_hierarchy().

◆ set_fields_selection()

static void set_fields_selection	(	HWND	hwnd,
		struct detail_data *	data,
		int	sel
	)

static

Definition at line 3134 of file main.c.

{
    HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
 
    if (sel >= 0 && sel < ARRAY_SIZE(listItems))
    {
        SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
        listItems[sel].add(list, data);
    }
}

Referenced by create_cert_details_list(), and refresh_details_view().

◆ set_general_cert_properties()

static void set_general_cert_properties	(	HWND	hwnd,
		struct edit_cert_data *	data
	)

static

Definition at line 3491 of file main.c.

{
    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);
}

Referenced by cert_properties_general_dlg_proc().

◆ set_general_info()

static void set_general_info	(	HWND	hwnd,
		PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo
	)

static

Definition at line 2452 of file main.c.

{
    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);
}

Referenced by general_dlg_proc().

◆ set_issuer_statement()

static void set_issuer_statement	(	HWND	hwnd,
		PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo
	)

static

Definition at line 2278 of file main.c.

{
    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);
        }
    }
}

Referenced by set_cert_info().

◆ set_policy_text()

static void set_policy_text	(	HWND	text,
		PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo
	)

static

Definition at line 2172 of file main.c.

{
    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);
    }
}

Referenced by set_cert_info().

◆ show_cert_chain()

static void show_cert_chain	(	HWND	hwnd,
		struct hierarchy_data *	data
	)

static

Definition at line 4018 of file main.c.

{
    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);
        }
    }
}

Referenced by show_cert_hierarchy().

◆ show_cert_dialog()

static BOOL show_cert_dialog	(	PCCRYPTUI_VIEWCERTIFICATE_STRUCTW	pCertViewInfo,
		CRYPT_PROVIDER_CERT *	provCert,
		BOOL *	pfPropertiesChanged
	)

static

Definition at line 4310 of file main.c.

{
    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;
}

Referenced by CryptUIDlgViewCertificateW().

◆ show_cert_hierarchy()

static void show_cert_hierarchy	(	HWND	hwnd,
		struct hierarchy_data *	data
	)

static

Definition at line 4100 of file main.c.

{
    /* 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);
}

Referenced by hierarchy_dlg_proc(), and show_dialog_for_selected_cert().

◆ show_cert_stores()

static void show_cert_stores	(	HWND	hwnd,
		DWORD	dwFlags,
		struct CertMgrData *	data
	)

static

Definition at line 496 of file main.c.

{
    const struct CertMgrStoreInfo *storeList;
    int cStores, i;
    HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
 
    if (dwFlags & CRYPTUI_CERT_MGR_PUBLISHER_TAB)
    {
        storeList = publisherStoreList;
        cStores = ARRAY_SIZE(publisherStoreList);
    }
    else
    {
        storeList = defaultStoreList;
        cStores = ARRAY_SIZE(defaultStoreList);
    }
    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);
    }
}

Referenced by cert_mgr_dlg_proc().

◆ show_cert_usages()

static void show_cert_usages	(	HWND	hwnd,
		struct edit_cert_data *	data
	)

static

Definition at line 3412 of file main.c.

{
    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);
}

Referenced by set_general_cert_properties().

◆ show_dialog_for_selected_cert()

static void show_dialog_for_selected_cert ( HWND hwnd )

static

Definition at line 4108 of file main.c.

{
    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);
        }
    }
}

Referenced by hierarchy_dlg_proc().

◆ show_edit_cert_properties_dialog()

static void show_edit_cert_properties_dialog	(	HWND	parent,
		struct detail_data *	data
	)

static

Definition at line 3746 of file main.c.

{
    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);
}

Referenced by detail_dlg_proc().

◆ show_export_details()

static void show_export_details	(	HWND	lv,
		const struct ExportWizData *	data
	)

static

Definition at line 6364 of file main.c.

{
    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, ARRAY_SIZE(text));
        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, ARRAY_SIZE(text));
        SendMessageW(lv, LVM_INSERTITEMW, item.iItem, (LPARAM)&item);
        item.iSubItem = 1;
        LoadStringW(hInstance, data->contextInfo.fExportChain ? IDS_YES : IDS_NO, text,
         ARRAY_SIZE(text));
        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, ARRAY_SIZE(text));
        SendMessageW(lv, LVM_INSERTITEMW, item.iItem, (LPARAM)&item);
        item.iSubItem = 1;
        LoadStringW(hInstance, data->contextInfo.fExportPrivateKeys ? IDS_YES : IDS_NO, text,
         ARRAY_SIZE(text));
        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, ARRAY_SIZE(text));
    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, ARRAY_SIZE(text));
    SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
}

Referenced by export_finish_dlg_proc().

◆ show_export_ui()

static BOOL show_export_ui	(	DWORD	dwFlags,
		HWND	hwndParent,
		LPCWSTR	pwszWizardTitle,
		PCCRYPTUI_WIZ_EXPORT_INFO	pExportInfo,
		const void *	pvoid
	)

static

Definition at line 6833 of file main.c.

{
    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;
}

Referenced by CryptUIWizExport().

◆ show_import_details()

static void show_import_details	(	HWND	lv,
		struct ImportWizData *	data
	)

static

Definition at line 5268 of file main.c.

{
    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, ARRAY_SIZE(text));
    item.pszText = text;
    SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
    item.iSubItem = 1;
    if (data->autoDest)
        LoadStringW(hInstance, IDS_IMPORT_DEST_AUTOMATIC, text, ARRAY_SIZE(text));
    else
        LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED, text, ARRAY_SIZE(text));
    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, ARRAY_SIZE(text));
    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, ARRAY_SIZE(text));
    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, ARRAY_SIZE(text));
        SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
        item.iSubItem = 1;
        item.pszText = data->fileName;
        SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
    }
}

Referenced by import_finish_dlg_proc().

◆ show_import_ui()

static BOOL show_import_ui	(	DWORD	dwFlags,
		HWND	hwndParent,
		LPCWSTR	pwszWizardTitle,
		PCCRYPTUI_WIZ_IMPORT_SRC_INFO	pImportSrc,
		HCERTSTORE	hDestCertStore
	)

static

Definition at line 5446 of file main.c.

{
    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;
}

Referenced by CryptUIWizImport().

◆ show_selected_cert()

static void show_selected_cert	(	HWND	hwnd,
		int	index
	)

static

Definition at line 835 of file main.c.

{
    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);
    }
}

Referenced by cert_mgr_dlg_proc().

◆ show_store_certs()

static void show_store_certs	(	HWND	hwnd,
		HCERTSTORE	store
	)

static

Definition at line 355 of file main.c.

{
    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);
}

Referenced by cert_mgr_dlg_proc(), and refresh_store_certs().

◆ show_user_notice()

static void show_user_notice	(	HWND	hwnd,
		struct IssuerStatement *	issuerStatement
	)

static

Definition at line 2506 of file main.c.

{
    DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
     user_notice_dlg_proc, (LPARAM)issuerStatement);
}

Referenced by general_dlg_proc().

◆ strdupAtoW()

static WCHAR * strdupAtoW ( const char * str )

static

Definition at line 67 of file main.c.

{
    DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
    WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
    if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
    return ret;
}

Referenced by cabinet_copy_file(), cabinet_next_cabinet(), ConvertChmString(), CryptUIDlgSelectCertificateA(), FindContextAlias(), FindHTMLHelpSetting(), HANDLE_CustomType21_22(), HANDLE_CustomType5_6(), HtmlHelpA(), msi_suminfo_dup_string(), MsiApplyMultiplePatchesA(), MsiApplyPatchA(), MsiBeginTransactionA(), MsiConfigureFeatureA(), MsiConfigureProductA(), MsiConfigureProductExA(), MsiCreateTransformSummaryInfoA(), MsiDatabaseApplyTransformA(), MsiDatabaseExportA(), MsiDatabaseGetPrimaryKeysA(), MsiDatabaseImportA(), MsiDatabaseIsTablePersistentA(), MsiDatabaseMergeA(), MsiDatabaseOpenViewA(), MsiDecomposeDescriptorA(), MsiDetermineApplicablePatchesA(), MsiDeterminePatchSequenceA(), MsiDoActionA(), MsiEnableLogA(), MsiEnumClientsA(), MsiEnumComponentCostsA(), MsiEnumComponentQualifiersA(), MsiEnumComponentsExA(), MsiEnumFeaturesA(), MsiEnumPatchesA(), MsiEnumPatchesExA(), MsiEnumProductsExA(), MsiEnumRelatedProductsA(), MsiGetComponentPathExA(), MsiGetComponentStateA(), MsiGetFeatureCostA(), MsiGetFeatureInfoA(), MsiGetFeatureStateA(), MsiGetFeatureUsageA(), MsiGetFeatureValidStatesA(), MsiGetFileHashA(), MsiGetFileSignatureInformationA(), MsiGetFileVersionA(), MsiGetPatchInfoA(), MsiGetPatchInfoExA(), MsiGetProductCodeA(), MsiGetProductInfoA(), MsiGetProductInfoExA(), MsiGetProductPropertyA(), MsiGetPropertyA(), MsiGetShortcutTargetA(), MsiGetSourcePathA(), MsiGetSummaryInformationA(), MsiGetTargetPathA(), MsiGetUserInfoA(), MsiInstallMissingComponentA(), MsiInstallProductA(), MsiOpenDatabaseA(), MsiOpenPackageExA(), MsiOpenProductA(), MsiPreviewDialogA(), MsiProvideComponentA(), MsiProvideQualifiedComponentExA(), MsiQueryComponentStateA(), MsiQueryFeatureStateA(), MsiQueryFeatureStateExA(), MsiQueryProductStateA(), MsiRecordSetStreamA(), MsiRecordSetStringA(), MsiReinstallFeatureA(), MsiReinstallProductA(), MsiSequenceA(), MsiSetComponentStateA(), MsiSetFeatureAttributesA(), MsiSetFeatureStateA(), MsiSetPropertyA(), MsiSetTargetPathA(), MsiSourceListAddMediaDiskA(), MsiSourceListAddSourceA(), MsiSourceListAddSourceExA(), MsiSourceListEnumMediaDisksA(), MsiSourceListEnumSourcesA(), MsiSourceListGetInfoA(), MsiSourceListSetInfoA(), MsiUseFeatureExA(), MsiVerifyPackageA(), patchinfoAtoW(), prop_sheet_pages_AtoW(), SetupGetSourceFileLocationA(), SetupGetTargetPathA(), SetupInitializeFileLogA(), SetupPromptForDiskA(), SetupQueueCopyIndirectA(), SetupQueueDeleteA(), SetupQueueRenameA(), SetupUninstallOEMInfA(), and wintypeAtoW().

◆ toggle_usage()

static void toggle_usage	(	HWND	hwnd,
		int	iItem
	)

static

Definition at line 617 of file main.c.

{
    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);
    }
}

Referenced by cert_mgr_advanced_dlg_proc(), and cert_properties_general_dlg_proc().

◆ user_notice_dlg_proc()

static LRESULT CALLBACK user_notice_dlg_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wp,
		LPARAM	lp
	)

static

Definition at line 2463 of file main.c.

{
    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,
         lstrlenW(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;
}

Referenced by show_user_notice().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( cryptui )

◆ WTHelperGetKnownUsages()

BOOL WINAPI WTHelperGetKnownUsages	(	DWORD	action,
		PCCRYPT_OID_INFO **	usages
	)

Definition at line 896 of file wintrust_main.c.

{
    BOOL ret;
 
    TRACE("(%d, %p)\n", action, usages);
 
    if (!usages)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (action == 1)
    {
        *usages = NULL;
        ret = CryptEnumOIDInfo(CRYPT_ENHKEY_USAGE_OID_GROUP_ID, 0, usages,
         WINTRUST_enumUsages);
    }
    else if (action == 2)
    {
        WINTRUST_Free(*usages);
        *usages = NULL;
        ret = TRUE;
    }
    else
    {
        WARN("unknown action %d\n", action);
        SetLastError(ERROR_INVALID_PARAMETER);
        ret = FALSE;
    }
    return ret;
}

Referenced by add_known_usages_to_list(), create_advanced_filter(), and InitFunctionPtrs().

Variable Documentation

◆ addressBook

const WCHAR addressBook[]

static

Initial value:

= {

'A','d','d','r','e','s','s','B','o','o','k',0 }

Definition at line 455 of file main.c.

Referenced by choose_store_for_cert(), and test_crypt_ui_wiz_import().

◆ allowFlags

DWORD allowFlags

Definition at line 4928 of file main.c.

Referenced by make_import_file_filter().

◆ ca

const WCHAR ca[] = { 'C','A',0 }

static

◆ defaultStoreList

const struct CertMgrStoreInfo defaultStoreList[]

static

Initial value:

= {
 { 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 },
}

Definition at line 470 of file main.c.

Referenced by show_cert_stores().

◆ disallowed

const WCHAR disallowed[] = { 'D','i','s','a','l','l','o','w','e','d',0 }

static

Definition at line 461 of file main.c.

Referenced by CRYPTDLG_IsCertAllowed(), and SoftpubAuthenticode().

◆ empty

const WCHAR empty[] = {0}

static

Definition at line 47 of file main.c.

Referenced by _create_option_elem(), _Slist_sort(), _test_open(), _test_server_open(), AppendFullPathURL(), list< _Tp, >::back(), BinaryToBase64W(), cert_mgr_clear_cert_selection(), cert_mgr_dlg_proc(), XMLStorage::XMLNode::Children::clear(), clear_lfn_slots(), create_command(), CRYPT_IsEmptyName(), delete_tree(), delete_tree_(), dictionary_put_Key(), do_reg_operation(), do_splits(), StringTest::find(), list< _Tp, >::front(), get_patch_product_codes(), get_regdata(), get_tasks_root_folder(), HTMLImageElementFactory_value(), _Rb_tree< _Key, _Compare, _Value, _KeyOfValue, _Traits, >::insert_unique(), InternetOpenRequest_test(), JSGlobal_parseInt(), lfn_remove(), TMapLoader::Load(), LoadWinTypeFromCHM(), MSI_GetProductInfo(), nfs41_client_state_revoked(), parse_culture(), parse_startup(), parse_supported_runtime(), list< _Tp, >::pop_back(), list< _Tp, >::pop_front(), proxtrans(), pSetupStringTableStringFromId(), recvrequest(), REGION_CropRegion(), reset(), run_service(), s_remote_FormatRecord(), s_remote_GetProperty(), s_remote_GetSourcePath(), s_remote_GetTargetPath(), s_remote_SummaryInfoGetProperty(), s_remote_ViewGetError(), select_style(), set_default_templates(), SHLWAPI_InvokeByIID(), SQLWritePrivateProfileStringW(), list< _Tp, >::swap(), StringTest::template_expression(), StringTest::template_wexpression(), test_assign(), test_construction(), test_copyassignment(), test_copyconstructor(), test_CopyFolder(), test_CopyStgMedium(), test_CPoint(), test_create_delete_svc(), test_create_device_list_ex(), test_CreateAssemblyNameObject(), test_CRect(), test_CryptCATOpen(), test_CSize(), test_DnsNameCompare_A(), test_DxDiag_SoundDevices(), test_DxDiag_SystemInfo(), test_empty_headers_param(), test_find_file(), test_fromguid(), test_GetAddrInfoW(), test_GetLongPathNameW(), test_GetVolumePathNamesForVolumeNameW(), test_HlinkGetSetStringReference(), test_InstallAssembly(), test_IsDomainLegalCookieDomainW(), test_IWinHttpRequest(), test_mbsspn(), test_mbsspnp(), test_menu_iteminfo(), test_message_allocate_buffer_wide(), test_message_from_string_wide(), test_message_ignore_inserts_wide(), test_misc(), test_NetFwAuthorizedApplication(), test_PdhValidatePathExW(), test_PdhValidatePathW(), test_PropVariantCompareEx(), test_QueryAssemblyInfo(), test_request_parameter_defaults(), test_sequence(), test_SQLGetPrivateProfileStringW(), test_Startup(), test_string_pointers(), test_stringtable(), test_Win32_Service(), test_WinHttpAddHeaders(), CProgressDialog::update_dialog(), update_title(), VARIANT_BstrReplaceDecimal(), Widget_array(), Widget_mystruct(), Widget_rect(), wnet_use_connection(), and xmlParse3986Segment().

◆ export_filter_cert

const WCHAR export_filter_cert[] = { '*','.','c','e','r',0 }

static

Definition at line 6174 of file main.c.

Referenced by make_export_file_filter().

◆ export_filter_cms

const WCHAR export_filter_cms[] = { '*','.','p','7','b',0 }

static

Definition at line 6177 of file main.c.

Referenced by make_export_file_filter().

◆ export_filter_crl

const WCHAR export_filter_crl[] = { '*','.','c','r','l',0 }

static

Definition at line 6175 of file main.c.

Referenced by make_export_file_filter().

◆ export_filter_ctl

const WCHAR export_filter_ctl[] = { '*','.','s','t','l',0 }

static

Definition at line 6176 of file main.c.

Referenced by make_export_file_filter().

◆ export_filter_pfx

const WCHAR export_filter_pfx[] = { '*','.','p','f','x',0 }

static

Definition at line 6178 of file main.c.

Referenced by make_export_file_filter().

◆ export_filter_sst

const WCHAR export_filter_sst[] = { '*','.','s','s','t',0 }

static

Definition at line 6179 of file main.c.

Referenced by make_export_file_filter().

◆ filter

LPCWSTR filter

Definition at line 4929 of file main.c.

Referenced by add_store_certs(), make_export_file_filter(), and make_import_file_filter().

◆ filter_all

const WCHAR filter_all[] = { '*','.','*',0 }

static

Definition at line 4923 of file main.c.

Referenced by make_export_file_filter().

◆ filter_cert

const WCHAR filter_cert[]

static

Initial value:

= { '*','.','c','e','r',';','*','.',

'c','r','t',0 }

Definition at line 4914 of file main.c.

◆ filter_cms

const WCHAR filter_cms[]

static

Initial value:

= { '*','.','s','p','c',';','*','.',

'p','7','b',0 }

Definition at line 4921 of file main.c.

◆ filter_crl

const WCHAR filter_crl[] = { '*','.','c','r','l',0 }

static

Definition at line 4918 of file main.c.

◆ filter_ctl

const WCHAR filter_ctl[] = { '*','.','s','t','l',0 }

static

Definition at line 4919 of file main.c.

◆ filter_pfx

const WCHAR filter_pfx[]

static

Initial value:

= { '*','.','p','f','x',';','*','.',

'p','1','2',0 }

Definition at line 4916 of file main.c.

◆ filter_serialized_store

const WCHAR filter_serialized_store[] = { '*','.','s','s','t',0 }

static

Definition at line 4920 of file main.c.

◆ hInstance

HINSTANCE hInstance

static

Definition at line 45 of file main.c.

◆ id

int id

Definition at line 4927 of file main.c.

Referenced by mapStructEntryToValue(), setOidWithItem(), and setOidWithItemAndIpAddr().

◆

const struct { ... } import_filters[]

Initial value:

= {
 { 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 },
}

Referenced by make_import_file_filter().

◆ listItems

const struct selection_list_item listItems[]

static

Initial value:

= {
 { 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 },
}

Definition at line 3091 of file main.c.

Referenced by create_show_list(), and set_fields_selection().

◆ my

const WCHAR my[] = { 'M','y',0 }

static

Definition at line 454 of file main.c.

◆ oidMap

struct OIDToString oidMap[]

static

Definition at line 1917 of file main.c.

Referenced by findSupportedOID().

◆ prop_id_map

const struct prop_id_to_string_id prop_id_map[]

static

Initial value:

= {
 { 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 },
}

Definition at line 3029 of file main.c.

Referenced by add_properties().

◆ publisherStoreList

const struct CertMgrStoreInfo publisherStoreList[]

static

Initial value:

= {
 { 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 },
}

Definition at line 481 of file main.c.

Referenced by show_cert_stores().

◆ root

const WCHAR root[] = { 'R','o','o','t',0 }

static

Definition at line 458 of file main.c.

◆ trustedPublisher

const WCHAR trustedPublisher[]

static

Initial value:

= {

'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0 }

Definition at line 459 of file main.c.

◆ v1_fields

const struct v1_field v1_fields[]

static

Initial value:

= {
 { 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 }
}

Definition at line 2835 of file main.c.

Referenced by add_v1_fields().

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

◆ CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE

◆ MAX_DESCRIPTION

◆ MAX_FRIENDLY_NAME

◆ MAX_PURPOSE

◆ MAX_STRING_LEN

◆ MY_INDENT

◆ NONAMELESSUNION

◆ WM_REFRESH_VIEW

Typedef Documentation

◆ add_fields_func

◆ create_detailed_value_func

◆ CRYPTUI_ENUM_DATA

◆ CRYPTUI_ENUM_SYSTEM_STORE_ARGS

◆ CRYPTUI_SELECTSTORE_INFO_A

◆ CRYPTUI_SELECTSTORE_INFO_W

◆ field_format_func

◆ PCRYPTUI_ENUM_DATA

◆ PCRYPTUI_ENUM_SYSTEM_STORE_ARGS

◆ PCRYPTUI_SELECTSTORE_INFO_A

◆ PCRYPTUI_SELECTSTORE_INFO_W

◆ PFN_SELECTED_STORE_CB

◆ prop_to_value_func

Enumeration Type Documentation

◆ CheckBitmapIndex

◆ PurposeFilter

◆ PurposeSelection

Function Documentation

◆ add_all_extensions()

◆ add_all_fields()

◆ add_cert_columns()

◆ add_cert_extension_detail()

◆ add_cert_string_to_control()

◆ add_cert_to_list()

◆ add_cert_to_view()

◆ add_critical_extensions()

◆ add_date_string_to_control()

◆ add_field_and_value_to_list()

◆ add_field_value_data()

◆ add_icon_to_control()

◆ add_known_usage()

◆ add_known_usages_to_list()

◆ add_local_oid_text_to_control()

◆ add_oid_text_to_control()

◆ add_oid_to_usage()

◆ add_properties()

◆ add_purpose()

◆ add_purpose_dlg_proc()

◆ add_store_certs()

◆ add_string_id_and_value_to_list()

◆ add_string_resource_to_control()

◆ add_string_resource_with_paraformat_to_control()

◆ add_text_with_paraformat_to_control()

◆ add_unformatted_text_to_control()

◆ add_v1_field()

◆ add_v1_fields()

◆ apply_general_changes()

◆ cert_mgr_advanced_dlg_proc()

◆ cert_mgr_clear_cert_selection()

◆ cert_mgr_current_store()

◆ cert_mgr_dlg_proc()

◆ cert_mgr_do_export()

◆ cert_mgr_do_remove()

◆ cert_mgr_index_to_cert()

◆ cert_mgr_index_to_store()

◆ cert_mgr_show_cert_usages()

◆ cert_mgr_sort_by_date()

◆ cert_mgr_sort_by_friendly_name()

◆ cert_mgr_sort_by_issuer()

◆ cert_mgr_sort_by_subject()

◆ cert_mgr_sort_by_text()

◆ cert_prop_sheet_proc()

◆ cert_properties_general_callback()