?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32/tests: Hack SHGetFileInfo() so it does not crash and add a test for it.
[wine/hacks.git] / dlls / crypt32 / store.c
blob8c8cda55164c21b5d8c7b1568ee0f95dc4ec6998
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/list.h"
39 #include "excpt.h"
40 #include "wine/exception.h"
41 #include "crypt32_private.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
44
45 #define WINE_CRYPTCERTSTORE_MAGIC 0x74726563
46
47 static const WINE_CONTEXT_INTERFACE gCertInterface = {
48 (CreateContextFunc)CertCreateCertificateContext,
49 (AddContextToStoreFunc)CertAddCertificateContextToStore,
50 (AddEncodedContextToStoreFunc)CertAddEncodedCertificateToStore,
51 (DuplicateContextFunc)CertDuplicateCertificateContext,
52 (EnumContextsInStoreFunc)CertEnumCertificatesInStore,
53 (EnumPropertiesFunc)CertEnumCertificateContextProperties,
54 (GetContextPropertyFunc)CertGetCertificateContextProperty,
55 (SetContextPropertyFunc)CertSetCertificateContextProperty,
56 (SerializeElementFunc)CertSerializeCertificateStoreElement,
57 (FreeContextFunc)CertFreeCertificateContext,
58 (DeleteContextFunc)CertDeleteCertificateFromStore,
59 };
60 PCWINE_CONTEXT_INTERFACE pCertInterface = &gCertInterface;
61
62 static const WINE_CONTEXT_INTERFACE gCRLInterface = {
63 (CreateContextFunc)CertCreateCRLContext,
64 (AddContextToStoreFunc)CertAddCRLContextToStore,
65 (AddEncodedContextToStoreFunc)CertAddEncodedCRLToStore,
66 (DuplicateContextFunc)CertDuplicateCRLContext,
67 (EnumContextsInStoreFunc)CertEnumCRLsInStore,
68 (EnumPropertiesFunc)CertEnumCRLContextProperties,
69 (GetContextPropertyFunc)CertGetCRLContextProperty,
70 (SetContextPropertyFunc)CertSetCRLContextProperty,
71 (SerializeElementFunc)CertSerializeCRLStoreElement,
72 (FreeContextFunc)CertFreeCRLContext,
73 (DeleteContextFunc)CertDeleteCRLFromStore,
74 };
75 PCWINE_CONTEXT_INTERFACE pCRLInterface = &gCRLInterface;
76
77 static const WINE_CONTEXT_INTERFACE gCTLInterface = {
78 (CreateContextFunc)CertCreateCTLContext,
79 (AddContextToStoreFunc)CertAddCTLContextToStore,
80 (AddEncodedContextToStoreFunc)CertAddEncodedCTLToStore,
81 (DuplicateContextFunc)CertDuplicateCTLContext,
82 (EnumContextsInStoreFunc)CertEnumCTLsInStore,
83 (EnumPropertiesFunc)CertEnumCTLContextProperties,
84 (GetContextPropertyFunc)CertGetCTLContextProperty,
85 (SetContextPropertyFunc)CertSetCTLContextProperty,
86 (SerializeElementFunc)CertSerializeCTLStoreElement,
87 (FreeContextFunc)CertFreeCTLContext,
88 (DeleteContextFunc)CertDeleteCTLFromStore,
89 };
90 PCWINE_CONTEXT_INTERFACE pCTLInterface = &gCTLInterface;
91
92 struct WINE_CRYPTCERTSTORE;
93
94 typedef struct WINE_CRYPTCERTSTORE * (*StoreOpenFunc)(HCRYPTPROV hCryptProv,
95 DWORD dwFlags, const void *pvPara);
96
97 /* Called to enumerate the next context in a store. */
98 typedef void * (*EnumFunc)(struct WINE_CRYPTCERTSTORE *store, void *pPrev);
99
100 /* Called to add a context to a store. If toReplace is not NULL,
101 * context replaces toReplace in the store, and access checks should not be
102 * performed. Otherwise context is a new context, and it should only be
103 * added if the store allows it. If ppStoreContext is not NULL, the added
104 * context should be returned in *ppStoreContext.
105 */
106 typedef BOOL (*AddFunc)(struct WINE_CRYPTCERTSTORE *store, void *context,
107 void *toReplace, const void **ppStoreContext);
108
109 typedef BOOL (*DeleteFunc)(struct WINE_CRYPTCERTSTORE *store, void *context);
110
111 typedef struct _CONTEXT_STORE
112 {
113 AddFunc addContext;
114 EnumFunc enumContext;
115 DeleteFunc deleteContext;
116 } CONTEXT_STORE, *PCONTEXT_STORE;
117
118 typedef enum _CertStoreType {
119 StoreTypeMem,
120 StoreTypeCollection,
121 StoreTypeProvider,
122 } CertStoreType;
123
124 /* A cert store is polymorphic through the use of function pointers. A type
125 * is still needed to distinguish collection stores from other types.
126 * On the function pointers:
127 * - closeStore is called when the store's ref count becomes 0
128 * - control is optional, but should be implemented by any store that supports
129 * persistence
130 */
131 typedef struct WINE_CRYPTCERTSTORE
132 {
133 DWORD dwMagic;
134 LONG ref;
135 DWORD dwOpenFlags;
136 HCRYPTPROV cryptProv;
137 CertStoreType type;
138 PFN_CERT_STORE_PROV_CLOSE closeStore;
139 CONTEXT_STORE certs;
140 CONTEXT_STORE crls;
141 PFN_CERT_STORE_PROV_CONTROL control; /* optional */
142 } WINECRYPT_CERTSTORE, *PWINECRYPT_CERTSTORE;
143
144 typedef struct _WINE_MEMSTORE
145 {
146 WINECRYPT_CERTSTORE hdr;
147 struct ContextList *certs;
148 struct ContextList *crls;
149 } WINE_MEMSTORE, *PWINE_MEMSTORE;
150
151 typedef struct _WINE_HASH_TO_DELETE
152 {
153 BYTE hash[20];
154 struct list entry;
155 } WINE_HASH_TO_DELETE, *PWINE_HASH_TO_DELETE;
156
157 typedef struct _WINE_REGSTOREINFO
158 {
159 DWORD dwOpenFlags;
160 HCRYPTPROV cryptProv;
161 PWINECRYPT_CERTSTORE memStore;
162 HKEY key;
163 BOOL dirty;
164 CRITICAL_SECTION cs;
165 struct list certsToDelete;
166 struct list crlsToDelete;
167 } WINE_REGSTOREINFO, *PWINE_REGSTOREINFO;
168
169 typedef struct _WINE_FILESTOREINFO
170 {
171 DWORD dwOpenFlags;
172 HCRYPTPROV cryptProv;
173 PWINECRYPT_CERTSTORE memStore;
174 HANDLE file;
175 BOOL dirty;
176 } WINE_FILESTOREINFO, *PWINE_FILESTOREINFO;
177
178 typedef struct _WINE_STORE_LIST_ENTRY
179 {
180 PWINECRYPT_CERTSTORE store;
181 DWORD dwUpdateFlags;
182 DWORD dwPriority;
183 struct list entry;
184 } WINE_STORE_LIST_ENTRY, *PWINE_STORE_LIST_ENTRY;
185
186 typedef struct _WINE_COLLECTIONSTORE
187 {
188 WINECRYPT_CERTSTORE hdr;
189 CRITICAL_SECTION cs;
190 struct list stores;
191 } WINE_COLLECTIONSTORE, *PWINE_COLLECTIONSTORE;
192
193 typedef struct _WINE_PROVIDERSTORE
194 {
195 WINECRYPT_CERTSTORE hdr;
196 DWORD dwStoreProvFlags;
197 PWINECRYPT_CERTSTORE memStore;
198 HCERTSTOREPROV hStoreProv;
199 PFN_CERT_STORE_PROV_CLOSE provCloseStore;
200 PFN_CERT_STORE_PROV_WRITE_CERT provWriteCert;
201 PFN_CERT_STORE_PROV_DELETE_CERT provDeleteCert;
202 PFN_CERT_STORE_PROV_WRITE_CRL provWriteCrl;
203 PFN_CERT_STORE_PROV_DELETE_CRL provDeleteCrl;
204 PFN_CERT_STORE_PROV_CONTROL provControl;
205 } WINE_PROVIDERSTORE, *PWINE_PROVIDERSTORE;
206
207 static void CRYPT_InitStore(WINECRYPT_CERTSTORE *store, HCRYPTPROV hCryptProv,
208 DWORD dwFlags, CertStoreType type)
209 {
210 store->ref = 1;
211 store->dwMagic = WINE_CRYPTCERTSTORE_MAGIC;
212 store->type = type;
213 if (!hCryptProv)
214 {
215 hCryptProv = CRYPT_GetDefaultProvider();
216 dwFlags |= CERT_STORE_NO_CRYPT_RELEASE_FLAG;
217 }
218 store->cryptProv = hCryptProv;
219 store->dwOpenFlags = dwFlags;
220 }
221
222 static BOOL CRYPT_MemAddCert(PWINECRYPT_CERTSTORE store, void *cert,
223 void *toReplace, const void **ppStoreContext)
224 {
225 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
226 PCERT_CONTEXT context;
227
228 TRACE("(%p, %p, %p, %p)\n", store, cert, toReplace, ppStoreContext);
229
230 context = (PCERT_CONTEXT)ContextList_Add(ms->certs, cert, toReplace);
231 if (context)
232 {
233 context->hCertStore = store;
234 if (ppStoreContext)
235 *ppStoreContext = CertDuplicateCertificateContext(context);
236 }
237 return context ? TRUE : FALSE;
238 }
239
240 static void *CRYPT_MemEnumCert(PWINECRYPT_CERTSTORE store, void *pPrev)
241 {
242 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
243 void *ret;
244
245 TRACE("(%p, %p)\n", store, pPrev);
246
247 ret = ContextList_Enum(ms->certs, pPrev);
248 if (!ret)
249 SetLastError(CRYPT_E_NOT_FOUND);
250
251 TRACE("returning %p\n", ret);
252 return ret;
253 }
254
255 static BOOL CRYPT_MemDeleteCert(PWINECRYPT_CERTSTORE store, void *pCertContext)
256 {
257 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
258
259 ContextList_Delete(ms->certs, pCertContext);
260 return TRUE;
261 }
262
263 static BOOL CRYPT_MemAddCrl(PWINECRYPT_CERTSTORE store, void *crl,
264 void *toReplace, const void **ppStoreContext)
265 {
266 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
267 PCRL_CONTEXT context;
268
269 TRACE("(%p, %p, %p, %p)\n", store, crl, toReplace, ppStoreContext);
270
271 context = (PCRL_CONTEXT)ContextList_Add(ms->crls, crl, toReplace);
272 if (context)
273 {
274 context->hCertStore = store;
275 if (ppStoreContext)
276 *ppStoreContext = CertDuplicateCRLContext(context);
277 }
278 return context ? TRUE : FALSE;
279 }
280
281 static void *CRYPT_MemEnumCrl(PWINECRYPT_CERTSTORE store, void *pPrev)
282 {
283 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
284 void *ret;
285
286 TRACE("(%p, %p)\n", store, pPrev);
287
288 ret = ContextList_Enum(ms->crls, pPrev);
289 if (!ret)
290 SetLastError(CRYPT_E_NOT_FOUND);
291
292 TRACE("returning %p\n", ret);
293 return ret;
294 }
295
296 static BOOL CRYPT_MemDeleteCrl(PWINECRYPT_CERTSTORE store, void *pCrlContext)
297 {
298 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
299
300 ContextList_Delete(ms->crls, pCrlContext);
301 return TRUE;
302 }
303
304 static void CRYPT_MemEmptyStore(PWINE_MEMSTORE store)
305 {
306 ContextList_Empty(store->certs);
307 ContextList_Empty(store->crls);
308 }
309
310 static void WINAPI CRYPT_MemCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
311 {
312 WINE_MEMSTORE *store = (WINE_MEMSTORE *)hCertStore;
313
314 TRACE("(%p, %08x)\n", store, dwFlags);
315 if (dwFlags)
316 FIXME("Unimplemented flags: %08x\n", dwFlags);
317
318 ContextList_Free(store->certs);
319 ContextList_Free(store->crls);
320 CryptMemFree(store);
321 }
322
323 static WINECRYPT_CERTSTORE *CRYPT_MemOpenStore(HCRYPTPROV hCryptProv,
324 DWORD dwFlags, const void *pvPara)
325 {
326 PWINE_MEMSTORE store;
327
328 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
329
330 if (dwFlags & CERT_STORE_DELETE_FLAG)
331 {
332 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
333 store = NULL;
334 }
335 else
336 {
337 store = CryptMemAlloc(sizeof(WINE_MEMSTORE));
338 if (store)
339 {
340 memset(store, 0, sizeof(WINE_MEMSTORE));
341 CRYPT_InitStore(&store->hdr, hCryptProv, dwFlags, StoreTypeMem);
342 store->hdr.closeStore = CRYPT_MemCloseStore;
343 store->hdr.certs.addContext = CRYPT_MemAddCert;
344 store->hdr.certs.enumContext = CRYPT_MemEnumCert;
345 store->hdr.certs.deleteContext = CRYPT_MemDeleteCert;
346 store->hdr.crls.addContext = CRYPT_MemAddCrl;
347 store->hdr.crls.enumContext = CRYPT_MemEnumCrl;
348 store->hdr.crls.deleteContext = CRYPT_MemDeleteCrl;
349 store->hdr.control = NULL;
350 store->certs = ContextList_Create(pCertInterface,
351 sizeof(CERT_CONTEXT));
352 store->crls = ContextList_Create(pCRLInterface,
353 sizeof(CRL_CONTEXT));
354 }
355 }
356 return (PWINECRYPT_CERTSTORE)store;
357 }
358
359 static void WINAPI CRYPT_CollectionCloseStore(HCERTSTORE store, DWORD dwFlags)
360 {
361 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
362 PWINE_STORE_LIST_ENTRY entry, next;
363
364 TRACE("(%p, %08x)\n", store, dwFlags);
365
366 LIST_FOR_EACH_ENTRY_SAFE(entry, next, &cs->stores, WINE_STORE_LIST_ENTRY,
367 entry)
368 {
369 TRACE("closing %p\n", entry);
370 CertCloseStore((HCERTSTORE)entry->store, dwFlags);
371 CryptMemFree(entry);
372 }
373 DeleteCriticalSection(&cs->cs);
374 CryptMemFree(cs);
375 }
376
377 static void *CRYPT_CollectionCreateContextFromChild(PWINE_COLLECTIONSTORE store,
378 PWINE_STORE_LIST_ENTRY storeEntry, void *child, size_t contextSize,
379 BOOL addRef)
380 {
381 void *ret = Context_CreateLinkContext(contextSize, child,
382 sizeof(PWINE_STORE_LIST_ENTRY), addRef);
383
384 if (ret)
385 *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(ret, contextSize)
386 = storeEntry;
387
388 return ret;
389 }
390
391 static BOOL CRYPT_CollectionAddContext(PWINE_COLLECTIONSTORE store,
392 unsigned int contextStoreOffset, void *context, void *toReplace, unsigned int contextSize,
393 void **pChildContext)
394 {
395 BOOL ret;
396 void *childContext = NULL;
397 PWINE_STORE_LIST_ENTRY storeEntry = NULL;
398
399 TRACE("(%p, %d, %p, %p, %d)\n", store, contextStoreOffset, context,
400 toReplace, contextSize);
401
402 ret = FALSE;
403 if (toReplace)
404 {
405 void *existingLinked = Context_GetLinkedContext(toReplace, contextSize);
406 PCONTEXT_STORE contextStore;
407
408 storeEntry = *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(toReplace,
409 contextSize);
410 contextStore = (PCONTEXT_STORE)((LPBYTE)storeEntry->store +
411 contextStoreOffset);
412 ret = contextStore->addContext(storeEntry->store, context,
413 existingLinked, (const void **)&childContext);
414 }
415 else
416 {
417 PWINE_STORE_LIST_ENTRY entry, next;
418
419 EnterCriticalSection(&store->cs);
420 LIST_FOR_EACH_ENTRY_SAFE(entry, next, &store->stores,
421 WINE_STORE_LIST_ENTRY, entry)
422 {
423 if (entry->dwUpdateFlags & CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG)
424 {
425 PCONTEXT_STORE contextStore = (PCONTEXT_STORE)(
426 (LPBYTE)entry->store + contextStoreOffset);
427
428 storeEntry = entry;
429 ret = contextStore->addContext(entry->store, context, NULL,
430 (const void **)&childContext);
431 break;
432 }
433 }
434 LeaveCriticalSection(&store->cs);
435 if (!storeEntry)
436 SetLastError(E_ACCESSDENIED);
437 }
438 *pChildContext = childContext;
439 return ret;
440 }
441
442 /* Advances a collection enumeration by one context, if possible, where
443 * advancing means:
444 * - calling the current store's enumeration function once, and returning
445 * the enumerated context if one is returned
446 * - moving to the next store if the current store has no more items, and
447 * recursively calling itself to get the next item.
448 * Returns NULL if the collection contains no more items or on error.
449 * Assumes the collection store's lock is held.
450 */
451 static void *CRYPT_CollectionAdvanceEnum(PWINE_COLLECTIONSTORE store,
452 PWINE_STORE_LIST_ENTRY storeEntry, size_t contextStoreOffset,
453 PCWINE_CONTEXT_INTERFACE contextInterface, void *pPrev, size_t contextSize)
454 {
455 void *ret, *child;
456 struct list *storeNext = list_next(&store->stores, &storeEntry->entry);
457 PCONTEXT_STORE contextStore = (PCONTEXT_STORE)((LPBYTE)storeEntry->store +
458 contextStoreOffset);
459
460 TRACE("(%p, %p, %p)\n", store, storeEntry, pPrev);
461
462 if (pPrev)
463 {
464 /* Ref-counting funny business: "duplicate" (addref) the child, because
465 * the free(pPrev) below can cause the ref count to become negative.
466 */
467 child = Context_GetLinkedContext(pPrev, contextSize);
468 contextInterface->duplicate(child);
469 child = contextStore->enumContext(storeEntry->store, child);
470 contextInterface->free(pPrev);
471 pPrev = NULL;
472 }
473 else
474 child = storeEntry->store->certs.enumContext(storeEntry->store, NULL);
475 if (child)
476 ret = CRYPT_CollectionCreateContextFromChild(store, storeEntry, child,
477 contextSize, FALSE);
478 else
479 {
480 if (storeNext)
481 ret = CRYPT_CollectionAdvanceEnum(store, LIST_ENTRY(storeNext,
482 WINE_STORE_LIST_ENTRY, entry), contextStoreOffset,
483 contextInterface, NULL, contextSize);
484 else
485 {
486 SetLastError(CRYPT_E_NOT_FOUND);
487 ret = NULL;
488 }
489 }
490 TRACE("returning %p\n", ret);
491 return ret;
492 }
493
494 static BOOL CRYPT_CollectionAddCert(PWINECRYPT_CERTSTORE store, void *cert,
495 void *toReplace, const void **ppStoreContext)
496 {
497 BOOL ret;
498 void *childContext = NULL;
499 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
500
501 ret = CRYPT_CollectionAddContext(cs, offsetof(WINECRYPT_CERTSTORE, certs),
502 cert, toReplace, sizeof(CERT_CONTEXT), &childContext);
503 if (ppStoreContext && childContext)
504 {
505 PWINE_STORE_LIST_ENTRY storeEntry = *(PWINE_STORE_LIST_ENTRY *)
506 Context_GetExtra(childContext, sizeof(CERT_CONTEXT));
507 PCERT_CONTEXT context =
508 CRYPT_CollectionCreateContextFromChild(cs, storeEntry, childContext,
509 sizeof(CERT_CONTEXT), TRUE);
510
511 if (context)
512 context->hCertStore = store;
513 *ppStoreContext = context;
514 }
515 CertFreeCertificateContext((PCCERT_CONTEXT)childContext);
516 return ret;
517 }
518
519 static void *CRYPT_CollectionEnumCert(PWINECRYPT_CERTSTORE store, void *pPrev)
520 {
521 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
522 void *ret;
523
524 TRACE("(%p, %p)\n", store, pPrev);
525
526 EnterCriticalSection(&cs->cs);
527 if (pPrev)
528 {
529 PWINE_STORE_LIST_ENTRY storeEntry =
530 *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(pPrev,
531 sizeof(CERT_CONTEXT));
532
533 ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
534 offsetof(WINECRYPT_CERTSTORE, certs), pCertInterface, pPrev,
535 sizeof(CERT_CONTEXT));
536 }
537 else
538 {
539 if (!list_empty(&cs->stores))
540 {
541 PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
542 WINE_STORE_LIST_ENTRY, entry);
543
544 ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
545 offsetof(WINECRYPT_CERTSTORE, certs), pCertInterface, NULL,
546 sizeof(CERT_CONTEXT));
547 }
548 else
549 {
550 SetLastError(CRYPT_E_NOT_FOUND);
551 ret = NULL;
552 }
553 }
554 LeaveCriticalSection(&cs->cs);
555 if (ret)
556 ((PCERT_CONTEXT)ret)->hCertStore = store;
557 TRACE("returning %p\n", ret);
558 return ret;
559 }
560
561 static BOOL CRYPT_CollectionDeleteCert(PWINECRYPT_CERTSTORE store,
562 void *pCertContext)
563 {
564 BOOL ret;
565
566 TRACE("(%p, %p)\n", store, pCertContext);
567
568 ret = CertDeleteCertificateFromStore((PCCERT_CONTEXT)
569 Context_GetLinkedContext(pCertContext, sizeof(CERT_CONTEXT)));
570 return ret;
571 }
572
573 static BOOL CRYPT_CollectionAddCRL(PWINECRYPT_CERTSTORE store, void *crl,
574 void *toReplace, const void **ppStoreContext)
575 {
576 BOOL ret;
577 void *childContext = NULL;
578 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
579
580 ret = CRYPT_CollectionAddContext(cs, offsetof(WINECRYPT_CERTSTORE, crls),
581 crl, toReplace, sizeof(CRL_CONTEXT), &childContext);
582 if (ppStoreContext && childContext)
583 {
584 PWINE_STORE_LIST_ENTRY storeEntry = *(PWINE_STORE_LIST_ENTRY *)
585 Context_GetExtra(childContext, sizeof(CRL_CONTEXT));
586 PCRL_CONTEXT context =
587 CRYPT_CollectionCreateContextFromChild(cs, storeEntry, childContext,
588 sizeof(CRL_CONTEXT), TRUE);
589
590 if (context)
591 context->hCertStore = store;
592 *ppStoreContext = context;
593 }
594 CertFreeCRLContext((PCCRL_CONTEXT)childContext);
595 return ret;
596 }
597
598 static void *CRYPT_CollectionEnumCRL(PWINECRYPT_CERTSTORE store, void *pPrev)
599 {
600 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
601 void *ret;
602
603 TRACE("(%p, %p)\n", store, pPrev);
604
605 EnterCriticalSection(&cs->cs);
606 if (pPrev)
607 {
608 PWINE_STORE_LIST_ENTRY storeEntry =
609 *(PWINE_STORE_LIST_ENTRY *)Context_GetExtra(pPrev,
610 sizeof(CRL_CONTEXT));
611
612 ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
613 offsetof(WINECRYPT_CERTSTORE, crls), pCRLInterface, pPrev,
614 sizeof(CRL_CONTEXT));
615 }
616 else
617 {
618 if (!list_empty(&cs->stores))
619 {
620 PWINE_STORE_LIST_ENTRY storeEntry = LIST_ENTRY(cs->stores.next,
621 WINE_STORE_LIST_ENTRY, entry);
622
623 ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry,
624 offsetof(WINECRYPT_CERTSTORE, crls), pCRLInterface, NULL,
625 sizeof(CRL_CONTEXT));
626 }
627 else
628 {
629 SetLastError(CRYPT_E_NOT_FOUND);
630 ret = NULL;
631 }
632 }
633 LeaveCriticalSection(&cs->cs);
634 if (ret)
635 ((PCRL_CONTEXT)ret)->hCertStore = store;
636 TRACE("returning %p\n", ret);
637 return ret;
638 }
639
640 static BOOL CRYPT_CollectionDeleteCRL(PWINECRYPT_CERTSTORE store,
641 void *pCrlContext)
642 {
643 BOOL ret;
644
645 TRACE("(%p, %p)\n", store, pCrlContext);
646
647 ret = CertDeleteCRLFromStore((PCCRL_CONTEXT)
648 Context_GetLinkedContext(pCrlContext, sizeof(CRL_CONTEXT)));
649 return ret;
650 }
651
652 static WINECRYPT_CERTSTORE *CRYPT_CollectionOpenStore(HCRYPTPROV hCryptProv,
653 DWORD dwFlags, const void *pvPara)
654 {
655 PWINE_COLLECTIONSTORE store;
656
657 if (dwFlags & CERT_STORE_DELETE_FLAG)
658 {
659 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
660 store = NULL;
661 }
662 else
663 {
664 store = CryptMemAlloc(sizeof(WINE_COLLECTIONSTORE));
665 if (store)
666 {
667 memset(store, 0, sizeof(WINE_COLLECTIONSTORE));
668 CRYPT_InitStore(&store->hdr, hCryptProv, dwFlags,
669 StoreTypeCollection);
670 store->hdr.closeStore = CRYPT_CollectionCloseStore;
671 store->hdr.certs.addContext = CRYPT_CollectionAddCert;
672 store->hdr.certs.enumContext = CRYPT_CollectionEnumCert;
673 store->hdr.certs.deleteContext = CRYPT_CollectionDeleteCert;
674 store->hdr.crls.addContext = CRYPT_CollectionAddCRL;
675 store->hdr.crls.enumContext = CRYPT_CollectionEnumCRL;
676 store->hdr.crls.deleteContext = CRYPT_CollectionDeleteCRL;
677 InitializeCriticalSection(&store->cs);
678 list_init(&store->stores);
679 }
680 }
681 return (PWINECRYPT_CERTSTORE)store;
682 }
683
684 static void WINAPI CRYPT_ProvCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
685 {
686 PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore;
687
688 TRACE("(%p, %08x)\n", store, dwFlags);
689
690 if (store->provCloseStore)
691 store->provCloseStore(store->hStoreProv, dwFlags);
692 if (!(store->dwStoreProvFlags & CERT_STORE_PROV_EXTERNAL_FLAG))
693 CertCloseStore(store->memStore, dwFlags);
694 CryptMemFree(store);
695 }
696
697 static BOOL CRYPT_ProvAddCert(PWINECRYPT_CERTSTORE store, void *cert,
698 void *toReplace, const void **ppStoreContext)
699 {
700 PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
701 BOOL ret;
702
703 TRACE("(%p, %p, %p, %p)\n", store, cert, toReplace, ppStoreContext);
704
705 if (toReplace)
706 ret = ps->memStore->certs.addContext(ps->memStore, cert, toReplace,
707 (const void **)ppStoreContext);
708 else
709 {
710 ret = TRUE;
711 if (ps->provWriteCert)
712 ret = ps->provWriteCert(ps->hStoreProv, (PCCERT_CONTEXT)cert,
713 CERT_STORE_PROV_WRITE_ADD_FLAG);
714 if (ret)
715 ret = ps->memStore->certs.addContext(ps->memStore, cert, NULL,
716 (const void **)ppStoreContext);
717 }
718 /* dirty trick: replace the returned context's hCertStore with
719 * store.
720 */
721 if (ppStoreContext)
722 (*(PCERT_CONTEXT *)ppStoreContext)->hCertStore = store;
723 return ret;
724 }
725
726 static void *CRYPT_ProvEnumCert(PWINECRYPT_CERTSTORE store, void *pPrev)
727 {
728 PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
729 void *ret;
730
731 ret = ps->memStore->certs.enumContext(ps->memStore, pPrev);
732 if (ret)
733 {
734 /* same dirty trick: replace the returned context's hCertStore with
735 * store.
736 */
737 ((PCERT_CONTEXT)ret)->hCertStore = store;
738 }
739 return ret;
740 }
741
742 static BOOL CRYPT_ProvDeleteCert(PWINECRYPT_CERTSTORE store, void *cert)
743 {
744 PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
745 BOOL ret = TRUE;
746
747 TRACE("(%p, %p)\n", store, cert);
748
749 if (ps->provDeleteCert)
750 ret = ps->provDeleteCert(ps->hStoreProv, cert, 0);
751 if (ret)
752 ret = ps->memStore->certs.deleteContext(ps->memStore, cert);
753 return ret;
754 }
755
756 static BOOL CRYPT_ProvAddCRL(PWINECRYPT_CERTSTORE store, void *crl,
757 void *toReplace, const void **ppStoreContext)
758 {
759 PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
760 BOOL ret;
761
762 TRACE("(%p, %p, %p, %p)\n", store, crl, toReplace, ppStoreContext);
763
764 if (toReplace)
765 ret = ps->memStore->crls.addContext(ps->memStore, crl, toReplace,
766 (const void **)ppStoreContext);
767 else
768 {
769 if (ps->hdr.dwOpenFlags & CERT_STORE_READONLY_FLAG)
770 {
771 SetLastError(ERROR_ACCESS_DENIED);
772 ret = FALSE;
773 }
774 else
775 {
776 ret = TRUE;
777 if (ps->provWriteCrl)
778 ret = ps->provWriteCrl(ps->hStoreProv, (PCCRL_CONTEXT)crl,
779 CERT_STORE_PROV_WRITE_ADD_FLAG);
780 if (ret)
781 ret = ps->memStore->crls.addContext(ps->memStore, crl, NULL,
782 (const void **)ppStoreContext);
783 }
784 }
785 /* dirty trick: replace the returned context's hCertStore with
786 * store.
787 */
788 if (ppStoreContext)
789 (*(PCRL_CONTEXT *)ppStoreContext)->hCertStore = store;
790 return ret;
791 }
792
793 static void *CRYPT_ProvEnumCRL(PWINECRYPT_CERTSTORE store, void *pPrev)
794 {
795 PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
796 void *ret;
797
798 ret = ps->memStore->crls.enumContext(ps->memStore, pPrev);
799 if (ret)
800 {
801 /* same dirty trick: replace the returned context's hCertStore with
802 * store.
803 */
804 ((PCERT_CONTEXT)ret)->hCertStore = store;
805 }
806 return ret;
807 }
808
809 static BOOL CRYPT_ProvDeleteCRL(PWINECRYPT_CERTSTORE store, void *crl)
810 {
811 PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
812 BOOL ret = TRUE;
813
814 TRACE("(%p, %p)\n", store, crl);
815
816 if (ps->provDeleteCrl)
817 ret = ps->provDeleteCrl(ps->hStoreProv, crl, 0);
818 if (ret)
819 ret = ps->memStore->crls.deleteContext(ps->memStore, crl);
820 return ret;
821 }
822
823 static BOOL WINAPI CRYPT_ProvControl(HCERTSTORE hCertStore, DWORD dwFlags,
824 DWORD dwCtrlType, void const *pvCtrlPara)
825 {
826 PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore;
827 BOOL ret = TRUE;
828
829 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
830 pvCtrlPara);
831
832 if (store->provControl)
833 ret = store->provControl(store->hStoreProv, dwFlags, dwCtrlType,
834 pvCtrlPara);
835 return ret;
836 }
837
838 static PWINECRYPT_CERTSTORE CRYPT_ProvCreateStore(HCRYPTPROV hCryptProv,
839 DWORD dwFlags, PWINECRYPT_CERTSTORE memStore, PCERT_STORE_PROV_INFO pProvInfo)
840 {
841 PWINE_PROVIDERSTORE ret = (PWINE_PROVIDERSTORE)CryptMemAlloc(
842 sizeof(WINE_PROVIDERSTORE));
843
844 if (ret)
845 {
846 CRYPT_InitStore(&ret->hdr, hCryptProv, dwFlags,
847 StoreTypeProvider);
848 ret->dwStoreProvFlags = pProvInfo->dwStoreProvFlags;
849 if (ret->dwStoreProvFlags & CERT_STORE_PROV_EXTERNAL_FLAG)
850 {
851 CertCloseStore(memStore, 0);
852 ret->memStore = NULL;
853 }
854 else
855 ret->memStore = memStore;
856 ret->hStoreProv = pProvInfo->hStoreProv;
857 ret->hdr.closeStore = CRYPT_ProvCloseStore;
858 ret->hdr.certs.addContext = CRYPT_ProvAddCert;
859 ret->hdr.certs.enumContext = CRYPT_ProvEnumCert;
860 ret->hdr.certs.deleteContext = CRYPT_ProvDeleteCert;
861 ret->hdr.crls.addContext = CRYPT_ProvAddCRL;
862 ret->hdr.crls.enumContext = CRYPT_ProvEnumCRL;
863 ret->hdr.crls.deleteContext = CRYPT_ProvDeleteCRL;
864 ret->hdr.control = CRYPT_ProvControl;
865 if (pProvInfo->cStoreProvFunc > CERT_STORE_PROV_CLOSE_FUNC)
866 ret->provCloseStore =
867 pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_CLOSE_FUNC];
868 else
869 ret->provCloseStore = NULL;
870 if (pProvInfo->cStoreProvFunc >
871 CERT_STORE_PROV_WRITE_CERT_FUNC)
872 ret->provWriteCert = pProvInfo->rgpvStoreProvFunc[
873 CERT_STORE_PROV_WRITE_CERT_FUNC];
874 else
875 ret->provWriteCert = NULL;
876 if (pProvInfo->cStoreProvFunc >
877 CERT_STORE_PROV_DELETE_CERT_FUNC)
878 ret->provDeleteCert = pProvInfo->rgpvStoreProvFunc[
879 CERT_STORE_PROV_DELETE_CERT_FUNC];
880 else
881 ret->provDeleteCert = NULL;
882 if (pProvInfo->cStoreProvFunc >
883 CERT_STORE_PROV_WRITE_CRL_FUNC)
884 ret->provWriteCrl = pProvInfo->rgpvStoreProvFunc[
885 CERT_STORE_PROV_WRITE_CRL_FUNC];
886 else
887 ret->provWriteCert = NULL;
888 if (pProvInfo->cStoreProvFunc >
889 CERT_STORE_PROV_DELETE_CRL_FUNC)
890 ret->provDeleteCrl = pProvInfo->rgpvStoreProvFunc[
891 CERT_STORE_PROV_DELETE_CRL_FUNC];
892 else
893 ret->provDeleteCert = NULL;
894 if (pProvInfo->cStoreProvFunc >
895 CERT_STORE_PROV_CONTROL_FUNC)
896 ret->provControl = pProvInfo->rgpvStoreProvFunc[
897 CERT_STORE_PROV_CONTROL_FUNC];
898 else
899 ret->provControl = NULL;
900 }
901 return (PWINECRYPT_CERTSTORE)ret;
902 }
903
904 static PWINECRYPT_CERTSTORE CRYPT_ProvOpenStore(LPCSTR lpszStoreProvider,
905 DWORD dwEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
906 {
907 static HCRYPTOIDFUNCSET set = NULL;
908 PFN_CERT_DLL_OPEN_STORE_PROV_FUNC provOpenFunc;
909 HCRYPTOIDFUNCADDR hFunc;
910 PWINECRYPT_CERTSTORE ret = NULL;
911
912 if (!set)
913 set = CryptInitOIDFunctionSet(CRYPT_OID_OPEN_STORE_PROV_FUNC, 0);
914 CryptGetOIDFunctionAddress(set, dwEncodingType, lpszStoreProvider, 0,
915 (void **)&provOpenFunc, &hFunc);
916 if (provOpenFunc)
917 {
918 CERT_STORE_PROV_INFO provInfo = { 0 };
919
920 provInfo.cbSize = sizeof(provInfo);
921 if (dwFlags & CERT_STORE_DELETE_FLAG)
922 provOpenFunc(lpszStoreProvider, dwEncodingType, hCryptProv,
923 dwFlags, pvPara, NULL, &provInfo);
924 else
925 {
926 HCERTSTORE memStore;
927
928 memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
929 CERT_STORE_CREATE_NEW_FLAG, NULL);
930 if (memStore)
931 {
932 if (provOpenFunc(lpszStoreProvider, dwEncodingType, hCryptProv,
933 dwFlags, pvPara, memStore, &provInfo))
934 ret = CRYPT_ProvCreateStore(hCryptProv, dwFlags, memStore,
935 &provInfo);
936 else
937 CertCloseStore(memStore, 0);
938 }
939 }
940 CryptFreeOIDFunctionAddress(hFunc, 0);
941 }
942 else
943 SetLastError(ERROR_FILE_NOT_FOUND);
944 return ret;
945 }
946
947 static void CRYPT_HashToStr(LPBYTE hash, LPWSTR asciiHash)
948 {
949 static const WCHAR fmt[] = { '%','0','2','X',0 };
950 DWORD i;
951
952 assert(hash);
953 assert(asciiHash);
954
955 for (i = 0; i < 20; i++)
956 wsprintfW(asciiHash + i * 2, fmt, hash[i]);
957 }
958
959 static const WCHAR CertsW[] = { 'C','e','r','t','i','f','i','c','a','t','e','s',
960 0 };
961 static const WCHAR CRLsW[] = { 'C','R','L','s',0 };
962 static const WCHAR CTLsW[] = { 'C','T','L','s',0 };
963 static const WCHAR BlobW[] = { 'B','l','o','b',0 };
964
965 static void CRYPT_RegReadSerializedFromReg(PWINE_REGSTOREINFO store, HKEY key,
966 DWORD contextType)
967 {
968 LONG rc;
969 DWORD index = 0;
970 WCHAR subKeyName[MAX_PATH];
971
972 do {
973 DWORD size = sizeof(subKeyName) / sizeof(WCHAR);
974
975 rc = RegEnumKeyExW(key, index++, subKeyName, &size, NULL, NULL, NULL,
976 NULL);
977 if (!rc)
978 {
979 HKEY subKey;
980
981 rc = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
982 if (!rc)
983 {
984 LPBYTE buf = NULL;
985
986 size = 0;
987 rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, NULL, &size);
988 if (!rc)
989 buf = CryptMemAlloc(size);
990 if (buf)
991 {
992 rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, buf,
993 &size);
994 if (!rc)
995 {
996 const void *context;
997 DWORD addedType;
998
999 TRACE("Adding cert with hash %s\n",
1000 debugstr_w(subKeyName));
1001 context = CRYPT_ReadSerializedElement(buf, size,
1002 contextType, &addedType);
1003 if (context)
1004 {
1005 const WINE_CONTEXT_INTERFACE *contextInterface;
1006 BYTE hash[20];
1007
1008 switch (addedType)
1009 {
1010 case CERT_STORE_CERTIFICATE_CONTEXT:
1011 contextInterface = &gCertInterface;
1012 break;
1013 case CERT_STORE_CRL_CONTEXT:
1014 contextInterface = &gCRLInterface;
1015 break;
1016 case CERT_STORE_CTL_CONTEXT:
1017 contextInterface = &gCTLInterface;
1018 break;
1019 default:
1020 contextInterface = NULL;
1021 }
1022 if (contextInterface)
1023 {
1024 size = sizeof(hash);
1025 if (contextInterface->getProp(context,
1026 CERT_HASH_PROP_ID, hash, &size))
1027 {
1028 WCHAR asciiHash[20 * 2 + 1];
1029
1030 CRYPT_HashToStr(hash, asciiHash);
1031 TRACE("comparing %s\n",
1032 debugstr_w(asciiHash));
1033 TRACE("with %s\n", debugstr_w(subKeyName));
1034 if (!lstrcmpW(asciiHash, subKeyName))
1035 {
1036 TRACE("hash matches, adding\n");
1037 contextInterface->addContextToStore(
1038 store->memStore, context,
1039 CERT_STORE_ADD_REPLACE_EXISTING, NULL);
1040 }
1041 else
1042 TRACE("hash doesn't match, ignoring\n");
1043 }
1044 contextInterface->free(context);
1045 }
1046 }
1047 }
1048 CryptMemFree(buf);
1049 }
1050 RegCloseKey(subKey);
1051 }
1052 /* Ignore intermediate errors, continue enumerating */
1053 rc = ERROR_SUCCESS;
1054 }
1055 } while (!rc);
1056 }
1057
1058 static void CRYPT_RegReadFromReg(PWINE_REGSTOREINFO store)
1059 {
1060 static const WCHAR * const subKeys[] = { CertsW, CRLsW, CTLsW };
1061 static const DWORD contextFlags[] = { CERT_STORE_CERTIFICATE_CONTEXT_FLAG,
1062 CERT_STORE_CRL_CONTEXT_FLAG, CERT_STORE_CTL_CONTEXT_FLAG };
1063 DWORD i;
1064
1065 for (i = 0; i < sizeof(subKeys) / sizeof(subKeys[0]); i++)
1066 {
1067 HKEY key;
1068 LONG rc;
1069
1070 rc = RegCreateKeyExW(store->key, subKeys[i], 0, NULL, 0, KEY_READ, NULL,
1071 &key, NULL);
1072 if (!rc)
1073 {
1074 CRYPT_RegReadSerializedFromReg(store, key, contextFlags[i]);
1075 RegCloseKey(key);
1076 }
1077 }
1078 }
1079
1080 /* Hash is assumed to be 20 bytes in length (a SHA-1 hash) */
1081 static BOOL CRYPT_WriteSerializedToReg(HKEY key, LPBYTE hash, LPBYTE buf,
1082 DWORD len)
1083 {
1084 WCHAR asciiHash[20 * 2 + 1];
1085 LONG rc;
1086 HKEY subKey;
1087 BOOL ret;
1088
1089 CRYPT_HashToStr(hash, asciiHash);
1090 rc = RegCreateKeyExW(key, asciiHash, 0, NULL, 0, KEY_ALL_ACCESS, NULL,
1091 &subKey, NULL);
1092 if (!rc)
1093 {
1094 rc = RegSetValueExW(subKey, BlobW, 0, REG_BINARY, buf, len);
1095 RegCloseKey(subKey);
1096 }
1097 if (!rc)
1098 ret = TRUE;
1099 else
1100 {
1101 SetLastError(rc);
1102 ret = FALSE;
1103 }
1104 return ret;
1105 }
1106
1107 static BOOL CRYPT_SerializeContextsToReg(HKEY key,
1108 const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore)
1109 {
1110 const void *context = NULL;
1111 BOOL ret;
1112
1113 do {
1114 context = contextInterface->enumContextsInStore(memStore, context);
1115 if (context)
1116 {
1117 BYTE hash[20];
1118 DWORD hashSize = sizeof(hash);
1119
1120 ret = contextInterface->getProp(context, CERT_HASH_PROP_ID, hash,
1121 &hashSize);
1122 if (ret)
1123 {
1124 DWORD size = 0;
1125 LPBYTE buf = NULL;
1126
1127 ret = contextInterface->serialize(context, 0, NULL, &size);
1128 if (size)
1129 buf = CryptMemAlloc(size);
1130 if (buf)
1131 {
1132 ret = contextInterface->serialize(context, 0, buf, &size);
1133 if (ret)
1134 ret = CRYPT_WriteSerializedToReg(key, hash, buf, size);
1135 }
1136 CryptMemFree(buf);
1137 }
1138 }
1139 else
1140 ret = TRUE;
1141 } while (ret && context != NULL);
1142 if (context)
1143 contextInterface->free(context);
1144 return ret;
1145 }
1146
1147 static BOOL CRYPT_RegWriteToReg(PWINE_REGSTOREINFO store)
1148 {
1149 static const WCHAR * const subKeys[] = { CertsW, CRLsW, CTLsW };
1150 static const WINE_CONTEXT_INTERFACE * const interfaces[] = { &gCertInterface,
1151 &gCRLInterface, &gCTLInterface };
1152 struct list *listToDelete[] = { &store->certsToDelete, &store->crlsToDelete,
1153 NULL };
1154 BOOL ret = TRUE;
1155 DWORD i;
1156
1157 for (i = 0; ret && i < sizeof(subKeys) / sizeof(subKeys[0]); i++)
1158 {
1159 HKEY key;
1160 LONG rc = RegCreateKeyExW(store->key, subKeys[i], 0, NULL, 0,
1161 KEY_ALL_ACCESS, NULL, &key, NULL);
1162
1163 if (!rc)
1164 {
1165 if (listToDelete[i])
1166 {
1167 PWINE_HASH_TO_DELETE toDelete, next;
1168 WCHAR asciiHash[20 * 2 + 1];
1169
1170 EnterCriticalSection(&store->cs);
1171 LIST_FOR_EACH_ENTRY_SAFE(toDelete, next, listToDelete[i],
1172 WINE_HASH_TO_DELETE, entry)
1173 {
1174 LONG rc;
1175
1176 CRYPT_HashToStr(toDelete->hash, asciiHash);
1177 TRACE("Removing %s\n", debugstr_w(asciiHash));
1178 rc = RegDeleteKeyW(key, asciiHash);
1179 if (rc != ERROR_SUCCESS && rc != ERROR_FILE_NOT_FOUND)
1180 {
1181 SetLastError(rc);
1182 ret = FALSE;
1183 }
1184 list_remove(&toDelete->entry);
1185 CryptMemFree(toDelete);
1186 }
1187 LeaveCriticalSection(&store->cs);
1188 }
1189 ret = CRYPT_SerializeContextsToReg(key, interfaces[i],
1190 store->memStore);
1191 RegCloseKey(key);
1192 }
1193 else
1194 {
1195 SetLastError(rc);
1196 ret = FALSE;
1197 }
1198 }
1199 return ret;
1200 }
1201
1202 /* If force is true or the registry store is dirty, writes the contents of the
1203 * store to the registry.
1204 */
1205 static BOOL CRYPT_RegFlushStore(PWINE_REGSTOREINFO store, BOOL force)
1206 {
1207 BOOL ret;
1208
1209 TRACE("(%p, %d)\n", store, force);
1210
1211 if (store->dirty || force)
1212 ret = CRYPT_RegWriteToReg(store);
1213 else
1214 ret = TRUE;
1215 return ret;
1216 }
1217
1218 static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
1219 {
1220 PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
1221
1222 TRACE("(%p, %08x)\n", store, dwFlags);
1223 if (dwFlags)
1224 FIXME("Unimplemented flags: %08x\n", dwFlags);
1225
1226 CRYPT_RegFlushStore(store, FALSE);
1227 RegCloseKey(store->key);
1228 DeleteCriticalSection(&store->cs);
1229 CryptMemFree(store);
1230 }
1231
1232 static BOOL WINAPI CRYPT_RegWriteContext(PWINE_REGSTOREINFO store,
1233 const void *context, DWORD dwFlags)
1234 {
1235 BOOL ret;
1236
1237 if (dwFlags & CERT_STORE_PROV_WRITE_ADD_FLAG)
1238 {
1239 store->dirty = TRUE;
1240 ret = TRUE;
1241 }
1242 else
1243 ret = FALSE;
1244 return ret;
1245 }
1246
1247 static BOOL CRYPT_RegDeleteContext(PWINE_REGSTOREINFO store,
1248 struct list *deleteList, const void *context,
1249 PCWINE_CONTEXT_INTERFACE contextInterface)
1250 {
1251 BOOL ret;
1252
1253 if (store->dwOpenFlags & CERT_STORE_READONLY_FLAG)
1254 {
1255 SetLastError(ERROR_ACCESS_DENIED);
1256 ret = FALSE;
1257 }
1258 else
1259 {
1260 PWINE_HASH_TO_DELETE toDelete =
1261 CryptMemAlloc(sizeof(WINE_HASH_TO_DELETE));
1262
1263 if (toDelete)
1264 {
1265 DWORD size = sizeof(toDelete->hash);
1266
1267 ret = contextInterface->getProp(context, CERT_HASH_PROP_ID,
1268 toDelete->hash, &size);
1269 if (ret)
1270 {
1271 EnterCriticalSection(&store->cs);
1272 list_add_tail(deleteList, &toDelete->entry);
1273 LeaveCriticalSection(&store->cs);
1274 }
1275 else
1276 {
1277 CryptMemFree(toDelete);
1278 ret = FALSE;
1279 }
1280 }
1281 else
1282 ret = FALSE;
1283 if (ret)
1284 store->dirty = TRUE;
1285 }
1286 return ret;
1287 }
1288
1289 static BOOL WINAPI CRYPT_RegWriteCert(HCERTSTORE hCertStore,
1290 PCCERT_CONTEXT cert, DWORD dwFlags)
1291 {
1292 PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
1293
1294 TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
1295
1296 return CRYPT_RegWriteContext(store, cert, dwFlags);
1297 }
1298
1299 static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore,
1300 PCCERT_CONTEXT pCertContext, DWORD dwFlags)
1301 {
1302 PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
1303
1304 TRACE("(%p, %p, %08x)\n", store, pCertContext, dwFlags);
1305
1306 return CRYPT_RegDeleteContext(store, &store->certsToDelete, pCertContext,
1307 pCertInterface);
1308 }
1309
1310 static BOOL WINAPI CRYPT_RegWriteCRL(HCERTSTORE hCertStore,
1311 PCCRL_CONTEXT crl, DWORD dwFlags)
1312 {
1313 PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
1314
1315 TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
1316
1317 return CRYPT_RegWriteContext(store, crl, dwFlags);
1318 }
1319
1320 static BOOL WINAPI CRYPT_RegDeleteCRL(HCERTSTORE hCertStore,
1321 PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
1322 {
1323 PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
1324
1325 TRACE("(%p, %p, %08x)\n", store, pCrlContext, dwFlags);
1326
1327 return CRYPT_RegDeleteContext(store, &store->crlsToDelete, pCrlContext,
1328 pCRLInterface);
1329 }
1330
1331 static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
1332 DWORD dwCtrlType, void const *pvCtrlPara)
1333 {
1334 PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
1335 BOOL ret;
1336
1337 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
1338 pvCtrlPara);
1339
1340 switch (dwCtrlType)
1341 {
1342 case CERT_STORE_CTRL_RESYNC:
1343 CRYPT_RegFlushStore(store, FALSE);
1344 CRYPT_MemEmptyStore((PWINE_MEMSTORE)store->memStore);
1345 CRYPT_RegReadFromReg(store);
1346 ret = TRUE;
1347 break;
1348 case CERT_STORE_CTRL_COMMIT:
1349 ret = CRYPT_RegFlushStore(store,
1350 dwFlags & CERT_STORE_CTRL_COMMIT_FORCE_FLAG);
1351 break;
1352 default:
1353 FIXME("%d: stub\n", dwCtrlType);
1354 ret = FALSE;
1355 }
1356 return ret;
1357 }
1358
1359 /* Copied from shlwapi's SHDeleteKeyW, and reformatted to match this file. */
1360 static DWORD CRYPT_RecurseDeleteKey(HKEY hKey, LPCWSTR lpszSubKey)
1361 {
1362 DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
1363 WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1364 HKEY hSubKey = 0;
1365
1366 TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
1367
1368 dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1369 if (!dwRet)
1370 {
1371 /* Find how many subkeys there are */
1372 dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1373 &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1374 if (!dwRet)
1375 {
1376 dwMaxSubkeyLen++;
1377 if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
1378 {
1379 /* Name too big: alloc a buffer for it */
1380 lpszName = CryptMemAlloc(dwMaxSubkeyLen*sizeof(WCHAR));
1381 }
1382
1383 if (!lpszName)
1384 dwRet = ERROR_NOT_ENOUGH_MEMORY;
1385 else
1386 {
1387 /* Recursively delete all the subkeys */
1388 for (i = 0; i < dwKeyCount && !dwRet; i++)
1389 {
1390 dwSize = dwMaxSubkeyLen;
1391 dwRet = RegEnumKeyExW(hSubKey, i, lpszName, &dwSize, NULL,
1392 NULL, NULL, NULL);
1393 if (!dwRet)
1394 dwRet = CRYPT_RecurseDeleteKey(hSubKey, lpszName);
1395 }
1396
1397 if (lpszName != szNameBuf)
1398 {
1399 /* Free buffer if allocated */
1400 CryptMemFree(lpszName);
1401 }
1402 }
1403 }
1404
1405 RegCloseKey(hSubKey);
1406 if (!dwRet)
1407 dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1408 }
1409 return dwRet;
1410 }
1411
1412 static void *regProvFuncs[] = {
1413 CRYPT_RegCloseStore,
1414 NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
1415 CRYPT_RegWriteCert,
1416 CRYPT_RegDeleteCert,
1417 NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
1418 NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
1419 CRYPT_RegWriteCRL,
1420 CRYPT_RegDeleteCRL,
1421 NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
1422 NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
1423 NULL, /* CERT_STORE_PROV_WRITE_CTL_FUNC */
1424 NULL, /* CERT_STORE_PROV_DELETE_CTL_FUNC */
1425 NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
1426 CRYPT_RegControl,
1427 };
1428
1429 static WINECRYPT_CERTSTORE *CRYPT_RegOpenStore(HCRYPTPROV hCryptProv,
1430 DWORD dwFlags, const void *pvPara)
1431 {
1432 PWINECRYPT_CERTSTORE store = NULL;
1433
1434 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
1435
1436 if (dwFlags & CERT_STORE_DELETE_FLAG)
1437 {
1438 DWORD rc = CRYPT_RecurseDeleteKey((HKEY)pvPara, CertsW);
1439
1440 if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
1441 rc = CRYPT_RecurseDeleteKey((HKEY)pvPara, CRLsW);
1442 if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
1443 rc = CRYPT_RecurseDeleteKey((HKEY)pvPara, CTLsW);
1444 if (rc == ERROR_NO_MORE_ITEMS)
1445 rc = ERROR_SUCCESS;
1446 SetLastError(rc);
1447 }
1448 else
1449 {
1450 HKEY key;
1451
1452 if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
1453 GetCurrentProcess(), (LPHANDLE)&key,
1454 dwFlags & CERT_STORE_READONLY_FLAG ? KEY_READ : KEY_ALL_ACCESS,
1455 TRUE, 0))
1456 {
1457 PWINECRYPT_CERTSTORE memStore;
1458
1459 memStore = CRYPT_MemOpenStore(hCryptProv, dwFlags, NULL);
1460 if (memStore)
1461 {
1462 PWINE_REGSTOREINFO regInfo = CryptMemAlloc(
1463 sizeof(WINE_REGSTOREINFO));
1464
1465 if (regInfo)
1466 {
1467 CERT_STORE_PROV_INFO provInfo = { 0 };
1468
1469 regInfo->dwOpenFlags = dwFlags;
1470 regInfo->cryptProv = hCryptProv;
1471 regInfo->memStore = memStore;
1472 regInfo->key = key;
1473 InitializeCriticalSection(&regInfo->cs);
1474 list_init(&regInfo->certsToDelete);
1475 list_init(&regInfo->crlsToDelete);
1476 CRYPT_RegReadFromReg(regInfo);
1477 regInfo->dirty = FALSE;
1478 provInfo.cbSize = sizeof(provInfo);
1479 provInfo.cStoreProvFunc = sizeof(regProvFuncs) /
1480 sizeof(regProvFuncs[0]);
1481 provInfo.rgpvStoreProvFunc = regProvFuncs;
1482 provInfo.hStoreProv = regInfo;
1483 store = CRYPT_ProvCreateStore(hCryptProv, dwFlags, memStore,
1484 &provInfo);
1485 }
1486 }
1487 }
1488 }
1489 TRACE("returning %p\n", store);
1490 return store;
1491 }
1492
1493 /* FIXME: this isn't complete for the Root store, in which the top-level
1494 * self-signed CA certs reside. Adding a cert to the Root store should present
1495 * the user with a dialog indicating the consequences of doing so, and asking
1496 * the user to confirm whether the cert should be added.
1497 */
1498 static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreW(HCRYPTPROV hCryptProv,
1499 DWORD dwFlags, const void *pvPara)
1500 {
1501 static const WCHAR fmt[] = { '%','s','\\','%','s',0 };
1502 LPCWSTR storeName = (LPCWSTR)pvPara;
1503 LPWSTR storePath;
1504 PWINECRYPT_CERTSTORE store = NULL;
1505 HKEY root;
1506 LPCWSTR base;
1507 BOOL ret;
1508
1509 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
1510 debugstr_w((LPCWSTR)pvPara));
1511
1512 if (!pvPara)
1513 {
1514 SetLastError(E_INVALIDARG);
1515 return NULL;
1516 }
1517
1518 ret = TRUE;
1519 switch (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK)
1520 {
1521 case CERT_SYSTEM_STORE_LOCAL_MACHINE:
1522 root = HKEY_LOCAL_MACHINE;
1523 base = CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH;
1524 break;
1525 case CERT_SYSTEM_STORE_CURRENT_USER:
1526 root = HKEY_CURRENT_USER;
1527 base = CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH;
1528 break;
1529 case CERT_SYSTEM_STORE_CURRENT_SERVICE:
1530 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
1531 * SystemCertificates
1532 */
1533 FIXME("CERT_SYSTEM_STORE_CURRENT_SERVICE, %s: stub\n",
1534 debugstr_w(storeName));
1535 return NULL;
1536 case CERT_SYSTEM_STORE_SERVICES:
1537 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
1538 * SystemCertificates
1539 */
1540 FIXME("CERT_SYSTEM_STORE_SERVICES, %s: stub\n",
1541 debugstr_w(storeName));
1542 return NULL;
1543 case CERT_SYSTEM_STORE_USERS:
1544 /* hku\user sid\Software\Microsoft\SystemCertificates */
1545 FIXME("CERT_SYSTEM_STORE_USERS, %s: stub\n",
1546 debugstr_w(storeName));
1547 return NULL;
1548 case CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY:
1549 root = HKEY_CURRENT_USER;
1550 base = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH;
1551 break;
1552 case CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY:
1553 root = HKEY_LOCAL_MACHINE;
1554 base = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH;
1555 break;
1556 case CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE:
1557 /* hklm\Software\Microsoft\EnterpriseCertificates */
1558 FIXME("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE, %s: stub\n",
1559 debugstr_w(storeName));
1560 return NULL;
1561 default:
1562 SetLastError(E_INVALIDARG);
1563 return NULL;
1564 }
1565
1566 storePath = CryptMemAlloc((lstrlenW(base) + lstrlenW(storeName) + 2) *
1567 sizeof(WCHAR));
1568 if (storePath)
1569 {
1570 LONG rc;
1571 HKEY key;
1572 REGSAM sam = dwFlags & CERT_STORE_READONLY_FLAG ? KEY_READ :
1573 KEY_ALL_ACCESS;
1574
1575 wsprintfW(storePath, fmt, base, storeName);
1576 if (dwFlags & CERT_STORE_OPEN_EXISTING_FLAG)
1577 rc = RegOpenKeyExW(root, storePath, 0, sam, &key);
1578 else
1579 {
1580 DWORD disp;
1581
1582 rc = RegCreateKeyExW(root, storePath, 0, NULL, 0, sam, NULL,
1583 &key, &disp);
1584 if (!rc && dwFlags & CERT_STORE_CREATE_NEW_FLAG &&
1585 disp == REG_OPENED_EXISTING_KEY)
1586 {
1587 RegCloseKey(key);
1588 rc = ERROR_FILE_EXISTS;
1589 }
1590 }
1591 if (!rc)
1592 {
1593 store = CRYPT_RegOpenStore(hCryptProv, dwFlags, key);
1594 RegCloseKey(key);
1595 }
1596 else
1597 SetLastError(rc);
1598 CryptMemFree(storePath);
1599 }
1600 return store;
1601 }
1602
1603 static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreA(HCRYPTPROV hCryptProv,
1604 DWORD dwFlags, const void *pvPara)
1605 {
1606 int len;
1607 PWINECRYPT_CERTSTORE ret = NULL;
1608
1609 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
1610 debugstr_a((LPCSTR)pvPara));
1611
1612 if (!pvPara)
1613 {
1614 SetLastError(ERROR_FILE_NOT_FOUND);
1615 return NULL;
1616 }
1617 len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
1618 if (len)
1619 {
1620 LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
1621
1622 if (storeName)
1623 {
1624 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
1625 ret = CRYPT_SysRegOpenStoreW(hCryptProv, dwFlags, storeName);
1626 CryptMemFree(storeName);
1627 }
1628 }
1629 return ret;
1630 }
1631
1632 static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreW(HCRYPTPROV hCryptProv,
1633 DWORD dwFlags, const void *pvPara)
1634 {
1635 HCERTSTORE store = 0;
1636 BOOL ret;
1637
1638 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
1639 debugstr_w((LPCWSTR)pvPara));
1640
1641 if (!pvPara)
1642 {
1643 SetLastError(ERROR_FILE_NOT_FOUND);
1644 return NULL;
1645 }
1646 /* This returns a different error than system registry stores if the
1647 * location is invalid.
1648 */
1649 switch (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK)
1650 {
1651 case CERT_SYSTEM_STORE_LOCAL_MACHINE:
1652 case CERT_SYSTEM_STORE_CURRENT_USER:
1653 case CERT_SYSTEM_STORE_CURRENT_SERVICE:
1654 case CERT_SYSTEM_STORE_SERVICES:
1655 case CERT_SYSTEM_STORE_USERS:
1656 case CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY:
1657 case CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY:
1658 case CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE:
1659 ret = TRUE;
1660 break;
1661 default:
1662 SetLastError(ERROR_FILE_NOT_FOUND);
1663 ret = FALSE;
1664 }
1665 if (ret)
1666 {
1667 HCERTSTORE regStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_W,
1668 0, hCryptProv, dwFlags, pvPara);
1669
1670 if (regStore)
1671 {
1672 store = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
1673 CERT_STORE_CREATE_NEW_FLAG, NULL);
1674 CertAddStoreToCollection(store, regStore,
1675 dwFlags & CERT_STORE_READONLY_FLAG ? 0 :
1676 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
1677 CertCloseStore(regStore, 0);
1678 /* CERT_SYSTEM_STORE_CURRENT_USER returns both the HKCU and HKLM
1679 * stores.
1680 */
1681 if ((dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK) ==
1682 CERT_SYSTEM_STORE_CURRENT_USER)
1683 {
1684 dwFlags &= ~CERT_SYSTEM_STORE_CURRENT_USER;
1685 dwFlags |= CERT_SYSTEM_STORE_LOCAL_MACHINE;
1686 regStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_W, 0,
1687 hCryptProv, dwFlags, pvPara);
1688 if (regStore)
1689 {
1690 CertAddStoreToCollection(store, regStore,
1691 dwFlags & CERT_STORE_READONLY_FLAG ? 0 :
1692 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
1693 CertCloseStore(regStore, 0);
1694 }
1695 }
1696 }
1697 }
1698 return (PWINECRYPT_CERTSTORE)store;
1699 }
1700
1701 static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreA(HCRYPTPROV hCryptProv,
1702 DWORD dwFlags, const void *pvPara)
1703 {
1704 int len;
1705 PWINECRYPT_CERTSTORE ret = NULL;
1706
1707 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
1708 debugstr_a((LPCSTR)pvPara));
1709
1710 if (!pvPara)
1711 {
1712 SetLastError(ERROR_FILE_NOT_FOUND);
1713 return NULL;
1714 }
1715 len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
1716 if (len)
1717 {
1718 LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
1719
1720 if (storeName)
1721 {
1722 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
1723 ret = CRYPT_SysOpenStoreW(hCryptProv, dwFlags, storeName);
1724 CryptMemFree(storeName);
1725 }
1726 }
1727 return ret;
1728 }
1729
1730 static void WINAPI CRYPT_FileCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
1731 {
1732 PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
1733
1734 TRACE("(%p, %08x)\n", store, dwFlags);
1735 if (store->dirty)
1736 CRYPT_WriteSerializedFile(store->file, store->memStore);
1737 CertCloseStore(store->memStore, dwFlags);
1738 CloseHandle(store->file);
1739 CryptMemFree(store);
1740 }
1741
1742 static BOOL WINAPI CRYPT_FileWriteCert(HCERTSTORE hCertStore,
1743 PCCERT_CONTEXT cert, DWORD dwFlags)
1744 {
1745 PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
1746
1747 TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
1748 store->dirty = TRUE;
1749 return TRUE;
1750 }
1751
1752 static BOOL WINAPI CRYPT_FileDeleteCert(HCERTSTORE hCertStore,
1753 PCCERT_CONTEXT pCertContext, DWORD dwFlags)
1754 {
1755 PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
1756
1757 TRACE("(%p, %p, %08x)\n", hCertStore, pCertContext, dwFlags);
1758 store->dirty = TRUE;
1759 return TRUE;
1760 }
1761
1762 static BOOL WINAPI CRYPT_FileWriteCRL(HCERTSTORE hCertStore,
1763 PCCRL_CONTEXT crl, DWORD dwFlags)
1764 {
1765 PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
1766
1767 TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
1768 store->dirty = TRUE;
1769 return TRUE;
1770 }
1771
1772 static BOOL WINAPI CRYPT_FileDeleteCRL(HCERTSTORE hCertStore,
1773 PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
1774 {
1775 PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
1776
1777 TRACE("(%p, %p, %08x)\n", hCertStore, pCrlContext, dwFlags);
1778 store->dirty = TRUE;
1779 return TRUE;
1780 }
1781
1782 static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
1783 DWORD dwCtrlType, void const *pvCtrlPara)
1784 {
1785 PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
1786 BOOL ret;
1787
1788 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
1789 pvCtrlPara);
1790
1791 switch (dwCtrlType)
1792 {
1793 case CERT_STORE_CTRL_RESYNC:
1794 CRYPT_MemEmptyStore((PWINE_MEMSTORE)store->memStore);
1795 CRYPT_ReadSerializedFile(store->file, store);
1796 ret = TRUE;
1797 break;
1798 case CERT_STORE_CTRL_COMMIT:
1799 if (!(store->dwOpenFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
1800 {
1801 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1802 ret = FALSE;
1803 }
1804 else if (store->dirty)
1805 ret = CRYPT_WriteSerializedFile(store->file, store->memStore);
1806 else
1807 ret = TRUE;
1808 break;
1809 default:
1810 FIXME("%d: stub\n", dwCtrlType);
1811 ret = FALSE;
1812 }
1813 return ret;
1814 }
1815
1816 static void *fileProvFuncs[] = {
1817 CRYPT_FileCloseStore,
1818 NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
1819 CRYPT_FileWriteCert,
1820 CRYPT_FileDeleteCert,
1821 NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
1822 NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
1823 CRYPT_FileWriteCRL,
1824 CRYPT_FileDeleteCRL,
1825 NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
1826 NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
1827 NULL, /* CERT_STORE_PROV_WRITE_CTL_FUNC */
1828 NULL, /* CERT_STORE_PROV_DELETE_CTL_FUNC */
1829 NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
1830 CRYPT_FileControl,
1831 };
1832
1833 static PWINECRYPT_CERTSTORE CRYPT_FileOpenStore(HCRYPTPROV hCryptProv,
1834 DWORD dwFlags, const void *pvPara)
1835 {
1836 PWINECRYPT_CERTSTORE store = NULL;
1837 HANDLE file = (HANDLE)pvPara;
1838
1839 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
1840
1841 if (!pvPara)
1842 {
1843 SetLastError(ERROR_INVALID_HANDLE);
1844 return NULL;
1845 }
1846 if (dwFlags & CERT_STORE_DELETE_FLAG)
1847 {
1848 SetLastError(E_INVALIDARG);
1849 return NULL;
1850 }
1851 if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
1852 (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
1853 {
1854 SetLastError(E_INVALIDARG);
1855 return NULL;
1856 }
1857
1858 if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
1859 GetCurrentProcess(), &file, dwFlags & CERT_STORE_READONLY_FLAG ?
1860 GENERIC_READ : GENERIC_READ | GENERIC_WRITE, TRUE, 0))
1861 {
1862 PWINECRYPT_CERTSTORE memStore;
1863
1864 memStore = CRYPT_MemOpenStore(hCryptProv, dwFlags, NULL);
1865 if (memStore)
1866 {
1867 if (CRYPT_ReadSerializedFile(file, memStore))
1868 {
1869 PWINE_FILESTOREINFO info = CryptMemAlloc(
1870 sizeof(WINE_FILESTOREINFO));
1871
1872 if (info)
1873 {
1874 CERT_STORE_PROV_INFO provInfo = { 0 };
1875
1876 info->dwOpenFlags = dwFlags;
1877 info->cryptProv = hCryptProv;
1878 info->memStore = memStore;
1879 info->file = file;
1880 info->dirty = FALSE;
1881 provInfo.cbSize = sizeof(provInfo);
1882 provInfo.cStoreProvFunc = sizeof(fileProvFuncs) /
1883 sizeof(fileProvFuncs[0]);
1884 provInfo.rgpvStoreProvFunc = fileProvFuncs;
1885 provInfo.hStoreProv = info;
1886 store = CRYPT_ProvCreateStore(hCryptProv, dwFlags, memStore,
1887 &provInfo);
1888 }
1889 }
1890 }
1891 }
1892 TRACE("returning %p\n", store);
1893 return store;
1894 }
1895
1896 static PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
1897 DWORD dwFlags, const void *pvPara)
1898 {
1899 HCERTSTORE store = 0;
1900 LPCWSTR fileName = (LPCWSTR)pvPara;
1901 DWORD access, create;
1902 HANDLE file;
1903
1904 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
1905
1906 if (!fileName)
1907 {
1908 SetLastError(ERROR_PATH_NOT_FOUND);
1909 return NULL;
1910 }
1911 if (!(dwFlags & (CERT_FILE_STORE_COMMIT_ENABLE_FLAG |
1912 CERT_STORE_READONLY_FLAG)))
1913 {
1914 SetLastError(ERROR_FILE_NOT_FOUND);
1915 return NULL;
1916 }
1917
1918 access = GENERIC_READ;
1919 if (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG)
1920 access |= GENERIC_WRITE;
1921 if (dwFlags & CERT_STORE_CREATE_NEW_FLAG)
1922 create = CREATE_NEW;
1923 else if (dwFlags & CERT_STORE_OPEN_EXISTING_FLAG)
1924 create = OPEN_EXISTING;
1925 else
1926 create = OPEN_ALWAYS;
1927 file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL, create,
1928 FILE_ATTRIBUTE_NORMAL, NULL);
1929 if (file != INVALID_HANDLE_VALUE)
1930 {
1931 /* FIXME: need to check whether it's a serialized store; if not, fall
1932 * back to a PKCS#7 signed message, then to a single serialized cert.
1933 */
1934 store = CertOpenStore(CERT_STORE_PROV_FILE, 0, hCryptProv, dwFlags,
1935 file);
1936 CloseHandle(file);
1937 }
1938 return (PWINECRYPT_CERTSTORE)store;
1939 }
1940
1941 static PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
1942 DWORD dwFlags, const void *pvPara)
1943 {
1944 int len;
1945 PWINECRYPT_CERTSTORE ret = NULL;
1946
1947 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
1948 debugstr_a((LPCSTR)pvPara));
1949
1950 if (!pvPara)
1951 {
1952 SetLastError(ERROR_FILE_NOT_FOUND);
1953 return NULL;
1954 }
1955 len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
1956 if (len)
1957 {
1958 LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
1959
1960 if (storeName)
1961 {
1962 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
1963 ret = CRYPT_FileNameOpenStoreW(hCryptProv, dwFlags, storeName);
1964 CryptMemFree(storeName);
1965 }
1966 }
1967 return ret;
1968 }
1969
1970 static PWINECRYPT_CERTSTORE CRYPT_PhysOpenStoreW(HCRYPTPROV hCryptProv,
1971 DWORD dwFlags, const void *pvPara)
1972 {
1973 if (dwFlags & CERT_SYSTEM_STORE_RELOCATE_FLAG)
1974 FIXME("(%ld, %08x, %p): stub\n", hCryptProv, dwFlags, pvPara);
1975 else
1976 FIXME("(%ld, %08x, %s): stub\n", hCryptProv, dwFlags,
1977 debugstr_w((LPCWSTR)pvPara));
1978 return NULL;
1979 }
1980
1981 HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider,
1982 DWORD dwMsgAndCertEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags,
1983 const void* pvPara)
1984 {
1985 WINECRYPT_CERTSTORE *hcs;
1986 StoreOpenFunc openFunc = NULL;
1987
1988 TRACE("(%s, %08x, %08lx, %08x, %p)\n", debugstr_a(lpszStoreProvider),
1989 dwMsgAndCertEncodingType, hCryptProv, dwFlags, pvPara);
1990
1991 if (!HIWORD(lpszStoreProvider))
1992 {
1993 switch (LOWORD(lpszStoreProvider))
1994 {
1995 case (int)CERT_STORE_PROV_MEMORY:
1996 openFunc = CRYPT_MemOpenStore;
1997 break;
1998 case (int)CERT_STORE_PROV_FILE:
1999 openFunc = CRYPT_FileOpenStore;
2000 break;
2001 case (int)CERT_STORE_PROV_REG:
2002 openFunc = CRYPT_RegOpenStore;
2003 break;
2004 case (int)CERT_STORE_PROV_FILENAME_A:
2005 openFunc = CRYPT_FileNameOpenStoreA;
2006 break;
2007 case (int)CERT_STORE_PROV_FILENAME_W:
2008 openFunc = CRYPT_FileNameOpenStoreW;
2009 break;
2010 case (int)CERT_STORE_PROV_COLLECTION:
2011 openFunc = CRYPT_CollectionOpenStore;
2012 break;
2013 case (int)CERT_STORE_PROV_SYSTEM_A:
2014 openFunc = CRYPT_SysOpenStoreA;
2015 break;
2016 case (int)CERT_STORE_PROV_SYSTEM_W:
2017 openFunc = CRYPT_SysOpenStoreW;
2018 break;
2019 case (int)CERT_STORE_PROV_SYSTEM_REGISTRY_A:
2020 openFunc = CRYPT_SysRegOpenStoreA;
2021 break;
2022 case (int)CERT_STORE_PROV_SYSTEM_REGISTRY_W:
2023 openFunc = CRYPT_SysRegOpenStoreW;
2024 break;
2025 case (int)CERT_STORE_PROV_PHYSICAL_W:
2026 openFunc = CRYPT_PhysOpenStoreW;
2027 break;
2028 default:
2029 if (LOWORD(lpszStoreProvider))
2030 FIXME("unimplemented type %d\n", LOWORD(lpszStoreProvider));
2031 }
2032 }
2033 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_MEMORY))
2034 openFunc = CRYPT_MemOpenStore;
2035 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_FILENAME_W))
2036 openFunc = CRYPT_FileOpenStore;
2037 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SYSTEM))
2038 openFunc = CRYPT_SysOpenStoreW;
2039 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_COLLECTION))
2040 openFunc = CRYPT_CollectionOpenStore;
2041 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SYSTEM_REGISTRY))
2042 openFunc = CRYPT_SysRegOpenStoreW;
2043 else
2044 {
2045 FIXME("unimplemented type %s\n", lpszStoreProvider);
2046 openFunc = NULL;
2047 }
2048
2049 if (!openFunc)
2050 hcs = CRYPT_ProvOpenStore(lpszStoreProvider, dwMsgAndCertEncodingType,
2051 hCryptProv, dwFlags, pvPara);
2052 else
2053 hcs = openFunc(hCryptProv, dwFlags, pvPara);
2054 return (HCERTSTORE)hcs;
2055 }
2056
2057 HCERTSTORE WINAPI CertOpenSystemStoreA(HCRYPTPROV hProv,
2058 LPCSTR szSubSystemProtocol)
2059 {
2060 if (!szSubSystemProtocol)
2061 {
2062 SetLastError(E_INVALIDARG);
2063 return 0;
2064 }
2065 return CertOpenStore(CERT_STORE_PROV_SYSTEM_A, 0, hProv,
2066 CERT_SYSTEM_STORE_CURRENT_USER, szSubSystemProtocol);
2067 }
2068
2069 HCERTSTORE WINAPI CertOpenSystemStoreW(HCRYPTPROV hProv,
2070 LPCWSTR szSubSystemProtocol)
2071 {
2072 if (!szSubSystemProtocol)
2073 {
2074 SetLastError(E_INVALIDARG);
2075 return 0;
2076 }
2077 return CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, hProv,
2078 CERT_SYSTEM_STORE_CURRENT_USER, szSubSystemProtocol);
2079 }
2080
2081 BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
2082 DWORD dwSaveAs, DWORD dwSaveTo, void* pvSaveToPara, DWORD dwFlags)
2083 {
2084 FIXME("(%p,%d,%d,%d,%p,%08x) stub!\n", hCertStore,
2085 dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
2086 return TRUE;
2087 }
2088
2089 DWORD CertStore_GetAccessState(HCERTSTORE hCertStore)
2090 {
2091 DWORD state = 0;
2092
2093 if (hCertStore)
2094 {
2095 PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
2096
2097 if (store->type != StoreTypeMem &&
2098 !(store->dwOpenFlags & CERT_STORE_READONLY_FLAG))
2099 state |= CERT_ACCESS_STATE_WRITE_PERSIST_FLAG;
2100 }
2101 return state;
2102 }
2103
2104 #define CertContext_CopyProperties(to, from) \
2105 Context_CopyProperties((to), (from), sizeof(CERT_CONTEXT))
2106
2107 BOOL WINAPI CertAddCertificateContextToStore(HCERTSTORE hCertStore,
2108 PCCERT_CONTEXT pCertContext, DWORD dwAddDisposition,
2109 PCCERT_CONTEXT *ppStoreContext)
2110 {
2111 PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
2112 BOOL ret = TRUE;
2113 PCCERT_CONTEXT toAdd = NULL, existing = NULL;
2114
2115 TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCertContext,
2116 dwAddDisposition, ppStoreContext);
2117
2118 /* Weird case to pass a test */
2119 if (dwAddDisposition == 0)
2120 {
2121 SetLastError(STATUS_ACCESS_VIOLATION);
2122 return FALSE;
2123 }
2124 if (dwAddDisposition != CERT_STORE_ADD_ALWAYS)
2125 {
2126 BYTE hashToAdd[20];
2127 DWORD size = sizeof(hashToAdd);
2128
2129 ret = CertGetCertificateContextProperty(pCertContext, CERT_HASH_PROP_ID,
2130 hashToAdd, &size);
2131 if (ret)
2132 {
2133 CRYPT_HASH_BLOB blob = { sizeof(hashToAdd), hashToAdd };
2134
2135 existing = CertFindCertificateInStore(hCertStore,
2136 pCertContext->dwCertEncodingType, 0, CERT_FIND_SHA1_HASH, &blob,
2137 NULL);
2138 }
2139 }
2140
2141 switch (dwAddDisposition)
2142 {
2143 case CERT_STORE_ADD_ALWAYS:
2144 toAdd = CertDuplicateCertificateContext(pCertContext);
2145 break;
2146 case CERT_STORE_ADD_NEW:
2147 if (existing)
2148 {
2149 TRACE("found matching certificate, not adding\n");
2150 SetLastError(CRYPT_E_EXISTS);
2151 ret = FALSE;
2152 }
2153 else
2154 toAdd = CertDuplicateCertificateContext(pCertContext);
2155 break;
2156 case CERT_STORE_ADD_REPLACE_EXISTING:
2157 toAdd = CertDuplicateCertificateContext(pCertContext);
2158 break;
2159 case CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES:
2160 toAdd = CertDuplicateCertificateContext(pCertContext);
2161 if (existing)
2162 CertContext_CopyProperties(toAdd, existing);
2163 break;
2164 case CERT_STORE_ADD_USE_EXISTING:
2165 if (existing)
2166 CertContext_CopyProperties(existing, pCertContext);
2167 break;
2168 default:
2169 FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
2170 ret = FALSE;
2171 }
2172
2173 if (toAdd)
2174 {
2175 if (store)
2176 ret = store->certs.addContext(store, (void *)toAdd,
2177 (void *)existing, (const void **)ppStoreContext);
2178 else if (ppStoreContext)
2179 *ppStoreContext = CertDuplicateCertificateContext(toAdd);
2180 CertFreeCertificateContext(toAdd);
2181 }
2182 CertFreeCertificateContext(existing);
2183
2184 TRACE("returning %d\n", ret);
2185 return ret;
2186 }
2187
2188 PCCERT_CONTEXT WINAPI CertEnumCertificatesInStore(HCERTSTORE hCertStore,
2189 PCCERT_CONTEXT pPrev)
2190 {
2191 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2192 PCCERT_CONTEXT ret;
2193
2194 TRACE("(%p, %p)\n", hCertStore, pPrev);
2195 if (!hCertStore)
2196 ret = NULL;
2197 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2198 ret = NULL;
2199 else
2200 ret = (PCCERT_CONTEXT)hcs->certs.enumContext(hcs, (void *)pPrev);
2201 return ret;
2202 }
2203
2204 BOOL WINAPI CertDeleteCertificateFromStore(PCCERT_CONTEXT pCertContext)
2205 {
2206 BOOL ret;
2207
2208 TRACE("(%p)\n", pCertContext);
2209
2210 if (!pCertContext)
2211 ret = TRUE;
2212 else if (!pCertContext->hCertStore)
2213 {
2214 ret = TRUE;
2215 CertFreeCertificateContext(pCertContext);
2216 }
2217 else
2218 {
2219 PWINECRYPT_CERTSTORE hcs =
2220 (PWINECRYPT_CERTSTORE)pCertContext->hCertStore;
2221
2222 if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2223 ret = FALSE;
2224 else
2225 ret = hcs->certs.deleteContext(hcs, (void *)pCertContext);
2226 CertFreeCertificateContext(pCertContext);
2227 }
2228 return ret;
2229 }
2230
2231 #define CrlContext_CopyProperties(to, from) \
2232 Context_CopyProperties((to), (from), sizeof(CRL_CONTEXT))
2233
2234 BOOL WINAPI CertAddCRLContextToStore(HCERTSTORE hCertStore,
2235 PCCRL_CONTEXT pCrlContext, DWORD dwAddDisposition,
2236 PCCRL_CONTEXT* ppStoreContext)
2237 {
2238 PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
2239 BOOL ret = TRUE;
2240 PCCRL_CONTEXT toAdd = NULL, existing = NULL;
2241
2242 TRACE("(%p, %p, %08x, %p)\n", hCertStore, pCrlContext,
2243 dwAddDisposition, ppStoreContext);
2244
2245 /* Weird case to pass a test */
2246 if (dwAddDisposition == 0)
2247 {
2248 SetLastError(STATUS_ACCESS_VIOLATION);
2249 return FALSE;
2250 }
2251 if (dwAddDisposition != CERT_STORE_ADD_ALWAYS)
2252 {
2253 existing = CertFindCRLInStore(hCertStore, 0, 0, CRL_FIND_EXISTING,
2254 pCrlContext, NULL);
2255 }
2256
2257 switch (dwAddDisposition)
2258 {
2259 case CERT_STORE_ADD_ALWAYS:
2260 toAdd = CertDuplicateCRLContext(pCrlContext);
2261 break;
2262 case CERT_STORE_ADD_NEW:
2263 if (existing)
2264 {
2265 TRACE("found matching CRL, not adding\n");
2266 SetLastError(CRYPT_E_EXISTS);
2267 ret = FALSE;
2268 }
2269 else
2270 toAdd = CertDuplicateCRLContext(pCrlContext);
2271 break;
2272 case CERT_STORE_ADD_NEWER:
2273 if (existing)
2274 {
2275 LONG newer = CompareFileTime(&existing->pCrlInfo->ThisUpdate,
2276 &pCrlContext->pCrlInfo->ThisUpdate);
2277
2278 if (newer < 0)
2279 toAdd = CertDuplicateCRLContext(pCrlContext);
2280 else
2281 {
2282 TRACE("existing CRL is newer, not adding\n");
2283 SetLastError(CRYPT_E_EXISTS);
2284 ret = FALSE;
2285 }
2286 }
2287 else
2288 toAdd = CertDuplicateCRLContext(pCrlContext);
2289 break;
2290 case CERT_STORE_ADD_REPLACE_EXISTING:
2291 toAdd = CertDuplicateCRLContext(pCrlContext);
2292 break;
2293 case CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES:
2294 toAdd = CertDuplicateCRLContext(pCrlContext);
2295 if (existing)
2296 CrlContext_CopyProperties(toAdd, existing);
2297 break;
2298 case CERT_STORE_ADD_USE_EXISTING:
2299 if (existing)
2300 CrlContext_CopyProperties(existing, pCrlContext);
2301 break;
2302 default:
2303 FIXME("Unimplemented add disposition %d\n", dwAddDisposition);
2304 ret = FALSE;
2305 }
2306
2307 if (toAdd)
2308 {
2309 if (store)
2310 ret = store->crls.addContext(store, (void *)toAdd,
2311 (void *)existing, (const void **)ppStoreContext);
2312 else if (ppStoreContext)
2313 *ppStoreContext = CertDuplicateCRLContext(toAdd);
2314 CertFreeCRLContext(toAdd);
2315 }
2316 CertFreeCRLContext(existing);
2317
2318 TRACE("returning %d\n", ret);
2319 return ret;
2320 }
2321
2322 BOOL WINAPI CertDeleteCRLFromStore(PCCRL_CONTEXT pCrlContext)
2323 {
2324 BOOL ret;
2325
2326 TRACE("(%p)\n", pCrlContext);
2327
2328 if (!pCrlContext)
2329 ret = TRUE;
2330 else if (!pCrlContext->hCertStore)
2331 {
2332 ret = TRUE;
2333 CertFreeCRLContext(pCrlContext);
2334 }
2335 else
2336 {
2337 PWINECRYPT_CERTSTORE hcs =
2338 (PWINECRYPT_CERTSTORE)pCrlContext->hCertStore;
2339
2340 if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2341 ret = FALSE;
2342 else
2343 ret = hcs->crls.deleteContext(hcs, (void *)pCrlContext);
2344 CertFreeCRLContext(pCrlContext);
2345 }
2346 return ret;
2347 }
2348
2349 PCCRL_CONTEXT WINAPI CertEnumCRLsInStore(HCERTSTORE hCertStore,
2350 PCCRL_CONTEXT pPrev)
2351 {
2352 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2353 PCCRL_CONTEXT ret;
2354
2355 TRACE("(%p, %p)\n", hCertStore, pPrev);
2356 if (!hCertStore)
2357 ret = NULL;
2358 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2359 ret = NULL;
2360 else
2361 ret = (PCCRL_CONTEXT)hcs->crls.enumContext(hcs, (void *)pPrev);
2362 return ret;
2363 }
2364
2365 PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwCertEncodingType,
2366 const BYTE* pbCtlEncoded, DWORD cbCtlEncoded)
2367 {
2368 FIXME("(%08x, %p, %08x): stub\n", dwCertEncodingType, pbCtlEncoded,
2369 cbCtlEncoded);
2370 return NULL;
2371 }
2372
2373 BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore,
2374 DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded,
2375 DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext)
2376 {
2377 FIXME("(%p, %08x, %p, %d, %08x, %p): stub\n", hCertStore,
2378 dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition,
2379 ppCtlContext);
2380 return FALSE;
2381 }
2382
2383 BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore,
2384 PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition,
2385 PCCTL_CONTEXT* ppStoreContext)
2386 {
2387 FIXME("(%p, %p, %08x, %p): stub\n", hCertStore, pCtlContext,
2388 dwAddDisposition, ppStoreContext);
2389 return TRUE;
2390 }
2391
2392 PCCTL_CONTEXT WINAPI CertDuplicateCTLContext(PCCTL_CONTEXT pCtlContext)
2393 {
2394 FIXME("(%p): stub\n", pCtlContext );
2395 return pCtlContext;
2396 }
2397
2398 BOOL WINAPI CertFreeCTLContext(PCCTL_CONTEXT pCtlContext)
2399 {
2400 FIXME("(%p): stub\n", pCtlContext );
2401 return TRUE;
2402 }
2403
2404 BOOL WINAPI CertDeleteCTLFromStore(PCCTL_CONTEXT pCtlContext)
2405 {
2406 FIXME("(%p): stub\n", pCtlContext);
2407 return TRUE;
2408 }
2409
2410 PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(HCERTSTORE hCertStore,
2411 PCCTL_CONTEXT pPrev)
2412 {
2413 FIXME("(%p, %p): stub\n", hCertStore, pPrev);
2414 return NULL;
2415 }
2416
2417 HCERTSTORE WINAPI CertDuplicateStore(HCERTSTORE hCertStore)
2418 {
2419 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2420
2421 TRACE("(%p)\n", hCertStore);
2422
2423 if (hcs && hcs->dwMagic == WINE_CRYPTCERTSTORE_MAGIC)
2424 InterlockedIncrement(&hcs->ref);
2425 return hCertStore;
2426 }
2427
2428 BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
2429 {
2430 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *) hCertStore;
2431
2432 TRACE("(%p, %08x)\n", hCertStore, dwFlags);
2433
2434 if( ! hCertStore )
2435 return TRUE;
2436
2437 if ( hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC )
2438 return FALSE;
2439
2440 if (InterlockedDecrement(&hcs->ref) == 0)
2441 {
2442 TRACE("%p's ref count is 0, freeing\n", hcs);
2443 hcs->dwMagic = 0;
2444 if (!(hcs->dwOpenFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
2445 CryptReleaseContext(hcs->cryptProv, 0);
2446 hcs->closeStore(hcs, dwFlags);
2447 }
2448 else
2449 TRACE("%p's ref count is %d\n", hcs, hcs->ref);
2450 return TRUE;
2451 }
2452
2453 BOOL WINAPI CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags,
2454 DWORD dwCtrlType, void const *pvCtrlPara)
2455 {
2456 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2457 BOOL ret;
2458
2459 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
2460 pvCtrlPara);
2461
2462 if (!hcs)
2463 ret = FALSE;
2464 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2465 ret = FALSE;
2466 else
2467 {
2468 if (hcs->control)
2469 ret = hcs->control(hCertStore, dwFlags, dwCtrlType, pvCtrlPara);
2470 else
2471 ret = TRUE;
2472 }
2473 return ret;
2474 }
2475
2476 DWORD WINAPI CertEnumCTLContextProperties(PCCTL_CONTEXT pCTLContext,
2477 DWORD dwPropId)
2478 {
2479 FIXME("(%p, %d): stub\n", pCTLContext, dwPropId);
2480 return 0;
2481 }
2482
2483 BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
2484 DWORD dwPropId, void *pvData, DWORD *pcbData)
2485 {
2486 FIXME("(%p, %d, %p, %p): stub\n", pCTLContext, dwPropId, pvData, pcbData);
2487 return FALSE;
2488 }
2489
2490 BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
2491 DWORD dwPropId, DWORD dwFlags, const void *pvData)
2492 {
2493 FIXME("(%p, %d, %08x, %p): stub\n", pCTLContext, dwPropId, dwFlags,
2494 pvData);
2495 return FALSE;
2496 }
2497
2498 BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
2499 HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
2500 {
2501 PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
2502 WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
2503 PWINE_STORE_LIST_ENTRY entry;
2504 BOOL ret;
2505
2506 TRACE("(%p, %p, %08x, %d)\n", hCollectionStore, hSiblingStore,
2507 dwUpdateFlags, dwPriority);
2508
2509 if (!collection || !sibling)
2510 return TRUE;
2511 if (collection->hdr.dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2512 {
2513 SetLastError(E_INVALIDARG);
2514 return FALSE;
2515 }
2516 if (collection->hdr.type != StoreTypeCollection)
2517 {
2518 SetLastError(E_INVALIDARG);
2519 return FALSE;
2520 }
2521 if (sibling->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2522 {
2523 SetLastError(E_INVALIDARG);
2524 return FALSE;
2525 }
2526
2527 entry = CryptMemAlloc(sizeof(WINE_STORE_LIST_ENTRY));
2528 if (entry)
2529 {
2530 InterlockedIncrement(&sibling->ref);
2531 TRACE("sibling %p's ref count is %d\n", sibling, sibling->ref);
2532 entry->store = sibling;
2533 entry->dwUpdateFlags = dwUpdateFlags;
2534 entry->dwPriority = dwPriority;
2535 list_init(&entry->entry);
2536 TRACE("%p: adding %p, priority %d\n", collection, entry, dwPriority);
2537 EnterCriticalSection(&collection->cs);
2538 if (dwPriority)
2539 {
2540 PWINE_STORE_LIST_ENTRY cursor;
2541 BOOL added = FALSE;
2542
2543 LIST_FOR_EACH_ENTRY(cursor, &collection->stores,
2544 WINE_STORE_LIST_ENTRY, entry)
2545 {
2546 if (cursor->dwPriority < dwPriority)
2547 {
2548 list_add_before(&cursor->entry, &entry->entry);
2549 added = TRUE;
2550 break;
2551 }
2552 }
2553 if (!added)
2554 list_add_tail(&collection->stores, &entry->entry);
2555 }
2556 else
2557 list_add_tail(&collection->stores, &entry->entry);
2558 LeaveCriticalSection(&collection->cs);
2559 ret = TRUE;
2560 }
2561 else
2562 ret = FALSE;
2563 return ret;
2564 }
2565
2566 void WINAPI CertRemoveStoreFromCollection(HCERTSTORE hCollectionStore,
2567 HCERTSTORE hSiblingStore)
2568 {
2569 PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
2570 WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
2571 PWINE_STORE_LIST_ENTRY store, next;
2572
2573 TRACE("(%p, %p)\n", hCollectionStore, hSiblingStore);
2574
2575 if (!collection || !sibling)
2576 return;
2577 if (collection->hdr.dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2578 {
2579 SetLastError(E_INVALIDARG);
2580 return;
2581 }
2582 if (collection->hdr.type != StoreTypeCollection)
2583 return;
2584 if (sibling->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2585 {
2586 SetLastError(E_INVALIDARG);
2587 return;
2588 }
2589 EnterCriticalSection(&collection->cs);
2590 LIST_FOR_EACH_ENTRY_SAFE(store, next, &collection->stores,
2591 WINE_STORE_LIST_ENTRY, entry)
2592 {
2593 if (store->store == sibling)
2594 {
2595 list_remove(&store->entry);
2596 CertCloseStore(store->store, 0);
2597 CryptMemFree(store);
2598 break;
2599 }
2600 }
2601 LeaveCriticalSection(&collection->cs);
2602 }
useful hacks and other patches not (yet) suitable for mainline