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