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 "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 /* FIXME: real names are unknown, functions are undocumented */
  77 struct _CRYPTUI_SELECTSTORE_INFO_A;
  78 struct _CRYPTUI_SELECTSTORE_INFO_W;
  79
  80 /***********************************************************************
  81  *              CryptUIDlgSelectStoreA (CRYPTUI.@)
  82  */
  83 HCERTSTORE WINAPI CryptUIDlgSelectStoreA(struct _CRYPTUI_SELECTSTORE_INFO_A *info)
  84 {
  85     FIXME("(%p): stub\n", info);
  86     return NULL;
  87 }
  88
  89 /***********************************************************************
  90  *              CryptUIDlgSelectStoreW (CRYPTUI.@)
  91  */
  92 HCERTSTORE WINAPI CryptUIDlgSelectStoreW(struct _CRYPTUI_SELECTSTORE_INFO_W *info)
  93 {
  94     FIXME("(%p): stub\n", info);
  95     return NULL;
  96 }
  97
  98 /***********************************************************************
  99  *              CryptUIDlgViewCertificateA (CRYPTUI.@)
 100  */
 101 BOOL WINAPI CryptUIDlgViewCertificateA(
 102  PCCRYPTUI_VIEWCERTIFICATE_STRUCTA pCertViewInfo, BOOL *pfPropertiesChanged)
 103 {
 104     CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
 105     LPWSTR title = NULL;
 106     BOOL ret;
 107
 108     TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
 109
 110     memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
 111     if (pCertViewInfo->szTitle)
 112     {
 113         int len = MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1,
 114          NULL, 0);
 115
 116         title = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 117         if (title)
 118         {
 119             MultiByteToWideChar(CP_ACP, 0, pCertViewInfo->szTitle, -1, title,
 120              len);
 121             viewInfo.szTitle = title;
 122         }
 123         else
 124         {
 125             ret = FALSE;
 126             goto error;
 127         }
 128     }
 129     if (pCertViewInfo->cPropSheetPages)
 130     {
 131         FIXME("ignoring additional prop sheet pages\n");
 132         viewInfo.cPropSheetPages = 0;
 133     }
 134     ret = CryptUIDlgViewCertificateW(&viewInfo, pfPropertiesChanged);
 135     HeapFree(GetProcessHeap(), 0, title);
 136 error:
 137     return ret;
 138 }
 139
 140 struct ReadStringStruct
 141 {
 142     LPCWSTR buf;
 143     LONG pos;
 144     LONG len;
 145 };
 146
 147 static DWORD CALLBACK read_text_callback(DWORD_PTR dwCookie, LPBYTE buf,
 148  LONG cb, LONG *pcb)
 149 {
 150     struct ReadStringStruct *string = (struct ReadStringStruct *)dwCookie;
 151     LONG cch = min(cb / sizeof(WCHAR), string->len - string->pos);
 152
 153     TRACE("(%p, %p, %d, %p)\n", string, buf, cb, pcb);
 154
 155     memmove(buf, string->buf + string->pos, cch * sizeof(WCHAR));
 156     string->pos += cch;
 157     *pcb = cch * sizeof(WCHAR);
 158     return 0;
 159 }
 160
 161 static void add_unformatted_text_to_control(HWND hwnd, LPCWSTR text, LONG len)
 162 {
 163     struct ReadStringStruct string;
 164     EDITSTREAM editstream;
 165
 166     TRACE("(%p, %s)\n", hwnd, debugstr_wn(text, len));
 167
 168     string.buf = text;
 169     string.pos = 0;
 170     string.len = len;
 171     editstream.dwCookie = (DWORD_PTR)&string;
 172     editstream.dwError = 0;
 173     editstream.pfnCallback = read_text_callback;
 174     SendMessageW(hwnd, EM_STREAMIN, SF_TEXT | SFF_SELECTION | SF_UNICODE,
 175      (LPARAM)&editstream);
 176 }
 177
 178 static void add_string_resource_to_control(HWND hwnd, int id)
 179 {
 180     LPWSTR str;
 181     LONG len;
 182
 183     len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
 184     add_unformatted_text_to_control(hwnd, str, len);
 185 }
 186
 187 static void add_text_with_paraformat_to_control(HWND hwnd, LPCWSTR text,
 188  LONG len, const PARAFORMAT2 *fmt)
 189 {
 190     add_unformatted_text_to_control(hwnd, text, len);
 191     SendMessageW(hwnd, EM_SETPARAFORMAT, 0, (LPARAM)fmt);
 192 }
 193
 194 static void add_string_resource_with_paraformat_to_control(HWND hwnd, int id,
 195  const PARAFORMAT2 *fmt)
 196 {
 197     LPWSTR str;
 198     LONG len;
 199
 200     len = LoadStringW(hInstance, id, (LPWSTR)&str, 0);
 201     add_text_with_paraformat_to_control(hwnd, str, len, fmt);
 202 }
 203
 204 static LPWSTR get_cert_name_string(PCCERT_CONTEXT pCertContext, DWORD dwType,
 205  DWORD dwFlags)
 206 {
 207     LPWSTR buf = NULL;
 208     DWORD len;
 209
 210     len = CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, NULL, 0);
 211     if (len)
 212     {
 213         buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 214         if (buf)
 215             CertGetNameStringW(pCertContext, dwType, dwFlags, NULL, buf, len);
 216     }
 217     return buf;
 218 }
 219
 220 static void add_cert_string_to_control(HWND hwnd, PCCERT_CONTEXT pCertContext,
 221  DWORD dwType, DWORD dwFlags)
 222 {
 223     LPWSTR name = get_cert_name_string(pCertContext, dwType, dwFlags);
 224
 225     if (name)
 226     {
 227         /* Don't include NULL-terminator in output */
 228         DWORD len = lstrlenW(name);
 229
 230         add_unformatted_text_to_control(hwnd, name, len);
 231         HeapFree(GetProcessHeap(), 0, name);
 232     }
 233 }
 234
 235 static void add_icon_to_control(HWND hwnd, int id)
 236 {
 237     HRESULT hr;
 238     LPRICHEDITOLE richEditOle = NULL;
 239     LPOLEOBJECT object = NULL;
 240     CLSID clsid;
 241     LPOLECACHE oleCache = NULL;
 242     FORMATETC formatEtc;
 243     DWORD conn;
 244     LPDATAOBJECT dataObject = NULL;
 245     HBITMAP bitmap = NULL;
 246     RECT rect;
 247     STGMEDIUM stgm;
 248     REOBJECT reObject;
 249
 250     TRACE("(%p, %d)\n", hwnd, id);
 251
 252     SendMessageW(hwnd, EM_GETOLEINTERFACE, 0, (LPARAM)&richEditOle);
 253     if (!richEditOle)
 254         goto end;
 255     hr = OleCreateDefaultHandler(&CLSID_NULL, NULL, &IID_IOleObject,
 256      (void**)&object);
 257     if (FAILED(hr))
 258         goto end;
 259     hr = IOleObject_GetUserClassID(object, &clsid);
 260     if (FAILED(hr))
 261         goto end;
 262     hr = IOleObject_QueryInterface(object, &IID_IOleCache, (void**)&oleCache);
 263     if (FAILED(hr))
 264         goto end;
 265     formatEtc.cfFormat = CF_BITMAP;
 266     formatEtc.ptd = NULL;
 267     formatEtc.dwAspect = DVASPECT_CONTENT;
 268     formatEtc.lindex = -1;
 269     formatEtc.tymed = TYMED_GDI;
 270     hr = IOleCache_Cache(oleCache, &formatEtc, 0, &conn);
 271     if (FAILED(hr))
 272         goto end;
 273     hr = IOleObject_QueryInterface(object, &IID_IDataObject,
 274      (void**)&dataObject);
 275     if (FAILED(hr))
 276         goto end;
 277     bitmap = LoadImageW(hInstance, MAKEINTRESOURCEW(id), IMAGE_BITMAP, 0, 0,
 278      LR_DEFAULTSIZE | LR_LOADTRANSPARENT);
 279     if (!bitmap)
 280         goto end;
 281     rect.left = rect.top = 0;
 282     rect.right = GetSystemMetrics(SM_CXICON);
 283     rect.bottom = GetSystemMetrics(SM_CYICON);
 284     stgm.tymed = TYMED_GDI;
 285     stgm.u.hBitmap = bitmap;
 286     stgm.pUnkForRelease = NULL;
 287     hr = IDataObject_SetData(dataObject, &formatEtc, &stgm, TRUE);
 288     if (FAILED(hr))
 289         goto end;
 290
 291     reObject.cbStruct = sizeof(reObject);
 292     reObject.cp = REO_CP_SELECTION;
 293     reObject.clsid = clsid;
 294     reObject.poleobj = object;
 295     reObject.pstg = NULL;
 296     reObject.polesite = NULL;
 297     reObject.sizel.cx = reObject.sizel.cy = 0;
 298     reObject.dvaspect = DVASPECT_CONTENT;
 299     reObject.dwFlags = 0;
 300     reObject.dwUser = 0;
 301
 302     IRichEditOle_InsertObject(richEditOle, &reObject);
 303
 304 end:
 305     if (dataObject)
 306         IDataObject_Release(dataObject);
 307     if (oleCache)
 308         IOleCache_Release(oleCache);
 309     if (object)
 310         IOleObject_Release(object);
 311     if (richEditOle)
 312         IRichEditOle_Release(richEditOle);
 313 }
 314
 315 #define MY_INDENT 200
 316
 317 static void add_oid_text_to_control(HWND hwnd, char *oid)
 318 {
 319     WCHAR nl = '\n';
 320     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid, 0);
 321     PARAFORMAT2 parFmt;
 322
 323     parFmt.cbSize = sizeof(parFmt);
 324     parFmt.dwMask = PFM_STARTINDENT;
 325     parFmt.dxStartIndent = MY_INDENT * 3;
 326     if (oidInfo)
 327     {
 328         add_text_with_paraformat_to_control(hwnd, oidInfo->pwszName,
 329          lstrlenW(oidInfo->pwszName), &parFmt);
 330         add_unformatted_text_to_control(hwnd, &nl, 1);
 331     }
 332 }
 333
 334 #define MAX_STRING_LEN 512
 335
 336 struct OIDToString
 337 {
 338     LPCSTR oid;
 339     int    id;
 340 };
 341
 342 /* The following list MUST be lexicographically sorted by OID */
 343 static struct OIDToString oidMap[] = {
 344  /* 1.3.6.1.4.1.311.10.3.1 */
 345  { szOID_KP_CTL_USAGE_SIGNING, IDS_PURPOSE_CTL_USAGE_SIGNING },
 346  /* 1.3.6.1.4.1.311.10.3.4 */
 347  { szOID_KP_EFS, IDS_PURPOSE_EFS },
 348  /* 1.3.6.1.4.1.311.10.3.4.1 */
 349  { szOID_EFS_RECOVERY, IDS_PURPOSE_EFS_RECOVERY },
 350  /* 1.3.6.1.4.1.311.10.3.5 */
 351  { szOID_WHQL_CRYPTO, IDS_PURPOSE_WHQL },
 352  /* 1.3.6.1.4.1.311.10.3.6 */
 353  { szOID_NT5_CRYPTO, IDS_PURPOSE_NT5 },
 354  /* 1.3.6.1.4.1.311.10.3.7 */
 355  { szOID_OEM_WHQL_CRYPTO, IDS_PURPOSE_OEM_WHQL },
 356  /* 1.3.6.1.4.1.311.10.3.8 */
 357  { szOID_EMBEDDED_NT_CRYPTO, IDS_PURPOSE_EMBEDDED_NT },
 358  /* 1.3.6.1.4.1.311.10.3.9 */
 359  { szOID_ROOT_LIST_SIGNER, IDS_PURPOSE_ROOT_LIST_SIGNER },
 360  /* 1.3.6.1.4.1.311.10.3.10 */
 361  { szOID_KP_QUALIFIED_SUBORDINATION, IDS_PURPOSE_QUALIFIED_SUBORDINATION },
 362  /* 1.3.6.1.4.1.311.10.3.11 */
 363  { szOID_KP_KEY_RECOVERY, IDS_PURPOSE_KEY_RECOVERY },
 364  /* 1.3.6.1.4.1.311.10.3.12 */
 365  { szOID_KP_DOCUMENT_SIGNING, IDS_PURPOSE_DOCUMENT_SIGNING },
 366  /* 1.3.6.1.4.1.311.10.3.13 */
 367  { szOID_KP_LIFETIME_SIGNING, IDS_PURPOSE_LIFETIME_SIGNING },
 368  /* 1.3.6.1.4.1.311.10.5.1 */
 369  { szOID_DRM, IDS_PURPOSE_DRM },
 370  /* 1.3.6.1.4.1.311.10.6.1 */
 371  { szOID_LICENSES, IDS_PURPOSE_LICENSES },
 372  /* 1.3.6.1.4.1.311.10.6.2 */
 373  { szOID_LICENSE_SERVER, IDS_PURPOSE_LICENSE_SERVER },
 374  /* 1.3.6.1.4.1.311.20.2.1 */
 375  { szOID_ENROLLMENT_AGENT, IDS_PURPOSE_ENROLLMENT_AGENT },
 376  /* 1.3.6.1.4.1.311.20.2.2 */
 377  { szOID_KP_SMARTCARD_LOGON, IDS_PURPOSE_SMARTCARD_LOGON },
 378  /* 1.3.6.1.4.1.311.21.5 */
 379  { szOID_KP_CA_EXCHANGE, IDS_PURPOSE_CA_EXCHANGE },
 380  /* 1.3.6.1.4.1.311.21.6 */
 381  { szOID_KP_KEY_RECOVERY_AGENT, IDS_PURPOSE_KEY_RECOVERY_AGENT },
 382  /* 1.3.6.1.4.1.311.21.19 */
 383  { szOID_DS_EMAIL_REPLICATION, IDS_PURPOSE_DS_EMAIL_REPLICATION },
 384  /* 1.3.6.1.5.5.7.3.1 */
 385  { szOID_PKIX_KP_SERVER_AUTH, IDS_PURPOSE_SERVER_AUTH },
 386  /* 1.3.6.1.5.5.7.3.2 */
 387  { szOID_PKIX_KP_CLIENT_AUTH, IDS_PURPOSE_CLIENT_AUTH },
 388  /* 1.3.6.1.5.5.7.3.3 */
 389  { szOID_PKIX_KP_CODE_SIGNING, IDS_PURPOSE_CODE_SIGNING },
 390  /* 1.3.6.1.5.5.7.3.4 */
 391  { szOID_PKIX_KP_EMAIL_PROTECTION, IDS_PURPOSE_EMAIL_PROTECTION },
 392  /* 1.3.6.1.5.5.7.3.5 */
 393  { szOID_PKIX_KP_IPSEC_END_SYSTEM, IDS_PURPOSE_IPSEC },
 394  /* 1.3.6.1.5.5.7.3.6 */
 395  { szOID_PKIX_KP_IPSEC_TUNNEL, IDS_PURPOSE_IPSEC },
 396  /* 1.3.6.1.5.5.7.3.7 */
 397  { szOID_PKIX_KP_IPSEC_USER, IDS_PURPOSE_IPSEC },
 398  /* 1.3.6.1.5.5.7.3.8 */
 399  { szOID_PKIX_KP_TIMESTAMP_SIGNING, IDS_PURPOSE_TIMESTAMP_SIGNING },
 400 };
 401
 402 static struct OIDToString *findSupportedOID(LPCSTR oid)
 403 {
 404     int indexHigh = sizeof(oidMap) / sizeof(oidMap[0]) - 1, indexLow = 0, i;
 405     struct OIDToString *ret = NULL;
 406
 407     for (i = (indexLow + indexHigh) / 2; !ret && indexLow <= indexHigh;
 408      i = (indexLow + indexHigh) / 2)
 409     {
 410         int cmp;
 411
 412         cmp = strcmp(oid, oidMap[i].oid);
 413         if (!cmp)
 414             ret = &oidMap[i];
 415         else if (cmp > 0)
 416             indexLow = i + 1;
 417         else
 418             indexHigh = i - 1;
 419     }
 420     return ret;
 421 }
 422
 423 static void add_local_oid_text_to_control(HWND text, LPCSTR oid)
 424 {
 425     struct OIDToString *entry;
 426     WCHAR nl = '\n';
 427     PARAFORMAT2 parFmt;
 428
 429     parFmt.cbSize = sizeof(parFmt);
 430     parFmt.dwMask = PFM_STARTINDENT;
 431     parFmt.dxStartIndent = MY_INDENT * 3;
 432     if ((entry = findSupportedOID(oid)))
 433     {
 434         WCHAR *str, *linebreak, *ptr;
 435         BOOL multiline = FALSE;
 436         int len;
 437
 438         len = LoadStringW(hInstance, entry->id, (LPWSTR)&str, 0);
 439         ptr = str;
 440         do {
 441             if ((linebreak = memchrW(ptr, '\n', len)))
 442             {
 443                 WCHAR copy[MAX_STRING_LEN];
 444
 445                 multiline = TRUE;
 446                 /* The source string contains a newline, which the richedit
 447                  * control won't find since it's interpreted as a paragraph
 448                  * break.  Therefore copy up to the newline.  lstrcpynW always
 449                  * NULL-terminates, so pass one more than the length of the
 450                  * source line so the copy includes the entire line and the
 451                  * NULL-terminator.
 452                  */
 453                 lstrcpynW(copy, ptr, linebreak - ptr + 1);
 454                 add_text_with_paraformat_to_control(text, copy,
 455                  linebreak - ptr, &parFmt);
 456                 ptr = linebreak + 1;
 457                 add_unformatted_text_to_control(text, &nl, 1);
 458             }
 459             else if (multiline && *ptr)
 460             {
 461                 /* Add the last line */
 462                 add_text_with_paraformat_to_control(text, ptr,
 463                  len - (ptr - str), &parFmt);
 464                 add_unformatted_text_to_control(text, &nl, 1);
 465             }
 466         } while (linebreak);
 467         if (!multiline)
 468         {
 469             add_text_with_paraformat_to_control(text, str, len, &parFmt);
 470             add_unformatted_text_to_control(text, &nl, 1);
 471         }
 472     }
 473     else
 474     {
 475         WCHAR *oidW = HeapAlloc(GetProcessHeap(), 0,
 476          (strlen(oid) + 1) * sizeof(WCHAR));
 477
 478         if (oidW)
 479         {
 480             LPCSTR src;
 481             WCHAR *dst;
 482
 483             for (src = oid, dst = oidW; *src; src++, dst++)
 484                 *dst = *src;
 485             *dst = 0;
 486             add_text_with_paraformat_to_control(text, oidW, lstrlenW(oidW),
 487              &parFmt);
 488             add_unformatted_text_to_control(text, &nl, 1);
 489             HeapFree(GetProcessHeap(), 0, oidW);
 490         }
 491     }
 492 }
 493
 494 static void display_app_usages(HWND text, PCCERT_CONTEXT cert,
 495  BOOL *anyUsageAdded)
 496 {
 497     static char any_app_policy[] = szOID_ANY_APPLICATION_POLICY;
 498     WCHAR nl = '\n';
 499     CHARFORMATW charFmt;
 500     PCERT_EXTENSION policyExt;
 501     if (!*anyUsageAdded)
 502     {
 503         PARAFORMAT2 parFmt;
 504
 505         parFmt.cbSize = sizeof(parFmt);
 506         parFmt.dwMask = PFM_STARTINDENT;
 507         parFmt.dxStartIndent = MY_INDENT;
 508         add_string_resource_with_paraformat_to_control(text,
 509          IDS_CERT_INFO_PURPOSES, &parFmt);
 510         add_unformatted_text_to_control(text, &nl, 1);
 511         *anyUsageAdded = TRUE;
 512     }
 513     memset(&charFmt, 0, sizeof(charFmt));
 514     charFmt.cbSize = sizeof(charFmt);
 515     charFmt.dwMask = CFM_BOLD;
 516     charFmt.dwEffects = 0;
 517     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 518     if ((policyExt = CertFindExtension(szOID_APPLICATION_CERT_POLICIES,
 519      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
 520     {
 521         CERT_POLICIES_INFO *policies;
 522         DWORD size;
 523
 524         if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_POLICIES,
 525          policyExt->Value.pbData, policyExt->Value.cbData,
 526          CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
 527         {
 528             DWORD i;
 529
 530             for (i = 0; i < policies->cPolicyInfo; i++)
 531             {
 532                 DWORD j;
 533
 534                 for (j = 0; j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
 535                     add_local_oid_text_to_control(text,
 536                      policies->rgPolicyInfo[i].rgPolicyQualifier[j].
 537                      pszPolicyQualifierId);
 538             }
 539             LocalFree(policies);
 540         }
 541     }
 542     else
 543         add_oid_text_to_control(text, any_app_policy);
 544 }
 545
 546 static BOOL display_cert_usages(HWND text, PCCERT_CONTEXT cert,
 547  BOOL *anyUsageAdded)
 548 {
 549     WCHAR nl = '\n';
 550     DWORD size;
 551     BOOL badUsages = FALSE;
 552
 553     if (CertGetEnhancedKeyUsage(cert, 0, NULL, &size))
 554     {
 555         CHARFORMATW charFmt;
 556         static char any_cert_policy[] = szOID_ANY_CERT_POLICY;
 557         PCERT_ENHKEY_USAGE usage = HeapAlloc(GetProcessHeap(), 0, size);
 558
 559         if (usage)
 560         {
 561             if (CertGetEnhancedKeyUsage(cert, 0, usage, &size))
 562             {
 563                 DWORD i;
 564
 565                 if (!*anyUsageAdded)
 566                 {
 567                     PARAFORMAT2 parFmt;
 568
 569                     parFmt.cbSize = sizeof(parFmt);
 570                     parFmt.dwMask = PFM_STARTINDENT;
 571                     parFmt.dxStartIndent = MY_INDENT;
 572                     add_string_resource_with_paraformat_to_control(text,
 573                      IDS_CERT_INFO_PURPOSES, &parFmt);
 574                     add_unformatted_text_to_control(text, &nl, 1);
 575                     *anyUsageAdded = TRUE;
 576                 }
 577                 memset(&charFmt, 0, sizeof(charFmt));
 578                 charFmt.cbSize = sizeof(charFmt);
 579                 charFmt.dwMask = CFM_BOLD;
 580                 charFmt.dwEffects = 0;
 581                 SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION,
 582                  (LPARAM)&charFmt);
 583                 if (!usage->cUsageIdentifier)
 584                     add_oid_text_to_control(text, any_cert_policy);
 585                 else
 586                     for (i = 0; i < usage->cUsageIdentifier; i++)
 587                         add_local_oid_text_to_control(text,
 588                          usage->rgpszUsageIdentifier[i]);
 589             }
 590             else
 591                 badUsages = TRUE;
 592             HeapFree(GetProcessHeap(), 0, usage);
 593         }
 594         else
 595             badUsages = TRUE;
 596     }
 597     else
 598         badUsages = TRUE;
 599     return badUsages;
 600 }
 601
 602 static void set_policy_text(HWND text,
 603  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 604 {
 605     BOOL includeCertUsages = FALSE, includeAppUsages = FALSE;
 606     BOOL badUsages = FALSE, anyUsageAdded = FALSE;
 607
 608     if (pCertViewInfo->cPurposes)
 609     {
 610         DWORD i;
 611
 612         for (i = 0; i < pCertViewInfo->cPurposes; i++)
 613         {
 614             if (!strcmp(pCertViewInfo->rgszPurposes[i], szOID_ANY_CERT_POLICY))
 615                 includeCertUsages = TRUE;
 616             else if (!strcmp(pCertViewInfo->rgszPurposes[i],
 617              szOID_ANY_APPLICATION_POLICY))
 618                 includeAppUsages = TRUE;
 619             else
 620                 badUsages = TRUE;
 621         }
 622     }
 623     else
 624         includeAppUsages = includeCertUsages = TRUE;
 625     if (includeAppUsages)
 626         display_app_usages(text, pCertViewInfo->pCertContext, &anyUsageAdded);
 627     if (includeCertUsages)
 628         badUsages = display_cert_usages(text, pCertViewInfo->pCertContext,
 629          &anyUsageAdded);
 630     if (badUsages)
 631     {
 632         PARAFORMAT2 parFmt;
 633
 634         parFmt.cbSize = sizeof(parFmt);
 635         parFmt.dwMask = PFM_STARTINDENT;
 636         parFmt.dxStartIndent = MY_INDENT;
 637         add_string_resource_with_paraformat_to_control(text,
 638          IDS_CERT_INFO_BAD_PURPOSES, &parFmt);
 639     }
 640 }
 641
 642 static CRYPT_OBJID_BLOB *find_policy_qualifier(CERT_POLICIES_INFO *policies,
 643  LPCSTR policyOid)
 644 {
 645     CRYPT_OBJID_BLOB *ret = NULL;
 646     DWORD i;
 647
 648     for (i = 0; !ret && i < policies->cPolicyInfo; i++)
 649     {
 650         DWORD j;
 651
 652         for (j = 0; !ret && j < policies->rgPolicyInfo[i].cPolicyQualifier; j++)
 653             if (!strcmp(policies->rgPolicyInfo[i].rgPolicyQualifier[j].
 654              pszPolicyQualifierId, policyOid))
 655                 ret = &policies->rgPolicyInfo[i].rgPolicyQualifier[j].
 656                  Qualifier;
 657     }
 658     return ret;
 659 }
 660
 661 static WCHAR *get_cps_str_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
 662 {
 663     LPWSTR qualifierStr = NULL;
 664     CERT_NAME_VALUE *qualifierValue;
 665     DWORD size;
 666
 667     if (CryptDecodeObjectEx(X509_ASN_ENCODING, X509_NAME_VALUE,
 668      qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
 669      &qualifierValue, &size))
 670     {
 671         size = CertRDNValueToStrW(qualifierValue->dwValueType,
 672          &qualifierValue->Value, NULL, 0);
 673         qualifierStr = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 674         if (qualifierStr)
 675             CertRDNValueToStrW(qualifierValue->dwValueType,
 676              &qualifierValue->Value, qualifierStr, size);
 677         LocalFree(qualifierValue);
 678     }
 679     return qualifierStr;
 680 }
 681
 682 static WCHAR *get_user_notice_from_qualifier(CRYPT_OBJID_BLOB *qualifier)
 683 {
 684     LPWSTR str = NULL;
 685     CERT_POLICY_QUALIFIER_USER_NOTICE *qualifierValue;
 686     DWORD size;
 687
 688     if (CryptDecodeObjectEx(X509_ASN_ENCODING,
 689      X509_PKIX_POLICY_QUALIFIER_USERNOTICE,
 690      qualifier->pbData, qualifier->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
 691      &qualifierValue, &size))
 692     {
 693         str = HeapAlloc(GetProcessHeap(), 0,
 694          (strlenW(qualifierValue->pszDisplayText) + 1) * sizeof(WCHAR));
 695         if (str)
 696             strcpyW(str, qualifierValue->pszDisplayText);
 697         LocalFree(qualifierValue);
 698     }
 699     return str;
 700 }
 701
 702 struct IssuerStatement
 703 {
 704     LPWSTR cps;
 705     LPWSTR userNotice;
 706 };
 707
 708 static void set_issuer_statement(HWND hwnd,
 709  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 710 {
 711     PCERT_EXTENSION policyExt;
 712
 713     if (!(pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ISSUERSTATEMENT) &&
 714      (policyExt = CertFindExtension(szOID_CERT_POLICIES,
 715      pCertViewInfo->pCertContext->pCertInfo->cExtension,
 716      pCertViewInfo->pCertContext->pCertInfo->rgExtension)))
 717     {
 718         CERT_POLICIES_INFO *policies;
 719         DWORD size;
 720
 721         if (CryptDecodeObjectEx(X509_ASN_ENCODING, policyExt->pszObjId,
 722          policyExt->Value.pbData, policyExt->Value.cbData,
 723          CRYPT_DECODE_ALLOC_FLAG, NULL, &policies, &size))
 724         {
 725             CRYPT_OBJID_BLOB *qualifier;
 726             LPWSTR cps = NULL, userNotice = NULL;
 727
 728             if ((qualifier = find_policy_qualifier(policies,
 729              szOID_PKIX_POLICY_QUALIFIER_CPS)))
 730                 cps = get_cps_str_from_qualifier(qualifier);
 731             if ((qualifier = find_policy_qualifier(policies,
 732              szOID_PKIX_POLICY_QUALIFIER_USERNOTICE)))
 733                 userNotice = get_user_notice_from_qualifier(qualifier);
 734             if (cps || userNotice)
 735             {
 736                 struct IssuerStatement *issuerStatement =
 737                  HeapAlloc(GetProcessHeap(), 0, sizeof(struct IssuerStatement));
 738
 739                 if (issuerStatement)
 740                 {
 741                     issuerStatement->cps = cps;
 742                     issuerStatement->userNotice = userNotice;
 743                     EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), TRUE);
 744                     SetWindowLongPtrW(hwnd, DWLP_USER,
 745                      (ULONG_PTR)issuerStatement);
 746                 }
 747             }
 748             LocalFree(policies);
 749         }
 750     }
 751 }
 752
 753 static void set_cert_info(HWND hwnd,
 754  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 755 {
 756     CHARFORMATW charFmt;
 757     PARAFORMAT2 parFmt;
 758     HWND icon = GetDlgItem(hwnd, IDC_CERTIFICATE_ICON);
 759     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_INFO);
 760     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
 761      (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
 762      pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
 763      pCertViewInfo->idxCounterSigner);
 764     CRYPT_PROVIDER_CERT *root =
 765      &provSigner->pasCertChain[provSigner->csCertChain - 1];
 766
 767     if (!provSigner->pChainContext ||
 768      (provSigner->pChainContext->TrustStatus.dwErrorStatus &
 769      CERT_TRUST_IS_PARTIAL_CHAIN))
 770         add_icon_to_control(icon, IDB_CERT_WARNING);
 771     else if (!root->fTrustedRoot)
 772         add_icon_to_control(icon, IDB_CERT_ERROR);
 773     else
 774         add_icon_to_control(icon, IDB_CERT);
 775
 776     memset(&charFmt, 0, sizeof(charFmt));
 777     charFmt.cbSize = sizeof(charFmt);
 778     charFmt.dwMask = CFM_BOLD;
 779     charFmt.dwEffects = CFE_BOLD;
 780     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 781     /* FIXME: vertically center text */
 782     parFmt.cbSize = sizeof(parFmt);
 783     parFmt.dwMask = PFM_STARTINDENT;
 784     parFmt.dxStartIndent = MY_INDENT;
 785     add_string_resource_with_paraformat_to_control(text,
 786      IDS_CERTIFICATEINFORMATION, &parFmt);
 787
 788     text = GetDlgItem(hwnd, IDC_CERTIFICATE_STATUS);
 789     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 790     if (provSigner->dwError == TRUST_E_CERT_SIGNATURE)
 791         add_string_resource_with_paraformat_to_control(text,
 792          IDS_CERT_INFO_BAD_SIG, &parFmt);
 793     else if (!provSigner->pChainContext ||
 794      (provSigner->pChainContext->TrustStatus.dwErrorStatus &
 795      CERT_TRUST_IS_PARTIAL_CHAIN))
 796         add_string_resource_with_paraformat_to_control(text,
 797          IDS_CERT_INFO_PARTIAL_CHAIN, &parFmt);
 798     else if (!root->fTrustedRoot)
 799     {
 800         if (provSigner->csCertChain == 1 && root->fSelfSigned)
 801             add_string_resource_with_paraformat_to_control(text,
 802              IDS_CERT_INFO_UNTRUSTED_CA, &parFmt);
 803         else
 804             add_string_resource_with_paraformat_to_control(text,
 805              IDS_CERT_INFO_UNTRUSTED_ROOT, &parFmt);
 806     }
 807     else
 808     {
 809         set_policy_text(text, pCertViewInfo);
 810         set_issuer_statement(hwnd, pCertViewInfo);
 811     }
 812 }
 813
 814 static void set_cert_name_string(HWND hwnd, PCCERT_CONTEXT cert,
 815  DWORD nameFlags, int heading)
 816 {
 817     WCHAR nl = '\n';
 818     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
 819     CHARFORMATW charFmt;
 820     PARAFORMAT2 parFmt;
 821
 822     memset(&charFmt, 0, sizeof(charFmt));
 823     charFmt.cbSize = sizeof(charFmt);
 824     charFmt.dwMask = CFM_BOLD;
 825     charFmt.dwEffects = CFE_BOLD;
 826     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 827     parFmt.cbSize = sizeof(parFmt);
 828     parFmt.dwMask = PFM_STARTINDENT;
 829     parFmt.dxStartIndent = MY_INDENT * 3;
 830     add_string_resource_with_paraformat_to_control(text, heading, &parFmt);
 831     charFmt.dwEffects = 0;
 832     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 833     add_cert_string_to_control(text, cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
 834      nameFlags);
 835     add_unformatted_text_to_control(text, &nl, 1);
 836     add_unformatted_text_to_control(text, &nl, 1);
 837     add_unformatted_text_to_control(text, &nl, 1);
 838
 839 }
 840
 841 static void add_date_string_to_control(HWND hwnd, const FILETIME *fileTime)
 842 {
 843     WCHAR dateFmt[80]; /* sufficient for all versions of LOCALE_SSHORTDATE */
 844     WCHAR date[80];
 845     SYSTEMTIME sysTime;
 846
 847     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SSHORTDATE, dateFmt,
 848      sizeof(dateFmt) / sizeof(dateFmt[0]));
 849     FileTimeToSystemTime(fileTime, &sysTime);
 850     GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, date,
 851      sizeof(date) / sizeof(date[0]));
 852     add_unformatted_text_to_control(hwnd, date, lstrlenW(date));
 853 }
 854
 855 static void set_cert_validity_period(HWND hwnd, PCCERT_CONTEXT cert)
 856 {
 857     WCHAR nl = '\n';
 858     HWND text = GetDlgItem(hwnd, IDC_CERTIFICATE_NAMES);
 859     CHARFORMATW charFmt;
 860     PARAFORMAT2 parFmt;
 861
 862     memset(&charFmt, 0, sizeof(charFmt));
 863     charFmt.cbSize = sizeof(charFmt);
 864     charFmt.dwMask = CFM_BOLD;
 865     charFmt.dwEffects = CFE_BOLD;
 866     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 867     parFmt.cbSize = sizeof(parFmt);
 868     parFmt.dwMask = PFM_STARTINDENT;
 869     parFmt.dxStartIndent = MY_INDENT * 3;
 870     add_string_resource_with_paraformat_to_control(text, IDS_VALID_FROM,
 871      &parFmt);
 872     charFmt.dwEffects = 0;
 873     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 874     add_date_string_to_control(text, &cert->pCertInfo->NotBefore);
 875     charFmt.dwEffects = CFE_BOLD;
 876     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 877     add_string_resource_to_control(text, IDS_VALID_TO);
 878     charFmt.dwEffects = 0;
 879     SendMessageW(text, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&charFmt);
 880     add_date_string_to_control(text, &cert->pCertInfo->NotAfter);
 881     add_unformatted_text_to_control(text, &nl, 1);
 882 }
 883
 884 static void set_general_info(HWND hwnd,
 885  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
 886 {
 887     set_cert_info(hwnd, pCertViewInfo);
 888     set_cert_name_string(hwnd, pCertViewInfo->pCertContext, 0,
 889      IDS_SUBJECT_HEADING);
 890     set_cert_name_string(hwnd, pCertViewInfo->pCertContext,
 891      CERT_NAME_ISSUER_FLAG, IDS_ISSUER_HEADING);
 892     set_cert_validity_period(hwnd, pCertViewInfo->pCertContext);
 893 }
 894
 895 static LRESULT CALLBACK user_notice_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
 896  LPARAM lp)
 897 {
 898     LRESULT ret = 0;
 899     HWND text;
 900     struct IssuerStatement *issuerStatement;
 901
 902     switch (msg)
 903     {
 904     case WM_INITDIALOG:
 905         text = GetDlgItem(hwnd, IDC_USERNOTICE);
 906         issuerStatement = (struct IssuerStatement *)lp;
 907         add_unformatted_text_to_control(text, issuerStatement->userNotice,
 908          strlenW(issuerStatement->userNotice));
 909         if (issuerStatement->cps)
 910             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)issuerStatement->cps);
 911         else
 912             EnableWindow(GetDlgItem(hwnd, IDC_CPS), FALSE);
 913         break;
 914     case WM_COMMAND:
 915         switch (wp)
 916         {
 917         case IDOK:
 918             EndDialog(hwnd, IDOK);
 919             ret = TRUE;
 920             break;
 921         case IDC_CPS:
 922         {
 923             IBindCtx *bctx = NULL;
 924             LPWSTR cps;
 925
 926             CreateBindCtx(0, &bctx);
 927             cps = (LPWSTR)GetWindowLongPtrW(hwnd, DWLP_USER);
 928             HlinkSimpleNavigateToString(cps, NULL, NULL, NULL, bctx, NULL,
 929              HLNF_OPENINNEWWINDOW, 0);
 930             IBindCtx_Release(bctx);
 931             break;
 932         }
 933         }
 934     }
 935     return ret;
 936 }
 937
 938 static void show_user_notice(HWND hwnd, struct IssuerStatement *issuerStatement)
 939 {
 940     DialogBoxParamW(hInstance, MAKEINTRESOURCEW(IDD_USERNOTICE), hwnd,
 941      user_notice_dlg_proc, (LPARAM)issuerStatement);
 942 }
 943
 944 static LRESULT CALLBACK general_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
 945  LPARAM lp)
 946 {
 947     PROPSHEETPAGEW *page;
 948     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
 949
 950     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
 951
 952     switch (msg)
 953     {
 954     case WM_INITDIALOG:
 955         page = (PROPSHEETPAGEW *)lp;
 956         pCertViewInfo = (PCCRYPTUI_VIEWCERTIFICATE_STRUCTW)page->lParam;
 957         if (pCertViewInfo->dwFlags & CRYPTUI_DISABLE_ADDTOSTORE)
 958             ShowWindow(GetDlgItem(hwnd, IDC_ADDTOSTORE), FALSE);
 959         EnableWindow(GetDlgItem(hwnd, IDC_ISSUERSTATEMENT), FALSE);
 960         set_general_info(hwnd, pCertViewInfo);
 961         break;
 962     case WM_COMMAND:
 963         switch (wp)
 964         {
 965         case IDC_ADDTOSTORE:
 966             FIXME("call CryptUIWizImport\n");
 967             break;
 968         case IDC_ISSUERSTATEMENT:
 969         {
 970             struct IssuerStatement *issuerStatement =
 971              (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
 972
 973             if (issuerStatement)
 974             {
 975                 if (issuerStatement->userNotice)
 976                     show_user_notice(hwnd, issuerStatement);
 977                 else if (issuerStatement->cps)
 978                 {
 979                     IBindCtx *bctx = NULL;
 980
 981                     CreateBindCtx(0, &bctx);
 982                     HlinkSimpleNavigateToString(issuerStatement->cps, NULL,
 983                      NULL, NULL, bctx, NULL, HLNF_OPENINNEWWINDOW, 0);
 984                     IBindCtx_Release(bctx);
 985                 }
 986             }
 987             break;
 988         }
 989         }
 990         break;
 991     }
 992     return 0;
 993 }
 994
 995 static UINT CALLBACK general_callback_proc(HWND hwnd, UINT msg,
 996  PROPSHEETPAGEW *page)
 997 {
 998     struct IssuerStatement *issuerStatement;
 999
1000     switch (msg)
1001     {
1002     case PSPCB_RELEASE:
1003         issuerStatement =
1004          (struct IssuerStatement *)GetWindowLongPtrW(hwnd, DWLP_USER);
1005         if (issuerStatement)
1006         {
1007             HeapFree(GetProcessHeap(), 0, issuerStatement->cps);
1008             HeapFree(GetProcessHeap(), 0, issuerStatement->userNotice);
1009             HeapFree(GetProcessHeap(), 0, issuerStatement);
1010         }
1011         break;
1012     }
1013     return 1;
1014 }
1015
1016 static void init_general_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
1017  PROPSHEETPAGEW *page)
1018 {
1019     memset(page, 0, sizeof(PROPSHEETPAGEW));
1020     page->dwSize = sizeof(PROPSHEETPAGEW);
1021     page->dwFlags = PSP_USECALLBACK;
1022     page->pfnCallback = general_callback_proc;
1023     page->hInstance = hInstance;
1024     page->u.pszTemplate = MAKEINTRESOURCEW(IDD_GENERAL);
1025     page->pfnDlgProc = general_dlg_proc;
1026     page->lParam = (LPARAM)pCertViewInfo;
1027 }
1028
1029 typedef WCHAR * (*field_format_func)(PCCERT_CONTEXT cert);
1030
1031 static WCHAR *field_format_version(PCCERT_CONTEXT cert)
1032 {
1033     static const WCHAR fmt[] = { 'V','%','d',0 };
1034     WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, 12 * sizeof(WCHAR));
1035
1036     if (buf)
1037         sprintfW(buf, fmt, cert->pCertInfo->dwVersion);
1038     return buf;
1039 }
1040
1041 static WCHAR *format_hex_string(void *pb, DWORD cb)
1042 {
1043     WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, (cb * 3 + 1) * sizeof(WCHAR));
1044
1045     if (buf)
1046     {
1047         static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1048         DWORD i;
1049         WCHAR *ptr;
1050
1051         for (i = 0, ptr = buf; i < cb; i++, ptr += 3)
1052             sprintfW(ptr, fmt, ((BYTE *)pb)[i]);
1053     }
1054     return buf;
1055 }
1056
1057 static WCHAR *field_format_serial_number(PCCERT_CONTEXT cert)
1058 {
1059     return format_hex_string(cert->pCertInfo->SerialNumber.pbData,
1060      cert->pCertInfo->SerialNumber.cbData);
1061 }
1062
1063 static WCHAR *field_format_issuer(PCCERT_CONTEXT cert)
1064 {
1065     return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1066      CERT_NAME_ISSUER_FLAG);
1067 }
1068
1069 static WCHAR *field_format_detailed_cert_name(PCERT_NAME_BLOB name)
1070 {
1071     WCHAR *str = NULL;
1072     DWORD len = CertNameToStrW(X509_ASN_ENCODING, name,
1073      CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, NULL, 0);
1074
1075     if (len)
1076     {
1077         str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1078         if (str)
1079             CertNameToStrW(X509_ASN_ENCODING, name,
1080              CERT_X500_NAME_STR | CERT_NAME_STR_CRLF_FLAG, str, len);
1081     }
1082     return str;
1083 }
1084
1085 static WCHAR *field_format_detailed_issuer(PCCERT_CONTEXT cert, void *param)
1086 {
1087     return field_format_detailed_cert_name(&cert->pCertInfo->Issuer);
1088 }
1089
1090 static WCHAR *field_format_subject(PCCERT_CONTEXT cert)
1091 {
1092     return get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
1093 }
1094
1095 static WCHAR *field_format_detailed_subject(PCCERT_CONTEXT cert, void *param)
1096 {
1097     return field_format_detailed_cert_name(&cert->pCertInfo->Subject);
1098 }
1099
1100 static WCHAR *format_long_date(const FILETIME *fileTime)
1101 {
1102     WCHAR dateFmt[80]; /* long enough for LOCALE_SLONGDATE */
1103     DWORD len;
1104     WCHAR *buf = NULL;
1105     SYSTEMTIME sysTime;
1106
1107     /* FIXME: format isn't quite right, want time too */
1108     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SLONGDATE, dateFmt,
1109      sizeof(dateFmt) / sizeof(dateFmt[0]));
1110     FileTimeToSystemTime(fileTime, &sysTime);
1111     len = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, NULL, 0);
1112     if (len)
1113     {
1114         buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1115         if (buf)
1116             GetDateFormatW(LOCALE_SYSTEM_DEFAULT, 0, &sysTime, dateFmt, buf,
1117              len);
1118     }
1119     return buf;
1120 }
1121
1122 static WCHAR *field_format_from_date(PCCERT_CONTEXT cert)
1123 {
1124     return format_long_date(&cert->pCertInfo->NotBefore);
1125 }
1126
1127 static WCHAR *field_format_to_date(PCCERT_CONTEXT cert)
1128 {
1129     return format_long_date(&cert->pCertInfo->NotAfter);
1130 }
1131
1132 static WCHAR *field_format_public_key(PCCERT_CONTEXT cert)
1133 {
1134     PCCRYPT_OID_INFO oidInfo;
1135     WCHAR *buf = NULL;
1136
1137     oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1138      cert->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId, 0);
1139     if (oidInfo)
1140     {
1141         WCHAR fmt[MAX_STRING_LEN];
1142
1143         if (LoadStringW(hInstance, IDS_FIELD_PUBLIC_KEY_FORMAT, fmt,
1144          sizeof(fmt) / sizeof(fmt[0])))
1145         {
1146             /* Allocate the output buffer.  Use the number of bytes in the
1147              * public key as a conservative (high) estimate for the number of
1148              * digits in its output.
1149              * The output is of the form (in English)
1150              * "<public key algorithm> (<public key bit length> bits)".
1151              * Ordinarily having two positional parameters in a string is not a
1152              * good idea, but as this isn't a sentence fragment, it shouldn't
1153              * be word-order dependent.
1154              */
1155             buf = HeapAlloc(GetProcessHeap(), 0,
1156              (strlenW(fmt) + strlenW(oidInfo->pwszName) +
1157              cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData * 8)
1158              * sizeof(WCHAR));
1159             if (buf)
1160                 sprintfW(buf, fmt, oidInfo->pwszName,
1161                  CertGetPublicKeyLength(X509_ASN_ENCODING,
1162                   &cert->pCertInfo->SubjectPublicKeyInfo));
1163         }
1164     }
1165     return buf;
1166 }
1167
1168 static WCHAR *field_format_detailed_public_key(PCCERT_CONTEXT cert, void *param)
1169 {
1170     return format_hex_string(
1171      cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData,
1172      cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData);
1173 }
1174
1175 struct field_value_data;
1176 struct detail_data
1177 {
1178     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
1179     BOOL *pfPropertiesChanged;
1180     int cFields;
1181     struct field_value_data *fields;
1182 };
1183
1184 typedef void (*add_fields_func)(HWND hwnd, struct detail_data *data);
1185
1186 typedef WCHAR *(*create_detailed_value_func)(PCCERT_CONTEXT cert, void *param);
1187
1188 struct field_value_data
1189 {
1190     create_detailed_value_func create;
1191     LPWSTR detailed_value;
1192     void *param;
1193 };
1194
1195 static void add_field_value_data(struct detail_data *data,
1196  create_detailed_value_func create, void *param)
1197 {
1198     if (data->cFields)
1199         data->fields = HeapReAlloc(GetProcessHeap(), 0, data->fields,
1200          (data->cFields + 1) * sizeof(struct field_value_data));
1201     else
1202         data->fields = HeapAlloc(GetProcessHeap(), 0,
1203          sizeof(struct field_value_data));
1204     if (data->fields)
1205     {
1206         data->fields[data->cFields].create = create;
1207         data->fields[data->cFields].detailed_value = NULL;
1208         data->fields[data->cFields].param = param;
1209         data->cFields++;
1210     }
1211 }
1212
1213 static void add_field_and_value_to_list(HWND hwnd, struct detail_data *data,
1214  LPWSTR field, LPWSTR value, create_detailed_value_func create, void *param)
1215 {
1216     LVITEMW item;
1217     int iItem = SendMessageW(hwnd, LVM_GETITEMCOUNT, 0, 0);
1218
1219     item.mask = LVIF_TEXT | LVIF_PARAM;
1220     item.iItem = iItem;
1221     item.iSubItem = 0;
1222     item.pszText = field;
1223     item.lParam = (LPARAM)data;
1224     SendMessageW(hwnd, LVM_INSERTITEMW, 0, (LPARAM)&item);
1225     if (value)
1226     {
1227         item.pszText = value;
1228         item.iSubItem = 1;
1229         SendMessageW(hwnd, LVM_SETITEMTEXTW, iItem, (LPARAM)&item);
1230     }
1231     add_field_value_data(data, create, param);
1232 }
1233
1234 static void add_string_id_and_value_to_list(HWND hwnd, struct detail_data *data,
1235  int id, LPWSTR value, create_detailed_value_func create, void *param)
1236 {
1237     WCHAR buf[MAX_STRING_LEN];
1238
1239     LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
1240     add_field_and_value_to_list(hwnd, data, buf, value, create, param);
1241 }
1242
1243 struct v1_field
1244 {
1245     int id;
1246     field_format_func format;
1247     create_detailed_value_func create_detailed_value;
1248 };
1249
1250 static void add_v1_field(HWND hwnd, struct detail_data *data,
1251  const struct v1_field *field)
1252 {
1253     WCHAR *val = field->format(data->pCertViewInfo->pCertContext);
1254
1255     if (val)
1256     {
1257         add_string_id_and_value_to_list(hwnd, data, field->id, val,
1258          field->create_detailed_value, NULL);
1259         HeapFree(GetProcessHeap(), 0, val);
1260     }
1261 }
1262
1263 static const struct v1_field v1_fields[] = {
1264  { IDS_FIELD_VERSION, field_format_version, NULL },
1265  { IDS_FIELD_SERIAL_NUMBER, field_format_serial_number, NULL },
1266  { IDS_FIELD_ISSUER, field_format_issuer, field_format_detailed_issuer },
1267  { IDS_FIELD_VALID_FROM, field_format_from_date, NULL },
1268  { IDS_FIELD_VALID_TO, field_format_to_date, NULL },
1269  { IDS_FIELD_SUBJECT, field_format_subject, field_format_detailed_subject },
1270  { IDS_FIELD_PUBLIC_KEY, field_format_public_key,
1271    field_format_detailed_public_key }
1272 };
1273
1274 static void add_v1_fields(HWND hwnd, struct detail_data *data)
1275 {
1276     int i;
1277     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1278
1279     /* The last item in v1_fields is the public key, which is not in the loop
1280      * because it's a special case.
1281      */
1282     for (i = 0; i < sizeof(v1_fields) / sizeof(v1_fields[0]) - 1; i++)
1283         add_v1_field(hwnd, data, &v1_fields[i]);
1284     if (cert->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData)
1285         add_v1_field(hwnd, data, &v1_fields[i]);
1286 }
1287
1288 static WCHAR *crypt_format_extension(PCERT_EXTENSION ext, DWORD formatStrType)
1289 {
1290     WCHAR *str = NULL;
1291     DWORD size;
1292
1293     if (CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
1294      ext->pszObjId, ext->Value.pbData, ext->Value.cbData, NULL, &size))
1295     {
1296         str = HeapAlloc(GetProcessHeap(), 0, size);
1297         CryptFormatObject(X509_ASN_ENCODING, 0, formatStrType, NULL,
1298          ext->pszObjId, ext->Value.pbData, ext->Value.cbData, str, &size);
1299     }
1300     return str;
1301 }
1302
1303 static WCHAR *field_format_extension_hex_with_ascii(PCERT_EXTENSION ext)
1304 {
1305     WCHAR *str = NULL;
1306
1307     if (ext->Value.cbData)
1308     {
1309         /* The output is formatted as:
1310          * <hex bytes>  <ascii bytes>\n
1311          * where <hex bytes> is a string of up to 8 bytes, output as %02x,
1312          * and <ascii bytes> is the ASCII equivalent of each byte, or '.' if
1313          * the byte is not printable.
1314          * So, for example, the extension value consisting of the following
1315          * bytes:
1316          *   0x30,0x14,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,
1317          *   0x13,0x09,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67
1318          * is output as:
1319          *   30 14 31 12 30 10 06 03  0.1.0...
1320          *   55 04 03 13 09 4a 75 61  U....Jua
1321          *   6e 20 4c 61 6e 67        n Lang
1322          * The allocation size therefore requires:
1323          * - 4 characters per character in an 8-byte line
1324          *   (2 for the hex format, one for the space, one for the ASCII value)
1325          * - 3 more characters per 8-byte line (two spaces and a newline)
1326          * - 1 character for the terminating nul
1327          * FIXME: should use a fixed-width font for this
1328          */
1329         DWORD lines = (ext->Value.cbData + 7) / 8;
1330
1331         str = HeapAlloc(GetProcessHeap(), 0,
1332          (lines * 8 * 4 + lines * 3 + 1) * sizeof(WCHAR));
1333         if (str)
1334         {
1335             static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
1336             DWORD i, j;
1337             WCHAR *ptr;
1338
1339             for (i = 0, ptr = str; i < ext->Value.cbData; i += 8)
1340             {
1341                 /* Output as hex bytes first */
1342                 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr += 3)
1343                     sprintfW(ptr, fmt, ext->Value.pbData[j]);
1344                 /* Pad the hex output with spaces for alignment */
1345                 if (j == ext->Value.cbData && j % 8)
1346                 {
1347                     static const WCHAR pad[] = { ' ',' ',' ' };
1348
1349                     for (; j % 8; j++, ptr += sizeof(pad) / sizeof(pad[0]))
1350                         memcpy(ptr, pad, sizeof(pad));
1351                 }
1352                 /* The last sprintfW included a space, so just insert one
1353                  * more space between the hex bytes and the ASCII output
1354                  */
1355                 *ptr++ = ' ';
1356                 /* Output as ASCII bytes */
1357                 for (j = i; j < min(i + 8, ext->Value.cbData); j++, ptr++)
1358                 {
1359                     if (isprintW(ext->Value.pbData[j]) &&
1360                      !isspaceW(ext->Value.pbData[j]))
1361                         *ptr = ext->Value.pbData[j];
1362                     else
1363                         *ptr = '.';
1364                 }
1365                 *ptr++ = '\n';
1366             }
1367             *ptr++ = '\0';
1368         }
1369     }
1370     return str;
1371 }
1372
1373 static WCHAR *field_format_detailed_extension(PCCERT_CONTEXT cert, void *param)
1374 {
1375     PCERT_EXTENSION ext = param;
1376     LPWSTR str = crypt_format_extension(ext,
1377      CRYPT_FORMAT_STR_MULTI_LINE | CRYPT_FORMAT_STR_NO_HEX);
1378
1379     if (!str)
1380         str = field_format_extension_hex_with_ascii(ext);
1381     return str;
1382 }
1383
1384 static void add_cert_extension_detail(HWND hwnd, struct detail_data *data,
1385  PCERT_EXTENSION ext)
1386 {
1387     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1388      ext->pszObjId, 0);
1389     LPWSTR val = crypt_format_extension(ext, 0);
1390
1391     if (oidInfo)
1392         add_field_and_value_to_list(hwnd, data, (LPWSTR)oidInfo->pwszName,
1393          val, field_format_detailed_extension, ext);
1394     else
1395     {
1396         DWORD len = strlen(ext->pszObjId);
1397         LPWSTR oidW = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1398
1399         if (oidW)
1400         {
1401             DWORD i;
1402
1403             for (i = 0; i <= len; i++)
1404                 oidW[i] = ext->pszObjId[i];
1405             add_field_and_value_to_list(hwnd, data, oidW, val,
1406              field_format_detailed_extension, ext);
1407             HeapFree(GetProcessHeap(), 0, oidW);
1408         }
1409     }
1410     HeapFree(GetProcessHeap(), 0, val);
1411 }
1412
1413 static void add_all_extensions(HWND hwnd, struct detail_data *data)
1414 {
1415     DWORD i;
1416     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1417
1418     for (i = 0; i < cert->pCertInfo->cExtension; i++)
1419         add_cert_extension_detail(hwnd, data, &cert->pCertInfo->rgExtension[i]);
1420 }
1421
1422 static void add_critical_extensions(HWND hwnd, struct detail_data *data)
1423 {
1424     DWORD i;
1425     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1426
1427     for (i = 0; i < cert->pCertInfo->cExtension; i++)
1428         if (cert->pCertInfo->rgExtension[i].fCritical)
1429             add_cert_extension_detail(hwnd, data,
1430              &cert->pCertInfo->rgExtension[i]);
1431 }
1432
1433 typedef WCHAR * (*prop_to_value_func)(void *pb, DWORD cb);
1434
1435 struct prop_id_to_string_id
1436 {
1437     DWORD prop;
1438     int id;
1439     BOOL prop_is_string;
1440     prop_to_value_func prop_to_value;
1441 };
1442
1443 static WCHAR *format_enhanced_key_usage_value(void *pb, DWORD cb)
1444 {
1445     CERT_EXTENSION ext;
1446
1447     ext.pszObjId = (LPSTR)X509_ENHANCED_KEY_USAGE;
1448     ext.fCritical = FALSE;
1449     ext.Value.pbData = pb;
1450     ext.Value.cbData = cb;
1451     return crypt_format_extension(&ext, 0);
1452 }
1453
1454 /* Logically the access state should also be checked, and IDC_EDITPROPERTIES
1455  * disabled for read-only certificates, but native doesn't appear to do that.
1456  */
1457 static const struct prop_id_to_string_id prop_id_map[] = {
1458  { CERT_HASH_PROP_ID, IDS_PROP_HASH, FALSE, format_hex_string },
1459  { CERT_FRIENDLY_NAME_PROP_ID, IDS_PROP_FRIENDLY_NAME, TRUE, NULL },
1460  { CERT_DESCRIPTION_PROP_ID, IDS_PROP_DESCRIPTION, TRUE, NULL },
1461  { CERT_ENHKEY_USAGE_PROP_ID, IDS_PROP_ENHKEY_USAGE, FALSE,
1462    format_enhanced_key_usage_value },
1463 };
1464
1465 static void add_properties(HWND hwnd, struct detail_data *data)
1466 {
1467     DWORD i;
1468     PCCERT_CONTEXT cert = data->pCertViewInfo->pCertContext;
1469
1470     for (i = 0; i < sizeof(prop_id_map) / sizeof(prop_id_map[0]); i++)
1471     {
1472         DWORD cb;
1473
1474         if (CertGetCertificateContextProperty(cert, prop_id_map[i].prop, NULL,
1475          &cb))
1476         {
1477             BYTE *pb;
1478             WCHAR *val = NULL;
1479
1480             /* FIXME: MS adds a separate value for the signature hash
1481              * algorithm.
1482              */
1483             pb = HeapAlloc(GetProcessHeap(), 0, cb);
1484             if (pb)
1485             {
1486                 if (CertGetCertificateContextProperty(cert,
1487                  prop_id_map[i].prop, pb, &cb))
1488                 {
1489                     if (prop_id_map[i].prop_is_string)
1490                     {
1491                         val = (LPWSTR)pb;
1492                         /* Don't double-free pb */
1493                         pb = NULL;
1494                     }
1495                     else
1496                         val = prop_id_map[i].prop_to_value(pb, cb);
1497                 }
1498                 HeapFree(GetProcessHeap(), 0, pb);
1499             }
1500             add_string_id_and_value_to_list(hwnd, data, prop_id_map[i].id, val,
1501              NULL, NULL);
1502         }
1503     }
1504 }
1505
1506 static void add_all_fields(HWND hwnd, struct detail_data *data)
1507 {
1508     add_v1_fields(hwnd, data);
1509     add_all_extensions(hwnd, data);
1510     add_properties(hwnd, data);
1511 }
1512
1513 struct selection_list_item
1514 {
1515     int id;
1516     add_fields_func add;
1517 };
1518
1519 const struct selection_list_item listItems[] = {
1520  { IDS_FIELDS_ALL, add_all_fields },
1521  { IDS_FIELDS_V1, add_v1_fields },
1522  { IDS_FIELDS_EXTENSIONS, add_all_extensions },
1523  { IDS_FIELDS_CRITICAL_EXTENSIONS, add_critical_extensions },
1524  { IDS_FIELDS_PROPERTIES, add_properties },
1525 };
1526
1527 static void create_show_list(HWND hwnd, struct detail_data *data)
1528 {
1529     HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
1530     WCHAR buf[MAX_STRING_LEN];
1531     int i;
1532
1533     for (i = 0; i < sizeof(listItems) / sizeof(listItems[0]); i++)
1534     {
1535         int index;
1536
1537         LoadStringW(hInstance, listItems[i].id, buf,
1538          sizeof(buf) / sizeof(buf[0]));
1539         index = SendMessageW(cb, CB_INSERTSTRING, -1, (LPARAM)buf);
1540         SendMessageW(cb, CB_SETITEMDATA, index, (LPARAM)data);
1541     }
1542     SendMessageW(cb, CB_SETCURSEL, 0, 0);
1543 }
1544
1545 static void create_listview_columns(HWND hwnd)
1546 {
1547     HWND lv = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1548     RECT rc;
1549     WCHAR buf[MAX_STRING_LEN];
1550     LVCOLUMNW column;
1551
1552     SendMessageW(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);
1553     GetWindowRect(lv, &rc);
1554     LoadStringW(hInstance, IDS_FIELD, buf, sizeof(buf) / sizeof(buf[0]));
1555     column.mask = LVCF_WIDTH | LVCF_TEXT;
1556     column.cx = (rc.right - rc.left) / 2 - 2;
1557     column.pszText = buf;
1558     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
1559     LoadStringW(hInstance, IDS_VALUE, buf, sizeof(buf) / sizeof(buf[0]));
1560     SendMessageW(lv, LVM_INSERTCOLUMNW, 1, (LPARAM)&column);
1561 }
1562
1563 static void set_fields_selection(HWND hwnd, struct detail_data *data, int sel)
1564 {
1565     HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
1566
1567     if (sel >= 0 && sel < sizeof(listItems) / sizeof(listItems[0]))
1568     {
1569         SendMessageW(list, LVM_DELETEALLITEMS, 0, 0);
1570         listItems[sel].add(list, data);
1571     }
1572 }
1573
1574 static void create_cert_details_list(HWND hwnd, struct detail_data *data)
1575 {
1576     create_show_list(hwnd, data);
1577     create_listview_columns(hwnd);
1578     set_fields_selection(hwnd, data, 0);
1579 }
1580
1581 typedef enum {
1582     CheckBitmapIndexUnchecked = 1,
1583     CheckBitmapIndexChecked = 2,
1584     CheckBitmapIndexDisabledUnchecked = 3,
1585     CheckBitmapIndexDisabledChecked = 4
1586 } CheckBitmapIndex;
1587
1588 static void add_purpose(HWND hwnd, LPCSTR oid)
1589 {
1590     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1591     PCRYPT_OID_INFO info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1592      sizeof(CRYPT_OID_INFO));
1593
1594     if (info)
1595     {
1596         char *oidCopy = HeapAlloc(GetProcessHeap(), 0, strlen(oid) + 1);
1597
1598         if (oidCopy)
1599         {
1600             LVITEMA item;
1601
1602             strcpy(oidCopy, oid);
1603             info->cbSize = sizeof(CRYPT_OID_INFO);
1604             info->pszOID = oidCopy;
1605             item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
1606             item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexChecked);
1607             item.stateMask = LVIS_STATEIMAGEMASK;
1608             item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
1609             item.iSubItem = 0;
1610             item.lParam = (LPARAM)info;
1611             item.pszText = oidCopy;
1612             SendMessageA(lv, LVM_INSERTITEMA, 0, (LPARAM)&item);
1613         }
1614         else
1615             HeapFree(GetProcessHeap(), 0, info);
1616     }
1617 }
1618
1619 static BOOL is_valid_oid(LPCSTR oid)
1620 {
1621     BOOL ret;
1622
1623     if (oid[0] != '0' && oid[0] != '1' && oid[0] != '2')
1624         ret = FALSE;
1625     else if (oid[1] != '.')
1626         ret = FALSE;
1627     else if (!oid[2])
1628         ret = FALSE;
1629     else
1630     {
1631         const char *ptr;
1632         BOOL expectNum = TRUE;
1633
1634         for (ptr = oid + 2, ret = TRUE; ret && *ptr; ptr++)
1635         {
1636             if (expectNum)
1637             {
1638                 if (!isdigit(*ptr))
1639                     ret = FALSE;
1640                 else if (*(ptr + 1) == '.')
1641                     expectNum = FALSE;
1642             }
1643             else
1644             {
1645                 if (*ptr != '.')
1646                     ret = FALSE;
1647                 else if (!(*(ptr + 1)))
1648                     ret = FALSE;
1649                 else
1650                     expectNum = TRUE;
1651             }
1652         }
1653     }
1654     return ret;
1655 }
1656
1657 static BOOL is_oid_in_list(HWND hwnd, LPCSTR oid)
1658 {
1659     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1660     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1661      (void *)oid, CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
1662     BOOL ret = FALSE;
1663
1664     if (oidInfo)
1665     {
1666         LVFINDINFOW findInfo;
1667
1668         findInfo.flags = LVFI_PARAM;
1669         findInfo.lParam = (LPARAM)oidInfo;
1670         if (SendMessageW(lv, LVM_FINDITEMW, -1, (LPARAM)&findInfo) != -1)
1671             ret = TRUE;
1672     }
1673     else
1674     {
1675         LVFINDINFOA findInfo;
1676
1677         findInfo.flags = LVFI_STRING;
1678         findInfo.psz = oid;
1679         if (SendMessageW(lv, LVM_FINDITEMA, -1, (LPARAM)&findInfo) != -1)
1680             ret = TRUE;
1681     }
1682     return ret;
1683 }
1684
1685 #define MAX_PURPOSE 255
1686
1687 static LRESULT CALLBACK add_purpose_dlg_proc(HWND hwnd, UINT msg,
1688  WPARAM wp, LPARAM lp)
1689 {
1690     LRESULT ret = 0;
1691     char buf[MAX_PURPOSE + 1];
1692
1693     switch (msg)
1694     {
1695     case WM_INITDIALOG:
1696         SendMessageW(GetDlgItem(hwnd, IDC_NEW_PURPOSE), EM_SETLIMITTEXT,
1697          MAX_PURPOSE, 0);
1698         ShowScrollBar(GetDlgItem(hwnd, IDC_NEW_PURPOSE), SB_VERT, FALSE);
1699         SetWindowLongPtrW(hwnd, DWLP_USER, lp);
1700         break;
1701     case WM_COMMAND:
1702         switch (HIWORD(wp))
1703         {
1704         case EN_CHANGE:
1705             if (LOWORD(wp) == IDC_NEW_PURPOSE)
1706             {
1707                 /* Show/hide scroll bar on description depending on how much
1708                  * text it has.
1709                  */
1710                 HWND description = GetDlgItem(hwnd, IDC_NEW_PURPOSE);
1711                 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
1712
1713                 ShowScrollBar(description, SB_VERT, lines > 1);
1714             }
1715             break;
1716         case BN_CLICKED:
1717             switch (LOWORD(wp))
1718             {
1719             case IDOK:
1720                 SendMessageA(GetDlgItem(hwnd, IDC_NEW_PURPOSE), WM_GETTEXT,
1721                  sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
1722                 if (!buf[0])
1723                 {
1724                     /* An empty purpose is the same as cancelling */
1725                     EndDialog(hwnd, IDCANCEL);
1726                     ret = TRUE;
1727                 }
1728                 else if (!is_valid_oid(buf))
1729                 {
1730                     WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
1731
1732                     LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_ERROR, error,
1733                      sizeof(error) / sizeof(error[0]));
1734                     LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
1735                      sizeof(title) / sizeof(title[0]));
1736                     MessageBoxW(hwnd, error, title, MB_ICONERROR | MB_OK);
1737                 }
1738                 else if (is_oid_in_list(
1739                  (HWND)GetWindowLongPtrW(hwnd, DWLP_USER), buf))
1740                 {
1741                     WCHAR title[MAX_STRING_LEN], error[MAX_STRING_LEN];
1742
1743                     LoadStringW(hInstance, IDS_CERTIFICATE_PURPOSE_EXISTS,
1744                      error, sizeof(error) / sizeof(error[0]));
1745                     LoadStringW(hInstance, IDS_CERTIFICATE_PROPERTIES, title,
1746                      sizeof(title) / sizeof(title[0]));
1747                     MessageBoxW(hwnd, error, title, MB_ICONEXCLAMATION | MB_OK);
1748                 }
1749                 else
1750                 {
1751                     HWND parent = (HWND)GetWindowLongPtrW(hwnd, DWLP_USER);
1752
1753                     add_purpose(parent, buf);
1754                     EndDialog(hwnd, wp);
1755                     ret = TRUE;
1756                 }
1757                 break;
1758             case IDCANCEL:
1759                 EndDialog(hwnd, wp);
1760                 ret = TRUE;
1761                 break;
1762             }
1763             break;
1764         }
1765         break;
1766     }
1767     return ret;
1768 }
1769
1770 static WCHAR *get_cert_property_as_string(PCCERT_CONTEXT cert, DWORD prop)
1771 {
1772     WCHAR *name = NULL;
1773     DWORD cb;
1774
1775     if (CertGetCertificateContextProperty(cert, prop, NULL, &cb))
1776     {
1777         name = HeapAlloc(GetProcessHeap(), 0, cb);
1778         if (name)
1779         {
1780             if (!CertGetCertificateContextProperty(cert, prop, (LPBYTE)name,
1781              &cb))
1782             {
1783                 HeapFree(GetProcessHeap(), 0, name);
1784                 name = NULL;
1785             }
1786         }
1787     }
1788     return name;
1789 }
1790
1791 static void redraw_states(HWND list, BOOL enabled)
1792 {
1793     int items = SendMessageW(list, LVM_GETITEMCOUNT, 0, 0), i;
1794
1795     for (i = 0; i < items; i++)
1796     {
1797         BOOL change = FALSE;
1798         int state;
1799
1800         state = SendMessageW(list, LVM_GETITEMSTATE, i, LVIS_STATEIMAGEMASK);
1801         /* This reverses the INDEXTOSTATEIMAGEMASK shift.  There doesn't appear
1802          * to be a handy macro for it.
1803          */
1804         state >>= 12;
1805         if (enabled)
1806         {
1807             if (state == CheckBitmapIndexDisabledChecked)
1808             {
1809                 state = CheckBitmapIndexChecked;
1810                 change = TRUE;
1811             }
1812             if (state == CheckBitmapIndexDisabledUnchecked)
1813             {
1814                 state = CheckBitmapIndexUnchecked;
1815                 change = TRUE;
1816             }
1817         }
1818         else
1819         {
1820             if (state == CheckBitmapIndexChecked)
1821             {
1822                 state = CheckBitmapIndexDisabledChecked;
1823                 change = TRUE;
1824             }
1825             if (state == CheckBitmapIndexUnchecked)
1826             {
1827                 state = CheckBitmapIndexDisabledUnchecked;
1828                 change = TRUE;
1829             }
1830         }
1831         if (change)
1832         {
1833             LVITEMW item;
1834
1835             item.state = INDEXTOSTATEIMAGEMASK(state);
1836             item.stateMask = LVIS_STATEIMAGEMASK;
1837             SendMessageW(list, LVM_SETITEMSTATE, i, (LPARAM)&item);
1838         }
1839     }
1840 }
1841
1842 typedef enum {
1843     PurposeEnableAll = 0,
1844     PurposeDisableAll,
1845     PurposeEnableSelected
1846 } PurposeSelection;
1847
1848 static void select_purposes(HWND hwnd, PurposeSelection selection)
1849 {
1850     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1851
1852     switch (selection)
1853     {
1854     case PurposeEnableAll:
1855     case PurposeDisableAll:
1856         EnableWindow(lv, FALSE);
1857         redraw_states(lv, FALSE);
1858         EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), FALSE);
1859         break;
1860     case PurposeEnableSelected:
1861         EnableWindow(lv, TRUE);
1862         redraw_states(lv, TRUE);
1863         EnableWindow(GetDlgItem(hwnd, IDC_ADD_PURPOSE), TRUE);
1864     }
1865 }
1866
1867 extern BOOL WINAPI WTHelperGetKnownUsages(DWORD action,
1868  PCCRYPT_OID_INFO **usages);
1869
1870 static void add_known_usage(HWND lv, PCCRYPT_OID_INFO info)
1871 {
1872     LVITEMW item;
1873
1874     item.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
1875     item.state = INDEXTOSTATEIMAGEMASK(CheckBitmapIndexDisabledChecked);
1876     item.stateMask = LVIS_STATEIMAGEMASK;
1877     item.iItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
1878     item.iSubItem = 0;
1879     item.lParam = (LPARAM)info;
1880     item.pszText = (LPWSTR)info->pwszName;
1881     SendMessageW(lv, LVM_INSERTITEMW, 0, (LPARAM)&item);
1882 }
1883
1884 struct edit_cert_data
1885 {
1886     PCCERT_CONTEXT cert;
1887     BOOL *pfPropertiesChanged;
1888     HIMAGELIST imageList;
1889 };
1890
1891 static void show_cert_usages(HWND hwnd, struct edit_cert_data *data)
1892 {
1893     PCCERT_CONTEXT cert = data->cert;
1894     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
1895     PCERT_ENHKEY_USAGE usage;
1896     DWORD size;
1897     PCCRYPT_OID_INFO *usages;
1898     RECT rc;
1899     LVCOLUMNW column;
1900     PurposeSelection purposeSelection;
1901
1902     GetWindowRect(lv, &rc);
1903     column.mask = LVCF_WIDTH;
1904     column.cx = rc.right - rc.left;
1905     SendMessageW(lv, LVM_INSERTCOLUMNW, 0, (LPARAM)&column);
1906     SendMessageW(lv, LVM_SETIMAGELIST, LVSIL_STATE, (LPARAM)data->imageList);
1907
1908     /* Get enhanced key usage.  Have to check for a property and an extension
1909      * separately, because CertGetEnhancedKeyUsage will succeed and return an
1910      * empty usage if neither is set.  Unfortunately an empty usage implies
1911      * no usage is allowed, so we have to distinguish between the two cases.
1912      */
1913     if (CertGetEnhancedKeyUsage(cert, CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG,
1914      NULL, &size))
1915     {
1916         usage = HeapAlloc(GetProcessHeap(), 0, size);
1917         if (!CertGetEnhancedKeyUsage(cert,
1918          CERT_FIND_PROP_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
1919         {
1920             HeapFree(GetProcessHeap(), 0, usage);
1921             usage = NULL;
1922         }
1923         else if (usage->cUsageIdentifier)
1924             purposeSelection = PurposeEnableSelected;
1925         else
1926             purposeSelection = PurposeDisableAll;
1927     }
1928     else if (CertGetEnhancedKeyUsage(cert, CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG,
1929      NULL, &size))
1930     {
1931         usage = HeapAlloc(GetProcessHeap(), 0, size);
1932         if (!CertGetEnhancedKeyUsage(cert,
1933          CERT_FIND_EXT_ONLY_ENHKEY_USAGE_FLAG, usage, &size))
1934         {
1935             HeapFree(GetProcessHeap(), 0, usage);
1936             usage = NULL;
1937         }
1938         else if (usage->cUsageIdentifier)
1939             purposeSelection = PurposeEnableAll;
1940         else
1941             purposeSelection = PurposeDisableAll;
1942     }
1943     else
1944     {
1945         purposeSelection = PurposeEnableAll;
1946         usage = NULL;
1947     }
1948     if (usage)
1949     {
1950         DWORD i;
1951
1952         for (i = 0; i < usage->cUsageIdentifier; i++)
1953         {
1954             PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1955              usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
1956
1957             if (info)
1958                 add_known_usage(lv, info);
1959             else
1960                 add_purpose(hwnd, usage->rgpszUsageIdentifier[i]);
1961         }
1962         HeapFree(GetProcessHeap(), 0, usage);
1963     }
1964     else
1965     {
1966         if (WTHelperGetKnownUsages(1, &usages))
1967         {
1968             PCCRYPT_OID_INFO *ptr;
1969
1970             for (ptr = usages; *ptr; ptr++)
1971                 add_known_usage(lv, *ptr);
1972             WTHelperGetKnownUsages(2, &usages);
1973         }
1974     }
1975     select_purposes(hwnd, purposeSelection);
1976     SendMessageW(GetDlgItem(hwnd, IDC_ENABLE_ALL_PURPOSES + purposeSelection),
1977      BM_CLICK, 0, 0);
1978 }
1979
1980 static void set_general_cert_properties(HWND hwnd, struct edit_cert_data *data)
1981 {
1982     PCCERT_CONTEXT cert = data->cert;
1983     WCHAR *str;
1984
1985     if ((str = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID)))
1986     {
1987         SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_SETTEXT, 0,
1988          (LPARAM)str);
1989         HeapFree(GetProcessHeap(), 0, str);
1990     }
1991     if ((str = get_cert_property_as_string(cert, CERT_DESCRIPTION_PROP_ID)))
1992     {
1993         SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_SETTEXT, 0,
1994          (LPARAM)str);
1995         HeapFree(GetProcessHeap(), 0, str);
1996     }
1997     show_cert_usages(hwnd, data);
1998 }
1999
2000 static void toggle_usage(HWND hwnd, int iItem)
2001 {
2002     LVITEMW item;
2003     int res;
2004     HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2005
2006     item.mask = LVIF_STATE;
2007     item.iItem = iItem;
2008     item.iSubItem = 0;
2009     item.stateMask = LVIS_STATEIMAGEMASK;
2010     res = SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item);
2011     if (res)
2012     {
2013         int state = item.state >> 12;
2014
2015         item.state = INDEXTOSTATEIMAGEMASK(
2016          state == CheckBitmapIndexChecked ? CheckBitmapIndexUnchecked :
2017          CheckBitmapIndexChecked);
2018         SendMessageW(lv, LVM_SETITEMSTATE, iItem, (LPARAM)&item);
2019     }
2020 }
2021
2022 static void set_cert_string_property(PCCERT_CONTEXT cert, DWORD prop,
2023  LPWSTR str)
2024 {
2025     if (str && strlenW(str))
2026     {
2027         CRYPT_DATA_BLOB blob;
2028
2029         blob.pbData = (BYTE *)str;
2030         blob.cbData = (strlenW(str) + 1) * sizeof(WCHAR);
2031         CertSetCertificateContextProperty(cert, prop, 0, &blob);
2032     }
2033     else
2034         CertSetCertificateContextProperty(cert, prop, 0, NULL);
2035 }
2036
2037 #define WM_REFRESH_VIEW WM_USER + 0
2038
2039 static BOOL CALLBACK refresh_propsheet_pages(HWND hwnd, LPARAM lParam)
2040 {
2041     if ((GetClassLongW(hwnd, GCW_ATOM) == WC_DIALOG))
2042         SendMessageW(hwnd, WM_REFRESH_VIEW, 0, 0);
2043     return TRUE;
2044 }
2045
2046 #define MAX_FRIENDLY_NAME 40
2047 #define MAX_DESCRIPTION 255
2048
2049 static void apply_general_changes(HWND hwnd)
2050 {
2051     WCHAR buf[MAX_DESCRIPTION + 1];
2052     struct edit_cert_data *data =
2053      (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
2054
2055     SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), WM_GETTEXT,
2056      sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2057     set_cert_string_property(data->cert, CERT_FRIENDLY_NAME_PROP_ID, buf);
2058     SendMessageW(GetDlgItem(hwnd, IDC_DESCRIPTION), WM_GETTEXT,
2059      sizeof(buf) / sizeof(buf[0]), (LPARAM)buf);
2060     set_cert_string_property(data->cert, CERT_DESCRIPTION_PROP_ID, buf);
2061     if (IsDlgButtonChecked(hwnd, IDC_ENABLE_ALL_PURPOSES))
2062     {
2063         /* Setting a NULL usage removes the enhanced key usage property. */
2064         CertSetEnhancedKeyUsage(data->cert, NULL);
2065     }
2066     else if (IsDlgButtonChecked(hwnd, IDC_DISABLE_ALL_PURPOSES))
2067     {
2068         CERT_ENHKEY_USAGE usage = { 0, NULL };
2069
2070         CertSetEnhancedKeyUsage(data->cert, &usage);
2071     }
2072     else if (IsDlgButtonChecked(hwnd, IDC_ENABLE_SELECTED_PURPOSES))
2073     {
2074         HWND lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2075         CERT_ENHKEY_USAGE usage = { 0, NULL };
2076         int purposes = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0), i;
2077         LVITEMW item;
2078
2079         item.mask = LVIF_STATE | LVIF_PARAM;
2080         item.iSubItem = 0;
2081         item.stateMask = LVIS_STATEIMAGEMASK;
2082         for (i = 0; i < purposes; i++)
2083         {
2084             item.iItem = i;
2085             if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item))
2086             {
2087                 int state = item.state >> 12;
2088
2089                 if (state == CheckBitmapIndexChecked)
2090                 {
2091                     CRYPT_OID_INFO *info = (CRYPT_OID_INFO *)item.lParam;
2092
2093                     if (usage.cUsageIdentifier)
2094                         usage.rgpszUsageIdentifier =
2095                          HeapReAlloc(GetProcessHeap(), 0,
2096                          usage.rgpszUsageIdentifier,
2097                          (usage.cUsageIdentifier + 1) * sizeof(LPSTR));
2098                     else
2099                         usage.rgpszUsageIdentifier =
2100                          HeapAlloc(GetProcessHeap(), 0, sizeof(LPSTR));
2101                     if (usage.rgpszUsageIdentifier)
2102                         usage.rgpszUsageIdentifier[usage.cUsageIdentifier++] =
2103                          (LPSTR)info->pszOID;
2104                 }
2105             }
2106         }
2107         CertSetEnhancedKeyUsage(data->cert, &usage);
2108         HeapFree(GetProcessHeap(), 0, usage.rgpszUsageIdentifier);
2109     }
2110     EnumChildWindows(GetParent(GetParent(hwnd)), refresh_propsheet_pages, 0);
2111     if (data->pfPropertiesChanged)
2112         *data->pfPropertiesChanged = TRUE;
2113 }
2114
2115 static LRESULT CALLBACK cert_properties_general_dlg_proc(HWND hwnd, UINT msg,
2116  WPARAM wp, LPARAM lp)
2117 {
2118     PROPSHEETPAGEW *page;
2119
2120     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2121
2122     switch (msg)
2123     {
2124     case WM_INITDIALOG:
2125     {
2126         HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
2127         struct detail_data *detailData;
2128         struct edit_cert_data *editData;
2129
2130         page = (PROPSHEETPAGEW *)lp;
2131         detailData = (struct detail_data *)page->lParam;
2132         SendMessageW(GetDlgItem(hwnd, IDC_FRIENDLY_NAME), EM_SETLIMITTEXT,
2133          MAX_FRIENDLY_NAME, 0);
2134         SendMessageW(description, EM_SETLIMITTEXT, MAX_DESCRIPTION, 0);
2135         ShowScrollBar(description, SB_VERT, FALSE);
2136         editData = HeapAlloc(GetProcessHeap(), 0,
2137          sizeof(struct edit_cert_data));
2138         if (editData)
2139         {
2140             editData->imageList = ImageList_Create(16, 16,
2141              ILC_COLOR4 | ILC_MASK, 4, 0);
2142             if (editData->imageList)
2143             {
2144                 HBITMAP bmp;
2145                 COLORREF backColor = RGB(255, 0, 255);
2146
2147                 bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_CHECKS));
2148                 ImageList_AddMasked(editData->imageList, bmp, backColor);
2149                 DeleteObject(bmp);
2150                 ImageList_SetBkColor(editData->imageList, CLR_NONE);
2151             }
2152             editData->cert = detailData->pCertViewInfo->pCertContext;
2153             editData->pfPropertiesChanged = detailData->pfPropertiesChanged;
2154             SetWindowLongPtrW(hwnd, DWLP_USER, (LPARAM)editData);
2155             set_general_cert_properties(hwnd, editData);
2156         }
2157         break;
2158     }
2159     case WM_NOTIFY:
2160     {
2161         NMHDR *hdr = (NMHDR *)lp;
2162         NMITEMACTIVATE *nm;
2163
2164         switch (hdr->code)
2165         {
2166         case NM_CLICK:
2167             nm = (NMITEMACTIVATE *)lp;
2168             toggle_usage(hwnd, nm->iItem);
2169             SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2170             break;
2171         case PSN_APPLY:
2172             apply_general_changes(hwnd);
2173             break;
2174         }
2175         break;
2176     }
2177     case WM_COMMAND:
2178         switch (HIWORD(wp))
2179         {
2180         case EN_CHANGE:
2181             SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2182             if (LOWORD(wp) == IDC_DESCRIPTION)
2183             {
2184                 /* Show/hide scroll bar on description depending on how much
2185                  * text it has.
2186                  */
2187                 HWND description = GetDlgItem(hwnd, IDC_DESCRIPTION);
2188                 int lines = SendMessageW(description, EM_GETLINECOUNT, 0, 0);
2189
2190                 ShowScrollBar(description, SB_VERT, lines > 1);
2191             }
2192             break;
2193         case BN_CLICKED:
2194             switch (LOWORD(wp))
2195             {
2196             case IDC_ADD_PURPOSE:
2197                 if (DialogBoxParamW(hInstance,
2198                  MAKEINTRESOURCEW(IDD_ADD_CERT_PURPOSE), hwnd,
2199                  add_purpose_dlg_proc, (LPARAM)hwnd) == IDOK)
2200                     SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2201                 break;
2202             case IDC_ENABLE_ALL_PURPOSES:
2203             case IDC_DISABLE_ALL_PURPOSES:
2204             case IDC_ENABLE_SELECTED_PURPOSES:
2205                 SendMessageW(GetParent(hwnd), PSM_CHANGED, (WPARAM)hwnd, 0);
2206                 select_purposes(hwnd, LOWORD(wp) - IDC_ENABLE_ALL_PURPOSES);
2207                 break;
2208             }
2209             break;
2210         }
2211         break;
2212     }
2213     return 0;
2214 }
2215
2216 static UINT CALLBACK cert_properties_general_callback(HWND hwnd, UINT msg,
2217  PROPSHEETPAGEW *page)
2218 {
2219     HWND lv;
2220     int cItem, i;
2221     struct edit_cert_data *data;
2222
2223     switch (msg)
2224     {
2225     case PSPCB_RELEASE:
2226         lv = GetDlgItem(hwnd, IDC_CERTIFICATE_USAGES);
2227         cItem = SendMessageW(lv, LVM_GETITEMCOUNT, 0, 0);
2228         for (i = 0; i < cItem; i++)
2229         {
2230             LVITEMW item;
2231
2232             item.mask = LVIF_PARAM;
2233             item.iItem = i;
2234             item.iSubItem = 0;
2235             if (SendMessageW(lv, LVM_GETITEMW, 0, (LPARAM)&item) && item.lParam)
2236             {
2237                 PCRYPT_OID_INFO info = (PCRYPT_OID_INFO)item.lParam;
2238
2239                 if (info->cbSize == sizeof(CRYPT_OID_INFO) && !info->dwGroupId)
2240                 {
2241                     HeapFree(GetProcessHeap(), 0, (LPSTR)info->pszOID);
2242                     HeapFree(GetProcessHeap(), 0, info);
2243                 }
2244             }
2245         }
2246         data = (struct edit_cert_data *)GetWindowLongPtrW(hwnd, DWLP_USER);
2247         if (data)
2248         {
2249             ImageList_Destroy(data->imageList);
2250             HeapFree(GetProcessHeap(), 0, data);
2251         }
2252         break;
2253     }
2254     return 1;
2255 }
2256
2257 static void show_edit_cert_properties_dialog(HWND parent,
2258  struct detail_data *data)
2259 {
2260     PROPSHEETHEADERW hdr;
2261     PROPSHEETPAGEW page; /* FIXME: need to add a cross-certificate page */
2262
2263     TRACE("(%p)\n", data);
2264
2265     memset(&page, 0, sizeof(PROPSHEETPAGEW));
2266     page.dwSize = sizeof(page);
2267     page.dwFlags = PSP_USECALLBACK;
2268     page.pfnCallback = cert_properties_general_callback;
2269     page.hInstance = hInstance;
2270     page.u.pszTemplate = MAKEINTRESOURCEW(IDD_CERT_PROPERTIES_GENERAL);
2271     page.pfnDlgProc = cert_properties_general_dlg_proc;
2272     page.lParam = (LPARAM)data;
2273
2274     memset(&hdr, 0, sizeof(hdr));
2275     hdr.dwSize = sizeof(hdr);
2276     hdr.hwndParent = parent;
2277     hdr.dwFlags = PSH_PROPSHEETPAGE;
2278     hdr.hInstance = hInstance;
2279     hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE_PROPERTIES);
2280     hdr.u3.ppsp = &page;
2281     hdr.nPages = 1;
2282     PropertySheetW(&hdr);
2283 }
2284
2285 static void free_detail_fields(struct detail_data *data)
2286 {
2287     DWORD i;
2288
2289     for (i = 0; i < data->cFields; i++)
2290         HeapFree(GetProcessHeap(), 0, data->fields[i].detailed_value);
2291     HeapFree(GetProcessHeap(), 0, data->fields);
2292     data->fields = NULL;
2293     data->cFields = 0;
2294 }
2295
2296 static void refresh_details_view(HWND hwnd)
2297 {
2298     HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2299     int curSel;
2300     struct detail_data *data;
2301
2302     curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
2303     /* Actually, any index will do, since they all store the same data value */
2304     data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA, curSel, 0);
2305     free_detail_fields(data);
2306     set_fields_selection(hwnd, data, curSel);
2307 }
2308
2309 static LRESULT CALLBACK detail_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2310  LPARAM lp)
2311 {
2312     PROPSHEETPAGEW *page;
2313     struct detail_data *data;
2314
2315     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2316
2317     switch (msg)
2318     {
2319     case WM_INITDIALOG:
2320         page = (PROPSHEETPAGEW *)lp;
2321         data = (struct detail_data *)page->lParam;
2322         create_cert_details_list(hwnd, data);
2323         if (!(data->pCertViewInfo->dwFlags & CRYPTUI_ENABLE_EDITPROPERTIES))
2324             EnableWindow(GetDlgItem(hwnd, IDC_EDITPROPERTIES), FALSE);
2325         if (data->pCertViewInfo->dwFlags & CRYPTUI_DISABLE_EXPORT)
2326             EnableWindow(GetDlgItem(hwnd, IDC_EXPORT), FALSE);
2327         break;
2328     case WM_NOTIFY:
2329     {
2330         NMITEMACTIVATE *nm;
2331         HWND list = GetDlgItem(hwnd, IDC_DETAIL_LIST);
2332
2333         nm = (NMITEMACTIVATE*)lp;
2334         if (nm->hdr.hwndFrom == list && nm->uNewState & LVN_ITEMACTIVATE
2335          && nm->hdr.code == LVN_ITEMCHANGED)
2336         {
2337             data = (struct detail_data *)nm->lParam;
2338             if (nm->iItem >= 0 && data && nm->iItem < data->cFields)
2339             {
2340                 WCHAR buf[MAX_STRING_LEN], *val = NULL;
2341                 HWND valueCtl = GetDlgItem(hwnd, IDC_DETAIL_VALUE);
2342
2343                 if (data->fields[nm->iItem].create)
2344                     val = data->fields[nm->iItem].create(
2345                      data->pCertViewInfo->pCertContext,
2346                      data->fields[nm->iItem].param);
2347                 else
2348                 {
2349                     LVITEMW item;
2350                     int res;
2351
2352                     item.cchTextMax = sizeof(buf) / sizeof(buf[0]);
2353                     item.mask = LVIF_TEXT;
2354                     item.pszText = buf;
2355                     item.iItem = nm->iItem;
2356                     item.iSubItem = 1;
2357                     res = SendMessageW(list, LVM_GETITEMW, 0, (LPARAM)&item);
2358                     if (res)
2359                         val = buf;
2360                 }
2361                 /* Select all the text in the control, the next update will
2362                  * replace it
2363                  */
2364                 SendMessageW(valueCtl, EM_SETSEL, 0, -1);
2365                 add_unformatted_text_to_control(valueCtl, val,
2366                  val ? strlenW(val) : 0);
2367                 if (val != buf)
2368                     HeapFree(GetProcessHeap(), 0, val);
2369             }
2370         }
2371         break;
2372     }
2373     case WM_COMMAND:
2374         switch (wp)
2375         {
2376         case IDC_EXPORT:
2377             FIXME("call CryptUIWizExport\n");
2378             break;
2379         case IDC_EDITPROPERTIES:
2380         {
2381             HWND cb = GetDlgItem(hwnd, IDC_DETAIL_SELECT);
2382             int curSel;
2383
2384             curSel = SendMessageW(cb, CB_GETCURSEL, 0, 0);
2385             /* Actually, any index will do, since they all store the same
2386              * data value
2387              */
2388             data = (struct detail_data *)SendMessageW(cb, CB_GETITEMDATA,
2389              curSel, 0);
2390             show_edit_cert_properties_dialog(GetParent(hwnd), data);
2391             break;
2392         }
2393         case ((CBN_SELCHANGE << 16) | IDC_DETAIL_SELECT):
2394             refresh_details_view(hwnd);
2395             break;
2396         }
2397         break;
2398     case WM_REFRESH_VIEW:
2399         refresh_details_view(hwnd);
2400         break;
2401     }
2402     return 0;
2403 }
2404
2405 static UINT CALLBACK detail_callback(HWND hwnd, UINT msg,
2406  PROPSHEETPAGEW *page)
2407 {
2408     struct detail_data *data;
2409
2410     switch (msg)
2411     {
2412     case PSPCB_RELEASE:
2413         data = (struct detail_data *)page->lParam;
2414         free_detail_fields(data);
2415         HeapFree(GetProcessHeap(), 0, data);
2416         break;
2417     }
2418     return 0;
2419 }
2420
2421 static BOOL init_detail_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2422  BOOL *pfPropertiesChanged, PROPSHEETPAGEW *page)
2423 {
2424     BOOL ret;
2425     struct detail_data *data = HeapAlloc(GetProcessHeap(), 0,
2426      sizeof(struct detail_data));
2427
2428     if (data)
2429     {
2430         data->pCertViewInfo = pCertViewInfo;
2431         data->pfPropertiesChanged = pfPropertiesChanged;
2432         data->cFields = 0;
2433         data->fields = NULL;
2434         memset(page, 0, sizeof(PROPSHEETPAGEW));
2435         page->dwSize = sizeof(PROPSHEETPAGEW);
2436         page->dwFlags = PSP_USECALLBACK;
2437         page->pfnCallback = detail_callback;
2438         page->hInstance = hInstance;
2439         page->u.pszTemplate = MAKEINTRESOURCEW(IDD_DETAIL);
2440         page->pfnDlgProc = detail_dlg_proc;
2441         page->lParam = (LPARAM)data;
2442         ret = TRUE;
2443     }
2444     else
2445         ret = FALSE;
2446     return ret;
2447 }
2448
2449 struct hierarchy_data
2450 {
2451     PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo;
2452     HIMAGELIST imageList;
2453     DWORD selectedCert;
2454 };
2455
2456 static LPARAM index_to_lparam(struct hierarchy_data *data, DWORD index)
2457 {
2458     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2459      (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2460      data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2461      data->pCertViewInfo->idxCounterSigner);
2462
2463     /* Takes advantage of the fact that a pointer is 32-bit aligned, and
2464      * therefore always even.
2465      */
2466     if (index == provSigner->csCertChain - 1)
2467         return (LPARAM)data;
2468     return index << 1 | 1;
2469 }
2470
2471 static inline DWORD lparam_to_index(struct hierarchy_data *data, LPARAM lp)
2472 {
2473     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2474      (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2475      data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2476      data->pCertViewInfo->idxCounterSigner);
2477
2478     if (!(lp & 1))
2479         return provSigner->csCertChain - 1;
2480     return lp >> 1;
2481 }
2482
2483 static struct hierarchy_data *get_hierarchy_data_from_tree_item(HWND tree,
2484  HTREEITEM hItem)
2485 {
2486     struct hierarchy_data *data = NULL;
2487     HTREEITEM root = NULL;
2488
2489     do {
2490         HTREEITEM parent = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM,
2491          TVGN_PARENT, (LPARAM)hItem);
2492
2493         if (!parent)
2494             root = hItem;
2495         hItem = parent;
2496     } while (hItem);
2497     if (root)
2498     {
2499         TVITEMW item;
2500
2501         item.mask = TVIF_PARAM;
2502         item.hItem = root;
2503         SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
2504         data = (struct hierarchy_data *)item.lParam;
2505     }
2506     return data;
2507 }
2508
2509 static WCHAR *get_cert_display_name(PCCERT_CONTEXT cert)
2510 {
2511     WCHAR *name = get_cert_property_as_string(cert, CERT_FRIENDLY_NAME_PROP_ID);
2512
2513     if (!name)
2514         name = get_cert_name_string(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0);
2515     return name;
2516 }
2517
2518 static void show_cert_chain(HWND hwnd, struct hierarchy_data *data)
2519 {
2520     HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2521     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2522      (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2523      data->pCertViewInfo->idxSigner, data->pCertViewInfo->fCounterSigner,
2524      data->pCertViewInfo->idxCounterSigner);
2525     DWORD i;
2526     HTREEITEM parent = NULL;
2527
2528     SendMessageW(tree, TVM_SETIMAGELIST, TVSIL_NORMAL, (LPARAM)data->imageList);
2529     for (i = provSigner->csCertChain; i; i--)
2530     {
2531         LPWSTR name;
2532
2533         name = get_cert_display_name(provSigner->pasCertChain[i - 1].pCert);
2534         if (name)
2535         {
2536             TVINSERTSTRUCTW tvis;
2537
2538             tvis.hParent = parent;
2539             tvis.hInsertAfter = TVI_LAST;
2540             tvis.u.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE |
2541              TVIF_SELECTEDIMAGE | TVIF_PARAM;
2542             tvis.u.item.pszText = name;
2543             tvis.u.item.state = TVIS_EXPANDED;
2544             tvis.u.item.stateMask = TVIS_EXPANDED;
2545             if (i == 1 &&
2546              (provSigner->pChainContext->TrustStatus.dwErrorStatus &
2547              CERT_TRUST_IS_PARTIAL_CHAIN))
2548             {
2549                 /* The root of the chain has a special case:  if the chain is
2550                  * a partial chain, the icon is a warning icon rather than an
2551                  * error icon.
2552                  */
2553                 tvis.u.item.iImage = 2;
2554             }
2555             else if (provSigner->pasCertChain[i - 1].pChainElement->TrustStatus.
2556              dwErrorStatus == 0)
2557                 tvis.u.item.iImage = 0;
2558             else
2559                 tvis.u.item.iImage = 1;
2560             tvis.u.item.iSelectedImage = tvis.u.item.iImage;
2561             tvis.u.item.lParam = index_to_lparam(data, i - 1);
2562             parent = (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0,
2563              (LPARAM)&tvis);
2564             HeapFree(GetProcessHeap(), 0, name);
2565         }
2566     }
2567 }
2568
2569 static void set_certificate_status(HWND hwnd, CRYPT_PROVIDER_CERT *cert)
2570 {
2571     /* Select all the text in the control, the next update will replace it */
2572     SendMessageW(hwnd, EM_SETSEL, 0, -1);
2573     /* Set the highest priority error messages first. */
2574     if (!(cert->dwConfidence & CERT_CONFIDENCE_SIG))
2575         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_SIGNATURE);
2576     else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIME))
2577         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIME);
2578     else if (!(cert->dwConfidence & CERT_CONFIDENCE_TIMENEST))
2579         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_BAD_TIMENEST);
2580     else if (cert->dwRevokedReason)
2581         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_REVOKED);
2582     else
2583         add_string_resource_to_control(hwnd, IDS_CERTIFICATE_VALID);
2584 }
2585
2586 static void set_certificate_status_for_end_cert(HWND hwnd,
2587  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo)
2588 {
2589     HWND status = GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT);
2590     CRYPT_PROVIDER_SGNR *provSigner = WTHelperGetProvSignerFromChain(
2591      (CRYPT_PROVIDER_DATA *)pCertViewInfo->u.pCryptProviderData,
2592      pCertViewInfo->idxSigner, pCertViewInfo->fCounterSigner,
2593      pCertViewInfo->idxCounterSigner);
2594     CRYPT_PROVIDER_CERT *provCert = WTHelperGetProvCertFromChain(provSigner,
2595      pCertViewInfo->idxCert);
2596
2597     set_certificate_status(status, provCert);
2598 }
2599
2600 static void show_cert_hierarchy(HWND hwnd, struct hierarchy_data *data)
2601 {
2602     /* Disable view certificate button until a certificate is selected */
2603     EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), FALSE);
2604     show_cert_chain(hwnd, data);
2605     set_certificate_status_for_end_cert(hwnd, data->pCertViewInfo);
2606 }
2607
2608 static void show_dialog_for_selected_cert(HWND hwnd)
2609 {
2610     HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2611     TVITEMW item;
2612     struct hierarchy_data *data;
2613     DWORD selection;
2614
2615     memset(&item, 0, sizeof(item));
2616     item.mask = TVIF_HANDLE | TVIF_PARAM;
2617     item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_CARET,
2618      (LPARAM)NULL);
2619     SendMessageW(tree, TVM_GETITEMW, 0, (LPARAM)&item);
2620     data = get_hierarchy_data_from_tree_item(tree, item.hItem);
2621     selection = lparam_to_index(data, item.lParam);
2622     if (selection != 0)
2623     {
2624         CRYPT_PROVIDER_SGNR *provSigner;
2625         CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
2626         BOOL changed = FALSE;
2627
2628         provSigner = WTHelperGetProvSignerFromChain(
2629          (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2630          data->pCertViewInfo->idxSigner,
2631          data->pCertViewInfo->fCounterSigner,
2632          data->pCertViewInfo->idxCounterSigner);
2633         memset(&viewInfo, 0, sizeof(viewInfo));
2634         viewInfo.dwSize = sizeof(viewInfo);
2635         viewInfo.dwFlags = data->pCertViewInfo->dwFlags;
2636         viewInfo.szTitle = data->pCertViewInfo->szTitle;
2637         viewInfo.pCertContext = provSigner->pasCertChain[selection].pCert;
2638         viewInfo.cStores = data->pCertViewInfo->cStores;
2639         viewInfo.rghStores = data->pCertViewInfo->rghStores;
2640         viewInfo.cPropSheetPages = data->pCertViewInfo->cPropSheetPages;
2641         viewInfo.rgPropSheetPages = data->pCertViewInfo->rgPropSheetPages;
2642         viewInfo.nStartPage = data->pCertViewInfo->nStartPage;
2643         CryptUIDlgViewCertificateW(&viewInfo, &changed);
2644         if (changed)
2645         {
2646             /* Delete the contents of the tree */
2647             SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
2648             /* Reinitialize the tree */
2649             show_cert_hierarchy(hwnd, data);
2650         }
2651     }
2652 }
2653
2654 static LRESULT CALLBACK hierarchy_dlg_proc(HWND hwnd, UINT msg, WPARAM wp,
2655  LPARAM lp)
2656 {
2657     PROPSHEETPAGEW *page;
2658     struct hierarchy_data *data;
2659     LRESULT ret = 0;
2660     HWND tree = GetDlgItem(hwnd, IDC_CERTPATH);
2661
2662     TRACE("(%p, %08x, %08lx, %08lx)\n", hwnd, msg, wp, lp);
2663
2664     switch (msg)
2665     {
2666     case WM_INITDIALOG:
2667         page = (PROPSHEETPAGEW *)lp;
2668         data = (struct hierarchy_data *)page->lParam;
2669         show_cert_hierarchy(hwnd, data);
2670         break;
2671     case WM_NOTIFY:
2672     {
2673         NMHDR *hdr;
2674
2675         hdr = (NMHDR *)lp;
2676         switch (hdr->code)
2677         {
2678         case TVN_SELCHANGEDW:
2679         {
2680             NMTREEVIEWW *nm = (NMTREEVIEWW*)lp;
2681             DWORD selection;
2682             CRYPT_PROVIDER_SGNR *provSigner;
2683
2684             data = get_hierarchy_data_from_tree_item(tree, nm->itemNew.hItem);
2685             selection = lparam_to_index(data, nm->itemNew.lParam);
2686             provSigner = WTHelperGetProvSignerFromChain(
2687              (CRYPT_PROVIDER_DATA *)data->pCertViewInfo->u.pCryptProviderData,
2688              data->pCertViewInfo->idxSigner,
2689              data->pCertViewInfo->fCounterSigner,
2690              data->pCertViewInfo->idxCounterSigner);
2691             EnableWindow(GetDlgItem(hwnd, IDC_VIEWCERTIFICATE), selection != 0);
2692             set_certificate_status(GetDlgItem(hwnd, IDC_CERTIFICATESTATUSTEXT),
2693              &provSigner->pasCertChain[selection]);
2694             break;
2695         }
2696         case NM_DBLCLK:
2697             show_dialog_for_selected_cert(hwnd);
2698             SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, 1);
2699             ret = 1;
2700             break;
2701         }
2702         break;
2703     }
2704     case WM_COMMAND:
2705         switch (wp)
2706         {
2707         case IDC_VIEWCERTIFICATE:
2708             show_dialog_for_selected_cert(hwnd);
2709             break;
2710         }
2711         break;
2712     case WM_REFRESH_VIEW:
2713     {
2714         TVITEMW item;
2715
2716         /* Get hierarchy data */
2717         memset(&item, 0, sizeof(item));
2718         item.mask = TVIF_HANDLE | TVIF_PARAM;
2719         item.hItem = (HTREEITEM)SendMessageW(tree, TVM_GETNEXTITEM, TVGN_ROOT,
2720          (LPARAM)NULL);
2721         data = get_hierarchy_data_from_tree_item(tree, item.hItem);
2722         /* Delete the contents of the tree */
2723         SendMessageW(tree, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
2724         /* Reinitialize the tree */
2725         show_cert_hierarchy(hwnd, data);
2726         break;
2727     }
2728     }
2729     return ret;
2730 }
2731
2732 static UINT CALLBACK hierarchy_callback(HWND hwnd, UINT msg,
2733  PROPSHEETPAGEW *page)
2734 {
2735     struct hierarchy_data *data;
2736
2737     switch (msg)
2738     {
2739     case PSPCB_RELEASE:
2740         data = (struct hierarchy_data *)page->lParam;
2741         ImageList_Destroy(data->imageList);
2742         HeapFree(GetProcessHeap(), 0, data);
2743         break;
2744     }
2745     return 0;
2746 }
2747
2748 static BOOL init_hierarchy_page(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2749  PROPSHEETPAGEW *page)
2750 {
2751     struct hierarchy_data *data = HeapAlloc(GetProcessHeap(), 0,
2752      sizeof(struct hierarchy_data));
2753     BOOL ret = FALSE;
2754
2755     if (data)
2756     {
2757         data->imageList = ImageList_Create(16, 16, ILC_COLOR4 | ILC_MASK, 2, 0);
2758         if (data->imageList)
2759         {
2760             HBITMAP bmp;
2761             COLORREF backColor = RGB(255, 0, 255);
2762
2763             data->pCertViewInfo = pCertViewInfo;
2764             data->selectedCert = 0xffffffff;
2765
2766             bmp = LoadBitmapW(hInstance, MAKEINTRESOURCEW(IDB_SMALL_ICONS));
2767             ImageList_AddMasked(data->imageList, bmp, backColor);
2768             DeleteObject(bmp);
2769             ImageList_SetBkColor(data->imageList, CLR_NONE);
2770
2771             memset(page, 0, sizeof(PROPSHEETPAGEW));
2772             page->dwSize = sizeof(PROPSHEETPAGEW);
2773             page->dwFlags = PSP_USECALLBACK;
2774             page->hInstance = hInstance;
2775             page->u.pszTemplate = MAKEINTRESOURCEW(IDD_HIERARCHY);
2776             page->pfnDlgProc = hierarchy_dlg_proc;
2777             page->lParam = (LPARAM)data;
2778             page->pfnCallback = hierarchy_callback;
2779             ret = TRUE;
2780         }
2781         else
2782             HeapFree(GetProcessHeap(), 0, data);
2783     }
2784     return ret;
2785 }
2786
2787 static int CALLBACK cert_prop_sheet_proc(HWND hwnd, UINT msg, LPARAM lp)
2788 {
2789     RECT rc;
2790     POINT topLeft;
2791
2792     TRACE("(%p, %08x, %08lx)\n", hwnd, msg, lp);
2793
2794     switch (msg)
2795     {
2796     case PSCB_INITIALIZED:
2797         /* Get cancel button's position.. */
2798         GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rc);
2799         topLeft.x = rc.left;
2800         topLeft.y = rc.top;
2801         ScreenToClient(hwnd, &topLeft);
2802         /* hide the cancel button.. */
2803         ShowWindow(GetDlgItem(hwnd, IDCANCEL), FALSE);
2804         /* get the OK button's size.. */
2805         GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
2806         /* and move the OK button to the cancel button's original position. */
2807         MoveWindow(GetDlgItem(hwnd, IDOK), topLeft.x, topLeft.y,
2808          rc.right - rc.left, rc.bottom - rc.top, FALSE);
2809         GetWindowRect(GetDlgItem(hwnd, IDOK), &rc);
2810         break;
2811     }
2812     return 0;
2813 }
2814
2815 static BOOL show_cert_dialog(PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo,
2816  CRYPT_PROVIDER_CERT *provCert, BOOL *pfPropertiesChanged)
2817 {
2818     static const WCHAR riched[] = { 'r','i','c','h','e','d','2','0',0 };
2819     DWORD nPages;
2820     PROPSHEETPAGEW *pages;
2821     BOOL ret = FALSE;
2822     HMODULE lib = LoadLibraryW(riched);
2823
2824     nPages = pCertViewInfo->cPropSheetPages + 1; /* one for the General tab */
2825     if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
2826         nPages++;
2827     if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
2828         nPages++;
2829     pages = HeapAlloc(GetProcessHeap(), 0, nPages * sizeof(PROPSHEETPAGEW));
2830     if (pages)
2831     {
2832         PROPSHEETHEADERW hdr;
2833         CRYPTUI_INITDIALOG_STRUCT *init = NULL;
2834         DWORD i;
2835
2836         memset(&hdr, 0, sizeof(hdr));
2837         hdr.dwSize = sizeof(hdr);
2838         hdr.dwFlags = PSH_NOAPPLYNOW | PSH_PROPSHEETPAGE | PSH_USECALLBACK;
2839         hdr.hInstance = hInstance;
2840         if (pCertViewInfo->szTitle)
2841             hdr.pszCaption = pCertViewInfo->szTitle;
2842         else
2843             hdr.pszCaption = MAKEINTRESOURCEW(IDS_CERTIFICATE);
2844         init_general_page(pCertViewInfo, &pages[hdr.nPages++]);
2845         if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_DETAILPAGE))
2846         {
2847             if (init_detail_page(pCertViewInfo, pfPropertiesChanged,
2848              &pages[hdr.nPages]))
2849                 hdr.nPages++;
2850         }
2851         if (!(pCertViewInfo->dwFlags & CRYPTUI_HIDE_HIERARCHYPAGE))
2852         {
2853             if (init_hierarchy_page(pCertViewInfo, &pages[hdr.nPages]))
2854                 hdr.nPages++;
2855         }
2856         /* Copy each additional page, and create the init dialog struct for it
2857          */
2858         if (pCertViewInfo->cPropSheetPages)
2859         {
2860             init = HeapAlloc(GetProcessHeap(), 0,
2861              pCertViewInfo->cPropSheetPages *
2862              sizeof(CRYPTUI_INITDIALOG_STRUCT));
2863             if (init)
2864             {
2865                 for (i = 0; i < pCertViewInfo->cPropSheetPages; i++)
2866                 {
2867                     memcpy(&pages[hdr.nPages + i],
2868                      &pCertViewInfo->rgPropSheetPages[i],
2869                      sizeof(PROPSHEETPAGEW));
2870                     init[i].lParam = pCertViewInfo->rgPropSheetPages[i].lParam;
2871                     init[i].pCertContext = pCertViewInfo->pCertContext;
2872                     pages[hdr.nPages + i].lParam = (LPARAM)&init[i];
2873                 }
2874                 if (pCertViewInfo->nStartPage & 0x8000)
2875                 {
2876                     /* Start page index is relative to the number of default
2877                      * pages
2878                      */
2879                     hdr.u2.nStartPage = pCertViewInfo->nStartPage + hdr.nPages;
2880                 }
2881                 else
2882                     hdr.u2.nStartPage = pCertViewInfo->nStartPage;
2883                 hdr.nPages = nPages;
2884                 ret = TRUE;
2885             }
2886             else
2887                 SetLastError(ERROR_OUTOFMEMORY);
2888         }
2889         else
2890         {
2891             /* Ignore the relative flag if there aren't any additional pages */
2892             hdr.u2.nStartPage = pCertViewInfo->nStartPage & 0x7fff;
2893             ret = TRUE;
2894         }
2895         if (ret)
2896         {
2897             INT_PTR l;
2898
2899             hdr.u3.ppsp = pages;
2900             hdr.pfnCallback = cert_prop_sheet_proc;
2901             l = PropertySheetW(&hdr);
2902             if (l == 0)
2903             {
2904                 SetLastError(ERROR_CANCELLED);
2905                 ret = FALSE;
2906             }
2907         }
2908         HeapFree(GetProcessHeap(), 0, init);
2909         HeapFree(GetProcessHeap(), 0, pages);
2910     }
2911     else
2912         SetLastError(ERROR_OUTOFMEMORY);
2913     FreeLibrary(lib);
2914     return ret;
2915 }
2916
2917 /***********************************************************************
2918  *              CryptUIDlgViewCertificateW (CRYPTUI.@)
2919  */
2920 BOOL WINAPI CryptUIDlgViewCertificateW(
2921  PCCRYPTUI_VIEWCERTIFICATE_STRUCTW pCertViewInfo, BOOL *pfPropertiesChanged)
2922 {
2923     static GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
2924     CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
2925     WINTRUST_DATA wvt;
2926     WINTRUST_CERT_INFO cert;
2927     BOOL ret = FALSE;
2928     CRYPT_PROVIDER_SGNR *signer;
2929     CRYPT_PROVIDER_CERT *provCert = NULL;
2930
2931     TRACE("(%p, %p)\n", pCertViewInfo, pfPropertiesChanged);
2932
2933     if (pCertViewInfo->dwSize != sizeof(CRYPTUI_VIEWCERTIFICATE_STRUCTW))
2934     {
2935         SetLastError(ERROR_INVALID_PARAMETER);
2936         return FALSE;
2937     }
2938     /* Make a local copy in case we have to call WinVerifyTrust ourselves */
2939     memcpy(&viewInfo, pCertViewInfo, sizeof(viewInfo));
2940     if (!viewInfo.u.hWVTStateData)
2941     {
2942         memset(&wvt, 0, sizeof(wvt));
2943         wvt.cbStruct = sizeof(wvt);
2944         wvt.dwUIChoice = WTD_UI_NONE;
2945         if (viewInfo.dwFlags &
2946          CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT)
2947             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT;
2948         if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_END_CERT)
2949             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_END_CERT;
2950         if (viewInfo.dwFlags & CRYPTUI_ENABLE_REVOCATION_CHECK_CHAIN)
2951             wvt.fdwRevocationChecks |= WTD_REVOCATION_CHECK_CHAIN;
2952         wvt.dwUnionChoice = WTD_CHOICE_CERT;
2953         memset(&cert, 0, sizeof(cert));
2954         cert.cbStruct = sizeof(cert);
2955         cert.psCertContext = (CERT_CONTEXT *)viewInfo.pCertContext;
2956         cert.chStores = viewInfo.cStores;
2957         cert.pahStores = viewInfo.rghStores;
2958         wvt.u.pCert = &cert;
2959         wvt.dwStateAction = WTD_STATEACTION_VERIFY;
2960         WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
2961         viewInfo.u.pCryptProviderData =
2962          WTHelperProvDataFromStateData(wvt.hWVTStateData);
2963         signer = WTHelperGetProvSignerFromChain(
2964          (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData, 0, FALSE, 0);
2965         provCert = WTHelperGetProvCertFromChain(signer, 0);
2966         ret = TRUE;
2967     }
2968     else
2969     {
2970         viewInfo.u.pCryptProviderData =
2971          WTHelperProvDataFromStateData(viewInfo.u.hWVTStateData);
2972         signer = WTHelperGetProvSignerFromChain(
2973          (CRYPT_PROVIDER_DATA *)viewInfo.u.pCryptProviderData,
2974          viewInfo.idxSigner, viewInfo.fCounterSigner,
2975          viewInfo.idxCounterSigner);
2976         provCert = WTHelperGetProvCertFromChain(signer, viewInfo.idxCert);
2977         ret = TRUE;
2978     }
2979     if (ret)
2980     {
2981         ret = show_cert_dialog(&viewInfo, provCert, pfPropertiesChanged);
2982         if (!viewInfo.u.hWVTStateData)
2983         {
2984             wvt.dwStateAction = WTD_STATEACTION_CLOSE;
2985             WinVerifyTrust(NULL, &generic_cert_verify, &wvt);
2986         }
2987     }
2988     return ret;
2989 }
2990
2991 /***********************************************************************
2992  *              CryptUIDlgViewContext (CRYPTUI.@)
2993  */
2994 BOOL WINAPI CryptUIDlgViewContext(DWORD dwContextType, LPVOID pvContext,
2995  HWND hwnd, LPCWSTR pwszTitle, DWORD dwFlags, LPVOID pvReserved)
2996 {
2997     BOOL ret;
2998
2999     TRACE("(%d, %p, %p, %s, %08x, %p)\n", dwContextType, pvContext, hwnd,
3000      debugstr_w(pwszTitle), dwFlags, pvReserved);
3001
3002     switch (dwContextType)
3003     {
3004     case CERT_STORE_CERTIFICATE_CONTEXT:
3005     {
3006         CRYPTUI_VIEWCERTIFICATE_STRUCTW viewInfo;
3007
3008         memset(&viewInfo, 0, sizeof(viewInfo));
3009         viewInfo.dwSize = sizeof(viewInfo);
3010         viewInfo.hwndParent = hwnd;
3011         viewInfo.szTitle = pwszTitle;
3012         viewInfo.pCertContext = pvContext;
3013         ret = CryptUIDlgViewCertificateW(&viewInfo, NULL);
3014         break;
3015     }
3016     default:
3017         FIXME("unimplemented for context type %d\n", dwContextType);
3018         SetLastError(E_INVALIDARG);
3019         ret = FALSE;
3020     }
3021     return ret;
3022 }
3023
3024 static PCCERT_CONTEXT make_cert_from_file(LPCWSTR fileName)
3025 {
3026     HANDLE file;
3027     DWORD size, encoding = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
3028     BYTE *buffer;
3029     PCCERT_CONTEXT cert;
3030
3031     file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
3032      OPEN_EXISTING, 0, NULL);
3033     if (file == INVALID_HANDLE_VALUE)
3034     {
3035         WARN("can't open certificate file %s\n", debugstr_w(fileName));
3036         return NULL;
3037     }
3038     if ((size = GetFileSize(file, NULL)))
3039     {
3040         if ((buffer = HeapAlloc(GetProcessHeap(), 0, size)))
3041         {
3042             DWORD read;
3043             if (!ReadFile(file, buffer, size, &read, NULL) || read != size)
3044             {
3045                 WARN("can't read certificate file %s\n", debugstr_w(fileName));
3046                 HeapFree(GetProcessHeap(), 0, buffer);
3047                 CloseHandle(file);
3048                 return NULL;
3049             }
3050         }
3051     }
3052     else
3053     {
3054         WARN("empty file %s\n", debugstr_w(fileName));
3055         CloseHandle(file);
3056         return NULL;
3057     }
3058     CloseHandle(file);
3059     cert = CertCreateCertificateContext(encoding, buffer, size);
3060     HeapFree(GetProcessHeap(), 0, buffer);
3061     return cert;
3062 }
3063
3064 /* Decodes a cert's basic constraints extension (either szOID_BASIC_CONSTRAINTS
3065  * or szOID_BASIC_CONSTRAINTS2, whichever is present) to determine if it
3066  * should be a CA.  If neither extension is present, returns
3067  * defaultIfNotSpecified.
3068  */
3069 static BOOL is_ca_cert(PCCERT_CONTEXT cert, BOOL defaultIfNotSpecified)
3070 {
3071     BOOL isCA = defaultIfNotSpecified;
3072     PCERT_EXTENSION ext = CertFindExtension(szOID_BASIC_CONSTRAINTS,
3073      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
3074
3075     if (ext)
3076     {
3077         CERT_BASIC_CONSTRAINTS_INFO *info;
3078         DWORD size = 0;
3079
3080         if (CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
3081          ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
3082          NULL, (LPBYTE)&info, &size))
3083         {
3084             if (info->SubjectType.cbData == 1)
3085                 isCA = info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
3086             LocalFree(info);
3087         }
3088     }
3089     else
3090     {
3091         ext = CertFindExtension(szOID_BASIC_CONSTRAINTS2,
3092          cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
3093         if (ext)
3094         {
3095             CERT_BASIC_CONSTRAINTS2_INFO info;
3096             DWORD size = sizeof(CERT_BASIC_CONSTRAINTS2_INFO);
3097
3098             if (CryptDecodeObjectEx(X509_ASN_ENCODING,
3099              szOID_BASIC_CONSTRAINTS2, ext->Value.pbData, ext->Value.cbData,
3100              0, NULL, &info, &size))
3101                 isCA = info.fCA;
3102         }
3103     }
3104     return isCA;
3105 }
3106
3107 static HCERTSTORE choose_store_for_cert(PCCERT_CONTEXT cert)
3108 {
3109     static const WCHAR AddressBook[] = { 'A','d','d','r','e','s','s',
3110      'B','o','o','k',0 };
3111     static const WCHAR CA[] = { 'C','A',0 };
3112     LPCWSTR storeName;
3113
3114     if (is_ca_cert(cert, TRUE))
3115         storeName = CA;
3116     else
3117         storeName = AddressBook;
3118     return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
3119      CERT_SYSTEM_STORE_CURRENT_USER, storeName);
3120 }
3121
3122 BOOL WINAPI CryptUIWizImport(DWORD dwFlags, HWND hwndParent, LPCWSTR pwszWizardTitle,
3123                              PCCRYPTUI_WIZ_IMPORT_SRC_INFO pImportSrc, HCERTSTORE hDestCertStore)
3124 {
3125     BOOL ret;
3126     HCERTSTORE store;
3127     const CERT_CONTEXT *cert;
3128     BOOL freeCert = FALSE;
3129
3130     TRACE("(0x%08x, %p, %s, %p, %p)\n", dwFlags, hwndParent, debugstr_w(pwszWizardTitle),
3131           pImportSrc, hDestCertStore);
3132
3133     if (!(dwFlags & CRYPTUI_WIZ_NO_UI)) FIXME("UI not implemented\n");
3134
3135     if (!pImportSrc ||
3136      pImportSrc->dwSize != sizeof(CRYPTUI_WIZ_IMPORT_SRC_INFO))
3137     {
3138         SetLastError(E_INVALIDARG);
3139         return FALSE;
3140     }
3141
3142     switch (pImportSrc->dwSubjectChoice)
3143     {
3144     case CRYPTUI_WIZ_IMPORT_SUBJECT_FILE:
3145         if (!(cert = make_cert_from_file(pImportSrc->u.pwszFileName)))
3146         {
3147             WARN("unable to create certificate context\n");
3148             return FALSE;
3149         }
3150         else
3151             freeCert = TRUE;
3152         break;
3153     case CRYPTUI_WIZ_IMPORT_SUBJECT_CERT_CONTEXT:
3154         cert = pImportSrc->u.pCertContext;
3155         if (!cert)
3156         {
3157             SetLastError(E_INVALIDARG);
3158             return FALSE;
3159         }
3160         break;
3161     default:
3162         FIXME("source type not implemented: %u\n", pImportSrc->dwSubjectChoice);
3163         SetLastError(E_INVALIDARG);
3164         return FALSE;
3165     }
3166     if (hDestCertStore) store = hDestCertStore;
3167     else
3168     {
3169         if (!(store = choose_store_for_cert(cert)))
3170         {
3171             WARN("unable to open certificate store\n");
3172             CertFreeCertificateContext(cert);
3173             return FALSE;
3174         }
3175     }
3176     ret = CertAddCertificateContextToStore(store, cert, CERT_STORE_ADD_REPLACE_EXISTING, NULL);
3177
3178     if (!hDestCertStore) CertCloseStore(store, 0);
3179     if (freeCert)
3180         CertFreeCertificateContext(cert);
3181     return ret;
3182 }