?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
When decoding a signed cert, make sure it's really a cert.
[wine/multimedia.git] / dlls / crypt32 / cert.c
blobabec7f5d132b7fa6d20913ac4834084c2cff848e
1 /*
2 * Copyright 2002 Mike McCormack for CodeWeavers
3 * Copyright 2004,2005 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 * - Opening a cert store provider should be morphed to support loading
24 * external DLLs.
25 * - The concept of physical stores and locations isn't implemented. (This
26 * doesn't mean registry stores et al aren't implemented. See the PSDK for
27 * registering and enumerating physical stores and locations.)
28 * - Many flags, options and whatnot are unimplemented.
29 */
30 #include <assert.h>
31 #include <stdarg.h>
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winnls.h"
35 #include "winreg.h"
36 #include "winuser.h"
37 #include "wincrypt.h"
38 #include "wine/debug.h"
39 #include "wine/list.h"
40 #include "excpt.h"
41 #include "wine/exception.h"
42 #include "crypt32_private.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
45
46 #define WINE_CRYPTCERTSTORE_MAGIC 0x74726563
47 /* The following aren't defined in wincrypt.h, as they're "reserved" */
48 #define CERT_CERT_PROP_ID 32
49 #define CERT_CRL_PROP_ID 33
50 #define CERT_CTL_PROP_ID 34
51
52 /* Some typedefs that make it easier to abstract which type of context we're
53 * working with.
54 */
55 typedef const void *(WINAPI *CreateContextFunc)(DWORD dwCertEncodingType,
56 const BYTE *pbCertEncoded, DWORD cbCertEncoded);
57 typedef BOOL (WINAPI *AddContextToStoreFunc)(HCERTSTORE hCertStore,
58 const void *context, DWORD dwAddDisposition, const void **ppStoreContext);
59 typedef BOOL (WINAPI *AddEncodedContextToStoreFunc)(HCERTSTORE hCertStore,
60 DWORD dwCertEncodingType, const BYTE *pbEncoded, DWORD cbEncoded,
61 DWORD dwAddDisposition, const void **ppContext);
62 typedef const void *(WINAPI *EnumContextsInStoreFunc)(HCERTSTORE hCertStore,
63 const void *pPrevContext);
64 typedef BOOL (WINAPI *GetContextPropertyFunc)(const void *context,
65 DWORD dwPropID, void *pvData, DWORD *pcbData);
66 typedef BOOL (WINAPI *SetContextPropertyFunc)(const void *context,
67 DWORD dwPropID, DWORD dwFlags, const void *pvData);
68 typedef BOOL (WINAPI *SerializeElementFunc)(const void *context, DWORD dwFlags,
69 BYTE *pbElement, DWORD *pcbElement);
70 typedef BOOL (WINAPI *FreeContextFunc)(const void *context);
71 typedef BOOL (WINAPI *DeleteContextFunc)(const void *context);
72
73 /* An abstract context (certificate, CRL, or CTL) interface */
74 typedef struct _WINE_CONTEXT_INTERFACE
75 {
76 CreateContextFunc create;
77 AddContextToStoreFunc addContextToStore;
78 AddEncodedContextToStoreFunc addEncodedToStore;
79 EnumContextsInStoreFunc enumContextsInStore;
80 GetContextPropertyFunc getProp;
81 SetContextPropertyFunc setProp;
82 SerializeElementFunc serialize;
83 FreeContextFunc free;
84 DeleteContextFunc deleteFromStore;
85 } WINE_CONTEXT_INTERFACE, *PWINE_CONTEXT_INTERFACE;
86
87 static const WINE_CONTEXT_INTERFACE gCertInterface = {
88 (CreateContextFunc)CertCreateCertificateContext,
89 (AddContextToStoreFunc)CertAddCertificateContextToStore,
90 (AddEncodedContextToStoreFunc)CertAddEncodedCertificateToStore,
91 (EnumContextsInStoreFunc)CertEnumCertificatesInStore,
92 (GetContextPropertyFunc)CertGetCertificateContextProperty,
93 (SetContextPropertyFunc)CertSetCertificateContextProperty,
94 (SerializeElementFunc)CertSerializeCertificateStoreElement,
95 (FreeContextFunc)CertFreeCertificateContext,
96 (DeleteContextFunc)CertDeleteCertificateFromStore,
97 };
98
99 static const WINE_CONTEXT_INTERFACE gCRLInterface = {
100 (CreateContextFunc)CertCreateCRLContext,
101 (AddContextToStoreFunc)CertAddCRLContextToStore,
102 (AddEncodedContextToStoreFunc)CertAddEncodedCRLToStore,
103 (EnumContextsInStoreFunc)CertEnumCRLsInStore,
104 (GetContextPropertyFunc)CertGetCRLContextProperty,
105 (SetContextPropertyFunc)CertSetCRLContextProperty,
106 (SerializeElementFunc)CertSerializeCRLStoreElement,
107 (FreeContextFunc)CertFreeCRLContext,
108 (DeleteContextFunc)CertDeleteCRLFromStore,
109 };
110
111 static const WINE_CONTEXT_INTERFACE gCTLInterface = {
112 (CreateContextFunc)CertCreateCTLContext,
113 (AddContextToStoreFunc)CertAddCTLContextToStore,
114 (AddEncodedContextToStoreFunc)CertAddEncodedCTLToStore,
115 (EnumContextsInStoreFunc)CertEnumCTLsInStore,
116 (GetContextPropertyFunc)CertGetCTLContextProperty,
117 (SetContextPropertyFunc)CertSetCTLContextProperty,
118 (SerializeElementFunc)CertSerializeCTLStoreElement,
119 (FreeContextFunc)CertFreeCTLContext,
120 (DeleteContextFunc)CertDeleteCTLFromStore,
121 };
122
123 struct WINE_CRYPTCERTSTORE;
124
125 typedef struct WINE_CRYPTCERTSTORE * (*StoreOpenFunc)(HCRYPTPROV hCryptProv,
126 DWORD dwFlags, const void *pvPara);
127
128 struct _WINE_CERT_CONTEXT_REF;
129
130 /* Called to enumerate the next certificate in a store. The returned pointer
131 * must be newly allocated (via HeapAlloc): CertFreeCertificateContext frees
132 * it.
133 */
134 typedef struct _WINE_CERT_CONTEXT_REF * (*EnumCertFunc)
135 (struct WINE_CRYPTCERTSTORE *store, struct _WINE_CERT_CONTEXT_REF *pPrev);
136
137 struct _WINE_CERT_CONTEXT;
138
139 /* Called to create a new reference to an existing cert context. Should call
140 * CRYPT_InitCertRef to make sure the reference count is properly updated.
141 * If the store does not provide any additional allocated data (that is, does
142 * not need to implement a FreeCertFunc), it may use CRYPT_CreateCertRef for
143 * this.
144 */
145 typedef struct _WINE_CERT_CONTEXT_REF * (*CreateRefFunc)
146 (struct _WINE_CERT_CONTEXT *context, HCERTSTORE store);
147
148 /* Optional, called when a cert context reference is being freed. Don't free
149 * the ref pointer itself, CertFreeCertificateContext does that.
150 */
151 typedef void (*FreeCertFunc)(struct _WINE_CERT_CONTEXT_REF *ref);
152
153 typedef enum _CertStoreType {
154 StoreTypeMem,
155 StoreTypeCollection,
156 StoreTypeReg,
157 StoreTypeDummy,
158 } CertStoreType;
159
160 /* A cert store is polymorphic through the use of function pointers. A type
161 * is still needed to distinguish collection stores from other types.
162 * On the function pointers:
163 * - closeStore is called when the store's ref count becomes 0
164 * - addCert is called with a PWINE_CERT_CONTEXT as the second parameter
165 * - control is optional, but should be implemented by any store that supports
166 * persistence
167 */
168 typedef struct WINE_CRYPTCERTSTORE
169 {
170 DWORD dwMagic;
171 LONG ref;
172 DWORD dwOpenFlags;
173 HCRYPTPROV cryptProv;
174 CertStoreType type;
175 PFN_CERT_STORE_PROV_CLOSE closeStore;
176 PFN_CERT_STORE_PROV_WRITE_CERT addCert;
177 CreateRefFunc createCertRef;
178 EnumCertFunc enumCert;
179 PFN_CERT_STORE_PROV_DELETE_CERT deleteCert;
180 FreeCertFunc freeCert; /* optional */
181 PFN_CERT_STORE_PROV_CONTROL control; /* optional */
182 } WINECRYPT_CERTSTORE, *PWINECRYPT_CERTSTORE;
183
184 /* A certificate context has pointers to data that are owned by this module,
185 * so rather than duplicate the data every time a certificate context is
186 * copied, I keep a reference count to the data. Thus I have two data
187 * structures, the "true" certificate context (that has the reference count)
188 * and a reference certificate context, that has a pointer to the true context.
189 * Each one can be cast to a PCERT_CONTEXT, though you'll usually be dealing
190 * with the reference version.
191 */
192 typedef struct _WINE_CERT_CONTEXT
193 {
194 CERT_CONTEXT cert;
195 LONG ref;
196 CRITICAL_SECTION cs;
197 struct list extendedProperties;
198 } WINE_CERT_CONTEXT, *PWINE_CERT_CONTEXT;
199
200 typedef struct _WINE_CERT_CONTEXT_REF
201 {
202 CERT_CONTEXT cert;
203 WINE_CERT_CONTEXT *context;
204 } WINE_CERT_CONTEXT_REF, *PWINE_CERT_CONTEXT_REF;
205
206 /* An extended certificate property in serialized form is prefixed by this
207 * header.
208 */
209 typedef struct _WINE_CERT_PROP_HEADER
210 {
211 DWORD propID;
212 DWORD unknown; /* always 1 */
213 DWORD cb;
214 } WINE_CERT_PROP_HEADER, *PWINE_CERT_PROP_HEADER;
215
216 /* Stores an extended property in a cert. */
217 typedef struct _WINE_CERT_PROPERTY
218 {
219 WINE_CERT_PROP_HEADER hdr;
220 LPBYTE pbData;
221 struct list entry;
222 } WINE_CERT_PROPERTY, *PWINE_CERT_PROPERTY;
223
224 /* A mem store has a list of these. They're also returned by the mem store
225 * during enumeration.
226 */
227 typedef struct _WINE_CERT_LIST_ENTRY
228 {
229 WINE_CERT_CONTEXT_REF cert;
230 struct list entry;
231 } WINE_CERT_LIST_ENTRY, *PWINE_CERT_LIST_ENTRY;
232
233 typedef struct _WINE_MEMSTORE
234 {
235 WINECRYPT_CERTSTORE hdr;
236 CRITICAL_SECTION cs;
237 struct list certs;
238 } WINE_MEMSTORE, *PWINE_MEMSTORE;
239
240 typedef struct _WINE_HASH_TO_DELETE
241 {
242 BYTE hash[20];
243 struct list entry;
244 } WINE_HASH_TO_DELETE, *PWINE_HASH_TO_DELETE;
245
246 /* Returned by a reg store during enumeration. */
247 typedef struct _WINE_REG_CERT_CONTEXT
248 {
249 WINE_CERT_CONTEXT_REF cert;
250 PWINE_CERT_CONTEXT_REF childContext;
251 } WINE_REG_CERT_CONTEXT, *PWINE_REG_CERT_CONTEXT;
252
253 typedef struct _WINE_REGSTORE
254 {
255 WINECRYPT_CERTSTORE hdr;
256 PWINECRYPT_CERTSTORE memStore;
257 HKEY key;
258 BOOL dirty;
259 CRITICAL_SECTION cs;
260 struct list certsToDelete;
261 } WINE_REGSTORE, *PWINE_REGSTORE;
262
263 typedef struct _WINE_STORE_LIST_ENTRY
264 {
265 PWINECRYPT_CERTSTORE store;
266 DWORD dwUpdateFlags;
267 DWORD dwPriority;
268 struct list entry;
269 } WINE_STORE_LIST_ENTRY, *PWINE_STORE_LIST_ENTRY;
270
271 /* Returned by a collection store during enumeration.
272 * Note: relies on the list entry being valid after use, which a number of
273 * conditions might make untrue (reentrancy, closing a collection store before
274 * continuing an enumeration on it, ...). The tests seem to indicate this
275 * sort of unsafety is okay, since Windows isn't well-behaved in these
276 * scenarios either.
277 */
278 typedef struct _WINE_COLLECTION_CERT_CONTEXT
279 {
280 WINE_CERT_CONTEXT_REF cert;
281 PWINE_STORE_LIST_ENTRY entry;
282 PWINE_CERT_CONTEXT_REF childContext;
283 } WINE_COLLECTION_CERT_CONTEXT, *PWINE_COLLECTION_CERT_CONTEXT;
284
285 typedef struct _WINE_COLLECTIONSTORE
286 {
287 WINECRYPT_CERTSTORE hdr;
288 CRITICAL_SECTION cs;
289 struct list stores;
290 } WINE_COLLECTIONSTORE, *PWINE_COLLECTIONSTORE;
291
292 /* Like CertGetCertificateContextProperty, but operates directly on the
293 * WINE_CERT_CONTEXT. Doesn't support special-case properties, since they
294 * are handled by CertGetCertificateContextProperty, and are particular to the
295 * store in which the property exists (which is separate from the context.)
296 */
297 static BOOL WINAPI CRYPT_GetCertificateContextProperty(
298 PWINE_CERT_CONTEXT context, DWORD dwPropId, void *pvData, DWORD *pcbData);
299
300 /* Like CertSetCertificateContextProperty, but operates directly on the
301 * WINE_CERT_CONTEXT. Doesn't handle special cases, since they're handled by
302 * CertSetCertificateContextProperty anyway.
303 */
304 static BOOL WINAPI CRYPT_SetCertificateContextProperty(
305 PWINE_CERT_CONTEXT context, DWORD dwPropId, DWORD dwFlags, const void *pvData);
306
307 /* Helper function for store reading functions and
308 * CertAddSerializedElementToStore. Returns a context of the appropriate type
309 * if it can, or NULL otherwise. Doesn't validate any of the properties in
310 * the serialized context (for example, bad hashes are retained.)
311 * *pdwContentType is set to the type of the returned context.
312 */
313 static const void * WINAPI CRYPT_ReadSerializedElement(const BYTE *pbElement,
314 DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType);
315
316 /* filter for page-fault exceptions */
317 static WINE_EXCEPTION_FILTER(page_fault)
318 {
319 if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
320 return EXCEPTION_EXECUTE_HANDLER;
321 return EXCEPTION_CONTINUE_SEARCH;
322 }
323
324 static void CRYPT_InitStore(WINECRYPT_CERTSTORE *store, HCRYPTPROV hCryptProv,
325 DWORD dwFlags, CertStoreType type)
326 {
327 store->ref = 1;
328 store->dwMagic = WINE_CRYPTCERTSTORE_MAGIC;
329 store->type = type;
330 if (!hCryptProv)
331 {
332 hCryptProv = CRYPT_GetDefaultProvider();
333 dwFlags |= CERT_STORE_NO_CRYPT_RELEASE_FLAG;
334 }
335 store->cryptProv = hCryptProv;
336 store->dwOpenFlags = dwFlags;
337 }
338
339 /* Initializes the reference ref to point to pCertContext, which is assumed to
340 * be a PWINE_CERT_CONTEXT, and increments pCertContext's reference count.
341 * Also sets the hCertStore member of the reference to store.
342 */
343 static void CRYPT_InitCertRef(PWINE_CERT_CONTEXT_REF ref,
344 PWINE_CERT_CONTEXT context, HCERTSTORE store)
345 {
346 TRACE("(%p, %p)\n", ref, context);
347 memcpy(&ref->cert, context, sizeof(ref->cert));
348 ref->context = context;
349 InterlockedIncrement(&context->ref);
350 ref->cert.hCertStore = store;
351 }
352
353 static PWINE_CERT_CONTEXT_REF CRYPT_CreateCertRef(PWINE_CERT_CONTEXT context,
354 HCERTSTORE store)
355 {
356 PWINE_CERT_CONTEXT_REF pCertRef = HeapAlloc(GetProcessHeap(), 0,
357 sizeof(WINE_CERT_CONTEXT_REF));
358
359 if (pCertRef)
360 CRYPT_InitCertRef(pCertRef, context, store);
361 return pCertRef;
362 }
363
364 static BOOL WINAPI CRYPT_MemAddCert(HCERTSTORE store, PCCERT_CONTEXT pCert,
365 DWORD dwAddDisposition)
366 {
367 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
368 BOOL add = FALSE, ret;
369
370 TRACE("(%p, %p, %ld)\n", store, pCert, dwAddDisposition);
371
372 switch (dwAddDisposition)
373 {
374 case CERT_STORE_ADD_ALWAYS:
375 add = TRUE;
376 break;
377 case CERT_STORE_ADD_NEW:
378 {
379 BYTE hashToAdd[20], hash[20];
380 DWORD size = sizeof(hashToAdd);
381
382 ret = CRYPT_GetCertificateContextProperty((PWINE_CERT_CONTEXT)pCert,
383 CERT_HASH_PROP_ID, hashToAdd, &size);
384 if (ret)
385 {
386 PWINE_CERT_LIST_ENTRY cursor;
387
388 /* Add if no cert with the same hash is found. */
389 add = TRUE;
390 EnterCriticalSection(&ms->cs);
391 LIST_FOR_EACH_ENTRY(cursor, &ms->certs, WINE_CERT_LIST_ENTRY, entry)
392 {
393 size = sizeof(hash);
394 ret = CertGetCertificateContextProperty(&cursor->cert.cert,
395 CERT_HASH_PROP_ID, hash, &size);
396 if (ret && !memcmp(hashToAdd, hash, size))
397 {
398 TRACE("found matching certificate, not adding\n");
399 SetLastError(CRYPT_E_EXISTS);
400 add = FALSE;
401 break;
402 }
403 }
404 LeaveCriticalSection(&ms->cs);
405 }
406 break;
407 }
408 case CERT_STORE_ADD_REPLACE_EXISTING:
409 {
410 BYTE hashToAdd[20], hash[20];
411 DWORD size = sizeof(hashToAdd);
412
413 add = TRUE;
414 ret = CRYPT_GetCertificateContextProperty((PWINE_CERT_CONTEXT)pCert,
415 CERT_HASH_PROP_ID, hashToAdd, &size);
416 if (ret)
417 {
418 PWINE_CERT_LIST_ENTRY cursor, next;
419
420 /* Look for existing cert to delete */
421 EnterCriticalSection(&ms->cs);
422 LIST_FOR_EACH_ENTRY_SAFE(cursor, next, &ms->certs,
423 WINE_CERT_LIST_ENTRY, entry)
424 {
425 size = sizeof(hash);
426 ret = CertGetCertificateContextProperty(&cursor->cert.cert,
427 CERT_HASH_PROP_ID, hash, &size);
428 if (ret && !memcmp(hashToAdd, hash, size))
429 {
430 TRACE("found matching certificate, replacing\n");
431 list_remove(&cursor->entry);
432 CertFreeCertificateContext((PCCERT_CONTEXT)cursor);
433 break;
434 }
435 }
436 LeaveCriticalSection(&ms->cs);
437 }
438 break;
439 }
440 default:
441 FIXME("Unimplemented add disposition %ld\n", dwAddDisposition);
442 add = FALSE;
443 }
444 if (add)
445 {
446 PWINE_CERT_LIST_ENTRY entry = HeapAlloc(GetProcessHeap(), 0,
447 sizeof(WINE_CERT_LIST_ENTRY));
448
449 if (entry)
450 {
451 TRACE("adding %p\n", entry);
452 CRYPT_InitCertRef(&entry->cert, (PWINE_CERT_CONTEXT)pCert, store);
453 list_init(&entry->entry);
454 EnterCriticalSection(&ms->cs);
455 list_add_tail(&ms->certs, &entry->entry);
456 LeaveCriticalSection(&ms->cs);
457 ret = TRUE;
458 }
459 else
460 ret = FALSE;
461 }
462 else
463 ret = FALSE;
464 return ret;
465 }
466
467 static PWINE_CERT_CONTEXT_REF CRYPT_MemEnumCert(PWINECRYPT_CERTSTORE store,
468 PWINE_CERT_CONTEXT_REF pPrev)
469 {
470 WINE_MEMSTORE *ms = (WINE_MEMSTORE *)store;
471 PWINE_CERT_LIST_ENTRY prevEntry = (PWINE_CERT_LIST_ENTRY)pPrev, ret;
472 struct list *listNext;
473
474 TRACE("(%p, %p)\n", store, pPrev);
475 EnterCriticalSection(&ms->cs);
476 if (prevEntry)
477 {
478 listNext = list_next(&ms->certs, &prevEntry->entry);
479 CertFreeCertificateContext((PCCERT_CONTEXT)pPrev);
480 }
481 else
482 listNext = list_next(&ms->certs, &ms->certs);
483 if (listNext)
484 {
485 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_CERT_LIST_ENTRY));
486 memcpy(ret, LIST_ENTRY(listNext, WINE_CERT_LIST_ENTRY, entry),
487 sizeof(WINE_CERT_LIST_ENTRY));
488 InterlockedIncrement(&ret->cert.context->ref);
489 }
490 else
491 {
492 SetLastError(CRYPT_E_NOT_FOUND);
493 ret = NULL;
494 }
495 LeaveCriticalSection(&ms->cs);
496
497 TRACE("returning %p\n", ret);
498 return (PWINE_CERT_CONTEXT_REF)ret;
499 }
500
501 static BOOL WINAPI CRYPT_MemDeleteCert(HCERTSTORE hCertStore,
502 PCCERT_CONTEXT pCertContext, DWORD dwFlags)
503 {
504 WINE_MEMSTORE *store = (WINE_MEMSTORE *)hCertStore;
505 WINE_CERT_CONTEXT_REF *ref = (WINE_CERT_CONTEXT_REF *)pCertContext;
506 PWINE_CERT_LIST_ENTRY cert, next;
507 BOOL ret;
508
509 /* Find the entry associated with the passed-in context, since the
510 * passed-in context may not be a list entry itself (e.g. if it came from
511 * CertDuplicateCertificateContext.) Pointing to the same context is
512 * a sufficient test of equality.
513 */
514 EnterCriticalSection(&store->cs);
515 LIST_FOR_EACH_ENTRY_SAFE(cert, next, &store->certs, WINE_CERT_LIST_ENTRY,
516 entry)
517 {
518 if (cert->cert.context == ref->context)
519 {
520 TRACE("removing %p\n", cert);
521 /* FIXME: this isn't entirely thread-safe, the entry itself isn't
522 * protected.
523 */
524 list_remove(&cert->entry);
525 cert->entry.prev = cert->entry.next = &store->certs;
526 break;
527 }
528 }
529 ret = TRUE;
530 LeaveCriticalSection(&store->cs);
531 return ret;
532 }
533
534 static void WINAPI CRYPT_MemCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
535 {
536 WINE_MEMSTORE *store = (WINE_MEMSTORE *)hCertStore;
537 PWINE_CERT_LIST_ENTRY cert, next;
538
539 TRACE("(%p, %08lx)\n", store, dwFlags);
540 if (dwFlags)
541 FIXME("Unimplemented flags: %08lx\n", dwFlags);
542
543 /* Note that CertFreeCertificateContext calls HeapFree on the passed-in
544 * pointer if its ref-count reaches zero. That's okay here because there
545 * aren't any allocated data outside of the WINE_CERT_CONTEXT_REF portion
546 * of the CertListEntry.
547 */
548 LIST_FOR_EACH_ENTRY_SAFE(cert, next, &store->certs, WINE_CERT_LIST_ENTRY,
549 entry)
550 {
551 TRACE("removing %p\n", cert);
552 list_remove(&cert->entry);
553 CertFreeCertificateContext((PCCERT_CONTEXT)cert);
554 }
555 DeleteCriticalSection(&store->cs);
556 HeapFree(GetProcessHeap(), 0, store);
557 }
558
559 static WINECRYPT_CERTSTORE *CRYPT_MemOpenStore(HCRYPTPROV hCryptProv,
560 DWORD dwFlags, const void *pvPara)
561 {
562 PWINE_MEMSTORE store;
563
564 TRACE("(%ld, %08lx, %p)\n", hCryptProv, dwFlags, pvPara);
565
566 if (dwFlags & CERT_STORE_DELETE_FLAG)
567 {
568 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
569 store = NULL;
570 }
571 else
572 {
573 store = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
574 sizeof(WINE_MEMSTORE));
575 if (store)
576 {
577 CRYPT_InitStore(&store->hdr, hCryptProv, dwFlags, StoreTypeMem);
578 store->hdr.closeStore = CRYPT_MemCloseStore;
579 store->hdr.addCert = CRYPT_MemAddCert;
580 store->hdr.createCertRef = CRYPT_CreateCertRef;
581 store->hdr.enumCert = CRYPT_MemEnumCert;
582 store->hdr.deleteCert = CRYPT_MemDeleteCert;
583 store->hdr.freeCert = NULL;
584 InitializeCriticalSection(&store->cs);
585 list_init(&store->certs);
586 }
587 }
588 return (PWINECRYPT_CERTSTORE)store;
589 }
590
591 static BOOL WINAPI CRYPT_CollectionAddCert(HCERTSTORE store,
592 PCCERT_CONTEXT pCert, DWORD dwAddDisposition)
593 {
594 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
595 PWINE_STORE_LIST_ENTRY entry, next;
596 BOOL ret;
597
598 TRACE("(%p, %p, %ld)\n", store, pCert, dwAddDisposition);
599
600 ret = FALSE;
601 EnterCriticalSection(&cs->cs);
602 LIST_FOR_EACH_ENTRY_SAFE(entry, next, &cs->stores, WINE_STORE_LIST_ENTRY,
603 entry)
604 {
605 if (entry->dwUpdateFlags & CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG)
606 {
607 ret = entry->store->addCert(entry->store, pCert, dwAddDisposition);
608 break;
609 }
610 }
611 LeaveCriticalSection(&cs->cs);
612 SetLastError(ret ? ERROR_SUCCESS : HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED));
613 return ret;
614 }
615
616 static PWINE_CERT_CONTEXT_REF CRYPT_CollectionCreateCertRef(
617 PWINE_CERT_CONTEXT context, HCERTSTORE store)
618 {
619 PWINE_COLLECTION_CERT_CONTEXT ret = HeapAlloc(GetProcessHeap(), 0,
620 sizeof(WINE_COLLECTION_CERT_CONTEXT));
621
622 if (ret)
623 {
624 /* Initialize to empty for now, just make sure the size is right */
625 CRYPT_InitCertRef((PWINE_CERT_CONTEXT_REF)ret, context, store);
626 ret->entry = NULL;
627 ret->childContext = NULL;
628 }
629 return (PWINE_CERT_CONTEXT_REF)ret;
630 }
631
632 static void WINAPI CRYPT_CollectionCloseStore(HCERTSTORE store, DWORD dwFlags)
633 {
634 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
635 PWINE_STORE_LIST_ENTRY entry, next;
636
637 TRACE("(%p, %08lx)\n", store, dwFlags);
638
639 LIST_FOR_EACH_ENTRY_SAFE(entry, next, &cs->stores, WINE_STORE_LIST_ENTRY,
640 entry)
641 {
642 TRACE("closing %p\n", entry);
643 CertCloseStore((HCERTSTORE)entry->store, dwFlags);
644 HeapFree(GetProcessHeap(), 0, entry);
645 }
646 DeleteCriticalSection(&cs->cs);
647 HeapFree(GetProcessHeap(), 0, cs);
648 }
649
650 /* Advances a collection enumeration by one cert, if possible, where advancing
651 * means:
652 * - calling the current store's enumeration function once, and returning
653 * the enumerated cert if one is returned
654 * - moving to the next store if the current store has no more items, and
655 * recursively calling itself to get the next item.
656 * Returns NULL if the collection contains no more items or on error.
657 * Assumes the collection store's lock is held.
658 */
659 static PWINE_COLLECTION_CERT_CONTEXT CRYPT_CollectionAdvanceEnum(
660 PWINE_COLLECTIONSTORE store, PWINE_STORE_LIST_ENTRY storeEntry,
661 PWINE_COLLECTION_CERT_CONTEXT pPrev)
662 {
663 PWINE_COLLECTION_CERT_CONTEXT ret;
664 PWINE_CERT_CONTEXT_REF child;
665
666 TRACE("(%p, %p, %p)\n", store, storeEntry, pPrev);
667
668 if (pPrev)
669 {
670 child = storeEntry->store->enumCert((HCERTSTORE)storeEntry->store,
671 pPrev->childContext);
672 if (child)
673 {
674 ret = pPrev;
675 memcpy(&ret->cert, child, sizeof(WINE_CERT_CONTEXT_REF));
676 ret->cert.cert.hCertStore = (HCERTSTORE)store;
677 InterlockedIncrement(&ret->cert.context->ref);
678 ret->childContext = child;
679 }
680 else
681 {
682 struct list *storeNext = list_next(&store->stores,
683 &storeEntry->entry);
684
685 pPrev->childContext = NULL;
686 CertFreeCertificateContext((PCCERT_CONTEXT)pPrev);
687 if (storeNext)
688 {
689 storeEntry = LIST_ENTRY(storeNext, WINE_STORE_LIST_ENTRY,
690 entry);
691 ret = CRYPT_CollectionAdvanceEnum(store, storeEntry, NULL);
692 }
693 else
694 {
695 SetLastError(CRYPT_E_NOT_FOUND);
696 ret = NULL;
697 }
698 }
699 }
700 else
701 {
702 child = storeEntry->store->enumCert((HCERTSTORE)storeEntry->store,
703 NULL);
704 if (child)
705 {
706 ret = (PWINE_COLLECTION_CERT_CONTEXT)CRYPT_CollectionCreateCertRef(
707 child->context, store);
708 if (ret)
709 {
710 ret->entry = storeEntry;
711 ret->childContext = child;
712 }
713 else
714 CertFreeCertificateContext((PCCERT_CONTEXT)child);
715 }
716 else
717 {
718 struct list *storeNext = list_next(&store->stores,
719 &storeEntry->entry);
720
721 if (storeNext)
722 {
723 storeEntry = LIST_ENTRY(storeNext, WINE_STORE_LIST_ENTRY,
724 entry);
725 ret = CRYPT_CollectionAdvanceEnum(store, storeEntry, NULL);
726 }
727 else
728 {
729 SetLastError(CRYPT_E_NOT_FOUND);
730 ret = NULL;
731 }
732 }
733 }
734 TRACE("returning %p\n", ret);
735 return ret;
736 }
737
738 static PWINE_CERT_CONTEXT_REF CRYPT_CollectionEnumCert(
739 PWINECRYPT_CERTSTORE store, PWINE_CERT_CONTEXT_REF pPrev)
740 {
741 PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
742 PWINE_COLLECTION_CERT_CONTEXT prevEntry =
743 (PWINE_COLLECTION_CERT_CONTEXT)pPrev, ret;
744
745 TRACE("(%p, %p)\n", store, pPrev);
746
747 if (prevEntry)
748 {
749 EnterCriticalSection(&cs->cs);
750 ret = CRYPT_CollectionAdvanceEnum(cs, prevEntry->entry, prevEntry);
751 LeaveCriticalSection(&cs->cs);
752 }
753 else
754 {
755 EnterCriticalSection(&cs->cs);
756 if (!list_empty(&cs->stores))
757 {
758 PWINE_STORE_LIST_ENTRY storeEntry;
759
760 storeEntry = LIST_ENTRY(cs->stores.next, WINE_STORE_LIST_ENTRY,
761 entry);
762 ret = CRYPT_CollectionAdvanceEnum(cs, storeEntry, prevEntry);
763 }
764 else
765 {
766 SetLastError(CRYPT_E_NOT_FOUND);
767 ret = NULL;
768 }
769 LeaveCriticalSection(&cs->cs);
770 }
771 TRACE("returning %p\n", ret);
772 return (PWINE_CERT_CONTEXT_REF)ret;
773 }
774
775 static BOOL WINAPI CRYPT_CollectionDeleteCert(HCERTSTORE hCertStore,
776 PCCERT_CONTEXT pCertContext, DWORD dwFlags)
777 {
778 PWINE_COLLECTION_CERT_CONTEXT context =
779 (PWINE_COLLECTION_CERT_CONTEXT)pCertContext;
780 BOOL ret;
781
782 TRACE("(%p, %p, %08lx)\n", hCertStore, pCertContext, dwFlags);
783
784 ret = CertDeleteCertificateFromStore((PCCERT_CONTEXT)context->childContext);
785 if (ret)
786 context->childContext = NULL;
787 return ret;
788 }
789
790 static void CRYPT_CollectionFreeCert(PWINE_CERT_CONTEXT_REF ref)
791 {
792 PWINE_COLLECTION_CERT_CONTEXT context = (PWINE_COLLECTION_CERT_CONTEXT)ref;
793
794 TRACE("(%p)\n", ref);
795
796 if (context->childContext)
797 CertFreeCertificateContext((PCCERT_CONTEXT)context->childContext);
798 }
799
800 static WINECRYPT_CERTSTORE *CRYPT_CollectionOpenStore(HCRYPTPROV hCryptProv,
801 DWORD dwFlags, const void *pvPara)
802 {
803 PWINE_COLLECTIONSTORE store;
804
805 if (dwFlags & CERT_STORE_DELETE_FLAG)
806 {
807 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
808 store = NULL;
809 }
810 else
811 {
812 store = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
813 sizeof(WINE_COLLECTIONSTORE));
814 if (store)
815 {
816 CRYPT_InitStore(&store->hdr, hCryptProv, dwFlags,
817 StoreTypeCollection);
818 store->hdr.closeStore = CRYPT_CollectionCloseStore;
819 store->hdr.addCert = CRYPT_CollectionAddCert;
820 store->hdr.createCertRef = CRYPT_CollectionCreateCertRef;
821 store->hdr.enumCert = CRYPT_CollectionEnumCert;
822 store->hdr.deleteCert = CRYPT_CollectionDeleteCert;
823 store->hdr.freeCert = CRYPT_CollectionFreeCert;
824 InitializeCriticalSection(&store->cs);
825 list_init(&store->stores);
826 }
827 }
828 return (PWINECRYPT_CERTSTORE)store;
829 }
830
831 static void CRYPT_HashToStr(LPBYTE hash, LPWSTR asciiHash)
832 {
833 static const WCHAR fmt[] = { '%','0','2','X',0 };
834 DWORD i;
835
836 assert(hash);
837 assert(asciiHash);
838
839 for (i = 0; i < 20; i++)
840 wsprintfW(asciiHash + i * 2, fmt, hash[i]);
841 }
842
843 static const WCHAR CertsW[] = { 'C','e','r','t','i','f','i','c','a','t','e','s',
844 0 };
845 static const WCHAR CRLsW[] = { 'C','R','L','s',0 };
846 static const WCHAR CTLsW[] = { 'C','T','L','s',0 };
847 static const WCHAR BlobW[] = { 'B','l','o','b',0 };
848
849 static void CRYPT_RegReadSerializedFromReg(PWINE_REGSTORE store, HKEY key,
850 DWORD contextType)
851 {
852 LONG rc;
853 DWORD index = 0;
854 WCHAR subKeyName[MAX_PATH];
855
856 do {
857 DWORD size = sizeof(subKeyName) / sizeof(WCHAR);
858
859 rc = RegEnumKeyExW(key, index++, subKeyName, &size, NULL, NULL, NULL,
860 NULL);
861 if (!rc)
862 {
863 HKEY subKey;
864
865 rc = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
866 if (!rc)
867 {
868 LPBYTE buf = NULL;
869
870 size = 0;
871 rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, NULL, &size);
872 if (!rc)
873 buf = HeapAlloc(GetProcessHeap(), 0, size);
874 if (buf)
875 {
876 rc = RegQueryValueExW(subKey, BlobW, NULL, NULL, buf,
877 &size);
878 if (!rc)
879 {
880 const void *context;
881 DWORD addedType;
882
883 TRACE("Adding cert with hash %s\n",
884 debugstr_w(subKeyName));
885 context = CRYPT_ReadSerializedElement(buf, size,
886 contextType, &addedType);
887 if (context)
888 {
889 const WINE_CONTEXT_INTERFACE *contextInterface;
890 BYTE hash[20];
891
892 switch (addedType)
893 {
894 case CERT_STORE_CERTIFICATE_CONTEXT:
895 contextInterface = &gCertInterface;
896 break;
897 case CERT_STORE_CRL_CONTEXT:
898 contextInterface = &gCRLInterface;
899 break;
900 case CERT_STORE_CTL_CONTEXT:
901 contextInterface = &gCTLInterface;
902 break;
903 default:
904 contextInterface = NULL;
905 }
906 if (contextInterface)
907 {
908 size = sizeof(hash);
909 if (contextInterface->getProp(context,
910 CERT_HASH_PROP_ID, hash, &size))
911 {
912 WCHAR asciiHash[20 * 2 + 1];
913
914 CRYPT_HashToStr(hash, asciiHash);
915 TRACE("comparing %s\n",
916 debugstr_w(asciiHash));
917 TRACE("with %s\n", debugstr_w(subKeyName));
918 if (!lstrcmpW(asciiHash, subKeyName))
919 {
920 TRACE("hash matches, adding\n");
921 contextInterface->addContextToStore(
922 store, context,
923 CERT_STORE_ADD_REPLACE_EXISTING, NULL);
924 }
925 else
926 {
927 TRACE("hash doesn't match, ignoring\n");
928 contextInterface->free(context);
929 }
930 }
931 }
932 }
933 }
934 HeapFree(GetProcessHeap(), 0, buf);
935 }
936 RegCloseKey(subKey);
937 }
938 /* Ignore intermediate errors, continue enumerating */
939 rc = ERROR_SUCCESS;
940 }
941 } while (!rc);
942 }
943
944 static void CRYPT_RegReadFromReg(PWINE_REGSTORE store)
945 {
946 static const WCHAR *subKeys[] = { CertsW, CRLsW, CTLsW };
947 static const DWORD contextFlags[] = { CERT_STORE_CERTIFICATE_CONTEXT_FLAG,
948 CERT_STORE_CRL_CONTEXT_FLAG, CERT_STORE_CTL_CONTEXT_FLAG };
949 DWORD i;
950
951 for (i = 0; i < sizeof(subKeys) / sizeof(subKeys[0]); i++)
952 {
953 HKEY key;
954 LONG rc;
955
956 rc = RegCreateKeyExW(store->key, subKeys[i], 0, NULL, 0, KEY_READ, NULL,
957 &key, NULL);
958 if (!rc)
959 {
960 CRYPT_RegReadSerializedFromReg(store, key, contextFlags[i]);
961 RegCloseKey(key);
962 }
963 }
964 }
965
966 /* Hash is assumed to be 20 bytes in length (a SHA-1 hash) */
967 static BOOL CRYPT_WriteSerializedToReg(HKEY key, LPBYTE hash, LPBYTE buf,
968 DWORD len)
969 {
970 WCHAR asciiHash[20 * 2 + 1];
971 LONG rc;
972 HKEY subKey;
973 BOOL ret;
974
975 CRYPT_HashToStr(hash, asciiHash);
976 rc = RegCreateKeyExW(key, asciiHash, 0, NULL, 0, KEY_ALL_ACCESS, NULL,
977 &subKey, NULL);
978 if (!rc)
979 {
980 rc = RegSetValueExW(subKey, BlobW, 0, REG_BINARY, buf, len);
981 RegCloseKey(subKey);
982 }
983 if (!rc)
984 ret = TRUE;
985 else
986 {
987 SetLastError(rc);
988 ret = FALSE;
989 }
990 return ret;
991 }
992
993 static BOOL CRYPT_SerializeContextsToReg(HKEY key,
994 const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore)
995 {
996 const void *context = NULL;
997 BOOL ret;
998
999 do {
1000 context = contextInterface->enumContextsInStore(memStore, context);
1001 if (context)
1002 {
1003 BYTE hash[20];
1004 DWORD hashSize = sizeof(hash);
1005
1006 ret = contextInterface->getProp(context, CERT_HASH_PROP_ID, hash,
1007 &hashSize);
1008 if (ret)
1009 {
1010 DWORD size = 0;
1011 LPBYTE buf = NULL;
1012
1013 ret = contextInterface->serialize(context, 0, NULL, &size);
1014 if (size)
1015 buf = HeapAlloc(GetProcessHeap(), 0, size);
1016 if (buf)
1017 {
1018 ret = contextInterface->serialize(context, 0, buf, &size);
1019 if (ret)
1020 ret = CRYPT_WriteSerializedToReg(key, hash, buf, size);
1021 }
1022 HeapFree(GetProcessHeap(), 0, buf);
1023 }
1024 }
1025 else
1026 ret = TRUE;
1027 } while (ret && context != NULL);
1028 if (context)
1029 contextInterface->free(context);
1030 return ret;
1031 }
1032
1033 static BOOL CRYPT_RegWriteToReg(PWINE_REGSTORE store)
1034 {
1035 static const WCHAR *subKeys[] = { CertsW, CRLsW, CTLsW };
1036 static const WINE_CONTEXT_INTERFACE *interfaces[] = { &gCertInterface,
1037 &gCRLInterface, &gCTLInterface };
1038 struct list *listToDelete[] = { &store->certsToDelete, NULL, NULL };
1039 BOOL ret = TRUE;
1040 DWORD i;
1041
1042 for (i = 0; ret && i < sizeof(subKeys) / sizeof(subKeys[0]); i++)
1043 {
1044 HKEY key;
1045 LONG rc = RegCreateKeyExW(store->key, subKeys[i], 0, NULL, 0,
1046 KEY_ALL_ACCESS, NULL, &key, NULL);
1047
1048 if (!rc)
1049 {
1050 if (listToDelete[i])
1051 {
1052 PWINE_HASH_TO_DELETE toDelete, next;
1053 WCHAR asciiHash[20 * 2 + 1];
1054
1055 EnterCriticalSection(&store->cs);
1056 LIST_FOR_EACH_ENTRY_SAFE(toDelete, next, listToDelete[i],
1057 WINE_HASH_TO_DELETE, entry)
1058 {
1059 LONG rc;
1060
1061 CRYPT_HashToStr(toDelete->hash, asciiHash);
1062 TRACE("Removing %s\n", debugstr_w(asciiHash));
1063 rc = RegDeleteKeyW(key, asciiHash);
1064 if (rc != ERROR_SUCCESS && rc != ERROR_FILE_NOT_FOUND)
1065 {
1066 SetLastError(rc);
1067 ret = FALSE;
1068 }
1069 list_remove(&toDelete->entry);
1070 HeapFree(GetProcessHeap(), 0, toDelete);
1071 }
1072 LeaveCriticalSection(&store->cs);
1073 }
1074 ret = CRYPT_SerializeContextsToReg(key, interfaces[i],
1075 store->memStore);
1076 RegCloseKey(key);
1077 }
1078 else
1079 {
1080 SetLastError(rc);
1081 ret = FALSE;
1082 }
1083 }
1084 return ret;
1085 }
1086
1087 /* If force is true or the registry store is dirty, writes the contents of the
1088 * store to the registry.
1089 */
1090 static BOOL CRYPT_RegFlushStore(PWINE_REGSTORE store, BOOL force)
1091 {
1092 BOOL ret;
1093
1094 if (store->dirty || force)
1095 ret = CRYPT_RegWriteToReg(store);
1096 else
1097 ret = TRUE;
1098 return ret;
1099 }
1100
1101 static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
1102 {
1103 PWINE_REGSTORE store = (PWINE_REGSTORE)hCertStore;
1104
1105 TRACE("(%p, %08lx)\n", store, dwFlags);
1106 if (dwFlags)
1107 FIXME("Unimplemented flags: %08lx\n", dwFlags);
1108
1109 CRYPT_RegFlushStore(store, FALSE);
1110 /* certsToDelete should already be cleared by this point */
1111 store->memStore->closeStore(store->memStore, 0);
1112 RegCloseKey(store->key);
1113 DeleteCriticalSection(&store->cs);
1114 HeapFree(GetProcessHeap(), 0, store);
1115 }
1116
1117 static BOOL WINAPI CRYPT_RegAddCert(HCERTSTORE hCertStore, PCCERT_CONTEXT cert,
1118 DWORD dwAddDisposition)
1119 {
1120 PWINE_REGSTORE store = (PWINE_REGSTORE)hCertStore;
1121 BOOL ret;
1122
1123 TRACE("(%p, %p, %ld)\n", hCertStore, cert, dwAddDisposition);
1124
1125 if (store->hdr.dwOpenFlags & CERT_STORE_READONLY_FLAG)
1126 {
1127 SetLastError(ERROR_ACCESS_DENIED);
1128 ret = FALSE;
1129 }
1130 else
1131 {
1132 ret = store->memStore->addCert(store->memStore, cert, dwAddDisposition);
1133 if (ret)
1134 store->dirty = TRUE;
1135 }
1136 return ret;
1137 }
1138
1139 static PWINE_CERT_CONTEXT_REF CRYPT_RegCreateCertRef(
1140 PWINE_CERT_CONTEXT context, HCERTSTORE store)
1141 {
1142 PWINE_REG_CERT_CONTEXT ret = HeapAlloc(GetProcessHeap(), 0,
1143 sizeof(WINE_REG_CERT_CONTEXT));
1144
1145 if (ret)
1146 {
1147 CRYPT_InitCertRef((PWINE_CERT_CONTEXT_REF)ret, context, store);
1148 ret->childContext = NULL;
1149 }
1150 return (PWINE_CERT_CONTEXT_REF)ret;
1151 }
1152
1153 static PWINE_CERT_CONTEXT_REF CRYPT_RegEnumCert(PWINECRYPT_CERTSTORE store,
1154 PWINE_CERT_CONTEXT_REF pPrev)
1155 {
1156 PWINE_REGSTORE rs = (PWINE_REGSTORE)store;
1157 PWINE_CERT_CONTEXT_REF child;
1158 PWINE_REG_CERT_CONTEXT prev = (PWINE_REG_CERT_CONTEXT)pPrev, ret = NULL;
1159
1160 TRACE("(%p, %p)\n", store, pPrev);
1161
1162 if (pPrev)
1163 {
1164 child = rs->memStore->enumCert(rs->memStore, prev->childContext);
1165 if (child)
1166 {
1167 ret = (PWINE_REG_CERT_CONTEXT)pPrev;
1168 memcpy(&ret->cert, child, sizeof(WINE_CERT_CONTEXT_REF));
1169 ret->cert.cert.hCertStore = (HCERTSTORE)store;
1170 ret->childContext = child;
1171 }
1172 }
1173 else
1174 {
1175 child = rs->memStore->enumCert(rs->memStore, NULL);
1176 if (child)
1177 {
1178 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_REG_CERT_CONTEXT));
1179
1180 if (ret)
1181 {
1182 memcpy(&ret->cert, child, sizeof(WINE_CERT_CONTEXT_REF));
1183 ret->cert.cert.hCertStore = (HCERTSTORE)store;
1184 ret->childContext = child;
1185 }
1186 else
1187 CertFreeCertificateContext((PCCERT_CONTEXT)child);
1188 }
1189 }
1190 return (PWINE_CERT_CONTEXT_REF)ret;
1191 }
1192
1193 static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore,
1194 PCCERT_CONTEXT pCertContext, DWORD dwFlags)
1195 {
1196 PWINE_REGSTORE store = (PWINE_REGSTORE)hCertStore;
1197 BOOL ret;
1198
1199 TRACE("(%p, %p, %08lx)\n", store, pCertContext, dwFlags);
1200
1201 if (store->hdr.dwOpenFlags & CERT_STORE_READONLY_FLAG)
1202 {
1203 SetLastError(ERROR_ACCESS_DENIED);
1204 ret = FALSE;
1205 }
1206 else
1207 {
1208 PWINE_HASH_TO_DELETE toDelete =
1209 HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HASH_TO_DELETE));
1210
1211 if (toDelete)
1212 {
1213 DWORD size = sizeof(toDelete->hash);
1214
1215 ret = CertGetCertificateContextProperty(pCertContext,
1216 CERT_HASH_PROP_ID, toDelete->hash, &size);
1217 if (ret)
1218 {
1219 list_init(&toDelete->entry);
1220 EnterCriticalSection(&store->cs);
1221 list_add_tail(&store->certsToDelete, &toDelete->entry);
1222 LeaveCriticalSection(&store->cs);
1223 ret = store->memStore->deleteCert(store->memStore, pCertContext,
1224 dwFlags);
1225 }
1226 else
1227 HeapFree(GetProcessHeap(), 0, toDelete);
1228 }
1229 else
1230 ret = FALSE;
1231 if (ret)
1232 store->dirty = TRUE;
1233 }
1234 return ret;
1235 }
1236
1237 static void CRYPT_RegFreeCert(PWINE_CERT_CONTEXT_REF ref)
1238 {
1239 PWINE_REG_CERT_CONTEXT context = (PWINE_REG_CERT_CONTEXT)ref;
1240
1241 TRACE("(%p)\n", ref);
1242
1243 if (context->childContext)
1244 CertFreeCertificateContext((PCCERT_CONTEXT)context->childContext);
1245 }
1246
1247 static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
1248 DWORD dwCtrlType, void const *pvCtrlPara)
1249 {
1250 PWINE_REGSTORE store = (PWINE_REGSTORE)hCertStore;
1251 BOOL ret;
1252
1253 switch (dwCtrlType)
1254 {
1255 case CERT_STORE_CTRL_RESYNC:
1256 CRYPT_RegFlushStore(store, FALSE);
1257 store->memStore->closeStore(store->memStore, 0);
1258 store->memStore = CRYPT_MemOpenStore(store->hdr.cryptProv,
1259 store->hdr.dwOpenFlags, NULL);
1260 if (store->memStore)
1261 {
1262 CRYPT_RegReadFromReg(store);
1263 ret = TRUE;
1264 }
1265 else
1266 ret = FALSE;
1267 break;
1268 case CERT_STORE_CTRL_COMMIT:
1269 ret = CRYPT_RegFlushStore(store,
1270 dwFlags & CERT_STORE_CTRL_COMMIT_FORCE_FLAG);
1271 break;
1272 default:
1273 FIXME("%ld: stub\n", dwCtrlType);
1274 ret = FALSE;
1275 }
1276 return ret;
1277 }
1278
1279 /* Copied from shlwapi's SHDeleteKeyW, and reformatted to match this file. */
1280 static DWORD CRYPT_RecurseDeleteKey(HKEY hKey, LPCWSTR lpszSubKey)
1281 {
1282 DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
1283 WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1284 HKEY hSubKey = 0;
1285
1286 TRACE("(hkey=%p,%s)\n", hKey, debugstr_w(lpszSubKey));
1287
1288 dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1289 if (!dwRet)
1290 {
1291 /* Find how many subkeys there are */
1292 dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1293 &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1294 if (!dwRet)
1295 {
1296 dwMaxSubkeyLen++;
1297 if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
1298 {
1299 /* Name too big: alloc a buffer for it */
1300 lpszName = HeapAlloc(GetProcessHeap(), 0,
1301 dwMaxSubkeyLen*sizeof(WCHAR));
1302 }
1303
1304 if (!lpszName)
1305 dwRet = ERROR_NOT_ENOUGH_MEMORY;
1306 else
1307 {
1308 /* Recursively delete all the subkeys */
1309 for (i = 0; i < dwKeyCount && !dwRet; i++)
1310 {
1311 dwSize = dwMaxSubkeyLen;
1312 dwRet = RegEnumKeyExW(hSubKey, i, lpszName, &dwSize, NULL,
1313 NULL, NULL, NULL);
1314 if (!dwRet)
1315 dwRet = CRYPT_RecurseDeleteKey(hSubKey, lpszName);
1316 }
1317
1318 if (lpszName != szNameBuf)
1319 {
1320 /* Free buffer if allocated */
1321 HeapFree(GetProcessHeap(), 0, lpszName);
1322 }
1323 }
1324 }
1325
1326 RegCloseKey(hSubKey);
1327 if (!dwRet)
1328 dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1329 }
1330 return dwRet;
1331 }
1332
1333 static WINECRYPT_CERTSTORE *CRYPT_RegOpenStore(HCRYPTPROV hCryptProv,
1334 DWORD dwFlags, const void *pvPara)
1335 {
1336 PWINE_REGSTORE store = NULL;
1337
1338 TRACE("(%ld, %08lx, %p)\n", hCryptProv, dwFlags, pvPara);
1339
1340 if (dwFlags & CERT_STORE_DELETE_FLAG)
1341 {
1342 DWORD rc = CRYPT_RecurseDeleteKey((HKEY)pvPara, CertsW);
1343
1344 if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
1345 rc = CRYPT_RecurseDeleteKey((HKEY)pvPara, CRLsW);
1346 if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
1347 rc = CRYPT_RecurseDeleteKey((HKEY)pvPara, CTLsW);
1348 if (rc == ERROR_NO_MORE_ITEMS)
1349 rc = ERROR_SUCCESS;
1350 SetLastError(rc);
1351 }
1352 else
1353 {
1354 HKEY key;
1355
1356 if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
1357 GetCurrentProcess(), (LPHANDLE)&key,
1358 dwFlags & CERT_STORE_READONLY_FLAG ? KEY_READ : KEY_ALL_ACCESS,
1359 TRUE, 0))
1360 {
1361 PWINECRYPT_CERTSTORE memStore;
1362
1363 memStore = CRYPT_MemOpenStore(hCryptProv, dwFlags, NULL);
1364 if (memStore)
1365 {
1366 store = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1367 sizeof(WINE_REGSTORE));
1368 if (store)
1369 {
1370 CRYPT_InitStore(&store->hdr, hCryptProv, dwFlags,
1371 StoreTypeReg);
1372 store->hdr.closeStore = CRYPT_RegCloseStore;
1373 store->hdr.addCert = CRYPT_RegAddCert;
1374 store->hdr.createCertRef = CRYPT_RegCreateCertRef;
1375 store->hdr.enumCert = CRYPT_RegEnumCert;
1376 store->hdr.deleteCert = CRYPT_RegDeleteCert;
1377 store->hdr.freeCert = CRYPT_RegFreeCert;
1378 store->hdr.control = CRYPT_RegControl;
1379 store->memStore = memStore;
1380 store->key = key;
1381 InitializeCriticalSection(&store->cs);
1382 list_init(&store->certsToDelete);
1383 CRYPT_RegReadFromReg(store);
1384 store->dirty = FALSE;
1385 }
1386 }
1387 }
1388 }
1389 TRACE("returning %p\n", store);
1390 return (WINECRYPT_CERTSTORE *)store;
1391 }
1392
1393 /* FIXME: this isn't complete for the Root store, in which the top-level
1394 * self-signed CA certs reside. Adding a cert to the Root store should present
1395 * the user with a dialog indicating the consequences of doing so, and asking
1396 * the user to confirm whether the cert should be added.
1397 */
1398 static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreW(HCRYPTPROV hCryptProv,
1399 DWORD dwFlags, const void *pvPara)
1400 {
1401 static const WCHAR fmt[] = { '%','s','\\','%','s',0 };
1402 LPCWSTR storeName = (LPCWSTR)pvPara;
1403 LPWSTR storePath;
1404 PWINECRYPT_CERTSTORE store = NULL;
1405 HKEY root;
1406 LPCWSTR base;
1407 BOOL ret;
1408
1409 TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags,
1410 debugstr_w((LPCWSTR)pvPara));
1411
1412 if (!pvPara)
1413 {
1414 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
1415 return NULL;
1416 }
1417
1418 ret = TRUE;
1419 switch (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK)
1420 {
1421 case CERT_SYSTEM_STORE_LOCAL_MACHINE:
1422 root = HKEY_LOCAL_MACHINE;
1423 base = CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH;
1424 break;
1425 case CERT_SYSTEM_STORE_CURRENT_USER:
1426 root = HKEY_CURRENT_USER;
1427 base = CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH;
1428 break;
1429 case CERT_SYSTEM_STORE_CURRENT_SERVICE:
1430 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
1431 * SystemCertificates
1432 */
1433 FIXME("CERT_SYSTEM_STORE_CURRENT_SERVICE, %s: stub\n",
1434 debugstr_w(storeName));
1435 return NULL;
1436 case CERT_SYSTEM_STORE_SERVICES:
1437 /* hklm\Software\Microsoft\Cryptography\Services\servicename\
1438 * SystemCertificates
1439 */
1440 FIXME("CERT_SYSTEM_STORE_SERVICES, %s: stub\n",
1441 debugstr_w(storeName));
1442 return NULL;
1443 case CERT_SYSTEM_STORE_USERS:
1444 /* hku\user sid\Software\Microsoft\SystemCertificates */
1445 FIXME("CERT_SYSTEM_STORE_USERS, %s: stub\n",
1446 debugstr_w(storeName));
1447 return NULL;
1448 case CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY:
1449 root = HKEY_CURRENT_USER;
1450 base = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH;
1451 break;
1452 case CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY:
1453 root = HKEY_LOCAL_MACHINE;
1454 base = CERT_GROUP_POLICY_SYSTEM_STORE_REGPATH;
1455 break;
1456 case CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE:
1457 /* hklm\Software\Microsoft\EnterpriseCertificates */
1458 FIXME("CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE, %s: stub\n",
1459 debugstr_w(storeName));
1460 return NULL;
1461 default:
1462 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
1463 return NULL;
1464 }
1465
1466 storePath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(base) +
1467 lstrlenW(storeName) + 2) * sizeof(WCHAR));
1468 if (storePath)
1469 {
1470 LONG rc;
1471 HKEY key;
1472 REGSAM sam = dwFlags & CERT_STORE_READONLY_FLAG ? KEY_READ :
1473 KEY_ALL_ACCESS;
1474
1475 wsprintfW(storePath, fmt, base, storeName);
1476 if (dwFlags & CERT_STORE_OPEN_EXISTING_FLAG)
1477 rc = RegOpenKeyExW(root, storePath, 0, sam, &key);
1478 else
1479 {
1480 DWORD disp;
1481
1482 rc = RegCreateKeyExW(root, storePath, 0, NULL, 0, sam, NULL,
1483 &key, &disp);
1484 if (!rc && dwFlags & CERT_STORE_CREATE_NEW_FLAG &&
1485 disp == REG_OPENED_EXISTING_KEY)
1486 {
1487 RegCloseKey(key);
1488 rc = ERROR_FILE_EXISTS;
1489 }
1490 }
1491 if (!rc)
1492 {
1493 store = CRYPT_RegOpenStore(hCryptProv, dwFlags, key);
1494 RegCloseKey(key);
1495 }
1496 else
1497 SetLastError(rc);
1498 HeapFree(GetProcessHeap(), 0, storePath);
1499 }
1500 return store;
1501 }
1502
1503 static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreA(HCRYPTPROV hCryptProv,
1504 DWORD dwFlags, const void *pvPara)
1505 {
1506 int len;
1507 PWINECRYPT_CERTSTORE ret = NULL;
1508
1509 TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags,
1510 debugstr_a((LPCSTR)pvPara));
1511
1512 if (!pvPara)
1513 {
1514 SetLastError(ERROR_FILE_NOT_FOUND);
1515 return NULL;
1516 }
1517 len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
1518 if (len)
1519 {
1520 LPWSTR storeName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1521
1522 if (storeName)
1523 {
1524 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
1525 ret = CRYPT_SysRegOpenStoreW(hCryptProv, dwFlags, storeName);
1526 HeapFree(GetProcessHeap(), 0, storeName);
1527 }
1528 }
1529 return ret;
1530 }
1531
1532 static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreW(HCRYPTPROV hCryptProv,
1533 DWORD dwFlags, const void *pvPara)
1534 {
1535 HCERTSTORE store = 0;
1536 BOOL ret;
1537
1538 TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags,
1539 debugstr_w((LPCWSTR)pvPara));
1540
1541 if (!pvPara)
1542 {
1543 SetLastError(ERROR_FILE_NOT_FOUND);
1544 return NULL;
1545 }
1546 /* This returns a different error than system registry stores if the
1547 * location is invalid.
1548 */
1549 switch (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK)
1550 {
1551 case CERT_SYSTEM_STORE_LOCAL_MACHINE:
1552 case CERT_SYSTEM_STORE_CURRENT_USER:
1553 case CERT_SYSTEM_STORE_CURRENT_SERVICE:
1554 case CERT_SYSTEM_STORE_SERVICES:
1555 case CERT_SYSTEM_STORE_USERS:
1556 case CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY:
1557 case CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY:
1558 case CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE:
1559 ret = TRUE;
1560 break;
1561 default:
1562 SetLastError(ERROR_FILE_NOT_FOUND);
1563 ret = FALSE;
1564 }
1565 if (ret)
1566 {
1567 HCERTSTORE regStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_W,
1568 0, hCryptProv, dwFlags, pvPara);
1569
1570 if (regStore)
1571 {
1572 store = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
1573 CERT_STORE_CREATE_NEW_FLAG, NULL);
1574 if (store)
1575 {
1576 CertAddStoreToCollection(store, regStore,
1577 dwFlags & CERT_STORE_READONLY_FLAG ? 0 :
1578 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
1579 CertCloseStore(regStore, 0);
1580 }
1581 }
1582 }
1583 return (PWINECRYPT_CERTSTORE)store;
1584 }
1585
1586 static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreA(HCRYPTPROV hCryptProv,
1587 DWORD dwFlags, const void *pvPara)
1588 {
1589 int len;
1590 PWINECRYPT_CERTSTORE ret = NULL;
1591
1592 TRACE("(%ld, %08lx, %s)\n", hCryptProv, dwFlags,
1593 debugstr_a((LPCSTR)pvPara));
1594
1595 if (!pvPara)
1596 {
1597 SetLastError(ERROR_FILE_NOT_FOUND);
1598 return NULL;
1599 }
1600 len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
1601 if (len)
1602 {
1603 LPWSTR storeName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1604
1605 if (storeName)
1606 {
1607 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
1608 ret = CRYPT_SysOpenStoreW(hCryptProv, dwFlags, storeName);
1609 HeapFree(GetProcessHeap(), 0, storeName);
1610 }
1611 }
1612 return ret;
1613 }
1614
1615 HCERTSTORE WINAPI CertOpenStore(LPCSTR lpszStoreProvider,
1616 DWORD dwMsgAndCertEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags,
1617 const void* pvPara)
1618 {
1619 WINECRYPT_CERTSTORE *hcs;
1620 StoreOpenFunc openFunc = NULL;
1621
1622 TRACE("(%s, %08lx, %08lx, %08lx, %p)\n", debugstr_a(lpszStoreProvider),
1623 dwMsgAndCertEncodingType, hCryptProv, dwFlags, pvPara);
1624
1625 if (!HIWORD(lpszStoreProvider))
1626 {
1627 switch (LOWORD(lpszStoreProvider))
1628 {
1629 case (int)CERT_STORE_PROV_MEMORY:
1630 openFunc = CRYPT_MemOpenStore;
1631 break;
1632 case (int)CERT_STORE_PROV_REG:
1633 openFunc = CRYPT_RegOpenStore;
1634 break;
1635 case (int)CERT_STORE_PROV_COLLECTION:
1636 openFunc = CRYPT_CollectionOpenStore;
1637 break;
1638 case (int)CERT_STORE_PROV_SYSTEM_A:
1639 openFunc = CRYPT_SysOpenStoreA;
1640 break;
1641 case (int)CERT_STORE_PROV_SYSTEM_W:
1642 openFunc = CRYPT_SysOpenStoreW;
1643 break;
1644 case (int)CERT_STORE_PROV_SYSTEM_REGISTRY_A:
1645 openFunc = CRYPT_SysRegOpenStoreA;
1646 break;
1647 case (int)CERT_STORE_PROV_SYSTEM_REGISTRY_W:
1648 openFunc = CRYPT_SysRegOpenStoreW;
1649 break;
1650 default:
1651 if (LOWORD(lpszStoreProvider))
1652 FIXME("unimplemented type %d\n", LOWORD(lpszStoreProvider));
1653 }
1654 }
1655 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_MEMORY))
1656 openFunc = CRYPT_MemOpenStore;
1657 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SYSTEM))
1658 openFunc = CRYPT_SysOpenStoreW;
1659 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_COLLECTION))
1660 openFunc = CRYPT_CollectionOpenStore;
1661 else if (!strcasecmp(lpszStoreProvider, sz_CERT_STORE_PROV_SYSTEM_REGISTRY))
1662 openFunc = CRYPT_SysRegOpenStoreW;
1663 else
1664 {
1665 FIXME("unimplemented type %s\n", lpszStoreProvider);
1666 openFunc = NULL;
1667 }
1668
1669 if (!openFunc)
1670 {
1671 /* FIXME: need to look for an installed provider for this type */
1672 SetLastError(ERROR_FILE_NOT_FOUND);
1673 hcs = NULL;
1674 }
1675 else
1676 hcs = openFunc(hCryptProv, dwFlags, pvPara);
1677 return (HCERTSTORE)hcs;
1678 }
1679
1680 HCERTSTORE WINAPI CertOpenSystemStoreA(HCRYPTPROV hProv,
1681 LPCSTR szSubSystemProtocol)
1682 {
1683 HCERTSTORE ret = 0;
1684
1685 if (szSubSystemProtocol)
1686 {
1687 int len = MultiByteToWideChar(CP_ACP, 0, szSubSystemProtocol, -1, NULL,
1688 0);
1689 LPWSTR param = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1690
1691 if (param)
1692 {
1693 MultiByteToWideChar(CP_ACP, 0, szSubSystemProtocol, -1, param, len);
1694 ret = CertOpenSystemStoreW(hProv, param);
1695 HeapFree(GetProcessHeap(), 0, param);
1696 }
1697 }
1698 else
1699 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
1700 return ret;
1701 }
1702
1703 HCERTSTORE WINAPI CertOpenSystemStoreW(HCRYPTPROV hProv,
1704 LPCWSTR szSubSystemProtocol)
1705 {
1706 HCERTSTORE ret;
1707
1708 if (!szSubSystemProtocol)
1709 {
1710 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
1711 return 0;
1712 }
1713
1714 /* FIXME: needs some tests. It seems to open both HKEY_LOCAL_MACHINE and
1715 * HKEY_CURRENT_USER stores, but I'm not sure under what conditions, if any,
1716 * it fails.
1717 */
1718 ret = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, hProv,
1719 CERT_STORE_CREATE_NEW_FLAG, NULL);
1720 if (ret)
1721 {
1722 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_W,
1723 0, hProv, CERT_SYSTEM_STORE_LOCAL_MACHINE, szSubSystemProtocol);
1724
1725 if (store)
1726 {
1727 CertAddStoreToCollection(ret, store,
1728 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
1729 CertCloseStore(store, 0);
1730 }
1731 store = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY_W,
1732 0, hProv, CERT_SYSTEM_STORE_CURRENT_USER, szSubSystemProtocol);
1733 if (store)
1734 {
1735 CertAddStoreToCollection(ret, store,
1736 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
1737 CertCloseStore(store, 0);
1738 }
1739 }
1740 return ret;
1741 }
1742
1743 BOOL WINAPI CertSaveStore(HCERTSTORE hCertStore, DWORD dwMsgAndCertEncodingType,
1744 DWORD dwSaveAs, DWORD dwSaveTo, void* pvSaveToPara, DWORD dwFlags)
1745 {
1746 FIXME("(%p,%ld,%ld,%ld,%p,%08lx) stub!\n", hCertStore,
1747 dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
1748 return TRUE;
1749 }
1750
1751 PCCRL_CONTEXT WINAPI CertCreateCRLContext( DWORD dwCertEncodingType,
1752 const BYTE* pbCrlEncoded, DWORD cbCrlEncoded)
1753 {
1754 PCRL_CONTEXT pcrl;
1755 BYTE* data;
1756
1757 TRACE("%08lx %p %08lx\n", dwCertEncodingType, pbCrlEncoded, cbCrlEncoded);
1758
1759 /* FIXME: semi-stub, need to use CryptDecodeObjectEx to decode the CRL. */
1760 pcrl = HeapAlloc( GetProcessHeap(), 0, sizeof (CRL_CONTEXT) );
1761 if( !pcrl )
1762 return NULL;
1763
1764 data = HeapAlloc( GetProcessHeap(), 0, cbCrlEncoded );
1765 if( !data )
1766 {
1767 HeapFree( GetProcessHeap(), 0, pcrl );
1768 return NULL;
1769 }
1770
1771 pcrl->dwCertEncodingType = dwCertEncodingType;
1772 pcrl->pbCrlEncoded = data;
1773 pcrl->cbCrlEncoded = cbCrlEncoded;
1774 pcrl->pCrlInfo = NULL;
1775 pcrl->hCertStore = 0;
1776
1777 return pcrl;
1778 }
1779
1780 /* Decodes the encoded certificate and creates the certificate context for it.
1781 * The reference count is initially zero, so you must create a reference to it
1782 * to avoid leaking memory.
1783 */
1784 static PWINE_CERT_CONTEXT CRYPT_CreateCertificateContext(
1785 DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)
1786 {
1787 PWINE_CERT_CONTEXT cert = NULL;
1788 BOOL ret;
1789 PCERT_SIGNED_CONTENT_INFO signedCert = NULL;
1790 PCERT_INFO certInfo = NULL;
1791 DWORD size = 0;
1792
1793 TRACE("(%08lx, %p, %ld)\n", dwCertEncodingType, pbCertEncoded,
1794 cbCertEncoded);
1795
1796 /* First try to decode it as a signed cert. */
1797 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT, pbCertEncoded,
1798 cbCertEncoded, CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
1799 (BYTE *)&signedCert, &size);
1800 if (ret)
1801 {
1802 size = 0;
1803 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_TO_BE_SIGNED,
1804 signedCert->ToBeSigned.pbData, signedCert->ToBeSigned.cbData,
1805 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
1806 (BYTE *)&certInfo, &size);
1807 LocalFree(signedCert);
1808 }
1809 /* Failing that, try it as an unsigned cert */
1810 if (!ret)
1811 {
1812 size = 0;
1813 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT_TO_BE_SIGNED,
1814 pbCertEncoded, cbCertEncoded,
1815 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
1816 (BYTE *)&certInfo, &size);
1817 }
1818 if (ret)
1819 {
1820 BYTE *data = NULL;
1821
1822 cert = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_CERT_CONTEXT));
1823 if (!cert)
1824 goto end;
1825 data = HeapAlloc(GetProcessHeap(), 0, cbCertEncoded);
1826 if (!data)
1827 {
1828 HeapFree(GetProcessHeap(), 0, cert);
1829 cert = NULL;
1830 goto end;
1831 }
1832 memcpy(data, pbCertEncoded, cbCertEncoded);
1833 cert->cert.dwCertEncodingType = dwCertEncodingType;
1834 cert->cert.pbCertEncoded = data;
1835 cert->cert.cbCertEncoded = cbCertEncoded;
1836 cert->cert.pCertInfo = certInfo;
1837 cert->cert.hCertStore = 0;
1838 cert->ref = 0;
1839 InitializeCriticalSection(&cert->cs);
1840 list_init(&cert->extendedProperties);
1841 }
1842
1843 end:
1844 return cert;
1845 }
1846
1847 static void CRYPT_FreeCert(PWINE_CERT_CONTEXT context)
1848 {
1849 PWINE_CERT_PROPERTY prop, next;
1850
1851 HeapFree(GetProcessHeap(), 0, context->cert.pbCertEncoded);
1852 LocalFree(context->cert.pCertInfo);
1853 DeleteCriticalSection(&context->cs);
1854 LIST_FOR_EACH_ENTRY_SAFE(prop, next, &context->extendedProperties,
1855 WINE_CERT_PROPERTY, entry)
1856 {
1857 list_remove(&prop->entry);
1858 HeapFree(GetProcessHeap(), 0, prop->pbData);
1859 HeapFree(GetProcessHeap(), 0, prop);
1860 }
1861 HeapFree(GetProcessHeap(), 0, context);
1862 }
1863
1864 PCCERT_CONTEXT WINAPI CertCreateCertificateContext(DWORD dwCertEncodingType,
1865 const BYTE *pbCertEncoded, DWORD cbCertEncoded)
1866 {
1867 PWINE_CERT_CONTEXT cert;
1868 PWINE_CERT_CONTEXT_REF ret = NULL;
1869
1870 TRACE("(%08lx, %p, %ld)\n", dwCertEncodingType, pbCertEncoded,
1871 cbCertEncoded);
1872
1873 cert = CRYPT_CreateCertificateContext(dwCertEncodingType, pbCertEncoded,
1874 cbCertEncoded);
1875 if (cert)
1876 ret = CRYPT_CreateCertRef(cert, 0);
1877 return (PCCERT_CONTEXT)ret;
1878 }
1879
1880 /* Since the properties are stored in a list, this is a tad inefficient
1881 * (O(n^2)) since I have to find the previous position every time.
1882 */
1883 DWORD WINAPI CertEnumCertificateContextProperties(PCCERT_CONTEXT pCertContext,
1884 DWORD dwPropId)
1885 {
1886 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext;
1887 DWORD ret;
1888
1889 TRACE("(%p, %ld)\n", pCertContext, dwPropId);
1890
1891 EnterCriticalSection(&ref->context->cs);
1892 if (dwPropId)
1893 {
1894 PWINE_CERT_PROPERTY cursor = NULL;
1895
1896 LIST_FOR_EACH_ENTRY(cursor, &ref->context->extendedProperties,
1897 WINE_CERT_PROPERTY, entry)
1898 {
1899 if (cursor->hdr.propID == dwPropId)
1900 break;
1901 }
1902 if (cursor)
1903 {
1904 if (cursor->entry.next != &ref->context->extendedProperties)
1905 ret = LIST_ENTRY(cursor->entry.next, WINE_CERT_PROPERTY,
1906 entry)->hdr.propID;
1907 else
1908 ret = 0;
1909 }
1910 else
1911 ret = 0;
1912 }
1913 else if (!list_empty(&ref->context->extendedProperties))
1914 ret = LIST_ENTRY(ref->context->extendedProperties.next,
1915 WINE_CERT_PROPERTY, entry)->hdr.propID;
1916 else
1917 ret = 0;
1918 LeaveCriticalSection(&ref->context->cs);
1919 return ret;
1920 }
1921
1922 static BOOL WINAPI CRYPT_GetCertificateContextProperty(
1923 PWINE_CERT_CONTEXT context, DWORD dwPropId, void *pvData, DWORD *pcbData)
1924 {
1925 PWINE_CERT_PROPERTY prop;
1926 BOOL ret, found;
1927
1928 TRACE("(%p, %ld, %p, %p)\n", context, dwPropId, pvData, pcbData);
1929
1930 EnterCriticalSection(&context->cs);
1931 ret = FALSE;
1932 found = FALSE;
1933 LIST_FOR_EACH_ENTRY(prop, &context->extendedProperties,
1934 WINE_CERT_PROPERTY, entry)
1935 {
1936 if (prop->hdr.propID == dwPropId)
1937 {
1938 if (!pvData)
1939 {
1940 *pcbData = prop->hdr.cb;
1941 ret = TRUE;
1942 }
1943 else if (*pcbData < prop->hdr.cb)
1944 {
1945 SetLastError(ERROR_MORE_DATA);
1946 *pcbData = prop->hdr.cb;
1947 }
1948 else
1949 {
1950 memcpy(pvData, prop->pbData, prop->hdr.cb);
1951 *pcbData = prop->hdr.cb;
1952 ret = TRUE;
1953 }
1954 found = TRUE;
1955 }
1956 break;
1957 }
1958 if (!found)
1959 {
1960 /* Implicit properties */
1961 switch (dwPropId)
1962 {
1963 case CERT_SHA1_HASH_PROP_ID:
1964 ret = CryptHashCertificate(0, CALG_SHA1, 0,
1965 context->cert.pbCertEncoded, context->cert.cbCertEncoded, pvData,
1966 pcbData);
1967 if (ret)
1968 {
1969 CRYPT_DATA_BLOB blob = { *pcbData, pvData };
1970
1971 ret = CRYPT_SetCertificateContextProperty(context, dwPropId,
1972 0, &blob);
1973 }
1974 break;
1975 case CERT_KEY_PROV_INFO_PROP_ID:
1976 case CERT_MD5_HASH_PROP_ID:
1977 case CERT_SIGNATURE_HASH_PROP_ID:
1978 case CERT_KEY_IDENTIFIER_PROP_ID:
1979 case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
1980 case CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID:
1981 case CERT_SUBJECT_NAME_MD5_HASH_PROP_ID:
1982 FIXME("implicit property %ld\n", dwPropId);
1983 break;
1984 }
1985 }
1986 LeaveCriticalSection(&context->cs);
1987 TRACE("returning %d\n", ret);
1988 return ret;
1989 }
1990
1991 BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext,
1992 DWORD dwPropId, void *pvData, DWORD *pcbData)
1993 {
1994 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext;
1995 BOOL ret;
1996
1997 TRACE("(%p, %ld, %p, %p)\n", pCertContext, dwPropId, pvData, pcbData);
1998
1999 /* Special cases for invalid/special prop IDs.
2000 */
2001 switch (dwPropId)
2002 {
2003 case 0:
2004 case CERT_CERT_PROP_ID:
2005 case CERT_CRL_PROP_ID:
2006 case CERT_CTL_PROP_ID:
2007 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2008 return FALSE;
2009 case CERT_ACCESS_STATE_PROP_ID:
2010 if (!pvData)
2011 {
2012 *pcbData = sizeof(DWORD);
2013 return TRUE;
2014 }
2015 else if (*pcbData < sizeof(DWORD))
2016 {
2017 SetLastError(ERROR_MORE_DATA);
2018 *pcbData = sizeof(DWORD);
2019 return FALSE;
2020 }
2021 else
2022 {
2023 DWORD state = 0;
2024
2025 if (pCertContext->hCertStore)
2026 {
2027 PWINECRYPT_CERTSTORE store =
2028 (PWINECRYPT_CERTSTORE)pCertContext->hCertStore;
2029
2030 /* Take advantage of knowledge of the stores to answer the
2031 * access state question
2032 */
2033 if (store->type != StoreTypeReg ||
2034 !(store->dwOpenFlags & CERT_STORE_READONLY_FLAG))
2035 state |= CERT_ACCESS_STATE_WRITE_PERSIST_FLAG;
2036 }
2037 *(DWORD *)pvData = state;
2038 return TRUE;
2039 }
2040 }
2041
2042 ret = CRYPT_GetCertificateContextProperty(ref->context, dwPropId,
2043 pvData, pcbData);
2044 TRACE("returning %d\n", ret);
2045 return ret;
2046 }
2047
2048 /* Copies cbData bytes from pbData to the context's property with ID
2049 * dwPropId.
2050 */
2051 static BOOL CRYPT_SaveCertificateContextProperty(PWINE_CERT_CONTEXT context,
2052 DWORD dwPropId, const BYTE *pbData, size_t cbData)
2053 {
2054 BOOL ret = FALSE;
2055 LPBYTE data;
2056
2057 if (cbData)
2058 {
2059 data = HeapAlloc(GetProcessHeap(), 0, cbData);
2060 if (data)
2061 memcpy(data, pbData, cbData);
2062 }
2063 else
2064 data = NULL;
2065 if (!cbData || data)
2066 {
2067 PWINE_CERT_PROPERTY prop;
2068
2069 EnterCriticalSection(&context->cs);
2070 LIST_FOR_EACH_ENTRY(prop, &context->extendedProperties,
2071 WINE_CERT_PROPERTY, entry)
2072 {
2073 if (prop->hdr.propID == dwPropId)
2074 break;
2075 }
2076 if (prop && prop->entry.next != &context->extendedProperties)
2077 {
2078 HeapFree(GetProcessHeap(), 0, prop->pbData);
2079 prop->hdr.cb = cbData;
2080 prop->pbData = cbData ? data : NULL;
2081 ret = TRUE;
2082 }
2083 else
2084 {
2085 prop = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_CERT_PROPERTY));
2086 if (prop)
2087 {
2088 prop->hdr.propID = dwPropId;
2089 prop->hdr.unknown = 1;
2090 prop->hdr.cb = cbData;
2091 list_init(&prop->entry);
2092 prop->pbData = cbData ? data : NULL;
2093 list_add_tail(&context->extendedProperties, &prop->entry);
2094 ret = TRUE;
2095 }
2096 else
2097 HeapFree(GetProcessHeap(), 0, data);
2098 }
2099 LeaveCriticalSection(&context->cs);
2100 }
2101 return ret;
2102 }
2103
2104 static BOOL WINAPI CRYPT_SetCertificateContextProperty(
2105 PWINE_CERT_CONTEXT context, DWORD dwPropId, DWORD dwFlags, const void *pvData)
2106 {
2107 BOOL ret = FALSE;
2108
2109 TRACE("(%p, %ld, %08lx, %p)\n", context, dwPropId, dwFlags, pvData);
2110
2111 if (!pvData)
2112 {
2113 PWINE_CERT_PROPERTY prop, next;
2114
2115 EnterCriticalSection(&context->cs);
2116 LIST_FOR_EACH_ENTRY_SAFE(prop, next, &context->extendedProperties,
2117 WINE_CERT_PROPERTY, entry)
2118 {
2119 if (prop->hdr.propID == dwPropId)
2120 {
2121 list_remove(&prop->entry);
2122 HeapFree(GetProcessHeap(), 0, prop->pbData);
2123 HeapFree(GetProcessHeap(), 0, prop);
2124 }
2125 }
2126 LeaveCriticalSection(&context->cs);
2127 ret = TRUE;
2128 }
2129 else
2130 {
2131 switch (dwPropId)
2132 {
2133 case CERT_AUTO_ENROLL_PROP_ID:
2134 case CERT_CTL_USAGE_PROP_ID:
2135 case CERT_DESCRIPTION_PROP_ID:
2136 case CERT_FRIENDLY_NAME_PROP_ID:
2137 case CERT_HASH_PROP_ID:
2138 case CERT_KEY_IDENTIFIER_PROP_ID:
2139 case CERT_MD5_HASH_PROP_ID:
2140 case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
2141 case CERT_PUBKEY_ALG_PARA_PROP_ID:
2142 case CERT_PVK_FILE_PROP_ID:
2143 case CERT_SIGNATURE_HASH_PROP_ID:
2144 case CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID:
2145 case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
2146 case CERT_ENROLLMENT_PROP_ID:
2147 case CERT_CROSS_CERT_DIST_POINTS_PROP_ID:
2148 case CERT_RENEWAL_PROP_ID:
2149 {
2150 PCRYPT_DATA_BLOB blob = (PCRYPT_DATA_BLOB)pvData;
2151
2152 ret = CRYPT_SaveCertificateContextProperty(context, dwPropId,
2153 blob->pbData, blob->cbData);
2154 break;
2155 }
2156 case CERT_DATE_STAMP_PROP_ID:
2157 ret = CRYPT_SaveCertificateContextProperty(context, dwPropId,
2158 pvData, sizeof(FILETIME));
2159 break;
2160 default:
2161 FIXME("%ld: stub\n", dwPropId);
2162 }
2163 }
2164 TRACE("returning %d\n", ret);
2165 return ret;
2166 }
2167
2168 BOOL WINAPI CertSetCertificateContextProperty(PCCERT_CONTEXT pCertContext,
2169 DWORD dwPropId, DWORD dwFlags, const void *pvData)
2170 {
2171 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext;
2172 BOOL ret;
2173
2174 TRACE("(%p, %ld, %08lx, %p)\n", pCertContext, dwPropId, dwFlags, pvData);
2175
2176 /* Handle special cases for "read-only"/invalid prop IDs. Windows just
2177 * crashes on most of these, I'll be safer.
2178 */
2179 switch (dwPropId)
2180 {
2181 case 0:
2182 case CERT_ACCESS_STATE_PROP_ID:
2183 case CERT_CERT_PROP_ID:
2184 case CERT_CRL_PROP_ID:
2185 case CERT_CTL_PROP_ID:
2186 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2187 return FALSE;
2188 }
2189 ret = CRYPT_SetCertificateContextProperty(ref->context, dwPropId,
2190 dwFlags, pvData);
2191 TRACE("returning %d\n", ret);
2192 return ret;
2193 }
2194
2195 /* Only the reference portion of the context is duplicated. The returned
2196 * context has the cert store set to 0, to prevent the store's certificate free
2197 * function from getting called on partial data.
2198 * FIXME: is this okay? Needs a test.
2199 */
2200 PCCERT_CONTEXT WINAPI CertDuplicateCertificateContext(
2201 PCCERT_CONTEXT pCertContext)
2202 {
2203 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext, ret;
2204
2205 TRACE("(%p)\n", pCertContext);
2206 if (ref)
2207 {
2208 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_CERT_CONTEXT_REF));
2209 if (ret)
2210 {
2211 memcpy(ret, ref, sizeof(*ret));
2212 ret->cert.hCertStore = 0;
2213 InterlockedIncrement(&ret->context->ref);
2214 }
2215 }
2216 else
2217 ret = NULL;
2218 return (PCCERT_CONTEXT)ret;
2219 }
2220
2221 BOOL WINAPI CertAddCertificateContextToStore(HCERTSTORE hCertStore,
2222 PCCERT_CONTEXT pCertContext, DWORD dwAddDisposition,
2223 PCCERT_CONTEXT *ppStoreContext)
2224 {
2225 PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
2226 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext;
2227 PWINE_CERT_CONTEXT cert;
2228 BOOL ret;
2229
2230 TRACE("(%p, %p, %08lx, %p)\n", hCertStore, pCertContext,
2231 dwAddDisposition, ppStoreContext);
2232
2233 /* FIXME: some tests needed to verify return codes */
2234 if (!store)
2235 {
2236 SetLastError(ERROR_INVALID_PARAMETER);
2237 return FALSE;
2238 }
2239 if (store->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2240 {
2241 SetLastError(ERROR_INVALID_PARAMETER);
2242 return FALSE;
2243 }
2244
2245 cert = CRYPT_CreateCertificateContext(ref->context->cert.dwCertEncodingType,
2246 ref->context->cert.pbCertEncoded, ref->context->cert.cbCertEncoded);
2247 if (cert)
2248 {
2249 PWINE_CERT_PROPERTY prop;
2250
2251 ret = TRUE;
2252 EnterCriticalSection(&ref->context->cs);
2253 LIST_FOR_EACH_ENTRY(prop, &ref->context->extendedProperties,
2254 WINE_CERT_PROPERTY, entry)
2255 {
2256 ret = CRYPT_SaveCertificateContextProperty(cert, prop->hdr.propID,
2257 prop->pbData, prop->hdr.cb);
2258 if (!ret)
2259 break;
2260 }
2261 LeaveCriticalSection(&ref->context->cs);
2262 if (ret)
2263 {
2264 ret = store->addCert(store, (PCCERT_CONTEXT)cert, dwAddDisposition);
2265 if (ret && ppStoreContext)
2266 *ppStoreContext = (PCCERT_CONTEXT)store->createCertRef(cert,
2267 hCertStore);
2268 }
2269 if (!ret)
2270 CRYPT_FreeCert(cert);
2271 }
2272 else
2273 ret = FALSE;
2274 return ret;
2275 }
2276
2277 BOOL WINAPI CertAddEncodedCertificateToStore(HCERTSTORE hCertStore,
2278 DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded,
2279 DWORD dwAddDisposition, PCCERT_CONTEXT *ppCertContext)
2280 {
2281 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2282 BOOL ret;
2283
2284 TRACE("(%p, %08lx, %p, %ld, %08lx, %p)\n", hCertStore, dwCertEncodingType,
2285 pbCertEncoded, cbCertEncoded, dwAddDisposition, ppCertContext);
2286
2287 if (!hcs)
2288 ret = FALSE;
2289 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2290 ret = FALSE;
2291 else
2292 {
2293 PWINE_CERT_CONTEXT cert = CRYPT_CreateCertificateContext(
2294 dwCertEncodingType, pbCertEncoded, cbCertEncoded);
2295
2296 if (cert)
2297 {
2298 ret = hcs->addCert(hcs, (PCCERT_CONTEXT)cert, dwAddDisposition);
2299 if (ret && ppCertContext)
2300 *ppCertContext = (PCCERT_CONTEXT)hcs->createCertRef(cert,
2301 hCertStore);
2302 if (!ret)
2303 CRYPT_FreeCert(cert);
2304 }
2305 else
2306 ret = FALSE;
2307 }
2308 return ret;
2309 }
2310
2311 PCCERT_CONTEXT WINAPI CertEnumCertificatesInStore(HCERTSTORE hCertStore,
2312 PCCERT_CONTEXT pPrev)
2313 {
2314 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2315 PWINE_CERT_CONTEXT_REF prev = (PWINE_CERT_CONTEXT_REF)pPrev;
2316 PCCERT_CONTEXT ret;
2317
2318 TRACE("(%p, %p)\n", hCertStore, pPrev);
2319 if (!hCertStore)
2320 ret = NULL;
2321 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2322 ret = NULL;
2323 else
2324 ret = (PCCERT_CONTEXT)hcs->enumCert(hcs, prev);
2325 return ret;
2326 }
2327
2328 BOOL WINAPI CertDeleteCertificateFromStore(PCCERT_CONTEXT pCertContext)
2329 {
2330 BOOL ret;
2331
2332 TRACE("(%p)\n", pCertContext);
2333
2334 if (!pCertContext)
2335 ret = TRUE;
2336 else if (!pCertContext->hCertStore)
2337 {
2338 ret = TRUE;
2339 CertFreeCertificateContext(pCertContext);
2340 }
2341 else
2342 {
2343 PWINECRYPT_CERTSTORE hcs =
2344 (PWINECRYPT_CERTSTORE)pCertContext->hCertStore;
2345
2346 if (!hcs)
2347 ret = TRUE;
2348 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2349 ret = FALSE;
2350 else
2351 {
2352 ret = hcs->deleteCert(hcs, pCertContext, 0);
2353 CertFreeCertificateContext(pCertContext);
2354 }
2355 }
2356 return ret;
2357 }
2358
2359 BOOL WINAPI CertAddEncodedCRLToStore(HCERTSTORE hCertStore,
2360 DWORD dwCertEncodingType, const BYTE *pbCrlEncoded, DWORD cbCrlEncoded,
2361 DWORD dwAddDisposition, PCCRL_CONTEXT *ppCrlContext)
2362 {
2363 FIXME("(%p, %08lx, %p, %ld, %08lx, %p): stub\n", hCertStore,
2364 dwCertEncodingType, pbCrlEncoded, cbCrlEncoded, dwAddDisposition,
2365 ppCrlContext);
2366 return FALSE;
2367 }
2368
2369 BOOL WINAPI CertAddCRLContextToStore( HCERTSTORE hCertStore,
2370 PCCRL_CONTEXT pCrlContext, DWORD dwAddDisposition,
2371 PCCRL_CONTEXT* ppStoreContext )
2372 {
2373 FIXME("%p %p %08lx %p\n", hCertStore, pCrlContext,
2374 dwAddDisposition, ppStoreContext);
2375 return TRUE;
2376 }
2377
2378 BOOL WINAPI CertFreeCRLContext( PCCRL_CONTEXT pCrlContext)
2379 {
2380 FIXME("%p\n", pCrlContext );
2381
2382 return TRUE;
2383 }
2384
2385 BOOL WINAPI CertDeleteCRLFromStore(PCCRL_CONTEXT pCrlContext)
2386 {
2387 FIXME("(%p): stub\n", pCrlContext);
2388 return TRUE;
2389 }
2390
2391 PCCRL_CONTEXT WINAPI CertEnumCRLsInStore(HCERTSTORE hCertStore,
2392 PCCRL_CONTEXT pPrev)
2393 {
2394 FIXME("(%p, %p): stub\n", hCertStore, pPrev);
2395 return NULL;
2396 }
2397
2398 PCCTL_CONTEXT WINAPI CertCreateCTLContext(DWORD dwCertEncodingType,
2399 const BYTE* pbCtlEncoded, DWORD cbCtlEncoded)
2400 {
2401 FIXME("(%08lx, %p, %08lx): stub\n", dwCertEncodingType, pbCtlEncoded,
2402 cbCtlEncoded);
2403 return NULL;
2404 }
2405
2406 BOOL WINAPI CertAddEncodedCTLToStore(HCERTSTORE hCertStore,
2407 DWORD dwMsgAndCertEncodingType, const BYTE *pbCtlEncoded, DWORD cbCtlEncoded,
2408 DWORD dwAddDisposition, PCCTL_CONTEXT *ppCtlContext)
2409 {
2410 FIXME("(%p, %08lx, %p, %ld, %08lx, %p): stub\n", hCertStore,
2411 dwMsgAndCertEncodingType, pbCtlEncoded, cbCtlEncoded, dwAddDisposition,
2412 ppCtlContext);
2413 return FALSE;
2414 }
2415
2416 BOOL WINAPI CertAddCTLContextToStore(HCERTSTORE hCertStore,
2417 PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition,
2418 PCCTL_CONTEXT* ppStoreContext)
2419 {
2420 FIXME("(%p, %p, %08lx, %p): stub\n", hCertStore, pCtlContext,
2421 dwAddDisposition, ppStoreContext);
2422 return TRUE;
2423 }
2424
2425 BOOL WINAPI CertFreeCTLContext(PCCTL_CONTEXT pCtlContext)
2426 {
2427 FIXME("(%p): stub\n", pCtlContext );
2428 return TRUE;
2429 }
2430
2431 BOOL WINAPI CertDeleteCTLFromStore(PCCTL_CONTEXT pCtlContext)
2432 {
2433 FIXME("(%p): stub\n", pCtlContext);
2434 return TRUE;
2435 }
2436
2437 PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(HCERTSTORE hCertStore,
2438 PCCTL_CONTEXT pPrev)
2439 {
2440 FIXME("(%p, %p): stub\n", hCertStore, pPrev);
2441 return NULL;
2442 }
2443
2444
2445 BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
2446 {
2447 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *) hCertStore;
2448
2449 TRACE("(%p, %08lx)\n", hCertStore, dwFlags);
2450
2451 if( ! hCertStore )
2452 return TRUE;
2453
2454 if ( hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC )
2455 return FALSE;
2456
2457 if (InterlockedDecrement(&hcs->ref) == 0)
2458 {
2459 TRACE("%p's ref count is 0, freeing\n", hcs);
2460 hcs->dwMagic = 0;
2461 if (!(hcs->dwOpenFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
2462 CryptReleaseContext(hcs->cryptProv, 0);
2463 hcs->closeStore(hcs, dwFlags);
2464 }
2465 else
2466 TRACE("%p's ref count is %ld\n", hcs, hcs->ref);
2467 return TRUE;
2468 }
2469
2470 BOOL WINAPI CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags,
2471 DWORD dwCtrlType, void const *pvCtrlPara)
2472 {
2473 WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
2474 BOOL ret;
2475
2476 TRACE("(%p, %08lx, %ld, %p)\n", hCertStore, dwFlags, dwCtrlType,
2477 pvCtrlPara);
2478
2479 if (!hcs)
2480 ret = FALSE;
2481 else if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2482 ret = FALSE;
2483 else
2484 {
2485 if (hcs->control)
2486 ret = hcs->control(hCertStore, dwFlags, dwCtrlType, pvCtrlPara);
2487 else
2488 ret = TRUE;
2489 }
2490 return ret;
2491 }
2492
2493 BOOL WINAPI CertGetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
2494 DWORD dwPropId, void *pvData, DWORD *pcbData)
2495 {
2496 FIXME("(%p, %ld, %p, %p): stub\n", pCRLContext, dwPropId, pvData, pcbData);
2497 return FALSE;
2498 }
2499
2500 BOOL WINAPI CertSetCRLContextProperty(PCCRL_CONTEXT pCRLContext,
2501 DWORD dwPropId, DWORD dwFlags, const void *pvData)
2502 {
2503 FIXME("(%p, %ld, %08lx, %p): stub\n", pCRLContext, dwPropId, dwFlags,
2504 pvData);
2505 return FALSE;
2506 }
2507
2508 BOOL WINAPI CertSerializeCRLStoreElement(PCCRL_CONTEXT pCrlContext,
2509 DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
2510 {
2511 FIXME("(%p, %08lx, %p, %p): stub\n", pCrlContext, dwFlags, pbElement,
2512 pcbElement);
2513 return FALSE;
2514 }
2515
2516 BOOL WINAPI CertGetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
2517 DWORD dwPropId, void *pvData, DWORD *pcbData)
2518 {
2519 FIXME("(%p, %ld, %p, %p): stub\n", pCTLContext, dwPropId, pvData, pcbData);
2520 return FALSE;
2521 }
2522
2523 BOOL WINAPI CertSetCTLContextProperty(PCCTL_CONTEXT pCTLContext,
2524 DWORD dwPropId, DWORD dwFlags, const void *pvData)
2525 {
2526 FIXME("(%p, %ld, %08lx, %p): stub\n", pCTLContext, dwPropId, dwFlags,
2527 pvData);
2528 return FALSE;
2529 }
2530
2531 BOOL WINAPI CertSerializeCTLStoreElement(PCCTL_CONTEXT pCtlContext,
2532 DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
2533 {
2534 FIXME("(%p, %08lx, %p, %p): stub\n", pCtlContext, dwFlags, pbElement,
2535 pcbElement);
2536 return FALSE;
2537 }
2538
2539 BOOL WINAPI CertSerializeCertificateStoreElement(PCCERT_CONTEXT pCertContext,
2540 DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)
2541 {
2542 BOOL ret;
2543
2544 TRACE("(%p, %08lx, %p, %p)\n", pCertContext, dwFlags, pbElement,
2545 pcbElement);
2546
2547 if (pCertContext)
2548 {
2549 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext;
2550 DWORD bytesNeeded = sizeof(WINE_CERT_PROP_HEADER) +
2551 pCertContext->cbCertEncoded;
2552 PWINE_CERT_PROPERTY prop;
2553
2554 EnterCriticalSection(&ref->context->cs);
2555 LIST_FOR_EACH_ENTRY(prop, &ref->context->extendedProperties,
2556 WINE_CERT_PROPERTY, entry)
2557 bytesNeeded += sizeof(WINE_CERT_PROP_HEADER) + prop->hdr.cb;
2558 if (!pbElement)
2559 {
2560 *pcbElement = bytesNeeded;
2561 ret = TRUE;
2562 }
2563 else if (*pcbElement < bytesNeeded)
2564 {
2565 *pcbElement = bytesNeeded;
2566 SetLastError(ERROR_MORE_DATA);
2567 ret = FALSE;
2568 }
2569 else
2570 {
2571 PWINE_CERT_PROP_HEADER hdr;
2572
2573 LIST_FOR_EACH_ENTRY(prop, &ref->context->extendedProperties,
2574 WINE_CERT_PROPERTY, entry)
2575 {
2576 memcpy(pbElement, &prop->hdr, sizeof(WINE_CERT_PROP_HEADER));
2577 pbElement += sizeof(WINE_CERT_PROP_HEADER);
2578 if (prop->hdr.cb)
2579 {
2580 memcpy(pbElement, prop->pbData, prop->hdr.cb);
2581 pbElement += prop->hdr.cb;
2582 }
2583 }
2584 hdr = (PWINE_CERT_PROP_HEADER)pbElement;
2585 hdr->propID = CERT_CERT_PROP_ID;
2586 hdr->unknown = 1;
2587 hdr->cb = pCertContext->cbCertEncoded;
2588 memcpy(pbElement + sizeof(WINE_CERT_PROP_HEADER),
2589 pCertContext->pbCertEncoded, pCertContext->cbCertEncoded);
2590 ret = TRUE;
2591 }
2592 LeaveCriticalSection(&ref->context->cs);
2593 }
2594 else
2595 ret = FALSE;
2596 return ret;
2597 }
2598
2599 /* Looks for the property with ID propID in the buffer buf. Returns a pointer
2600 * to its header if a valid header is found, NULL if not. Valid means the
2601 * length of thte property won't overrun buf, and the unknown field is 1.
2602 */
2603 static const WINE_CERT_PROP_HEADER *CRYPT_findPropID(const BYTE *buf,
2604 DWORD size, DWORD propID)
2605 {
2606 const WINE_CERT_PROP_HEADER *ret = NULL;
2607 BOOL done = FALSE;
2608
2609 while (size && !ret && !done)
2610 {
2611 if (size < sizeof(WINE_CERT_PROP_HEADER))
2612 {
2613 SetLastError(CRYPT_E_FILE_ERROR);
2614 done = TRUE;
2615 }
2616 else
2617 {
2618 const WINE_CERT_PROP_HEADER *hdr =
2619 (const WINE_CERT_PROP_HEADER *)buf;
2620
2621 size -= sizeof(WINE_CERT_PROP_HEADER);
2622 buf += sizeof(WINE_CERT_PROP_HEADER);
2623 if (size < hdr->cb)
2624 {
2625 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2626 done = TRUE;
2627 }
2628 else if (!hdr->propID)
2629 {
2630 /* assume a zero prop ID means the data are uninitialized, so
2631 * stop looking.
2632 */
2633 done = TRUE;
2634 }
2635 else if (hdr->unknown != 1)
2636 {
2637 SetLastError(ERROR_FILE_NOT_FOUND);
2638 done = TRUE;
2639 }
2640 else if (hdr->propID == propID)
2641 ret = hdr;
2642 else
2643 {
2644 buf += hdr->cb;
2645 size -= hdr->cb;
2646 }
2647 }
2648 }
2649 return ret;
2650 }
2651
2652 static const void * WINAPI CRYPT_ReadSerializedElement(const BYTE *pbElement,
2653 DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType)
2654 {
2655 const void *context;
2656
2657 TRACE("(%p, %ld, %08lx, %p)\n", pbElement, cbElement, dwContextTypeFlags,
2658 pdwContentType);
2659
2660 if (!cbElement)
2661 {
2662 SetLastError(ERROR_END_OF_MEDIA);
2663 return NULL;
2664 }
2665
2666 __TRY
2667 {
2668 const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
2669 const WINE_CERT_PROP_HEADER *hdr = NULL;
2670 DWORD type = 0;
2671 BOOL ret;
2672
2673 ret = TRUE;
2674 context = NULL;
2675 if (dwContextTypeFlags == CERT_STORE_ALL_CONTEXT_FLAG)
2676 {
2677 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
2678 if (hdr)
2679 type = CERT_STORE_CERTIFICATE_CONTEXT;
2680 else
2681 {
2682 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
2683 if (hdr)
2684 type = CERT_STORE_CRL_CONTEXT;
2685 else
2686 {
2687 hdr = CRYPT_findPropID(pbElement, cbElement,
2688 CERT_CTL_PROP_ID);
2689 if (hdr)
2690 type = CERT_STORE_CTL_CONTEXT;
2691 }
2692 }
2693 }
2694 else if (dwContextTypeFlags & CERT_STORE_CERTIFICATE_CONTEXT_FLAG)
2695 {
2696 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
2697 type = CERT_STORE_CERTIFICATE_CONTEXT;
2698 }
2699 else if (dwContextTypeFlags & CERT_STORE_CRL_CONTEXT_FLAG)
2700 {
2701 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
2702 type = CERT_STORE_CRL_CONTEXT;
2703 }
2704 else if (dwContextTypeFlags & CERT_STORE_CTL_CONTEXT_FLAG)
2705 {
2706 hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CTL_PROP_ID);
2707 type = CERT_STORE_CTL_CONTEXT;
2708 }
2709
2710 switch (type)
2711 {
2712 case CERT_STORE_CERTIFICATE_CONTEXT:
2713 contextInterface = &gCertInterface;
2714 break;
2715 case CERT_STORE_CRL_CONTEXT:
2716 contextInterface = &gCRLInterface;
2717 break;
2718 case CERT_STORE_CTL_CONTEXT:
2719 contextInterface = &gCTLInterface;
2720 break;
2721 default:
2722 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2723 ret = FALSE;
2724 }
2725 if (!hdr)
2726 ret = FALSE;
2727
2728 if (ret)
2729 context = contextInterface->create(X509_ASN_ENCODING,
2730 (BYTE *)hdr + sizeof(WINE_CERT_PROP_HEADER), hdr->cb);
2731 if (ret && context)
2732 {
2733 BOOL noMoreProps = FALSE;
2734
2735 while (!noMoreProps && ret)
2736 {
2737 if (cbElement < sizeof(WINE_CERT_PROP_HEADER))
2738 ret = FALSE;
2739 else
2740 {
2741 const WINE_CERT_PROP_HEADER *hdr =
2742 (const WINE_CERT_PROP_HEADER *)pbElement;
2743
2744 TRACE("prop is %ld\n", hdr->propID);
2745 cbElement -= sizeof(WINE_CERT_PROP_HEADER);
2746 pbElement += sizeof(WINE_CERT_PROP_HEADER);
2747 if (cbElement < hdr->cb)
2748 {
2749 SetLastError(HRESULT_FROM_WIN32(
2750 ERROR_INVALID_PARAMETER));
2751 ret = FALSE;
2752 }
2753 else if (!hdr->propID)
2754 {
2755 /* Like in CRYPT_findPropID, stop if the propID is zero
2756 */
2757 noMoreProps = TRUE;
2758 }
2759 else if (hdr->unknown != 1)
2760 {
2761 SetLastError(ERROR_FILE_NOT_FOUND);
2762 ret = FALSE;
2763 }
2764 else if (hdr->propID != CERT_CERT_PROP_ID &&
2765 hdr->propID != CERT_CRL_PROP_ID && hdr->propID !=
2766 CERT_CTL_PROP_ID)
2767 {
2768 /* Have to create a blob for most types, but not
2769 * for all.. arghh.
2770 */
2771 switch (hdr->propID)
2772 {
2773 case CERT_AUTO_ENROLL_PROP_ID:
2774 case CERT_CTL_USAGE_PROP_ID:
2775 case CERT_DESCRIPTION_PROP_ID:
2776 case CERT_FRIENDLY_NAME_PROP_ID:
2777 case CERT_HASH_PROP_ID:
2778 case CERT_KEY_IDENTIFIER_PROP_ID:
2779 case CERT_MD5_HASH_PROP_ID:
2780 case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
2781 case CERT_PUBKEY_ALG_PARA_PROP_ID:
2782 case CERT_PVK_FILE_PROP_ID:
2783 case CERT_SIGNATURE_HASH_PROP_ID:
2784 case CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID:
2785 case CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID:
2786 case CERT_ENROLLMENT_PROP_ID:
2787 case CERT_CROSS_CERT_DIST_POINTS_PROP_ID:
2788 case CERT_RENEWAL_PROP_ID:
2789 {
2790 CRYPT_DATA_BLOB blob = { hdr->cb,
2791 (LPBYTE)pbElement };
2792
2793 ret = contextInterface->setProp(context,
2794 hdr->propID, 0, &blob);
2795 break;
2796 }
2797 case CERT_DATE_STAMP_PROP_ID:
2798 ret = contextInterface->setProp(context,
2799 hdr->propID, 0, pbElement);
2800 break;
2801 default:
2802 FIXME("prop ID %ld: stub\n", hdr->propID);
2803 }
2804 }
2805 pbElement += hdr->cb;
2806 cbElement -= hdr->cb;
2807 if (!cbElement)
2808 noMoreProps = TRUE;
2809 }
2810 }
2811 if (ret)
2812 {
2813 if (pdwContentType)
2814 *pdwContentType = type;
2815 }
2816 else
2817 {
2818 contextInterface->free(context);
2819 context = NULL;
2820 }
2821 }
2822 }
2823 __EXCEPT(page_fault)
2824 {
2825 SetLastError(STATUS_ACCESS_VIOLATION);
2826 context = NULL;
2827 }
2828 __ENDTRY
2829 return context;
2830 }
2831
2832 BOOL WINAPI CertAddSerializedElementToStore(HCERTSTORE hCertStore,
2833 const BYTE *pbElement, DWORD cbElement, DWORD dwAddDisposition, DWORD dwFlags,
2834 DWORD dwContextTypeFlags, DWORD *pdwContentType, const void **ppvContext)
2835 {
2836 const void *context;
2837 DWORD type;
2838 BOOL ret;
2839
2840 TRACE("(%p, %p, %ld, %08lx, %08lx, %08lx, %p, %p)\n", hCertStore,
2841 pbElement, cbElement, dwAddDisposition, dwFlags, dwContextTypeFlags,
2842 pdwContentType, ppvContext);
2843
2844 /* Call the internal function, then delete the hashes. Tests show this
2845 * function uses real hash values, not whatever's stored in the hash
2846 * property.
2847 */
2848 context = CRYPT_ReadSerializedElement(pbElement, cbElement,
2849 dwContextTypeFlags, &type);
2850 if (context)
2851 {
2852 const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
2853
2854 switch (type)
2855 {
2856 case CERT_STORE_CERTIFICATE_CONTEXT:
2857 contextInterface = &gCertInterface;
2858 break;
2859 case CERT_STORE_CRL_CONTEXT:
2860 contextInterface = &gCRLInterface;
2861 break;
2862 case CERT_STORE_CTL_CONTEXT:
2863 contextInterface = &gCTLInterface;
2864 break;
2865 default:
2866 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2867 }
2868 if (contextInterface)
2869 {
2870 contextInterface->setProp(context, CERT_HASH_PROP_ID, 0, NULL);
2871 contextInterface->setProp(context, CERT_MD5_HASH_PROP_ID, 0, NULL);
2872 contextInterface->setProp(context, CERT_SIGNATURE_HASH_PROP_ID, 0,
2873 NULL);
2874 if (pdwContentType)
2875 *pdwContentType = type;
2876 ret = contextInterface->addContextToStore(hCertStore, context,
2877 dwAddDisposition, ppvContext);
2878 contextInterface->free(context);
2879 }
2880 else
2881 ret = FALSE;
2882 }
2883 else
2884 ret = FALSE;
2885 return ret;
2886 }
2887
2888 BOOL WINAPI CertFreeCertificateContext(PCCERT_CONTEXT pCertContext)
2889 {
2890 TRACE("(%p)\n", pCertContext);
2891
2892 if (pCertContext)
2893 {
2894 PWINE_CERT_CONTEXT_REF ref = (PWINE_CERT_CONTEXT_REF)pCertContext;
2895 PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)ref->cert.hCertStore;
2896
2897 if (InterlockedDecrement(&ref->context->ref) == 0)
2898 {
2899 TRACE("%p's ref count is 0, freeing\n", ref->context);
2900 CRYPT_FreeCert(ref->context);
2901 }
2902 else
2903 TRACE("%p's ref count is %ld\n", ref->context, ref->context->ref);
2904 if (store && store->dwMagic == WINE_CRYPTCERTSTORE_MAGIC &&
2905 store->freeCert)
2906 store->freeCert(ref);
2907 HeapFree(GetProcessHeap(), 0, ref);
2908 }
2909 return TRUE;
2910 }
2911
2912 PCCERT_CONTEXT WINAPI CertFindCertificateInStore(HCERTSTORE hCertStore,
2913 DWORD dwCertEncodingType, DWORD dwFlags, DWORD dwType,
2914 const void *pvPara, PCCERT_CONTEXT pPrevCertContext)
2915 {
2916 FIXME("stub: %p %ld %ld %ld %p %p\n", hCertStore, dwCertEncodingType,
2917 dwFlags, dwType, pvPara, pPrevCertContext);
2918 SetLastError(CRYPT_E_NOT_FOUND);
2919 return NULL;
2920 }
2921
2922 BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
2923 HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
2924 {
2925 PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
2926 WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
2927 PWINE_STORE_LIST_ENTRY entry;
2928 BOOL ret;
2929
2930 TRACE("(%p, %p, %08lx, %ld)\n", hCollectionStore, hSiblingStore,
2931 dwUpdateFlags, dwPriority);
2932
2933 if (!collection || !sibling)
2934 return TRUE;
2935 if (collection->hdr.dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2936 {
2937 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2938 return FALSE;
2939 }
2940 if (collection->hdr.type != StoreTypeCollection)
2941 {
2942 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2943 return FALSE;
2944 }
2945 if (sibling->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
2946 {
2947 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
2948 return FALSE;
2949 }
2950
2951 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_STORE_LIST_ENTRY));
2952 if (entry)
2953 {
2954 InterlockedIncrement(&sibling->ref);
2955 TRACE("sibling %p's ref count is %ld\n", sibling, sibling->ref);
2956 entry->store = sibling;
2957 entry->dwUpdateFlags = dwUpdateFlags;
2958 entry->dwPriority = dwPriority;
2959 list_init(&entry->entry);
2960 TRACE("%p: adding %p, priority %ld\n", collection, entry, dwPriority);
2961 EnterCriticalSection(&collection->cs);
2962 if (dwPriority)
2963 {
2964 PWINE_STORE_LIST_ENTRY cursor;
2965 BOOL added = FALSE;
2966
2967 LIST_FOR_EACH_ENTRY(cursor, &collection->stores,
2968 WINE_STORE_LIST_ENTRY, entry)
2969 {
2970 if (cursor->dwPriority < dwPriority)
2971 {
2972 list_add_before(&cursor->entry, &entry->entry);
2973 added = TRUE;
2974 break;
2975 }
2976 }
2977 if (!added)
2978 list_add_tail(&collection->stores, &entry->entry);
2979 }
2980 else
2981 list_add_tail(&collection->stores, &entry->entry);
2982 LeaveCriticalSection(&collection->cs);
2983 ret = TRUE;
2984 }
2985 else
2986 ret = FALSE;
2987 return ret;
2988 }
2989
2990 void WINAPI CertRemoveStoreFromCollection(HCERTSTORE hCollectionStore,
2991 HCERTSTORE hSiblingStore)
2992 {
2993 PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
2994 WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
2995 PWINE_STORE_LIST_ENTRY store, next;
2996
2997 TRACE("(%p, %p)\n", hCollectionStore, hSiblingStore);
2998
2999 if (!collection || !sibling)
3000 return;
3001 if (collection->hdr.dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
3002 {
3003 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
3004 return;
3005 }
3006 if (collection->hdr.type != StoreTypeCollection)
3007 return;
3008 if (sibling->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
3009 {
3010 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER));
3011 return;
3012 }
3013 EnterCriticalSection(&collection->cs);
3014 LIST_FOR_EACH_ENTRY_SAFE(store, next, &collection->stores,
3015 WINE_STORE_LIST_ENTRY, entry)
3016 {
3017 if (store->store == sibling)
3018 {
3019 list_remove(&store->entry);
3020 CertCloseStore(store->store, 0);
3021 HeapFree(GetProcessHeap(), 0, store);
3022 break;
3023 }
3024 }
3025 LeaveCriticalSection(&collection->cs);
3026 }
3027
3028 PCRYPT_ATTRIBUTE WINAPI CertFindAttribute(LPCSTR pszObjId, DWORD cAttr,
3029 CRYPT_ATTRIBUTE rgAttr[])
3030 {
3031 PCRYPT_ATTRIBUTE ret = NULL;
3032 DWORD i;
3033
3034 TRACE("%s %ld %p\n", debugstr_a(pszObjId), cAttr, rgAttr);
3035
3036 if (!cAttr)
3037 return NULL;
3038 if (!pszObjId)
3039 {
3040 SetLastError(ERROR_INVALID_PARAMETER);
3041 return NULL;
3042 }
3043
3044 for (i = 0; !ret && i < cAttr; i++)
3045 if (rgAttr[i].pszObjId && !strcmp(pszObjId, rgAttr[i].pszObjId))
3046 ret = &rgAttr[i];
3047 return ret;
3048 }
3049
3050 PCERT_EXTENSION WINAPI CertFindExtension(LPCSTR pszObjId, DWORD cExtensions,
3051 CERT_EXTENSION rgExtensions[])
3052 {
3053 PCERT_EXTENSION ret = NULL;
3054 DWORD i;
3055
3056 TRACE("%s %ld %p\n", debugstr_a(pszObjId), cExtensions, rgExtensions);
3057
3058 if (!cExtensions)
3059 return NULL;
3060 if (!pszObjId)
3061 {
3062 SetLastError(ERROR_INVALID_PARAMETER);
3063 return NULL;
3064 }
3065
3066 for (i = 0; !ret && i < cExtensions; i++)
3067 if (rgExtensions[i].pszObjId && !strcmp(pszObjId,
3068 rgExtensions[i].pszObjId))
3069 ret = &rgExtensions[i];
3070 return ret;
3071 }
3072
3073 PCERT_RDN_ATTR WINAPI CertFindRDNAttr(LPCSTR pszObjId, PCERT_NAME_INFO pName)
3074 {
3075 PCERT_RDN_ATTR ret = NULL;
3076 DWORD i, j;
3077
3078 TRACE("%s %p\n", debugstr_a(pszObjId), pName);
3079
3080 if (!pszObjId)
3081 {
3082 SetLastError(ERROR_INVALID_PARAMETER);
3083 return NULL;
3084 }
3085
3086 for (i = 0; !ret && i < pName->cRDN; i++)
3087 for (j = 0; !ret && j < pName->rgRDN[i].cRDNAttr; j++)
3088 if (pName->rgRDN[i].rgRDNAttr[j].pszObjId && !strcmp(pszObjId,
3089 pName->rgRDN[i].rgRDNAttr[j].pszObjId))
3090 ret = &pName->rgRDN[i].rgRDNAttr[j];
3091 return ret;
3092 }
3093
3094 LONG WINAPI CertVerifyTimeValidity(LPFILETIME pTimeToVerify,
3095 PCERT_INFO pCertInfo)
3096 {
3097 FILETIME fileTime;
3098 LONG ret;
3099
3100 if (!pTimeToVerify)
3101 {
3102 SYSTEMTIME sysTime;
3103
3104 GetSystemTime(&sysTime);
3105 SystemTimeToFileTime(&sysTime, &fileTime);
3106 pTimeToVerify = &fileTime;
3107 }
3108 if ((ret = CompareFileTime(pTimeToVerify, &pCertInfo->NotBefore)) >= 0)
3109 {
3110 ret = CompareFileTime(pTimeToVerify, &pCertInfo->NotAfter);
3111 if (ret < 0)
3112 ret = 0;
3113 }
3114 return ret;
3115 }
3116
3117 BOOL WINAPI CryptHashCertificate(HCRYPTPROV hCryptProv, ALG_ID Algid,
3118 DWORD dwFlags, const BYTE *pbEncoded, DWORD cbEncoded, BYTE *pbComputedHash,
3119 DWORD *pcbComputedHash)
3120 {
3121 BOOL ret = TRUE;
3122 HCRYPTHASH hHash = 0;
3123
3124 TRACE("(%ld, %d, %08lx, %p, %ld, %p, %p)\n", hCryptProv, Algid, dwFlags,
3125 pbEncoded, cbEncoded, pbComputedHash, pcbComputedHash);
3126
3127 if (!hCryptProv)
3128 hCryptProv = CRYPT_GetDefaultProvider();
3129 if (!Algid)
3130 Algid = CALG_SHA1;
3131 if (ret)
3132 {
3133 ret = CryptCreateHash(hCryptProv, Algid, 0, 0, &hHash);
3134 if (ret)
3135 {
3136 ret = CryptHashData(hHash, pbEncoded, cbEncoded, 0);
3137 if (ret)
3138 ret = CryptGetHashParam(hHash, HP_HASHVAL, pbComputedHash,
3139 pcbComputedHash, 0);
3140 CryptDestroyHash(hHash);
3141 }
3142 }
3143 return ret;
3144 }
Maarten's multimedia branch