git.oblomov.eu Git - wine/blob - dlls/cryptui/main.c

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