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