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

   1 /*
   2  * Copyright 2004-2007 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18 #include <stdarg.h>
  19 #include "windef.h"
  20 #include "winbase.h"
  21 #include "wincrypt.h"
  22 #include "wine/debug.h"
  23 #include "wine/list.h"
  24 #include "crypt32_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  27
  28 typedef struct _WINE_PROVIDERSTORE
  29 {
  30     WINECRYPT_CERTSTORE             hdr;
  31     DWORD                           dwStoreProvFlags;
  32     PWINECRYPT_CERTSTORE            memStore;
  33     HCERTSTOREPROV                  hStoreProv;
  34     PFN_CERT_STORE_PROV_CLOSE       provCloseStore;
  35     PFN_CERT_STORE_PROV_WRITE_CERT  provWriteCert;
  36     PFN_CERT_STORE_PROV_DELETE_CERT provDeleteCert;
  37     PFN_CERT_STORE_PROV_WRITE_CRL   provWriteCrl;
  38     PFN_CERT_STORE_PROV_DELETE_CRL  provDeleteCrl;
  39     PFN_CERT_STORE_PROV_WRITE_CTL   provWriteCtl;
  40     PFN_CERT_STORE_PROV_DELETE_CTL  provDeleteCtl;
  41     PFN_CERT_STORE_PROV_CONTROL     provControl;
  42 } WINE_PROVIDERSTORE, *PWINE_PROVIDERSTORE;
  43
  44 static void WINAPI CRYPT_ProvCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
  45 {
  46     PWINE_PROVIDERSTORE store = hCertStore;
  47
  48     TRACE("(%p, %08x)\n", store, dwFlags);
  49
  50     if (store->provCloseStore)
  51         store->provCloseStore(store->hStoreProv, dwFlags);
  52     if (!(store->dwStoreProvFlags & CERT_STORE_PROV_EXTERNAL_FLAG))
  53         CertCloseStore(store->memStore, dwFlags);
  54     CRYPT_FreeStore((PWINECRYPT_CERTSTORE)store);
  55 }
  56
  57 static BOOL CRYPT_ProvAddCert(PWINECRYPT_CERTSTORE store, void *cert,
  58  void *toReplace, const void **ppStoreContext)
  59 {
  60     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
  61     BOOL ret;
  62
  63     TRACE("(%p, %p, %p, %p)\n", store, cert, toReplace, ppStoreContext);
  64
  65     if (toReplace)
  66         ret = ps->memStore->certs.addContext(ps->memStore, cert, toReplace,
  67          ppStoreContext);
  68     else
  69     {
  70         ret = TRUE;
  71         if (ps->provWriteCert)
  72             ret = ps->provWriteCert(ps->hStoreProv, cert,
  73              CERT_STORE_PROV_WRITE_ADD_FLAG);
  74         if (ret)
  75             ret = ps->memStore->certs.addContext(ps->memStore, cert, NULL,
  76              ppStoreContext);
  77     }
  78     /* dirty trick: replace the returned context's hCertStore with
  79      * store.
  80      */
  81     if (ret && ppStoreContext)
  82         (*(PCERT_CONTEXT *)ppStoreContext)->hCertStore = store;
  83     return ret;
  84 }
  85
  86 static void *CRYPT_ProvEnumCert(PWINECRYPT_CERTSTORE store, void *pPrev)
  87 {
  88     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
  89     void *ret;
  90
  91     ret = ps->memStore->certs.enumContext(ps->memStore, pPrev);
  92     if (ret)
  93     {
  94         /* same dirty trick: replace the returned context's hCertStore with
  95          * store.
  96          */
  97         ((PCERT_CONTEXT)ret)->hCertStore = store;
  98     }
  99     return ret;
 100 }
 101
 102 static BOOL CRYPT_ProvDeleteCert(PWINECRYPT_CERTSTORE store, void *cert)
 103 {
 104     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 105     BOOL ret = TRUE;
 106
 107     TRACE("(%p, %p)\n", store, cert);
 108
 109     if (ps->provDeleteCert)
 110         ret = ps->provDeleteCert(ps->hStoreProv, cert, 0);
 111     if (ret)
 112         ret = ps->memStore->certs.deleteContext(ps->memStore, cert);
 113     return ret;
 114 }
 115
 116 static BOOL CRYPT_ProvAddCRL(PWINECRYPT_CERTSTORE store, void *crl,
 117  void *toReplace, const void **ppStoreContext)
 118 {
 119     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 120     BOOL ret;
 121
 122     TRACE("(%p, %p, %p, %p)\n", store, crl, toReplace, ppStoreContext);
 123
 124     if (toReplace)
 125         ret = ps->memStore->crls.addContext(ps->memStore, crl, toReplace,
 126          ppStoreContext);
 127     else
 128     {
 129         if (ps->hdr.dwOpenFlags & CERT_STORE_READONLY_FLAG)
 130         {
 131             SetLastError(ERROR_ACCESS_DENIED);
 132             ret = FALSE;
 133         }
 134         else
 135         {
 136             ret = TRUE;
 137             if (ps->provWriteCrl)
 138                 ret = ps->provWriteCrl(ps->hStoreProv, crl,
 139                  CERT_STORE_PROV_WRITE_ADD_FLAG);
 140             if (ret)
 141                 ret = ps->memStore->crls.addContext(ps->memStore, crl, NULL,
 142                  ppStoreContext);
 143         }
 144     }
 145     /* dirty trick: replace the returned context's hCertStore with
 146      * store.
 147      */
 148     if (ret && ppStoreContext)
 149         (*(PCRL_CONTEXT *)ppStoreContext)->hCertStore = store;
 150     return ret;
 151 }
 152
 153 static void *CRYPT_ProvEnumCRL(PWINECRYPT_CERTSTORE store, void *pPrev)
 154 {
 155     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 156     void *ret;
 157
 158     ret = ps->memStore->crls.enumContext(ps->memStore, pPrev);
 159     if (ret)
 160     {
 161         /* same dirty trick: replace the returned context's hCertStore with
 162          * store.
 163          */
 164         ((PCRL_CONTEXT)ret)->hCertStore = store;
 165     }
 166     return ret;
 167 }
 168
 169 static BOOL CRYPT_ProvDeleteCRL(PWINECRYPT_CERTSTORE store, void *crl)
 170 {
 171     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 172     BOOL ret = TRUE;
 173
 174     TRACE("(%p, %p)\n", store, crl);
 175
 176     if (ps->provDeleteCrl)
 177         ret = ps->provDeleteCrl(ps->hStoreProv, crl, 0);
 178     if (ret)
 179         ret = ps->memStore->crls.deleteContext(ps->memStore, crl);
 180     return ret;
 181 }
 182
 183 static BOOL CRYPT_ProvAddCTL(PWINECRYPT_CERTSTORE store, void *ctl,
 184  void *toReplace, const void **ppStoreContext)
 185 {
 186     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 187     BOOL ret;
 188
 189     TRACE("(%p, %p, %p, %p)\n", store, ctl, toReplace, ppStoreContext);
 190
 191     if (toReplace)
 192         ret = ps->memStore->ctls.addContext(ps->memStore, ctl, toReplace,
 193          ppStoreContext);
 194     else
 195     {
 196         if (ps->hdr.dwOpenFlags & CERT_STORE_READONLY_FLAG)
 197         {
 198             SetLastError(ERROR_ACCESS_DENIED);
 199             ret = FALSE;
 200         }
 201         else
 202         {
 203             ret = TRUE;
 204             if (ps->provWriteCtl)
 205                 ret = ps->provWriteCtl(ps->hStoreProv, ctl,
 206                  CERT_STORE_PROV_WRITE_ADD_FLAG);
 207             if (ret)
 208                 ret = ps->memStore->ctls.addContext(ps->memStore, ctl, NULL,
 209                  ppStoreContext);
 210         }
 211     }
 212     /* dirty trick: replace the returned context's hCertStore with
 213      * store.
 214      */
 215     if (ret && ppStoreContext)
 216         (*(PCTL_CONTEXT *)ppStoreContext)->hCertStore = store;
 217     return ret;
 218 }
 219
 220 static void *CRYPT_ProvEnumCTL(PWINECRYPT_CERTSTORE store, void *pPrev)
 221 {
 222     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 223     void *ret;
 224
 225     ret = ps->memStore->ctls.enumContext(ps->memStore, pPrev);
 226     if (ret)
 227     {
 228         /* same dirty trick: replace the returned context's hCertStore with
 229          * store.
 230          */
 231         ((PCTL_CONTEXT)ret)->hCertStore = store;
 232     }
 233     return ret;
 234 }
 235
 236 static BOOL CRYPT_ProvDeleteCTL(PWINECRYPT_CERTSTORE store, void *ctl)
 237 {
 238     PWINE_PROVIDERSTORE ps = (PWINE_PROVIDERSTORE)store;
 239     BOOL ret = TRUE;
 240
 241     TRACE("(%p, %p)\n", store, ctl);
 242
 243     if (ps->provDeleteCtl)
 244         ret = ps->provDeleteCtl(ps->hStoreProv, ctl, 0);
 245     if (ret)
 246         ret = ps->memStore->ctls.deleteContext(ps->memStore, ctl);
 247     return ret;
 248 }
 249
 250 static BOOL WINAPI CRYPT_ProvControl(HCERTSTORE hCertStore, DWORD dwFlags,
 251  DWORD dwCtrlType, void const *pvCtrlPara)
 252 {
 253     PWINE_PROVIDERSTORE store = hCertStore;
 254     BOOL ret = TRUE;
 255
 256     TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
 257      pvCtrlPara);
 258
 259     if (store->provControl)
 260         ret = store->provControl(store->hStoreProv, dwFlags, dwCtrlType,
 261          pvCtrlPara);
 262     return ret;
 263 }
 264
 265 PWINECRYPT_CERTSTORE CRYPT_ProvCreateStore(DWORD dwFlags,
 266  PWINECRYPT_CERTSTORE memStore, const CERT_STORE_PROV_INFO *pProvInfo)
 267 {
 268     PWINE_PROVIDERSTORE ret = CryptMemAlloc(sizeof(WINE_PROVIDERSTORE));
 269
 270     if (ret)
 271     {
 272         CRYPT_InitStore(&ret->hdr, dwFlags, StoreTypeProvider);
 273         ret->dwStoreProvFlags = pProvInfo->dwStoreProvFlags;
 274         if (ret->dwStoreProvFlags & CERT_STORE_PROV_EXTERNAL_FLAG)
 275         {
 276             CertCloseStore(memStore, 0);
 277             ret->memStore = NULL;
 278         }
 279         else
 280             ret->memStore = memStore;
 281         ret->hStoreProv = pProvInfo->hStoreProv;
 282         ret->hdr.closeStore = CRYPT_ProvCloseStore;
 283         ret->hdr.certs.addContext = CRYPT_ProvAddCert;
 284         ret->hdr.certs.enumContext = CRYPT_ProvEnumCert;
 285         ret->hdr.certs.deleteContext = CRYPT_ProvDeleteCert;
 286         ret->hdr.crls.addContext = CRYPT_ProvAddCRL;
 287         ret->hdr.crls.enumContext = CRYPT_ProvEnumCRL;
 288         ret->hdr.crls.deleteContext = CRYPT_ProvDeleteCRL;
 289         ret->hdr.ctls.addContext = CRYPT_ProvAddCTL;
 290         ret->hdr.ctls.enumContext = CRYPT_ProvEnumCTL;
 291         ret->hdr.ctls.deleteContext = CRYPT_ProvDeleteCTL;
 292         ret->hdr.control = CRYPT_ProvControl;
 293         if (pProvInfo->cStoreProvFunc > CERT_STORE_PROV_CLOSE_FUNC)
 294             ret->provCloseStore =
 295              pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_CLOSE_FUNC];
 296         else
 297             ret->provCloseStore = NULL;
 298         if (pProvInfo->cStoreProvFunc >
 299          CERT_STORE_PROV_WRITE_CERT_FUNC)
 300             ret->provWriteCert = pProvInfo->rgpvStoreProvFunc[
 301              CERT_STORE_PROV_WRITE_CERT_FUNC];
 302         else
 303             ret->provWriteCert = NULL;
 304         if (pProvInfo->cStoreProvFunc >
 305          CERT_STORE_PROV_DELETE_CERT_FUNC)
 306             ret->provDeleteCert = pProvInfo->rgpvStoreProvFunc[
 307              CERT_STORE_PROV_DELETE_CERT_FUNC];
 308         else
 309             ret->provDeleteCert = NULL;
 310         if (pProvInfo->cStoreProvFunc >
 311          CERT_STORE_PROV_WRITE_CRL_FUNC)
 312             ret->provWriteCrl = pProvInfo->rgpvStoreProvFunc[
 313              CERT_STORE_PROV_WRITE_CRL_FUNC];
 314         else
 315             ret->provWriteCrl = NULL;
 316         if (pProvInfo->cStoreProvFunc >
 317          CERT_STORE_PROV_DELETE_CRL_FUNC)
 318             ret->provDeleteCrl = pProvInfo->rgpvStoreProvFunc[
 319              CERT_STORE_PROV_DELETE_CRL_FUNC];
 320         else
 321             ret->provDeleteCrl = NULL;
 322         if (pProvInfo->cStoreProvFunc >
 323          CERT_STORE_PROV_WRITE_CTL_FUNC)
 324             ret->provWriteCtl = pProvInfo->rgpvStoreProvFunc[
 325              CERT_STORE_PROV_WRITE_CTL_FUNC];
 326         else
 327             ret->provWriteCtl = NULL;
 328         if (pProvInfo->cStoreProvFunc >
 329          CERT_STORE_PROV_DELETE_CTL_FUNC)
 330             ret->provDeleteCtl = pProvInfo->rgpvStoreProvFunc[
 331              CERT_STORE_PROV_DELETE_CTL_FUNC];
 332         else
 333             ret->provDeleteCtl = NULL;
 334         if (pProvInfo->cStoreProvFunc >
 335          CERT_STORE_PROV_CONTROL_FUNC)
 336             ret->provControl = pProvInfo->rgpvStoreProvFunc[
 337              CERT_STORE_PROV_CONTROL_FUNC];
 338         else
 339             ret->provControl = NULL;
 340     }
 341     return (PWINECRYPT_CERTSTORE)ret;
 342 }
 343
 344 PWINECRYPT_CERTSTORE CRYPT_ProvOpenStore(LPCSTR lpszStoreProvider,
 345  DWORD dwEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)
 346 {
 347     static HCRYPTOIDFUNCSET set = NULL;
 348     PFN_CERT_DLL_OPEN_STORE_PROV_FUNC provOpenFunc;
 349     HCRYPTOIDFUNCADDR hFunc;
 350     PWINECRYPT_CERTSTORE ret = NULL;
 351
 352     if (!set)
 353         set = CryptInitOIDFunctionSet(CRYPT_OID_OPEN_STORE_PROV_FUNC, 0);
 354     CryptGetOIDFunctionAddress(set, dwEncodingType, lpszStoreProvider, 0,
 355      (void **)&provOpenFunc, &hFunc);
 356     if (provOpenFunc)
 357     {
 358         CERT_STORE_PROV_INFO provInfo = { 0 };
 359
 360         provInfo.cbSize = sizeof(provInfo);
 361         if (dwFlags & CERT_STORE_DELETE_FLAG)
 362             provOpenFunc(lpszStoreProvider, dwEncodingType, hCryptProv,
 363              dwFlags, pvPara, NULL, &provInfo);
 364         else
 365         {
 366             HCERTSTORE memStore;
 367
 368             memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
 369              CERT_STORE_CREATE_NEW_FLAG, NULL);
 370             if (memStore)
 371             {
 372                 if (provOpenFunc(lpszStoreProvider, dwEncodingType, hCryptProv,
 373                  dwFlags, pvPara, memStore, &provInfo))
 374                     ret = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
 375                 else
 376                     CertCloseStore(memStore, 0);
 377             }
 378         }
 379         CryptFreeOIDFunctionAddress(hFunc, 0);
 380     }
 381     else
 382         SetLastError(ERROR_FILE_NOT_FOUND);
 383     return ret;
 384 }