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