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