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