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