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

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