?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cryptui: Make sure input file is not empty.
[wine/wine64.git] / dlls / cryptui / main.c
blob23efa0753048d12f777d2633342393229438a2f1
1 /*
2 * Copyright 2008 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winnls.h"
29 #include "winuser.h"
30 #include "softpub.h"
31 #include "wingdi.h"
32 #include "richedit.h"
33 #include "ole2.h"
34 #include "richole.h"
35 #include "commdlg.h"
36 #include "commctrl.h"
37 #include "cryptuiapi.h"
38 #include "cryptuires.h"
39 #include "urlmon.h"
40 #include "hlink.h"
41 #include "wine/debug.h"
42 #include "wine/unicode.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(cryptui);
45
46 static HINSTANCE hInstance;
47
48 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
49 {
50 TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
51
52 switch (fdwReason)
53 {
54 case DLL_WINE_PREATTACH:
55 return FALSE; /* prefer native version */
56 case DLL_PROCESS_ATTACH:
57 hInstance = hinstDLL;
58 DisableThreadLibraryCalls(hinstDLL);
59 break;
60 case DLL_PROCESS_DETACH:
61 break;
62 default:
63 break;
64 }
65 return TRUE;
66 }
67
68 /***********************************************************************
69 * CryptUIDlgCertMgr (CRYPTUI.@)
70 */
71 BOOL WINAPI CryptUIDlgCertMgr(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
72 {
73 FIXME("(%p): stub\n", pCryptUICertMgr);
74 return FALSE;
75 }
76
77 /* FIXME: real names are unknown, functions are undocumented */
78 typedef struct _CRYPTUI_ENUM_SYSTEM_STORE_ARGS
79 {
80 DWORD dwFlags;
81 void *pvSystemStoreLocationPara;
82 } CRYPTUI_ENUM_SYSTEM_STORE_ARGS, *PCRYPTUI_ENUM_SYSTEM_STORE_ARGS;
83
84 typedef struct _CRYPTUI_ENUM_DATA
85 {
86 DWORD cStores;
87 HCERTSTORE *rghStore;
88 DWORD cEnumArgs;
89 PCRYPTUI_ENUM_SYSTEM_STORE_ARGS rgEnumArgs;
90 } CRYPTUI_ENUM_DATA, *PCRYPTUI_ENUM_DATA;
91
92 typedef BOOL (WINAPI *PFN_SELECTED_STORE_CB)(HCERTSTORE store, HWND hwnd,
93 void *pvArg);
94
95 /* Values for dwFlags */
96 #define CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE 0x00000001
97
98 typedef struct _CRYPTUI_SELECTSTORE_INFO_A
99 {
100 DWORD dwSize;
101 HWND parent;
102 DWORD dwFlags;
103 LPSTR pszTitle;
104 LPSTR pszText;
105 CRYPTUI_ENUM_DATA *pEnumData;
106 PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
107 void *pvArg;
108 } CRYPTUI_SELECTSTORE_INFO_A, *PCRYPTUI_SELECTSTORE_INFO_A;
109
110 typedef struct _CRYPTUI_SELECTSTORE_INFO_W
111 {
112 DWORD dwSize;
113 HWND parent;
114 DWORD dwFlags;
115 LPWSTR pwszTitle;
116 LPWSTR pwszText;
117 CRYPTUI_ENUM_DATA *pEnumData;
118 PFN_SELECTED_STORE_CB pfnSelectedStoreCallback;
119 void *pvArg;
120 } CRYPTUI_SELECTSTORE_INFO_W, *PCRYPTUI_SELECTSTORE_INFO_W;
121
122 struct StoreInfo
123 {
124 enum {
125 StoreHandle,
126 SystemStore
127 } type;
128 union {
129 HCERTSTORE store;
130 LPWSTR name;
131 } DUMMYUNIONNAME;
132 };
133
134 static BOOL WINAPI enum_store_callback(const void *pvSystemStore,
135 DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved,
136 void *pvArg)
137 {
138 HWND tree = GetDlgItem(pvArg, IDC_STORE_LIST);
139 TVINSERTSTRUCTW tvis;
140 LPCWSTR localizedName;
141 BOOL ret = TRUE;
142
143 tvis.hParent = NULL;
144 tvis.hInsertAfter = TVI_LAST;
145 tvis.u.item.mask = TVIF_TEXT;
146 if ((localizedName = CryptFindLocalizedName(pvSystemStore)))
147 {
148 struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(), 0,
149 sizeof(struct StoreInfo));
150
151 if (storeInfo)
152 {
153 storeInfo->type = SystemStore;
154 storeInfo->u.name = HeapAlloc(GetProcessHeap(), 0,
155 (strlenW(pvSystemStore) + 1) * sizeof(WCHAR));
156 if (storeInfo->u.name)
157 {
158 tvis.u.item.mask |= TVIF_PARAM;
159 tvis.u.item.lParam = (LPARAM)storeInfo;
160 strcpyW(storeInfo->u.name, pvSystemStore);
161 }
162 else
163 {
164 HeapFree(GetProcessHeap(), 0, storeInfo);
165 ret = FALSE;
166 }
167 }
168 else
169 ret = FALSE;
170 tvis.u.item.pszText = (LPWSTR)localizedName;
171 }
172 else
173 tvis.u.item.pszText = (LPWSTR)pvSystemStore;
174 /* FIXME: need a folder icon for the store too */
175 if (ret)
176 SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
177 return ret;
178 }
179
180 static void enumerate_stores(HWND hwnd, CRYPTUI_ENUM_DATA *pEnumData)
181 {
182 DWORD i;
183 HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
184
185 for (i = 0; i < pEnumData->cEnumArgs; i++)
186 CertEnumSystemStore(pEnumData->rgEnumArgs[i].dwFlags,
187 pEnumData->rgEnumArgs[i].pvSystemStoreLocationPara,
188 hwnd, enum_store_callback);
189 for (i = 0; i < pEnumData->cStores; i++)
190 {
191 DWORD size;
192
193 if (CertGetStoreProperty(pEnumData->rghStore[i],
194 CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, &size))
195 {
196 LPWSTR name = HeapAlloc(GetProcessHeap(), 0, size);
197
198 if (name)
199 {
200 if (CertGetStoreProperty(pEnumData->rghStore[i],
201 CERT_STORE_LOCALIZED_NAME_PROP_ID, name, &size))
202 {
203 struct StoreInfo *storeInfo = HeapAlloc(GetProcessHeap(),
204 0, sizeof(struct StoreInfo));
205
206 if (storeInfo)
207 {
208 TVINSERTSTRUCTW tvis;
209
210 storeInfo->type = StoreHandle;
211 storeInfo->u.store = pEnumData->rghStore[i];
212 tvis.hParent = NULL;
213 tvis.hInsertAfter = TVI_LAST;
214 tvis.u.item.mask = TVIF_TEXT | TVIF_PARAM;
215 tvis.u.item.pszText = name;
216 tvis.u.item.lParam = (LPARAM)storeInfo;
217 SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
218 }
219 }
220 HeapFree(GetProcessHeap(), 0, name);
221 }
222 }
223 }
224 }
225
226 static void free_store_info(HWND tree)
227 {
228 HTREEITEM next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CHILD,
229 (LPARAM)NULL);
230
231 while (next)
232 {
233 TVITEMW item;
234
235 memset(&item, 0, sizeof(item));
236 item.mask = TVIF_HANDLE | TVIF_PARAM;
237 item.hItem = next;
238 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
239 if (item.lParam)
240 {
241 struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
242
243 if (storeInfo->type == SystemStore)
244 HeapFree(GetProcessHeap(), 0, storeInfo->u.name);
245 HeapFree(GetProcessHeap(), 0, storeInfo);
246 }
247 next = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_NEXT,
248 (LPARAM)next);
249 }
250 }
251
252 #define MAX_STRING_LEN 512
253
254 static HCERTSTORE selected_item_to_store(HWND tree, HTREEITEM hItem)
255 {
256 WCHAR buf[MAX_STRING_LEN];
257 TVITEMW item;
258 HCERTSTORE store;
259
260 memset(&item, 0, sizeof(item));
261 item.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT;
262 item.hItem = hItem;
263 item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
264 item.pszText = buf;
265 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
266 if (item.lParam)
267 {
268 struct StoreInfo *storeInfo = (struct StoreInfo *)item.lParam;
269
270 if (storeInfo->type == StoreHandle)
271 store = storeInfo->u.store;
272 else
273 store = CertOpenSystemStoreW(0, storeInfo->u.name);
274 }
275 else
276 {
277 /* It's implicitly a system store */
278 store = CertOpenSystemStoreW(0, buf);
279 }
280 return store;
281 }
282
283 struct SelectStoreInfo
284 {
285 PCRYPTUI_SELECTSTORE_INFO_W info;
286 HCERTSTORE store;
287 };
288
289 static LRESULT CALLBACK select_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
290 LPARAM lp)
291 {
292 struct SelectStoreInfo *selectInfo;
293 LRESULT ret = 0;
294
295 switch (msg)
296 {
297 case WM_INITDIALOG:
298 {
299 selectInfo = (struct SelectStoreInfo *)lp;
300 SetWindowLongPtrW(hwnd, DWLP_USER, lp);
301 if (selectInfo->info->pwszTitle)
302 SendMessageW(hwnd, WM_SETTEXT, 0,
303 (LPARAM)selectInfo->info->pwszTitle);
304 if (selectInfo->info->pwszText)
305 SendMessageW(GetDlgItem(hwnd, IDC_STORE_TEXT), WM_SETTEXT, 0,
306 (LPARAM)selectInfo->info->pwszText);
307 if (!(selectInfo->info->dwFlags & CRYPTUI_ENABLE_SHOW_PHYSICAL_STORE))
308 ShowWindow(GetDlgItem(hwnd, IDC_SHOW_PHYSICAL_STORES), FALSE);
309 enumerate_stores(hwnd, selectInfo->info->pEnumData);
310 break;
311 }
312 case WM_COMMAND:
313 switch (wp)
314 {
315 case IDOK:
316 {
317 HWND tree = GetDlgItem(hwnd, IDC_STORE_LIST);
318 HTREEITEM selection = (HTREEITEM)SendMessageW(tree,
319 TVM_GETNEXTITEM, TVGN_CARET, (LPARAM)NULL);
320
321 selectInfo = (struct SelectStoreInfo *)GetWindowLongPtrW(hwnd,
322 DWLP_USER);
323 if (!selection)
324 {
325 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN], *pTitle;
326
327 if (selectInfo->info->pwszTitle)
328 pTitle = selectInfo->info->pwszTitle;
329 else
330 {
331 LoadStringW(hInstance, IDS_SELECT_STORE_TITLE, title,
332 sizeof(title) / sizeof(title[0]));
333 pTitle = title;
334 }
335 LoadStringW(hInstance, IDS_SELECT_STORE, error,
336 sizeof(error) / sizeof(error[0]));
337 MessageBoxW(hwnd, error, pTitle, MB_ICONEXCLAMATION | MB_OK);
338 }
339 else
340 {
341 HCERTSTORE store = selected_item_to_store(tree, selection);
342
343 if (!selectInfo->info->pfnSelectedStoreCallback ||
344 selectInfo->info->pfnSelectedStoreCallback(store, hwnd,
345 selectInfo->info->pvArg))
346 {
347 selectInfo->store = store;
348 free_store_info(tree);
349 EndDialog(hwnd, IDOK);
350 }
351 else
352 CertCloseStore(store, 0);
353 }
354 ret = TRUE;
355 break;
356 }
357 case IDCANCEL:
358 free_store_info(GetDlgItem(hwnd, IDC_STORE_LIST));
359 EndDialog(hwnd, IDCANCEL);
360 ret = TRUE;
361 break;
362 }
363 break;
364 }
365 return ret;
366 }
367
368 /***********************************************************************
369 * CryptUIDlgSelectStoreW (CRYPTUI.@)
370 */
371 HCERTSTORE WINAPI CryptUIDlgSelectStoreW(PCRYPTUI_SELECTSTORE_INFO_W info)
372 {
373 struct SelectStoreInfo selectInfo = { info, NULL };
374
375 TRACE("(%p)\n", info);
376
377 if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_W))
378 {
379 WARN("unexpected size %d\n", info->dwSize);
380 SetLastError(E_INVALIDARG);
381 return NULL;
382 }
383 DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_SELECT_STORE), info->parent,
384 select_store_dlg_proc, (LPARAM)&selectInfo);
385 return selectInfo.store;
386 }
387
388 /***********************************************************************
389 * CryptUIDlgSelectStoreA (CRYPTUI.@)
390 */
391 HCERTSTORE WINAPI CryptUIDlgSelectStoreA(PCRYPTUI_SELECTSTORE_INFO_A info)
392 {
393 CRYPTUI_SELECTSTORE_INFO_W infoW;
394 HCERTSTORE ret;
395 int len;
396
397 TRACE("(%p)\n", info);
398
399 if (info->dwSize != sizeof(CRYPTUI_SELECTSTORE_INFO_A))
400 {
401 WARN("unexpected size %d\n", info->dwSize);
402 SetLastError(E_INVALIDARG);
403 return NULL;
404 }
405 memcpy(&infoW, &info, sizeof(info));
406 if (info->pszTitle)
407 {
408 len = MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, NULL, 0);
409 infoW.pwszTitle = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
410 MultiByteToWideChar(CP_ACP, 0, info->pszTitle, -1, infoW.pwszTitle,
411 len);
412 }
413 if (info->pszText)
414 {
415 len = MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, NULL, 0);
416 infoW.pwszText = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
417 MultiByteToWideChar(CP_ACP, 0, info->pszText, -1, infoW.pwszText, len);
418 }
419 ret = CryptUIDlgSelectStoreW(&infoW);
420 HeapFree(GetProcessHeap(), 0, infoW.pwszText);
421 HeapFree(GetProcessHeap(), 0, infoW.pwszTitle);
422 return ret;
423 }
424
425 /***********************************************************************
426 * CryptUIDlgViewCertificateA (CRYPTUI.@)
427 */
428 BOOL WINAPI CryptUIDlgViewCertificateA(
429 PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
430 {
431 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
432 LPWSTR title = NULL;
433 BOOL ret;
434
435 TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
436
437 memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
438 if (pCertViewInfo->szTitle)
439 {
440 int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
441 NULL, 0);
442
443 title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
444 if (title)
445 {
446 MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
447 len);
448 viewInfo.szTitle = title;
449 }
450 else
451 {
452 ret = FALSE;
453 goto error;
454 }
455 }
456 if (pCertViewInfo->cPropSheetPages)
457 {
458 FIXME("ignoring additional prop sheet pages\n");
459 viewInfo.cPropSheetPages = 0;
460 }
461 ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
462 HeapFree(GetProcessHeap(), 0, title);
463 error:
464 return ret;
465 }
466
467 struct ReadStringStruct
468 {
469 LPCWSTR buf;
470 LONG pos;
471 LONG len;
472 };
473
474 static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
475 LONG cb, LONG *pcb)
476 {
477 struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
478 LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
479
480 TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
481
482 memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
483 string->pos += cch;
484 *pcb = cch * sizeof(WCHAR);
485 return 0;
486 }
487
488 static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
489 {
490 struct ReadStringStruct string;
491 EDITSTREAM editstream;
492
493 TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
494
495 string.buf = text;
496 string.pos = 0;
497 string.len = len;
498 editstream.dwCookie = (DWORD_PTR)&string;
499 editstream.dwError = 0;
500 editstream.pfnCallback = read_text_callback;
501 SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
502 (LPARAM)&editstream);
503 }
504
505 static void add_string_resource_to_control(HWND hwnd, int id)
506 {
507 LPWSTR str;
508 LONG len;
509
510 len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
511 add_unformatted_text_to_control(hwnd, str, len);
512 }
513
514 static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
515 LONG len, const PARAFORMAT2 *fmt)
516 {
517 add_unformatted_text_to_control(hwnd, text, len);
518 SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
519 }
520
521 static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
522 const PARAFORMAT2 *fmt)
523 {
524 LPWSTR str;
525 LONG len;
526
527 len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
528 add_text_with_paraformat_to_control(hwnd, str, len, fmt);
529 }
530
531 static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
532 DWORD dwFlags)
533 {
534 LPWSTR buf = NULL;
535 DWORD len;
536
537 len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
538 if (len)
539 {
540 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
541 if (buf)
542 CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
543 }
544 return buf;
545 }
546
547 static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
548 DWORD dwType, DWORD dwFlags)
549 {
550 LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
551
552 if (name)
553 {
554 /* Don't include NULL-terminator in output */
555 DWORD len = lstrlenW(name);
556
557 add_unformatted_text_to_control(hwnd, name, len);
558 HeapFree(GetProcessHeap(), 0, name);
559 }
560 }
561
562 static void add_icon_to_control(HWND hwnd, int id)
563 {
564 HRESULT hr;
565 LPRICHEDITOLE richEditOle = NULL;
566 LPOLEOBJECT object = NULL;
567 CLSID clsid;
568 LPOLECACHE oleCache = NULL;
569 FORMATETC formatEtc;
570 DWORD conn;
571 LPDATAOBJECT dataObject = NULL;
572 HBITMAP bitmap = NULL;
573 RECT rect;
574 STGMEDIUM stgm;
575 REOBJECT reObject;
576
577 TRACE("(%p, %d)\n", hwnd, id);
578
579 SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
580 if (!richEditOle)
581 goto end;
582 hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
583 (void**)&object);
584 if (FAILED(hr))
585 goto end;
586 hr = IOleObject_GetUserClassID(object, &clsid);
587 if (FAILED(hr))
588 goto end;
589 hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
590 if (FAILED(hr))
591 goto end;
592 formatEtc.cfFormat = CF_BITMAP;
593 formatEtc.ptd = NULL;
594 formatEtc.dwAspect = DVASPECT_CONTENT;
595 formatEtc.lindex = -1;
596 formatEtc.tymed = TYMED_GDI;
597 hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
598 if (FAILED(hr))
599 goto end;
600 hr = IOleObject_QueryInterface(object, &IID_IDataObject,
601 (void**)&dataObject);
602 if (FAILED(hr))
603 goto end;
604 bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
605 LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
606 if (!bitmap)
607 goto end;
608 rect.left = rect.top = 0;
609 rect.right = GetSystemMetrics(SM_CXICON);
610 rect.bottom = GetSystemMetrics(SM_CYICON);
611 stgm.tymed = TYMED_GDI;
612 stgm.u.hBitmap = bitmap;
613 stgm.pUnkForRelease = NULL;
614 hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
615 if (FAILED(hr))
616 goto end;
617
618 reObject.cbStruct = sizeof(reObject);
619 reObject.cp = REO_CP_SELECTION;
620 reObject.clsid = clsid;
621 reObject.poleobj = object;
622 reObject.pstg = NULL;
623 reObject.polesite = NULL;
624 reObject.sizel.cx = reObject.sizel.cy = 0;
625 reObject.dvaspect = DVASPECT_CONTENT;
626 reObject.dwFlags = 0;
627 reObject.dwUser = 0;
628
629 IRichEditOle_InsertObject(richEditOle, &reObject);
630
631 end:
632 if (dataObject)
633 IDataObject_Release(dataObject);
634 if (oleCache)
635 IOleCache_Release(oleCache);
636 if (object)
637 IOleObject_Release(object);
638 if (richEditOle)
639 IRichEditOle_Release(richEditOle);
640 }
641
642 #define MY_INDENT 200
643
644 static void add_oid_text_to_control(HWND hwnd, char *oid)
645 {
646 WCHAR nl = '\n';
647 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
648 PARAFORMAT2 parFmt;
649
650 parFmt.cbSize = sizeof(parFmt);
651 parFmt.dwMask = PFM_STARTINDENT;
652 parFmt.dxStartIndent = MY_INDENT * 3;
653 if (oidInfo)
654 {
655 add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
656 lstrlenW(oidInfo->pwszName), &parFmt);
657 add_unformatted_text_to_control(hwnd, &nl, 1);
658 }
659 }
660
661 struct OIDToString
662 {
663 LPCSTR oid;
664 int id;
665 };
666
667 /* The following list MUST be lexicographically sorted by OID */
668 static struct OIDToString oidMap[] = {
669 /* 1.3.6.1.4.1.311.10.3.1 */
670 { szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
671 /* 1.3.6.1.4.1.311.10.3.4 */
672 { szOID_KP_EFS, IDS_PURPOSE_EFS },
673 /* 1.3.6.1.4.1.311.10.3.4.1 */
674 { szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
675 /* 1.3.6.1.4.1.311.10.3.5 */
676 { szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
677 /* 1.3.6.1.4.1.311.10.3.6 */
678 { szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
679 /* 1.3.6.1.4.1.311.10.3.7 */
680 { szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
681 /* 1.3.6.1.4.1.311.10.3.8 */
682 { szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
683 /* 1.3.6.1.4.1.311.10.3.9 */
684 { szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
685 /* 1.3.6.1.4.1.311.10.3.10 */
686 { szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
687 /* 1.3.6.1.4.1.311.10.3.11 */
688 { szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
689 /* 1.3.6.1.4.1.311.10.3.12 */
690 { szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
691 /* 1.3.6.1.4.1.311.10.3.13 */
692 { szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
693 /* 1.3.6.1.4.1.311.10.5.1 */
694 { szOID_DRM, IDS_PURPOSE_DRM },
695 /* 1.3.6.1.4.1.311.10.6.1 */
696 { szOID_LICENSES, IDS_PURPOSE_LICENSES },
697 /* 1.3.6.1.4.1.311.10.6.2 */
698 { szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
699 /* 1.3.6.1.4.1.311.20.2.1 */
700 { szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
701 /* 1.3.6.1.4.1.311.20.2.2 */
702 { szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
703 /* 1.3.6.1.4.1.311.21.5 */
704 { szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
705 /* 1.3.6.1.4.1.311.21.6 */
706 { szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
707 /* 1.3.6.1.4.1.311.21.19 */
708 { szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
709 /* 1.3.6.1.5.5.7.3.1 */
710 { szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
711 /* 1.3.6.1.5.5.7.3.2 */
712 { szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
713 /* 1.3.6.1.5.5.7.3.3 */
714 { szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
715 /* 1.3.6.1.5.5.7.3.4 */
716 { szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
717 /* 1.3.6.1.5.5.7.3.5 */
718 { szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
719 /* 1.3.6.1.5.5.7.3.6 */
720 { szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
721 /* 1.3.6.1.5.5.7.3.7 */
722 { szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
723 /* 1.3.6.1.5.5.7.3.8 */
724 { szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
725 };
726
727 static struct OIDToString *findSupportedOID(LPCSTR oid)
728 {
729 int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0, i;
730 struct OIDToString *ret = NULL;
731
732 for (i = (indexLow + indexHigh) / 2; !ret && indexLow <= indexHigh;
733 i = (indexLow + indexHigh) / 2)
734 {
735 int cmp;
736
737 cmp = strcmp(oid, oidMap[i].oid);
738 if (!cmp)
739 ret = &oidMap[i];
740 else if (cmp > 0)
741 indexLow = i + 1;
742 else
743 indexHigh = i - 1;
744 }
745 return ret;
746 }
747
748 static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
749 {
750 struct OIDToString *entry;
751 WCHAR nl = '\n';
752 PARAFORMAT2 parFmt;
753
754 parFmt.cbSize = sizeof(parFmt);
755 parFmt.dwMask = PFM_STARTINDENT;
756 parFmt.dxStartIndent = MY_INDENT * 3;
757 if ((entry = findSupportedOID(oid)))
758 {
759 WCHAR *str, *linebreak, *ptr;
760 BOOL multiline = FALSE;
761 int len;
762
763 len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
764 ptr = str;
765 do {
766 if ((linebreak = memchrW(ptr, '\n', len)))
767 {
768 WCHAR copy[MAX_STRING_LEN];
769
770 multiline = TRUE;
771 /* The source string contains a newline, which the richedit
772 * control won't find since it's interpreted as a paragraph
773 * break. Therefore copy up to the newline. lstrcpynW always
774 * NULL-terminates, so pass one more than the length of the
775 * source line so the copy includes the entire line and the
776 * NULL-terminator.
777 */
778 lstrcpynW(copy, ptr, linebreak - ptr + 1);
779 add_text_with_paraformat_to_control(text, copy,
780 linebreak - ptr, &parFmt);
781 ptr = linebreak + 1;
782 add_unformatted_text_to_control(text, &nl, 1);
783 }
784 else if (multiline && *ptr)
785 {
786 /* Add the last line */
787 add_text_with_paraformat_to_control(text, ptr,
788 len - (ptr - str), &parFmt);
789 add_unformatted_text_to_control(text, &nl, 1);
790 }
791 } while (linebreak);
792 if (!multiline)
793 {
794 add_text_with_paraformat_to_control(text, str, len, &parFmt);
795 add_unformatted_text_to_control(text, &nl, 1);
796 }
797 }
798 else
799 {
800 WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
801 (strlen(oid) + 1) * sizeof(WCHAR));
802
803 if (oidW)
804 {
805 LPCSTR src;
806 WCHAR *dst;
807
808 for (src = oid, dst = oidW; *src; src++, dst++)
809 *dst = *src;
810 *dst = 0;
811 add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
812 &parFmt);
813 add_unformatted_text_to_control(text, &nl, 1);
814 HeapFree(GetProcessHeap(), 0, oidW);
815 }
816 }
817 }
818
819 static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
820 BOOL *anyUsageAdded)
821 {
822 static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
823 WCHAR nl = '\n';
824 CHARFORMATW charFmt;
825 PCERT_EXTENSION policyExt;
826 if (!*anyUsageAdded)
827 {
828 PARAFORMAT2 parFmt;
829
830 parFmt.cbSize = sizeof(parFmt);
831 parFmt.dwMask = PFM_STARTINDENT;
832 parFmt.dxStartIndent = MY_INDENT;
833 add_string_resource_with_paraformat_to_control(text,
834 IDS_CERT_INFO_PURPOSES, &parFmt);
835 add_unformatted_text_to_control(text, &nl, 1);
836 *anyUsageAdded = TRUE;
837 }
838 memset(&charFmt, 0, sizeof(charFmt));
839 charFmt.cbSize = sizeof(charFmt);
840 charFmt.dwMask = CFM_BOLD;
841 charFmt.dwEffects = 0;
842 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
843 if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
844 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
845 {
846 CERT_POLICIES_INFO *policies;
847 DWORD size;
848
849 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
850 policyExt->Value.pbData, policyExt->Value.cbData,
851 CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
852 {
853 DWORD i;
854
855 for (i = 0; i < policies->cPolicyInfo; i++)
856 {
857 DWORD j;
858
859 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
860 add_local_oid_text_to_control(text,
861 policies->rgPolicyInfo[i].rgPolicyQualifier[j].
862 pszPolicyQualifierId);
863 }
864 LocalFree(policies);
865 }
866 }
867 else
868 add_oid_text_to_control(text, any_app_policy);
869 }
870
871 static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
872 BOOL *anyUsageAdded)
873 {
874 WCHAR nl = '\n';
875 DWORD size;
876 BOOL badUsages = FALSE;
877
878 if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
879 {
880 CHARFORMATW charFmt;
881 static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
882 PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
883
884 if (usage)
885 {
886 if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
887 {
888 DWORD i;
889
890 if (!*anyUsageAdded)
891 {
892 PARAFORMAT2 parFmt;
893
894 parFmt.cbSize = sizeof(parFmt);
895 parFmt.dwMask = PFM_STARTINDENT;
896 parFmt.dxStartIndent = MY_INDENT;
897 add_string_resource_with_paraformat_to_control(text,
898 IDS_CERT_INFO_PURPOSES, &parFmt);
899 add_unformatted_text_to_control(text, &nl, 1);
900 *anyUsageAdded = TRUE;
901 }
902 memset(&charFmt, 0, sizeof(charFmt));
903 charFmt.cbSize = sizeof(charFmt);
904 charFmt.dwMask = CFM_BOLD;
905 charFmt.dwEffects = 0;
906 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
907 (LPARAM)&charFmt);
908 if (!usage->cUsageIdentifier)
909 add_oid_text_to_control(text, any_cert_policy);
910 else
911 for (i = 0; i < usage->cUsageIdentifier; i++)
912 add_local_oid_text_to_control(text,
913 usage->rgpszUsageIdentifier[i]);
914 }
915 else
916 badUsages = TRUE;
917 HeapFree(GetProcessHeap(), 0, usage);
918 }
919 else
920 badUsages = TRUE;
921 }
922 else
923 badUsages = TRUE;
924 return badUsages;
925 }
926
927 static void set_policy_text(HWND text,
928 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
929 {
930 BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
931 BOOL badUsages = FALSE, anyUsageAdded = FALSE;
932
933 if (pCertViewInfo->cPurposes)
934 {
935 DWORD i;
936
937 for (i = 0; i < pCertViewInfo->cPurposes; i++)
938 {
939 if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
940 includeCertUsages = TRUE;
941 else if (!strcmp(pCertViewInfo->rgszPurposes[i],
942 szOID_ANY_APPLICATION_POLICY))
943 includeAppUsages = TRUE;
944 else
945 badUsages = TRUE;
946 }
947 }
948 else
949 includeAppUsages = includeCertUsages = TRUE;
950 if (includeAppUsages)
951 display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
952 if (includeCertUsages)
953 badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
954 &anyUsageAdded);
955 if (badUsages)
956 {
957 PARAFORMAT2 parFmt;
958
959 parFmt.cbSize = sizeof(parFmt);
960 parFmt.dwMask = PFM_STARTINDENT;
961 parFmt.dxStartIndent = MY_INDENT;
962 add_string_resource_with_paraformat_to_control(text,
963 IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
964 }
965 }
966
967 static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
968 LPCSTR policyOid)
969 {
970 CRYPT_OBJID_BLOB *ret = NULL;
971 DWORD i;
972
973 for (i = 0; !ret && i < policies->cPolicyInfo; i++)
974 {
975 DWORD j;
976
977 for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
978 if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
979 pszPolicyQualifierId, policyOid))
980 ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
981 Qualifier;
982 }
983 return ret;
984 }
985
986 static WCHAR *get_cps_str_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
987 {
988 LPWSTR qualifierStr = NULL;
989 CERT_NAME_VALUE *qualifierValue;
990 DWORD size;
991
992 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
993 qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
994 &qualifierValue, &size))
995 {
996 size = CertRDNValueToStrW(qualifierValue->dwValueType,
997 &qualifierValue->Value, NULL, 0);
998 qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
999 if (qualifierStr)
1000 CertRDNValueToStrW(qualifierValue->dwValueType,
1001 &qualifierValue->Value, qualifierStr, size);
1002 LocalFree(qualifierValue);
1003 }
1004 return qualifierStr;
1005 }
1006
1007 static WCHAR *get_user_notice_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
1008 {
1009 LPWSTR str = NULL;
1010 CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
1011 DWORD size;
1012
1013 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
1014 X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
1015 qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
1016 &qualifierValue, &size))
1017 {
1018 str = HeapAlloc(GetProcessHeap(), 0,
1019 (strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
1020 if (str)
1021 strcpyW(str, qualifierValue->pszDisplayText);
1022 LocalFree(qualifierValue);
1023 }
1024 return str;
1025 }
1026
1027 struct IssuerStatement
1028 {
1029 LPWSTR cps;
1030 LPWSTR userNotice;
1031 };
1032
1033 static void set_issuer_statement(HWND hwnd,
1034 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1035 {
1036 PCERT_EXTENSION policyExt;
1037
1038 if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
1039 (policyExt = CertFindExtension(szOID_CERT_POLICIES,
1040 pCertViewInfo->pCertContext->pCertInfo->cExtension,
1041 pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
1042 {
1043 CERT_POLICIES_INFO *policies;
1044 DWORD size;
1045
1046 if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
1047 policyExt->Value.pbData, policyExt->Value.cbData,
1048 CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
1049 {
1050 CRYPT_OBJID_BLOB *qualifier;
1051 LPWSTR cps = NULL, userNotice = NULL;
1052
1053 if ((qualifier = find_policy_qualifier(policies,
1054 szOID_PKIX_POLICY_QUALIFIER_CPS)))
1055 cps = get_cps_str_from_qualifier(qualifier);
1056 if ((qualifier = find_policy_qualifier(policies,
1057 szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
1058 userNotice = get_user_notice_from_qualifier(qualifier);
1059 if (cps || userNotice)
1060 {
1061 struct IssuerStatement *issuerStatement =
1062 HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
1063
1064 if (issuerStatement)
1065 {
1066 issuerStatement->cps = cps;
1067 issuerStatement->userNotice = userNotice;
1068 EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
1069 SetWindowLongPtrW(hwnd, DWLP_USER,
1070 (ULONG_PTR)issuerStatement);
1071 }
1072 }
1073 LocalFree(policies);
1074 }
1075 }
1076 }
1077
1078 static void set_cert_info(HWND hwnd,
1079 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1080 {
1081 CHARFORMATW charFmt;
1082 PARAFORMAT2 parFmt;
1083 HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
1084 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
1085 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
1086 (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
1087 pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
1088 pCertViewInfo->idxCounterSigner);
1089 CRYPT_PROVIDER_CERT *root =
1090 &provSigner->pasCertChain[provSigner->csCertChain - 1];
1091
1092 if (!provSigner->pChainContext ||
1093 (provSigner->pChainContext->TrustStatus.dwErrorStatus &
1094 CERT_TRUST_IS_PARTIAL_CHAIN))
1095 add_icon_to_control(icon, IDB_CERT_WARNING);
1096 else if (!root->fTrustedRoot)
1097 add_icon_to_control(icon, IDB_CERT_ERROR);
1098 else
1099 add_icon_to_control(icon, IDB_CERT);
1100
1101 memset(&charFmt, 0, sizeof(charFmt));
1102 charFmt.cbSize = sizeof(charFmt);
1103 charFmt.dwMask = CFM_BOLD;
1104 charFmt.dwEffects = CFE_BOLD;
1105 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1106 /* FIXME: vertically center text */
1107 parFmt.cbSize = sizeof(parFmt);
1108 parFmt.dwMask = PFM_STARTINDENT;
1109 parFmt.dxStartIndent = MY_INDENT;
1110 add_string_resource_with_paraformat_to_control(text,
1111 IDS_CERTIFICATEINFORMATION, &parFmt);
1112
1113 text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
1114 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1115 if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
1116 add_string_resource_with_paraformat_to_control(text,
1117 IDS_CERT_INFO_BAD_SIG, &parFmt);
1118 else if (!provSigner->pChainContext ||
1119 (provSigner->pChainContext->TrustStatus.dwErrorStatus &
1120 CERT_TRUST_IS_PARTIAL_CHAIN))
1121 add_string_resource_with_paraformat_to_control(text,
1122 IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
1123 else if (!root->fTrustedRoot)
1124 {
1125 if (provSigner->csCertChain == 1 && root->fSelfSigned)
1126 add_string_resource_with_paraformat_to_control(text,
1127 IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
1128 else
1129 add_string_resource_with_paraformat_to_control(text,
1130 IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
1131 }
1132 else
1133 {
1134 set_policy_text(text, pCertViewInfo);
1135 set_issuer_statement(hwnd, pCertViewInfo);
1136 }
1137 }
1138
1139 static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
1140 DWORD nameFlags, int heading)
1141 {
1142 WCHAR nl = '\n';
1143 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
1144 CHARFORMATW charFmt;
1145 PARAFORMAT2 parFmt;
1146
1147 memset(&charFmt, 0, sizeof(charFmt));
1148 charFmt.cbSize = sizeof(charFmt);
1149 charFmt.dwMask = CFM_BOLD;
1150 charFmt.dwEffects = CFE_BOLD;
1151 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1152 parFmt.cbSize = sizeof(parFmt);
1153 parFmt.dwMask = PFM_STARTINDENT;
1154 parFmt.dxStartIndent = MY_INDENT * 3;
1155 add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
1156 charFmt.dwEffects = 0;
1157 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1158 add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1159 nameFlags);
1160 add_unformatted_text_to_control(text, &nl, 1);
1161 add_unformatted_text_to_control(text, &nl, 1);
1162 add_unformatted_text_to_control(text, &nl, 1);
1163
1164 }
1165
1166 static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
1167 {
1168 WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
1169 WCHAR date[80];
1170 SYSTEMTIME sysTime;
1171
1172 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
1173 sizeof(dateFmt) / sizeof(dateFmt[0]));
1174 FileTimeToSystemTime(fileTime, &sysTime);
1175 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
1176 sizeof(date) / sizeof(date[0]));
1177 add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
1178 }
1179
1180 static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
1181 {
1182 WCHAR nl = '\n';
1183 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
1184 CHARFORMATW charFmt;
1185 PARAFORMAT2 parFmt;
1186
1187 memset(&charFmt, 0, sizeof(charFmt));
1188 charFmt.cbSize = sizeof(charFmt);
1189 charFmt.dwMask = CFM_BOLD;
1190 charFmt.dwEffects = CFE_BOLD;
1191 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1192 parFmt.cbSize = sizeof(parFmt);
1193 parFmt.dwMask = PFM_STARTINDENT;
1194 parFmt.dxStartIndent = MY_INDENT * 3;
1195 add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
1196 &parFmt);
1197 charFmt.dwEffects = 0;
1198 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1199 add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
1200 charFmt.dwEffects = CFE_BOLD;
1201 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1202 add_string_resource_to_control(text, IDS_VALID_TO);
1203 charFmt.dwEffects = 0;
1204 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
1205 add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
1206 add_unformatted_text_to_control(text, &nl, 1);
1207 }
1208
1209 static void set_general_info(HWND hwnd,
1210 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
1211 {
1212 set_cert_info(hwnd, pCertViewInfo);
1213 set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
1214 IDS_SUBJECT_HEADING);
1215 set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
1216 CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
1217 set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
1218 }
1219
1220 static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1221 LPARAM lp)
1222 {
1223 LRESULT ret = 0;
1224 HWND text;
1225 struct IssuerStatement *issuerStatement;
1226
1227 switch (msg)
1228 {
1229 case WM_INITDIALOG:
1230 text = GetDlgItem(hwnd, IDC_USERNOTICE);
1231 issuerStatement = (struct IssuerStatement *)lp;
1232 add_unformatted_text_to_control(text, issuerStatement->userNotice,
1233 strlenW(issuerStatement->userNotice));
1234 if (issuerStatement->cps)
1235 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
1236 else
1237 EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
1238 break;
1239 case WM_COMMAND:
1240 switch (wp)
1241 {
1242 case IDOK:
1243 EndDialog(hwnd, IDOK);
1244 ret = TRUE;
1245 break;
1246 case IDC_CPS:
1247 {
1248 IBindCtx *bctx = NULL;
1249 LPWSTR cps;
1250
1251 CreateBindCtx(0, &bctx);
1252 cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
1253 HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
1254 HLNF_OPENINNEWWINDOW, 0);
1255 IBindCtx_Release(bctx);
1256 break;
1257 }
1258 }
1259 }
1260 return ret;
1261 }
1262
1263 static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
1264 {
1265 DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
1266 user_notice_dlg_proc, (LPARAM)issuerStatement);
1267 }
1268
1269 static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1270 LPARAM lp)
1271 {
1272 PROPSHEETPAGEW *page;
1273 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
1274
1275 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
1276
1277 switch (msg)
1278 {
1279 case WM_INITDIALOG:
1280 page = (PROPSHEETPAGEW *)lp;
1281 pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
1282 if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
1283 ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
1284 EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
1285 set_general_info(hwnd, pCertViewInfo);
1286 break;
1287 case WM_COMMAND:
1288 switch (wp)
1289 {
1290 case IDC_ADDTOSTORE:
1291 FIXME("call CryptUIWizImport\n");
1292 break;
1293 case IDC_ISSUERSTATEMENT:
1294 {
1295 struct IssuerStatement *issuerStatement =
1296 (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
1297
1298 if (issuerStatement)
1299 {
1300 if (issuerStatement->userNotice)
1301 show_user_notice(hwnd, issuerStatement);
1302 else if (issuerStatement->cps)
1303 {
1304 IBindCtx *bctx = NULL;
1305
1306 CreateBindCtx(0, &bctx);
1307 HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
1308 NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
1309 IBindCtx_Release(bctx);
1310 }
1311 }
1312 break;
1313 }
1314 }
1315 break;
1316 }
1317 return 0;
1318 }
1319
1320 static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
1321 PROPSHEETPAGEW *page)
1322 {
1323 struct IssuerStatement *issuerStatement;
1324
1325 switch (msg)
1326 {
1327 case PSPCB_RELEASE:
1328 issuerStatement =
1329 (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
1330 if (issuerStatement)
1331 {
1332 HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
1333 HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
1334 HeapFree(GetProcessHeap(), 0, issuerStatement);
1335 }
1336 break;
1337 }
1338 return 1;
1339 }
1340
1341 static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
1342 PROPSHEETPAGEW *page)
1343 {
1344 memset(page, 0, sizeof(PROPSHEETPAGEW));
1345 page->dwSize = sizeof(PROPSHEETPAGEW);
1346 page->dwFlags = PSP_USECALLBACK;
1347 page->pfnCallback = general_callback_proc;
1348 page->hInstance = hInstance;
1349 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
1350 page->pfnDlgProc = general_dlg_proc;
1351 page->lParam = (LPARAM)pCertViewInfo;
1352 }
1353
1354 typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
1355
1356 static WCHAR *field_format_version(PCCERT_CONTEXT cert)
1357 {
1358 static const WCHAR fmt[] = { 'V','%','d',0 };
1359 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
1360
1361 if (buf)
1362 sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
1363 return buf;
1364 }
1365
1366 static WCHAR *format_hex_string(void *pb, DWORD cb)
1367 {
1368 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
1369
1370 if (buf)
1371 {
1372 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1373 DWORD i;
1374 WCHAR *ptr;
1375
1376 for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
1377 sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
1378 }
1379 return buf;
1380 }
1381
1382 static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
1383 {
1384 return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
1385 cert->pCertInfo->SerialNumber.cbData);
1386 }
1387
1388 static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
1389 {
1390 return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1391 CERT_NAME_ISSUER_FLAG);
1392 }
1393
1394 static WCHAR *field_format_detailed_cert_name(PCERT_NAME_BLOB name)
1395 {
1396 WCHAR *str = NULL;
1397 DWORD len = CertNameToStrW(X509_ASN_ENCODING, name,
1398 CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, NULL, 0);
1399
1400 if (len)
1401 {
1402 str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1403 if (str)
1404 CertNameToStrW(X509_ASN_ENCODING, name,
1405 CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, str, len);
1406 }
1407 return str;
1408 }
1409
1410 static WCHAR *field_format_detailed_issuer(PCCERT_CONTEXT cert, void *param)
1411 {
1412 return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
1413 }
1414
1415 static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
1416 {
1417 return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
1418 }
1419
1420 static WCHAR *field_format_detailed_subject(PCCERT_CONTEXT cert, void *param)
1421 {
1422 return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
1423 }
1424
1425 static WCHAR *format_long_date(const FILETIME *fileTime)
1426 {
1427 WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
1428 DWORD len;
1429 WCHAR *buf = NULL;
1430 SYSTEMTIME sysTime;
1431
1432 /* FIXME: format isn't quite right, want time too */
1433 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
1434 sizeof(dateFmt) / sizeof(dateFmt[0]));
1435 FileTimeToSystemTime(fileTime, &sysTime);
1436 len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
1437 if (len)
1438 {
1439 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1440 if (buf)
1441 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
1442 len);
1443 }
1444 return buf;
1445 }
1446
1447 static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
1448 {
1449 return format_long_date(&cert->pCertInfo->NotBefore);
1450 }
1451
1452 static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
1453 {
1454 return format_long_date(&cert->pCertInfo->NotAfter);
1455 }
1456
1457 static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
1458 {
1459 PCCRYPT_OID_INFO oidInfo;
1460 WCHAR *buf = NULL;
1461
1462 oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1463 cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
1464 if (oidInfo)
1465 {
1466 WCHAR fmt[MAX_STRING_LEN];
1467
1468 if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
1469 sizeof(fmt) / sizeof(fmt[0])))
1470 {
1471 /* Allocate the output buffer. Use the number of bytes in the
1472 * public key as a conservative (high) estimate for the number of
1473 * digits in its output.
1474 * The output is of the form (in English)
1475 * "<public key algorithm> (<public key bit length> bits)".
1476 * Ordinarily having two positional parameters in a string is not a
1477 * good idea, but as this isn't a sentence fragment, it shouldn't
1478 * be word-order dependent.
1479 */
1480 buf = HeapAlloc(GetProcessHeap(), 0,
1481 (strlenW(fmt) + strlenW(oidInfo->pwszName) +
1482 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8)
1483 * sizeof(WCHAR));
1484 if (buf)
1485 sprintfW(buf, fmt, oidInfo->pwszName,
1486 CertGetPublicKeyLength(X509_ASN_ENCODING,
1487 &cert->pCertInfo->SubjectPublicKeyInfo));
1488 }
1489 }
1490 return buf;
1491 }
1492
1493 static WCHAR *field_format_detailed_public_key(PCCERT_CONTEXT cert, void *param)
1494 {
1495 return format_hex_string(
1496 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
1497 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
1498 }
1499
1500 struct field_value_data;
1501 struct detail_data
1502 {
1503 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
1504 BOOL *pfPropertiesChanged;
1505 int cFields;
1506 struct field_value_data *fields;
1507 };
1508
1509 typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
1510
1511 typedef WCHAR *(*create_detailed_value_func)(PCCERT_CONTEXT cert, void *param);
1512
1513 struct field_value_data
1514 {
1515 create_detailed_value_func create;
1516 LPWSTR detailed_value;
1517 void *param;
1518 };
1519
1520 static void add_field_value_data(struct detail_data *data,
1521 create_detailed_value_func create, void *param)
1522 {
1523 if (data->cFields)
1524 data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
1525 (data->cFields + 1) * sizeof(struct field_value_data));
1526 else
1527 data->fields = HeapAlloc(GetProcessHeap(), 0,
1528 sizeof(struct field_value_data));
1529 if (data->fields)
1530 {
1531 data->fields[data->cFields].create = create;
1532 data->fields[data->cFields].detailed_value = NULL;
1533 data->fields[data->cFields].param = param;
1534 data->cFields++;
1535 }
1536 }
1537
1538 static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
1539 LPWSTR field, LPWSTR value, create_detailed_value_func create, void *param)
1540 {
1541 LVITEMW item;
1542 int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
1543
1544 item.mask = LVIF_TEXT | LVIF_PARAM;
1545 item.iItem = iItem;
1546 item.iSubItem = 0;
1547 item.pszText = field;
1548 item.lParam = (LPARAM)data;
1549 SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
1550 if (value)
1551 {
1552 item.pszText = value;
1553 item.iSubItem = 1;
1554 SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
1555 }
1556 add_field_value_data(data, create, param);
1557 }
1558
1559 static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
1560 int id, LPWSTR value, create_detailed_value_func create, void *param)
1561 {
1562 WCHAR buf[MAX_STRING_LEN];
1563
1564 LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
1565 add_field_and_value_to_list(hwnd, data, buf, value, create, param);
1566 }
1567
1568 struct v1_field
1569 {
1570 int id;
1571 field_format_func format;
1572 create_detailed_value_func create_detailed_value;
1573 };
1574
1575 static void add_v1_field(HWND hwnd, struct detail_data *data,
1576 const struct v1_field *field)
1577 {
1578 WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
1579
1580 if (val)
1581 {
1582 add_string_id_and_value_to_list(hwnd, data, field->id, val,
1583 field->create_detailed_value, NULL);
1584 HeapFree(GetProcessHeap(), 0, val);
1585 }
1586 }
1587
1588 static const struct v1_field v1_fields[] = {
1589 { IDS_FIELD_VERSION, field_format_version, NULL },
1590 { IDS_FIELD_SERIAL_NUMBER, field_format_serial_number, NULL },
1591 { IDS_FIELD_ISSUER, field_format_issuer, field_format_detailed_issuer },
1592 { IDS_FIELD_VALID_FROM, field_format_from_date, NULL },
1593 { IDS_FIELD_VALID_TO, field_format_to_date, NULL },
1594 { IDS_FIELD_SUBJECT, field_format_subject, field_format_detailed_subject },
1595 { IDS_FIELD_PUBLIC_KEY, field_format_public_key,
1596 field_format_detailed_public_key }
1597 };
1598
1599 static void add_v1_fields(HWND hwnd, struct detail_data *data)
1600 {
1601 int i;
1602 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1603
1604 /* The last item in v1_fields is the public key, which is not in the loop
1605 * because it's a special case.
1606 */
1607 for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
1608 add_v1_field(hwnd, data, &v1_fields[i]);
1609 if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
1610 add_v1_field(hwnd, data, &v1_fields[i]);
1611 }
1612
1613 static WCHAR *crypt_format_extension(PCERT_EXTENSION ext, DWORD formatStrType)
1614 {
1615 WCHAR *str = NULL;
1616 DWORD size;
1617
1618 if (CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
1619 ext->pszObjId, ext->Value.pbData, ext->Value.cbData, NULL, &size))
1620 {
1621 str = HeapAlloc(GetProcessHeap(), 0, size);
1622 CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
1623 ext->pszObjId, ext->Value.pbData, ext->Value.cbData, str, &size);
1624 }
1625 return str;
1626 }
1627
1628 static WCHAR *field_format_extension_hex_with_ascii(PCERT_EXTENSION ext)
1629 {
1630 WCHAR *str = NULL;
1631
1632 if (ext->Value.cbData)
1633 {
1634 /* The output is formatted as:
1635 * <hex bytes> <ascii bytes>\n
1636 * where <hex bytes> is a string of up to 8 bytes, output as %02x,
1637 * and <ascii bytes> is the ASCII equivalent of each byte, or '.' if
1638 * the byte is not printable.
1639 * So, for example, the extension value consisting of the following
1640 * bytes:
1641 * 0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,
1642 * 0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67
1643 * is output as:
1644 * 30 14 31 12 30 10 06 03 0.1.0...
1645 * 55 04 03 13 09 4a 75 61 U....Jua
1646 * 6e 20 4c 61 6e 67 n Lang
1647 * The allocation size therefore requires:
1648 * - 4 characters per character in an 8-byte line
1649 * (2 for the hex format, one for the space, one for the ASCII value)
1650 * - 3 more characters per 8-byte line (two spaces and a newline)
1651 * - 1 character for the terminating nul
1652 * FIXME: should use a fixed-width font for this
1653 */
1654 DWORD lines = (ext->Value.cbData + 7) / 8;
1655
1656 str = HeapAlloc(GetProcessHeap(), 0,
1657 (lines * 8 * 4 + lines * 3 + 1) * sizeof(WCHAR));
1658 if (str)
1659 {
1660 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1661 DWORD i, j;
1662 WCHAR *ptr;
1663
1664 for (i = 0, ptr = str; i < ext->Value.cbData; i += 8)
1665 {
1666 /* Output as hex bytes first */
1667 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr += 3)
1668 sprintfW(ptr, fmt, ext->Value.pbData[j]);
1669 /* Pad the hex output with spaces for alignment */
1670 if (j == ext->Value.cbData && j % 8)
1671 {
1672 static const WCHAR pad[] = { ' ',' ',' ' };
1673
1674 for (; j % 8; j++, ptr += sizeof(pad) / sizeof(pad[0]))
1675 memcpy(ptr, pad, sizeof(pad));
1676 }
1677 /* The last sprintfW included a space, so just insert one
1678 * more space between the hex bytes and the ASCII output
1679 */
1680 *ptr++ = ' ';
1681 /* Output as ASCII bytes */
1682 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr++)
1683 {
1684 if (isprintW(ext->Value.pbData[j]) &&
1685 !isspaceW(ext->Value.pbData[j]))
1686 *ptr = ext->Value.pbData[j];
1687 else
1688 *ptr = '.';
1689 }
1690 *ptr++ = '\n';
1691 }
1692 *ptr++ = '\0';
1693 }
1694 }
1695 return str;
1696 }
1697
1698 static WCHAR *field_format_detailed_extension(PCCERT_CONTEXT cert, void *param)
1699 {
1700 PCERT_EXTENSION ext = param;
1701 LPWSTR str = crypt_format_extension(ext,
1702 CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX);
1703
1704 if (!str)
1705 str = field_format_extension_hex_with_ascii(ext);
1706 return str;
1707 }
1708
1709 static void add_cert_extension_detail(HWND hwnd, struct detail_data *data,
1710 PCERT_EXTENSION ext)
1711 {
1712 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1713 ext->pszObjId, 0);
1714 LPWSTR val = crypt_format_extension(ext, 0);
1715
1716 if (oidInfo)
1717 add_field_and_value_to_list(hwnd, data, (LPWSTR)oidInfo->pwszName,
1718 val, field_format_detailed_extension, ext);
1719 else
1720 {
1721 DWORD len = strlen(ext->pszObjId);
1722 LPWSTR oidW = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1723
1724 if (oidW)
1725 {
1726 DWORD i;
1727
1728 for (i = 0; i <= len; i++)
1729 oidW[i] = ext->pszObjId[i];
1730 add_field_and_value_to_list(hwnd, data, oidW, val,
1731 field_format_detailed_extension, ext);
1732 HeapFree(GetProcessHeap(), 0, oidW);
1733 }
1734 }
1735 HeapFree(GetProcessHeap(), 0, val);
1736 }
1737
1738 static void add_all_extensions(HWND hwnd, struct detail_data *data)
1739 {
1740 DWORD i;
1741 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1742
1743 for (i = 0; i < cert->pCertInfo->cExtension; i++)
1744 add_cert_extension_detail(hwnd, data, &cert->pCertInfo->rgExtension[i]);
1745 }
1746
1747 static void add_critical_extensions(HWND hwnd, struct detail_data *data)
1748 {
1749 DWORD i;
1750 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1751
1752 for (i = 0; i < cert->pCertInfo->cExtension; i++)
1753 if (cert->pCertInfo->rgExtension[i].fCritical)
1754 add_cert_extension_detail(hwnd, data,
1755 &cert->pCertInfo->rgExtension[i]);
1756 }
1757
1758 typedef WCHAR * (*prop_to_value_func)(void *pb, DWORD cb);
1759
1760 struct prop_id_to_string_id
1761 {
1762 DWORD prop;
1763 int id;
1764 BOOL prop_is_string;
1765 prop_to_value_func prop_to_value;
1766 };
1767
1768 static WCHAR *format_enhanced_key_usage_value(void *pb, DWORD cb)
1769 {
1770 CERT_EXTENSION ext;
1771
1772 ext.pszObjId = (LPSTR)X509_ENHANCED_KEY_USAGE;
1773 ext.fCritical = FALSE;
1774 ext.Value.pbData = pb;
1775 ext.Value.cbData = cb;
1776 return crypt_format_extension(&ext, 0);
1777 }
1778
1779 /* Logically the access state should also be checked, and IDC_EDITPROPERTIES
1780 * disabled for read-only certificates, but native doesn't appear to do that.
1781 */
1782 static const struct prop_id_to_string_id prop_id_map[] = {
1783 { CERT_HASH_PROP_ID, IDS_PROP_HASH, FALSE, format_hex_string },
1784 { CERT_FRIENDLY_NAME_PROP_ID, IDS_PROP_FRIENDLY_NAME, TRUE, NULL },
1785 { CERT_DESCRIPTION_PROP_ID, IDS_PROP_DESCRIPTION, TRUE, NULL },
1786 { CERT_ENHKEY_USAGE_PROP_ID, IDS_PROP_ENHKEY_USAGE, FALSE,
1787 format_enhanced_key_usage_value },
1788 };
1789
1790 static void add_properties(HWND hwnd, struct detail_data *data)
1791 {
1792 DWORD i;
1793 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1794
1795 for (i = 0; i < sizeof(prop_id_map) / sizeof(prop_id_map[0]); i++)
1796 {
1797 DWORD cb;
1798
1799 if (CertGetCertificateContextProperty(cert, prop_id_map[i].prop, NULL,
1800 &cb))
1801 {
1802 BYTE *pb;
1803 WCHAR *val = NULL;
1804
1805 /* FIXME: MS adds a separate value for the signature hash
1806 * algorithm.
1807 */
1808 pb = HeapAlloc(GetProcessHeap(), 0, cb);
1809 if (pb)
1810 {
1811 if (CertGetCertificateContextProperty(cert,
1812 prop_id_map[i].prop, pb, &cb))
1813 {
1814 if (prop_id_map[i].prop_is_string)
1815 {
1816 val = (LPWSTR)pb;
1817 /* Don't double-free pb */
1818 pb = NULL;
1819 }
1820 else
1821 val = prop_id_map[i].prop_to_value(pb, cb);
1822 }
1823 HeapFree(GetProcessHeap(), 0, pb);
1824 }
1825 add_string_id_and_value_to_list(hwnd, data, prop_id_map[i].id, val,
1826 NULL, NULL);
1827 }
1828 }
1829 }
1830
1831 static void add_all_fields(HWND hwnd, struct detail_data *data)
1832 {
1833 add_v1_fields(hwnd, data);
1834 add_all_extensions(hwnd, data);
1835 add_properties(hwnd, data);
1836 }
1837
1838 struct selection_list_item
1839 {
1840 int id;
1841 add_fields_func add;
1842 };
1843
1844 const struct selection_list_item listItems[] = {
1845 { IDS_FIELDS_ALL, add_all_fields },
1846 { IDS_FIELDS_V1, add_v1_fields },
1847 { IDS_FIELDS_EXTENSIONS, add_all_extensions },
1848 { IDS_FIELDS_CRITICAL_EXTENSIONS, add_critical_extensions },
1849 { IDS_FIELDS_PROPERTIES, add_properties },
1850 };
1851
1852 static void create_show_list(HWND hwnd, struct detail_data *data)
1853 {
1854 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
1855 WCHAR buf[MAX_STRING_LEN];
1856 int i;
1857
1858 for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
1859 {
1860 int index;
1861
1862 LoadStringW(hInstance, listItems[i].id, buf,
1863 sizeof(buf) / sizeof(buf[0]));
1864 index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
1865 SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
1866 }
1867 SendMessageW(cb, CB_SETCURSEL, 0, 0);
1868 }
1869
1870 static void create_listview_columns(HWND hwnd)
1871 {
1872 HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1873 RECT rc;
1874 WCHAR buf[MAX_STRING_LEN];
1875 LVCOLUMNW column;
1876
1877 SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
1878 GetWindowRect(lv, &rc);
1879 LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
1880 column.mask = LVCF_WIDTH | LVCF_TEXT;
1881 column.cx = (rc.right - rc.left) / 2 - 2;
1882 column.pszText = buf;
1883 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
1884 LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
1885 SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
1886 }
1887
1888 static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
1889 {
1890 HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1891
1892 if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
1893 {
1894 SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
1895 listItems[sel].add(list, data);
1896 }
1897 }
1898
1899 static void create_cert_details_list(HWND hwnd, struct detail_data *data)
1900 {
1901 create_show_list(hwnd, data);
1902 create_listview_columns(hwnd);
1903 set_fields_selection(hwnd, data, 0);
1904 }
1905
1906 typedef enum {
1907 CheckBitmapIndexUnchecked = 1,
1908 CheckBitmapIndexChecked = 2,
1909 CheckBitmapIndexDisabledUnchecked = 3,
1910 CheckBitmapIndexDisabledChecked = 4
1911 } CheckBitmapIndex;
1912
1913 static void add_purpose(HWND hwnd, LPCSTR oid)
1914 {
1915 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1916 PCRYPT_OID_INFO info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1917 sizeof(CRYPT_OID_INFO));
1918
1919 if (info)
1920 {
1921 char *oidCopy = HeapAlloc(GetProcessHeap(), 0, strlen(oid) + 1);
1922
1923 if (oidCopy)
1924 {
1925 LVITEMA item;
1926
1927 strcpy(oidCopy, oid);
1928 info->cbSize = sizeof(CRYPT_OID_INFO);
1929 info->pszOID = oidCopy;
1930 item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
1931 item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexChecked);
1932 item.stateMask = LVIS_STATEIMAGEMASK;
1933 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
1934 item.iSubItem = 0;
1935 item.lParam = (LPARAM)info;
1936 item.pszText = oidCopy;
1937 SendMessageA(lv, LVM_INSERTITEMA, 0, (LPARAM)&item);
1938 }
1939 else
1940 HeapFree(GetProcessHeap(), 0, info);
1941 }
1942 }
1943
1944 static BOOL is_valid_oid(LPCSTR oid)
1945 {
1946 BOOL ret;
1947
1948 if (oid[0] != '0' && oid[0] != '1' && oid[0] != '2')
1949 ret = FALSE;
1950 else if (oid[1] != '.')
1951 ret = FALSE;
1952 else if (!oid[2])
1953 ret = FALSE;
1954 else
1955 {
1956 const char *ptr;
1957 BOOL expectNum = TRUE;
1958
1959 for (ptr = oid + 2, ret = TRUE; ret && *ptr; ptr++)
1960 {
1961 if (expectNum)
1962 {
1963 if (!isdigit(*ptr))
1964 ret = FALSE;
1965 else if (*(ptr + 1) == '.')
1966 expectNum = FALSE;
1967 }
1968 else
1969 {
1970 if (*ptr != '.')
1971 ret = FALSE;
1972 else if (!(*(ptr + 1)))
1973 ret = FALSE;
1974 else
1975 expectNum = TRUE;
1976 }
1977 }
1978 }
1979 return ret;
1980 }
1981
1982 static BOOL is_oid_in_list(HWND hwnd, LPCSTR oid)
1983 {
1984 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1985 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1986 (void *)oid, CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
1987 BOOL ret = FALSE;
1988
1989 if (oidInfo)
1990 {
1991 LVFINDINFOW findInfo;
1992
1993 findInfo.flags = LVFI_PARAM;
1994 findInfo.lParam = (LPARAM)oidInfo;
1995 if (SendMessageW(lv, LVM_FINDITEMW, -1, (LPARAM)&findInfo) != -1)
1996 ret = TRUE;
1997 }
1998 else
1999 {
2000 LVFINDINFOA findInfo;
2001
2002 findInfo.flags = LVFI_STRING;
2003 findInfo.psz = oid;
2004 if (SendMessageW(lv, LVM_FINDITEMA, -1, (LPARAM)&findInfo) != -1)
2005 ret = TRUE;
2006 }
2007 return ret;
2008 }
2009
2010 #define MAX_PURPOSE 255
2011
2012 static LRESULT CALLBACK add_purpose_dlg_proc(HWND hwnd, UINT msg,
2013 WPARAM wp, LPARAM lp)
2014 {
2015 LRESULT ret = 0;
2016 char buf[MAX_PURPOSE + 1];
2017
2018 switch (msg)
2019 {
2020 case WM_INITDIALOG:
2021 SendMessageW(GetDlgItem(hwnd, IDC_NEW_PURPOSE), EM_SETLIMITTEXT,
2022 MAX_PURPOSE, 0);
2023 ShowScrollBar(GetDlgItem(hwnd, IDC_NEW_PURPOSE), SB_VERT, FALSE);
2024 SetWindowLongPtrW(hwnd, DWLP_USER, lp);
2025 break;
2026 case WM_COMMAND:
2027 switch (HIWORD(wp))
2028 {
2029 case EN_CHANGE:
2030 if (LOWORD(wp) == IDC_NEW_PURPOSE)
2031 {
2032 /* Show/hide scroll bar on description depending on how much
2033 * text it has.
2034 */
2035 HWND description = GetDlgItem(hwnd, IDC_NEW_PURPOSE);
2036 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
2037
2038 ShowScrollBar(description, SB_VERT, lines > 1);
2039 }
2040 break;
2041 case BN_CLICKED:
2042 switch (LOWORD(wp))
2043 {
2044 case IDOK:
2045 SendMessageA(GetDlgItem(hwnd, IDC_NEW_PURPOSE), WM_GETTEXT,
2046 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2047 if (!buf[0])
2048 {
2049 /* An empty purpose is the same as cancelling */
2050 EndDialog(hwnd, IDCANCEL);
2051 ret = TRUE;
2052 }
2053 else if (!is_valid_oid(buf))
2054 {
2055 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
2056
2057 LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_ERROR, error,
2058 sizeof(error) / sizeof(error[0]));
2059 LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
2060 sizeof(title) / sizeof(title[0]));
2061 MessageBoxW(hwnd, error, title, MB_ICONERROR | MB_OK);
2062 }
2063 else if (is_oid_in_list(
2064 (HWND)GetWindowLongPtrW(hwnd, DWLP_USER), buf))
2065 {
2066 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
2067
2068 LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_EXISTS,
2069 error, sizeof(error) / sizeof(error[0]));
2070 LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
2071 sizeof(title) / sizeof(title[0]));
2072 MessageBoxW(hwnd, error, title, MB_ICONEXCLAMATION | MB_OK);
2073 }
2074 else
2075 {
2076 HWND parent = (HWND)GetWindowLongPtrW(hwnd, DWLP_USER);
2077
2078 add_purpose(parent, buf);
2079 EndDialog(hwnd, wp);
2080 ret = TRUE;
2081 }
2082 break;
2083 case IDCANCEL:
2084 EndDialog(hwnd, wp);
2085 ret = TRUE;
2086 break;
2087 }
2088 break;
2089 }
2090 break;
2091 }
2092 return ret;
2093 }
2094
2095 static WCHAR *get_cert_property_as_string(PCCERT_CONTEXT cert, DWORD prop)
2096 {
2097 WCHAR *name = NULL;
2098 DWORD cb;
2099
2100 if (CertGetCertificateContextProperty(cert, prop, NULL, &cb))
2101 {
2102 name = HeapAlloc(GetProcessHeap(), 0, cb);
2103 if (name)
2104 {
2105 if (!CertGetCertificateContextProperty(cert, prop, (LPBYTE)name,
2106 &cb))
2107 {
2108 HeapFree(GetProcessHeap(), 0, name);
2109 name = NULL;
2110 }
2111 }
2112 }
2113 return name;
2114 }
2115
2116 static void redraw_states(HWND list, BOOL enabled)
2117 {
2118 int items = SendMessageW(list, LVM_GETITEMCOUNT, 0, 0), i;
2119
2120 for (i = 0; i < items; i++)
2121 {
2122 BOOL change = FALSE;
2123 int state;
2124
2125 state = SendMessageW(list, LVM_GETITEMSTATE, i, LVIS_STATEIMAGEMASK);
2126 /* This reverses the INDEXTOSTATEIMAGEMASK shift. There doesn't appear
2127 * to be a handy macro for it.
2128 */
2129 state >>= 12;
2130 if (enabled)
2131 {
2132 if (state == CheckBitmapIndexDisabledChecked)
2133 {
2134 state = CheckBitmapIndexChecked;
2135 change = TRUE;
2136 }
2137 if (state == CheckBitmapIndexDisabledUnchecked)
2138 {
2139 state = CheckBitmapIndexUnchecked;
2140 change = TRUE;
2141 }
2142 }
2143 else
2144 {
2145 if (state == CheckBitmapIndexChecked)
2146 {
2147 state = CheckBitmapIndexDisabledChecked;
2148 change = TRUE;
2149 }
2150 if (state == CheckBitmapIndexUnchecked)
2151 {
2152 state = CheckBitmapIndexDisabledUnchecked;
2153 change = TRUE;
2154 }
2155 }
2156 if (change)
2157 {
2158 LVITEMW item;
2159
2160 item.state = INDEXTOSTATEIMAGEMASK(state);
2161 item.stateMask = LVIS_STATEIMAGEMASK;
2162 SendMessageW(list, LVM_SETITEMSTATE, i, (LPARAM)&item);
2163 }
2164 }
2165 }
2166
2167 typedef enum {
2168 PurposeEnableAll = 0,
2169 PurposeDisableAll,
2170 PurposeEnableSelected
2171 } PurposeSelection;
2172
2173 static void select_purposes(HWND hwnd, PurposeSelection selection)
2174 {
2175 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2176
2177 switch (selection)
2178 {
2179 case PurposeEnableAll:
2180 case PurposeDisableAll:
2181 EnableWindow(lv, FALSE);
2182 redraw_states(lv, FALSE);
2183 EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), FALSE);
2184 break;
2185 case PurposeEnableSelected:
2186 EnableWindow(lv, TRUE);
2187 redraw_states(lv, TRUE);
2188 EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), TRUE);
2189 }
2190 }
2191
2192 extern BOOL WINAPI WTHelperGetKnownUsages(DWORD action,
2193 PCCRYPT_OID_INFO **usages);
2194
2195 static void add_known_usage(HWND lv, PCCRYPT_OID_INFO info)
2196 {
2197 LVITEMW item;
2198
2199 item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
2200 item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexDisabledChecked);
2201 item.stateMask = LVIS_STATEIMAGEMASK;
2202 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
2203 item.iSubItem = 0;
2204 item.lParam = (LPARAM)info;
2205 item.pszText = (LPWSTR)info->pwszName;
2206 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
2207 }
2208
2209 struct edit_cert_data
2210 {
2211 PCCERT_CONTEXT cert;
2212 BOOL *pfPropertiesChanged;
2213 HIMAGELIST imageList;
2214 };
2215
2216 static void show_cert_usages(HWND hwnd, struct edit_cert_data *data)
2217 {
2218 PCCERT_CONTEXT cert = data->cert;
2219 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2220 PCERT_ENHKEY_USAGE usage;
2221 DWORD size;
2222 PCCRYPT_OID_INFO *usages;
2223 RECT rc;
2224 LVCOLUMNW column;
2225 PurposeSelection purposeSelection;
2226
2227 GetWindowRect(lv, &rc);
2228 column.mask = LVCF_WIDTH;
2229 column.cx = rc.right - rc.left;
2230 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
2231 SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)data->imageList);
2232
2233 /* Get enhanced key usage. Have to check for a property and an extension
2234 * separately, because CertGetEnhancedKeyUsage will succeed and return an
2235 * empty usage if neither is set. Unfortunately an empty usage implies
2236 * no usage is allowed, so we have to distinguish between the two cases.
2237 */
2238 if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
2239 NULL, &size))
2240 {
2241 usage = HeapAlloc(GetProcessHeap(), 0, size);
2242 if (!CertGetEnhancedKeyUsage(cert,
2243 CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
2244 {
2245 HeapFree(GetProcessHeap(), 0, usage);
2246 usage = NULL;
2247 }
2248 else if (usage->cUsageIdentifier)
2249 purposeSelection = PurposeEnableSelected;
2250 else
2251 purposeSelection = PurposeDisableAll;
2252 }
2253 else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
2254 NULL, &size))
2255 {
2256 usage = HeapAlloc(GetProcessHeap(), 0, size);
2257 if (!CertGetEnhancedKeyUsage(cert,
2258 CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
2259 {
2260 HeapFree(GetProcessHeap(), 0, usage);
2261 usage = NULL;
2262 }
2263 else if (usage->cUsageIdentifier)
2264 purposeSelection = PurposeEnableAll;
2265 else
2266 purposeSelection = PurposeDisableAll;
2267 }
2268 else
2269 {
2270 purposeSelection = PurposeEnableAll;
2271 usage = NULL;
2272 }
2273 if (usage)
2274 {
2275 DWORD i;
2276
2277 for (i = 0; i < usage->cUsageIdentifier; i++)
2278 {
2279 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
2280 usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
2281
2282 if (info)
2283 add_known_usage(lv, info);
2284 else
2285 add_purpose(hwnd, usage->rgpszUsageIdentifier[i]);
2286 }
2287 HeapFree(GetProcessHeap(), 0, usage);
2288 }
2289 else
2290 {
2291 if (WTHelperGetKnownUsages(1, &usages))
2292 {
2293 PCCRYPT_OID_INFO *ptr;
2294
2295 for (ptr = usages; *ptr; ptr++)
2296 add_known_usage(lv, *ptr);
2297 WTHelperGetKnownUsages(2, &usages);
2298 }
2299 }
2300 select_purposes(hwnd, purposeSelection);
2301 SendMessageW(GetDlgItem(hwnd, IDC_ENABLE_ALL_PURPOSES + purposeSelection),
2302 BM_CLICK, 0, 0);
2303 }
2304
2305 static void set_general_cert_properties(HWND hwnd, struct edit_cert_data *data)
2306 {
2307 PCCERT_CONTEXT cert = data->cert;
2308 WCHAR *str;
2309
2310 if ((str = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID)))
2311 {
2312 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_SETTEXT, 0,
2313 (LPARAM)str);
2314 HeapFree(GetProcessHeap(), 0, str);
2315 }
2316 if ((str = get_cert_property_as_string(cert, CERT_DESCRIPTION_PROP_ID)))
2317 {
2318 SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_SETTEXT, 0,
2319 (LPARAM)str);
2320 HeapFree(GetProcessHeap(), 0, str);
2321 }
2322 show_cert_usages(hwnd, data);
2323 }
2324
2325 static void toggle_usage(HWND hwnd, int iItem)
2326 {
2327 LVITEMW item;
2328 int res;
2329 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2330
2331 item.mask = LVIF_STATE;
2332 item.iItem = iItem;
2333 item.iSubItem = 0;
2334 item.stateMask = LVIS_STATEIMAGEMASK;
2335 res = SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
2336 if (res)
2337 {
2338 int state = item.state >> 12;
2339
2340 item.state = INDEXTOSTATEIMAGEMASK(
2341 state == CheckBitmapIndexChecked ? CheckBitmapIndexUnchecked :
2342 CheckBitmapIndexChecked);
2343 SendMessageW(lv, LVM_SETITEMSTATE, iItem, (LPARAM)&item);
2344 }
2345 }
2346
2347 static void set_cert_string_property(PCCERT_CONTEXT cert, DWORD prop,
2348 LPWSTR str)
2349 {
2350 if (str && strlenW(str))
2351 {
2352 CRYPT_DATA_BLOB blob;
2353
2354 blob.pbData = (BYTE *)str;
2355 blob.cbData = (strlenW(str) + 1) * sizeof(WCHAR);
2356 CertSetCertificateContextProperty(cert, prop, 0, &blob);
2357 }
2358 else
2359 CertSetCertificateContextProperty(cert, prop, 0, NULL);
2360 }
2361
2362 #define WM_REFRESH_VIEW WM_USER + 0
2363
2364 static BOOL CALLBACK refresh_propsheet_pages(HWND hwnd, LPARAM lParam)
2365 {
2366 if ((GetClassLongW(hwnd, GCW_ATOM) == WC_DIALOG))
2367 SendMessageW(hwnd, WM_REFRESH_VIEW, 0, 0);
2368 return TRUE;
2369 }
2370
2371 #define MAX_FRIENDLY_NAME 40
2372 #define MAX_DESCRIPTION 255
2373
2374 static void apply_general_changes(HWND hwnd)
2375 {
2376 WCHAR buf[MAX_DESCRIPTION + 1];
2377 struct edit_cert_data *data =
2378 (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
2379
2380 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_GETTEXT,
2381 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2382 set_cert_string_property(data->cert, CERT_FRIENDLY_NAME_PROP_ID, buf);
2383 SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_GETTEXT,
2384 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2385 set_cert_string_property(data->cert, CERT_DESCRIPTION_PROP_ID, buf);
2386 if (IsDlgButtonChecked(hwnd, IDC_ENABLE_ALL_PURPOSES))
2387 {
2388 /* Setting a NULL usage removes the enhanced key usage property. */
2389 CertSetEnhancedKeyUsage(data->cert, NULL);
2390 }
2391 else if (IsDlgButtonChecked(hwnd, IDC_DISABLE_ALL_PURPOSES))
2392 {
2393 CERT_ENHKEY_USAGE usage = { 0, NULL };
2394
2395 CertSetEnhancedKeyUsage(data->cert, &usage);
2396 }
2397 else if (IsDlgButtonChecked(hwnd, IDC_ENABLE_SELECTED_PURPOSES))
2398 {
2399 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2400 CERT_ENHKEY_USAGE usage = { 0, NULL };
2401 int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
2402 LVITEMW item;
2403
2404 item.mask = LVIF_STATE | LVIF_PARAM;
2405 item.iSubItem = 0;
2406 item.stateMask = LVIS_STATEIMAGEMASK;
2407 for (i = 0; i < purposes; i++)
2408 {
2409 item.iItem = i;
2410 if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
2411 {
2412 int state = item.state >> 12;
2413
2414 if (state == CheckBitmapIndexChecked)
2415 {
2416 CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
2417
2418 if (usage.cUsageIdentifier)
2419 usage.rgpszUsageIdentifier =
2420 HeapReAlloc(GetProcessHeap(), 0,
2421 usage.rgpszUsageIdentifier,
2422 (usage.cUsageIdentifier + 1) * sizeof(LPSTR));
2423 else
2424 usage.rgpszUsageIdentifier =
2425 HeapAlloc(GetProcessHeap(), 0, sizeof(LPSTR));
2426 if (usage.rgpszUsageIdentifier)
2427 usage.rgpszUsageIdentifier[usage.cUsageIdentifier++] =
2428 (LPSTR)info->pszOID;
2429 }
2430 }
2431 }
2432 CertSetEnhancedKeyUsage(data->cert, &usage);
2433 HeapFree(GetProcessHeap(), 0, usage.rgpszUsageIdentifier);
2434 }
2435 EnumChildWindows(GetParent(GetParent(hwnd)), refresh_propsheet_pages, 0);
2436 if (data->pfPropertiesChanged)
2437 *data->pfPropertiesChanged = TRUE;
2438 }
2439
2440 static LRESULT CALLBACK cert_properties_general_dlg_proc(HWND hwnd, UINT msg,
2441 WPARAM wp, LPARAM lp)
2442 {
2443 PROPSHEETPAGEW *page;
2444
2445 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2446
2447 switch (msg)
2448 {
2449 case WM_INITDIALOG:
2450 {
2451 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
2452 struct detail_data *detailData;
2453 struct edit_cert_data *editData;
2454
2455 page = (PROPSHEETPAGEW *)lp;
2456 detailData = (struct detail_data *)page->lParam;
2457 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), EM_SETLIMITTEXT,
2458 MAX_FRIENDLY_NAME, 0);
2459 SendMessageW(description, EM_SETLIMITTEXT, MAX_DESCRIPTION, 0);
2460 ShowScrollBar(description, SB_VERT, FALSE);
2461 editData = HeapAlloc(GetProcessHeap(), 0,
2462 sizeof(struct edit_cert_data));
2463 if (editData)
2464 {
2465 editData->imageList = ImageList_Create(16, 16,
2466 ILC_COLOR4 | ILC_MASK, 4, 0);
2467 if (editData->imageList)
2468 {
2469 HBITMAP bmp;
2470 COLORREF backColor = RGB(255, 0, 255);
2471
2472 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
2473 ImageList_AddMasked(editData->imageList, bmp, backColor);
2474 DeleteObject(bmp);
2475 ImageList_SetBkColor(editData->imageList, CLR_NONE);
2476 }
2477 editData->cert = detailData->pCertViewInfo->pCertContext;
2478 editData->pfPropertiesChanged = detailData->pfPropertiesChanged;
2479 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)editData);
2480 set_general_cert_properties(hwnd, editData);
2481 }
2482 break;
2483 }
2484 case WM_NOTIFY:
2485 {
2486 NMHDR *hdr = (NMHDR *)lp;
2487 NMITEMACTIVATE *nm;
2488
2489 switch (hdr->code)
2490 {
2491 case NM_CLICK:
2492 nm = (NMITEMACTIVATE *)lp;
2493 toggle_usage(hwnd, nm->iItem);
2494 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2495 break;
2496 case PSN_APPLY:
2497 apply_general_changes(hwnd);
2498 break;
2499 }
2500 break;
2501 }
2502 case WM_COMMAND:
2503 switch (HIWORD(wp))
2504 {
2505 case EN_CHANGE:
2506 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2507 if (LOWORD(wp) == IDC_DESCRIPTION)
2508 {
2509 /* Show/hide scroll bar on description depending on how much
2510 * text it has.
2511 */
2512 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
2513 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
2514
2515 ShowScrollBar(description, SB_VERT, lines > 1);
2516 }
2517 break;
2518 case BN_CLICKED:
2519 switch (LOWORD(wp))
2520 {
2521 case IDC_ADD_PURPOSE:
2522 if (DialogBoxParamW(hInstance,
2523 MAKEINTRESOURCEW(IDD_ADD_CERT_PURPOSE), hwnd,
2524 add_purpose_dlg_proc, (LPARAM)hwnd) == IDOK)
2525 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2526 break;
2527 case IDC_ENABLE_ALL_PURPOSES:
2528 case IDC_DISABLE_ALL_PURPOSES:
2529 case IDC_ENABLE_SELECTED_PURPOSES:
2530 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2531 select_purposes(hwnd, LOWORD(wp) - IDC_ENABLE_ALL_PURPOSES);
2532 break;
2533 }
2534 break;
2535 }
2536 break;
2537 }
2538 return 0;
2539 }
2540
2541 static UINT CALLBACK cert_properties_general_callback(HWND hwnd, UINT msg,
2542 PROPSHEETPAGEW *page)
2543 {
2544 HWND lv;
2545 int cItem, i;
2546 struct edit_cert_data *data;
2547
2548 switch (msg)
2549 {
2550 case PSPCB_RELEASE:
2551 lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2552 cItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
2553 for (i = 0; i < cItem; i++)
2554 {
2555 LVITEMW item;
2556
2557 item.mask = LVIF_PARAM;
2558 item.iItem = i;
2559 item.iSubItem = 0;
2560 if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item) && item.lParam)
2561 {
2562 PCRYPT_OID_INFO info = (PCRYPT_OID_INFO)item.lParam;
2563
2564 if (info->cbSize == sizeof(CRYPT_OID_INFO) && !info->dwGroupId)
2565 {
2566 HeapFree(GetProcessHeap(), 0, (LPSTR)info->pszOID);
2567 HeapFree(GetProcessHeap(), 0, info);
2568 }
2569 }
2570 }
2571 data = (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
2572 if (data)
2573 {
2574 ImageList_Destroy(data->imageList);
2575 HeapFree(GetProcessHeap(), 0, data);
2576 }
2577 break;
2578 }
2579 return 1;
2580 }
2581
2582 static void show_edit_cert_properties_dialog(HWND parent,
2583 struct detail_data *data)
2584 {
2585 PROPSHEETHEADERW hdr;
2586 PROPSHEETPAGEW page; /* FIXME: need to add a cross-certificate page */
2587
2588 TRACE("(%p)\n", data);
2589
2590 memset(&page, 0, sizeof(PROPSHEETPAGEW));
2591 page.dwSize = sizeof(page);
2592 page.dwFlags = PSP_USECALLBACK;
2593 page.pfnCallback = cert_properties_general_callback;
2594 page.hInstance = hInstance;
2595 page.u.pszTemplate = MAKEINTRESOURCEW(IDD_CERT_PROPERTIES_GENERAL);
2596 page.pfnDlgProc = cert_properties_general_dlg_proc;
2597 page.lParam = (LPARAM)data;
2598
2599 memset(&hdr, 0, sizeof(hdr));
2600 hdr.dwSize = sizeof(hdr);
2601 hdr.hwndParent = parent;
2602 hdr.dwFlags = PSH_PROPSHEETPAGE;
2603 hdr.hInstance = hInstance;
2604 hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE_PROPERTIES);
2605 hdr.u3.ppsp = &page;
2606 hdr.nPages = 1;
2607 PropertySheetW(&hdr);
2608 }
2609
2610 static void free_detail_fields(struct detail_data *data)
2611 {
2612 DWORD i;
2613
2614 for (i = 0; i < data->cFields; i++)
2615 HeapFree(GetProcessHeap(), 0, data->fields[i].detailed_value);
2616 HeapFree(GetProcessHeap(), 0, data->fields);
2617 data->fields = NULL;
2618 data->cFields = 0;
2619 }
2620
2621 static void refresh_details_view(HWND hwnd)
2622 {
2623 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2624 int curSel;
2625 struct detail_data *data;
2626
2627 curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
2628 /* Actually, any index will do, since they all store the same data value */
2629 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
2630 free_detail_fields(data);
2631 set_fields_selection(hwnd, data, curSel);
2632 }
2633
2634 static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2635 LPARAM lp)
2636 {
2637 PROPSHEETPAGEW *page;
2638 struct detail_data *data;
2639
2640 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2641
2642 switch (msg)
2643 {
2644 case WM_INITDIALOG:
2645 page = (PROPSHEETPAGEW *)lp;
2646 data = (struct detail_data *)page->lParam;
2647 create_cert_details_list(hwnd, data);
2648 if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
2649 EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
2650 if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
2651 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
2652 break;
2653 case WM_NOTIFY:
2654 {
2655 NMITEMACTIVATE *nm;
2656 HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
2657
2658 nm = (NMITEMACTIVATE*)lp;
2659 if (nm->hdr.hwndFrom == list && nm->uNewState & LVN_ITEMACTIVATE
2660 && nm->hdr.code == LVN_ITEMCHANGED)
2661 {
2662 data = (struct detail_data *)nm->lParam;
2663 if (nm->iItem >= 0 && data && nm->iItem < data->cFields)
2664 {
2665 WCHAR buf[MAX_STRING_LEN], *val = NULL;
2666 HWND valueCtl = GetDlgItem(hwnd, IDC_DETAIL_VALUE);
2667
2668 if (data->fields[nm->iItem].create)
2669 val = data->fields[nm->iItem].create(
2670 data->pCertViewInfo->pCertContext,
2671 data->fields[nm->iItem].param);
2672 else
2673 {
2674 LVITEMW item;
2675 int res;
2676
2677 item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
2678 item.mask = LVIF_TEXT;
2679 item.pszText = buf;
2680 item.iItem = nm->iItem;
2681 item.iSubItem = 1;
2682 res = SendMessageW(list, LVM_GETITEMW, 0, (LPARAM)&item);
2683 if (res)
2684 val = buf;
2685 }
2686 /* Select all the text in the control, the next update will
2687 * replace it
2688 */
2689 SendMessageW(valueCtl, EM_SETSEL, 0, -1);
2690 add_unformatted_text_to_control(valueCtl, val,
2691 val ? strlenW(val) : 0);
2692 if (val != buf)
2693 HeapFree(GetProcessHeap(), 0, val);
2694 }
2695 }
2696 break;
2697 }
2698 case WM_COMMAND:
2699 switch (wp)
2700 {
2701 case IDC_EXPORT:
2702 FIXME("call CryptUIWizExport\n");
2703 break;
2704 case IDC_EDITPROPERTIES:
2705 {
2706 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2707 int curSel;
2708
2709 curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
2710 /* Actually, any index will do, since they all store the same
2711 * data value
2712 */
2713 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA,
2714 curSel, 0);
2715 show_edit_cert_properties_dialog(GetParent(hwnd), data);
2716 break;
2717 }
2718 case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
2719 refresh_details_view(hwnd);
2720 break;
2721 }
2722 break;
2723 case WM_REFRESH_VIEW:
2724 refresh_details_view(hwnd);
2725 break;
2726 }
2727 return 0;
2728 }
2729
2730 static UINT CALLBACK detail_callback(HWND hwnd, UINT msg,
2731 PROPSHEETPAGEW *page)
2732 {
2733 struct detail_data *data;
2734
2735 switch (msg)
2736 {
2737 case PSPCB_RELEASE:
2738 data = (struct detail_data *)page->lParam;
2739 free_detail_fields(data);
2740 HeapFree(GetProcessHeap(), 0, data);
2741 break;
2742 }
2743 return 0;
2744 }
2745
2746 static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2747 BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
2748 {
2749 BOOL ret;
2750 struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
2751 sizeof(struct detail_data));
2752
2753 if (data)
2754 {
2755 data->pCertViewInfo = pCertViewInfo;
2756 data->pfPropertiesChanged = pfPropertiesChanged;
2757 data->cFields = 0;
2758 data->fields = NULL;
2759 memset(page, 0, sizeof(PROPSHEETPAGEW));
2760 page->dwSize = sizeof(PROPSHEETPAGEW);
2761 page->dwFlags = PSP_USECALLBACK;
2762 page->pfnCallback = detail_callback;
2763 page->hInstance = hInstance;
2764 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
2765 page->pfnDlgProc = detail_dlg_proc;
2766 page->lParam = (LPARAM)data;
2767 ret = TRUE;
2768 }
2769 else
2770 ret = FALSE;
2771 return ret;
2772 }
2773
2774 struct hierarchy_data
2775 {
2776 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
2777 HIMAGELIST imageList;
2778 DWORD selectedCert;
2779 };
2780
2781 static LPARAM index_to_lparam(struct hierarchy_data *data, DWORD index)
2782 {
2783 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2784 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2785 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2786 data->pCertViewInfo->idxCounterSigner);
2787
2788 /* Takes advantage of the fact that a pointer is 32-bit aligned, and
2789 * therefore always even.
2790 */
2791 if (index == provSigner->csCertChain - 1)
2792 return (LPARAM)data;
2793 return index << 1 | 1;
2794 }
2795
2796 static inline DWORD lparam_to_index(struct hierarchy_data *data, LPARAM lp)
2797 {
2798 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2799 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2800 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2801 data->pCertViewInfo->idxCounterSigner);
2802
2803 if (!(lp & 1))
2804 return provSigner->csCertChain - 1;
2805 return lp >> 1;
2806 }
2807
2808 static struct hierarchy_data *get_hierarchy_data_from_tree_item(HWND tree,
2809 HTREEITEM hItem)
2810 {
2811 struct hierarchy_data *data = NULL;
2812 HTREEITEM root = NULL;
2813
2814 do {
2815 HTREEITEM parent = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM,
2816 TVGN_PARENT, (LPARAM)hItem);
2817
2818 if (!parent)
2819 root = hItem;
2820 hItem = parent;
2821 } while (hItem);
2822 if (root)
2823 {
2824 TVITEMW item;
2825
2826 item.mask = TVIF_PARAM;
2827 item.hItem = root;
2828 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
2829 data = (struct hierarchy_data *)item.lParam;
2830 }
2831 return data;
2832 }
2833
2834 static WCHAR *get_cert_display_name(PCCERT_CONTEXT cert)
2835 {
2836 WCHAR *name = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID);
2837
2838 if (!name)
2839 name = get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
2840 return name;
2841 }
2842
2843 static void show_cert_chain(HWND hwnd, struct hierarchy_data *data)
2844 {
2845 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2846 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2847 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2848 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2849 data->pCertViewInfo->idxCounterSigner);
2850 DWORD i;
2851 HTREEITEM parent = NULL;
2852
2853 SendMessageW(tree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)data->imageList);
2854 for (i = provSigner->csCertChain; i; i--)
2855 {
2856 LPWSTR name;
2857
2858 name = get_cert_display_name(provSigner->pasCertChain[i - 1].pCert);
2859 if (name)
2860 {
2861 TVINSERTSTRUCTW tvis;
2862
2863 tvis.hParent = parent;
2864 tvis.hInsertAfter = TVI_LAST;
2865 tvis.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE |
2866 TVIF_SELECTEDIMAGE | TVIF_PARAM;
2867 tvis.u.item.pszText = name;
2868 tvis.u.item.state = TVIS_EXPANDED;
2869 tvis.u.item.stateMask = TVIS_EXPANDED;
2870 if (i == 1 &&
2871 (provSigner->pChainContext->TrustStatus.dwErrorStatus &
2872 CERT_TRUST_IS_PARTIAL_CHAIN))
2873 {
2874 /* The root of the chain has a special case: if the chain is
2875 * a partial chain, the icon is a warning icon rather than an
2876 * error icon.
2877 */
2878 tvis.u.item.iImage = 2;
2879 }
2880 else if (provSigner->pasCertChain[i - 1].pChainElement->TrustStatus.
2881 dwErrorStatus == 0)
2882 tvis.u.item.iImage = 0;
2883 else
2884 tvis.u.item.iImage = 1;
2885 tvis.u.item.iSelectedImage = tvis.u.item.iImage;
2886 tvis.u.item.lParam = index_to_lparam(data, i - 1);
2887 parent = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0,
2888 (LPARAM)&tvis);
2889 HeapFree(GetProcessHeap(), 0, name);
2890 }
2891 }
2892 }
2893
2894 static void set_certificate_status(HWND hwnd, CRYPT_PROVIDER_CERT *cert)
2895 {
2896 /* Select all the text in the control, the next update will replace it */
2897 SendMessageW(hwnd, EM_SETSEL, 0, -1);
2898 /* Set the highest priority error messages first. */
2899 if (!(cert->dwConfidence & CERT_CONFIDENCE_SIG))
2900 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_SIGNATURE);
2901 else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIME))
2902 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIME);
2903 else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIMENEST))
2904 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIMENEST);
2905 else if (cert->dwRevokedReason)
2906 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_REVOKED);
2907 else
2908 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_VALID);
2909 }
2910
2911 static void set_certificate_status_for_end_cert(HWND hwnd,
2912 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2913 {
2914 HWND status = GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT);
2915 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2916 (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
2917 pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
2918 pCertViewInfo->idxCounterSigner);
2919 CRYPT_PROVIDER_CERT *provCert = WTHelperGetProvCertFromChain(provSigner,
2920 pCertViewInfo->idxCert);
2921
2922 set_certificate_status(status, provCert);
2923 }
2924
2925 static void show_cert_hierarchy(HWND hwnd, struct hierarchy_data *data)
2926 {
2927 /* Disable view certificate button until a certificate is selected */
2928 EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), FALSE);
2929 show_cert_chain(hwnd, data);
2930 set_certificate_status_for_end_cert(hwnd, data->pCertViewInfo);
2931 }
2932
2933 static void show_dialog_for_selected_cert(HWND hwnd)
2934 {
2935 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2936 TVITEMW item;
2937 struct hierarchy_data *data;
2938 DWORD selection;
2939
2940 memset(&item, 0, sizeof(item));
2941 item.mask = TVIF_HANDLE | TVIF_PARAM;
2942 item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CARET,
2943 (LPARAM)NULL);
2944 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
2945 data = get_hierarchy_data_from_tree_item(tree, item.hItem);
2946 selection = lparam_to_index(data, item.lParam);
2947 if (selection != 0)
2948 {
2949 CRYPT_PROVIDER_SGNR *provSigner;
2950 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
2951 BOOL changed = FALSE;
2952
2953 provSigner = WTHelperGetProvSignerFromChain(
2954 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2955 data->pCertViewInfo->idxSigner,
2956 data->pCertViewInfo->fCounterSigner,
2957 data->pCertViewInfo->idxCounterSigner);
2958 memset(&viewInfo, 0, sizeof(viewInfo));
2959 viewInfo.dwSize = sizeof(viewInfo);
2960 viewInfo.dwFlags = data->pCertViewInfo->dwFlags;
2961 viewInfo.szTitle = data->pCertViewInfo->szTitle;
2962 viewInfo.pCertContext = provSigner->pasCertChain[selection].pCert;
2963 viewInfo.cStores = data->pCertViewInfo->cStores;
2964 viewInfo.rghStores = data->pCertViewInfo->rghStores;
2965 viewInfo.cPropSheetPages = data->pCertViewInfo->cPropSheetPages;
2966 viewInfo.rgPropSheetPages = data->pCertViewInfo->rgPropSheetPages;
2967 viewInfo.nStartPage = data->pCertViewInfo->nStartPage;
2968 CryptUIDlgViewCertificateW(&viewInfo, &changed);
2969 if (changed)
2970 {
2971 /* Delete the contents of the tree */
2972 SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
2973 /* Reinitialize the tree */
2974 show_cert_hierarchy(hwnd, data);
2975 }
2976 }
2977 }
2978
2979 static LRESULT CALLBACK hierarchy_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2980 LPARAM lp)
2981 {
2982 PROPSHEETPAGEW *page;
2983 struct hierarchy_data *data;
2984 LRESULT ret = 0;
2985 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2986
2987 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2988
2989 switch (msg)
2990 {
2991 case WM_INITDIALOG:
2992 page = (PROPSHEETPAGEW *)lp;
2993 data = (struct hierarchy_data *)page->lParam;
2994 show_cert_hierarchy(hwnd, data);
2995 break;
2996 case WM_NOTIFY:
2997 {
2998 NMHDR *hdr;
2999
3000 hdr = (NMHDR *)lp;
3001 switch (hdr->code)
3002 {
3003 case TVN_SELCHANGEDW:
3004 {
3005 NMTREEVIEWW *nm = (NMTREEVIEWW*)lp;
3006 DWORD selection;
3007 CRYPT_PROVIDER_SGNR *provSigner;
3008
3009 data = get_hierarchy_data_from_tree_item(tree, nm->itemNew.hItem);
3010 selection = lparam_to_index(data, nm->itemNew.lParam);
3011 provSigner = WTHelperGetProvSignerFromChain(
3012 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
3013 data->pCertViewInfo->idxSigner,
3014 data->pCertViewInfo->fCounterSigner,
3015 data->pCertViewInfo->idxCounterSigner);
3016 EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), selection != 0);
3017 set_certificate_status(GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT),
3018 &provSigner->pasCertChain[selection]);
3019 break;
3020 }
3021 case NM_DBLCLK:
3022 show_dialog_for_selected_cert(hwnd);
3023 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
3024 ret = 1;
3025 break;
3026 }
3027 break;
3028 }
3029 case WM_COMMAND:
3030 switch (wp)
3031 {
3032 case IDC_VIEWCERTIFICATE:
3033 show_dialog_for_selected_cert(hwnd);
3034 break;
3035 }
3036 break;
3037 case WM_REFRESH_VIEW:
3038 {
3039 TVITEMW item;
3040
3041 /* Get hierarchy data */
3042 memset(&item, 0, sizeof(item));
3043 item.mask = TVIF_HANDLE | TVIF_PARAM;
3044 item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_ROOT,
3045 (LPARAM)NULL);
3046 data = get_hierarchy_data_from_tree_item(tree, item.hItem);
3047 /* Delete the contents of the tree */
3048 SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
3049 /* Reinitialize the tree */
3050 show_cert_hierarchy(hwnd, data);
3051 break;
3052 }
3053 }
3054 return ret;
3055 }
3056
3057 static UINT CALLBACK hierarchy_callback(HWND hwnd, UINT msg,
3058 PROPSHEETPAGEW *page)
3059 {
3060 struct hierarchy_data *data;
3061
3062 switch (msg)
3063 {
3064 case PSPCB_RELEASE:
3065 data = (struct hierarchy_data *)page->lParam;
3066 ImageList_Destroy(data->imageList);
3067 HeapFree(GetProcessHeap(), 0, data);
3068 break;
3069 }
3070 return 0;
3071 }
3072
3073 static BOOL init_hierarchy_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
3074 PROPSHEETPAGEW *page)
3075 {
3076 struct hierarchy_data *data = HeapAlloc(GetProcessHeap(), 0,
3077 sizeof(struct hierarchy_data));
3078 BOOL ret = FALSE;
3079
3080 if (data)
3081 {
3082 data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
3083 if (data->imageList)
3084 {
3085 HBITMAP bmp;
3086 COLORREF backColor = RGB(255, 0, 255);
3087
3088 data->pCertViewInfo = pCertViewInfo;
3089 data->selectedCert = 0xffffffff;
3090
3091 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
3092 ImageList_AddMasked(data->imageList, bmp, backColor);
3093 DeleteObject(bmp);
3094 ImageList_SetBkColor(data->imageList, CLR_NONE);
3095
3096 memset(page, 0, sizeof(PROPSHEETPAGEW));
3097 page->dwSize = sizeof(PROPSHEETPAGEW);
3098 page->dwFlags = PSP_USECALLBACK;
3099 page->hInstance = hInstance;
3100 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_HIERARCHY);
3101 page->pfnDlgProc = hierarchy_dlg_proc;
3102 page->lParam = (LPARAM)data;
3103 page->pfnCallback = hierarchy_callback;
3104 ret = TRUE;
3105 }
3106 else
3107 HeapFree(GetProcessHeap(), 0, data);
3108 }
3109 return ret;
3110 }
3111
3112 static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
3113 {
3114 RECT rc;
3115 POINT topLeft;
3116
3117 TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
3118
3119 switch (msg)
3120 {
3121 case PSCB_INITIALIZED:
3122 /* Get cancel button's position.. */
3123 GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
3124 topLeft.x = rc.left;
3125 topLeft.y = rc.top;
3126 ScreenToClient(hwnd, &topLeft);
3127 /* hide the cancel button.. */
3128 ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
3129 /* get the OK button's size.. */
3130 GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
3131 /* and move the OK button to the cancel button's original position. */
3132 MoveWindow(GetDlgItem(hwnd, IDOK), topLeft.x, topLeft.y,
3133 rc.right - rc.left, rc.bottom - rc.top, FALSE);
3134 GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
3135 break;
3136 }
3137 return 0;
3138 }
3139
3140 static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
3141 CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
3142 {
3143 static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
3144 DWORD nPages;
3145 PROPSHEETPAGEW *pages;
3146 BOOL ret = FALSE;
3147 HMODULE lib = LoadLibraryW(riched);
3148
3149 nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
3150 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
3151 nPages++;
3152 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
3153 nPages++;
3154 pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
3155 if (pages)
3156 {
3157 PROPSHEETHEADERW hdr;
3158 CRYPTUI_INITDIALOG_STRUCT *init = NULL;
3159 DWORD i;
3160
3161 memset(&hdr, 0, sizeof(hdr));
3162 hdr.dwSize = sizeof(hdr);
3163 hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
3164 hdr.hInstance = hInstance;
3165 if (pCertViewInfo->szTitle)
3166 hdr.pszCaption = pCertViewInfo->szTitle;
3167 else
3168 hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
3169 init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
3170 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
3171 {
3172 if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
3173 &pages[hdr.nPages]))
3174 hdr.nPages++;
3175 }
3176 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
3177 {
3178 if (init_hierarchy_page(pCertViewInfo, &pages[hdr.nPages]))
3179 hdr.nPages++;
3180 }
3181 /* Copy each additional page, and create the init dialog struct for it
3182 */
3183 if (pCertViewInfo->cPropSheetPages)
3184 {
3185 init = HeapAlloc(GetProcessHeap(), 0,
3186 pCertViewInfo->cPropSheetPages *
3187 sizeof(CRYPTUI_INITDIALOG_STRUCT));
3188 if (init)
3189 {
3190 for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
3191 {
3192 memcpy(&pages[hdr.nPages + i],
3193 &pCertViewInfo->rgPropSheetPages[i],
3194 sizeof(PROPSHEETPAGEW));
3195 init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
3196 init[i].pCertContext = pCertViewInfo->pCertContext;
3197 pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
3198 }
3199 if (pCertViewInfo->nStartPage & 0x8000)
3200 {
3201 /* Start page index is relative to the number of default
3202 * pages
3203 */
3204 hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
3205 }
3206 else
3207 hdr.u2.nStartPage = pCertViewInfo->nStartPage;
3208 hdr.nPages = nPages;
3209 ret = TRUE;
3210 }
3211 else
3212 SetLastError(ERROR_OUTOFMEMORY);
3213 }
3214 else
3215 {
3216 /* Ignore the relative flag if there aren't any additional pages */
3217 hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
3218 ret = TRUE;
3219 }
3220 if (ret)
3221 {
3222 INT_PTR l;
3223
3224 hdr.u3.ppsp = pages;
3225 hdr.pfnCallback = cert_prop_sheet_proc;
3226 l = PropertySheetW(&hdr);
3227 if (l == 0)
3228 {
3229 SetLastError(ERROR_CANCELLED);
3230 ret = FALSE;
3231 }
3232 }
3233 HeapFree(GetProcessHeap(), 0, init);
3234 HeapFree(GetProcessHeap(), 0, pages);
3235 }
3236 else
3237 SetLastError(ERROR_OUTOFMEMORY);
3238 FreeLibrary(lib);
3239 return ret;
3240 }
3241
3242 /***********************************************************************
3243 * CryptUIDlgViewCertificateW (CRYPTUI.@)
3244 */
3245 BOOL WINAPI CryptUIDlgViewCertificateW(
3246 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
3247 {
3248 static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
3249 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
3250 WINTRUST_DATA wvt;
3251 WINTRUST_CERT_INFO cert;
3252 BOOL ret = FALSE;
3253 CRYPT_PROVIDER_SGNR *signer;
3254 CRYPT_PROVIDER_CERT *provCert = NULL;
3255
3256 TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
3257
3258 if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
3259 {
3260 SetLastError(ERROR_INVALID_PARAMETER);
3261 return FALSE;
3262 }
3263 /* Make a local copy in case we have to call WinVerifyTrust ourselves */
3264 memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
3265 if (!viewInfo.u.hWVTStateData)
3266 {
3267 memset(&wvt, 0, sizeof(wvt));
3268 wvt.cbStruct = sizeof(wvt);
3269 wvt.dwUIChoice = WTD_UI_NONE;
3270 if (viewInfo.dwFlags &
3271 CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
3272 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
3273 if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
3274 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
3275 if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
3276 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
3277 wvt.dwUnionChoice = WTD_CHOICE_CERT;
3278 memset(&cert, 0, sizeof(cert));
3279 cert.cbStruct = sizeof(cert);
3280 cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
3281 cert.chStores = viewInfo.cStores;
3282 cert.pahStores = viewInfo.rghStores;
3283 wvt.u.pCert = &cert;
3284 wvt.dwStateAction = WTD_STATEACTION_VERIFY;
3285 WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
3286 viewInfo.u.pCryptProviderData =
3287 WTHelperProvDataFromStateData(wvt.hWVTStateData);
3288 signer = WTHelperGetProvSignerFromChain(
3289 (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
3290 provCert = WTHelperGetProvCertFromChain(signer, 0);
3291 ret = TRUE;
3292 }
3293 else
3294 {
3295 viewInfo.u.pCryptProviderData =
3296 WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
3297 signer = WTHelperGetProvSignerFromChain(
3298 (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
3299 viewInfo.idxSigner, viewInfo.fCounterSigner,
3300 viewInfo.idxCounterSigner);
3301 provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
3302 ret = TRUE;
3303 }
3304 if (ret)
3305 {
3306 ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
3307 if (!viewInfo.u.hWVTStateData)
3308 {
3309 wvt.dwStateAction = WTD_STATEACTION_CLOSE;
3310 WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
3311 }
3312 }
3313 return ret;
3314 }
3315
3316 /***********************************************************************
3317 * CryptUIDlgViewContext (CRYPTUI.@)
3318 */
3319 BOOL WINAPI CryptUIDlgViewContext(DWORD dwContextType, LPVOID pvContext,
3320 HWND hwnd, LPCWSTR pwszTitle, DWORD dwFlags, LPVOID pvReserved)
3321 {
3322 BOOL ret;
3323
3324 TRACE("(%d, %p, %p, %s, %08x, %p)\n", dwContextType, pvContext, hwnd,
3325 debugstr_w(pwszTitle), dwFlags, pvReserved);
3326
3327 switch (dwContextType)
3328 {
3329 case CERT_STORE_CERTIFICATE_CONTEXT:
3330 {
3331 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
3332
3333 memset(&viewInfo, 0, sizeof(viewInfo));
3334 viewInfo.dwSize = sizeof(viewInfo);
3335 viewInfo.hwndParent = hwnd;
3336 viewInfo.szTitle = pwszTitle;
3337 viewInfo.pCertContext = pvContext;
3338 ret = CryptUIDlgViewCertificateW(&viewInfo, NULL);
3339 break;
3340 }
3341 default:
3342 FIXME("unimplemented for context type %d\n", dwContextType);
3343 SetLastError(E_INVALIDARG);
3344 ret = FALSE;
3345 }
3346 return ret;
3347 }
3348
3349 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
3350 * or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
3351 * should be a CA. If neither extension is present, returns
3352 * defaultIfNotSpecified.
3353 */
3354 static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
3355 {
3356 BOOL isCA = defaultIfNotSpecified;
3357 PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
3358 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
3359
3360 if (ext)
3361 {
3362 CERT_BASIC_CONSTRAINTS_INFO *info;
3363 DWORD size = 0;
3364
3365 if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
3366 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
3367 NULL, (LPBYTE)&info, &size))
3368 {
3369 if (info->SubjectType.cbData == 1)
3370 isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
3371 LocalFree(info);
3372 }
3373 }
3374 else
3375 {
3376 ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
3377 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
3378 if (ext)
3379 {
3380 CERT_BASIC_CONSTRAINTS2_INFO info;
3381 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
3382
3383 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
3384 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
3385 0, NULL, &info, &size))
3386 isCA = info.fCA;
3387 }
3388 }
3389 return isCA;
3390 }
3391
3392 static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
3393 {
3394 static const WCHAR AddressBook[] = { 'A','d','d','r','e','s','s',
3395 'B','o','o','k',0 };
3396 static const WCHAR CA[] = { 'C','A',0 };
3397 LPCWSTR storeName;
3398
3399 if (is_ca_cert(cert, TRUE))
3400 storeName = CA;
3401 else
3402 storeName = AddressBook;
3403 return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3404 CERT_SYSTEM_STORE_CURRENT_USER, storeName);
3405 }
3406
3407 static BOOL import_cert(PCCERT_CONTEXT cert, HCERTSTORE hDestCertStore)
3408 {
3409 HCERTSTORE store;
3410 BOOL ret;
3411
3412 if (!cert)
3413 {
3414 SetLastError(E_INVALIDARG);
3415 return FALSE;
3416 }
3417 if (hDestCertStore) store = hDestCertStore;
3418 else
3419 {
3420 if (!(store = choose_store_for_cert(cert)))
3421 {
3422 WARN("unable to open certificate store\n");
3423 return FALSE;
3424 }
3425 }
3426 ret = CertAddCertificateContextToStore(store, cert,
3427 CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
3428 if (!hDestCertStore) CertCloseStore(store, 0);
3429 return ret;
3430 }
3431
3432 static BOOL import_crl(PCCRL_CONTEXT crl, HCERTSTORE hDestCertStore)
3433 {
3434 HCERTSTORE store;
3435 BOOL ret;
3436
3437 if (!crl)
3438 {
3439 SetLastError(E_INVALIDARG);
3440 return FALSE;
3441 }
3442 if (hDestCertStore) store = hDestCertStore;
3443 else
3444 {
3445 static const WCHAR ca[] = { 'C','A',0 };
3446
3447 if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3448 CERT_SYSTEM_STORE_CURRENT_USER, ca)))
3449 {
3450 WARN("unable to open certificate store\n");
3451 return FALSE;
3452 }
3453 }
3454 ret = CertAddCRLContextToStore(store, crl,
3455 CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
3456 if (!hDestCertStore) CertCloseStore(store, 0);
3457 return ret;
3458 }
3459
3460 static BOOL import_ctl(PCCTL_CONTEXT ctl, HCERTSTORE hDestCertStore)
3461 {
3462 HCERTSTORE store;
3463 BOOL ret;
3464
3465 if (!ctl)
3466 {
3467 SetLastError(E_INVALIDARG);
3468 return FALSE;
3469 }
3470 if (hDestCertStore) store = hDestCertStore;
3471 else
3472 {
3473 static const WCHAR trust[] = { 'T','r','u','s','t',0 };
3474
3475 if (!(store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3476 CERT_SYSTEM_STORE_CURRENT_USER, trust)))
3477 {
3478 WARN("unable to open certificate store\n");
3479 return FALSE;
3480 }
3481 }
3482 ret = CertAddCTLContextToStore(store, ctl,
3483 CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES, NULL);
3484 if (!hDestCertStore) CertCloseStore(store, 0);
3485 return ret;
3486 }
3487
3488 /* Checks type, a type such as CERT_QUERY_CONTENT_CERT returned by
3489 * CryptQueryObject, against the allowed types. Returns TRUE if the
3490 * type is allowed, FALSE otherwise.
3491 */
3492 static BOOL check_context_type(DWORD dwFlags, DWORD type)
3493 {
3494 BOOL ret;
3495
3496 if (dwFlags &
3497 (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
3498 CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
3499 {
3500 switch (type)
3501 {
3502 case CERT_QUERY_CONTENT_CERT:
3503 case CERT_QUERY_CONTENT_SERIALIZED_CERT:
3504 ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT;
3505 break;
3506 case CERT_QUERY_CONTENT_CRL:
3507 case CERT_QUERY_CONTENT_SERIALIZED_CRL:
3508 ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL;
3509 break;
3510 case CERT_QUERY_CONTENT_CTL:
3511 case CERT_QUERY_CONTENT_SERIALIZED_CTL:
3512 ret = dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL;
3513 break;
3514 default:
3515 /* The remaining types contain more than one type, so allow
3516 * any combination.
3517 */
3518 ret = TRUE;
3519 }
3520 }
3521 else
3522 {
3523 /* No allowed types specified, so any type is allowed */
3524 ret = TRUE;
3525 }
3526 if (!ret)
3527 SetLastError(E_INVALIDARG);
3528 return ret;
3529 }
3530
3531
3532 static void import_warning(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
3533 int warningID)
3534 {
3535 if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
3536 {
3537 WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
3538 LPCWSTR pTitle;
3539
3540 if (szTitle)
3541 pTitle = szTitle;
3542 else
3543 {
3544 LoadStringW(hInstance, IDS_IMPORT_WIZARD, title,
3545 sizeof(title) / sizeof(title[0]));
3546 pTitle = title;
3547 }
3548 LoadStringW(hInstance, warningID, error,
3549 sizeof(error) / sizeof(error[0]));
3550 MessageBoxW(hwnd, error, pTitle, MB_ICONERROR | MB_OK);
3551 }
3552 }
3553
3554 static void import_warn_type_mismatch(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle)
3555 {
3556 import_warning(dwFlags, hwnd, szTitle, IDS_IMPORT_TYPE_MISMATCH);
3557 }
3558
3559 static BOOL check_store_context_type(DWORD dwFlags, HCERTSTORE store)
3560 {
3561 BOOL ret;
3562
3563 if (dwFlags &
3564 (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
3565 CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
3566 {
3567 PCCERT_CONTEXT cert;
3568 PCCRL_CONTEXT crl;
3569 PCCTL_CONTEXT ctl;
3570
3571 ret = TRUE;
3572 if ((cert = CertEnumCertificatesInStore(store, NULL)))
3573 {
3574 CertFreeCertificateContext(cert);
3575 if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT))
3576 ret = FALSE;
3577 }
3578 if (ret && (crl = CertEnumCRLsInStore(store, NULL)))
3579 {
3580 CertFreeCRLContext(crl);
3581 if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL))
3582 ret = FALSE;
3583 }
3584 if (ret && (ctl = CertEnumCTLsInStore(store, NULL)))
3585 {
3586 CertFreeCTLContext(ctl);
3587 if (!(dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
3588 ret = FALSE;
3589 }
3590 }
3591 else
3592 ret = TRUE;
3593 if (!ret)
3594 SetLastError(E_INVALIDARG);
3595 return ret;
3596 }
3597
3598 static BOOL import_store(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
3599 HCERTSTORE source, HCERTSTORE dest)
3600 {
3601 BOOL ret;
3602
3603 if ((ret = check_store_context_type(dwFlags, source)))
3604 {
3605 PCCERT_CONTEXT cert = NULL;
3606 PCCRL_CONTEXT crl = NULL;
3607 PCCTL_CONTEXT ctl = NULL;
3608
3609 do {
3610 cert = CertEnumCertificatesInStore(source, cert);
3611 if (cert)
3612 ret = import_cert(cert, dest);
3613 } while (ret && cert);
3614 do {
3615 crl = CertEnumCRLsInStore(source, crl);
3616 if (crl)
3617 ret = import_crl(crl, dest);
3618 } while (ret && crl);
3619 do {
3620 ctl = CertEnumCTLsInStore(source, ctl);
3621 if (ctl)
3622 ret = import_ctl(ctl, dest);
3623 } while (ret && ctl);
3624 }
3625 else
3626 import_warn_type_mismatch(dwFlags, hwnd, szTitle);
3627 return ret;
3628 }
3629
3630 static BOOL import_file(DWORD dwFlags, HWND hwnd, LPCWSTR szTitle,
3631 LPCWSTR fileName, HCERTSTORE dest)
3632 {
3633 HCERTSTORE source;
3634 DWORD contentType, expectedContentTypeFlags;
3635 BOOL ret;
3636
3637 if (dwFlags &
3638 (CRYPTUI_WIZ_IMPORT_ALLOW_CERT | CRYPTUI_WIZ_IMPORT_ALLOW_CRL |
3639 CRYPTUI_WIZ_IMPORT_ALLOW_CTL))
3640 {
3641 expectedContentTypeFlags =
3642 CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
3643 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
3644 CERT_QUERY_CONTENT_FLAG_PFX;
3645 if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CERT)
3646 expectedContentTypeFlags |=
3647 CERT_QUERY_CONTENT_FLAG_CERT |
3648 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT;
3649 if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CRL)
3650 expectedContentTypeFlags |=
3651 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
3652 CERT_QUERY_CONTENT_FLAG_CRL;
3653 if (dwFlags & CRYPTUI_WIZ_IMPORT_ALLOW_CTL)
3654 expectedContentTypeFlags |=
3655 CERT_QUERY_CONTENT_FLAG_CTL |
3656 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL;
3657 }
3658 else
3659 expectedContentTypeFlags =
3660 CERT_QUERY_CONTENT_FLAG_CERT |
3661 CERT_QUERY_CONTENT_FLAG_CTL |
3662 CERT_QUERY_CONTENT_FLAG_CRL |
3663 CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
3664 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT |
3665 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL |
3666 CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL |
3667 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
3668 CERT_QUERY_CONTENT_FLAG_PFX;
3669
3670 ret = CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
3671 expectedContentTypeFlags, CERT_QUERY_FORMAT_FLAG_ALL, 0, NULL,
3672 &contentType, NULL, &source, NULL, NULL);
3673 if (ret)
3674 {
3675 ret = import_store(dwFlags, hwnd, szTitle, source, dest);
3676 CertCloseStore(source, 0);
3677 }
3678 return ret;
3679 }
3680
3681 static LRESULT CALLBACK import_welcome_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3682 LPARAM lp)
3683 {
3684 LRESULT ret = 0;
3685
3686 switch (msg)
3687 {
3688 case WM_NOTIFY:
3689 {
3690 NMHDR *hdr = (NMHDR *)lp;
3691
3692 switch (hdr->code)
3693 {
3694 case PSN_SETACTIVE:
3695 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0, PSWIZB_NEXT);
3696 ret = TRUE;
3697 break;
3698 }
3699 break;
3700 }
3701 }
3702 return ret;
3703 }
3704
3705 static const WCHAR filter_cert[] = { '*','.','c','e','r',';','*','.',
3706 'c','r','t',0 };
3707 static const WCHAR filter_pfx[] = { '*','.','p','f','x',';','*','.',
3708 'p','1','2',0 };
3709 static const WCHAR filter_crl[] = { '*','.','c','r','l',0 };
3710 static const WCHAR filter_ctl[] = { '*','.','s','t','l',0 };
3711 static const WCHAR filter_serialized_store[] = { '*','.','s','s','t',0 };
3712 static const WCHAR filter_cms[] = { '*','.','s','p','c',';','*','.',
3713 'p','7','b',0 };
3714 static const WCHAR filter_all[] = { '*','.','*',0 };
3715
3716 struct StringToFilter
3717 {
3718 int id;
3719 DWORD allowFlags;
3720 LPCWSTR filter;
3721 } import_filters[] = {
3722 { IDS_IMPORT_FILTER_CERT, CRYPTUI_WIZ_IMPORT_ALLOW_CERT, filter_cert },
3723 { IDS_IMPORT_FILTER_PFX, 0, filter_pfx },
3724 { IDS_IMPORT_FILTER_CRL, CRYPTUI_WIZ_IMPORT_ALLOW_CRL, filter_crl },
3725 { IDS_IMPORT_FILTER_CTL, CRYPTUI_WIZ_IMPORT_ALLOW_CTL, filter_ctl },
3726 { IDS_IMPORT_FILTER_SERIALIZED_STORE, 0, filter_serialized_store },
3727 { IDS_IMPORT_FILTER_CMS, 0, filter_cms },
3728 { IDS_IMPORT_FILTER_ALL, 0, filter_all },
3729 };
3730
3731 static WCHAR *make_import_file_filter(DWORD dwFlags)
3732 {
3733 DWORD i;
3734 int len, totalLen = 2;
3735 LPWSTR filter = NULL, str;
3736
3737 for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
3738 {
3739 if (!import_filters[i].allowFlags || !dwFlags ||
3740 (dwFlags & import_filters[i].allowFlags))
3741 {
3742 len = LoadStringW(hInstance, import_filters[i].id, (LPWSTR)&str, 0);
3743 totalLen += len + strlenW(import_filters[i].filter) + 2;
3744 }
3745 }
3746 filter = HeapAlloc(GetProcessHeap(), 0, totalLen * sizeof(WCHAR));
3747 if (filter)
3748 {
3749 LPWSTR ptr;
3750
3751 ptr = filter;
3752 for (i = 0; i < sizeof(import_filters) / sizeof(import_filters[0]); i++)
3753 {
3754 if (!import_filters[i].allowFlags || !dwFlags ||
3755 (dwFlags & import_filters[i].allowFlags))
3756 {
3757 len = LoadStringW(hInstance, import_filters[i].id,
3758 (LPWSTR)&str, 0);
3759 memcpy(ptr, str, len * sizeof(WCHAR));
3760 ptr += len;
3761 *ptr++ = 0;
3762 strcpyW(ptr, import_filters[i].filter);
3763 ptr += strlenW(import_filters[i].filter) + 1;
3764 }
3765 }
3766 *ptr++ = 0;
3767 }
3768 return filter;
3769 }
3770
3771 struct ImportWizData
3772 {
3773 DWORD dwFlags;
3774 LPCWSTR pwszWizardTitle;
3775 PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc;
3776 HCERTSTORE hDestCertStore;
3777 };
3778
3779 static LRESULT CALLBACK import_file_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3780 LPARAM lp)
3781 {
3782 LRESULT ret = 0;
3783 struct ImportWizData *data;
3784
3785 switch (msg)
3786 {
3787 case WM_INITDIALOG:
3788 {
3789 PROPSHEETPAGEW *page = (PROPSHEETPAGEW *)lp;
3790
3791 data = (struct ImportWizData *)page->lParam;
3792 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
3793 break;
3794 }
3795 case WM_NOTIFY:
3796 {
3797 NMHDR *hdr = (NMHDR *)lp;
3798
3799 switch (hdr->code)
3800 {
3801 case PSN_SETACTIVE:
3802 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
3803 PSWIZB_BACK | PSWIZB_NEXT);
3804 ret = TRUE;
3805 break;
3806 case PSN_WIZNEXT:
3807 {
3808 HWND fileNameEdit = GetDlgItem(hwnd, IDC_IMPORT_FILENAME);
3809 DWORD len = SendMessageW(fileNameEdit, WM_GETTEXTLENGTH, 0, 0);
3810
3811 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
3812 if (!len)
3813 {
3814 import_warning(data->dwFlags, hwnd, data->pwszWizardTitle,
3815 IDS_IMPORT_EMPTY_FILE);
3816 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
3817 ret = 1;
3818 }
3819 else
3820 {
3821 LPWSTR fileName = HeapAlloc(GetProcessHeap(), 0,
3822 (len + 1) * sizeof(WCHAR));
3823
3824 SendMessageW(fileNameEdit, WM_GETTEXT, len + 1,
3825 (LPARAM)fileName);
3826 FIXME("validate %s\n", debugstr_w(fileName));
3827 }
3828 break;
3829 }
3830 }
3831 break;
3832 }
3833 case WM_COMMAND:
3834 switch (wp)
3835 {
3836 case IDC_IMPORT_BROWSE_FILE:
3837 {
3838 OPENFILENAMEW ofn;
3839 WCHAR fileBuf[MAX_PATH];
3840
3841 data = (struct ImportWizData *)GetWindowLongPtrW(hwnd, DWLP_USER);
3842 memset(&ofn, 0, sizeof(ofn));
3843 ofn.lStructSize = sizeof(ofn);
3844 ofn.hwndOwner = hwnd;
3845 ofn.lpstrFilter = make_import_file_filter(data->dwFlags);
3846 ofn.lpstrFile = fileBuf;
3847 ofn.nMaxFile = sizeof(fileBuf) / sizeof(fileBuf[0]);
3848 fileBuf[0] = 0;
3849 if (GetOpenFileNameW(&ofn))
3850 SendMessageW(GetDlgItem(hwnd, IDC_IMPORT_FILENAME), WM_SETTEXT,
3851 0, (LPARAM)ofn.lpstrFile);
3852 HeapFree(GetProcessHeap(), 0, (LPWSTR)ofn.lpstrFilter);
3853 break;
3854 }
3855 }
3856 break;
3857 }
3858 return ret;
3859 }
3860
3861 static LRESULT CALLBACK import_store_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3862 LPARAM lp)
3863 {
3864 LRESULT ret = 0;
3865
3866 switch (msg)
3867 {
3868 case WM_NOTIFY:
3869 {
3870 NMHDR *hdr = (NMHDR *)lp;
3871
3872 switch (hdr->code)
3873 {
3874 case PSN_SETACTIVE:
3875 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
3876 PSWIZB_BACK | PSWIZB_NEXT);
3877 ret = TRUE;
3878 break;
3879 }
3880 break;
3881 }
3882 }
3883 return ret;
3884 }
3885
3886 static LRESULT CALLBACK import_finish_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
3887 LPARAM lp)
3888 {
3889 LRESULT ret = 0;
3890
3891 switch (msg)
3892 {
3893 case WM_NOTIFY:
3894 {
3895 NMHDR *hdr = (NMHDR *)lp;
3896
3897 switch (hdr->code)
3898 {
3899 case PSN_SETACTIVE:
3900 PostMessageW(GetParent(hwnd), PSM_SETWIZBUTTONS, 0,
3901 PSWIZB_BACK | PSWIZB_FINISH);
3902 ret = TRUE;
3903 break;
3904 }
3905 break;
3906 }
3907 }
3908 return ret;
3909 }
3910
3911 static BOOL show_import_ui(DWORD dwFlags, HWND hwndParent,
3912 LPCWSTR pwszWizardTitle, PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc,
3913 HCERTSTORE hDestCertStore)
3914 {
3915 PROPSHEETHEADERW hdr;
3916 PROPSHEETPAGEW pages[4];
3917 struct ImportWizData data = { dwFlags, pwszWizardTitle, pImportSrc,
3918 hDestCertStore };
3919
3920 FIXME("\n");
3921
3922 memset(&pages, 0, sizeof(pages));
3923
3924 pages[0].dwSize = sizeof(pages[0]);
3925 pages[0].hInstance = hInstance;
3926 pages[0].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_WELCOME);
3927 pages[0].pfnDlgProc = import_welcome_dlg_proc;
3928 pages[0].dwFlags = PSP_HIDEHEADER;
3929
3930 pages[1].dwSize = sizeof(pages[1]);
3931 pages[1].hInstance = hInstance;
3932 pages[1].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FILE);
3933 pages[1].pfnDlgProc = import_file_dlg_proc;
3934 pages[1].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
3935 pages[1].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_FILE_TITLE);
3936 pages[1].pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_IMPORT_FILE_SUBTITLE);
3937 pages[1].lParam = (LPARAM)&data;
3938
3939 pages[2].dwSize = sizeof(pages[2]);
3940 pages[2].hInstance = hInstance;
3941 pages[2].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_STORE);
3942 pages[2].pfnDlgProc = import_store_dlg_proc;
3943 pages[2].dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
3944 pages[2].pszHeaderTitle = MAKEINTRESOURCEW(IDS_IMPORT_STORE_TITLE);
3945 pages[2].pszHeaderSubTitle = MAKEINTRESOURCEW(IDS_IMPORT_STORE_SUBTITLE);
3946
3947 pages[3].dwSize = sizeof(pages[3]);
3948 pages[3].hInstance = hInstance;
3949 pages[3].u.pszTemplate = MAKEINTRESOURCEW(IDD_IMPORT_FINISH);
3950 pages[3].pfnDlgProc = import_finish_dlg_proc;
3951 pages[3].dwFlags = PSP_HIDEHEADER;
3952
3953 memset(&hdr, 0, sizeof(hdr));
3954 hdr.dwSize = sizeof(hdr);
3955 hdr.hwndParent = hwndParent;
3956 hdr.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD97_OLD | PSH_HEADER;
3957 hdr.hInstance = hInstance;
3958 if (pwszWizardTitle)
3959 hdr.pszCaption = pwszWizardTitle;
3960 else
3961 hdr.pszCaption = MAKEINTRESOURCEW(IDS_IMPORT_WIZARD);
3962 hdr.u3.ppsp = pages;
3963 hdr.nPages = 4;
3964 PropertySheetW(&hdr);
3965 return FALSE;
3966 }
3967
3968 BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
3969 PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
3970 {
3971 BOOL ret;
3972
3973 TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
3974 pImportSrc, hDestCertStore);
3975
3976 if (pImportSrc &&
3977 pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
3978 {
3979 SetLastError(E_INVALIDARG);
3980 return FALSE;
3981 }
3982
3983 if (!(dwFlags & CRYPTUI_WIZ_NO_UI))
3984 ret = show_import_ui(dwFlags, hwndParent, pwszWizardTitle, pImportSrc,
3985 hDestCertStore);
3986 else if (pImportSrc)
3987 {
3988 switch (pImportSrc->dwSubjectChoice)
3989 {
3990 case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
3991 ret = import_file(dwFlags, hwndParent, pwszWizardTitle,
3992 pImportSrc->u.pwszFileName, hDestCertStore);
3993 break;
3994 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
3995 if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CERT)))
3996 ret = import_cert(pImportSrc->u.pCertContext, hDestCertStore);
3997 else
3998 import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
3999 break;
4000 case CRYPTUI_WIZ_IMPORT_SUBJECT_CRL_CONTEXT:
4001 if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CRL)))
4002 ret = import_crl(pImportSrc->u.pCRLContext, hDestCertStore);
4003 else
4004 import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
4005 break;
4006 case CRYPTUI_WIZ_IMPORT_SUBJECT_CTL_CONTEXT:
4007 if ((ret = check_context_type(dwFlags, CERT_QUERY_CONTENT_CTL)))
4008 ret = import_ctl(pImportSrc->u.pCTLContext, hDestCertStore);
4009 else
4010 import_warn_type_mismatch(dwFlags, hwndParent, pwszWizardTitle);
4011 break;
4012 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_STORE:
4013 ret = import_store(dwFlags, hwndParent, pwszWizardTitle,
4014 pImportSrc->u.hCertStore, hDestCertStore);
4015 break;
4016 default:
4017 WARN("unknown source type: %u\n", pImportSrc->dwSubjectChoice);
4018 SetLastError(E_INVALIDARG);
4019 ret = FALSE;
4020 }
4021 }
4022 else
4023 {
4024 /* Can't have no UI without specifying source */
4025 SetLastError(E_INVALIDARG);
4026 ret = FALSE;
4027 }
4028
4029 return ret;
4030 }