source: trunk/src/crypt32/serialize.c@ 21316

Last change on this file since 21316 was 21311, checked in by vladest, 16 years ago

Added CRYPT32 and MSCMS APIs support
File size: 29.2 KB
Line 
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
30WINE_DEFAULT_DEBUG_CHANNEL(crypt);
31
32/* An extended certificate property in serialized form is prefixed by this
33 * header.
34 */
35typedef 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
42static 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
144BOOL 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
152BOOL 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
160BOOL 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 */
172static 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
221static 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
295const 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->confree(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
426static const BYTE fileHeader[] = { 0, 0, 0, 0, 'C','E','R','T' };
427
428BOOL CRYPT_ReadSerializedStoreFromFile(HANDLE file, HCERTSTORE store)
429{
430 BYTE fileHeaderBuf[sizeof(fileHeader)];
431 DWORD read;
432 BOOL ret;
433
434 /* Failure reading is non-critical, we'll leave the store empty */
435 ret = ReadFile(file, fileHeaderBuf, sizeof(fileHeaderBuf), &read, NULL);
436 if (ret)
437 {
438 if (!read)
439 ; /* an empty file is okay */
440 else if (read != sizeof(fileHeaderBuf))
441 ret = FALSE;
442 else if (!memcmp(fileHeaderBuf, fileHeader, read))
443 {
444 WINE_CERT_PROP_HEADER propHdr;
445 const void *context = NULL;
446 const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
447 LPBYTE buf = NULL;
448 DWORD bufSize = 0;
449
450 do {
451 ret = ReadFile(file, &propHdr, sizeof(propHdr), &read, NULL);
452 if (ret && read == sizeof(propHdr))
453 {
454 if (contextInterface && context &&
455 (propHdr.propID == CERT_CERT_PROP_ID ||
456 propHdr.propID == CERT_CRL_PROP_ID ||
457 propHdr.propID == CERT_CTL_PROP_ID))
458 {
459 /* We have a new context, so free the existing one */
460 contextInterface->confree(context);
461 }
462 if (propHdr.cb > bufSize)
463 {
464 /* Not reusing realloc, because the old data aren't
465 * needed any longer.
466 */
467 CryptMemFree(buf);
468 buf = CryptMemAlloc(propHdr.cb);
469 bufSize = propHdr.cb;
470 }
471 if (buf)
472 {
473 ret = ReadFile(file, buf, propHdr.cb, &read, NULL);
474 if (ret && read == propHdr.cb)
475 {
476 if (propHdr.propID == CERT_CERT_PROP_ID)
477 {
478 contextInterface = pCertInterface;
479 ret = contextInterface->addEncodedToStore(store,
480 X509_ASN_ENCODING, buf, read,
481 CERT_STORE_ADD_NEW, &context);
482 }
483 else if (propHdr.propID == CERT_CRL_PROP_ID)
484 {
485 contextInterface = pCRLInterface;
486 ret = contextInterface->addEncodedToStore(store,
487 X509_ASN_ENCODING, buf, read,
488 CERT_STORE_ADD_NEW, &context);
489 }
490 else if (propHdr.propID == CERT_CTL_PROP_ID)
491 {
492 contextInterface = pCTLInterface;
493 ret = contextInterface->addEncodedToStore(store,
494 X509_ASN_ENCODING, buf, read,
495 CERT_STORE_ADD_NEW, &context);
496 }
497 else
498 ret = CRYPT_ReadContextProp(contextInterface,
499 context, &propHdr, buf, read);
500 }
501 }
502 else
503 ret = FALSE;
504 }
505 } while (ret && read > 0);
506 if (contextInterface && context)
507 {
508 /* Free the last context added */
509 contextInterface->confree(context);
510 }
511 CryptMemFree(buf);
512 ret = TRUE;
513 }
514 else
515 ret = FALSE;
516 }
517 else
518 ret = TRUE;
519 return ret;
520}
521
522static BOOL WINAPI CRYPT_SerializeCertNoHash(PCCERT_CONTEXT pCertContext,
523 DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
524{
525 return CRYPT_SerializeStoreElement(pCertContext,
526 pCertContext->pbCertEncoded, pCertContext->cbCertEncoded,
527 CERT_CERT_PROP_ID, pCertInterface, dwFlags, TRUE, pbElement, pcbElement);
528}
529
530static BOOL WINAPI CRYPT_SerializeCRLNoHash(PCCRL_CONTEXT pCrlContext,
531 DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
532{
533 return CRYPT_SerializeStoreElement(pCrlContext,
534 pCrlContext->pbCrlEncoded, pCrlContext->cbCrlEncoded,
535 CERT_CRL_PROP_ID, pCRLInterface, dwFlags, TRUE, pbElement, pcbElement);
536}
537
538static BOOL WINAPI CRYPT_SerializeCTLNoHash(PCCTL_CONTEXT pCtlContext,
539 DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
540{
541 return CRYPT_SerializeStoreElement(pCtlContext,
542 pCtlContext->pbCtlEncoded, pCtlContext->cbCtlEncoded,
543 CERT_CTL_PROP_ID, pCTLInterface, dwFlags, TRUE, pbElement, pcbElement);
544}
545
546typedef BOOL (*SerializedOutputFunc)(void *handle, const void *buffer,
547 DWORD size);
548
549static BOOL CRYPT_SerializeContextsToStream(SerializedOutputFunc output,
550 void *handle, const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE store)
551{
552 const void *context = NULL;
553 BOOL ret;
554
555 do {
556 context = contextInterface->enumContextsInStore(store, context);
557 if (context)
558 {
559 DWORD size = 0;
560 LPBYTE buf = NULL;
561
562 ret = contextInterface->serialize(context, 0, NULL, &size);
563 if (size)
564 buf = CryptMemAlloc(size);
565 if (buf)
566 {
567 ret = contextInterface->serialize(context, 0, buf, &size);
568 if (ret)
569 ret = output(handle, buf, size);
570 }
571 CryptMemFree(buf);
572 }
573 else
574 ret = TRUE;
575 } while (ret && context != NULL);
576 if (context)
577 contextInterface->confree(context);
578 return ret;
579}
580
581static BOOL CRYPT_WriteSerializedStoreToStream(HCERTSTORE store,
582 SerializedOutputFunc output, void *handle)
583{
584 static const BYTE fileTrailer[12] = { 0 };
585 WINE_CONTEXT_INTERFACE interface;
586 BOOL ret;
587
588 ret = output(handle, fileHeader, sizeof(fileHeader));
589 if (ret)
590 {
591 memcpy(&interface, pCertInterface, sizeof(interface));
592 interface.serialize = (SerializeElementFunc)CRYPT_SerializeCertNoHash;
593 ret = CRYPT_SerializeContextsToStream(output, handle, &interface,
594 store);
595 }
596 if (ret)
597 {
598 memcpy(&interface, pCRLInterface, sizeof(interface));
599 interface.serialize = (SerializeElementFunc)CRYPT_SerializeCRLNoHash;
600 ret = CRYPT_SerializeContextsToStream(output, handle, &interface,
601 store);
602 }
603 if (ret)
604 {
605 memcpy(&interface, pCTLInterface, sizeof(interface));
606 interface.serialize = (SerializeElementFunc)CRYPT_SerializeCTLNoHash;
607 ret = CRYPT_SerializeContextsToStream(output, handle, &interface,
608 store);
609 }
610 if (ret)
611 ret = output(handle, fileTrailer, sizeof(fileTrailer));
612 return ret;
613}
614
615static BOOL CRYPT_FileOutputFunc(void *handle, const void *buffer, DWORD size)
616{
617 return WriteFile(handle, buffer, size, &size, NULL);
618}
619
620static BOOL CRYPT_WriteSerializedStoreToFile(HANDLE file, HCERTSTORE store)
621{
622 SetFilePointer(file, 0, NULL, FILE_BEGIN);
623 return CRYPT_WriteSerializedStoreToStream(store, CRYPT_FileOutputFunc,
624 file);
625}
626
627static BOOL CRYPT_SavePKCSToMem(HCERTSTORE store,
628 DWORD dwMsgAndCertEncodingType, void *handle)
629{
630 CERT_BLOB *blob = (CERT_BLOB *)handle;
631 CRYPT_SIGNED_INFO signedInfo = { 0 };
632 PCCERT_CONTEXT cert = NULL;
633 PCCRL_CONTEXT crl = NULL;
634 DWORD size;
635 BOOL ret = TRUE;
636
637 TRACE("(%d, %p)\n", blob->pbData ? blob->cbData : 0, blob->pbData);
638
639 do {
640 cert = CertEnumCertificatesInStore(store, cert);
641 if (cert)
642 signedInfo.cCertEncoded++;
643 } while (cert);
644 if (signedInfo.cCertEncoded)
645 {
646 signedInfo.rgCertEncoded = CryptMemAlloc(
647 signedInfo.cCertEncoded * sizeof(CERT_BLOB));
648 if (!signedInfo.rgCertEncoded)
649 {
650 SetLastError(ERROR_OUTOFMEMORY);
651 ret = FALSE;
652 }
653 else
654 {
655 DWORD i = 0;
656
657 do {
658 cert = CertEnumCertificatesInStore(store, cert);
659 if (cert)
660 {
661 signedInfo.rgCertEncoded[i].cbData = cert->cbCertEncoded;
662 signedInfo.rgCertEncoded[i].pbData = cert->pbCertEncoded;
663 i++;
664 }
665 } while (cert);
666 }
667 }
668
669 do {
670 crl = CertEnumCRLsInStore(store, crl);
671 if (crl)
672 signedInfo.cCrlEncoded++;
673 } while (crl);
674 if (signedInfo.cCrlEncoded)
675 {
676 signedInfo.rgCrlEncoded = CryptMemAlloc(
677 signedInfo.cCrlEncoded * sizeof(CERT_BLOB));
678 if (!signedInfo.rgCrlEncoded)
679 {
680 SetLastError(ERROR_OUTOFMEMORY);
681 ret = FALSE;
682 }
683 else
684 {
685 DWORD i = 0;
686
687 do {
688 crl = CertEnumCRLsInStore(store, crl);
689 if (crl)
690 {
691 signedInfo.rgCrlEncoded[i].cbData = crl->cbCrlEncoded;
692 signedInfo.rgCrlEncoded[i].pbData = crl->pbCrlEncoded;
693 i++;
694 }
695 } while (crl);
696 }
697 }
698 if (ret)
699 {
700 ret = CRYPT_AsnEncodeCMSSignedInfo(&signedInfo, NULL, &size);
701 if (ret)
702 {
703 if (!blob->pbData)
704 blob->cbData = size;
705 else if (blob->cbData < size)
706 {
707 blob->cbData = size;
708 SetLastError(ERROR_MORE_DATA);
709 ret = FALSE;
710 }
711 else
712 {
713 blob->cbData = size;
714 ret = CRYPT_AsnEncodeCMSSignedInfo(&signedInfo, blob->pbData,
715 &blob->cbData);
716 }
717 }
718 }
719 CryptMemFree(signedInfo.rgCertEncoded);
720 CryptMemFree(signedInfo.rgCrlEncoded);
721 TRACE("returning %d\n", ret);
722 return ret;
723}
724
725static BOOL CRYPT_SavePKCSToFile(HCERTSTORE store,
726 DWORD dwMsgAndCertEncodingType, void *handle)
727{
728 CERT_BLOB blob = { 0, NULL };
729 BOOL ret;
730
731 TRACE("(%p)\n", handle);
732
733 ret = CRYPT_SavePKCSToMem(store, dwMsgAndCertEncodingType, &blob);
734 if (ret)
735 {
736 blob.pbData = CryptMemAlloc(blob.cbData);
737 if (blob.pbData)
738 {
739 ret = CRYPT_SavePKCSToMem(store, dwMsgAndCertEncodingType, &blob);
740 if (ret)
741 ret = WriteFile(handle, blob.pbData, blob.cbData,
742 &blob.cbData, NULL);
743 }
744 else
745 {
746 SetLastError(ERROR_OUTOFMEMORY);
747 ret = FALSE;
748 }
749 }
750 TRACE("returning %d\n", ret);
751 return ret;
752}
753
754static BOOL CRYPT_SaveSerializedToFile(HCERTSTORE store,
755 DWORD dwMsgAndCertEncodingType, void *handle)
756{
757 return CRYPT_WriteSerializedStoreToFile(handle, store);
758}
759
760struct MemWrittenTracker
761{
762 DWORD cbData;
763 BYTE *pbData;
764 DWORD written;
765};
766
767/* handle is a pointer to a MemWrittenTracker. Assumes its pointer is valid. */
768static BOOL CRYPT_MemOutputFunc(void *handle, const void *buffer, DWORD size)
769{
770 struct MemWrittenTracker *tracker = (struct MemWrittenTracker *)handle;
771 BOOL ret;
772
773 if (tracker->written + size > tracker->cbData)
774 {
775 SetLastError(ERROR_MORE_DATA);
776 /* Update written so caller can notify its caller of the required size
777 */
778 tracker->written += size;
779 ret = FALSE;
780 }
781 else
782 {
783 memcpy(tracker->pbData + tracker->written, buffer, size);
784 tracker->written += size;
785 ret = TRUE;
786 }
787 return ret;
788}
789
790static BOOL CRYPT_CountSerializedBytes(void *handle, const void *buffer,
791 DWORD size)
792{
793 *(DWORD *)handle += size;
794 return TRUE;
795}
796
797static BOOL CRYPT_SaveSerializedToMem(HCERTSTORE store,
798 DWORD dwMsgAndCertEncodingType, void *handle)
799{
800 CERT_BLOB *blob = (CERT_BLOB *)handle;
801 DWORD size = 0;
802 BOOL ret;
803
804 ret = CRYPT_WriteSerializedStoreToStream(store, CRYPT_CountSerializedBytes,
805 &size);
806 if (ret)
807 {
808 if (!blob->pbData)
809 blob->cbData = size;
810 else if (blob->cbData < size)
811 {
812 SetLastError(ERROR_MORE_DATA);
813 blob->cbData = size;
814 ret = FALSE;
815 }
816 else
817 {
818 struct MemWrittenTracker tracker = { blob->cbData, blob->pbData,
819 0 };
820
821 ret = CRYPT_WriteSerializedStoreToStream(store, CRYPT_MemOutputFunc,
822 &tracker);
823 if (!ret && GetLastError() == ERROR_MORE_DATA)
824 blob->cbData = tracker.written;
825 }
826 }
827 TRACE("returning %d\n", ret);
828 return ret;
829}
830
831BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
832 DWORD dwSaveAs, DWORD dwSaveTo, void *pvSaveToPara, DWORD dwFlags)
833{
834 BOOL (*saveFunc)(HCERTSTORE, DWORD, void *);
835 void *handle;
836 BOOL ret;
837
838 TRACE("(%p, %08x, %d, %d, %p, %08x)\n", hCertStore,
839 dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
840
841 switch (dwSaveAs)
842 {
843 case CERT_STORE_SAVE_AS_STORE:
844 case CERT_STORE_SAVE_AS_PKCS7:
845 break;
846 default:
847 WARN("unimplemented for %d\n", dwSaveAs);
848 SetLastError(ERROR_INVALID_PARAMETER);
849 return FALSE;
850 }
851 switch (dwSaveTo)
852 {
853 case CERT_STORE_SAVE_TO_FILE:
854 handle = pvSaveToPara;
855 saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
856 CRYPT_SaveSerializedToFile : CRYPT_SavePKCSToFile;
857 break;
858 case CERT_STORE_SAVE_TO_FILENAME_A:
859 handle = CreateFileA((LPCSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
860 CREATE_ALWAYS, 0, NULL);
861 saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
862 CRYPT_SaveSerializedToFile : CRYPT_SavePKCSToFile;
863 break;
864 case CERT_STORE_SAVE_TO_FILENAME_W:
865 handle = CreateFileW((LPCWSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
866 CREATE_ALWAYS, 0, NULL);
867 saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
868 CRYPT_SaveSerializedToFile : CRYPT_SavePKCSToFile;
869 break;
870 case CERT_STORE_SAVE_TO_MEMORY:
871 handle = pvSaveToPara;
872 saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
873 CRYPT_SaveSerializedToMem : CRYPT_SavePKCSToMem;
874 break;
875 default:
876 WARN("unimplemented for %d\n", dwSaveTo);
877 SetLastError(ERROR_INVALID_PARAMETER);
878 return FALSE;
879 }
880 ret = saveFunc(hCertStore, dwMsgAndCertEncodingType, handle);
881 TRACE("returning %d\n", ret);
882 return ret;
883}
884
885BOOL WINAPI CertAddSerializedElementToStore(HCERTSTORE hCertStore,
886 const BYTE *pbElement, DWORD cbElement, DWORD dwAddDisposition, DWORD dwFlags,
887 DWORD dwContextTypeFlags, DWORD *pdwContentType, const void **ppvContext)
888{
889 const void *context;
890 DWORD type;
891 BOOL ret;
892
893 TRACE("(%p, %p, %d, %08x, %08x, %08x, %p, %p)\n", hCertStore,
894 pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags,
895 pdwContentType, ppvContext);
896
897 /* Call the internal function, then delete the hashes. Tests show this
898 * function uses real hash values, not whatever's stored in the hash
899 * property.
900 */
901 context = CRYPT_ReadSerializedElement(pbElement, cbElement,
902 dwContextTypeFlags, &type);
903 if (context)
904 {
905 const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
906
907 switch (type)
908 {
909 case CERT_STORE_CERTIFICATE_CONTEXT:
910 contextInterface = pCertInterface;
911 break;
912 case CERT_STORE_CRL_CONTEXT:
913 contextInterface = pCRLInterface;
914 break;
915 case CERT_STORE_CTL_CONTEXT:
916 contextInterface = pCTLInterface;
917 break;
918 default:
919 SetLastError(E_INVALIDARG);
920 }
921 if (contextInterface)
922 {
923 contextInterface->setProp(context, CERT_HASH_PROP_ID, 0, NULL);
924 contextInterface->setProp(context, CERT_MD5_HASH_PROP_ID, 0, NULL);
925 contextInterface->setProp(context, CERT_SIGNATURE_HASH_PROP_ID, 0,
926 NULL);
927 if (pdwContentType)
928 *pdwContentType = type;
929 ret = contextInterface->addContextToStore(hCertStore, context,
930 dwAddDisposition, ppvContext);
931 contextInterface->confree(context);
932 }
933 else
934 ret = FALSE;
935 }
936 else
937 ret = FALSE;
938 return ret;
939}
Note: See TracBrowser for help on using the repository browser.