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