git.oblomov.eu Git - wine/blob - dlls/cryptnet/cryptnet_main.c

   1 /*
   2  * Copyright (C) 2006 Maarten Lankhorst
   3  * Copyright 2007 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  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23 #include <stdio.h>
  24 #include "windef.h"
  25 #include "wine/debug.h"
  26 #include "winbase.h"
  27 #include "winnt.h"
  28 #include "winnls.h"
  29 #include "wininet.h"
  30 #define NONAMELESSUNION
  31 #define CERT_REVOCATION_PARA_HAS_EXTRA_FIELDS
  32 #include "wincrypt.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(cryptnet);
  35
  36 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  37 {
  38    TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
  39
  40    switch (fdwReason) {
  41       case DLL_PROCESS_ATTACH:
  42          DisableThreadLibraryCalls(hinstDLL);
  43          break;
  44       case DLL_PROCESS_DETACH:
  45          /* Do uninitialisation here */
  46          break;
  47       default: break;
  48    }
  49    return TRUE;
  50 }
  51
  52 static const WCHAR cryptNet[] = { 'c','r','y','p','t','n','e','t','.',
  53    'd','l','l',0 };
  54 static const WCHAR ldapProvOpenStore[] = { 'L','d','a','p','P','r','o','v',
  55    'O','p','e','S','t','o','r','e',0 };
  56
  57 /***********************************************************************
  58  *    DllRegisterServer (CRYPTNET.@)
  59  */
  60 HRESULT WINAPI DllRegisterServer(void)
  61 {
  62    TRACE("\n");
  63    CryptRegisterDefaultOIDFunction(X509_ASN_ENCODING,
  64     CRYPT_OID_VERIFY_REVOCATION_FUNC, 0, cryptNet);
  65    CryptRegisterOIDFunction(0, CRYPT_OID_OPEN_STORE_PROV_FUNC, "Ldap",
  66     cryptNet, "LdapProvOpenStore");
  67    CryptRegisterOIDFunction(0, CRYPT_OID_OPEN_STORE_PROV_FUNC,
  68     CERT_STORE_PROV_LDAP_W, cryptNet, "LdapProvOpenStore");
  69    return S_OK;
  70 }
  71
  72 /***********************************************************************
  73  *    DllUnregisterServer (CRYPTNET.@)
  74  */
  75 HRESULT WINAPI DllUnregisterServer(void)
  76 {
  77    TRACE("\n");
  78    CryptUnregisterDefaultOIDFunction(X509_ASN_ENCODING,
  79     CRYPT_OID_VERIFY_REVOCATION_FUNC, cryptNet);
  80    CryptUnregisterOIDFunction(0, CRYPT_OID_OPEN_STORE_PROV_FUNC, "Ldap");
  81    CryptUnregisterOIDFunction(0, CRYPT_OID_OPEN_STORE_PROV_FUNC,
  82     CERT_STORE_PROV_LDAP_W);
  83    return S_OK;
  84 }
  85
  86 static const char *url_oid_to_str(LPCSTR oid)
  87 {
  88     if (HIWORD(oid))
  89         return oid;
  90     else
  91     {
  92         static char buf[10];
  93
  94         switch (LOWORD(oid))
  95         {
  96 #define _x(oid) case LOWORD(oid): return #oid
  97         _x(URL_OID_CERTIFICATE_ISSUER);
  98         _x(URL_OID_CERTIFICATE_CRL_DIST_POINT);
  99         _x(URL_OID_CTL_ISSUER);
 100         _x(URL_OID_CTL_NEXT_UPDATE);
 101         _x(URL_OID_CRL_ISSUER);
 102         _x(URL_OID_CERTIFICATE_FRESHEST_CRL);
 103         _x(URL_OID_CRL_FRESHEST_CRL);
 104         _x(URL_OID_CROSS_CERT_DIST_POINT);
 105 #undef _x
 106         default:
 107             snprintf(buf, sizeof(buf), "%d", LOWORD(oid));
 108             return buf;
 109         }
 110     }
 111 }
 112
 113 typedef BOOL (WINAPI *UrlDllGetObjectUrlFunc)(LPCSTR, LPVOID, DWORD,
 114  PCRYPT_URL_ARRAY, DWORD *, PCRYPT_URL_INFO, DWORD *, LPVOID);
 115
 116 static BOOL WINAPI CRYPT_GetUrlFromCertificateIssuer(LPCSTR pszUrlOid,
 117  LPVOID pvPara, DWORD dwFlags, PCRYPT_URL_ARRAY pUrlArray, DWORD *pcbUrlArray,
 118  PCRYPT_URL_INFO pUrlInfo, DWORD *pcbUrlInfo, LPVOID pvReserved)
 119 {
 120     /* FIXME: This depends on the AIA (authority info access) extension being
 121      * supported in crypt32.
 122      */
 123     FIXME("\n");
 124     SetLastError(CRYPT_E_NOT_FOUND);
 125     return FALSE;
 126 }
 127
 128 static BOOL WINAPI CRYPT_GetUrlFromCertificateCRLDistPoint(LPCSTR pszUrlOid,
 129  LPVOID pvPara, DWORD dwFlags, PCRYPT_URL_ARRAY pUrlArray, DWORD *pcbUrlArray,
 130  PCRYPT_URL_INFO pUrlInfo, DWORD *pcbUrlInfo, LPVOID pvReserved)
 131 {
 132     PCCERT_CONTEXT cert = (PCCERT_CONTEXT)pvPara;
 133     PCERT_EXTENSION ext;
 134     BOOL ret = FALSE;
 135
 136     /* The only applicable flag is CRYPT_GET_URL_FROM_EXTENSION */
 137     if (dwFlags && !(dwFlags & CRYPT_GET_URL_FROM_EXTENSION))
 138     {
 139         SetLastError(CRYPT_E_NOT_FOUND);
 140         return FALSE;
 141     }
 142     if ((ext = CertFindExtension(szOID_CRL_DIST_POINTS,
 143      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
 144     {
 145         CRL_DIST_POINTS_INFO *info;
 146         DWORD size;
 147
 148         ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_CRL_DIST_POINTS,
 149          ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL,
 150          &info, &size);
 151         if (ret)
 152         {
 153             DWORD i, cUrl, bytesNeeded = sizeof(CRYPT_URL_ARRAY);
 154
 155             for (i = 0, cUrl = 0; i < info->cDistPoint; i++)
 156                 if (info->rgDistPoint[i].DistPointName.dwDistPointNameChoice
 157                  == CRL_DIST_POINT_FULL_NAME)
 158                 {
 159                     DWORD j;
 160                     CERT_ALT_NAME_INFO *name =
 161                      &info->rgDistPoint[i].DistPointName.FullName;
 162
 163                     for (j = 0; j < name->cAltEntry; j++)
 164                         if (name->rgAltEntry[j].dwAltNameChoice ==
 165                          CERT_ALT_NAME_URL)
 166                         {
 167                             if (name->rgAltEntry[j].pwszURL)
 168                             {
 169                                 cUrl++;
 170                                 bytesNeeded += sizeof(LPWSTR) +
 171                                  (lstrlenW(name->rgAltEntry[j].pwszURL) + 1)
 172                                  * sizeof(WCHAR);
 173                             }
 174                         }
 175                 }
 176             if (!pcbUrlArray)
 177             {
 178                 SetLastError(E_INVALIDARG);
 179                 ret = FALSE;
 180             }
 181             else if (!pUrlArray)
 182                 *pcbUrlArray = bytesNeeded;
 183             else if (*pcbUrlArray < bytesNeeded)
 184             {
 185                 SetLastError(ERROR_MORE_DATA);
 186                 *pcbUrlArray = bytesNeeded;
 187                 ret = FALSE;
 188             }
 189             else
 190             {
 191                 LPWSTR nextUrl;
 192
 193                 *pcbUrlArray = bytesNeeded;
 194                 pUrlArray->cUrl = 0;
 195                 pUrlArray->rgwszUrl =
 196                  (LPWSTR *)((BYTE *)pUrlArray + sizeof(CRYPT_URL_ARRAY));
 197                 nextUrl = (LPWSTR)((BYTE *)pUrlArray + sizeof(CRYPT_URL_ARRAY)
 198                  + cUrl * sizeof(LPWSTR));
 199                 for (i = 0; i < info->cDistPoint; i++)
 200                     if (info->rgDistPoint[i].DistPointName.dwDistPointNameChoice
 201                      == CRL_DIST_POINT_FULL_NAME)
 202                     {
 203                         DWORD j;
 204                         CERT_ALT_NAME_INFO *name =
 205                          &info->rgDistPoint[i].DistPointName.FullName;
 206
 207                         for (j = 0; j < name->cAltEntry; j++)
 208                             if (name->rgAltEntry[j].dwAltNameChoice ==
 209                              CERT_ALT_NAME_URL)
 210                             {
 211                                 if (name->rgAltEntry[j].pwszURL)
 212                                 {
 213                                     lstrcpyW(nextUrl,
 214                                      name->rgAltEntry[j].pwszURL);
 215                                     pUrlArray->rgwszUrl[pUrlArray->cUrl++] =
 216                                      nextUrl;
 217                                     nextUrl +=
 218                                      (lstrlenW(name->rgAltEntry[j].pwszURL) + 1)
 219                                      * sizeof(WCHAR);
 220                                 }
 221                             }
 222                     }
 223             }
 224             if (ret)
 225             {
 226                 if (pcbUrlInfo)
 227                 {
 228                     FIXME("url info: stub\n");
 229                     if (!pUrlInfo)
 230                         *pcbUrlInfo = sizeof(CRYPT_URL_INFO);
 231                     else if (*pcbUrlInfo < sizeof(CRYPT_URL_INFO))
 232                     {
 233                         *pcbUrlInfo = sizeof(CRYPT_URL_INFO);
 234                         SetLastError(ERROR_MORE_DATA);
 235                         ret = FALSE;
 236                     }
 237                     else
 238                     {
 239                         *pcbUrlInfo = sizeof(CRYPT_URL_INFO);
 240                         memset(pUrlInfo, 0, sizeof(CRYPT_URL_INFO));
 241                     }
 242                 }
 243             }
 244             LocalFree(info);
 245         }
 246     }
 247     else
 248         SetLastError(CRYPT_E_NOT_FOUND);
 249     return ret;
 250 }
 251
 252 /***********************************************************************
 253  *    CryptGetObjectUrl (CRYPTNET.@)
 254  */
 255 BOOL WINAPI CryptGetObjectUrl(LPCSTR pszUrlOid, LPVOID pvPara, DWORD dwFlags,
 256  PCRYPT_URL_ARRAY pUrlArray, DWORD *pcbUrlArray, PCRYPT_URL_INFO pUrlInfo,
 257  DWORD *pcbUrlInfo, LPVOID pvReserved)
 258 {
 259     UrlDllGetObjectUrlFunc func = NULL;
 260     HCRYPTOIDFUNCADDR hFunc = NULL;
 261     BOOL ret = FALSE;
 262
 263     TRACE("(%s, %p, %08x, %p, %p, %p, %p, %p)\n", debugstr_a(pszUrlOid),
 264      pvPara, dwFlags, pUrlArray, pcbUrlArray, pUrlInfo, pcbUrlInfo, pvReserved);
 265
 266     if (!HIWORD(pszUrlOid))
 267     {
 268         switch (LOWORD(pszUrlOid))
 269         {
 270         case LOWORD(URL_OID_CERTIFICATE_ISSUER):
 271             func = CRYPT_GetUrlFromCertificateIssuer;
 272             break;
 273         case LOWORD(URL_OID_CERTIFICATE_CRL_DIST_POINT):
 274             func = CRYPT_GetUrlFromCertificateCRLDistPoint;
 275             break;
 276         default:
 277             FIXME("unimplemented for %s\n", url_oid_to_str(pszUrlOid));
 278             SetLastError(ERROR_FILE_NOT_FOUND);
 279         }
 280     }
 281     else
 282     {
 283         static HCRYPTOIDFUNCSET set = NULL;
 284
 285         if (!set)
 286             set = CryptInitOIDFunctionSet(URL_OID_GET_OBJECT_URL_FUNC, 0);
 287         CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, pszUrlOid, 0,
 288          (void **)&func, &hFunc);
 289     }
 290     if (func)
 291         ret = func(pszUrlOid, pvPara, dwFlags, pUrlArray, pcbUrlArray,
 292          pUrlInfo, pcbUrlInfo, pvReserved);
 293     if (hFunc)
 294         CryptFreeOIDFunctionAddress(hFunc, 0);
 295     return ret;
 296 }
 297
 298 /***********************************************************************
 299  *    CryptRetrieveObjectByUrlA (CRYPTNET.@)
 300  */
 301 BOOL WINAPI CryptRetrieveObjectByUrlA(LPCSTR pszURL, LPCSTR pszObjectOid,
 302  DWORD dwRetrievalFlags, DWORD dwTimeout, LPVOID *ppvObject,
 303  HCRYPTASYNC hAsyncRetrieve, PCRYPT_CREDENTIALS pCredentials, LPVOID pvVerify,
 304  PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
 305 {
 306     BOOL ret = FALSE;
 307     int len;
 308
 309     TRACE("(%s, %s, %08x, %d, %p, %p, %p, %p, %p)\n", debugstr_a(pszURL),
 310      debugstr_a(pszObjectOid), dwRetrievalFlags, dwTimeout, ppvObject,
 311      hAsyncRetrieve, pCredentials, pvVerify, pAuxInfo);
 312
 313     if (!pszURL)
 314     {
 315         SetLastError(ERROR_INVALID_PARAMETER);
 316         return FALSE;
 317     }
 318     len = MultiByteToWideChar(CP_ACP, 0, pszURL, -1, NULL, 0);
 319     if (len)
 320     {
 321         LPWSTR url = CryptMemAlloc(len * sizeof(WCHAR));
 322
 323         if (url)
 324         {
 325             MultiByteToWideChar(CP_ACP, 0, pszURL, -1, url, len);
 326             ret = CryptRetrieveObjectByUrlW(url, pszObjectOid,
 327              dwRetrievalFlags, dwTimeout, ppvObject, hAsyncRetrieve,
 328              pCredentials, pvVerify, pAuxInfo);
 329             CryptMemFree(url);
 330         }
 331         else
 332             SetLastError(ERROR_OUTOFMEMORY);
 333     }
 334     return ret;
 335 }
 336
 337 static void WINAPI CRYPT_FreeBlob(LPCSTR pszObjectOid,
 338  PCRYPT_BLOB_ARRAY pObject, void *pvFreeContext)
 339 {
 340     DWORD i;
 341
 342     for (i = 0; i < pObject->cBlob; i++)
 343         CryptMemFree(pObject->rgBlob[i].pbData);
 344     CryptMemFree(pObject->rgBlob);
 345 }
 346
 347 static BOOL CRYPT_GetObjectFromFile(HANDLE hFile, PCRYPT_BLOB_ARRAY pObject)
 348 {
 349     BOOL ret;
 350     LARGE_INTEGER size;
 351
 352     if ((ret = GetFileSizeEx(hFile, &size)))
 353     {
 354         if (size.HighPart)
 355         {
 356             WARN("file too big\n");
 357             SetLastError(ERROR_INVALID_DATA);
 358             ret = FALSE;
 359         }
 360         else
 361         {
 362             CRYPT_DATA_BLOB blob;
 363
 364             blob.pbData = CryptMemAlloc(size.LowPart);
 365             if (blob.pbData)
 366             {
 367                 blob.cbData = size.LowPart;
 368                 ret = ReadFile(hFile, blob.pbData, size.LowPart, &blob.cbData,
 369                  NULL);
 370                 if (ret)
 371                 {
 372                     pObject->rgBlob = CryptMemAlloc(sizeof(CRYPT_DATA_BLOB));
 373                     if (pObject->rgBlob)
 374                     {
 375                         pObject->cBlob = 1;
 376                         memcpy(pObject->rgBlob, &blob, sizeof(CRYPT_DATA_BLOB));
 377                     }
 378                     else
 379                     {
 380                         SetLastError(ERROR_OUTOFMEMORY);
 381                         ret = FALSE;
 382                     }
 383                 }
 384                 if (!ret)
 385                     CryptMemFree(blob.pbData);
 386             }
 387             else
 388             {
 389                 SetLastError(ERROR_OUTOFMEMORY);
 390                 ret = FALSE;
 391             }
 392         }
 393     }
 394     return ret;
 395 }
 396
 397 /* FIXME: should make wininet cache all downloads instead */
 398 static BOOL CRYPT_GetObjectFromCache(LPCWSTR pszURL, PCRYPT_BLOB_ARRAY pObject,
 399  PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
 400 {
 401     BOOL ret = FALSE;
 402     INTERNET_CACHE_ENTRY_INFOW cacheInfo = { sizeof(cacheInfo), 0 };
 403     DWORD size = sizeof(cacheInfo);
 404
 405     TRACE("(%s, %p, %p)\n", debugstr_w(pszURL), pObject, pAuxInfo);
 406
 407     if (GetUrlCacheEntryInfoW(pszURL, &cacheInfo, &size) ||
 408      GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 409     {
 410         FILETIME ft;
 411
 412         GetSystemTimeAsFileTime(&ft);
 413         if (CompareFileTime(&cacheInfo.ExpireTime, &ft) >= 0)
 414         {
 415             LPINTERNET_CACHE_ENTRY_INFOW pCacheInfo = CryptMemAlloc(size);
 416
 417             if (pCacheInfo)
 418             {
 419                 if (GetUrlCacheEntryInfoW(pszURL, pCacheInfo, &size))
 420                 {
 421                     HANDLE hFile = CreateFileW(pCacheInfo->lpszLocalFileName,
 422                      GENERIC_READ, 0, NULL, OPEN_EXISTING,
 423                      FILE_ATTRIBUTE_NORMAL, NULL);
 424
 425                     if (hFile != INVALID_HANDLE_VALUE)
 426                     {
 427                         if ((ret = CRYPT_GetObjectFromFile(hFile, pObject)))
 428                         {
 429                             if (pAuxInfo && pAuxInfo->cbSize >=
 430                              offsetof(CRYPT_RETRIEVE_AUX_INFO,
 431                              pLastSyncTime) + sizeof(PFILETIME) &&
 432                              pAuxInfo->pLastSyncTime)
 433                                 memcpy(pAuxInfo->pLastSyncTime,
 434                                  &pCacheInfo->LastSyncTime,
 435                                  sizeof(FILETIME));
 436                         }
 437                         CloseHandle(hFile);
 438                     }
 439                 }
 440                 CryptMemFree(pCacheInfo);
 441             }
 442             else
 443                 SetLastError(ERROR_OUTOFMEMORY);
 444         }
 445         else
 446             DeleteUrlCacheEntryW(pszURL);
 447     }
 448     TRACE("returning %d\n", ret);
 449     return ret;
 450 }
 451
 452 static inline LPWSTR strndupW(LPWSTR string, int len)
 453 {
 454     LPWSTR ret = NULL;
 455     if (string && (ret = CryptMemAlloc((len + 1) * sizeof(WCHAR))) != NULL)
 456     {
 457         memcpy(ret, string, len * sizeof(WCHAR));
 458         ret[len] = 0;
 459     }
 460     return ret;
 461 }
 462
 463 /* Parses the URL, and sets components's lpszHostName and lpszUrlPath members
 464  * to NULL-terminated copies of those portions of the URL (to be freed with
 465  * CryptMemFree.)
 466  */
 467 static BOOL CRYPT_CrackUrl(LPCWSTR pszURL, URL_COMPONENTSW *components)
 468 {
 469     BOOL ret;
 470
 471     TRACE("(%s, %p)\n", debugstr_w(pszURL), components);
 472
 473     memset(components, 0, sizeof(*components));
 474     components->dwStructSize = sizeof(*components);
 475     components->dwHostNameLength = 1;
 476     components->dwUrlPathLength = 1;
 477     ret = InternetCrackUrlW(pszURL, 0, ICU_DECODE, components);
 478     if (ret)
 479     {
 480         LPWSTR hostname = strndupW(components->lpszHostName,
 481          components->dwHostNameLength);
 482         LPWSTR path = strndupW(components->lpszUrlPath,
 483          components->dwUrlPathLength);
 484
 485         components->lpszHostName = hostname;
 486         components->lpszUrlPath = path;
 487         switch (components->nScheme)
 488         {
 489         case INTERNET_SCHEME_FTP:
 490             if (!components->nPort)
 491                 components->nPort = INTERNET_DEFAULT_FTP_PORT;
 492             break;
 493         case INTERNET_SCHEME_HTTP:
 494             if (!components->nPort)
 495                 components->nPort = INTERNET_DEFAULT_HTTP_PORT;
 496             break;
 497         default:
 498             ; /* do nothing */
 499         }
 500     }
 501     TRACE("returning %d\n", ret);
 502     return ret;
 503 }
 504
 505 struct InetContext
 506 {
 507     HANDLE event;
 508     DWORD  timeout;
 509     DWORD  error;
 510 };
 511
 512 static struct InetContext *CRYPT_MakeInetContext(DWORD dwTimeout)
 513 {
 514     struct InetContext *context = CryptMemAlloc(sizeof(struct InetContext));
 515
 516     if (context)
 517     {
 518         context->event = CreateEventW(NULL, FALSE, FALSE, NULL);
 519         if (!context->event)
 520         {
 521             CryptMemFree(context);
 522             context = NULL;
 523         }
 524         else
 525         {
 526             context->timeout = dwTimeout;
 527             context->error = ERROR_SUCCESS;
 528         }
 529     }
 530     return context;
 531 }
 532
 533 static BOOL CRYPT_DownloadObject(DWORD dwRetrievalFlags, HINTERNET hHttp,
 534  struct InetContext *context, PCRYPT_BLOB_ARRAY pObject,
 535  PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
 536 {
 537     CRYPT_DATA_BLOB object = { 0, NULL };
 538     DWORD bytesAvailable;
 539     BOOL ret;
 540
 541     do {
 542         if ((ret = InternetQueryDataAvailable(hHttp, &bytesAvailable, 0, 0)))
 543         {
 544             if (bytesAvailable)
 545             {
 546                 if (object.pbData)
 547                     object.pbData = CryptMemRealloc(object.pbData,
 548                      object.cbData + bytesAvailable);
 549                 else
 550                     object.pbData = CryptMemAlloc(bytesAvailable);
 551                 if (object.pbData)
 552                 {
 553                     INTERNET_BUFFERSA buffer = { sizeof(buffer), 0 };
 554
 555                     buffer.dwBufferLength = bytesAvailable;
 556                     buffer.lpvBuffer = object.pbData + object.cbData;
 557                     if (!(ret = InternetReadFileExA(hHttp, &buffer, IRF_NO_WAIT,
 558                      (DWORD_PTR)context)))
 559                     {
 560                         if (GetLastError() == ERROR_IO_PENDING)
 561                         {
 562                             if (WaitForSingleObject(context->event,
 563                              context->timeout) == WAIT_TIMEOUT)
 564                                 SetLastError(ERROR_TIMEOUT);
 565                             else if (context->error)
 566                                 SetLastError(context->error);
 567                             else
 568                                 ret = TRUE;
 569                         }
 570                     }
 571                     if (ret)
 572                         object.cbData += bytesAvailable;
 573                 }
 574                 else
 575                 {
 576                     SetLastError(ERROR_OUTOFMEMORY);
 577                     ret = FALSE;
 578                 }
 579             }
 580         }
 581         else if (GetLastError() == ERROR_IO_PENDING)
 582         {
 583             if (WaitForSingleObject(context->event, context->timeout) ==
 584              WAIT_TIMEOUT)
 585                 SetLastError(ERROR_TIMEOUT);
 586             else
 587                 ret = TRUE;
 588         }
 589     } while (ret && bytesAvailable);
 590     if (ret)
 591     {
 592         pObject->rgBlob = CryptMemAlloc(sizeof(CRYPT_DATA_BLOB));
 593         if (!pObject->rgBlob)
 594         {
 595             CryptMemFree(object.pbData);
 596             SetLastError(ERROR_OUTOFMEMORY);
 597             ret = FALSE;
 598         }
 599         else
 600         {
 601             pObject->rgBlob[0].cbData = object.cbData;
 602             pObject->rgBlob[0].pbData = object.pbData;
 603             pObject->cBlob = 1;
 604         }
 605     }
 606     TRACE("returning %d\n", ret);
 607     return ret;
 608 }
 609
 610 static void CRYPT_CacheURL(LPCWSTR pszURL, PCRYPT_BLOB_ARRAY pObject,
 611  DWORD dwRetrievalFlags, FILETIME expires)
 612 {
 613     WCHAR cacheFileName[MAX_PATH];
 614
 615     /* FIXME: let wininet directly cache instead */
 616     if (CreateUrlCacheEntryW(pszURL, pObject->rgBlob[0].cbData, NULL,
 617      cacheFileName, 0))
 618     {
 619         HANDLE hCacheFile = CreateFileW(cacheFileName, GENERIC_WRITE, 0, NULL,
 620          CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 621
 622         if (hCacheFile != INVALID_HANDLE_VALUE)
 623         {
 624             DWORD bytesWritten, entryType;
 625             FILETIME ft = { 0 };
 626
 627             if (!(dwRetrievalFlags & CRYPT_STICKY_CACHE_RETRIEVAL))
 628                 entryType = NORMAL_CACHE_ENTRY;
 629             else
 630                 entryType = STICKY_CACHE_ENTRY;
 631             WriteFile(hCacheFile, pObject->rgBlob[0].pbData,
 632              pObject->rgBlob[0].cbData, &bytesWritten, NULL);
 633             CloseHandle(hCacheFile);
 634             CommitUrlCacheEntryW(pszURL, cacheFileName, expires, ft, entryType,
 635              NULL, 0, NULL, NULL);
 636         }
 637     }
 638 }
 639
 640 static void CALLBACK CRYPT_InetStatusCallback(HINTERNET hInt,
 641  DWORD_PTR dwContext, DWORD status, void *statusInfo, DWORD statusInfoLen)
 642 {
 643     struct InetContext *context = (struct InetContext *)dwContext;
 644     LPINTERNET_ASYNC_RESULT result;
 645
 646     switch (status)
 647     {
 648     case INTERNET_STATUS_REQUEST_COMPLETE:
 649         result = (LPINTERNET_ASYNC_RESULT)statusInfo;
 650         context->error = result->dwError;
 651         SetEvent(context->event);
 652     }
 653 }
 654
 655 static BOOL CRYPT_Connect(URL_COMPONENTSW *components,
 656  struct InetContext *context, PCRYPT_CREDENTIALS pCredentials,
 657  HINTERNET *phInt, HINTERNET *phHost)
 658 {
 659     BOOL ret;
 660
 661     TRACE("(%s:%d, %p, %p, %p, %p)\n", debugstr_w(components->lpszHostName),
 662      components->nPort, context, pCredentials, phInt, phInt);
 663
 664     *phHost = NULL;
 665     *phInt = InternetOpenW(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL,
 666      context ? INTERNET_FLAG_ASYNC : 0);
 667     if (*phInt)
 668     {
 669         DWORD service;
 670
 671         if (context)
 672             InternetSetStatusCallbackW(*phInt, CRYPT_InetStatusCallback);
 673         switch (components->nScheme)
 674         {
 675         case INTERNET_SCHEME_FTP:
 676             service = INTERNET_SERVICE_FTP;
 677             break;
 678         case INTERNET_SCHEME_HTTP:
 679             service = INTERNET_SERVICE_HTTP;
 680             break;
 681         default:
 682             service = 0;
 683         }
 684         /* FIXME: use pCredentials for username/password */
 685         *phHost = InternetConnectW(*phInt, components->lpszHostName,
 686          components->nPort, NULL, NULL, service, 0, (DWORD_PTR)context);
 687         if (!*phHost)
 688         {
 689             InternetCloseHandle(*phInt);
 690             *phInt = NULL;
 691             ret = FALSE;
 692         }
 693         else
 694             ret = TRUE;
 695     }
 696     else
 697         ret = FALSE;
 698     TRACE("returning %d\n", ret);
 699     return ret;
 700 }
 701
 702 static BOOL WINAPI FTP_RetrieveEncodedObjectW(LPCWSTR pszURL,
 703  LPCSTR pszObjectOid, DWORD dwRetrievalFlags, DWORD dwTimeout,
 704  PCRYPT_BLOB_ARRAY pObject, PFN_FREE_ENCODED_OBJECT_FUNC *ppfnFreeObject,
 705  void **ppvFreeContext, HCRYPTASYNC hAsyncRetrieve,
 706  PCRYPT_CREDENTIALS pCredentials, PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
 707 {
 708     FIXME("(%s, %s, %08x, %d, %p, %p, %p, %p, %p, %p)\n", debugstr_w(pszURL),
 709      debugstr_a(pszObjectOid), dwRetrievalFlags, dwTimeout, pObject,
 710      ppfnFreeObject, ppvFreeContext, hAsyncRetrieve, pCredentials, pAuxInfo);
 711
 712     pObject->cBlob = 0;
 713     pObject->rgBlob = NULL;
 714     *ppfnFreeObject = CRYPT_FreeBlob;
 715     *ppvFreeContext = NULL;
 716     return FALSE;
 717 }
 718
 719 static const WCHAR x509cacert[] = { 'a','p','p','l','i','c','a','t','i','o','n',
 720  '/','x','-','x','5','0','9','-','c','a','-','c','e','r','t',0 };
 721 static const WCHAR x509emailcert[] = { 'a','p','p','l','i','c','a','t','i','o',
 722  'n','/','x','-','x','5','0','9','-','e','m','a','i','l','-','c','e','r','t',
 723  0 };
 724 static const WCHAR x509servercert[] = { 'a','p','p','l','i','c','a','t','i','o',
 725  'n','/','x','-','x','5','0','9','-','s','e','r','v','e','r','-','c','e','r',
 726  't',0 };
 727 static const WCHAR x509usercert[] = { 'a','p','p','l','i','c','a','t','i','o',
 728  'n','/','x','-','x','5','0','9','-','u','s','e','r','-','c','e','r','t',0 };
 729 static const WCHAR pkcs7cert[] = { 'a','p','p','l','i','c','a','t','i','o','n',
 730  '/','x','-','p','k','c','s','7','-','c','e','r','t','i','f','c','a','t','e',
 731  's',0 };
 732 static const WCHAR pkixCRL[] = { 'a','p','p','l','i','c','a','t','i','o','n',
 733  '/','p','k','i','x','-','c','r','l',0 };
 734 static const WCHAR pkcs7CRL[] = { 'a','p','p','l','i','c','a','t','i','o','n',
 735  '/','x','-','p','k','c','s','7','-','c','r','l',0 };
 736 static const WCHAR pkcs7sig[] = { 'a','p','p','l','i','c','a','t','i','o','n',
 737  '/','x','-','p','k','c','s','7','-','s','i','g','n','a','t','u','r','e',0 };
 738 static const WCHAR pkcs7mime[] = { 'a','p','p','l','i','c','a','t','i','o','n',
 739  '/','x','-','p','k','c','s','7','-','m','i','m','e',0 };
 740
 741 static BOOL WINAPI HTTP_RetrieveEncodedObjectW(LPCWSTR pszURL,
 742  LPCSTR pszObjectOid, DWORD dwRetrievalFlags, DWORD dwTimeout,
 743  PCRYPT_BLOB_ARRAY pObject, PFN_FREE_ENCODED_OBJECT_FUNC *ppfnFreeObject,
 744  void **ppvFreeContext, HCRYPTASYNC hAsyncRetrieve,
 745  PCRYPT_CREDENTIALS pCredentials, PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
 746 {
 747     BOOL ret = FALSE;
 748
 749     TRACE("(%s, %s, %08x, %d, %p, %p, %p, %p, %p, %p)\n", debugstr_w(pszURL),
 750      debugstr_a(pszObjectOid), dwRetrievalFlags, dwTimeout, pObject,
 751      ppfnFreeObject, ppvFreeContext, hAsyncRetrieve, pCredentials, pAuxInfo);
 752
 753     pObject->cBlob = 0;
 754     pObject->rgBlob = NULL;
 755     *ppfnFreeObject = CRYPT_FreeBlob;
 756     *ppvFreeContext = NULL;
 757
 758     if (!(dwRetrievalFlags & CRYPT_WIRE_ONLY_RETRIEVAL))
 759         ret = CRYPT_GetObjectFromCache(pszURL, pObject, pAuxInfo);
 760     if (!ret && (!(dwRetrievalFlags & CRYPT_CACHE_ONLY_RETRIEVAL) ||
 761      (dwRetrievalFlags & CRYPT_WIRE_ONLY_RETRIEVAL)))
 762     {
 763         URL_COMPONENTSW components;
 764
 765         if ((ret = CRYPT_CrackUrl(pszURL, &components)))
 766         {
 767             HINTERNET hInt, hHost;
 768             struct InetContext *context = NULL;
 769
 770             if (dwTimeout)
 771                 context = CRYPT_MakeInetContext(dwTimeout);
 772             ret = CRYPT_Connect(&components, context, pCredentials, &hInt,
 773              &hHost);
 774             if (ret)
 775             {
 776                 static LPCWSTR types[] = { x509cacert, x509emailcert,
 777                  x509servercert, x509usercert, pkcs7cert, pkixCRL, pkcs7CRL,
 778                  pkcs7sig, pkcs7mime, NULL };
 779                 HINTERNET hHttp = HttpOpenRequestW(hHost, NULL,
 780                  components.lpszUrlPath, NULL, NULL, types,
 781                  INTERNET_FLAG_NO_COOKIES | INTERNET_FLAG_NO_UI,
 782                  (DWORD_PTR)context);
 783
 784                 if (hHttp)
 785                 {
 786                     if (dwTimeout)
 787                     {
 788                         InternetSetOptionW(hHttp,
 789                          INTERNET_OPTION_RECEIVE_TIMEOUT, &dwTimeout,
 790                          sizeof(dwTimeout));
 791                         InternetSetOptionW(hHttp, INTERNET_OPTION_SEND_TIMEOUT,
 792                          &dwTimeout, sizeof(dwTimeout));
 793                     }
 794                     ret = HttpSendRequestExW(hHttp, NULL, NULL, 0,
 795                      (DWORD_PTR)context);
 796                     if (!ret && GetLastError() == ERROR_IO_PENDING)
 797                     {
 798                         if (WaitForSingleObject(context->event,
 799                          context->timeout) == WAIT_TIMEOUT)
 800                             SetLastError(ERROR_TIMEOUT);
 801                         else
 802                             ret = TRUE;
 803                     }
 804                     /* We don't set ret to TRUE in this block to avoid masking
 805                      * an error from HttpSendRequestExW.
 806                      */
 807                     if (!HttpEndRequestW(hHttp, NULL, 0, (DWORD_PTR)context) &&
 808                      GetLastError() == ERROR_IO_PENDING)
 809                     {
 810                         if (WaitForSingleObject(context->event,
 811                          context->timeout) == WAIT_TIMEOUT)
 812                         {
 813                             SetLastError(ERROR_TIMEOUT);
 814                             ret = FALSE;
 815                         }
 816                     }
 817                     if (ret)
 818                         ret = CRYPT_DownloadObject(dwRetrievalFlags, hHttp,
 819                          context, pObject, pAuxInfo);
 820                     if (ret && !(dwRetrievalFlags & CRYPT_DONT_CACHE_RESULT))
 821                     {
 822                         SYSTEMTIME st;
 823                         DWORD len = sizeof(st);
 824
 825                         if (HttpQueryInfoW(hHttp,
 826                          HTTP_QUERY_EXPIRES | HTTP_QUERY_FLAG_SYSTEMTIME, &st,
 827                          &len, NULL))
 828                         {
 829                             FILETIME ft;
 830
 831                             SystemTimeToFileTime(&st, &ft);
 832                             CRYPT_CacheURL(pszURL, pObject, dwRetrievalFlags,
 833                              ft);
 834                         }
 835                     }
 836                     InternetCloseHandle(hHttp);
 837                 }
 838                 InternetCloseHandle(hHost);
 839                 InternetCloseHandle(hInt);
 840             }
 841             if (context)
 842             {
 843                 CloseHandle(context->event);
 844                 CryptMemFree(context);
 845             }
 846             CryptMemFree(components.lpszUrlPath);
 847             CryptMemFree(components.lpszHostName);
 848         }
 849     }
 850     TRACE("returning %d\n", ret);
 851     return ret;
 852 }
 853
 854 static BOOL WINAPI File_RetrieveEncodedObjectW(LPCWSTR pszURL,
 855  LPCSTR pszObjectOid, DWORD dwRetrievalFlags, DWORD dwTimeout,
 856  PCRYPT_BLOB_ARRAY pObject, PFN_FREE_ENCODED_OBJECT_FUNC *ppfnFreeObject,
 857  void **ppvFreeContext, HCRYPTASYNC hAsyncRetrieve,
 858  PCRYPT_CREDENTIALS pCredentials, PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
 859 {
 860     URL_COMPONENTSW components = { sizeof(components), 0 };
 861     BOOL ret;
 862
 863     TRACE("(%s, %s, %08x, %d, %p, %p, %p, %p, %p, %p)\n", debugstr_w(pszURL),
 864      debugstr_a(pszObjectOid), dwRetrievalFlags, dwTimeout, pObject,
 865      ppfnFreeObject, ppvFreeContext, hAsyncRetrieve, pCredentials, pAuxInfo);
 866
 867     pObject->cBlob = 0;
 868     pObject->rgBlob = NULL;
 869     *ppfnFreeObject = CRYPT_FreeBlob;
 870     *ppvFreeContext = NULL;
 871
 872     components.dwUrlPathLength = 1;
 873     ret = InternetCrackUrlW(pszURL, 0, ICU_DECODE, &components);
 874     if (ret)
 875     {
 876         LPWSTR path;
 877
 878         /* 3 == lstrlenW(L"c:") + 1 */
 879         path = CryptMemAlloc((components.dwUrlPathLength + 3) * sizeof(WCHAR));
 880         if (path)
 881         {
 882             HANDLE hFile;
 883
 884             /* Try to create the file directly - Wine handles / in pathnames */
 885             lstrcpynW(path, components.lpszUrlPath,
 886              components.dwUrlPathLength + 1);
 887             hFile = CreateFileW(path, GENERIC_READ, 0, NULL, OPEN_EXISTING,
 888              FILE_ATTRIBUTE_NORMAL, NULL);
 889             if (hFile == INVALID_HANDLE_VALUE)
 890             {
 891                 /* Try again on the current drive */
 892                 GetCurrentDirectoryW(components.dwUrlPathLength, path);
 893                 if (path[1] == ':')
 894                 {
 895                     lstrcpynW(path + 2, components.lpszUrlPath,
 896                      components.dwUrlPathLength + 1);
 897                     hFile = CreateFileW(path, GENERIC_READ, 0, NULL,
 898                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 899                 }
 900                 if (hFile == INVALID_HANDLE_VALUE)
 901                 {
 902                     /* Try again on the Windows drive */
 903                     GetWindowsDirectoryW(path, components.dwUrlPathLength);
 904                     if (path[1] == ':')
 905                     {
 906                         lstrcpynW(path + 2, components.lpszUrlPath,
 907                          components.dwUrlPathLength + 1);
 908                         hFile = CreateFileW(path, GENERIC_READ, 0, NULL,
 909                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 910                     }
 911                 }
 912             }
 913             if (hFile != INVALID_HANDLE_VALUE)
 914             {
 915                 if ((ret = CRYPT_GetObjectFromFile(hFile, pObject)))
 916                 {
 917                     if (pAuxInfo && pAuxInfo->cbSize >=
 918                      offsetof(CRYPT_RETRIEVE_AUX_INFO,
 919                      pLastSyncTime) + sizeof(PFILETIME) &&
 920                      pAuxInfo->pLastSyncTime)
 921                         GetFileTime(hFile, NULL, NULL,
 922                          pAuxInfo->pLastSyncTime);
 923                 }
 924                 CloseHandle(hFile);
 925             }
 926             else
 927                 ret = FALSE;
 928             CryptMemFree(path);
 929         }
 930     }
 931     return ret;
 932 }
 933
 934 typedef BOOL (WINAPI *SchemeDllRetrieveEncodedObjectW)(LPCWSTR pwszUrl,
 935  LPCSTR pszObjectOid, DWORD dwRetrievalFlags, DWORD dwTimeout,
 936  PCRYPT_BLOB_ARRAY pObject, PFN_FREE_ENCODED_OBJECT_FUNC *ppfnFreeObject,
 937  void **ppvFreeContext, HCRYPTASYNC hAsyncRetrieve,
 938  PCRYPT_CREDENTIALS pCredentials, PCRYPT_RETRIEVE_AUX_INFO pAuxInfo);
 939
 940 static BOOL CRYPT_GetRetrieveFunction(LPCWSTR pszURL,
 941  SchemeDllRetrieveEncodedObjectW *pFunc, HCRYPTOIDFUNCADDR *phFunc)
 942 {
 943     URL_COMPONENTSW components = { sizeof(components), 0 };
 944     BOOL ret;
 945
 946     TRACE("(%s, %p, %p)\n", debugstr_w(pszURL), pFunc, phFunc);
 947
 948     *pFunc = NULL;
 949     *phFunc = 0;
 950     components.dwSchemeLength = 1;
 951     ret = InternetCrackUrlW(pszURL, 0, ICU_DECODE, &components);
 952     if (ret)
 953     {
 954         /* Microsoft always uses CryptInitOIDFunctionSet/
 955          * CryptGetOIDFunctionAddress, but there doesn't seem to be a pressing
 956          * reason to do so for builtin schemes.
 957          */
 958         switch (components.nScheme)
 959         {
 960         case INTERNET_SCHEME_FTP:
 961             *pFunc = FTP_RetrieveEncodedObjectW;
 962             break;
 963         case INTERNET_SCHEME_HTTP:
 964             *pFunc = HTTP_RetrieveEncodedObjectW;
 965             break;
 966         case INTERNET_SCHEME_FILE:
 967             *pFunc = File_RetrieveEncodedObjectW;
 968             break;
 969         default:
 970         {
 971             int len = WideCharToMultiByte(CP_ACP, 0, components.lpszScheme,
 972              components.dwSchemeLength, NULL, 0, NULL, NULL);
 973
 974             if (len)
 975             {
 976                 LPSTR scheme = CryptMemAlloc(len);
 977
 978                 if (scheme)
 979                 {
 980                     static HCRYPTOIDFUNCSET set = NULL;
 981
 982                     if (!set)
 983                         set = CryptInitOIDFunctionSet(
 984                          SCHEME_OID_RETRIEVE_ENCODED_OBJECTW_FUNC, 0);
 985                     WideCharToMultiByte(CP_ACP, 0, components.lpszScheme,
 986                      components.dwSchemeLength, scheme, len, NULL, NULL);
 987                     ret = CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING,
 988                      scheme, 0, (void **)pFunc, phFunc);
 989                     CryptMemFree(scheme);
 990                 }
 991                 else
 992                 {
 993                     SetLastError(ERROR_OUTOFMEMORY);
 994                     ret = FALSE;
 995                 }
 996             }
 997             else
 998                 ret = FALSE;
 999         }
1000         }
1001     }
1002     TRACE("returning %d\n", ret);
1003     return ret;
1004 }
1005
1006 static BOOL WINAPI CRYPT_CreateBlob(LPCSTR pszObjectOid,
1007  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext)
1008 {
1009     DWORD size, i;
1010     CRYPT_BLOB_ARRAY *context;
1011     BOOL ret = FALSE;
1012
1013     size = sizeof(CRYPT_BLOB_ARRAY) + pObject->cBlob * sizeof(CRYPT_DATA_BLOB);
1014     for (i = 0; i < pObject->cBlob; i++)
1015         size += pObject->rgBlob[i].cbData;
1016     context = CryptMemAlloc(size);
1017     if (context)
1018     {
1019         LPBYTE nextData;
1020
1021         context->cBlob = 0;
1022         context->rgBlob =
1023          (CRYPT_DATA_BLOB *)((LPBYTE)context + sizeof(CRYPT_BLOB_ARRAY));
1024         nextData =
1025          (LPBYTE)context->rgBlob + pObject->cBlob * sizeof(CRYPT_DATA_BLOB);
1026         for (i = 0; i < pObject->cBlob; i++)
1027         {
1028             memcpy(nextData, pObject->rgBlob[i].pbData,
1029              pObject->rgBlob[i].cbData);
1030             context->rgBlob[i].pbData = nextData;
1031             context->rgBlob[i].cbData = pObject->rgBlob[i].cbData;
1032             nextData += pObject->rgBlob[i].cbData;
1033             context->cBlob++;
1034         }
1035         *ppvContext = context;
1036         ret = TRUE;
1037     }
1038     return ret;
1039 }
1040
1041 typedef BOOL (WINAPI *AddContextToStore)(HCERTSTORE hCertStore,
1042  const void *pContext, DWORD dwAddDisposition, const void **ppStoreContext);
1043
1044 static BOOL CRYPT_CreateContext(PCRYPT_BLOB_ARRAY pObject,
1045  DWORD dwExpectedContentTypeFlags, AddContextToStore addFunc, void **ppvContext)
1046 {
1047     BOOL ret = TRUE;
1048
1049     if (!pObject->cBlob)
1050     {
1051         SetLastError(ERROR_INVALID_DATA);
1052         *ppvContext = NULL;
1053         ret = FALSE;
1054     }
1055     else if (pObject->cBlob == 1)
1056     {
1057         if (!CryptQueryObject(CERT_QUERY_OBJECT_BLOB, &pObject->rgBlob[0],
1058          dwExpectedContentTypeFlags, CERT_QUERY_FORMAT_FLAG_BINARY, 0, NULL,
1059          NULL, NULL, NULL, NULL, (const void **)ppvContext))
1060         {
1061             SetLastError(CRYPT_E_NO_MATCH);
1062             ret = FALSE;
1063         }
1064     }
1065     else
1066     {
1067         HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
1068          CERT_STORE_CREATE_NEW_FLAG, NULL);
1069
1070         if (store)
1071         {
1072             DWORD i;
1073             const void *context;
1074
1075             for (i = 0; i < pObject->cBlob; i++)
1076             {
1077                 if (CryptQueryObject(CERT_QUERY_OBJECT_BLOB,
1078                  &pObject->rgBlob[i], dwExpectedContentTypeFlags,
1079                  CERT_QUERY_FORMAT_FLAG_BINARY, 0, NULL, NULL, NULL, NULL,
1080                  NULL, &context))
1081                 {
1082                     if (!addFunc(store, context, CERT_STORE_ADD_ALWAYS, NULL))
1083                         ret = FALSE;
1084                 }
1085                 else
1086                 {
1087                     SetLastError(CRYPT_E_NO_MATCH);
1088                     ret = FALSE;
1089                 }
1090             }
1091         }
1092         else
1093             ret = FALSE;
1094         *ppvContext = store;
1095     }
1096     return ret;
1097 }
1098
1099 static BOOL WINAPI CRYPT_CreateCert(LPCSTR pszObjectOid,
1100  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext)
1101 {
1102     return CRYPT_CreateContext(pObject, CERT_QUERY_CONTENT_FLAG_CERT,
1103      (AddContextToStore)CertAddCertificateContextToStore, ppvContext);
1104 }
1105
1106 static BOOL WINAPI CRYPT_CreateCRL(LPCSTR pszObjectOid,
1107  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext)
1108 {
1109     return CRYPT_CreateContext(pObject, CERT_QUERY_CONTENT_FLAG_CRL,
1110      (AddContextToStore)CertAddCRLContextToStore, ppvContext);
1111 }
1112
1113 static BOOL WINAPI CRYPT_CreateCTL(LPCSTR pszObjectOid,
1114  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext)
1115 {
1116     return CRYPT_CreateContext(pObject, CERT_QUERY_CONTENT_FLAG_CTL,
1117      (AddContextToStore)CertAddCTLContextToStore, ppvContext);
1118 }
1119
1120 static BOOL WINAPI CRYPT_CreatePKCS7(LPCSTR pszObjectOid,
1121  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext)
1122 {
1123     BOOL ret;
1124
1125     if (!pObject->cBlob)
1126     {
1127         SetLastError(ERROR_INVALID_DATA);
1128         *ppvContext = NULL;
1129         ret = FALSE;
1130     }
1131     else if (pObject->cBlob == 1)
1132         ret = CryptQueryObject(CERT_QUERY_OBJECT_BLOB, &pObject->rgBlob[0],
1133          CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
1134          CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED, CERT_QUERY_FORMAT_FLAG_BINARY,
1135          0, NULL, NULL, NULL, (HCERTSTORE *)ppvContext, NULL, NULL);
1136     else
1137     {
1138         FIXME("multiple messages unimplemented\n");
1139         ret = FALSE;
1140     }
1141     return ret;
1142 }
1143
1144 static BOOL WINAPI CRYPT_CreateAny(LPCSTR pszObjectOid,
1145  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext)
1146 {
1147     BOOL ret;
1148
1149     if (!pObject->cBlob)
1150     {
1151         SetLastError(ERROR_INVALID_DATA);
1152         *ppvContext = NULL;
1153         ret = FALSE;
1154     }
1155     else
1156     {
1157         HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0,
1158          CERT_STORE_CREATE_NEW_FLAG, NULL);
1159
1160         if (store)
1161         {
1162             HCERTSTORE memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
1163              CERT_STORE_CREATE_NEW_FLAG, NULL);
1164
1165             if (memStore)
1166             {
1167                 CertAddStoreToCollection(store, memStore,
1168                  CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
1169                 CertCloseStore(memStore, 0);
1170             }
1171             else
1172             {
1173                 CertCloseStore(store, 0);
1174                 store = NULL;
1175             }
1176         }
1177         if (store)
1178         {
1179             DWORD i;
1180
1181             ret = TRUE;
1182             for (i = 0; i < pObject->cBlob; i++)
1183             {
1184                 DWORD contentType, expectedContentTypes =
1185                  CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED |
1186                  CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED |
1187                  CERT_QUERY_CONTENT_FLAG_CERT |
1188                  CERT_QUERY_CONTENT_FLAG_CRL |
1189                  CERT_QUERY_CONTENT_FLAG_CTL;
1190                 HCERTSTORE contextStore;
1191                 const void *context;
1192
1193                 if (CryptQueryObject(CERT_QUERY_OBJECT_BLOB,
1194                  &pObject->rgBlob[i], expectedContentTypes,
1195                  CERT_QUERY_FORMAT_FLAG_BINARY, 0, NULL, &contentType, NULL,
1196                  &contextStore, NULL, &context))
1197                 {
1198                     switch (contentType)
1199                     {
1200                     case CERT_QUERY_CONTENT_CERT:
1201                         if (!CertAddCertificateContextToStore(store,
1202                          (PCCERT_CONTEXT)context, CERT_STORE_ADD_ALWAYS, NULL))
1203                             ret = FALSE;
1204                         break;
1205                     case CERT_QUERY_CONTENT_CRL:
1206                         if (!CertAddCRLContextToStore(store,
1207                          (PCCRL_CONTEXT)context, CERT_STORE_ADD_ALWAYS, NULL))
1208                              ret = FALSE;
1209                         break;
1210                     case CERT_QUERY_CONTENT_CTL:
1211                         if (!CertAddCTLContextToStore(store,
1212                          (PCCTL_CONTEXT)context, CERT_STORE_ADD_ALWAYS, NULL))
1213                              ret = FALSE;
1214                         break;
1215                     default:
1216                         CertAddStoreToCollection(store, contextStore, 0, 0);
1217                     }
1218                 }
1219                 else
1220                     ret = FALSE;
1221             }
1222         }
1223         else
1224             ret = FALSE;
1225         *ppvContext = store;
1226     }
1227     return ret;
1228 }
1229
1230 typedef BOOL (WINAPI *ContextDllCreateObjectContext)(LPCSTR pszObjectOid,
1231  DWORD dwRetrievalFlags, PCRYPT_BLOB_ARRAY pObject, void **ppvContext);
1232
1233 static BOOL CRYPT_GetCreateFunction(LPCSTR pszObjectOid,
1234  ContextDllCreateObjectContext *pFunc, HCRYPTOIDFUNCADDR *phFunc)
1235 {
1236     BOOL ret = TRUE;
1237
1238     TRACE("(%s, %p, %p)\n", debugstr_a(pszObjectOid), pFunc, phFunc);
1239
1240     *pFunc = NULL;
1241     *phFunc = 0;
1242     if (!HIWORD(pszObjectOid))
1243     {
1244         switch (LOWORD(pszObjectOid))
1245         {
1246         case 0:
1247             *pFunc = CRYPT_CreateBlob;
1248             break;
1249         case LOWORD(CONTEXT_OID_CERTIFICATE):
1250             *pFunc = CRYPT_CreateCert;
1251             break;
1252         case LOWORD(CONTEXT_OID_CRL):
1253             *pFunc = CRYPT_CreateCRL;
1254             break;
1255         case LOWORD(CONTEXT_OID_CTL):
1256             *pFunc = CRYPT_CreateCTL;
1257             break;
1258         case LOWORD(CONTEXT_OID_PKCS7):
1259             *pFunc = CRYPT_CreatePKCS7;
1260             break;
1261         case LOWORD(CONTEXT_OID_CAPI2_ANY):
1262             *pFunc = CRYPT_CreateAny;
1263             break;
1264         }
1265     }
1266     if (!*pFunc)
1267     {
1268         static HCRYPTOIDFUNCSET set = NULL;
1269
1270         if (!set)
1271             set = CryptInitOIDFunctionSet(
1272              CONTEXT_OID_CREATE_OBJECT_CONTEXT_FUNC, 0);
1273         ret = CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, pszObjectOid,
1274          0, (void **)pFunc, phFunc);
1275     }
1276     TRACE("returning %d\n", ret);
1277     return ret;
1278 }
1279
1280 /***********************************************************************
1281  *    CryptRetrieveObjectByUrlW (CRYPTNET.@)
1282  */
1283 BOOL WINAPI CryptRetrieveObjectByUrlW(LPCWSTR pszURL, LPCSTR pszObjectOid,
1284  DWORD dwRetrievalFlags, DWORD dwTimeout, LPVOID *ppvObject,
1285  HCRYPTASYNC hAsyncRetrieve, PCRYPT_CREDENTIALS pCredentials, LPVOID pvVerify,
1286  PCRYPT_RETRIEVE_AUX_INFO pAuxInfo)
1287 {
1288     BOOL ret;
1289     SchemeDllRetrieveEncodedObjectW retrieve;
1290     ContextDllCreateObjectContext create;
1291     HCRYPTOIDFUNCADDR hRetrieve = 0, hCreate = 0;
1292
1293     TRACE("(%s, %s, %08x, %d, %p, %p, %p, %p, %p)\n", debugstr_w(pszURL),
1294      debugstr_a(pszObjectOid), dwRetrievalFlags, dwTimeout, ppvObject,
1295      hAsyncRetrieve, pCredentials, pvVerify, pAuxInfo);
1296
1297     if (!pszURL)
1298     {
1299         SetLastError(ERROR_INVALID_PARAMETER);
1300         return FALSE;
1301     }
1302     ret = CRYPT_GetRetrieveFunction(pszURL, &retrieve, &hRetrieve);
1303     if (ret)
1304         ret = CRYPT_GetCreateFunction(pszObjectOid, &create, &hCreate);
1305     if (ret)
1306     {
1307         CRYPT_BLOB_ARRAY object = { 0, NULL };
1308         PFN_FREE_ENCODED_OBJECT_FUNC freeObject;
1309         void *freeContext;
1310
1311         ret = retrieve(pszURL, pszObjectOid, dwRetrievalFlags, dwTimeout,
1312          &object, &freeObject, &freeContext, hAsyncRetrieve, pCredentials,
1313          pAuxInfo);
1314         if (ret)
1315         {
1316             ret = create(pszObjectOid, dwRetrievalFlags, &object, ppvObject);
1317             freeObject(pszObjectOid, &object, freeContext);
1318         }
1319     }
1320     if (hCreate)
1321         CryptFreeOIDFunctionAddress(hCreate, 0);
1322     if (hRetrieve)
1323         CryptFreeOIDFunctionAddress(hRetrieve, 0);
1324     TRACE("returning %d\n", ret);
1325     return ret;
1326 }
1327
1328 typedef struct _OLD_CERT_REVOCATION_STATUS {
1329     DWORD cbSize;
1330     DWORD dwIndex;
1331     DWORD dwError;
1332     DWORD dwReason;
1333 } OLD_CERT_REVOCATION_STATUS, *POLD_CERT_REVOCATION_STATUS;
1334
1335 /***********************************************************************
1336  *    CertDllVerifyRevocation (CRYPTNET.@)
1337  */
1338 BOOL WINAPI CertDllVerifyRevocation(DWORD dwEncodingType, DWORD dwRevType,
1339  DWORD cContext, PVOID rgpvContext[], DWORD dwFlags,
1340  PCERT_REVOCATION_PARA pRevPara, PCERT_REVOCATION_STATUS pRevStatus)
1341 {
1342     DWORD error = 0, i;
1343     BOOL ret;
1344
1345     TRACE("(%08x, %d, %d, %p, %08x, %p, %p)\n", dwEncodingType, dwRevType,
1346      cContext, rgpvContext, dwFlags, pRevPara, pRevStatus);
1347
1348     if (pRevStatus->cbSize != sizeof(OLD_CERT_REVOCATION_STATUS) &&
1349      pRevStatus->cbSize != sizeof(CERT_REVOCATION_STATUS))
1350     {
1351         SetLastError(E_INVALIDARG);
1352         return FALSE;
1353     }
1354     memset(&pRevStatus->dwIndex, 0, pRevStatus->cbSize - sizeof(DWORD));
1355     if (dwRevType != CERT_CONTEXT_REVOCATION_TYPE)
1356     {
1357         error = CRYPT_E_NO_REVOCATION_CHECK;
1358         ret = FALSE;
1359     }
1360     else
1361     {
1362         ret = TRUE;
1363         for (i = 0; ret && i < cContext; i++)
1364         {
1365             DWORD cbUrlArray;
1366
1367             ret = CryptGetObjectUrl(URL_OID_CERTIFICATE_CRL_DIST_POINT,
1368              rgpvContext[i], 0, NULL, &cbUrlArray, NULL, NULL, NULL);
1369             if (!ret && GetLastError() == CRYPT_E_NOT_FOUND)
1370             {
1371                 error = CRYPT_E_NO_REVOCATION_CHECK;
1372                 pRevStatus->dwIndex = i;
1373             }
1374             else if (ret)
1375             {
1376                 CRYPT_URL_ARRAY *urlArray = CryptMemAlloc(cbUrlArray);
1377
1378                 if (urlArray)
1379                 {
1380                     DWORD j, retrievalFlags = 0, startTime, endTime, timeout;
1381
1382                     ret = CryptGetObjectUrl(URL_OID_CERTIFICATE_CRL_DIST_POINT,
1383                      rgpvContext[i], 0, urlArray, &cbUrlArray, NULL, NULL,
1384                      NULL);
1385                     if (dwFlags & CERT_VERIFY_CACHE_ONLY_BASED_REVOCATION)
1386                         retrievalFlags |= CRYPT_CACHE_ONLY_RETRIEVAL;
1387                     if (dwFlags & CERT_VERIFY_REV_ACCUMULATIVE_TIMEOUT_FLAG &&
1388                      pRevPara->cbSize >= offsetof(CERT_REVOCATION_PARA,
1389                      dwUrlRetrievalTimeout) + sizeof(DWORD))
1390                     {
1391                         startTime = GetTickCount();
1392                         endTime = startTime + pRevPara->dwUrlRetrievalTimeout;
1393                         timeout = pRevPara->dwUrlRetrievalTimeout;
1394                     }
1395                     else
1396                         endTime = timeout = 0;
1397                     for (j = 0; ret && j < urlArray->cUrl; j++)
1398                     {
1399                         PCCRL_CONTEXT crl;
1400
1401                         ret = CryptRetrieveObjectByUrlW(urlArray->rgwszUrl[j],
1402                          CONTEXT_OID_CRL, retrievalFlags, timeout,
1403                          (void **)&crl, NULL, NULL, NULL, NULL);
1404                         if (ret)
1405                         {
1406                             PCRL_ENTRY entry = NULL;
1407
1408                             CertFindCertificateInCRL(
1409                              (PCCERT_CONTEXT)rgpvContext[i], crl, 0, NULL,
1410                              &entry);
1411                             if (entry)
1412                             {
1413                                 error = CRYPT_E_REVOKED;
1414                                 pRevStatus->dwIndex = i;
1415                                 ret = FALSE;
1416                             }
1417                             else if (timeout)
1418                             {
1419                                 DWORD time = GetTickCount();
1420
1421                                 if ((int)(endTime - time) <= 0)
1422                                 {
1423                                     error = ERROR_TIMEOUT;
1424                                     pRevStatus->dwIndex = i;
1425                                     ret = FALSE;
1426                                 }
1427                                 else
1428                                     timeout = endTime - time;
1429                             }
1430                             CertFreeCRLContext(crl);
1431                         }
1432                         else
1433                             error = CRYPT_E_REVOCATION_OFFLINE;
1434                     }
1435                     CryptMemFree(urlArray);
1436                 }
1437                 else
1438                 {
1439                     error = ERROR_OUTOFMEMORY;
1440                     pRevStatus->dwIndex = i;
1441                     ret = FALSE;
1442                 }
1443             }
1444             else
1445                 pRevStatus->dwIndex = i;
1446         }
1447     }
1448
1449     if (!ret)
1450     {
1451         SetLastError(error);
1452         pRevStatus->dwError = error;
1453     }
1454     TRACE("returning %d (%08x)\n", ret, error);
1455     return ret;
1456 }