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 "commctrl.h"
  36 #include "cryptuiapi.h"
  37 #include "cryptuires.h"
  38 #include "urlmon.h"
  39 #include "hlink.h"
  40 #include "wine/debug.h"
  41 #include "wine/unicode.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(cryptui);
  44
  45 static HINSTANCE hInstance;
  46
  47 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  48 {
  49     TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
  50
  51     switch (fdwReason)
  52     {
  53         case DLL_WINE_PREATTACH:
  54             return FALSE;    /* prefer native version */
  55         case DLL_PROCESS_ATTACH:
  56             hInstance = hinstDLL;
  57             DisableThreadLibraryCalls(hinstDLL);
  58             break;
  59         case DLL_PROCESS_DETACH:
  60             break;
  61         default:
  62             break;
  63     }
  64     return TRUE;
  65 }
  66
  67 /***********************************************************************
  68  *              CryptUIDlgCertMgr (CRYPTUI.@)
  69  */
  70 BOOL WINAPI CryptUIDlgCertMgr(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr)
  71 {
  72     FIXME("(%p): stub\n", pCryptUICertMgr);
  73     return FALSE;
  74 }
  75
  76 /***********************************************************************
  77  *              CryptUIDlgViewCertificateA (CRYPTUI.@)
  78  */
  79 BOOL WINAPI CryptUIDlgViewCertificateA(
  80  PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
  81 {
  82     CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
  83     LPWSTR title = NULL;
  84     BOOL ret;
  85
  86     TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
  87
  88     memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
  89     if (pCertViewInfo->szTitle)
  90     {
  91         int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
  92          NULL, 0);
  93
  94         title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  95         if (title)
  96         {
  97             MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
  98              len);
  99             viewInfo.szTitle = title;
 100         }
 101         else
 102         {
 103             ret = FALSE;
 104             goto error;
 105         }
 106     }
 107     if (pCertViewInfo->cPropSheetPages)
 108     {
 109         FIXME("ignoring additional prop sheet pages\n");
 110         viewInfo.cPropSheetPages = 0;
 111     }
 112     ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
 113     HeapFree(GetProcessHeap(), 0, title);
 114 error:
 115     return ret;
 116 }
 117
 118 struct ReadStringStruct
 119 {
 120     LPCWSTR buf;
 121     LONG pos;
 122     LONG len;
 123 };
 124
 125 static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
 126  LONG cb, LONG *pcb)
 127 {
 128     struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
 129     LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
 130
 131     TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
 132
 133     memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
 134     string->pos += cch;
 135     *pcb = cch * sizeof(WCHAR);
 136     return 0;
 137 }
 138
 139 static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
 140 {
 141     struct ReadStringStruct string;
 142     EDITSTREAM editstream;
 143
 144     TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
 145
 146     string.buf = text;
 147     string.pos = 0;
 148     string.len = len;
 149     editstream.dwCookie = (DWORD_PTR)&string;
 150     editstream.dwError = 0;
 151     editstream.pfnCallback = read_text_callback;
 152     SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
 153      (LPARAM)&editstream);
 154 }
 155
 156 static void add_string_resource_to_control(HWND hwnd, int id)
 157 {
 158     LPWSTR str;
 159     LONG len;
 160
 161     len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
 162     add_unformatted_text_to_control(hwnd, str, len);
 163 }
 164
 165 static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
 166  LONG len, const PARAFORMAT2 *fmt)
 167 {
 168     add_unformatted_text_to_control(hwnd, text, len);
 169     SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
 170 }
 171
 172 static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
 173  const PARAFORMAT2 *fmt)
 174 {
 175     LPWSTR str;
 176     LONG len;
 177
 178     len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
 179     add_text_with_paraformat_to_control(hwnd, str, len, fmt);
 180 }
 181
 182 static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
 183  DWORD dwFlags)
 184 {
 185     LPWSTR buf = NULL;
 186     DWORD len;
 187
 188     len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
 189     if (len)
 190     {
 191         buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 192         if (buf)
 193             CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
 194     }
 195     return buf;
 196 }
 197
 198 static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
 199  DWORD dwType, DWORD dwFlags)
 200 {
 201     LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
 202
 203     if (name)
 204     {
 205         /* Don't include NULL-terminator in output */
 206         DWORD len = lstrlenW(name);
 207
 208         add_unformatted_text_to_control(hwnd, name, len);
 209         HeapFree(GetProcessHeap(), 0, name);
 210     }
 211 }
 212
 213 static void add_icon_to_control(HWND hwnd, int id)
 214 {
 215     HRESULT hr;
 216     LPRICHEDITOLE richEditOle = NULL;
 217     LPOLEOBJECT object = NULL;
 218     CLSID clsid;
 219     LPOLECACHE oleCache = NULL;
 220     FORMATETC formatEtc;
 221     DWORD conn;
 222     LPDATAOBJECT dataObject = NULL;
 223     HBITMAP bitmap = NULL;
 224     RECT rect;
 225     STGMEDIUM stgm;
 226     REOBJECT reObject;
 227
 228     TRACE("(%p, %d)\n", hwnd, id);
 229
 230     SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
 231     if (!richEditOle)
 232         goto end;
 233     hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
 234      (void**)&object);
 235     if (FAILED(hr))
 236         goto end;
 237     hr = IOleObject_GetUserClassID(object, &clsid);
 238     if (FAILED(hr))
 239         goto end;
 240     hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
 241     if (FAILED(hr))
 242         goto end;
 243     formatEtc.cfFormat = CF_BITMAP;
 244     formatEtc.ptd = NULL;
 245     formatEtc.dwAspect = DVASPECT_CONTENT;
 246     formatEtc.lindex = -1;
 247     formatEtc.tymed = TYMED_GDI;
 248     hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
 249     if (FAILED(hr))
 250         goto end;
 251     hr = IOleObject_QueryInterface(object, &IID_IDataObject,
 252      (void**)&dataObject);
 253     if (FAILED(hr))
 254         goto end;
 255     bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
 256      LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
 257     if (!bitmap)
 258         goto end;
 259     rect.left = rect.top = 0;
 260     rect.right = GetSystemMetrics(SM_CXICON);
 261     rect.bottom = GetSystemMetrics(SM_CYICON);
 262     stgm.tymed = TYMED_GDI;
 263     stgm.u.hBitmap = bitmap;
 264     stgm.pUnkForRelease = NULL;
 265     hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
 266     if (FAILED(hr))
 267         goto end;
 268
 269     reObject.cbStruct = sizeof(reObject);
 270     reObject.cp = REO_CP_SELECTION;
 271     reObject.clsid = clsid;
 272     reObject.poleobj = object;
 273     reObject.pstg = NULL;
 274     reObject.polesite = NULL;
 275     reObject.sizel.cx = reObject.sizel.cy = 0;
 276     reObject.dvaspect = DVASPECT_CONTENT;
 277     reObject.dwFlags = 0;
 278     reObject.dwUser = 0;
 279
 280     IRichEditOle_InsertObject(richEditOle, &reObject);
 281
 282 end:
 283     if (dataObject)
 284         IDataObject_Release(dataObject);
 285     if (oleCache)
 286         IOleCache_Release(oleCache);
 287     if (object)
 288         IOleObject_Release(object);
 289     if (richEditOle)
 290         IRichEditOle_Release(richEditOle);
 291 }
 292
 293 #define MY_INDENT 200
 294
 295 static void add_oid_text_to_control(HWND hwnd, char *oid)
 296 {
 297     WCHAR nl = '\n';
 298     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
 299     PARAFORMAT2 parFmt;
 300
 301     parFmt.cbSize = sizeof(parFmt);
 302     parFmt.dwMask = PFM_STARTINDENT;
 303     parFmt.dxStartIndent = MY_INDENT * 3;
 304     if (oidInfo)
 305     {
 306         add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
 307          lstrlenW(oidInfo->pwszName), &parFmt);
 308         add_unformatted_text_to_control(hwnd, &nl, 1);
 309     }
 310 }
 311
 312 #define MAX_STRING_LEN 512
 313
 314 struct OIDToString
 315 {
 316     LPCSTR oid;
 317     int    id;
 318 };
 319
 320 /* The following list MUST be lexicographically sorted by OID */
 321 static struct OIDToString oidMap[] = {
 322  /* 1.3.6.1.4.1.311.10.3.1 */
 323  { szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
 324  /* 1.3.6.1.4.1.311.10.3.4 */
 325  { szOID_KP_EFS, IDS_PURPOSE_EFS },
 326  /* 1.3.6.1.4.1.311.10.3.4.1 */
 327  { szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
 328  /* 1.3.6.1.4.1.311.10.3.5 */
 329  { szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
 330  /* 1.3.6.1.4.1.311.10.3.6 */
 331  { szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
 332  /* 1.3.6.1.4.1.311.10.3.7 */
 333  { szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
 334  /* 1.3.6.1.4.1.311.10.3.8 */
 335  { szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
 336  /* 1.3.6.1.4.1.311.10.3.9 */
 337  { szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
 338  /* 1.3.6.1.4.1.311.10.3.10 */
 339  { szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
 340  /* 1.3.6.1.4.1.311.10.3.11 */
 341  { szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
 342  /* 1.3.6.1.4.1.311.10.3.12 */
 343  { szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
 344  /* 1.3.6.1.4.1.311.10.3.13 */
 345  { szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
 346  /* 1.3.6.1.4.1.311.10.5.1 */
 347  { szOID_DRM, IDS_PURPOSE_DRM },
 348  /* 1.3.6.1.4.1.311.10.6.1 */
 349  { szOID_LICENSES, IDS_PURPOSE_LICENSES },
 350  /* 1.3.6.1.4.1.311.10.6.2 */
 351  { szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
 352  /* 1.3.6.1.4.1.311.20.2.1 */
 353  { szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
 354  /* 1.3.6.1.4.1.311.20.2.2 */
 355  { szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
 356  /* 1.3.6.1.4.1.311.21.5 */
 357  { szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
 358  /* 1.3.6.1.4.1.311.21.6 */
 359  { szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
 360  /* 1.3.6.1.4.1.311.21.19 */
 361  { szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
 362  /* 1.3.6.1.5.5.7.3.1 */
 363  { szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
 364  /* 1.3.6.1.5.5.7.3.2 */
 365  { szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
 366  /* 1.3.6.1.5.5.7.3.3 */
 367  { szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
 368  /* 1.3.6.1.5.5.7.3.4 */
 369  { szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
 370  /* 1.3.6.1.5.5.7.3.5 */
 371  { szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
 372  /* 1.3.6.1.5.5.7.3.6 */
 373  { szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
 374  /* 1.3.6.1.5.5.7.3.7 */
 375  { szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
 376  /* 1.3.6.1.5.5.7.3.8 */
 377  { szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
 378 };
 379
 380 static struct OIDToString *findSupportedOID(LPCSTR oid)
 381 {
 382     int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0, i;
 383     struct OIDToString *ret = NULL;
 384
 385     for (i = (indexLow + indexHigh) / 2; !ret && indexLow <= indexHigh;
 386      i = (indexLow + indexHigh) / 2)
 387     {
 388         int cmp;
 389
 390         cmp = strcmp(oid, oidMap[i].oid);
 391         if (!cmp)
 392             ret = &oidMap[i];
 393         else if (cmp > 0)
 394             indexLow = i + 1;
 395         else
 396             indexHigh = i - 1;
 397     }
 398     return ret;
 399 }
 400
 401 static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
 402 {
 403     struct OIDToString *entry;
 404     WCHAR nl = '\n';
 405     PARAFORMAT2 parFmt;
 406
 407     parFmt.cbSize = sizeof(parFmt);
 408     parFmt.dwMask = PFM_STARTINDENT;
 409     parFmt.dxStartIndent = MY_INDENT * 3;
 410     if ((entry = findSupportedOID(oid)))
 411     {
 412         WCHAR *str, *linebreak, *ptr;
 413         BOOL multiline = FALSE;
 414         int len;
 415
 416         len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
 417         ptr = str;
 418         do {
 419             if ((linebreak = memchrW(ptr, '\n', len)))
 420             {
 421                 WCHAR copy[MAX_STRING_LEN];
 422
 423                 multiline = TRUE;
 424                 /* The source string contains a newline, which the richedit
 425                  * control won't find since it's interpreted as a paragraph
 426                  * break.  Therefore copy up to the newline.  lstrcpynW always
 427                  * NULL-terminates, so pass one more than the length of the
 428                  * source line so the copy includes the entire line and the
 429                  * NULL-terminator.
 430                  */
 431                 lstrcpynW(copy, ptr, linebreak - ptr + 1);
 432                 add_text_with_paraformat_to_control(text, copy,
 433                  linebreak - ptr, &parFmt);
 434                 ptr = linebreak + 1;
 435                 add_unformatted_text_to_control(text, &nl, 1);
 436             }
 437             else if (multiline && *ptr)
 438             {
 439                 /* Add the last line */
 440                 add_text_with_paraformat_to_control(text, ptr,
 441                  len - (ptr - str), &parFmt);
 442                 add_unformatted_text_to_control(text, &nl, 1);
 443             }
 444         } while (linebreak);
 445         if (!multiline)
 446         {
 447             add_text_with_paraformat_to_control(text, str, len, &parFmt);
 448             add_unformatted_text_to_control(text, &nl, 1);
 449         }
 450     }
 451     else
 452     {
 453         WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
 454          (strlen(oid) + 1) * sizeof(WCHAR));
 455
 456         if (oidW)
 457         {
 458             LPCSTR src;
 459             WCHAR *dst;
 460
 461             for (src = oid, dst = oidW; *src; src++, dst++)
 462                 *dst = *src;
 463             *dst = 0;
 464             add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
 465              &parFmt);
 466             add_unformatted_text_to_control(text, &nl, 1);
 467             HeapFree(GetProcessHeap(), 0, oidW);
 468         }
 469     }
 470 }
 471
 472 static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
 473  BOOL *anyUsageAdded)
 474 {
 475     static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
 476     WCHAR nl = '\n';
 477     CHARFORMATW charFmt;
 478     PCERT_EXTENSION policyExt;
 479     if (!*anyUsageAdded)
 480     {
 481         PARAFORMAT2 parFmt;
 482
 483         parFmt.cbSize = sizeof(parFmt);
 484         parFmt.dwMask = PFM_STARTINDENT;
 485         parFmt.dxStartIndent = MY_INDENT;
 486         add_string_resource_with_paraformat_to_control(text,
 487          IDS_CERT_INFO_PURPOSES, &parFmt);
 488         add_unformatted_text_to_control(text, &nl, 1);
 489         *anyUsageAdded = TRUE;
 490     }
 491     memset(&charFmt, 0, sizeof(charFmt));
 492     charFmt.cbSize = sizeof(charFmt);
 493     charFmt.dwMask = CFM_BOLD;
 494     charFmt.dwEffects = 0;
 495     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 496     if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
 497      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
 498     {
 499         CERT_POLICIES_INFO *policies;
 500         DWORD size;
 501
 502         if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
 503          policyExt->Value.pbData, policyExt->Value.cbData,
 504          CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
 505         {
 506             DWORD i;
 507
 508             for (i = 0; i < policies->cPolicyInfo; i++)
 509             {
 510                 DWORD j;
 511
 512                 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
 513                     add_local_oid_text_to_control(text,
 514                      policies->rgPolicyInfo[i].rgPolicyQualifier[j].
 515                      pszPolicyQualifierId);
 516             }
 517             LocalFree(policies);
 518         }
 519     }
 520     else
 521         add_oid_text_to_control(text, any_app_policy);
 522 }
 523
 524 static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
 525  BOOL *anyUsageAdded)
 526 {
 527     WCHAR nl = '\n';
 528     DWORD size;
 529     BOOL badUsages = FALSE;
 530
 531     if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
 532     {
 533         CHARFORMATW charFmt;
 534         static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
 535         PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
 536
 537         if (usage)
 538         {
 539             if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
 540             {
 541                 DWORD i;
 542
 543                 if (!*anyUsageAdded)
 544                 {
 545                     PARAFORMAT2 parFmt;
 546
 547                     parFmt.cbSize = sizeof(parFmt);
 548                     parFmt.dwMask = PFM_STARTINDENT;
 549                     parFmt.dxStartIndent = MY_INDENT;
 550                     add_string_resource_with_paraformat_to_control(text,
 551                      IDS_CERT_INFO_PURPOSES, &parFmt);
 552                     add_unformatted_text_to_control(text, &nl, 1);
 553                     *anyUsageAdded = TRUE;
 554                 }
 555                 memset(&charFmt, 0, sizeof(charFmt));
 556                 charFmt.cbSize = sizeof(charFmt);
 557                 charFmt.dwMask = CFM_BOLD;
 558                 charFmt.dwEffects = 0;
 559                 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
 560                  (LPARAM)&charFmt);
 561                 if (!usage->cUsageIdentifier)
 562                     add_oid_text_to_control(text, any_cert_policy);
 563                 else
 564                     for (i = 0; i < usage->cUsageIdentifier; i++)
 565                         add_local_oid_text_to_control(text,
 566                          usage->rgpszUsageIdentifier[i]);
 567             }
 568             else
 569                 badUsages = TRUE;
 570             HeapFree(GetProcessHeap(), 0, usage);
 571         }
 572         else
 573             badUsages = TRUE;
 574     }
 575     else
 576         badUsages = TRUE;
 577     return badUsages;
 578 }
 579
 580 static void set_policy_text(HWND text,
 581  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 582 {
 583     BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
 584     BOOL badUsages = FALSE, anyUsageAdded = FALSE;
 585
 586     if (pCertViewInfo->cPurposes)
 587     {
 588         DWORD i;
 589
 590         for (i = 0; i < pCertViewInfo->cPurposes; i++)
 591         {
 592             if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
 593                 includeCertUsages = TRUE;
 594             else if (!strcmp(pCertViewInfo->rgszPurposes[i],
 595              szOID_ANY_APPLICATION_POLICY))
 596                 includeAppUsages = TRUE;
 597             else
 598                 badUsages = TRUE;
 599         }
 600     }
 601     else
 602         includeAppUsages = includeCertUsages = TRUE;
 603     if (includeAppUsages)
 604         display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
 605     if (includeCertUsages)
 606         badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
 607          &anyUsageAdded);
 608     if (badUsages)
 609     {
 610         PARAFORMAT2 parFmt;
 611
 612         parFmt.cbSize = sizeof(parFmt);
 613         parFmt.dwMask = PFM_STARTINDENT;
 614         parFmt.dxStartIndent = MY_INDENT;
 615         add_string_resource_with_paraformat_to_control(text,
 616          IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
 617     }
 618 }
 619
 620 static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
 621  LPCSTR policyOid)
 622 {
 623     CRYPT_OBJID_BLOB *ret = NULL;
 624     DWORD i;
 625
 626     for (i = 0; !ret && i < policies->cPolicyInfo; i++)
 627     {
 628         DWORD j;
 629
 630         for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
 631             if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
 632              pszPolicyQualifierId, policyOid))
 633                 ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
 634                  Qualifier;
 635     }
 636     return ret;
 637 }
 638
 639 static WCHAR *get_cps_str_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
 640 {
 641     LPWSTR qualifierStr = NULL;
 642     CERT_NAME_VALUE *qualifierValue;
 643     DWORD size;
 644
 645     if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
 646      qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
 647      &qualifierValue, &size))
 648     {
 649         size = CertRDNValueToStrW(qualifierValue->dwValueType,
 650          &qualifierValue->Value, NULL, 0);
 651         qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 652         if (qualifierStr)
 653             CertRDNValueToStrW(qualifierValue->dwValueType,
 654              &qualifierValue->Value, qualifierStr, size);
 655         LocalFree(qualifierValue);
 656     }
 657     return qualifierStr;
 658 }
 659
 660 static WCHAR *get_user_notice_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
 661 {
 662     LPWSTR str = NULL;
 663     CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
 664     DWORD size;
 665
 666     if (CryptDecodeObjectEx(X509_ASN_ENCODING,
 667      X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
 668      qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
 669      &qualifierValue, &size))
 670     {
 671         str = HeapAlloc(GetProcessHeap(), 0,
 672          (strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
 673         if (str)
 674             strcpyW(str, qualifierValue->pszDisplayText);
 675         LocalFree(qualifierValue);
 676     }
 677     return str;
 678 }
 679
 680 struct IssuerStatement
 681 {
 682     LPWSTR cps;
 683     LPWSTR userNotice;
 684 };
 685
 686 static void set_issuer_statement(HWND hwnd,
 687  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 688 {
 689     PCERT_EXTENSION policyExt;
 690
 691     if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
 692      (policyExt = CertFindExtension(szOID_CERT_POLICIES,
 693      pCertViewInfo->pCertContext->pCertInfo->cExtension,
 694      pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
 695     {
 696         CERT_POLICIES_INFO *policies;
 697         DWORD size;
 698
 699         if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
 700          policyExt->Value.pbData, policyExt->Value.cbData,
 701          CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
 702         {
 703             CRYPT_OBJID_BLOB *qualifier;
 704             LPWSTR cps = NULL, userNotice = NULL;
 705
 706             if ((qualifier = find_policy_qualifier(policies,
 707              szOID_PKIX_POLICY_QUALIFIER_CPS)))
 708                 cps = get_cps_str_from_qualifier(qualifier);
 709             if ((qualifier = find_policy_qualifier(policies,
 710              szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
 711                 userNotice = get_user_notice_from_qualifier(qualifier);
 712             if (cps || userNotice)
 713             {
 714                 struct IssuerStatement *issuerStatement =
 715                  HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
 716
 717                 if (issuerStatement)
 718                 {
 719                     issuerStatement->cps = cps;
 720                     issuerStatement->userNotice = userNotice;
 721                     EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
 722                     SetWindowLongPtrW(hwnd, DWLP_USER,
 723                      (ULONG_PTR)issuerStatement);
 724                 }
 725             }
 726             LocalFree(policies);
 727         }
 728     }
 729 }
 730
 731 static void set_cert_info(HWND hwnd,
 732  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 733 {
 734     CHARFORMATW charFmt;
 735     PARAFORMAT2 parFmt;
 736     HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
 737     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
 738     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
 739      (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
 740      pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
 741      pCertViewInfo->idxCounterSigner);
 742     CRYPT_PROVIDER_CERT *root =
 743      &provSigner->pasCertChain[provSigner->csCertChain - 1];
 744
 745     if (provSigner->pChainContext->TrustStatus.dwErrorStatus &
 746      CERT_TRUST_IS_PARTIAL_CHAIN)
 747         add_icon_to_control(icon, IDB_CERT_WARNING);
 748     else if (!root->fTrustedRoot)
 749         add_icon_to_control(icon, IDB_CERT_ERROR);
 750     else
 751         add_icon_to_control(icon, IDB_CERT);
 752
 753     memset(&charFmt, 0, sizeof(charFmt));
 754     charFmt.cbSize = sizeof(charFmt);
 755     charFmt.dwMask = CFM_BOLD;
 756     charFmt.dwEffects = CFE_BOLD;
 757     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 758     /* FIXME: vertically center text */
 759     parFmt.cbSize = sizeof(parFmt);
 760     parFmt.dwMask = PFM_STARTINDENT;
 761     parFmt.dxStartIndent = MY_INDENT;
 762     add_string_resource_with_paraformat_to_control(text,
 763      IDS_CERTIFICATEINFORMATION, &parFmt);
 764
 765     text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
 766     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 767     if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
 768         add_string_resource_with_paraformat_to_control(text,
 769          IDS_CERT_INFO_BAD_SIG, &parFmt);
 770     else if (provSigner->pChainContext->TrustStatus.dwErrorStatus &
 771      CERT_TRUST_IS_PARTIAL_CHAIN)
 772         add_string_resource_with_paraformat_to_control(text,
 773          IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
 774     else if (!root->fTrustedRoot)
 775     {
 776         if (provSigner->csCertChain == 1 && root->fSelfSigned)
 777             add_string_resource_with_paraformat_to_control(text,
 778              IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
 779         else
 780             add_string_resource_with_paraformat_to_control(text,
 781              IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
 782     }
 783     else
 784     {
 785         set_policy_text(text, pCertViewInfo);
 786         set_issuer_statement(hwnd, pCertViewInfo);
 787     }
 788 }
 789
 790 static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
 791  DWORD nameFlags, int heading)
 792 {
 793     WCHAR nl = '\n';
 794     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
 795     CHARFORMATW charFmt;
 796     PARAFORMAT2 parFmt;
 797
 798     memset(&charFmt, 0, sizeof(charFmt));
 799     charFmt.cbSize = sizeof(charFmt);
 800     charFmt.dwMask = CFM_BOLD;
 801     charFmt.dwEffects = CFE_BOLD;
 802     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 803     parFmt.cbSize = sizeof(parFmt);
 804     parFmt.dwMask = PFM_STARTINDENT;
 805     parFmt.dxStartIndent = MY_INDENT * 3;
 806     add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
 807     charFmt.dwEffects = 0;
 808     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 809     add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
 810      nameFlags);
 811     add_unformatted_text_to_control(text, &nl, 1);
 812     add_unformatted_text_to_control(text, &nl, 1);
 813     add_unformatted_text_to_control(text, &nl, 1);
 814
 815 }
 816
 817 static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
 818 {
 819     WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
 820     WCHAR date[80];
 821     SYSTEMTIME sysTime;
 822
 823     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
 824      sizeof(dateFmt) / sizeof(dateFmt[0]));
 825     FileTimeToSystemTime(fileTime, &sysTime);
 826     GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
 827      sizeof(date) / sizeof(date[0]));
 828     add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
 829 }
 830
 831 static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
 832 {
 833     WCHAR nl = '\n';
 834     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
 835     CHARFORMATW charFmt;
 836     PARAFORMAT2 parFmt;
 837
 838     memset(&charFmt, 0, sizeof(charFmt));
 839     charFmt.cbSize = sizeof(charFmt);
 840     charFmt.dwMask = CFM_BOLD;
 841     charFmt.dwEffects = CFE_BOLD;
 842     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 843     parFmt.cbSize = sizeof(parFmt);
 844     parFmt.dwMask = PFM_STARTINDENT;
 845     parFmt.dxStartIndent = MY_INDENT * 3;
 846     add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
 847      &parFmt);
 848     charFmt.dwEffects = 0;
 849     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 850     add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
 851     charFmt.dwEffects = CFE_BOLD;
 852     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 853     add_string_resource_to_control(text, IDS_VALID_TO);
 854     charFmt.dwEffects = 0;
 855     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 856     add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
 857     add_unformatted_text_to_control(text, &nl, 1);
 858 }
 859
 860 static void set_general_info(HWND hwnd,
 861  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 862 {
 863     set_cert_info(hwnd, pCertViewInfo);
 864     set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
 865      IDS_SUBJECT_HEADING);
 866     set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
 867      CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
 868     set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
 869 }
 870
 871 static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
 872  LPARAM lp)
 873 {
 874     LRESULT ret = 0;
 875     HWND text;
 876     struct IssuerStatement *issuerStatement;
 877
 878     switch (msg)
 879     {
 880     case WM_INITDIALOG:
 881         text = GetDlgItem(hwnd, IDC_USERNOTICE);
 882         issuerStatement = (struct IssuerStatement *)lp;
 883         add_unformatted_text_to_control(text, issuerStatement->userNotice,
 884          strlenW(issuerStatement->userNotice));
 885         if (issuerStatement->cps)
 886             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
 887         else
 888             EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
 889         break;
 890     case WM_COMMAND:
 891         switch (wp)
 892         {
 893         case IDOK:
 894             EndDialog(hwnd, IDOK);
 895             ret = TRUE;
 896             break;
 897         case IDC_CPS:
 898         {
 899             IBindCtx *bctx = NULL;
 900             LPWSTR cps;
 901
 902             CreateBindCtx(0, &bctx);
 903             cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
 904             HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
 905              HLNF_OPENINNEWWINDOW, 0);
 906             IBindCtx_Release(bctx);
 907             break;
 908         }
 909         }
 910     }
 911     return ret;
 912 }
 913
 914 static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
 915 {
 916     DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
 917      user_notice_dlg_proc, (LPARAM)issuerStatement);
 918 }
 919
 920 static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
 921  LPARAM lp)
 922 {
 923     PROPSHEETPAGEW *page;
 924     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
 925
 926     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
 927
 928     switch (msg)
 929     {
 930     case WM_INITDIALOG:
 931         page = (PROPSHEETPAGEW *)lp;
 932         pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
 933         if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
 934             ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
 935         EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
 936         set_general_info(hwnd, pCertViewInfo);
 937         break;
 938     case WM_COMMAND:
 939         switch (wp)
 940         {
 941         case IDC_ADDTOSTORE:
 942             FIXME("call CryptUIWizImport\n");
 943             break;
 944         case IDC_ISSUERSTATEMENT:
 945         {
 946             struct IssuerStatement *issuerStatement =
 947              (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
 948
 949             if (issuerStatement)
 950             {
 951                 if (issuerStatement->userNotice)
 952                     show_user_notice(hwnd, issuerStatement);
 953                 else if (issuerStatement->cps)
 954                 {
 955                     IBindCtx *bctx = NULL;
 956
 957                     CreateBindCtx(0, &bctx);
 958                     HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
 959                      NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
 960                     IBindCtx_Release(bctx);
 961                 }
 962             }
 963             break;
 964         }
 965         }
 966         break;
 967     }
 968     return 0;
 969 }
 970
 971 static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
 972  PROPSHEETPAGEW *page)
 973 {
 974     struct IssuerStatement *issuerStatement;
 975
 976     switch (msg)
 977     {
 978     case PSPCB_RELEASE:
 979         issuerStatement =
 980          (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
 981         if (issuerStatement)
 982         {
 983             HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
 984             HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
 985             HeapFree(GetProcessHeap(), 0, issuerStatement);
 986         }
 987         break;
 988     }
 989     return 1;
 990 }
 991
 992 static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
 993  PROPSHEETPAGEW *page)
 994 {
 995     memset(page, 0, sizeof(PROPSHEETPAGEW));
 996     page->dwSize = sizeof(PROPSHEETPAGEW);
 997     page->dwFlags = PSP_USECALLBACK;
 998     page->pfnCallback = general_callback_proc;
 999     page->hInstance = hInstance;
1000     page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
1001     page->pfnDlgProc = general_dlg_proc;
1002     page->lParam = (LPARAM)pCertViewInfo;
1003 }
1004
1005 typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
1006
1007 static WCHAR *field_format_version(PCCERT_CONTEXT cert)
1008 {
1009     static const WCHAR fmt[] = { 'V','%','d',0 };
1010     WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
1011
1012     if (buf)
1013         sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
1014     return buf;
1015 }
1016
1017 static WCHAR *format_hex_string(void *pb, DWORD cb)
1018 {
1019     WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
1020
1021     if (buf)
1022     {
1023         static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1024         DWORD i;
1025         WCHAR *ptr;
1026
1027         for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
1028             sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
1029     }
1030     return buf;
1031 }
1032
1033 static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
1034 {
1035     return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
1036      cert->pCertInfo->SerialNumber.cbData);
1037 }
1038
1039 static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
1040 {
1041     return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1042      CERT_NAME_ISSUER_FLAG);
1043 }
1044
1045 static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
1046 {
1047     return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
1048 }
1049
1050 static WCHAR *format_long_date(const FILETIME *fileTime)
1051 {
1052     WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
1053     DWORD len;
1054     WCHAR *buf = NULL;
1055     SYSTEMTIME sysTime;
1056
1057     /* FIXME: format isn't quite right, want time too */
1058     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
1059      sizeof(dateFmt) / sizeof(dateFmt[0]));
1060     FileTimeToSystemTime(fileTime, &sysTime);
1061     len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
1062     if (len)
1063     {
1064         buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1065         if (buf)
1066             GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
1067              len);
1068     }
1069     return buf;
1070 }
1071
1072 static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
1073 {
1074     return format_long_date(&cert->pCertInfo->NotBefore);
1075 }
1076
1077 static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
1078 {
1079     return format_long_date(&cert->pCertInfo->NotAfter);
1080 }
1081
1082 static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
1083 {
1084     PCCRYPT_OID_INFO oidInfo;
1085     WCHAR *buf = NULL;
1086
1087     oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1088      cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
1089     if (oidInfo)
1090     {
1091         WCHAR fmt[MAX_STRING_LEN];
1092
1093         if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
1094          sizeof(fmt) / sizeof(fmt[0])))
1095         {
1096             /* Allocate the output buffer.  Use the number of bytes in the
1097              * public key as a conservative (high) estimate for the number of
1098              * digits in its output.
1099              * The output is of the form (in English)
1100              * "<public key algorithm> (<public key bit length> bits)".
1101              * Ordinarily having two positional parameters in a string is not a
1102              * good idea, but as this isn't a sentence fragment, it shouldn't
1103              * be word-order dependent.
1104              */
1105             buf = HeapAlloc(GetProcessHeap(), 0,
1106              (strlenW(fmt) + strlenW(oidInfo->pwszName) +
1107              cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8)
1108              * sizeof(WCHAR));
1109             if (buf)
1110                 sprintfW(buf, fmt, oidInfo->pwszName,
1111                  CertGetPublicKeyLength(X509_ASN_ENCODING,
1112                   &cert->pCertInfo->SubjectPublicKeyInfo));
1113         }
1114     }
1115     return buf;
1116 }
1117
1118 struct field_value_data;
1119 struct detail_data
1120 {
1121     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
1122     BOOL *pfPropertiesChanged;
1123     int cFields;
1124     struct field_value_data *fields;
1125 };
1126
1127 typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
1128
1129 struct field_value_data
1130 {
1131     void *param;
1132 };
1133
1134 static void add_field_value_data(struct detail_data *data, void *param)
1135 {
1136     if (data->cFields)
1137         data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
1138          (data->cFields + 1) * sizeof(struct field_value_data));
1139     else
1140         data->fields = HeapAlloc(GetProcessHeap(), 0,
1141          sizeof(struct field_value_data));
1142     if (data->fields)
1143     {
1144         data->fields[data->cFields].param = param;
1145         data->cFields++;
1146     }
1147 }
1148
1149 static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
1150  LPWSTR field, LPWSTR value, void *param)
1151 {
1152     LVITEMW item;
1153     int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
1154
1155     item.mask = LVIF_TEXT | LVIF_PARAM;
1156     item.iItem = iItem;
1157     item.iSubItem = 0;
1158     item.pszText = field;
1159     item.lParam = (LPARAM)data;
1160     SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
1161     if (value)
1162     {
1163         item.pszText = value;
1164         item.iSubItem = 1;
1165         SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
1166     }
1167     add_field_value_data(data, param);
1168 }
1169
1170 static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
1171  int id, LPWSTR value, void *param)
1172 {
1173     WCHAR buf[MAX_STRING_LEN];
1174
1175     LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
1176     add_field_and_value_to_list(hwnd, data, buf, value, param);
1177 }
1178
1179 struct v1_field
1180 {
1181     int id;
1182     field_format_func format;
1183 };
1184
1185 static void add_v1_field(HWND hwnd, struct detail_data *data,
1186  const struct v1_field *field)
1187 {
1188     WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
1189
1190     if (val)
1191     {
1192         add_string_id_and_value_to_list(hwnd, data, field->id, val, NULL);
1193         HeapFree(GetProcessHeap(), 0, val);
1194     }
1195 }
1196
1197 static const struct v1_field v1_fields[] = {
1198  { IDS_FIELD_VERSION, field_format_version },
1199  { IDS_FIELD_SERIAL_NUMBER, field_format_serial_number },
1200  { IDS_FIELD_ISSUER, field_format_issuer },
1201  { IDS_FIELD_VALID_FROM, field_format_from_date },
1202  { IDS_FIELD_VALID_TO, field_format_to_date },
1203  { IDS_FIELD_SUBJECT, field_format_subject },
1204  { IDS_FIELD_PUBLIC_KEY, field_format_public_key }
1205 };
1206
1207 static void add_v1_fields(HWND hwnd, struct detail_data *data)
1208 {
1209     int i;
1210     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1211
1212     /* The last item in v1_fields is the public key, which is not in the loop
1213      * because it's a special case.
1214      */
1215     for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
1216         add_v1_field(hwnd, data, &v1_fields[i]);
1217     if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
1218         add_v1_field(hwnd, data, &v1_fields[i]);
1219 }
1220
1221 static void add_all_fields(HWND hwnd, struct detail_data *data)
1222 {
1223     add_v1_fields(hwnd, data);
1224     FIXME("add extensions and properties\n");
1225 }
1226
1227 struct selection_list_item
1228 {
1229     int id;
1230     add_fields_func add;
1231 };
1232
1233 const struct selection_list_item listItems[] = {
1234  { IDS_FIELDS_ALL, add_all_fields },
1235  { IDS_FIELDS_V1, add_v1_fields },
1236  { IDS_FIELDS_EXTENSIONS, NULL },
1237  { IDS_FIELDS_CRITICAL_EXTENSIONS, NULL },
1238  { IDS_FIELDS_PROPERTIES, NULL },
1239 };
1240
1241 static void create_show_list(HWND hwnd, struct detail_data *data)
1242 {
1243     HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
1244     WCHAR buf[MAX_STRING_LEN];
1245     int i;
1246
1247     for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
1248     {
1249         int index;
1250
1251         LoadStringW(hInstance, listItems[i].id, buf,
1252          sizeof(buf) / sizeof(buf[0]));
1253         index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
1254         SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
1255     }
1256     SendMessageW(cb, CB_SETCURSEL, 0, 0);
1257 }
1258
1259 static void create_listview_columns(HWND hwnd)
1260 {
1261     HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1262     RECT rc;
1263     WCHAR buf[MAX_STRING_LEN];
1264     LVCOLUMNW column;
1265
1266     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
1267     GetWindowRect(lv, &rc);
1268     LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
1269     column.mask = LVCF_WIDTH | LVCF_TEXT;
1270     column.cx = (rc.right - rc.left) / 2 - 2;
1271     column.pszText = buf;
1272     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
1273     LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
1274     SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
1275 }
1276
1277 static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
1278 {
1279     HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1280
1281     if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
1282     {
1283         SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
1284         if (listItems[sel].add)
1285             listItems[sel].add(list, data);
1286     }
1287 }
1288
1289 static void create_cert_details_list(HWND hwnd, struct detail_data *data)
1290 {
1291     create_show_list(hwnd, data);
1292     create_listview_columns(hwnd);
1293     set_fields_selection(hwnd, data, 0);
1294 }
1295
1296 static void free_detail_fields(struct detail_data *data)
1297 {
1298     HeapFree(GetProcessHeap(), 0, data->fields);
1299     data->fields = NULL;
1300     data->cFields = 0;
1301 }
1302
1303 static void refresh_details_view(HWND hwnd)
1304 {
1305     HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
1306     int curSel;
1307     struct detail_data *data;
1308
1309     curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
1310     /* Actually, any index will do, since they all store the same data value */
1311     data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
1312     free_detail_fields(data);
1313     set_fields_selection(hwnd, data, curSel);
1314 }
1315
1316 static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
1317  LPARAM lp)
1318 {
1319     PROPSHEETPAGEW *page;
1320     struct detail_data *data;
1321
1322     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
1323
1324     switch (msg)
1325     {
1326     case WM_INITDIALOG:
1327         page = (PROPSHEETPAGEW *)lp;
1328         data = (struct detail_data *)page->lParam;
1329         create_cert_details_list(hwnd, data);
1330         if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
1331             EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
1332         if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
1333             EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
1334         break;
1335     case WM_COMMAND:
1336         switch (wp)
1337         {
1338         case IDC_EXPORT:
1339             FIXME("call CryptUIWizExport\n");
1340             break;
1341         case IDC_EDITPROPERTIES:
1342             FIXME("show edit properties dialog\n");
1343             break;
1344         case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
1345             refresh_details_view(hwnd);
1346             break;
1347         }
1348         break;
1349     }
1350     return 0;
1351 }
1352
1353 static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
1354  BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
1355 {
1356     BOOL ret;
1357     struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
1358      sizeof(struct detail_data));
1359
1360     if (data)
1361     {
1362         data->pCertViewInfo = pCertViewInfo;
1363         data->pfPropertiesChanged = pfPropertiesChanged;
1364         data->cFields = 0;
1365         data->fields = NULL;
1366         memset(page, 0, sizeof(PROPSHEETPAGEW));
1367         page->dwSize = sizeof(PROPSHEETPAGEW);
1368         page->hInstance = hInstance;
1369         page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
1370         page->pfnDlgProc = detail_dlg_proc;
1371         page->lParam = (LPARAM)data;
1372         ret = TRUE;
1373     }
1374     else
1375         ret = FALSE;
1376     return ret;
1377 }
1378
1379 static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
1380 {
1381     RECT rc;
1382     POINT topLeft;
1383
1384     TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
1385
1386     switch (msg)
1387     {
1388     case PSCB_INITIALIZED:
1389         /* Get cancel button's position.. */
1390         GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
1391         topLeft.x = rc.left;
1392         topLeft.y = rc.top;
1393         ScreenToClient(hwnd, &topLeft);
1394         /* hide the cancel button.. */
1395         ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
1396         /* get the OK button's size.. */
1397         GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
1398         /* and move the OK button to the cancel button's original position. */
1399         MoveWindow(GetDlgItem(hwnd, IDOK), topLeft.x, topLeft.y,
1400          rc.right - rc.left, rc.bottom - rc.top, FALSE);
1401         GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
1402         break;
1403     }
1404     return 0;
1405 }
1406
1407 static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
1408  CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
1409 {
1410     static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
1411     DWORD nPages;
1412     PROPSHEETPAGEW *pages;
1413     BOOL ret = FALSE;
1414     HMODULE lib = LoadLibraryW(riched);
1415
1416     nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
1417     if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
1418         nPages++;
1419     if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
1420         FIXME("show hierarchy page\n");
1421     pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
1422     if (pages)
1423     {
1424         PROPSHEETHEADERW hdr;
1425         CRYPTUI_INITDIALOG_STRUCT *init = NULL;
1426         DWORD i;
1427
1428         memset(&hdr, 0, sizeof(hdr));
1429         hdr.dwSize = sizeof(hdr);
1430         hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
1431         hdr.hInstance = hInstance;
1432         if (pCertViewInfo->szTitle)
1433             hdr.pszCaption = pCertViewInfo->szTitle;
1434         else
1435             hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
1436         init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
1437         if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
1438         {
1439             if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
1440              &pages[hdr.nPages]))
1441                 hdr.nPages++;
1442         }
1443         /* Copy each additional page, and create the init dialog struct for it
1444          */
1445         if (pCertViewInfo->cPropSheetPages)
1446         {
1447             init = HeapAlloc(GetProcessHeap(), 0,
1448              pCertViewInfo->cPropSheetPages *
1449              sizeof(CRYPTUI_INITDIALOG_STRUCT));
1450             if (init)
1451             {
1452                 for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
1453                 {
1454                     memcpy(&pages[hdr.nPages + i],
1455                      &pCertViewInfo->rgPropSheetPages[i],
1456                      sizeof(PROPSHEETPAGEW));
1457                     init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
1458                     init[i].pCertContext = pCertViewInfo->pCertContext;
1459                     pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
1460                 }
1461                 if (pCertViewInfo->nStartPage & 0x8000)
1462                 {
1463                     /* Start page index is relative to the number of default
1464                      * pages
1465                      */
1466                     hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
1467                 }
1468                 else
1469                     hdr.u2.nStartPage = pCertViewInfo->nStartPage;
1470                 hdr.nPages = nPages;
1471                 ret = TRUE;
1472             }
1473             else
1474                 SetLastError(ERROR_OUTOFMEMORY);
1475         }
1476         else
1477         {
1478             /* Ignore the relative flag if there aren't any additional pages */
1479             hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
1480             ret = TRUE;
1481         }
1482         if (ret)
1483         {
1484             INT_PTR l;
1485
1486             hdr.u3.ppsp = pages;
1487             hdr.pfnCallback = cert_prop_sheet_proc;
1488             l = PropertySheetW(&hdr);
1489             if (l == 0)
1490             {
1491                 SetLastError(ERROR_CANCELLED);
1492                 ret = FALSE;
1493             }
1494         }
1495         HeapFree(GetProcessHeap(), 0, init);
1496         HeapFree(GetProcessHeap(), 0, pages);
1497     }
1498     else
1499         SetLastError(ERROR_OUTOFMEMORY);
1500     FreeLibrary(lib);
1501     return ret;
1502 }
1503
1504 /***********************************************************************
1505  *              CryptUIDlgViewCertificateW (CRYPTUI.@)
1506  */
1507 BOOL WINAPI CryptUIDlgViewCertificateW(
1508  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
1509 {
1510     static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
1511     CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
1512     WINTRUST_DATA wvt;
1513     WINTRUST_CERT_INFO cert;
1514     BOOL ret = FALSE;
1515     CRYPT_PROVIDER_SGNR *signer;
1516     CRYPT_PROVIDER_CERT *provCert = NULL;
1517
1518     TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
1519
1520     if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
1521     {
1522         SetLastError(ERROR_INVALID_PARAMETER);
1523         return FALSE;
1524     }
1525     /* Make a local copy in case we have to call WinVerifyTrust ourselves */
1526     memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
1527     if (!viewInfo.u.hWVTStateData)
1528     {
1529         memset(&wvt, 0, sizeof(wvt));
1530         wvt.cbStruct = sizeof(wvt);
1531         wvt.dwUIChoice = WTD_UI_NONE;
1532         if (viewInfo.dwFlags &
1533          CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
1534             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
1535         if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
1536             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
1537         if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
1538             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
1539         wvt.dwUnionChoice = WTD_CHOICE_CERT;
1540         memset(&cert, 0, sizeof(cert));
1541         cert.cbStruct = sizeof(cert);
1542         cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
1543         cert.chStores = viewInfo.cStores;
1544         cert.pahStores = viewInfo.rghStores;
1545         wvt.u.pCert = &cert;
1546         wvt.dwStateAction = WTD_STATEACTION_VERIFY;
1547         WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
1548         viewInfo.u.pCryptProviderData =
1549          WTHelperProvDataFromStateData(wvt.hWVTStateData);
1550         signer = WTHelperGetProvSignerFromChain(
1551          (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
1552         provCert = WTHelperGetProvCertFromChain(signer, 0);
1553         ret = TRUE;
1554     }
1555     else
1556     {
1557         viewInfo.u.pCryptProviderData =
1558          WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
1559         signer = WTHelperGetProvSignerFromChain(
1560          (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
1561          viewInfo.idxSigner, viewInfo.fCounterSigner,
1562          viewInfo.idxCounterSigner);
1563         provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
1564         ret = TRUE;
1565     }
1566     if (ret)
1567     {
1568         ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
1569         if (!viewInfo.u.hWVTStateData)
1570         {
1571             wvt.dwStateAction = WTD_STATEACTION_CLOSE;
1572             WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
1573         }
1574     }
1575     return ret;
1576 }
1577
1578 static PCCERT_CONTEXT make_cert_from_file(LPCWSTR fileName)
1579 {
1580     HANDLE file;
1581     DWORD size, encoding = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1582     BYTE *buffer;
1583     PCCERT_CONTEXT cert;
1584
1585     file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
1586      OPEN_EXISTING, 0, NULL);
1587     if (file == INVALID_HANDLE_VALUE)
1588     {
1589         WARN("can't open certificate file %s\n", debugstr_w(fileName));
1590         return NULL;
1591     }
1592     if ((size = GetFileSize(file, NULL)))
1593     {
1594         if ((buffer = HeapAlloc(GetProcessHeap(), 0, size)))
1595         {
1596             DWORD read;
1597             if (!ReadFile(file, buffer, size, &read, NULL) || read != size)
1598             {
1599                 WARN("can't read certificate file %s\n", debugstr_w(fileName));
1600                 HeapFree(GetProcessHeap(), 0, buffer);
1601                 CloseHandle(file);
1602                 return NULL;
1603             }
1604         }
1605     }
1606     else
1607     {
1608         WARN("empty file %s\n", debugstr_w(fileName));
1609         CloseHandle(file);
1610         return NULL;
1611     }
1612     CloseHandle(file);
1613     cert = CertCreateCertificateContext(encoding, buffer, size);
1614     HeapFree(GetProcessHeap(), 0, buffer);
1615     return cert;
1616 }
1617
1618 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
1619  * or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
1620  * should be a CA.  If neither extension is present, returns
1621  * defaultIfNotSpecified.
1622  */
1623 static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
1624 {
1625     BOOL isCA = defaultIfNotSpecified;
1626     PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
1627      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
1628
1629     if (ext)
1630     {
1631         CERT_BASIC_CONSTRAINTS_INFO *info;
1632         DWORD size = 0;
1633
1634         if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
1635          ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
1636          NULL, (LPBYTE)&info, &size))
1637         {
1638             if (info->SubjectType.cbData == 1)
1639                 isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
1640             LocalFree(info);
1641         }
1642     }
1643     else
1644     {
1645         ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
1646          cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
1647         if (ext)
1648         {
1649             CERT_BASIC_CONSTRAINTS2_INFO info;
1650             DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
1651
1652             if (CryptDecodeObjectEx(X509_ASN_ENCODING,
1653              szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
1654              0, NULL, &info, &size))
1655                 isCA = info.fCA;
1656         }
1657     }
1658     return isCA;
1659 }
1660
1661 static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
1662 {
1663     static const WCHAR AddressBook[] = { 'A','d','d','r','e','s','s',
1664      'B','o','o','k',0 };
1665     static const WCHAR CA[] = { 'C','A',0 };
1666     LPCWSTR storeName;
1667
1668     if (is_ca_cert(cert, TRUE))
1669         storeName = CA;
1670     else
1671         storeName = AddressBook;
1672     return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
1673      CERT_SYSTEM_STORE_CURRENT_USER, storeName);
1674 }
1675
1676 BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
1677                              PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
1678 {
1679     BOOL ret;
1680     HCERTSTORE store;
1681     const CERT_CONTEXT *cert;
1682     BOOL freeCert = FALSE;
1683
1684     TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
1685           pImportSrc, hDestCertStore);
1686
1687     if (!(dwFlags & CRYPTUI_WIZ_NO_UI)) FIXME("UI not implemented\n");
1688
1689     if (!pImportSrc ||
1690      pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
1691     {
1692         SetLastError(E_INVALIDARG);
1693         return FALSE;
1694     }
1695
1696     switch (pImportSrc->dwSubjectChoice)
1697     {
1698     case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
1699         if (!(cert = make_cert_from_file(pImportSrc->u.pwszFileName)))
1700         {
1701             WARN("unable to create certificate context\n");
1702             return FALSE;
1703         }
1704         else
1705             freeCert = TRUE;
1706         break;
1707     case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
1708         cert = pImportSrc->u.pCertContext;
1709         if (!cert)
1710         {
1711             SetLastError(E_INVALIDARG);
1712             return FALSE;
1713         }
1714         break;
1715     default:
1716         FIXME("source type not implemented: %u\n", pImportSrc->dwSubjectChoice);
1717         SetLastError(E_INVALIDARG);
1718         return FALSE;
1719     }
1720     if (hDestCertStore) store = hDestCertStore;
1721     else
1722     {
1723         if (!(store = choose_store_for_cert(cert)))
1724         {
1725             WARN("unable to open certificate store\n");
1726             CertFreeCertificateContext(cert);
1727             return FALSE;
1728         }
1729     }
1730     ret = CertAddCertificateContextToStore(store, cert, CERT_STORE_ADD_REPLACE_EXISTING, NULL);
1731
1732     if (!hDestCertStore) CertCloseStore(store, 0);
1733     if (freeCert)
1734         CertFreeCertificateContext(cert);
1735     return ret;
1736 }