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