dlls/crypt32/object.c

   1 /*
   2  * crypt32 Crypt*Object functions
   3  *
   4  * Copyright 2007 Juan Lang
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdarg.h>
  21 #define NONAMELESSUNION
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "wincrypt.h"
  25 #include "mssip.h"
  26 #include "winuser.h"
  27 #include "crypt32_private.h"
  28 #include "cryptres.h"
  29 #include "wine/unicode.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  33
  34 static BOOL CRYPT_ReadBlobFromFile(LPCWSTR fileName, PCERT_BLOB blob)
  35 {
  36     BOOL ret = FALSE;
  37     HANDLE file;
  38
  39     TRACE("%s\n", debugstr_w(fileName));
  40
  41     file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
  42      OPEN_EXISTING, 0, NULL);
  43     if (file != INVALID_HANDLE_VALUE)
  44     {
  45         ret = TRUE;
  46         blob->cbData = GetFileSize(file, NULL);
  47         if (blob->cbData)
  48         {
  49             blob->pbData = CryptMemAlloc(blob->cbData);
  50             if (blob->pbData)
  51             {
  52                 DWORD read;
  53
  54                 ret = ReadFile(file, blob->pbData, blob->cbData, &read, NULL);
  55             }
  56         }
  57         CloseHandle(file);
  58     }
  59     TRACE("returning %d\n", ret);
  60     return ret;
  61 }
  62
  63 static BOOL CRYPT_QueryContextObject(DWORD dwObjectType, const void *pvObject,
  64  DWORD dwExpectedContentTypeFlags, DWORD *pdwMsgAndCertEncodingType,
  65  DWORD *pdwContentType, HCERTSTORE *phCertStore, const void **ppvContext)
  66 {
  67     CERT_BLOB fileBlob;
  68     const CERT_BLOB *blob;
  69     HCERTSTORE store;
  70     DWORD contentType;
  71     BOOL ret;
  72
  73     switch (dwObjectType)
  74     {
  75     case CERT_QUERY_OBJECT_FILE:
  76         /* Cert, CRL, and CTL contexts can't be "embedded" in a file, so
  77          * just read the file directly
  78          */
  79         ret = CRYPT_ReadBlobFromFile((LPCWSTR)pvObject, &fileBlob);
  80         blob = &fileBlob;
  81         break;
  82     case CERT_QUERY_OBJECT_BLOB:
  83         blob = (const CERT_BLOB *)pvObject;
  84         ret = TRUE;
  85         break;
  86     default:
  87         SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
  88         ret = FALSE;
  89     }
  90     if (!ret)
  91         return FALSE;
  92
  93     store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
  94      CERT_STORE_CREATE_NEW_FLAG, NULL);
  95     ret = FALSE;
  96     if (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CERT)
  97     {
  98         ret = pCertInterface->addEncodedToStore(store, X509_ASN_ENCODING,
  99          blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext);
 100         if (ret)
 101             contentType = CERT_QUERY_CONTENT_CERT;
 102     }
 103     if (!ret && (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CRL))
 104     {
 105         ret = pCRLInterface->addEncodedToStore(store, X509_ASN_ENCODING,
 106          blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext);
 107         if (ret)
 108             contentType = CERT_QUERY_CONTENT_CRL;
 109     }
 110     if (!ret && (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CTL))
 111     {
 112         ret = pCTLInterface->addEncodedToStore(store, X509_ASN_ENCODING,
 113          blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext);
 114         if (ret)
 115             contentType = CERT_QUERY_CONTENT_CTL;
 116     }
 117     if (ret)
 118     {
 119         if (pdwMsgAndCertEncodingType)
 120             *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
 121         if (pdwContentType)
 122             *pdwContentType = contentType;
 123         if (phCertStore)
 124             *phCertStore = CertDuplicateStore(store);
 125     }
 126     CertCloseStore(store, 0);
 127     if (blob == &fileBlob)
 128         CryptMemFree(blob->pbData);
 129     TRACE("returning %d\n", ret);
 130     return ret;
 131 }
 132
 133 static BOOL CRYPT_QuerySerializedContextObject(DWORD dwObjectType,
 134  const void *pvObject, DWORD dwExpectedContentTypeFlags,
 135  DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
 136  HCERTSTORE *phCertStore, const void **ppvContext)
 137 {
 138     CERT_BLOB fileBlob;
 139     const CERT_BLOB *blob;
 140     const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
 141     const void *context;
 142     DWORD contextType;
 143     BOOL ret;
 144
 145     switch (dwObjectType)
 146     {
 147     case CERT_QUERY_OBJECT_FILE:
 148         /* Cert, CRL, and CTL contexts can't be "embedded" in a file, so
 149          * just read the file directly
 150          */
 151         ret = CRYPT_ReadBlobFromFile((LPCWSTR)pvObject, &fileBlob);
 152         blob = &fileBlob;
 153         break;
 154     case CERT_QUERY_OBJECT_BLOB:
 155         blob = (const CERT_BLOB *)pvObject;
 156         ret = TRUE;
 157         break;
 158     default:
 159         SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
 160         ret = FALSE;
 161     }
 162     if (!ret)
 163         return FALSE;
 164
 165     context = CRYPT_ReadSerializedElement(blob->pbData, blob->cbData,
 166      CERT_STORE_ALL_CONTEXT_FLAG, &contextType);
 167     if (context)
 168     {
 169         DWORD contentType, certStoreOffset;
 170
 171         ret = TRUE;
 172         switch (contextType)
 173         {
 174         case CERT_STORE_CERTIFICATE_CONTEXT:
 175             contextInterface = pCertInterface;
 176             contentType = CERT_QUERY_CONTENT_SERIALIZED_CERT;
 177             certStoreOffset = offsetof(CERT_CONTEXT, hCertStore);
 178             if (!(dwExpectedContentTypeFlags &
 179              CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT))
 180             {
 181                 SetLastError(ERROR_INVALID_DATA);
 182                 ret = FALSE;
 183                 goto end;
 184             }
 185             break;
 186         case CERT_STORE_CRL_CONTEXT:
 187             contextInterface = pCRLInterface;
 188             contentType = CERT_QUERY_CONTENT_SERIALIZED_CRL;
 189             certStoreOffset = offsetof(CRL_CONTEXT, hCertStore);
 190             if (!(dwExpectedContentTypeFlags &
 191              CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL))
 192             {
 193                 SetLastError(ERROR_INVALID_DATA);
 194                 ret = FALSE;
 195                 goto end;
 196             }
 197             break;
 198         case CERT_STORE_CTL_CONTEXT:
 199             contextInterface = pCTLInterface;
 200             contentType = CERT_QUERY_CONTENT_SERIALIZED_CTL;
 201             certStoreOffset = offsetof(CTL_CONTEXT, hCertStore);
 202             if (!(dwExpectedContentTypeFlags &
 203              CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL))
 204             {
 205                 SetLastError(ERROR_INVALID_DATA);
 206                 ret = FALSE;
 207                 goto end;
 208             }
 209             break;
 210         default:
 211             SetLastError(ERROR_INVALID_DATA);
 212             ret = FALSE;
 213             goto end;
 214         }
 215         if (pdwMsgAndCertEncodingType)
 216             *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
 217         if (pdwContentType)
 218             *pdwContentType = contentType;
 219         if (phCertStore)
 220             *phCertStore = CertDuplicateStore(
 221              *(HCERTSTORE *)((const BYTE *)context + certStoreOffset));
 222         if (ppvContext)
 223             *ppvContext = contextInterface->duplicate(context);
 224     }
 225
 226 end:
 227     if (contextInterface && context)
 228         contextInterface->free(context);
 229     if (blob == &fileBlob)
 230         CryptMemFree(blob->pbData);
 231     TRACE("returning %d\n", ret);
 232     return ret;
 233 }
 234
 235 static BOOL CRYPT_QuerySerializedStoreObject(DWORD dwObjectType,
 236  const void *pvObject, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
 237  HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
 238 {
 239     LPCWSTR fileName = (LPCWSTR)pvObject;
 240     HANDLE file;
 241     BOOL ret = FALSE;
 242
 243     if (dwObjectType != CERT_QUERY_OBJECT_FILE)
 244     {
 245         FIXME("unimplemented for non-file type %d\n", dwObjectType);
 246         SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
 247         return FALSE;
 248     }
 249     TRACE("%s\n", debugstr_w(fileName));
 250     file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL,
 251      OPEN_EXISTING, 0, NULL);
 252     if (file != INVALID_HANDLE_VALUE)
 253     {
 254         HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
 255          CERT_STORE_CREATE_NEW_FLAG, NULL);
 256
 257         ret = CRYPT_ReadSerializedStoreFromFile(file, store);
 258         if (ret)
 259         {
 260             if (pdwMsgAndCertEncodingType)
 261                 *pdwMsgAndCertEncodingType = X509_ASN_ENCODING;
 262             if (pdwContentType)
 263                 *pdwContentType = CERT_QUERY_CONTENT_SERIALIZED_STORE;
 264             if (phCertStore)
 265                 *phCertStore = CertDuplicateStore(store);
 266         }
 267         CertCloseStore(store, 0);
 268         CloseHandle(file);
 269     }
 270     TRACE("returning %d\n", ret);
 271     return ret;
 272 }
 273
 274 /* Used to decode non-embedded messages */
 275 static BOOL CRYPT_QueryMessageObject(DWORD dwObjectType, const void *pvObject,
 276  DWORD dwExpectedContentTypeFlags, DWORD *pdwMsgAndCertEncodingType,
 277  DWORD *pdwContentType, HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
 278 {
 279     CERT_BLOB fileBlob;
 280     const CERT_BLOB *blob;
 281     BOOL ret;
 282     HCRYPTMSG msg = NULL;
 283     DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 284
 285     switch (dwObjectType)
 286     {
 287     case CERT_QUERY_OBJECT_FILE:
 288         /* This isn't an embedded PKCS7 message, so just read the file
 289          * directly
 290          */
 291         ret = CRYPT_ReadBlobFromFile((LPCWSTR)pvObject, &fileBlob);
 292         blob = &fileBlob;
 293         break;
 294     case CERT_QUERY_OBJECT_BLOB:
 295         blob = (const CERT_BLOB *)pvObject;
 296         ret = TRUE;
 297         break;
 298     default:
 299         SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */
 300         ret = FALSE;
 301     }
 302     if (!ret)
 303         return FALSE;
 304
 305     ret = FALSE;
 306     /* Try it first as a PKCS content info */
 307     if ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) ||
 308      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))
 309     {
 310         msg = CryptMsgOpenToDecode(encodingType, 0, 0, 0, NULL, NULL);
 311         if (msg)
 312         {
 313             ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
 314             if (ret)
 315             {
 316                 DWORD type, len = sizeof(type);
 317
 318                 ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &type, &len);
 319                 if (ret)
 320                 {
 321                     if ((dwExpectedContentTypeFlags &
 322                      CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED))
 323                     {
 324                         if (type != CMSG_SIGNED)
 325                         {
 326                             SetLastError(ERROR_INVALID_DATA);
 327                             ret = FALSE;
 328                         }
 329                         else if (pdwContentType)
 330                             *pdwContentType = CERT_QUERY_CONTENT_PKCS7_SIGNED;
 331                     }
 332                     else if ((dwExpectedContentTypeFlags &
 333                      CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))
 334                     {
 335                         if (type != CMSG_DATA)
 336                         {
 337                             SetLastError(ERROR_INVALID_DATA);
 338                             ret = FALSE;
 339                         }
 340                         else if (pdwContentType)
 341                             *pdwContentType = CERT_QUERY_CONTENT_PKCS7_UNSIGNED;
 342                     }
 343                 }
 344             }
 345             if (!ret)
 346             {
 347                 CryptMsgClose(msg);
 348                 msg = NULL;
 349             }
 350         }
 351     }
 352     /* Failing that, try explicitly typed messages */
 353     if (!ret &&
 354      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED))
 355     {
 356         msg = CryptMsgOpenToDecode(encodingType, 0, CMSG_SIGNED, 0, NULL, NULL);
 357         if (msg)
 358         {
 359             ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
 360             if (!ret)
 361             {
 362                 CryptMsgClose(msg);
 363                 msg = NULL;
 364             }
 365         }
 366         if (msg && pdwContentType)
 367             *pdwContentType = CERT_QUERY_CONTENT_PKCS7_SIGNED;
 368     }
 369     if (!ret &&
 370      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))
 371     {
 372         msg = CryptMsgOpenToDecode(encodingType, 0, CMSG_DATA, 0, NULL, NULL);
 373         if (msg)
 374         {
 375             ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE);
 376             if (!ret)
 377             {
 378                 CryptMsgClose(msg);
 379                 msg = NULL;
 380             }
 381         }
 382         if (msg && pdwContentType)
 383             *pdwContentType = CERT_QUERY_CONTENT_PKCS7_UNSIGNED;
 384     }
 385     if (pdwMsgAndCertEncodingType)
 386         *pdwMsgAndCertEncodingType = encodingType;
 387     if (msg)
 388     {
 389         if (phMsg)
 390             *phMsg = msg;
 391         if (phCertStore)
 392             *phCertStore = CertOpenStore(CERT_STORE_PROV_MSG, encodingType, 0,
 393              0, msg);
 394     }
 395     if (blob == &fileBlob)
 396         CryptMemFree(blob->pbData);
 397     TRACE("returning %d\n", ret);
 398     return ret;
 399 }
 400
 401 static BOOL CRYPT_QueryEmbeddedMessageObject(DWORD dwObjectType,
 402  const void *pvObject, DWORD dwExpectedContentTypeFlags,
 403  DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
 404  HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
 405 {
 406     HANDLE file;
 407     GUID subject;
 408     BOOL ret = FALSE;
 409
 410     TRACE("%s\n", debugstr_w((LPCWSTR)pvObject));
 411
 412     if (dwObjectType != CERT_QUERY_OBJECT_FILE)
 413     {
 414         FIXME("don't know what to do for type %d embedded signed messages\n",
 415          dwObjectType);
 416         SetLastError(E_INVALIDARG);
 417         return FALSE;
 418     }
 419     file = CreateFileW((LPCWSTR)pvObject, GENERIC_READ, FILE_SHARE_READ,
 420      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 421     if (file != INVALID_HANDLE_VALUE)
 422     {
 423         ret = CryptSIPRetrieveSubjectGuid((LPCWSTR)pvObject, file, &subject);
 424         if (ret)
 425         {
 426             SIP_DISPATCH_INFO sip;
 427
 428             memset(&sip, 0, sizeof(sip));
 429             sip.cbSize = sizeof(sip);
 430             ret = CryptSIPLoad(&subject, 0, &sip);
 431             if (ret)
 432             {
 433                 SIP_SUBJECTINFO subjectInfo;
 434                 CERT_BLOB blob;
 435                 DWORD encodingType;
 436
 437                 memset(&subjectInfo, 0, sizeof(subjectInfo));
 438                 subjectInfo.cbSize = sizeof(subjectInfo);
 439                 subjectInfo.pgSubjectType = &subject;
 440                 subjectInfo.hFile = file;
 441                 subjectInfo.pwsFileName = (LPCWSTR)pvObject;
 442                 ret = sip.pfGet(&subjectInfo, &encodingType, 0, &blob.cbData,
 443                  NULL);
 444                 if (ret)
 445                 {
 446                     blob.pbData = CryptMemAlloc(blob.cbData);
 447                     if (blob.pbData)
 448                     {
 449                         ret = sip.pfGet(&subjectInfo, &encodingType, 0,
 450                          &blob.cbData, blob.pbData);
 451                         if (ret)
 452                         {
 453                             ret = CRYPT_QueryMessageObject(
 454                              CERT_QUERY_OBJECT_BLOB, &blob,
 455                              CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
 456                              pdwMsgAndCertEncodingType, NULL, phCertStore,
 457                              phMsg);
 458                             if (ret && pdwContentType)
 459                                 *pdwContentType =
 460                                  CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED;
 461                         }
 462                         CryptMemFree(blob.pbData);
 463                     }
 464                     else
 465                     {
 466                         SetLastError(ERROR_OUTOFMEMORY);
 467                         ret = FALSE;
 468                     }
 469                 }
 470             }
 471         }
 472         CloseHandle(file);
 473     }
 474     TRACE("returning %d\n", ret);
 475     return ret;
 476 }
 477
 478 BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void *pvObject,
 479  DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags,
 480  DWORD dwFlags, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
 481  DWORD *pdwFormatType, HCERTSTORE *phCertStore, HCRYPTMSG *phMsg,
 482  const void **ppvContext)
 483 {
 484     static const DWORD unimplementedTypes =
 485      CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX |
 486      CERT_QUERY_CONTENT_FLAG_CERT_PAIR;
 487     BOOL ret = TRUE;
 488
 489     TRACE("(%08x, %p, %08x, %08x, %08x, %p, %p, %p, %p, %p, %p)\n",
 490      dwObjectType, pvObject, dwExpectedContentTypeFlags,
 491      dwExpectedFormatTypeFlags, dwFlags, pdwMsgAndCertEncodingType,
 492      pdwContentType, pdwFormatType, phCertStore, phMsg, ppvContext);
 493
 494     if (dwExpectedContentTypeFlags & unimplementedTypes)
 495         WARN("unimplemented for types %08x\n",
 496          dwExpectedContentTypeFlags & unimplementedTypes);
 497     if (!(dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BINARY))
 498     {
 499         FIXME("unimplemented for anything but binary\n");
 500         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 501         return FALSE;
 502     }
 503     if (pdwFormatType)
 504         *pdwFormatType = CERT_QUERY_FORMAT_BINARY;
 505
 506     if (phCertStore)
 507         *phCertStore = NULL;
 508     if (phMsg)
 509         *phMsg = NULL;
 510     if (ppvContext)
 511         *ppvContext = NULL;
 512
 513     ret = FALSE;
 514     if ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CERT) ||
 515      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CRL) ||
 516      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CTL))
 517     {
 518         ret = CRYPT_QueryContextObject(dwObjectType, pvObject,
 519          dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType,
 520          phCertStore, ppvContext);
 521     }
 522     if (!ret &&
 523      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE))
 524     {
 525         ret = CRYPT_QuerySerializedStoreObject(dwObjectType, pvObject,
 526          pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg);
 527     }
 528     if (!ret &&
 529      ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT) ||
 530      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL) ||
 531      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL)))
 532     {
 533         ret = CRYPT_QuerySerializedContextObject(dwObjectType, pvObject,
 534          dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType,
 535          phCertStore, ppvContext);
 536     }
 537     if (!ret &&
 538      ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) ||
 539      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)))
 540     {
 541         ret = CRYPT_QueryMessageObject(dwObjectType, pvObject,
 542          dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType,
 543          phCertStore, phMsg);
 544     }
 545     if (!ret &&
 546      (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED))
 547     {
 548         ret = CRYPT_QueryEmbeddedMessageObject(dwObjectType, pvObject,
 549          dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType,
 550          phCertStore, phMsg);
 551     }
 552     TRACE("returning %d\n", ret);
 553     return ret;
 554 }
 555
 556 static BOOL WINAPI CRYPT_FormatHexString(DWORD dwCertEncodingType,
 557  DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
 558  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
 559  DWORD *pcbFormat)
 560 {
 561     BOOL ret;
 562     DWORD bytesNeeded;
 563
 564     if (cbEncoded)
 565         bytesNeeded = (cbEncoded * 3) * sizeof(WCHAR);
 566     else
 567         bytesNeeded = sizeof(WCHAR);
 568     if (!pbFormat)
 569     {
 570         *pcbFormat = bytesNeeded;
 571         ret = TRUE;
 572     }
 573     else if (*pcbFormat < bytesNeeded)
 574     {
 575         *pcbFormat = bytesNeeded;
 576         SetLastError(ERROR_MORE_DATA);
 577         ret = FALSE;
 578     }
 579     else
 580     {
 581         static const WCHAR fmt[] = { '%','0','2','x',' ',0 };
 582         static const WCHAR endFmt[] = { '%','0','2','x',0 };
 583         DWORD i;
 584         LPWSTR ptr = pbFormat;
 585
 586         *pcbFormat = bytesNeeded;
 587         if (cbEncoded)
 588         {
 589             for (i = 0; i < cbEncoded; i++)
 590             {
 591                 if (i < cbEncoded - 1)
 592                     ptr += sprintfW(ptr, fmt, pbEncoded[i]);
 593                 else
 594                     ptr += sprintfW(ptr, endFmt, pbEncoded[i]);
 595             }
 596         }
 597         else
 598             *ptr = 0;
 599         ret = TRUE;
 600     }
 601     return ret;
 602 }
 603
 604 #define MAX_STRING_RESOURCE_LEN 128
 605
 606 static const WCHAR crlf[] = { '\r','\n',0 };
 607 static const WCHAR commaSpace[] = { ',',' ',0 };
 608
 609 static WCHAR subjectTypeHeader[MAX_STRING_RESOURCE_LEN];
 610 static WCHAR subjectTypeCA[MAX_STRING_RESOURCE_LEN];
 611 static WCHAR subjectTypeEndCert[MAX_STRING_RESOURCE_LEN];
 612 static WCHAR pathLengthHeader[MAX_STRING_RESOURCE_LEN];
 613
 614 static BOOL WINAPI CRYPT_FormatBasicConstraints2(DWORD dwCertEncodingType,
 615  DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
 616  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
 617  DWORD *pcbFormat)
 618 {
 619     DWORD size;
 620     CERT_BASIC_CONSTRAINTS2_INFO *info;
 621     BOOL ret;
 622
 623     if (!cbEncoded)
 624     {
 625         SetLastError(E_INVALIDARG);
 626         return FALSE;
 627     }
 628     if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BASIC_CONSTRAINTS2,
 629      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
 630     {
 631         static const WCHAR pathFmt[] = { '%','d',0 };
 632         static BOOL stringsLoaded = FALSE;
 633         DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
 634         WCHAR pathLength[MAX_STRING_RESOURCE_LEN];
 635         LPCWSTR sep, subjectType;
 636         DWORD sepLen;
 637
 638         if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
 639         {
 640             sep = crlf;
 641             sepLen = strlenW(crlf) * sizeof(WCHAR);
 642         }
 643         else
 644         {
 645             sep = commaSpace;
 646             sepLen = strlenW(commaSpace) * sizeof(WCHAR);
 647         }
 648
 649         if (!stringsLoaded)
 650         {
 651             LoadStringW(hInstance, IDS_SUBJECT_TYPE, subjectTypeHeader,
 652              sizeof(subjectTypeHeader) / sizeof(subjectTypeHeader[0]));
 653             LoadStringW(hInstance, IDS_SUBJECT_TYPE_CA, subjectTypeCA,
 654              sizeof(subjectTypeCA) / sizeof(subjectTypeCA[0]));
 655             LoadStringW(hInstance, IDS_SUBJECT_TYPE_END_CERT,
 656              subjectTypeEndCert,
 657              sizeof(subjectTypeEndCert) / sizeof(subjectTypeEndCert[0]));
 658             LoadStringW(hInstance, IDS_PATH_LENGTH, pathLengthHeader,
 659              sizeof(pathLengthHeader) / sizeof(pathLengthHeader[0]));
 660             stringsLoaded = TRUE;
 661         }
 662         bytesNeeded += strlenW(subjectTypeHeader) * sizeof(WCHAR);
 663         if (info->fCA)
 664             subjectType = subjectTypeCA;
 665         else
 666             subjectType = subjectTypeEndCert;
 667         bytesNeeded += strlenW(subjectType) * sizeof(WCHAR);
 668         bytesNeeded += sepLen;
 669         bytesNeeded += strlenW(pathLengthHeader) * sizeof(WCHAR);
 670         if (info->fPathLenConstraint)
 671             sprintfW(pathLength, pathFmt, info->dwPathLenConstraint);
 672         else
 673             LoadStringW(hInstance, IDS_PATH_LENGTH_NONE, pathLength,
 674              sizeof(pathLength) / sizeof(pathLength[0]));
 675         bytesNeeded += strlenW(pathLength) * sizeof(WCHAR);
 676         if (!pbFormat)
 677             *pcbFormat = bytesNeeded;
 678         else if (*pcbFormat < bytesNeeded)
 679         {
 680             *pcbFormat = bytesNeeded;
 681             SetLastError(ERROR_MORE_DATA);
 682             ret = FALSE;
 683         }
 684         else
 685         {
 686             LPWSTR str = pbFormat;
 687
 688             *pcbFormat = bytesNeeded;
 689             strcpyW(str, subjectTypeHeader);
 690             str += strlenW(subjectTypeHeader);
 691             strcpyW(str, subjectType);
 692             str += strlenW(subjectType);
 693             strcpyW(str, sep);
 694             str += sepLen / sizeof(WCHAR);
 695             strcpyW(str, pathLengthHeader);
 696             str += strlenW(pathLengthHeader);
 697             strcpyW(str, pathLength);
 698             str += strlenW(pathLength);
 699         }
 700         LocalFree(info);
 701     }
 702     return ret;
 703 }
 704
 705 static BOOL CRYPT_FormatHexStringWithPrefix(CRYPT_DATA_BLOB *blob, int id,
 706  LPWSTR str, DWORD *pcbStr)
 707 {
 708     WCHAR buf[MAX_STRING_RESOURCE_LEN];
 709     DWORD bytesNeeded;
 710     BOOL ret;
 711
 712     LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0]));
 713     CRYPT_FormatHexString(X509_ASN_ENCODING, 0, 0, NULL, NULL,
 714      blob->pbData, blob->cbData, NULL, &bytesNeeded);
 715     bytesNeeded += strlenW(buf) * sizeof(WCHAR);
 716     if (!str)
 717     {
 718         *pcbStr = bytesNeeded;
 719         ret = TRUE;
 720     }
 721     else if (*pcbStr < bytesNeeded)
 722     {
 723         *pcbStr = bytesNeeded;
 724         SetLastError(ERROR_MORE_DATA);
 725         ret = FALSE;
 726     }
 727     else
 728     {
 729         *pcbStr = bytesNeeded;
 730         strcpyW(str, buf);
 731         str += strlenW(str);
 732         bytesNeeded -= strlenW(str) * sizeof(WCHAR);
 733         ret = CRYPT_FormatHexString(X509_ASN_ENCODING, 0, 0, NULL, NULL,
 734          blob->pbData, blob->cbData, str, &bytesNeeded);
 735     }
 736     return ret;
 737 }
 738
 739 static BOOL CRYPT_FormatKeyId(CRYPT_DATA_BLOB *keyId, LPWSTR str,
 740  DWORD *pcbStr)
 741 {
 742     return CRYPT_FormatHexStringWithPrefix(keyId, IDS_KEY_ID, str, pcbStr);
 743 }
 744
 745 static BOOL CRYPT_FormatCertSerialNumber(CRYPT_DATA_BLOB *serialNum, LPWSTR str,
 746  DWORD *pcbStr)
 747 {
 748     return CRYPT_FormatHexStringWithPrefix(serialNum, IDS_CERT_SERIAL_NUMBER,
 749      str, pcbStr);
 750 }
 751
 752 static BOOL CRYPT_FormatAltNameEntry(DWORD dwFormatStrType,
 753  CERT_ALT_NAME_ENTRY *entry, LPWSTR str, DWORD *pcbStr)
 754 {
 755     BOOL ret;
 756     WCHAR buf[MAX_STRING_RESOURCE_LEN];
 757     WCHAR mask[MAX_STRING_RESOURCE_LEN];
 758     WCHAR ipAddrBuf[32];
 759     WCHAR maskBuf[16];
 760     DWORD bytesNeeded = sizeof(WCHAR);
 761
 762     switch (entry->dwAltNameChoice)
 763     {
 764     case CERT_ALT_NAME_RFC822_NAME:
 765         LoadStringW(hInstance, IDS_ALT_NAME_RFC822_NAME, buf,
 766          sizeof(buf) / sizeof(buf[0]));
 767         bytesNeeded += strlenW(entry->u.pwszRfc822Name) * sizeof(WCHAR);
 768         ret = TRUE;
 769         break;
 770     case CERT_ALT_NAME_DNS_NAME:
 771         LoadStringW(hInstance, IDS_ALT_NAME_DNS_NAME, buf,
 772          sizeof(buf) / sizeof(buf[0]));
 773         bytesNeeded += strlenW(entry->u.pwszDNSName) * sizeof(WCHAR);
 774         ret = TRUE;
 775         break;
 776     case CERT_ALT_NAME_URL:
 777         LoadStringW(hInstance, IDS_ALT_NAME_URL, buf,
 778          sizeof(buf) / sizeof(buf[0]));
 779         bytesNeeded += strlenW(entry->u.pwszURL) * sizeof(WCHAR);
 780         ret = TRUE;
 781         break;
 782     case CERT_ALT_NAME_IP_ADDRESS:
 783     {
 784         static const WCHAR ipAddrWithMaskFmt[] = { '%','d','.','%','d','.',
 785          '%','d','.','%','d','/','%','d','.','%','d','.','%','d','.','%','d',0
 786         };
 787         static const WCHAR ipAddrFmt[] = { '%','d','.','%','d','.','%','d',
 788          '.','%','d',0 };
 789
 790         LoadStringW(hInstance, IDS_ALT_NAME_IP_ADDRESS, buf,
 791          sizeof(buf) / sizeof(buf[0]));
 792         if (entry->u.IPAddress.cbData == 8)
 793         {
 794             if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
 795             {
 796                 LoadStringW(hInstance, IDS_ALT_NAME_MASK, mask,
 797                  sizeof(mask) / sizeof(mask[0]));
 798                 bytesNeeded += strlenW(mask) * sizeof(WCHAR);
 799                 sprintfW(ipAddrBuf, ipAddrFmt,
 800                  entry->u.IPAddress.pbData[0],
 801                  entry->u.IPAddress.pbData[1],
 802                  entry->u.IPAddress.pbData[2],
 803                  entry->u.IPAddress.pbData[3]);
 804                 bytesNeeded += strlenW(ipAddrBuf) * sizeof(WCHAR);
 805                 sprintfW(maskBuf, ipAddrFmt,
 806                  entry->u.IPAddress.pbData[4],
 807                  entry->u.IPAddress.pbData[5],
 808                  entry->u.IPAddress.pbData[6],
 809                  entry->u.IPAddress.pbData[7]);
 810                 bytesNeeded += strlenW(maskBuf) * sizeof(WCHAR);
 811                 bytesNeeded += strlenW(crlf) * sizeof(WCHAR);
 812             }
 813             else
 814             {
 815                 sprintfW(ipAddrBuf, ipAddrWithMaskFmt,
 816                  entry->u.IPAddress.pbData[0],
 817                  entry->u.IPAddress.pbData[1],
 818                  entry->u.IPAddress.pbData[2],
 819                  entry->u.IPAddress.pbData[3],
 820                  entry->u.IPAddress.pbData[4],
 821                  entry->u.IPAddress.pbData[5],
 822                  entry->u.IPAddress.pbData[6],
 823                  entry->u.IPAddress.pbData[7]);
 824                 bytesNeeded += (strlenW(ipAddrBuf) + 1) * sizeof(WCHAR);
 825             }
 826             ret = TRUE;
 827         }
 828         else
 829         {
 830             FIXME("unknown IP address format (%d bytes)\n",
 831              entry->u.IPAddress.cbData);
 832             ret = FALSE;
 833         }
 834         break;
 835     }
 836     default:
 837         FIXME("unimplemented for %d\n", entry->dwAltNameChoice);
 838         ret = FALSE;
 839     }
 840     if (ret)
 841     {
 842         bytesNeeded += strlenW(buf) * sizeof(WCHAR);
 843         if (!str)
 844             *pcbStr = bytesNeeded;
 845         else if (*pcbStr < bytesNeeded)
 846         {
 847             *pcbStr = bytesNeeded;
 848             SetLastError(ERROR_MORE_DATA);
 849             ret = FALSE;
 850         }
 851         else
 852         {
 853             *pcbStr = bytesNeeded;
 854             strcpyW(str, buf);
 855             str += strlenW(str);
 856             switch (entry->dwAltNameChoice)
 857             {
 858             case CERT_ALT_NAME_RFC822_NAME:
 859             case CERT_ALT_NAME_DNS_NAME:
 860             case CERT_ALT_NAME_URL:
 861                 strcpyW(str, entry->u.pwszURL);
 862                 break;
 863             case CERT_ALT_NAME_IP_ADDRESS:
 864                 if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
 865                 {
 866                     strcpyW(str, ipAddrBuf);
 867                     str += strlenW(ipAddrBuf);
 868                     strcpyW(str, crlf);
 869                     str += strlenW(crlf);
 870                     strcpyW(str, mask);
 871                     str += strlenW(mask);
 872                     strcpyW(str, maskBuf);
 873                 }
 874                 else
 875                     strcpyW(str, ipAddrBuf);
 876                 break;
 877             }
 878         }
 879     }
 880     return ret;
 881 }
 882
 883 static BOOL CRYPT_FormatAltNameInfo(DWORD dwFormatStrType,
 884  CERT_ALT_NAME_INFO *name, LPWSTR str, DWORD *pcbStr)
 885 {
 886     DWORD i, size, bytesNeeded = 0;
 887     BOOL ret = TRUE;
 888     LPCWSTR sep;
 889     DWORD sepLen;
 890
 891     if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
 892     {
 893         sep = crlf;
 894         sepLen = strlenW(crlf) * sizeof(WCHAR);
 895     }
 896     else
 897     {
 898         sep = commaSpace;
 899         sepLen = strlenW(commaSpace) * sizeof(WCHAR);
 900     }
 901
 902     for (i = 0; ret && i < name->cAltEntry; i++)
 903     {
 904         ret = CRYPT_FormatAltNameEntry(dwFormatStrType, &name->rgAltEntry[i],
 905          NULL, &size);
 906         if (ret)
 907         {
 908             bytesNeeded += size - sizeof(WCHAR);
 909             if (i < name->cAltEntry - 1)
 910                 bytesNeeded += sepLen;
 911         }
 912     }
 913     if (ret)
 914     {
 915         bytesNeeded += sizeof(WCHAR);
 916         if (!str)
 917             *pcbStr = bytesNeeded;
 918         else if (*pcbStr < bytesNeeded)
 919         {
 920             *pcbStr = bytesNeeded;
 921             SetLastError(ERROR_MORE_DATA);
 922             ret = FALSE;
 923         }
 924         else
 925         {
 926             *pcbStr = bytesNeeded;
 927             for (i = 0; ret && i < name->cAltEntry; i++)
 928             {
 929                 ret = CRYPT_FormatAltNameEntry(dwFormatStrType,
 930                  &name->rgAltEntry[i], str, &size);
 931                 if (ret)
 932                 {
 933                     str += size / sizeof(WCHAR) - 1;
 934                     if (i < name->cAltEntry - 1)
 935                     {
 936                         strcpyW(str, sep);
 937                         str += sepLen / sizeof(WCHAR);
 938                     }
 939                 }
 940             }
 941         }
 942     }
 943     return ret;
 944 }
 945
 946 static BOOL CRYPT_FormatCertIssuer(DWORD dwFormatStrType,
 947  CERT_ALT_NAME_INFO *issuer, LPWSTR str, DWORD *pcbStr)
 948 {
 949     WCHAR buf[MAX_STRING_RESOURCE_LEN];
 950     DWORD bytesNeeded;
 951     BOOL ret;
 952
 953     LoadStringW(hInstance, IDS_CERT_ISSUER, buf, sizeof(buf) / sizeof(buf[0]));
 954     ret = CRYPT_FormatAltNameInfo(dwFormatStrType, issuer, NULL, &bytesNeeded);
 955     bytesNeeded += strlenW(buf) * sizeof(WCHAR);
 956     if (ret)
 957     {
 958         if (!str)
 959             *pcbStr = bytesNeeded;
 960         else if (*pcbStr < bytesNeeded)
 961         {
 962             *pcbStr = bytesNeeded;
 963             SetLastError(ERROR_MORE_DATA);
 964             ret = FALSE;
 965         }
 966         else
 967         {
 968             *pcbStr = bytesNeeded;
 969             strcpyW(str, buf);
 970             str += strlenW(str);
 971             bytesNeeded -= strlenW(str) * sizeof(WCHAR);
 972             ret = CRYPT_FormatAltNameInfo(dwFormatStrType, issuer, str,
 973              &bytesNeeded);
 974         }
 975     }
 976     return ret;
 977 }
 978
 979 static BOOL WINAPI CRYPT_FormatAuthorityKeyId2(DWORD dwCertEncodingType,
 980  DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
 981  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
 982  DWORD *pcbFormat)
 983 {
 984     CERT_AUTHORITY_KEY_ID2_INFO *info;
 985     DWORD size;
 986     BOOL ret = FALSE;
 987
 988     if (!cbEncoded)
 989     {
 990         SetLastError(E_INVALIDARG);
 991         return FALSE;
 992     }
 993     if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_AUTHORITY_KEY_ID2,
 994      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
 995     {
 996         DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
 997         LPCWSTR sep;
 998         DWORD sepLen;
 999         BOOL needSeparator = FALSE;
1000
1001         if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1002         {
1003             sep = crlf;
1004             sepLen = strlenW(crlf) * sizeof(WCHAR);
1005         }
1006         else
1007         {
1008             sep = commaSpace;
1009             sepLen = strlenW(commaSpace) * sizeof(WCHAR);
1010         }
1011
1012         if (info->KeyId.cbData)
1013         {
1014             needSeparator = TRUE;
1015             ret = CRYPT_FormatKeyId(&info->KeyId, NULL, &size);
1016             if (ret)
1017             {
1018                 /* don't include NULL-terminator more than once */
1019                 bytesNeeded += size - sizeof(WCHAR);
1020             }
1021         }
1022         if (info->AuthorityCertIssuer.cAltEntry)
1023         {
1024             if (needSeparator)
1025                 bytesNeeded += sepLen;
1026             needSeparator = TRUE;
1027             ret = CRYPT_FormatCertIssuer(dwFormatStrType,
1028              &info->AuthorityCertIssuer, NULL, &size);
1029             if (ret)
1030             {
1031                 /* don't include NULL-terminator more than once */
1032                 bytesNeeded += size - sizeof(WCHAR);
1033             }
1034         }
1035         if (info->AuthorityCertSerialNumber.cbData)
1036         {
1037             if (needSeparator)
1038                 bytesNeeded += sepLen;
1039             ret = CRYPT_FormatCertSerialNumber(
1040              &info->AuthorityCertSerialNumber, NULL, &size);
1041             if (ret)
1042             {
1043                 /* don't include NULL-terminator more than once */
1044                 bytesNeeded += size - sizeof(WCHAR);
1045             }
1046         }
1047         if (ret)
1048         {
1049             if (!pbFormat)
1050                 *pcbFormat = bytesNeeded;
1051             else if (*pcbFormat < bytesNeeded)
1052             {
1053                 *pcbFormat = bytesNeeded;
1054                 SetLastError(ERROR_MORE_DATA);
1055                 ret = FALSE;
1056             }
1057             else
1058             {
1059                 LPWSTR str = pbFormat;
1060
1061                 *pcbFormat = bytesNeeded;
1062                 needSeparator = FALSE;
1063                 if (info->KeyId.cbData)
1064                 {
1065                     needSeparator = TRUE;
1066                     ret = CRYPT_FormatKeyId(&info->KeyId, str, &size);
1067                     if (ret)
1068                         str += size / sizeof(WCHAR);
1069                 }
1070                 if (info->AuthorityCertIssuer.cAltEntry)
1071                 {
1072                     if (needSeparator)
1073                     {
1074                         strcpyW(str, sep);
1075                         str += sepLen / sizeof(WCHAR);
1076                     }
1077                     needSeparator = TRUE;
1078                     ret = CRYPT_FormatCertIssuer(dwFormatStrType,
1079                      &info->AuthorityCertIssuer, str, &size);
1080                     if (ret)
1081                         str += size / sizeof(WCHAR);
1082                 }
1083                 if (info->AuthorityCertSerialNumber.cbData)
1084                 {
1085                     if (needSeparator)
1086                     {
1087                         strcpyW(str, sep);
1088                         str += sepLen / sizeof(WCHAR);
1089                     }
1090                     ret = CRYPT_FormatCertSerialNumber(
1091                      &info->AuthorityCertSerialNumber, str, &size);
1092                 }
1093             }
1094         }
1095         LocalFree(info);
1096     }
1097     return ret;
1098 }
1099
1100 static BOOL WINAPI CRYPT_FormatEnhancedKeyUsage(DWORD dwCertEncodingType,
1101  DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct,
1102  LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat,
1103  DWORD *pcbFormat)
1104 {
1105     CERT_ENHKEY_USAGE *usage;
1106     DWORD size;
1107     BOOL ret = FALSE;
1108
1109     if (!cbEncoded)
1110     {
1111         SetLastError(E_INVALIDARG);
1112         return FALSE;
1113     }
1114     if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ENHANCED_KEY_USAGE,
1115      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size)))
1116     {
1117         WCHAR unknown[MAX_STRING_RESOURCE_LEN];
1118         DWORD i;
1119         DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
1120         LPCWSTR sep;
1121         DWORD sepLen;
1122
1123         if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE)
1124         {
1125             sep = crlf;
1126             sepLen = strlenW(crlf) * sizeof(WCHAR);
1127         }
1128         else
1129         {
1130             sep = commaSpace;
1131             sepLen = strlenW(commaSpace) * sizeof(WCHAR);
1132         }
1133
1134         LoadStringW(hInstance, IDS_USAGE_UNKNOWN, unknown,
1135          sizeof(unknown) / sizeof(unknown[0]));
1136         for (i = 0; i < usage->cUsageIdentifier; i++)
1137         {
1138             PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1139              usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
1140
1141             if (info)
1142                 bytesNeeded += strlenW(info->pwszName) * sizeof(WCHAR);
1143             else
1144                 bytesNeeded += strlenW(unknown) * sizeof(WCHAR);
1145             bytesNeeded += sizeof(WCHAR); /* space */
1146             bytesNeeded += sizeof(WCHAR); /* left paren */
1147             bytesNeeded += strlen(usage->rgpszUsageIdentifier[i]) *
1148              sizeof(WCHAR);
1149             bytesNeeded += sizeof(WCHAR); /* right paren */
1150             if (i < usage->cUsageIdentifier - 1)
1151                 bytesNeeded += sepLen;
1152         }
1153         if (!pbFormat)
1154             *pcbFormat = bytesNeeded;
1155         else if (*pcbFormat < bytesNeeded)
1156         {
1157             *pcbFormat = bytesNeeded;
1158             SetLastError(ERROR_MORE_DATA);
1159             ret = FALSE;
1160         }
1161         else
1162         {
1163             LPWSTR str = pbFormat;
1164
1165             *pcbFormat = bytesNeeded;
1166             for (i = 0; i < usage->cUsageIdentifier; i++)
1167             {
1168                 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1169                  usage->rgpszUsageIdentifier[i],
1170                  CRYPT_ENHKEY_USAGE_OID_GROUP_ID);
1171                 LPCSTR oidPtr;
1172
1173                 if (info)
1174                 {
1175                     strcpyW(str, info->pwszName);
1176                     str += strlenW(info->pwszName);
1177                 }
1178                 else
1179                 {
1180                     strcpyW(str, unknown);
1181                     str += strlenW(unknown);
1182                 }
1183                 *str++ = ' ';
1184                 *str++ = '(';
1185                 for (oidPtr = usage->rgpszUsageIdentifier[i]; *oidPtr; oidPtr++)
1186                     *str++ = *oidPtr;
1187                 *str++ = ')';
1188                 *str = 0;
1189                 if (i < usage->cUsageIdentifier - 1)
1190                 {
1191                     strcpyW(str, sep);
1192                     str += sepLen / sizeof(WCHAR);
1193                 }
1194             }
1195         }
1196         LocalFree(usage);
1197     }
1198     return ret;
1199 }
1200
1201 typedef BOOL (WINAPI *CryptFormatObjectFunc)(DWORD, DWORD, DWORD, void *,
1202  LPCSTR, const BYTE *, DWORD, void *, DWORD *);
1203
1204 static CryptFormatObjectFunc CRYPT_GetBuiltinFormatFunction(DWORD encodingType,
1205  DWORD formatStrType, LPCSTR lpszStructType)
1206 {
1207     CryptFormatObjectFunc format = NULL;
1208
1209     if ((encodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING)
1210     {
1211         SetLastError(ERROR_FILE_NOT_FOUND);
1212         return NULL;
1213     }
1214     if (!HIWORD(lpszStructType))
1215     {
1216         switch (LOWORD(lpszStructType))
1217         {
1218         case LOWORD(X509_BASIC_CONSTRAINTS2):
1219             format = CRYPT_FormatBasicConstraints2;
1220             break;
1221         case LOWORD(X509_AUTHORITY_KEY_ID2):
1222             format = CRYPT_FormatAuthorityKeyId2;
1223             break;
1224         case LOWORD(X509_ENHANCED_KEY_USAGE):
1225             format = CRYPT_FormatEnhancedKeyUsage;
1226             break;
1227         }
1228     }
1229     else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
1230         format = CRYPT_FormatBasicConstraints2;
1231     else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
1232         format = CRYPT_FormatAuthorityKeyId2;
1233     else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
1234         format = CRYPT_FormatEnhancedKeyUsage;
1235     if (!format && !(formatStrType & CRYPT_FORMAT_STR_NO_HEX))
1236         format = CRYPT_FormatHexString;
1237     return format;
1238 }
1239
1240 BOOL WINAPI CryptFormatObject(DWORD dwCertEncodingType, DWORD dwFormatType,
1241  DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType,
1242  const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat)
1243 {
1244     CryptFormatObjectFunc format = NULL;
1245     HCRYPTOIDFUNCADDR hFunc = NULL;
1246     BOOL ret = FALSE;
1247
1248     TRACE("(%08x, %d, %08x, %p, %s, %p, %d, %p, %p)\n", dwCertEncodingType,
1249      dwFormatType, dwFormatStrType, pFormatStruct, debugstr_a(lpszStructType),
1250      pbEncoded, cbEncoded, pbFormat, pcbFormat);
1251
1252     if (!(format = CRYPT_GetBuiltinFormatFunction(dwCertEncodingType,
1253      dwFormatStrType, lpszStructType)))
1254     {
1255         static HCRYPTOIDFUNCSET set = NULL;
1256
1257         if (!set)
1258             set = CryptInitOIDFunctionSet(CRYPT_OID_FORMAT_OBJECT_FUNC, 0);
1259         CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
1260          (void **)&format, &hFunc);
1261     }
1262     if (format)
1263         ret = format(dwCertEncodingType, dwFormatType, dwFormatStrType,
1264          pFormatStruct, lpszStructType, pbEncoded, cbEncoded, pbFormat,
1265          pcbFormat);
1266     if (hFunc)
1267         CryptFreeOIDFunctionAddress(hFunc, 0);
1268     return ret;
1269 }