git.oblomov.eu Git - wine/blob - dlls/crypt32/serialize.c

   1 /*
   2  * Copyright 2004-2007 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 #include "wine/port.h"
  21
  22 #include <stdarg.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wincrypt.h"
  26 #include "wine/debug.h"
  27 #include "wine/exception.h"
  28 #include "crypt32_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  31
  32 /* An extended certificate property in serialized form is prefixed by this
  33  * header.
  34  */
  35 typedef struct _WINE_CERT_PROP_HEADER
  36 {
  37     DWORD propID;
  38     DWORD unknown; /* always 1 */
  39     DWORD cb;
  40 } WINE_CERT_PROP_HEADER, *PWINE_CERT_PROP_HEADER;
  41
  42 static BOOL CRYPT_SerializeStoreElement(const void *context,
  43  const BYTE *encodedContext, DWORD cbEncodedContext, DWORD contextPropID,
  44  PCWINE_CONTEXT_INTERFACE contextInterface, DWORD dwFlags, BOOL omitHashes,
  45  BYTE *pbElement, DWORD *pcbElement)
  46 {
  47     BOOL ret;
  48
  49     TRACE("(%p, %p, %08x, %d, %p, %p)\n", context, contextInterface, dwFlags,
  50      omitHashes, pbElement, pcbElement);
  51
  52     if (context)
  53     {
  54         DWORD bytesNeeded = sizeof(WINE_CERT_PROP_HEADER) + cbEncodedContext;
  55         DWORD prop = 0;
  56
  57         ret = TRUE;
  58         do {
  59             prop = contextInterface->enumProps(context, prop);
  60             if (prop && (!omitHashes || !IS_CERT_HASH_PROP_ID(prop)))
  61             {
  62                 DWORD propSize = 0;
  63
  64                 ret = contextInterface->getProp(context, prop, NULL, &propSize);
  65                 if (ret)
  66                     bytesNeeded += sizeof(WINE_CERT_PROP_HEADER) + propSize;
  67             }
  68         } while (ret && prop != 0);
  69
  70         if (!pbElement)
  71         {
  72             *pcbElement = bytesNeeded;
  73             ret = TRUE;
  74         }
  75         else if (*pcbElement < bytesNeeded)
  76         {
  77             *pcbElement = bytesNeeded;
  78             SetLastError(ERROR_MORE_DATA);
  79             ret = FALSE;
  80         }
  81         else
  82         {
  83             PWINE_CERT_PROP_HEADER hdr;
  84             DWORD bufSize = 0;
  85             LPBYTE buf = NULL;
  86
  87             prop = 0;
  88             do {
  89                 prop = contextInterface->enumProps(context, prop);
  90                 if (prop && (!omitHashes || !IS_CERT_HASH_PROP_ID(prop)))
  91                 {
  92                     DWORD propSize = 0;
  93
  94                     ret = contextInterface->getProp(context, prop, NULL,
  95                      &propSize);
  96                     if (ret)
  97                     {
  98                         if (bufSize < propSize)
  99                         {
 100                             if (buf)
 101                                 buf = CryptMemRealloc(buf, propSize);
 102                             else
 103                                 buf = CryptMemAlloc(propSize);
 104                             bufSize = propSize;
 105                         }
 106                         if (buf)
 107                         {
 108                             ret = contextInterface->getProp(context, prop, buf,
 109                              &propSize);
 110                             if (ret)
 111                             {
 112                                 hdr = (PWINE_CERT_PROP_HEADER)pbElement;
 113                                 hdr->propID = prop;
 114                                 hdr->unknown = 1;
 115                                 hdr->cb = propSize;
 116                                 pbElement += sizeof(WINE_CERT_PROP_HEADER);
 117                                 if (propSize)
 118                                 {
 119                                     memcpy(pbElement, buf, propSize);
 120                                     pbElement += propSize;
 121                                 }
 122                             }
 123                         }
 124                         else
 125                             ret = FALSE;
 126                     }
 127                 }
 128             } while (ret && prop != 0);
 129             CryptMemFree(buf);
 130
 131             hdr = (PWINE_CERT_PROP_HEADER)pbElement;
 132             hdr->propID = contextPropID;
 133             hdr->unknown = 1;
 134             hdr->cb = cbEncodedContext;
 135             memcpy(pbElement + sizeof(WINE_CERT_PROP_HEADER),
 136              encodedContext, cbEncodedContext);
 137         }
 138     }
 139     else
 140         ret = FALSE;
 141     return ret;
 142 }
 143
 144 BOOL WINAPI CertSerializeCertificateStoreElement(PCCERT_CONTEXT pCertContext,
 145  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
 146 {
 147     return CRYPT_SerializeStoreElement(pCertContext,
 148      pCertContext->pbCertEncoded, pCertContext->cbCertEncoded,
 149      CERT_CERT_PROP_ID, pCertInterface, dwFlags, FALSE, pbElement, pcbElement);
 150 }
 151
 152 BOOL WINAPI CertSerializeCRLStoreElement(PCCRL_CONTEXT pCrlContext,
 153  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
 154 {
 155     return CRYPT_SerializeStoreElement(pCrlContext,
 156      pCrlContext->pbCrlEncoded, pCrlContext->cbCrlEncoded,
 157      CERT_CRL_PROP_ID, pCRLInterface, dwFlags, FALSE, pbElement, pcbElement);
 158 }
 159
 160 BOOL WINAPI CertSerializeCTLStoreElement(PCCTL_CONTEXT pCtlContext,
 161  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
 162 {
 163     return CRYPT_SerializeStoreElement(pCtlContext,
 164      pCtlContext->pbCtlEncoded, pCtlContext->cbCtlEncoded,
 165      CERT_CTL_PROP_ID, pCTLInterface, dwFlags, FALSE, pbElement, pcbElement);
 166 }
 167
 168 /* Looks for the property with ID propID in the buffer buf.  Returns a pointer
 169  * to its header if a valid header is found, NULL if not.  Valid means the
 170  * length of thte property won't overrun buf, and the unknown field is 1.
 171  */
 172 static const WINE_CERT_PROP_HEADER *CRYPT_findPropID(const BYTE *buf,
 173  DWORD size, DWORD propID)
 174 {
 175     const WINE_CERT_PROP_HEADER *ret = NULL;
 176     BOOL done = FALSE;
 177
 178     while (size && !ret && !done)
 179     {
 180         if (size < sizeof(WINE_CERT_PROP_HEADER))
 181         {
 182             SetLastError(CRYPT_E_FILE_ERROR);
 183             done = TRUE;
 184         }
 185         else
 186         {
 187             const WINE_CERT_PROP_HEADER *hdr =
 188              (const WINE_CERT_PROP_HEADER *)buf;
 189
 190             size -= sizeof(WINE_CERT_PROP_HEADER);
 191             buf += sizeof(WINE_CERT_PROP_HEADER);
 192             if (size < hdr->cb)
 193             {
 194                 SetLastError(E_INVALIDARG);
 195                 done = TRUE;
 196             }
 197             else if (!hdr->propID)
 198             {
 199                 /* assume a zero prop ID means the data are uninitialized, so
 200                  * stop looking.
 201                  */
 202                 done = TRUE;
 203             }
 204             else if (hdr->unknown != 1)
 205             {
 206                 SetLastError(ERROR_FILE_NOT_FOUND);
 207                 done = TRUE;
 208             }
 209             else if (hdr->propID == propID)
 210                 ret = hdr;
 211             else
 212             {
 213                 buf += hdr->cb;
 214                 size -= hdr->cb;
 215             }
 216         }
 217     }
 218     return ret;
 219 }
 220
 221 static BOOL CRYPT_ReadContextProp(
 222  const WINE_CONTEXT_INTERFACE *contextInterface, const void *context,
 223  const WINE_CERT_PROP_HEADER *hdr, const BYTE *pbElement, DWORD cbElement)
 224 {
 225     BOOL ret;
 226
 227     if (cbElement < hdr->cb)
 228     {
 229         SetLastError(E_INVALIDARG);
 230         ret = FALSE;
 231     }
 232     else if (hdr->unknown != 1)
 233     {
 234         SetLastError(ERROR_FILE_NOT_FOUND);
 235         ret = FALSE;
 236     }
 237     else if (hdr->propID != CERT_CERT_PROP_ID &&
 238      hdr->propID != CERT_CRL_PROP_ID && hdr->propID != CERT_CTL_PROP_ID)
 239     {
 240         /* Have to create a blob for most types, but not
 241          * for all.. arghh.
 242          */
 243         switch (hdr->propID)
 244         {
 245         case CERT_AUTO_ENROLL_PROP_ID:
 246         case CERT_CTL_USAGE_PROP_ID:
 247         case CERT_DESCRIPTION_PROP_ID:
 248         case CERT_FRIENDLY_NAME_PROP_ID:
 249         case CERT_HASH_PROP_ID:
 250         case CERT_KEY_IDENTIFIER_PROP_ID:
 251         case CERT_MD5_HASH_PROP_ID:
 252         case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
 253         case CERT_PUBKEY_ALG_PARA_PROP_ID:
 254         case CERT_PVK_FILE_PROP_ID:
 255         case CERT_SIGNATURE_HASH_PROP_ID:
 256         case CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID:
 257         case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
 258         case CERT_ENROLLMENT_PROP_ID:
 259         case CERT_CROSS_CERT_DIST_POINTS_PROP_ID:
 260         case CERT_RENEWAL_PROP_ID:
 261         {
 262             CRYPT_DATA_BLOB blob = { hdr->cb,
 263              (LPBYTE)pbElement };
 264
 265             ret = contextInterface->setProp(context,
 266              hdr->propID, 0, &blob);
 267             break;
 268         }
 269         case CERT_DATE_STAMP_PROP_ID:
 270             ret = contextInterface->setProp(context,
 271              hdr->propID, 0, pbElement);
 272             break;
 273         case CERT_KEY_PROV_INFO_PROP_ID:
 274         {
 275             PCRYPT_KEY_PROV_INFO info =
 276              (PCRYPT_KEY_PROV_INFO)pbElement;
 277
 278             CRYPT_FixKeyProvInfoPointers(info);
 279             ret = contextInterface->setProp(context,
 280              hdr->propID, 0, pbElement);
 281             break;
 282         }
 283         default:
 284             ret = FALSE;
 285         }
 286     }
 287     else
 288     {
 289         /* ignore the context itself */
 290         ret = TRUE;
 291     }
 292     return ret;
 293 }
 294
 295 const void *CRYPT_ReadSerializedElement(const BYTE *pbElement, DWORD cbElement,
 296  DWORD dwContextTypeFlags, DWORD *pdwContentType)
 297 {
 298     const void *context;
 299
 300     TRACE("(%p, %d, %08x, %p)\n", pbElement, cbElement, dwContextTypeFlags,
 301      pdwContentType);
 302
 303     if (!cbElement)
 304     {
 305         SetLastError(ERROR_END_OF_MEDIA);
 306         return NULL;
 307     }
 308
 309     __TRY
 310     {
 311         const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
 312         const WINE_CERT_PROP_HEADER *hdr = NULL;
 313         DWORD type = 0;
 314         BOOL ret;
 315
 316         ret = TRUE;
 317         context = NULL;
 318         if (dwContextTypeFlags == CERT_STORE_ALL_CONTEXT_FLAG)
 319         {
 320             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
 321             if (hdr)
 322                 type = CERT_STORE_CERTIFICATE_CONTEXT;
 323             else
 324             {
 325                 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
 326                 if (hdr)
 327                     type = CERT_STORE_CRL_CONTEXT;
 328                 else
 329                 {
 330                     hdr = CRYPT_findPropID(pbElement, cbElement,
 331                      CERT_CTL_PROP_ID);
 332                     if (hdr)
 333                         type = CERT_STORE_CTL_CONTEXT;
 334                 }
 335             }
 336         }
 337         else if (dwContextTypeFlags & CERT_STORE_CERTIFICATE_CONTEXT_FLAG)
 338         {
 339             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
 340             type = CERT_STORE_CERTIFICATE_CONTEXT;
 341         }
 342         else if (dwContextTypeFlags & CERT_STORE_CRL_CONTEXT_FLAG)
 343         {
 344             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
 345             type = CERT_STORE_CRL_CONTEXT;
 346         }
 347         else if (dwContextTypeFlags & CERT_STORE_CTL_CONTEXT_FLAG)
 348         {
 349             hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CTL_PROP_ID);
 350             type = CERT_STORE_CTL_CONTEXT;
 351         }
 352
 353         switch (type)
 354         {
 355         case CERT_STORE_CERTIFICATE_CONTEXT:
 356             contextInterface = pCertInterface;
 357             break;
 358         case CERT_STORE_CRL_CONTEXT:
 359             contextInterface = pCRLInterface;
 360             break;
 361         case CERT_STORE_CTL_CONTEXT:
 362             contextInterface = pCTLInterface;
 363             break;
 364         default:
 365             SetLastError(E_INVALIDARG);
 366             ret = FALSE;
 367         }
 368         if (!hdr)
 369             ret = FALSE;
 370
 371         if (ret)
 372             context = contextInterface->create(X509_ASN_ENCODING,
 373              (BYTE *)hdr + sizeof(WINE_CERT_PROP_HEADER), hdr->cb);
 374         if (ret && context)
 375         {
 376             BOOL noMoreProps = FALSE;
 377
 378             while (!noMoreProps && ret)
 379             {
 380                 if (cbElement < sizeof(WINE_CERT_PROP_HEADER))
 381                     ret = FALSE;
 382                 else
 383                 {
 384                     const WINE_CERT_PROP_HEADER *hdr =
 385                      (const WINE_CERT_PROP_HEADER *)pbElement;
 386
 387                     TRACE("prop is %d\n", hdr->propID);
 388                     cbElement -= sizeof(WINE_CERT_PROP_HEADER);
 389                     pbElement += sizeof(WINE_CERT_PROP_HEADER);
 390                     if (!hdr->propID)
 391                     {
 392                         /* Like in CRYPT_findPropID, stop if the propID is zero
 393                          */
 394                         noMoreProps = TRUE;
 395                     }
 396                     else
 397                         ret = CRYPT_ReadContextProp(contextInterface, context,
 398                          hdr, pbElement, cbElement);
 399                     pbElement += hdr->cb;
 400                     cbElement -= hdr->cb;
 401                     if (!cbElement)
 402                         noMoreProps = TRUE;
 403                 }
 404             }
 405             if (ret)
 406             {
 407                 if (pdwContentType)
 408                     *pdwContentType = type;
 409             }
 410             else
 411             {
 412                 contextInterface->free(context);
 413                 context = NULL;
 414             }
 415         }
 416     }
 417     __EXCEPT_PAGE_FAULT
 418     {
 419         SetLastError(STATUS_ACCESS_VIOLATION);
 420         context = NULL;
 421     }
 422     __ENDTRY
 423     return context;
 424 }
 425
 426 static const BYTE fileHeader[] = { 0, 0, 0, 0, 'C','E','R','T' };
 427
 428 typedef BOOL (*read_serialized_func)(void *handle, void *buffer,
 429  DWORD bytesToRead, DWORD *bytesRead);
 430
 431 static BOOL CRYPT_ReadSerializedStore(void *handle,
 432  read_serialized_func read_func, HCERTSTORE store)
 433 {
 434     BYTE fileHeaderBuf[sizeof(fileHeader)];
 435     DWORD read;
 436     BOOL ret;
 437
 438     /* Failure reading is non-critical, we'll leave the store empty */
 439     ret = read_func(handle, fileHeaderBuf, sizeof(fileHeaderBuf), &read);
 440     if (ret)
 441     {
 442         if (!read)
 443             ; /* an empty file is okay */
 444         else if (read != sizeof(fileHeaderBuf))
 445             ret = FALSE;
 446         else if (!memcmp(fileHeaderBuf, fileHeader, read))
 447         {
 448             WINE_CERT_PROP_HEADER propHdr;
 449             const void *context = NULL;
 450             const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
 451             LPBYTE buf = NULL;
 452             DWORD bufSize = 0;
 453
 454             do {
 455                 ret = read_func(handle, &propHdr, sizeof(propHdr), &read);
 456                 if (ret && read == sizeof(propHdr))
 457                 {
 458                     if (contextInterface && context &&
 459                      (propHdr.propID == CERT_CERT_PROP_ID ||
 460                      propHdr.propID == CERT_CRL_PROP_ID ||
 461                      propHdr.propID == CERT_CTL_PROP_ID))
 462                     {
 463                         /* We have a new context, so free the existing one */
 464                         contextInterface->free(context);
 465                     }
 466                     if (propHdr.cb > bufSize)
 467                     {
 468                         /* Not reusing realloc, because the old data aren't
 469                          * needed any longer.
 470                          */
 471                         CryptMemFree(buf);
 472                         buf = CryptMemAlloc(propHdr.cb);
 473                         bufSize = propHdr.cb;
 474                     }
 475                     if (buf)
 476                     {
 477                         ret = read_func(handle, buf, propHdr.cb, &read);
 478                         if (ret && read == propHdr.cb)
 479                         {
 480                             if (propHdr.propID == CERT_CERT_PROP_ID)
 481                             {
 482                                 contextInterface = pCertInterface;
 483                                 ret = contextInterface->addEncodedToStore(store,
 484                                  X509_ASN_ENCODING, buf, read,
 485                                  CERT_STORE_ADD_NEW, &context);
 486                             }
 487                             else if (propHdr.propID == CERT_CRL_PROP_ID)
 488                             {
 489                                 contextInterface = pCRLInterface;
 490                                 ret = contextInterface->addEncodedToStore(store,
 491                                  X509_ASN_ENCODING, buf, read,
 492                                  CERT_STORE_ADD_NEW, &context);
 493                             }
 494                             else if (propHdr.propID == CERT_CTL_PROP_ID)
 495                             {
 496                                 contextInterface = pCTLInterface;
 497                                 ret = contextInterface->addEncodedToStore(store,
 498                                  X509_ASN_ENCODING, buf, read,
 499                                  CERT_STORE_ADD_NEW, &context);
 500                             }
 501                             else
 502                                 ret = CRYPT_ReadContextProp(contextInterface,
 503                                  context, &propHdr, buf, read);
 504                         }
 505                     }
 506                     else
 507                         ret = FALSE;
 508                 }
 509             } while (ret && read > 0);
 510             if (contextInterface && context)
 511             {
 512                 /* Free the last context added */
 513                 contextInterface->free(context);
 514             }
 515             CryptMemFree(buf);
 516             ret = TRUE;
 517         }
 518         else
 519             ret = FALSE;
 520     }
 521     else
 522         ret = TRUE;
 523     return ret;
 524 }
 525
 526 static BOOL read_file_wrapper(void *handle, void *buffer, DWORD bytesToRead,
 527  DWORD *bytesRead)
 528 {
 529     return ReadFile(handle, buffer, bytesToRead, bytesRead, NULL);
 530 }
 531
 532 BOOL CRYPT_ReadSerializedStoreFromFile(HANDLE file, HCERTSTORE store)
 533 {
 534     return CRYPT_ReadSerializedStore(file, read_file_wrapper, store);
 535 }
 536
 537 struct BlobReader
 538 {
 539     const CRYPT_DATA_BLOB *blob;
 540     DWORD current;
 541 };
 542
 543 static BOOL read_blob_wrapper(void *handle, void *buffer, DWORD bytesToRead,
 544  DWORD *bytesRead)
 545 {
 546     struct BlobReader *reader = handle;
 547     BOOL ret;
 548
 549     if (reader->current < reader->blob->cbData)
 550     {
 551         *bytesRead = min(bytesToRead, reader->blob->cbData - reader->current);
 552         memcpy(buffer, reader->blob->pbData + reader->current, *bytesRead);
 553         ret = TRUE;
 554     }
 555     else
 556         ret = FALSE;
 557     return ret;
 558 }
 559
 560 BOOL CRYPT_ReadSerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob,
 561  HCERTSTORE store)
 562 {
 563     struct BlobReader reader = { blob, 0 };
 564
 565     return CRYPT_ReadSerializedStore(&reader, read_blob_wrapper, store);
 566 }
 567
 568 static BOOL WINAPI CRYPT_SerializeCertNoHash(PCCERT_CONTEXT pCertContext,
 569  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
 570 {
 571     return CRYPT_SerializeStoreElement(pCertContext,
 572      pCertContext->pbCertEncoded, pCertContext->cbCertEncoded,
 573      CERT_CERT_PROP_ID, pCertInterface, dwFlags, TRUE, pbElement, pcbElement);
 574 }
 575
 576 static BOOL WINAPI CRYPT_SerializeCRLNoHash(PCCRL_CONTEXT pCrlContext,
 577  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
 578 {
 579     return CRYPT_SerializeStoreElement(pCrlContext,
 580      pCrlContext->pbCrlEncoded, pCrlContext->cbCrlEncoded,
 581      CERT_CRL_PROP_ID, pCRLInterface, dwFlags, TRUE, pbElement, pcbElement);
 582 }
 583
 584 static BOOL WINAPI CRYPT_SerializeCTLNoHash(PCCTL_CONTEXT pCtlContext,
 585  DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
 586 {
 587     return CRYPT_SerializeStoreElement(pCtlContext,
 588      pCtlContext->pbCtlEncoded, pCtlContext->cbCtlEncoded,
 589      CERT_CTL_PROP_ID, pCTLInterface, dwFlags, TRUE, pbElement, pcbElement);
 590 }
 591
 592 typedef BOOL (*SerializedOutputFunc)(void *handle, const void *buffer,
 593  DWORD size);
 594
 595 static BOOL CRYPT_SerializeContextsToStream(SerializedOutputFunc output,
 596  void *handle, const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE store)
 597 {
 598     const void *context = NULL;
 599     BOOL ret;
 600
 601     do {
 602         context = contextInterface->enumContextsInStore(store, context);
 603         if (context)
 604         {
 605             DWORD size = 0;
 606             LPBYTE buf = NULL;
 607
 608             ret = contextInterface->serialize(context, 0, NULL, &size);
 609             if (size)
 610                 buf = CryptMemAlloc(size);
 611             if (buf)
 612             {
 613                 ret = contextInterface->serialize(context, 0, buf, &size);
 614                 if (ret)
 615                     ret = output(handle, buf, size);
 616             }
 617             CryptMemFree(buf);
 618         }
 619         else
 620             ret = TRUE;
 621     } while (ret && context != NULL);
 622     if (context)
 623         contextInterface->free(context);
 624     return ret;
 625 }
 626
 627 static BOOL CRYPT_WriteSerializedStoreToStream(HCERTSTORE store,
 628  SerializedOutputFunc output, void *handle)
 629 {
 630     static const BYTE fileTrailer[12] = { 0 };
 631     WINE_CONTEXT_INTERFACE interface;
 632     BOOL ret;
 633
 634     ret = output(handle, fileHeader, sizeof(fileHeader));
 635     if (ret)
 636     {
 637         memcpy(&interface, pCertInterface, sizeof(interface));
 638         interface.serialize = (SerializeElementFunc)CRYPT_SerializeCertNoHash;
 639         ret = CRYPT_SerializeContextsToStream(output, handle, &interface,
 640          store);
 641     }
 642     if (ret)
 643     {
 644         memcpy(&interface, pCRLInterface, sizeof(interface));
 645         interface.serialize = (SerializeElementFunc)CRYPT_SerializeCRLNoHash;
 646         ret = CRYPT_SerializeContextsToStream(output, handle, &interface,
 647          store);
 648     }
 649     if (ret)
 650     {
 651         memcpy(&interface, pCTLInterface, sizeof(interface));
 652         interface.serialize = (SerializeElementFunc)CRYPT_SerializeCTLNoHash;
 653         ret = CRYPT_SerializeContextsToStream(output, handle, &interface,
 654          store);
 655     }
 656     if (ret)
 657         ret = output(handle, fileTrailer, sizeof(fileTrailer));
 658     return ret;
 659 }
 660
 661 static BOOL CRYPT_FileOutputFunc(void *handle, const void *buffer, DWORD size)
 662 {
 663     return WriteFile(handle, buffer, size, &size, NULL);
 664 }
 665
 666 static BOOL CRYPT_WriteSerializedStoreToFile(HANDLE file, HCERTSTORE store)
 667 {
 668     SetFilePointer(file, 0, NULL, FILE_BEGIN);
 669     return CRYPT_WriteSerializedStoreToStream(store, CRYPT_FileOutputFunc,
 670      file);
 671 }
 672
 673 static BOOL CRYPT_SavePKCSToMem(HCERTSTORE store,
 674  DWORD dwMsgAndCertEncodingType, void *handle)
 675 {
 676     CERT_BLOB *blob = handle;
 677     CRYPT_SIGNED_INFO signedInfo = { 0 };
 678     PCCERT_CONTEXT cert = NULL;
 679     PCCRL_CONTEXT crl = NULL;
 680     DWORD size;
 681     BOOL ret = TRUE;
 682
 683     TRACE("(%d, %p)\n", blob->pbData ? blob->cbData : 0, blob->pbData);
 684
 685     do {
 686         cert = CertEnumCertificatesInStore(store, cert);
 687         if (cert)
 688             signedInfo.cCertEncoded++;
 689     } while (cert);
 690     if (signedInfo.cCertEncoded)
 691     {
 692         signedInfo.rgCertEncoded = CryptMemAlloc(
 693          signedInfo.cCertEncoded * sizeof(CERT_BLOB));
 694         if (!signedInfo.rgCertEncoded)
 695         {
 696             SetLastError(ERROR_OUTOFMEMORY);
 697             ret = FALSE;
 698         }
 699         else
 700         {
 701             DWORD i = 0;
 702
 703             do {
 704                 cert = CertEnumCertificatesInStore(store, cert);
 705                 if (cert)
 706                 {
 707                     signedInfo.rgCertEncoded[i].cbData = cert->cbCertEncoded;
 708                     signedInfo.rgCertEncoded[i].pbData = cert->pbCertEncoded;
 709                     i++;
 710                 }
 711             } while (cert);
 712         }
 713     }
 714
 715     do {
 716         crl = CertEnumCRLsInStore(store, crl);
 717         if (crl)
 718             signedInfo.cCrlEncoded++;
 719     } while (crl);
 720     if (signedInfo.cCrlEncoded)
 721     {
 722         signedInfo.rgCrlEncoded = CryptMemAlloc(
 723          signedInfo.cCrlEncoded * sizeof(CERT_BLOB));
 724         if (!signedInfo.rgCrlEncoded)
 725         {
 726             SetLastError(ERROR_OUTOFMEMORY);
 727             ret = FALSE;
 728         }
 729         else
 730         {
 731             DWORD i = 0;
 732
 733             do {
 734                 crl = CertEnumCRLsInStore(store, crl);
 735                 if (crl)
 736                 {
 737                     signedInfo.rgCrlEncoded[i].cbData = crl->cbCrlEncoded;
 738                     signedInfo.rgCrlEncoded[i].pbData = crl->pbCrlEncoded;
 739                     i++;
 740                 }
 741             } while (crl);
 742         }
 743     }
 744     if (ret)
 745     {
 746         ret = CRYPT_AsnEncodeCMSSignedInfo(&signedInfo, NULL, &size);
 747         if (ret)
 748         {
 749             if (!blob->pbData)
 750                 blob->cbData = size;
 751             else if (blob->cbData < size)
 752             {
 753                 blob->cbData = size;
 754                 SetLastError(ERROR_MORE_DATA);
 755                 ret = FALSE;
 756             }
 757             else
 758             {
 759                 blob->cbData = size;
 760                 ret = CRYPT_AsnEncodeCMSSignedInfo(&signedInfo, blob->pbData,
 761                  &blob->cbData);
 762             }
 763         }
 764     }
 765     CryptMemFree(signedInfo.rgCertEncoded);
 766     CryptMemFree(signedInfo.rgCrlEncoded);
 767     TRACE("returning %d\n", ret);
 768     return ret;
 769 }
 770
 771 static BOOL CRYPT_SavePKCSToFile(HCERTSTORE store,
 772  DWORD dwMsgAndCertEncodingType, void *handle)
 773 {
 774     CERT_BLOB blob = { 0, NULL };
 775     BOOL ret;
 776
 777     TRACE("(%p)\n", handle);
 778
 779     ret = CRYPT_SavePKCSToMem(store, dwMsgAndCertEncodingType, &blob);
 780     if (ret)
 781     {
 782         blob.pbData = CryptMemAlloc(blob.cbData);
 783         if (blob.pbData)
 784         {
 785             ret = CRYPT_SavePKCSToMem(store, dwMsgAndCertEncodingType, &blob);
 786             if (ret)
 787                 ret = WriteFile(handle, blob.pbData, blob.cbData,
 788                  &blob.cbData, NULL);
 789         }
 790         else
 791         {
 792             SetLastError(ERROR_OUTOFMEMORY);
 793             ret = FALSE;
 794         }
 795     }
 796     TRACE("returning %d\n", ret);
 797     return ret;
 798 }
 799
 800 static BOOL CRYPT_SaveSerializedToFile(HCERTSTORE store,
 801  DWORD dwMsgAndCertEncodingType, void *handle)
 802 {
 803     return CRYPT_WriteSerializedStoreToFile(handle, store);
 804 }
 805
 806 struct MemWrittenTracker
 807 {
 808     DWORD cbData;
 809     BYTE *pbData;
 810     DWORD written;
 811 };
 812
 813 /* handle is a pointer to a MemWrittenTracker.  Assumes its pointer is valid. */
 814 static BOOL CRYPT_MemOutputFunc(void *handle, const void *buffer, DWORD size)
 815 {
 816     struct MemWrittenTracker *tracker = handle;
 817     BOOL ret;
 818
 819     if (tracker->written + size > tracker->cbData)
 820     {
 821         SetLastError(ERROR_MORE_DATA);
 822         /* Update written so caller can notify its caller of the required size
 823          */
 824         tracker->written += size;
 825         ret = FALSE;
 826     }
 827     else
 828     {
 829         memcpy(tracker->pbData + tracker->written, buffer, size);
 830         tracker->written += size;
 831         ret = TRUE;
 832     }
 833     return ret;
 834 }
 835
 836 static BOOL CRYPT_CountSerializedBytes(void *handle, const void *buffer,
 837  DWORD size)
 838 {
 839     *(DWORD *)handle += size;
 840     return TRUE;
 841 }
 842
 843 static BOOL CRYPT_SaveSerializedToMem(HCERTSTORE store,
 844  DWORD dwMsgAndCertEncodingType, void *handle)
 845 {
 846     CERT_BLOB *blob = handle;
 847     DWORD size = 0;
 848     BOOL ret;
 849
 850     ret = CRYPT_WriteSerializedStoreToStream(store, CRYPT_CountSerializedBytes,
 851      &size);
 852     if (ret)
 853     {
 854         if (!blob->pbData)
 855             blob->cbData = size;
 856         else if (blob->cbData < size)
 857         {
 858             SetLastError(ERROR_MORE_DATA);
 859             blob->cbData = size;
 860             ret = FALSE;
 861         }
 862         else
 863         {
 864             struct MemWrittenTracker tracker = { blob->cbData, blob->pbData,
 865              0 };
 866
 867             ret = CRYPT_WriteSerializedStoreToStream(store, CRYPT_MemOutputFunc,
 868              &tracker);
 869             if (!ret && GetLastError() == ERROR_MORE_DATA)
 870                 blob->cbData = tracker.written;
 871         }
 872     }
 873     TRACE("returning %d\n", ret);
 874     return ret;
 875 }
 876
 877 BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
 878  DWORD dwSaveAs, DWORD dwSaveTo, void *pvSaveToPara, DWORD dwFlags)
 879 {
 880     BOOL (*saveFunc)(HCERTSTORE, DWORD, void *);
 881     void *handle;
 882     BOOL ret, closeFile = TRUE;
 883
 884     TRACE("(%p, %08x, %d, %d, %p, %08x)\n", hCertStore,
 885           dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
 886
 887     switch (dwSaveAs)
 888     {
 889     case CERT_STORE_SAVE_AS_STORE:
 890         if (dwSaveTo == CERT_STORE_SAVE_TO_MEMORY)
 891             saveFunc = CRYPT_SaveSerializedToMem;
 892         else
 893             saveFunc = CRYPT_SaveSerializedToFile;
 894         break;
 895     case CERT_STORE_SAVE_AS_PKCS7:
 896         if (dwSaveTo == CERT_STORE_SAVE_TO_MEMORY)
 897             saveFunc = CRYPT_SavePKCSToMem;
 898         else
 899             saveFunc = CRYPT_SavePKCSToFile;
 900         break;
 901     default:
 902         WARN("unimplemented for %d\n", dwSaveAs);
 903         SetLastError(ERROR_INVALID_PARAMETER);
 904         return FALSE;
 905     }
 906     switch (dwSaveTo)
 907     {
 908     case CERT_STORE_SAVE_TO_FILE:
 909         handle = pvSaveToPara;
 910         closeFile = FALSE;
 911         break;
 912     case CERT_STORE_SAVE_TO_FILENAME_A:
 913         handle = CreateFileA(pvSaveToPara, GENERIC_WRITE, 0, NULL,
 914          CREATE_ALWAYS, 0, NULL);
 915         break;
 916     case CERT_STORE_SAVE_TO_FILENAME_W:
 917         handle = CreateFileW(pvSaveToPara, GENERIC_WRITE, 0, NULL,
 918          CREATE_ALWAYS, 0, NULL);
 919         break;
 920     case CERT_STORE_SAVE_TO_MEMORY:
 921         handle = pvSaveToPara;
 922         break;
 923     default:
 924         WARN("unimplemented for %d\n", dwSaveTo);
 925         SetLastError(ERROR_INVALID_PARAMETER);
 926         return FALSE;
 927     }
 928     ret = saveFunc(hCertStore, dwMsgAndCertEncodingType, handle);
 929     if (closeFile)
 930         CloseHandle(handle);
 931     TRACE("returning %d\n", ret);
 932     return ret;
 933 }
 934
 935 BOOL WINAPI CertAddSerializedElementToStore(HCERTSTORE hCertStore,
 936  const BYTE *pbElement, DWORD cbElement, DWORD dwAddDisposition, DWORD dwFlags,
 937  DWORD dwContextTypeFlags, DWORD *pdwContentType, const void **ppvContext)
 938 {
 939     const void *context;
 940     DWORD type;
 941     BOOL ret;
 942
 943     TRACE("(%p, %p, %d, %08x, %08x, %08x, %p, %p)\n", hCertStore,
 944      pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags,
 945      pdwContentType, ppvContext);
 946
 947     /* Call the internal function, then delete the hashes.  Tests show this
 948      * function uses real hash values, not whatever's stored in the hash
 949      * property.
 950      */
 951     context = CRYPT_ReadSerializedElement(pbElement, cbElement,
 952      dwContextTypeFlags, &type);
 953     if (context)
 954     {
 955         const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
 956
 957         switch (type)
 958         {
 959         case CERT_STORE_CERTIFICATE_CONTEXT:
 960             contextInterface = pCertInterface;
 961             break;
 962         case CERT_STORE_CRL_CONTEXT:
 963             contextInterface = pCRLInterface;
 964             break;
 965         case CERT_STORE_CTL_CONTEXT:
 966             contextInterface = pCTLInterface;
 967             break;
 968         default:
 969             SetLastError(E_INVALIDARG);
 970         }
 971         if (contextInterface)
 972         {
 973             contextInterface->setProp(context, CERT_HASH_PROP_ID, 0, NULL);
 974             contextInterface->setProp(context, CERT_MD5_HASH_PROP_ID, 0, NULL);
 975             contextInterface->setProp(context, CERT_SIGNATURE_HASH_PROP_ID, 0,
 976              NULL);
 977             if (pdwContentType)
 978                 *pdwContentType = type;
 979             ret = contextInterface->addContextToStore(hCertStore, context,
 980              dwAddDisposition, ppvContext);
 981             contextInterface->free(context);
 982         }
 983         else
 984             ret = FALSE;
 985     }
 986     else
 987         ret = FALSE;
 988     return ret;
 989 }