git.oblomov.eu Git - wine/blob - dlls/wintrust/wintrust_main.c

   1 /*
   2  * Copyright 2001 Rein Klazes
   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 #include "config.h"
  21
  22 #include <stdarg.h>
  23
  24 #define NONAMELESSUNION
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "winreg.h"
  30 #include "guiddef.h"
  31 #include "wintrust.h"
  32 #include "softpub.h"
  33 #include "mscat.h"
  34 #include "objbase.h"
  35 #include "winuser.h"
  36 #include "cryptdlg.h"
  37 #include "cryptuiapi.h"
  38 #include "wintrust_priv.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(wintrust);
  42
  43
  44 /* Utility functions */
  45 void * WINAPI WINTRUST_Alloc(DWORD cb)
  46 {
  47     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cb);
  48 }
  49
  50 static void* WINTRUST_ReAlloc(void *ptr, DWORD cb) __WINE_ALLOC_SIZE(2);
  51 static void* WINTRUST_ReAlloc(void *ptr, DWORD cb)
  52 {
  53     return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptr, cb);
  54 }
  55
  56 void WINAPI WINTRUST_Free(void *p)
  57 {
  58     HeapFree(GetProcessHeap(), 0, p);
  59 }
  60
  61 /***********************************************************************
  62  *              DllMain  (WINTRUST.@)
  63  */
  64 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
  65 {
  66     switch(reason)
  67     {
  68     case DLL_PROCESS_ATTACH:
  69         DisableThreadLibraryCalls( inst );
  70         break;
  71     }
  72     return TRUE;
  73 }
  74
  75 /***********************************************************************
  76  *              TrustIsCertificateSelfSigned (WINTRUST.@)
  77  */
  78 BOOL WINAPI TrustIsCertificateSelfSigned( PCCERT_CONTEXT cert )
  79 {
  80     PCERT_EXTENSION ext;
  81     DWORD size;
  82     BOOL ret;
  83
  84     TRACE("%p\n", cert);
  85     if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
  86      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
  87     {
  88         CERT_AUTHORITY_KEY_ID2_INFO *info;
  89
  90         ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
  91          X509_AUTHORITY_KEY_ID2, ext->Value.pbData, ext->Value.cbData,
  92          CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
  93          &info, &size);
  94         if (ret)
  95         {
  96             if (info->AuthorityCertIssuer.cAltEntry &&
  97              info->AuthorityCertSerialNumber.cbData)
  98             {
  99                 PCERT_ALT_NAME_ENTRY directoryName = NULL;
 100                 DWORD i;
 101
 102                 for (i = 0; !directoryName &&
 103                  i < info->AuthorityCertIssuer.cAltEntry; i++)
 104                     if (info->AuthorityCertIssuer.rgAltEntry[i].dwAltNameChoice
 105                      == CERT_ALT_NAME_DIRECTORY_NAME)
 106                         directoryName =
 107                          &info->AuthorityCertIssuer.rgAltEntry[i];
 108                 if (directoryName)
 109                 {
 110                     ret = CertCompareCertificateName(cert->dwCertEncodingType,
 111                      &directoryName->u.DirectoryName, &cert->pCertInfo->Issuer)
 112                      && CertCompareIntegerBlob(&info->AuthorityCertSerialNumber,
 113                      &cert->pCertInfo->SerialNumber);
 114                 }
 115                 else
 116                 {
 117                     FIXME("no supported name type in authority key id2\n");
 118                     ret = FALSE;
 119                 }
 120             }
 121             else if (info->KeyId.cbData)
 122             {
 123                 ret = CertGetCertificateContextProperty(cert,
 124                  CERT_KEY_IDENTIFIER_PROP_ID, NULL, &size);
 125                 if (ret && size == info->KeyId.cbData)
 126                 {
 127                     LPBYTE buf = CryptMemAlloc(size);
 128
 129                     if (buf)
 130                     {
 131                         CertGetCertificateContextProperty(cert,
 132                          CERT_KEY_IDENTIFIER_PROP_ID, buf, &size);
 133                         ret = !memcmp(buf, info->KeyId.pbData, size);
 134                         CryptMemFree(buf);
 135                     }
 136                     else
 137                         ret = FALSE;
 138                 }
 139                 else
 140                     ret = FALSE;
 141             }
 142             LocalFree(info);
 143         }
 144     }
 145     else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
 146      cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
 147     {
 148         CERT_AUTHORITY_KEY_ID_INFO *info;
 149
 150         ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
 151          X509_AUTHORITY_KEY_ID, ext->Value.pbData, ext->Value.cbData,
 152          CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
 153          &info, &size);
 154         if (ret)
 155         {
 156             if (info->CertIssuer.cbData && info->CertSerialNumber.cbData)
 157             {
 158                 ret = CertCompareCertificateName(cert->dwCertEncodingType,
 159                  &info->CertIssuer, &cert->pCertInfo->Issuer) &&
 160                  CertCompareIntegerBlob(&info->CertSerialNumber,
 161                  &cert->pCertInfo->SerialNumber);
 162             }
 163             else if (info->KeyId.cbData)
 164             {
 165                 ret = CertGetCertificateContextProperty(cert,
 166                  CERT_KEY_IDENTIFIER_PROP_ID, NULL, &size);
 167                 if (ret && size == info->KeyId.cbData)
 168                 {
 169                     LPBYTE buf = CryptMemAlloc(size);
 170
 171                     if (buf)
 172                     {
 173                         CertGetCertificateContextProperty(cert,
 174                          CERT_KEY_IDENTIFIER_PROP_ID, buf, &size);
 175                         ret = !memcmp(buf, info->KeyId.pbData, size);
 176                         CryptMemFree(buf);
 177                     }
 178                     else
 179                         ret = FALSE;
 180                 }
 181                 else
 182                     ret = FALSE;
 183             }
 184             else
 185                 ret = FALSE;
 186             LocalFree(info);
 187         }
 188     }
 189     else
 190         ret = CertCompareCertificateName(cert->dwCertEncodingType,
 191          &cert->pCertInfo->Subject, &cert->pCertInfo->Issuer);
 192     return ret;
 193 }
 194
 195 typedef HRESULT (WINAPI *wintrust_step_func)(CRYPT_PROVIDER_DATA *data);
 196
 197 struct wintrust_step
 198 {
 199     wintrust_step_func func;
 200     DWORD              error_index;
 201 };
 202
 203 static DWORD WINTRUST_ExecuteSteps(const struct wintrust_step *steps,
 204  DWORD numSteps, CRYPT_PROVIDER_DATA *provData)
 205 {
 206     DWORD i, err = ERROR_SUCCESS;
 207
 208     for (i = 0; !err && i < numSteps; i++)
 209     {
 210         err = steps[i].func(provData);
 211         if (err)
 212             err = provData->padwTrustStepErrors[steps[i].error_index];
 213     }
 214     return err;
 215 }
 216
 217 static CRYPT_PROVIDER_DATA *WINTRUST_AllocateProviderData(void)
 218 {
 219     CRYPT_PROVIDER_DATA *provData;
 220
 221     provData = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_DATA));
 222     if (!provData)
 223         goto oom;
 224     provData->cbStruct = sizeof(CRYPT_PROVIDER_DATA);
 225
 226     provData->padwTrustStepErrors =
 227      WINTRUST_Alloc(TRUSTERROR_MAX_STEPS * sizeof(DWORD));
 228     if (!provData->padwTrustStepErrors)
 229         goto oom;
 230     provData->cdwTrustStepErrors = TRUSTERROR_MAX_STEPS;
 231
 232     provData->u.pPDSip = WINTRUST_Alloc(sizeof(PROVDATA_SIP));
 233     if (!provData->u.pPDSip)
 234         goto oom;
 235     provData->u.pPDSip->cbStruct = sizeof(PROVDATA_SIP);
 236
 237     provData->psPfns = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_FUNCTIONS));
 238     if (!provData->psPfns)
 239         goto oom;
 240     provData->psPfns->cbStruct = sizeof(CRYPT_PROVIDER_FUNCTIONS);
 241     return provData;
 242
 243 oom:
 244     if (provData)
 245     {
 246         WINTRUST_Free(provData->padwTrustStepErrors);
 247         WINTRUST_Free(provData->u.pPDSip);
 248         WINTRUST_Free(provData->psPfns);
 249         WINTRUST_Free(provData);
 250     }
 251     return NULL;
 252 }
 253
 254 /* Adds trust steps for each function in psPfns.  Assumes steps has at least
 255  * 5 entries.  Returns the number of steps added.
 256  */
 257 static DWORD WINTRUST_AddTrustStepsFromFunctions(struct wintrust_step *steps,
 258  const CRYPT_PROVIDER_FUNCTIONS *psPfns)
 259 {
 260     DWORD numSteps = 0;
 261
 262     if (psPfns->pfnInitialize)
 263     {
 264         steps[numSteps].func = psPfns->pfnInitialize;
 265         steps[numSteps++].error_index = TRUSTERROR_STEP_FINAL_WVTINIT;
 266     }
 267     if (psPfns->pfnObjectTrust)
 268     {
 269         steps[numSteps].func = psPfns->pfnObjectTrust;
 270         steps[numSteps++].error_index = TRUSTERROR_STEP_FINAL_OBJPROV;
 271     }
 272     if (psPfns->pfnSignatureTrust)
 273     {
 274         steps[numSteps].func = psPfns->pfnSignatureTrust;
 275         steps[numSteps++].error_index = TRUSTERROR_STEP_FINAL_SIGPROV;
 276     }
 277     if (psPfns->pfnCertificateTrust)
 278     {
 279         steps[numSteps].func = psPfns->pfnCertificateTrust;
 280         steps[numSteps++].error_index = TRUSTERROR_STEP_FINAL_CERTPROV;
 281     }
 282     if (psPfns->pfnFinalPolicy)
 283     {
 284         steps[numSteps].func = psPfns->pfnFinalPolicy;
 285         steps[numSteps++].error_index = TRUSTERROR_STEP_FINAL_POLICYPROV;
 286     }
 287     return numSteps;
 288 }
 289
 290 static LONG WINTRUST_DefaultVerify(HWND hwnd, GUID *actionID,
 291  WINTRUST_DATA *data)
 292 {
 293     DWORD err = ERROR_SUCCESS, numSteps = 0;
 294     CRYPT_PROVIDER_DATA *provData;
 295     BOOL ret;
 296     struct wintrust_step verifySteps[5];
 297
 298     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
 299
 300     provData = WINTRUST_AllocateProviderData();
 301     if (!provData)
 302         return ERROR_OUTOFMEMORY;
 303
 304     ret = WintrustLoadFunctionPointers(actionID, provData->psPfns);
 305     if (!ret)
 306     {
 307         err = GetLastError();
 308         goto error;
 309     }
 310
 311     data->hWVTStateData = provData;
 312     provData->pWintrustData = data;
 313     if (hwnd == INVALID_HANDLE_VALUE)
 314         provData->hWndParent = GetDesktopWindow();
 315     else
 316         provData->hWndParent = hwnd;
 317     provData->pgActionID = actionID;
 318     WintrustGetRegPolicyFlags(&provData->dwRegPolicySettings);
 319
 320     numSteps = WINTRUST_AddTrustStepsFromFunctions(verifySteps,
 321      provData->psPfns);
 322     err = WINTRUST_ExecuteSteps(verifySteps, numSteps, provData);
 323     goto done;
 324
 325 error:
 326     if (provData)
 327     {
 328         WINTRUST_Free(provData->padwTrustStepErrors);
 329         WINTRUST_Free(provData->u.pPDSip);
 330         WINTRUST_Free(provData->psPfns);
 331         WINTRUST_Free(provData);
 332     }
 333 done:
 334     TRACE("returning %08x\n", err);
 335     return err;
 336 }
 337
 338 static LONG WINTRUST_DefaultClose(HWND hwnd, GUID *actionID,
 339  WINTRUST_DATA *data)
 340 {
 341     DWORD err = ERROR_SUCCESS;
 342     CRYPT_PROVIDER_DATA *provData = data->hWVTStateData;
 343
 344     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
 345
 346     if (provData)
 347     {
 348         if (provData->psPfns->pfnCleanupPolicy)
 349             err = provData->psPfns->pfnCleanupPolicy(provData);
 350
 351         WINTRUST_Free(provData->padwTrustStepErrors);
 352         WINTRUST_Free(provData->u.pPDSip);
 353         WINTRUST_Free(provData->psPfns);
 354         WINTRUST_Free(provData);
 355         data->hWVTStateData = NULL;
 356     }
 357     TRACE("returning %08x\n", err);
 358     return err;
 359 }
 360
 361 static LONG WINTRUST_DefaultVerifyAndClose(HWND hwnd, GUID *actionID,
 362  WINTRUST_DATA *data)
 363 {
 364     LONG err;
 365
 366     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
 367
 368     err = WINTRUST_DefaultVerify(hwnd, actionID, data);
 369     WINTRUST_DefaultClose(hwnd, actionID, data);
 370     TRACE("returning %08x\n", err);
 371     return err;
 372 }
 373
 374 static LONG WINTRUST_PublishedSoftware(HWND hwnd, GUID *actionID,
 375  WINTRUST_DATA *data)
 376 {
 377     WINTRUST_DATA wintrust_data = { sizeof(wintrust_data), 0 };
 378     /* Undocumented: the published software action is passed a path,
 379      * and pSIPClientData points to a WIN_TRUST_SUBJECT_FILE.
 380      */
 381     LPWIN_TRUST_SUBJECT_FILE subjectFile = data->pSIPClientData;
 382     WINTRUST_FILE_INFO fileInfo = { sizeof(fileInfo), 0 };
 383
 384     TRACE("subjectFile->hFile: %p\n", subjectFile->hFile);
 385     TRACE("subjectFile->lpPath: %s\n", debugstr_w(subjectFile->lpPath));
 386     fileInfo.pcwszFilePath = subjectFile->lpPath;
 387     fileInfo.hFile = subjectFile->hFile;
 388     wintrust_data.u.pFile = &fileInfo;
 389     wintrust_data.dwUnionChoice = WTD_CHOICE_FILE;
 390     wintrust_data.dwUIChoice = WTD_UI_NONE;
 391
 392     return WINTRUST_DefaultVerifyAndClose(hwnd, actionID, &wintrust_data);
 393 }
 394
 395 /* Sadly, the function to load the cert for the CERT_CERTIFICATE_ACTION_VERIFY
 396  * action is not stored in the registry and is located in wintrust, not in
 397  * cryptdlg along with the rest of the implementation (verified by running the
 398  * action with a native wintrust.dll.)
 399  */
 400 static HRESULT WINAPI WINTRUST_CertVerifyObjTrust(CRYPT_PROVIDER_DATA *data)
 401 {
 402     BOOL ret;
 403
 404     TRACE("(%p)\n", data);
 405
 406     if (!data->padwTrustStepErrors)
 407         return S_FALSE;
 408
 409     switch (data->pWintrustData->dwUnionChoice)
 410     {
 411     case WTD_CHOICE_BLOB:
 412         if (data->pWintrustData->u.pBlob &&
 413          WVT_IS_CBSTRUCT_GT_MEMBEROFFSET(WINTRUST_BLOB_INFO,
 414          data->pWintrustData->u.pBlob->cbStruct, pbMemObject) &&
 415          data->pWintrustData->u.pBlob->cbMemObject ==
 416          sizeof(CERT_VERIFY_CERTIFICATE_TRUST) &&
 417          data->pWintrustData->u.pBlob->pbMemObject)
 418         {
 419             CERT_VERIFY_CERTIFICATE_TRUST *pCert =
 420              (CERT_VERIFY_CERTIFICATE_TRUST *)
 421              data->pWintrustData->u.pBlob->pbMemObject;
 422
 423             if (pCert->cbSize == sizeof(CERT_VERIFY_CERTIFICATE_TRUST) &&
 424              pCert->pccert)
 425             {
 426                 CRYPT_PROVIDER_SGNR signer = { sizeof(signer), { 0 } };
 427                 DWORD i;
 428                 SYSTEMTIME sysTime;
 429
 430                 /* Add a signer with nothing but the time to verify, so we can
 431                  * add a cert to it
 432                  */
 433                 GetSystemTime(&sysTime);
 434                 SystemTimeToFileTime(&sysTime, &signer.sftVerifyAsOf);
 435                 ret = data->psPfns->pfnAddSgnr2Chain(data, FALSE, 0, &signer);
 436                 if (!ret)
 437                     goto error;
 438                 ret = data->psPfns->pfnAddCert2Chain(data, 0, FALSE, 0,
 439                  pCert->pccert);
 440                 if (!ret)
 441                     goto error;
 442                 for (i = 0; ret && i < pCert->cRootStores; i++)
 443                     ret = data->psPfns->pfnAddStore2Chain(data,
 444                      pCert->rghstoreRoots[i]);
 445                 for (i = 0; ret && i < pCert->cStores; i++)
 446                     ret = data->psPfns->pfnAddStore2Chain(data,
 447                      pCert->rghstoreCAs[i]);
 448                 for (i = 0; ret && i < pCert->cTrustStores; i++)
 449                     ret = data->psPfns->pfnAddStore2Chain(data,
 450                      pCert->rghstoreTrust[i]);
 451             }
 452             else
 453             {
 454                 SetLastError(ERROR_INVALID_PARAMETER);
 455                 ret = FALSE;
 456             }
 457         }
 458         else
 459         {
 460             SetLastError(ERROR_INVALID_PARAMETER);
 461             ret = FALSE;
 462         }
 463         break;
 464     default:
 465         FIXME("unimplemented for %d\n", data->pWintrustData->dwUnionChoice);
 466         SetLastError(ERROR_INVALID_PARAMETER);
 467         ret = FALSE;
 468     }
 469
 470 error:
 471     if (!ret)
 472         data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV] =
 473          GetLastError();
 474     TRACE("returning %d (%08x)\n", ret ? S_OK : S_FALSE,
 475      data->padwTrustStepErrors[TRUSTERROR_STEP_FINAL_OBJPROV]);
 476     return ret ? S_OK : S_FALSE;
 477 }
 478
 479 static LONG WINTRUST_CertVerify(HWND hwnd, GUID *actionID,
 480  WINTRUST_DATA *data)
 481 {
 482     DWORD err = ERROR_SUCCESS, numSteps = 0;
 483     CRYPT_PROVIDER_DATA *provData;
 484     BOOL ret;
 485     struct wintrust_step verifySteps[5];
 486
 487     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
 488
 489     provData = WINTRUST_AllocateProviderData();
 490     if (!provData)
 491         return ERROR_OUTOFMEMORY;
 492
 493     ret = WintrustLoadFunctionPointers(actionID, provData->psPfns);
 494     if (!ret)
 495     {
 496         err = GetLastError();
 497         goto error;
 498     }
 499     if (!provData->psPfns->pfnObjectTrust)
 500         provData->psPfns->pfnObjectTrust = WINTRUST_CertVerifyObjTrust;
 501     /* Not sure why, but native skips the policy check */
 502     provData->psPfns->pfnCertCheckPolicy = NULL;
 503
 504     data->hWVTStateData = provData;
 505     provData->pWintrustData = data;
 506     if (hwnd == INVALID_HANDLE_VALUE)
 507         provData->hWndParent = GetDesktopWindow();
 508     else
 509         provData->hWndParent = hwnd;
 510     provData->pgActionID = actionID;
 511     WintrustGetRegPolicyFlags(&provData->dwRegPolicySettings);
 512
 513     numSteps = WINTRUST_AddTrustStepsFromFunctions(verifySteps,
 514      provData->psPfns);
 515     err = WINTRUST_ExecuteSteps(verifySteps, numSteps, provData);
 516     goto done;
 517
 518 error:
 519     if (provData)
 520     {
 521         WINTRUST_Free(provData->padwTrustStepErrors);
 522         WINTRUST_Free(provData->u.pPDSip);
 523         WINTRUST_Free(provData->psPfns);
 524         WINTRUST_Free(provData);
 525     }
 526 done:
 527     TRACE("returning %08x\n", err);
 528     return err;
 529 }
 530
 531 static LONG WINTRUST_CertVerifyAndClose(HWND hwnd, GUID *actionID,
 532  WINTRUST_DATA *data)
 533 {
 534     LONG err;
 535
 536     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(actionID), data);
 537
 538     err = WINTRUST_CertVerify(hwnd, actionID, data);
 539     WINTRUST_DefaultClose(hwnd, actionID, data);
 540     TRACE("returning %08x\n", err);
 541     return err;
 542 }
 543
 544 static LONG WINTRUST_CertActionVerify(HWND hwnd, GUID *actionID,
 545  WINTRUST_DATA *data)
 546 {
 547     DWORD stateAction;
 548     LONG err = ERROR_SUCCESS;
 549
 550     if (WVT_ISINSTRUCT(WINTRUST_DATA, data->cbStruct, dwStateAction))
 551         stateAction = data->dwStateAction;
 552     else
 553     {
 554         TRACE("no dwStateAction, assuming WTD_STATEACTION_IGNORE\n");
 555         stateAction = WTD_STATEACTION_IGNORE;
 556     }
 557     switch (stateAction)
 558     {
 559     case WTD_STATEACTION_IGNORE:
 560         err = WINTRUST_CertVerifyAndClose(hwnd, actionID, data);
 561         break;
 562     case WTD_STATEACTION_VERIFY:
 563         err = WINTRUST_CertVerify(hwnd, actionID, data);
 564         break;
 565     case WTD_STATEACTION_CLOSE:
 566         err = WINTRUST_DefaultClose(hwnd, actionID, data);
 567         break;
 568     default:
 569         FIXME("unimplemented for %d\n", data->dwStateAction);
 570     }
 571     return err;
 572 }
 573
 574 static void dump_file_info(WINTRUST_FILE_INFO *pFile)
 575 {
 576     TRACE("%p\n", pFile);
 577     if (pFile)
 578     {
 579         TRACE("cbStruct: %d\n", pFile->cbStruct);
 580         TRACE("pcwszFilePath: %s\n", debugstr_w(pFile->pcwszFilePath));
 581         TRACE("hFile: %p\n", pFile->hFile);
 582         TRACE("pgKnownSubject: %s\n", debugstr_guid(pFile->pgKnownSubject));
 583     }
 584 }
 585
 586 static void dump_catalog_info(WINTRUST_CATALOG_INFO *catalog)
 587 {
 588     TRACE("%p\n", catalog);
 589     if (catalog)
 590     {
 591         TRACE("cbStruct: %d\n", catalog->cbStruct);
 592         TRACE("dwCatalogVersion: %d\n", catalog->dwCatalogVersion);
 593         TRACE("pcwszCatalogFilePath: %s\n",
 594          debugstr_w(catalog->pcwszCatalogFilePath));
 595         TRACE("pcwszMemberTag: %s\n", debugstr_w(catalog->pcwszMemberTag));
 596         TRACE("pcwszMemberFilePath: %s\n",
 597          debugstr_w(catalog->pcwszMemberFilePath));
 598         TRACE("hMemberFile: %p\n", catalog->hMemberFile);
 599         TRACE("pbCalculatedFileHash: %p\n", catalog->pbCalculatedFileHash);
 600         TRACE("cbCalculatedFileHash: %d\n", catalog->cbCalculatedFileHash);
 601         TRACE("pcCatalogContext: %p\n", catalog->pcCatalogContext);
 602     }
 603 }
 604
 605 static void dump_blob_info(WINTRUST_BLOB_INFO *blob)
 606 {
 607     TRACE("%p\n", blob);
 608     if (blob)
 609     {
 610         TRACE("cbStruct: %d\n", blob->cbStruct);
 611         TRACE("gSubject: %s\n", debugstr_guid(&blob->gSubject));
 612         TRACE("pcwszDisplayName: %s\n", debugstr_w(blob->pcwszDisplayName));
 613         TRACE("cbMemObject: %d\n", blob->cbMemObject);
 614         TRACE("pbMemObject: %p\n", blob->pbMemObject);
 615         TRACE("cbMemSignedMsg: %d\n", blob->cbMemSignedMsg);
 616         TRACE("pbMemSignedMsg: %p\n", blob->pbMemSignedMsg);
 617     }
 618 }
 619
 620 static void dump_sgnr_info(WINTRUST_SGNR_INFO *sgnr)
 621 {
 622     TRACE("%p\n", sgnr);
 623     if (sgnr)
 624     {
 625         TRACE("cbStruct: %d\n", sgnr->cbStruct);
 626         TRACE("pcwszDisplayName: %s\n", debugstr_w(sgnr->pcwszDisplayName));
 627         TRACE("psSignerInfo: %p\n", sgnr->psSignerInfo);
 628         TRACE("chStores: %d\n", sgnr->chStores);
 629     }
 630 }
 631
 632 static void dump_cert_info(WINTRUST_CERT_INFO *cert)
 633 {
 634     TRACE("%p\n", cert);
 635     if (cert)
 636     {
 637         TRACE("cbStruct: %d\n", cert->cbStruct);
 638         TRACE("pcwszDisplayName: %s\n", debugstr_w(cert->pcwszDisplayName));
 639         TRACE("psCertContext: %p\n", cert->psCertContext);
 640         TRACE("chStores: %d\n", cert->chStores);
 641         TRACE("dwFlags: %08x\n", cert->dwFlags);
 642         TRACE("psftVerifyAsOf: %p\n", cert->psftVerifyAsOf);
 643     }
 644 }
 645
 646 static void dump_wintrust_data(WINTRUST_DATA *data)
 647 {
 648     TRACE("%p\n", data);
 649     if (data)
 650     {
 651         TRACE("cbStruct: %d\n", data->cbStruct);
 652         TRACE("pPolicyCallbackData: %p\n", data->pPolicyCallbackData);
 653         TRACE("pSIPClientData: %p\n", data->pSIPClientData);
 654         TRACE("dwUIChoice: %d\n", data->dwUIChoice);
 655         TRACE("fdwRevocationChecks: %08x\n", data->fdwRevocationChecks);
 656         TRACE("dwUnionChoice: %d\n", data->dwUnionChoice);
 657         switch (data->dwUnionChoice)
 658         {
 659         case WTD_CHOICE_FILE:
 660             dump_file_info(data->u.pFile);
 661             break;
 662         case WTD_CHOICE_CATALOG:
 663             dump_catalog_info(data->u.pCatalog);
 664             break;
 665         case WTD_CHOICE_BLOB:
 666             dump_blob_info(data->u.pBlob);
 667             break;
 668         case WTD_CHOICE_SIGNER:
 669             dump_sgnr_info(data->u.pSgnr);
 670             break;
 671         case WTD_CHOICE_CERT:
 672             dump_cert_info(data->u.pCert);
 673             break;
 674         }
 675         TRACE("dwStateAction: %d\n", data->dwStateAction);
 676         TRACE("hWVTStateData: %p\n", data->hWVTStateData);
 677         TRACE("pwszURLReference: %s\n", debugstr_w(data->pwszURLReference));
 678         TRACE("dwProvFlags: %08x\n", data->dwProvFlags);
 679         TRACE("dwUIContext: %d\n", data->dwUIContext);
 680     }
 681 }
 682
 683 /***********************************************************************
 684  *              WinVerifyTrust (WINTRUST.@)
 685  *
 686  * Verifies an object by calling the specified trust provider.
 687  *
 688  * PARAMS
 689  *   hwnd       [I] Handle to a caller window.
 690  *   ActionID   [I] Pointer to a GUID that identifies the action to perform.
 691  *   ActionData [I] Information used by the trust provider to verify the object.
 692  *
 693  * RETURNS
 694  *   Success: Zero.
 695  *   Failure: A TRUST_E_* error code.
 696  *
 697  * NOTES
 698  *   Trust providers can be found at:
 699  *   HKLM\SOFTWARE\Microsoft\Cryptography\Providers\Trust\
 700  */
 701 LONG WINAPI WinVerifyTrust( HWND hwnd, GUID *ActionID, LPVOID ActionData )
 702 {
 703     static const GUID unknown = { 0xC689AAB8, 0x8E78, 0x11D0, { 0x8C,0x47,
 704      0x00,0xC0,0x4F,0xC2,0x95,0xEE } };
 705     static const GUID published_software = WIN_SPUB_ACTION_PUBLISHED_SOFTWARE;
 706     static const GUID generic_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
 707     static const GUID generic_cert_verify = WINTRUST_ACTION_GENERIC_CERT_VERIFY;
 708     static const GUID generic_chain_verify = WINTRUST_ACTION_GENERIC_CHAIN_VERIFY;
 709     static const GUID cert_action_verify = CERT_CERTIFICATE_ACTION_VERIFY;
 710     LONG err = ERROR_SUCCESS;
 711     WINTRUST_DATA *actionData = ActionData;
 712
 713     TRACE("(%p, %s, %p)\n", hwnd, debugstr_guid(ActionID), ActionData);
 714     dump_wintrust_data(ActionData);
 715
 716     /* Support for known old-style callers: */
 717     if (IsEqualGUID(ActionID, &published_software))
 718         err = WINTRUST_PublishedSoftware(hwnd, ActionID, ActionData);
 719     else if (IsEqualGUID(ActionID, &cert_action_verify))
 720         err = WINTRUST_CertActionVerify(hwnd, ActionID, ActionData);
 721     else
 722     {
 723         DWORD stateAction;
 724
 725         /* Check known actions to warn of possible problems */
 726         if (!IsEqualGUID(ActionID, &unknown) &&
 727          !IsEqualGUID(ActionID, &generic_verify_v2) &&
 728          !IsEqualGUID(ActionID, &generic_cert_verify) &&
 729          !IsEqualGUID(ActionID, &generic_chain_verify))
 730             WARN("unknown action %s, default behavior may not be right\n",
 731              debugstr_guid(ActionID));
 732         if (WVT_ISINSTRUCT(WINTRUST_DATA, actionData->cbStruct, dwStateAction))
 733             stateAction = actionData->dwStateAction;
 734         else
 735         {
 736             TRACE("no dwStateAction, assuming WTD_STATEACTION_IGNORE\n");
 737             stateAction = WTD_STATEACTION_IGNORE;
 738         }
 739         switch (stateAction)
 740         {
 741         case WTD_STATEACTION_IGNORE:
 742             err = WINTRUST_DefaultVerifyAndClose(hwnd, ActionID, ActionData);
 743             break;
 744         case WTD_STATEACTION_VERIFY:
 745             err = WINTRUST_DefaultVerify(hwnd, ActionID, ActionData);
 746             break;
 747         case WTD_STATEACTION_CLOSE:
 748             err = WINTRUST_DefaultClose(hwnd, ActionID, ActionData);
 749             break;
 750         default:
 751             FIXME("unimplemented for %d\n", actionData->dwStateAction);
 752         }
 753     }
 754
 755     TRACE("returning %08x\n", err);
 756     return err;
 757 }
 758
 759 /***********************************************************************
 760  *              WinVerifyTrustEx (WINTRUST.@)
 761  */
 762 HRESULT WINAPI WinVerifyTrustEx( HWND hwnd, GUID *ActionID,
 763  WINTRUST_DATA* ActionData )
 764 {
 765     return WinVerifyTrust(hwnd, ActionID, ActionData);
 766 }
 767
 768 /***********************************************************************
 769  *              WTHelperGetProvSignerFromChain (WINTRUST.@)
 770  */
 771 CRYPT_PROVIDER_SGNR * WINAPI WTHelperGetProvSignerFromChain(
 772  CRYPT_PROVIDER_DATA *pProvData, DWORD idxSigner, BOOL fCounterSigner,
 773  DWORD idxCounterSigner)
 774 {
 775     CRYPT_PROVIDER_SGNR *sgnr;
 776
 777     TRACE("(%p %d %d %d)\n", pProvData, idxSigner, fCounterSigner,
 778      idxCounterSigner);
 779
 780     if (idxSigner >= pProvData->csSigners || !pProvData->pasSigners)
 781         return NULL;
 782     sgnr = &pProvData->pasSigners[idxSigner];
 783     if (fCounterSigner)
 784     {
 785         if (idxCounterSigner >= sgnr->csCounterSigners ||
 786          !sgnr->pasCounterSigners)
 787             return NULL;
 788         sgnr = &sgnr->pasCounterSigners[idxCounterSigner];
 789     }
 790     TRACE("returning %p\n", sgnr);
 791     return sgnr;
 792 }
 793
 794 /***********************************************************************
 795  *              WTHelperGetProvCertFromChain (WINTRUST.@)
 796  */
 797 CRYPT_PROVIDER_CERT * WINAPI WTHelperGetProvCertFromChain(
 798  CRYPT_PROVIDER_SGNR *pSgnr, DWORD idxCert)
 799 {
 800     CRYPT_PROVIDER_CERT *cert;
 801
 802     TRACE("(%p %d)\n", pSgnr, idxCert);
 803
 804     if (idxCert >= pSgnr->csCertChain || !pSgnr->pasCertChain)
 805         return NULL;
 806     cert = &pSgnr->pasCertChain[idxCert];
 807     TRACE("returning %p\n", cert);
 808     return cert;
 809 }
 810
 811 CRYPT_PROVIDER_PRIVDATA *WINAPI WTHelperGetProvPrivateDataFromChain(
 812  CRYPT_PROVIDER_DATA* pProvData,
 813  GUID* pgProviderID)
 814 {
 815     CRYPT_PROVIDER_PRIVDATA *privdata = NULL;
 816     DWORD i;
 817
 818     TRACE("(%p, %s)\n", pProvData, debugstr_guid(pgProviderID));
 819
 820     for (i = 0; i < pProvData->csProvPrivData; i++)
 821         if (IsEqualGUID(pgProviderID, &pProvData->pasProvPrivData[i].gProviderID))
 822         {
 823             privdata = &pProvData->pasProvPrivData[i];
 824             break;
 825         }
 826
 827     return privdata;
 828 }
 829
 830 /***********************************************************************
 831  *              WTHelperProvDataFromStateData (WINTRUST.@)
 832  */
 833 CRYPT_PROVIDER_DATA * WINAPI WTHelperProvDataFromStateData(HANDLE hStateData)
 834 {
 835     TRACE("%p\n", hStateData);
 836     return hStateData;
 837 }
 838
 839 /***********************************************************************
 840  *              WTHelperGetFileName(WINTRUST.@)
 841  */
 842 LPCWSTR WINAPI WTHelperGetFileName(WINTRUST_DATA *data)
 843 {
 844     TRACE("%p\n",data);
 845     if (data->dwUnionChoice == WTD_CHOICE_FILE)
 846         return data->u.pFile->pcwszFilePath;
 847     else
 848         return NULL;
 849 }
 850
 851 /***********************************************************************
 852  *              WTHelperGetFileHandle(WINTRUST.@)
 853  */
 854 HANDLE WINAPI WTHelperGetFileHandle(WINTRUST_DATA *data)
 855 {
 856     TRACE("%p\n",data);
 857     if (data->dwUnionChoice == WTD_CHOICE_FILE)
 858         return data->u.pFile->hFile;
 859     else
 860         return INVALID_HANDLE_VALUE;
 861 }
 862
 863 static BOOL WINAPI WINTRUST_enumUsages(PCCRYPT_OID_INFO pInfo, void *pvArg)
 864 {
 865     PCCRYPT_OID_INFO **usages = pvArg;
 866     DWORD cUsages;
 867     BOOL ret;
 868
 869     if (!*usages)
 870     {
 871         cUsages = 0;
 872         *usages = WINTRUST_Alloc(2 * sizeof(PCCRYPT_OID_INFO));
 873     }
 874     else
 875     {
 876         PCCRYPT_OID_INFO *ptr;
 877
 878         /* Count the existing usages.
 879          * FIXME: make sure the new usage doesn't duplicate any in the list?
 880          */
 881         for (cUsages = 0, ptr = *usages; *ptr; ptr++, cUsages++)
 882             ;
 883         *usages = WINTRUST_ReAlloc(*usages,
 884          (cUsages + 2) * sizeof(PCCRYPT_OID_INFO));
 885     }
 886     if (*usages)
 887     {
 888         (*usages)[cUsages] = pInfo;
 889         (*usages)[cUsages + 1] = NULL;
 890         ret = TRUE;
 891     }
 892     else
 893     {
 894         SetLastError(ERROR_OUTOFMEMORY);
 895         ret = FALSE;
 896     }
 897     return ret;
 898 }
 899
 900 /***********************************************************************
 901  *              WTHelperGetKnownUsages(WINTRUST.@)
 902  *
 903  * Enumerates the known enhanced key usages as an array of PCCRYPT_OID_INFOs.
 904  *
 905  * PARAMS
 906  *  action      [In]     1 => allocate and return known usages, 2 => free previously
 907  *                       allocated usages.
 908  *  usages      [In/Out] If action == 1, *usages is set to an array of
 909  *                       PCCRYPT_OID_INFO *.  The array is terminated with a NULL
 910  *                       pointer.
 911  *                       If action == 2, *usages is freed.
 912  *
 913  * RETURNS
 914  *  TRUE on success, FALSE on failure.
 915  */
 916 BOOL WINAPI WTHelperGetKnownUsages(DWORD action, PCCRYPT_OID_INFO **usages)
 917 {
 918     BOOL ret;
 919
 920     TRACE("(%d, %p)\n", action, usages);
 921
 922     if (!usages)
 923     {
 924         SetLastError(ERROR_INVALID_PARAMETER);
 925         return FALSE;
 926     }
 927
 928     if (action == 1)
 929     {
 930         *usages = NULL;
 931         ret = CryptEnumOIDInfo(CRYPT_ENHKEY_USAGE_OID_GROUP_ID, 0, usages,
 932          WINTRUST_enumUsages);
 933     }
 934     else if (action == 2)
 935     {
 936         WINTRUST_Free(*usages);
 937         *usages = NULL;
 938         ret = TRUE;
 939     }
 940     else
 941     {
 942         WARN("unknown action %d\n", action);
 943         SetLastError(ERROR_INVALID_PARAMETER);
 944         ret = FALSE;
 945     }
 946     return ret;
 947 }
 948
 949 static const WCHAR Software_Publishing[] = {
 950  'S','o','f','t','w','a','r','e','\\',
 951  'M','i','c','r','o','s','o','f','t','\\',
 952  'W','i','n','d','o','w','s','\\',
 953  'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 954  'W','i','n','t','r','u','s','t','\\',
 955  'T','r','u','s','t',' ','P','r','o','v','i','d','e','r','s','\\',
 956  'S','o','f','t','w','a','r','e',' ',
 957  'P','u','b','l','i','s','h','i','n','g',0 };
 958 static const WCHAR State[] = { 'S','t','a','t','e',0 };
 959
 960 /***********************************************************************
 961  *              WintrustGetRegPolicyFlags (WINTRUST.@)
 962  */
 963 void WINAPI WintrustGetRegPolicyFlags( DWORD* pdwPolicyFlags )
 964 {
 965     HKEY key;
 966     LONG r;
 967
 968     TRACE("%p\n", pdwPolicyFlags);
 969
 970     *pdwPolicyFlags = 0;
 971     r = RegCreateKeyExW(HKEY_CURRENT_USER, Software_Publishing, 0, NULL, 0,
 972      KEY_READ, NULL, &key, NULL);
 973     if (!r)
 974     {
 975         DWORD size = sizeof(DWORD);
 976
 977         r = RegQueryValueExW(key, State, NULL, NULL, (LPBYTE)pdwPolicyFlags,
 978          &size);
 979         RegCloseKey(key);
 980         if (r)
 981         {
 982             /* Failed to query, create and return default value */
 983             *pdwPolicyFlags = WTPF_IGNOREREVOCATIONONTS |
 984              WTPF_OFFLINEOKNBU_COM |
 985              WTPF_OFFLINEOKNBU_IND |
 986              WTPF_OFFLINEOK_COM |
 987              WTPF_OFFLINEOK_IND;
 988             WintrustSetRegPolicyFlags(*pdwPolicyFlags);
 989         }
 990     }
 991 }
 992
 993 /***********************************************************************
 994  *              WintrustSetRegPolicyFlags (WINTRUST.@)
 995  */
 996 BOOL WINAPI WintrustSetRegPolicyFlags( DWORD dwPolicyFlags)
 997 {
 998     HKEY key;
 999     LONG r;
1000
1001     TRACE("%x\n", dwPolicyFlags);
1002
1003     r = RegCreateKeyExW(HKEY_CURRENT_USER, Software_Publishing, 0,
1004      NULL, 0, KEY_WRITE, NULL, &key, NULL);
1005     if (!r)
1006     {
1007         r = RegSetValueExW(key, State, 0, REG_DWORD, (LPBYTE)&dwPolicyFlags,
1008          sizeof(DWORD));
1009         RegCloseKey(key);
1010     }
1011     if (r) SetLastError(r);
1012     return r == ERROR_SUCCESS;
1013 }
1014
1015 /* Utility functions */
1016
1017 BOOL WINAPI WINTRUST_AddStore(CRYPT_PROVIDER_DATA *data, HCERTSTORE store)
1018 {
1019     BOOL ret = FALSE;
1020
1021     TRACE("(%p, %p)\n", data, store);
1022
1023     if (data->chStores)
1024         data->pahStores = WINTRUST_ReAlloc(data->pahStores,
1025          (data->chStores + 1) * sizeof(HCERTSTORE));
1026     else
1027     {
1028         data->pahStores = WINTRUST_Alloc(sizeof(HCERTSTORE));
1029         data->chStores = 0;
1030     }
1031     if (data->pahStores)
1032     {
1033         data->pahStores[data->chStores++] = CertDuplicateStore(store);
1034         ret = TRUE;
1035     }
1036     else
1037         SetLastError(ERROR_OUTOFMEMORY);
1038     return ret;
1039 }
1040
1041 BOOL WINAPI WINTRUST_AddSgnr(CRYPT_PROVIDER_DATA *data,
1042  BOOL fCounterSigner, DWORD idxSigner, CRYPT_PROVIDER_SGNR *sgnr)
1043 {
1044     BOOL ret = FALSE;
1045
1046     TRACE("(%p, %d, %d, %p)\n", data, fCounterSigner, idxSigner, sgnr);
1047
1048     if (sgnr->cbStruct > sizeof(CRYPT_PROVIDER_SGNR))
1049     {
1050         SetLastError(ERROR_INVALID_PARAMETER);
1051         return FALSE;
1052     }
1053     if (fCounterSigner)
1054     {
1055         FIXME("unimplemented for counter signers\n");
1056         SetLastError(ERROR_INVALID_PARAMETER);
1057         return FALSE;
1058     }
1059     if (data->csSigners)
1060         data->pasSigners = WINTRUST_ReAlloc(data->pasSigners,
1061          (data->csSigners + 1) * sizeof(CRYPT_PROVIDER_SGNR));
1062     else
1063     {
1064         data->pasSigners = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_SGNR));
1065         data->csSigners = 0;
1066     }
1067     if (data->pasSigners)
1068     {
1069         if (idxSigner < data->csSigners)
1070             memmove(&data->pasSigners[idxSigner],
1071              &data->pasSigners[idxSigner + 1],
1072              (data->csSigners - idxSigner) * sizeof(CRYPT_PROVIDER_SGNR));
1073         ret = TRUE;
1074         if (sgnr->cbStruct == sizeof(CRYPT_PROVIDER_SGNR))
1075         {
1076             /* The PSDK says psSigner should be allocated using pfnAlloc, but
1077              * it doesn't say anything about ownership.  Since callers are
1078              * internal, assume ownership is passed, and just store the
1079              * pointer.
1080              */
1081             memcpy(&data->pasSigners[idxSigner], sgnr,
1082              sizeof(CRYPT_PROVIDER_SGNR));
1083         }
1084         else
1085             memset(&data->pasSigners[idxSigner], 0,
1086              sizeof(CRYPT_PROVIDER_SGNR));
1087         data->csSigners++;
1088     }
1089     else
1090         SetLastError(ERROR_OUTOFMEMORY);
1091     return ret;
1092 }
1093
1094 BOOL WINAPI WINTRUST_AddCert(CRYPT_PROVIDER_DATA *data, DWORD idxSigner,
1095  BOOL fCounterSigner, DWORD idxCounterSigner, PCCERT_CONTEXT pCert2Add)
1096 {
1097     BOOL ret = FALSE;
1098
1099     TRACE("(%p, %d, %d, %d, %p)\n", data, idxSigner, fCounterSigner,
1100      idxSigner, pCert2Add);
1101
1102     if (fCounterSigner)
1103     {
1104         FIXME("unimplemented for counter signers\n");
1105         SetLastError(ERROR_INVALID_PARAMETER);
1106         return FALSE;
1107     }
1108     if (data->pasSigners[idxSigner].csCertChain)
1109         data->pasSigners[idxSigner].pasCertChain =
1110          WINTRUST_ReAlloc(data->pasSigners[idxSigner].pasCertChain,
1111          (data->pasSigners[idxSigner].csCertChain + 1) *
1112          sizeof(CRYPT_PROVIDER_CERT));
1113     else
1114     {
1115         data->pasSigners[idxSigner].pasCertChain =
1116          WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_CERT));
1117         data->pasSigners[idxSigner].csCertChain = 0;
1118     }
1119     if (data->pasSigners[idxSigner].pasCertChain)
1120     {
1121         CRYPT_PROVIDER_CERT *cert = &data->pasSigners[idxSigner].pasCertChain[
1122          data->pasSigners[idxSigner].csCertChain];
1123
1124         cert->cbStruct = sizeof(CRYPT_PROVIDER_CERT);
1125         cert->pCert = CertDuplicateCertificateContext(pCert2Add);
1126         data->pasSigners[idxSigner].csCertChain++;
1127         ret = TRUE;
1128     }
1129     else
1130         SetLastError(ERROR_OUTOFMEMORY);
1131     return ret;
1132 }
1133
1134 BOOL WINAPI WINTRUST_AddPrivData(CRYPT_PROVIDER_DATA *data,
1135  CRYPT_PROVIDER_PRIVDATA *pPrivData2Add)
1136 {
1137     BOOL ret = FALSE;
1138
1139     TRACE("(%p, %p)\n", data, pPrivData2Add);
1140
1141     if (pPrivData2Add->cbStruct > sizeof(CRYPT_PROVIDER_PRIVDATA))
1142     {
1143         SetLastError(ERROR_INVALID_PARAMETER);
1144         WARN("invalid struct size\n");
1145         return FALSE;
1146     }
1147     if (data->csProvPrivData)
1148         data->pasProvPrivData = WINTRUST_ReAlloc(data->pasProvPrivData,
1149          (data->csProvPrivData + 1) * sizeof(CRYPT_PROVIDER_SGNR));
1150     else
1151     {
1152         data->pasProvPrivData = WINTRUST_Alloc(sizeof(CRYPT_PROVIDER_SGNR));
1153         data->csProvPrivData = 0;
1154     }
1155     if (data->pasProvPrivData)
1156     {
1157         DWORD i;
1158
1159         for (i = 0; i < data->csProvPrivData; i++)
1160             if (IsEqualGUID(&pPrivData2Add->gProviderID, &data->pasProvPrivData[i]))
1161                 break;
1162
1163         data->pasProvPrivData[i] = *pPrivData2Add;
1164         if (i == data->csProvPrivData)
1165             data->csProvPrivData++;
1166     }
1167     else
1168         SetLastError(ERROR_OUTOFMEMORY);
1169     return ret;
1170 }
1171
1172 /***********************************************************************
1173  *              OpenPersonalTrustDBDialog (WINTRUST.@)
1174  *
1175  * Opens the certificate manager dialog, showing only the stores that
1176  * contain trusted software publishers.
1177  *
1178  * PARAMS
1179  *  hwnd [I] handle of parent window
1180  *
1181  * RETURNS
1182  *  TRUE if the dialog could be opened, FALSE if not.
1183  */
1184 BOOL WINAPI OpenPersonalTrustDBDialog(HWND hwnd)
1185 {
1186     CRYPTUI_CERT_MGR_STRUCT uiCertMgr;
1187
1188     uiCertMgr.dwSize = sizeof(uiCertMgr);
1189     uiCertMgr.hwndParent = hwnd;
1190     uiCertMgr.dwFlags = CRYPTUI_CERT_MGR_PUBLISHER_TAB;
1191     uiCertMgr.pwszTitle = NULL;
1192     uiCertMgr.pszInitUsageOID = NULL;
1193     return CryptUIDlgCertMgr(&uiCertMgr);
1194 }
1195
1196 /***********************************************************************
1197  *              WTHelperCertCheckValidSignature
1198  */
1199 HRESULT WINAPI WTHelperCertCheckValidSignature(CRYPT_PROVIDER_DATA *pProvData)
1200 {
1201     FIXME("Stub\n");
1202     return S_OK;
1203 }
1204
1205 /***********************************************************************
1206  *              IsCatalogFile
1207  */
1208 BOOL WINAPI IsCatalogFile(HANDLE hFile, WCHAR *pwszFileName)
1209 {
1210     static const GUID catGUID = { 0xDE351A43, 0x8E59, 0x11D0, { 0x8C,0x47,0x00,0xC0,0x4F,0xC2,0x95,0xEE }};
1211     GUID guid;
1212
1213     TRACE("(%p, %s)\n", hFile, debugstr_w(pwszFileName));
1214
1215     if (!CryptSIPRetrieveSubjectGuid(pwszFileName, hFile, &guid))
1216         return FALSE;
1217     return IsEqualGUID(&guid, &catGUID);
1218 }
1219
1220 /***********************************************************************
1221  *              FindCertsByIssuer
1222  */
1223 HRESULT WINAPI FindCertsByIssuer(PCERT_CHAIN pCertChains, DWORD *pcbCertChains,
1224  DWORD *pcCertChains, BYTE* pbEncodedIssuerName, DWORD cbEncodedIssuerName,
1225  LPCWSTR pwszPurpose, DWORD dwKeySpec)
1226 {
1227     FIXME("(%p, %p, %p, %p, %d, %s, %d): stub\n", pCertChains, pcbCertChains,
1228      pcCertChains, pbEncodedIssuerName, cbEncodedIssuerName,
1229      debugstr_w(pwszPurpose), dwKeySpec);
1230     return E_FAIL;
1231 }