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