ReactOS 0.4.15-dev-5666-gc548b97
store.c
Go to the documentation of this file.
1/*
2 * Copyright 2002 Mike McCormack for CodeWeavers
3 * Copyright 2004-2006 Juan Lang
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 * FIXME:
20 * - The concept of physical stores and locations isn't implemented. (This
21 * doesn't mean registry stores et al aren't implemented. See the PSDK for
22 * registering and enumerating physical stores and locations.)
23 * - Many flags, options and whatnot are unimplemented.
24 */
25
26#include "config.h"
27#include "wine/port.h"
28
29#include <assert.h>
30#include <stdarg.h>
31#include "windef.h"
32#include "winbase.h"
33#include "winnls.h"
34#include "winreg.h"
35#include "winuser.h"
36#include "wincrypt.h"
37#include "wine/debug.h"
38#include "wine/exception.h"
39#include "crypt32_private.h"
40
42
53};
55
66};
68
79};
81
82typedef struct _WINE_MEMSTORE
83{
86 struct list certs;
87 struct list crls;
88 struct list ctls;
90
92{
93 store->ref = 1;
95 store->type = type;
96 store->dwOpenFlags = dwFlags;
97 store->vtbl = vtbl;
98 store->properties = NULL;
99}
100
102{
103 if (store->properties)
105 store->dwMagic = 0;
106 CryptMemFree(store);
107}
108
110 DWORD unk1)
111{
112 static BOOL warned = FALSE;
113 const WINE_CONTEXT_INTERFACE * const interfaces[] = { pCertInterface,
115 DWORD i;
116
117 TRACE("(%p, %p, %08x, %08x)\n", store1, store2, unk0, unk1);
118 if (!warned)
119 {
120 FIXME("semi-stub\n");
121 warned = TRUE;
122 }
123
124 /* Poor-man's resync: empty first store, then add everything from second
125 * store to it.
126 */
127 for (i = 0; i < ARRAY_SIZE(interfaces); i++)
128 {
129 const void *context;
130
131 do {
132 context = interfaces[i]->enumContextsInStore(store1, NULL);
133 if (context)
134 interfaces[i]->deleteFromStore(context);
135 } while (context);
136 do {
137 context = interfaces[i]->enumContextsInStore(store2, context);
138 if (context)
139 interfaces[i]->addContextToStore(store1, context,
141 } while (context);
142 }
143 return TRUE;
144}
145
146static BOOL MemStore_addContext(WINE_MEMSTORE *store, struct list *list, context_t *orig_context,
147 context_t *existing, context_t **ret_context, BOOL use_link)
148{
150
151 context = orig_context->vtbl->clone(orig_context, &store->hdr, use_link);
152 if (!context)
153 return FALSE;
154
155 TRACE("adding %p\n", context);
156 EnterCriticalSection(&store->cs);
157 if (existing) {
158 context->u.entry.prev = existing->u.entry.prev;
159 context->u.entry.next = existing->u.entry.next;
160 context->u.entry.prev->next = &context->u.entry;
161 context->u.entry.next->prev = &context->u.entry;
162 list_init(&existing->u.entry);
163 if(!existing->ref)
164 Context_Release(existing);
165 }else {
166 list_add_head(list, &context->u.entry);
167 }
168 LeaveCriticalSection(&store->cs);
169
170 if(ret_context)
171 *ret_context = context;
172 else
174 return TRUE;
175}
176
178{
179 struct list *next;
180 context_t *ret;
181
182 EnterCriticalSection(&store->cs);
183 if (prev) {
184 next = list_next(list, &prev->u.entry);
185 Context_Release(prev);
186 }else {
188 }
189 LeaveCriticalSection(&store->cs);
190
191 if (!next) {
193 return NULL;
194 }
195
196 ret = LIST_ENTRY(next, context_t, u.entry);
198 return ret;
199}
200
202{
203 BOOL in_list = FALSE;
204
205 EnterCriticalSection(&store->cs);
206 if (!list_empty(&context->u.entry)) {
207 list_remove(&context->u.entry);
208 list_init(&context->u.entry);
209 in_list = TRUE;
210 }
211 LeaveCriticalSection(&store->cs);
212
213 if(in_list && !context->ref)
215 return TRUE;
216}
217
218static void free_contexts(struct list *list)
219{
221
223 {
224 TRACE("freeing %p\n", context);
225 list_remove(&context->u.entry);
227 }
228}
229
231{
232 /* Free the context only if it's not in a list. Otherwise it may be reused later. */
233 if(list_empty(&context->u.entry))
235}
236
238 context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
239{
240 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
241
242 TRACE("(%p, %p, %p, %p)\n", store, cert, toReplace, ppStoreContext);
243 return MemStore_addContext(ms, &ms->certs, cert, toReplace, ppStoreContext, use_link);
244}
245
247{
248 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
249
250 TRACE("(%p, %p)\n", store, prev);
251
252 return MemStore_enumContext(ms, &ms->certs, prev);
253}
254
256{
257 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
258
259 TRACE("(%p, %p)\n", store, context);
260
262}
263
265 context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
266{
267 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
268
269 TRACE("(%p, %p, %p, %p)\n", store, crl, toReplace, ppStoreContext);
270
271 return MemStore_addContext(ms, &ms->crls, crl, toReplace, ppStoreContext, use_link);
272}
273
275{
276 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
277
278 TRACE("(%p, %p)\n", store, prev);
279
280 return MemStore_enumContext(ms, &ms->crls, prev);
281}
282
284{
285 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
286
287 TRACE("(%p, %p)\n", store, context);
288
290}
291
293 context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
294{
295 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
296
297 TRACE("(%p, %p, %p, %p)\n", store, ctl, toReplace, ppStoreContext);
298
299 return MemStore_addContext(ms, &ms->ctls, ctl, toReplace, ppStoreContext, use_link);
300}
301
303{
304 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
305
306 TRACE("(%p, %p)\n", store, prev);
307
308 return MemStore_enumContext(ms, &ms->ctls, prev);
309}
310
312{
313 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
314
315 TRACE("(%p, %p)\n", store, context);
316
318}
319
321{
322 LONG ref = InterlockedIncrement(&store->ref);
323 TRACE("ref = %d\n", ref);
324}
325
327{
329 LONG ref;
330
332 FIXME("Unimplemented flags %x\n", flags);
333
334 ref = InterlockedDecrement(&store->hdr.ref);
335 TRACE("(%p) ref=%d\n", store, ref);
336 if(ref)
338
339 free_contexts(&store->certs);
340 free_contexts(&store->crls);
341 free_contexts(&store->ctls);
342 store->cs.DebugInfo->Spare[0] = 0;
343 DeleteCriticalSection(&store->cs);
344 CRYPT_FreeStore(&store->hdr);
345 return ERROR_SUCCESS;
346}
347
349 DWORD dwCtrlType, void const *pvCtrlPara)
350{
352 return FALSE;
353}
354
360 {
364 }, {
368 }, {
372 }
373};
374
376 DWORD dwFlags, const void *pvPara)
377{
378 WINE_MEMSTORE *store;
379
380 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
381
383 {
385 store = NULL;
386 }
387 else
388 {
389 store = CryptMemAlloc(sizeof(WINE_MEMSTORE));
390 if (store)
391 {
392 memset(store, 0, sizeof(WINE_MEMSTORE));
395 store->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ContextList.cs");
396 list_init(&store->certs);
397 list_init(&store->crls);
398 list_init(&store->ctls);
399 /* Mem store doesn't need crypto provider, so close it */
400 if (hCryptProv && !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
401 CryptReleaseContext(hCryptProv, 0);
402 }
403 }
404 return (WINECRYPT_CERTSTORE*)store;
405}
406
407static const WCHAR rootW[] = { 'R','o','o','t',0 };
408
410 DWORD dwFlags, const void *pvPara)
411{
412 static const WCHAR fmt[] = { '%','s','\\','%','s',0 };
413 LPCWSTR storeName = pvPara;
414 LPWSTR storePath;
415 WINECRYPT_CERTSTORE *store = NULL;
416 HKEY root;
418
419 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
421
422 if (!pvPara)
423 {
425 return NULL;
426 }
427
429 {
433 /* If the HKLM\Root certs are requested, expressing system certs into the registry */
434 if (!lstrcmpiW(storeName, rootW))
436 break;
440 break;
442 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
443 * SystemCertificates
444 */
445 FIXME("CERT_SYSTEM_STORE_CURRENT_SERVICE, %s: stub\n",
446 debugstr_w(storeName));
447 return NULL;
449 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
450 * SystemCertificates
451 */
452 FIXME("CERT_SYSTEM_STORE_SERVICES, %s: stub\n",
453 debugstr_w(storeName));
454 return NULL;
456 /* hku\user sid\Software\Microsoft\SystemCertificates */
457 FIXME("CERT_SYSTEM_STORE_USERS, %s: stub\n",
458 debugstr_w(storeName));
459 return NULL;
463 break;
467 break;
469 /* hklm\Software\Microsoft\EnterpriseCertificates */
470 FIXME("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE, %s: stub\n",
471 debugstr_w(storeName));
472 return NULL;
473 default:
475 return NULL;
476 }
477
478 storePath = CryptMemAlloc((lstrlenW(base) + lstrlenW(storeName) + 2) *
479 sizeof(WCHAR));
480 if (storePath)
481 {
482 LONG rc;
483 HKEY key;
486
487 wsprintfW(storePath, fmt, base, storeName);
489 rc = RegOpenKeyExW(root, storePath, 0, sam, &key);
490 else
491 {
492 DWORD disp;
493
494 rc = RegCreateKeyExW(root, storePath, 0, NULL, 0, sam, NULL,
495 &key, &disp);
496 if (!rc && dwFlags & CERT_STORE_CREATE_NEW_FLAG &&
498 {
501 }
502 }
503 if (!rc)
504 {
505 store = CRYPT_RegOpenStore(hCryptProv, dwFlags, key);
507 }
508 else
509 SetLastError(rc);
510 CryptMemFree(storePath);
511 }
512 return store;
513}
514
516 DWORD dwFlags, const void *pvPara)
517{
518 int len;
520
521 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
523
524 if (!pvPara)
525 {
527 return NULL;
528 }
530 if (len)
531 {
532 LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
533
534 if (storeName)
535 {
536 MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
537 ret = CRYPT_SysRegOpenStoreW(hCryptProv, dwFlags, storeName);
538 CryptMemFree(storeName);
539 }
540 }
541 return ret;
542}
543
545 DWORD dwFlags, const void *pvPara)
546{
547 HCERTSTORE store = 0;
548 BOOL ret;
549
550 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
552
553 if (!pvPara)
554 {
556 return NULL;
557 }
558 /* This returns a different error than system registry stores if the
559 * location is invalid.
560 */
562 {
571 ret = TRUE;
572 break;
573 default:
575 ret = FALSE;
576 }
577 if (ret)
578 {
580 0, 0, dwFlags, pvPara);
581
582 if (regStore)
583 {
586 CertAddStoreToCollection(store, regStore,
589 CertCloseStore(regStore, 0);
590 /* CERT_SYSTEM_STORE_CURRENT_USER returns both the HKCU and HKLM
591 * stores.
592 */
595 {
596 dwFlags &= ~CERT_SYSTEM_STORE_CURRENT_USER;
599 0, dwFlags, pvPara);
600 if (regStore)
601 {
602 CertAddStoreToCollection(store, regStore,
605 CertCloseStore(regStore, 0);
606 }
607 }
608 /* System store doesn't need crypto provider, so close it */
609 if (hCryptProv && !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
610 CryptReleaseContext(hCryptProv, 0);
611 }
612 }
613 return store;
614}
615
617 DWORD dwFlags, const void *pvPara)
618{
619 int len;
621
622 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
624
625 if (!pvPara)
626 {
628 return NULL;
629 }
631 if (len)
632 {
633 LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
634
635 if (storeName)
636 {
637 MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
638 ret = CRYPT_SysOpenStoreW(hCryptProv, dwFlags, storeName);
639 CryptMemFree(storeName);
640 }
641 }
642 return ret;
643}
644
646{
647 HCRYPTMSG msg = hCertStore;
648
649 TRACE("(%p, %08x)\n", msg, dwFlags);
651}
652
653static void *msgProvFuncs[] = {
655};
656
658 DWORD dwFlags, const void *pvPara)
659{
660 WINECRYPT_CERTSTORE *store = NULL;
662 WINECRYPT_CERTSTORE *memStore;
663
664 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
665
666 memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
668 if (memStore)
669 {
670 BOOL ret;
671 DWORD size, count, i;
672
673 size = sizeof(count);
675 for (i = 0; ret && i < count; i++)
676 {
677 size = 0;
679 if (ret)
680 {
682
683 if (buf)
684 {
686 if (ret)
689 NULL);
691 }
692 }
693 }
694 size = sizeof(count);
696 for (i = 0; ret && i < count; i++)
697 {
698 size = 0;
700 if (ret)
701 {
703
704 if (buf)
705 {
707 if (ret)
708 ret = CertAddEncodedCRLToStore(memStore,
710 NULL);
712 }
713 }
714 }
715 if (ret)
716 {
717 CERT_STORE_PROV_INFO provInfo = { 0 };
718
719 provInfo.cbSize = sizeof(provInfo);
722 provInfo.hStoreProv = CryptMsgDuplicate(msg);
723 store = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
724 /* Msg store doesn't need crypto provider, so close it */
725 if (hCryptProv && !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
726 CryptReleaseContext(hCryptProv, 0);
727 }
728 else
729 CertCloseStore(memStore, 0);
730 }
731 TRACE("returning %p\n", store);
732 return store;
733}
734
736 DWORD dwFlags, const void *pvPara)
737{
739 WINECRYPT_CERTSTORE *store = NULL;
740 const CRYPT_DATA_BLOB *data = pvPara;
741 BOOL ret;
742 DWORD msgOpenFlags = dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG ? 0 :
744
745 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
746
748 hCryptProv, NULL, NULL);
749 ret = CryptMsgUpdate(msg, data->pbData, data->cbData, TRUE);
750 if (!ret)
751 {
754 hCryptProv, NULL, NULL);
755 ret = CryptMsgUpdate(msg, data->pbData, data->cbData, TRUE);
756 if (ret)
757 {
758 DWORD type, size = sizeof(type);
759
760 /* Only signed messages are allowed, check type */
762 if (ret && type != CMSG_SIGNED)
763 {
765 ret = FALSE;
766 }
767 }
768 }
769 if (ret)
770 store = CRYPT_MsgOpenStore(0, dwFlags, msg);
772 TRACE("returning %p\n", store);
773 return store;
774}
775
777 DWORD dwFlags, const void *pvPara)
778{
779 HCERTSTORE store;
780 const CRYPT_DATA_BLOB *data = pvPara;
781
782 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
783
785 {
787 return NULL;
788 }
789
792 if (store)
793 {
795 {
796 CertCloseStore(store, 0);
797 store = NULL;
798 }
799 }
800 TRACE("returning %p\n", store);
801 return (WINECRYPT_CERTSTORE*)store;
802}
803
805 DWORD dwFlags, const void *pvPara)
806{
808 FIXME("(%ld, %08x, %p): stub\n", hCryptProv, dwFlags, pvPara);
809 else
810 FIXME("(%ld, %08x, %s): stub\n", hCryptProv, dwFlags,
812 return NULL;
813}
814
817 const void* pvPara)
818{
820 StoreOpenFunc openFunc = NULL;
821
822 TRACE("(%s, %08x, %08lx, %08x, %p)\n", debugstr_a(lpszStoreProvider),
824
825 if (IS_INTOID(lpszStoreProvider))
826 {
827 switch (LOWORD(lpszStoreProvider))
828 {
830 openFunc = CRYPT_MsgOpenStore;
831 break;
833 openFunc = CRYPT_MemOpenStore;
834 break;
836 openFunc = CRYPT_FileOpenStore;
837 break;
839 openFunc = CRYPT_PKCSOpenStore;
840 break;
842 openFunc = CRYPT_SerializedOpenStore;
843 break;
845 openFunc = CRYPT_RegOpenStore;
846 break;
848 openFunc = CRYPT_FileNameOpenStoreA;
849 break;
851 openFunc = CRYPT_FileNameOpenStoreW;
852 break;
854 openFunc = CRYPT_CollectionOpenStore;
855 break;
857 openFunc = CRYPT_SysOpenStoreA;
858 break;
860 openFunc = CRYPT_SysOpenStoreW;
861 break;
863 openFunc = CRYPT_SysRegOpenStoreA;
864 break;
866 openFunc = CRYPT_SysRegOpenStoreW;
867 break;
869 openFunc = CRYPT_PhysOpenStoreW;
870 break;
871 default:
872 if (LOWORD(lpszStoreProvider))
873 FIXME("unimplemented type %d\n", LOWORD(lpszStoreProvider));
874 }
875 }
876 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_MEMORY))
877 openFunc = CRYPT_MemOpenStore;
878 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_FILENAME_W))
879 openFunc = CRYPT_FileOpenStore;
880 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SYSTEM))
881 openFunc = CRYPT_SysOpenStoreW;
882 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_PKCS7))
883 openFunc = CRYPT_PKCSOpenStore;
884 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SERIALIZED))
885 openFunc = CRYPT_SerializedOpenStore;
886 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_COLLECTION))
887 openFunc = CRYPT_CollectionOpenStore;
888 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SYSTEM_REGISTRY))
889 openFunc = CRYPT_SysRegOpenStoreW;
890 else
891 {
892 FIXME("unimplemented type %s\n", lpszStoreProvider);
893 openFunc = NULL;
894 }
895
896 if (!openFunc)
897 hcs = CRYPT_ProvOpenStore(lpszStoreProvider, dwMsgAndCertEncodingType,
898 hCryptProv, dwFlags, pvPara);
899 else
900 hcs = openFunc(hCryptProv, dwFlags, pvPara);
901 return hcs;
902}
903
905 LPCSTR szSubSystemProtocol)
906{
907 if (!szSubSystemProtocol)
908 {
910 return 0;
911 }
913 CERT_SYSTEM_STORE_CURRENT_USER, szSubSystemProtocol);
914}
915
917 LPCWSTR szSubSystemProtocol)
918{
919 if (!szSubSystemProtocol)
920 {
922 return 0;
923 }
925 CERT_SYSTEM_STORE_CURRENT_USER, szSubSystemProtocol);
926}
927
929{
930 cert_t *prev = pPrev ? cert_from_ptr(pPrev) : NULL, *ret;
931 WINECRYPT_CERTSTORE *hcs = hCertStore;
932
933 TRACE("(%p, %p)\n", hCertStore, pPrev);
934 if (!hCertStore)
935 ret = NULL;
936 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
937 ret = NULL;
938 else
939 ret = (cert_t*)hcs->vtbl->certs.enumContext(hcs, prev ? &prev->base : NULL);
940 return ret ? &ret->ctx : NULL;
941}
942
944{
946
947 TRACE("(%p)\n", pCertContext);
948
949 if (!pCertContext)
950 return TRUE;
951
953
955 return FALSE;
956
957 return hcs->vtbl->certs.delete(hcs, &cert_from_ptr(pCertContext)->base);
958}
959
963{
964 WINECRYPT_CERTSTORE *store = hCertStore;
965 BOOL ret = TRUE;
966 PCCRL_CONTEXT toAdd = NULL, existing = NULL;
967
968 TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCrlContext,
970
971 /* Weird case to pass a test */
972 if (dwAddDisposition == 0)
973 {
975 return FALSE;
976 }
978 {
979 existing = CertFindCRLInStore(hCertStore, 0, 0, CRL_FIND_EXISTING,
981 }
982
983 switch (dwAddDisposition)
984 {
987 break;
989 if (existing)
990 {
991 TRACE("found matching CRL, not adding\n");
993 ret = FALSE;
994 }
995 else
997 break;
999 if (existing)
1000 {
1001 LONG newer = CompareFileTime(&existing->pCrlInfo->ThisUpdate,
1003
1004 if (newer < 0)
1006 else
1007 {
1008 TRACE("existing CRL is newer, not adding\n");
1010 ret = FALSE;
1011 }
1012 }
1013 else
1015 break;
1017 if (existing)
1018 {
1019 LONG newer = CompareFileTime(&existing->pCrlInfo->ThisUpdate,
1021
1022 if (newer < 0)
1023 {
1025 Context_CopyProperties(toAdd, existing);
1026 }
1027 else
1028 {
1029 TRACE("existing CRL is newer, not adding\n");
1031 ret = FALSE;
1032 }
1033 }
1034 else
1036 break;
1039 break;
1042 if (existing)
1043 Context_CopyProperties(toAdd, existing);
1044 break;
1046 if (existing)
1047 {
1049 if (ppStoreContext)
1051 }
1052 else
1054 break;
1055 default:
1056 FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
1057 ret = FALSE;
1058 }
1059
1060 if (toAdd)
1061 {
1062 if (store) {
1063 context_t *ret_context;
1064 ret = store->vtbl->crls.addContext(store, context_from_ptr(toAdd),
1065 existing ? context_from_ptr(existing) : NULL, ppStoreContext ? &ret_context : NULL, FALSE);
1066 if (ret && ppStoreContext)
1067 *ppStoreContext = context_ptr(ret_context);
1068 }else if (ppStoreContext) {
1070 }
1071 CertFreeCRLContext(toAdd);
1072 }
1073 if (existing)
1074 CertFreeCRLContext(existing);
1075
1076 TRACE("returning %d\n", ret);
1077 return ret;
1078}
1079
1081{
1083 BOOL ret;
1084
1085 TRACE("(%p)\n", pCrlContext);
1086
1087 if (!pCrlContext)
1088 return TRUE;
1089
1090 hcs = pCrlContext->hCertStore;
1091
1093 return FALSE;
1094
1095 ret = hcs->vtbl->crls.delete(hcs, &crl_from_ptr(pCrlContext)->base);
1096 if (ret)
1098 return ret;
1099}
1100
1102{
1103 crl_t *ret, *prev = pPrev ? crl_from_ptr(pPrev) : NULL;
1104 WINECRYPT_CERTSTORE *hcs = hCertStore;
1105
1106 TRACE("(%p, %p)\n", hCertStore, pPrev);
1107 if (!hCertStore)
1108 ret = NULL;
1109 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
1110 ret = NULL;
1111 else
1112 ret = (crl_t*)hcs->vtbl->crls.enumContext(hcs, prev ? &prev->base : NULL);
1113 return ret ? &ret->ctx : NULL;
1114}
1115
1117{
1118 WINECRYPT_CERTSTORE *hcs = hCertStore;
1119
1120 TRACE("(%p)\n", hCertStore);
1121
1122 if (hcs && hcs->dwMagic == WINE_CRYPTCERTSTORE_MAGIC)
1123 hcs->vtbl->addref(hcs);
1124 return hCertStore;
1125}
1126
1128{
1129 WINECRYPT_CERTSTORE *hcs = hCertStore;
1130 DWORD res;
1131
1132 TRACE("(%p, %08x)\n", hCertStore, dwFlags);
1133
1134 if( ! hCertStore )
1135 return TRUE;
1136
1137 if ( hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC )
1138 return FALSE;
1139
1140 res = hcs->vtbl->release(hcs, dwFlags);
1141 if (res != ERROR_SUCCESS) {
1143 return FALSE;
1144 }
1145
1146 return TRUE;
1147}
1148
1150 DWORD dwCtrlType, void const *pvCtrlPara)
1151{
1152 WINECRYPT_CERTSTORE *hcs = hCertStore;
1153 BOOL ret;
1154
1155 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
1156 pvCtrlPara);
1157
1158 if (!hcs)
1159 ret = FALSE;
1160 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
1161 ret = FALSE;
1162 else
1163 {
1164 if (hcs->vtbl->control)
1165 ret = hcs->vtbl->control(hcs, dwFlags, dwCtrlType, pvCtrlPara);
1166 else
1167 ret = TRUE;
1168 }
1169 return ret;
1170}
1171
1173 void *pvData, DWORD *pcbData)
1174{
1175 WINECRYPT_CERTSTORE *store = hCertStore;
1176 BOOL ret = FALSE;
1177
1178 TRACE("(%p, %d, %p, %p)\n", hCertStore, dwPropId, pvData, pcbData);
1179
1180 switch (dwPropId)
1181 {
1183 if (!pvData)
1184 {
1185 *pcbData = sizeof(DWORD);
1186 ret = TRUE;
1187 }
1188 else if (*pcbData < sizeof(DWORD))
1189 {
1191 *pcbData = sizeof(DWORD);
1192 }
1193 else
1194 {
1195 DWORD state = 0;
1196
1197 if (store->type != StoreTypeMem &&
1200 *(DWORD *)pvData = state;
1201 ret = TRUE;
1202 }
1203 break;
1204 default:
1205 if (store->properties)
1206 {
1208
1210 &blob);
1211 if (ret)
1212 {
1213 if (!pvData)
1214 *pcbData = blob.cbData;
1215 else if (*pcbData < blob.cbData)
1216 {
1218 *pcbData = blob.cbData;
1219 ret = FALSE;
1220 }
1221 else
1222 {
1223 memcpy(pvData, blob.pbData, blob.cbData);
1224 *pcbData = blob.cbData;
1225 }
1226 }
1227 else
1229 }
1230 else
1232 }
1233 return ret;
1234}
1235
1237 DWORD dwFlags, const void *pvData)
1238{
1239 WINECRYPT_CERTSTORE *store = hCertStore;
1240 BOOL ret = FALSE;
1241
1242 TRACE("(%p, %d, %08x, %p)\n", hCertStore, dwPropId, dwFlags, pvData);
1243
1244 if (!store->properties)
1246 switch (dwPropId)
1247 {
1250 break;
1251 default:
1252 if (pvData)
1253 {
1254 const CRYPT_DATA_BLOB *blob = pvData;
1255
1257 blob->pbData, blob->cbData);
1258 }
1259 else
1260 {
1262 ret = TRUE;
1263 }
1264 }
1265 return ret;
1266}
1267
1269 void *pvSystemStoreLocationPara, HKEY *key)
1270{
1271 HKEY root;
1272 LPCWSTR base;
1273
1274 TRACE("(%08x, %p)\n", dwFlags, pvSystemStoreLocationPara);
1275
1277 {
1281 break;
1285 break;
1287 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
1288 * SystemCertificates
1289 */
1290 FIXME("CERT_SYSTEM_STORE_CURRENT_SERVICE\n");
1291 return ERROR_FILE_NOT_FOUND;
1293 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
1294 * SystemCertificates
1295 */
1296 FIXME("CERT_SYSTEM_STORE_SERVICES\n");
1297 return ERROR_FILE_NOT_FOUND;
1299 /* hku\user sid\Software\Microsoft\SystemCertificates */
1300 FIXME("CERT_SYSTEM_STORE_USERS\n");
1301 return ERROR_FILE_NOT_FOUND;
1305 break;
1309 break;
1311 /* hklm\Software\Microsoft\EnterpriseCertificates */
1312 FIXME("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE\n");
1313 return ERROR_FILE_NOT_FOUND;
1314 default:
1315 return ERROR_FILE_NOT_FOUND;
1316 }
1317
1318 return RegOpenKeyExW(root, base, 0, KEY_READ, key);
1319}
1320
1321BOOL WINAPI CertEnumSystemStore(DWORD dwFlags, void *pvSystemStoreLocationPara,
1322 void *pvArg, PFN_CERT_ENUM_SYSTEM_STORE pfnEnum)
1323{
1324 BOOL ret = FALSE;
1325 LONG rc;
1326 HKEY key;
1327 CERT_SYSTEM_STORE_INFO info = { sizeof(info) };
1328
1329 TRACE("(%08x, %p, %p, %p)\n", dwFlags, pvSystemStoreLocationPara, pvArg,
1330 pfnEnum);
1331
1332 rc = CRYPT_OpenParentStore(dwFlags, pvArg, &key);
1333 if (!rc)
1334 {
1335 DWORD index = 0;
1336
1337 ret = TRUE;
1338 do {
1341
1342 rc = RegEnumKeyExW(key, index++, name, &size, NULL, NULL, NULL,
1343 NULL);
1344 if (!rc)
1345 ret = pfnEnum(name, dwFlags, &info, NULL, pvArg);
1346 } while (ret && !rc);
1347 if (ret && rc != ERROR_NO_MORE_ITEMS)
1348 SetLastError(rc);
1349 }
1350 else
1351 SetLastError(rc);
1352 /* Include root store for the local machine location (it isn't in the
1353 * registry)
1354 */
1357 ret = pfnEnum(rootW, dwFlags, &info, NULL, pvArg);
1358 return ret;
1359}
1360
1361BOOL WINAPI CertEnumPhysicalStore(const void *pvSystemStore, DWORD dwFlags,
1362 void *pvArg, PFN_CERT_ENUM_PHYSICAL_STORE pfnEnum)
1363{
1365 FIXME("(%p, %08x, %p, %p): stub\n", pvSystemStore, dwFlags, pvArg,
1366 pfnEnum);
1367 else
1368 FIXME("(%s, %08x, %p, %p): stub\n", debugstr_w(pvSystemStore),
1369 dwFlags, pvArg,
1370 pfnEnum);
1371 return FALSE;
1372}
1373
1375 LPCWSTR pwszStoreName, PCERT_PHYSICAL_STORE_INFO pStoreInfo, void *pvReserved)
1376{
1378 FIXME("(%p, %08x, %s, %p, %p): stub\n", pvSystemStore, dwFlags,
1379 debugstr_w(pwszStoreName), pStoreInfo, pvReserved);
1380 else
1381 FIXME("(%s, %08x, %s, %p, %p): stub\n", debugstr_w(pvSystemStore),
1382 dwFlags, debugstr_w(pwszStoreName), pStoreInfo, pvReserved);
1383 return FALSE;
1384}
1385
1387 LPCWSTR pwszStoreName)
1388{
1389 FIXME("(%p, %08x, %s): stub\n", pvSystemStore, dwFlags, debugstr_w(pwszStoreName));
1390 return TRUE;
1391}
1392
1394 PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved)
1395{
1396 HCERTSTORE hstore;
1397
1399 {
1400 FIXME("(%p, %08x, %p, %p): flag not supported\n", pvSystemStore, dwFlags, pStoreInfo, pvReserved);
1401 return FALSE;
1402 }
1403
1404 TRACE("(%s, %08x, %p, %p)\n", debugstr_w(pvSystemStore), dwFlags, pStoreInfo, pvReserved);
1405
1406 hstore = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_W, 0, 0, dwFlags, pvSystemStore);
1407 if (hstore)
1408 {
1409 CertCloseStore(hstore, 0);
1410 return TRUE;
1411 }
1412
1413 return FALSE;
1414}
1415
1417{
1418 HCERTSTORE hstore;
1419
1421 {
1422 FIXME("(%p, %08x): flag not supported\n", pvSystemStore, dwFlags);
1423 return FALSE;
1424 }
1425 TRACE("(%s, %08x)\n", debugstr_w(pvSystemStore), dwFlags);
1426
1428 if (hstore == NULL)
1429 return FALSE;
1430
1432 if (hstore == NULL && GetLastError() == 0)
1433 return TRUE;
1434
1435 return FALSE;
1436}
1437
1439{
1440 TRACE("(%p)\n", store);
1441}
1442
1444{
1445 TRACE("(%p)\n", store);
1446 return E_UNEXPECTED;
1447}
1448
1450{
1452}
1453
1455 context_t *replace, context_t **ret_context, BOOL use_link)
1456{
1457 TRACE("(%p, %p, %p, %p)\n", store, context, replace, ret_context);
1458
1459 /* FIXME: We should clone the context */
1460 if(ret_context) {
1462 *ret_context = context;
1463 }
1464
1465 return TRUE;
1466}
1467
1469{
1470 TRACE("(%p, %p)\n", store, prev);
1471
1473 return NULL;
1474}
1475
1477{
1478 return TRUE;
1479}
1480
1481static BOOL EmptyStore_control(WINECRYPT_CERTSTORE *store, DWORD flags, DWORD ctrl_type, void const *ctrl_para)
1482{
1483 TRACE("()\n");
1484
1486 return FALSE;
1487}
1488
1494 {
1498 }, {
1502 }, {
1506 }
1507};
1508
1510
1512{
1514}
static int state
Definition: maze.c:121
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define msg(x)
Definition: auth_time.c:54
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
static REGSAM sam
Definition: query.c:143
void newer(int argc, const char *argv[])
Definition: cmds.c:2278
#define ARRAY_SIZE(a)
Definition: main.h:24
static void list_remove(struct list_entry *entry)
Definition: list.h:90
static int list_empty(struct list_entry *head)
Definition: list.h:58
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
static void list_init(struct list_entry *head)
Definition: list.h:51
#define FIXME(fmt,...)
Definition: debug.h:111
#define RegCloseKey(hKey)
Definition: registry.h:47
struct _root root
Definition: list.h:37
BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore, HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
WINECRYPT_CERTSTORE * CRYPT_CollectionOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
const void *(WINAPI * EnumContextsInStoreFunc)(HCERTSTORE hCertStore, const void *pPrevContext)
static void * context_ptr(context_t *context)
enum _CertStoreType CertStoreType
WINECRYPT_CERTSTORE * CRYPT_ProvOpenStore(LPCSTR lpszStoreProvider, DWORD dwEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN
Definition: provstore.c:375
BOOL(WINAPI * SerializeElementFunc)(const void *context, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
WINECRYPT_CERTSTORE * CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN
Definition: filestore.c:292
BOOL CRYPT_ReadSerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob, HCERTSTORE store) DECLSPEC_HIDDEN
Definition: serialize.c:578
void ContextPropertyList_Free(CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN
Definition: proplist.c:56
static crl_t * crl_from_ptr(const CRL_CONTEXT *ptr)
void CRYPT_ImportSystemRootCertsToReg(void) DECLSPEC_HIDDEN
Definition: rootstore.c:1044
BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN
Definition: proplist.c:72
struct WINE_CRYPTCERTSTORE *(* StoreOpenFunc)(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
#define WINE_CRYPTCERTSTORE_MAGIC
BOOL(WINAPI * AddContextToStoreFunc)(HCERTSTORE hCertStore, const void *context, DWORD dwAddDisposition, const void **ppStoreContext)
BOOL(WINAPI * GetContextPropertyFunc)(const void *context, DWORD dwPropID, void *pvData, DWORD *pcbData)
static context_t * context_from_ptr(const void *ptr)
BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN
Definition: proplist.c:95
WINECRYPT_CERTSTORE * CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN
Definition: filestore.c:383
BOOL(WINAPI * SetContextPropertyFunc)(const void *context, DWORD dwPropID, DWORD dwFlags, const void *pvData)
void ContextPropertyList_RemoveProperty(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN
Definition: proplist.c:149
@ StoreTypeEmpty
@ StoreTypeMem
static cert_t * cert_from_ptr(const CERT_CONTEXT *ptr)
WINECRYPT_CERTSTORE * CRYPT_ProvCreateStore(DWORD dwFlags, WINECRYPT_CERTSTORE *memStore, const CERT_STORE_PROV_INFO *pProvInfo) DECLSPEC_HIDDEN
Definition: provstore.c:307
WINECRYPT_CERTSTORE * CRYPT_FileOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN
Definition: filestore.c:242
const void *(WINAPI * CreateContextFunc)(DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)
BOOL(WINAPI * DeleteContextFunc)(const void *contex)
WINECRYPT_CERTSTORE * CRYPT_RegOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN
Definition: regstore.c:512
#define IS_INTOID(x)
DWORD(WINAPI * EnumPropertiesFunc)(const void *context, DWORD dwPropId)
CONTEXT_PROPERTY_LIST * ContextPropertyList_Create(void) DECLSPEC_HIDDEN
Definition: proplist.c:43
BOOL(WINAPI * AddEncodedContextToStoreFunc)(HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwAddDisposition, const void **ppContext)
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define E_INVALIDARG
Definition: ddrawi.h:101
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1091
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3356
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2527
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
BOOL WINAPI CertAddCertificateContextToStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pCertContext, DWORD dwAddDisposition, PCCERT_CONTEXT *ppStoreContext)
Definition: cert.c:286
PCCERT_CONTEXT WINAPI CertCreateCertificateContext(DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)
Definition: cert.c:316
BOOL WINAPI CertAddEncodedCertificateToStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded, DWORD dwAddDisposition, PCCERT_CONTEXT *ppCertContext)
Definition: cert.c:58
BOOL WINAPI CertSetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, DWORD dwFlags, const void *pvData)
Definition: cert.c:799
BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, void *pvData, DWORD *pcbData)
Definition: cert.c:551
DWORD WINAPI CertEnumCertificateContextProperties(PCCERT_CONTEXT pCertContext, DWORD dwPropId)
Definition: cert.c:380
void Context_AddRef(context_t *context)
Definition: context.c:78
void Context_Release(context_t *context)
Definition: context.c:106
void Context_Free(context_t *context)
Definition: context.c:90
void Context_CopyProperties(const void *to, const void *from)
Definition: context.c:123
BOOL WINAPI CertGetCRLContextProperty(PCCRL_CONTEXT pCRLContext, DWORD dwPropId, void *pvData, DWORD *pcbData)
Definition: crl.c:472
DWORD WINAPI CertEnumCRLContextProperties(PCCRL_CONTEXT pCRLContext, DWORD dwPropId)
Definition: crl.c:395
BOOL WINAPI CertFreeCRLContext(PCCRL_CONTEXT pCrlContext)
Definition: crl.c:386
BOOL WINAPI CertSetCRLContextProperty(PCCRL_CONTEXT pCRLContext, DWORD dwPropId, DWORD dwFlags, const void *pvData)
Definition: crl.c:566
PCCRL_CONTEXT WINAPI CertDuplicateCRLContext(PCCRL_CONTEXT pCrlContext)
Definition: crl.c:378
PCCRL_CONTEXT WINAPI CertFindCRLInStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, DWORD dwFindFlags, DWORD dwFindType, const void *pvFindPara, PCCRL_CONTEXT pPrevCrlContext)
Definition: crl.c:287
BOOL WINAPI CertAddEncodedCRLToStore(HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE *pbCrlEncoded, DWORD cbCrlEncoded, DWORD dwAddDisposition, PCCRL_CONTEXT *ppCrlContext)
Definition: crl.c:129
PCCRL_CONTEXT WINAPI CertCreateCRLContext(DWORD dwCertEncodingType, const BYTE *pbCrlEncoded, DWORD cbCrlEncoded)
Definition: crl.c:85
PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(HCERTSTORE hCertStore, PCCTL_CONTEXT pPrev)
Definition: ctl.c:200
PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded)
Definition: ctl.c:363
BOOL WINAPI CertDeleteCTLFromStore(PCCTL_CONTEXT pCtlContext)
Definition: ctl.c:341
BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext, DWORD dwPropId, DWORD dwFlags, const void *pvData)
Definition: ctl.c:685
DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext, DWORD dwPropId)
Definition: ctl.c:508
BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext, DWORD dwPropId, void *pvData, DWORD *pcbData)
Definition: ctl.c:590
BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded, DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext)
Definition: ctl.c:177
BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore, PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition, PCCTL_CONTEXT *ppStoreContext)
Definition: ctl.c:63
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo, PCMSG_STREAM_INFO pStreamInfo)
Definition: msg.c:3552
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:3616
HCRYPTMSG WINAPI CryptMsgDuplicate(HCRYPTMSG hCryptMsg)
Definition: msg.c:3584
BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
Definition: msg.c:3597
static context_t * EmptyStore_enum(WINECRYPT_CERTSTORE *store, context_t *prev)
Definition: store.c:1468
BOOL WINAPI CertAddCRLContextToStore(HCERTSTORE hCertStore, PCCRL_CONTEXT pCrlContext, DWORD dwAddDisposition, PCCRL_CONTEXT *ppStoreContext)
Definition: store.c:960
static WINECRYPT_CERTSTORE * CRYPT_SysOpenStoreW(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:544
static DWORD MemStore_release(WINECRYPT_CERTSTORE *cert_store, DWORD flags)
Definition: store.c:326
static WINECRYPT_CERTSTORE * CRYPT_PKCSOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:735
static void * msgProvFuncs[]
Definition: store.c:653
static WINECRYPT_CERTSTORE * CRYPT_SysRegOpenStoreW(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:409
static context_t * MemStore_enumCRL(WINECRYPT_CERTSTORE *store, context_t *prev)
Definition: store.c:274
BOOL WINAPI CertRegisterSystemStore(const void *pvSystemStore, DWORD dwFlags, PCERT_SYSTEM_STORE_INFO pStoreInfo, void *pvReserved)
Definition: store.c:1393
static void EmptyStore_addref(WINECRYPT_CERTSTORE *store)
Definition: store.c:1438
void CRYPT_InitStore(WINECRYPT_CERTSTORE *store, DWORD dwFlags, CertStoreType type, const store_vtbl_t *vtbl)
Definition: store.c:91
HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider, DWORD dwMsgAndCertEncodingType, HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:815
BOOL WINAPI I_CertUpdateStore(HCERTSTORE store1, HCERTSTORE store2, DWORD unk0, DWORD unk1)
Definition: store.c:109
static context_t * MemStore_enumContext(WINE_MEMSTORE *store, struct list *list, context_t *prev)
Definition: store.c:177
static WINECRYPT_CERTSTORE * CRYPT_SerializedOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:776
void CRYPT_FreeStore(WINECRYPT_CERTSTORE *store)
Definition: store.c:101
BOOL WINAPI CertSetStoreProperty(HCERTSTORE hCertStore, DWORD dwPropId, DWORD dwFlags, const void *pvData)
Definition: store.c:1236
static const WINE_CONTEXT_INTERFACE gCertInterface
Definition: store.c:43
static const store_vtbl_t MemStoreVtbl
Definition: store.c:355
static const store_vtbl_t EmptyStoreVtbl
Definition: store.c:1489
static DWORD EmptyStore_release(WINECRYPT_CERTSTORE *store, DWORD flags)
Definition: store.c:1443
static WINECRYPT_CERTSTORE * CRYPT_PhysOpenStoreW(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:804
static BOOL MemStore_addCTL(WINECRYPT_CERTSTORE *store, context_t *ctl, context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
Definition: store.c:292
static BOOL EmptyStore_add(WINECRYPT_CERTSTORE *store, context_t *context, context_t *replace, context_t **ret_context, BOOL use_link)
Definition: store.c:1454
BOOL WINAPI CertRegisterPhysicalStore(const void *pvSystemStore, DWORD dwFlags, LPCWSTR pwszStoreName, PCERT_PHYSICAL_STORE_INFO pStoreInfo, void *pvReserved)
Definition: store.c:1374
const WINE_CONTEXT_INTERFACE * pCTLInterface
Definition: store.c:80
BOOL WINAPI CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara)
Definition: store.c:1149
const WINE_CONTEXT_INTERFACE * pCertInterface
Definition: store.c:54
static WINECRYPT_CERTSTORE * CRYPT_MemOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:375
static BOOL MemStore_addCRL(WINECRYPT_CERTSTORE *store, context_t *crl, context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
Definition: store.c:264
static BOOL MemStore_deleteCRL(WINECRYPT_CERTSTORE *store, context_t *context)
Definition: store.c:283
static void MemStore_releaseContext(WINECRYPT_CERTSTORE *store, context_t *context)
Definition: store.c:230
struct _WINE_MEMSTORE WINE_MEMSTORE
BOOL WINAPI CertEnumPhysicalStore(const void *pvSystemStore, DWORD dwFlags, void *pvArg, PFN_CERT_ENUM_PHYSICAL_STORE pfnEnum)
Definition: store.c:1361
static WINECRYPT_CERTSTORE * CRYPT_SysOpenStoreA(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:616
HCERTSTORE WINAPI CertDuplicateStore(HCERTSTORE hCertStore)
Definition: store.c:1116
static WINECRYPT_CERTSTORE * CRYPT_SysRegOpenStoreA(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:515
static void WINAPI CRYPT_MsgCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:645
static void MemStore_addref(WINECRYPT_CERTSTORE *store)
Definition: store.c:320
BOOL WINAPI CertEnumSystemStore(DWORD dwFlags, void *pvSystemStoreLocationPara, void *pvArg, PFN_CERT_ENUM_SYSTEM_STORE pfnEnum)
Definition: store.c:1321
static BOOL MemStore_control(WINECRYPT_CERTSTORE *store, DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara)
Definition: store.c:348
BOOL WINAPI CertUnregisterPhysicalStore(const void *pvSystemStore, DWORD dwFlags, LPCWSTR pwszStoreName)
Definition: store.c:1386
static const WINE_CONTEXT_INTERFACE gCTLInterface
Definition: store.c:69
BOOL WINAPI CertDeleteCRLFromStore(PCCRL_CONTEXT pCrlContext)
Definition: store.c:1080
static BOOL EmptyStore_delete(WINECRYPT_CERTSTORE *store, context_t *context)
Definition: store.c:1476
BOOL WINAPI CertUnregisterSystemStore(const void *pvSystemStore, DWORD dwFlags)
Definition: store.c:1416
const WINE_CONTEXT_INTERFACE * pCRLInterface
Definition: store.c:67
static BOOL MemStore_deleteContext(WINE_MEMSTORE *store, context_t *context)
Definition: store.c:201
void init_empty_store(void)
Definition: store.c:1511
static BOOL MemStore_deleteCert(WINECRYPT_CERTSTORE *store, context_t *context)
Definition: store.c:255
static WINECRYPT_CERTSTORE * CRYPT_MsgOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
Definition: store.c:657
static context_t * MemStore_enumCert(WINECRYPT_CERTSTORE *store, context_t *prev)
Definition: store.c:246
static void free_contexts(struct list *list)
Definition: store.c:218
static const WCHAR rootW[]
Definition: store.c:407
static BOOL MemStore_deleteCTL(WINECRYPT_CERTSTORE *store, context_t *context)
Definition: store.c:311
static LONG CRYPT_OpenParentStore(DWORD dwFlags, void *pvSystemStoreLocationPara, HKEY *key)
Definition: store.c:1268
static BOOL MemStore_addCert(WINECRYPT_CERTSTORE *store, context_t *cert, context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
Definition: store.c:237
PCCRL_CONTEXT WINAPI CertEnumCRLsInStore(HCERTSTORE hCertStore, PCCRL_CONTEXT pPrev)
Definition: store.c:1101
static const WINE_CONTEXT_INTERFACE gCRLInterface
Definition: store.c:56
PCCERT_CONTEXT WINAPI CertEnumCertificatesInStore(HCERTSTORE hCertStore, PCCERT_CONTEXT pPrev)
Definition: store.c:928
HCERTSTORE WINAPI CertOpenSystemStoreA(HCRYPTPROV_LEGACY hProv, LPCSTR szSubSystemProtocol)
Definition: store.c:904
WINECRYPT_CERTSTORE empty_store
Definition: store.c:1509
static BOOL MemStore_addContext(WINE_MEMSTORE *store, struct list *list, context_t *orig_context, context_t *existing, context_t **ret_context, BOOL use_link)
Definition: store.c:146
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
Definition: store.c:1127
static void EmptyStore_releaseContext(WINECRYPT_CERTSTORE *store, context_t *context)
Definition: store.c:1449
BOOL WINAPI CertGetStoreProperty(HCERTSTORE hCertStore, DWORD dwPropId, void *pvData, DWORD *pcbData)
Definition: store.c:1172
static context_t * MemStore_enumCTL(WINECRYPT_CERTSTORE *store, context_t *prev)
Definition: store.c:302
static BOOL EmptyStore_control(WINECRYPT_CERTSTORE *store, DWORD flags, DWORD ctrl_type, void const *ctrl_para)
Definition: store.c:1481
BOOL WINAPI CertDeleteCertificateFromStore(PCCERT_CONTEXT pCertContext)
Definition: store.c:943
HCERTSTORE WINAPI CertOpenSystemStoreW(HCRYPTPROV_LEGACY hProv, LPCWSTR szSubSystemProtocol)
Definition: store.c:916
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define CP_ACP
Definition: compat.h:109
#define SetLastError(x)
Definition: compat.h:752
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define MAX_PATH
Definition: compat.h:34
#define MultiByteToWideChar
Definition: compat.h:110
#define lstrlenW
Definition: compat.h:750
LONG WINAPI CompareFileTime(IN CONST FILETIME *lpFileTime1, IN CONST FILETIME *lpFileTime2)
Definition: time.c:106
#define strcasecmp
Definition: fake.h:9
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLuint res
Definition: glext.h:9613
GLuint index
Definition: glext.h:6031
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static const BYTE crl[]
Definition: message.c:864
static BYTE cert[]
Definition: msg.c:1437
DWORD cert_store
Definition: store.c:344
static LPCSTR DWORD void * pvReserved
Definition: str.c:196
static HCRYPTPROV hProv
Definition: rsaenh.c:32
static DWORD unk1
Definition: cursoricon.c:1638
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_READ
Definition: nt_native.h:1023
#define DWORD
Definition: nt_native.h:44
#define REG_OPENED_EXISTING_KEY
Definition: nt_native.h:1085
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define LOWORD(l)
Definition: pedump.c:82
long LONG
Definition: pedump.c:60
static unsigned __int64 next
Definition: rand_nt.c:6
INT replace(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], DWORD dwFlags, BOOL *doMore)
Definition: replace.c:47
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
__WINE_SERVER_LIST_INLINE struct list * list_next(const struct list *list, const struct list *elem)
Definition: list.h:115
#define memset(x, y, z)
Definition: compat.h:39
BOOL WINAPI CertSerializeCRLStoreElement(PCCRL_CONTEXT pCrlContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
Definition: serialize.c:152
BOOL WINAPI CertSerializeCTLStoreElement(PCCTL_CONTEXT pCtlContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
Definition: serialize.c:160
BOOL WINAPI CertSerializeCertificateStoreElement(PCCERT_CONTEXT pCertContext, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
Definition: serialize.c:144
#define TRACE(s)
Definition: solgame.cpp:4
const store_vtbl_t * vtbl
CONTEXT_PROPERTY_LIST * properties
HCERTSTORE hCertStore
Definition: wincrypt.h:483
void ** rgpvStoreProvFunc
Definition: wincrypt.h:1149
HCERTSTOREPROV hStoreProv
Definition: wincrypt.h:1150
BOOL(* delete)(struct WINE_CRYPTCERTSTORE *, context_t *)
context_t *(* enumContext)(struct WINE_CRYPTCERTSTORE *store, context_t *prev)
BOOL(* addContext)(struct WINE_CRYPTCERTSTORE *, context_t *, context_t *, context_t **, BOOL)
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:887
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:894
HCERTSTORE hCertStore
Definition: wincrypt.h:623
PCRL_INFO pCrlInfo
Definition: wincrypt.h:622
FILETIME ThisUpdate
Definition: wincrypt.h:498
DeleteContextFunc deleteFromStore
AddContextToStoreFunc addContextToStore
EnumContextsInStoreFunc enumContextsInStore
struct list certs
Definition: store.c:86
CRITICAL_SECTION cs
Definition: store.c:85
struct list ctls
Definition: store.c:88
WINECRYPT_CERTSTORE hdr
Definition: store.c:84
struct list crls
Definition: store.c:87
const context_vtbl_t * vtbl
struct list entry
union _context_t::@339 u
Definition: image.c:134
context_t base
struct _context_t *(* clone)(context_t *, struct WINE_CRYPTCERTSTORE *, BOOL)
Definition: http.c:7252
context_t base
Definition: dsound.c:943
Definition: copy.c:22
Definition: name.c:39
Definition: send.c:48
DWORD(* release)(struct WINE_CRYPTCERTSTORE *, DWORD)
void(* addref)(struct WINE_CRYPTCERTSTORE *)
CONTEXT_FUNCS crls
CONTEXT_FUNCS certs
BOOL(* control)(struct WINE_CRYPTCERTSTORE *, DWORD, DWORD, void const *)
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define LIST_ENTRY(type)
Definition: queue.h:175
#define DWORD_PTR
Definition: treelist.c:76
unsigned char * LPBYTE
Definition: typedefs.h:53
int ret
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
_In_ DWORD dwMsgAndCertEncodingType
Definition: wincrypt.h:5076
#define sz_CERT_STORE_PROV_SERIALIZED
Definition: wincrypt.h:2278
_In_ PCCRL_CONTEXT pCrlContext
Definition: wincrypt.h:4992
#define CERT_STORE_PROV_PKCS7
Definition: wincrypt.h:2254
#define sz_CERT_STORE_PROV_FILENAME_W
Definition: wincrypt.h:2273
#define CERT_STORE_PROV_COLLECTION
Definition: wincrypt.h:2261
#define CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
Definition: wincrypt.h:2580
ULONG_PTR HCRYPTPROV_LEGACY
Definition: wincrypt.h:48
#define CERT_STORE_ADD_REPLACE_EXISTING
Definition: wincrypt.h:2484
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
#define CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES
Definition: wincrypt.h:2488
#define CERT_STORE_PROV_FILENAME_A
Definition: wincrypt.h:2256
#define CERT_SYSTEM_STORE_SERVICES
Definition: wincrypt.h:2330
#define sz_CERT_STORE_PROV_COLLECTION
Definition: wincrypt.h:2279
#define sz_CERT_STORE_PROV_MEMORY
Definition: wincrypt.h:2272
_In_ DWORD dwPropId
Definition: wincrypt.h:4948
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867
#define sz_CERT_STORE_PROV_SYSTEM_REGISTRY
Definition: wincrypt.h:2281
#define CERT_STORE_OPEN_EXISTING_FLAG
Definition: wincrypt.h:2465
#define CERT_STORE_ADD_NEWER
Definition: wincrypt.h:2487
_In_ PCCERT_CONTEXT _In_ DWORD dwAddDisposition
Definition: wincrypt.h:4984
#define CERT_STORE_CREATE_NEW_FLAG
Definition: wincrypt.h:2464
void * HCRYPTMSG
Definition: wincrypt.h:52
#define sz_CERT_STORE_PROV_SYSTEM
Definition: wincrypt.h:2276
#define CERT_CLOSE_STORE_CHECK_FLAG
Definition: wincrypt.h:2479
#define CERT_SYSTEM_STORE_RELOCATE_FLAG
Definition: wincrypt.h:2640
BOOL(WINAPI * PFN_CERT_ENUM_SYSTEM_STORE)(_In_ const void *pvSystemStore, _In_ DWORD dwFlags, _In_ PCERT_SYSTEM_STORE_INFO pStoreInfo, _Reserved_ void *pvReserved, _Inout_opt_ void *pvArg)
Definition: wincrypt.h:1114
#define CERT_STORE_PROV_SERIALIZED
Definition: wincrypt.h:2255
#define CERT_SYSTEM_STORE_LOCATION_MASK
Definition: wincrypt.h:2303
#define CERT_STORE_PROV_SYSTEM_REGISTRY_W
Definition: wincrypt.h:2263
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
#define CERT_STORE_PROV_FILENAME_W
Definition: wincrypt.h:2257
#define CERT_STORE_PROV_SYSTEM_A
Definition: wincrypt.h:2258
#define CERT_SYSTEM_STORE_CURRENT_SERVICE
Definition: wincrypt.h:2328
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
#define CERT_SYSTEM_STORE_USERS
Definition: wincrypt.h:2332
#define sz_CERT_STORE_PROV_PKCS7
Definition: wincrypt.h:2277
#define CERT_STORE_PROV_MEMORY
Definition: wincrypt.h:2251
#define CERT_STORE_PROV_REG
Definition: wincrypt.h:2253
#define CERT_STORE_PROV_FILE
Definition: wincrypt.h:2252
#define CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE
Definition: wincrypt.h:2338
#define CERT_STORE_PROV_MSG
Definition: wincrypt.h:2250
_In_ void * pvPara
Definition: wincrypt.h:6077
#define CERT_ACCESS_STATE_PROP_ID
Definition: wincrypt.h:2700
static const WCHAR CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH[]
Definition: wincrypt.h:2356
#define CERT_SYSTEM_STORE_LOCAL_MACHINE
Definition: wincrypt.h:2326
#define CERT_STORE_ADD_USE_EXISTING
Definition: wincrypt.h:2483
_In_ PCCERT_CONTEXT _In_ DWORD _Outptr_opt_ PCCERT_CONTEXT * ppStoreContext
Definition: wincrypt.h:4985
BOOL(WINAPI * PFN_CERT_ENUM_PHYSICAL_STORE)(_In_ const void *pvSystemStore, _In_ DWORD dwFlags, _In_ LPCWSTR pwszStoreName, _In_ PCERT_PHYSICAL_STORE_INFO pStoreInfo, _Reserved_ void *pvReserved, _Inout_opt_ void *pvArg)
Definition: wincrypt.h:1122
#define CERT_ACCESS_STATE_WRITE_PERSIST_FLAG
Definition: wincrypt.h:2766
#define CERT_STORE_ADD_NEW
Definition: wincrypt.h:2482
_In_ PCCERT_CONTEXT pCertContext
Definition: wincrypt.h:4836
#define CMSG_SIGNED
Definition: wincrypt.h:3680
#define CERT_STORE_ADD_ALWAYS
Definition: wincrypt.h:2485
#define CERT_STORE_PROV_SYSTEM_W
Definition: wincrypt.h:2259
static const WCHAR CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH[]
Definition: wincrypt.h:2359
#define CMSG_CRL_PARAM
Definition: wincrypt.h:3938
#define CERT_STORE_NO_CRYPT_RELEASE_FLAG
Definition: wincrypt.h:2452
#define CERT_SYSTEM_STORE_CURRENT_USER
Definition: wincrypt.h:2324
#define CERT_STORE_PROV_SYSTEM_REGISTRY_A
Definition: wincrypt.h:2262
#define PKCS_7_ASN_ENCODING
Definition: wincrypt.h:2299
#define CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY
Definition: wincrypt.h:2334
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4950
#define CERT_STORE_DELETE_FLAG
Definition: wincrypt.h:2455
#define CERT_STORE_PROV_PHYSICAL_W
Definition: wincrypt.h:2265
#define CERT_STORE_READONLY_FLAG
Definition: wincrypt.h:2466
#define CMSG_CERT_COUNT_PARAM
Definition: wincrypt.h:3935
#define CMSG_CRL_COUNT_PARAM
Definition: wincrypt.h:3937
#define CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY
Definition: wincrypt.h:2336
#define CMSG_CERT_PARAM
Definition: wincrypt.h:3936
#define CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES
Definition: wincrypt.h:2486
#define CRL_FIND_EXISTING
Definition: wincrypt.h:2929
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3749
#define WINAPI
Definition: msvc.h:6
#define CRYPT_E_NOT_FOUND
Definition: winerror.h:3007
#define ERROR_FILE_EXISTS
Definition: winerror.h:165
#define E_UNEXPECTED
Definition: winerror.h:2456
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define CRYPT_E_PENDING_CLOSE
Definition: winerror.h:3018
#define CRYPT_E_EXISTS
Definition: winerror.h:3008
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_USER
Definition: winreg.h:11
ACCESS_MASK REGSAM
Definition: winreg.h:69
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
const char * LPCSTR
Definition: xmlstorage.h:183
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185