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