?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cryptui: Show/hide add purpose OID's scrollbar depending on how much text it has.
[wine/wine64.git] / dlls / cryptui / main.c
blob7bd835f3deff2d2f0f2385f6d9b8d21212030194
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 "commctrl.h"
36 #include "cryptuiapi.h"
37 #include "cryptuires.h"
38 #include "urlmon.h"
39 #include "hlink.h"
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(cryptui);
44
45 static HINSTANCE hInstance;
46
47 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
48 {
49 TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
50
51 switch (fdwReason)
52 {
53 case DLL_WINE_PREATTACH:
54 return FALSE; /* prefer native version */
55 case DLL_PROCESS_ATTACH:
56 hInstance = hinstDLL;
57 DisableThreadLibraryCalls(hinstDLL);
58 break;
59 case DLL_PROCESS_DETACH:
60 break;
61 default:
62 break;
63 }
64 return TRUE;
65 }
66
67 /***********************************************************************
68 * CryptUIDlgCertMgr (CRYPTUI.@)
69 */
70 BOOL WINAPI CryptUIDlgCertMgr(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
71 {
72 FIXME("(%p): stub\n", pCryptUICertMgr);
73 return FALSE;
74 }
75
76 /***********************************************************************
77 * CryptUIDlgViewCertificateA (CRYPTUI.@)
78 */
79 BOOL WINAPI CryptUIDlgViewCertificateA(
80 PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
81 {
82 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
83 LPWSTR title = NULL;
84 BOOL ret;
85
86 TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
87
88 memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
89 if (pCertViewInfo->szTitle)
90 {
91 int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
92 NULL, 0);
93
94 title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
95 if (title)
96 {
97 MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
98 len);
99 viewInfo.szTitle = title;
100 }
101 else
102 {
103 ret = FALSE;
104 goto error;
105 }
106 }
107 if (pCertViewInfo->cPropSheetPages)
108 {
109 FIXME("ignoring additional prop sheet pages\n");
110 viewInfo.cPropSheetPages = 0;
111 }
112 ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
113 HeapFree(GetProcessHeap(), 0, title);
114 error:
115 return ret;
116 }
117
118 struct ReadStringStruct
119 {
120 LPCWSTR buf;
121 LONG pos;
122 LONG len;
123 };
124
125 static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
126 LONG cb, LONG *pcb)
127 {
128 struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
129 LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
130
131 TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
132
133 memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
134 string->pos += cch;
135 *pcb = cch * sizeof(WCHAR);
136 return 0;
137 }
138
139 static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
140 {
141 struct ReadStringStruct string;
142 EDITSTREAM editstream;
143
144 TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
145
146 string.buf = text;
147 string.pos = 0;
148 string.len = len;
149 editstream.dwCookie = (DWORD_PTR)&string;
150 editstream.dwError = 0;
151 editstream.pfnCallback = read_text_callback;
152 SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
153 (LPARAM)&editstream);
154 }
155
156 static void add_string_resource_to_control(HWND hwnd, int id)
157 {
158 LPWSTR str;
159 LONG len;
160
161 len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
162 add_unformatted_text_to_control(hwnd, str, len);
163 }
164
165 static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
166 LONG len, const PARAFORMAT2 *fmt)
167 {
168 add_unformatted_text_to_control(hwnd, text, len);
169 SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
170 }
171
172 static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
173 const PARAFORMAT2 *fmt)
174 {
175 LPWSTR str;
176 LONG len;
177
178 len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
179 add_text_with_paraformat_to_control(hwnd, str, len, fmt);
180 }
181
182 static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
183 DWORD dwFlags)
184 {
185 LPWSTR buf = NULL;
186 DWORD len;
187
188 len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
189 if (len)
190 {
191 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
192 if (buf)
193 CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
194 }
195 return buf;
196 }
197
198 static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
199 DWORD dwType, DWORD dwFlags)
200 {
201 LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
202
203 if (name)
204 {
205 /* Don't include NULL-terminator in output */
206 DWORD len = lstrlenW(name);
207
208 add_unformatted_text_to_control(hwnd, name, len);
209 HeapFree(GetProcessHeap(), 0, name);
210 }
211 }
212
213 static void add_icon_to_control(HWND hwnd, int id)
214 {
215 HRESULT hr;
216 LPRICHEDITOLE richEditOle = NULL;
217 LPOLEOBJECT object = NULL;
218 CLSID clsid;
219 LPOLECACHE oleCache = NULL;
220 FORMATETC formatEtc;
221 DWORD conn;
222 LPDATAOBJECT dataObject = NULL;
223 HBITMAP bitmap = NULL;
224 RECT rect;
225 STGMEDIUM stgm;
226 REOBJECT reObject;
227
228 TRACE("(%p, %d)\n", hwnd, id);
229
230 SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
231 if (!richEditOle)
232 goto end;
233 hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
234 (void**)&object);
235 if (FAILED(hr))
236 goto end;
237 hr = IOleObject_GetUserClassID(object, &clsid);
238 if (FAILED(hr))
239 goto end;
240 hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
241 if (FAILED(hr))
242 goto end;
243 formatEtc.cfFormat = CF_BITMAP;
244 formatEtc.ptd = NULL;
245 formatEtc.dwAspect = DVASPECT_CONTENT;
246 formatEtc.lindex = -1;
247 formatEtc.tymed = TYMED_GDI;
248 hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
249 if (FAILED(hr))
250 goto end;
251 hr = IOleObject_QueryInterface(object, &IID_IDataObject,
252 (void**)&dataObject);
253 if (FAILED(hr))
254 goto end;
255 bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
256 LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
257 if (!bitmap)
258 goto end;
259 rect.left = rect.top = 0;
260 rect.right = GetSystemMetrics(SM_CXICON);
261 rect.bottom = GetSystemMetrics(SM_CYICON);
262 stgm.tymed = TYMED_GDI;
263 stgm.u.hBitmap = bitmap;
264 stgm.pUnkForRelease = NULL;
265 hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
266 if (FAILED(hr))
267 goto end;
268
269 reObject.cbStruct = sizeof(reObject);
270 reObject.cp = REO_CP_SELECTION;
271 reObject.clsid = clsid;
272 reObject.poleobj = object;
273 reObject.pstg = NULL;
274 reObject.polesite = NULL;
275 reObject.sizel.cx = reObject.sizel.cy = 0;
276 reObject.dvaspect = DVASPECT_CONTENT;
277 reObject.dwFlags = 0;
278 reObject.dwUser = 0;
279
280 IRichEditOle_InsertObject(richEditOle, &reObject);
281
282 end:
283 if (dataObject)
284 IDataObject_Release(dataObject);
285 if (oleCache)
286 IOleCache_Release(oleCache);
287 if (object)
288 IOleObject_Release(object);
289 if (richEditOle)
290 IRichEditOle_Release(richEditOle);
291 }
292
293 #define MY_INDENT 200
294
295 static void add_oid_text_to_control(HWND hwnd, char *oid)
296 {
297 WCHAR nl = '\n';
298 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
299 PARAFORMAT2 parFmt;
300
301 parFmt.cbSize = sizeof(parFmt);
302 parFmt.dwMask = PFM_STARTINDENT;
303 parFmt.dxStartIndent = MY_INDENT * 3;
304 if (oidInfo)
305 {
306 add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
307 lstrlenW(oidInfo->pwszName), &parFmt);
308 add_unformatted_text_to_control(hwnd, &nl, 1);
309 }
310 }
311
312 #define MAX_STRING_LEN 512
313
314 struct OIDToString
315 {
316 LPCSTR oid;
317 int id;
318 };
319
320 /* The following list MUST be lexicographically sorted by OID */
321 static struct OIDToString oidMap[] = {
322 /* 1.3.6.1.4.1.311.10.3.1 */
323 { szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
324 /* 1.3.6.1.4.1.311.10.3.4 */
325 { szOID_KP_EFS, IDS_PURPOSE_EFS },
326 /* 1.3.6.1.4.1.311.10.3.4.1 */
327 { szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
328 /* 1.3.6.1.4.1.311.10.3.5 */
329 { szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
330 /* 1.3.6.1.4.1.311.10.3.6 */
331 { szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
332 /* 1.3.6.1.4.1.311.10.3.7 */
333 { szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
334 /* 1.3.6.1.4.1.311.10.3.8 */
335 { szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
336 /* 1.3.6.1.4.1.311.10.3.9 */
337 { szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
338 /* 1.3.6.1.4.1.311.10.3.10 */
339 { szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
340 /* 1.3.6.1.4.1.311.10.3.11 */
341 { szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
342 /* 1.3.6.1.4.1.311.10.3.12 */
343 { szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
344 /* 1.3.6.1.4.1.311.10.3.13 */
345 { szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
346 /* 1.3.6.1.4.1.311.10.5.1 */
347 { szOID_DRM, IDS_PURPOSE_DRM },
348 /* 1.3.6.1.4.1.311.10.6.1 */
349 { szOID_LICENSES, IDS_PURPOSE_LICENSES },
350 /* 1.3.6.1.4.1.311.10.6.2 */
351 { szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
352 /* 1.3.6.1.4.1.311.20.2.1 */
353 { szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
354 /* 1.3.6.1.4.1.311.20.2.2 */
355 { szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
356 /* 1.3.6.1.4.1.311.21.5 */
357 { szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
358 /* 1.3.6.1.4.1.311.21.6 */
359 { szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
360 /* 1.3.6.1.4.1.311.21.19 */
361 { szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
362 /* 1.3.6.1.5.5.7.3.1 */
363 { szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
364 /* 1.3.6.1.5.5.7.3.2 */
365 { szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
366 /* 1.3.6.1.5.5.7.3.3 */
367 { szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
368 /* 1.3.6.1.5.5.7.3.4 */
369 { szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
370 /* 1.3.6.1.5.5.7.3.5 */
371 { szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
372 /* 1.3.6.1.5.5.7.3.6 */
373 { szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
374 /* 1.3.6.1.5.5.7.3.7 */
375 { szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
376 /* 1.3.6.1.5.5.7.3.8 */
377 { szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
378 };
379
380 static struct OIDToString *findSupportedOID(LPCSTR oid)
381 {
382 int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0, i;
383 struct OIDToString *ret = NULL;
384
385 for (i = (indexLow + indexHigh) / 2; !ret && indexLow <= indexHigh;
386 i = (indexLow + indexHigh) / 2)
387 {
388 int cmp;
389
390 cmp = strcmp(oid, oidMap[i].oid);
391 if (!cmp)
392 ret = &oidMap[i];
393 else if (cmp > 0)
394 indexLow = i + 1;
395 else
396 indexHigh = i - 1;
397 }
398 return ret;
399 }
400
401 static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
402 {
403 struct OIDToString *entry;
404 WCHAR nl = '\n';
405 PARAFORMAT2 parFmt;
406
407 parFmt.cbSize = sizeof(parFmt);
408 parFmt.dwMask = PFM_STARTINDENT;
409 parFmt.dxStartIndent = MY_INDENT * 3;
410 if ((entry = findSupportedOID(oid)))
411 {
412 WCHAR *str, *linebreak, *ptr;
413 BOOL multiline = FALSE;
414 int len;
415
416 len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
417 ptr = str;
418 do {
419 if ((linebreak = memchrW(ptr, '\n', len)))
420 {
421 WCHAR copy[MAX_STRING_LEN];
422
423 multiline = TRUE;
424 /* The source string contains a newline, which the richedit
425 * control won't find since it's interpreted as a paragraph
426 * break. Therefore copy up to the newline. lstrcpynW always
427 * NULL-terminates, so pass one more than the length of the
428 * source line so the copy includes the entire line and the
429 * NULL-terminator.
430 */
431 lstrcpynW(copy, ptr, linebreak - ptr + 1);
432 add_text_with_paraformat_to_control(text, copy,
433 linebreak - ptr, &parFmt);
434 ptr = linebreak + 1;
435 add_unformatted_text_to_control(text, &nl, 1);
436 }
437 else if (multiline && *ptr)
438 {
439 /* Add the last line */
440 add_text_with_paraformat_to_control(text, ptr,
441 len - (ptr - str), &parFmt);
442 add_unformatted_text_to_control(text, &nl, 1);
443 }
444 } while (linebreak);
445 if (!multiline)
446 {
447 add_text_with_paraformat_to_control(text, str, len, &parFmt);
448 add_unformatted_text_to_control(text, &nl, 1);
449 }
450 }
451 else
452 {
453 WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
454 (strlen(oid) + 1) * sizeof(WCHAR));
455
456 if (oidW)
457 {
458 LPCSTR src;
459 WCHAR *dst;
460
461 for (src = oid, dst = oidW; *src; src++, dst++)
462 *dst = *src;
463 *dst = 0;
464 add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
465 &parFmt);
466 add_unformatted_text_to_control(text, &nl, 1);
467 HeapFree(GetProcessHeap(), 0, oidW);
468 }
469 }
470 }
471
472 static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
473 BOOL *anyUsageAdded)
474 {
475 static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
476 WCHAR nl = '\n';
477 CHARFORMATW charFmt;
478 PCERT_EXTENSION policyExt;
479 if (!*anyUsageAdded)
480 {
481 PARAFORMAT2 parFmt;
482
483 parFmt.cbSize = sizeof(parFmt);
484 parFmt.dwMask = PFM_STARTINDENT;
485 parFmt.dxStartIndent = MY_INDENT;
486 add_string_resource_with_paraformat_to_control(text,
487 IDS_CERT_INFO_PURPOSES, &parFmt);
488 add_unformatted_text_to_control(text, &nl, 1);
489 *anyUsageAdded = TRUE;
490 }
491 memset(&charFmt, 0, sizeof(charFmt));
492 charFmt.cbSize = sizeof(charFmt);
493 charFmt.dwMask = CFM_BOLD;
494 charFmt.dwEffects = 0;
495 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
496 if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
497 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
498 {
499 CERT_POLICIES_INFO *policies;
500 DWORD size;
501
502 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
503 policyExt->Value.pbData, policyExt->Value.cbData,
504 CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
505 {
506 DWORD i;
507
508 for (i = 0; i < policies->cPolicyInfo; i++)
509 {
510 DWORD j;
511
512 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
513 add_local_oid_text_to_control(text,
514 policies->rgPolicyInfo[i].rgPolicyQualifier[j].
515 pszPolicyQualifierId);
516 }
517 LocalFree(policies);
518 }
519 }
520 else
521 add_oid_text_to_control(text, any_app_policy);
522 }
523
524 static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
525 BOOL *anyUsageAdded)
526 {
527 WCHAR nl = '\n';
528 DWORD size;
529 BOOL badUsages = FALSE;
530
531 if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
532 {
533 CHARFORMATW charFmt;
534 static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
535 PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
536
537 if (usage)
538 {
539 if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
540 {
541 DWORD i;
542
543 if (!*anyUsageAdded)
544 {
545 PARAFORMAT2 parFmt;
546
547 parFmt.cbSize = sizeof(parFmt);
548 parFmt.dwMask = PFM_STARTINDENT;
549 parFmt.dxStartIndent = MY_INDENT;
550 add_string_resource_with_paraformat_to_control(text,
551 IDS_CERT_INFO_PURPOSES, &parFmt);
552 add_unformatted_text_to_control(text, &nl, 1);
553 *anyUsageAdded = TRUE;
554 }
555 memset(&charFmt, 0, sizeof(charFmt));
556 charFmt.cbSize = sizeof(charFmt);
557 charFmt.dwMask = CFM_BOLD;
558 charFmt.dwEffects = 0;
559 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
560 (LPARAM)&charFmt);
561 if (!usage->cUsageIdentifier)
562 add_oid_text_to_control(text, any_cert_policy);
563 else
564 for (i = 0; i < usage->cUsageIdentifier; i++)
565 add_local_oid_text_to_control(text,
566 usage->rgpszUsageIdentifier[i]);
567 }
568 else
569 badUsages = TRUE;
570 HeapFree(GetProcessHeap(), 0, usage);
571 }
572 else
573 badUsages = TRUE;
574 }
575 else
576 badUsages = TRUE;
577 return badUsages;
578 }
579
580 static void set_policy_text(HWND text,
581 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
582 {
583 BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
584 BOOL badUsages = FALSE, anyUsageAdded = FALSE;
585
586 if (pCertViewInfo->cPurposes)
587 {
588 DWORD i;
589
590 for (i = 0; i < pCertViewInfo->cPurposes; i++)
591 {
592 if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
593 includeCertUsages = TRUE;
594 else if (!strcmp(pCertViewInfo->rgszPurposes[i],
595 szOID_ANY_APPLICATION_POLICY))
596 includeAppUsages = TRUE;
597 else
598 badUsages = TRUE;
599 }
600 }
601 else
602 includeAppUsages = includeCertUsages = TRUE;
603 if (includeAppUsages)
604 display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
605 if (includeCertUsages)
606 badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
607 &anyUsageAdded);
608 if (badUsages)
609 {
610 PARAFORMAT2 parFmt;
611
612 parFmt.cbSize = sizeof(parFmt);
613 parFmt.dwMask = PFM_STARTINDENT;
614 parFmt.dxStartIndent = MY_INDENT;
615 add_string_resource_with_paraformat_to_control(text,
616 IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
617 }
618 }
619
620 static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
621 LPCSTR policyOid)
622 {
623 CRYPT_OBJID_BLOB *ret = NULL;
624 DWORD i;
625
626 for (i = 0; !ret && i < policies->cPolicyInfo; i++)
627 {
628 DWORD j;
629
630 for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
631 if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
632 pszPolicyQualifierId, policyOid))
633 ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
634 Qualifier;
635 }
636 return ret;
637 }
638
639 static WCHAR *get_cps_str_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
640 {
641 LPWSTR qualifierStr = NULL;
642 CERT_NAME_VALUE *qualifierValue;
643 DWORD size;
644
645 if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
646 qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
647 &qualifierValue, &size))
648 {
649 size = CertRDNValueToStrW(qualifierValue->dwValueType,
650 &qualifierValue->Value, NULL, 0);
651 qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
652 if (qualifierStr)
653 CertRDNValueToStrW(qualifierValue->dwValueType,
654 &qualifierValue->Value, qualifierStr, size);
655 LocalFree(qualifierValue);
656 }
657 return qualifierStr;
658 }
659
660 static WCHAR *get_user_notice_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
661 {
662 LPWSTR str = NULL;
663 CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
664 DWORD size;
665
666 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
667 X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
668 qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
669 &qualifierValue, &size))
670 {
671 str = HeapAlloc(GetProcessHeap(), 0,
672 (strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
673 if (str)
674 strcpyW(str, qualifierValue->pszDisplayText);
675 LocalFree(qualifierValue);
676 }
677 return str;
678 }
679
680 struct IssuerStatement
681 {
682 LPWSTR cps;
683 LPWSTR userNotice;
684 };
685
686 static void set_issuer_statement(HWND hwnd,
687 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
688 {
689 PCERT_EXTENSION policyExt;
690
691 if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
692 (policyExt = CertFindExtension(szOID_CERT_POLICIES,
693 pCertViewInfo->pCertContext->pCertInfo->cExtension,
694 pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
695 {
696 CERT_POLICIES_INFO *policies;
697 DWORD size;
698
699 if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
700 policyExt->Value.pbData, policyExt->Value.cbData,
701 CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
702 {
703 CRYPT_OBJID_BLOB *qualifier;
704 LPWSTR cps = NULL, userNotice = NULL;
705
706 if ((qualifier = find_policy_qualifier(policies,
707 szOID_PKIX_POLICY_QUALIFIER_CPS)))
708 cps = get_cps_str_from_qualifier(qualifier);
709 if ((qualifier = find_policy_qualifier(policies,
710 szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
711 userNotice = get_user_notice_from_qualifier(qualifier);
712 if (cps || userNotice)
713 {
714 struct IssuerStatement *issuerStatement =
715 HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
716
717 if (issuerStatement)
718 {
719 issuerStatement->cps = cps;
720 issuerStatement->userNotice = userNotice;
721 EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
722 SetWindowLongPtrW(hwnd, DWLP_USER,
723 (ULONG_PTR)issuerStatement);
724 }
725 }
726 LocalFree(policies);
727 }
728 }
729 }
730
731 static void set_cert_info(HWND hwnd,
732 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
733 {
734 CHARFORMATW charFmt;
735 PARAFORMAT2 parFmt;
736 HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
737 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
738 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
739 (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
740 pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
741 pCertViewInfo->idxCounterSigner);
742 CRYPT_PROVIDER_CERT *root =
743 &provSigner->pasCertChain[provSigner->csCertChain - 1];
744
745 if (provSigner->pChainContext->TrustStatus.dwErrorStatus &
746 CERT_TRUST_IS_PARTIAL_CHAIN)
747 add_icon_to_control(icon, IDB_CERT_WARNING);
748 else if (!root->fTrustedRoot)
749 add_icon_to_control(icon, IDB_CERT_ERROR);
750 else
751 add_icon_to_control(icon, IDB_CERT);
752
753 memset(&charFmt, 0, sizeof(charFmt));
754 charFmt.cbSize = sizeof(charFmt);
755 charFmt.dwMask = CFM_BOLD;
756 charFmt.dwEffects = CFE_BOLD;
757 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
758 /* FIXME: vertically center text */
759 parFmt.cbSize = sizeof(parFmt);
760 parFmt.dwMask = PFM_STARTINDENT;
761 parFmt.dxStartIndent = MY_INDENT;
762 add_string_resource_with_paraformat_to_control(text,
763 IDS_CERTIFICATEINFORMATION, &parFmt);
764
765 text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
766 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
767 if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
768 add_string_resource_with_paraformat_to_control(text,
769 IDS_CERT_INFO_BAD_SIG, &parFmt);
770 else if (provSigner->pChainContext->TrustStatus.dwErrorStatus &
771 CERT_TRUST_IS_PARTIAL_CHAIN)
772 add_string_resource_with_paraformat_to_control(text,
773 IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
774 else if (!root->fTrustedRoot)
775 {
776 if (provSigner->csCertChain == 1 && root->fSelfSigned)
777 add_string_resource_with_paraformat_to_control(text,
778 IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
779 else
780 add_string_resource_with_paraformat_to_control(text,
781 IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
782 }
783 else
784 {
785 set_policy_text(text, pCertViewInfo);
786 set_issuer_statement(hwnd, pCertViewInfo);
787 }
788 }
789
790 static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
791 DWORD nameFlags, int heading)
792 {
793 WCHAR nl = '\n';
794 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
795 CHARFORMATW charFmt;
796 PARAFORMAT2 parFmt;
797
798 memset(&charFmt, 0, sizeof(charFmt));
799 charFmt.cbSize = sizeof(charFmt);
800 charFmt.dwMask = CFM_BOLD;
801 charFmt.dwEffects = CFE_BOLD;
802 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
803 parFmt.cbSize = sizeof(parFmt);
804 parFmt.dwMask = PFM_STARTINDENT;
805 parFmt.dxStartIndent = MY_INDENT * 3;
806 add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
807 charFmt.dwEffects = 0;
808 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
809 add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
810 nameFlags);
811 add_unformatted_text_to_control(text, &nl, 1);
812 add_unformatted_text_to_control(text, &nl, 1);
813 add_unformatted_text_to_control(text, &nl, 1);
814
815 }
816
817 static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
818 {
819 WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
820 WCHAR date[80];
821 SYSTEMTIME sysTime;
822
823 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
824 sizeof(dateFmt) / sizeof(dateFmt[0]));
825 FileTimeToSystemTime(fileTime, &sysTime);
826 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
827 sizeof(date) / sizeof(date[0]));
828 add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
829 }
830
831 static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
832 {
833 WCHAR nl = '\n';
834 HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
835 CHARFORMATW charFmt;
836 PARAFORMAT2 parFmt;
837
838 memset(&charFmt, 0, sizeof(charFmt));
839 charFmt.cbSize = sizeof(charFmt);
840 charFmt.dwMask = CFM_BOLD;
841 charFmt.dwEffects = CFE_BOLD;
842 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
843 parFmt.cbSize = sizeof(parFmt);
844 parFmt.dwMask = PFM_STARTINDENT;
845 parFmt.dxStartIndent = MY_INDENT * 3;
846 add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
847 &parFmt);
848 charFmt.dwEffects = 0;
849 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
850 add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
851 charFmt.dwEffects = CFE_BOLD;
852 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
853 add_string_resource_to_control(text, IDS_VALID_TO);
854 charFmt.dwEffects = 0;
855 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
856 add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
857 add_unformatted_text_to_control(text, &nl, 1);
858 }
859
860 static void set_general_info(HWND hwnd,
861 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
862 {
863 set_cert_info(hwnd, pCertViewInfo);
864 set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
865 IDS_SUBJECT_HEADING);
866 set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
867 CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
868 set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
869 }
870
871 static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
872 LPARAM lp)
873 {
874 LRESULT ret = 0;
875 HWND text;
876 struct IssuerStatement *issuerStatement;
877
878 switch (msg)
879 {
880 case WM_INITDIALOG:
881 text = GetDlgItem(hwnd, IDC_USERNOTICE);
882 issuerStatement = (struct IssuerStatement *)lp;
883 add_unformatted_text_to_control(text, issuerStatement->userNotice,
884 strlenW(issuerStatement->userNotice));
885 if (issuerStatement->cps)
886 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
887 else
888 EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
889 break;
890 case WM_COMMAND:
891 switch (wp)
892 {
893 case IDOK:
894 EndDialog(hwnd, IDOK);
895 ret = TRUE;
896 break;
897 case IDC_CPS:
898 {
899 IBindCtx *bctx = NULL;
900 LPWSTR cps;
901
902 CreateBindCtx(0, &bctx);
903 cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
904 HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
905 HLNF_OPENINNEWWINDOW, 0);
906 IBindCtx_Release(bctx);
907 break;
908 }
909 }
910 }
911 return ret;
912 }
913
914 static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
915 {
916 DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
917 user_notice_dlg_proc, (LPARAM)issuerStatement);
918 }
919
920 static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
921 LPARAM lp)
922 {
923 PROPSHEETPAGEW *page;
924 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
925
926 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
927
928 switch (msg)
929 {
930 case WM_INITDIALOG:
931 page = (PROPSHEETPAGEW *)lp;
932 pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
933 if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
934 ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
935 EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
936 set_general_info(hwnd, pCertViewInfo);
937 break;
938 case WM_COMMAND:
939 switch (wp)
940 {
941 case IDC_ADDTOSTORE:
942 FIXME("call CryptUIWizImport\n");
943 break;
944 case IDC_ISSUERSTATEMENT:
945 {
946 struct IssuerStatement *issuerStatement =
947 (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
948
949 if (issuerStatement)
950 {
951 if (issuerStatement->userNotice)
952 show_user_notice(hwnd, issuerStatement);
953 else if (issuerStatement->cps)
954 {
955 IBindCtx *bctx = NULL;
956
957 CreateBindCtx(0, &bctx);
958 HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
959 NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
960 IBindCtx_Release(bctx);
961 }
962 }
963 break;
964 }
965 }
966 break;
967 }
968 return 0;
969 }
970
971 static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
972 PROPSHEETPAGEW *page)
973 {
974 struct IssuerStatement *issuerStatement;
975
976 switch (msg)
977 {
978 case PSPCB_RELEASE:
979 issuerStatement =
980 (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
981 if (issuerStatement)
982 {
983 HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
984 HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
985 HeapFree(GetProcessHeap(), 0, issuerStatement);
986 }
987 break;
988 }
989 return 1;
990 }
991
992 static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
993 PROPSHEETPAGEW *page)
994 {
995 memset(page, 0, sizeof(PROPSHEETPAGEW));
996 page->dwSize = sizeof(PROPSHEETPAGEW);
997 page->dwFlags = PSP_USECALLBACK;
998 page->pfnCallback = general_callback_proc;
999 page->hInstance = hInstance;
1000 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
1001 page->pfnDlgProc = general_dlg_proc;
1002 page->lParam = (LPARAM)pCertViewInfo;
1003 }
1004
1005 typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
1006
1007 static WCHAR *field_format_version(PCCERT_CONTEXT cert)
1008 {
1009 static const WCHAR fmt[] = { 'V','%','d',0 };
1010 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
1011
1012 if (buf)
1013 sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
1014 return buf;
1015 }
1016
1017 static WCHAR *format_hex_string(void *pb, DWORD cb)
1018 {
1019 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
1020
1021 if (buf)
1022 {
1023 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1024 DWORD i;
1025 WCHAR *ptr;
1026
1027 for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
1028 sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
1029 }
1030 return buf;
1031 }
1032
1033 static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
1034 {
1035 return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
1036 cert->pCertInfo->SerialNumber.cbData);
1037 }
1038
1039 static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
1040 {
1041 return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1042 CERT_NAME_ISSUER_FLAG);
1043 }
1044
1045 static WCHAR *field_format_detailed_cert_name(PCERT_NAME_BLOB name)
1046 {
1047 WCHAR *str = NULL;
1048 DWORD len = CertNameToStrW(X509_ASN_ENCODING, name,
1049 CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, NULL, 0);
1050
1051 if (len)
1052 {
1053 str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1054 if (str)
1055 CertNameToStrW(X509_ASN_ENCODING, name,
1056 CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, str, len);
1057 }
1058 return str;
1059 }
1060
1061 static WCHAR *field_format_detailed_issuer(PCCERT_CONTEXT cert, void *param)
1062 {
1063 return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
1064 }
1065
1066 static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
1067 {
1068 return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
1069 }
1070
1071 static WCHAR *field_format_detailed_subject(PCCERT_CONTEXT cert, void *param)
1072 {
1073 return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
1074 }
1075
1076 static WCHAR *format_long_date(const FILETIME *fileTime)
1077 {
1078 WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
1079 DWORD len;
1080 WCHAR *buf = NULL;
1081 SYSTEMTIME sysTime;
1082
1083 /* FIXME: format isn't quite right, want time too */
1084 GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
1085 sizeof(dateFmt) / sizeof(dateFmt[0]));
1086 FileTimeToSystemTime(fileTime, &sysTime);
1087 len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
1088 if (len)
1089 {
1090 buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1091 if (buf)
1092 GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
1093 len);
1094 }
1095 return buf;
1096 }
1097
1098 static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
1099 {
1100 return format_long_date(&cert->pCertInfo->NotBefore);
1101 }
1102
1103 static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
1104 {
1105 return format_long_date(&cert->pCertInfo->NotAfter);
1106 }
1107
1108 static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
1109 {
1110 PCCRYPT_OID_INFO oidInfo;
1111 WCHAR *buf = NULL;
1112
1113 oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1114 cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
1115 if (oidInfo)
1116 {
1117 WCHAR fmt[MAX_STRING_LEN];
1118
1119 if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
1120 sizeof(fmt) / sizeof(fmt[0])))
1121 {
1122 /* Allocate the output buffer. Use the number of bytes in the
1123 * public key as a conservative (high) estimate for the number of
1124 * digits in its output.
1125 * The output is of the form (in English)
1126 * "<public key algorithm> (<public key bit length> bits)".
1127 * Ordinarily having two positional parameters in a string is not a
1128 * good idea, but as this isn't a sentence fragment, it shouldn't
1129 * be word-order dependent.
1130 */
1131 buf = HeapAlloc(GetProcessHeap(), 0,
1132 (strlenW(fmt) + strlenW(oidInfo->pwszName) +
1133 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8)
1134 * sizeof(WCHAR));
1135 if (buf)
1136 sprintfW(buf, fmt, oidInfo->pwszName,
1137 CertGetPublicKeyLength(X509_ASN_ENCODING,
1138 &cert->pCertInfo->SubjectPublicKeyInfo));
1139 }
1140 }
1141 return buf;
1142 }
1143
1144 static WCHAR *field_format_detailed_public_key(PCCERT_CONTEXT cert, void *param)
1145 {
1146 return format_hex_string(
1147 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
1148 cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
1149 }
1150
1151 struct field_value_data;
1152 struct detail_data
1153 {
1154 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
1155 BOOL *pfPropertiesChanged;
1156 int cFields;
1157 struct field_value_data *fields;
1158 HIMAGELIST imageList;
1159 };
1160
1161 typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
1162
1163 typedef WCHAR *(*create_detailed_value_func)(PCCERT_CONTEXT cert, void *param);
1164
1165 struct field_value_data
1166 {
1167 create_detailed_value_func create;
1168 LPWSTR detailed_value;
1169 void *param;
1170 };
1171
1172 static void add_field_value_data(struct detail_data *data,
1173 create_detailed_value_func create, void *param)
1174 {
1175 if (data->cFields)
1176 data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
1177 (data->cFields + 1) * sizeof(struct field_value_data));
1178 else
1179 data->fields = HeapAlloc(GetProcessHeap(), 0,
1180 sizeof(struct field_value_data));
1181 if (data->fields)
1182 {
1183 data->fields[data->cFields].create = create;
1184 data->fields[data->cFields].detailed_value = NULL;
1185 data->fields[data->cFields].param = param;
1186 data->cFields++;
1187 }
1188 }
1189
1190 static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
1191 LPWSTR field, LPWSTR value, create_detailed_value_func create, void *param)
1192 {
1193 LVITEMW item;
1194 int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
1195
1196 item.mask = LVIF_TEXT | LVIF_PARAM;
1197 item.iItem = iItem;
1198 item.iSubItem = 0;
1199 item.pszText = field;
1200 item.lParam = (LPARAM)data;
1201 SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
1202 if (value)
1203 {
1204 item.pszText = value;
1205 item.iSubItem = 1;
1206 SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
1207 }
1208 add_field_value_data(data, create, param);
1209 }
1210
1211 static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
1212 int id, LPWSTR value, create_detailed_value_func create, void *param)
1213 {
1214 WCHAR buf[MAX_STRING_LEN];
1215
1216 LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
1217 add_field_and_value_to_list(hwnd, data, buf, value, create, param);
1218 }
1219
1220 struct v1_field
1221 {
1222 int id;
1223 field_format_func format;
1224 create_detailed_value_func create_detailed_value;
1225 };
1226
1227 static void add_v1_field(HWND hwnd, struct detail_data *data,
1228 const struct v1_field *field)
1229 {
1230 WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
1231
1232 if (val)
1233 {
1234 add_string_id_and_value_to_list(hwnd, data, field->id, val,
1235 field->create_detailed_value, NULL);
1236 HeapFree(GetProcessHeap(), 0, val);
1237 }
1238 }
1239
1240 static const struct v1_field v1_fields[] = {
1241 { IDS_FIELD_VERSION, field_format_version, NULL },
1242 { IDS_FIELD_SERIAL_NUMBER, field_format_serial_number, NULL },
1243 { IDS_FIELD_ISSUER, field_format_issuer, field_format_detailed_issuer },
1244 { IDS_FIELD_VALID_FROM, field_format_from_date, NULL },
1245 { IDS_FIELD_VALID_TO, field_format_to_date, NULL },
1246 { IDS_FIELD_SUBJECT, field_format_subject, field_format_detailed_subject },
1247 { IDS_FIELD_PUBLIC_KEY, field_format_public_key,
1248 field_format_detailed_public_key }
1249 };
1250
1251 static void add_v1_fields(HWND hwnd, struct detail_data *data)
1252 {
1253 int i;
1254 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1255
1256 /* The last item in v1_fields is the public key, which is not in the loop
1257 * because it's a special case.
1258 */
1259 for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
1260 add_v1_field(hwnd, data, &v1_fields[i]);
1261 if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
1262 add_v1_field(hwnd, data, &v1_fields[i]);
1263 }
1264
1265 static WCHAR *crypt_format_extension(PCERT_EXTENSION ext, DWORD formatStrType)
1266 {
1267 WCHAR *str = NULL;
1268 DWORD size;
1269
1270 if (CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
1271 ext->pszObjId, ext->Value.pbData, ext->Value.cbData, NULL, &size))
1272 {
1273 str = HeapAlloc(GetProcessHeap(), 0, size);
1274 CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
1275 ext->pszObjId, ext->Value.pbData, ext->Value.cbData, str, &size);
1276 }
1277 return str;
1278 }
1279
1280 static WCHAR *field_format_extension_hex_with_ascii(PCERT_EXTENSION ext)
1281 {
1282 WCHAR *str = NULL;
1283
1284 if (ext->Value.cbData)
1285 {
1286 /* The output is formatted as:
1287 * <hex bytes> <ascii bytes>\n
1288 * where <hex bytes> is a string of up to 8 bytes, output as %02x,
1289 * and <ascii bytes> is the ASCII equivalent of each byte, or '.' if
1290 * the byte is not printable.
1291 * So, for example, the extension value consisting of the following
1292 * bytes:
1293 * 0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,
1294 * 0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67
1295 * is output as:
1296 * 30 14 31 12 30 10 06 03 0.1.0...
1297 * 55 04 03 13 09 4a 75 61 U....Jua
1298 * 6e 20 4c 61 6e 67 n Lang
1299 * The allocation size therefore requires:
1300 * - 4 characters per character in an 8-byte line
1301 * (2 for the hex format, one for the space, one for the ASCII value)
1302 * - 3 more characters per 8-byte line (two spaces and a newline)
1303 * - 1 character for the terminating nul
1304 * FIXME: should use a fixed-width font for this
1305 */
1306 DWORD lines = (ext->Value.cbData + 7) / 8;
1307
1308 str = HeapAlloc(GetProcessHeap(), 0,
1309 (lines * 8 * 4 + lines * 3 + 1) * sizeof(WCHAR));
1310 if (str)
1311 {
1312 static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1313 DWORD i, j;
1314 WCHAR *ptr;
1315
1316 for (i = 0, ptr = str; i < ext->Value.cbData; i += 8)
1317 {
1318 /* Output as hex bytes first */
1319 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr += 3)
1320 sprintfW(ptr, fmt, ext->Value.pbData[j]);
1321 /* Pad the hex output with spaces for alignment */
1322 if (j == ext->Value.cbData && j % 8)
1323 {
1324 static const WCHAR pad[] = { ' ',' ',' ' };
1325
1326 for (; j % 8; j++, ptr += sizeof(pad) / sizeof(pad[0]))
1327 memcpy(ptr, pad, sizeof(pad));
1328 }
1329 /* The last sprintfW included a space, so just insert one
1330 * more space between the hex bytes and the ASCII output
1331 */
1332 *ptr++ = ' ';
1333 /* Output as ASCII bytes */
1334 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr++)
1335 {
1336 if (isprintW(ext->Value.pbData[j]) &&
1337 !isspaceW(ext->Value.pbData[j]))
1338 *ptr = ext->Value.pbData[j];
1339 else
1340 *ptr = '.';
1341 }
1342 *ptr++ = '\n';
1343 }
1344 *ptr++ = '\0';
1345 }
1346 }
1347 return str;
1348 }
1349
1350 static WCHAR *field_format_detailed_extension(PCCERT_CONTEXT cert, void *param)
1351 {
1352 PCERT_EXTENSION ext = param;
1353 LPWSTR str = crypt_format_extension(ext,
1354 CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX);
1355
1356 if (!str)
1357 str = field_format_extension_hex_with_ascii(ext);
1358 return str;
1359 }
1360
1361 static void add_cert_extension_detail(HWND hwnd, struct detail_data *data,
1362 PCERT_EXTENSION ext)
1363 {
1364 PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1365 ext->pszObjId, 0);
1366 LPWSTR val = crypt_format_extension(ext, 0);
1367
1368 if (oidInfo)
1369 add_field_and_value_to_list(hwnd, data, (LPWSTR)oidInfo->pwszName,
1370 val, field_format_detailed_extension, ext);
1371 else
1372 {
1373 DWORD len = strlen(ext->pszObjId);
1374 LPWSTR oidW = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1375
1376 if (oidW)
1377 {
1378 DWORD i;
1379
1380 for (i = 0; i <= len; i++)
1381 oidW[i] = ext->pszObjId[i];
1382 add_field_and_value_to_list(hwnd, data, oidW, val,
1383 field_format_detailed_extension, ext);
1384 HeapFree(GetProcessHeap(), 0, oidW);
1385 }
1386 }
1387 HeapFree(GetProcessHeap(), 0, val);
1388 }
1389
1390 static void add_all_extensions(HWND hwnd, struct detail_data *data)
1391 {
1392 DWORD i;
1393 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1394
1395 for (i = 0; i < cert->pCertInfo->cExtension; i++)
1396 add_cert_extension_detail(hwnd, data, &cert->pCertInfo->rgExtension[i]);
1397 }
1398
1399 static void add_critical_extensions(HWND hwnd, struct detail_data *data)
1400 {
1401 DWORD i;
1402 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1403
1404 for (i = 0; i < cert->pCertInfo->cExtension; i++)
1405 if (cert->pCertInfo->rgExtension[i].fCritical)
1406 add_cert_extension_detail(hwnd, data,
1407 &cert->pCertInfo->rgExtension[i]);
1408 }
1409
1410 typedef WCHAR * (*prop_to_value_func)(void *pb, DWORD cb);
1411
1412 struct prop_id_to_string_id
1413 {
1414 DWORD prop;
1415 int id;
1416 BOOL prop_is_string;
1417 prop_to_value_func prop_to_value;
1418 };
1419
1420 static WCHAR *format_enhanced_key_usage_value(void *pb, DWORD cb)
1421 {
1422 CERT_EXTENSION ext;
1423
1424 ext.pszObjId = (LPSTR)X509_ENHANCED_KEY_USAGE;
1425 ext.fCritical = FALSE;
1426 ext.Value.pbData = pb;
1427 ext.Value.cbData = cb;
1428 return crypt_format_extension(&ext, 0);
1429 }
1430
1431 /* Logically the access state should also be checked, and IDC_EDITPROPERTIES
1432 * disabled for read-only certificates, but native doesn't appear to do that.
1433 */
1434 static const struct prop_id_to_string_id prop_id_map[] = {
1435 { CERT_HASH_PROP_ID, IDS_PROP_HASH, FALSE, format_hex_string },
1436 { CERT_FRIENDLY_NAME_PROP_ID, IDS_PROP_FRIENDLY_NAME, TRUE, NULL },
1437 { CERT_DESCRIPTION_PROP_ID, IDS_PROP_DESCRIPTION, TRUE, NULL },
1438 { CERT_ENHKEY_USAGE_PROP_ID, IDS_PROP_ENHKEY_USAGE, FALSE,
1439 format_enhanced_key_usage_value },
1440 };
1441
1442 static void add_properties(HWND hwnd, struct detail_data *data)
1443 {
1444 DWORD i;
1445 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1446
1447 for (i = 0; i < sizeof(prop_id_map) / sizeof(prop_id_map[0]); i++)
1448 {
1449 DWORD cb;
1450
1451 if (CertGetCertificateContextProperty(cert, prop_id_map[i].prop, NULL,
1452 &cb))
1453 {
1454 BYTE *pb;
1455 WCHAR *val = NULL;
1456
1457 /* FIXME: MS adds a separate value for the signature hash
1458 * algorithm.
1459 */
1460 pb = HeapAlloc(GetProcessHeap(), 0, cb);
1461 if (pb)
1462 {
1463 if (CertGetCertificateContextProperty(cert,
1464 prop_id_map[i].prop, pb, &cb))
1465 {
1466 if (prop_id_map[i].prop_is_string)
1467 {
1468 val = (LPWSTR)pb;
1469 /* Don't double-free pb */
1470 pb = NULL;
1471 }
1472 else
1473 val = prop_id_map[i].prop_to_value(pb, cb);
1474 }
1475 HeapFree(GetProcessHeap(), 0, pb);
1476 }
1477 add_string_id_and_value_to_list(hwnd, data, prop_id_map[i].id, val,
1478 NULL, NULL);
1479 }
1480 }
1481 }
1482
1483 static void add_all_fields(HWND hwnd, struct detail_data *data)
1484 {
1485 add_v1_fields(hwnd, data);
1486 add_all_extensions(hwnd, data);
1487 add_properties(hwnd, data);
1488 }
1489
1490 struct selection_list_item
1491 {
1492 int id;
1493 add_fields_func add;
1494 };
1495
1496 const struct selection_list_item listItems[] = {
1497 { IDS_FIELDS_ALL, add_all_fields },
1498 { IDS_FIELDS_V1, add_v1_fields },
1499 { IDS_FIELDS_EXTENSIONS, add_all_extensions },
1500 { IDS_FIELDS_CRITICAL_EXTENSIONS, add_critical_extensions },
1501 { IDS_FIELDS_PROPERTIES, add_properties },
1502 };
1503
1504 static void create_show_list(HWND hwnd, struct detail_data *data)
1505 {
1506 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
1507 WCHAR buf[MAX_STRING_LEN];
1508 int i;
1509
1510 for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
1511 {
1512 int index;
1513
1514 LoadStringW(hInstance, listItems[i].id, buf,
1515 sizeof(buf) / sizeof(buf[0]));
1516 index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
1517 SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
1518 }
1519 SendMessageW(cb, CB_SETCURSEL, 0, 0);
1520 }
1521
1522 static void create_listview_columns(HWND hwnd)
1523 {
1524 HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1525 RECT rc;
1526 WCHAR buf[MAX_STRING_LEN];
1527 LVCOLUMNW column;
1528
1529 SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
1530 GetWindowRect(lv, &rc);
1531 LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
1532 column.mask = LVCF_WIDTH | LVCF_TEXT;
1533 column.cx = (rc.right - rc.left) / 2 - 2;
1534 column.pszText = buf;
1535 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
1536 LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
1537 SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
1538 }
1539
1540 static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
1541 {
1542 HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1543
1544 if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
1545 {
1546 SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
1547 listItems[sel].add(list, data);
1548 }
1549 }
1550
1551 static void create_cert_details_list(HWND hwnd, struct detail_data *data)
1552 {
1553 create_show_list(hwnd, data);
1554 create_listview_columns(hwnd);
1555 set_fields_selection(hwnd, data, 0);
1556 }
1557
1558 typedef enum {
1559 CheckBitmapIndexUnchecked = 1,
1560 CheckBitmapIndexChecked = 2,
1561 CheckBitmapIndexDisabledUnchecked = 3,
1562 CheckBitmapIndexDisabledChecked = 4
1563 } CheckBitmapIndex;
1564
1565 static void add_purpose(HWND hwnd, LPCSTR oid)
1566 {
1567 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1568 PCRYPT_OID_INFO info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1569 sizeof(CRYPT_OID_INFO));
1570
1571 if (info)
1572 {
1573 char *oidCopy = HeapAlloc(GetProcessHeap(), 0, strlen(oid) + 1);
1574
1575 if (oidCopy)
1576 {
1577 LVITEMA item;
1578
1579 strcpy(oidCopy, oid);
1580 info->cbSize = sizeof(CRYPT_OID_INFO);
1581 info->pszOID = oidCopy;
1582 item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
1583 item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexChecked);
1584 item.stateMask = LVIS_STATEIMAGEMASK;
1585 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
1586 item.iSubItem = 0;
1587 item.lParam = (LPARAM)info;
1588 item.pszText = oidCopy;
1589 SendMessageA(lv, LVM_INSERTITEMA, 0, (LPARAM)&item);
1590 }
1591 else
1592 HeapFree(GetProcessHeap(), 0, info);
1593 }
1594 }
1595
1596 #define MAX_PURPOSE 255
1597
1598 static LRESULT CALLBACK add_purpose_dlg_proc(HWND hwnd, UINT msg,
1599 WPARAM wp, LPARAM lp)
1600 {
1601 LRESULT ret = 0;
1602 char buf[MAX_PURPOSE + 1];
1603
1604 switch (msg)
1605 {
1606 case WM_INITDIALOG:
1607 SendMessageW(GetDlgItem(hwnd, IDC_NEW_PURPOSE), EM_SETLIMITTEXT,
1608 MAX_PURPOSE, 0);
1609 ShowScrollBar(GetDlgItem(hwnd, IDC_NEW_PURPOSE), SB_VERT, FALSE);
1610 SetWindowLongPtrW(hwnd, DWLP_USER, lp);
1611 break;
1612 case WM_COMMAND:
1613 switch (HIWORD(wp))
1614 {
1615 case EN_CHANGE:
1616 if (LOWORD(wp) == IDC_NEW_PURPOSE)
1617 {
1618 /* Show/hide scroll bar on description depending on how much
1619 * text it has.
1620 */
1621 HWND description = GetDlgItem(hwnd, IDC_NEW_PURPOSE);
1622 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
1623
1624 ShowScrollBar(description, SB_VERT, lines > 1);
1625 }
1626 break;
1627 case BN_CLICKED:
1628 switch (LOWORD(wp))
1629 {
1630 case IDOK:
1631 SendMessageA(GetDlgItem(hwnd, IDC_NEW_PURPOSE), WM_GETTEXT,
1632 sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
1633 if (!buf[0])
1634 {
1635 /* An empty purpose is the same as cancelling */
1636 EndDialog(hwnd, IDCANCEL);
1637 ret = TRUE;
1638 }
1639 else
1640 {
1641 HWND parent = (HWND)GetWindowLongPtrW(hwnd, DWLP_USER);
1642
1643 FIXME("validate %s\n", debugstr_a(buf));
1644 add_purpose(parent, buf);
1645 EndDialog(hwnd, wp);
1646 ret = TRUE;
1647 }
1648 break;
1649 case IDCANCEL:
1650 EndDialog(hwnd, wp);
1651 ret = TRUE;
1652 break;
1653 }
1654 break;
1655 }
1656 break;
1657 }
1658 return ret;
1659 }
1660
1661 static WCHAR *get_cert_property_as_string(PCCERT_CONTEXT cert, DWORD prop)
1662 {
1663 WCHAR *name = NULL;
1664 DWORD cb;
1665
1666 if (CertGetCertificateContextProperty(cert, prop, NULL, &cb))
1667 {
1668 name = HeapAlloc(GetProcessHeap(), 0, cb);
1669 if (name)
1670 {
1671 if (!CertGetCertificateContextProperty(cert, prop, (LPBYTE)name,
1672 &cb))
1673 {
1674 HeapFree(GetProcessHeap(), 0, name);
1675 name = NULL;
1676 }
1677 }
1678 }
1679 return name;
1680 }
1681
1682 static void redraw_states(HWND list, BOOL enabled)
1683 {
1684 int items = SendMessageW(list, LVM_GETITEMCOUNT, 0, 0), i;
1685
1686 for (i = 0; i < items; i++)
1687 {
1688 BOOL change = FALSE;
1689 int state;
1690
1691 state = SendMessageW(list, LVM_GETITEMSTATE, i, LVIS_STATEIMAGEMASK);
1692 /* This reverses the INDEXTOSTATEIMAGEMASK shift. There doesn't appear
1693 * to be a handy macro for it.
1694 */
1695 state >>= 12;
1696 if (enabled)
1697 {
1698 if (state == CheckBitmapIndexDisabledChecked)
1699 {
1700 state = CheckBitmapIndexChecked;
1701 change = TRUE;
1702 }
1703 if (state == CheckBitmapIndexDisabledUnchecked)
1704 {
1705 state = CheckBitmapIndexUnchecked;
1706 change = TRUE;
1707 }
1708 }
1709 else
1710 {
1711 if (state == CheckBitmapIndexChecked)
1712 {
1713 state = CheckBitmapIndexDisabledChecked;
1714 change = TRUE;
1715 }
1716 if (state == CheckBitmapIndexUnchecked)
1717 {
1718 state = CheckBitmapIndexDisabledUnchecked;
1719 change = TRUE;
1720 }
1721 }
1722 if (change)
1723 {
1724 LVITEMW item;
1725
1726 item.state = INDEXTOSTATEIMAGEMASK(state);
1727 item.stateMask = LVIS_STATEIMAGEMASK;
1728 SendMessageW(list, LVM_SETITEMSTATE, i, (LPARAM)&item);
1729 }
1730 }
1731 }
1732
1733 typedef enum {
1734 PurposeEnableAll = 0,
1735 PurposeDisableAll,
1736 PurposeEnableSelected
1737 } PurposeSelection;
1738
1739 static void select_purposes(HWND hwnd, PurposeSelection selection)
1740 {
1741 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1742
1743 switch (selection)
1744 {
1745 case PurposeEnableAll:
1746 case PurposeDisableAll:
1747 EnableWindow(lv, FALSE);
1748 redraw_states(lv, FALSE);
1749 EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), FALSE);
1750 break;
1751 case PurposeEnableSelected:
1752 EnableWindow(lv, TRUE);
1753 redraw_states(lv, TRUE);
1754 EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), TRUE);
1755 }
1756 }
1757
1758 extern BOOL WINAPI WTHelperGetKnownUsages(DWORD action,
1759 PCCRYPT_OID_INFO **usages);
1760
1761 static void add_known_usage(HWND lv, PCCRYPT_OID_INFO info)
1762 {
1763 LVITEMW item;
1764
1765 item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
1766 item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexDisabledChecked);
1767 item.stateMask = LVIS_STATEIMAGEMASK;
1768 item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
1769 item.iSubItem = 0;
1770 item.lParam = (LPARAM)info;
1771 item.pszText = (LPWSTR)info->pwszName;
1772 SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
1773 }
1774
1775 static void show_cert_usages(HWND hwnd, struct detail_data *data)
1776 {
1777 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1778 HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1779 PCERT_ENHKEY_USAGE usage;
1780 DWORD size;
1781 PCCRYPT_OID_INFO *usages;
1782 RECT rc;
1783 LVCOLUMNW column;
1784 PurposeSelection purposeSelection;
1785
1786 GetWindowRect(lv, &rc);
1787 column.mask = LVCF_WIDTH;
1788 column.cx = rc.right - rc.left;
1789 SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
1790 SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)data->imageList);
1791
1792 /* Get enhanced key usage. Have to check for a property and an extension
1793 * separately, because CertGetEnhancedKeyUsage will succeed and return an
1794 * empty usage if neither is set. Unfortunately an empty usage implies
1795 * no usage is allowed, so we have to distinguish between the two cases.
1796 */
1797 if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
1798 NULL, &size))
1799 {
1800 usage = HeapAlloc(GetProcessHeap(), 0, size);
1801 if (!CertGetEnhancedKeyUsage(cert,
1802 CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
1803 {
1804 HeapFree(GetProcessHeap(), 0, usage);
1805 usage = NULL;
1806 }
1807 else if (usage->cUsageIdentifier)
1808 purposeSelection = PurposeEnableSelected;
1809 else
1810 purposeSelection = PurposeDisableAll;
1811 }
1812 else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
1813 NULL, &size))
1814 {
1815 usage = HeapAlloc(GetProcessHeap(), 0, size);
1816 if (!CertGetEnhancedKeyUsage(cert,
1817 CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
1818 {
1819 HeapFree(GetProcessHeap(), 0, usage);
1820 usage = NULL;
1821 }
1822 else if (usage->cUsageIdentifier)
1823 purposeSelection = PurposeEnableAll;
1824 else
1825 purposeSelection = PurposeDisableAll;
1826 }
1827 else
1828 {
1829 purposeSelection = PurposeEnableAll;
1830 usage = NULL;
1831 }
1832 if (usage)
1833 {
1834 DWORD i;
1835
1836 for (i = 0; i < usage->cUsageIdentifier; i++)
1837 {
1838 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1839 usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
1840
1841 if (info)
1842 add_known_usage(lv, info);
1843 else
1844 add_purpose(hwnd, usage->rgpszUsageIdentifier[i]);
1845 }
1846 HeapFree(GetProcessHeap(), 0, usage);
1847 }
1848 else
1849 {
1850 if (WTHelperGetKnownUsages(1, &usages))
1851 {
1852 PCCRYPT_OID_INFO *ptr;
1853
1854 for (ptr = usages; *ptr; ptr++)
1855 add_known_usage(lv, *ptr);
1856 WTHelperGetKnownUsages(2, &usages);
1857 }
1858 }
1859 select_purposes(hwnd, purposeSelection);
1860 SendMessageW(GetDlgItem(hwnd, IDC_ENABLE_ALL_PURPOSES + purposeSelection),
1861 BM_CLICK, 0, 0);
1862 }
1863
1864 static void set_general_cert_properties(HWND hwnd, struct detail_data *data)
1865 {
1866 PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1867 WCHAR *str;
1868
1869 if ((str = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID)))
1870 {
1871 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_SETTEXT, 0,
1872 (LPARAM)str);
1873 HeapFree(GetProcessHeap(), 0, str);
1874 }
1875 if ((str = get_cert_property_as_string(cert, CERT_DESCRIPTION_PROP_ID)))
1876 {
1877 SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_SETTEXT, 0,
1878 (LPARAM)str);
1879 HeapFree(GetProcessHeap(), 0, str);
1880 }
1881 show_cert_usages(hwnd, data);
1882 }
1883
1884 #define MAX_FRIENDLY_NAME 40
1885 #define MAX_DESCRIPTION 255
1886
1887 static LRESULT CALLBACK cert_properties_general_dlg_proc(HWND hwnd, UINT msg,
1888 WPARAM wp, LPARAM lp)
1889 {
1890 PROPSHEETPAGEW *page;
1891 struct detail_data *data;
1892
1893 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
1894
1895 switch (msg)
1896 {
1897 case WM_INITDIALOG:
1898 {
1899 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
1900
1901 page = (PROPSHEETPAGEW *)lp;
1902 data = (struct detail_data *)page->lParam;
1903 SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), EM_SETLIMITTEXT,
1904 MAX_FRIENDLY_NAME, 0);
1905 SendMessageW(description, EM_SETLIMITTEXT, MAX_DESCRIPTION, 0);
1906 ShowScrollBar(description, SB_VERT, FALSE);
1907 set_general_cert_properties(hwnd, data);
1908 SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)data);
1909 break;
1910 }
1911 case WM_COMMAND:
1912 switch (HIWORD(wp))
1913 {
1914 case EN_CHANGE:
1915 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
1916 if (LOWORD(wp) == IDC_DESCRIPTION)
1917 {
1918 /* Show/hide scroll bar on description depending on how much
1919 * text it has.
1920 */
1921 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
1922 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
1923
1924 ShowScrollBar(description, SB_VERT, lines > 1);
1925 }
1926 break;
1927 case BN_CLICKED:
1928 switch (LOWORD(wp))
1929 {
1930 case IDC_ADD_PURPOSE:
1931 if (DialogBoxParamW(hInstance,
1932 MAKEINTRESOURCEW(IDD_ADD_CERT_PURPOSE), hwnd,
1933 add_purpose_dlg_proc, (LPARAM)hwnd) == IDOK)
1934 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
1935 break;
1936 case IDC_ENABLE_ALL_PURPOSES:
1937 case IDC_DISABLE_ALL_PURPOSES:
1938 case IDC_ENABLE_SELECTED_PURPOSES:
1939 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
1940 select_purposes(hwnd, LOWORD(wp) - IDC_ENABLE_ALL_PURPOSES);
1941 break;
1942 }
1943 break;
1944 }
1945 break;
1946 }
1947 return 0;
1948 }
1949
1950 static UINT CALLBACK cert_properties_general_callback(HWND hwnd, UINT msg,
1951 PROPSHEETPAGEW *page)
1952 {
1953 HWND lv;
1954 int cItem, i;
1955
1956 switch (msg)
1957 {
1958 case PSPCB_RELEASE:
1959 lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1960 cItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
1961 for (i = 0; i < cItem; i++)
1962 {
1963 LVITEMW item;
1964
1965 item.mask = LVIF_PARAM;
1966 item.iItem = i;
1967 item.iSubItem = 0;
1968 if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item) && item.lParam)
1969 {
1970 PCRYPT_OID_INFO info = (PCRYPT_OID_INFO)item.lParam;
1971
1972 if (info->cbSize == sizeof(CRYPT_OID_INFO) && !info->dwGroupId)
1973 {
1974 HeapFree(GetProcessHeap(), 0, (LPSTR)info->pszOID);
1975 HeapFree(GetProcessHeap(), 0, info);
1976 }
1977 }
1978 }
1979 break;
1980 }
1981 return 1;
1982 }
1983
1984 static void show_edit_cert_properties_dialog(HWND parent,
1985 struct detail_data *data)
1986 {
1987 PROPSHEETHEADERW hdr;
1988 PROPSHEETPAGEW page; /* FIXME: need to add a cross-certificate page */
1989
1990 TRACE("(%p)\n", data);
1991
1992 memset(&page, 0, sizeof(PROPSHEETPAGEW));
1993 page.dwSize = sizeof(page);
1994 page.dwFlags = PSP_USECALLBACK;
1995 page.pfnCallback = cert_properties_general_callback;
1996 page.hInstance = hInstance;
1997 page.u.pszTemplate = MAKEINTRESOURCEW(IDD_CERT_PROPERTIES_GENERAL);
1998 page.pfnDlgProc = cert_properties_general_dlg_proc;
1999 page.lParam = (LPARAM)data;
2000
2001 memset(&hdr, 0, sizeof(hdr));
2002 hdr.dwSize = sizeof(hdr);
2003 hdr.hwndParent = parent;
2004 hdr.dwFlags = PSH_PROPSHEETPAGE;
2005 hdr.hInstance = hInstance;
2006 hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE_PROPERTIES);
2007 hdr.u3.ppsp = &page;
2008 hdr.nPages = 1;
2009 PropertySheetW(&hdr);
2010 }
2011
2012 static void free_detail_fields(struct detail_data *data)
2013 {
2014 DWORD i;
2015
2016 for (i = 0; i < data->cFields; i++)
2017 HeapFree(GetProcessHeap(), 0, data->fields[i].detailed_value);
2018 HeapFree(GetProcessHeap(), 0, data->fields);
2019 data->fields = NULL;
2020 data->cFields = 0;
2021 }
2022
2023 static void refresh_details_view(HWND hwnd)
2024 {
2025 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2026 int curSel;
2027 struct detail_data *data;
2028
2029 curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
2030 /* Actually, any index will do, since they all store the same data value */
2031 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
2032 free_detail_fields(data);
2033 set_fields_selection(hwnd, data, curSel);
2034 }
2035
2036 static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2037 LPARAM lp)
2038 {
2039 PROPSHEETPAGEW *page;
2040 struct detail_data *data;
2041
2042 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2043
2044 switch (msg)
2045 {
2046 case WM_INITDIALOG:
2047 page = (PROPSHEETPAGEW *)lp;
2048 data = (struct detail_data *)page->lParam;
2049 create_cert_details_list(hwnd, data);
2050 if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
2051 EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
2052 if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
2053 EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
2054 break;
2055 case WM_NOTIFY:
2056 {
2057 NMITEMACTIVATE *nm;
2058 HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
2059
2060 nm = (NMITEMACTIVATE*)lp;
2061 if (nm->hdr.hwndFrom == list && nm->uNewState & LVN_ITEMACTIVATE
2062 && nm->hdr.code == LVN_ITEMCHANGED)
2063 {
2064 data = (struct detail_data *)nm->lParam;
2065 if (nm->iItem >= 0 && data && nm->iItem < data->cFields)
2066 {
2067 WCHAR buf[MAX_STRING_LEN], *val = NULL;
2068 HWND valueCtl = GetDlgItem(hwnd, IDC_DETAIL_VALUE);
2069
2070 if (data->fields[nm->iItem].create)
2071 val = data->fields[nm->iItem].create(
2072 data->pCertViewInfo->pCertContext,
2073 data->fields[nm->iItem].param);
2074 else
2075 {
2076 LVITEMW item;
2077 int res;
2078
2079 item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
2080 item.mask = LVIF_TEXT;
2081 item.pszText = buf;
2082 item.iItem = nm->iItem;
2083 item.iSubItem = 1;
2084 res = SendMessageW(list, LVM_GETITEMW, 0, (LPARAM)&item);
2085 if (res)
2086 val = buf;
2087 }
2088 /* Select all the text in the control, the next update will
2089 * replace it
2090 */
2091 SendMessageW(valueCtl, EM_SETSEL, 0, -1);
2092 add_unformatted_text_to_control(valueCtl, val,
2093 val ? strlenW(val) : 0);
2094 if (val != buf)
2095 HeapFree(GetProcessHeap(), 0, val);
2096 }
2097 }
2098 break;
2099 }
2100 case WM_COMMAND:
2101 switch (wp)
2102 {
2103 case IDC_EXPORT:
2104 FIXME("call CryptUIWizExport\n");
2105 break;
2106 case IDC_EDITPROPERTIES:
2107 {
2108 HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2109 int curSel;
2110
2111 curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
2112 /* Actually, any index will do, since they all store the same
2113 * data value
2114 */
2115 data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA,
2116 curSel, 0);
2117 show_edit_cert_properties_dialog(GetParent(hwnd), data);
2118 break;
2119 }
2120 case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
2121 refresh_details_view(hwnd);
2122 break;
2123 }
2124 break;
2125 }
2126 return 0;
2127 }
2128
2129 static UINT CALLBACK detail_callback(HWND hwnd, UINT msg,
2130 PROPSHEETPAGEW *page)
2131 {
2132 struct detail_data *data;
2133
2134 switch (msg)
2135 {
2136 case PSPCB_RELEASE:
2137 data = (struct detail_data *)page->lParam;
2138 free_detail_fields(data);
2139 ImageList_Destroy(data->imageList);
2140 HeapFree(GetProcessHeap(), 0, data);
2141 break;
2142 }
2143 return 0;
2144 }
2145
2146 static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2147 BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
2148 {
2149 BOOL ret;
2150 struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
2151 sizeof(struct detail_data));
2152
2153 if (data)
2154 {
2155 data->pCertViewInfo = pCertViewInfo;
2156 data->pfPropertiesChanged = pfPropertiesChanged;
2157 data->cFields = 0;
2158 data->fields = NULL;
2159 data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 4, 0);
2160 if (data->imageList)
2161 {
2162 HBITMAP bmp;
2163 COLORREF backColor = RGB(255, 0, 255);
2164
2165 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
2166 ImageList_AddMasked(data->imageList, bmp, backColor);
2167 DeleteObject(bmp);
2168 ImageList_SetBkColor(data->imageList, CLR_NONE);
2169 }
2170 memset(page, 0, sizeof(PROPSHEETPAGEW));
2171 page->dwSize = sizeof(PROPSHEETPAGEW);
2172 page->dwFlags = PSP_USECALLBACK;
2173 page->pfnCallback = detail_callback;
2174 page->hInstance = hInstance;
2175 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
2176 page->pfnDlgProc = detail_dlg_proc;
2177 page->lParam = (LPARAM)data;
2178 ret = TRUE;
2179 }
2180 else
2181 ret = FALSE;
2182 return ret;
2183 }
2184
2185 struct hierarchy_data
2186 {
2187 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
2188 HIMAGELIST imageList;
2189 DWORD selectedCert;
2190 };
2191
2192 static LPARAM index_to_lparam(struct hierarchy_data *data, DWORD index)
2193 {
2194 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2195 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2196 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2197 data->pCertViewInfo->idxCounterSigner);
2198
2199 /* Takes advantage of the fact that a pointer is 32-bit aligned, and
2200 * therefore always even.
2201 */
2202 if (index == provSigner->csCertChain - 1)
2203 return (LPARAM)data;
2204 return index << 1 | 1;
2205 }
2206
2207 static inline DWORD lparam_to_index(struct hierarchy_data *data, LPARAM lp)
2208 {
2209 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2210 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2211 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2212 data->pCertViewInfo->idxCounterSigner);
2213
2214 if (!(lp & 1))
2215 return provSigner->csCertChain - 1;
2216 return lp >> 1;
2217 }
2218
2219 static struct hierarchy_data *get_hierarchy_data_from_tree_item(HWND tree,
2220 HTREEITEM hItem)
2221 {
2222 struct hierarchy_data *data = NULL;
2223 HTREEITEM root = NULL;
2224
2225 do {
2226 HTREEITEM parent = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM,
2227 TVGN_PARENT, (LPARAM)hItem);
2228
2229 if (!parent)
2230 root = hItem;
2231 hItem = parent;
2232 } while (hItem);
2233 if (root)
2234 {
2235 TVITEMW item;
2236
2237 item.mask = TVIF_PARAM;
2238 item.hItem = root;
2239 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
2240 data = (struct hierarchy_data *)item.lParam;
2241 }
2242 return data;
2243 }
2244
2245 static WCHAR *get_cert_display_name(PCCERT_CONTEXT cert)
2246 {
2247 WCHAR *name = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID);
2248
2249 if (!name)
2250 name = get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
2251 return name;
2252 }
2253
2254 static void show_cert_chain(HWND hwnd, struct hierarchy_data *data)
2255 {
2256 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2257 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2258 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2259 data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2260 data->pCertViewInfo->idxCounterSigner);
2261 DWORD i;
2262 HTREEITEM parent = NULL;
2263
2264 SendMessageW(tree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)data->imageList);
2265 for (i = provSigner->csCertChain; i; i--)
2266 {
2267 LPWSTR name;
2268
2269 name = get_cert_display_name(provSigner->pasCertChain[i - 1].pCert);
2270 if (name)
2271 {
2272 TVINSERTSTRUCTW tvis;
2273
2274 tvis.hParent = parent;
2275 tvis.hInsertAfter = TVI_LAST;
2276 tvis.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE |
2277 TVIF_SELECTEDIMAGE | TVIF_PARAM;
2278 tvis.u.item.pszText = name;
2279 tvis.u.item.state = TVIS_EXPANDED;
2280 tvis.u.item.stateMask = TVIS_EXPANDED;
2281 if (i == 1 &&
2282 (provSigner->pChainContext->TrustStatus.dwErrorStatus &
2283 CERT_TRUST_IS_PARTIAL_CHAIN))
2284 {
2285 /* The root of the chain has a special case: if the chain is
2286 * a partial chain, the icon is a warning icon rather than an
2287 * error icon.
2288 */
2289 tvis.u.item.iImage = 2;
2290 }
2291 else if (provSigner->pasCertChain[i - 1].pChainElement->TrustStatus.
2292 dwErrorStatus == 0)
2293 tvis.u.item.iImage = 0;
2294 else
2295 tvis.u.item.iImage = 1;
2296 tvis.u.item.iSelectedImage = tvis.u.item.iImage;
2297 tvis.u.item.lParam = index_to_lparam(data, i - 1);
2298 parent = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0,
2299 (LPARAM)&tvis);
2300 HeapFree(GetProcessHeap(), 0, name);
2301 }
2302 }
2303 }
2304
2305 static void set_certificate_status(HWND hwnd, CRYPT_PROVIDER_CERT *cert)
2306 {
2307 /* Select all the text in the control, the next update will replace it */
2308 SendMessageW(hwnd, EM_SETSEL, 0, -1);
2309 /* Set the highest priority error messages first. */
2310 if (!(cert->dwConfidence & CERT_CONFIDENCE_SIG))
2311 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_SIGNATURE);
2312 else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIME))
2313 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIME);
2314 else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIMENEST))
2315 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIMENEST);
2316 else if (cert->dwRevokedReason)
2317 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_REVOKED);
2318 else
2319 add_string_resource_to_control(hwnd, IDS_CERTIFICATE_VALID);
2320 }
2321
2322 static void set_certificate_status_for_end_cert(HWND hwnd,
2323 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2324 {
2325 HWND status = GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT);
2326 CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2327 (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
2328 pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
2329 pCertViewInfo->idxCounterSigner);
2330 CRYPT_PROVIDER_CERT *provCert = WTHelperGetProvCertFromChain(provSigner,
2331 pCertViewInfo->idxCert);
2332
2333 set_certificate_status(status, provCert);
2334 }
2335
2336 static void show_cert_hierarchy(HWND hwnd, struct hierarchy_data *data)
2337 {
2338 /* Disable view certificate button until a certificate is selected */
2339 EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), FALSE);
2340 show_cert_chain(hwnd, data);
2341 set_certificate_status_for_end_cert(hwnd, data->pCertViewInfo);
2342 }
2343
2344 static void show_dialog_for_selected_cert(HWND hwnd)
2345 {
2346 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2347 TVITEMW item;
2348 struct hierarchy_data *data;
2349 DWORD selection;
2350
2351 memset(&item, 0, sizeof(item));
2352 item.mask = TVIF_HANDLE | TVIF_PARAM;
2353 item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CARET,
2354 (LPARAM)NULL);
2355 SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
2356 data = get_hierarchy_data_from_tree_item(tree, item.hItem);
2357 selection = lparam_to_index(data, item.lParam);
2358 if (selection != 0)
2359 {
2360 CRYPT_PROVIDER_SGNR *provSigner;
2361 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
2362 BOOL changed = FALSE;
2363
2364 provSigner = WTHelperGetProvSignerFromChain(
2365 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2366 data->pCertViewInfo->idxSigner,
2367 data->pCertViewInfo->fCounterSigner,
2368 data->pCertViewInfo->idxCounterSigner);
2369 memset(&viewInfo, 0, sizeof(viewInfo));
2370 viewInfo.dwSize = sizeof(viewInfo);
2371 viewInfo.dwFlags = data->pCertViewInfo->dwFlags;
2372 viewInfo.szTitle = data->pCertViewInfo->szTitle;
2373 viewInfo.pCertContext = provSigner->pasCertChain[selection].pCert;
2374 viewInfo.cStores = data->pCertViewInfo->cStores;
2375 viewInfo.rghStores = data->pCertViewInfo->rghStores;
2376 viewInfo.cPropSheetPages = data->pCertViewInfo->cPropSheetPages;
2377 viewInfo.rgPropSheetPages = data->pCertViewInfo->rgPropSheetPages;
2378 viewInfo.nStartPage = data->pCertViewInfo->nStartPage;
2379 CryptUIDlgViewCertificateW(&viewInfo, &changed);
2380 if (changed)
2381 {
2382 /* Delete the contents of the tree */
2383 SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
2384 /* Reinitialize the tree */
2385 show_cert_hierarchy(hwnd, data);
2386 }
2387 }
2388 }
2389
2390 static LRESULT CALLBACK hierarchy_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2391 LPARAM lp)
2392 {
2393 PROPSHEETPAGEW *page;
2394 struct hierarchy_data *data;
2395 LRESULT ret = 0;
2396
2397 TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2398
2399 switch (msg)
2400 {
2401 case WM_INITDIALOG:
2402 page = (PROPSHEETPAGEW *)lp;
2403 data = (struct hierarchy_data *)page->lParam;
2404 show_cert_hierarchy(hwnd, data);
2405 break;
2406 case WM_NOTIFY:
2407 {
2408 NMHDR *hdr;
2409
2410 hdr = (NMHDR *)lp;
2411 switch (hdr->code)
2412 {
2413 case TVN_SELCHANGEDW:
2414 {
2415 NMTREEVIEWW *nm = (NMTREEVIEWW*)lp;
2416 HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2417 DWORD selection;
2418 CRYPT_PROVIDER_SGNR *provSigner;
2419
2420 data = get_hierarchy_data_from_tree_item(tree, nm->itemNew.hItem);
2421 selection = lparam_to_index(data, nm->itemNew.lParam);
2422 provSigner = WTHelperGetProvSignerFromChain(
2423 (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2424 data->pCertViewInfo->idxSigner,
2425 data->pCertViewInfo->fCounterSigner,
2426 data->pCertViewInfo->idxCounterSigner);
2427 EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), selection != 0);
2428 set_certificate_status(GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT),
2429 &provSigner->pasCertChain[selection]);
2430 break;
2431 }
2432 case NM_DBLCLK:
2433 show_dialog_for_selected_cert(hwnd);
2434 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
2435 ret = 1;
2436 break;
2437 }
2438 break;
2439 }
2440 case WM_COMMAND:
2441 switch (wp)
2442 {
2443 case IDC_VIEWCERTIFICATE:
2444 show_dialog_for_selected_cert(hwnd);
2445 break;
2446 }
2447 break;
2448 }
2449 return ret;
2450 }
2451
2452 static UINT CALLBACK hierarchy_callback(HWND hwnd, UINT msg,
2453 PROPSHEETPAGEW *page)
2454 {
2455 struct hierarchy_data *data;
2456
2457 switch (msg)
2458 {
2459 case PSPCB_RELEASE:
2460 data = (struct hierarchy_data *)page->lParam;
2461 ImageList_Destroy(data->imageList);
2462 HeapFree(GetProcessHeap(), 0, data);
2463 break;
2464 }
2465 return 0;
2466 }
2467
2468 static BOOL init_hierarchy_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2469 PROPSHEETPAGEW *page)
2470 {
2471 struct hierarchy_data *data = HeapAlloc(GetProcessHeap(), 0,
2472 sizeof(struct hierarchy_data));
2473 BOOL ret = FALSE;
2474
2475 if (data)
2476 {
2477 data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
2478 if (data->imageList)
2479 {
2480 HBITMAP bmp;
2481 COLORREF backColor = RGB(255, 0, 255);
2482
2483 data->pCertViewInfo = pCertViewInfo;
2484 data->selectedCert = 0xffffffff;
2485
2486 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
2487 ImageList_AddMasked(data->imageList, bmp, backColor);
2488 DeleteObject(bmp);
2489 ImageList_SetBkColor(data->imageList, CLR_NONE);
2490
2491 memset(page, 0, sizeof(PROPSHEETPAGEW));
2492 page->dwSize = sizeof(PROPSHEETPAGEW);
2493 page->dwFlags = PSP_USECALLBACK;
2494 page->hInstance = hInstance;
2495 page->u.pszTemplate = MAKEINTRESOURCEW(IDD_HIERARCHY);
2496 page->pfnDlgProc = hierarchy_dlg_proc;
2497 page->lParam = (LPARAM)data;
2498 page->pfnCallback = hierarchy_callback;
2499 ret = TRUE;
2500 }
2501 else
2502 HeapFree(GetProcessHeap(), 0, data);
2503 }
2504 return ret;
2505 }
2506
2507 static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
2508 {
2509 RECT rc;
2510 POINT topLeft;
2511
2512 TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
2513
2514 switch (msg)
2515 {
2516 case PSCB_INITIALIZED:
2517 /* Get cancel button's position.. */
2518 GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
2519 topLeft.x = rc.left;
2520 topLeft.y = rc.top;
2521 ScreenToClient(hwnd, &topLeft);
2522 /* hide the cancel button.. */
2523 ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
2524 /* get the OK button's size.. */
2525 GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
2526 /* and move the OK button to the cancel button's original position. */
2527 MoveWindow(GetDlgItem(hwnd, IDOK), topLeft.x, topLeft.y,
2528 rc.right - rc.left, rc.bottom - rc.top, FALSE);
2529 GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
2530 break;
2531 }
2532 return 0;
2533 }
2534
2535 static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2536 CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
2537 {
2538 static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
2539 DWORD nPages;
2540 PROPSHEETPAGEW *pages;
2541 BOOL ret = FALSE;
2542 HMODULE lib = LoadLibraryW(riched);
2543
2544 nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
2545 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
2546 nPages++;
2547 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
2548 nPages++;
2549 pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
2550 if (pages)
2551 {
2552 PROPSHEETHEADERW hdr;
2553 CRYPTUI_INITDIALOG_STRUCT *init = NULL;
2554 DWORD i;
2555
2556 memset(&hdr, 0, sizeof(hdr));
2557 hdr.dwSize = sizeof(hdr);
2558 hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
2559 hdr.hInstance = hInstance;
2560 if (pCertViewInfo->szTitle)
2561 hdr.pszCaption = pCertViewInfo->szTitle;
2562 else
2563 hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
2564 init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
2565 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
2566 {
2567 if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
2568 &pages[hdr.nPages]))
2569 hdr.nPages++;
2570 }
2571 if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
2572 {
2573 if (init_hierarchy_page(pCertViewInfo, &pages[hdr.nPages]))
2574 hdr.nPages++;
2575 }
2576 /* Copy each additional page, and create the init dialog struct for it
2577 */
2578 if (pCertViewInfo->cPropSheetPages)
2579 {
2580 init = HeapAlloc(GetProcessHeap(), 0,
2581 pCertViewInfo->cPropSheetPages *
2582 sizeof(CRYPTUI_INITDIALOG_STRUCT));
2583 if (init)
2584 {
2585 for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
2586 {
2587 memcpy(&pages[hdr.nPages + i],
2588 &pCertViewInfo->rgPropSheetPages[i],
2589 sizeof(PROPSHEETPAGEW));
2590 init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
2591 init[i].pCertContext = pCertViewInfo->pCertContext;
2592 pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
2593 }
2594 if (pCertViewInfo->nStartPage & 0x8000)
2595 {
2596 /* Start page index is relative to the number of default
2597 * pages
2598 */
2599 hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
2600 }
2601 else
2602 hdr.u2.nStartPage = pCertViewInfo->nStartPage;
2603 hdr.nPages = nPages;
2604 ret = TRUE;
2605 }
2606 else
2607 SetLastError(ERROR_OUTOFMEMORY);
2608 }
2609 else
2610 {
2611 /* Ignore the relative flag if there aren't any additional pages */
2612 hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
2613 ret = TRUE;
2614 }
2615 if (ret)
2616 {
2617 INT_PTR l;
2618
2619 hdr.u3.ppsp = pages;
2620 hdr.pfnCallback = cert_prop_sheet_proc;
2621 l = PropertySheetW(&hdr);
2622 if (l == 0)
2623 {
2624 SetLastError(ERROR_CANCELLED);
2625 ret = FALSE;
2626 }
2627 }
2628 HeapFree(GetProcessHeap(), 0, init);
2629 HeapFree(GetProcessHeap(), 0, pages);
2630 }
2631 else
2632 SetLastError(ERROR_OUTOFMEMORY);
2633 FreeLibrary(lib);
2634 return ret;
2635 }
2636
2637 /***********************************************************************
2638 * CryptUIDlgViewCertificateW (CRYPTUI.@)
2639 */
2640 BOOL WINAPI CryptUIDlgViewCertificateW(
2641 PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
2642 {
2643 static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
2644 CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
2645 WINTRUST_DATA wvt;
2646 WINTRUST_CERT_INFO cert;
2647 BOOL ret = FALSE;
2648 CRYPT_PROVIDER_SGNR *signer;
2649 CRYPT_PROVIDER_CERT *provCert = NULL;
2650
2651 TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
2652
2653 if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
2654 {
2655 SetLastError(ERROR_INVALID_PARAMETER);
2656 return FALSE;
2657 }
2658 /* Make a local copy in case we have to call WinVerifyTrust ourselves */
2659 memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
2660 if (!viewInfo.u.hWVTStateData)
2661 {
2662 memset(&wvt, 0, sizeof(wvt));
2663 wvt.cbStruct = sizeof(wvt);
2664 wvt.dwUIChoice = WTD_UI_NONE;
2665 if (viewInfo.dwFlags &
2666 CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
2667 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
2668 if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
2669 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
2670 if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
2671 wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
2672 wvt.dwUnionChoice = WTD_CHOICE_CERT;
2673 memset(&cert, 0, sizeof(cert));
2674 cert.cbStruct = sizeof(cert);
2675 cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
2676 cert.chStores = viewInfo.cStores;
2677 cert.pahStores = viewInfo.rghStores;
2678 wvt.u.pCert = &cert;
2679 wvt.dwStateAction = WTD_STATEACTION_VERIFY;
2680 WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
2681 viewInfo.u.pCryptProviderData =
2682 WTHelperProvDataFromStateData(wvt.hWVTStateData);
2683 signer = WTHelperGetProvSignerFromChain(
2684 (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
2685 provCert = WTHelperGetProvCertFromChain(signer, 0);
2686 ret = TRUE;
2687 }
2688 else
2689 {
2690 viewInfo.u.pCryptProviderData =
2691 WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
2692 signer = WTHelperGetProvSignerFromChain(
2693 (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
2694 viewInfo.idxSigner, viewInfo.fCounterSigner,
2695 viewInfo.idxCounterSigner);
2696 provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
2697 ret = TRUE;
2698 }
2699 if (ret)
2700 {
2701 ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
2702 if (!viewInfo.u.hWVTStateData)
2703 {
2704 wvt.dwStateAction = WTD_STATEACTION_CLOSE;
2705 WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
2706 }
2707 }
2708 return ret;
2709 }
2710
2711 static PCCERT_CONTEXT make_cert_from_file(LPCWSTR fileName)
2712 {
2713 HANDLE file;
2714 DWORD size, encoding = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
2715 BYTE *buffer;
2716 PCCERT_CONTEXT cert;
2717
2718 file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
2719 OPEN_EXISTING, 0, NULL);
2720 if (file == INVALID_HANDLE_VALUE)
2721 {
2722 WARN("can't open certificate file %s\n", debugstr_w(fileName));
2723 return NULL;
2724 }
2725 if ((size = GetFileSize(file, NULL)))
2726 {
2727 if ((buffer = HeapAlloc(GetProcessHeap(), 0, size)))
2728 {
2729 DWORD read;
2730 if (!ReadFile(file, buffer, size, &read, NULL) || read != size)
2731 {
2732 WARN("can't read certificate file %s\n", debugstr_w(fileName));
2733 HeapFree(GetProcessHeap(), 0, buffer);
2734 CloseHandle(file);
2735 return NULL;
2736 }
2737 }
2738 }
2739 else
2740 {
2741 WARN("empty file %s\n", debugstr_w(fileName));
2742 CloseHandle(file);
2743 return NULL;
2744 }
2745 CloseHandle(file);
2746 cert = CertCreateCertificateContext(encoding, buffer, size);
2747 HeapFree(GetProcessHeap(), 0, buffer);
2748 return cert;
2749 }
2750
2751 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
2752 * or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
2753 * should be a CA. If neither extension is present, returns
2754 * defaultIfNotSpecified.
2755 */
2756 static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
2757 {
2758 BOOL isCA = defaultIfNotSpecified;
2759 PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
2760 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
2761
2762 if (ext)
2763 {
2764 CERT_BASIC_CONSTRAINTS_INFO *info;
2765 DWORD size = 0;
2766
2767 if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
2768 ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
2769 NULL, (LPBYTE)&info, &size))
2770 {
2771 if (info->SubjectType.cbData == 1)
2772 isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
2773 LocalFree(info);
2774 }
2775 }
2776 else
2777 {
2778 ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
2779 cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
2780 if (ext)
2781 {
2782 CERT_BASIC_CONSTRAINTS2_INFO info;
2783 DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
2784
2785 if (CryptDecodeObjectEx(X509_ASN_ENCODING,
2786 szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
2787 0, NULL, &info, &size))
2788 isCA = info.fCA;
2789 }
2790 }
2791 return isCA;
2792 }
2793
2794 static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
2795 {
2796 static const WCHAR AddressBook[] = { 'A','d','d','r','e','s','s',
2797 'B','o','o','k',0 };
2798 static const WCHAR CA[] = { 'C','A',0 };
2799 LPCWSTR storeName;
2800
2801 if (is_ca_cert(cert, TRUE))
2802 storeName = CA;
2803 else
2804 storeName = AddressBook;
2805 return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
2806 CERT_SYSTEM_STORE_CURRENT_USER, storeName);
2807 }
2808
2809 BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
2810 PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
2811 {
2812 BOOL ret;
2813 HCERTSTORE store;
2814 const CERT_CONTEXT *cert;
2815 BOOL freeCert = FALSE;
2816
2817 TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
2818 pImportSrc, hDestCertStore);
2819
2820 if (!(dwFlags & CRYPTUI_WIZ_NO_UI)) FIXME("UI not implemented\n");
2821
2822 if (!pImportSrc ||
2823 pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
2824 {
2825 SetLastError(E_INVALIDARG);
2826 return FALSE;
2827 }
2828
2829 switch (pImportSrc->dwSubjectChoice)
2830 {
2831 case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
2832 if (!(cert = make_cert_from_file(pImportSrc->u.pwszFileName)))
2833 {
2834 WARN("unable to create certificate context\n");
2835 return FALSE;
2836 }
2837 else
2838 freeCert = TRUE;
2839 break;
2840 case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
2841 cert = pImportSrc->u.pCertContext;
2842 if (!cert)
2843 {
2844 SetLastError(E_INVALIDARG);
2845 return FALSE;
2846 }
2847 break;
2848 default:
2849 FIXME("source type not implemented: %u\n", pImportSrc->dwSubjectChoice);
2850 SetLastError(E_INVALIDARG);
2851 return FALSE;
2852 }
2853 if (hDestCertStore) store = hDestCertStore;
2854 else
2855 {
2856 if (!(store = choose_store_for_cert(cert)))
2857 {
2858 WARN("unable to open certificate store\n");
2859 CertFreeCertificateContext(cert);
2860 return FALSE;
2861 }
2862 }
2863 ret = CertAddCertificateContextToStore(store, cert, CERT_STORE_ADD_REPLACE_EXISTING, NULL);
2864
2865 if (!hDestCertStore) CertCloseStore(store, 0);
2866 if (freeCert)
2867 CertFreeCertificateContext(cert);
2868 return ret;
2869 }