projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Create this branch to work on loading of different Kernel-Debugger DLL providers...
[reactos.git] / dll / win32 / cryptui / main.c
1 /*
2 * Copyright 2008 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #define WIN32_NO_STATUS
20 #define _INC_WINDOWS
21 #define COM_NO_WINDOWS_H
22
23 #include <config.h>
24
25 #include <stdarg.h>
26
27 #define COBJMACROS
28 #define NONAMELESSUNION
29
30 #include <windef.h>
31 #include <winbase.h>
32 //#include "winnls.h"
33 #include <winuser.h>
34 #include <softpub.h>
35 #include <wingdi.h>
36 #include <richedit.h>
37 #include <ole2.h>
38 #include <richole.h>
39 #include <commdlg.h>
40 #include <commctrl.h>
41 #include <cryptuiapi.h>
42 #include "cryptuires.h"
43 //#include "urlmon.h"
44 #include <hlink.h>
45 #include <winreg.h>
46 #include <wine/debug.h>
47 #include <wine/unicode.h>
48
49 WINE_DEFAULT_DEBUG_CHANNEL(cryptui);
50
51 static HINSTANCE hInstance;
52
53 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
54 {
55 TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
56
57 switch (fdwReason)
58 {
59 case DLL_WINE_PREATTACH:
60 return FALSE; /* prefer native version */
61 case DLL_PROCESS_ATTACH:
62 hInstance = hinstDLL;
63 DisableThreadLibraryCalls(hinstDLL);
64 break;
65 case DLL_PROCESS_DETACH:
66 break;
67 default:
68 break;
69 }
70 return TRUE;
71 }
72
73 #define MAX_STRING_LEN 512
74
75 static void add_cert_columns(HWND hwnd)
76 {
77 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
78 RECT rc;
79 WCHAR buf[MAX_STRING_LEN];
80 LVCOLUMNW column;
81
82 SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
83 GetWindowRect(lv, &rc);
84 LoadStringW(hInstance, IDS_SUBJECT_COLUMN, buf,
85 sizeof(buf) / sizeof(buf[0]));
86 column.mask = LVCF_WIDTH | LVCF_TEXT;
87 column.cx = (rc.right - rc.left) * 29 / 100 - 2;
88 column.pszText = buf;
89 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
90 LoadStringW(hInstance, IDS_ISSUER_COLUMN, buf,
91 sizeof(buf) / sizeof(buf[0]));
92 SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
93 column.cx = (rc.right - rc.left) * 16 / 100 - 2;
94 LoadStringW(hInstance, IDS_EXPIRATION_COLUMN, buf,
95 sizeof(buf) / sizeof(buf[0]));
96 SendMessageW(lv, LVM_INSERTCOLUMNW, 2, (LPARAM)&column);
97 column.cx = (rc.right - rc.left) * 23 / 100 - 1;
98 LoadStringW(hInstance, IDS_FRIENDLY_NAME_COLUMN, buf,
99 sizeof(buf) / sizeof(buf[0]));
100 SendMessageW(lv, LVM_INSERTCOLUMNW, 3, (LPARAM)&column);
101 }
102
103 static void add_cert_to_view(HWND lv, PCCERT_CONTEXT cert, DWORD *allocatedLen,
104 LPWSTR *str)
105 {
106 DWORD len;
107 LVITEMW item;
108 WCHAR dateFmt[80]; /* sufficient for LOCALE_SSHORTDATE */
109 WCHAR date[80];
110 SYSTEMTIME sysTime;
111 LPWSTR none;
112
113 item.mask = LVIF_IMAGE | LVIF_PARAM | LVIF_TEXT;
114 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
115 item.iSubItem = 0;
116 item.iImage = 0;
117 item.lParam = (LPARAM)CertDuplicateCertificateContext(cert);
118 len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
119 NULL, 0);
120 if (len > *allocatedLen)
121 {
122 HeapFree(GetProcessHeap(), 0, *str);
123 *str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
124 if (*str)
125 *allocatedLen = len;
126 }
127 if (*str)
128 {
129 CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL,
130 *str, len);
131 item.pszText = *str;
132 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
133 }
134
135 item.mask = LVIF_TEXT;
136 len = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
137 CERT_NAME_ISSUER_FLAG, NULL, NULL, 0);
138 if (len > *allocatedLen)
139 {
140 HeapFree(GetProcessHeap(), 0, *str);
141 *str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
142 if (*str)
143 *allocatedLen = len;
144 }
145 if (*str)
146 {
147 CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
148 CERT_NAME_ISSUER_FLAG, NULL, *str, len);
149 item.pszText = *str;
150 item.iSubItem = 1;
151 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
152 }
153
154 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
155 sizeof(dateFmt) / sizeof(dateFmt[0]));
156 FileTimeToSystemTime(&cert->pCertInfo->NotAfter, &sysTime);
157 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
158 sizeof(date) / sizeof(date[0]));
159 item.pszText = date;
160 item.iSubItem = 2;
161 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
162
163 if (!CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID,
164 NULL, &len))
165 len = LoadStringW(hInstance, IDS_FRIENDLY_NAME_NONE, (LPWSTR)&none, 0);
166 if (len > *allocatedLen)
167 {
168 HeapFree(GetProcessHeap(), 0, *str);
169 *str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
170 if (*str)
171 *allocatedLen = len;
172 }
173 if (*str)
174 {
175 if (!CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID,
176 *str, &len))
177 item.pszText = none;
178 else
179 item.pszText = *str;
180 item.iSubItem = 3;
181 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
182 }
183 }
184
185 static LPSTR get_cert_mgr_usages(void)
186 {
187 static const WCHAR keyName[] = { 'S','o','f','t','w','a','r','e','\\','M',
188 'i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g','r','a',
189 'p','h','y','\\','U','I','\\','C','e','r','t','m','g','r','\\','P','u',
190 'r','p','o','s','e',0 };
191 LPSTR str = NULL;
192 HKEY key;
193
194 if (!RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, NULL, 0, KEY_READ,
195 NULL, &key, NULL))
196 {
197 LONG rc;
198 DWORD type, size;
199
200 rc = RegQueryValueExA(key, "Purpose", NULL, &type, NULL, &size);
201 if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
202 {
203 str = HeapAlloc(GetProcessHeap(), 0, size);
204 if (str)
205 {
206 rc = RegQueryValueExA(key, "Purpose", NULL, NULL, (LPBYTE)str,
207 &size);
208 if (rc)
209 {
210 HeapFree(GetProcessHeap(), 0, str);
211 str = NULL;
212 }
213 }
214 }
215 RegCloseKey(key);
216 }
217 return str;
218 }
219
220 typedef enum {
221 PurposeFilterShowAll = 0,
222 PurposeFilterShowAdvanced = 1,
223 PurposeFilterShowOID = 2
224 } PurposeFilter;
225
226 static void initialize_purpose_selection(HWND hwnd)
227 {
228 HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
229 WCHAR buf[MAX_STRING_LEN];
230 LPSTR usages;
231 int index;
232
233 LoadStringW(hInstance, IDS_PURPOSE_ALL, buf,
234 sizeof(buf) / sizeof(buf[0]));
235 index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
236 SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)PurposeFilterShowAll);
237 LoadStringW(hInstance, IDS_PURPOSE_ADVANCED, buf,
238 sizeof(buf) / sizeof(buf[0]));
239 index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
240 SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)PurposeFilterShowAdvanced);
241 SendMessageW(cb, CB_SETCURSEL, 0, 0);
242 if ((usages = get_cert_mgr_usages()))
243 {
244 LPSTR ptr, comma;
245
246 for (ptr = usages, comma = strchr(ptr, ','); ptr && *ptr;
247 ptr = comma ? comma + 1 : NULL,
248 comma = ptr ? strchr(ptr, ',') : NULL)
249 {
250 PCCRYPT_OID_INFO info;
251
252 if (comma)
253 *comma = 0;
254 if ((info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, ptr, 0)))
255 {
256 index = SendMessageW(cb, CB_INSERTSTRING, 0,
257 (LPARAM)info->pwszName);
258 SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)info);
259 }
260 }
261 HeapFree(GetProcessHeap(), 0, usages);
262 }
263 }
264
265 extern BOOL WINAPI WTHelperGetKnownUsages(DWORD action,
266 PCCRYPT_OID_INFO **usages);
267
268 static CERT_ENHKEY_USAGE *add_oid_to_usage(CERT_ENHKEY_USAGE *usage, LPSTR oid)
269 {
270 if (!usage->cUsageIdentifier)
271 usage->rgpszUsageIdentifier = HeapAlloc(GetProcessHeap(), 0,
272 sizeof(LPSTR));
273 else
274 usage->rgpszUsageIdentifier = HeapReAlloc(GetProcessHeap(), 0,
275 usage->rgpszUsageIdentifier,
276 (usage->cUsageIdentifier + 1) * sizeof(LPSTR));
277 if (usage->rgpszUsageIdentifier)
278 usage->rgpszUsageIdentifier[usage->cUsageIdentifier++] = oid;
279 else
280 {
281 HeapFree(GetProcessHeap(), 0, usage);
282 usage = NULL;
283 }
284 return usage;
285 }
286
287 static CERT_ENHKEY_USAGE *convert_usages_str_to_usage(LPSTR usageStr)
288 {
289 CERT_ENHKEY_USAGE *usage = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
290 sizeof(CERT_ENHKEY_USAGE));
291
292 if (usage)
293 {
294 LPSTR ptr, comma;
295
296 for (ptr = usageStr, comma = strchr(ptr, ','); usage && ptr && *ptr;
297 ptr = comma ? comma + 1 : NULL,
298 comma = ptr ? strchr(ptr, ',') : NULL)
299 {
300 if (comma)
301 *comma = 0;
302 usage = add_oid_to_usage(usage, ptr);
303 }
304 }
305 return usage;
306 }
307
308 static CERT_ENHKEY_USAGE *create_advanced_filter(void)
309 {
310 CERT_ENHKEY_USAGE *advancedUsage = HeapAlloc(GetProcessHeap(),
311 HEAP_ZERO_MEMORY, sizeof(CERT_ENHKEY_USAGE));
312
313 if (advancedUsage)
314 {
315 PCCRYPT_OID_INFO *usages;
316
317 if (WTHelperGetKnownUsages(1, &usages))
318 {
319 LPSTR disabledUsagesStr;
320
321 if ((disabledUsagesStr = get_cert_mgr_usages()))
322 {
323 CERT_ENHKEY_USAGE *disabledUsages =
324 convert_usages_str_to_usage(disabledUsagesStr);
325
326 if (disabledUsages)
327 {
328 PCCRYPT_OID_INFO *ptr;
329
330 for (ptr = usages; advancedUsage && *ptr; ptr++)
331 {
332 DWORD i;
333 BOOL disabled = FALSE;
334
335 for (i = 0; !disabled &&
336 i < disabledUsages->cUsageIdentifier; i++)
337 if (!strcmp(disabledUsages->rgpszUsageIdentifier[i],
338 (*ptr)->pszOID))
339 disabled = TRUE;
340 if (!disabled)
341 advancedUsage = add_oid_to_usage(advancedUsage,
342 (LPSTR)(*ptr)->pszOID);
343 }
344 /* The individual strings are pointers to disabledUsagesStr,
345 * so they're freed when it is.
346 */
347 HeapFree(GetProcessHeap(), 0,
348 disabledUsages->rgpszUsageIdentifier);
349 HeapFree(GetProcessHeap(), 0, disabledUsages);
350 }
351 HeapFree(GetProcessHeap(), 0, disabledUsagesStr);
352 }
353 WTHelperGetKnownUsages(2, &usages);
354 }
355 }
356 return advancedUsage;
357 }
358
359 static int CALLBACK cert_mgr_sort_by_subject(LPARAM lp1, LPARAM lp2, LPARAM lp);
360
361 static void show_store_certs(HWND hwnd, HCERTSTORE store)
362 {
363 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
364 HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
365 PCCERT_CONTEXT cert = NULL;
366 DWORD allocatedLen = 0;
367 LPWSTR str = NULL;
368 int index;
369 PurposeFilter filter = PurposeFilterShowAll;
370 LPCSTR oid = NULL;
371 CERT_ENHKEY_USAGE *advanced = NULL;
372
373 index = SendMessageW(cb, CB_GETCURSEL, 0, 0);
374 if (index >= 0)
375 {
376 INT_PTR data = SendMessageW(cb, CB_GETITEMDATA, index, 0);
377
378 if (!HIWORD(data))
379 filter = data;
380 else
381 {
382 PCCRYPT_OID_INFO info = (PCCRYPT_OID_INFO)data;
383
384 filter = PurposeFilterShowOID;
385 oid = info->pszOID;
386 }
387 }
388 if (filter == PurposeFilterShowAdvanced)
389 advanced = create_advanced_filter();
390 do {
391 cert = CertEnumCertificatesInStore(store, cert);
392 if (cert)
393 {
394 BOOL show = FALSE;
395
396 if (filter == PurposeFilterShowAll)
397 show = TRUE;
398 else
399 {
400 int numOIDs;
401 DWORD cbOIDs = 0;
402
403 if (CertGetValidUsages(1, &cert, &numOIDs, NULL, &cbOIDs))
404 {
405 if (numOIDs == -1)
406 {
407 /* -1 implies all usages are valid */
408 show = TRUE;
409 }
410 else
411 {
412 LPSTR *oids = HeapAlloc(GetProcessHeap(), 0, cbOIDs);
413
414 if (oids)
415 {
416 if (CertGetValidUsages(1, &cert, &numOIDs, oids,
417 &cbOIDs))
418 {
419 int i;
420
421 if (filter == PurposeFilterShowOID)
422 {
423 for (i = 0; !show && i < numOIDs; i++)
424 if (!strcmp(oids[i], oid))
425 show = TRUE;
426 }
427 else
428 {
429 for (i = 0; !show && i < numOIDs; i++)
430 {
431 DWORD j;
432
433 for (j = 0; !show &&
434 j < advanced->cUsageIdentifier; j++)
435 if (!strcmp(oids[i],
436 advanced->rgpszUsageIdentifier[j]))
437 show = TRUE;
438 }
439 }
440 }
441 HeapFree(GetProcessHeap(), 0, oids);
442 }
443 }
444 }
445 }
446 if (show)
447 add_cert_to_view(lv, cert, &allocatedLen, &str);
448 }
449 } while (cert);
450 HeapFree(GetProcessHeap(), 0, str);
451 if (advanced)
452 {
453 HeapFree(GetProcessHeap(), 0, advanced->rgpszUsageIdentifier);
454 HeapFree(GetProcessHeap(), 0, advanced);
455 }
456 SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
457 (LPARAM)cert_mgr_sort_by_subject);
458 }
459
460 static const WCHAR my[] = { 'M','y',0 };
461 static const WCHAR addressBook[] = {
462 'A','d','d','r','e','s','s','B','o','o','k',0 };
463 static const WCHAR ca[] = { 'C','A',0 };
464 static const WCHAR root[] = { 'R','o','o','t',0 };
465 static const WCHAR trustedPublisher[] = {
466 'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0 };
467 static const WCHAR disallowed[] = { 'D','i','s','a','l','l','o','w','e','d',0 };
468
469 struct CertMgrStoreInfo
470 {
471 LPCWSTR name;
472 int removeWarning;
473 int removePluralWarning;
474 };
475
476 static const struct CertMgrStoreInfo defaultStoreList[] = {
477 { my, IDS_WARN_REMOVE_MY, IDS_WARN_REMOVE_PLURAL_MY },
478 { addressBook, IDS_WARN_REMOVE_ADDRESSBOOK,
479 IDS_WARN_REMOVE_PLURAL_ADDRESSBOOK },
480 { ca, IDS_WARN_REMOVE_CA, IDS_WARN_REMOVE_PLURAL_CA },
481 { root, IDS_WARN_REMOVE_ROOT, IDS_WARN_REMOVE_PLURAL_ROOT },
482 { trustedPublisher, IDS_WARN_REMOVE_TRUSTEDPUBLISHER,
483 IDS_WARN_REMOVE_PLURAL_TRUSTEDPUBLISHER },
484 { disallowed, IDS_WARN_REMOVE_DEFAULT },
485 };
486
487 static const struct CertMgrStoreInfo publisherStoreList[] = {
488 { root, IDS_WARN_REMOVE_ROOT, IDS_WARN_REMOVE_PLURAL_ROOT },
489 { trustedPublisher, IDS_WARN_REMOVE_TRUSTEDPUBLISHER,
490 IDS_WARN_REMOVE_PLURAL_TRUSTEDPUBLISHER },
491 { disallowed, IDS_WARN_REMOVE_PLURAL_DEFAULT },
492 };
493
494 struct CertMgrData
495 {
496 HIMAGELIST imageList;
497 LPCWSTR title;
498 DWORD nStores;
499 const struct CertMgrStoreInfo *stores;
500 };
501
502 static void show_cert_stores(HWND hwnd, DWORD dwFlags, struct CertMgrData *data)
503 {
504 const struct CertMgrStoreInfo *storeList;
505 int cStores, i;
506 HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
507
508 if (dwFlags & CRYPTUI_CERT_MGR_PUBLISHER_TAB)
509 {
510 storeList = publisherStoreList;
511 cStores = sizeof(publisherStoreList) / sizeof(publisherStoreList[0]);
512 }
513 else
514 {
515 storeList = defaultStoreList;
516 cStores = sizeof(defaultStoreList) / sizeof(defaultStoreList[0]);
517 }
518 if (dwFlags & CRYPTUI_CERT_MGR_SINGLE_TAB_FLAG)
519 cStores = 1;
520 data->nStores = cStores;
521 data->stores = storeList;
522 for (i = 0; i < cStores; i++)
523 {
524 LPCWSTR name;
525 TCITEMW item;
526 HCERTSTORE store;
527
528 if (!(name = CryptFindLocalizedName(storeList[i].name)))
529 name = storeList[i].name;
530 store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
531 CERT_SYSTEM_STORE_CURRENT_USER, storeList[i].name);
532 item.mask = TCIF_TEXT | TCIF_PARAM;
533 item.pszText = (LPWSTR)name;
534 item.lParam = (LPARAM)store;
535 SendMessageW(tab, TCM_INSERTITEMW, i, (LPARAM)&item);
536 }
537 }
538
539 static void free_certs(HWND lv)
540 {
541 LVITEMW item;
542 int items = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
543
544 for (i = 0; i < items; i++)
545 {
546 item.mask = LVIF_PARAM;
547 item.iItem = i;
548 item.iSubItem = 0;
549 SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
550 CertFreeCertificateContext((PCCERT_CONTEXT)item.lParam);
551 }
552 }
553
554 static HCERTSTORE cert_mgr_index_to_store(HWND tab, int index)
555 {
556 TCITEMW item;
557
558 item.mask = TCIF_PARAM;
559 SendMessageW(tab, TCM_GETITEMW, index, (LPARAM)&item);
560 return (HCERTSTORE)item.lParam;
561 }
562
563 static HCERTSTORE cert_mgr_current_store(HWND hwnd)
564 {
565 HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
566
567 return cert_mgr_index_to_store(tab, SendMessageW(tab, TCM_GETCURSEL, 0, 0));
568 }
569
570 static void close_stores(HWND tab)
571 {
572 int i, tabs = SendMessageW(tab, TCM_GETITEMCOUNT, 0, 0);
573
574 for (i = 0; i < tabs; i++)
575 CertCloseStore(cert_mgr_index_to_store(tab, i), 0);
576 }
577
578 static void refresh_store_certs(HWND hwnd)
579 {
580 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
581
582 free_certs(lv);
583 SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
584 show_store_certs(hwnd, cert_mgr_current_store(hwnd));
585 }
586
587 typedef enum {
588 CheckBitmapIndexUnchecked = 1,
589 CheckBitmapIndexChecked = 2,
590 CheckBitmapIndexDisabledUnchecked = 3,
591 CheckBitmapIndexDisabledChecked = 4
592 } CheckBitmapIndex;
593
594 static void add_known_usage(HWND lv, PCCRYPT_OID_INFO info,
595 CheckBitmapIndex state)
596 {
597 LVITEMW item;
598
599 item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
600 item.state = INDEXTOSTATEIMAGEMASK(state);
601 item.stateMask = LVIS_STATEIMAGEMASK;
602 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
603 item.iSubItem = 0;
604 item.lParam = (LPARAM)info;
605 item.pszText = (LPWSTR)info->pwszName;
606 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
607 }
608
609 static void add_known_usages_to_list(HWND lv, CheckBitmapIndex state)
610 {
611 PCCRYPT_OID_INFO *usages;
612
613 if (WTHelperGetKnownUsages(1, &usages))
614 {
615 PCCRYPT_OID_INFO *ptr;
616
617 for (ptr = usages; *ptr; ptr++)
618 add_known_usage(lv, *ptr, state);
619 WTHelperGetKnownUsages(2, &usages);
620 }
621 }
622
623 static void toggle_usage(HWND hwnd, int iItem)
624 {
625 LVITEMW item;
626 int res;
627 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
628
629 item.mask = LVIF_STATE;
630 item.iItem = iItem;
631 item.iSubItem = 0;
632 item.stateMask = LVIS_STATEIMAGEMASK;
633 res = SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
634 if (res)
635 {
636 int state = item.state >> 12;
637
638 item.state = INDEXTOSTATEIMAGEMASK(
639 state == CheckBitmapIndexChecked ? CheckBitmapIndexUnchecked :
640 CheckBitmapIndexChecked);
641 SendMessageW(lv, LVM_SETITEMSTATE, iItem, (LPARAM)&item);
642 }
643 }
644
645 static LONG_PTR find_oid_in_list(HWND lv, LPCSTR oid)
646 {
647 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
648 (void *)oid, CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
649 LONG_PTR ret;
650
651 if (oidInfo)
652 {
653 LVFINDINFOW findInfo;
654
655 findInfo.flags = LVFI_PARAM;
656 findInfo.lParam = (LPARAM)oidInfo;
657 ret = SendMessageW(lv, LVM_FINDITEMW, -1, (LPARAM)&findInfo);
658 }
659 else
660 {
661 LVFINDINFOA findInfo;
662
663 findInfo.flags = LVFI_STRING;
664 findInfo.psz = oid;
665 ret = SendMessageW(lv, LVM_FINDITEMA, -1, (LPARAM)&findInfo);
666 }
667 return ret;
668 }
669
670 static void save_cert_mgr_usages(HWND hwnd)
671 {
672 static const WCHAR keyName[] = { 'S','o','f','t','w','a','r','e','\\','M',
673 'i','c','r','o','s','o','f','t','\\','C','r','y','p','t','o','g','r','a',
674 'p','h','y','\\','U','I','\\','C','e','r','t','m','g','r','\\','P','u',
675 'r','p','o','s','e',0 };
676 HKEY key;
677 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
678 int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
679 LVITEMW item;
680 LPSTR str = NULL;
681
682 item.mask = LVIF_STATE | LVIF_PARAM;
683 item.iSubItem = 0;
684 item.stateMask = LVIS_STATEIMAGEMASK;
685 for (i = 0; i < purposes; i++)
686 {
687 item.iItem = i;
688 if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
689 {
690 int state = item.state >> 12;
691
692 if (state == CheckBitmapIndexUnchecked)
693 {
694 CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
695 BOOL firstString = TRUE;
696
697 if (!str)
698 str = HeapAlloc(GetProcessHeap(), 0,
699 strlen(info->pszOID) + 1);
700 else
701 {
702 str = HeapReAlloc(GetProcessHeap(), 0, str,
703 strlen(str) + 1 + strlen(info->pszOID) + 1);
704 firstString = FALSE;
705 }
706 if (str)
707 {
708 LPSTR ptr = firstString ? str : str + strlen(str);
709
710 if (!firstString)
711 *ptr++ = ',';
712 strcpy(ptr, info->pszOID);
713 }
714 }
715 }
716 }
717 if (!RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, NULL, 0, KEY_ALL_ACCESS,
718 NULL, &key, NULL))
719 {
720 if (str)
721 RegSetValueExA(key, "Purpose", 0, REG_SZ, (const BYTE *)str,
722 strlen(str) + 1);
723 else
724 RegDeleteValueA(key, "Purpose");
725 RegCloseKey(key);
726 }
727 HeapFree(GetProcessHeap(), 0, str);
728 }
729
730 static LRESULT CALLBACK cert_mgr_advanced_dlg_proc(HWND hwnd, UINT msg,
731 WPARAM wp, LPARAM lp)
732 {
733 switch (msg)
734 {
735 case WM_INITDIALOG:
736 {
737 RECT rc;
738 LVCOLUMNW column;
739 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
740 HIMAGELIST imageList;
741 LPSTR disabledUsages;
742
743 GetWindowRect(lv, &rc);
744 column.mask = LVCF_WIDTH;
745 column.cx = rc.right - rc.left;
746 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
747 imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 4, 0);
748 if (imageList)
749 {
750 HBITMAP bmp;
751 COLORREF backColor = RGB(255, 0, 255);
752
753 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
754 ImageList_AddMasked(imageList, bmp, backColor);
755 DeleteObject(bmp);
756 ImageList_SetBkColor(imageList, CLR_NONE);
757 SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)imageList);
758 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)imageList);
759 }
760 add_known_usages_to_list(lv, CheckBitmapIndexChecked);
761 if ((disabledUsages = get_cert_mgr_usages()))
762 {
763 LPSTR ptr, comma;
764
765 for (ptr = disabledUsages, comma = strchr(ptr, ','); ptr && *ptr;
766 ptr = comma ? comma + 1 : NULL,
767 comma = ptr ? strchr(ptr, ',') : NULL)
768 {
769 LONG_PTR index;
770
771 if (comma)
772 *comma = 0;
773 if ((index = find_oid_in_list(lv, ptr)) != -1)
774 toggle_usage(hwnd, index);
775 }
776 HeapFree(GetProcessHeap(), 0, disabledUsages);
777 }
778 break;
779 }
780 case WM_NOTIFY:
781 {
782 NMHDR *hdr = (NMHDR *)lp;
783 NMITEMACTIVATE *nm;
784
785 switch (hdr->code)
786 {
787 case NM_CLICK:
788 nm = (NMITEMACTIVATE *)lp;
789 toggle_usage(hwnd, nm->iItem);
790 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
791 break;
792 }
793 break;
794 }
795 case WM_COMMAND:
796 switch (wp)
797 {
798 case IDOK:
799 save_cert_mgr_usages(hwnd);
800 ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
801 EndDialog(hwnd, IDOK);
802 break;
803 case IDCANCEL:
804 ImageList_Destroy((HIMAGELIST)GetWindowLongPtrW(hwnd, DWLP_USER));
805 EndDialog(hwnd, IDCANCEL);
806 break;
807 }
808 break;
809 }
810 return 0;
811 }
812
813 static void cert_mgr_clear_cert_selection(HWND hwnd)
814 {
815 WCHAR empty[] = { 0 };
816
817 EnableWindow(GetDlgItem(hwnd, IDC_MGR_EXPORT), FALSE);
818 EnableWindow(GetDlgItem(hwnd, IDC_MGR_REMOVE), FALSE);
819 EnableWindow(GetDlgItem(hwnd, IDC_MGR_VIEW), FALSE);
820 SendMessageW(GetDlgItem(hwnd, IDC_MGR_PURPOSES), WM_SETTEXT, 0,
821 (LPARAM)empty);
822 refresh_store_certs(hwnd);
823 }
824
825 static PCCERT_CONTEXT cert_mgr_index_to_cert(HWND hwnd, int index)
826 {
827 PCCERT_CONTEXT cert = NULL;
828 LVITEMW item;
829
830 item.mask = LVIF_PARAM;
831 item.iItem = index;
832 item.iSubItem = 0;
833 if (SendMessageW(GetDlgItem(hwnd, IDC_MGR_CERTS), LVM_GETITEMW, 0,
834 (LPARAM)&item))
835 cert = (PCCERT_CONTEXT)item.lParam;
836 return cert;
837 }
838
839 static void show_selected_cert(HWND hwnd, int index)
840 {
841 PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, index);
842
843 if (cert)
844 {
845 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
846
847 memset(&viewInfo, 0, sizeof(viewInfo));
848 viewInfo.dwSize = sizeof(viewInfo);
849 viewInfo.hwndParent = hwnd;
850 viewInfo.pCertContext = cert;
851 /* FIXME: this should be modal */
852 CryptUIDlgViewCertificateW(&viewInfo, NULL);
853 }
854 }
855
856 static void cert_mgr_show_cert_usages(HWND hwnd, int index)
857 {
858 HWND text = GetDlgItem(hwnd, IDC_MGR_PURPOSES);
859 PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, index);
860 PCERT_ENHKEY_USAGE usage;
861 DWORD size;
862
863 /* Get enhanced key usage. Have to check for a property and an extension
864 * separately, because CertGetEnhancedKeyUsage will succeed and return an
865 * empty usage if neither is set. Unfortunately an empty usage implies
866 * no usage is allowed, so we have to distinguish between the two cases.
867 */
868 if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
869 NULL, &size))
870 {
871 usage = HeapAlloc(GetProcessHeap(), 0, size);
872 if (!CertGetEnhancedKeyUsage(cert,
873 CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
874 {
875 HeapFree(GetProcessHeap(), 0, usage);
876 usage = NULL;
877 }
878 }
879 else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
880 NULL, &size))
881 {
882 usage = HeapAlloc(GetProcessHeap(), 0, size);
883 if (!CertGetEnhancedKeyUsage(cert,
884 CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
885 {
886 HeapFree(GetProcessHeap(), 0, usage);
887 usage = NULL;
888 }
889 }
890 else
891 usage = NULL;
892 if (usage)
893 {
894 if (usage->cUsageIdentifier)
895 {
896 static const WCHAR commaSpace[] = { ',',' ',0 };
897 DWORD i, len = 1;
898 LPWSTR str, ptr;
899
900 for (i = 0; i < usage->cUsageIdentifier; i++)
901 {
902 PCCRYPT_OID_INFO info =
903 CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
904 usage->rgpszUsageIdentifier[i],
905 CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
906
907 if (info)
908 len += strlenW(info->pwszName);
909 else
910 len += strlen(usage->rgpszUsageIdentifier[i]);
911 if (i < usage->cUsageIdentifier - 1)
912 len += strlenW(commaSpace);
913 }
914 str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
915 if (str)
916 {
917 for (i = 0, ptr = str; i < usage->cUsageIdentifier; i++)
918 {
919 PCCRYPT_OID_INFO info =
920 CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
921 usage->rgpszUsageIdentifier[i],
922 CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
923
924 if (info)
925 {
926 strcpyW(ptr, info->pwszName);
927 ptr += strlenW(info->pwszName);
928 }
929 else
930 {
931 LPCSTR src = usage->rgpszUsageIdentifier[i];
932
933 for (; *src; ptr++, src++)
934 *ptr = *src;
935 *ptr = 0;
936 }
937 if (i < usage->cUsageIdentifier - 1)
938 {
939 strcpyW(ptr, commaSpace);
940 ptr += strlenW(commaSpace);
941 }
942 }
943 *ptr = 0;
944 SendMessageW(text, WM_SETTEXT, 0, (LPARAM)str);
945 HeapFree(GetProcessHeap(), 0, str);
946 }
947 HeapFree(GetProcessHeap(), 0, usage);
948 }
949 else
950 {
951 WCHAR buf[MAX_STRING_LEN];
952
953 LoadStringW(hInstance, IDS_ALLOWED_PURPOSE_NONE, buf,
954 sizeof(buf) / sizeof(buf[0]));
955 SendMessageW(text, WM_SETTEXT, 0, (LPARAM)buf);
956 }
957 }
958 else
959 {
960 WCHAR buf[MAX_STRING_LEN];
961
962 LoadStringW(hInstance, IDS_ALLOWED_PURPOSE_ALL, buf,
963 sizeof(buf) / sizeof(buf[0]));
964 SendMessageW(text, WM_SETTEXT, 0, (LPARAM)buf);
965 }
966 }
967
968 static void cert_mgr_do_remove(HWND hwnd)
969 {
970 int tabIndex = SendMessageW(GetDlgItem(hwnd, IDC_MGR_STORES),
971 TCM_GETCURSEL, 0, 0);
972 struct CertMgrData *data =
973 (struct CertMgrData *)GetWindowLongPtrW(hwnd, DWLP_USER);
974
975 if (tabIndex < data->nStores)
976 {
977 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
978 WCHAR warning[MAX_STRING_LEN], title[MAX_STRING_LEN];
979 LPCWSTR pTitle;
980 int warningID;
981
982 if (SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0) > 1)
983 warningID = data->stores[tabIndex].removePluralWarning;
984 else
985 warningID = data->stores[tabIndex].removeWarning;
986 if (data->title)
987 pTitle = data->title;
988 else
989 {
990 LoadStringW(hInstance, IDS_CERT_MGR, title,
991 sizeof(title) / sizeof(title[0]));
992 pTitle = title;
993 }
994 LoadStringW(hInstance, warningID, warning,
995 sizeof(warning) / sizeof(warning[0]));
996 if (MessageBoxW(hwnd, warning, pTitle, MB_YESNO) == IDYES)
997 {
998 int selection = -1;
999
1000 do {
1001 selection = SendMessageW(lv, LVM_GETNEXTITEM, selection,
1002 LVNI_SELECTED);
1003 if (selection >= 0)
1004 {
1005 PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd,
1006 selection);
1007
1008 CertDeleteCertificateFromStore(cert);
1009 }
1010 } while (selection >= 0);
1011 cert_mgr_clear_cert_selection(hwnd);
1012 }
1013 }
1014 }
1015
1016 static void cert_mgr_do_export(HWND hwnd)
1017 {
1018 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
1019 int selectionCount = SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0);
1020
1021 if (selectionCount == 1)
1022 {
1023 int selection = SendMessageW(lv, LVM_GETNEXTITEM, -1,
1024 LVNI_SELECTED);
1025
1026 if (selection >= 0)
1027 {
1028 PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd, selection);
1029
1030 if (cert)
1031 {
1032 CRYPTUI_WIZ_EXPORT_INFO info;
1033
1034 info.dwSize = sizeof(info);
1035 info.pwszExportFileName = NULL;
1036 info.dwSubjectChoice = CRYPTUI_WIZ_EXPORT_CERT_CONTEXT;
1037 info.u.pCertContext = cert;
1038 info.cStores = 0;
1039 CryptUIWizExport(0, hwnd, NULL, &info, NULL);
1040 }
1041 }
1042 }
1043 else if (selectionCount > 1)
1044 {
1045 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
1046 CERT_STORE_CREATE_NEW_FLAG, NULL);
1047
1048 if (store)
1049 {
1050 CRYPTUI_WIZ_EXPORT_INFO info;
1051 int selection = -1;
1052
1053 info.dwSize = sizeof(info);
1054 info.pwszExportFileName = NULL;
1055 info.dwSubjectChoice =
1056 CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY;
1057 info.u.hCertStore = store;
1058 info.cStores = 0;
1059 do {
1060 selection = SendMessageW(lv, LVM_GETNEXTITEM, selection,
1061 LVNI_SELECTED);
1062 if (selection >= 0)
1063 {
1064 PCCERT_CONTEXT cert = cert_mgr_index_to_cert(hwnd,
1065 selection);
1066
1067 CertAddCertificateContextToStore(store, cert,
1068 CERT_STORE_ADD_ALWAYS, NULL);
1069 }
1070 } while (selection >= 0);
1071 CryptUIWizExport(0, hwnd, NULL, &info, NULL);
1072 CertCloseStore(store, 0);
1073 }
1074 }
1075 }
1076
1077 static int cert_mgr_sort_by_text(HWND lv, int col, int index1, int index2)
1078 {
1079 LVITEMW item;
1080 WCHAR buf1[MAX_STRING_LEN];
1081 WCHAR buf2[MAX_STRING_LEN];
1082
1083 item.cchTextMax = sizeof(buf1) / sizeof(buf1[0]);
1084 item.mask = LVIF_TEXT;
1085 item.pszText = buf1;
1086 item.iItem = index1;
1087 item.iSubItem = col;
1088 SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
1089 item.pszText = buf2;
1090 item.iItem = index2;
1091 SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
1092 return strcmpW(buf1, buf2);
1093 }
1094
1095 static int CALLBACK cert_mgr_sort_by_subject(LPARAM lp1, LPARAM lp2, LPARAM lp)
1096 {
1097 return cert_mgr_sort_by_text((HWND)lp, 0, lp1, lp2);
1098 }
1099
1100 static int CALLBACK cert_mgr_sort_by_issuer(LPARAM lp1, LPARAM lp2, LPARAM lp)
1101 {
1102 return cert_mgr_sort_by_text((HWND)lp, 1, lp1, lp2);
1103 }
1104
1105 static int CALLBACK cert_mgr_sort_by_date(LPARAM lp1, LPARAM lp2, LPARAM lp)
1106 {
1107 PCCERT_CONTEXT cert1 = (PCCERT_CONTEXT)lp1;
1108 PCCERT_CONTEXT cert2 = (PCCERT_CONTEXT)lp2;
1109 return CompareFileTime(&cert1->pCertInfo->NotAfter,
1110 &cert2->pCertInfo->NotAfter);
1111 }
1112
1113 static int CALLBACK cert_mgr_sort_by_friendly_name(LPARAM lp1, LPARAM lp2,
1114 LPARAM lp)
1115 {
1116 return cert_mgr_sort_by_text((HWND)lp, 3, lp1, lp2);
1117 }
1118
1119 static LRESULT CALLBACK cert_mgr_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1120 LPARAM lp)
1121 {
1122 struct CertMgrData *data;
1123
1124 switch (msg)
1125 {
1126 case WM_INITDIALOG:
1127 {
1128 PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr =
1129 (PCCRYPTUI_CERT_MGR_STRUCT)lp;
1130 HWND tab = GetDlgItem(hwnd, IDC_MGR_STORES);
1131
1132 data = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CertMgrData));
1133 if (!data)
1134 return 0;
1135 data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
1136 if (data->imageList)
1137 {
1138 HBITMAP bmp;
1139 COLORREF backColor = RGB(255, 0, 255);
1140
1141 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
1142 ImageList_AddMasked(data->imageList, bmp, backColor);
1143 DeleteObject(bmp);
1144 ImageList_SetBkColor(data->imageList, CLR_NONE);
1145 SendMessageW(GetDlgItem(hwnd, IDC_MGR_CERTS), LVM_SETIMAGELIST,
1146 LVSIL_SMALL, (LPARAM)data->imageList);
1147 }
1148 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
1149 data->title = pCryptUICertMgr->pwszTitle;
1150
1151 initialize_purpose_selection(hwnd);
1152 add_cert_columns(hwnd);
1153 if (pCryptUICertMgr->pwszTitle)
1154 SendMessageW(hwnd, WM_SETTEXT, 0,
1155 (LPARAM)pCryptUICertMgr->pwszTitle);
1156 show_cert_stores(hwnd, pCryptUICertMgr->dwFlags, data);
1157 show_store_certs(hwnd, cert_mgr_index_to_store(tab, 0));
1158 break;
1159 }
1160 case WM_NOTIFY:
1161 {
1162 NMHDR *hdr = (NMHDR *)lp;
1163
1164 switch (hdr->code)
1165 {
1166 case TCN_SELCHANGE:
1167 cert_mgr_clear_cert_selection(hwnd);
1168 break;
1169 case LVN_ITEMCHANGED:
1170 {
1171 WCHAR empty[] = { 0 };
1172 NMITEMACTIVATE *nm = (NMITEMACTIVATE*)lp;
1173 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
1174 int numSelected = SendMessageW(lv, LVM_GETSELECTEDCOUNT, 0, 0);
1175
1176 EnableWindow(GetDlgItem(hwnd, IDC_MGR_EXPORT), numSelected > 0);
1177 EnableWindow(GetDlgItem(hwnd, IDC_MGR_REMOVE), numSelected > 0);
1178 EnableWindow(GetDlgItem(hwnd, IDC_MGR_VIEW), numSelected == 1);
1179 if (numSelected == 1)
1180 cert_mgr_show_cert_usages(hwnd, nm->iItem);
1181 else
1182 SendMessageW(GetDlgItem(hwnd, IDC_MGR_PURPOSES), WM_SETTEXT, 0,
1183 (LPARAM)empty);
1184 break;
1185 }
1186 case NM_DBLCLK:
1187 show_selected_cert(hwnd, ((NMITEMACTIVATE *)lp)->iItem);
1188 break;
1189 case LVN_KEYDOWN:
1190 {
1191 NMLVKEYDOWN *lvk = (NMLVKEYDOWN *)lp;
1192
1193 if (lvk->wVKey == VK_DELETE)
1194 cert_mgr_do_remove(hwnd);
1195 break;
1196 }
1197 case LVN_COLUMNCLICK:
1198 {
1199 NMLISTVIEW *nmlv = (NMLISTVIEW *)lp;
1200 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
1201
1202 /* FIXME: doesn't support swapping sort order between ascending
1203 * and descending.
1204 */
1205 switch (nmlv->iSubItem)
1206 {
1207 case 0:
1208 SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
1209 (LPARAM)cert_mgr_sort_by_subject);
1210 break;
1211 case 1:
1212 SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
1213 (LPARAM)cert_mgr_sort_by_issuer);
1214 break;
1215 case 2:
1216 SendMessageW(lv, LVM_SORTITEMS, 0,
1217 (LPARAM)cert_mgr_sort_by_date);
1218 break;
1219 case 3:
1220 SendMessageW(lv, LVM_SORTITEMSEX, (WPARAM)lv,
1221 (LPARAM)cert_mgr_sort_by_friendly_name);
1222 break;
1223 }
1224 break;
1225 }
1226 }
1227 break;
1228 }
1229 case WM_COMMAND:
1230 switch (wp)
1231 {
1232 case ((CBN_SELCHANGE << 16) | IDC_MGR_PURPOSE_SELECTION):
1233 cert_mgr_clear_cert_selection(hwnd);
1234 break;
1235 case IDC_MGR_IMPORT:
1236 if (CryptUIWizImport(0, hwnd, NULL, NULL,
1237 cert_mgr_current_store(hwnd)))
1238 refresh_store_certs(hwnd);
1239 break;
1240 case IDC_MGR_ADVANCED:
1241 if (DialogBoxW(hInstance, MAKEINTRESOURCEW(IDD_CERT_MGR_ADVANCED),
1242 hwnd, cert_mgr_advanced_dlg_proc) == IDOK)
1243 {
1244 HWND cb = GetDlgItem(hwnd, IDC_MGR_PURPOSE_SELECTION);
1245 int index, len;
1246 LPWSTR curString = NULL;
1247
1248 index = SendMessageW(cb, CB_GETCURSEL, 0, 0);
1249 if (index >= 0)
1250 {
1251 len = SendMessageW(cb, CB_GETLBTEXTLEN, index, 0);
1252 curString = HeapAlloc(GetProcessHeap(), 0,
1253 (len + 1) * sizeof(WCHAR));
1254 SendMessageW(cb, CB_GETLBTEXT, index, (LPARAM)curString);
1255 }
1256 SendMessageW(cb, CB_RESETCONTENT, 0, 0);
1257 initialize_purpose_selection(hwnd);
1258 if (curString)
1259 {
1260 index = SendMessageW(cb, CB_FINDSTRINGEXACT, -1,
1261 (LPARAM)curString);
1262 if (index >= 0)
1263 SendMessageW(cb, CB_SETCURSEL, index, 0);
1264 HeapFree(GetProcessHeap(), 0, curString);
1265 }
1266 refresh_store_certs(hwnd);
1267 }
1268 break;
1269 case IDC_MGR_VIEW:
1270 {
1271 HWND lv = GetDlgItem(hwnd, IDC_MGR_CERTS);
1272 int selection = SendMessageW(lv, LVM_GETNEXTITEM, -1,
1273 LVNI_SELECTED);
1274
1275 if (selection >= 0)
1276 show_selected_cert(hwnd, selection);
1277 break;
1278 }
1279 case IDC_MGR_EXPORT:
1280 cert_mgr_do_export(hwnd);
1281 break;
1282 case IDC_MGR_REMOVE:
1283 cert_mgr_do_remove(hwnd);
1284 break;
1285 case IDCANCEL:
1286 free_certs(GetDlgItem(hwnd, IDC_MGR_CERTS));
1287 close_stores(GetDlgItem(hwnd, IDC_MGR_STORES));
1288 data = (struct CertMgrData *)GetWindowLongPtrW(hwnd, DWLP_USER);
1289 ImageList_Destroy(data->imageList);
1290 HeapFree(GetProcessHeap(), 0, data);
1291 EndDialog(hwnd, IDCANCEL);
1292 break;
1293 }
1294 break;
1295 }
1296 return 0;
1297 }
1298
1299 /***********************************************************************
1300 * CryptUIDlgCertMgr (CRYPTUI.@)
1301 */
1302 BOOL WINAPI CryptUIDlgCertMgr(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
1303 {
1304 TRACE("(%p)\n", pCryptUICertMgr);
1305
1306 if (pCryptUICertMgr->dwSize != sizeof(CRYPTUI_CERT_MGR_STRUCT))
1307 {
1308 WARN("unexpected size %d\n", pCryptUICertMgr->dwSize);
1309 SetLastError(E_INVALIDARG);
1310 return FALSE;
1311 }
1312 DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_CERT_MGR),
1313 pCryptUICertMgr->hwndParent, cert_mgr_dlg_proc, (LPARAM)pCryptUICertMgr);
1314 return TRUE;
1315 }
1316
1317 /* FIXME: real names are unknown, functions are undocumented */
1318 typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS
1319 {
1320 DWORD dwFlags;
1321 void *pvSystemStoreLocationPara;
1322 } CRYPTUI_ENUM_SYSTEM_STORE_ARGS, *PCRYPTUI_ENUM_SYSTEM_STORE_ARGS;
1323
1324 typedef struct _CRYPTUI_ENUM_DATA
1325 {
1326 DWORD cStores;
1327 HCERTSTORE *rghStore;
1328 DWORD cEnumArgs;
1329 PCRYPTUI_ENUM_SYSTEM_STORE_ARGS rgEnumArgs;
1330 } CRYPTUI_ENUM_DATA, *PCRYPTUI_ENUM_DATA;
1331
1332 typedef BOOL (WINAPI *PFN_SELECTED_STORE_CB)(HCERTSTORE store, HWND hwnd,
1333 void *pvArg);
1334
1335 /* Values for dwFlags */
1336 #define CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE 0x00000001
1337
1338 typedef struct _CRYPTUI_SELECTSTORE_INFO_A
1339 {
1340 DWORD dwSize;
1341 HWND parent;
1342 DWORD dwFlags;
1343 LPSTR pszTitle;
1344 LPSTR pszText;
1345 CRYPTUI_ENUM_DATA *pEnumData;
1346 PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
1347 void *pvArg;
1348 } CRYPTUI_SELECTSTORE_INFO_A, *PCRYPTUI_SELECTSTORE_INFO_A;
1349
1350 typedef struct _CRYPTUI_SELECTSTORE_INFO_W
1351 {
1352 DWORD dwSize;
1353 HWND parent;
1354 DWORD dwFlags;
1355 LPWSTR pwszTitle;
1356 LPWSTR pwszText;
1357 CRYPTUI_ENUM_DATA *pEnumData;
1358 PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
1359 void *pvArg;
1360 } CRYPTUI_SELECTSTORE_INFO_W, *PCRYPTUI_SELECTSTORE_INFO_W;
1361
1362 struct StoreInfo
1363 {
1364 enum {
1365 StoreHandle,
1366 SystemStore
1367 } type;
1368 union {
1369 HCERTSTORE store;
1370 LPWSTR name;
1371 } DUMMYUNIONNAME;
1372 };
1373
1374 static BOOL WINAPI enum_store_callback(const void *pvSystemStore,
1375 DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved,
1376 void *pvArg)
1377 {
1378 HWND tree = GetDlgItem(pvArg, IDC_STORE_LIST);
1379 TVINSERTSTRUCTW tvis;
1380 LPCWSTR localizedName;
1381 BOOL ret = TRUE;
1382
1383 tvis.hParent = NULL;
1384 tvis.hInsertAfter = TVI_LAST;
1385 tvis.u.item.mask = TVIF_TEXT;
1386 if ((localizedName = CryptFindLocalizedName(pvSystemStore)))
1387 {
1388 struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(), 0,
1389 sizeof(struct StoreInfo));
1390
1391 if (storeInfo)
1392 {
1393 storeInfo->type = SystemStore;
1394 storeInfo->u.name = HeapAlloc(GetProcessHeap(), 0,
1395 (strlenW(pvSystemStore) + 1) * sizeof(WCHAR));
1396 if (storeInfo->u.name)
1397 {
1398 tvis.u.item.mask |= TVIF_PARAM;
1399 tvis.u.item.lParam = (LPARAM)storeInfo;
1400 strcpyW(storeInfo->u.name, pvSystemStore);
1401 }
1402 else
1403 {
1404 HeapFree(GetProcessHeap(), 0, storeInfo);
1405 ret = FALSE;
1406 }
1407 }
1408 else
1409 ret = FALSE;
1410 tvis.u.item.pszText = (LPWSTR)localizedName;
1411 }
1412 else
1413 tvis.u.item.pszText = (LPWSTR)pvSystemStore;
1414 /* FIXME: need a folder icon for the store too */
1415 if (ret)
1416 SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
1417 return ret;
1418 }
1419
1420 static void enumerate_stores(HWND hwnd, CRYPTUI_ENUM_DATA *pEnumData)
1421 {
1422 DWORD i;
1423 HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
1424
1425 for (i = 0; i < pEnumData->cEnumArgs; i++)
1426 CertEnumSystemStore(pEnumData->rgEnumArgs[i].dwFlags,
1427 pEnumData->rgEnumArgs[i].pvSystemStoreLocationPara,
1428 hwnd, enum_store_callback);
1429 for (i = 0; i < pEnumData->cStores; i++)
1430 {
1431 DWORD size;
1432
1433 if (CertGetStoreProperty(pEnumData->rghStore[i],
1434 CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, &size))
1435 {
1436 LPWSTR name = HeapAlloc(GetProcessHeap(), 0, size);
1437
1438 if (name)
1439 {
1440 if (CertGetStoreProperty(pEnumData->rghStore[i],
1441 CERT_STORE_LOCALIZED_NAME_PROP_ID, name, &size))
1442 {
1443 struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(),
1444 0, sizeof(struct StoreInfo));
1445
1446 if (storeInfo)
1447 {
1448 TVINSERTSTRUCTW tvis;
1449
1450 storeInfo->type = StoreHandle;
1451 storeInfo->u.store = pEnumData->rghStore[i];
1452 tvis.hParent = NULL;
1453 tvis.hInsertAfter = TVI_LAST;
1454 tvis.u.item.mask = TVIF_TEXT | TVIF_PARAM;
1455 tvis.u.item.pszText = name;
1456 tvis.u.item.lParam = (LPARAM)storeInfo;
1457 SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
1458 }
1459 }
1460 HeapFree(GetProcessHeap(), 0, name);
1461 }
1462 }
1463 }
1464 }
1465
1466 static void free_store_info(HWND tree)
1467 {
1468 HTREEITEM next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CHILD,
1469 0);
1470
1471 while (next)
1472 {
1473 TVITEMW item;
1474
1475 memset(&item, 0, sizeof(item));
1476 item.mask = TVIF_HANDLE | TVIF_PARAM;
1477 item.hItem = next;
1478 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
1479 if (item.lParam)
1480 {
1481 struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
1482
1483 if (storeInfo->type == SystemStore)
1484 HeapFree(GetProcessHeap(), 0, storeInfo->u.name);
1485 HeapFree(GetProcessHeap(), 0, storeInfo);
1486 }
1487 next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_NEXT,
1488 (LPARAM)next);
1489 }
1490 }
1491
1492 static HCERTSTORE selected_item_to_store(HWND tree, HTREEITEM hItem)
1493 {
1494 WCHAR buf[MAX_STRING_LEN];
1495 TVITEMW item;
1496 HCERTSTORE store;
1497
1498 memset(&item, 0, sizeof(item));
1499 item.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT;
1500 item.hItem = hItem;
1501 item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
1502 item.pszText = buf;
1503 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
1504 if (item.lParam)
1505 {
1506 struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
1507
1508 if (storeInfo->type == StoreHandle)
1509 store = storeInfo->u.store;
1510 else
1511 store = CertOpenSystemStoreW(0, storeInfo->u.name);
1512 }
1513 else
1514 {
1515 /* It's implicitly a system store */
1516 store = CertOpenSystemStoreW(0, buf);
1517 }
1518 return store;
1519 }
1520
1521 struct SelectStoreInfo
1522 {
1523 PCRYPTUI_SELECTSTORE_INFO_W info;
1524 HCERTSTORE store;
1525 };
1526
1527 static LRESULT CALLBACK select_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1528 LPARAM lp)
1529 {
1530 struct SelectStoreInfo *selectInfo;
1531 LRESULT ret = 0;
1532
1533 switch (msg)
1534 {
1535 case WM_INITDIALOG:
1536 {
1537 selectInfo = (struct SelectStoreInfo *)lp;
1538 SetWindowLongPtrW(hwnd, DWLP_USER, lp);
1539 if (selectInfo->info->pwszTitle)
1540 SendMessageW(hwnd, WM_SETTEXT, 0,
1541 (LPARAM)selectInfo->info->pwszTitle);
1542 if (selectInfo->info->pwszText)
1543 SendMessageW(GetDlgItem(hwnd, IDC_STORE_TEXT), WM_SETTEXT, 0,
1544 (LPARAM)selectInfo->info->pwszText);
1545 if (!(selectInfo->info->dwFlags & CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE))
1546 ShowWindow(GetDlgItem(hwnd, IDC_SHOW_PHYSICAL_STORES), FALSE);
1547 enumerate_stores(hwnd, selectInfo->info->pEnumData);
1548 break;
1549 }
1550 case WM_COMMAND:
1551 switch (wp)
1552 {
1553 case IDOK:
1554 {
1555 HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
1556 HTREEITEM selection = (HTREEITEM)SendMessageW(tree,
1557 TVM_GETNEXTITEM, TVGN_CARET, 0);
1558
1559 selectInfo = (struct SelectStoreInfo *)GetWindowLongPtrW(hwnd,
1560 DWLP_USER);
1561 if (!selection)
1562 {
1563 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN], *pTitle;
1564
1565 if (selectInfo->info->pwszTitle)
1566 pTitle = selectInfo->info->pwszTitle;
1567 else
1568 {
1569 LoadStringW(hInstance, IDS_SELECT_STORE_TITLE, title,
1570 sizeof(title) / sizeof(title[0]));
1571 pTitle = title;
1572 }
1573 LoadStringW(hInstance, IDS_SELECT_STORE, error,
1574 sizeof(error) / sizeof(error[0]));
1575 MessageBoxW(hwnd, error, pTitle, MB_ICONEXCLAMATION | MB_OK);
1576 }
1577 else
1578 {
1579 HCERTSTORE store = selected_item_to_store(tree, selection);
1580
1581 if (!selectInfo->info->pfnSelectedStoreCallback ||
1582 selectInfo->info->pfnSelectedStoreCallback(store, hwnd,
1583 selectInfo->info->pvArg))
1584 {
1585 selectInfo->store = store;
1586 free_store_info(tree);
1587 EndDialog(hwnd, IDOK);
1588 }
1589 else
1590 CertCloseStore(store, 0);
1591 }
1592 ret = TRUE;
1593 break;
1594 }
1595 case IDCANCEL:
1596 free_store_info(GetDlgItem(hwnd, IDC_STORE_LIST));
1597 EndDialog(hwnd, IDCANCEL);
1598 ret = TRUE;
1599 break;
1600 }
1601 break;
1602 }
1603 return ret;
1604 }
1605
1606 /***********************************************************************
1607 * CryptUIDlgSelectStoreW (CRYPTUI.@)
1608 */
1609 HCERTSTORE WINAPI CryptUIDlgSelectStoreW(PCRYPTUI_SELECTSTORE_INFO_W info)
1610 {
1611 struct SelectStoreInfo selectInfo = { info, NULL };
1612
1613 TRACE("(%p)\n", info);
1614
1615 if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_W))
1616 {
1617 WARN("unexpected size %d\n", info->dwSize);
1618 SetLastError(E_INVALIDARG);
1619 return NULL;
1620 }
1621 DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_SELECT_STORE), info->parent,
1622 select_store_dlg_proc, (LPARAM)&selectInfo);
1623 return selectInfo.store;
1624 }
1625
1626 /***********************************************************************
1627 * CryptUIDlgSelectStoreA (CRYPTUI.@)
1628 */
1629 HCERTSTORE WINAPI CryptUIDlgSelectStoreA(PCRYPTUI_SELECTSTORE_INFO_A info)
1630 {
1631 CRYPTUI_SELECTSTORE_INFO_W infoW;
1632 HCERTSTORE ret;
1633 int len;
1634
1635 TRACE("(%p)\n", info);
1636
1637 if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_A))
1638 {
1639 WARN("unexpected size %d\n", info->dwSize);
1640 SetLastError(E_INVALIDARG);
1641 return NULL;
1642 }
1643 memcpy(&infoW, info, sizeof(*info));
1644 if (info->pszTitle)
1645 {
1646 len = MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, NULL, 0);
1647 infoW.pwszTitle = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1648 MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, infoW.pwszTitle,
1649 len);
1650 }
1651 if (info->pszText)
1652 {
1653 len = MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, NULL, 0);
1654 infoW.pwszText = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1655 MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, infoW.pwszText, len);
1656 }
1657 ret = CryptUIDlgSelectStoreW(&infoW);
1658 HeapFree(GetProcessHeap(), 0, infoW.pwszText);
1659 HeapFree(GetProcessHeap(), 0, infoW.pwszTitle);
1660 return ret;
1661 }
1662
1663 /***********************************************************************
1664 * CryptUIDlgViewCertificateA (CRYPTUI.@)
1665 */
1666 BOOL WINAPI CryptUIDlgViewCertificateA(
1667 PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
1668 {
1669 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
1670 LPWSTR title = NULL;
1671 BOOL ret;
1672
1673 TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
1674
1675 memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
1676 if (pCertViewInfo->szTitle)
1677 {
1678 int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
1679 NULL, 0);
1680
1681 title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1682 if (title)
1683 {
1684 MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
1685 len);
1686 viewInfo.szTitle = title;
1687 }
1688 else
1689 {
1690 ret = FALSE;
1691 goto error;
1692 }
1693 }
1694 if (pCertViewInfo->cPropSheetPages)
1695 {
1696 FIXME("ignoring additional prop sheet pages\n");
1697 viewInfo.cPropSheetPages = 0;
1698 }
1699 ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
1700 HeapFree(GetProcessHeap(), 0, title);
1701 error:
1702 return ret;
1703 }
1704
1705 struct ReadStringStruct
1706 {
1707 LPCWSTR buf;
1708 LONG pos;
1709 LONG len;
1710 };
1711
1712 static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
1713 LONG cb, LONG *pcb)
1714 {
1715 struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
1716 LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
1717
1718 TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
1719
1720 memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
1721 string->pos += cch;
1722 *pcb = cch * sizeof(WCHAR);
1723 return 0;
1724 }
1725
1726 static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
1727 {
1728 struct ReadStringStruct string;
1729 EDITSTREAM editstream;
1730
1731 TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
1732
1733 string.buf = text;
1734 string.pos = 0;
1735 string.len = len;
1736 editstream.dwCookie = (DWORD_PTR)&string;
1737 editstream.dwError = 0;
1738 editstream.pfnCallback = read_text_callback;
1739 SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
1740 (LPARAM)&editstream);
1741 }
1742
1743 static void add_string_resource_to_control(HWND hwnd, int id)
1744 {
1745 LPWSTR str;
1746 LONG len;
1747
1748 len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
1749 add_unformatted_text_to_control(hwnd, str, len);
1750 }
1751
1752 static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
1753 LONG len, const PARAFORMAT2 *fmt)
1754 {
1755 add_unformatted_text_to_control(hwnd, text, len);
1756 SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
1757 }
1758
1759 static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
1760 const PARAFORMAT2 *fmt)
1761 {
1762 LPWSTR str;
1763 LONG len;
1764
1765 len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
1766 add_text_with_paraformat_to_control(hwnd, str, len, fmt);
1767 }
1768
1769 static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
1770 DWORD dwFlags)
1771 {
1772 LPWSTR buf = NULL;
1773 DWORD len;
1774
1775 len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
1776 if (len)
1777 {
1778 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1779 if (buf)
1780 CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
1781 }
1782 return buf;
1783 }
1784
1785 static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
1786 DWORD dwType, DWORD dwFlags)
1787 {
1788 LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
1789
1790 if (name)
1791 {
1792 /* Don't include NULL-terminator in output */
1793 DWORD len = lstrlenW(name);
1794
1795 add_unformatted_text_to_control(hwnd, name, len);
1796 HeapFree(GetProcessHeap(), 0, name);
1797 }
1798 }
1799
1800 static void add_icon_to_control(HWND hwnd, int id)
1801 {
1802 HRESULT hr;
1803 LPRICHEDITOLE richEditOle = NULL;
1804 LPOLEOBJECT object = NULL;
1805 CLSID clsid;
1806 LPOLECACHE oleCache = NULL;
1807 FORMATETC formatEtc;
1808 DWORD conn;
1809 LPDATAOBJECT dataObject = NULL;
1810 HBITMAP bitmap = NULL;
1811 STGMEDIUM stgm;
1812 LPOLECLIENTSITE clientSite = NULL;
1813 REOBJECT reObject;
1814
1815 TRACE("(%p, %d)\n", hwnd, id);
1816
1817 SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
1818 if (!richEditOle)
1819 goto end;
1820 hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
1821 (void**)&object);
1822 if (FAILED(hr))
1823 goto end;
1824 hr = IOleObject_GetUserClassID(object, &clsid);
1825 if (FAILED(hr))
1826 goto end;
1827 hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
1828 if (FAILED(hr))
1829 goto end;
1830 formatEtc.cfFormat = CF_BITMAP;
1831 formatEtc.ptd = NULL;
1832 formatEtc.dwAspect = DVASPECT_CONTENT;
1833 formatEtc.lindex = -1;
1834 formatEtc.tymed = TYMED_GDI;
1835 hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
1836 if (FAILED(hr))
1837 goto end;
1838 hr = IOleObject_QueryInterface(object, &IID_IDataObject,
1839 (void**)&dataObject);
1840 if (FAILED(hr))
1841 goto end;
1842 hr = IRichEditOle_GetClientSite(richEditOle, &clientSite);
1843 if (FAILED(hr))
1844 goto end;
1845 bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
1846 LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
1847 if (!bitmap)
1848 goto end;
1849 stgm.tymed = TYMED_GDI;
1850 stgm.u.hBitmap = bitmap;
1851 stgm.pUnkForRelease = NULL;
1852 hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
1853 if (FAILED(hr))
1854 goto end;
1855
1856 reObject.cbStruct = sizeof(reObject);
1857 reObject.cp = REO_CP_SELECTION;
1858 reObject.clsid = clsid;
1859 reObject.poleobj = object;
1860 reObject.pstg = NULL;
1861 reObject.polesite = clientSite;
1862 reObject.sizel.cx = reObject.sizel.cy = 0;
1863 reObject.dvaspect = DVASPECT_CONTENT;
1864 reObject.dwFlags = 0;
1865 reObject.dwUser = 0;
1866
1867 IRichEditOle_InsertObject(richEditOle, &reObject);
1868
1869 end:
1870 if (clientSite)
1871 IOleClientSite_Release(clientSite);
1872 if (dataObject)
1873 IDataObject_Release(dataObject);
1874 if (oleCache)
1875 IOleCache_Release(oleCache);
1876 if (object)
1877 IOleObject_Release(object);
1878 if (richEditOle)
1879 IRichEditOle_Release(richEditOle);
1880 }
1881
1882 #define MY_INDENT 200
1883
1884 static void add_oid_text_to_control(HWND hwnd, char *oid)
1885 {
1886 WCHAR nl = '\n';
1887 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
1888 PARAFORMAT2 parFmt;
1889
1890 parFmt.cbSize = sizeof(parFmt);
1891 parFmt.dwMask = PFM_STARTINDENT;
1892 parFmt.dxStartIndent = MY_INDENT * 3;
1893 if (oidInfo)
1894 {
1895 add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
1896 lstrlenW(oidInfo->pwszName), &parFmt);
1897 add_unformatted_text_to_control(hwnd, &nl, 1);
1898 }
1899 }
1900
1901 struct OIDToString
1902 {
1903 LPCSTR oid;
1904 int id;
1905 };
1906
1907 /* The following list MUST be lexicographically sorted by OID */
1908 static struct OIDToString oidMap[] = {
1909 /* 1.3.6.1.4.1.311.10.3.1 */
1910 { szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
1911 /* 1.3.6.1.4.1.311.10.3.4 */
1912 { szOID_KP_EFS, IDS_PURPOSE_EFS },
1913 /* 1.3.6.1.4.1.311.10.3.4.1 */
1914 { szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
1915 /* 1.3.6.1.4.1.311.10.3.5 */
1916 { szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
1917 /* 1.3.6.1.4.1.311.10.3.6 */
1918 { szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
1919 /* 1.3.6.1.4.1.311.10.3.7 */
1920 { szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
1921 /* 1.3.6.1.4.1.311.10.3.8 */
1922 { szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
1923 /* 1.3.6.1.4.1.311.10.3.9 */
1924 { szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
1925 /* 1.3.6.1.4.1.311.10.3.10 */
1926 { szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
1927 /* 1.3.6.1.4.1.311.10.3.11 */
1928 { szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
1929 /* 1.3.6.1.4.1.311.10.3.12 */
1930 { szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
1931 /* 1.3.6.1.4.1.311.10.3.13 */
1932 { szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
1933 /* 1.3.6.1.4.1.311.10.5.1 */
1934 { szOID_DRM, IDS_PURPOSE_DRM },
1935 /* 1.3.6.1.4.1.311.10.6.1 */
1936 { szOID_LICENSES, IDS_PURPOSE_LICENSES },
1937 /* 1.3.6.1.4.1.311.10.6.2 */
1938 { szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
1939 /* 1.3.6.1.4.1.311.20.2.1 */
1940 { szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
1941 /* 1.3.6.1.4.1.311.20.2.2 */
1942 { szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
1943 /* 1.3.6.1.4.1.311.21.5 */
1944 { szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
1945 /* 1.3.6.1.4.1.311.21.6 */
1946 { szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
1947 /* 1.3.6.1.4.1.311.21.19 */
1948 { szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
1949 /* 1.3.6.1.5.5.7.3.1 */
1950 { szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
1951 /* 1.3.6.1.5.5.7.3.2 */
1952 { szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
1953 /* 1.3.6.1.5.5.7.3.3 */
1954 { szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
1955 /* 1.3.6.1.5.5.7.3.4 */
1956 { szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
1957 /* 1.3.6.1.5.5.7.3.5 */
1958 { szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
1959 /* 1.3.6.1.5.5.7.3.6 */
1960 { szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
1961 /* 1.3.6.1.5.5.7.3.7 */
1962 { szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
1963 /* 1.3.6.1.5.5.7.3.8 */
1964 { szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
1965 };
1966
1967 static struct OIDToString *findSupportedOID(LPCSTR oid)
1968 {
1969 int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0;
1970
1971 while (indexLow <= indexHigh)
1972 {
1973 int cmp, i = (indexLow + indexHigh) / 2;
1974 if (!(cmp = strcmp(oid, oidMap[i].oid)))
1975 return &oidMap[i];
1976 if (cmp > 0)
1977 indexLow = i + 1;
1978 else
1979 indexHigh = i - 1;
1980 }
1981 return NULL;
1982 }
1983
1984 static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
1985 {
1986 struct OIDToString *entry;
1987 WCHAR nl = '\n';
1988 PARAFORMAT2 parFmt;
1989
1990 parFmt.cbSize = sizeof(parFmt);
1991 parFmt.dwMask = PFM_STARTINDENT;
1992 parFmt.dxStartIndent = MY_INDENT * 3;
1993 if ((entry = findSupportedOID(oid)))
1994 {
1995 WCHAR *str, *linebreak, *ptr;
1996 BOOL multiline = FALSE;
1997 int len;
1998
1999 len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
2000 ptr = str;
2001 do {
2002 if ((linebreak = memchrW(ptr, '\n', len)))
2003 {
2004 WCHAR copy[MAX_STRING_LEN];
2005
2006 multiline = TRUE;
2007 /* The source string contains a newline, which the richedit
2008 * control won't find since it's interpreted as a paragraph
2009 * break. Therefore copy up to the newline. lstrcpynW always
2010 * NULL-terminates, so pass one more than the length of the
2011 * source line so the copy includes the entire line and the
2012 * NULL-terminator.
2013 */
2014 lstrcpynW(copy, ptr, linebreak - ptr + 1);
2015 add_text_with_paraformat_to_control(text, copy,
2016 linebreak - ptr, &parFmt);
2017 ptr = linebreak + 1;
2018 add_unformatted_text_to_control(text, &nl, 1);
2019 }
2020 else if (multiline && *ptr)
2021 {
2022 /* Add the last line */
2023 add_text_with_paraformat_to_control(text, ptr,
2024 len - (ptr - str), &parFmt);
2025 add_unformatted_text_to_control(text, &nl, 1);
2026 }
2027 } while (linebreak);
2028 if (!multiline)
2029 {
2030 add_text_with_paraformat_to_control(text, str, len, &parFmt);
2031 add_unformatted_text_to_control(text, &nl, 1);
2032 }
2033 }
2034 else
2035 {
2036 WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
2037 (strlen(oid) + 1) * sizeof(WCHAR));
2038
2039 if (oidW)
2040 {
2041 LPCSTR src;
2042 WCHAR *dst;
2043
2044 for (src = oid, dst = oidW; *src; src++, dst++)
2045 *dst = *src;
2046 *dst = 0;
2047 add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
2048 &parFmt);
2049 add_unformatted_text_to_control(text, &nl, 1);
2050 HeapFree(GetProcessHeap(), 0, oidW);
2051 }
2052 }
2053 }
2054
2055 static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
2056 BOOL *anyUsageAdded)
2057 {
2058 static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
2059 WCHAR nl = '\n';
2060 CHARFORMATW charFmt;
2061 PCERT_EXTENSION policyExt;
2062 if (!*anyUsageAdded)
2063 {
2064 PARAFORMAT2 parFmt;
2065
2066 parFmt.cbSize = sizeof(parFmt);
2067 parFmt.dwMask = PFM_STARTINDENT;
2068 parFmt.dxStartIndent = MY_INDENT;
2069 add_string_resource_with_paraformat_to_control(text,
2070 IDS_CERT_INFO_PURPOSES, &parFmt);
2071 add_unformatted_text_to_control(text, &nl, 1);
2072 *anyUsageAdded = TRUE;
2073 }
2074 memset(&charFmt, 0, sizeof(charFmt));
2075 charFmt.cbSize = sizeof(charFmt);
2076 charFmt.dwMask = CFM_BOLD;
2077 charFmt.dwEffects = 0;
2078 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2079 if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
2080 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
2081 {
2082 CERT_POLICIES_INFO *policies;
2083 DWORD size;
2084
2085 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
2086 policyExt->Value.pbData, policyExt->Value.cbData,
2087 CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
2088 {
2089 DWORD i;
2090
2091 for (i = 0; i < policies->cPolicyInfo; i++)
2092 {
2093 DWORD j;
2094
2095 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
2096 add_local_oid_text_to_control(text,
2097 policies->rgPolicyInfo[i].rgPolicyQualifier[j].
2098 pszPolicyQualifierId);
2099 }
2100 LocalFree(policies);
2101 }
2102 }
2103 else
2104 add_oid_text_to_control(text, any_app_policy);
2105 }
2106
2107 static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
2108 BOOL *anyUsageAdded)
2109 {
2110 WCHAR nl = '\n';
2111 DWORD size;
2112 BOOL badUsages = FALSE;
2113
2114 if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
2115 {
2116 CHARFORMATW charFmt;
2117 static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
2118 PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
2119
2120 if (usage)
2121 {
2122 if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
2123 {
2124 DWORD i;
2125
2126 if (!*anyUsageAdded)
2127 {
2128 PARAFORMAT2 parFmt;
2129
2130 parFmt.cbSize = sizeof(parFmt);
2131 parFmt.dwMask = PFM_STARTINDENT;
2132 parFmt.dxStartIndent = MY_INDENT;
2133 add_string_resource_with_paraformat_to_control(text,
2134 IDS_CERT_INFO_PURPOSES, &parFmt);
2135 add_unformatted_text_to_control(text, &nl, 1);
2136 *anyUsageAdded = TRUE;
2137 }
2138 memset(&charFmt, 0, sizeof(charFmt));
2139 charFmt.cbSize = sizeof(charFmt);
2140 charFmt.dwMask = CFM_BOLD;
2141 charFmt.dwEffects = 0;
2142 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
2143 (LPARAM)&charFmt);
2144 if (!usage->cUsageIdentifier)
2145 add_oid_text_to_control(text, any_cert_policy);
2146 else
2147 for (i = 0; i < usage->cUsageIdentifier; i++)
2148 add_local_oid_text_to_control(text,
2149 usage->rgpszUsageIdentifier[i]);
2150 }
2151 else
2152 badUsages = TRUE;
2153 HeapFree(GetProcessHeap(), 0, usage);
2154 }
2155 else
2156 badUsages = TRUE;
2157 }
2158 else
2159 badUsages = TRUE;
2160 return badUsages;
2161 }
2162
2163 static void set_policy_text(HWND text,
2164 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2165 {
2166 BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
2167 BOOL badUsages = FALSE, anyUsageAdded = FALSE;
2168
2169 if (pCertViewInfo->cPurposes)
2170 {
2171 DWORD i;
2172
2173 for (i = 0; i < pCertViewInfo->cPurposes; i++)
2174 {
2175 if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
2176 includeCertUsages = TRUE;
2177 else if (!strcmp(pCertViewInfo->rgszPurposes[i],
2178 szOID_ANY_APPLICATION_POLICY))
2179 includeAppUsages = TRUE;
2180 else
2181 badUsages = TRUE;
2182 }
2183 }
2184 else
2185 includeAppUsages = includeCertUsages = TRUE;
2186 if (includeAppUsages)
2187 display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
2188 if (includeCertUsages)
2189 badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
2190 &anyUsageAdded);
2191 if (badUsages)
2192 {
2193 PARAFORMAT2 parFmt;
2194
2195 parFmt.cbSize = sizeof(parFmt);
2196 parFmt.dwMask = PFM_STARTINDENT;
2197 parFmt.dxStartIndent = MY_INDENT;
2198 add_string_resource_with_paraformat_to_control(text,
2199 IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
2200 }
2201 }
2202
2203 static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
2204 LPCSTR policyOid)
2205 {
2206 CRYPT_OBJID_BLOB *ret = NULL;
2207 DWORD i;
2208
2209 for (i = 0; !ret && i < policies->cPolicyInfo; i++)
2210 {
2211 DWORD j;
2212
2213 for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
2214 if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
2215 pszPolicyQualifierId, policyOid))
2216 ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
2217 Qualifier;
2218 }
2219 return ret;
2220 }
2221
2222 static WCHAR *get_cps_str_from_qualifier(const CRYPT_OBJID_BLOB *qualifier)
2223 {
2224 LPWSTR qualifierStr = NULL;
2225 CERT_NAME_VALUE *qualifierValue;
2226 DWORD size;
2227
2228 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
2229 qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
2230 &qualifierValue, &size))
2231 {
2232 size = CertRDNValueToStrW(qualifierValue->dwValueType,
2233 &qualifierValue->Value, NULL, 0);
2234 qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
2235 if (qualifierStr)
2236 CertRDNValueToStrW(qualifierValue->dwValueType,
2237 &qualifierValue->Value, qualifierStr, size);
2238 LocalFree(qualifierValue);
2239 }
2240 return qualifierStr;
2241 }
2242
2243 static WCHAR *get_user_notice_from_qualifier(const CRYPT_OBJID_BLOB *qualifier)
2244 {
2245 LPWSTR str = NULL;
2246 CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
2247 DWORD size;
2248
2249 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
2250 X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
2251 qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
2252 &qualifierValue, &size))
2253 {
2254 str = HeapAlloc(GetProcessHeap(), 0,
2255 (strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
2256 if (str)
2257 strcpyW(str, qualifierValue->pszDisplayText);
2258 LocalFree(qualifierValue);
2259 }
2260 return str;
2261 }
2262
2263 struct IssuerStatement
2264 {
2265 LPWSTR cps;
2266 LPWSTR userNotice;
2267 };
2268
2269 static void set_issuer_statement(HWND hwnd,
2270 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2271 {
2272 PCERT_EXTENSION policyExt;
2273
2274 if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
2275 (policyExt = CertFindExtension(szOID_CERT_POLICIES,
2276 pCertViewInfo->pCertContext->pCertInfo->cExtension,
2277 pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
2278 {
2279 CERT_POLICIES_INFO *policies;
2280 DWORD size;
2281
2282 if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
2283 policyExt->Value.pbData, policyExt->Value.cbData,
2284 CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
2285 {
2286 CRYPT_OBJID_BLOB *qualifier;
2287 LPWSTR cps = NULL, userNotice = NULL;
2288
2289 if ((qualifier = find_policy_qualifier(policies,
2290 szOID_PKIX_POLICY_QUALIFIER_CPS)))
2291 cps = get_cps_str_from_qualifier(qualifier);
2292 if ((qualifier = find_policy_qualifier(policies,
2293 szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
2294 userNotice = get_user_notice_from_qualifier(qualifier);
2295 if (cps || userNotice)
2296 {
2297 struct IssuerStatement *issuerStatement =
2298 HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
2299
2300 if (issuerStatement)
2301 {
2302 issuerStatement->cps = cps;
2303 issuerStatement->userNotice = userNotice;
2304 EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
2305 SetWindowLongPtrW(hwnd, DWLP_USER,
2306 (ULONG_PTR)issuerStatement);
2307 }
2308 }
2309 LocalFree(policies);
2310 }
2311 }
2312 }
2313
2314 static void set_cert_info(HWND hwnd,
2315 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2316 {
2317 CHARFORMATW charFmt;
2318 PARAFORMAT2 parFmt;
2319 HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
2320 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
2321 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2322 (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
2323 pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
2324 pCertViewInfo->idxCounterSigner);
2325 CRYPT_PROVIDER_CERT *root =
2326 &provSigner->pasCertChain[provSigner->csCertChain - 1];
2327
2328 if (!provSigner->pChainContext ||
2329 (provSigner->pChainContext->TrustStatus.dwErrorStatus &
2330 CERT_TRUST_IS_PARTIAL_CHAIN))
2331 add_icon_to_control(icon, IDB_CERT_WARNING);
2332 else if (!root->fTrustedRoot)
2333 add_icon_to_control(icon, IDB_CERT_ERROR);
2334 else
2335 add_icon_to_control(icon, IDB_CERT);
2336
2337 memset(&charFmt, 0, sizeof(charFmt));
2338 charFmt.cbSize = sizeof(charFmt);
2339 charFmt.dwMask = CFM_BOLD;
2340 charFmt.dwEffects = CFE_BOLD;
2341 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2342 /* FIXME: vertically center text */
2343 parFmt.cbSize = sizeof(parFmt);
2344 parFmt.dwMask = PFM_STARTINDENT;
2345 parFmt.dxStartIndent = MY_INDENT;
2346 add_string_resource_with_paraformat_to_control(text,
2347 IDS_CERTIFICATEINFORMATION, &parFmt);
2348
2349 text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
2350 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2351 if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
2352 add_string_resource_with_paraformat_to_control(text,
2353 IDS_CERT_INFO_BAD_SIG, &parFmt);
2354 else if (!provSigner->pChainContext ||
2355 (provSigner->pChainContext->TrustStatus.dwErrorStatus &
2356 CERT_TRUST_IS_PARTIAL_CHAIN))
2357 add_string_resource_with_paraformat_to_control(text,
2358 IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
2359 else if (!root->fTrustedRoot)
2360 {
2361 if (provSigner->csCertChain == 1 && root->fSelfSigned)
2362 add_string_resource_with_paraformat_to_control(text,
2363 IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
2364 else
2365 add_string_resource_with_paraformat_to_control(text,
2366 IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
2367 }
2368 else
2369 {
2370 set_policy_text(text, pCertViewInfo);
2371 set_issuer_statement(hwnd, pCertViewInfo);
2372 }
2373 }
2374
2375 static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
2376 DWORD nameFlags, int heading)
2377 {
2378 WCHAR nl = '\n';
2379 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
2380 CHARFORMATW charFmt;
2381 PARAFORMAT2 parFmt;
2382
2383 memset(&charFmt, 0, sizeof(charFmt));
2384 charFmt.cbSize = sizeof(charFmt);
2385 charFmt.dwMask = CFM_BOLD;
2386 charFmt.dwEffects = CFE_BOLD;
2387 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2388 parFmt.cbSize = sizeof(parFmt);
2389 parFmt.dwMask = PFM_STARTINDENT;
2390 parFmt.dxStartIndent = MY_INDENT * 3;
2391 add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
2392 charFmt.dwEffects = 0;
2393 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2394 add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
2395 nameFlags);
2396 add_unformatted_text_to_control(text, &nl, 1);
2397 add_unformatted_text_to_control(text, &nl, 1);
2398 add_unformatted_text_to_control(text, &nl, 1);
2399
2400 }
2401
2402 static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
2403 {
2404 WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
2405 WCHAR date[80];
2406 SYSTEMTIME sysTime;
2407
2408 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
2409 sizeof(dateFmt) / sizeof(dateFmt[0]));
2410 FileTimeToSystemTime(fileTime, &sysTime);
2411 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
2412 sizeof(date) / sizeof(date[0]));
2413 add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
2414 }
2415
2416 static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
2417 {
2418 WCHAR nl = '\n';
2419 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
2420 CHARFORMATW charFmt;
2421 PARAFORMAT2 parFmt;
2422
2423 memset(&charFmt, 0, sizeof(charFmt));
2424 charFmt.cbSize = sizeof(charFmt);
2425 charFmt.dwMask = CFM_BOLD;
2426 charFmt.dwEffects = CFE_BOLD;
2427 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2428 parFmt.cbSize = sizeof(parFmt);
2429 parFmt.dwMask = PFM_STARTINDENT;
2430 parFmt.dxStartIndent = MY_INDENT * 3;
2431 add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
2432 &parFmt);
2433 charFmt.dwEffects = 0;
2434 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2435 add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
2436 charFmt.dwEffects = CFE_BOLD;
2437 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2438 add_string_resource_to_control(text, IDS_VALID_TO);
2439 charFmt.dwEffects = 0;
2440 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
2441 add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
2442 add_unformatted_text_to_control(text, &nl, 1);
2443 }
2444
2445 static void set_general_info(HWND hwnd,
2446 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2447 {
2448 set_cert_info(hwnd, pCertViewInfo);
2449 set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
2450 IDS_SUBJECT_HEADING);
2451 set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
2452 CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
2453 set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
2454 }
2455
2456 static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2457 LPARAM lp)
2458 {
2459 LRESULT ret = 0;
2460 HWND text;
2461 struct IssuerStatement *issuerStatement;
2462
2463 switch (msg)
2464 {
2465 case WM_INITDIALOG:
2466 text = GetDlgItem(hwnd, IDC_USERNOTICE);
2467 issuerStatement = (struct IssuerStatement *)lp;
2468 add_unformatted_text_to_control(text, issuerStatement->userNotice,
2469 strlenW(issuerStatement->userNotice));
2470 if (issuerStatement->cps)
2471 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
2472 else
2473 EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
2474 break;
2475 case WM_COMMAND:
2476 switch (wp)
2477 {
2478 case IDOK:
2479 EndDialog(hwnd, IDOK);
2480 ret = TRUE;
2481 break;
2482 case IDC_CPS:
2483 {
2484 IBindCtx *bctx = NULL;
2485 LPWSTR cps;
2486
2487 CreateBindCtx(0, &bctx);
2488 cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
2489 HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
2490 HLNF_OPENINNEWWINDOW, 0);
2491 IBindCtx_Release(bctx);
2492 break;
2493 }
2494 }
2495 }
2496 return ret;
2497 }
2498
2499 static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
2500 {
2501 DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
2502 user_notice_dlg_proc, (LPARAM)issuerStatement);
2503 }
2504
2505 static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2506 LPARAM lp)
2507 {
2508 PROPSHEETPAGEW *page;
2509 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
2510
2511 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2512
2513 switch (msg)
2514 {
2515 case WM_INITDIALOG:
2516 page = (PROPSHEETPAGEW *)lp;
2517 pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
2518 if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
2519 ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
2520 EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
2521 set_general_info(hwnd, pCertViewInfo);
2522 break;
2523 case WM_COMMAND:
2524 switch (wp)
2525 {
2526 case IDC_ADDTOSTORE:
2527 CryptUIWizImport(0, hwnd, NULL, NULL, NULL);
2528 break;
2529 case IDC_ISSUERSTATEMENT:
2530 {
2531 struct IssuerStatement *issuerStatement =
2532 (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
2533
2534 if (issuerStatement)
2535 {
2536 if (issuerStatement->userNotice)
2537 show_user_notice(hwnd, issuerStatement);
2538 else if (issuerStatement->cps)
2539 {
2540 IBindCtx *bctx = NULL;
2541
2542 CreateBindCtx(0, &bctx);
2543 HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
2544 NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
2545 IBindCtx_Release(bctx);
2546 }
2547 }
2548 break;
2549 }
2550 }
2551 break;
2552 }
2553 return 0;
2554 }
2555
2556 static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
2557 PROPSHEETPAGEW *page)
2558 {
2559 struct IssuerStatement *issuerStatement;
2560
2561 switch (msg)
2562 {
2563 case PSPCB_RELEASE:
2564 issuerStatement =
2565 (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
2566 if (issuerStatement)
2567 {
2568 HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
2569 HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
2570 HeapFree(GetProcessHeap(), 0, issuerStatement);
2571 }
2572 break;
2573 }
2574 return 1;
2575 }
2576
2577 static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2578 PROPSHEETPAGEW *page)
2579 {
2580 memset(page, 0, sizeof(PROPSHEETPAGEW));
2581 page->dwSize = sizeof(PROPSHEETPAGEW);
2582 page->dwFlags = PSP_USECALLBACK;
2583 page->pfnCallback = general_callback_proc;
2584 page->hInstance = hInstance;
2585 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
2586 page->pfnDlgProc = general_dlg_proc;
2587 page->lParam = (LPARAM)pCertViewInfo;
2588 }
2589
2590 typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
2591
2592 static WCHAR *field_format_version(PCCERT_CONTEXT cert)
2593 {
2594 static const WCHAR fmt[] = { 'V','%','d',0 };
2595 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
2596
2597 if (buf)
2598 sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
2599 return buf;
2600 }
2601
2602 static WCHAR *format_hex_string(void *pb, DWORD cb)
2603 {
2604 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
2605
2606 if (buf)
2607 {
2608 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
2609 DWORD i;
2610 WCHAR *ptr;
2611
2612 for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
2613 sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
2614 }
2615 return buf;
2616 }
2617
2618 static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
2619 {
2620 return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
2621 cert->pCertInfo->SerialNumber.cbData);
2622 }
2623
2624 static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
2625 {
2626 return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
2627 CERT_NAME_ISSUER_FLAG);
2628 }
2629
2630 static WCHAR *field_format_detailed_cert_name(PCERT_NAME_BLOB name)
2631 {
2632 WCHAR *str = NULL;
2633 DWORD len = CertNameToStrW(X509_ASN_ENCODING, name,
2634 CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, NULL, 0);
2635
2636 if (len)
2637 {
2638 str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2639 if (str)
2640 CertNameToStrW(X509_ASN_ENCODING, name,
2641 CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, str, len);
2642 }
2643 return str;
2644 }
2645
2646 static WCHAR *field_format_detailed_issuer(PCCERT_CONTEXT cert, void *param)
2647 {
2648 return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
2649 }
2650
2651 static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
2652 {
2653 return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
2654 }
2655
2656 static WCHAR *field_format_detailed_subject(PCCERT_CONTEXT cert, void *param)
2657 {
2658 return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
2659 }
2660
2661 static WCHAR *format_long_date(const FILETIME *fileTime)
2662 {
2663 WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
2664 DWORD len;
2665 WCHAR *buf = NULL;
2666 SYSTEMTIME sysTime;
2667
2668 /* FIXME: format isn't quite right, want time too */
2669 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
2670 sizeof(dateFmt) / sizeof(dateFmt[0]));
2671 FileTimeToSystemTime(fileTime, &sysTime);
2672 len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
2673 if (len)
2674 {
2675 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2676 if (buf)
2677 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
2678 len);
2679 }
2680 return buf;
2681 }
2682
2683 static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
2684 {
2685 return format_long_date(&cert->pCertInfo->NotBefore);
2686 }
2687
2688 static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
2689 {
2690 return format_long_date(&cert->pCertInfo->NotAfter);
2691 }
2692
2693 static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
2694 {
2695 PCCRYPT_OID_INFO oidInfo;
2696 WCHAR *buf = NULL;
2697
2698 oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2699 cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
2700 if (oidInfo)
2701 {
2702 WCHAR fmt[MAX_STRING_LEN];
2703
2704 if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
2705 sizeof(fmt) / sizeof(fmt[0])))
2706 {
2707 DWORD len;
2708
2709 /* Allocate the output buffer. Use the number of bytes in the
2710 * public key as a conservative (high) estimate for the number of
2711 * digits in its output.
2712 * The output is of the form (in English)
2713 * "<public key algorithm> (<public key bit length> bits)".
2714 * Ordinarily having two positional parameters in a string is not a
2715 * good idea, but as this isn't a sentence fragment, it shouldn't
2716 * be word-order dependent.
2717 */
2718 len = strlenW(fmt) + strlenW(oidInfo->pwszName) +
2719 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8;
2720 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*buf));
2721 if (buf)
2722 {
2723 DWORD_PTR args[2];
2724 args[0] = (DWORD_PTR)oidInfo->pwszName;
2725 args[1] = CertGetPublicKeyLength(X509_ASN_ENCODING,
2726 &cert->pCertInfo->SubjectPublicKeyInfo);
2727 FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
2728 fmt, 0, 0, buf, len, (__ms_va_list*)args);
2729 }
2730 }
2731 }
2732 return buf;
2733 }
2734
2735 static WCHAR *field_format_detailed_public_key(PCCERT_CONTEXT cert, void *param)
2736 {
2737 return format_hex_string(
2738 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
2739 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
2740 }
2741
2742 struct field_value_data;
2743 struct detail_data
2744 {
2745 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
2746 BOOL *pfPropertiesChanged;
2747 int cFields;
2748 struct field_value_data *fields;
2749 };
2750
2751 typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
2752
2753 typedef WCHAR *(*create_detailed_value_func)(PCCERT_CONTEXT cert, void *param);
2754
2755 struct field_value_data
2756 {
2757 create_detailed_value_func create;
2758 LPWSTR detailed_value;
2759 void *param;
2760 };
2761
2762 static void add_field_value_data(struct detail_data *data,
2763 create_detailed_value_func create, void *param)
2764 {
2765 if (data->cFields)
2766 data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
2767 (data->cFields + 1) * sizeof(struct field_value_data));
2768 else
2769 data->fields = HeapAlloc(GetProcessHeap(), 0,
2770 sizeof(struct field_value_data));
2771 if (data->fields)
2772 {
2773 data->fields[data->cFields].create = create;
2774 data->fields[data->cFields].detailed_value = NULL;
2775 data->fields[data->cFields].param = param;
2776 data->cFields++;
2777 }
2778 }
2779
2780 static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
2781 LPWSTR field, LPWSTR value, create_detailed_value_func create, void *param)
2782 {
2783 LVITEMW item;
2784 int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
2785
2786 item.mask = LVIF_TEXT | LVIF_PARAM;
2787 item.iItem = iItem;
2788 item.iSubItem = 0;
2789 item.pszText = field;
2790 item.lParam = (LPARAM)data;
2791 SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
2792 if (value)
2793 {
2794 item.pszText = value;
2795 item.iSubItem = 1;
2796 SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
2797 }
2798 add_field_value_data(data, create, param);
2799 }
2800
2801 static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
2802 int id, LPWSTR value, create_detailed_value_func create, void *param)
2803 {
2804 WCHAR buf[MAX_STRING_LEN];
2805
2806 LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
2807 add_field_and_value_to_list(hwnd, data, buf, value, create, param);
2808 }
2809
2810 struct v1_field
2811 {
2812 int id;
2813 field_format_func format;
2814 create_detailed_value_func create_detailed_value;
2815 };
2816
2817 static void add_v1_field(HWND hwnd, struct detail_data *data,
2818 const struct v1_field *field)
2819 {
2820 WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
2821
2822 if (val)
2823 {
2824 add_string_id_and_value_to_list(hwnd, data, field->id, val,
2825 field->create_detailed_value, NULL);
2826 HeapFree(GetProcessHeap(), 0, val);
2827 }
2828 }
2829
2830 static const struct v1_field v1_fields[] = {
2831 { IDS_FIELD_VERSION, field_format_version, NULL },
2832 { IDS_FIELD_SERIAL_NUMBER, field_format_serial_number, NULL },
2833 { IDS_FIELD_ISSUER, field_format_issuer, field_format_detailed_issuer },
2834 { IDS_FIELD_VALID_FROM, field_format_from_date, NULL },
2835 { IDS_FIELD_VALID_TO, field_format_to_date, NULL },
2836 { IDS_FIELD_SUBJECT, field_format_subject, field_format_detailed_subject },
2837 { IDS_FIELD_PUBLIC_KEY, field_format_public_key,
2838 field_format_detailed_public_key }
2839 };
2840
2841 static void add_v1_fields(HWND hwnd, struct detail_data *data)
2842 {
2843 unsigned int i;
2844 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2845
2846 /* The last item in v1_fields is the public key, which is not in the loop
2847 * because it's a special case.
2848 */
2849 for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
2850 add_v1_field(hwnd, data, &v1_fields[i]);
2851 if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
2852 add_v1_field(hwnd, data, &v1_fields[i]);
2853 }
2854
2855 static WCHAR *crypt_format_extension(const CERT_EXTENSION *ext, DWORD formatStrType)
2856 {
2857 WCHAR *str = NULL;
2858 DWORD size;
2859
2860 if (CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
2861 ext->pszObjId, ext->Value.pbData, ext->Value.cbData, NULL, &size))
2862 {
2863 str = HeapAlloc(GetProcessHeap(), 0, size);
2864 CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
2865 ext->pszObjId, ext->Value.pbData, ext->Value.cbData, str, &size);
2866 }
2867 return str;
2868 }
2869
2870 static WCHAR *field_format_extension_hex_with_ascii(const CERT_EXTENSION *ext)
2871 {
2872 WCHAR *str = NULL;
2873
2874 if (ext->Value.cbData)
2875 {
2876 /* The output is formatted as:
2877 * <hex bytes> <ascii bytes>\n
2878 * where <hex bytes> is a string of up to 8 bytes, output as %02x,
2879 * and <ascii bytes> is the ASCII equivalent of each byte, or '.' if
2880 * the byte is not printable.
2881 * So, for example, the extension value consisting of the following
2882 * bytes:
2883 * 0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,
2884 * 0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67
2885 * is output as:
2886 * 30 14 31 12 30 10 06 03 0.1.0...
2887 * 55 04 03 13 09 4a 75 61 U....Jua
2888 * 6e 20 4c 61 6e 67 n Lang
2889 * The allocation size therefore requires:
2890 * - 4 characters per character in an 8-byte line
2891 * (2 for the hex format, one for the space, one for the ASCII value)
2892 * - 3 more characters per 8-byte line (two spaces and a newline)
2893 * - 1 character for the terminating nul
2894 * FIXME: should use a fixed-width font for this
2895 */
2896 DWORD lines = (ext->Value.cbData + 7) / 8;
2897
2898 str = HeapAlloc(GetProcessHeap(), 0,
2899 (lines * 8 * 4 + lines * 3 + 1) * sizeof(WCHAR));
2900 if (str)
2901 {
2902 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
2903 DWORD i, j;
2904 WCHAR *ptr;
2905
2906 for (i = 0, ptr = str; i < ext->Value.cbData; i += 8)
2907 {
2908 /* Output as hex bytes first */
2909 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr += 3)
2910 sprintfW(ptr, fmt, ext->Value.pbData[j]);
2911 /* Pad the hex output with spaces for alignment */
2912 if (j == ext->Value.cbData && j % 8)
2913 {
2914 static const WCHAR pad[] = { ' ',' ',' ' };
2915
2916 for (; j % 8; j++, ptr += sizeof(pad) / sizeof(pad[0]))
2917 memcpy(ptr, pad, sizeof(pad));
2918 }
2919 /* The last sprintfW included a space, so just insert one
2920 * more space between the hex bytes and the ASCII output
2921 */
2922 *ptr++ = ' ';
2923 /* Output as ASCII bytes */
2924 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr++)
2925 {
2926 if (isprintW(ext->Value.pbData[j]) &&
2927 !isspaceW(ext->Value.pbData[j]))
2928 *ptr = ext->Value.pbData[j];
2929 else
2930 *ptr = '.';
2931 }
2932 *ptr++ = '\n';
2933 }
2934 *ptr++ = '\0';
2935 }
2936 }
2937 return str;
2938 }
2939
2940 static WCHAR *field_format_detailed_extension(PCCERT_CONTEXT cert, void *param)
2941 {
2942 PCERT_EXTENSION ext = param;
2943 LPWSTR str = crypt_format_extension(ext,
2944 CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX);
2945
2946 if (!str)
2947 str = field_format_extension_hex_with_ascii(ext);
2948 return str;
2949 }
2950
2951 static void add_cert_extension_detail(HWND hwnd, struct detail_data *data,
2952 PCERT_EXTENSION ext)
2953 {
2954 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2955 ext->pszObjId, 0);
2956 LPWSTR val = crypt_format_extension(ext, 0);
2957
2958 if (oidInfo)
2959 add_field_and_value_to_list(hwnd, data, (LPWSTR)oidInfo->pwszName,
2960 val, field_format_detailed_extension, ext);
2961 else
2962 {
2963 DWORD len = strlen(ext->pszObjId);
2964 LPWSTR oidW = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
2965
2966 if (oidW)
2967 {
2968 DWORD i;
2969
2970 for (i = 0; i <= len; i++)
2971 oidW[i] = ext->pszObjId[i];
2972 add_field_and_value_to_list(hwnd, data, oidW, val,
2973 field_format_detailed_extension, ext);
2974 HeapFree(GetProcessHeap(), 0, oidW);
2975 }
2976 }
2977 HeapFree(GetProcessHeap(), 0, val);
2978 }
2979
2980 static void add_all_extensions(HWND hwnd, struct detail_data *data)
2981 {
2982 DWORD i;
2983 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2984
2985 for (i = 0; i < cert->pCertInfo->cExtension; i++)
2986 add_cert_extension_detail(hwnd, data, &cert->pCertInfo->rgExtension[i]);
2987 }
2988
2989 static void add_critical_extensions(HWND hwnd, struct detail_data *data)
2990 {
2991 DWORD i;
2992 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
2993
2994 for (i = 0; i < cert->pCertInfo->cExtension; i++)
2995 if (cert->pCertInfo->rgExtension[i].fCritical)
2996 add_cert_extension_detail(hwnd, data,
2997 &cert->pCertInfo->rgExtension[i]);
2998 }
2999
3000 typedef WCHAR * (*prop_to_value_func)(void *pb, DWORD cb);
3001
3002 struct prop_id_to_string_id
3003 {
3004 DWORD prop;
3005 int id;
3006 BOOL prop_is_string;
3007 prop_to_value_func prop_to_value;
3008 };
3009
3010 static WCHAR *format_enhanced_key_usage_value(void *pb, DWORD cb)
3011 {
3012 CERT_EXTENSION ext;
3013
3014 ext.pszObjId = (LPSTR)X509_ENHANCED_KEY_USAGE;
3015 ext.fCritical = FALSE;
3016 ext.Value.pbData = pb;
3017 ext.Value.cbData = cb;
3018 return crypt_format_extension(&ext, 0);
3019 }
3020
3021 /* Logically the access state should also be checked, and IDC_EDITPROPERTIES
3022 * disabled for read-only certificates, but native doesn't appear to do that.
3023 */
3024 static const struct prop_id_to_string_id prop_id_map[] = {
3025 { CERT_HASH_PROP_ID, IDS_PROP_HASH, FALSE, format_hex_string },
3026 { CERT_FRIENDLY_NAME_PROP_ID, IDS_PROP_FRIENDLY_NAME, TRUE, NULL },
3027 { CERT_DESCRIPTION_PROP_ID, IDS_PROP_DESCRIPTION, TRUE, NULL },
3028 { CERT_ENHKEY_USAGE_PROP_ID, IDS_PROP_ENHKEY_USAGE, FALSE,
3029 format_enhanced_key_usage_value },
3030 };
3031
3032 static void add_properties(HWND hwnd, struct detail_data *data)
3033 {
3034 DWORD i;
3035 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
3036
3037 for (i = 0; i < sizeof(prop_id_map) / sizeof(prop_id_map[0]); i++)
3038 {
3039 DWORD cb;
3040
3041 if (CertGetCertificateContextProperty(cert, prop_id_map[i].prop, NULL,
3042 &cb))
3043 {
3044 BYTE *pb;
3045 WCHAR *val = NULL;
3046
3047 /* FIXME: MS adds a separate value for the signature hash
3048 * algorithm.
3049 */
3050 pb = HeapAlloc(GetProcessHeap(), 0, cb);
3051 if (pb)
3052 {
3053 if (CertGetCertificateContextProperty(cert,
3054 prop_id_map[i].prop, pb, &cb))
3055 {
3056 if (prop_id_map[i].prop_is_string)
3057 {
3058 val = (LPWSTR)pb;
3059 /* Don't double-free pb */
3060 pb = NULL;
3061 }
3062 else
3063 val = prop_id_map[i].prop_to_value(pb, cb);
3064 }
3065 HeapFree(GetProcessHeap(), 0, pb);
3066 }
3067 add_string_id_and_value_to_list(hwnd, data, prop_id_map[i].id, val,
3068 NULL, NULL);
3069 }
3070 }
3071 }
3072
3073 static void add_all_fields(HWND hwnd, struct detail_data *data)
3074 {
3075 add_v1_fields(hwnd, data);
3076 add_all_extensions(hwnd, data);
3077 add_properties(hwnd, data);
3078 }
3079
3080 struct selection_list_item
3081 {
3082 int id;
3083 add_fields_func add;
3084 };
3085
3086 static const struct selection_list_item listItems[] = {
3087 { IDS_FIELDS_ALL, add_all_fields },
3088 { IDS_FIELDS_V1, add_v1_fields },
3089 { IDS_FIELDS_EXTENSIONS, add_all_extensions },
3090 { IDS_FIELDS_CRITICAL_EXTENSIONS, add_critical_extensions },
3091 { IDS_FIELDS_PROPERTIES, add_properties },
3092 };
3093
3094 static void create_show_list(HWND hwnd, struct detail_data *data)
3095 {
3096 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
3097 WCHAR buf[MAX_STRING_LEN];
3098 int i;
3099
3100 for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
3101 {
3102 int index;
3103
3104 LoadStringW(hInstance, listItems[i].id, buf,
3105 sizeof(buf) / sizeof(buf[0]));
3106 index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
3107 SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
3108 }
3109 SendMessageW(cb, CB_SETCURSEL, 0, 0);
3110 }
3111
3112 static void create_listview_columns(HWND hwnd)
3113 {
3114 HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
3115 RECT rc;
3116 WCHAR buf[MAX_STRING_LEN];
3117 LVCOLUMNW column;
3118
3119 SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
3120 GetWindowRect(lv, &rc);
3121 LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
3122 column.mask = LVCF_WIDTH | LVCF_TEXT;
3123 column.cx = (rc.right - rc.left) / 2 - 2;
3124 column.pszText = buf;
3125 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
3126 LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
3127 SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
3128 }
3129
3130 static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
3131 {
3132 HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
3133
3134 if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
3135 {
3136 SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
3137 listItems[sel].add(list, data);
3138 }
3139 }
3140
3141 static void create_cert_details_list(HWND hwnd, struct detail_data *data)
3142 {
3143 create_show_list(hwnd, data);
3144 create_listview_columns(hwnd);
3145 set_fields_selection(hwnd, data, 0);
3146 }
3147
3148 static void add_purpose(HWND hwnd, LPCSTR oid)
3149 {
3150 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
3151 PCRYPT_OID_INFO info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3152 sizeof(CRYPT_OID_INFO));
3153
3154 if (info)
3155 {
3156 char *oidCopy = HeapAlloc(GetProcessHeap(), 0, strlen(oid) + 1);
3157
3158 if (oidCopy)
3159 {
3160 LVITEMA item;
3161
3162 strcpy(oidCopy, oid);
3163 info->cbSize = sizeof(CRYPT_OID_INFO);
3164 info->pszOID = oidCopy;
3165 item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
3166 item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexChecked);
3167 item.stateMask = LVIS_STATEIMAGEMASK;
3168 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
3169 item.iSubItem = 0;
3170 item.lParam = (LPARAM)info;
3171 item.pszText = oidCopy;
3172 SendMessageA(lv, LVM_INSERTITEMA, 0, (LPARAM)&item);
3173 }
3174 else
3175 HeapFree(GetProcessHeap(), 0, info);
3176 }
3177 }
3178
3179 static BOOL is_valid_oid(LPCSTR oid)
3180 {
3181 BOOL ret;
3182
3183 if (oid[0] != '0' && oid[0] != '1' && oid[0] != '2')
3184 ret = FALSE;
3185 else if (oid[1] != '.')
3186 ret = FALSE;
3187 else if (!oid[2])
3188 ret = FALSE;
3189 else
3190 {
3191 const char *ptr;
3192 BOOL expectNum = TRUE;
3193
3194 for (ptr = oid + 2, ret = TRUE; ret && *ptr; ptr++)
3195 {
3196 if (expectNum)
3197 {
3198 if (!isdigit(*ptr))
3199 ret = FALSE;
3200 else if (*(ptr + 1) == '.')
3201 expectNum = FALSE;
3202 }
3203 else
3204 {
3205 if (*ptr != '.')
3206 ret = FALSE;
3207 else if (!(*(ptr + 1)))
3208 ret = FALSE;
3209 else
3210 expectNum = TRUE;
3211 }
3212 }
3213 }
3214 return ret;
3215 }
3216
3217 static BOOL is_oid_in_list(HWND hwnd, LPCSTR oid)
3218 {
3219 return find_oid_in_list(GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES), oid)
3220 != -1;
3221 }
3222
3223 #define MAX_PURPOSE 255
3224
3225 static LRESULT CALLBACK add_purpose_dlg_proc(HWND hwnd, UINT msg,
3226 WPARAM wp, LPARAM lp)
3227 {
3228 LRESULT ret = 0;
3229 char buf[MAX_PURPOSE + 1];
3230
3231 switch (msg)
3232 {
3233 case WM_INITDIALOG:
3234 SendMessageW(GetDlgItem(hwnd, IDC_NEW_PURPOSE), EM_SETLIMITTEXT,
3235 MAX_PURPOSE, 0);
3236 ShowScrollBar(GetDlgItem(hwnd, IDC_NEW_PURPOSE), SB_VERT, FALSE);
3237 SetWindowLongPtrW(hwnd, DWLP_USER, lp);
3238 break;
3239 case WM_COMMAND:
3240 switch (HIWORD(wp))
3241 {
3242 case EN_CHANGE:
3243 if (LOWORD(wp) == IDC_NEW_PURPOSE)
3244 {
3245 /* Show/hide scroll bar on description depending on how much
3246 * text it has.
3247 */
3248 HWND description = GetDlgItem(hwnd, IDC_NEW_PURPOSE);
3249 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
3250
3251 ShowScrollBar(description, SB_VERT, lines > 1);
3252 }
3253 break;
3254 case BN_CLICKED:
3255 switch (LOWORD(wp))
3256 {
3257 case IDOK:
3258 SendMessageA(GetDlgItem(hwnd, IDC_NEW_PURPOSE), WM_GETTEXT,
3259 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
3260 if (!buf[0])
3261 {
3262 /* An empty purpose is the same as cancelling */
3263 EndDialog(hwnd, IDCANCEL);
3264 ret = TRUE;
3265 }
3266 else if (!is_valid_oid(buf))
3267 {
3268 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
3269
3270 LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_ERROR, error,
3271 sizeof(error) / sizeof(error[0]));
3272 LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
3273 sizeof(title) / sizeof(title[0]));
3274 MessageBoxW(hwnd, error, title, MB_ICONERROR | MB_OK);
3275 }
3276 else if (is_oid_in_list(
3277 (HWND)GetWindowLongPtrW(hwnd, DWLP_USER), buf))
3278 {
3279 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
3280
3281 LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_EXISTS,
3282 error, sizeof(error) / sizeof(error[0]));
3283 LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
3284 sizeof(title) / sizeof(title[0]));
3285 MessageBoxW(hwnd, error, title, MB_ICONEXCLAMATION | MB_OK);
3286 }
3287 else
3288 {
3289 HWND parent = (HWND)GetWindowLongPtrW(hwnd, DWLP_USER);
3290
3291 add_purpose(parent, buf);
3292 EndDialog(hwnd, wp);
3293 ret = TRUE;
3294 }
3295 break;
3296 case IDCANCEL:
3297 EndDialog(hwnd, wp);
3298 ret = TRUE;
3299 break;
3300 }
3301 break;
3302 }
3303 break;
3304 }
3305 return ret;
3306 }
3307
3308 static WCHAR *get_cert_property_as_string(PCCERT_CONTEXT cert, DWORD prop)
3309 {
3310 WCHAR *name = NULL;
3311 DWORD cb;
3312
3313 if (CertGetCertificateContextProperty(cert, prop, NULL, &cb))
3314 {
3315 name = HeapAlloc(GetProcessHeap(), 0, cb);
3316 if (name)
3317 {
3318 if (!CertGetCertificateContextProperty(cert, prop, name, &cb))
3319 {
3320 HeapFree(GetProcessHeap(), 0, name);
3321 name = NULL;
3322 }
3323 }
3324 }
3325 return name;
3326 }
3327
3328 static void redraw_states(HWND list, BOOL enabled)
3329 {
3330 int items = SendMessageW(list, LVM_GETITEMCOUNT, 0, 0), i;
3331
3332 for (i = 0; i < items; i++)
3333 {
3334 BOOL change = FALSE;
3335 int state;
3336
3337 state = SendMessageW(list, LVM_GETITEMSTATE, i, LVIS_STATEIMAGEMASK);
3338 /* This reverses the INDEXTOSTATEIMAGEMASK shift. There doesn't appear
3339 * to be a handy macro for it.
3340 */
3341 state >>= 12;
3342 if (enabled)
3343 {
3344 if (state == CheckBitmapIndexDisabledChecked)
3345 {
3346 state = CheckBitmapIndexChecked;
3347 change = TRUE;
3348 }
3349 if (state == CheckBitmapIndexDisabledUnchecked)
3350 {
3351 state = CheckBitmapIndexUnchecked;
3352 change = TRUE;
3353 }
3354 }
3355 else
3356 {
3357 if (state == CheckBitmapIndexChecked)
3358 {
3359 state = CheckBitmapIndexDisabledChecked;
3360 change = TRUE;
3361 }
3362 if (state == CheckBitmapIndexUnchecked)
3363 {
3364 state = CheckBitmapIndexDisabledUnchecked;
3365 change = TRUE;
3366 }
3367 }
3368 if (change)
3369 {
3370 LVITEMW item;
3371
3372 item.state = INDEXTOSTATEIMAGEMASK(state);
3373 item.stateMask = LVIS_STATEIMAGEMASK;
3374 SendMessageW(list, LVM_SETITEMSTATE, i, (LPARAM)&item);
3375 }
3376 }
3377 }
3378
3379 typedef enum {
3380 PurposeEnableAll = 0,
3381 PurposeDisableAll,
3382 PurposeEnableSelected
3383 } PurposeSelection;
3384
3385 static void select_purposes(HWND hwnd, PurposeSelection selection)
3386 {
3387 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
3388
3389 switch (selection)
3390 {
3391 case PurposeEnableAll:
3392 case PurposeDisableAll:
3393 EnableWindow(lv, FALSE);
3394 redraw_states(lv, FALSE);
3395 EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), FALSE);
3396 break;
3397 case PurposeEnableSelected:
3398 EnableWindow(lv, TRUE);
3399 redraw_states(lv, TRUE);
3400 EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), TRUE);
3401 }
3402 }
3403
3404 struct edit_cert_data
3405 {
3406 PCCERT_CONTEXT cert;
3407 BOOL *pfPropertiesChanged;
3408 HIMAGELIST imageList;
3409 };
3410
3411 static void show_cert_usages(HWND hwnd, struct edit_cert_data *data)
3412 {
3413 PCCERT_CONTEXT cert = data->cert;
3414 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
3415 PCERT_ENHKEY_USAGE usage;
3416 DWORD size;
3417 RECT rc;
3418 LVCOLUMNW column;
3419 PurposeSelection purposeSelection = PurposeEnableAll;
3420
3421 GetWindowRect(lv, &rc);
3422 column.mask = LVCF_WIDTH;
3423 column.cx = rc.right - rc.left;
3424 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
3425 SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)data->imageList);
3426
3427 /* Get enhanced key usage. Have to check for a property and an extension
3428 * separately, because CertGetEnhancedKeyUsage will succeed and return an
3429 * empty usage if neither is set. Unfortunately an empty usage implies
3430 * no usage is allowed, so we have to distinguish between the two cases.
3431 */
3432 if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
3433 NULL, &size))
3434 {
3435 usage = HeapAlloc(GetProcessHeap(), 0, size);
3436 if (!CertGetEnhancedKeyUsage(cert,
3437 CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
3438 {
3439 HeapFree(GetProcessHeap(), 0, usage);
3440 usage = NULL;
3441 }
3442 else if (usage->cUsageIdentifier)
3443 purposeSelection = PurposeEnableSelected;
3444 else
3445 purposeSelection = PurposeDisableAll;
3446 }
3447 else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
3448 NULL, &size))
3449 {
3450 usage = HeapAlloc(GetProcessHeap(), 0, size);
3451 if (!CertGetEnhancedKeyUsage(cert,
3452 CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
3453 {
3454 HeapFree(GetProcessHeap(), 0, usage);
3455 usage = NULL;
3456 }
3457 else if (usage->cUsageIdentifier)
3458 purposeSelection = PurposeEnableAll;
3459 else
3460 purposeSelection = PurposeDisableAll;
3461 }
3462 else
3463 {
3464 purposeSelection = PurposeEnableAll;
3465 usage = NULL;
3466 }
3467 if (usage)
3468 {
3469 DWORD i;
3470
3471 for (i = 0; i < usage->cUsageIdentifier; i++)
3472 {
3473 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
3474 usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
3475
3476 if (info)
3477 add_known_usage(lv, info, CheckBitmapIndexDisabledChecked);
3478 else
3479 add_purpose(hwnd, usage->rgpszUsageIdentifier[i]);
3480 }
3481 HeapFree(GetProcessHeap(), 0, usage);
3482 }
3483 else
3484 add_known_usages_to_list(lv, CheckBitmapIndexDisabledChecked);
3485 select_purposes(hwnd, purposeSelection);
3486 SendMessageW(GetDlgItem(hwnd, IDC_ENABLE_ALL_PURPOSES + purposeSelection),
3487 BM_CLICK, 0, 0);
3488 }
3489
3490 static void set_general_cert_properties(HWND hwnd, struct edit_cert_data *data)
3491 {
3492 PCCERT_CONTEXT cert = data->cert;
3493 WCHAR *str;
3494
3495 if ((str = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID)))
3496 {
3497 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_SETTEXT, 0,
3498 (LPARAM)str);
3499 HeapFree(GetProcessHeap(), 0, str);
3500 }
3501 if ((str = get_cert_property_as_string(cert, CERT_DESCRIPTION_PROP_ID)))
3502 {
3503 SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_SETTEXT, 0,
3504 (LPARAM)str);
3505 HeapFree(GetProcessHeap(), 0, str);
3506 }
3507 show_cert_usages(hwnd, data);
3508 }
3509
3510 static void set_cert_string_property(PCCERT_CONTEXT cert, DWORD prop,
3511 LPWSTR str)
3512 {
3513 if (str && strlenW(str))
3514 {
3515 CRYPT_DATA_BLOB blob;
3516
3517 blob.pbData = (BYTE *)str;
3518 blob.cbData = (strlenW(str) + 1) * sizeof(WCHAR);
3519 CertSetCertificateContextProperty(cert, prop, 0, &blob);
3520 }
3521 else
3522 CertSetCertificateContextProperty(cert, prop, 0, NULL);
3523 }
3524
3525 #define WM_REFRESH_VIEW WM_USER + 0
3526
3527 static BOOL CALLBACK refresh_propsheet_pages(HWND hwnd, LPARAM lParam)
3528 {
3529 if ((GetClassLongW(hwnd, GCW_ATOM) == WC_DIALOG))
3530 SendMessageW(hwnd, WM_REFRESH_VIEW, 0, 0);
3531 return TRUE;
3532 }
3533
3534 #define MAX_FRIENDLY_NAME 40
3535 #define MAX_DESCRIPTION 255
3536
3537 static void apply_general_changes(HWND hwnd)
3538 {
3539 WCHAR buf[MAX_DESCRIPTION + 1];
3540 struct edit_cert_data *data =
3541 (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
3542
3543 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_GETTEXT,
3544 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
3545 set_cert_string_property(data->cert, CERT_FRIENDLY_NAME_PROP_ID, buf);
3546 SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_GETTEXT,
3547 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
3548 set_cert_string_property(data->cert, CERT_DESCRIPTION_PROP_ID, buf);
3549 if (IsDlgButtonChecked(hwnd, IDC_ENABLE_ALL_PURPOSES))
3550 {
3551 /* Setting a NULL usage removes the enhanced key usage property. */
3552 CertSetEnhancedKeyUsage(data->cert, NULL);
3553 }
3554 else if (IsDlgButtonChecked(hwnd, IDC_DISABLE_ALL_PURPOSES))
3555 {
3556 CERT_ENHKEY_USAGE usage = { 0, NULL };
3557
3558 CertSetEnhancedKeyUsage(data->cert, &usage);
3559 }
3560 else if (IsDlgButtonChecked(hwnd, IDC_ENABLE_SELECTED_PURPOSES))
3561 {
3562 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
3563 CERT_ENHKEY_USAGE usage = { 0, NULL };
3564 int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
3565 LVITEMW item;
3566
3567 item.mask = LVIF_STATE | LVIF_PARAM;
3568 item.iSubItem = 0;
3569 item.stateMask = LVIS_STATEIMAGEMASK;
3570 for (i = 0; i < purposes; i++)
3571 {
3572 item.iItem = i;
3573 if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
3574 {
3575 int state = item.state >> 12;
3576
3577 if (state == CheckBitmapIndexChecked)
3578 {
3579 CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
3580
3581 if (usage.cUsageIdentifier)
3582 usage.rgpszUsageIdentifier =
3583 HeapReAlloc(GetProcessHeap(), 0,
3584 usage.rgpszUsageIdentifier,
3585 (usage.cUsageIdentifier + 1) * sizeof(LPSTR));
3586 else
3587 usage.rgpszUsageIdentifier =
3588 HeapAlloc(GetProcessHeap(), 0, sizeof(LPSTR));
3589 if (usage.rgpszUsageIdentifier)
3590 usage.rgpszUsageIdentifier[usage.cUsageIdentifier++] =
3591 (LPSTR)info->pszOID;
3592 }
3593 }
3594 }
3595 CertSetEnhancedKeyUsage(data->cert, &usage);
3596 HeapFree(GetProcessHeap(), 0, usage.rgpszUsageIdentifier);
3597 }
3598 EnumChildWindows(GetParent(GetParent(hwnd)), refresh_propsheet_pages, 0);
3599 if (data->pfPropertiesChanged)
3600 *data->pfPropertiesChanged = TRUE;
3601 }
3602
3603 static LRESULT CALLBACK cert_properties_general_dlg_proc(HWND hwnd, UINT msg,
3604 WPARAM wp, LPARAM lp)
3605 {
3606 PROPSHEETPAGEW *page;
3607
3608 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
3609
3610 switch (msg)
3611 {
3612 case WM_INITDIALOG:
3613 {
3614 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
3615 struct detail_data *detailData;
3616 struct edit_cert_data *editData;
3617
3618 page = (PROPSHEETPAGEW *)lp;
3619 detailData = (struct detail_data *)page->lParam;
3620 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), EM_SETLIMITTEXT,
3621 MAX_FRIENDLY_NAME, 0);
3622 SendMessageW(description, EM_SETLIMITTEXT, MAX_DESCRIPTION, 0);
3623 ShowScrollBar(description, SB_VERT, FALSE);
3624 editData = HeapAlloc(GetProcessHeap(), 0,
3625 sizeof(struct edit_cert_data));
3626 if (editData)
3627 {
3628 editData->imageList = ImageList_Create(16, 16,
3629 ILC_COLOR4 | ILC_MASK, 4, 0);
3630 if (editData->imageList)
3631 {
3632 HBITMAP bmp;
3633 COLORREF backColor = RGB(255, 0, 255);
3634
3635 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
3636 ImageList_AddMasked(editData->imageList, bmp, backColor);
3637 DeleteObject(bmp);
3638 ImageList_SetBkColor(editData->imageList, CLR_NONE);
3639 }
3640 editData->cert = detailData->pCertViewInfo->pCertContext;
3641 editData->pfPropertiesChanged = detailData->pfPropertiesChanged;
3642 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)editData);
3643 set_general_cert_properties(hwnd, editData);
3644 }
3645 break;
3646 }
3647 case WM_NOTIFY:
3648 {
3649 NMHDR *hdr = (NMHDR *)lp;
3650 NMITEMACTIVATE *nm;
3651
3652 switch (hdr->code)
3653 {
3654 case NM_CLICK:
3655 nm = (NMITEMACTIVATE *)lp;
3656 toggle_usage(hwnd, nm->iItem);
3657 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3658 break;
3659 case PSN_APPLY:
3660 apply_general_changes(hwnd);
3661 break;
3662 }
3663 break;
3664 }
3665 case WM_COMMAND:
3666 switch (HIWORD(wp))
3667 {
3668 case EN_CHANGE:
3669 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3670 if (LOWORD(wp) == IDC_DESCRIPTION)
3671 {
3672 /* Show/hide scroll bar on description depending on how much
3673 * text it has.
3674 */
3675 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
3676 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
3677
3678 ShowScrollBar(description, SB_VERT, lines > 1);
3679 }
3680 break;
3681 case BN_CLICKED:
3682 switch (LOWORD(wp))
3683 {
3684 case IDC_ADD_PURPOSE:
3685 if (DialogBoxParamW(hInstance,
3686 MAKEINTRESOURCEW(IDD_ADD_CERT_PURPOSE), hwnd,
3687 add_purpose_dlg_proc, (LPARAM)hwnd) == IDOK)
3688 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3689 break;
3690 case IDC_ENABLE_ALL_PURPOSES:
3691 case IDC_DISABLE_ALL_PURPOSES:
3692 case IDC_ENABLE_SELECTED_PURPOSES:
3693 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
3694 select_purposes(hwnd, LOWORD(wp) - IDC_ENABLE_ALL_PURPOSES);
3695 break;
3696 }
3697 break;
3698 }
3699 break;
3700 }
3701 return 0;
3702 }
3703
3704 static UINT CALLBACK cert_properties_general_callback(HWND hwnd, UINT msg,
3705 PROPSHEETPAGEW *page)
3706 {
3707 HWND lv;
3708 int cItem, i;
3709 struct edit_cert_data *data;
3710
3711 switch (msg)
3712 {
3713 case PSPCB_RELEASE:
3714 lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
3715 cItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
3716 for (i = 0; i < cItem; i++)
3717 {
3718 LVITEMW item;
3719
3720 item.mask = LVIF_PARAM;
3721 item.iItem = i;
3722 item.iSubItem = 0;
3723 if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item) && item.lParam)
3724 {
3725 PCRYPT_OID_INFO info = (PCRYPT_OID_INFO)item.lParam;
3726
3727 if (info->cbSize == sizeof(CRYPT_OID_INFO) && !info->dwGroupId)
3728 {
3729 HeapFree(GetProcessHeap(), 0, (LPSTR)info->pszOID);
3730 HeapFree(GetProcessHeap(), 0, info);
3731 }
3732 }
3733 }
3734 data = (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
3735 if (data)
3736 {
3737 ImageList_Destroy(data->imageList);
3738 HeapFree(GetProcessHeap(), 0, data);
3739 }
3740 break;
3741 }
3742 return 1;
3743 }
3744
3745 static void show_edit_cert_properties_dialog(HWND parent,
3746 struct detail_data *data)
3747 {
3748 PROPSHEETHEADERW hdr;
3749 PROPSHEETPAGEW page; /* FIXME: need to add a cross-certificate page */
3750
3751 TRACE("(%p)\n", data);
3752
3753 memset(&page, 0, sizeof(PROPSHEETPAGEW));
3754 page.dwSize = sizeof(page);
3755 page.dwFlags = PSP_USECALLBACK;
3756 page.pfnCallback = cert_properties_general_callback;
3757 page.hInstance = hInstance;
3758 page.u.pszTemplate = MAKEINTRESOURCEW(IDD_CERT_PROPERTIES_GENERAL);
3759 page.pfnDlgProc = cert_properties_general_dlg_proc;
3760 page.lParam = (LPARAM)data;
3761
3762 memset(&hdr, 0, sizeof(hdr));
3763 hdr.dwSize = sizeof(hdr);
3764 hdr.hwndParent = parent;
3765 hdr.dwFlags = PSH_PROPSHEETPAGE;
3766 hdr.hInstance = hInstance;
3767 hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE_PROPERTIES);
3768 hdr.u3.ppsp = &page;
3769 hdr.nPages = 1;
3770 PropertySheetW(&hdr);
3771 }
3772
3773 static void free_detail_fields(struct detail_data *data)
3774 {
3775 int i;
3776
3777 for (i = 0; i < data->cFields; i++)
3778 HeapFree(GetProcessHeap(), 0, data->fields[i].detailed_value);
3779 HeapFree(GetProcessHeap(), 0, data->fields);
3780 data->fields = NULL;
3781 data->cFields = 0;
3782 }
3783
3784 static void refresh_details_view(HWND hwnd)
3785 {
3786 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
3787 int curSel;
3788 struct detail_data *data;
3789
3790 curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
3791 /* Actually, any index will do, since they all store the same data value */
3792 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
3793 free_detail_fields(data);
3794 set_fields_selection(hwnd, data, curSel);
3795 }
3796
3797 static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3798 LPARAM lp)
3799 {
3800 PROPSHEETPAGEW *page;
3801 struct detail_data *data;
3802
3803 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
3804
3805 switch (msg)
3806 {
3807 case WM_INITDIALOG:
3808 page = (PROPSHEETPAGEW *)lp;
3809 data = (struct detail_data *)page->lParam;
3810 create_cert_details_list(hwnd, data);
3811 if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
3812 EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
3813 if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
3814 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
3815 break;
3816 case WM_NOTIFY:
3817 {
3818 NMITEMACTIVATE *nm;
3819 HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
3820
3821 nm = (NMITEMACTIVATE*)lp;
3822 if (nm->hdr.hwndFrom == list && nm->uNewState & LVN_ITEMACTIVATE
3823 && nm->hdr.code == LVN_ITEMCHANGED)
3824 {
3825 data = (struct detail_data *)nm->lParam;
3826 if (nm->iItem >= 0 && data && nm->iItem < data->cFields)
3827 {
3828 WCHAR buf[MAX_STRING_LEN], *val = NULL;
3829 HWND valueCtl = GetDlgItem(hwnd, IDC_DETAIL_VALUE);
3830
3831 if (data->fields[nm->iItem].create)
3832 val = data->fields[nm->iItem].create(
3833 data->pCertViewInfo->pCertContext,
3834 data->fields[nm->iItem].param);
3835 else
3836 {
3837 LVITEMW item;
3838 int res;
3839
3840 item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
3841 item.mask = LVIF_TEXT;
3842 item.pszText = buf;
3843 item.iItem = nm->iItem;
3844 item.iSubItem = 1;
3845 res = SendMessageW(list, LVM_GETITEMW, 0, (LPARAM)&item);
3846 if (res)
3847 val = buf;
3848 }
3849 /* Select all the text in the control, the next update will
3850 * replace it
3851 */
3852 SendMessageW(valueCtl, EM_SETSEL, 0, -1);
3853 add_unformatted_text_to_control(valueCtl, val,
3854 val ? strlenW(val) : 0);
3855 if (val != buf)
3856 HeapFree(GetProcessHeap(), 0, val);
3857 }
3858 }
3859 break;
3860 }
3861 case WM_COMMAND:
3862 switch (wp)
3863 {
3864 case IDC_EXPORT:
3865 {
3866 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
3867 CRYPTUI_WIZ_EXPORT_INFO info;
3868
3869 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, 0, 0);
3870 info.dwSize = sizeof(info);
3871 info.pwszExportFileName = NULL;
3872 info.dwSubjectChoice = CRYPTUI_WIZ_EXPORT_CERT_CONTEXT;
3873 info.u.pCertContext = data->pCertViewInfo->pCertContext;
3874 info.cStores = 0;
3875 CryptUIWizExport(0, hwnd, NULL, &info, NULL);
3876 break;
3877 }
3878 case IDC_EDITPROPERTIES:
3879 {
3880 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
3881 int curSel;
3882
3883 curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
3884 /* Actually, any index will do, since they all store the same
3885 * data value
3886 */
3887 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA,
3888 curSel, 0);
3889 show_edit_cert_properties_dialog(GetParent(hwnd), data);
3890 break;
3891 }
3892 case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
3893 refresh_details_view(hwnd);
3894 break;
3895 }
3896 break;
3897 case WM_REFRESH_VIEW:
3898 refresh_details_view(hwnd);
3899 break;
3900 }
3901 return 0;
3902 }
3903
3904 static UINT CALLBACK detail_callback(HWND hwnd, UINT msg,
3905 PROPSHEETPAGEW *page)
3906 {
3907 struct detail_data *data;
3908
3909 switch (msg)
3910 {
3911 case PSPCB_RELEASE:
3912 data = (struct detail_data *)page->lParam;
3913 free_detail_fields(data);
3914 HeapFree(GetProcessHeap(), 0, data);
3915 break;
3916 }
3917 return 0;
3918 }
3919
3920 static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
3921 BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
3922 {
3923 BOOL ret;
3924 struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
3925 sizeof(struct detail_data));
3926
3927 if (data)
3928 {
3929 data->pCertViewInfo = pCertViewInfo;
3930 data->pfPropertiesChanged = pfPropertiesChanged;
3931 data->cFields = 0;
3932 data->fields = NULL;
3933 memset(page, 0, sizeof(PROPSHEETPAGEW));
3934 page->dwSize = sizeof(PROPSHEETPAGEW);
3935 page->dwFlags = PSP_USECALLBACK;
3936 page->pfnCallback = detail_callback;
3937 page->hInstance = hInstance;
3938 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
3939 page->pfnDlgProc = detail_dlg_proc;
3940 page->lParam = (LPARAM)data;
3941 ret = TRUE;
3942 }
3943 else
3944 ret = FALSE;
3945 return ret;
3946 }
3947
3948 struct hierarchy_data
3949 {
3950 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
3951 HIMAGELIST imageList;
3952 DWORD selectedCert;
3953 };
3954
3955 static LPARAM index_to_lparam(struct hierarchy_data *data, DWORD index)
3956 {
3957 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
3958 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3959 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
3960 data->pCertViewInfo->idxCounterSigner);
3961
3962 /* Takes advantage of the fact that a pointer is 32-bit aligned, and
3963 * therefore always even.
3964 */
3965 if (index == provSigner->csCertChain - 1)
3966 return (LPARAM)data;
3967 return index << 1 | 1;
3968 }
3969
3970 static inline DWORD lparam_to_index(struct hierarchy_data *data, LPARAM lp)
3971 {
3972 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
3973 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3974 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
3975 data->pCertViewInfo->idxCounterSigner);
3976
3977 if (!(lp & 1))
3978 return provSigner->csCertChain - 1;
3979 return lp >> 1;
3980 }
3981
3982 static struct hierarchy_data *get_hierarchy_data_from_tree_item(HWND tree,
3983 HTREEITEM hItem)
3984 {
3985 struct hierarchy_data *data = NULL;
3986 HTREEITEM root = NULL;
3987
3988 do {
3989 HTREEITEM parent = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM,
3990 TVGN_PARENT, (LPARAM)hItem);
3991
3992 if (!parent)
3993 root = hItem;
3994 hItem = parent;
3995 } while (hItem);
3996 if (root)
3997 {
3998 TVITEMW item;
3999
4000 item.mask = TVIF_PARAM;
4001 item.hItem = root;
4002 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
4003 data = (struct hierarchy_data *)item.lParam;
4004 }
4005 return data;
4006 }
4007
4008 static WCHAR *get_cert_display_name(PCCERT_CONTEXT cert)
4009 {
4010 WCHAR *name = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID);
4011
4012 if (!name)
4013 name = get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
4014 return name;
4015 }
4016
4017 static void show_cert_chain(HWND hwnd, struct hierarchy_data *data)
4018 {
4019 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
4020 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
4021 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
4022 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
4023 data->pCertViewInfo->idxCounterSigner);
4024 DWORD i;
4025 HTREEITEM parent = NULL;
4026
4027 SendMessageW(tree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)data->imageList);
4028 for (i = provSigner->csCertChain; i; i--)
4029 {
4030 LPWSTR name;
4031
4032 name = get_cert_display_name(provSigner->pasCertChain[i - 1].pCert);
4033 if (name)
4034 {
4035 TVINSERTSTRUCTW tvis;
4036
4037 tvis.hParent = parent;
4038 tvis.hInsertAfter = TVI_LAST;
4039 tvis.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE |
4040 TVIF_SELECTEDIMAGE | TVIF_PARAM;
4041 tvis.u.item.pszText = name;
4042 tvis.u.item.state = TVIS_EXPANDED;
4043 tvis.u.item.stateMask = TVIS_EXPANDED;
4044 if (i == 1 && (!provSigner->pChainContext ||
4045 provSigner->pChainContext->TrustStatus.dwErrorStatus &
4046 CERT_TRUST_IS_PARTIAL_CHAIN))
4047 {
4048 /* The root of the chain has a special case: if the chain is
4049 * a partial chain, the icon is a warning icon rather than an
4050 * error icon.
4051 */
4052 tvis.u.item.iImage = 2;
4053 }
4054 else if (provSigner->pasCertChain[i - 1].pChainElement->TrustStatus.
4055 dwErrorStatus == 0)
4056 tvis.u.item.iImage = 0;
4057 else
4058 tvis.u.item.iImage = 1;
4059 tvis.u.item.iSelectedImage = tvis.u.item.iImage;
4060 tvis.u.item.lParam = index_to_lparam(data, i - 1);
4061 parent = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0,
4062 (LPARAM)&tvis);
4063 HeapFree(GetProcessHeap(), 0, name);
4064 }
4065 }
4066 }
4067
4068 static void set_certificate_status(HWND hwnd, const CRYPT_PROVIDER_CERT *cert)
4069 {
4070 /* Select all the text in the control, the next update will replace it */
4071 SendMessageW(hwnd, EM_SETSEL, 0, -1);
4072 /* Set the highest priority error messages first. */
4073 if (!(cert->dwConfidence & CERT_CONFIDENCE_SIG))
4074 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_SIGNATURE);
4075 else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIME))
4076 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIME);
4077 else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIMENEST))
4078 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIMENEST);
4079 else if (cert->dwRevokedReason)
4080 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_REVOKED);
4081 else
4082 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_VALID);
4083 }
4084
4085 static void set_certificate_status_for_end_cert(HWND hwnd,
4086 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
4087 {
4088 HWND status = GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT);
4089 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
4090 (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
4091 pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
4092 pCertViewInfo->idxCounterSigner);
4093 CRYPT_PROVIDER_CERT *provCert = WTHelperGetProvCertFromChain(provSigner,
4094 pCertViewInfo->idxCert);
4095
4096 set_certificate_status(status, provCert);
4097 }
4098
4099 static void show_cert_hierarchy(HWND hwnd, struct hierarchy_data *data)
4100 {
4101 /* Disable view certificate button until a certificate is selected */
4102 EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), FALSE);
4103 show_cert_chain(hwnd, data);
4104 set_certificate_status_for_end_cert(hwnd, data->pCertViewInfo);
4105 }
4106
4107 static void show_dialog_for_selected_cert(HWND hwnd)
4108 {
4109 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
4110 TVITEMW item;
4111 struct hierarchy_data *data;
4112 DWORD selection;
4113
4114 memset(&item, 0, sizeof(item));
4115 item.mask = TVIF_HANDLE | TVIF_PARAM;
4116 item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CARET, 0);
4117 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
4118 data = get_hierarchy_data_from_tree_item(tree, item.hItem);
4119 selection = lparam_to_index(data, item.lParam);
4120 if (selection != 0)
4121 {
4122 CRYPT_PROVIDER_SGNR *provSigner;
4123 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
4124 BOOL changed = FALSE;
4125
4126 provSigner = WTHelperGetProvSignerFromChain(
4127 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
4128 data->pCertViewInfo->idxSigner,
4129 data->pCertViewInfo->fCounterSigner,
4130 data->pCertViewInfo->idxCounterSigner);
4131 memset(&viewInfo, 0, sizeof(viewInfo));
4132 viewInfo.dwSize = sizeof(viewInfo);
4133 viewInfo.dwFlags = data->pCertViewInfo->dwFlags;
4134 viewInfo.szTitle = data->pCertViewInfo->szTitle;
4135 viewInfo.pCertContext = provSigner->pasCertChain[selection].pCert;
4136 viewInfo.cStores = data->pCertViewInfo->cStores;
4137 viewInfo.rghStores = data->pCertViewInfo->rghStores;
4138 viewInfo.cPropSheetPages = data->pCertViewInfo->cPropSheetPages;
4139 viewInfo.rgPropSheetPages = data->pCertViewInfo->rgPropSheetPages;
4140 viewInfo.nStartPage = data->pCertViewInfo->nStartPage;
4141 CryptUIDlgViewCertificateW(&viewInfo, &changed);
4142 if (changed)
4143 {
4144 /* Delete the contents of the tree */
4145 SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
4146 /* Reinitialize the tree */
4147 show_cert_hierarchy(hwnd, data);
4148 }
4149 }
4150 }
4151
4152 static LRESULT CALLBACK hierarchy_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
4153 LPARAM lp)
4154 {
4155 PROPSHEETPAGEW *page;
4156 struct hierarchy_data *data;
4157 LRESULT ret = 0;
4158 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
4159
4160 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
4161
4162 switch (msg)
4163 {
4164 case WM_INITDIALOG:
4165 page = (PROPSHEETPAGEW *)lp;
4166 data = (struct hierarchy_data *)page->lParam;
4167 show_cert_hierarchy(hwnd, data);
4168 break;
4169 case WM_NOTIFY:
4170 {
4171 NMHDR *hdr;
4172
4173 hdr = (NMHDR *)lp;
4174 switch (hdr->code)
4175 {
4176 case TVN_SELCHANGEDW:
4177 {
4178 NMTREEVIEWW *nm = (NMTREEVIEWW*)lp;
4179 DWORD selection;
4180 CRYPT_PROVIDER_SGNR *provSigner;
4181
4182 data = get_hierarchy_data_from_tree_item(tree, nm->itemNew.hItem);
4183 selection = lparam_to_index(data, nm->itemNew.lParam);
4184 provSigner = WTHelperGetProvSignerFromChain(
4185 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
4186 data->pCertViewInfo->idxSigner,
4187 data->pCertViewInfo->fCounterSigner,
4188 data->pCertViewInfo->idxCounterSigner);
4189 EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), selection != 0);
4190 set_certificate_status(GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT),
4191 &provSigner->pasCertChain[selection]);
4192 break;
4193 }
4194 case NM_DBLCLK:
4195 show_dialog_for_selected_cert(hwnd);
4196 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
4197 ret = 1;
4198 break;
4199 }
4200 break;
4201 }
4202 case WM_COMMAND:
4203 switch (wp)
4204 {
4205 case IDC_VIEWCERTIFICATE:
4206 show_dialog_for_selected_cert(hwnd);
4207 break;
4208 }
4209 break;
4210 case WM_REFRESH_VIEW:
4211 {
4212 TVITEMW item;
4213
4214 /* Get hierarchy data */
4215 memset(&item, 0, sizeof(item));
4216 item.mask = TVIF_HANDLE | TVIF_PARAM;
4217 item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_ROOT,
4218 0);
4219 data = get_hierarchy_data_from_tree_item(tree, item.hItem);
4220 /* Delete the contents of the tree */
4221 SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
4222 /* Reinitialize the tree */
4223 show_cert_hierarchy(hwnd, data);
4224 break;
4225 }
4226 }
4227 return ret;
4228 }
4229
4230 static UINT CALLBACK hierarchy_callback(HWND hwnd, UINT msg,
4231 PROPSHEETPAGEW *page)
4232 {
4233 struct hierarchy_data *data;
4234
4235 switch (msg)
4236 {
4237 case PSPCB_RELEASE:
4238 data = (struct hierarchy_data *)page->lParam;
4239 ImageList_Destroy(data->imageList);
4240 HeapFree(GetProcessHeap(), 0, data);
4241 break;
4242 }
4243 return 0;
4244 }
4245
4246 static BOOL init_hierarchy_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
4247 PROPSHEETPAGEW *page)
4248 {
4249 struct hierarchy_data *data = HeapAlloc(GetProcessHeap(), 0,
4250 sizeof(struct hierarchy_data));
4251 BOOL ret = FALSE;
4252
4253 if (data)
4254 {
4255 data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
4256 if (data->imageList)
4257 {
4258 HBITMAP bmp;
4259 COLORREF backColor = RGB(255, 0, 255);
4260
4261 data->pCertViewInfo = pCertViewInfo;
4262 data->selectedCert = 0xffffffff;
4263
4264 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
4265 ImageList_AddMasked(data->imageList, bmp, backColor);
4266 DeleteObject(bmp);
4267 ImageList_SetBkColor(data->imageList, CLR_NONE);
4268
4269 memset(page, 0, sizeof(PROPSHEETPAGEW));
4270 page->dwSize = sizeof(PROPSHEETPAGEW);
4271 page->dwFlags = PSP_USECALLBACK;
4272 page->hInstance = hInstance;
4273 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_HIERARCHY);
4274 page->pfnDlgProc = hierarchy_dlg_proc;
4275 page->lParam = (LPARAM)data;
4276 page->pfnCallback = hierarchy_callback;
4277 ret = TRUE;
4278 }
4279 else
4280 HeapFree(GetProcessHeap(), 0, data);
4281 }
4282 return ret;
4283 }
4284
4285 static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
4286 {
4287 RECT rc;
4288
4289 TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
4290
4291 switch (msg)
4292 {
4293 case PSCB_INITIALIZED:
4294 /* Get cancel button's position.. */
4295 GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
4296 MapWindowPoints( 0, hwnd, (POINT *)&rc, 2 );
4297 /* hide the cancel button.. */
4298 ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
4299 /* and move the OK button to the cancel button's original position. */
4300 SetWindowPos(GetDlgItem(hwnd, IDOK), 0, rc.left, rc.top, 0, 0,
4301 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW );
4302 break;
4303 }
4304 return 0;
4305 }
4306
4307 static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
4308 CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
4309 {
4310 static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
4311 DWORD nPages;
4312 PROPSHEETPAGEW *pages;
4313 BOOL ret = FALSE;
4314 HMODULE lib = LoadLibraryW(riched);
4315
4316 nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
4317 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
4318 nPages++;
4319 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
4320 nPages++;
4321 pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
4322 if (pages)
4323 {
4324 PROPSHEETHEADERW hdr;
4325 CRYPTUI_INITDIALOG_STRUCT *init = NULL;
4326 DWORD i;
4327
4328 memset(&hdr, 0, sizeof(hdr));
4329 hdr.dwSize = sizeof(hdr);
4330 hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
4331 hdr.hInstance = hInstance;
4332 if (pCertViewInfo->szTitle)
4333 hdr.pszCaption = pCertViewInfo->szTitle;
4334 else
4335 hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
4336 init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
4337 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
4338 {
4339 if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
4340 &pages[hdr.nPages]))
4341 hdr.nPages++;
4342 }
4343 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
4344 {
4345 if (init_hierarchy_page(pCertViewInfo, &pages[hdr.nPages]))
4346 hdr.nPages++;
4347 }
4348 /* Copy each additional page, and create the init dialog struct for it
4349 */
4350 if (pCertViewInfo->cPropSheetPages)
4351 {
4352 init = HeapAlloc(GetProcessHeap(), 0,
4353 pCertViewInfo->cPropSheetPages *
4354 sizeof(CRYPTUI_INITDIALOG_STRUCT));
4355 if (init)
4356 {
4357 for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
4358 {
4359 memcpy(&pages[hdr.nPages + i],
4360 &pCertViewInfo->rgPropSheetPages[i],
4361 sizeof(PROPSHEETPAGEW));
4362 init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
4363 init[i].pCertContext = pCertViewInfo->pCertContext;
4364 pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
4365 }
4366 if (pCertViewInfo->nStartPage & 0x8000)
4367 {
4368 /* Start page index is relative to the number of default
4369 * pages
4370 */
4371 hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
4372 }
4373 else
4374 hdr.u2.nStartPage = pCertViewInfo->nStartPage;
4375 hdr.nPages = nPages;
4376 ret = TRUE;
4377 }
4378 else
4379 SetLastError(ERROR_OUTOFMEMORY);
4380 }
4381 else
4382 {
4383 /* Ignore the relative flag if there aren't any additional pages */
4384 hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
4385 ret = TRUE;
4386 }
4387 if (ret)
4388 {
4389 INT_PTR l;
4390
4391 hdr.u3.ppsp = pages;
4392 hdr.pfnCallback = cert_prop_sheet_proc;
4393 l = PropertySheetW(&hdr);
4394 if (l == 0)
4395 {
4396 SetLastError(ERROR_CANCELLED);
4397 ret = FALSE;
4398 }
4399 }
4400 HeapFree(GetProcessHeap(), 0, init);
4401 HeapFree(GetProcessHeap(), 0, pages);
4402 }
4403 else
4404 SetLastError(ERROR_OUTOFMEMORY);
4405 FreeLibrary(lib);
4406 return ret;
4407 }
4408
4409 /***********************************************************************
4410 * CryptUIDlgViewCertificateW (CRYPTUI.@)
4411 */
4412 BOOL WINAPI CryptUIDlgViewCertificateW(
4413 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
4414 {
4415 static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
4416 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
4417 WINTRUST_DATA wvt;
4418 WINTRUST_CERT_INFO cert;
4419 BOOL ret = FALSE;
4420 CRYPT_PROVIDER_SGNR *signer;
4421 CRYPT_PROVIDER_CERT *provCert = NULL;
4422
4423 TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
4424
4425 if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
4426 {
4427 SetLastError(ERROR_INVALID_PARAMETER);
4428 return FALSE;
4429 }
4430 /* Make a local copy in case we have to call WinVerifyTrust ourselves */
4431 memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
4432 if (!pCertViewInfo->u.hWVTStateData)
4433 {
4434 memset(&wvt, 0, sizeof(wvt));
4435 wvt.cbStruct = sizeof(wvt);
4436 wvt.dwUIChoice = WTD_UI_NONE;
4437 if (viewInfo.dwFlags &
4438 CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
4439 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
4440 if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
4441 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
4442 if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
4443 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
4444 wvt.dwUnionChoice = WTD_CHOICE_CERT;
4445 memset(&cert, 0, sizeof(cert));
4446 cert.cbStruct = sizeof(cert);
4447 cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
4448 cert.chStores = viewInfo.cStores;
4449 cert.pahStores = viewInfo.rghStores;
4450 wvt.u.pCert = &cert;
4451 wvt.dwStateAction = WTD_STATEACTION_VERIFY;
4452 WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
4453 viewInfo.u.pCryptProviderData =
4454 WTHelperProvDataFromStateData(wvt.hWVTStateData);
4455 signer = WTHelperGetProvSignerFromChain(
4456 (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
4457 provCert = WTHelperGetProvCertFromChain(signer, 0);
4458 ret = TRUE;
4459 }
4460 else
4461 {
4462 viewInfo.u.pCryptProviderData =
4463 WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
4464 signer = WTHelperGetProvSignerFromChain(
4465 (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
4466 viewInfo.idxSigner, viewInfo.fCounterSigner,
4467 viewInfo.idxCounterSigner);
4468 provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
4469 ret = TRUE;
4470 }
4471 if (ret)
4472 {
4473 ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
4474 if (!pCertViewInfo->u.hWVTStateData)
4475 {
4476 wvt.dwStateAction = WTD_STATEACTION_CLOSE;
4477 WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
4478 }
4479 }
4480 return ret;
4481 }
4482
4483 /***********************************************************************
4484 * CryptUIDlgViewContext (CRYPTUI.@)
4485 */
4486 BOOL WINAPI CryptUIDlgViewContext(DWORD dwContextType, LPVOID pvContext,
4487 HWND hwnd, LPCWSTR pwszTitle, DWORD dwFlags, LPVOID pvReserved)
4488 {
4489 BOOL ret;
4490
4491 TRACE("(%d, %p, %p, %s, %08x, %p)\n", dwContextType, pvContext, hwnd,
4492 debugstr_w(pwszTitle), dwFlags, pvReserved);
4493
4494 switch (dwContextType)
4495 {
4496 case CERT_STORE_CERTIFICATE_CONTEXT:
4497 {
4498 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
4499
4500 memset(&viewInfo, 0, sizeof(viewInfo));
4501 viewInfo.dwSize = sizeof(viewInfo);
4502 viewInfo.hwndParent = hwnd;
4503 viewInfo.szTitle = pwszTitle;
4504 viewInfo.pCertContext = pvContext;
4505 ret = CryptUIDlgViewCertificateW(&viewInfo, NULL);
4506 break;
4507 }
4508 default:
4509 FIXME("unimplemented for context type %d\n", dwContextType);
4510 SetLastError(E_INVALIDARG);
4511 ret = FALSE;
4512 }
4513 return ret;
4514 }
4515
4516 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
4517 * or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
4518 * should be a CA. If neither extension is present, returns
4519 * defaultIfNotSpecified.
4520 */
4521 static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
4522 {
4523 BOOL isCA = defaultIfNotSpecified;
4524 PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
4525 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
4526
4527 if (ext)
4528 {
4529 CERT_BASIC_CONSTRAINTS_INFO *info;
4530 DWORD size = 0;
4531
4532 if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
4533 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
4534 NULL, &info, &size))
4535 {
4536 if (info->SubjectType.cbData == 1)
4537 isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
4538 LocalFree(info);
4539 }
4540 }
4541 else
4542 {
4543 ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
4544 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
4545 if (ext)
4546 {
4547 CERT_BASIC_CONSTRAINTS2_INFO info;
4548 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
4549
4550 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
4551 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
4552 0, NULL, &info, &size))
4553 isCA = info.fCA;
4554 }
4555 }
4556 return isCA;
4557 }
4558
4559 static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
4560 {
4561 LPCWSTR storeName;
4562
4563 if (is_ca_cert(cert, TRUE))
4564 storeName = ca;
4565 else
4566 storeName = addressBook;
4567 return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
4568 CERT_SYSTEM_STORE_CURRENT_USER, storeName);
4569 }
4570
4571 static BOOL import_cert(PCCERT_CONTEXT cert, HCERTSTORE hDestCertStore)
4572 {
4573 HCERTSTORE store;
4574 BOOL ret;
4575
4576 if (!cert)
4577 {
4578 SetLastError(E_INVALIDARG);
4579 return FALSE;
4580 }
4581 if (hDestCertStore) store = hDestCertStore;
4582 else
4583 {
4584 if (!(store = choose_store_for_cert(cert)))
4585 {
4586 WARN("unable to open certificate store\n");
4587 return FALSE;
4588 }
4589 }
4590 ret = CertAddCertificateContextToStore(store, cert,
4591 CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
4592 if (!hDestCertStore) CertCloseStore(store, 0);
4593 return ret;
4594 }
4595
4596 static BOOL import_crl(PCCRL_CONTEXT crl, HCERTSTORE hDestCertStore)
4597 {
4598 HCERTSTORE store;
4599 BOOL ret;
4600
4601 if (!crl)
4602 {
4603 SetLastError(E_INVALIDARG);
4604 return FALSE;
4605 }
4606 if (hDestCertStore) store = hDestCertStore;
4607 else
4608 {
4609 if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
4610 CERT_SYSTEM_STORE_CURRENT_USER, ca)))
4611 {
4612 WARN("unable to open certificate store\n");
4613 return FALSE;
4614 }
4615 }
4616 ret = CertAddCRLContextToStore(store, crl,
4617 CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
4618 if (!hDestCertStore) CertCloseStore(store, 0);
4619 return ret;
4620 }
4621
4622 static BOOL import_ctl(PCCTL_CONTEXT ctl, HCERTSTORE hDestCertStore)
4623 {
4624 HCERTSTORE store;
4625 BOOL ret;
4626
4627 if (!ctl)
4628 {
4629 SetLastError(E_INVALIDARG);
4630 return FALSE;
4631 }
4632 if (hDestCertStore) store = hDestCertStore;
4633 else
4634 {
4635 static const WCHAR trust[] = { 'T','r','u','s','t',0 };
4636
4637 if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
4638 CERT_SYSTEM_STORE_CURRENT_USER, trust)))
4639 {
4640 WARN("unable to open certificate store\n");
4641 return FALSE;
4642 }
4643 }
4644 ret = CertAddCTLContextToStore(store, ctl,
4645 CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
4646 if (!hDestCertStore) CertCloseStore(store, 0);
4647 return ret;
4648 }
4649
4650 /* Checks type, a type such as CERT_QUERY_CONTENT_CERT returned by
4651 * CryptQueryObject, against the allowed types. Returns TRUE if the
4652 * type is allowed, FALSE otherwise.
4653 */
4654 static BOOL check_context_type(DWORD dwFlags, DWORD type)
4655 {
4656 BOOL ret;
4657
4658 if (dwFlags &
4659 (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
4660 CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4661 {
4662 switch (type)
4663 {
4664 case CERT_QUERY_CONTENT_CERT:
4665 case CERT_QUERY_CONTENT_SERIALIZED_CERT:
4666 ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT;
4667 break;
4668 case CERT_QUERY_CONTENT_CRL:
4669 case CERT_QUERY_CONTENT_SERIALIZED_CRL:
4670 ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL;
4671 break;
4672 case CERT_QUERY_CONTENT_CTL:
4673 case CERT_QUERY_CONTENT_SERIALIZED_CTL:
4674 ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL;
4675 break;
4676 default:
4677 /* The remaining types contain more than one type, so allow
4678 * any combination.
4679 */
4680 ret = TRUE;
4681 }
4682 }
4683 else
4684 {
4685 /* No allowed types specified, so any type is allowed */
4686 ret = TRUE;
4687 }
4688 if (!ret)
4689 SetLastError(E_INVALIDARG);
4690 return ret;
4691 }
4692
4693
4694 static void import_warning(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
4695 int warningID)
4696 {
4697 if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
4698 {
4699 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
4700 LPCWSTR pTitle;
4701
4702 if (szTitle)
4703 pTitle = szTitle;
4704 else
4705 {
4706 LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
4707 sizeof(title) / sizeof(title[0]));
4708 pTitle = title;
4709 }
4710 LoadStringW(hInstance, warningID, error,
4711 sizeof(error) / sizeof(error[0]));
4712 MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
4713 }
4714 }
4715
4716 static void import_warn_type_mismatch(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle)
4717 {
4718 import_warning(dwFlags, hwnd, szTitle, IDS_IMPORT_TYPE_MISMATCH);
4719 }
4720
4721 static BOOL check_store_context_type(DWORD dwFlags, HCERTSTORE store)
4722 {
4723 BOOL ret;
4724
4725 if (dwFlags &
4726 (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
4727 CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4728 {
4729 PCCERT_CONTEXT cert;
4730 PCCRL_CONTEXT crl;
4731 PCCTL_CONTEXT ctl;
4732
4733 ret = TRUE;
4734 if ((cert = CertEnumCertificatesInStore(store, NULL)))
4735 {
4736 CertFreeCertificateContext(cert);
4737 if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT))
4738 ret = FALSE;
4739 }
4740 if (ret && (crl = CertEnumCRLsInStore(store, NULL)))
4741 {
4742 CertFreeCRLContext(crl);
4743 if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL))
4744 ret = FALSE;
4745 }
4746 if (ret && (ctl = CertEnumCTLsInStore(store, NULL)))
4747 {
4748 CertFreeCTLContext(ctl);
4749 if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4750 ret = FALSE;
4751 }
4752 }
4753 else
4754 ret = TRUE;
4755 if (!ret)
4756 SetLastError(E_INVALIDARG);
4757 return ret;
4758 }
4759
4760 static BOOL import_store(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
4761 HCERTSTORE source, HCERTSTORE dest)
4762 {
4763 BOOL ret;
4764
4765 if ((ret = check_store_context_type(dwFlags, source)))
4766 {
4767 PCCERT_CONTEXT cert = NULL;
4768 PCCRL_CONTEXT crl = NULL;
4769 PCCTL_CONTEXT ctl = NULL;
4770
4771 do {
4772 cert = CertEnumCertificatesInStore(source, cert);
4773 if (cert)
4774 ret = import_cert(cert, dest);
4775 } while (ret && cert);
4776 do {
4777 crl = CertEnumCRLsInStore(source, crl);
4778 if (crl)
4779 ret = import_crl(crl, dest);
4780 } while (ret && crl);
4781 do {
4782 ctl = CertEnumCTLsInStore(source, ctl);
4783 if (ctl)
4784 ret = import_ctl(ctl, dest);
4785 } while (ret && ctl);
4786 }
4787 else
4788 import_warn_type_mismatch(dwFlags, hwnd, szTitle);
4789 return ret;
4790 }
4791
4792 static HCERTSTORE open_store_from_file(DWORD dwFlags, LPCWSTR fileName,
4793 DWORD *pContentType)
4794 {
4795 HCERTSTORE store = NULL;
4796 DWORD contentType = 0, expectedContentTypeFlags;
4797
4798 if (dwFlags &
4799 (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
4800 CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
4801 {
4802 expectedContentTypeFlags =
4803 CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
4804 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
4805 CERT_QUERY_CONTENT_FLAG_PFX;
4806 if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT)
4807 expectedContentTypeFlags |=
4808 CERT_QUERY_CONTENT_FLAG_CERT |
4809 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT;
4810 if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL)
4811 expectedContentTypeFlags |=
4812 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
4813 CERT_QUERY_CONTENT_FLAG_CRL;
4814 if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL)
4815 expectedContentTypeFlags |=
4816 CERT_QUERY_CONTENT_FLAG_CTL |
4817 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL;
4818 }
4819 else
4820 expectedContentTypeFlags =
4821 CERT_QUERY_CONTENT_FLAG_CERT |
4822 CERT_QUERY_CONTENT_FLAG_CTL |
4823 CERT_QUERY_CONTENT_FLAG_CRL |
4824 CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
4825 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT |
4826 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL |
4827 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
4828 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
4829 CERT_QUERY_CONTENT_FLAG_PFX;
4830
4831 CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
4832 expectedContentTypeFlags, CERT_QUERY_FORMAT_FLAG_ALL, 0, NULL,
4833 &contentType, NULL, &store, NULL, NULL);
4834 if (pContentType)
4835 *pContentType = contentType;
4836 return store;
4837 }
4838
4839 static BOOL import_file(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
4840 LPCWSTR fileName, HCERTSTORE dest)
4841 {
4842 HCERTSTORE source;
4843 BOOL ret;
4844
4845 if ((source = open_store_from_file(dwFlags, fileName, NULL)))
4846 {
4847 ret = import_store(dwFlags, hwnd, szTitle, source, dest);
4848 CertCloseStore(source, 0);
4849 }
4850 else
4851 ret = FALSE;
4852 return ret;
4853 }
4854
4855 struct ImportWizData
4856 {
4857 HFONT titleFont;
4858 DWORD dwFlags;
4859 LPCWSTR pwszWizardTitle;
4860 CRYPTUI_WIZ_IMPORT_SRC_INFO importSrc;
4861 LPWSTR fileName;
4862 DWORD contentType;
4863 BOOL freeSource;
4864 HCERTSTORE hDestCertStore;
4865 BOOL freeDest;
4866 BOOL autoDest;
4867 BOOL success;
4868 };
4869
4870 static LRESULT CALLBACK import_welcome_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
4871 LPARAM lp)
4872 {
4873 LRESULT ret = 0;
4874
4875 switch (msg)
4876 {
4877 case WM_INITDIALOG:
4878 {
4879 struct ImportWizData *data;
4880 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
4881 WCHAR fontFace[MAX_STRING_LEN];
4882 HDC hDC = GetDC(hwnd);
4883 int height;
4884
4885 data = (struct ImportWizData *)page->lParam;
4886 LoadStringW(hInstance, IDS_WIZARD_TITLE_FONT, fontFace,
4887 sizeof(fontFace) / sizeof(fontFace[0]));
4888 height = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
4889 data->titleFont = CreateFontW(height, 0, 0, 0, FW_BOLD, 0, 0, 0,
4890 DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
4891 DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontFace);
4892 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_TITLE), WM_SETFONT,
4893 (WPARAM)data->titleFont, TRUE);
4894 ReleaseDC(hwnd, hDC);
4895 break;
4896 }
4897 case WM_NOTIFY:
4898 {
4899 NMHDR *hdr = (NMHDR *)lp;
4900
4901 switch (hdr->code)
4902 {
4903 case PSN_SETACTIVE:
4904 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
4905 ret = TRUE;
4906 break;
4907 }
4908 break;
4909 }
4910 }
4911 return ret;
4912 }
4913
4914 static const WCHAR filter_cert[] = { '*','.','c','e','r',';','*','.',
4915 'c','r','t',0 };
4916 static const WCHAR filter_pfx[] = { '*','.','p','f','x',';','*','.',
4917 'p','1','2',0 };
4918 static const WCHAR filter_crl[] = { '*','.','c','r','l',0 };
4919 static const WCHAR filter_ctl[] = { '*','.','s','t','l',0 };
4920 static const WCHAR filter_serialized_store[] = { '*','.','s','s','t',0 };
4921 static const WCHAR filter_cms[] = { '*','.','s','p','c',';','*','.',
4922 'p','7','b',0 };
4923 static const WCHAR filter_all[] = { '*','.','*',0 };
4924
4925 static struct StringToFilter
4926 {
4927 int id;
4928 DWORD allowFlags;
4929 LPCWSTR filter;
4930 } import_filters[] = {
4931 { IDS_IMPORT_FILTER_CERT, CRYPTUI_WIZ_IMPORT_ALLOW_CERT, filter_cert },
4932 { IDS_IMPORT_FILTER_PFX, 0, filter_pfx },
4933 { IDS_IMPORT_FILTER_CRL, CRYPTUI_WIZ_IMPORT_ALLOW_CRL, filter_crl },
4934 { IDS_IMPORT_FILTER_CTL, CRYPTUI_WIZ_IMPORT_ALLOW_CTL, filter_ctl },
4935 { IDS_IMPORT_FILTER_SERIALIZED_STORE, 0, filter_serialized_store },
4936 { IDS_IMPORT_FILTER_CMS, 0, filter_cms },
4937 { IDS_IMPORT_FILTER_ALL, 0, filter_all },
4938 };
4939
4940 static WCHAR *make_import_file_filter(DWORD dwFlags)
4941 {
4942 DWORD i;
4943 int len, totalLen = 2;
4944 LPWSTR filter = NULL, str;
4945
4946 for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
4947 {
4948 if (!import_filters[i].allowFlags || !dwFlags ||
4949 (dwFlags & import_filters[i].allowFlags))
4950 {
4951 len = LoadStringW(hInstance, import_filters[i].id, (LPWSTR)&str, 0);
4952 totalLen += len + strlenW(import_filters[i].filter) + 2;
4953 }
4954 }
4955 filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
4956 if (filter)
4957 {
4958 LPWSTR ptr;
4959
4960 ptr = filter;
4961 for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
4962 {
4963 if (!import_filters[i].allowFlags || !dwFlags ||
4964 (dwFlags & import_filters[i].allowFlags))
4965 {
4966 len = LoadStringW(hInstance, import_filters[i].id,
4967 (LPWSTR)&str, 0);
4968 memcpy(ptr, str, len * sizeof(WCHAR));
4969 ptr += len;
4970 *ptr++ = 0;
4971 strcpyW(ptr, import_filters[i].filter);
4972 ptr += strlenW(import_filters[i].filter) + 1;
4973 }
4974 }
4975 *ptr++ = 0;
4976 }
4977 return filter;
4978 }
4979
4980 static BOOL import_validate_filename(HWND hwnd, struct ImportWizData *data,
4981 LPCWSTR fileName)
4982 {
4983 HANDLE file;
4984 BOOL ret = FALSE;
4985
4986 file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
4987 OPEN_EXISTING, 0, NULL);
4988 if (file != INVALID_HANDLE_VALUE)
4989 {
4990 HCERTSTORE source = open_store_from_file(data->dwFlags, fileName,
4991 &data->contentType);
4992 int warningID = 0;
4993
4994 if (!source)
4995 warningID = IDS_IMPORT_BAD_FORMAT;
4996 else if (!check_store_context_type(data->dwFlags, source))
4997 warningID = IDS_IMPORT_TYPE_MISMATCH;
4998 else
4999 {
5000 data->importSrc.dwSubjectChoice =
5001 CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE;
5002 data->importSrc.u.hCertStore = source;
5003 data->freeSource = TRUE;
5004 ret = TRUE;
5005 }
5006 if (warningID)
5007 {
5008 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
5009 warningID);
5010 }
5011 CloseHandle(file);
5012 }
5013 else
5014 {
5015 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
5016 LPCWSTR pTitle;
5017 LPWSTR msgBuf, fullError;
5018
5019 if (data->pwszWizardTitle)
5020 pTitle = data->pwszWizardTitle;
5021 else
5022 {
5023 LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
5024 sizeof(title) / sizeof(title[0]));
5025 pTitle = title;
5026 }
5027 LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error,
5028 sizeof(error) / sizeof(error[0]));
5029 FormatMessageW(
5030 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
5031 GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
5032 fullError = HeapAlloc(GetProcessHeap(), 0,
5033 (strlenW(error) + strlenW(fileName) + strlenW(msgBuf) + 3)
5034 * sizeof(WCHAR));
5035 if (fullError)
5036 {
5037 LPWSTR ptr = fullError;
5038
5039 strcpyW(ptr, error);
5040 ptr += strlenW(error);
5041 strcpyW(ptr, fileName);
5042 ptr += strlenW(fileName);
5043 *ptr++ = ':';
5044 *ptr++ = '\n';
5045 strcpyW(ptr, msgBuf);
5046 MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
5047 HeapFree(GetProcessHeap(), 0, fullError);
5048 }
5049 LocalFree(msgBuf);
5050 }
5051 return ret;
5052 }
5053
5054 static LRESULT CALLBACK import_file_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
5055 LPARAM lp)
5056 {
5057 LRESULT ret = 0;
5058 struct ImportWizData *data;
5059
5060 switch (msg)
5061 {
5062 case WM_INITDIALOG:
5063 {
5064 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5065
5066 data = (struct ImportWizData *)page->lParam;
5067 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
5068 if (data->fileName)
5069 {
5070 HWND fileNameEdit = GetDlgItem(hwnd, IDC_IMPORT_FILENAME);
5071
5072 SendMessageW(fileNameEdit, WM_SETTEXT, 0, (LPARAM)data->fileName);
5073 }
5074 break;
5075 }
5076 case WM_NOTIFY:
5077 {
5078 NMHDR *hdr = (NMHDR *)lp;
5079
5080 switch (hdr->code)
5081 {
5082 case PSN_SETACTIVE:
5083 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
5084 PSWIZB_BACK | PSWIZB_NEXT);
5085 ret = TRUE;
5086 break;
5087 case PSN_WIZNEXT:
5088 {
5089 HWND fileNameEdit = GetDlgItem(hwnd, IDC_IMPORT_FILENAME);
5090 DWORD len = SendMessageW(fileNameEdit, WM_GETTEXTLENGTH, 0, 0);
5091
5092 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5093 if (!len)
5094 {
5095 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
5096 IDS_IMPORT_EMPTY_FILE);
5097 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
5098 ret = 1;
5099 }
5100 else
5101 {
5102 LPWSTR fileName = HeapAlloc(GetProcessHeap(), 0,
5103 (len + 1) * sizeof(WCHAR));
5104
5105 if (fileName)
5106 {
5107 SendMessageW(fileNameEdit, WM_GETTEXT, len + 1,
5108 (LPARAM)fileName);
5109 if (!import_validate_filename(hwnd, data, fileName))
5110 {
5111 HeapFree(GetProcessHeap(), 0, fileName);
5112 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
5113 ret = 1;
5114 }
5115 else
5116 data->fileName = fileName;
5117 }
5118 }
5119 break;
5120 }
5121 }
5122 break;
5123 }
5124 case WM_COMMAND:
5125 switch (wp)
5126 {
5127 case IDC_IMPORT_BROWSE_FILE:
5128 {
5129 OPENFILENAMEW ofn;
5130 WCHAR fileBuf[MAX_PATH];
5131
5132 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5133 memset(&ofn, 0, sizeof(ofn));
5134 ofn.lStructSize = sizeof(ofn);
5135 ofn.hwndOwner = hwnd;
5136 ofn.lpstrFilter = make_import_file_filter(data->dwFlags);
5137 ofn.lpstrFile = fileBuf;
5138 ofn.nMaxFile = sizeof(fileBuf) / sizeof(fileBuf[0]);
5139 fileBuf[0] = 0;
5140 if (GetOpenFileNameW(&ofn))
5141 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_FILENAME), WM_SETTEXT,
5142 0, (LPARAM)ofn.lpstrFile);
5143 HeapFree(GetProcessHeap(), 0, (LPWSTR)ofn.lpstrFilter);
5144 break;
5145 }
5146 }
5147 break;
5148 }
5149 return ret;
5150 }
5151
5152 static LRESULT CALLBACK import_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
5153 LPARAM lp)
5154 {
5155 LRESULT ret = 0;
5156 struct ImportWizData *data;
5157
5158 switch (msg)
5159 {
5160 case WM_INITDIALOG:
5161 {
5162 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5163
5164 data = (struct ImportWizData *)page->lParam;
5165 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
5166 if (!data->hDestCertStore)
5167 {
5168 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_AUTO_STORE), BM_CLICK,
5169 0, 0);
5170 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), FALSE);
5171 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), FALSE);
5172 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE), FALSE);
5173 }
5174 else
5175 {
5176 WCHAR storeTitle[MAX_STRING_LEN];
5177
5178 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE), BM_CLICK,
5179 0, 0);
5180 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), TRUE);
5181 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), TRUE);
5182 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_SPECIFY_STORE),
5183 !(data->dwFlags & CRYPTUI_WIZ_IMPORT_NO_CHANGE_DEST_STORE));
5184 LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED,
5185 storeTitle, sizeof(storeTitle) / sizeof(storeTitle[0]));
5186 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_STORE), WM_SETTEXT,
5187 0, (LPARAM)storeTitle);
5188 }
5189 break;
5190 }
5191 case WM_NOTIFY:
5192 {
5193 NMHDR *hdr = (NMHDR *)lp;
5194
5195 switch (hdr->code)
5196 {
5197 case PSN_SETACTIVE:
5198 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
5199 PSWIZB_BACK | PSWIZB_NEXT);
5200 ret = TRUE;
5201 break;
5202 case PSN_WIZNEXT:
5203 {
5204 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5205 if (IsDlgButtonChecked(hwnd, IDC_IMPORT_SPECIFY_STORE) &&
5206 !data->hDestCertStore)
5207 {
5208 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
5209 IDS_IMPORT_SELECT_STORE);
5210 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
5211 ret = 1;
5212 }
5213 break;
5214 }
5215 }
5216 break;
5217 }
5218 case WM_COMMAND:
5219 switch (wp)
5220 {
5221 case IDC_IMPORT_AUTO_STORE:
5222 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5223 data->autoDest = TRUE;
5224 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), FALSE);
5225 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), FALSE);
5226 break;
5227 case IDC_IMPORT_SPECIFY_STORE:
5228 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5229 data->autoDest = FALSE;
5230 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_STORE), TRUE);
5231 EnableWindow(GetDlgItem(hwnd, IDC_IMPORT_BROWSE_STORE), TRUE);
5232 break;
5233 case IDC_IMPORT_BROWSE_STORE:
5234 {
5235 CRYPTUI_ENUM_SYSTEM_STORE_ARGS enumArgs = {
5236 CERT_SYSTEM_STORE_CURRENT_USER, NULL };
5237 CRYPTUI_ENUM_DATA enumData = { 0, NULL, 1, &enumArgs };
5238 CRYPTUI_SELECTSTORE_INFO_W selectInfo;
5239 HCERTSTORE store;
5240
5241 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5242 selectInfo.dwSize = sizeof(selectInfo);
5243 selectInfo.parent = hwnd;
5244 selectInfo.dwFlags = CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE;
5245 selectInfo.pwszTitle = NULL;
5246 selectInfo.pwszText = NULL;
5247 selectInfo.pEnumData = &enumData;
5248 selectInfo.pfnSelectedStoreCallback = NULL;
5249 if ((store = CryptUIDlgSelectStoreW(&selectInfo)))
5250 {
5251 WCHAR storeTitle[MAX_STRING_LEN];
5252
5253 LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED,
5254 storeTitle, sizeof(storeTitle) / sizeof(storeTitle[0]));
5255 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_STORE), WM_SETTEXT,
5256 0, (LPARAM)storeTitle);
5257 data->hDestCertStore = store;
5258 data->freeDest = TRUE;
5259 }
5260 break;
5261 }
5262 }
5263 break;
5264 }
5265 return ret;
5266 }
5267
5268 static void show_import_details(HWND lv, struct ImportWizData *data)
5269 {
5270 WCHAR text[MAX_STRING_LEN];
5271 LVITEMW item;
5272 int contentID;
5273
5274 item.mask = LVIF_TEXT;
5275 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
5276 item.iSubItem = 0;
5277 LoadStringW(hInstance, IDS_IMPORT_STORE_SELECTION, text,
5278 sizeof(text)/ sizeof(text[0]));
5279 item.pszText = text;
5280 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
5281 item.iSubItem = 1;
5282 if (data->autoDest)
5283 LoadStringW(hInstance, IDS_IMPORT_DEST_AUTOMATIC, text,
5284 sizeof(text)/ sizeof(text[0]));
5285 else
5286 LoadStringW(hInstance, IDS_IMPORT_DEST_DETERMINED, text,
5287 sizeof(text)/ sizeof(text[0]));
5288 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
5289 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
5290 item.iSubItem = 0;
5291 LoadStringW(hInstance, IDS_IMPORT_CONTENT, text,
5292 sizeof(text)/ sizeof(text[0]));
5293 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
5294 switch (data->contentType)
5295 {
5296 case CERT_QUERY_CONTENT_CERT:
5297 case CERT_QUERY_CONTENT_SERIALIZED_CERT:
5298 contentID = IDS_IMPORT_CONTENT_CERT;
5299 break;
5300 case CERT_QUERY_CONTENT_CRL:
5301 case CERT_QUERY_CONTENT_SERIALIZED_CRL:
5302 contentID = IDS_IMPORT_CONTENT_CRL;
5303 break;
5304 case CERT_QUERY_CONTENT_CTL:
5305 case CERT_QUERY_CONTENT_SERIALIZED_CTL:
5306 contentID = IDS_IMPORT_CONTENT_CTL;
5307 break;
5308 case CERT_QUERY_CONTENT_PKCS7_SIGNED:
5309 contentID = IDS_IMPORT_CONTENT_CMS;
5310 break;
5311 case CERT_QUERY_CONTENT_FLAG_PFX:
5312 contentID = IDS_IMPORT_CONTENT_PFX;
5313 break;
5314 default:
5315 contentID = IDS_IMPORT_CONTENT_STORE;
5316 break;
5317 }
5318 LoadStringW(hInstance, contentID, text, sizeof(text)/ sizeof(text[0]));
5319 item.iSubItem = 1;
5320 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
5321 if (data->fileName)
5322 {
5323 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
5324 item.iSubItem = 0;
5325 LoadStringW(hInstance, IDS_IMPORT_FILE, text,
5326 sizeof(text)/ sizeof(text[0]));
5327 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
5328 item.iSubItem = 1;
5329 item.pszText = data->fileName;
5330 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
5331 }
5332 }
5333
5334 static BOOL do_import(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
5335 PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
5336 {
5337 BOOL ret;
5338
5339 switch (pImportSrc->dwSubjectChoice)
5340 {
5341 case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
5342 ret = import_file(dwFlags, hwndParent, pwszWizardTitle,
5343 pImportSrc->u.pwszFileName, hDestCertStore);
5344 break;
5345 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
5346 if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CERT)))
5347 ret = import_cert(pImportSrc->u.pCertContext, hDestCertStore);
5348 else
5349 import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
5350 break;
5351 case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
5352 if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CRL)))
5353 ret = import_crl(pImportSrc->u.pCRLContext, hDestCertStore);
5354 else
5355 import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
5356 break;
5357 case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
5358 if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CTL)))
5359 ret = import_ctl(pImportSrc->u.pCTLContext, hDestCertStore);
5360 else
5361 import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
5362 break;
5363 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
5364 ret = import_store(dwFlags, hwndParent, pwszWizardTitle,
5365 pImportSrc->u.hCertStore, hDestCertStore);
5366 break;
5367 default:
5368 WARN("unknown source type: %u\n", pImportSrc->dwSubjectChoice);
5369 SetLastError(E_INVALIDARG);
5370 ret = FALSE;
5371 }
5372 return ret;
5373 }
5374
5375 static LRESULT CALLBACK import_finish_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
5376 LPARAM lp)
5377 {
5378 LRESULT ret = 0;
5379 struct ImportWizData *data;
5380
5381 switch (msg)
5382 {
5383 case WM_INITDIALOG:
5384 {
5385 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5386 HWND lv = GetDlgItem(hwnd, IDC_IMPORT_SETTINGS);
5387 RECT rc;
5388 LVCOLUMNW column;
5389
5390 data = (struct ImportWizData *)page->lParam;
5391 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
5392 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_TITLE), WM_SETFONT,
5393 (WPARAM)data->titleFont, TRUE);
5394 GetWindowRect(lv, &rc);
5395 column.mask = LVCF_WIDTH;
5396 column.cx = (rc.right - rc.left) / 2 - 2;
5397 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
5398 SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
5399 show_import_details(lv, data);
5400 break;
5401 }
5402 case WM_NOTIFY:
5403 {
5404 NMHDR *hdr = (NMHDR *)lp;
5405
5406 switch (hdr->code)
5407 {
5408 case PSN_SETACTIVE:
5409 {
5410 HWND lv = GetDlgItem(hwnd, IDC_IMPORT_SETTINGS);
5411
5412 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5413 SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
5414 show_import_details(lv, data);
5415 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
5416 PSWIZB_BACK | PSWIZB_FINISH);
5417 ret = TRUE;
5418 break;
5419 }
5420 case PSN_WIZFINISH:
5421 {
5422 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5423 if ((data->success = do_import(data->dwFlags, hwnd,
5424 data->pwszWizardTitle, &data->importSrc, data->hDestCertStore)))
5425 {
5426 WCHAR title[MAX_STRING_LEN], message[MAX_STRING_LEN];
5427 LPCWSTR pTitle;
5428
5429 if (data->pwszWizardTitle)
5430 pTitle = data->pwszWizardTitle;
5431 else
5432 {
5433 LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
5434 sizeof(title) / sizeof(title[0]));
5435 pTitle = title;
5436 }
5437 LoadStringW(hInstance, IDS_IMPORT_SUCCEEDED, message,
5438 sizeof(message) / sizeof(message[0]));
5439 MessageBoxW(hwnd, message, pTitle, MB_OK);
5440 }
5441 else
5442 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
5443 IDS_IMPORT_FAILED);
5444 break;
5445 }
5446 }
5447 break;
5448 }
5449 }
5450 return ret;
5451 }
5452
5453 static BOOL show_import_ui(DWORD dwFlags, HWND hwndParent,
5454 LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc,
5455 HCERTSTORE hDestCertStore)
5456 {
5457 PROPSHEETHEADERW hdr;
5458 PROPSHEETPAGEW pages[4];
5459 struct ImportWizData data;
5460 int nPages = 0;
5461
5462 data.dwFlags = dwFlags;
5463 data.pwszWizardTitle = pwszWizardTitle;
5464 if (pImportSrc)
5465 {
5466 memcpy(&data.importSrc, pImportSrc, sizeof(data.importSrc));
5467 data.fileName = (LPWSTR)pImportSrc->u.pwszFileName;
5468 }
5469 else
5470 {
5471 memset(&data.importSrc, 0, sizeof(data.importSrc));
5472 data.fileName = NULL;
5473 }
5474 data.freeSource = FALSE;
5475 data.hDestCertStore = hDestCertStore;
5476 data.freeDest = FALSE;
5477 data.autoDest = TRUE;
5478 data.success = TRUE;
5479
5480 memset(pages, 0, sizeof(pages));
5481
5482 pages[nPages].dwSize = sizeof(pages[0]);
5483 pages[nPages].hInstance = hInstance;
5484 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_WELCOME);
5485 pages[nPages].pfnDlgProc = import_welcome_dlg_proc;
5486 pages[nPages].dwFlags = PSP_HIDEHEADER;
5487 pages[nPages].lParam = (LPARAM)&data;
5488 nPages++;
5489
5490 if (!pImportSrc ||
5491 pImportSrc->dwSubjectChoice == CRYPTUI_WIZ_IMPORT_SUBJECT_FILE)
5492 {
5493 pages[nPages].dwSize = sizeof(pages[0]);
5494 pages[nPages].hInstance = hInstance;
5495 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FILE);
5496 pages[nPages].pfnDlgProc = import_file_dlg_proc;
5497 pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
5498 pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_FILE_TITLE);
5499 pages[nPages].pszHeaderSubTitle =
5500 MAKEINTRESOURCEW(IDS_IMPORT_FILE_SUBTITLE);
5501 pages[nPages].lParam = (LPARAM)&data;
5502 nPages++;
5503 }
5504 else
5505 {
5506 switch (pImportSrc->dwSubjectChoice)
5507 {
5508 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
5509 data.contentType = CERT_QUERY_CONTENT_CERT;
5510 break;
5511 case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
5512 data.contentType = CERT_QUERY_CONTENT_CRL;
5513 break;
5514 case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
5515 data.contentType = CERT_QUERY_CONTENT_CTL;
5516 break;
5517 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
5518 data.contentType = CERT_QUERY_CONTENT_SERIALIZED_STORE;
5519 break;
5520 }
5521 }
5522
5523 pages[nPages].dwSize = sizeof(pages[0]);
5524 pages[nPages].hInstance = hInstance;
5525 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_STORE);
5526 pages[nPages].pfnDlgProc = import_store_dlg_proc;
5527 pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
5528 pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_STORE_TITLE);
5529 pages[nPages].pszHeaderSubTitle =
5530 MAKEINTRESOURCEW(IDS_IMPORT_STORE_SUBTITLE);
5531 pages[nPages].lParam = (LPARAM)&data;
5532 nPages++;
5533
5534 pages[nPages].dwSize = sizeof(pages[0]);
5535 pages[nPages].hInstance = hInstance;
5536 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FINISH);
5537 pages[nPages].pfnDlgProc = import_finish_dlg_proc;
5538 pages[nPages].dwFlags = PSP_HIDEHEADER;
5539 pages[nPages].lParam = (LPARAM)&data;
5540 nPages++;
5541
5542 memset(&hdr, 0, sizeof(hdr));
5543 hdr.dwSize = sizeof(hdr);
5544 hdr.hwndParent = hwndParent;
5545 hdr.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD97_NEW | PSH_HEADER |
5546 PSH_WATERMARK;
5547 hdr.hInstance = hInstance;
5548 if (pwszWizardTitle)
5549 hdr.pszCaption = pwszWizardTitle;
5550 else
5551 hdr.pszCaption = MAKEINTRESOURCEW(IDS_IMPORT_WIZARD);
5552 hdr.u3.ppsp = pages;
5553 hdr.nPages = nPages;
5554 hdr.u4.pszbmWatermark = MAKEINTRESOURCEW(IDB_CERT_WATERMARK);
5555 hdr.u5.pszbmHeader = MAKEINTRESOURCEW(IDB_CERT_HEADER);
5556 PropertySheetW(&hdr);
5557 if (data.fileName != data.importSrc.u.pwszFileName)
5558 HeapFree(GetProcessHeap(), 0, data.fileName);
5559 if (data.freeSource &&
5560 data.importSrc.dwSubjectChoice == CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE)
5561 CertCloseStore(data.importSrc.u.hCertStore, 0);
5562 DeleteObject(data.titleFont);
5563 return data.success;
5564 }
5565
5566 BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
5567 PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
5568 {
5569 BOOL ret;
5570
5571 TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
5572 pImportSrc, hDestCertStore);
5573
5574 if (pImportSrc &&
5575 pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
5576 {
5577 SetLastError(E_INVALIDARG);
5578 return FALSE;
5579 }
5580
5581 if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
5582 ret = show_import_ui(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
5583 hDestCertStore);
5584 else if (pImportSrc)
5585 ret = do_import(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
5586 hDestCertStore);
5587 else
5588 {
5589 /* Can't have no UI without specifying source */
5590 SetLastError(E_INVALIDARG);
5591 ret = FALSE;
5592 }
5593
5594 return ret;
5595 }
5596
5597 struct ExportWizData
5598 {
5599 HFONT titleFont;
5600 DWORD dwFlags;
5601 LPCWSTR pwszWizardTitle;
5602 CRYPTUI_WIZ_EXPORT_INFO exportInfo;
5603 CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO contextInfo;
5604 BOOL freePassword;
5605 PCRYPT_KEY_PROV_INFO keyProvInfo;
5606 BOOL deleteKeys;
5607 LPWSTR fileName;
5608 HANDLE file;
5609 BOOL success;
5610 };
5611
5612 static LRESULT CALLBACK export_welcome_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
5613 LPARAM lp)
5614 {
5615 LRESULT ret = 0;
5616
5617 switch (msg)
5618 {
5619 case WM_INITDIALOG:
5620 {
5621 struct ExportWizData *data;
5622 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5623 WCHAR fontFace[MAX_STRING_LEN];
5624 HDC hDC = GetDC(hwnd);
5625 int height;
5626
5627 data = (struct ExportWizData *)page->lParam;
5628 LoadStringW(hInstance, IDS_WIZARD_TITLE_FONT, fontFace,
5629 sizeof(fontFace) / sizeof(fontFace[0]));
5630 height = -MulDiv(12, GetDeviceCaps(hDC, LOGPIXELSY), 72);
5631 data->titleFont = CreateFontW(height, 0, 0, 0, FW_BOLD, 0, 0, 0,
5632 DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
5633 DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontFace);
5634 SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_TITLE), WM_SETFONT,
5635 (WPARAM)data->titleFont, TRUE);
5636 ReleaseDC(hwnd, hDC);
5637 break;
5638 }
5639 case WM_NOTIFY:
5640 {
5641 NMHDR *hdr = (NMHDR *)lp;
5642
5643 switch (hdr->code)
5644 {
5645 case PSN_SETACTIVE:
5646 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
5647 ret = TRUE;
5648 break;
5649 }
5650 break;
5651 }
5652 }
5653 return ret;
5654 }
5655
5656 static PCRYPT_KEY_PROV_INFO export_get_private_key_info(PCCERT_CONTEXT cert)
5657 {
5658 PCRYPT_KEY_PROV_INFO info = NULL;
5659 DWORD size;
5660
5661 if (CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID,
5662 NULL, &size))
5663 {
5664 info = HeapAlloc(GetProcessHeap(), 0, size);
5665 if (info)
5666 {
5667 if (!CertGetCertificateContextProperty(cert,
5668 CERT_KEY_PROV_INFO_PROP_ID, info, &size))
5669 {
5670 HeapFree(GetProcessHeap(), 0, info);
5671 info = NULL;
5672 }
5673 }
5674 }
5675 return info;
5676 }
5677
5678 static BOOL export_acquire_private_key(const CRYPT_KEY_PROV_INFO *info,
5679 HCRYPTPROV *phProv)
5680 {
5681 BOOL ret;
5682
5683 ret = CryptAcquireContextW(phProv, info->pwszContainerName,
5684 info->pwszProvName, info->dwProvType, 0);
5685 if (ret)
5686 {
5687 DWORD i;
5688
5689 for (i = 0; i < info->cProvParam; i++)
5690 CryptSetProvParam(*phProv, info->rgProvParam[i].dwParam,
5691 info->rgProvParam[i].pbData, info->rgProvParam[i].dwFlags);
5692 }
5693 return ret;
5694 }
5695
5696 static BOOL export_is_key_exportable(HCRYPTPROV hProv, DWORD keySpec)
5697 {
5698 BOOL ret;
5699 HCRYPTKEY key;
5700
5701 if ((ret = CryptGetUserKey(hProv, keySpec, &key)))
5702 {
5703 DWORD permissions, size = sizeof(permissions);
5704
5705 if ((ret = CryptGetKeyParam(key, KP_PERMISSIONS, (BYTE *)&permissions,
5706 &size, 0)) && !(permissions & CRYPT_EXPORT))
5707 ret = FALSE;
5708 CryptDestroyKey(key);
5709 }
5710 return ret;
5711 }
5712
5713 static LRESULT CALLBACK export_private_key_dlg_proc(HWND hwnd, UINT msg,
5714 WPARAM wp, LPARAM lp)
5715 {
5716 LRESULT ret = 0;
5717 struct ExportWizData *data;
5718
5719 switch (msg)
5720 {
5721 case WM_INITDIALOG:
5722 {
5723 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5724 PCRYPT_KEY_PROV_INFO info;
5725 HCRYPTPROV hProv = 0;
5726 int errorID = 0;
5727
5728 data = (struct ExportWizData *)page->lParam;
5729 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
5730 /* Get enough information about a key to see whether it's exportable.
5731 */
5732 if (!(info = export_get_private_key_info(
5733 data->exportInfo.u.pCertContext)))
5734 errorID = IDS_EXPORT_PRIVATE_KEY_UNAVAILABLE;
5735 else if (!export_acquire_private_key(info, &hProv))
5736 errorID = IDS_EXPORT_PRIVATE_KEY_UNAVAILABLE;
5737 else if (!export_is_key_exportable(hProv, info->dwKeySpec))
5738 errorID = IDS_EXPORT_PRIVATE_KEY_NON_EXPORTABLE;
5739
5740 if (errorID)
5741 {
5742 WCHAR error[MAX_STRING_LEN];
5743
5744 LoadStringW(hInstance, errorID, error,
5745 sizeof(error) / sizeof(error[0]));
5746 SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_PRIVATE_KEY_UNAVAILABLE),
5747 WM_SETTEXT, 0, (LPARAM)error);
5748 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PRIVATE_KEY_YES), FALSE);
5749 }
5750 else
5751 data->keyProvInfo = info;
5752 if (hProv)
5753 CryptReleaseContext(hProv, 0);
5754 SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_PRIVATE_KEY_NO), BM_CLICK,
5755 0, 0);
5756 break;
5757 }
5758 case WM_NOTIFY:
5759 {
5760 NMHDR *hdr = (NMHDR *)lp;
5761
5762 switch (hdr->code)
5763 {
5764 case PSN_SETACTIVE:
5765 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
5766 PSWIZB_BACK | PSWIZB_NEXT);
5767 ret = TRUE;
5768 break;
5769 case PSN_WIZNEXT:
5770 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5771 if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PRIVATE_KEY_NO))
5772 {
5773 data->contextInfo.dwExportFormat =
5774 CRYPTUI_WIZ_EXPORT_FORMAT_DER;
5775 data->contextInfo.fExportPrivateKeys = FALSE;
5776 }
5777 else
5778 {
5779 data->contextInfo.dwExportFormat =
5780 CRYPTUI_WIZ_EXPORT_FORMAT_PFX;
5781 data->contextInfo.fExportPrivateKeys = TRUE;
5782 }
5783 break;
5784 }
5785 break;
5786 }
5787 }
5788 return ret;
5789 }
5790
5791 static BOOL export_info_has_private_key(PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo)
5792 {
5793 BOOL ret = FALSE;
5794
5795 if (pExportInfo->dwSubjectChoice == CRYPTUI_WIZ_EXPORT_CERT_CONTEXT)
5796 {
5797 DWORD size;
5798
5799 /* If there's a CRYPT_KEY_PROV_INFO set for this cert, assume the
5800 * cert has a private key.
5801 */
5802 if (CertGetCertificateContextProperty(pExportInfo->u.pCertContext,
5803 CERT_KEY_PROV_INFO_PROP_ID, NULL, &size))
5804 ret = TRUE;
5805 }
5806 return ret;
5807 }
5808
5809 static void export_format_enable_controls(HWND hwnd, const struct ExportWizData *data)
5810 {
5811 int defaultFormatID;
5812
5813 switch (data->contextInfo.dwExportFormat)
5814 {
5815 case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
5816 defaultFormatID = IDC_EXPORT_FORMAT_BASE64;
5817 break;
5818 case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
5819 defaultFormatID = IDC_EXPORT_FORMAT_CMS;
5820 break;
5821 case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
5822 defaultFormatID = IDC_EXPORT_FORMAT_PFX;
5823 break;
5824 default:
5825 defaultFormatID = IDC_EXPORT_FORMAT_DER;
5826 }
5827 SendMessageW(GetDlgItem(hwnd, defaultFormatID), BM_CLICK, 0, 0);
5828 if (defaultFormatID == IDC_EXPORT_FORMAT_PFX)
5829 {
5830 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_DER), FALSE);
5831 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_BASE64), FALSE);
5832 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_CMS), FALSE);
5833 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_PFX), TRUE);
5834 }
5835 else
5836 {
5837 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_DER), TRUE);
5838 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_BASE64), TRUE);
5839 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_CMS), TRUE);
5840 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_FORMAT_PFX), FALSE);
5841 }
5842 }
5843
5844 static LRESULT CALLBACK export_format_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
5845 LPARAM lp)
5846 {
5847 LRESULT ret = 0;
5848 struct ExportWizData *data;
5849
5850 switch (msg)
5851 {
5852 case WM_INITDIALOG:
5853 {
5854 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5855
5856 data = (struct ExportWizData *)page->lParam;
5857 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
5858 export_format_enable_controls(hwnd, data);
5859 break;
5860 }
5861 case WM_NOTIFY:
5862 {
5863 NMHDR *hdr = (NMHDR *)lp;
5864
5865 switch (hdr->code)
5866 {
5867 case PSN_SETACTIVE:
5868 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
5869 PSWIZB_BACK | PSWIZB_NEXT);
5870 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5871 export_format_enable_controls(hwnd, data);
5872 ret = TRUE;
5873 break;
5874 case PSN_WIZNEXT:
5875 {
5876 BOOL skipPasswordPage = TRUE;
5877
5878 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
5879 if (IsDlgButtonChecked(hwnd, IDC_EXPORT_FORMAT_DER))
5880 data->contextInfo.dwExportFormat =
5881 CRYPTUI_WIZ_EXPORT_FORMAT_DER;
5882 else if (IsDlgButtonChecked(hwnd, IDC_EXPORT_FORMAT_BASE64))
5883 data->contextInfo.dwExportFormat =
5884 CRYPTUI_WIZ_EXPORT_FORMAT_BASE64;
5885 else if (IsDlgButtonChecked(hwnd, IDC_EXPORT_FORMAT_CMS))
5886 {
5887 data->contextInfo.dwExportFormat =
5888 CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
5889 if (IsDlgButtonChecked(hwnd, IDC_EXPORT_CMS_INCLUDE_CHAIN))
5890 data->contextInfo.fExportChain =
5891 CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
5892 }
5893 else
5894 {
5895 data->contextInfo.dwExportFormat =
5896 CRYPTUI_WIZ_EXPORT_FORMAT_PFX;
5897 if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PFX_INCLUDE_CHAIN))
5898 data->contextInfo.fExportChain = TRUE;
5899 if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PFX_STRONG_ENCRYPTION))
5900 data->contextInfo.fStrongEncryption = TRUE;
5901 if (IsDlgButtonChecked(hwnd, IDC_EXPORT_PFX_DELETE_PRIVATE_KEY))
5902 data->deleteKeys = TRUE;
5903 skipPasswordPage = FALSE;
5904 }
5905 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT,
5906 skipPasswordPage ? IDD_EXPORT_FILE : 0);
5907 ret = 1;
5908 break;
5909 }
5910 }
5911 break;
5912 }
5913 case WM_COMMAND:
5914 switch (HIWORD(wp))
5915 {
5916 case BN_CLICKED:
5917 switch (LOWORD(wp))
5918 {
5919 case IDC_EXPORT_FORMAT_DER:
5920 case IDC_EXPORT_FORMAT_BASE64:
5921 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_CMS_INCLUDE_CHAIN),
5922 FALSE);
5923 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_INCLUDE_CHAIN),
5924 FALSE);
5925 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_STRONG_ENCRYPTION),
5926 FALSE);
5927 EnableWindow(GetDlgItem(hwnd,
5928 IDC_EXPORT_PFX_DELETE_PRIVATE_KEY), FALSE);
5929 break;
5930 case IDC_EXPORT_FORMAT_CMS:
5931 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_CMS_INCLUDE_CHAIN),
5932 TRUE);
5933 break;
5934 case IDC_EXPORT_FORMAT_PFX:
5935 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_INCLUDE_CHAIN),
5936 TRUE);
5937 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT_PFX_STRONG_ENCRYPTION),
5938 TRUE);
5939 EnableWindow(GetDlgItem(hwnd,
5940 IDC_EXPORT_PFX_DELETE_PRIVATE_KEY), TRUE);
5941 break;
5942 }
5943 break;
5944 }
5945 break;
5946 }
5947 return ret;
5948 }
5949
5950 static void export_password_mismatch(HWND hwnd, const struct ExportWizData *data)
5951 {
5952 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
5953 LPCWSTR pTitle;
5954
5955 if (data->pwszWizardTitle)
5956 pTitle = data->pwszWizardTitle;
5957 else
5958 {
5959 LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
5960 sizeof(title) / sizeof(title[0]));
5961 pTitle = title;
5962 }
5963 LoadStringW(hInstance, IDS_EXPORT_PASSWORD_MISMATCH, error,
5964 sizeof(error) / sizeof(error[0]));
5965 MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
5966 SetFocus(GetDlgItem(hwnd, IDC_EXPORT_PASSWORD));
5967 }
5968
5969 static LRESULT CALLBACK export_password_dlg_proc(HWND hwnd, UINT msg,
5970 WPARAM wp, LPARAM lp)
5971 {
5972 LRESULT ret = 0;
5973 struct ExportWizData *data;
5974
5975 switch (msg)
5976 {
5977 case WM_INITDIALOG:
5978 {
5979 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
5980
5981 data = (struct ExportWizData *)page->lParam;
5982 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
5983 break;
5984 }
5985 case WM_NOTIFY:
5986 {
5987 NMHDR *hdr = (NMHDR *)lp;
5988
5989 switch (hdr->code)
5990 {
5991 case PSN_SETACTIVE:
5992 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
5993 PSWIZB_BACK | PSWIZB_NEXT);
5994 ret = TRUE;
5995 break;
5996 case PSN_WIZNEXT:
5997 {
5998 HWND passwordEdit = GetDlgItem(hwnd, IDC_EXPORT_PASSWORD);
5999 HWND passwordConfirmEdit = GetDlgItem(hwnd,
6000 IDC_EXPORT_PASSWORD_CONFIRM);
6001 DWORD passwordLen = SendMessageW(passwordEdit, WM_GETTEXTLENGTH,
6002 0, 0);
6003 DWORD passwordConfirmLen = SendMessageW(passwordConfirmEdit,
6004 WM_GETTEXTLENGTH, 0, 0);
6005
6006 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
6007 if (!passwordLen && !passwordConfirmLen)
6008 data->contextInfo.pwszPassword = NULL;
6009 else if (passwordLen != passwordConfirmLen)
6010 {
6011 export_password_mismatch(hwnd, data);
6012 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
6013 ret = 1;
6014 }
6015 else
6016 {
6017 LPWSTR password = HeapAlloc(GetProcessHeap(), 0,
6018 (passwordLen + 1) * sizeof(WCHAR));
6019 LPWSTR passwordConfirm = HeapAlloc(GetProcessHeap(), 0,
6020 (passwordConfirmLen + 1) * sizeof(WCHAR));
6021 BOOL freePassword = TRUE;
6022
6023 if (password && passwordConfirm)
6024 {
6025 SendMessageW(passwordEdit, WM_GETTEXT, passwordLen + 1,
6026 (LPARAM)password);
6027 SendMessageW(passwordConfirmEdit, WM_GETTEXT,
6028 passwordConfirmLen + 1, (LPARAM)passwordConfirm);
6029 if (strcmpW(password, passwordConfirm))
6030 {
6031 export_password_mismatch(hwnd, data);
6032 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
6033 ret = 1;
6034 }
6035 else
6036 {
6037 data->contextInfo.pwszPassword = password;
6038 freePassword = FALSE;
6039 data->freePassword = TRUE;
6040 }
6041 }
6042 if (freePassword)
6043 HeapFree(GetProcessHeap(), 0, password);
6044 HeapFree(GetProcessHeap(), 0, passwordConfirm);
6045 }
6046 break;
6047 }
6048 }
6049 break;
6050 }
6051 }
6052 return ret;
6053 }
6054
6055 static LPWSTR export_append_extension(const struct ExportWizData *data,
6056 LPWSTR fileName)
6057 {
6058 static const WCHAR cer[] = { '.','c','e','r',0 };
6059 static const WCHAR crl[] = { '.','c','r','l',0 };
6060 static const WCHAR ctl[] = { '.','c','t','l',0 };
6061 static const WCHAR p7b[] = { '.','p','7','b',0 };
6062 static const WCHAR pfx[] = { '.','p','f','x',0 };
6063 static const WCHAR sst[] = { '.','s','s','t',0 };
6064 LPCWSTR extension;
6065 LPWSTR dot;
6066 BOOL appendExtension;
6067
6068 switch (data->contextInfo.dwExportFormat)
6069 {
6070 case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
6071 extension = p7b;
6072 break;
6073 case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
6074 extension = pfx;
6075 break;
6076 default:
6077 switch (data->exportInfo.dwSubjectChoice)
6078 {
6079 case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
6080 extension = crl;
6081 break;
6082 case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
6083 extension = ctl;
6084 break;
6085 case CRYPTUI_WIZ_EXPORT_CERT_STORE:
6086 extension = sst;
6087 break;
6088 default:
6089 extension = cer;
6090 }
6091 }
6092 dot = strrchrW(fileName, '.');
6093 if (dot)
6094 appendExtension = strcmpiW(dot, extension) != 0;
6095 else
6096 appendExtension = TRUE;
6097 if (appendExtension)
6098 {
6099 fileName = HeapReAlloc(GetProcessHeap(), 0, fileName,
6100 (strlenW(fileName) + strlenW(extension) + 1) * sizeof(WCHAR));
6101 if (fileName)
6102 strcatW(fileName, extension);
6103 }
6104 return fileName;
6105 }
6106
6107 static BOOL export_validate_filename(HWND hwnd, struct ExportWizData *data,
6108 LPCWSTR fileName)
6109 {
6110 HANDLE file;
6111 BOOL tryCreate = TRUE, forceCreate = FALSE, ret = FALSE;
6112
6113 file = CreateFileW(fileName, GENERIC_WRITE,
6114 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
6115 if (file != INVALID_HANDLE_VALUE)
6116 {
6117 WCHAR warning[MAX_STRING_LEN], title[MAX_STRING_LEN];
6118 LPCWSTR pTitle;
6119
6120 if (data->pwszWizardTitle)
6121 pTitle = data->pwszWizardTitle;
6122 else
6123 {
6124 LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
6125 sizeof(title) / sizeof(title[0]));
6126 pTitle = title;
6127 }
6128 LoadStringW(hInstance, IDS_EXPORT_FILE_EXISTS, warning,
6129 sizeof(warning) / sizeof(warning[0]));
6130 if (MessageBoxW(hwnd, warning, pTitle, MB_YESNO) == IDYES)
6131 forceCreate = TRUE;
6132 else
6133 tryCreate = FALSE;
6134 CloseHandle(file);
6135 }
6136 if (tryCreate)
6137 {
6138 file = CreateFileW(fileName, GENERIC_WRITE,
6139 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
6140 forceCreate ? CREATE_ALWAYS : CREATE_NEW,
6141 0, NULL);
6142 if (file != INVALID_HANDLE_VALUE)
6143 {
6144 data->file = file;
6145 ret = TRUE;
6146 }
6147 else
6148 {
6149 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
6150 LPCWSTR pTitle;
6151 LPWSTR msgBuf, fullError;
6152
6153 if (data->pwszWizardTitle)
6154 pTitle = data->pwszWizardTitle;
6155 else
6156 {
6157 LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
6158 sizeof(title) / sizeof(title[0]));
6159 pTitle = title;
6160 }
6161 LoadStringW(hInstance, IDS_IMPORT_OPEN_FAILED, error,
6162 sizeof(error) / sizeof(error[0]));
6163 FormatMessageW(
6164 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
6165 GetLastError(), 0, (LPWSTR) &msgBuf, 0, NULL);
6166 fullError = HeapAlloc(GetProcessHeap(), 0,
6167 (strlenW(error) + strlenW(fileName) + strlenW(msgBuf) + 3)
6168 * sizeof(WCHAR));
6169 if (fullError)
6170 {
6171 LPWSTR ptr = fullError;
6172
6173 strcpyW(ptr, error);
6174 ptr += strlenW(error);
6175 strcpyW(ptr, fileName);
6176 ptr += strlenW(fileName);
6177 *ptr++ = ':';
6178 *ptr++ = '\n';
6179 strcpyW(ptr, msgBuf);
6180 MessageBoxW(hwnd, fullError, pTitle, MB_ICONERROR | MB_OK);
6181 HeapFree(GetProcessHeap(), 0, fullError);
6182 }
6183 LocalFree(msgBuf);
6184 }
6185 }
6186 return ret;
6187 }
6188
6189 static const WCHAR export_filter_cert[] = { '*','.','c','e','r',0 };
6190 static const WCHAR export_filter_crl[] = { '*','.','c','r','l',0 };
6191 static const WCHAR export_filter_ctl[] = { '*','.','s','t','l',0 };
6192 static const WCHAR export_filter_cms[] = { '*','.','p','7','b',0 };
6193 static const WCHAR export_filter_pfx[] = { '*','.','p','f','x',0 };
6194 static const WCHAR export_filter_sst[] = { '*','.','s','s','t',0 };
6195
6196 static WCHAR *make_export_file_filter(DWORD exportFormat, DWORD subjectChoice)
6197 {
6198 int baseLen, allLen, totalLen = 2, baseID;
6199 LPWSTR filter = NULL, baseFilter, all;
6200 LPCWSTR filterStr;
6201
6202 switch (exportFormat)
6203 {
6204 case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
6205 baseID = IDS_EXPORT_FILTER_BASE64_CERT;
6206 filterStr = export_filter_cert;
6207 break;
6208 case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
6209 baseID = IDS_EXPORT_FILTER_PFX;
6210 filterStr = export_filter_pfx;
6211 break;
6212 case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
6213 baseID = IDS_EXPORT_FILTER_CMS;
6214 filterStr = export_filter_cms;
6215 break;
6216 default:
6217 switch (subjectChoice)
6218 {
6219 case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
6220 baseID = IDS_EXPORT_FILTER_CRL;
6221 filterStr = export_filter_crl;
6222 break;
6223 case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
6224 baseID = IDS_EXPORT_FILTER_CTL;
6225 filterStr = export_filter_ctl;
6226 break;
6227 case CRYPTUI_WIZ_EXPORT_CERT_STORE:
6228 baseID = IDS_EXPORT_FILTER_SERIALIZED_CERT_STORE;
6229 filterStr = export_filter_sst;
6230 break;
6231 default:
6232 baseID = IDS_EXPORT_FILTER_CERT;
6233 filterStr = export_filter_cert;
6234 break;
6235 }
6236 }
6237 baseLen = LoadStringW(hInstance, baseID, (LPWSTR)&baseFilter, 0);
6238 totalLen += baseLen + strlenW(filterStr) + 2;
6239 allLen = LoadStringW(hInstance, IDS_IMPORT_FILTER_ALL, (LPWSTR)&all, 0);
6240 totalLen += allLen + strlenW(filter_all) + 2;
6241 filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
6242 if (filter)
6243 {
6244 LPWSTR ptr;
6245
6246 ptr = filter;
6247 memcpy(ptr, baseFilter, baseLen * sizeof(WCHAR));
6248 ptr += baseLen;
6249 *ptr++ = 0;
6250 strcpyW(ptr, filterStr);
6251 ptr += strlenW(filterStr) + 1;
6252 memcpy(ptr, all, allLen * sizeof(WCHAR));
6253 ptr += allLen;
6254 *ptr++ = 0;
6255 strcpyW(ptr, filter_all);
6256 ptr += strlenW(filter_all) + 1;
6257 *ptr++ = 0;
6258 }
6259 return filter;
6260 }
6261
6262 static LRESULT CALLBACK export_file_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
6263 LPARAM lp)
6264 {
6265 LRESULT ret = 0;
6266 struct ExportWizData *data;
6267
6268 switch (msg)
6269 {
6270 case WM_INITDIALOG:
6271 {
6272 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
6273
6274 data = (struct ExportWizData *)page->lParam;
6275 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
6276 if (data->exportInfo.pwszExportFileName)
6277 SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_FILENAME), WM_SETTEXT, 0,
6278 (LPARAM)data->exportInfo.pwszExportFileName);
6279 break;
6280 }
6281 case WM_NOTIFY:
6282 {
6283 NMHDR *hdr = (NMHDR *)lp;
6284
6285 switch (hdr->code)
6286 {
6287 case PSN_WIZBACK:
6288 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
6289 if (data->contextInfo.dwExportFormat !=
6290 CRYPTUI_WIZ_EXPORT_FORMAT_PFX)
6291 {
6292 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, IDD_EXPORT_FORMAT);
6293 ret = 1;
6294 }
6295 break;
6296 case PSN_WIZNEXT:
6297 {
6298 HWND fileNameEdit = GetDlgItem(hwnd, IDC_EXPORT_FILENAME);
6299 DWORD len = SendMessageW(fileNameEdit, WM_GETTEXTLENGTH, 0, 0);
6300
6301 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
6302 if (!len)
6303 {
6304 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
6305 LPCWSTR pTitle;
6306
6307 if (data->pwszWizardTitle)
6308 pTitle = data->pwszWizardTitle;
6309 else
6310 {
6311 LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
6312 sizeof(title) / sizeof(title[0]));
6313 pTitle = title;
6314 }
6315 LoadStringW(hInstance, IDS_IMPORT_EMPTY_FILE, error,
6316 sizeof(error) / sizeof(error[0]));
6317 MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
6318 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
6319 ret = 1;
6320 }
6321 else
6322 {
6323 LPWSTR fileName = HeapAlloc(GetProcessHeap(), 0,
6324 (len + 1) * sizeof(WCHAR));
6325
6326 if (fileName)
6327 {
6328 SendMessageW(fileNameEdit, WM_GETTEXT, len + 1,
6329 (LPARAM)fileName);
6330 fileName = export_append_extension(data, fileName);
6331 if (!export_validate_filename(hwnd, data, fileName))
6332 {
6333 HeapFree(GetProcessHeap(), 0, fileName);
6334 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
6335 ret = 1;
6336 }
6337 else
6338 data->fileName = fileName;
6339 }
6340 }
6341 break;
6342 }
6343 case PSN_SETACTIVE:
6344 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
6345 PSWIZB_BACK | PSWIZB_NEXT);
6346 ret = TRUE;
6347 break;
6348 }
6349 break;
6350 }
6351 case WM_COMMAND:
6352 switch (wp)
6353 {
6354 case IDC_EXPORT_BROWSE_FILE:
6355 {
6356 OPENFILENAMEW ofn;
6357 WCHAR fileBuf[MAX_PATH];
6358
6359 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
6360 memset(&ofn, 0, sizeof(ofn));
6361 ofn.lStructSize = sizeof(ofn);
6362 ofn.hwndOwner = hwnd;
6363 ofn.lpstrFilter = make_export_file_filter(
6364 data->contextInfo.dwExportFormat,
6365 data->exportInfo.dwSubjectChoice);
6366 ofn.lpstrFile = fileBuf;
6367 ofn.nMaxFile = sizeof(fileBuf) / sizeof(fileBuf[0]);
6368 fileBuf[0] = 0;
6369 if (GetSaveFileNameW(&ofn))
6370 SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_FILENAME), WM_SETTEXT,
6371 0, (LPARAM)ofn.lpstrFile);
6372 HeapFree(GetProcessHeap(), 0, (LPWSTR)ofn.lpstrFilter);
6373 break;
6374 }
6375 }
6376 break;
6377 }
6378 return ret;
6379 }
6380
6381 static void show_export_details(HWND lv, const struct ExportWizData *data)
6382 {
6383 WCHAR text[MAX_STRING_LEN];
6384 LVITEMW item;
6385 int contentID;
6386
6387 item.mask = LVIF_TEXT;
6388 if (data->fileName)
6389 {
6390 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
6391 item.iSubItem = 0;
6392 LoadStringW(hInstance, IDS_IMPORT_FILE, text,
6393 sizeof(text)/ sizeof(text[0]));
6394 item.pszText = text;
6395 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
6396 item.iSubItem = 1;
6397 item.pszText = data->fileName;
6398 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
6399 }
6400
6401 item.pszText = text;
6402 switch (data->exportInfo.dwSubjectChoice)
6403 {
6404 case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
6405 case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
6406 case CRYPTUI_WIZ_EXPORT_CERT_STORE:
6407 case CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY:
6408 /* do nothing */
6409 break;
6410 default:
6411 {
6412 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
6413 item.iSubItem = 0;
6414 LoadStringW(hInstance, IDS_EXPORT_INCLUDE_CHAIN, text,
6415 sizeof(text) / sizeof(text[0]));
6416 SendMessageW(lv, LVM_INSERTITEMW, item.iItem, (LPARAM)&item);
6417 item.iSubItem = 1;
6418 LoadStringW(hInstance,
6419 data->contextInfo.fExportChain ? IDS_YES : IDS_NO, text,
6420 sizeof(text) / sizeof(text[0]));
6421 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
6422
6423 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
6424 item.iSubItem = 0;
6425 LoadStringW(hInstance, IDS_EXPORT_KEYS, text,
6426 sizeof(text) / sizeof(text[0]));
6427 SendMessageW(lv, LVM_INSERTITEMW, item.iItem, (LPARAM)&item);
6428 item.iSubItem = 1;
6429 LoadStringW(hInstance,
6430 data->contextInfo.fExportPrivateKeys ? IDS_YES : IDS_NO, text,
6431 sizeof(text) / sizeof(text[0]));
6432 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
6433 }
6434 }
6435
6436 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
6437 item.iSubItem = 0;
6438 LoadStringW(hInstance, IDS_EXPORT_FORMAT, text,
6439 sizeof(text)/ sizeof(text[0]));
6440 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
6441
6442 item.iSubItem = 1;
6443 switch (data->exportInfo.dwSubjectChoice)
6444 {
6445 case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
6446 contentID = IDS_EXPORT_FILTER_CRL;
6447 break;
6448 case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
6449 contentID = IDS_EXPORT_FILTER_CTL;
6450 break;
6451 case CRYPTUI_WIZ_EXPORT_CERT_STORE:
6452 contentID = IDS_EXPORT_FILTER_SERIALIZED_CERT_STORE;
6453 break;
6454 default:
6455 switch (data->contextInfo.dwExportFormat)
6456 {
6457 case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
6458 contentID = IDS_EXPORT_FILTER_BASE64_CERT;
6459 break;
6460 case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
6461 contentID = IDS_EXPORT_FILTER_CMS;
6462 break;
6463 case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
6464 contentID = IDS_EXPORT_FILTER_PFX;
6465 break;
6466 default:
6467 contentID = IDS_EXPORT_FILTER_CERT;
6468 }
6469 }
6470 LoadStringW(hInstance, contentID, text, sizeof(text) / sizeof(text[0]));
6471 SendMessageW(lv, LVM_SETITEMTEXTW, item.iItem, (LPARAM)&item);
6472 }
6473
6474 static inline BOOL save_der(HANDLE file, const BYTE *pb, DWORD cb)
6475 {
6476 DWORD bytesWritten;
6477
6478 return WriteFile(file, pb, cb, &bytesWritten, NULL);
6479 }
6480
6481 static BOOL save_base64(HANDLE file, const BYTE *pb, DWORD cb)
6482 {
6483 BOOL ret;
6484 DWORD size = 0;
6485
6486 if ((ret = CryptBinaryToStringA(pb, cb, CRYPT_STRING_BASE64, NULL, &size)))
6487 {
6488 LPSTR buf = HeapAlloc(GetProcessHeap(), 0, size);
6489
6490 if (buf)
6491 {
6492 if ((ret = CryptBinaryToStringA(pb, cb, CRYPT_STRING_BASE64, buf,
6493 &size)))
6494 ret = WriteFile(file, buf, size, &size, NULL);
6495 HeapFree(GetProcessHeap(), 0, buf);
6496 }
6497 else
6498 {
6499 SetLastError(ERROR_OUTOFMEMORY);
6500 ret = FALSE;
6501 }
6502 }
6503 return ret;
6504 }
6505
6506 static inline BOOL save_store_as_cms(HANDLE file, HCERTSTORE store)
6507 {
6508 return CertSaveStore(store, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
6509 CERT_STORE_SAVE_AS_PKCS7, CERT_STORE_SAVE_TO_FILE, file, 0);
6510 }
6511
6512 static BOOL save_cert_as_cms(HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo,
6513 BOOL includeChain)
6514 {
6515 BOOL ret;
6516 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
6517 CERT_STORE_CREATE_NEW_FLAG, NULL);
6518
6519 if (store)
6520 {
6521 if (includeChain)
6522 {
6523 HCERTSTORE addlStore = CertOpenStore(CERT_STORE_PROV_COLLECTION,
6524 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL);
6525
6526 if (addlStore)
6527 {
6528 DWORD i;
6529
6530 ret = TRUE;
6531 for (i = 0; ret && i < pExportInfo->cStores; i++)
6532 ret = CertAddStoreToCollection(addlStore,
6533 pExportInfo->rghStores, 0, 0);
6534 if (ret)
6535 {
6536 PCCERT_CHAIN_CONTEXT chain;
6537
6538 ret = CertGetCertificateChain(NULL,
6539 pExportInfo->u.pCertContext, NULL, addlStore, NULL, 0,
6540 NULL, &chain);
6541 if (ret)
6542 {
6543 DWORD j;
6544
6545 for (i = 0; ret && i < chain->cChain; i++)
6546 for (j = 0; ret && j < chain->rgpChain[i]->cElement;
6547 j++)
6548 ret = CertAddCertificateContextToStore(store,
6549 chain->rgpChain[i]->rgpElement[j]->pCertContext,
6550 CERT_STORE_ADD_ALWAYS, NULL);
6551 CertFreeCertificateChain(chain);
6552 }
6553 else
6554 {
6555 /* No chain could be created, just add the individual
6556 * cert to the message.
6557 */
6558 ret = CertAddCertificateContextToStore(store,
6559 pExportInfo->u.pCertContext, CERT_STORE_ADD_ALWAYS,
6560 NULL);
6561 }
6562 }
6563 CertCloseStore(addlStore, 0);
6564 }
6565 else
6566 ret = FALSE;
6567 }
6568 else
6569 ret = CertAddCertificateContextToStore(store,
6570 pExportInfo->u.pCertContext, CERT_STORE_ADD_ALWAYS, NULL);
6571 if (ret)
6572 ret = save_store_as_cms(file, store);
6573 CertCloseStore(store, 0);
6574 }
6575 else
6576 ret = FALSE;
6577 return ret;
6578 }
6579
6580 static BOOL save_serialized_store(HANDLE file, HCERTSTORE store)
6581 {
6582 return CertSaveStore(store, PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
6583 CERT_STORE_SAVE_AS_STORE, CERT_STORE_SAVE_TO_FILE, file, 0);
6584 }
6585
6586 static BOOL save_pfx(HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo,
6587 PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO pContextInfo,
6588 PCRYPT_KEY_PROV_INFO keyProvInfo, BOOL deleteKeys)
6589 {
6590 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, X509_ASN_ENCODING,
6591 0, CERT_STORE_CREATE_NEW_FLAG, NULL);
6592 BOOL ret = FALSE;
6593
6594 if (store)
6595 {
6596 CRYPT_DATA_BLOB pfxBlob = { 0, NULL };
6597 PCCERT_CONTEXT cert = NULL;
6598 BOOL freeKeyProvInfo = FALSE;
6599
6600 if (pContextInfo->fExportChain)
6601 {
6602 HCERTCHAINENGINE engine = NULL;
6603
6604 if (pExportInfo->cStores)
6605 {
6606 CERT_CHAIN_ENGINE_CONFIG config;
6607
6608 memset(&config, 0, sizeof(config));
6609 config.cbSize = sizeof(config);
6610 config.cAdditionalStore = pExportInfo->cStores;
6611 config.rghAdditionalStore = pExportInfo->rghStores;
6612 ret = CertCreateCertificateChainEngine(&config, &engine);
6613 }
6614 else
6615 ret = TRUE;
6616 if (ret)
6617 {
6618 CERT_CHAIN_PARA chainPara;
6619 PCCERT_CHAIN_CONTEXT chain;
6620
6621 memset(&chainPara, 0, sizeof(chainPara));
6622 chainPara.cbSize = sizeof(chainPara);
6623 ret = CertGetCertificateChain(engine,
6624 pExportInfo->u.pCertContext, NULL, NULL, &chainPara, 0, NULL,
6625 &chain);
6626 if (ret)
6627 {
6628 DWORD i, j;
6629
6630 for (i = 0; ret && i < chain->cChain; i++)
6631 for (j = 0; ret && j < chain->rgpChain[i]->cElement;
6632 j++)
6633 {
6634 if (i == 0 && j == 0)
6635 ret = CertAddCertificateContextToStore(store,
6636 chain->rgpChain[i]->rgpElement[j]->pCertContext,
6637 CERT_STORE_ADD_ALWAYS, &cert);
6638 else
6639 ret = CertAddCertificateContextToStore(store,
6640 chain->rgpChain[i]->rgpElement[j]->pCertContext,
6641 CERT_STORE_ADD_ALWAYS, NULL);
6642 }
6643 CertFreeCertificateChain(chain);
6644 }
6645 }
6646 if (engine)
6647 CertFreeCertificateChainEngine(engine);
6648 }
6649 else
6650 ret = CertAddCertificateContextToStore(store,
6651 pExportInfo->u.pCertContext, CERT_STORE_ADD_ALWAYS, &cert);
6652 /* Copy private key info to newly created cert, so it'll get exported
6653 * along with the cert.
6654 */
6655 if (ret && pContextInfo->fExportPrivateKeys)
6656 {
6657 if (keyProvInfo)
6658 ret = CertSetCertificateContextProperty(cert,
6659 CERT_KEY_PROV_INFO_PROP_ID, 0, keyProvInfo);
6660 else
6661 {
6662 if (!(keyProvInfo = export_get_private_key_info(cert)))
6663 ret = FALSE;
6664 else
6665 {
6666 ret = CertSetCertificateContextProperty(cert,
6667 CERT_KEY_PROV_INFO_PROP_ID, 0, keyProvInfo);
6668 freeKeyProvInfo = TRUE;
6669 }
6670 }
6671 }
6672 if (ret)
6673 {
6674 DWORD exportFlags =
6675 REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY | EXPORT_PRIVATE_KEYS;
6676
6677 ret = PFXExportCertStore(store, &pfxBlob,
6678 pContextInfo->pwszPassword, exportFlags);
6679 if (ret)
6680 {
6681 pfxBlob.pbData = HeapAlloc(GetProcessHeap(), 0, pfxBlob.cbData);
6682 if (pfxBlob.pbData)
6683 {
6684 ret = PFXExportCertStore(store, &pfxBlob,
6685 pContextInfo->pwszPassword, exportFlags);
6686 if (ret)
6687 {
6688 DWORD bytesWritten;
6689
6690 ret = WriteFile(file, pfxBlob.pbData, pfxBlob.cbData,
6691 &bytesWritten, NULL);
6692 }
6693 }
6694 else
6695 {
6696 SetLastError(ERROR_OUTOFMEMORY);
6697 ret = FALSE;
6698 }
6699 }
6700 }
6701 if (ret && deleteKeys)
6702 {
6703 HCRYPTPROV prov;
6704
6705 CryptAcquireContextW(&prov, keyProvInfo->pwszContainerName,
6706 keyProvInfo->pwszProvName, keyProvInfo->dwProvType,
6707 CRYPT_DELETEKEYSET);
6708 }
6709 if (freeKeyProvInfo)
6710 HeapFree(GetProcessHeap(), 0, keyProvInfo);
6711 CertFreeCertificateContext(cert);
6712 CertCloseStore(store, 0);
6713 }
6714 return ret;
6715 }
6716
6717 static BOOL do_export(HANDLE file, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo,
6718 PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO pContextInfo,
6719 PCRYPT_KEY_PROV_INFO keyProvInfo, BOOL deleteKeys)
6720 {
6721 BOOL ret;
6722
6723 if (pContextInfo->dwSize != sizeof(CRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO))
6724 {
6725 SetLastError(E_INVALIDARG);
6726 return FALSE;
6727 }
6728 switch (pExportInfo->dwSubjectChoice)
6729 {
6730 case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
6731 ret = save_der(file,
6732 pExportInfo->u.pCRLContext->pbCrlEncoded,
6733 pExportInfo->u.pCRLContext->cbCrlEncoded);
6734 break;
6735 case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
6736 ret = save_der(file,
6737 pExportInfo->u.pCTLContext->pbCtlEncoded,
6738 pExportInfo->u.pCTLContext->cbCtlEncoded);
6739 break;
6740 case CRYPTUI_WIZ_EXPORT_CERT_STORE:
6741 ret = save_serialized_store(file, pExportInfo->u.hCertStore);
6742 break;
6743 case CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY:
6744 ret = save_store_as_cms(file, pExportInfo->u.hCertStore);
6745 break;
6746 default:
6747 switch (pContextInfo->dwExportFormat)
6748 {
6749 case CRYPTUI_WIZ_EXPORT_FORMAT_DER:
6750 ret = save_der(file, pExportInfo->u.pCertContext->pbCertEncoded,
6751 pExportInfo->u.pCertContext->cbCertEncoded);
6752 break;
6753 case CRYPTUI_WIZ_EXPORT_FORMAT_BASE64:
6754 ret = save_base64(file,
6755 pExportInfo->u.pCertContext->pbCertEncoded,
6756 pExportInfo->u.pCertContext->cbCertEncoded);
6757 break;
6758 case CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7:
6759 ret = save_cert_as_cms(file, pExportInfo,
6760 pContextInfo->fExportChain);
6761 break;
6762 case CRYPTUI_WIZ_EXPORT_FORMAT_PFX:
6763 ret = save_pfx(file, pExportInfo, pContextInfo, keyProvInfo,
6764 deleteKeys);
6765 break;
6766 default:
6767 SetLastError(E_FAIL);
6768 ret = FALSE;
6769 }
6770 }
6771 return ret;
6772 }
6773
6774 static LRESULT CALLBACK export_finish_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
6775 LPARAM lp)
6776 {
6777 LRESULT ret = 0;
6778 struct ExportWizData *data;
6779
6780 switch (msg)
6781 {
6782 case WM_INITDIALOG:
6783 {
6784 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
6785 HWND lv = GetDlgItem(hwnd, IDC_EXPORT_SETTINGS);
6786 RECT rc;
6787 LVCOLUMNW column;
6788
6789 data = (struct ExportWizData *)page->lParam;
6790 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
6791 SendMessageW(GetDlgItem(hwnd, IDC_EXPORT_TITLE), WM_SETFONT,
6792 (WPARAM)data->titleFont, TRUE);
6793 GetWindowRect(lv, &rc);
6794 column.mask = LVCF_WIDTH;
6795 column.cx = (rc.right - rc.left) / 2 - 2;
6796 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
6797 SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
6798 show_export_details(lv, data);
6799 break;
6800 }
6801 case WM_NOTIFY:
6802 {
6803 NMHDR *hdr = (NMHDR *)lp;
6804
6805 switch (hdr->code)
6806 {
6807 case PSN_SETACTIVE:
6808 {
6809 HWND lv = GetDlgItem(hwnd, IDC_EXPORT_SETTINGS);
6810
6811 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
6812 SendMessageW(lv, LVM_DELETEALLITEMS, 0, 0);
6813 show_export_details(lv, data);
6814 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
6815 PSWIZB_BACK | PSWIZB_FINISH);
6816 ret = TRUE;
6817 break;
6818 }
6819 case PSN_WIZFINISH:
6820 {
6821 int messageID;
6822 WCHAR title[MAX_STRING_LEN], message[MAX_STRING_LEN];
6823 LPCWSTR pTitle;
6824 DWORD mbFlags;
6825
6826 data = (struct ExportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
6827 if ((data->success = do_export(data->file, &data->exportInfo,
6828 &data->contextInfo, data->keyProvInfo, data->deleteKeys)))
6829 {
6830 messageID = IDS_EXPORT_SUCCEEDED;
6831 mbFlags = MB_OK;
6832 }
6833 else
6834 {
6835 messageID = IDS_EXPORT_FAILED;
6836 mbFlags = MB_OK | MB_ICONERROR;
6837 }
6838 if (data->pwszWizardTitle)
6839 pTitle = data->pwszWizardTitle;
6840 else
6841 {
6842 LoadStringW(hInstance, IDS_EXPORT_WIZARD, title,
6843 sizeof(title) / sizeof(title[0]));
6844 pTitle = title;
6845 }
6846 LoadStringW(hInstance, messageID, message,
6847 sizeof(message) / sizeof(message[0]));
6848 MessageBoxW(hwnd, message, pTitle, mbFlags);
6849 break;
6850 }
6851 }
6852 break;
6853 }
6854 }
6855 return ret;
6856 }
6857
6858 static BOOL show_export_ui(DWORD dwFlags, HWND hwndParent,
6859 LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, const void *pvoid)
6860 {
6861 PROPSHEETHEADERW hdr;
6862 PROPSHEETPAGEW pages[6];
6863 struct ExportWizData data;
6864 int nPages = 0;
6865 BOOL hasPrivateKey, showFormatPage = TRUE;
6866 INT_PTR l;
6867
6868 data.dwFlags = dwFlags;
6869 data.pwszWizardTitle = pwszWizardTitle;
6870 memset(&data.exportInfo, 0, sizeof(data.exportInfo));
6871 memcpy(&data.exportInfo, pExportInfo,
6872 min(sizeof(data.exportInfo), pExportInfo->dwSize));
6873 if (pExportInfo->dwSize > sizeof(data.exportInfo))
6874 data.exportInfo.dwSize = sizeof(data.exportInfo);
6875 data.contextInfo.dwSize = sizeof(data.contextInfo);
6876 data.contextInfo.dwExportFormat = CRYPTUI_WIZ_EXPORT_FORMAT_DER;
6877 data.contextInfo.fExportChain = FALSE;
6878 data.contextInfo.fStrongEncryption = FALSE;
6879 data.contextInfo.fExportPrivateKeys = FALSE;
6880 data.contextInfo.pwszPassword = NULL;
6881 data.freePassword = FALSE;
6882 if (pExportInfo->dwSubjectChoice == CRYPTUI_WIZ_EXPORT_CERT_CONTEXT &&
6883 pvoid)
6884 memcpy(&data.contextInfo, pvoid,
6885 min(((PCCRYPTUI_WIZ_EXPORT_CERTCONTEXT_INFO)pvoid)->dwSize,
6886 sizeof(data.contextInfo)));
6887 data.keyProvInfo = NULL;
6888 data.deleteKeys = FALSE;
6889 data.fileName = NULL;
6890 data.file = INVALID_HANDLE_VALUE;
6891 data.success = FALSE;
6892
6893 memset(pages, 0, sizeof(pages));
6894
6895 pages[nPages].dwSize = sizeof(pages[0]);
6896 pages[nPages].hInstance = hInstance;
6897 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_WELCOME);
6898 pages[nPages].pfnDlgProc = export_welcome_dlg_proc;
6899 pages[nPages].dwFlags = PSP_HIDEHEADER;
6900 pages[nPages].lParam = (LPARAM)&data;
6901 nPages++;
6902
6903 hasPrivateKey = export_info_has_private_key(pExportInfo);
6904 switch (pExportInfo->dwSubjectChoice)
6905 {
6906 case CRYPTUI_WIZ_EXPORT_CRL_CONTEXT:
6907 case CRYPTUI_WIZ_EXPORT_CTL_CONTEXT:
6908 showFormatPage = FALSE;
6909 data.contextInfo.dwExportFormat = CRYPTUI_WIZ_EXPORT_FORMAT_DER;
6910 break;
6911 case CRYPTUI_WIZ_EXPORT_CERT_STORE:
6912 showFormatPage = FALSE;
6913 data.contextInfo.dwExportFormat =
6914 CRYPTUI_WIZ_EXPORT_FORMAT_SERIALIZED_CERT_STORE;
6915 break;
6916 case CRYPTUI_WIZ_EXPORT_CERT_STORE_CERTIFICATES_ONLY:
6917 showFormatPage = FALSE;
6918 data.contextInfo.dwExportFormat = CRYPTUI_WIZ_EXPORT_FORMAT_PKCS7;
6919 break;
6920 }
6921
6922 if (hasPrivateKey && showFormatPage)
6923 {
6924 pages[nPages].dwSize = sizeof(pages[0]);
6925 pages[nPages].hInstance = hInstance;
6926 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_PRIVATE_KEY);
6927 pages[nPages].pfnDlgProc = export_private_key_dlg_proc;
6928 pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
6929 pages[nPages].pszHeaderTitle =
6930 MAKEINTRESOURCEW(IDS_EXPORT_PRIVATE_KEY_TITLE);
6931 pages[nPages].pszHeaderSubTitle =
6932 MAKEINTRESOURCEW(IDS_EXPORT_PRIVATE_KEY_SUBTITLE);
6933 pages[nPages].lParam = (LPARAM)&data;
6934 nPages++;
6935 }
6936 if (showFormatPage)
6937 {
6938 pages[nPages].dwSize = sizeof(pages[0]);
6939 pages[nPages].hInstance = hInstance;
6940 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_FORMAT);
6941 pages[nPages].pfnDlgProc = export_format_dlg_proc;
6942 pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
6943 pages[nPages].pszHeaderTitle =
6944 MAKEINTRESOURCEW(IDS_EXPORT_FORMAT_TITLE);
6945 pages[nPages].pszHeaderSubTitle =
6946 MAKEINTRESOURCEW(IDS_EXPORT_FORMAT_SUBTITLE);
6947 pages[nPages].lParam = (LPARAM)&data;
6948 nPages++;
6949 }
6950 if (hasPrivateKey && showFormatPage)
6951 {
6952 pages[nPages].dwSize = sizeof(pages[0]);
6953 pages[nPages].hInstance = hInstance;
6954 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_PASSWORD);
6955 pages[nPages].pfnDlgProc = export_password_dlg_proc;
6956 pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
6957 pages[nPages].pszHeaderTitle =
6958 MAKEINTRESOURCEW(IDS_EXPORT_PASSWORD_TITLE);
6959 pages[nPages].pszHeaderSubTitle =
6960 MAKEINTRESOURCEW(IDS_EXPORT_PASSWORD_SUBTITLE);
6961 pages[nPages].lParam = (LPARAM)&data;
6962 nPages++;
6963 }
6964
6965 pages[nPages].dwSize = sizeof(pages[0]);
6966 pages[nPages].hInstance = hInstance;
6967 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_FILE);
6968 pages[nPages].pfnDlgProc = export_file_dlg_proc;
6969 pages[nPages].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
6970 pages[nPages].pszHeaderTitle = MAKEINTRESOURCEW(IDS_EXPORT_FILE_TITLE);
6971 pages[nPages].pszHeaderSubTitle =
6972 MAKEINTRESOURCEW(IDS_EXPORT_FILE_SUBTITLE);
6973 pages[nPages].lParam = (LPARAM)&data;
6974 nPages++;
6975
6976 pages[nPages].dwSize = sizeof(pages[0]);
6977 pages[nPages].hInstance = hInstance;
6978 pages[nPages].u.pszTemplate = MAKEINTRESOURCEW(IDD_EXPORT_FINISH);
6979 pages[nPages].pfnDlgProc = export_finish_dlg_proc;
6980 pages[nPages].dwFlags = PSP_HIDEHEADER;
6981 pages[nPages].lParam = (LPARAM)&data;
6982 nPages++;
6983
6984 memset(&hdr, 0, sizeof(hdr));
6985 hdr.dwSize = sizeof(hdr);
6986 hdr.hwndParent = hwndParent;
6987 hdr.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD97_NEW | PSH_HEADER |
6988 PSH_WATERMARK;
6989 hdr.hInstance = hInstance;
6990 if (pwszWizardTitle)
6991 hdr.pszCaption = pwszWizardTitle;
6992 else
6993 hdr.pszCaption = MAKEINTRESOURCEW(IDS_EXPORT_WIZARD);
6994 hdr.u3.ppsp = pages;
6995 hdr.nPages = nPages;
6996 hdr.u4.pszbmWatermark = MAKEINTRESOURCEW(IDB_CERT_WATERMARK);
6997 hdr.u5.pszbmHeader = MAKEINTRESOURCEW(IDB_CERT_HEADER);
6998 l = PropertySheetW(&hdr);
6999 DeleteObject(data.titleFont);
7000 if (data.freePassword)
7001 HeapFree(GetProcessHeap(), 0,
7002 (LPWSTR)data.contextInfo.pwszPassword);
7003 HeapFree(GetProcessHeap(), 0, data.keyProvInfo);
7004 CloseHandle(data.file);
7005 HeapFree(GetProcessHeap(), 0, data.fileName);
7006 if (l == 0)
7007 {
7008 SetLastError(ERROR_CANCELLED);
7009 return FALSE;
7010 }
7011 else
7012 return data.success;
7013 }
7014
7015 BOOL WINAPI CryptUIWizExport(DWORD dwFlags, HWND hwndParent,
7016 LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_EXPORT_INFO pExportInfo, void *pvoid)
7017 {
7018 BOOL ret;
7019
7020 TRACE("(%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent,
7021 debugstr_w(pwszWizardTitle), pExportInfo, pvoid);
7022
7023 if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
7024 ret = show_export_ui(dwFlags, hwndParent, pwszWizardTitle, pExportInfo,
7025 pvoid);
7026 else
7027 {
7028 HANDLE file = CreateFileW(pExportInfo->pwszExportFileName,
7029 GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
7030 CREATE_ALWAYS, 0, NULL);
7031
7032 if (file != INVALID_HANDLE_VALUE)
7033 {
7034 ret = do_export(file, pExportInfo, pvoid, NULL, FALSE);
7035 CloseHandle(file);
7036 }
7037 else
7038 ret = FALSE;
7039 }
7040 return ret;
7041 }
7042
7043 BOOL WINAPI CryptUIDlgViewSignerInfoA(CRYPTUI_VIEWSIGNERINFO_STRUCTA *pcvsi)
7044 {
7045 FIXME("%p: stub\n", pcvsi);
7046 return FALSE;
7047 }
7048
7049 PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateW(PCCRYPTUI_SELECTCERTIFICATE_STRUCTW pcsc)
7050 {
7051 FIXME("%p: stub\n", pcsc);
7052 return NULL;
7053 }
7054
7055 PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateA(PCCRYPTUI_SELECTCERTIFICATE_STRUCTA pcsc)
7056 {
7057 FIXME("%p: stub\n", pcsc);
7058 return NULL;
7059 }
A free Windows-compatible Operating System