git.oblomov.eu Git - wine/blob - dlls/crypt32/store.c

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