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

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